initial commit of EdgeCloudSim

EdgeCloudSim with default network model, mobility model,  load generator
model, edge orchestrator, and VM CPU utilization model

src/edu/boun/edgecloudsim/network/MM1Queue.java

@@ -0,0 +1,186 @@
+/*
+ * Title:        EdgeCloudSim - M/M/1 Queue model implementation
+ * 
+ * Description: 
+ * MM1Queue implements M/M/1 Queue model for WLAN and WAN communication
+ * 
+ * Licence:      GPL - http://www.gnu.org/copyleft/gpl.html
+ * Copyright (c) 2017, Bogazici University, Istanbul, Turkey
+ */
+
+package edu.boun.edgecloudsim.network;
+
+import org.cloudbus.cloudsim.core.CloudSim;
+
+import edu.boun.edgecloudsim.core.SimManager;
+import edu.boun.edgecloudsim.core.SimSettings;
+import edu.boun.edgecloudsim.edge_server.EdgeHost;
+import edu.boun.edgecloudsim.utils.Location;
+
+public class MM1Queue extends NetworkModel {
+	private double WlanPoissonMean; //seconds
+	private double WanPoissonMean; //seconds
+	private double avgTaskInputSize; //bytes
+	private double avgTaskOutputSize; //bytes
+	private int maxNumOfClientsInPlace;
+	
+	public MM1Queue(int _numberOfMobileDevices) {
+		super(_numberOfMobileDevices);
+	}
+
+
+	@Override
+	public void initialize() {
+		WlanPoissonMean=0;
+		WanPoissonMean=0;
+		avgTaskInputSize=0;
+		avgTaskOutputSize=0;
+		maxNumOfClientsInPlace=0;
+		
+		//Calculate interarrival time and task sizes
+		double numOfTaskType = 0;
+		SimSettings SS = SimSettings.getInstance();
+		for (SimSettings.APP_TYPES taskType : SimSettings.APP_TYPES.values()) {
+			double weight = SS.getTaskLookUpTable()[taskType.ordinal()][0]/(double)100;
+			if(weight != 0) {
+				WlanPoissonMean += (SS.getTaskLookUpTable()[taskType.ordinal()][2])*weight;
+				
+				double percentageOfCloudCommunication = SS.getTaskLookUpTable()[taskType.ordinal()][1];
+				WanPoissonMean += (WlanPoissonMean)*((double)100/percentageOfCloudCommunication)*weight;
+				
+				avgTaskInputSize += SS.getTaskLookUpTable()[taskType.ordinal()][5]*weight;
+				
+				avgTaskOutputSize += SS.getTaskLookUpTable()[taskType.ordinal()][6]*weight;
+				
+				numOfTaskType++;
+			}
+		}
+		
+		WlanPoissonMean = WlanPoissonMean/numOfTaskType;
+		avgTaskInputSize = avgTaskInputSize/numOfTaskType;
+		avgTaskOutputSize = avgTaskOutputSize/numOfTaskType;
+	}
+
+    /**
+    * source device is always mobile device in our simulation scenarios!
+    */
+	@Override
+	public double getUploadDelay(int sourceDeviceId, int destDeviceId) {
+		double delay = 0;
+		Location accessPointLocation = SimManager.getInstance().getMobilityModel().getLocation(sourceDeviceId,CloudSim.clock());
+
+		//if destination device is the cloud datacenter, both wan and wlan delay should be considered
+		if(destDeviceId == SimSettings.CLOUD_DATACENTER_ID){
+			double wlanDelay = getWlanUploadDelay(accessPointLocation, CloudSim.clock());
+			double wanDelay = getWanUploadDelay(accessPointLocation, CloudSim.clock() + wlanDelay);
+			if(wlanDelay > 0 && wanDelay >0)
+				delay = wlanDelay + wanDelay;
+		}
+		else{
+			delay = getWlanUploadDelay(accessPointLocation, CloudSim.clock());
+			
+			//all requests are send to edge orchestrator first than redirected related VM
+			delay += (SimSettings.getInstance().getInternalLanDelay() * 2);
+		}
+		
+		return delay;
+	}
+
+    /**
+    * destination device is always mobile device in our simulation scenarios!
+    */
+	@Override
+	public double getDownloadDelay(int sourceDeviceId, int destDeviceId) {
+		double delay = 0;
+		Location accessPointLocation = SimManager.getInstance().getMobilityModel().getLocation(destDeviceId,CloudSim.clock());
+		
+		//if source device is the cloud datacenter, both wan and wlan delay should be considered
+		if(sourceDeviceId == SimSettings.CLOUD_DATACENTER_ID){
+			double wlanDelay = getWlanDownloadDelay(accessPointLocation, CloudSim.clock());
+			double wanDelay = getWanDownloadDelay(accessPointLocation, CloudSim.clock() + wlanDelay);
+			if(wlanDelay > 0 && wanDelay >0)
+				delay = wlanDelay + wanDelay;
+		}
+		else{
+			delay = getWlanDownloadDelay(accessPointLocation, CloudSim.clock());
+			
+			EdgeHost host = (EdgeHost)(SimManager.
+					getInstance().
+					getLocalServerManager().
+					getDatacenterList().get(sourceDeviceId).
+					getHostList().get(0));
+			
+			//if source device id is the edge server which is located in another location, add internal lan delay
+			//in our scenasrio, serving wlan ID is equal to the host id, because there is only one host in one place
+			if(host.getLocation().getServingWlanId() != accessPointLocation.getServingWlanId())
+				delay += (SimSettings.getInstance().getInternalLanDelay() * 2);
+		}
+		
+		return delay;
+	}
+	
+	public int getMaxNumOfClientsInPlace(){
+		return maxNumOfClientsInPlace;
+	}
+	
+	private int getDeviceCount(Location deviceLocation, double time){
+		int deviceCount = 0;
+		
+		for(int i=0; i<numberOfMobileDevices; i++) {
+			Location location = SimManager.getInstance().getMobilityModel().getLocation(i,time);
+			if(location.equals(deviceLocation))
+				deviceCount++;
+		}
+		
+		//record max number of client just for debugging
+		if(maxNumOfClientsInPlace<deviceCount)
+			maxNumOfClientsInPlace = deviceCount;
+		
+		return deviceCount;
+	}
+	
+	private double calculateMM1(double propogationDelay, int bandwidth /*Kbps*/, double PoissonMean, double avgTaskSize /*KB*/, int deviceCount){
+		double Bps=0, mu=0, lamda=0;
+		
+		avgTaskSize = avgTaskSize * (double)1000; //convert from KB to Byte
+		
+		Bps = bandwidth * (double)1000 / (double)8; //convert from Kbps to Byte per seconds
+	    lamda = ((double)1/(double)PoissonMean); //task per seconds
+		mu = Bps / avgTaskSize ; //task per seconds
+		double result = (double)1 / (mu-lamda*(double)deviceCount);
+		
+		return result + propogationDelay;
+	}
+	
+	private double getWlanDownloadDelay(Location accessPointLocation, double time) {
+		return calculateMM1(0,
+				SimSettings.getInstance().getWlanBandwidth(),
+				WlanPoissonMean,
+				avgTaskOutputSize,
+				getDeviceCount(accessPointLocation, time));
+	}
+	
+	private double getWlanUploadDelay(Location accessPointLocation, double time) {
+		return calculateMM1(0,
+				SimSettings.getInstance().getWlanBandwidth(),
+				WlanPoissonMean,
+				avgTaskInputSize,
+				getDeviceCount(accessPointLocation, time));
+	}
+	
+	private double getWanDownloadDelay(Location accessPointLocation, double time) {
+		return calculateMM1(SimSettings.getInstance().getWanPropogationDelay(),
+				SimSettings.getInstance().getWanBandwidth(),
+				WanPoissonMean,
+				avgTaskOutputSize,
+				getDeviceCount(accessPointLocation, time));
+	}
+	
+	private double getWanUploadDelay(Location accessPointLocation, double time) {
+		return calculateMM1(SimSettings.getInstance().getWanPropogationDelay(),
+				SimSettings.getInstance().getWanBandwidth(),
+				WanPoissonMean,
+				avgTaskInputSize,
+				getDeviceCount(accessPointLocation, time));
+	}
+}

src/edu/boun/edgecloudsim/network/NetworkModel.java

@@ -0,0 +1,37 @@
+/*
+ * Title:        EdgeCloudSim - Network Model
+ * 
+ * Description: 
+ * NetworkModel is an abstract class which is used for calculating the
+ * network delay from device to device. For those who wants to add a
+ * custom Network Model to EdgeCloudSim should extend this class and
+ * provide a concreate instance via ScenarioFactory
+ *               
+ * Licence:      GPL - http://www.gnu.org/copyleft/gpl.html
+ * Copyright (c) 2017, Bogazici University, Istanbul, Turkey
+ */
+
+package edu.boun.edgecloudsim.network;
+
+public abstract class NetworkModel {
+	protected int numberOfMobileDevices;
+
+	public NetworkModel(int _numberOfMobileDevices){
+		numberOfMobileDevices=_numberOfMobileDevices;
+	};
+	
+	/**
+	* initializes costom network model
+	*/
+	public abstract void initialize();
+	
+    /**
+    * calculates the upload delay from source to destination device
+    */
+	public abstract double getUploadDelay(int sourceDeviceId, int destDeviceId);
+	
+    /**
+    * calculates the download delay from source to destination device
+    */
+	public abstract double getDownloadDelay(int sourceDeviceId, int destDeviceId);
+}