init

src/org/cloudbus/cloudsim/VmAllocationPolicySimple.java

@@ -0,0 +1,240 @@
+/*
+ * Title:        CloudSim Toolkit
+ * Description:  CloudSim (Cloud Simulation) Toolkit for Modeling and Simulation of Clouds
+ * Licence:      GPL - http://www.gnu.org/copyleft/gpl.html
+ *
+ * Copyright (c) 2009-2012, The University of Melbourne, Australia
+ */
+
+package org.cloudbus.cloudsim;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.cloudbus.cloudsim.core.CloudSim;
+
+/**
+ * VmAllocationPolicySimple is an VmAllocationPolicy that chooses, as the host for a VM, the host
+ * with less PEs in use.
+ * 
+ * @author Rodrigo N. Calheiros
+ * @author Anton Beloglazov
+ * @since CloudSim Toolkit 1.0
+ */
+public class VmAllocationPolicySimple extends VmAllocationPolicy {
+
+	/** The vm table. */
+	private Map<String, Host> vmTable;
+
+	/** The used pes. */
+	private Map<String, Integer> usedPes;
+
+	/** The free pes. */
+	private List<Integer> freePes;
+
+	/**
+	 * Creates the new VmAllocationPolicySimple object.
+	 * 
+	 * @param list the list
+	 * @pre $none
+	 * @post $none
+	 */
+	public VmAllocationPolicySimple(List<? extends Host> list) {
+		super(list);
+
+		setFreePes(new ArrayList<Integer>());
+		for (Host host : getHostList()) {
+			getFreePes().add(host.getNumberOfPes());
+
+		}
+
+		setVmTable(new HashMap<String, Host>());
+		setUsedPes(new HashMap<String, Integer>());
+	}
+
+	/**
+	 * Allocates a host for a given VM.
+	 * 
+	 * @param vm VM specification
+	 * @return $true if the host could be allocated; $false otherwise
+	 * @pre $none
+	 * @post $none
+	 */
+	@Override
+	public boolean allocateHostForVm(Vm vm) {
+		int requiredPes = vm.getNumberOfPes();
+		boolean result = false;
+		int tries = 0;
+		List<Integer> freePesTmp = new ArrayList<Integer>();
+		for (Integer freePes : getFreePes()) {
+			freePesTmp.add(freePes);
+		}
+
+		if (!getVmTable().containsKey(vm.getUid())) { // if this vm was not created
+			do {// we still trying until we find a host or until we try all of them
+				int moreFree = Integer.MIN_VALUE;
+				int idx = -1;
+
+				// we want the host with less pes in use
+				for (int i = 0; i < freePesTmp.size(); i++) {
+					if (freePesTmp.get(i) > moreFree) {
+						moreFree = freePesTmp.get(i);
+						idx = i;
+					}
+				}
+
+				Host host = getHostList().get(idx);
+				result = host.vmCreate(vm);
+
+				if (result) { // if vm were succesfully created in the host
+					getVmTable().put(vm.getUid(), host);
+					getUsedPes().put(vm.getUid(), requiredPes);
+					getFreePes().set(idx, getFreePes().get(idx) - requiredPes);
+					result = true;
+					break;
+				} else {
+					freePesTmp.set(idx, Integer.MIN_VALUE);
+				}
+				tries++;
+			} while (!result && tries < getFreePes().size());
+
+		}
+
+		return result;
+	}
+
+	/**
+	 * Releases the host used by a VM.
+	 * 
+	 * @param vm the vm
+	 * @pre $none
+	 * @post none
+	 */
+	@Override
+	public void deallocateHostForVm(Vm vm) {
+		Host host = getVmTable().remove(vm.getUid());
+		int idx = getHostList().indexOf(host);
+		int pes = getUsedPes().remove(vm.getUid());
+		if (host != null) {
+			host.vmDestroy(vm);
+			getFreePes().set(idx, getFreePes().get(idx) + pes);
+		}
+	}
+
+	/**
+	 * Gets the host that is executing the given VM belonging to the given user.
+	 * 
+	 * @param vm the vm
+	 * @return the Host with the given vmID and userID; $null if not found
+	 * @pre $none
+	 * @post $none
+	 */
+	@Override
+	public Host getHost(Vm vm) {
+		return getVmTable().get(vm.getUid());
+	}
+
+	/**
+	 * Gets the host that is executing the given VM belonging to the given user.
+	 * 
+	 * @param vmId the vm id
+	 * @param userId the user id
+	 * @return the Host with the given vmID and userID; $null if not found
+	 * @pre $none
+	 * @post $none
+	 */
+	@Override
+	public Host getHost(int vmId, int userId) {
+		return getVmTable().get(Vm.getUid(userId, vmId));
+	}
+
+	/**
+	 * Gets the vm table.
+	 * 
+	 * @return the vm table
+	 */
+	public Map<String, Host> getVmTable() {
+		return vmTable;
+	}
+
+	/**
+	 * Sets the vm table.
+	 * 
+	 * @param vmTable the vm table
+	 */
+	protected void setVmTable(Map<String, Host> vmTable) {
+		this.vmTable = vmTable;
+	}
+
+	/**
+	 * Gets the used pes.
+	 * 
+	 * @return the used pes
+	 */
+	protected Map<String, Integer> getUsedPes() {
+		return usedPes;
+	}
+
+	/**
+	 * Sets the used pes.
+	 * 
+	 * @param usedPes the used pes
+	 */
+	protected void setUsedPes(Map<String, Integer> usedPes) {
+		this.usedPes = usedPes;
+	}
+
+	/**
+	 * Gets the free pes.
+	 * 
+	 * @return the free pes
+	 */
+	protected List<Integer> getFreePes() {
+		return freePes;
+	}
+
+	/**
+	 * Sets the free pes.
+	 * 
+	 * @param freePes the new free pes
+	 */
+	protected void setFreePes(List<Integer> freePes) {
+		this.freePes = freePes;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see cloudsim.VmAllocationPolicy#optimizeAllocation(double, cloudsim.VmList, double)
+	 */
+	@Override
+	public List<Map<String, Object>> optimizeAllocation(List<? extends Vm> vmList) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.cloudbus.cloudsim.VmAllocationPolicy#allocateHostForVm(org.cloudbus.cloudsim.Vm,
+	 * org.cloudbus.cloudsim.Host)
+	 */
+	@Override
+	public boolean allocateHostForVm(Vm vm, Host host) {
+		if (host.vmCreate(vm)) { // if vm has been succesfully created in the host
+			getVmTable().put(vm.getUid(), host);
+
+			int requiredPes = vm.getNumberOfPes();
+			int idx = getHostList().indexOf(host);
+			getUsedPes().put(vm.getUid(), requiredPes);
+			getFreePes().set(idx, getFreePes().get(idx) - requiredPes);
+
+			Log.formatLine(
+					"%.2f: VM #" + vm.getId() + " has been allocated to the host #" + host.getId(),
+					CloudSim.clock());
+			return true;
+		}
+
+		return false;
+	}
+}