The mobile processing unit support as well as a sample application are added.
The mobile processing units are simulated via CloudSim. It is assumed that the mobile devices operate Hosts and VMs like a server. Therefore, the classes located in the mobile_processing_unit package have a similar naming convention to the other Cloud and Edge components.
This commit is contained in:
Cagatay Sonmez
@@ -19,6 +19,8 @@ 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.edge_client.mobile_processing_unit.DefaultMobileServerManager;
|
||||
import edu.boun.edgecloudsim.edge_client.mobile_processing_unit.MobileServerManager;
|
||||
import edu.boun.edgecloudsim.mobility.MobilityModel;
|
||||
import edu.boun.edgecloudsim.mobility.NomadicMobility;
|
||||
import edu.boun.edgecloudsim.task_generator.IdleActiveLoadGenerator;
|
||||
@@ -71,8 +73,14 @@ public class SampleScenarioFactory implements ScenarioFactory {
|
||||
public CloudServerManager getCloudServerManager() {
|
||||
return new DefaultCloudServerManager();
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public MobileDeviceManager getMobileDeviceManager() throws Exception {
|
||||
return new DefaultMobileDeviceManager();
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobileServerManager getMobileServerManager() {
|
||||
return new DefaultMobileServerManager();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,6 +17,8 @@ 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.edge_client.mobile_processing_unit.DefaultMobileServerManager;
|
||||
import edu.boun.edgecloudsim.edge_client.mobile_processing_unit.MobileServerManager;
|
||||
import edu.boun.edgecloudsim.mobility.MobilityModel;
|
||||
import edu.boun.edgecloudsim.mobility.NomadicMobility;
|
||||
import edu.boun.edgecloudsim.task_generator.IdleActiveLoadGenerator;
|
||||
@@ -73,4 +75,9 @@ public class SampleScenarioFactory implements ScenarioFactory {
|
||||
public MobileDeviceManager getMobileDeviceManager() throws Exception {
|
||||
return new SampleMobileDeviceManager();
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobileServerManager getMobileServerManager() {
|
||||
return new DefaultMobileServerManager();
|
||||
}
|
||||
}
|
||||
|
||||
131
src/edu/boun/edgecloudsim/applications/sample_app3/MainApp.java
Normal file
131
src/edu/boun/edgecloudsim/applications/sample_app3/MainApp.java
Normal file
@@ -0,0 +1,131 @@
|
||||
/*
|
||||
* Title: EdgeCloudSim - Main Application
|
||||
*
|
||||
* Description: Main application for Sample App3
|
||||
*
|
||||
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
|
||||
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
|
||||
*/
|
||||
|
||||
package edu.boun.edgecloudsim.applications.sample_app3;
|
||||
|
||||
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_app3/config/default_config.properties";
|
||||
applicationsFile = "scripts/sample_app3/config/applications.xml";
|
||||
edgeDevicesFile = "scripts/sample_app3/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));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
/*
|
||||
* Title: EdgeCloudSim - Edge Orchestrator
|
||||
*
|
||||
* Description:
|
||||
* SampleEdgeOrchestrator offloads tasks to proper server
|
||||
* In this scenario mobile devices can also execute tasks
|
||||
*
|
||||
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
|
||||
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
|
||||
*/
|
||||
|
||||
package edu.boun.edgecloudsim.applications.sample_app3;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.cloudbus.cloudsim.Vm;
|
||||
import org.cloudbus.cloudsim.core.CloudSim;
|
||||
import org.cloudbus.cloudsim.core.SimEvent;
|
||||
|
||||
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.edge_client.mobile_processing_unit.MobileVM;
|
||||
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)
|
||||
*
|
||||
*/
|
||||
@Override
|
||||
public int getDeviceToOffload(Task task) {
|
||||
int result = 0;
|
||||
|
||||
if(policy.equals("ONLY_EDGE")){
|
||||
result = SimSettings.GENERIC_EDGE_DEVICE_ID;
|
||||
}
|
||||
else if(policy.equals("ONLY_MOBILE")){
|
||||
result = SimSettings.MOBILE_DATACENTER_ID;
|
||||
}
|
||||
else if(policy.equals("HYBRID")){
|
||||
List<MobileVM> vmArray = SimManager.getInstance().getMobileServerManager().getVmList(task.getMobileDeviceId());
|
||||
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(0).getVmType());
|
||||
double targetVmCapacity = (double) 100 - vmArray.get(0).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
|
||||
|
||||
if (requiredCapacity <= targetVmCapacity)
|
||||
result = SimSettings.MOBILE_DATACENTER_ID;
|
||||
else
|
||||
result = SimSettings.GENERIC_EDGE_DEVICE_ID;
|
||||
}
|
||||
else {
|
||||
SimLogger.printLine("Unknow edge orchestrator policy! Terminating simulation...");
|
||||
System.exit(0);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Vm getVmToOffload(Task task, int deviceId) {
|
||||
Vm selectedVM = null;
|
||||
|
||||
if (deviceId == SimSettings.MOBILE_DATACENTER_ID) {
|
||||
List<MobileVM> vmArray = SimManager.getInstance().getMobileServerManager().getVmList(task.getMobileDeviceId());
|
||||
double requiredCapacity = ((CpuUtilizationModel_Custom)task.getUtilizationModelCpu()).predictUtilization(vmArray.get(0).getVmType());
|
||||
double targetVmCapacity = (double) 100 - vmArray.get(0).getCloudletScheduler().getTotalUtilizationOfCpu(CloudSim.clock());
|
||||
|
||||
if (requiredCapacity <= targetVmCapacity)
|
||||
selectedVM = vmArray.get(0);
|
||||
}
|
||||
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!
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,299 @@
|
||||
/*
|
||||
* 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
|
||||
* mobile device processing unit.
|
||||
*
|
||||
* 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_app3;
|
||||
|
||||
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.core.SimSettings.VM_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.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 REQUEST_RECEIVED_BY_EDGE_DEVICE = BASE + 1;
|
||||
private static final int REQUEST_RECEIVED_BY_MOBILE_DEVICE = BASE + 2;
|
||||
private static final int RESPONSE_RECEIVED_BY_MOBILE_DEVICE = BASE + 3;
|
||||
|
||||
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();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.GENERIC_EDGE_DEVICE_ID){
|
||||
double delay = networkModel.getDownloadDelay(task.getAssociatedDatacenterId(), 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(task.getSubmittedLocation(), 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);
|
||||
}
|
||||
}
|
||||
else if(task.getAssociatedDatacenterId() == SimSettings.MOBILE_DATACENTER_ID) {
|
||||
SimLogger.getInstance().taskEnded(task.getCloudletId(), CloudSim.clock());
|
||||
|
||||
/*
|
||||
* TODO: In this scenario device to device (D2D) communication is ignored.
|
||||
* If you want to consider D2D communication, you should transmit the result
|
||||
* of the task to the sender mobile device. Hence, you should calculate
|
||||
* D2D_DELAY here and send the following event:
|
||||
*
|
||||
* schedule(getId(), delay, RESPONSE_RECEIVED_BY_MOBILE_DEVICE, task);
|
||||
*
|
||||
* Please not that you should deal with the mobility and D2D delay calculation.
|
||||
* The task can be failed due to the network bandwidth or the nobility.
|
||||
*/
|
||||
}
|
||||
else {
|
||||
SimLogger.printLine("Unknown datacenter id! Terminating simulation...");
|
||||
System.exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
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_MOBILE_DEVICE:
|
||||
{
|
||||
Task task = (Task) ev.getData();
|
||||
submitTaskToVm(task, SimSettings.VM_TYPES.MOBILE_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 RESPONSE_RECEIVED_BY_MOBILE_DEVICE:
|
||||
{
|
||||
Task task = (Task) ev.getData();
|
||||
|
||||
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) {
|
||||
double delay = 0;
|
||||
int nextEvent = 0;
|
||||
int nextDeviceForNetworkModel = 0;
|
||||
VM_TYPES vmType = null;
|
||||
NETWORK_DELAY_TYPES delayType = null;
|
||||
|
||||
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.GENERIC_EDGE_DEVICE_ID){
|
||||
delay = networkModel.getUploadDelay(task.getMobileDeviceId(), nextHopId, task);
|
||||
vmType = SimSettings.VM_TYPES.EDGE_VM;
|
||||
nextEvent = REQUEST_RECEIVED_BY_EDGE_DEVICE;
|
||||
delayType = NETWORK_DELAY_TYPES.WLAN_DELAY;
|
||||
nextDeviceForNetworkModel = SimSettings.GENERIC_EDGE_DEVICE_ID;
|
||||
}
|
||||
else if(nextHopId == SimSettings.MOBILE_DATACENTER_ID){
|
||||
vmType = VM_TYPES.MOBILE_VM;
|
||||
nextEvent = REQUEST_RECEIVED_BY_MOBILE_DEVICE;
|
||||
|
||||
/*
|
||||
* TODO: In this scenario device to device (D2D) communication is ignored.
|
||||
* If you want to consider D2D communication, you should calculate D2D
|
||||
* network delay here.
|
||||
*
|
||||
* You should also add D2D_DELAY to the following enum in SimSettings
|
||||
* public static enum NETWORK_DELAY_TYPES { WLAN_DELAY, MAN_DELAY, WAN_DELAY }
|
||||
*
|
||||
* If you want to get statistics of the D2D networking, you should modify
|
||||
* SimLogger in a way to consider D2D_DELAY statistics.
|
||||
*/
|
||||
}
|
||||
else {
|
||||
SimLogger.printLine("Unknown nextHopId! Terminating simulation...");
|
||||
System.exit(0);
|
||||
}
|
||||
|
||||
if(delay>0 || nextHopId == SimSettings.MOBILE_DATACENTER_ID){
|
||||
|
||||
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());
|
||||
|
||||
SimLogger.getInstance().taskStarted(task.getCloudletId(), CloudSim.clock());
|
||||
|
||||
if(nextHopId != SimSettings.MOBILE_DATACENTER_ID) {
|
||||
networkModel.uploadStarted(task.getSubmittedLocation(), nextDeviceForNetworkModel);
|
||||
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.ordinal());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//SimLogger.printLine("Task #" + task.getCloudletId() + " cannot assign to any VM");
|
||||
SimLogger.getInstance().rejectedDueToBandwidth(task.getCloudletId(), CloudSim.clock(), vmType.ordinal(), 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;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,184 @@
|
||||
/*
|
||||
* Title: EdgeCloudSim - Mobile Server Manager
|
||||
*
|
||||
* Description:
|
||||
* VehicularDefaultMobileServerManager is responsible for creating
|
||||
* mobile datacenters, hosts and VMs.
|
||||
*
|
||||
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
|
||||
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
|
||||
*/
|
||||
|
||||
package edu.boun.edgecloudsim.applications.sample_app3;
|
||||
|
||||
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;
|
||||
import edu.boun.edgecloudsim.edge_client.mobile_processing_unit.MobileHost;
|
||||
import edu.boun.edgecloudsim.edge_client.mobile_processing_unit.MobileServerManager;
|
||||
import edu.boun.edgecloudsim.edge_client.mobile_processing_unit.MobileVM;
|
||||
import edu.boun.edgecloudsim.edge_client.mobile_processing_unit.MobileVmAllocationPolicy_Custom;
|
||||
|
||||
public class SampleMobileServerManager extends MobileServerManager{
|
||||
private int numOfMobileDevices=0;
|
||||
|
||||
public SampleMobileServerManager(int _numOfMobileDevices) {
|
||||
numOfMobileDevices=_numOfMobileDevices;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initialize() {
|
||||
}
|
||||
|
||||
@Override
|
||||
public VmAllocationPolicy getVmAllocationPolicy(List<? extends Host> list, int dataCenterIndex) {
|
||||
return new MobileVmAllocationPolicy_Custom(list, dataCenterIndex);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void startDatacenters() throws Exception {
|
||||
//in the initial version, each mobile device has a separate datacenter
|
||||
//however, this approach encounters with out of memory (oom) problem.
|
||||
//therefore, we use single datacenter for all mobile devices!
|
||||
localDatacenter = createDatacenter(SimSettings.MOBILE_DATACENTER_ID);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void terminateDatacenters() {
|
||||
localDatacenter.shutdownEntity();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void createVmList(int brockerId) {
|
||||
//VMs should have unique IDs, so create Mobile VMs after Edge+Cloud VMs
|
||||
int vmCounter=SimSettings.getInstance().getNumOfEdgeVMs() + SimSettings.getInstance().getNumOfCloudVMs();
|
||||
|
||||
//Create VMs for each hosts
|
||||
//Note that each mobile device has one host with one VM!
|
||||
for (int i = 0; i < numOfMobileDevices; i++) {
|
||||
vmList.add(i, new ArrayList<MobileVM>());
|
||||
|
||||
String vmm = "Xen";
|
||||
int numOfCores = SimSettings.getInstance().getCoreForMobileVM();
|
||||
double mips = SimSettings.getInstance().getMipsForMobileVM();
|
||||
int ram = SimSettings.getInstance().getRamForMobileVM();
|
||||
long storage = SimSettings.getInstance().getStorageForMobileVM();
|
||||
long bandwidth = 0;
|
||||
|
||||
//VM Parameters
|
||||
MobileVM vm = new MobileVM(vmCounter, brockerId, mips, numOfCores, ram, bandwidth, storage, vmm, new CloudletSchedulerTimeShared());
|
||||
vmList.get(i).add(vm);
|
||||
vmCounter++;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
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<MobileVM> vmArray = SimManager.getInstance().getMobileServerManager().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<MobileHost> hostList=createHosts();
|
||||
|
||||
String name = "MobileDatacenter_" + 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<MobileHost> createHosts(){
|
||||
// Here are the steps needed to create a PowerDatacenter:
|
||||
// 1. We need to create a list to store one or more Machines
|
||||
List<MobileHost> hostList = new ArrayList<MobileHost>();
|
||||
|
||||
for (int i = 0; i < numOfMobileDevices; i++) {
|
||||
|
||||
int numOfCores = SimSettings.getInstance().getCoreForMobileVM();
|
||||
double mips = SimSettings.getInstance().getMipsForMobileVM();
|
||||
int ram = SimSettings.getInstance().getRamForMobileVM();
|
||||
long storage = SimSettings.getInstance().getStorageForMobileVM();
|
||||
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
|
||||
MobileHost host = new MobileHost(
|
||||
//Hosts should have unique IDs, so create Mobile Hosts after Edge+Cloud Hosts
|
||||
i+SimSettings.getInstance().getNumOfEdgeHosts()+SimSettings.getInstance().getNumOfCoudHost(),
|
||||
new RamProvisionerSimple(ram),
|
||||
new BwProvisionerSimple(bandwidth), //kbps
|
||||
storage,
|
||||
peList,
|
||||
new VmSchedulerSpaceShared(peList)
|
||||
);
|
||||
|
||||
host.setMobileDeviceId(i);
|
||||
hostList.add(host);
|
||||
}
|
||||
|
||||
return hostList;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,243 @@
|
||||
/*
|
||||
* Title: EdgeCloudSim - Network Model
|
||||
*
|
||||
* Description:
|
||||
* SampleNetworkModel uses
|
||||
* the result of an empirical study for the WLAN delay
|
||||
* The experimental network model is developed
|
||||
* by taking measurements from the real life deployments.
|
||||
*
|
||||
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
|
||||
* Copyright (c) 2017, Bogazici University, Istanbul, Turkey
|
||||
*/
|
||||
|
||||
package edu.boun.edgecloudsim.applications.sample_app3;
|
||||
|
||||
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 {
|
||||
private int[] wlanClients;
|
||||
|
||||
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 SampleNetworkModel(int _numberOfMobileDevices, String _simScenario) {
|
||||
super(_numberOfMobileDevices, _simScenario);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initialize() {
|
||||
wlanClients = new int[SimSettings.getInstance().getNumOfEdgeDatacenters()]; //we have one access point for each datacenter
|
||||
}
|
||||
|
||||
/**
|
||||
* source device is always mobile device in our simulation scenarios!
|
||||
*/
|
||||
@Override
|
||||
public double getUploadDelay(int sourceDeviceId, int destDeviceId, Task task) {
|
||||
double delay = 0;
|
||||
|
||||
//mobile device to edge device (wifi access point)
|
||||
if (destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID) {
|
||||
delay = getWlanUploadDelay(task.getSubmittedLocation(), task.getCloudletFileSize());
|
||||
}
|
||||
else {
|
||||
SimLogger.printLine("Error - unknown device id in getUploadDelay(). Terminating simulation...");
|
||||
System.exit(0);
|
||||
}
|
||||
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;
|
||||
|
||||
Location accessPointLocation = SimManager.getInstance().getMobilityModel().getLocation(destDeviceId,CloudSim.clock());
|
||||
|
||||
//edge device (wifi access point) to mobile device
|
||||
if (sourceDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID) {
|
||||
delay = getWlanDownloadDelay(accessPointLocation, task.getCloudletOutputSize());
|
||||
}
|
||||
else {
|
||||
SimLogger.printLine("Error - unknown device id in getDownloadDelay(). Terminating simulation...");
|
||||
System.exit(0);
|
||||
}
|
||||
|
||||
return delay;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void uploadStarted(Location accessPointLocation, int destDeviceId) {
|
||||
if (destDeviceId == SimSettings.GENERIC_EDGE_DEVICE_ID) {
|
||||
wlanClients[accessPointLocation.getServingWlanId()]++;
|
||||
}
|
||||
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.GENERIC_EDGE_DEVICE_ID) {
|
||||
wlanClients[accessPointLocation.getServingWlanId()]--;
|
||||
}
|
||||
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.GENERIC_EDGE_DEVICE_ID) {
|
||||
wlanClients[accessPointLocation.getServingWlanId()]++;
|
||||
}
|
||||
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.GENERIC_EDGE_DEVICE_ID) {
|
||||
wlanClients[accessPointLocation.getServingWlanId()]--;
|
||||
}
|
||||
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 < 0)
|
||||
System.out.println("--> ");
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
/*
|
||||
* 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_app3;
|
||||
|
||||
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.edge_client.mobile_processing_unit.MobileServerManager;
|
||||
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();
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobileServerManager getMobileServerManager() {
|
||||
return new SampleMobileServerManager(numOfMobileDevice);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user