init

src/org/cloudbus/cloudsim/VmSchedulerTimeSharedOverSubscription.java

@@ -0,0 +1,176 @@
+/*
+ * 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 java.util.Map.Entry;
+
+import org.cloudbus.cloudsim.lists.PeList;
+
+/**
+ * This is a Time-Shared VM Scheduler, which allows over-subscription. In other words, the scheduler
+ * still allows the allocation of VMs that require more CPU capacity that is available.
+ * Oversubscription results in performance degradation.
+ * 
+ * @author Anton Beloglazov
+ * @author Rodrigo N. Calheiros
+ * @since CloudSim Toolkit 3.0
+ */
+public class VmSchedulerTimeSharedOverSubscription extends VmSchedulerTimeShared {
+
+	/**
+	 * Instantiates a new vm scheduler time shared over subscription.
+	 * 
+	 * @param pelist the pelist
+	 */
+	public VmSchedulerTimeSharedOverSubscription(List<? extends Pe> pelist) {
+		super(pelist);
+	}
+
+	/**
+	 * Allocate pes for vm. The policy allows over-subscription. In other words, the policy still
+	 * allows the allocation of VMs that require more CPU capacity that is available.
+	 * Oversubscription results in performance degradation. Each virtual PE cannot be allocated more
+	 * CPU capacity than MIPS of a single PE.
+	 * 
+	 * @param vmUid the vm uid
+	 * @param mipsShareRequested the mips share requested
+	 * @return true, if successful
+	 */
+	@Override
+	protected boolean allocatePesForVm(String vmUid, List<Double> mipsShareRequested) {
+		double totalRequestedMips = 0;
+		
+		// if the requested mips is bigger than the capacity of a single PE, we cap
+		// the request to the PE's capacity
+		List<Double> mipsShareRequestedCapped = new ArrayList<Double>();
+		double peMips = getPeCapacity();
+		for (Double mips : mipsShareRequested) {
+			if (mips > peMips) {
+				mipsShareRequestedCapped.add(peMips);
+				totalRequestedMips += peMips;
+			} else {
+				mipsShareRequestedCapped.add(mips);
+				totalRequestedMips += mips;
+			}
+		}
+
+		getMipsMapRequested().put(vmUid, mipsShareRequested);
+		setPesInUse(getPesInUse() + mipsShareRequested.size());
+
+		if (getVmsMigratingIn().contains(vmUid)) {
+			// the destination host only experience 10% of the migrating VM's MIPS
+			totalRequestedMips *= 0.1;
+		}
+
+		if (getAvailableMips() >= totalRequestedMips) {
+			List<Double> mipsShareAllocated = new ArrayList<Double>();
+			for (Double mipsRequested : mipsShareRequestedCapped) {
+				if (getVmsMigratingOut().contains(vmUid)) {
+					// performance degradation due to migration = 10% MIPS
+					mipsRequested *= 0.9;
+				} else if (getVmsMigratingIn().contains(vmUid)) {
+					// the destination host only experience 10% of the migrating VM's MIPS
+					mipsRequested *= 0.1;
+				}
+				mipsShareAllocated.add(mipsRequested);
+			}
+			//System.out.println("Setting MIPS of "+vmUid+" to "+mipsShareAllocated);
+
+			getMipsMap().put(vmUid, mipsShareAllocated);
+			setAvailableMips(getAvailableMips() - totalRequestedMips);
+		} else {
+			redistributeMipsDueToOverSubscription();
+		}
+		/*for(String uid : getMipsMap().keySet()){
+			System.out.println(uid+"\t--->\t"+getMipsMap().get(uid));
+		}*/
+
+		return true;
+	}
+
+	/**
+	 * This method recalculates distribution of MIPs among VMs considering eventual shortage of MIPS
+	 * compared to the amount requested by VMs.
+	 */
+	protected void redistributeMipsDueToOverSubscription() {
+		// First, we calculate the scaling factor - the MIPS allocation for all VMs will be scaled
+		// proportionally
+		double totalRequiredMipsByAllVms = 0;
+
+		Map<String, List<Double>> mipsMapCapped = new HashMap<String, List<Double>>();
+		for (Entry<String, List<Double>> entry : getMipsMapRequested().entrySet()) {
+
+			double requiredMipsByThisVm = 0.0;
+			String vmId = entry.getKey();
+			List<Double> mipsShareRequested = entry.getValue();
+			List<Double> mipsShareRequestedCapped = new ArrayList<Double>();
+			double peMips = getPeCapacity();
+			for (Double mips : mipsShareRequested) {
+				if (mips > peMips) {
+					mipsShareRequestedCapped.add(peMips);
+					requiredMipsByThisVm += peMips;
+				} else {
+					mipsShareRequestedCapped.add(mips);
+					requiredMipsByThisVm += mips;
+				}
+			}
+
+			mipsMapCapped.put(vmId, mipsShareRequestedCapped);
+
+			if (getVmsMigratingIn().contains(entry.getKey())) {
+				// the destination host only experience 10% of the migrating VM's MIPS
+				requiredMipsByThisVm *= 0.1;
+			}
+			totalRequiredMipsByAllVms += requiredMipsByThisVm;
+		}
+
+		double totalAvailableMips = PeList.getTotalMips(getPeList());
+
+		double scalingFactor = totalAvailableMips / totalRequiredMipsByAllVms;
+
+		// Clear the old MIPS allocation
+		getMipsMap().clear();
+
+		// Update the actual MIPS allocated to the VMs
+		for (Entry<String, List<Double>> entry : mipsMapCapped.entrySet()) {
+			String vmUid = entry.getKey();
+			List<Double> requestedMips = entry.getValue();
+			List<Double> updatedMipsAllocation = new ArrayList<Double>();
+			for (Double mips : requestedMips) {
+				if (getVmsMigratingOut().contains(vmUid)) {
+					// the original amount is scaled
+					mips *= scalingFactor;
+					// performance degradation due to migration = 10% MIPS
+					mips *= 0.9;
+				} else if (getVmsMigratingIn().contains(vmUid)) {
+					// the destination host only experiences 10% of the migrating VM's MIPS
+					mips *= 0.1;
+					// the final 10% of the requested MIPS are scaled
+					mips *= scalingFactor;
+				} else {
+					mips *= scalingFactor;
+				}
+
+				updatedMipsAllocation.add(Math.floor(mips));
+			}
+
+			// add in the new map
+			//System.out.println("Setting MIPS of "+vmUid+" to "+updatedMipsAllocation);
+			getMipsMap().put(vmUid, updatedMipsAllocation);
+
+		}
+
+		// As the host is oversubscribed, there no more available MIPS
+		setAvailableMips(0);
+	}
+
+}