tormakris/edgecloudsim
4
0
Fork 0
Code Pull Requests Releases Activity

major modifications for v2.0 release

Browse Source 
Release notes

1- Cloud server processing was simplified in the initial version, it is handled via cloudsim components now.

2- Cloud server manager, edge server manager, mobile device manager and vm allocation policy are used as abstract class in factory pattern to allow developers to use different business logic without modifying EdgeCloudSim source code.

3- The task and place types are no longer defined as enumeration. They are used as integer value in order to manipulate more place type without modifying enum variable.

4- Two sample applications (one of them is simple and the other one extended application) are added along with the corresponding matlab files to plot statistics.

5- Cloud server properties are added to the simulation settings file

6- New log items are added to simulation result files

7- Code refactoring is applied including the modification of comments
This commit is contained in:
Cagatay Sonmez
2018-09-10 14:22:27 +03:00
parent e01833bda6
commit d4545f009f
89 changed files with 10699 additions and 4689 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
src/edu/boun/edgecloudsim/sample_application/mainApp.java → src/edu/boun/edgecloudsim/applications/sample_app1/MainApp.java
View File

@ -1,132 +1,131 @@
/*
* Title: EdgeCloudSim - Sample Application
*
* Description: Sample application for EdgeCloudSim
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.sample_application;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.core.CloudSim;
import edu.boun.edgecloudsim.core.ScenarioFactory;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.SimLogger;
import edu.boun.edgecloudsim.utils.SimUtils;
public class mainApp {
/**
* Creates main() to run this example
*/
public static void main(String[] args) {
//disable console output of cloudsim library
Log.disable();
//enable console ourput and file output of this application
SimLogger.enablePrintLog();
int iterationNumber = 1;
String configFile = "";
String outputFolder = "";
String edgeDevicesFile = "";
String applicationsFile = "";
if (args.length == 5){
configFile = args[0];
edgeDevicesFile = args[1];
applicationsFile = args[2];
outputFolder = args[3];
iterationNumber = Integer.parseInt(args[4]);
}
else{
SimLogger.printLine("Simulation setting file, output folder and iteration number are not provided! Using default ones...");
String configName = "default_config";
configFile = "config/sample_application/" + configName + ".properties";
applicationsFile = "config/sample_application/applications.xml";
edgeDevicesFile = "config/sample_application/edge_devices.xml";
outputFolder = "D:/" + configName + "/ite" + iterationNumber;
}
//load settings from configuration file
SimSettings SS = SimSettings.getInstance();
if(SS.initialize(configFile, edgeDevicesFile, applicationsFile) == false){
SimLogger.printLine("cannot initialize simulation settings!");
System.exit(0);
}
if(SS.getFileLoggingEnabled()){
SimLogger.enableFileLog();
SimUtils.cleanOutputFolder(outputFolder);
}
DateFormat df = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
Date SimulationStartDate = Calendar.getInstance().getTime();
String now = df.format(SimulationStartDate);
SimLogger.printLine("Simulation started at " + now);
SimLogger.printLine("----------------------------------------------------------------------");
for(int j=SS.getMinNumOfMobileDev(); j<=SS.getMaxNumOfMobileDev(); j+=SS.getMobileDevCounterSize())
{
for(int k=0; k<SS.getSimulationScenarios().length; k++)
{
for(int i=0; i<SS.getOrchestratorPolicies().length; i++)
{
String simScenario = SS.getSimulationScenarios()[k];
String orchestratorPolicy = SS.getOrchestratorPolicies()[i];
Date ScenarioStartDate = Calendar.getInstance().getTime();
now = df.format(ScenarioStartDate);
SimLogger.printLine("Scenario started at " + now);
SimLogger.printLine("Scenario: " + simScenario + " - Policy: " + orchestratorPolicy + " - #iteration: " + iterationNumber);
SimLogger.printLine("Duration: " + SS.getSimulationTime()/3600 + " hour(s) - Poisson: " + SS.getTaskLookUpTable()[0][2] + " - #devices: " + j);
SimLogger.getInstance().simStarted(outputFolder,"SIMRESULT_" + simScenario + "_" + orchestratorPolicy + "_" + j + "DEVICES");
try
{
// First step: Initialize the CloudSim package. It should be called
// before creating any entities.
int num_user = 2; // number of grid users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events
// Initialize the CloudSim library
CloudSim.init(num_user, calendar, trace_flag, 0.01);
// Generate EdgeCloudsim Scenario Factory
ScenarioFactory sampleFactory = new SampleScenarioFactory(j,SS.getSimulationTime(), orchestratorPolicy, simScenario);
// Generate EdgeCloudSim Simulation Manager
SimManager manager = new SimManager(sampleFactory, j, simScenario);
// Start simulation
manager.startSimulation();
}
catch (Exception e)
{
SimLogger.printLine("The simulation has been terminated due to an unexpected error");
e.printStackTrace();
System.exit(0);
}
Date ScenarioEndDate = Calendar.getInstance().getTime();
now = df.format(ScenarioEndDate);
SimLogger.printLine("Scenario finished at " + now + ". It took " + SimUtils.getTimeDifference(ScenarioStartDate,ScenarioEndDate));
SimLogger.printLine("----------------------------------------------------------------------");
}//End of orchestrators loop
}//End of scenarios loop
}//End of mobile devices loop
Date SimulationEndDate = Calendar.getInstance().getTime();
now = df.format(SimulationEndDate);
SimLogger.printLine("Simulation finished at " + now + ". It took " + SimUtils.getTimeDifference(SimulationStartDate,SimulationEndDate));
}
}
/*
* Title: EdgeCloudSim - Main Application
*
* Description: Main application for Simple App
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.applications.sample_app1;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.core.CloudSim;
import edu.boun.edgecloudsim.core.ScenarioFactory;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.SimLogger;
import edu.boun.edgecloudsim.utils.SimUtils;
public class MainApp {
/**
* Creates main() to run this example
*/
public static void main(String[] args) {
//disable console output of cloudsim library
Log.disable();
//enable console ourput and file output of this application
SimLogger.enablePrintLog();
int iterationNumber = 1;
String configFile = "";
String outputFolder = "";
String edgeDevicesFile = "";
String applicationsFile = "";
if (args.length == 5){
configFile = args[0];
edgeDevicesFile = args[1];
applicationsFile = args[2];
outputFolder = args[3];
iterationNumber = Integer.parseInt(args[4]);
}
else{
SimLogger.printLine("Simulation setting file, output folder and iteration number are not provided! Using default ones...");
configFile = "scripts/sample_app1/config/default_config.properties";
applicationsFile = "scripts/sample_app1/config/applications.xml";
edgeDevicesFile = "scripts/sample_app1/config/edge_devices.xml";
outputFolder = "sim_results/ite" + iterationNumber;
}
//load settings from configuration file
SimSettings SS = SimSettings.getInstance();
if(SS.initialize(configFile, edgeDevicesFile, applicationsFile) == false){
SimLogger.printLine("cannot initialize simulation settings!");
System.exit(0);
}
if(SS.getFileLoggingEnabled()){
SimLogger.enableFileLog();
SimUtils.cleanOutputFolder(outputFolder);
}
DateFormat df = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
Date SimulationStartDate = Calendar.getInstance().getTime();
String now = df.format(SimulationStartDate);
SimLogger.printLine("Simulation started at " + now);
SimLogger.printLine("----------------------------------------------------------------------");
for(int j=SS.getMinNumOfMobileDev(); j<=SS.getMaxNumOfMobileDev(); j+=SS.getMobileDevCounterSize())
{
for(int k=0; k<SS.getSimulationScenarios().length; k++)
{
for(int i=0; i<SS.getOrchestratorPolicies().length; i++)
{
String simScenario = SS.getSimulationScenarios()[k];
String orchestratorPolicy = SS.getOrchestratorPolicies()[i];
Date ScenarioStartDate = Calendar.getInstance().getTime();
now = df.format(ScenarioStartDate);
SimLogger.printLine("Scenario started at " + now);
SimLogger.printLine("Scenario: " + simScenario + " - Policy: " + orchestratorPolicy + " - #iteration: " + iterationNumber);
SimLogger.printLine("Duration: " + SS.getSimulationTime()/3600 + " hour(s) - Poisson: " + SS.getTaskLookUpTable()[0][2] + " - #devices: " + j);
SimLogger.getInstance().simStarted(outputFolder,"SIMRESULT_" + simScenario + "_" + orchestratorPolicy + "_" + j + "DEVICES");
try
{
// First step: Initialize the CloudSim package. It should be called
// before creating any entities.
int num_user = 2; // number of grid users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events
// Initialize the CloudSim library
CloudSim.init(num_user, calendar, trace_flag, 0.01);
// Generate EdgeCloudsim Scenario Factory
ScenarioFactory sampleFactory = new SampleScenarioFactory(j,SS.getSimulationTime(), orchestratorPolicy, simScenario);
// Generate EdgeCloudSim Simulation Manager
SimManager manager = new SimManager(sampleFactory, j, simScenario, orchestratorPolicy);
// Start simulation
manager.startSimulation();
}
catch (Exception e)
{
SimLogger.printLine("The simulation has been terminated due to an unexpected error");
e.printStackTrace();
System.exit(0);
}
Date ScenarioEndDate = Calendar.getInstance().getTime();
now = df.format(ScenarioEndDate);
SimLogger.printLine("Scenario finished at " + now + ". It took " + SimUtils.getTimeDifference(ScenarioStartDate,ScenarioEndDate));
SimLogger.printLine("----------------------------------------------------------------------");
}//End of orchestrators loop
}//End of scenarios loop
}//End of mobile devices loop
Date SimulationEndDate = Calendar.getInstance().getTime();
now = df.format(SimulationEndDate);
SimLogger.printLine("Simulation finished at " + now + ". It took " + SimUtils.getTimeDifference(SimulationStartDate,SimulationEndDate));
}
}

155
src/edu/boun/edgecloudsim/sample_application/SampleScenarioFactory.java → src/edu/boun/edgecloudsim/applications/sample_app1/SampleScenarioFactory.java
View File

@ -1,77 +1,78 @@
/*
* Title: EdgeCloudSim - Sample Scenario Factory
*
* Description: Sample factory providing the default
* instances of required abstract classes
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.sample_application;
import java.util.List;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.VmAllocationPolicy;
import edu.boun.edgecloudsim.core.ScenarioFactory;
import edu.boun.edgecloudsim.core.SimSettings.APP_TYPES;
import edu.boun.edgecloudsim.edge_orchestrator.BasicEdgeOrchestrator;
import edu.boun.edgecloudsim.edge_orchestrator.EdgeOrchestrator;
import edu.boun.edgecloudsim.edge_server.VmAllocationPolicy_Custom;
import edu.boun.edgecloudsim.edge_client.CpuUtilizationModel_Custom;
import edu.boun.edgecloudsim.mobility.MobilityModel;
import edu.boun.edgecloudsim.mobility.NomadicMobility;
import edu.boun.edgecloudsim.task_generator.IdleActiveLoadGenerator;
import edu.boun.edgecloudsim.task_generator.LoadGeneratorModel;
import edu.boun.edgecloudsim.network.MM1Queue;
import edu.boun.edgecloudsim.network.NetworkModel;
public class SampleScenarioFactory implements ScenarioFactory {
private int numOfMobileDevice;
private double simulationTime;
private String orchestratorPolicy;
private String simScenario;
SampleScenarioFactory(int _numOfMobileDevice,
double _simulationTime,
String _orchestratorPolicy,
String _simScenario){
orchestratorPolicy = _orchestratorPolicy;
numOfMobileDevice = _numOfMobileDevice;
simulationTime = _simulationTime;
simScenario = _simScenario;
}
@Override
public LoadGeneratorModel getLoadGeneratorModel() {
return new IdleActiveLoadGenerator(numOfMobileDevice, simulationTime, simScenario);
}
@Override
public EdgeOrchestrator getEdgeOrchestrator() {
return new BasicEdgeOrchestrator(orchestratorPolicy, simScenario);
}
@Override
public MobilityModel getMobilityModel() {
return new NomadicMobility(numOfMobileDevice,simulationTime);
}
@Override
public NetworkModel getNetworkModel() {
return new MM1Queue(numOfMobileDevice);
}
@Override
public VmAllocationPolicy getVmAllocationPolicy(List<? extends Host> hostList, int dataCenterIndex) {
return new VmAllocationPolicy_Custom(hostList,dataCenterIndex);
}
@Override
public UtilizationModel getCpuUtilizationModel(APP_TYPES _taskType) {
return new CpuUtilizationModel_Custom(_taskType);
}
}
/*
* Title: EdgeCloudSim - Scenario Factory
*
* Description: Sample scenario factory providing the default
* instances of required abstract classes
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.applications.sample_app1;
import edu.boun.edgecloudsim.cloud_server.CloudServerManager;
import edu.boun.edgecloudsim.cloud_server.DefaultCloudServerManager;
import edu.boun.edgecloudsim.core.ScenarioFactory;
import edu.boun.edgecloudsim.edge_orchestrator.BasicEdgeOrchestrator;
import edu.boun.edgecloudsim.edge_orchestrator.EdgeOrchestrator;
import edu.boun.edgecloudsim.edge_server.DefaultEdgeServerManager;
import edu.boun.edgecloudsim.edge_server.EdgeServerManager;
import edu.boun.edgecloudsim.edge_client.DefaultMobileDeviceManager;
import edu.boun.edgecloudsim.edge_client.MobileDeviceManager;
import edu.boun.edgecloudsim.mobility.MobilityModel;
import edu.boun.edgecloudsim.mobility.NomadicMobility;
import edu.boun.edgecloudsim.task_generator.IdleActiveLoadGenerator;
import edu.boun.edgecloudsim.task_generator.LoadGeneratorModel;
import edu.boun.edgecloudsim.network.MM1Queue;
import edu.boun.edgecloudsim.network.NetworkModel;
public class SampleScenarioFactory implements ScenarioFactory {
private int numOfMobileDevice;
private double simulationTime;
private String orchestratorPolicy;
private String simScenario;
SampleScenarioFactory(int _numOfMobileDevice,
double _simulationTime,
String _orchestratorPolicy,
String _simScenario){
orchestratorPolicy = _orchestratorPolicy;
numOfMobileDevice = _numOfMobileDevice;
simulationTime = _simulationTime;
simScenario = _simScenario;
}
@Override
public LoadGeneratorModel getLoadGeneratorModel() {
return new IdleActiveLoadGenerator(numOfMobileDevice, simulationTime, simScenario);
}
@Override
public EdgeOrchestrator getEdgeOrchestrator() {
return new BasicEdgeOrchestrator(orchestratorPolicy, simScenario);
}
@Override
public MobilityModel getMobilityModel() {
return new NomadicMobility(numOfMobileDevice,simulationTime);
}
@Override
public NetworkModel getNetworkModel() {
return new MM1Queue(numOfMobileDevice, simScenario);
}
@Override
public EdgeServerManager getEdgeServerManager() {
return new DefaultEdgeServerManager();
}
@Override
public CloudServerManager getCloudServerManager() {
return new DefaultCloudServerManager();
}
public MobileDeviceManager getMobileDeviceManager() throws Exception {
return new DefaultMobileDeviceManager();
}
}

131
src/edu/boun/edgecloudsim/applications/sample_app2/MainApp.java Normal file
View File

@ -0,0 +1,131 @@
/*
* Title: EdgeCloudSim - Main Application
*
* Description: Main application for Sample App2
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.applications.sample_app2;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.core.CloudSim;
import edu.boun.edgecloudsim.core.ScenarioFactory;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.SimLogger;
import edu.boun.edgecloudsim.utils.SimUtils;
public class MainApp {
/**
* Creates main() to run this example
*/
public static void main(String[] args) {
//disable console output of cloudsim library
Log.disable();
//enable console ourput and file output of this application
SimLogger.enablePrintLog();
int iterationNumber = 1;
String configFile = "";
String outputFolder = "";
String edgeDevicesFile = "";
String applicationsFile = "";
if (args.length == 5){
configFile = args[0];
edgeDevicesFile = args[1];
applicationsFile = args[2];
outputFolder = args[3];
iterationNumber = Integer.parseInt(args[4]);
}
else{
SimLogger.printLine("Simulation setting file, output folder and iteration number are not provided! Using default ones...");
configFile = "scripts/sample_app2/config/default_config.properties";
applicationsFile = "scripts/sample_app2/config/applications.xml";
edgeDevicesFile = "scripts/sample_app2/config/edge_devices.xml";
outputFolder = "sim_results/ite" + iterationNumber;
}
//load settings from configuration file
SimSettings SS = SimSettings.getInstance();
if(SS.initialize(configFile, edgeDevicesFile, applicationsFile) == false){
SimLogger.printLine("cannot initialize simulation settings!");
System.exit(0);
}
if(SS.getFileLoggingEnabled()){
SimLogger.enableFileLog();
SimUtils.cleanOutputFolder(outputFolder);
}
DateFormat df = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
Date SimulationStartDate = Calendar.getInstance().getTime();
String now = df.format(SimulationStartDate);
SimLogger.printLine("Simulation started at " + now);
SimLogger.printLine("----------------------------------------------------------------------");
for(int j=SS.getMinNumOfMobileDev(); j<=SS.getMaxNumOfMobileDev(); j+=SS.getMobileDevCounterSize())
{
for(int k=0; k<SS.getSimulationScenarios().length; k++)
{
for(int i=0; i<SS.getOrchestratorPolicies().length; i++)
{
String simScenario = SS.getSimulationScenarios()[k];
String orchestratorPolicy = SS.getOrchestratorPolicies()[i];
Date ScenarioStartDate = Calendar.getInstance().getTime();
now = df.format(ScenarioStartDate);
SimLogger.printLine("Scenario started at " + now);
SimLogger.printLine("Scenario: " + simScenario + " - Policy: " + orchestratorPolicy + " - #iteration: " + iterationNumber);
SimLogger.printLine("Duration: " + SS.getSimulationTime()/60 + " min (warm up period: "+ SS.getWarmUpPeriod()/60 +" min) - #devices: " + j);
SimLogger.getInstance().simStarted(outputFolder,"SIMRESULT_" + simScenario + "_" + orchestratorPolicy + "_" + j + "DEVICES");
try
{
// First step: Initialize the CloudSim package. It should be called
// before creating any entities.
int num_user = 2; // number of grid users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events
// Initialize the CloudSim library
CloudSim.init(num_user, calendar, trace_flag, 0.01);
// Generate EdgeCloudsim Scenario Factory
ScenarioFactory sampleFactory = new SampleScenarioFactory(j,SS.getSimulationTime(), orchestratorPolicy, simScenario);
// Generate EdgeCloudSim Simulation Manager
SimManager manager = new SimManager(sampleFactory, j, simScenario, orchestratorPolicy);
// Start simulation
manager.startSimulation();
}
catch (Exception e)
{
SimLogger.printLine("The simulation has been terminated due to an unexpected error");
e.printStackTrace();
System.exit(0);
}
Date ScenarioEndDate = Calendar.getInstance().getTime();
now = df.format(ScenarioEndDate);
SimLogger.printLine("Scenario finished at " + now + ". It took " + SimUtils.getTimeDifference(ScenarioStartDate,ScenarioEndDate));
SimLogger.printLine("----------------------------------------------------------------------");
}//End of orchestrators loop
}//End of scenarios loop
}//End of mobile devices loop
Date SimulationEndDate = Calendar.getInstance().getTime();
now = df.format(SimulationEndDate);
SimLogger.printLine("Simulation finished at " + now + ". It took " + SimUtils.getTimeDifference(SimulationStartDate,SimulationEndDate));
}
}

163
src/edu/boun/edgecloudsim/applications/sample_app2/SampleEdgeOrchestrator.java Normal file
View File

@ -0,0 +1,163 @@
/*
* Title: EdgeCloudSim - Edge Orchestrator
*
* Description:
* SampleEdgeOrchestrator offloads tasks to proper server
* by considering WAN bandwidth and edge server utilization.
* After the target server is decided, the least loaded VM is selected.
* If the target server is a remote edge server, MAN is used.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.applications.sample_app2;
import java.util.List;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.SimEvent;
import edu.boun.edgecloudsim.cloud_server.CloudVM;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.edge_orchestrator.EdgeOrchestrator;
import edu.boun.edgecloudsim.edge_server.EdgeVM;
import edu.boun.edgecloudsim.edge_client.CpuUtilizationModel_Custom;
import edu.boun.edgecloudsim.edge_client.Task;
import edu.boun.edgecloudsim.utils.SimLogger;
public class SampleEdgeOrchestrator extends EdgeOrchestrator {
private int numberOfHost; //used by load balancer
public SampleEdgeOrchestrator(String _policy, String _simScenario) {
super(_policy, _simScenario);
}
@Override
public void initialize() {
numberOfHost=SimSettings.getInstance().getNumOfEdgeHosts();
}
/*
* (non-Javadoc)
* @see edu.boun.edgecloudsim.edge_orchestrator.EdgeOrchestrator#getDeviceToOffload(edu.boun.edgecloudsim.edge_client.Task)
*
* It is assumed that the edge orchestrator app is running on the edge devices in a distributed manner
*/
@Override
public int getDeviceToOffload(Task task) {
int result = 0;
//RODO: return proper host ID
if(simScenario.equals("SINGLE_TIER")){
result = SimSettings.GENERIC_EDGE_DEVICE_ID;
}
else if(simScenario.equals("TWO_TIER_WITH_EO")){
//dummy task to simulate a task with 1 Mbit file size to upload and download
Task dummyTask = new Task(0, 0, 0, 0, 128, 128, new UtilizationModelFull(), new UtilizationModelFull(), new UtilizationModelFull());
double wanDelay = SimManager.getInstance().getNetworkModel().getUploadDelay(task.getMobileDeviceId(),
SimSettings.CLOUD_DATACENTER_ID, dummyTask /* 1 Mbit */);
double wanBW = (wanDelay == 0) ? 0 : (1 / wanDelay); /* Mbps */
double edgeUtilization = SimManager.getInstance().getEdgeServerManager().getAvgUtilization();
if(policy.equals("NETWORK_BASED")){
if(wanBW > 6)
result = SimSettings.CLOUD_DATACENTER_ID;
else
result = SimSettings.GENERIC_EDGE_DEVICE_ID;
}
else if(policy.equals("UTILIZATION_BASED")){
double utilization = edgeUtilization;
if(utilization > 80)
result = SimSettings.CLOUD_DATACENTER_ID;
else
result = SimSettings.GENERIC_EDGE_DEVICE_ID;
}
else if(policy.equals("HYBRID")){
double utilization = edgeUtilization;
if(wanBW > 6 && utilization > 80)
result = SimSettings.CLOUD_DATACENTER_ID;
else
result = SimSettings.GENERIC_EDGE_DEVICE_ID;
}
else {
SimLogger.printLine("Unknow edge orchestrator policy! Terminating simulation...");
System.exit(0);
}
}
else {
SimLogger.printLine("Unknow simulation scenario! Terminating simulation...");
System.exit(0);
}
return result;
}
@Override
public Vm getVmToOffload(Task task, int deviceId) {
Vm selectedVM = null;
if(deviceId == SimSettings.CLOUD_DATACENTER_ID){
//Select VM on cloud devices via Least Loaded algorithm!
double selectedVmCapacity = 0; //start with min value
List<Host> list = SimManager.getInstance().getCloudServerManager().getDatacenter().getHostList();
for (int hostIndex=0; hostIndex < list.size(); hostIndex++) {
List<CloudVM> vmArray = SimManager.getInstance().getCloudServerManager().getVmList(hostIndex);
for(int vmIndex=0; vmIndex<vmArray.size(); vmIndex++){
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(vmIndex).getVmType());
double targetVmCapacity = (double)100 - vmArray.get(vmIndex).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
if(requiredCapacity <= targetVmCapacity && targetVmCapacity > selectedVmCapacity){
selectedVM = vmArray.get(vmIndex);
selectedVmCapacity = targetVmCapacity;
}
}
}
}
else if(deviceId == SimSettings.GENERIC_EDGE_DEVICE_ID){
//Select VM on edge devices via Least Loaded algorithm!
double selectedVmCapacity = 0; //start with min value
for(int hostIndex=0; hostIndex<numberOfHost; hostIndex++){
List<EdgeVM> vmArray = SimManager.getInstance().getEdgeServerManager().getVmList(hostIndex);
for(int vmIndex=0; vmIndex<vmArray.size(); vmIndex++){
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(vmIndex).getVmType());
double targetVmCapacity = (double)100 - vmArray.get(vmIndex).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
if(requiredCapacity <= targetVmCapacity && targetVmCapacity > selectedVmCapacity){
selectedVM = vmArray.get(vmIndex);
selectedVmCapacity = targetVmCapacity;
}
}
}
}
else{
SimLogger.printLine("Unknown device id! The simulation has been terminated.");
System.exit(0);
}
return selectedVM;
}
@Override
public void processEvent(SimEvent arg0) {
// Nothing to do!
}
@Override
public void shutdownEntity() {
// Nothing to do!
}
@Override
public void startEntity() {
// Nothing to do!
}
}

399
src/edu/boun/edgecloudsim/applications/sample_app2/SampleMobileDeviceManager.java Normal file
View File

@ -0,0 +1,399 @@
/*
* Title: EdgeCloudSim - Mobile Device Manager
*
* Description:
* Mobile Device Manager is one of the most important component
* in EdgeCloudSim. It is responsible for creating the tasks,
* submitting them to the related VM with respect to the
* Edge Orchestrator decision, and takes proper actions when
* the execution of the tasks are finished. It also feeds the
* SimLogger with the relevant results.
* SampleMobileDeviceManager sends tasks to the edge servers or
* cloud servers. The mobile devices use WAN if the tasks are
* offloaded to the edge servers. On the other hand, they use WLAN
* if the target server is an edge server. Finally, the mobile
* devices use MAN if they must be served by a remote edge server
* due to the congestion at their own location. In this case,
* they access the edge server via two hops where the packets
* must go through WLAN and MAN.
*
* If you want to use different topology, you should modify
* the flow implemented in this class.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.applications.sample_app2;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.CloudSimTags;
import org.cloudbus.cloudsim.core.SimEvent;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.core.SimSettings.NETWORK_DELAY_TYPES;
import edu.boun.edgecloudsim.edge_client.CpuUtilizationModel_Custom;
import edu.boun.edgecloudsim.edge_client.MobileDeviceManager;
import edu.boun.edgecloudsim.edge_client.Task;
import edu.boun.edgecloudsim.edge_server.EdgeHost;
import edu.boun.edgecloudsim.edge_server.EdgeVM;
import edu.boun.edgecloudsim.network.NetworkModel;
import edu.boun.edgecloudsim.utils.EdgeTask;
import edu.boun.edgecloudsim.utils.Location;
import edu.boun.edgecloudsim.utils.SimLogger;
public class SampleMobileDeviceManager extends MobileDeviceManager {
private static final int BASE = 100000; //start from base in order not to conflict cloudsim tag!
private static final int UPDATE_MM1_QUEUE_MODEL = BASE + 1;
private static final int REQUEST_RECEIVED_BY_CLOUD = BASE + 2;
private static final int REQUEST_RECEIVED_BY_EDGE_DEVICE = BASE + 3;
private static final int REQUEST_RECEIVED_BY_REMOTE_EDGE_DEVICE = BASE + 4;
private static final int REQUEST_RECEIVED_BY_EDGE_DEVICE_TO_RELAY_NEIGHBOR = BASE + 5;
private static final int RESPONSE_RECEIVED_BY_MOBILE_DEVICE = BASE + 6;
private static final int RESPONSE_RECEIVED_BY_EDGE_DEVICE_TO_RELAY_MOBILE_DEVICE = BASE + 7;
private static final double MM1_QUEUE_MODEL_UPDATE_INTEVAL = 5; //seconds
private int taskIdCounter=0;
public SampleMobileDeviceManager() throws Exception{
}
@Override
public void initialize() {
}
@Override
public UtilizationModel getCpuUtilizationModel() {
return new CpuUtilizationModel_Custom();
}
@Override
public void startEntity() {
super.startEntity();
schedule(getId(), SimSettings.CLIENT_ACTIVITY_START_TIME +
MM1_QUEUE_MODEL_UPDATE_INTEVAL, UPDATE_MM1_QUEUE_MODEL);
}
/**
* Submit cloudlets to the created VMs.
*
* @pre $none
* @post $none
*/
protected void submitCloudlets() {
//do nothing!
}
/**
* Process a cloudlet return event.
*
* @param ev a SimEvent object
* @pre ev != $null
* @post $none
*/
protected void processCloudletReturn(SimEvent ev) {
NetworkModel networkModel = SimManager.getInstance().getNetworkModel();
Task task = (Task) ev.getData();
SimLogger.getInstance().taskExecuted(task.getCloudletId());
if(task.getAssociatedDatacenterId() == SimSettings.CLOUD_DATACENTER_ID){
//SimLogger.printLine(CloudSim.clock() + ": " + getName() + ": task #" + task.getCloudletId() + " received from cloud");
double WanDelay = networkModel.getDownloadDelay(SimSettings.CLOUD_DATACENTER_ID, task.getMobileDeviceId(), task);
if(WanDelay > 0)
{
Location currentLocation = SimManager.getInstance().getMobilityModel().getLocation(task.getMobileDeviceId(),CloudSim.clock()+WanDelay);
if(task.getSubmittedLocation().getServingWlanId() == currentLocation.getServingWlanId())
{
networkModel.downloadStarted(task.getSubmittedLocation(), SimSettings.CLOUD_DATACENTER_ID);
SimLogger.getInstance().setDownloadDelay(task.getCloudletId(), WanDelay, NETWORK_DELAY_TYPES.WAN_DELAY);
schedule(getId(), WanDelay, RESPONSE_RECEIVED_BY_MOBILE_DEVICE, task);
}
else
{
SimLogger.getInstance().failedDueToMobility(task.getCloudletId(), CloudSim.clock());
}
}
else
{
SimLogger.getInstance().failedDueToBandwidth(task.getCloudletId(), CloudSim.clock(), NETWORK_DELAY_TYPES.WAN_DELAY);
}
}
else{
int nextEvent = RESPONSE_RECEIVED_BY_MOBILE_DEVICE;
int nextDeviceForNetworkModel = SimSettings.GENERIC_EDGE_DEVICE_ID;
NETWORK_DELAY_TYPES delayType = NETWORK_DELAY_TYPES.WLAN_DELAY;
double delay = networkModel.getDownloadDelay(task.getAssociatedHostId(), task.getMobileDeviceId(), task);
EdgeHost host = (EdgeHost)(SimManager.
getInstance().
getEdgeServerManager().
getDatacenterList().get(task.getAssociatedHostId()).
getHostList().get(0));
//if neighbor edge device is selected
if(host.getLocation().getServingWlanId() != task.getSubmittedLocation().getServingWlanId())
{
delay = networkModel.getDownloadDelay(SimSettings.GENERIC_EDGE_DEVICE_ID, SimSettings.GENERIC_EDGE_DEVICE_ID, task);
nextEvent = RESPONSE_RECEIVED_BY_EDGE_DEVICE_TO_RELAY_MOBILE_DEVICE;
nextDeviceForNetworkModel = SimSettings.GENERIC_EDGE_DEVICE_ID + 1;
delayType = NETWORK_DELAY_TYPES.MAN_DELAY;
}
if(delay > 0)
{
Location currentLocation = SimManager.getInstance().getMobilityModel().getLocation(task.getMobileDeviceId(),CloudSim.clock()+delay);
if(task.getSubmittedLocation().getServingWlanId() == currentLocation.getServingWlanId())
{
networkModel.downloadStarted(currentLocation, nextDeviceForNetworkModel);
SimLogger.getInstance().setDownloadDelay(task.getCloudletId(), delay, delayType);
schedule(getId(), delay, nextEvent, task);
}
else
{
SimLogger.getInstance().failedDueToMobility(task.getCloudletId(), CloudSim.clock());
}
}
else
{
SimLogger.getInstance().failedDueToBandwidth(task.getCloudletId(), CloudSim.clock(), delayType);
}
}
}
protected void processOtherEvent(SimEvent ev) {
if (ev == null) {
SimLogger.printLine(getName() + ".processOtherEvent(): " + "Error - an event is null! Terminating simulation...");
System.exit(0);
return;
}
NetworkModel networkModel = SimManager.getInstance().getNetworkModel();
switch (ev.getTag()) {
case UPDATE_MM1_QUEUE_MODEL:
{
((SampleNetworkModel)networkModel).updateMM1QueeuModel();
schedule(getId(), MM1_QUEUE_MODEL_UPDATE_INTEVAL, UPDATE_MM1_QUEUE_MODEL);
break;
}
case REQUEST_RECEIVED_BY_CLOUD:
{
Task task = (Task) ev.getData();
networkModel.uploadFinished(task.getSubmittedLocation(), SimSettings.CLOUD_DATACENTER_ID);
submitTaskToVm(task, SimSettings.VM_TYPES.CLOUD_VM);
break;
}
case REQUEST_RECEIVED_BY_EDGE_DEVICE:
{
Task task = (Task) ev.getData();
networkModel.uploadFinished(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID);
submitTaskToVm(task, SimSettings.VM_TYPES.EDGE_VM);
break;
}
case REQUEST_RECEIVED_BY_REMOTE_EDGE_DEVICE:
{
Task task = (Task) ev.getData();
networkModel.uploadFinished(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID+1);
submitTaskToVm(task, SimSettings.VM_TYPES.EDGE_VM);
break;
}
case REQUEST_RECEIVED_BY_EDGE_DEVICE_TO_RELAY_NEIGHBOR:
{
Task task = (Task) ev.getData();
networkModel.uploadFinished(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID);
double manDelay = networkModel.getUploadDelay(SimSettings.GENERIC_EDGE_DEVICE_ID, SimSettings.GENERIC_EDGE_DEVICE_ID, task);
if(manDelay>0){
networkModel.uploadStarted(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID+1);
SimLogger.getInstance().setUploadDelay(task.getCloudletId(), manDelay, NETWORK_DELAY_TYPES.MAN_DELAY);
schedule(getId(), manDelay, REQUEST_RECEIVED_BY_REMOTE_EDGE_DEVICE, task);
}
else
{
//SimLogger.printLine("Task #" + task.getCloudletId() + " cannot assign to any VM");
SimLogger.getInstance().rejectedDueToBandwidth(
task.getCloudletId(),
CloudSim.clock(),
SimSettings.VM_TYPES.EDGE_VM.ordinal(),
NETWORK_DELAY_TYPES.MAN_DELAY);
}
break;
}
case RESPONSE_RECEIVED_BY_EDGE_DEVICE_TO_RELAY_MOBILE_DEVICE:
{
Task task = (Task) ev.getData();
networkModel.downloadFinished(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID+1);
//SimLogger.printLine(CloudSim.clock() + ": " + getName() + ": task #" + task.getCloudletId() + " received from edge");
double delay = networkModel.getDownloadDelay(task.getAssociatedHostId(), task.getMobileDeviceId(), task);
if(delay > 0)
{
Location currentLocation = SimManager.getInstance().getMobilityModel().getLocation(task.getMobileDeviceId(),CloudSim.clock()+delay);
if(task.getSubmittedLocation().getServingWlanId() == currentLocation.getServingWlanId())
{
networkModel.downloadStarted(currentLocation, SimSettings.GENERIC_EDGE_DEVICE_ID);
SimLogger.getInstance().setDownloadDelay(task.getCloudletId(), delay, NETWORK_DELAY_TYPES.WLAN_DELAY);
schedule(getId(), delay, RESPONSE_RECEIVED_BY_MOBILE_DEVICE, task);
}
else
{
SimLogger.getInstance().failedDueToMobility(task.getCloudletId(), CloudSim.clock());
}
}
else
{
SimLogger.getInstance().failedDueToBandwidth(task.getCloudletId(), CloudSim.clock(), NETWORK_DELAY_TYPES.WLAN_DELAY);
}
break;
}
case RESPONSE_RECEIVED_BY_MOBILE_DEVICE:
{
Task task = (Task) ev.getData();
if(task.getAssociatedDatacenterId() == SimSettings.CLOUD_DATACENTER_ID)
networkModel.downloadFinished(task.getSubmittedLocation(), SimSettings.CLOUD_DATACENTER_ID);
else
networkModel.downloadFinished(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID);
SimLogger.getInstance().taskEnded(task.getCloudletId(), CloudSim.clock());
break;
}
default:
SimLogger.printLine(getName() + ".processOtherEvent(): " + "Error - event unknown by this DatacenterBroker. Terminating simulation...");
System.exit(0);
break;
}
}
public void submitTask(EdgeTask edgeTask) {
int vmType=0;
int nextEvent=0;
int nextDeviceForNetworkModel;
NETWORK_DELAY_TYPES delayType;
double delay=0;
NetworkModel networkModel = SimManager.getInstance().getNetworkModel();
//create a task
Task task = createTask(edgeTask);
Location currentLocation = SimManager.getInstance().getMobilityModel().
getLocation(task.getMobileDeviceId(), CloudSim.clock());
//set location of the mobile device which generates this task
task.setSubmittedLocation(currentLocation);
//add related task to log list
SimLogger.getInstance().addLog(task.getCloudletId(),
task.getTaskType(),
(int)task.getCloudletLength(),
(int)task.getCloudletFileSize(),
(int)task.getCloudletOutputSize());
int nextHopId = SimManager.getInstance().getEdgeOrchestrator().getDeviceToOffload(task);
if(nextHopId == SimSettings.CLOUD_DATACENTER_ID){
delay = networkModel.getUploadDelay(task.getMobileDeviceId(), SimSettings.CLOUD_DATACENTER_ID, task);
vmType = SimSettings.VM_TYPES.CLOUD_VM.ordinal();
nextEvent = REQUEST_RECEIVED_BY_CLOUD;
delayType = NETWORK_DELAY_TYPES.WAN_DELAY;
nextDeviceForNetworkModel = SimSettings.CLOUD_DATACENTER_ID;
}
else {
delay = networkModel.getUploadDelay(task.getMobileDeviceId(), SimSettings.GENERIC_EDGE_DEVICE_ID, task);
vmType = SimSettings.VM_TYPES.EDGE_VM.ordinal();
nextEvent = REQUEST_RECEIVED_BY_EDGE_DEVICE;
delayType = NETWORK_DELAY_TYPES.WLAN_DELAY;
nextDeviceForNetworkModel = SimSettings.GENERIC_EDGE_DEVICE_ID;
}
if(delay>0){
Vm selectedVM = SimManager.getInstance().getEdgeOrchestrator().getVmToOffload(task, nextHopId);
if(selectedVM != null){
//set related host id
task.setAssociatedDatacenterId(nextHopId);
//set related host id
task.setAssociatedHostId(selectedVM.getHost().getId());
//set related vm id
task.setAssociatedVmId(selectedVM.getId());
//bind task to related VM
getCloudletList().add(task);
bindCloudletToVm(task.getCloudletId(), selectedVM.getId());
if(selectedVM instanceof EdgeVM){
EdgeHost host = (EdgeHost)(selectedVM.getHost());
//if neighbor edge device is selected
if(host.getLocation().getServingWlanId() != task.getSubmittedLocation().getServingWlanId()){
nextEvent = REQUEST_RECEIVED_BY_EDGE_DEVICE_TO_RELAY_NEIGHBOR;
}
}
networkModel.uploadStarted(currentLocation, nextDeviceForNetworkModel);
SimLogger.getInstance().taskStarted(task.getCloudletId(), CloudSim.clock());
SimLogger.getInstance().setUploadDelay(task.getCloudletId(), delay, delayType);
schedule(getId(), delay, nextEvent, task);
}
else{
//SimLogger.printLine("Task #" + task.getCloudletId() + " cannot assign to any VM");
SimLogger.getInstance().rejectedDueToVMCapacity(task.getCloudletId(), CloudSim.clock(), vmType);
}
}
else
{
//SimLogger.printLine("Task #" + task.getCloudletId() + " cannot assign to any VM");
SimLogger.getInstance().rejectedDueToBandwidth(task.getCloudletId(), CloudSim.clock(), vmType, delayType);
}
}
private void submitTaskToVm(Task task, SimSettings.VM_TYPES vmType) {
//SimLogger.printLine(CloudSim.clock() + ": Cloudlet#" + task.getCloudletId() + " is submitted to VM#" + task.getVmId());
schedule(getVmsToDatacentersMap().get(task.getVmId()), 0, CloudSimTags.CLOUDLET_SUBMIT, task);
SimLogger.getInstance().taskAssigned(task.getCloudletId(),
task.getAssociatedDatacenterId(),
task.getAssociatedHostId(),
task.getAssociatedVmId(),
vmType.ordinal());
}
private Task createTask(EdgeTask edgeTask){
UtilizationModel utilizationModel = new UtilizationModelFull(); /*UtilizationModelStochastic*/
UtilizationModel utilizationModelCPU = getCpuUtilizationModel();
Task task = new Task(edgeTask.mobileDeviceId, ++taskIdCounter,
edgeTask.length, edgeTask.pesNumber,
edgeTask.inputFileSize, edgeTask.outputFileSize,
utilizationModelCPU, utilizationModel, utilizationModel);
//set the owner of this task
task.setUserId(this.getId());
task.setTaskType(edgeTask.taskType);
if (utilizationModelCPU instanceof CpuUtilizationModel_Custom) {
((CpuUtilizationModel_Custom)utilizationModelCPU).setTask(task);
}
return task;
}
}

432
src/edu/boun/edgecloudsim/applications/sample_app2/SampleNetworkModel.java Normal file
View File

@ -0,0 +1,432 @@
/*
* Title: EdgeCloudSim - Network Model
*
* Description:
* SampleNetworkModel uses
* -> the result of an empirical study for the WLAN and WAN delays
* The experimental network model is developed
* by taking measurements from the real life deployments.
*
* -> MMPP/MMPP/1 queue model for MAN delay
* MAN delay is observed via a single server queue model with
* Markov-modulated Poisson process (MMPP) arrivals.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.applications.sample_app2;
import org.cloudbus.cloudsim.core.CloudSim;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.edge_client.Task;
import edu.boun.edgecloudsim.network.NetworkModel;
import edu.boun.edgecloudsim.utils.Location;
import edu.boun.edgecloudsim.utils.SimLogger;
public class SampleNetworkModel extends NetworkModel {
public static enum NETWORK_TYPE {WLAN, LAN};
public static enum LINK_TYPE {DOWNLOAD, UPLOAD};
public static double MAN_BW = 1300*1024; //Kbps
@SuppressWarnings("unused")
private int manClients;
private int[] wanClients;
private int[] wlanClients;
private double lastMM1QueeuUpdateTime;
private double ManPoissonMeanForDownload; //seconds
private double ManPoissonMeanForUpload; //seconds
private double avgManTaskInputSize; //bytes
private double avgManTaskOutputSize; //bytes
//record last n task statistics during MM1_QUEUE_MODEL_UPDATE_INTEVAL seconds to simulate mmpp/m/1 queue model
private double totalManTaskInputSize;
private double totalManTaskOutputSize;
private double numOfManTaskForDownload;
private double numOfManTaskForUpload;
public static final double[] experimentalWlanDelay = {
/*1 Client*/ 88040.279 /*(Kbps)*/,
/*2 Clients*/ 45150.982 /*(Kbps)*/,
/*3 Clients*/ 30303.641 /*(Kbps)*/,
/*4 Clients*/ 27617.211 /*(Kbps)*/,
/*5 Clients*/ 24868.616 /*(Kbps)*/,
/*6 Clients*/ 22242.296 /*(Kbps)*/,
/*7 Clients*/ 20524.064 /*(Kbps)*/,
/*8 Clients*/ 18744.889 /*(Kbps)*/,
/*9 Clients*/ 17058.827 /*(Kbps)*/,
/*10 Clients*/ 15690.455 /*(Kbps)*/,
/*11 Clients*/ 14127.744 /*(Kbps)*/,
/*12 Clients*/ 13522.408 /*(Kbps)*/,
/*13 Clients*/ 13177.631 /*(Kbps)*/,
/*14 Clients*/ 12811.330 /*(Kbps)*/,
/*15 Clients*/ 12584.387 /*(Kbps)*/,
/*15 Clients*/ 12135.161 /*(Kbps)*/,
/*16 Clients*/ 11705.638 /*(Kbps)*/,
/*17 Clients*/ 11276.116 /*(Kbps)*/,
/*18 Clients*/ 10846.594 /*(Kbps)*/,
/*19 Clients*/ 10417.071 /*(Kbps)*/,
/*20 Clients*/ 9987.549 /*(Kbps)*/,
/*21 Clients*/ 9367.587 /*(Kbps)*/,
/*22 Clients*/ 8747.625 /*(Kbps)*/,
/*23 Clients*/ 8127.663 /*(Kbps)*/,
/*24 Clients*/ 7907.701 /*(Kbps)*/,
/*25 Clients*/ 7887.739 /*(Kbps)*/,
/*26 Clients*/ 7690.831 /*(Kbps)*/,
/*27 Clients*/ 7393.922 /*(Kbps)*/,
/*28 Clients*/ 7297.014 /*(Kbps)*/,
/*29 Clients*/ 7100.106 /*(Kbps)*/,
/*30 Clients*/ 6903.197 /*(Kbps)*/,
/*31 Clients*/ 6701.986 /*(Kbps)*/,
/*32 Clients*/ 6500.776 /*(Kbps)*/,
/*33 Clients*/ 6399.565 /*(Kbps)*/,
/*34 Clients*/ 6098.354 /*(Kbps)*/,
/*35 Clients*/ 5897.143 /*(Kbps)*/,
/*36 Clients*/ 5552.127 /*(Kbps)*/,
/*37 Clients*/ 5207.111 /*(Kbps)*/,
/*38 Clients*/ 4862.096 /*(Kbps)*/,
/*39 Clients*/ 4517.080 /*(Kbps)*/,
/*40 Clients*/ 4172.064 /*(Kbps)*/,
/*41 Clients*/ 4092.922 /*(Kbps)*/,
/*42 Clients*/ 4013.781 /*(Kbps)*/,
/*43 Clients*/ 3934.639 /*(Kbps)*/,
/*44 Clients*/ 3855.498 /*(Kbps)*/,
/*45 Clients*/ 3776.356 /*(Kbps)*/,
/*46 Clients*/ 3697.215 /*(Kbps)*/,
/*47 Clients*/ 3618.073 /*(Kbps)*/,
/*48 Clients*/ 3538.932 /*(Kbps)*/,
/*49 Clients*/ 3459.790 /*(Kbps)*/,
/*50 Clients*/ 3380.649 /*(Kbps)*/,
/*51 Clients*/ 3274.611 /*(Kbps)*/,
/*52 Clients*/ 3168.573 /*(Kbps)*/,
/*53 Clients*/ 3062.536 /*(Kbps)*/,
/*54 Clients*/ 2956.498 /*(Kbps)*/,
/*55 Clients*/ 2850.461 /*(Kbps)*/,
/*56 Clients*/ 2744.423 /*(Kbps)*/,
/*57 Clients*/ 2638.386 /*(Kbps)*/,
/*58 Clients*/ 2532.348 /*(Kbps)*/,
/*59 Clients*/ 2426.310 /*(Kbps)*/,
/*60 Clients*/ 2320.273 /*(Kbps)*/,
/*61 Clients*/ 2283.828 /*(Kbps)*/,
/*62 Clients*/ 2247.383 /*(Kbps)*/,
/*63 Clients*/ 2210.939 /*(Kbps)*/,
/*64 Clients*/ 2174.494 /*(Kbps)*/,
/*65 Clients*/ 2138.049 /*(Kbps)*/,
/*66 Clients*/ 2101.604 /*(Kbps)*/,
/*67 Clients*/ 2065.160 /*(Kbps)*/,
/*68 Clients*/ 2028.715 /*(Kbps)*/,
/*69 Clients*/ 1992.270 /*(Kbps)*/,
/*70 Clients*/ 1955.825 /*(Kbps)*/,
/*71 Clients*/ 1946.788 /*(Kbps)*/,
/*72 Clients*/ 1937.751 /*(Kbps)*/,
/*73 Clients*/ 1928.714 /*(Kbps)*/,
/*74 Clients*/ 1919.677 /*(Kbps)*/,
/*75 Clients*/ 1910.640 /*(Kbps)*/,
/*76 Clients*/ 1901.603 /*(Kbps)*/,
/*77 Clients*/ 1892.566 /*(Kbps)*/,
/*78 Clients*/ 1883.529 /*(Kbps)*/,
/*79 Clients*/ 1874.492 /*(Kbps)*/,
/*80 Clients*/ 1865.455 /*(Kbps)*/,
/*81 Clients*/ 1833.185 /*(Kbps)*/,
/*82 Clients*/ 1800.915 /*(Kbps)*/,
/*83 Clients*/ 1768.645 /*(Kbps)*/,
/*84 Clients*/ 1736.375 /*(Kbps)*/,
/*85 Clients*/ 1704.106 /*(Kbps)*/,
/*86 Clients*/ 1671.836 /*(Kbps)*/,
/*87 Clients*/ 1639.566 /*(Kbps)*/,
/*88 Clients*/ 1607.296 /*(Kbps)*/,
/*89 Clients*/ 1575.026 /*(Kbps)*/,
/*90 Clients*/ 1542.756 /*(Kbps)*/,
/*91 Clients*/ 1538.544 /*(Kbps)*/,
/*92 Clients*/ 1534.331 /*(Kbps)*/,
/*93 Clients*/ 1530.119 /*(Kbps)*/,
/*94 Clients*/ 1525.906 /*(Kbps)*/,
/*95 Clients*/ 1521.694 /*(Kbps)*/,
/*96 Clients*/ 1517.481 /*(Kbps)*/,
/*97 Clients*/ 1513.269 /*(Kbps)*/,
/*98 Clients*/ 1509.056 /*(Kbps)*/,
/*99 Clients*/ 1504.844 /*(Kbps)*/,
/*100 Clients*/ 1500.631 /*(Kbps)*/
};
public static final double[] experimentalWanDelay = {
/*1 Client*/ 20703.973 /*(Kbps)*/,
/*2 Clients*/ 12023.957 /*(Kbps)*/,
/*3 Clients*/ 9887.785 /*(Kbps)*/,
/*4 Clients*/ 8915.775 /*(Kbps)*/,
/*5 Clients*/ 8259.277 /*(Kbps)*/,
/*6 Clients*/ 7560.574 /*(Kbps)*/,
/*7 Clients*/ 7262.140 /*(Kbps)*/,
/*8 Clients*/ 7155.361 /*(Kbps)*/,
/*9 Clients*/ 7041.153 /*(Kbps)*/,
/*10 Clients*/ 6994.595 /*(Kbps)*/,
/*11 Clients*/ 6653.232 /*(Kbps)*/,
/*12 Clients*/ 6111.868 /*(Kbps)*/,
/*13 Clients*/ 5570.505 /*(Kbps)*/,
/*14 Clients*/ 5029.142 /*(Kbps)*/,
/*15 Clients*/ 4487.779 /*(Kbps)*/,
/*16 Clients*/ 3899.729 /*(Kbps)*/,
/*17 Clients*/ 3311.680 /*(Kbps)*/,
/*18 Clients*/ 2723.631 /*(Kbps)*/,
/*19 Clients*/ 2135.582 /*(Kbps)*/,
/*20 Clients*/ 1547.533 /*(Kbps)*/,
/*21 Clients*/ 1500.252 /*(Kbps)*/,
/*22 Clients*/ 1452.972 /*(Kbps)*/,
/*23 Clients*/ 1405.692 /*(Kbps)*/,
/*24 Clients*/ 1358.411 /*(Kbps)*/,
/*25 Clients*/ 1311.131 /*(Kbps)*/
};
public SampleNetworkModel(int _numberOfMobileDevices, String _simScenario) {
super(_numberOfMobileDevices, _simScenario);
}
@Override
public void initialize() {
wanClients = new int[SimSettings.getInstance().getNumOfEdgeDatacenters()]; //we have one access point for each datacenter
wlanClients = new int[SimSettings.getInstance().getNumOfEdgeDatacenters()]; //we have one access point for each datacenter
int numOfApp = SimSettings.getInstance().getTaskLookUpTable().length;
SimSettings SS = SimSettings.getInstance();
for(int taskIndex=0; taskIndex<numOfApp; taskIndex++) {
if(SS.getTaskLookUpTable()[taskIndex][0] == 0) {
SimLogger.printLine("Usage percantage of task " + taskIndex + " is 0! Terminating simulation...");
System.exit(0);
}
else{
double weight = SS.getTaskLookUpTable()[taskIndex][0]/(double)100;
//assume half of the tasks use the MAN at the beginning
ManPoissonMeanForDownload += ((SS.getTaskLookUpTable()[taskIndex][2])*weight) * 4;
ManPoissonMeanForUpload = ManPoissonMeanForDownload;
avgManTaskInputSize += SS.getTaskLookUpTable()[taskIndex][5]*weight;
avgManTaskOutputSize += SS.getTaskLookUpTable()[taskIndex][6]*weight;
}
}
ManPoissonMeanForDownload = ManPoissonMeanForDownload/numOfApp;
ManPoissonMeanForUpload = ManPoissonMeanForUpload/numOfApp;
avgManTaskInputSize = avgManTaskInputSize/numOfApp;
avgManTaskOutputSize = avgManTaskOutputSize/numOfApp;
lastMM1QueeuUpdateTime = SimSettings.CLIENT_ACTIVITY_START_TIME;
totalManTaskOutputSize = 0;
numOfManTaskForDownload = 0;
totalManTaskInputSize = 0;
numOfManTaskForUpload = 0;
}
/**
* source device is always mobile device in our simulation scenarios!
*/
@Override
public double getUploadDelay(int sourceDeviceId, int destDeviceId, Task task) {
double delay = 0;
//special case for man communication
if(sourceDeviceId == destDeviceId && sourceDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID){
return delay = getManUploadDelay();
}
Location accessPointLocation = SimManager.getInstance().getMobilityModel().getLocation(sourceDeviceId,CloudSim.clock());
//mobile device to cloud server
if(destDeviceId == SimSettings.CLOUD_DATACENTER_ID){
delay = getWanUploadDelay(accessPointLocation, task.getCloudletFileSize());
}
//mobile device to edge device (wifi access point)
else if (destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID) {
delay = getWlanUploadDelay(accessPointLocation, task.getCloudletFileSize());
}
return delay;
}
/**
* destination device is always mobile device in our simulation scenarios!
*/
@Override
public double getDownloadDelay(int sourceDeviceId, int destDeviceId, Task task) {
double delay = 0;
//special case for man communication
if(sourceDeviceId == destDeviceId && sourceDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID){
return delay = getManDownloadDelay();
}
Location accessPointLocation = SimManager.getInstance().getMobilityModel().getLocation(destDeviceId,CloudSim.clock());
//cloud server to mobile device
if(sourceDeviceId == SimSettings.CLOUD_DATACENTER_ID){
delay = getWanDownloadDelay(accessPointLocation, task.getCloudletOutputSize());
}
//edge device (wifi access point) to mobile device
else{
delay = getWlanDownloadDelay(accessPointLocation, task.getCloudletOutputSize());
}
return delay;
}
@Override
public void uploadStarted(Location accessPointLocation, int destDeviceId) {
if(destDeviceId == SimSettings.CLOUD_DATACENTER_ID)
wanClients[accessPointLocation.getServingWlanId()]++;
else if (destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID)
wlanClients[accessPointLocation.getServingWlanId()]++;
else if (destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID+1)
manClients++;
else {
SimLogger.printLine("Error - unknown device id in uploadStarted(). Terminating simulation...");
System.exit(0);
}
}
@Override
public void uploadFinished(Location accessPointLocation, int destDeviceId) {
if(destDeviceId == SimSettings.CLOUD_DATACENTER_ID)
wanClients[accessPointLocation.getServingWlanId()]--;
else if (destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID)
wlanClients[accessPointLocation.getServingWlanId()]--;
else if (destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID+1)
manClients--;
else {
SimLogger.printLine("Error - unknown device id in uploadFinished(). Terminating simulation...");
System.exit(0);
}
}
@Override
public void downloadStarted(Location accessPointLocation, int sourceDeviceId) {
if(sourceDeviceId == SimSettings.CLOUD_DATACENTER_ID)
wanClients[accessPointLocation.getServingWlanId()]++;
else if(sourceDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID)
wlanClients[accessPointLocation.getServingWlanId()]++;
else if(sourceDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID+1)
manClients++;
else {
SimLogger.printLine("Error - unknown device id in downloadStarted(). Terminating simulation...");
System.exit(0);
}
}
@Override
public void downloadFinished(Location accessPointLocation, int sourceDeviceId) {
if(sourceDeviceId == SimSettings.CLOUD_DATACENTER_ID)
wanClients[accessPointLocation.getServingWlanId()]--;
else if(sourceDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID)
wlanClients[accessPointLocation.getServingWlanId()]--;
else if(sourceDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID+1)
manClients--;
else {
SimLogger.printLine("Error - unknown device id in downloadFinished(). Terminating simulation...");
System.exit(0);
}
}
private double getWlanDownloadDelay(Location accessPointLocation, double dataSize) {
int numOfWlanUser = wlanClients[accessPointLocation.getServingWlanId()];
double taskSizeInKb = dataSize * (double)8; //KB to Kb
double result=0;
if(numOfWlanUser < experimentalWlanDelay.length)
result = taskSizeInKb /*Kb*/ / (experimentalWlanDelay[numOfWlanUser] * (double) 3 ) /*Kbps*/; //802.11ac is around 3 times faster than 802.11n
//System.out.println("--> " + numOfWlanUser + " user, " + taskSizeInKb + " KB, " +result + " sec");
return result;
}
//wlan upload and download delay is symmetric in this model
private double getWlanUploadDelay(Location accessPointLocation, double dataSize) {
return getWlanDownloadDelay(accessPointLocation, dataSize);
}
private double getWanDownloadDelay(Location accessPointLocation, double dataSize) {
int numOfWanUser = wanClients[accessPointLocation.getServingWlanId()];
double taskSizeInKb = dataSize * (double)8; //KB to Kb
double result=0;
if(numOfWanUser < experimentalWanDelay.length)
result = taskSizeInKb /*Kb*/ / (experimentalWanDelay[numOfWanUser]) /*Kbps*/;
//System.out.println("--> " + numOfWanUser + " user, " + taskSizeInKb + " KB, " +result + " sec");
return result;
}
//wan upload and download delay is symmetric in this model
private double getWanUploadDelay(Location accessPointLocation, double dataSize) {
return getWanDownloadDelay(accessPointLocation, dataSize);
}
private double calculateMM1(double propogationDelay, double bandwidth /*Kbps*/, double PoissonMean, double avgTaskSize /*KB*/, int deviceCount){
double mu=0, lamda=0;
avgTaskSize = avgTaskSize * 8; //convert from KB to Kb
lamda = ((double)1/(double)PoissonMean); //task per seconds
mu = bandwidth /*Kbps*/ / avgTaskSize /*Kb*/; //task per seconds
double result = (double)1 / (mu-lamda*(double)deviceCount);
if(result < 0)
return 0;
result += propogationDelay;
return (result > 15) ? 0 : result;
}
private double getManDownloadDelay() {
double result = calculateMM1(SimSettings.getInstance().getInternalLanDelay(),
MAN_BW,
ManPoissonMeanForDownload,
avgManTaskOutputSize,
numberOfMobileDevices);
totalManTaskOutputSize += avgManTaskOutputSize;
numOfManTaskForDownload++;
//System.out.println("--> " + SimManager.getInstance().getNumOfMobileDevice() + " user, " +result + " sec");
return result;
}
private double getManUploadDelay() {
double result = calculateMM1(SimSettings.getInstance().getInternalLanDelay(),
MAN_BW,
ManPoissonMeanForUpload,
avgManTaskInputSize,
numberOfMobileDevices);
totalManTaskInputSize += avgManTaskInputSize;
numOfManTaskForUpload++;
//System.out.println(CloudSim.clock() + " -> " + SimManager.getInstance().getNumOfMobileDevice() + " user, " + result + " sec");
return result;
}
public void updateMM1QueeuModel(){
double lastInterval = CloudSim.clock() - lastMM1QueeuUpdateTime;
lastMM1QueeuUpdateTime = CloudSim.clock();
if(numOfManTaskForDownload != 0){
ManPoissonMeanForDownload = lastInterval / (numOfManTaskForDownload / (double)numberOfMobileDevices);
avgManTaskOutputSize = totalManTaskOutputSize / numOfManTaskForDownload;
}
if(numOfManTaskForUpload != 0){
ManPoissonMeanForUpload = lastInterval / (numOfManTaskForUpload / (double)numberOfMobileDevices);
avgManTaskInputSize = totalManTaskInputSize / numOfManTaskForUpload;
}
totalManTaskOutputSize = 0;
numOfManTaskForDownload = 0;
totalManTaskInputSize = 0;
numOfManTaskForUpload = 0;
}
}

76
src/edu/boun/edgecloudsim/applications/sample_app2/SampleScenarioFactory.java Normal file
View File

@ -0,0 +1,76 @@
/*
* Title: EdgeCloudSim - Scenario Factory
*
* Description: Sample scenario factory providing the default
* instances of required abstract classes
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.applications.sample_app2;
import edu.boun.edgecloudsim.cloud_server.CloudServerManager;
import edu.boun.edgecloudsim.cloud_server.DefaultCloudServerManager;
import edu.boun.edgecloudsim.core.ScenarioFactory;
import edu.boun.edgecloudsim.edge_orchestrator.EdgeOrchestrator;
import edu.boun.edgecloudsim.edge_server.DefaultEdgeServerManager;
import edu.boun.edgecloudsim.edge_server.EdgeServerManager;
import edu.boun.edgecloudsim.edge_client.MobileDeviceManager;
import edu.boun.edgecloudsim.mobility.MobilityModel;
import edu.boun.edgecloudsim.mobility.NomadicMobility;
import edu.boun.edgecloudsim.task_generator.IdleActiveLoadGenerator;
import edu.boun.edgecloudsim.task_generator.LoadGeneratorModel;
import edu.boun.edgecloudsim.network.NetworkModel;
public class SampleScenarioFactory implements ScenarioFactory {
private int numOfMobileDevice;
private double simulationTime;
private String orchestratorPolicy;
private String simScenario;
SampleScenarioFactory(int _numOfMobileDevice,
double _simulationTime,
String _orchestratorPolicy,
String _simScenario){
orchestratorPolicy = _orchestratorPolicy;
numOfMobileDevice = _numOfMobileDevice;
simulationTime = _simulationTime;
simScenario = _simScenario;
}
@Override
public LoadGeneratorModel getLoadGeneratorModel() {
return new IdleActiveLoadGenerator(numOfMobileDevice, simulationTime, simScenario);
}
@Override
public EdgeOrchestrator getEdgeOrchestrator() {
return new SampleEdgeOrchestrator(orchestratorPolicy, simScenario);
}
@Override
public MobilityModel getMobilityModel() {
return new NomadicMobility(numOfMobileDevice,simulationTime);
}
@Override
public NetworkModel getNetworkModel() {
return new SampleNetworkModel(numOfMobileDevice, simScenario);
}
@Override
public EdgeServerManager getEdgeServerManager() {
return new DefaultEdgeServerManager();
}
@Override
public CloudServerManager getCloudServerManager() {
return new DefaultCloudServerManager();
}
@Override
public MobileDeviceManager getMobileDeviceManager() throws Exception {
return new SampleMobileDeviceManager();
}
}

54
src/edu/boun/edgecloudsim/cloud_server/CloudServerManager.java Normal file
View File

@ -0,0 +1,54 @@
package edu.boun.edgecloudsim.cloud_server;
import java.util.ArrayList;
import java.util.List;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.VmAllocationPolicy;
public abstract class CloudServerManager {
protected Datacenter localDatacenter;
protected List<List<CloudVM>> vmList;
public CloudServerManager() {
vmList = new ArrayList<List<CloudVM>>();
}
public List<CloudVM> getVmList(int hostId){
return vmList.get(hostId);
}
public Datacenter getDatacenter(){
return localDatacenter;
}
/*
* initialize edge server manager if needed
*/
public abstract void initialize();
/*
* provides abstract Vm Allocation Policy for Cloud Datacenters
*/
public abstract VmAllocationPolicy getVmAllocationPolicy(List<? extends Host> list, int dataCenterIndex);
/*
* Starts Datacenters
*/
public abstract void startDatacenters() throws Exception;
/*
* Terminates Datacenters
*/
public abstract void terminateDatacenters();
/*
* Creates VM List
*/
public abstract void createVmList(int brockerId);
/*
* returns average utilization of all VMs
*/
public abstract double getAvgUtilization();
}

50
src/edu/boun/edgecloudsim/cloud_server/CloudVM.java Normal file
View File

@ -0,0 +1,50 @@
/*
* Title: EdgeCloudSim - CloudVM
*
* Description:
* CloudVM adds vm type information over CloudSim's VM class
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.cloud_server;
import java.util.ArrayList;
import java.util.List;
import org.cloudbus.cloudsim.CloudletScheduler;
import org.cloudbus.cloudsim.Vm;
import edu.boun.edgecloudsim.core.SimSettings;
public class CloudVM extends Vm {
private SimSettings.VM_TYPES type;
public CloudVM(int id, int userId, double mips, int numberOfPes, int ram,
long bw, long size, String vmm, CloudletScheduler cloudletScheduler) {
super(id, userId, mips, numberOfPes, ram, bw, size, vmm, cloudletScheduler);
type = SimSettings.VM_TYPES.CLOUD_VM;
}
public SimSettings.VM_TYPES getVmType(){
return type;
}
/**
* dynamically reconfigures the mips value of a VM in CloudSim
*
* @param mips new mips value for this VM.
*/
public void reconfigureMips(double mips){
super.setMips(mips);
super.getHost().getVmScheduler().deallocatePesForVm(this);
List<Double> mipsShareAllocated = new ArrayList<Double>();
for(int i= 0; i<getNumberOfPes(); i++)
mipsShareAllocated.add(mips);
super.getHost().getVmScheduler().allocatePesForVm(this, mipsShareAllocated);
}
}

127
src/edu/boun/edgecloudsim/cloud_server/CloudVmAllocationPolicy_Custom.java Normal file
View File

@ -0,0 +1,127 @@
/*
* Title: EdgeCloudSim - Custom VM Allocation Policy for Cloud VMs
*
* Description:
* VmAllocationPolicy_Custom implements VmAllocationPolicy to decide which.
* VM is created on which host locatied on the datacenters. For those
* who wants to add another Vm Allocation Policy to EdgeCloudSim should
* provide another concreate instance of VmAllocationPolicy via ScenarioFactory
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.cloud_server;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicy;
import org.cloudbus.cloudsim.core.CloudSim;
import edu.boun.edgecloudsim.core.SimSettings;
/*
* Same as VmAllocationPolicySimple.
*/
public class CloudVmAllocationPolicy_Custom extends VmAllocationPolicy {
/** The vm table. */
private Map<String, Host> vmTable;
private static int createdVmNum;
private int DataCenterIndex;
public CloudVmAllocationPolicy_Custom(List<? extends Host> list, int _DataCenterIndex) {
super(list);
setVmTable(new HashMap<String, Host>());
DataCenterIndex=_DataCenterIndex;
createdVmNum = 0;
}
@Override
public boolean allocateHostForVm(Vm vm) {
boolean result = false;
if (!getVmTable().containsKey(vm.getUid()) && vm instanceof CloudVM) { // if this vm was not created
int hostIndex = (vm.getId() - SimSettings.getInstance().getNumOfEdgeVMs()) / SimSettings.getInstance().getNumOfCloudVMsPerHost();
if(DataCenterIndex == SimSettings.CLOUD_DATACENTER_ID){
Host host = getHostList().get(hostIndex);
result = host.vmCreate(vm);
if (result) { // if vm were succesfully created in the host
getVmTable().put(vm.getUid(), host);
createdVmNum++;
Log.formatLine("%.2f: Cloud VM #" + vm.getId() + " has been allocated to the host #" + host.getId(),CloudSim.clock());
result = true;
}
}
}
return result;
}
@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);
createdVmNum++;
Log.formatLine("%.2f: Cloud VM #" + vm.getId() + " has been allocated to the host #" + host.getId(),CloudSim.clock());
return true;
}
return false;
}
@Override
public List<Map<String, Object>> optimizeAllocation(
List<? extends Vm> vmList) {
// TODO Auto-generated method stub
return null;
}
@Override
public void deallocateHostForVm(Vm vm) {
Host host = getVmTable().remove(vm.getUid());
if (host != null) {
host.vmDestroy(vm);
}
}
@Override
public Host getHost(Vm vm) {
return getVmTable().get(vm.getUid());
}
@Override
public Host getHost(int vmId, int userId) {
return getVmTable().get(Vm.getUid(userId, vmId));
}
public static int getCreatedVmNum(){
return createdVmNum;
}
/**
* 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;
}
}

168
src/edu/boun/edgecloudsim/cloud_server/DefaultCloudServerManager.java Normal file
View File

@ -0,0 +1,168 @@
/*
* Title: EdgeCloudSim - Cloud Server Manager
*
* Description:
* DefaultCloudServerManager is responsible for creating datacenters, hosts and VMs.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.cloud_server;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.VmAllocationPolicy;
import org.cloudbus.cloudsim.VmSchedulerSpaceShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
public class DefaultCloudServerManager extends CloudServerManager{
public DefaultCloudServerManager() {
}
@Override
public void initialize() {
}
@Override
public VmAllocationPolicy getVmAllocationPolicy(List<? extends Host> hostList, int dataCenterIndex) {
return new CloudVmAllocationPolicy_Custom(hostList,dataCenterIndex);
}
public void startDatacenters() throws Exception{
localDatacenter = createDatacenter(SimSettings.CLOUD_DATACENTER_ID);
}
public void terminateDatacenters(){
localDatacenter.shutdownEntity();
}
public void createVmList(int brockerId){
//VMs should have unique IDs, so create Cloud VMs after Edge VMs
int vmCounter=SimSettings.getInstance().getNumOfEdgeVMs();
//Create VMs for each hosts
for (int i = 0; i < SimSettings.getInstance().getNumOfCoudHost(); i++) {
vmList.add(i, new ArrayList<CloudVM>());
for(int j = 0; j < SimSettings.getInstance().getNumOfCloudVMsPerHost(); j++){
String vmm = "Xen";
int numOfCores = SimSettings.getInstance().getCoreForCloudVM();
double mips = SimSettings.getInstance().getMipsForCloudVM();
int ram = SimSettings.getInstance().getRamForCloudVM();
long storage = SimSettings.getInstance().getStorageForCloudVM();
long bandwidth = 0;
//VM Parameters
CloudVM vm = new CloudVM(vmCounter, brockerId, mips, numOfCores, ram, bandwidth, storage, vmm, new CloudletSchedulerTimeShared());
vmList.get(i).add(vm);
vmCounter++;
}
}
}
//average utilization of all VMs
public double getAvgUtilization(){
double totalUtilization = 0;
double vmCounter = 0;
List<? extends Host> list = localDatacenter.getHostList();
// for each host...
for (int hostIndex=0; hostIndex < list.size(); hostIndex++) {
List<CloudVM> vmArray = SimManager.getInstance().getCloudServerManager().getVmList(hostIndex);
//for each vm...
for(int vmIndex=0; vmIndex<vmArray.size(); vmIndex++){
totalUtilization += vmArray.get(vmIndex).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
vmCounter++;
}
}
return totalUtilization / vmCounter;
}
private Datacenter createDatacenter(int index) throws Exception{
String arch = "x86";
String os = "Linux";
String vmm = "Xen";
double costPerBw = 0;
double costPerSec = 0;
double costPerMem = 0;
double costPerStorage = 0;
List<Host> hostList=createHosts();
String name = "CloudDatacenter_" + Integer.toString(index);
double time_zone = 3.0; // time zone this resource located
LinkedList<Storage> storageList = new LinkedList<Storage>(); //we are not adding SAN devices by now
// 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).
DatacenterCharacteristics characteristics = new DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, costPerSec, costPerMem, costPerStorage, costPerBw);
// 6. Finally, we need to create a PowerDatacenter object.
Datacenter datacenter = null;
VmAllocationPolicy vm_policy = getVmAllocationPolicy(hostList,index);
datacenter = new Datacenter(name, characteristics, vm_policy, storageList, 0);
return datacenter;
}
private List<Host> createHosts(){
// Here are the steps needed to create a PowerDatacenter:
// 1. We need to create a list to store one or more Machines
List<Host> hostList = new ArrayList<Host>();
for (int i = 0; i < SimSettings.getInstance().getNumOfCoudHost(); i++) {
int numOfVMPerHost = SimSettings.getInstance().getNumOfCloudVMsPerHost();
int numOfCores = SimSettings.getInstance().getCoreForCloudVM() * numOfVMPerHost;
double mips = SimSettings.getInstance().getMipsForCloudVM() * numOfVMPerHost;
int ram = SimSettings.getInstance().getRamForCloudVM() * numOfVMPerHost;
long storage = SimSettings.getInstance().getStorageForCloudVM() * numOfVMPerHost;
long bandwidth = 0;
// 2. A Machine contains one or more PEs or CPUs/Cores. Therefore, should
// create a list to store these PEs before creating
// a Machine.
List<Pe> peList = new ArrayList<Pe>();
// 3. Create PEs and add these into the list.
//for a quad-core machine, a list of 4 PEs is required:
for(int j=0; j<numOfCores; j++){
peList.add(new Pe(j, new PeProvisionerSimple(mips))); // need to store Pe id and MIPS Rating
}
//4. Create Hosts with its id and list of PEs and add them to the list of machines
Host host = new Host(
//Hosts should have unique IDs, so create Cloud Hosts after Edge Hosts
i+SimSettings.getInstance().getNumOfEdgeHosts(),
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bandwidth), //kbps
storage,
peList,
new VmSchedulerSpaceShared(peList)
);
hostList.add(host);
}
return hostList;
}
}

116
src/edu/boun/edgecloudsim/core/ScenarioFactory.java
View File

@ -1,57 +1,59 @@
/*
* Title: EdgeCloudSim - Scenarion Factory interface
*
* Description:
* ScenarioFactory responsible for providing customizable components
* such as Network Model, Mobility Model, Edge Orchestrator.
* This interface is very critical for using custom models on EdgeCloudSim
* This interface should be implemented by EdgeCloudSim users
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.core;
import java.util.List;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.VmAllocationPolicy;
import edu.boun.edgecloudsim.edge_orchestrator.EdgeOrchestrator;
import edu.boun.edgecloudsim.mobility.MobilityModel;
import edu.boun.edgecloudsim.task_generator.LoadGeneratorModel;
import edu.boun.edgecloudsim.network.NetworkModel;
public interface ScenarioFactory {
/**
* provides abstract Load Generator Model
*/
public LoadGeneratorModel getLoadGeneratorModel();
/**
* provides abstract Edge Orchestrator
*/
public EdgeOrchestrator getEdgeOrchestrator();
/**
* provides abstract Mobility Model
*/
public MobilityModel getMobilityModel();
/**
* provides abstract Network Model
*/
public NetworkModel getNetworkModel();
/**
* provides abstract CPU Utilization Model
*/
public UtilizationModel getCpuUtilizationModel(SimSettings.APP_TYPES _taskType);
/**
* provides abstract Vm Allocation Policy
*/
public VmAllocationPolicy getVmAllocationPolicy(List<? extends Host> list, int dataCenterIndex);
}
/*
* Title: EdgeCloudSim - Scenarion Factory interface
*
* Description:
* ScenarioFactory responsible for providing customizable components
* such as Network Model, Mobility Model, Edge Orchestrator.
* This interface is very critical for using custom models on EdgeCloudSim
* This interface should be implemented by EdgeCloudSim users
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.core;
import edu.boun.edgecloudsim.cloud_server.CloudServerManager;
import edu.boun.edgecloudsim.edge_client.MobileDeviceManager;
import edu.boun.edgecloudsim.edge_orchestrator.EdgeOrchestrator;
import edu.boun.edgecloudsim.edge_server.EdgeServerManager;
import edu.boun.edgecloudsim.mobility.MobilityModel;
import edu.boun.edgecloudsim.task_generator.LoadGeneratorModel;
import edu.boun.edgecloudsim.network.NetworkModel;
public interface ScenarioFactory {
/**
* provides abstract Load Generator Model
*/
public LoadGeneratorModel getLoadGeneratorModel();
/**
* provides abstract Edge Orchestrator
*/
public EdgeOrchestrator getEdgeOrchestrator();
/**
* provides abstract Mobility Model
*/
public MobilityModel getMobilityModel();
/**
* provides abstract Network Model
*/
public NetworkModel getNetworkModel();
/**
* provides abstract Edge Server Model
*/
public EdgeServerManager getEdgeServerManager();
/**
* provides abstract Cloud Server Model
*/
public CloudServerManager getCloudServerManager();
/**
* provides abstract Mobile Device Manager Model
*/
public MobileDeviceManager getMobileDeviceManager() throws Exception;
}

451
src/edu/boun/edgecloudsim/core/SimManager.java
View File

@ -1,200 +1,251 @@
/*
* Title: EdgeCloudSim - Simulation Manager
*
* Description:
* SimManager is an singleton class providing many abstract classeses such as
* Network Model, Mobility Model, Edge Orchestrator to other modules
* Critical simulation related information would be gathered via this class
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.core;
import java.io.IOException;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.SimEntity;
import org.cloudbus.cloudsim.core.SimEvent;
import edu.boun.edgecloudsim.edge_orchestrator.EdgeOrchestrator;
import edu.boun.edgecloudsim.edge_server.EdgeServerManager;
import edu.boun.edgecloudsim.edge_server.VmAllocationPolicy_Custom;
import edu.boun.edgecloudsim.edge_client.MobileDeviceManager;
import edu.boun.edgecloudsim.mobility.MobilityModel;
import edu.boun.edgecloudsim.task_generator.LoadGeneratorModel;
import edu.boun.edgecloudsim.network.NetworkModel;
import edu.boun.edgecloudsim.utils.EdgeTask;
import edu.boun.edgecloudsim.utils.SimLogger;
public class SimManager extends SimEntity {
private static final int CREATE_TASK = 0;
private static final int CHECK_ALL_VM = 1;
private static final int GET_LOAD_LOG = 2;
private static final int PRINT_PROGRESS = 3;
private static final int STOP_SIMULATION = 4;
private int numOfMobileDevice;
private NetworkModel networkModel;
private MobilityModel mobilityModel;
private ScenarioFactory scenarioFactory;
private EdgeOrchestrator edgeOrchestrator;
private EdgeServerManager edgeServerManager;
private LoadGeneratorModel loadGeneratorModel;
private MobileDeviceManager mobileDeviceManager;
private static SimManager instance = null;
public SimManager(ScenarioFactory _scenarioFactory, int _numOfMobileDevice, String _simScenario) throws Exception {
super("SimManager");
scenarioFactory = _scenarioFactory;
numOfMobileDevice = _numOfMobileDevice;
SimLogger.print("Creating tasks...");
loadGeneratorModel = scenarioFactory.getLoadGeneratorModel();
loadGeneratorModel.initializeModel();
SimLogger.printLine("Done, ");
SimLogger.print("Creating device locations...");
mobilityModel = scenarioFactory.getMobilityModel();
mobilityModel.initialize();
SimLogger.printLine("Done.");
//Generate network model
networkModel = scenarioFactory.getNetworkModel();
networkModel.initialize();
//Generate edge orchestrator
edgeOrchestrator = scenarioFactory.getEdgeOrchestrator();
edgeOrchestrator.initialize();
//Create Physical Servers
edgeServerManager = new EdgeServerManager();
//Create Client Manager
mobileDeviceManager = new MobileDeviceManager();
instance = this;
}
public static SimManager getInstance(){
return instance;
}
/**
* Triggering CloudSim to start simulation
*/
public void startSimulation() throws Exception{
//Starts the simulation
SimLogger.print(super.getName()+" is starting...");
//Start Edge Servers & Generate VMs
edgeServerManager.startDatacenters();
edgeServerManager.createVmList(mobileDeviceManager.getId());
CloudSim.startSimulation();
}
public ScenarioFactory getScenarioFactory(){
return scenarioFactory;
}
public int getNumOfMobileDevice(){
return numOfMobileDevice;
}
public NetworkModel getNetworkModel(){
return networkModel;
}
public MobilityModel getMobilityModel(){
return mobilityModel;
}
public EdgeOrchestrator getEdgeOrchestrator(){
return edgeOrchestrator;
}
public EdgeServerManager getLocalServerManager(){
return edgeServerManager;
}
public MobileDeviceManager getMobileDeviceManager(){
return mobileDeviceManager;
}
@Override
public void startEntity() {
for(int i=0; i<edgeServerManager.getDatacenterList().size(); i++)
mobileDeviceManager.submitVmList(edgeServerManager.getVmList(i));
//Creation of tasks are scheduled here!
for(int i=0; i< loadGeneratorModel.getTaskList().size(); i++)
schedule(getId(), loadGeneratorModel.getTaskList().get(i).startTime, CREATE_TASK, loadGeneratorModel.getTaskList().get(i));
//Periodic event loops starts from here!
schedule(getId(), 5, CHECK_ALL_VM);
schedule(getId(), SimSettings.getInstance().getSimulationTime()/100, PRINT_PROGRESS);
schedule(getId(), SimSettings.getInstance().getVmLoadLogInterval(), GET_LOAD_LOG);
schedule(getId(), SimSettings.getInstance().getSimulationTime(), STOP_SIMULATION);
SimLogger.printLine("Done.");
}
@Override
public void processEvent(SimEvent ev) {
synchronized(this){
switch (ev.getTag()) {
case CREATE_TASK:
try {
EdgeTask edgeTask = (EdgeTask) ev.getData();
mobileDeviceManager.submitTask(edgeTask);
} catch (Exception e) {
e.printStackTrace();
System.exit(0);
}
break;
case CHECK_ALL_VM:
int totalNumOfVm = SimSettings.getInstance().getNumOfEdgeVMs();
if(VmAllocationPolicy_Custom.getCreatedVmNum() != totalNumOfVm){
SimLogger.printLine("All VMs cannot be created! Terminating simulation...");
System.exit(0);
}
break;
case GET_LOAD_LOG:
SimLogger.getInstance().addVmUtilizationLog(CloudSim.clock(),edgeServerManager.getAvgUtilization());
schedule(getId(), SimSettings.getInstance().getVmLoadLogInterval(), GET_LOAD_LOG);
break;
case PRINT_PROGRESS:
int progress = (int)((CloudSim.clock()*100)/SimSettings.getInstance().getSimulationTime());
if(progress % 10 == 0)
SimLogger.print(Integer.toString(progress));
else
SimLogger.print(".");
if(CloudSim.clock() < SimSettings.getInstance().getSimulationTime())
schedule(getId(), SimSettings.getInstance().getSimulationTime()/100, PRINT_PROGRESS);
break;
case STOP_SIMULATION:
SimLogger.printLine("100");
CloudSim.terminateSimulation();
try {
SimLogger.getInstance().simStopped();
} catch (IOException e) {
e.printStackTrace();
System.exit(0);
}
break;
default:
Log.printLine(getName() + ": unknown event type");
break;
}
}
}
@Override
public void shutdownEntity() {
edgeServerManager.terminateDatacenters();
}
}
/*
* Title: EdgeCloudSim - Simulation Manager
*
* Description:
* SimManager is an singleton class providing many abstract classeses such as
* Network Model, Mobility Model, Edge Orchestrator to other modules
* Critical simulation related information would be gathered via this class
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.core;
import java.io.IOException;
import java.util.List;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.SimEntity;
import org.cloudbus.cloudsim.core.SimEvent;
import edu.boun.edgecloudsim.edge_orchestrator.EdgeOrchestrator;
import edu.boun.edgecloudsim.edge_server.EdgeServerManager;
import edu.boun.edgecloudsim.edge_server.EdgeVmAllocationPolicy_Custom;
import edu.boun.edgecloudsim.cloud_server.CloudServerManager;
import edu.boun.edgecloudsim.edge_client.MobileDeviceManager;
import edu.boun.edgecloudsim.mobility.MobilityModel;
import edu.boun.edgecloudsim.task_generator.LoadGeneratorModel;
import edu.boun.edgecloudsim.network.NetworkModel;
import edu.boun.edgecloudsim.utils.EdgeTask;
import edu.boun.edgecloudsim.utils.SimLogger;
public class SimManager extends SimEntity {
private static final int CREATE_TASK = 0;
private static final int CHECK_ALL_VM = 1;
private static final int GET_LOAD_LOG = 2;
private static final int PRINT_PROGRESS = 3;
private static final int STOP_SIMULATION = 4;
private String simScenario;
private String orchestratorPolicy;
private int numOfMobileDevice;
private NetworkModel networkModel;
private MobilityModel mobilityModel;
private ScenarioFactory scenarioFactory;
private EdgeOrchestrator edgeOrchestrator;
private EdgeServerManager edgeServerManager;
private CloudServerManager cloudServerManager;
private LoadGeneratorModel loadGeneratorModel;
private MobileDeviceManager mobileDeviceManager;
private static SimManager instance = null;
public SimManager(ScenarioFactory _scenarioFactory, int _numOfMobileDevice, String _simScenario, String _orchestratorPolicy) throws Exception {
super("SimManager");
simScenario = _simScenario;
scenarioFactory = _scenarioFactory;
numOfMobileDevice = _numOfMobileDevice;
orchestratorPolicy = _orchestratorPolicy;
SimLogger.print("Creating tasks...");
loadGeneratorModel = scenarioFactory.getLoadGeneratorModel();
loadGeneratorModel.initializeModel();
SimLogger.printLine("Done, ");
SimLogger.print("Creating device locations...");
mobilityModel = scenarioFactory.getMobilityModel();
mobilityModel.initialize();
SimLogger.printLine("Done.");
//Generate network model
networkModel = scenarioFactory.getNetworkModel();
networkModel.initialize();
//Generate edge orchestrator
edgeOrchestrator = scenarioFactory.getEdgeOrchestrator();
edgeOrchestrator.initialize();
//Create Physical Servers
edgeServerManager = scenarioFactory.getEdgeServerManager();
edgeServerManager.initialize();
//Create Physical Servers on cloud
cloudServerManager = scenarioFactory.getCloudServerManager();
cloudServerManager.initialize();
//Create Client Manager
mobileDeviceManager = scenarioFactory.getMobileDeviceManager();
mobileDeviceManager.initialize();
instance = this;
}
public static SimManager getInstance(){
return instance;
}
/**
* Triggering CloudSim to start simulation
*/
public void startSimulation() throws Exception{
//Starts the simulation
SimLogger.print(super.getName()+" is starting...");
//Start Edge Datacenters & Generate VMs
edgeServerManager.startDatacenters();
edgeServerManager.createVmList(mobileDeviceManager.getId());
//Start Edge Datacenters & Generate VMs
cloudServerManager.startDatacenters();
cloudServerManager.createVmList(mobileDeviceManager.getId());
CloudSim.startSimulation();
}
public String getSimulationScenario(){
return simScenario;
}
public String getOrchestratorPolicy(){
return orchestratorPolicy;
}
public ScenarioFactory getScenarioFactory(){
return scenarioFactory;
}
public int getNumOfMobileDevice(){
return numOfMobileDevice;
}
public NetworkModel getNetworkModel(){
return networkModel;
}
public MobilityModel getMobilityModel(){
return mobilityModel;
}
public EdgeOrchestrator getEdgeOrchestrator(){
return edgeOrchestrator;
}
public EdgeServerManager getEdgeServerManager(){
return edgeServerManager;
}
public CloudServerManager getCloudServerManager(){
return cloudServerManager;
}
public LoadGeneratorModel getLoadGeneratorModel(){
return loadGeneratorModel;
}
public MobileDeviceManager getMobileDeviceManager(){
return mobileDeviceManager;
}
@Override
public void startEntity() {
int hostCounter=0;
for(int i= 0; i<edgeServerManager.getDatacenterList().size(); i++) {
List<? extends Host> list = edgeServerManager.getDatacenterList().get(i).getHostList();
for (int j=0; j < list.size(); j++) {
mobileDeviceManager.submitVmList(edgeServerManager.getVmList(hostCounter));
hostCounter++;
}
}
for(int i= 0; i<SimSettings.getInstance().getNumOfCoudHost(); i++) {
mobileDeviceManager.submitVmList(cloudServerManager.getVmList(i));
}
//Creation of tasks are scheduled here!
for(int i=0; i< loadGeneratorModel.getTaskList().size(); i++)
schedule(getId(), loadGeneratorModel.getTaskList().get(i).startTime, CREATE_TASK, loadGeneratorModel.getTaskList().get(i));
//Periodic event loops starts from here!
schedule(getId(), 5, CHECK_ALL_VM);
schedule(getId(), SimSettings.getInstance().getSimulationTime()/100, PRINT_PROGRESS);
schedule(getId(), SimSettings.getInstance().getVmLoadLogInterval(), GET_LOAD_LOG);
schedule(getId(), SimSettings.getInstance().getSimulationTime(), STOP_SIMULATION);
SimLogger.printLine("Done.");
}
@Override
public void processEvent(SimEvent ev) {
synchronized(this){
switch (ev.getTag()) {
case CREATE_TASK:
try {
EdgeTask edgeTask = (EdgeTask) ev.getData();
mobileDeviceManager.submitTask(edgeTask);
} catch (Exception e) {
e.printStackTrace();
System.exit(0);
}
break;
case CHECK_ALL_VM:
int totalNumOfVm = SimSettings.getInstance().getNumOfEdgeVMs();
if(EdgeVmAllocationPolicy_Custom.getCreatedVmNum() != totalNumOfVm){
SimLogger.printLine("All VMs cannot be created! Terminating simulation...");
System.exit(0);
}
break;
case GET_LOAD_LOG:
SimLogger.getInstance().addVmUtilizationLog(
CloudSim.clock(),
edgeServerManager.getAvgUtilization(),
cloudServerManager.getAvgUtilization());
schedule(getId(), SimSettings.getInstance().getVmLoadLogInterval(), GET_LOAD_LOG);
break;
case PRINT_PROGRESS:
int progress = (int)((CloudSim.clock()*100)/SimSettings.getInstance().getSimulationTime());
if(progress % 10 == 0)
SimLogger.print(Integer.toString(progress));
else
SimLogger.print(".");
if(CloudSim.clock() < SimSettings.getInstance().getSimulationTime())
schedule(getId(), SimSettings.getInstance().getSimulationTime()/100, PRINT_PROGRESS);
break;
case STOP_SIMULATION:
SimLogger.printLine("100");
CloudSim.terminateSimulation();
try {
SimLogger.getInstance().simStopped();
} catch (IOException e) {
e.printStackTrace();
System.exit(0);
}
break;
default:
Log.printLine(getName() + ": unknown event type");
break;
}
}
}
@Override
public void shutdownEntity() {
edgeServerManager.terminateDatacenters();
cloudServerManager.terminateDatacenters();
}
}

1112
src/edu/boun/edgecloudsim/core/SimSettings.java
View File

File diff suppressed because it is too large Load Diff

101
src/edu/boun/edgecloudsim/edge_client/CpuUtilizationModel_Custom.java
View File

@ -1,42 +1,59 @@
/*
* Title: EdgeCloudSim - Custom VM Cpu Utilization Model
*
* Description:
* CpuUtilizationModel_Custom implements UtilizationModel and used for
* VM CPU utilization model. In CloudSim, the CPU utilization of the VM
* is a simple counter. We provide more realistic utilization model
* which decide CPU utilization of each application by using the
* values defined in the applications.xml file. For those who wants to
* add another VM Cpu Utilization Model to EdgeCloudSim should provide
* another concreate instance of UtilizationModel via ScenarioFactory
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_client;
import org.cloudbus.cloudsim.UtilizationModel;
import edu.boun.edgecloudsim.core.SimSettings;
public class CpuUtilizationModel_Custom implements UtilizationModel {
private SimSettings.APP_TYPES taskType;
public CpuUtilizationModel_Custom(SimSettings.APP_TYPES _taskType){
taskType=_taskType;
}
/*
* (non-Javadoc)
* @see cloudsim.power.UtilizationModel#getUtilization(double)
*/
@Override
public double getUtilization(double time) {
return SimSettings.getInstance().getTaskLookUpTable()[taskType.ordinal()][9];
}
public double predictUtilization(SimSettings.VM_TYPES _vmType){
return SimSettings.getInstance().getTaskLookUpTable()[taskType.ordinal()][9];
}
}
/*
* Title: EdgeCloudSim - Custom VM Cpu Utilization Model
*
* Description:
* CpuUtilizationModel_Custom implements UtilizationModel and used for
* VM CPU utilization model. In CloudSim, the CPU utilization of the VM
* is a simple counter. We provide more realistic utilization model
* which decide CPU utilization of each application by using the
* values defined in the applications.xml file. For those who wants to
* add another VM Cpu Utilization Model to EdgeCloudSim should provide
* another concreate instance of UtilizationModel via ScenarioFactory
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_client;
import org.cloudbus.cloudsim.UtilizationModel;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.SimLogger;
public class CpuUtilizationModel_Custom implements UtilizationModel {
private Task task;
public CpuUtilizationModel_Custom(){
}
/*
* (non-Javadoc)
* @see cloudsim.power.UtilizationModel#getUtilization(double)
*/
@Override
public double getUtilization(double time) {
int index = 9;
if(task.getAssociatedDatacenterId() == SimSettings.CLOUD_DATACENTER_ID)
index = 10;
return SimSettings.getInstance().getTaskLookUpTable()[task.getTaskType()][index];
}
public void setTask(Task _task){
task=_task;
}
public double predictUtilization(SimSettings.VM_TYPES _vmType){
int index = 0;
if(_vmType == SimSettings.VM_TYPES.EDGE_VM)
index = 9;
else if(_vmType == SimSettings.VM_TYPES.CLOUD_VM)
index = 10;
else{
SimLogger.printLine("Unknown VM Type! Terminating simulation...");
System.exit(0);
}
return SimSettings.getInstance().getTaskLookUpTable()[task.getTaskType()][index];
}
}

293
src/edu/boun/edgecloudsim/edge_client/DefaultMobileDeviceManager.java Normal file
View File

@ -0,0 +1,293 @@
/*
* Title: EdgeCloudSim - Mobile Device Manager
*
* Description:
* DefaultMobileDeviceManager is responsible for submitting the tasks to the related
* device by using the Edge Orchestrator. It also takes proper actions
* when the execution of the tasks are finished.
* By default, DefaultMobileDeviceManager sends tasks to the edge servers or
* cloud servers. If you want to use different topology, for example
* MAN edge server, you should modify the flow defined in this class.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_client;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.CloudSimTags;
import org.cloudbus.cloudsim.core.SimEvent;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.core.SimSettings.NETWORK_DELAY_TYPES;
import edu.boun.edgecloudsim.network.NetworkModel;
import edu.boun.edgecloudsim.utils.EdgeTask;
import edu.boun.edgecloudsim.utils.Location;
import edu.boun.edgecloudsim.utils.SimLogger;
public class DefaultMobileDeviceManager extends MobileDeviceManager {
private static final int BASE = 100000; //start from base in order not to conflict cloudsim tag!
private static final int REQUEST_RECEIVED_BY_CLOUD = BASE + 1;
private static final int REQUEST_RECIVED_BY_EDGE_DEVICE = BASE + 2;
private static final int RESPONSE_RECEIVED_BY_MOBILE_DEVICE = BASE + 3;
private int taskIdCounter=0;
public DefaultMobileDeviceManager() throws Exception{
}
@Override
public void initialize() {
}
@Override
public UtilizationModel getCpuUtilizationModel() {
return new CpuUtilizationModel_Custom();
}
/**
* Submit cloudlets to the created VMs.
*
* @pre $none
* @post $none
*/
protected void submitCloudlets() {
//do nothing!
}
/**
* Process a cloudlet return event.
*
* @param ev a SimEvent object
* @pre ev != $null
* @post $none
*/
protected void processCloudletReturn(SimEvent ev) {
NetworkModel networkModel = SimManager.getInstance().getNetworkModel();
Task task = (Task) ev.getData();
SimLogger.getInstance().taskExecuted(task.getCloudletId());
if(task.getAssociatedDatacenterId() == SimSettings.CLOUD_DATACENTER_ID){
//SimLogger.printLine(CloudSim.clock() + ": " + getName() + ": task #" + task.getCloudletId() + " received from cloud");
double WanDelay = networkModel.getDownloadDelay(SimSettings.CLOUD_DATACENTER_ID, task.getMobileDeviceId(), task);
if(WanDelay > 0)
{
Location currentLocation = SimManager.getInstance().getMobilityModel().getLocation(task.getMobileDeviceId(),CloudSim.clock()+WanDelay);
if(task.getSubmittedLocation().getServingWlanId() == currentLocation.getServingWlanId())
{
networkModel.downloadStarted(task.getSubmittedLocation(), SimSettings.CLOUD_DATACENTER_ID);
SimLogger.getInstance().setDownloadDelay(task.getCloudletId(), WanDelay, NETWORK_DELAY_TYPES.WAN_DELAY);
schedule(getId(), WanDelay, RESPONSE_RECEIVED_BY_MOBILE_DEVICE, task);
}
else
{
SimLogger.getInstance().failedDueToMobility(task.getCloudletId(), CloudSim.clock());
}
}
else
{
SimLogger.getInstance().failedDueToBandwidth(task.getCloudletId(), CloudSim.clock(), NETWORK_DELAY_TYPES.WAN_DELAY);
}
}
else{
//SimLogger.printLine(CloudSim.clock() + ": " + getName() + ": task #" + task.getCloudletId() + " received from edge");
double WlanDelay = networkModel.getDownloadDelay(task.getAssociatedHostId(), task.getMobileDeviceId(), task);
if(WlanDelay > 0)
{
Location currentLocation = SimManager.getInstance().getMobilityModel().getLocation(task.getMobileDeviceId(),CloudSim.clock()+WlanDelay);
if(task.getSubmittedLocation().getServingWlanId() == currentLocation.getServingWlanId())
{
networkModel.downloadStarted(currentLocation, SimSettings.GENERIC_EDGE_DEVICE_ID);
SimLogger.getInstance().setDownloadDelay(task.getCloudletId(), WlanDelay, NETWORK_DELAY_TYPES.WLAN_DELAY);
schedule(getId(), WlanDelay, RESPONSE_RECEIVED_BY_MOBILE_DEVICE, task);
}
else
{
SimLogger.getInstance().failedDueToMobility(task.getCloudletId(), CloudSim.clock());
}
}
else
{
SimLogger.getInstance().failedDueToBandwidth(task.getCloudletId(), CloudSim.clock(), NETWORK_DELAY_TYPES.WLAN_DELAY);
}
}
}
protected void processOtherEvent(SimEvent ev) {
if (ev == null) {
SimLogger.printLine(getName() + ".processOtherEvent(): " + "Error - an event is null! Terminating simulation...");
System.exit(0);
return;
}
NetworkModel networkModel = SimManager.getInstance().getNetworkModel();
switch (ev.getTag()) {
case REQUEST_RECEIVED_BY_CLOUD:
{
Task task = (Task) ev.getData();
networkModel.uploadFinished(task.getSubmittedLocation(), SimSettings.CLOUD_DATACENTER_ID);
submitTaskToVm(task,0,SimSettings.CLOUD_DATACENTER_ID);
break;
}
case REQUEST_RECIVED_BY_EDGE_DEVICE:
{
Task task = (Task) ev.getData();
networkModel.uploadFinished(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID);
submitTaskToVm(task, 0, SimSettings.GENERIC_EDGE_DEVICE_ID);
break;
}
case RESPONSE_RECEIVED_BY_MOBILE_DEVICE:
{
Task task = (Task) ev.getData();
if(task.getAssociatedDatacenterId() == SimSettings.CLOUD_DATACENTER_ID)
networkModel.downloadFinished(task.getSubmittedLocation(), SimSettings.CLOUD_DATACENTER_ID);
else
networkModel.downloadFinished(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID);
SimLogger.getInstance().taskEnded(task.getCloudletId(), CloudSim.clock());
break;
}
default:
SimLogger.printLine(getName() + ".processOtherEvent(): " + "Error - event unknown by this DatacenterBroker. Terminating simulation...");
System.exit(0);
break;
}
}
public void submitTask(EdgeTask edgeTask) {
NetworkModel networkModel = SimManager.getInstance().getNetworkModel();
//create a task
Task task = createTask(edgeTask);
Location currentLocation = SimManager.getInstance().getMobilityModel().
getLocation(task.getMobileDeviceId(),CloudSim.clock());
//set location of the mobile device which generates this task
task.setSubmittedLocation(currentLocation);
//add related task to log list
SimLogger.getInstance().addLog(task.getCloudletId(),
task.getTaskType(),
(int)task.getCloudletLength(),
(int)task.getCloudletFileSize(),
(int)task.getCloudletOutputSize());
int nextHopId = SimManager.getInstance().getEdgeOrchestrator().getDeviceToOffload(task);
if(nextHopId == SimSettings.CLOUD_DATACENTER_ID){
double WanDelay = networkModel.getUploadDelay(task.getMobileDeviceId(), nextHopId, task);
if(WanDelay>0){
networkModel.uploadStarted(currentLocation, nextHopId);
SimLogger.getInstance().taskStarted(task.getCloudletId(), CloudSim.clock());
SimLogger.getInstance().setUploadDelay(task.getCloudletId(), WanDelay, NETWORK_DELAY_TYPES.WAN_DELAY);
schedule(getId(), WanDelay, REQUEST_RECEIVED_BY_CLOUD, task);
}
else
{
//SimLogger.printLine("Task #" + task.getCloudletId() + " cannot assign to any VM");
SimLogger.getInstance().rejectedDueToBandwidth(
task.getCloudletId(),
CloudSim.clock(),
SimSettings.VM_TYPES.CLOUD_VM.ordinal(),
NETWORK_DELAY_TYPES.WAN_DELAY);
}
}
else if(nextHopId == SimSettings.GENERIC_EDGE_DEVICE_ID) {
double WlanDelay = networkModel.getUploadDelay(task.getMobileDeviceId(), nextHopId, task);
if(WlanDelay > 0){
networkModel.uploadStarted(currentLocation, nextHopId);
schedule(getId(), WlanDelay, REQUEST_RECIVED_BY_EDGE_DEVICE, task);
SimLogger.getInstance().taskStarted(task.getCloudletId(), CloudSim.clock());
SimLogger.getInstance().setUploadDelay(task.getCloudletId(), WlanDelay, NETWORK_DELAY_TYPES.WLAN_DELAY);
}
else {
SimLogger.getInstance().rejectedDueToBandwidth(
task.getCloudletId(),
CloudSim.clock(),
SimSettings.VM_TYPES.EDGE_VM.ordinal(),
NETWORK_DELAY_TYPES.WLAN_DELAY);
}
}
else {
SimLogger.printLine("Unknown nextHopId! Terminating simulation...");
System.exit(0);
}
}
private void submitTaskToVm(Task task, double delay, int datacenterId) {
//select a VM
Vm selectedVM = SimManager.getInstance().getEdgeOrchestrator().getVmToOffload(task, datacenterId);
int vmType = 0;
if(datacenterId == SimSettings.CLOUD_DATACENTER_ID)
vmType = SimSettings.VM_TYPES.CLOUD_VM.ordinal();
else
vmType = SimSettings.VM_TYPES.EDGE_VM.ordinal();
if(selectedVM != null){
if(datacenterId == SimSettings.CLOUD_DATACENTER_ID)
task.setAssociatedDatacenterId(SimSettings.CLOUD_DATACENTER_ID);
else
task.setAssociatedDatacenterId(selectedVM.getHost().getDatacenter().getId());
//save related host id
task.setAssociatedHostId(selectedVM.getHost().getId());
//set related vm id
task.setAssociatedVmId(selectedVM.getId());
//bind task to related VM
getCloudletList().add(task);
bindCloudletToVm(task.getCloudletId(),selectedVM.getId());
//SimLogger.printLine(CloudSim.clock() + ": Cloudlet#" + task.getCloudletId() + " is submitted to VM#" + task.getVmId());
schedule(getVmsToDatacentersMap().get(task.getVmId()), delay, CloudSimTags.CLOUDLET_SUBMIT, task);
SimLogger.getInstance().taskAssigned(task.getCloudletId(),
selectedVM.getHost().getDatacenter().getId(),
selectedVM.getHost().getId(),
selectedVM.getId(),
vmType);
}
else{
//SimLogger.printLine("Task #" + task.getCloudletId() + " cannot assign to any VM");
SimLogger.getInstance().rejectedDueToVMCapacity(task.getCloudletId(), CloudSim.clock(), vmType);
}
}
private Task createTask(EdgeTask edgeTask){
UtilizationModel utilizationModel = new UtilizationModelFull(); /*UtilizationModelStochastic*/
UtilizationModel utilizationModelCPU = getCpuUtilizationModel();
Task task = new Task(edgeTask.mobileDeviceId, ++taskIdCounter,
edgeTask.length, edgeTask.pesNumber,
edgeTask.inputFileSize, edgeTask.outputFileSize,
utilizationModelCPU, utilizationModel, utilizationModel);
//set the owner of this task
task.setUserId(this.getId());
task.setTaskType(edgeTask.taskType);
if (utilizationModelCPU instanceof CpuUtilizationModel_Custom) {
((CpuUtilizationModel_Custom)utilizationModelCPU).setTask(task);
}
return task;
}
}

349
src/edu/boun/edgecloudsim/edge_client/MobileDeviceManager.java
View File

@ -1,324 +1,25 @@
/*
* Title: EdgeCloudSim - Mobile Device Manager
*
* Description:
* MobileDeviceManager is responsible for submitting the tasks to the related
* device by using the Edge Orchestrator. It also takes proper actions
* when the execution of the tasks are finished.
* By default, MobileDeviceManager sends tasks to the edge servers or
* cloud servers. If you want to use different topology, for example
* MAN edge server, you should modify the flow defined in this class.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_client;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.CloudSimTags;
import org.cloudbus.cloudsim.core.SimEvent;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.edge_server.EdgeVM;
import edu.boun.edgecloudsim.network.NetworkModel;
import edu.boun.edgecloudsim.utils.EdgeTask;
import edu.boun.edgecloudsim.utils.Location;
import edu.boun.edgecloudsim.utils.SimLogger;
public class MobileDeviceManager extends DatacenterBroker {
private static final int BASE = 100000; //start from base in order not to conflict cloudsim tag!
private static final int REQUEST_RECEIVED_BY_CLOUD = BASE + 1;
private static final int REQUEST_PROCESSED_BY_CLOUD = BASE + 2;
private static final int REQUEST_RECIVED_BY_EDGE_DEVICE = BASE + 3;
private static final int RESPONSE_RECEIVED_BY_MOBILE_DEVICE = BASE + 4;
// private static final int REQUEST_RECIVED_BY_EDGE_ORCHESTRATOR = BASE + 5;
private int taskIdCounter=0;
public MobileDeviceManager() throws Exception {
super("Global_Broker");
}
/**
* Submit cloudlets to the created VMs.
*
* @pre $none
* @post $none
*/
protected void submitCloudlets() {
//do nothing!
}
/**
* Process a cloudlet return event.
*
* @param ev a SimEvent object
* @pre ev != $null
* @post $none
*/
protected void processCloudletReturn(SimEvent ev) {
NetworkModel networkModel = SimManager.getInstance().getNetworkModel();
Task task = (Task) ev.getData();
Location currentLocation = SimManager.getInstance().getMobilityModel().getLocation(task.getMobileDeviceId(),CloudSim.clock());
if(task.getSubmittedLocation().equals(currentLocation))
{
//SimLogger.printLine(CloudSim.clock() + ": " + getName() + ": Cloudlet " + task.getCloudletId() + " received");
double WlanDelay = networkModel.getDownloadDelay(task.getAssociatedHostId(), task.getMobileDeviceId(), task.getCloudletOutputSize());
if(WlanDelay > 0)
{
networkModel.downloadStarted(currentLocation, SimSettings.GENERIC_EDGE_DEVICE_ID);
schedule(getId(), WlanDelay, RESPONSE_RECEIVED_BY_MOBILE_DEVICE, task);
SimLogger.getInstance().downloadStarted(task.getCloudletId(), WlanDelay);
}
else
{
SimLogger.getInstance().failedDueToBandwidth(task.getCloudletId(), CloudSim.clock());
}
}
else
{
//SimLogger.printLine("task cannot be finished due to mobility of user!");
//SimLogger.printLine("device: " +task.getMobileDeviceId()+" - submitted " + task.getSubmissionTime() + " @ " + task.getSubmittedLocation().getXPos() + " handled " + CloudSim.clock() + " @ " + currentLocation.getXPos());
SimLogger.getInstance().failedDueToMobility(task.getCloudletId(), CloudSim.clock());
}
}
protected void processOtherEvent(SimEvent ev) {
if (ev == null) {
SimLogger.printLine(getName() + ".processOtherEvent(): " + "Error - an event is null! Terminating simulation...");
System.exit(0);
return;
}
NetworkModel networkModel = SimManager.getInstance().getNetworkModel();
switch (ev.getTag()) {
case REQUEST_RECEIVED_BY_CLOUD:
{
Task task = (Task) ev.getData();
networkModel.uploadFinished(task.getSubmittedLocation(), SimSettings.CLOUD_DATACENTER_ID);
//save related host id
task.setAssociatedHostId(SimSettings.CLOUD_HOST_ID);
SimLogger.getInstance().uploaded(task.getCloudletId(),
SimSettings.CLOUD_DATACENTER_ID,
SimSettings.CLOUD_HOST_ID,
SimSettings.CLOUD_VM_ID,
SimSettings.VM_TYPES.CLOUD_VM.ordinal());
//calculate computational delay in cloud
double ComputationDelay = (double)task.getCloudletLength() / (double)SimSettings.getInstance().getMipsForCloud();
schedule(getId(), ComputationDelay, REQUEST_PROCESSED_BY_CLOUD, task);
break;
}
case REQUEST_PROCESSED_BY_CLOUD:
{
Task task = (Task) ev.getData();
//SimLogger.printLine(CloudSim.clock() + ": " + getName() + ": Cloudlet " + task.getCloudletId() + " received");
double WanDelay = networkModel.getDownloadDelay(SimSettings.CLOUD_DATACENTER_ID, task.getMobileDeviceId(), task.getCloudletOutputSize());
if(WanDelay > 0)
{
Location currentLocation = SimManager.getInstance().getMobilityModel().getLocation(task.getMobileDeviceId(),CloudSim.clock()+WanDelay);
if(task.getSubmittedLocation().equals(currentLocation))
{
networkModel.downloadStarted(task.getSubmittedLocation(), SimSettings.CLOUD_DATACENTER_ID);
schedule(getId(), WanDelay, RESPONSE_RECEIVED_BY_MOBILE_DEVICE, task);
SimLogger.getInstance().downloadStarted(task.getCloudletId(), WanDelay);
}
else
{
//SimLogger.printLine("task cannot be finished due to mobility of user!");
//SimLogger.printLine("device: " +task.getMobileDeviceId()+" - submitted " + task.getSubmissionTime() + " @ " + task.getSubmittedLocation().getXPos() + " handled " + CloudSim.clock() + " @ " + currentLocation.getXPos());
SimLogger.getInstance().failedDueToMobility(task.getCloudletId(), CloudSim.clock());
}
}
else
{
SimLogger.getInstance().failedDueToBandwidth(task.getCloudletId(), CloudSim.clock());
}
break;
}
/*
case REQUEST_RECIVED_BY_EDGE_ORCHESTRATOR:
{
Task task = (Task) ev.getData();
double internalDelay = networkModel.getDownloadDelay(
SimSettings.EDGE_ORCHESTRATOR_ID,
SimSettings.GENERIC_EDGE_DEVICE_ID,
task.getCloudletOutputSize());
networkModel.downloadStarted(
SimSettings.EDGE_ORCHESTRATOR_ID,
SimSettings.GENERIC_EDGE_DEVICE_ID,
task.getCloudletOutputSize());
submitTaskToEdgeDevice(task,internalDelay);
break;
}
*/
case REQUEST_RECIVED_BY_EDGE_DEVICE:
{
Task task = (Task) ev.getData();
networkModel.uploadFinished(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID);
submitTaskToEdgeDevice(task,0);
break;
}
case RESPONSE_RECEIVED_BY_MOBILE_DEVICE:
{
Task task = (Task) ev.getData();
if(task.getAssociatedHostId() == SimSettings.CLOUD_HOST_ID)
networkModel.downloadFinished(task.getSubmittedLocation(), SimSettings.CLOUD_DATACENTER_ID);
else
networkModel.downloadFinished(task.getSubmittedLocation(), SimSettings.GENERIC_EDGE_DEVICE_ID);
//SimLogger.printLine(CloudSim.clock() + ": " + getName() + ": Cloudlet " + cloudlet.getCloudletId() + " is received");
SimLogger.getInstance().downloaded(task.getCloudletId(), CloudSim.clock());
break;
}
default:
SimLogger.printLine(getName() + ".processOtherEvent(): " + "Error - event unknown by this DatacenterBroker. Terminating simulation...");
System.exit(0);
break;
}
}
public void submitTaskToEdgeDevice(Task task, double delay) {
//select a VM
EdgeVM selectedVM = SimManager.getInstance().getEdgeOrchestrator().getVmToOffload(task);
if(selectedVM != null){
//save related host id
task.setAssociatedHostId(selectedVM.getHost().getId());
//bind task to related VM
getCloudletList().add(task);
bindCloudletToVm(task.getCloudletId(),selectedVM.getId());
//SimLogger.printLine(CloudSim.clock() + ": Cloudlet#" + task.getCloudletId() + " is submitted to VM#" + task.getVmId());
schedule(getVmsToDatacentersMap().get(task.getVmId()), delay, CloudSimTags.CLOUDLET_SUBMIT, task);
SimLogger.getInstance().uploaded(task.getCloudletId(),
selectedVM.getHost().getDatacenter().getId(),
selectedVM.getHost().getId(),
selectedVM.getId(),
selectedVM.getVmType().ordinal());
}
else{
//SimLogger.printLine("Task #" + task.getCloudletId() + " cannot assign to any VM");
SimLogger.getInstance().rejectedDueToVMCapacity(task.getCloudletId(), CloudSim.clock());
}
}
public void submitTask(EdgeTask edgeTask) {
NetworkModel networkModel = SimManager.getInstance().getNetworkModel();
//create a task
Task task = createTask(edgeTask);
Location currentLocation = SimManager.getInstance().getMobilityModel().
getLocation(task.getMobileDeviceId(),CloudSim.clock());
//set location of the mobile device which generates this task
task.setSubmittedLocation(currentLocation);
//add related task to log list
SimLogger.getInstance().addLog(CloudSim.clock(),
task.getCloudletId(),
task.getTaskType().ordinal(),
(int)task.getCloudletLength(),
(int)task.getCloudletFileSize(),
(int)task.getCloudletOutputSize());
int nextHopId = SimManager.getInstance().getEdgeOrchestrator().getDeviceToOffload(task);
if(nextHopId == SimSettings.CLOUD_DATACENTER_ID){
double WanDelay = networkModel.getUploadDelay(task.getMobileDeviceId(), nextHopId, task.getCloudletFileSize());
if(WanDelay>0){
networkModel.uploadStarted(currentLocation, nextHopId);
schedule(getId(), WanDelay, REQUEST_RECEIVED_BY_CLOUD, task);
SimLogger.getInstance().uploadStarted(task.getCloudletId(),WanDelay);
}
else
{
//SimLogger.printLine("Task #" + task.getCloudletId() + " cannot assign to any VM");
SimLogger.getInstance().rejectedDueToBandwidth(
task.getCloudletId(),
CloudSim.clock(),
SimSettings.VM_TYPES.CLOUD_VM.ordinal());
}
}
// else if(nextHopId == SimSettings.EDGE_ORCHESTRATOR_ID){
// double WlanDelay = networkModel.getUploadDelay(task.getMobileDeviceId(), nextHopId, task.getCloudletFileSize());
//
// if(WlanDelay > 0){
// networkModel.uploadStarted(task.getMobileDeviceId(), nextHopId, task.getCloudletFileSize());
// schedule(getId(), WlanDelay, REQUEST_RECIVED_BY_EDGE_ORCHESTRATOR, task);
// SimLogger.getInstance().uploadStarted(task.getCloudletId(),WlanDelay);
// }
// else {
// SimLogger.getInstance().rejectedDueToBandwidth(
// task.getCloudletId(),
// CloudSim.clock(),
// SimSettings.VM_TYPES.EDGE_VM.ordinal());
// }
// }
else if(nextHopId == SimSettings.GENERIC_EDGE_DEVICE_ID) {
double WlanDelay = networkModel.getUploadDelay(task.getMobileDeviceId(), nextHopId, task.getCloudletFileSize());
if(WlanDelay > 0){
networkModel.uploadStarted(currentLocation, nextHopId);
schedule(getId(), WlanDelay, REQUEST_RECIVED_BY_EDGE_DEVICE, task);
SimLogger.getInstance().uploadStarted(task.getCloudletId(),WlanDelay);
}
else {
SimLogger.getInstance().rejectedDueToBandwidth(
task.getCloudletId(),
CloudSim.clock(),
SimSettings.VM_TYPES.EDGE_VM.ordinal());
}
}
else {
SimLogger.printLine("Unknown nextHopId! Terminating simulation...");
System.exit(0);
}
}
public Task createTask(EdgeTask edgeTask){
UtilizationModel utilizationModel = new UtilizationModelFull(); /*UtilizationModelStochastic*/
UtilizationModel utilizationModelCPU = SimManager.getInstance().getScenarioFactory().getCpuUtilizationModel(edgeTask.taskType);
Task task = new Task(edgeTask.mobileDeviceId, ++taskIdCounter,
edgeTask.length, edgeTask.pesNumber,
edgeTask.inputFileSize, edgeTask.outputFileSize,
utilizationModelCPU, utilizationModel, utilizationModel);
//set the owner of this task
task.setUserId(this.getId());
task.setTaskType(edgeTask.taskType);
return task;
}
public void taskEnded(){
clearDatacenters();
finishExecution();
}
}
package edu.boun.edgecloudsim.edge_client;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.UtilizationModel;
import edu.boun.edgecloudsim.utils.EdgeTask;
public abstract class MobileDeviceManager extends DatacenterBroker {
public MobileDeviceManager() throws Exception {
super("Global_Broker");
}
/*
* initialize mobile device manager if needed
*/
public abstract void initialize();
/*
* provides abstract CPU Utilization Model
*/
public abstract UtilizationModel getCpuUtilizationModel();
public abstract void submitTask(EdgeTask edgeTask);
}

149
src/edu/boun/edgecloudsim/edge_client/Task.java
View File

@ -1,66 +1,83 @@
/*
* Title: EdgeCloudSim - Task
*
* Description:
* Task adds app type, task submission location, mobile device id and host id
* information to CloudSim's Cloudlet class.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_client;
import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.UtilizationModel;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.Location;
public class Task extends Cloudlet {
private SimSettings.APP_TYPES type;
private Location submittedLocation;
private int mobileDeviceId;
private int hostIndex;
public Task(int _mobileDeviceId, int cloudletId, long cloudletLength, int pesNumber,
long cloudletFileSize, long cloudletOutputSize,
UtilizationModel utilizationModelCpu,
UtilizationModel utilizationModelRam,
UtilizationModel utilizationModelBw) {
super(cloudletId, cloudletLength, pesNumber, cloudletFileSize,
cloudletOutputSize, utilizationModelCpu, utilizationModelRam,
utilizationModelBw);
mobileDeviceId = _mobileDeviceId;
}
public void setSubmittedLocation(Location _submittedLocation){
submittedLocation =_submittedLocation;
}
public void setAssociatedHostId(int _hostIndex){
hostIndex=_hostIndex;
}
public void setTaskType(SimSettings.APP_TYPES _type){
type=_type;
}
public int getMobileDeviceId(){
return mobileDeviceId;
}
public Location getSubmittedLocation(){
return submittedLocation;
}
public int getAssociatedHostId(){
return hostIndex;
}
public SimSettings.APP_TYPES getTaskType(){
return type;
}
}
/*
* Title: EdgeCloudSim - Task
*
* Description:
* Task adds app type, task submission location, mobile device id and host id
* information to CloudSim's Cloudlet class.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_client;
import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.UtilizationModel;
import edu.boun.edgecloudsim.utils.Location;
public class Task extends Cloudlet {
private Location submittedLocation;
private int type;
private int mobileDeviceId;
private int hostIndex;
private int vmIndex;
private int datacenterId;
public Task(int _mobileDeviceId, int cloudletId, long cloudletLength, int pesNumber,
long cloudletFileSize, long cloudletOutputSize,
UtilizationModel utilizationModelCpu,
UtilizationModel utilizationModelRam,
UtilizationModel utilizationModelBw) {
super(cloudletId, cloudletLength, pesNumber, cloudletFileSize,
cloudletOutputSize, utilizationModelCpu, utilizationModelRam,
utilizationModelBw);
mobileDeviceId = _mobileDeviceId;
}
public void setSubmittedLocation(Location _submittedLocation){
submittedLocation =_submittedLocation;
}
public void setAssociatedDatacenterId(int _datacenterId){
datacenterId=_datacenterId;
}
public void setAssociatedHostId(int _hostIndex){
hostIndex=_hostIndex;
}
public void setAssociatedVmId(int _vmIndex){
vmIndex=_vmIndex;
}
public void setTaskType(int _type){
type=_type;
}
public int getMobileDeviceId(){
return mobileDeviceId;
}
public Location getSubmittedLocation(){
return submittedLocation;
}
public int getAssociatedDatacenterId(){
return datacenterId;
}
public int getAssociatedHostId(){
return hostIndex;
}
public int getAssociatedVmId(){
return vmIndex;
}
public int getTaskType(){
return type;
}
}

66
src/edu/boun/edgecloudsim/edge_orchestrator/BasicEdgeOrchestrator.java
View File

@ -14,8 +14,12 @@ package edu.boun.edgecloudsim.edge_orchestrator;
import java.util.List;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.SimEvent;
import edu.boun.edgecloudsim.cloud_server.CloudVM;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.edge_server.EdgeVM;
@ -47,10 +51,10 @@ public class BasicEdgeOrchestrator extends EdgeOrchestrator {
public int getDeviceToOffload(Task task) {
int result = SimSettings.GENERIC_EDGE_DEVICE_ID;
if(!simScenario.equals("SINGLE_TIER")){
//decide to use cloud or cloudlet VM
//decide to use cloud or Edge VM
int CloudVmPicker = SimUtils.getRandomNumber(0, 100);
if(CloudVmPicker <= SimSettings.getInstance().getTaskLookUpTable()[task.getTaskType().ordinal()][1])
if(CloudVmPicker <= SimSettings.getInstance().getTaskLookUpTable()[task.getTaskType()][1])
result = SimSettings.CLOUD_DATACENTER_ID;
else
result = SimSettings.GENERIC_EDGE_DEVICE_ID;
@ -60,11 +64,31 @@ public class BasicEdgeOrchestrator extends EdgeOrchestrator {
}
@Override
public EdgeVM getVmToOffload(Task task) {
if(simScenario.equals("TWO_TIER_WITH_EO"))
return selectVmOnLoadBalancer(task);
public Vm getVmToOffload(Task task, int deviceId) {
Vm selectedVM = null;
if(deviceId == SimSettings.CLOUD_DATACENTER_ID){
//Select VM on cloud devices via Least Loaded algorithm!
double selectedVmCapacity = 0; //start with min value
List<Host> list = SimManager.getInstance().getCloudServerManager().getDatacenter().getHostList();
for (int hostIndex=0; hostIndex < list.size(); hostIndex++) {
List<CloudVM> vmArray = SimManager.getInstance().getCloudServerManager().getVmList(hostIndex);
for(int vmIndex=0; vmIndex<vmArray.size(); vmIndex++){
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(vmIndex).getVmType());
double targetVmCapacity = (double)100 - vmArray.get(vmIndex).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
if(requiredCapacity <= targetVmCapacity && targetVmCapacity > selectedVmCapacity){
selectedVM = vmArray.get(vmIndex);
selectedVmCapacity = targetVmCapacity;
}
}
}
}
else if(simScenario.equals("TWO_TIER_WITH_EO"))
selectedVM = selectVmOnLoadBalancer(task);
else
return selectVmOnHost(task);
selectedVM = selectVmOnHost(task);
return selectedVM;
}
public EdgeVM selectVmOnHost(Task task){
@ -74,7 +98,7 @@ public class BasicEdgeOrchestrator extends EdgeOrchestrator {
//in our scenasrio, serving wlan ID is equal to the host id
//because there is only one host in one place
int relatedHostId=deviceLocation.getServingWlanId();
List<EdgeVM> vmArray = SimManager.getInstance().getLocalServerManager().getVmList(relatedHostId);
List<EdgeVM> vmArray = SimManager.getInstance().getEdgeServerManager().getVmList(relatedHostId);
if(policy.equalsIgnoreCase("RANDOM_FIT")){
int randomIndex = SimUtils.getRandomNumber(0, vmArray.size()-1);
@ -137,7 +161,7 @@ public class BasicEdgeOrchestrator extends EdgeOrchestrator {
if(policy.equalsIgnoreCase("RANDOM_FIT")){
int randomHostIndex = SimUtils.getRandomNumber(0, numberOfHost-1);
List<EdgeVM> vmArray = SimManager.getInstance().getLocalServerManager().getVmList(randomHostIndex);
List<EdgeVM> vmArray = SimManager.getInstance().getEdgeServerManager().getVmList(randomHostIndex);
int randomIndex = SimUtils.getRandomNumber(0, vmArray.size()-1);
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(randomIndex).getVmType());
@ -148,7 +172,7 @@ public class BasicEdgeOrchestrator extends EdgeOrchestrator {
else if(policy.equalsIgnoreCase("WORST_FIT")){
double selectedVmCapacity = 0; //start with min value
for(int hostIndex=0; hostIndex<numberOfHost; hostIndex++){
List<EdgeVM> vmArray = SimManager.getInstance().getLocalServerManager().getVmList(hostIndex);
List<EdgeVM> vmArray = SimManager.getInstance().getEdgeServerManager().getVmList(hostIndex);
for(int vmIndex=0; vmIndex<vmArray.size(); vmIndex++){
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(vmIndex).getVmType());
double targetVmCapacity = (double)100 - vmArray.get(vmIndex).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
@ -162,7 +186,7 @@ public class BasicEdgeOrchestrator extends EdgeOrchestrator {
else if(policy.equalsIgnoreCase("BEST_FIT")){
double selectedVmCapacity = 101; //start with max value
for(int hostIndex=0; hostIndex<numberOfHost; hostIndex++){
List<EdgeVM> vmArray = SimManager.getInstance().getLocalServerManager().getVmList(hostIndex);
List<EdgeVM> vmArray = SimManager.getInstance().getEdgeServerManager().getVmList(hostIndex);
for(int vmIndex=0; vmIndex<vmArray.size(); vmIndex++){
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(vmIndex).getVmType());
double targetVmCapacity = (double)100 - vmArray.get(vmIndex).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
@ -175,7 +199,7 @@ public class BasicEdgeOrchestrator extends EdgeOrchestrator {
}
else if(policy.equalsIgnoreCase("FIRST_FIT")){
for(int hostIndex=0; hostIndex<numberOfHost; hostIndex++){
List<EdgeVM> vmArray = SimManager.getInstance().getLocalServerManager().getVmList(hostIndex);
List<EdgeVM> vmArray = SimManager.getInstance().getEdgeServerManager().getVmList(hostIndex);
for(int vmIndex=0; vmIndex<vmArray.size(); vmIndex++){
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(vmIndex).getVmType());
double targetVmCapacity = (double)100 - vmArray.get(vmIndex).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
@ -192,7 +216,7 @@ public class BasicEdgeOrchestrator extends EdgeOrchestrator {
int tries = 0;
lastSelectedHostIndex = (lastSelectedHostIndex+1) % numberOfHost;
List<EdgeVM> vmArray = SimManager.getInstance().getLocalServerManager().getVmList(lastSelectedHostIndex);
List<EdgeVM> vmArray = SimManager.getInstance().getEdgeServerManager().getVmList(lastSelectedHostIndex);
while(tries < vmArray.size()){
lastSelectedVmIndexes[lastSelectedHostIndex] = (lastSelectedVmIndexes[lastSelectedHostIndex]+1) % vmArray.size();
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(lastSelectedVmIndexes[lastSelectedHostIndex]).getVmType());
@ -210,4 +234,22 @@ public class BasicEdgeOrchestrator extends EdgeOrchestrator {
return selectedVM;
}
@Override
public void processEvent(SimEvent arg0) {
// TODO Auto-generated method stub
}
@Override
public void shutdownEntity() {
// TODO Auto-generated method stub
}
@Override
public void startEntity() {
// TODO Auto-generated method stub
}
}

87
src/edu/boun/edgecloudsim/edge_orchestrator/EdgeOrchestrator.java
View File

@ -1,42 +1,45 @@
/*
* Title: EdgeCloudSim - Edge Orchestrator
*
* Description:
* EdgeOrchestrator is an abstract class which is used for selecting VM
* for each client requests. For those who wants to add a custom
* Edge Orchestrator 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.edge_orchestrator;
import edu.boun.edgecloudsim.edge_server.EdgeVM;
import edu.boun.edgecloudsim.edge_client.Task;
public abstract class EdgeOrchestrator {
protected String policy;
protected String simScenario;
public EdgeOrchestrator(String _policy, String _simScenario){
policy = _policy;
simScenario = _simScenario;
}
/*
* initialize edge orchestrator if needed
*/
public abstract void initialize();
/*
* decides where to offload
*/
public abstract int getDeviceToOffload(Task task);
/*
* returns proper VM from the related edge orchestrator point of view
*/
public abstract EdgeVM getVmToOffload(Task task);
}
/*
* Title: EdgeCloudSim - Edge Orchestrator
*
* Description:
* EdgeOrchestrator is an abstract class which is used for selecting VM
* for each client requests. For those who wants to add a custom
* Edge Orchestrator 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.edge_orchestrator;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.core.SimEntity;
import edu.boun.edgecloudsim.edge_client.Task;
public abstract class EdgeOrchestrator extends SimEntity{
protected String policy;
protected String simScenario;
public EdgeOrchestrator(String _policy, String _simScenario){
super("EdgeOrchestrator");
policy = _policy;
simScenario = _simScenario;
}
/*
* initialize edge orchestrator if needed
*/
public abstract void initialize();
/*
* decides where to offload
*/
public abstract int getDeviceToOffload(Task task);
/*
* returns proper VM from the edge orchestrator point of view
*/
public abstract Vm getVmToOffload(Task task, int deviceId);
}

218
src/edu/boun/edgecloudsim/edge_server/DefaultEdgeServerManager.java Normal file
View File

@ -0,0 +1,218 @@
/*
* Title: EdgeCloudSim - Edge Server Manager
*
* Description:
* DefaultEdgeServerManager is responsible for creating datacenters, hosts and VMs.
* It also provides the list of VMs running on the hosts.
* This information is critical for the edge orchestrator.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_server;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.VmAllocationPolicy;
import org.cloudbus.cloudsim.VmSchedulerSpaceShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.Location;
public class DefaultEdgeServerManager extends EdgeServerManager{
private int hostIdCounter;
public DefaultEdgeServerManager() {
hostIdCounter = 0;
}
@Override
public void initialize() {
}
@Override
public VmAllocationPolicy getVmAllocationPolicy(List<? extends Host> hostList, int dataCenterIndex) {
return new EdgeVmAllocationPolicy_Custom(hostList,dataCenterIndex);
}
public void startDatacenters() throws Exception{
Document doc = SimSettings.getInstance().getEdgeDevicesDocument();
NodeList datacenterList = doc.getElementsByTagName("datacenter");
for (int i = 0; i < datacenterList.getLength(); i++) {
Node datacenterNode = datacenterList.item(i);
Element datacenterElement = (Element) datacenterNode;
localDatacenters.add(createDatacenter(i, datacenterElement));
}
}
public void createVmList(int brockerId){
int hostCounter=0;
int vmCounter=0;
//Create VMs for each hosts
Document doc = SimSettings.getInstance().getEdgeDevicesDocument();
NodeList datacenterList = doc.getElementsByTagName("datacenter");
for (int i = 0; i < datacenterList.getLength(); i++) {
Node datacenterNode = datacenterList.item(i);
Element datacenterElement = (Element) datacenterNode;
NodeList hostNodeList = datacenterElement.getElementsByTagName("host");
for (int j = 0; j < hostNodeList.getLength(); j++) {
vmList.add(hostCounter, new ArrayList<EdgeVM>());
Node hostNode = hostNodeList.item(j);
Element hostElement = (Element) hostNode;
NodeList vmNodeList = hostElement.getElementsByTagName("VM");
for (int k = 0; k < vmNodeList.getLength(); k++) {
Node vmNode = vmNodeList.item(k);
Element vmElement = (Element) vmNode;
String vmm = vmElement.getAttribute("vmm");
int numOfCores = Integer.parseInt(vmElement.getElementsByTagName("core").item(0).getTextContent());
double mips = Double.parseDouble(vmElement.getElementsByTagName("mips").item(0).getTextContent());
int ram = Integer.parseInt(vmElement.getElementsByTagName("ram").item(0).getTextContent());
long storage = Long.parseLong(vmElement.getElementsByTagName("storage").item(0).getTextContent());
long bandwidth = SimSettings.getInstance().getWlanBandwidth() / (hostNodeList.getLength()+vmNodeList.getLength());
//VM Parameters
EdgeVM vm = new EdgeVM(vmCounter, brockerId, mips, numOfCores, ram, bandwidth, storage, vmm, new CloudletSchedulerTimeShared());
vmList.get(hostCounter).add(vm);
vmCounter++;
}
hostCounter++;
}
}
}
public void terminateDatacenters(){
for (Datacenter datacenter : localDatacenters) {
datacenter.shutdownEntity();
}
}
//average utilization of all VMs
public double getAvgUtilization(){
double totalUtilization = 0;
double vmCounter = 0;
// for each datacenter...
for(int i= 0; i<localDatacenters.size(); i++) {
List<? extends Host> list = localDatacenters.get(i).getHostList();
// for each host...
for (int j=0; j < list.size(); j++) {
Host host = list.get(j);
List<EdgeVM> vmArray = SimManager.getInstance().getEdgeServerManager().getVmList(host.getId());
//for each vm...
for(int vmIndex=0; vmIndex<vmArray.size(); vmIndex++){
totalUtilization += vmArray.get(vmIndex).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
vmCounter++;
}
}
}
return totalUtilization / vmCounter;
}
private Datacenter createDatacenter(int index, Element datacenterElement) throws Exception{
String arch = datacenterElement.getAttribute("arch");
String os = datacenterElement.getAttribute("os");
String vmm = datacenterElement.getAttribute("vmm");
double costPerBw = Double.parseDouble(datacenterElement.getElementsByTagName("costPerBw").item(0).getTextContent());
double costPerSec = Double.parseDouble(datacenterElement.getElementsByTagName("costPerSec").item(0).getTextContent());
double costPerMem = Double.parseDouble(datacenterElement.getElementsByTagName("costPerMem").item(0).getTextContent());
double costPerStorage = Double.parseDouble(datacenterElement.getElementsByTagName("costPerStorage").item(0).getTextContent());
List<EdgeHost> hostList=createHosts(datacenterElement);
String name = "Datacenter_" + Integer.toString(index);
double time_zone = 3.0; // time zone this resource located
LinkedList<Storage> storageList = new LinkedList<Storage>(); //we are not adding SAN devices by now
// 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).
DatacenterCharacteristics characteristics = new DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, costPerSec, costPerMem, costPerStorage, costPerBw);
// 6. Finally, we need to create a PowerDatacenter object.
Datacenter datacenter = null;
VmAllocationPolicy vm_policy = getVmAllocationPolicy(hostList,index);
datacenter = new Datacenter(name, characteristics, vm_policy, storageList, 0);
return datacenter;
}
private List<EdgeHost> createHosts(Element datacenterElement){
// Here are the steps needed to create a PowerDatacenter:
// 1. We need to create a list to store one or more Machines
List<EdgeHost> hostList = new ArrayList<EdgeHost>();
Element location = (Element)datacenterElement.getElementsByTagName("location").item(0);
String attractiveness = location.getElementsByTagName("attractiveness").item(0).getTextContent();
int wlan_id = Integer.parseInt(location.getElementsByTagName("wlan_id").item(0).getTextContent());
int x_pos = Integer.parseInt(location.getElementsByTagName("x_pos").item(0).getTextContent());
int y_pos = Integer.parseInt(location.getElementsByTagName("y_pos").item(0).getTextContent());
int placeTypeIndex = Integer.parseInt(attractiveness);
NodeList hostNodeList = datacenterElement.getElementsByTagName("host");
for (int j = 0; j < hostNodeList.getLength(); j++) {
Node hostNode = hostNodeList.item(j);
Element hostElement = (Element) hostNode;
int numOfCores = Integer.parseInt(hostElement.getElementsByTagName("core").item(0).getTextContent());
double mips = Double.parseDouble(hostElement.getElementsByTagName("mips").item(0).getTextContent());
int ram = Integer.parseInt(hostElement.getElementsByTagName("ram").item(0).getTextContent());
long storage = Long.parseLong(hostElement.getElementsByTagName("storage").item(0).getTextContent());
long bandwidth = SimSettings.getInstance().getWlanBandwidth() / hostNodeList.getLength();
// 2. A Machine contains one or more PEs or CPUs/Cores. Therefore, should
// create a list to store these PEs before creating
// a Machine.
List<Pe> peList = new ArrayList<Pe>();
// 3. Create PEs and add these into the list.
//for a quad-core machine, a list of 4 PEs is required:
for(int i=0; i<numOfCores; i++){
peList.add(new Pe(i, new PeProvisionerSimple(mips))); // need to store Pe id and MIPS Rating
}
//4. Create Hosts with its id and list of PEs and add them to the list of machines
EdgeHost host = new EdgeHost(
hostIdCounter,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bandwidth), //kbps
storage,
peList,
new VmSchedulerSpaceShared(peList)
);
host.setPlace(new Location(placeTypeIndex, wlan_id, x_pos, y_pos));
hostList.add(host);
hostIdCounter++;
}
return hostList;
}
}

80
src/edu/boun/edgecloudsim/edge_server/EdgeHost.java
View File

@ -1,40 +1,40 @@
/*
* Title: EdgeCloudSim - EdgeHost
*
* Description:
* EdgeHost adds location information over CloudSim's Host class
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_server;
import java.util.List;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.VmScheduler;
import org.cloudbus.cloudsim.provisioners.BwProvisioner;
import org.cloudbus.cloudsim.provisioners.RamProvisioner;
import edu.boun.edgecloudsim.utils.Location;
public class EdgeHost extends Host {
private Location location;
public EdgeHost(int id, RamProvisioner ramProvisioner,
BwProvisioner bwProvisioner, long storage,
List<? extends Pe> peList, VmScheduler vmScheduler) {
super(id, ramProvisioner, bwProvisioner, storage, peList, vmScheduler);
}
public void setPlace(Location _location){
location=_location;
}
public Location getLocation(){
return location;
}
}
/*
* Title: EdgeCloudSim - EdgeHost
*
* Description:
* EdgeHost adds location information over CloudSim's Host class
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_server;
import java.util.List;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.VmScheduler;
import org.cloudbus.cloudsim.provisioners.BwProvisioner;
import org.cloudbus.cloudsim.provisioners.RamProvisioner;
import edu.boun.edgecloudsim.utils.Location;
public class EdgeHost extends Host {
private Location location;
public EdgeHost(int id, RamProvisioner ramProvisioner,
BwProvisioner bwProvisioner, long storage,
List<? extends Pe> peList, VmScheduler vmScheduler) {
super(id, ramProvisioner, bwProvisioner, storage, peList, vmScheduler);
}
public void setPlace(Location _location){
location=_location;
}
public Location getLocation(){
return location;
}
}

279
src/edu/boun/edgecloudsim/edge_server/EdgeServerManager.java
View File

@ -1,224 +1,55 @@
/*
* Title: EdgeCloudSim - Edge Server Manager
*
* Description:
* EdgeServerManager is responsible for creating datacenters, hosts and VMs.
* It also provides the list of VMs running on the hosts.
* This information is critical for the edge orchestrator.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_server;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.VmAllocationPolicy;
import org.cloudbus.cloudsim.VmSchedulerSpaceShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import edu.boun.edgecloudsim.core.SimManager;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.Location;
import edu.boun.edgecloudsim.utils.SimUtils;
public class EdgeServerManager {
private List<Datacenter> localDatacenters;
private List<List<EdgeVM>> vmList;
private int hostIdCounter;
public EdgeServerManager() {
localDatacenters=new ArrayList<Datacenter>();
vmList = new ArrayList<List<EdgeVM>>();
hostIdCounter = 0;
}
public List<EdgeVM> getVmList(int hostId){
return vmList.get(hostId);
}
public List<Datacenter> getDatacenterList(){
return localDatacenters;
}
public void startDatacenters() throws Exception{
//create random number generator for each place
Document doc = SimSettings.getInstance().getEdgeDevicesDocument();
NodeList datacenterList = doc.getElementsByTagName("datacenter");
for (int i = 0; i < datacenterList.getLength(); i++) {
Node datacenterNode = datacenterList.item(i);
Element datacenterElement = (Element) datacenterNode;
localDatacenters.add(createDatacenter(i, datacenterElement));
}
}
public void createVmList(int brockerId){
int hostCounter=0;
int vmCounter=0;
//Create VMs for each hosts
Document doc = SimSettings.getInstance().getEdgeDevicesDocument();
NodeList datacenterList = doc.getElementsByTagName("datacenter");
for (int i = 0; i < datacenterList.getLength(); i++) {
Node datacenterNode = datacenterList.item(i);
Element datacenterElement = (Element) datacenterNode;
NodeList hostNodeList = datacenterElement.getElementsByTagName("host");
for (int j = 0; j < hostNodeList.getLength(); j++) {
vmList.add(hostCounter, new ArrayList<EdgeVM>());
Node hostNode = hostNodeList.item(j);
Element hostElement = (Element) hostNode;
NodeList vmNodeList = hostElement.getElementsByTagName("VM");
for (int k = 0; k < vmNodeList.getLength(); k++) {
Node vmNode = vmNodeList.item(k);
Element vmElement = (Element) vmNode;
String vmm = vmElement.getAttribute("vmm");
int numOfCores = Integer.parseInt(vmElement.getElementsByTagName("core").item(0).getTextContent());
double mips = Double.parseDouble(vmElement.getElementsByTagName("mips").item(0).getTextContent());
int ram = Integer.parseInt(vmElement.getElementsByTagName("ram").item(0).getTextContent());
long storage = Long.parseLong(vmElement.getElementsByTagName("storage").item(0).getTextContent());
long bandwidth = SimSettings.getInstance().getWlanBandwidth() / (hostNodeList.getLength()+vmNodeList.getLength());
//VM Parameters
EdgeVM vm = new EdgeVM(vmCounter, brockerId, mips, numOfCores, ram, bandwidth, storage, vmm, new CloudletSchedulerTimeShared());
vm.setVmType(SimSettings.VM_TYPES.EDGE_VM);
vmList.get(hostCounter).add(vm);
vmCounter++;
}
hostCounter++;
}
}
}
public void terminateDatacenters(){
for (Datacenter datacenter : localDatacenters) {
datacenter.shutdownEntity();
}
}
//average utilization of all VMs
public double getAvgUtilization(){
double totalUtilization = 0;
double vmCounter = 0;
// for each datacenter...
for(int i= 0; i<localDatacenters.size(); i++) {
List<? extends Host> list = localDatacenters.get(i).getHostList();
// for each host...
for (int j=0; j < list.size(); j++) {
Host host = list.get(j);
List<EdgeVM> vmArray = SimManager.getInstance().getLocalServerManager().getVmList(host.getId());
//for each vm...
for(int vmIndex=0; vmIndex<vmArray.size(); vmIndex++){
totalUtilization += vmArray.get(vmIndex).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
vmCounter++;
}
}
}
return totalUtilization / vmCounter;
}
private Datacenter createDatacenter(int index, Element datacenterElement) throws Exception{
String arch = datacenterElement.getAttribute("arch");
String os = datacenterElement.getAttribute("os");
String vmm = datacenterElement.getAttribute("vmm");
double costPerBw = Double.parseDouble(datacenterElement.getElementsByTagName("costPerBw").item(0).getTextContent());
double costPerSec = Double.parseDouble(datacenterElement.getElementsByTagName("costPerSec").item(0).getTextContent());
double costPerMem = Double.parseDouble(datacenterElement.getElementsByTagName("costPerMem").item(0).getTextContent());
double costPerStorage = Double.parseDouble(datacenterElement.getElementsByTagName("costPerStorage").item(0).getTextContent());
List<EdgeHost> hostList=createHosts(datacenterElement);
String name = "Datacenter_" + Integer.toString(index);
double time_zone = 3.0; // time zone this resource located
LinkedList<Storage> storageList = new LinkedList<Storage>(); //we are not adding SAN devices by now
// 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).
DatacenterCharacteristics characteristics = new DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, costPerSec, costPerMem, costPerStorage, costPerBw);
// 6. Finally, we need to create a PowerDatacenter object.
Datacenter datacenter = null;
VmAllocationPolicy vm_policy = SimManager.getInstance().getScenarioFactory().getVmAllocationPolicy(hostList,index);
datacenter = new Datacenter(name, characteristics, vm_policy, storageList, 0);
return datacenter;
}
private List<EdgeHost> createHosts(Element datacenterElement){
// Here are the steps needed to create a PowerDatacenter:
// 1. We need to create a list to store one or more Machines
List<EdgeHost> hostList = new ArrayList<EdgeHost>();
Element location = (Element)datacenterElement.getElementsByTagName("location").item(0);
String attractiveness = location.getElementsByTagName("attractiveness").item(0).getTextContent();
int wlan_id = Integer.parseInt(location.getElementsByTagName("wlan_id").item(0).getTextContent());
int x_pos = Integer.parseInt(location.getElementsByTagName("x_pos").item(0).getTextContent());
int y_pos = Integer.parseInt(location.getElementsByTagName("y_pos").item(0).getTextContent());
SimSettings.PLACE_TYPES placeType = SimUtils.stringToPlace(attractiveness);
NodeList hostNodeList = datacenterElement.getElementsByTagName("host");
for (int j = 0; j < hostNodeList.getLength(); j++) {
Node hostNode = hostNodeList.item(j);
Element hostElement = (Element) hostNode;
int numOfCores = Integer.parseInt(hostElement.getElementsByTagName("core").item(0).getTextContent());
double mips = Double.parseDouble(hostElement.getElementsByTagName("mips").item(0).getTextContent());
int ram = Integer.parseInt(hostElement.getElementsByTagName("ram").item(0).getTextContent());
long storage = Long.parseLong(hostElement.getElementsByTagName("storage").item(0).getTextContent());
long bandwidth = SimSettings.getInstance().getWlanBandwidth() / hostNodeList.getLength();
// 2. A Machine contains one or more PEs or CPUs/Cores. Therefore, should
// create a list to store these PEs before creating
// a Machine.
List<Pe> peList = new ArrayList<Pe>();
// 3. Create PEs and add these into the list.
//for a quad-core machine, a list of 4 PEs is required:
for(int i=0; i<numOfCores; i++){
peList.add(new Pe(i, new PeProvisionerSimple(mips))); // need to store Pe id and MIPS Rating
}
//4. Create Hosts with its id and list of PEs and add them to the list of machines
EdgeHost host = new EdgeHost(
hostIdCounter,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bandwidth), //kbps
storage,
peList,
new VmSchedulerSpaceShared(peList)
);
host.setPlace(new Location(placeType, wlan_id, x_pos, y_pos));
hostList.add(host);
hostIdCounter++;
}
return hostList;
}
}
package edu.boun.edgecloudsim.edge_server;
import java.util.ArrayList;
import java.util.List;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.VmAllocationPolicy;
public abstract class EdgeServerManager {
protected List<Datacenter> localDatacenters;
protected List<List<EdgeVM>> vmList;
public EdgeServerManager() {
localDatacenters=new ArrayList<Datacenter>();
vmList = new ArrayList<List<EdgeVM>>();
}
public List<EdgeVM> getVmList(int hostId){
return vmList.get(hostId);
}
public List<Datacenter> getDatacenterList(){
return localDatacenters;
}
/*
* initialize edge server manager if needed
*/
public abstract void initialize();
/*
* provides abstract Vm Allocation Policy for Edge Datacenters
*/
public abstract VmAllocationPolicy getVmAllocationPolicy(List<? extends Host> list, int dataCenterIndex);
/*
* Starts Datacenters
*/
public abstract void startDatacenters() throws Exception;
/*
* Terminates Datacenters
*/
public abstract void terminateDatacenters();
/*
* Creates VM List
*/
public abstract void createVmList(int brockerId);
/*
* returns average utilization of all VMs
*/
public abstract double getAvgUtilization();
}

65
src/edu/boun/edgecloudsim/edge_server/EdgeVM.java
View File

@ -1,34 +1,31 @@
/*
* Title: EdgeCloudSim - EdgeVM
*
* Description:
* EdgeVM adds vm type information over CloudSim's VM class
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_server;
import org.cloudbus.cloudsim.CloudletScheduler;
import org.cloudbus.cloudsim.Vm;
import edu.boun.edgecloudsim.core.SimSettings;
public class EdgeVM extends Vm {
private SimSettings.VM_TYPES type;
public EdgeVM(int id, int userId, double mips, int numberOfPes, int ram,
long bw, long size, String vmm, CloudletScheduler cloudletScheduler) {
super(id, userId, mips, numberOfPes, ram, bw, size, vmm, cloudletScheduler);
}
public void setVmType(SimSettings.VM_TYPES _type){
type=_type;
}
public SimSettings.VM_TYPES getVmType(){
return type;
}
}
/*
* Title: EdgeCloudSim - EdgeVM
*
* Description:
* EdgeVM adds vm type information over CloudSim's VM class
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_server;
import org.cloudbus.cloudsim.CloudletScheduler;
import org.cloudbus.cloudsim.Vm;
import edu.boun.edgecloudsim.core.SimSettings;
public class EdgeVM extends Vm {
private SimSettings.VM_TYPES type;
public EdgeVM(int id, int userId, double mips, int numberOfPes, int ram,
long bw, long size, String vmm, CloudletScheduler cloudletScheduler) {
super(id, userId, mips, numberOfPes, ram, bw, size, vmm, cloudletScheduler);
type = SimSettings.VM_TYPES.EDGE_VM;
}
public SimSettings.VM_TYPES getVmType(){
return type;
}
}

316
src/edu/boun/edgecloudsim/edge_server/VmAllocationPolicy_Custom.java → src/edu/boun/edgecloudsim/edge_server/EdgeVmAllocationPolicy_Custom.java
View File

@ -1,158 +1,158 @@
/*
* Title: EdgeCloudSim - Custom Vm Allocation Policy
*
* Description:
* VmAllocationPolicy_Custom implements VmAllocationPolicy to decide which.
* VM is created on which host locatied on the datacenters. For those
* who wants to add another Vm Allocation Policy to EdgeCloudSim should
* provide another concreate instance of VmAllocationPolicy via ScenarioFactory
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_server;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicy;
import org.cloudbus.cloudsim.core.CloudSim;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import edu.boun.edgecloudsim.core.SimSettings;
/*
* Same as VmAllocationPolicySimple.
*/
public class VmAllocationPolicy_Custom extends VmAllocationPolicy {
/** The vm table. */
private Map<String, Host> vmTable;
private static int createdVmNum;
private int DataCenterIndex;
public VmAllocationPolicy_Custom(List<? extends Host> list, int _DataCenterIndex) {
super(list);
setVmTable(new HashMap<String, Host>());
DataCenterIndex=_DataCenterIndex;
createdVmNum = 0;
}
@Override
public boolean allocateHostForVm(Vm vm) {
boolean result = false;
if (!getVmTable().containsKey(vm.getUid())) { // if this vm was not created
boolean vmFound = false;
int vmCounter = 0;
int hostIndex = 0;
int dataCenterIndex = 0;
//find proper datacenter id and host id for this VM
Document doc = SimSettings.getInstance().getEdgeDevicesDocument();
NodeList datacenterList = doc.getElementsByTagName("datacenter");
for (int i = 0; (!vmFound && i < datacenterList.getLength()); i++) {
Node datacenterNode = datacenterList.item(i);
Element datacenterElement = (Element) datacenterNode;
NodeList hostNodeList = datacenterElement.getElementsByTagName("host");
for (int j = 0; (!vmFound && j < hostNodeList.getLength()); j++) {
Node hostNode = hostNodeList.item(j);
Element hostElement = (Element) hostNode;
NodeList vmNodeList = hostElement.getElementsByTagName("VM");
for (int k = 0; (!vmFound && k < vmNodeList.getLength()); k++) {
if(vmCounter == vm.getId()){
dataCenterIndex = i;
hostIndex = j;
vmFound = true;
}
vmCounter++;
}
}
}
if(vmFound && dataCenterIndex == DataCenterIndex && hostIndex < getHostList().size()){
Host host = getHostList().get(hostIndex);
result = host.vmCreate(vm);
if (result) { // if vm were succesfully created in the host
getVmTable().put(vm.getUid(), host);
createdVmNum++;
Log.formatLine("%.2f: VM #" + vm.getId() + " has been allocated to the host #" + host.getId(),CloudSim.clock());
result = true;
}
}
}
return result;
}
@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);
createdVmNum++;
Log.formatLine("%.2f: VM #" + vm.getId() + " has been allocated to the host #" + host.getId(),CloudSim.clock());
return true;
}
return false;
}
@Override
public List<Map<String, Object>> optimizeAllocation(
List<? extends Vm> vmList) {
// TODO Auto-generated method stub
return null;
}
@Override
public void deallocateHostForVm(Vm vm) {
Host host = getVmTable().remove(vm.getUid());
if (host != null) {
host.vmDestroy(vm);
}
}
@Override
public Host getHost(Vm vm) {
return getVmTable().get(vm.getUid());
}
@Override
public Host getHost(int vmId, int userId) {
return getVmTable().get(Vm.getUid(userId, vmId));
}
public static int getCreatedVmNum(){
return createdVmNum;
}
/**
* 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;
}
}
/*
* Title: EdgeCloudSim - Custom Vm Allocation Policy for Edge VMs
*
* Description:
* VmAllocationPolicy_Custom implements VmAllocationPolicy to decide which.
* VM is created on which host locatied on the datacenters. For those
* who wants to add another Vm Allocation Policy to EdgeCloudSim should
* provide another concreate instance of VmAllocationPolicy via ScenarioFactory
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.edge_server;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicy;
import org.cloudbus.cloudsim.core.CloudSim;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import edu.boun.edgecloudsim.core.SimSettings;
/*
* Same as VmAllocationPolicySimple.
*/
public class EdgeVmAllocationPolicy_Custom extends VmAllocationPolicy {
/** The vm table. */
private Map<String, Host> vmTable;
private static int createdVmNum;
private int DataCenterIndex;
public EdgeVmAllocationPolicy_Custom(List<? extends Host> list, int _DataCenterIndex) {
super(list);
setVmTable(new HashMap<String, Host>());
DataCenterIndex=_DataCenterIndex;
createdVmNum = 0;
}
@Override
public boolean allocateHostForVm(Vm vm) {
boolean result = false;
if (!getVmTable().containsKey(vm.getUid()) && vm instanceof EdgeVM) { // if this vm was not created
boolean vmFound = false;
int vmCounter = 0;
int hostIndex = 0;
int dataCenterIndex = 0;
//find proper datacenter id and host id for this VM
Document doc = SimSettings.getInstance().getEdgeDevicesDocument();
NodeList datacenterList = doc.getElementsByTagName("datacenter");
for (int i = 0; (!vmFound && i < datacenterList.getLength()); i++) {
Node datacenterNode = datacenterList.item(i);
Element datacenterElement = (Element) datacenterNode;
NodeList hostNodeList = datacenterElement.getElementsByTagName("host");
for (int j = 0; (!vmFound && j < hostNodeList.getLength()); j++) {
Node hostNode = hostNodeList.item(j);
Element hostElement = (Element) hostNode;
NodeList vmNodeList = hostElement.getElementsByTagName("VM");
for (int k = 0; (!vmFound && k < vmNodeList.getLength()); k++) {
if(vmCounter == vm.getId()){
dataCenterIndex = i;
hostIndex = j;
vmFound = true;
}
vmCounter++;
}
}
}
if(vmFound && dataCenterIndex == DataCenterIndex && hostIndex < getHostList().size()){
Host host = getHostList().get(hostIndex);
result = host.vmCreate(vm);
if (result) { // if vm were succesfully created in the host
getVmTable().put(vm.getUid(), host);
createdVmNum++;
Log.formatLine("%.2f: Edge VM #" + vm.getId() + " has been allocated to the host #" + host.getId(),CloudSim.clock());
result = true;
}
}
}
return result;
}
@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);
createdVmNum++;
Log.formatLine("%.2f: Edge VM #" + vm.getId() + " has been allocated to the host #" + host.getId(),CloudSim.clock());
return true;
}
return false;
}
@Override
public List<Map<String, Object>> optimizeAllocation(
List<? extends Vm> vmList) {
// TODO Auto-generated method stub
return null;
}
@Override
public void deallocateHostForVm(Vm vm) {
Host host = getVmTable().remove(vm.getUid());
if (host != null) {
host.vmDestroy(vm);
}
}
@Override
public Host getHost(Vm vm) {
return getVmTable().get(vm.getUid());
}
@Override
public Host getHost(int vmId, int userId) {
return getVmTable().get(Vm.getUid(userId, vmId));
}
public static int getCreatedVmNum(){
return createdVmNum;
}
/**
* 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;
}
}

72
src/edu/boun/edgecloudsim/mobility/MobilityModel.java
View File

@ -1,36 +1,36 @@
/*
* Title: EdgeCloudSim - Mobility Model
*
* Description:
* MobilityModel is an abstract class which is used for calculating the
* location of each mobile devices with respect to the time. For those who
* wants to add a custom Mobility 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.mobility;
import edu.boun.edgecloudsim.utils.Location;
public abstract class MobilityModel {
protected int numberOfMobileDevices;
protected double simulationTime;
public MobilityModel(int _numberOfMobileDevices, double _simulationTime){
numberOfMobileDevices=_numberOfMobileDevices;
simulationTime=_simulationTime;
};
/*
* calculate location of the devices according to related mobility model
*/
public abstract void initialize();
/*
* returns location of a device at a certain time
*/
public abstract Location getLocation(int deviceId, double time);
}
/*
* Title: EdgeCloudSim - Mobility Model
*
* Description:
* MobilityModel is an abstract class which is used for calculating the
* location of each mobile devices with respect to the time. For those who
* wants to add a custom Mobility 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.mobility;
import edu.boun.edgecloudsim.utils.Location;
public abstract class MobilityModel {
protected int numberOfMobileDevices;
protected double simulationTime;
public MobilityModel(int _numberOfMobileDevices, double _simulationTime){
numberOfMobileDevices=_numberOfMobileDevices;
simulationTime=_simulationTime;
};
/*
* calculate location of the devices according to related mobility model
*/
public abstract void initialize();
/*
* returns location of a device at a certain time
*/
public abstract Location getLocation(int deviceId, double time);
}

246
src/edu/boun/edgecloudsim/mobility/NomadicMobility.java
View File

@ -1,123 +1,123 @@
/*
* Title: EdgeCloudSim - Nomadic Mobility model implementation
*
* Description:
* MobilityModel implements basic nomadic mobility model where the
* place of the devices are changed from time to time instead of a
* continuous location update.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.mobility;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeMap;
import java.util.Map.Entry;
import org.apache.commons.math3.distribution.ExponentialDistribution;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.Location;
import edu.boun.edgecloudsim.utils.SimLogger;
import edu.boun.edgecloudsim.utils.SimUtils;
public class NomadicMobility extends MobilityModel {
private List<TreeMap<Double, Location>> treeMapArray;
public NomadicMobility(int _numberOfMobileDevices, double _simulationTime) {
super(_numberOfMobileDevices, _simulationTime);
// TODO Auto-generated constructor stub
}
@Override
public void initialize() {
treeMapArray = new ArrayList<TreeMap<Double, Location>>();
ExponentialDistribution[] expRngList = new ExponentialDistribution[SimSettings.getInstance().getNumOfEdgeDatacenters()];
//create random number generator for each place
Document doc = SimSettings.getInstance().getEdgeDevicesDocument();
NodeList datacenterList = doc.getElementsByTagName("datacenter");
for (int i = 0; i < datacenterList.getLength(); i++) {
Node datacenterNode = datacenterList.item(i);
Element datacenterElement = (Element) datacenterNode;
Element location = (Element)datacenterElement.getElementsByTagName("location").item(0);
String attractiveness = location.getElementsByTagName("attractiveness").item(0).getTextContent();
SimSettings.PLACE_TYPES placeType = SimUtils.stringToPlace(attractiveness);
expRngList[i] = new ExponentialDistribution(SimSettings.getInstance().getMobilityLookUpTable()[placeType.ordinal()]);
}
//initialize tree maps and position of mobile devices
for(int i=0; i<numberOfMobileDevices; i++) {
treeMapArray.add(i, new TreeMap<Double, Location>());
int randDatacenterId = SimUtils.getRandomNumber(0, SimSettings.getInstance().getNumOfEdgeDatacenters()-1);
Node datacenterNode = datacenterList.item(randDatacenterId);
Element datacenterElement = (Element) datacenterNode;
Element location = (Element)datacenterElement.getElementsByTagName("location").item(0);
String attractiveness = location.getElementsByTagName("attractiveness").item(0).getTextContent();
SimSettings.PLACE_TYPES placeType = SimUtils.stringToPlace(attractiveness);
int wlan_id = Integer.parseInt(location.getElementsByTagName("wlan_id").item(0).getTextContent());
int x_pos = Integer.parseInt(location.getElementsByTagName("x_pos").item(0).getTextContent());
int y_pos = Integer.parseInt(location.getElementsByTagName("y_pos").item(0).getTextContent());
//start locating user from 10th seconds
treeMapArray.get(i).put((double)10, new Location(placeType, wlan_id, x_pos, y_pos));
}
for(int i=0; i<numberOfMobileDevices; i++) {
TreeMap<Double, Location> treeMap = treeMapArray.get(i);
while(treeMap.lastKey() < SimSettings.getInstance().getSimulationTime()) {
boolean placeFound = false;
int currentLocationId = treeMap.lastEntry().getValue().getServingWlanId();
double waitingTime = expRngList[currentLocationId].sample();
while(placeFound == false){
int newDatacenterId = SimUtils.getRandomNumber(0,SimSettings.getInstance().getNumOfEdgeDatacenters()-1);
if(newDatacenterId != currentLocationId){
placeFound = true;
Node datacenterNode = datacenterList.item(newDatacenterId);
Element datacenterElement = (Element) datacenterNode;
Element location = (Element)datacenterElement.getElementsByTagName("location").item(0);
String attractiveness = location.getElementsByTagName("attractiveness").item(0).getTextContent();
SimSettings.PLACE_TYPES placeType = SimUtils.stringToPlace(attractiveness);
int wlan_id = Integer.parseInt(location.getElementsByTagName("wlan_id").item(0).getTextContent());
int x_pos = Integer.parseInt(location.getElementsByTagName("x_pos").item(0).getTextContent());
int y_pos = Integer.parseInt(location.getElementsByTagName("y_pos").item(0).getTextContent());
treeMap.put(treeMap.lastKey()+waitingTime, new Location(placeType, wlan_id, x_pos, y_pos));
}
}
if(!placeFound){
SimLogger.printLine("impossible is occured! location cannot be assigned to the device!");
System.exit(0);
}
}
}
}
@Override
public Location getLocation(int deviceId, double time) {
TreeMap<Double, Location> treeMap = treeMapArray.get(deviceId);
Entry<Double, Location> e = treeMap.floorEntry(time);
if(e == null){
SimLogger.printLine("impossible is occured! no location is found for the device!");
System.exit(0);
}
return e.getValue();
}
}
/*
* Title: EdgeCloudSim - Nomadic Mobility model implementation
*
* Description:
* MobilityModel implements basic nomadic mobility model where the
* place of the devices are changed from time to time instead of a
* continuous location update.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.mobility;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeMap;
import java.util.Map.Entry;
import org.apache.commons.math3.distribution.ExponentialDistribution;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.Location;
import edu.boun.edgecloudsim.utils.SimLogger;
import edu.boun.edgecloudsim.utils.SimUtils;
public class NomadicMobility extends MobilityModel {
private List<TreeMap<Double, Location>> treeMapArray;
public NomadicMobility(int _numberOfMobileDevices, double _simulationTime) {
super(_numberOfMobileDevices, _simulationTime);
// TODO Auto-generated constructor stub
}
@Override
public void initialize() {
treeMapArray = new ArrayList<TreeMap<Double, Location>>();
ExponentialDistribution[] expRngList = new ExponentialDistribution[SimSettings.getInstance().getNumOfEdgeDatacenters()];
//create random number generator for each place
Document doc = SimSettings.getInstance().getEdgeDevicesDocument();
NodeList datacenterList = doc.getElementsByTagName("datacenter");
for (int i = 0; i < datacenterList.getLength(); i++) {
Node datacenterNode = datacenterList.item(i);
Element datacenterElement = (Element) datacenterNode;
Element location = (Element)datacenterElement.getElementsByTagName("location").item(0);
String attractiveness = location.getElementsByTagName("attractiveness").item(0).getTextContent();
int placeTypeIndex = Integer.parseInt(attractiveness);
expRngList[i] = new ExponentialDistribution(SimSettings.getInstance().getMobilityLookUpTable()[placeTypeIndex]);
}
//initialize tree maps and position of mobile devices
for(int i=0; i<numberOfMobileDevices; i++) {
treeMapArray.add(i, new TreeMap<Double, Location>());
int randDatacenterId = SimUtils.getRandomNumber(0, SimSettings.getInstance().getNumOfEdgeDatacenters()-1);
Node datacenterNode = datacenterList.item(randDatacenterId);
Element datacenterElement = (Element) datacenterNode;
Element location = (Element)datacenterElement.getElementsByTagName("location").item(0);
String attractiveness = location.getElementsByTagName("attractiveness").item(0).getTextContent();
int placeTypeIndex = Integer.parseInt(attractiveness);
int wlan_id = Integer.parseInt(location.getElementsByTagName("wlan_id").item(0).getTextContent());
int x_pos = Integer.parseInt(location.getElementsByTagName("x_pos").item(0).getTextContent());
int y_pos = Integer.parseInt(location.getElementsByTagName("y_pos").item(0).getTextContent());
//start locating user shortly after the simulation started (e.g. 10 seconds)
treeMapArray.get(i).put(SimSettings.CLIENT_ACTIVITY_START_TIME, new Location(placeTypeIndex, wlan_id, x_pos, y_pos));
}
for(int i=0; i<numberOfMobileDevices; i++) {
TreeMap<Double, Location> treeMap = treeMapArray.get(i);
while(treeMap.lastKey() < SimSettings.getInstance().getSimulationTime()) {
boolean placeFound = false;
int currentLocationId = treeMap.lastEntry().getValue().getServingWlanId();
double waitingTime = expRngList[currentLocationId].sample();
while(placeFound == false){
int newDatacenterId = SimUtils.getRandomNumber(0,SimSettings.getInstance().getNumOfEdgeDatacenters()-1);
if(newDatacenterId != currentLocationId){
placeFound = true;
Node datacenterNode = datacenterList.item(newDatacenterId);
Element datacenterElement = (Element) datacenterNode;
Element location = (Element)datacenterElement.getElementsByTagName("location").item(0);
String attractiveness = location.getElementsByTagName("attractiveness").item(0).getTextContent();
int placeTypeIndex = Integer.parseInt(attractiveness);
int wlan_id = Integer.parseInt(location.getElementsByTagName("wlan_id").item(0).getTextContent());
int x_pos = Integer.parseInt(location.getElementsByTagName("x_pos").item(0).getTextContent());
int y_pos = Integer.parseInt(location.getElementsByTagName("y_pos").item(0).getTextContent());
treeMap.put(treeMap.lastKey()+waitingTime, new Location(placeTypeIndex, wlan_id, x_pos, y_pos));
}
}
if(!placeFound){
SimLogger.printLine("impossible is occured! location cannot be assigned to the device!");
System.exit(0);
}
}
}
}
@Override
public Location getLocation(int deviceId, double time) {
TreeMap<Double, Location> treeMap = treeMapArray.get(deviceId);
Entry<Double, Location> e = treeMap.floorEntry(time);
if(e == null){
SimLogger.printLine("impossible is occured! no location is found for the device '" + deviceId + "' at " + time);
System.exit(0);
}
return e.getValue();
}
}

445
src/edu/boun/edgecloudsim/network/MM1Queue.java
View File

@ -1,222 +1,223 @@
/*
* 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 dataSize) {
double delay = 0;
Location accessPointLocation = SimManager.getInstance().getMobilityModel().getLocation(sourceDeviceId,CloudSim.clock());
//mobile device to cloud server
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;
}
//mobile device to edge orchestrator
else if(destDeviceId == SimSettings.EDGE_ORCHESTRATOR_ID){
delay = getWlanUploadDelay(accessPointLocation, CloudSim.clock()) +
SimSettings.getInstance().getInternalLanDelay();
}
//mobile device to edge device (wifi access point)
else if (destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID) {
delay = getWlanUploadDelay(accessPointLocation, CloudSim.clock());
}
return delay;
}
/**
* destination device is always mobile device in our simulation scenarios!
*/
@Override
public double getDownloadDelay(int sourceDeviceId, int destDeviceId, double dataSize) {
//Special Case -> edge orchestrator to edge device
if(sourceDeviceId == SimSettings.EDGE_ORCHESTRATOR_ID &&
destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID){
return SimSettings.getInstance().getInternalLanDelay();
}
double delay = 0;
Location accessPointLocation = SimManager.getInstance().getMobilityModel().getLocation(destDeviceId,CloudSim.clock());
//cloud server to mobile device
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;
}
//edge device (wifi access point) to mobile device
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);
result += propogationDelay;
return (result > 5) ? -1 : result;
}
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));
}
@Override
public void uploadStarted(Location accessPointLocation, int destDeviceId) {
// TODO Auto-generated method stub
}
@Override
public void uploadFinished(Location accessPointLocation, int destDeviceId) {
// TODO Auto-generated method stub
}
@Override
public void downloadStarted(Location accessPointLocation, int sourceDeviceId) {
// TODO Auto-generated method stub
}
@Override
public void downloadFinished(Location accessPointLocation, int sourceDeviceId) {
// TODO Auto-generated method stub
}
}
/*
* 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_client.Task;
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, String _simScenario) {
super(_numberOfMobileDevices, _simScenario);
}
@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 (int i=0; i<SimSettings.getInstance().getTaskLookUpTable().length; i++) {
double weight = SS.getTaskLookUpTable()[i][0]/(double)100;
if(weight != 0) {
WlanPoissonMean += (SS.getTaskLookUpTable()[i][2])*weight;
double percentageOfCloudCommunication = SS.getTaskLookUpTable()[i][1];
WanPoissonMean += (WlanPoissonMean)*((double)100/percentageOfCloudCommunication)*weight;
avgTaskInputSize += SS.getTaskLookUpTable()[i][5]*weight;
avgTaskOutputSize += SS.getTaskLookUpTable()[i][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, Task task) {
double delay = 0;
Location accessPointLocation = SimManager.getInstance().getMobilityModel().getLocation(sourceDeviceId,CloudSim.clock());
//mobile device to cloud server
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;
}
//mobile device to edge orchestrator
else if(destDeviceId == SimSettings.EDGE_ORCHESTRATOR_ID){
delay = getWlanUploadDelay(accessPointLocation, CloudSim.clock()) +
SimSettings.getInstance().getInternalLanDelay();
}
//mobile device to edge device (wifi access point)
else if (destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID) {
delay = getWlanUploadDelay(accessPointLocation, CloudSim.clock());
}
return delay;
}
/**
* destination device is always mobile device in our simulation scenarios!
*/
@Override
public double getDownloadDelay(int sourceDeviceId, int destDeviceId, Task task) {
//Special Case -> edge orchestrator to edge device
if(sourceDeviceId == SimSettings.EDGE_ORCHESTRATOR_ID &&
destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID){
return SimSettings.getInstance().getInternalLanDelay();
}
double delay = 0;
Location accessPointLocation = SimManager.getInstance().getMobilityModel().getLocation(destDeviceId,CloudSim.clock());
//cloud server to mobile device
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;
}
//edge device (wifi access point) to mobile device
else{
delay = getWlanDownloadDelay(accessPointLocation, CloudSim.clock());
EdgeHost host = (EdgeHost)(SimManager.
getInstance().
getEdgeServerManager().
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);
result += propogationDelay;
return (result > 5) ? -1 : result;
}
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));
}
@Override
public void uploadStarted(Location accessPointLocation, int destDeviceId) {
// TODO Auto-generated method stub
}
@Override
public void uploadFinished(Location accessPointLocation, int destDeviceId) {
// TODO Auto-generated method stub
}
@Override
public void downloadStarted(Location accessPointLocation, int sourceDeviceId) {
// TODO Auto-generated method stub
}
@Override
public void downloadFinished(Location accessPointLocation, int sourceDeviceId) {
// TODO Auto-generated method stub
}
}

99
src/edu/boun/edgecloudsim/network/NetworkModel.java
View File

@ -1,48 +1,51 @@
/*
* 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;
import edu.boun.edgecloudsim.utils.Location;
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, double dataSize);
/**
* calculates the download delay from source to destination device
*/
public abstract double getDownloadDelay(int sourceDeviceId, int destDeviceId, double dataSize);
/**
* Mobile device manager should inform network manager about the network operation
* This information may be important for some network delay models
*/
public abstract void uploadStarted(Location accessPointLocation, int destDeviceId);
public abstract void uploadFinished(Location accessPointLocation, int destDeviceId);
public abstract void downloadStarted(Location accessPointLocation, int sourceDeviceId);
public abstract void downloadFinished(Location accessPointLocation, int sourceDeviceId);
}
/*
* 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;
import edu.boun.edgecloudsim.edge_client.Task;
import edu.boun.edgecloudsim.utils.Location;
public abstract class NetworkModel {
protected int numberOfMobileDevices;
protected String simScenario;
public NetworkModel(int _numberOfMobileDevices, String _simScenario){
numberOfMobileDevices=_numberOfMobileDevices;
simScenario = _simScenario;
};
/**
* initializes custom network model
*/
public abstract void initialize();
/**
* calculates the upload delay from source to destination device
*/
public abstract double getUploadDelay(int sourceDeviceId, int destDeviceId, Task task);
/**
* calculates the download delay from source to destination device
*/
public abstract double getDownloadDelay(int sourceDeviceId, int destDeviceId, Task task);
/**
* Mobile device manager should inform network manager about the network operation
* This information may be important for some network delay models
*/
public abstract void uploadStarted(Location accessPointLocation, int destDeviceId);
public abstract void uploadFinished(Location accessPointLocation, int destDeviceId);
public abstract void downloadStarted(Location accessPointLocation, int sourceDeviceId);
public abstract void downloadFinished(Location accessPointLocation, int sourceDeviceId);
}

198
src/edu/boun/edgecloudsim/task_generator/IdleActiveLoadGenerator.java
View File

@ -1,94 +1,104 @@
/*
* Title: EdgeCloudSim - Idle/Active Load Generator implementation
*
* Description:
* IdleActiveLoadGenerator implements basic load generator model where the
* mobile devices generate task in active period and waits in idle period.
* Task interarrival time (load generation period), Idle and active periods
* are defined in the configuration file.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.task_generator;
import java.util.ArrayList;
import org.apache.commons.math3.distribution.ExponentialDistribution;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.core.SimSettings.APP_TYPES;
import edu.boun.edgecloudsim.utils.EdgeTask;
import edu.boun.edgecloudsim.utils.SimLogger;
import edu.boun.edgecloudsim.utils.SimUtils;
public class IdleActiveLoadGenerator extends LoadGeneratorModel{
public IdleActiveLoadGenerator(int _numberOfMobileDevices, double _simulationTime, String _simScenario) {
super(_numberOfMobileDevices, _simulationTime, _simScenario);
}
@Override
public void initializeModel() {
taskList = new ArrayList<EdgeTask>();
//exponential number generator for file input size, file output size and task length
ExponentialDistribution[][] expRngList = new ExponentialDistribution[SimSettings.APP_TYPES.values().length][3];
//create random number generator for each place
for(int i=0; i<SimSettings.APP_TYPES.values().length; i++) {
if(SimSettings.getInstance().getTaskLookUpTable()[i][0] ==0)
continue;
expRngList[i][0] = new ExponentialDistribution(SimSettings.getInstance().getTaskLookUpTable()[i][5]);
expRngList[i][1] = new ExponentialDistribution(SimSettings.getInstance().getTaskLookUpTable()[i][6]);
expRngList[i][2] = new ExponentialDistribution(SimSettings.getInstance().getTaskLookUpTable()[i][7]);
}
//Each mobile device utilizes an app type (task type)
for(int i=0; i<numberOfMobileDevices; i++) {
APP_TYPES randomTaskType = null;
double taskTypeSelector = SimUtils.getRandomDoubleNumber(0,100);
double taskTypePercentage = 0;
for (SimSettings.APP_TYPES taskType : SimSettings.APP_TYPES.values()) {
taskTypePercentage += SimSettings.getInstance().getTaskLookUpTable()[taskType.ordinal()][0];
if(taskTypeSelector <= taskTypePercentage){
randomTaskType = taskType;
break;
}
}
if(randomTaskType == null){
SimLogger.printLine("Impossible is occured! no random task type!");
continue;
}
double poissonMean = SimSettings.getInstance().getTaskLookUpTable()[randomTaskType.ordinal()][2];
double activePeriod = SimSettings.getInstance().getTaskLookUpTable()[randomTaskType.ordinal()][3];
double idlePeriod = SimSettings.getInstance().getTaskLookUpTable()[randomTaskType.ordinal()][4];
double activePeriodStartTime = SimUtils.getRandomDoubleNumber(10, 10+activePeriod); //start from 10th seconds
double virtualTime = activePeriodStartTime; //start from 10th seconds
ExponentialDistribution rng = new ExponentialDistribution(poissonMean);
while(virtualTime < simulationTime) {
double interval = rng.sample();
if(interval <= 0){
SimLogger.printLine("Impossible is occured! interval is " + interval + " for device " + i + " time " + virtualTime);
continue;
}
//SimLogger.printLine(virtualTime + " -> " + interval + " for device " + i + " time ");
virtualTime += interval;
if(virtualTime > activePeriodStartTime + activePeriod){
activePeriodStartTime = activePeriodStartTime + activePeriod + idlePeriod;
virtualTime = activePeriodStartTime;
continue;
}
taskList.add(new EdgeTask(i,randomTaskType, virtualTime, expRngList));
}
}
}
}
/*
* Title: EdgeCloudSim - Idle/Active Load Generator implementation
*
* Description:
* IdleActiveLoadGenerator implements basic load generator model where the
* mobile devices generate task in active period and waits in idle period.
* Task interarrival time (load generation period), Idle and active periods
* are defined in the configuration file.
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.task_generator;
import java.util.ArrayList;
import org.apache.commons.math3.distribution.ExponentialDistribution;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.utils.EdgeTask;
import edu.boun.edgecloudsim.utils.SimLogger;
import edu.boun.edgecloudsim.utils.SimUtils;
public class IdleActiveLoadGenerator extends LoadGeneratorModel{
int taskTypeOfDevices[];
public IdleActiveLoadGenerator(int _numberOfMobileDevices, double _simulationTime, String _simScenario) {
super(_numberOfMobileDevices, _simulationTime, _simScenario);
}
@Override
public void initializeModel() {
taskList = new ArrayList<EdgeTask>();
//exponential number generator for file input size, file output size and task length
ExponentialDistribution[][] expRngList = new ExponentialDistribution[SimSettings.getInstance().getTaskLookUpTable().length][3];
//create random number generator for each place
for(int i=0; i<SimSettings.getInstance().getTaskLookUpTable().length; i++) {
if(SimSettings.getInstance().getTaskLookUpTable()[i][0] ==0)
continue;
expRngList[i][0] = new ExponentialDistribution(SimSettings.getInstance().getTaskLookUpTable()[i][5]);
expRngList[i][1] = new ExponentialDistribution(SimSettings.getInstance().getTaskLookUpTable()[i][6]);
expRngList[i][2] = new ExponentialDistribution(SimSettings.getInstance().getTaskLookUpTable()[i][7]);
}
//Each mobile device utilizes an app type (task type)
taskTypeOfDevices = new int[numberOfMobileDevices];
for(int i=0; i<numberOfMobileDevices; i++) {
int randomTaskType = -1;
double taskTypeSelector = SimUtils.getRandomDoubleNumber(0,100);
double taskTypePercentage = 0;
for (int j=0; j<SimSettings.getInstance().getTaskLookUpTable().length; j++) {
taskTypePercentage += SimSettings.getInstance().getTaskLookUpTable()[j][0];
if(taskTypeSelector <= taskTypePercentage){
randomTaskType = j;
break;
}
}
if(randomTaskType == -1){
SimLogger.printLine("Impossible is occured! no random task type!");
continue;
}
taskTypeOfDevices[i] = randomTaskType;
double poissonMean = SimSettings.getInstance().getTaskLookUpTable()[randomTaskType][2];
double activePeriod = SimSettings.getInstance().getTaskLookUpTable()[randomTaskType][3];
double idlePeriod = SimSettings.getInstance().getTaskLookUpTable()[randomTaskType][4];
double activePeriodStartTime = SimUtils.getRandomDoubleNumber(
SimSettings.CLIENT_ACTIVITY_START_TIME,
SimSettings.CLIENT_ACTIVITY_START_TIME + activePeriod); //active period starts shortly after the simulation started (e.g. 10 seconds)
double virtualTime = activePeriodStartTime;
ExponentialDistribution rng = new ExponentialDistribution(poissonMean);
while(virtualTime < simulationTime) {
double interval = rng.sample();
if(interval <= 0){
SimLogger.printLine("Impossible is occured! interval is " + interval + " for device " + i + " time " + virtualTime);
continue;
}
//SimLogger.printLine(virtualTime + " -> " + interval + " for device " + i + " time ");
virtualTime += interval;
if(virtualTime > activePeriodStartTime + activePeriod){
activePeriodStartTime = activePeriodStartTime + activePeriod + idlePeriod;
virtualTime = activePeriodStartTime;
continue;
}
taskList.add(new EdgeTask(i,randomTaskType, virtualTime, expRngList));
}
}
}
@Override
public int getTaskTypeOfDevice(int deviceId) {
// TODO Auto-generated method stub
return taskTypeOfDevices[deviceId];
}
}

93
src/edu/boun/edgecloudsim/task_generator/LoadGeneratorModel.java
View File

@ -1,44 +1,49 @@
/*
* Title: EdgeCloudSim - Load Generator Model
*
* Description:
* LoadGeneratorModel is an abstract class which is used for
* deciding task generation pattern via a task list. For those who
* wants to add a custom Load Generator 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.task_generator;
import java.util.List;
import edu.boun.edgecloudsim.utils.EdgeTask;
public abstract class LoadGeneratorModel {
protected List<EdgeTask> taskList;
protected int numberOfMobileDevices;
protected double simulationTime;
protected String simScenario;
public LoadGeneratorModel(int _numberOfMobileDevices, double _simulationTime, String _simScenario){
numberOfMobileDevices=_numberOfMobileDevices;
simulationTime=_simulationTime;
simScenario=_simScenario;
};
/*
* each task has a virtual start time
* it will be used while generating task
*/
public List<EdgeTask> getTaskList() {
return taskList;
}
/*
* fill task list according to related task generation model
*/
public abstract void initializeModel();
}
/*
* Title: EdgeCloudSim - Load Generator Model
*
* Description:
* LoadGeneratorModel is an abstract class which is used for
* deciding task generation pattern via a task list. For those who
* wants to add a custom Load Generator 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.task_generator;
import java.util.List;
import edu.boun.edgecloudsim.utils.EdgeTask;
public abstract class LoadGeneratorModel {
protected List<EdgeTask> taskList;
protected int numberOfMobileDevices;
protected double simulationTime;
protected String simScenario;
public LoadGeneratorModel(int _numberOfMobileDevices, double _simulationTime, String _simScenario){
numberOfMobileDevices=_numberOfMobileDevices;
simulationTime=_simulationTime;
simScenario=_simScenario;
};
/*
* each task has a virtual start time
* it will be used while generating task
*/
public List<EdgeTask> getTaskList() {
return taskList;
}
/*
* fill task list according to related task generation model
*/
public abstract void initializeModel();
/*
* returns the task type (index) that the mobile device uses
*/
public abstract int getTaskTypeOfDevice(int deviceId);
}

71
src/edu/boun/edgecloudsim/utils/EdgeTask.java
View File

@ -1,36 +1,35 @@
/*
* Title: EdgeCloudSim - EdgeTask
*
* Description:
* A custom class used in Load Generator Model to store tasks information
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.utils;
import org.apache.commons.math3.distribution.ExponentialDistribution;
import edu.boun.edgecloudsim.core.SimSettings;
import edu.boun.edgecloudsim.core.SimSettings.APP_TYPES;
public class EdgeTask {
public APP_TYPES taskType;
public double startTime;
public long length, inputFileSize, outputFileSize;
public int pesNumber;
public int mobileDeviceId;
public EdgeTask(int _mobileDeviceId, APP_TYPES _taskType, double _startTime, ExponentialDistribution[][] expRngList) {
mobileDeviceId=_mobileDeviceId;
startTime=_startTime;
taskType=_taskType;
inputFileSize = (long)expRngList[_taskType.ordinal()][0].sample();
outputFileSize =(long)expRngList[_taskType.ordinal()][1].sample();
length = (long)expRngList[_taskType.ordinal()][2].sample();
pesNumber = (int)SimSettings.getInstance().getTaskLookUpTable()[_taskType.ordinal()][8];
}
}
/*
* Title: EdgeCloudSim - EdgeTask
*
* Description:
* A custom class used in Load Generator Model to store tasks information
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.utils;
import org.apache.commons.math3.distribution.ExponentialDistribution;
import edu.boun.edgecloudsim.core.SimSettings;
public class EdgeTask {
public double startTime;
public long length, inputFileSize, outputFileSize;
public int taskType;
public int pesNumber;
public int mobileDeviceId;
public EdgeTask(int _mobileDeviceId, int _taskType, double _startTime, ExponentialDistribution[][] expRngList) {
mobileDeviceId=_mobileDeviceId;
startTime=_startTime;
taskType=_taskType;
inputFileSize = (long)expRngList[_taskType][0].sample();
outputFileSize =(long)expRngList[_taskType][1].sample();
length = (long)expRngList[_taskType][2].sample();
pesNumber = (int)SimSettings.getInstance().getTaskLookUpTable()[_taskType][8];
}
}

108
src/edu/boun/edgecloudsim/utils/Location.java
View File

@ -1,55 +1,53 @@
/*
* Title: EdgeCloudSim - Location
*
* Description: Location class used in EdgeCloudSim
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.utils;
import edu.boun.edgecloudsim.core.SimSettings;
public class Location {
private int xPos;
private int yPos;
private int servingWlanId;
SimSettings.PLACE_TYPES placeType;
public Location(SimSettings.PLACE_TYPES _placeType, int _servingWlanId, int _xPos, int _yPos){
servingWlanId = _servingWlanId;
placeType=_placeType;
xPos = _xPos;
yPos = _yPos;
}
@Override
public boolean equals(Object other){
boolean result = false;
if (other == null) return false;
if (!(other instanceof Location))return false;
if (other == this) return true;
Location otherLocation = (Location)other;
if(this.xPos == otherLocation.xPos && this.yPos == otherLocation.yPos)
result = true;
return result;
}
public int getServingWlanId(){
return servingWlanId;
}
public SimSettings.PLACE_TYPES getPlaceType(){
return placeType;
}
public int getXPos(){
return xPos;
}
public int getYPos(){
return yPos;
}
}
/*
* Title: EdgeCloudSim - Location
*
* Description: Location class used in EdgeCloudSim
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.utils;
public class Location {
private int xPos;
private int yPos;
private int servingWlanId;
private int placeTypeIndex;
public Location(int _placeTypeIndex, int _servingWlanId, int _xPos, int _yPos){
servingWlanId = _servingWlanId;
placeTypeIndex=_placeTypeIndex;
xPos = _xPos;
yPos = _yPos;
}
@Override
public boolean equals(Object other){
boolean result = false;
if (other == null) return false;
if (!(other instanceof Location))return false;
if (other == this) return true;
Location otherLocation = (Location)other;
if(this.xPos == otherLocation.xPos && this.yPos == otherLocation.yPos)
result = true;
return result;
}
public int getServingWlanId(){
return servingWlanId;
}
public int getPlaceTypeIndex(){
return placeTypeIndex;
}
public int getXPos(){
return xPos;
}
public int getYPos(){
return yPos;
}
}

100
src/edu/boun/edgecloudsim/utils/PoissonDistr.java
View File

@ -1,50 +1,50 @@
/*
* Title: EdgeCloudSim - Poisson Distribution
*
* Description: Wrapper class for colt Poisson Distribution
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.utils;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import cern.jet.random.Poisson;
import cern.jet.random.engine.MersenneTwister;
import cern.jet.random.engine.RandomEngine;
public class PoissonDistr {
Poisson poisson;
RandomEngine engine;
/**
* Creates a new exponential number generator.
*
* @param mean the mean for the distribution.
*/
public PoissonDistr(double mean) {
engine = new MersenneTwister(new Date());
poisson = new Poisson(mean, engine);
//always sleep for some milliseconds in order not to have same seed for iterative PoissonDistr contruction
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
SimLogger.printLine("impossible is occured! Poisson random number cannot be created!");
e.printStackTrace();
System.exit(0);
}
}
/**
* Generate a new random number.
*
* @return the next random number in the sequence
*/
public double sample() {
return poisson.nextDouble();
}
}
/*
* Title: EdgeCloudSim - Poisson Distribution
*
* Description: Wrapper class for colt Poisson Distribution
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.utils;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import cern.jet.random.Poisson;
import cern.jet.random.engine.MersenneTwister;
import cern.jet.random.engine.RandomEngine;
public class PoissonDistr {
Poisson poisson;
RandomEngine engine;
/**
* Creates a new exponential number generator.
*
* @param mean the mean for the distribution.
*/
public PoissonDistr(double mean) {
engine = new MersenneTwister(new Date());
poisson = new Poisson(mean, engine);
//always sleep for some milliseconds in order not to have same seed for iterative PoissonDistr contruction
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
SimLogger.printLine("impossible is occured! Poisson random number cannot be created!");
e.printStackTrace();
System.exit(0);
}
}
/**
* Generate a new random number.
*
* @return the next random number in the sequence
*/
public double sample() {
return poisson.nextDouble();
}
}

1492
src/edu/boun/edgecloudsim/utils/SimLogger.java
View File

File diff suppressed because it is too large Load Diff

188
src/edu/boun/edgecloudsim/utils/SimUtils.java
View File

@ -1,103 +1,85 @@
/*
* Title: EdgeCloudSim - Simulation Utils
*
* Description: Utility class providing helper functions
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.utils;
import java.io.File;
import java.util.Date;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import edu.boun.edgecloudsim.core.SimSettings;
public class SimUtils {
public static final Random RNG = new Random(System.currentTimeMillis());
public static int getRandomNumber(int start, int end) {
//return pd.sample();
long range = (long)end - (long)start + 1;
long fraction = (long)(range * RNG.nextDouble());
return (int)(fraction + start);
}
public static double getRandomDoubleNumber(double start, double end) {
//return pd.sample();
double range = end - start;
double fraction = (range * RNG.nextDouble());
return (fraction + start);
}
public static long getRandomLongNumber(int start, int end) {
//return pd.sample();
long range = (long)end - (long)start + 1;
long fraction = (long)(range * RNG.nextDouble());
return (fraction + start);
}
public static void cleanOutputFolder(String outputFolder){
//clean the folder where the result files will be saved
File dir = new File(outputFolder);
if(dir.exists() && dir.isDirectory())
{
for (File f: dir.listFiles())
{
if (f.exists() && f.isFile())
{
if(!f.delete())
{
SimLogger.printLine("file cannot be cleared: " + f.getAbsolutePath());
System.exit(0);
}
}
}
}
else {
SimLogger.printLine("Output folder is not available: " + outputFolder);
System.exit(0);
}
}
public static String getTimeDifference(Date startDate, Date endDate){
String result = "";
long duration = endDate.getTime() - startDate.getTime();
long diffInMilli = TimeUnit.MILLISECONDS.toMillis(duration);
long diffInSeconds = TimeUnit.MILLISECONDS.toSeconds(duration);
long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(duration);
long diffInHours = TimeUnit.MILLISECONDS.toHours(duration);
long diffInDays = TimeUnit.MILLISECONDS.toDays(duration);
if(diffInDays>0)
result += diffInDays + ((diffInDays>1 == true) ? " Days " : " Day ");
if(diffInHours>0)
result += diffInHours % 24 + ((diffInHours>1 == true) ? " Hours " : " Hour ");
if(diffInMinutes>0)
result += diffInMinutes % 60 + ((diffInMinutes>1 == true) ? " Minutes " : " Minute ");
if(diffInSeconds>0)
result += diffInSeconds % 60 + ((diffInSeconds>1 == true) ? " Seconds" : " Second");
if(diffInMilli>0 && result.isEmpty())
result += diffInMilli + ((diffInMilli>1 == true) ? " Milli Seconds" : " Milli Second");
return result;
}
public static SimSettings.PLACE_TYPES stringToPlace(String attractiveness){
SimSettings.PLACE_TYPES placeType = null;
if(attractiveness.equals("1"))
placeType = SimSettings.PLACE_TYPES.ATTRACTIVENESS_L1;
else if(attractiveness.equals("2"))
placeType = SimSettings.PLACE_TYPES.ATTRACTIVENESS_L2;
else if(attractiveness.equals("3"))
placeType = SimSettings.PLACE_TYPES.ATTRACTIVENESS_L3;
else{
SimLogger.printLine("Unknown attractiveness level! Terminating simulation...");
System.exit(0);
}
return placeType;
}
}
/*
* Title: EdgeCloudSim - Simulation Utils
*
* Description: Utility class providing helper functions
*
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
*/
package edu.boun.edgecloudsim.utils;
import java.io.File;
import java.util.Date;
import java.util.Random;
import java.util.concurrent.TimeUnit;
public class SimUtils {
public static final Random RNG = new Random(System.currentTimeMillis());
public static int getRandomNumber(int start, int end) {
//return pd.sample();
long range = (long)end - (long)start + 1;
long fraction = (long)(range * RNG.nextDouble());
return (int)(fraction + start);
}
public static double getRandomDoubleNumber(double start, double end) {
//return pd.sample();
double range = end - start;
double fraction = (range * RNG.nextDouble());
return (fraction + start);
}
public static long getRandomLongNumber(int start, int end) {
//return pd.sample();
long range = (long)end - (long)start + 1;
long fraction = (long)(range * RNG.nextDouble());
return (fraction + start);
}
public static void cleanOutputFolder(String outputFolder){
//clean the folder where the result files will be saved
File dir = new File(outputFolder);
if(dir.exists() && dir.isDirectory())
{
for (File f: dir.listFiles())
{
if (f.exists() && f.isFile())
{
if(!f.delete())
{
SimLogger.printLine("file cannot be cleared: " + f.getAbsolutePath());
System.exit(0);
}
}
}
}
else {
SimLogger.printLine("Output folder is not available: " + outputFolder);
System.exit(0);
}
}
public static String getTimeDifference(Date startDate, Date endDate){
String result = "";
long duration = endDate.getTime() - startDate.getTime();
long diffInMilli = TimeUnit.MILLISECONDS.toMillis(duration);
long diffInSeconds = TimeUnit.MILLISECONDS.toSeconds(duration);
long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(duration);
long diffInHours = TimeUnit.MILLISECONDS.toHours(duration);
long diffInDays = TimeUnit.MILLISECONDS.toDays(duration);
if(diffInDays>0)
result += diffInDays + ((diffInDays>1 == true) ? " Days " : " Day ");
if(diffInHours>0)
result += diffInHours % 24 + ((diffInHours>1 == true) ? " Hours " : " Hour ");
if(diffInMinutes>0)
result += diffInMinutes % 60 + ((diffInMinutes>1 == true) ? " Minutes " : " Minute ");
if(diffInSeconds>0)
result += diffInSeconds % 60 + ((diffInSeconds>1 == true) ? " Seconds" : " Second");
if(diffInMilli>0 && result.isEmpty())
result += diffInMilli + ((diffInMilli>1 == true) ? " Milli Seconds" : " Milli Second");
return result;
}
}