Solved issue #11:

- VmSchedulerTimeShared and VmSchedulerTimeSharedOverSubscription were refactored to isolate the method
that decides MIPS shares in case of oversubscription.

- CloudSimExample1 has been reverted to its original version.

modules/cloudsim-examples/src/main/java/org/cloudbus/cloudsim/examples/CloudSimExample1.java

@@ -89,15 +89,9 @@ public class CloudSimExample1 {
 			// create VM
 			Vm vm = new Vm(vmid, brokerId, mips, pesNumber, ram, bw, size, vmm, new CloudletSchedulerTimeShared());
 
-			Vm vm1 = new Vm(1, brokerId, mips, pesNumber, ram, bw, size, vmm, new CloudletSchedulerTimeShared());
-			Vm vm2 = new Vm(2, brokerId, mips, pesNumber, ram, bw, size, vmm, new CloudletSchedulerTimeShared());
-
 			// add the VM to the vmList
 			vmlist.add(vm);
 
-			vmlist.add(vm1);
-			vmlist.add(vm2);
-
 			// submit vm list to the broker
 			broker.submitVmList(vmlist);
 
@@ -115,21 +109,9 @@ public class CloudSimExample1 {
 			cloudlet.setUserId(brokerId);
 			cloudlet.setVmId(vmid);
 
-			Cloudlet cloudlet1 = new Cloudlet(1, length, pesNumber, fileSize, outputSize, utilizationModel, utilizationModel, utilizationModel);
-			cloudlet1.setUserId(brokerId);
-			cloudlet1.setVmId(1);
-			
-			Cloudlet cloudlet2 = new Cloudlet(2, length, pesNumber, fileSize, outputSize, utilizationModel, utilizationModel, utilizationModel);
-			cloudlet2.setUserId(brokerId);
-			cloudlet2.setVmId(2);
-			
-
 			// add the cloudlet to the list
 			cloudletList.add(cloudlet);
 
-			cloudletList.add(cloudlet1);
-			cloudletList.add(cloudlet2);
-
 			// submit cloudlet list to the broker
 			broker.submitCloudletList(cloudletList);
 

modules/cloudsim/src/main/java/org/cloudbus/cloudsim/VmSchedulerTimeShared.java

@@ -99,7 +99,7 @@ public class VmSchedulerTimeShared extends VmScheduler {
 			if (getVmsMigratingOut().contains(vmUid)) {
 				mipsRequested *= 0.9; // performance degradation due to migration = 10% MIPS
 			} else if (getVmsMigratingIn().contains(vmUid)) {
-				mipsRequested *= 0.1; // performance cost incurred by the destination host = 10% MIPS
+				mipsRequested *= 0.1; // performance cost incurred by the destination host = 90% MIPS
 			}
 			mipsShareAllocated.add(mipsRequested);
 		}
@@ -108,49 +108,79 @@ public class VmSchedulerTimeShared extends VmScheduler {
 			getMipsMap().put(vmUid, mipsShareAllocated);
 			setAvailableMips(getAvailableMips() - totalRequestedMips);
 		} else {			
-			int pesSkipped = 0;
-			for (List<Double> mipsMap : getMipsMap().values()) {
-				for (int i = 0; i < mipsMap.size(); i++) {
-					if (mipsMap.get(i) == 0) {
-						pesSkipped++;
-						continue;
-					}
+			updateShortage();
 		}
+
+		return true;
 	}
 
-			double shortage = (totalRequestedMips - getAvailableMips()) / (getPesInUse() - pesSkipped);
+	/**
+	 * This method recalculates distribution of MIPs among VMs considering eventual shortage of MIPS
+	 * compared to the amount requested by VMs.
+	 */
+	protected void updateShortage() {
+		//first, we have to know the wight of each VM
+		//in the allocation of mips. We want to keep
+		//allocation proportional to it
 		
-			getMipsMap().put(vmUid, mipsShareAllocated);
-			setAvailableMips(0);
-
-			double additionalShortage = 0;
-			do {
-				additionalShortage = 0;
-				for (Entry<String, List<Double>> entry : getMipsMap().entrySet()) {
-					if (getVmsMigratingIn().contains(entry.getKey())) {
-						continue;
-					}
-					List<Double> mipsMap = entry.getValue(); 
-					for (int i = 0; i < mipsMap.size(); i++) {
-						if (mipsMap.get(i) == 0) {
-							continue;
-						}
-						if (mipsMap.get(i) >= shortage) {
-							mipsMap.set(i, mipsMap.get(i) - shortage);
-						} else {
-							additionalShortage += shortage - mipsMap.get(i);
-							mipsMap.set(i, 0.0);
-						}
-						if (mipsMap.get(i) == 0) {
-							pesSkipped++;
+		HashMap<String,Double> weightMap = new  HashMap<String,Double>();
+		double totalRequiredMips = 0.0;
+		
+		Iterator<Entry<String, List<Double>>> iter = mipsMapRequested.entrySet().iterator();
+		while (iter.hasNext()){
+			Entry<String, List<Double>> entry = iter.next();
+			
+			//each element of the iterator is one entry of the table: (vmId, mipsShare)
+			String vmId = entry.getKey();
+			List<Double> shares = entry.getValue();
+			
+			//count amount of mips required by the vm
+			double requiredMipsByThisVm = 0.0;
+			for(double share: shares){
+				totalRequiredMips+=share;
+				requiredMipsByThisVm+=share;
 			}
+			
+			//store the value to use later to define weights
+			weightMap.put(vmId, requiredMipsByThisVm);
 		}
+			
+		//now, we have the information on individual weights
+		//use this information to define actual shares of
+		//mips received by each VM
+				
+		iter = mipsMapRequested.entrySet().iterator();
+		while (iter.hasNext()){
+			Entry<String, List<Double>> entry = iter.next();
+			
+			//each element of the iterator is one entry of the table: (vmId, mipsShare)
+			String vmId = entry.getKey();
+			List<Double> shares = entry.getValue();
+			
+			//get weight of this vm
+			double vmWeight = weightMap.get(vmId)/totalRequiredMips;
+			
+			//update actual received share
+			LinkedList<Double> updatedSharesList = new LinkedList<Double>();
+			double actuallyAllocatedMips = 0.0;
+			for(double share: shares){
+				double updatedShare = share*vmWeight;
+				
+				//update share if migrating
+				if (getVmsMigratingOut().contains(vmId)) {
+					updatedShare *= 0.9; // performance degradation due to migration = 10% MIPS
+				} else if (getVmsMigratingIn().contains(vmId)) {
+					updatedShare *= 0.1; // performance cost incurred by the destination host = 90% MIPS
 				}
-				shortage = additionalShortage / (getPesInUse() - pesSkipped);
-			} while (additionalShortage > 0);
+				
+				actuallyAllocatedMips+=updatedShare;
+				updatedSharesList.add(updatedShare);
 			}
 			
-		return true;
+			//add in the new map
+			getMipsMap().put(vmId, updatedSharesList);
+			setAvailableMips(getAvailableMips() - actuallyAllocatedMips);
+		}	
 	}
 
 	/**
@@ -170,8 +200,8 @@ public class VmSchedulerTimeShared extends VmScheduler {
 		for (Map.Entry<String, List<Double>> entry : getMipsMap().entrySet()) {
 			String vmUid = entry.getKey();
 			getPeMap().put(vmUid, new LinkedList<Pe>());
+			
 			for (double mips : entry.getValue()) {
-				System.out.println("=> mips:"+mips);
 				while (mips >= 0.1) {
 					if (availableMips >= mips) {
 						peProvisioner.allocateMipsForVm(vmUid, mips);

modules/cloudsim/src/main/java/org/cloudbus/cloudsim/VmSchedulerTimeSharedOverSubscription.java

@@ -86,36 +86,7 @@ public class VmSchedulerTimeSharedOverSubscription extends VmSchedulerTimeShared
 				pesSkipped += mipsShareRequested.size();
 			}	
 
-			double shortage = (totalRequestedMips - getAvailableMips()) / (getPesInUse() - pesSkipped);
-
-			getMipsMap().put(vmUid, mipsShareAllocated);
-			setAvailableMips(0);
-
-			double additionalShortage = 0;
-			do {
-				additionalShortage = 0;
-				for (Entry<String, List<Double>> entry : getMipsMap().entrySet()) {
-					if (getVmsMigratingIn().contains(entry.getKey())) {
-						continue;
-					}
-					List<Double> mipsMap = entry.getValue(); 
-					for (int i = 0; i < mipsMap.size(); i++) {
-						if (mipsMap.get(i) == 0) {
-							continue;
-						}
-						if (mipsMap.get(i) >= shortage) {
-							mipsMap.set(i, mipsMap.get(i) - shortage);
-						} else {
-							additionalShortage += shortage - mipsMap.get(i);
-							mipsMap.set(i, 0.0);
-						}
-						if (mipsMap.get(i) == 0) {
-							pesSkipped++;
-						}
-					}
-				}
-				shortage = additionalShortage / (getPesInUse() - pesSkipped);
-			} while (additionalShortage > 0);
+			updateShortage();
 		}
 
 		return true;

modules/cloudsim/src/main/java/org/cloudbus/cloudsim/provisioners/PeProvisionerSimple.java

@@ -68,8 +68,6 @@ public class PeProvisionerSimple extends PeProvisioner {
 
 		setAvailableMips(getAvailableMips() - mips);
 		getPeTable().put(vmUid, allocatedMips);
-System.out.print("MIPS allocated for vm "+vmUid+" :");
-for (double m:allocatedMips) System.out.print(" "+m+" "); System.out.println();
 
 		return true;
 	}
@@ -89,6 +87,7 @@ for (double m:allocatedMips) System.out.print(" "+m+" "); System.out.println();
 		}
 
 		setAvailableMips(getAvailableMips() + getTotalAllocatedMipsForVm(vm) - totalMipsToAllocate);
+
 		getPeTable().put(vm.getUid(), mips);
 
 		return true;

modules/cloudsim/src/test/java/org/cloudbus/cloudsim/TimeSharedProblemDetector.java

+package org.cloudbus.cloudsim;
+
+/*
+ * 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, The University of Melbourne, Australia
+ */
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.cloudbus.cloudsim.Cloudlet;
+import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
+import org.cloudbus.cloudsim.Datacenter;
+import org.cloudbus.cloudsim.DatacenterBroker;
+import org.cloudbus.cloudsim.DatacenterCharacteristics;
+import org.cloudbus.cloudsim.Host;
+import org.cloudbus.cloudsim.Log;
+import org.cloudbus.cloudsim.Pe;
+import org.cloudbus.cloudsim.Storage;
+import org.cloudbus.cloudsim.UtilizationModel;
+import org.cloudbus.cloudsim.UtilizationModelFull;
+import org.cloudbus.cloudsim.Vm;
+import org.cloudbus.cloudsim.VmAllocationPolicySimple;
+import org.cloudbus.cloudsim.VmSchedulerTimeShared;
+import org.cloudbus.cloudsim.core.CloudSim;
+import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
+import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
+import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;
+
+/**
+ * A simple example showing how to create a datacenter with one host and run one
+ * cloudlet on it.
+ */
+public class TimeSharedProblemDetector {
+
+	/** The cloudlet list. */
+	private static List<Cloudlet> cloudletList;
+
+	/** The vmlist. */
+	private static List<Vm> vmlist;
+
+	/**
+	 * Creates main() to run this example.
+	 *
+	 * @param args the args
+	 */
+	public static void main(String[] args) {
+
+		Log.printLine("Starting CloudSimExample1...");
+
+		try {
+			// First step: Initialize the CloudSim package. It should be called
+			// before creating any entities.
+			int num_user = 1; // number of cloud users
+			Calendar calendar = Calendar.getInstance();
+			boolean trace_flag = false; // mean trace events
+
+			// Initialize the CloudSim library
+			CloudSim.init(num_user, calendar, trace_flag);
+
+			// Second step: Create Datacenters
+			// Datacenters are the resource providers in CloudSim. We need at
+			// list one of them to run a CloudSim simulation
+			Datacenter datacenter0 = createDatacenter("Datacenter_0");
+
+			// Third step: Create Broker
+			DatacenterBroker broker = createBroker();
+			int brokerId = broker.getId();
+
+			// Fourth step: Create one virtual machine
+			vmlist = new ArrayList<Vm>();
+
+			// VM description
+			int vmid = 0;
+			int mips = 1000;
+			long size = 10000; // image size (MB)
+			int ram = 512; // vm memory (MB)
+			long bw = 1000;
+			int pesNumber = 1; // number of cpus
+			String vmm = "Xen"; // VMM name
+
+			// create VM
+			Vm vm = new Vm(vmid, brokerId, mips, pesNumber, ram, bw, size, vmm, new CloudletSchedulerTimeShared());
+			
+			Vm vm1 = new Vm(1, brokerId, mips, pesNumber, ram, bw, size, vmm, new CloudletSchedulerTimeShared());
+			Vm vm2 = new Vm(2, brokerId, mips, pesNumber, ram, bw, size, vmm, new CloudletSchedulerTimeShared());
+
+			// add the VM to the vmList
+			vmlist.add(vm);
+			
+			vmlist.add(vm1);
+			vmlist.add(vm2);
+
+			// submit vm list to the broker
+			broker.submitVmList(vmlist);
+
+			// Fifth step: Create one Cloudlet
+			cloudletList = new ArrayList<Cloudlet>();
+
+			// Cloudlet properties
+			int id = 0;
+			long length = 400000;
+			long fileSize = 300;
+			long outputSize = 300;
+			UtilizationModel utilizationModel = new UtilizationModelFull();
+
+			Cloudlet cloudlet = new Cloudlet(id, length, pesNumber, fileSize, outputSize, utilizationModel, utilizationModel, utilizationModel);
+			cloudlet.setUserId(brokerId);
+			cloudlet.setVmId(vmid);
+			
+			Cloudlet cloudlet1 = new Cloudlet(1, length, pesNumber, fileSize, outputSize, utilizationModel, utilizationModel, utilizationModel);
+			cloudlet1.setUserId(brokerId);
+			cloudlet1.setVmId(1);
+			
+			Cloudlet cloudlet2 = new Cloudlet(2, length, pesNumber, fileSize, outputSize, utilizationModel, utilizationModel, utilizationModel);
+			cloudlet2.setUserId(brokerId);
+			cloudlet2.setVmId(2);
+			
+
+			// add the cloudlet to the list
+			cloudletList.add(cloudlet);	
+			cloudletList.add(cloudlet1);
+			cloudletList.add(cloudlet2);
+
+			// submit cloudlet list to the broker
+			broker.submitCloudletList(cloudletList);
+
+			// Sixth step: Starts the simulation
+			CloudSim.startSimulation();
+
+			CloudSim.stopSimulation();
+
+			//Final step: Print results when simulation is over
+			List<Cloudlet> newList = broker.getCloudletReceivedList();
+			printCloudletList(newList);
+
+			// Print the debt of each user to each datacenter
+			datacenter0.printDebts();
+
+			Log.printLine("CloudSimExample1 finished!");
+		} catch (Exception e) {
+			e.printStackTrace();
+			Log.printLine("Unwanted errors happen");
+		}
+	}
+
+	/**
+	 * Creates the datacenter.
+	 *
+	 * @param name the name
+	 *
+	 * @return the datacenter
+	 */
+	private static Datacenter createDatacenter(String name) {
+
+		// Here are the steps needed to create a PowerDatacenter:
+		// 1. We need to create a list to store
+		// our machine
+		List<Host> hostList = new ArrayList<Host>();
+
+		// 2. A Machine contains one or more PEs or CPUs/Cores.
+		// In this example, it will have only one core.
+		List<Pe> peList = new ArrayList<Pe>();
+
+		int mips = 1000;
+
+		// 3. Create PEs and add these into a list.
+		peList.add(new Pe(0, new PeProvisionerSimple(mips))); // need to store Pe id and MIPS Rating
+
+		// 4. Create Host with its id and list of PEs and add them to the list
+		// of machines
+		int hostId = 0;
+		int ram = 2048; // host memory (MB)
+		long storage = 1000000; // host storage
+		int bw = 10000;
+
+		hostList.add(
+			new Host(
+				hostId,
+				new RamProvisionerSimple(ram),
+				new BwProvisionerSimple(bw),
+				storage,
+				peList,
+				new VmSchedulerTimeShared(peList)
+			)
+		); // This is our machine
+
+		// 5. Create a DatacenterCharacteristics object that stores the
+		// properties of a data center: architecture, OS, list of
+		// Machines, allocation policy: time- or space-shared, time zone
+		// and its price (G$/Pe time unit).
+		String arch = "x86"; // system architecture
+		String os = "Linux"; // operating system
+		String vmm = "Xen";
+		double time_zone = 10.0; // time zone this resource located
+		double cost = 3.0; // the cost of using processing in this resource
+		double costPerMem = 0.05; // the cost of using memory in this resource
+		double costPerStorage = 0.001; // the cost of using storage in this
+										// resource
+		double costPerBw = 0.0; // the cost of using bw in this resource
+		LinkedList<Storage> storageList = new LinkedList<Storage>(); // we are not adding SAN
+													// devices by now
+
+		DatacenterCharacteristics characteristics = new DatacenterCharacteristics(
+				arch, os, vmm, hostList, time_zone, cost, costPerMem,
+				costPerStorage, costPerBw);
+
+		// 6. Finally, we need to create a PowerDatacenter object.
+		Datacenter datacenter = null;
+		try {
+			datacenter = new Datacenter(name, characteristics, new VmAllocationPolicySimple(hostList), storageList, 0);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+
+		return datacenter;
+	}
+
+	// We strongly encourage users to develop their own broker policies, to
+	// submit vms and cloudlets according
+	// to the specific rules of the simulated scenario
+	/**
+	 * Creates the broker.
+	 *
+	 * @return the datacenter broker
+	 */
+	private static DatacenterBroker createBroker() {
+		DatacenterBroker broker = null;
+		try {
+			broker = new DatacenterBroker("Broker");
+		} catch (Exception e) {
+			e.printStackTrace();
+			return null;
+		}
+		return broker;
+	}
+
+	/**
+	 * Prints the Cloudlet objects.
+	 *
+	 * @param list list of Cloudlets
+	 */
+	private static void printCloudletList(List<Cloudlet> list) {
+		int size = list.size();
+		Cloudlet cloudlet;
+
+		String indent = "    ";
+		Log.printLine();
+		Log.printLine("========== OUTPUT ==========");
+		Log.printLine("Cloudlet ID" + indent + "STATUS" + indent
+				+ "Data center ID" + indent + "VM ID" + indent + "Time" + indent
+				+ "Start Time" + indent + "Finish Time");
+
+		DecimalFormat dft = new DecimalFormat("###.##");
+		for (int i = 0; i < size; i++) {
+			cloudlet = list.get(i);
+			Log.print(indent + cloudlet.getCloudletId() + indent + indent);
+
+			if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS) {
+				Log.print("SUCCESS");
+
+				Log.printLine(indent + indent + cloudlet.getResourceId()
+						+ indent + indent + indent + cloudlet.getVmId()
+						+ indent + indent
+						+ dft.format(cloudlet.getActualCPUTime()) + indent
+						+ indent + dft.format(cloudlet.getExecStartTime())
+						+ indent + indent
+						+ dft.format(cloudlet.getFinishTime()));
+			}
+		}
+	}
+
+}