Condition for Create Application Scheduling in IFogSim
Description: Application scheduling in iFogSim involves determining the placement of application modules across available computational resources, including fog nodes, edge devices, and cloud servers, to optimize performance metrics like latency, energy consumption, or network utilization. The process considers factors such as module dependencies, computational requirements, resource capacities, and communication delays between nodes. Scheduling strategies range from static approaches, where module placement remains fixed, to dynamic approaches, which adapt to changing workloads or resource availability. iFogSim supports implementing custom scheduling algorithms, allowing simulation and analysis of various strategies tailored to specific use cases, such as real-time processing or energy-efficient operations.
Sample Code
Main.java:
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package rapid;
static List fogDevices = new ArrayList();
static List sensors = new ArrayList();
static List actuators = new ArrayList();
static int numOfFogColony;
static int numOfFogCell;
static int numOfNode_S;
static int numOfNode_M;
static int numOfWearable;
static int numOfHealthCenter;
private static boolean CLOUD = true;
public Main(int fogclny, int fogcl, int fognod, int wear, int hcenter) {
setFogColony(fogclny);
setFogCell(fogcl);
setFogNodeStatic(fognod / 2);
setFogNodeMobile(fognod / 2);
setWearable(wear);
setActuator(hcenter);
}
public void process() {
Log.printLine("RAPID Starting of IABO...");
try {
Log.disable();
int num_user = 1; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events
CloudSim.init(num_user, calendar, trace_flag);
String appId = "rapid"; // identifier of the application
} else if (device.getName().startsWith("isp-GW")) {
moduleMapping.addModuleToDevice("isp_transport", device.getName());
}
}
if (CLOUD) {
// if the mode of deployment is cloud-based
moduleMapping.addModuleToDevice("patient_tracker_dw", "cloud");
moduleMapping.addModuleToDevice("patient_tracker_uw", "cloud");
moduleMapping.addModuleToDevice("healthcare_analyser", "cloud"); // placing all instances of Object Detector module in the Cloud
}
rapidcontroller = new RapidController("master-controller", fogDevices, sensors,
actuators);
rapidcontroller.submitApplication(application,
(CLOUD) ? (new ModulePlacementMapping(fogDevices, application, moduleMapping))
: (new RapidModulePlacement(fogDevices, sensors, actuators, application, moduleMapping)));
TimeKeeper.getInstance().setSimulationStartTime(Calendar.getInstance().getTimeInMillis());
/**
* Function to create the Health care wearable application in the DDF model.
*
* @param appId unique identifier of the application
* @param userId identifier of the user of the application
* @return Application model
*/
@SuppressWarnings({"serial"})
private Application createApplication1(String appId, int userId) {
Application application1 = Application.createApplication(appId, userId);
/*
* Adding modules (vertices) to the application model (directed graph)
*/
application1.addAppModule("stream_receiver", 100); // iot
application1.addAppModule("health_data_receiver", 100); //fm
application1.addAppModule("isp_transport", 100); //isp
/*
* Defining the input-output relationships (represented by selectivity) of the application modules.
*/
application1.addTupleMapping("stream_receiver", "WEARABLE", "STREAM_DATA", new FractionalSelectivity(1.0));
application1.addTupleMapping("health_data_receiver", "STREAM_DATA", "HEALTH_SENSED_DATA", new FractionalSelectivity(0.5));
application1.addTupleMapping("health_data_receiver", "STREAM_DATA", "DATA_REQUEST", new FractionalSelectivity(0.5));
application1.addTupleMapping("request_receiver", "HEALTH_SENSED_DATA", "HEALTH_SENSED_DATA", new FractionalSelectivity(1.0));
application1.addTupleMapping("healthcare_analyser", "HEALTH_SENSED_DATA", "HEALTH_REPORT", new FractionalSelectivity(1.0));
application1.addTupleMapping("isp_transport", "DATA_REQUEST", "SEND_REQUEST", new FractionalSelectivity(1.0));
application1.addTupleMapping("health_caretaker", "SEND_REQUEST", "REPLY_DATA", new FractionalSelectivity(1.0));
application1.addTupleMapping("isp_transport", "REPLY_DATA", "UNIVERSAL_DATA", new FractionalSelectivity(1.0));
application1.addTupleMapping("report_analyser", "UNIVERSAL_DATA", "PATIENT_REPORT", new FractionalSelectivity(0.5));
application1.addTupleMapping("report_analyser", "HEALTH_REPORT", "PATIENT_REPORT", new FractionalSelectivity(0.5));
application1.addTupleMapping("patient_tracker_dw", "PATIENT_REPORT", "PATIENT_PRESENCE", new FractionalSelectivity(1.0));
application1.addTupleMapping("patient_tracker_uw", "PATIENT_PRESENCE", "PATIENT_REACH", new FractionalSelectivity(1.0));
application1.addTupleMapping("nomad_tracker", "PATIENT_REACH", "PATIENT_STATUS", new FractionalSelectivity(0.5));
application1.addTupleMapping("alert_center", "PATIENT_STATUS", "PATIENT_HEALTH_LOCATION", new FractionalSelectivity(1.0));
/*
* Connecting the application modules (vertices) in the application model (directed graph) with edges
*/
//sensor from wearable
application1.addAppEdge("WEARABLE", "stream_receiver", 1000, 2000, "WEARABLE", Tuple.UP, AppEdge.SENSOR);
//from iot-gateway
application1.addAppEdge("stream_receiver", "health_data_receiver", 100, 20000, "STREAM_DATA", Tuple.UP, AppEdge.MODULE);
//from fm to fog node and cloud
application1.addAppEdge("health_data_receiver", "request_receiver", 1000, 20000, "HEALTH_SENSED_DATA", Tuple.DOWN, AppEdge.MODULE); // DOWN to fog nodes
application1.addAppEdge("request_receiver", "healthcare_analyser", 1000, 20000, "HEALTH_SENSED_DATA", Tuple.DOWN, AppEdge.MODULE); // DOWN to fog nodes
//fm to isp
application1.addAppEdge("health_data_receiver", "isp_transport", 100, 20000, "DATA_REQUEST", Tuple.UP, AppEdge.MODULE);
//isp to hct
application1.addAppEdge("isp_transport", "health_caretaker", 100, 20000, "SEND_REQUEST", Tuple.DOWN, AppEdge.MODULE); // down
//hct to isp
application1.addAppEdge("health_caretaker", "isp_transport", 1000, 20000, "REPLY_DATA", Tuple.UP, AppEdge.MODULE); // up
//isp to fm
application1.addAppEdge("isp_transport", "report_analyser", 1000, 20000, "UNIVERSAL_DATA", Tuple.DOWN, AppEdge.MODULE); //
// fm to fm
//from fog node and cloud to fm
application1.addAppEdge("healthcare_analyser", "report_analyser", 500, 20000, "HEALTH_REPORT", Tuple.UP, AppEdge.MODULE); // UP from fog node
//fm to fc
application1.addAppEdge("report_analyser", "patient_tracker_dw", 1000, 1000, "PATIENT_REPORT", Tuple.DOWN, AppEdge.MODULE); //
//patient identification fc to iot
application1.addAppEdge("patient_tracker_dw", "patient_tracker_uw", 1000, 1000, "PATIENT_PRESENCE", Tuple.UP, AppEdge.MODULE); //
// iot to fc
application1.addAppEdge("patient_tracker_uw", "nomad_tracker", 1000, 1000, "PATIENT_REACH", Tuple.UP, AppEdge.MODULE); //
//fm to fc
application1.addAppEdge("nomad_tracker", "alert_center", 1000, 1000, "PATIENT_STATUS", Tuple.DOWN, AppEdge.MODULE); //
//fc to iot
//iot to actuator
application1.addAppEdge("alert_center", "HEALTHCENTER", 1000, 500, "PATIENT_HEALTH_LOCATION", Tuple.DOWN, AppEdge.ACTUATOR);
/*
* Defining application loops (maybe incomplete loops) to monitor the latency of.
* Here, we add two loops for monitoring : Motion Detector -> Object Detector -> Object Tracker and Object Tracker -> PTZ Control
*/
final AppLoop loop1 = new AppLoop(new ArrayList() {
{
add("WEARABLE");
add("stream_receiver");
add("health_data_receiver");
add("isp_transport");
add("health_caretaker");
add("isp_transport");
add("report_analyser");
}
});
final AppLoop loop2 = new AppLoop(new ArrayList() {
{
add("health_data_receiver");
add("request_receiver");
add("healthcare_analyser");
add("report_analyser");
add("patient_tracker_dw");
add("patient_tracker_uw");
add("nomad_tracker");
add("alert_center");
}
});
final AppLoop loop3 = new AppLoop(new ArrayList() {
{
add("alert_center");
add("HEALTHCENTER");
}
});
List loops = new ArrayList() {
{
add(loop1);
add(loop2);
add(loop3);
}
};
application1.setLoops(loops);
return application1;
/**
* Creates a vanilla fog device
*
* @param nodeName name of the device to be used in simulation
* @param mips MIPS
* @param ram RAM
* @param upBw uplink bandwidth
* @param downBw downlink bandwidth
* @param level hierarchy level of the device
* @param ratePerMips cost rate per MIPS used
* @param busyPower
* @param idlePower
* @return
*/
private FogDevice createFogDevice(String nodeName, long mips,
int ram, long upBw, long downBw, int level, double ratePerMips, double busyPower, double idlePower) {
List peList = new ArrayList();
// 3. Create PEs and add these into a list.
peList.add(new Pe(0, new PeProvisionerOverbooking(mips))); // need to store Pe id and MIPS Rating
int hostId = FogUtils.generateEntityId();
long storage = 1000000; // host storage
int bw = 10000;
PowerHost host = new PowerHost(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerOverbooking(bw),
storage,
peList,
new StreamOperatorScheduler(peList),
new FogLinearPowerModel(busyPower, idlePower)
);
List hostList = new ArrayList();
hostList.add(host);
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource located
double cost = 3.0; // the cost of using processing in this resource
double costPerMem = 0.05; // the cost of using memory in this resource
double costPerStorage = 0.001; // the cost of using storage in this
// resource
double costPerBw = 0.0; // the cost of using bw in this resource
LinkedList storageList = new LinkedList(); // we are not adding SAN
// devices by now
private FogManager createFogManager(String nodeName, long mips,
int ram, long upBw, long downBw, int level, double ratePerMips, double busyPower, double idlePower) {
List peList = new ArrayList();
// 3. Create PEs and add these into a list.
peList.add(new Pe(0, new PeProvisionerOverbooking(mips))); // need to store Pe id and MIPS Rating
int hostId = FogUtils.generateEntityId();
long storage = 1000000; // host storage
int bw = 10000;
PowerHost host = new PowerHost(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerOverbooking(bw),
storage,
peList,
new StreamOperatorScheduler(peList),
new FogLinearPowerModel(busyPower, idlePower)
);
List hostList = new ArrayList();
hostList.add(host);
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource located
double cost = 3.0; // the cost of using processing in this resource
double costPerMem = 0.05; // the cost of using memory in this resource
double costPerStorage = 0.001; // the cost of using storage in this
// resource
double costPerBw = 0.0; // the cost of using bw in this resource
LinkedList storageList = new LinkedList(); // we are not adding SAN
// devices by now
private FogCell createFogCell(String nodeName, long mips,
int ram, long upBw, long downBw, int level, double ratePerMips, double busyPower, double idlePower) {
List peList = new ArrayList();
// 3. Create PEs and add these into a list.
peList.add(new Pe(0, new PeProvisionerOverbooking(mips))); // need to store Pe id and MIPS Rating
int hostId = FogUtils.generateEntityId();
long storage = 1000000; // host storage
int bw = 10000;
PowerHost host = new PowerHost(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerOverbooking(bw),
storage,
peList,
new StreamOperatorScheduler(peList),
new FogLinearPowerModel(busyPower, idlePower)
);
List hostList = new ArrayList();
hostList.add(host);
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource located
double cost = 3.0; // the cost of using processing in this resource
double costPerMem = 0.05; // the cost of using memory in this resource
double costPerStorage = 0.001; // the cost of using storage in this
// resource
double costPerBw = 0.0; // the cost of using bw in this resource
LinkedList storageList = new LinkedList(); // we are not adding SAN
// devices by now
fogdevice.setLevel(level);
return fogdevice;
private FogNodeS createFogNodes(String nodeName, long mips,
int ram, long upBw, long downBw, int level, double ratePerMips, double busyPower, double idlePower) {
List peList = new ArrayList();
// 3. Create PEs and add these into a list.
peList.add(new Pe(0, new PeProvisionerOverbooking(mips))); // need to store Pe id and MIPS Rating
int hostId = FogUtils.generateEntityId();
long storage = 1000000; // host storage
int bw = 10000;
PowerHost host = new PowerHost(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerOverbooking(bw),
storage,
peList,
new StreamOperatorScheduler(peList),
new FogLinearPowerModel(busyPower, idlePower)
);
List hostList = new ArrayList();
hostList.add(host);
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource located
double cost = 3.0; // the cost of using processing in this resource
double costPerMem = 0.05; // the cost of using memory in this resource
double costPerStorage = 0.001; // the cost of using storage in this
// resource
double costPerBw = 0.0; // the cost of using bw in this resource
LinkedList storageList = new LinkedList(); // we are not adding SAN
// devices by now
FogDeviceCharacteristics characteristics = new FogDeviceCharacteristics(
arch, os, vmm, host, time_zone, cost, costPerMem,
costPerStorage, costPerBw
);
FogNodeS fogdevice = null;
try {
fogdevice = new FogNodeS(nodeName, characteristics,
new AppModuleAllocationPolicy(hostList), storageList, 10, upBw, downBw, 0, ratePerMips);
} catch (Exception e) {
e.printStackTrace();
}
fogdevice.setLevel(level);
return fogdevice;
}
/**
* Creates the fog devices in the physical topology of the simulation.
*
* @param userId
* @param appId
*/
private void createFogDevices(int userId, String appId) {
FogDevice cloud = createFogDevice("cloud", 44800, 40000, 100, 10000, 0, 0.01, 16 * 103, 16 * 83.25);
cloud.setParentId(-1);
fogDevices.add(cloud);
FogDevice gateway = createFogDevice("isp-GW", 2800, 4000, 10000, 10000, 1, 0.0, 107.339, 83.4333);
gateway.setParentId(cloud.getId());
gateway.setUplinkLatency(100); // latency of connection between proxy server and cloud is 100 ms
fogDevices.add(gateway);
FogDevice careTaker = createFogDevice("hlth-care", 2800, 4000, 100, 10000, 2, 0.0, 107.339, 83.43333);
careTaker.setParentId(gateway.getId());
careTaker.setUplinkLatency(15);
fogDevices.add(careTaker);
for (int i = 0; i < getFogColony(); i++) {
addFogColony(i + "", userId, appId, gateway.getId());
}
}
private FogManager addFogColony(String id, int userId, String appId, int parentId) {
FogManager fogManager = createFogManager("fm-" + id, 22400, 32000, 10000, 10000, 2, 0.0, 107.339 * 10, 83.4333 * 10);
fogDevices.add(fogManager);
fogManager.setUplinkLatency(2); // latency of connection between router and proxy server is 2 ms
List listofcells = new ArrayList();
for (int i = 0; i < getFogCell(); i++) {
String fogcellId = id + "-" + i;
FogCell fogcell = addFogCell(fogcellId, userId, appId, fogManager.getId());
listofcells.add(new Cells(fogcell.getName(), fogcell));
}
fogManager.setFogCells(listofcells);
fogManager.setParentId(parentId);
return fogManager;
}
private FogCell addFogCell(String id, int userId, String appId, int parentId) {
FogCell fogCell = createFogCell("fc-" + id, 22400, 32000, 10000, 10000, 3, 0.0, 107.339 * 10, 83.4333 * 10);
fogDevices.add(fogCell);
fogCell.setUplinkLatency(2); // latency of connection between fog Cell and Fog Manager is 2 ms
List nodeSlist = new ArrayList();
for (int i = 0; i < getFogNodeStatic(); i++) {
String nodeSId = id + "-" + i;
FogDevice nodeS = addNodeStatic(nodeSId, userId, appId, fogCell.getId());
nodeSlist.add(new Nodes(nodeS.getName(), nodeS));
}
fogCell.setStaticNodes(nodeSlist);
List nodeMlist = new ArrayList();
for (int i = 0; i < getFogNodeMobile(); i++) {
String nodeMId = id + "-" + i;
FogDevice nodeM = addNodeMobile(nodeMId, userId, appId, fogCell.getId());
nodeMlist.add(new Nodes(nodeM.getName(), nodeM));
}
fogCell.setMobileNodes(nodeMlist);
FogDevice iotDevice = addIotDevice(id, userId, appId, fogCell.getId());
fogCell.setIotDevice(new Nodes(iotDevice.getName(), iotDevice));
fogCell.setParentId(parentId);
return fogCell;
}
private FogDevice addNodeStatic(String id, int userId, String appId, int parentId) {
FogDevice nodes = createFogDevice("ns-" + id, 11200, 16000, 10000, 10000, 4, 0.0, 107.339, 83.4333);
fogDevices.add(nodes);
nodes.setUplinkLatency(2); // latency of connection between fog Cell and Fog Nodes is 2 ms
nodes.setParentId(parentId);
return nodes;
}
private FogDevice addNodeMobile(String id, int userId, String appId, int parentId) {
FogDevice nodem = createFogDevice("nm-" + id, 11200, 16000, 10000, 10000, 4, 0.0, 107.339, 83.4333);
fogDevices.add(nodem);
nodem.setUplinkLatency(2); // latency of connection between fog Cell and Fog Nodes is 2 ms
nodem.setParentId(parentId);
return nodem;
}
private FogDevice addIotDevice(String id, int userId, String appId, int parentId) {
FogDevice iotGateway = createFogDevice("iot-gateway" + id, 28000, 40000, 10000, 10000, 4, 0.0, 87.53, 82.44);
// FogDevice iotGateway = createFogDevice("iot-gateway" + id, 500, 1000, 10000, 10000, 4, 0.0, 87.53, 82.44);
fogDevices.add(iotGateway);
iotGateway.setUplinkLatency(2);
for (int i = 0; i < getWearable(); i++) {
Sensor wearable = new Sensor("w-" + id + "-" + i, "WEARABLE", userId, appId, new DeterministicDistribution(5)); // inter-transmission time of wearable (sensor) follows a deterministic distribution
sensors.add(wearable);
wearable.setGatewayDeviceId(iotGateway.getId());
wearable.setLatency(1.0); // latency of connection between wearable (sensor) and the parent iotGateway is 1 ms
}
for (int j = 0; j < getActuator(); j++) {
Actuator healthcenter = new Actuator("hc-" + id + "-" + j, userId, appId, "HEALTHCENTER");
actuators.add(healthcenter);
healthcenter.setGatewayDeviceId(iotGateway.getId());
healthcenter.setLatency(1.0); // latency of connection between healthcenter and the parent iotGateway is 1 ms
}
iotGateway.setParentId(parentId);
return iotGateway;
}
public static void setFogColony(int fcolony) {
numOfFogColony = fcolony;
}
public static void setFogCell(int fcell) {
numOfFogCell = fcell;
}
public static void setFogNodeStatic(int fnodes) {
numOfNode_S = fnodes;
}
public static void setFogNodeMobile(int fnodem) {
numOfNode_M = fnodem;
}
public static void setWearable(int wearable) {
numOfWearable = wearable;
}
public static void setActuator(int actuator) {
numOfHealthCenter = actuator;
}
public static int getFogColony() {
return numOfFogColony;
}
public static int getFogCell() {
return numOfFogCell;
}
public static int getFogNodeStatic() {
return numOfNode_S;
}
public static int getFogNodeMobile() {
return numOfNode_M;
}
public static int getWearable() {
return numOfWearable;
}
public static int getActuator() {
return numOfHealthCenter;
}
}
FogDevice.java:
protected void updateAllocatedMips(String incomingOperator) {
getHost().getVmScheduler().deallocatePesForAllVms();
for (final Vm vm : getHost().getVmList()) {
if(vm.getCloudletScheduler().runningCloudlets() > 0 || ((AppModule) vm).getName().equals(incomingOperator)) {
getHost().getVmScheduler().allocatePesForVm(vm, new ArrayList() {
protected static final long serialVersionUID = 1L;
{
add((double) getHost().getTotalMips());
}
});
} else {
getHost().getVmScheduler().allocatePesForVm(vm, new ArrayList() {
protected static final long serialVersionUID = 1L;
{
add(0.0);
}
});
}
}
updateEnergyConsumption();
}
private void updateEnergyConsumption() {
double totalMipsAllocated = 0;
for (final Vm vm : getHost().getVmList()) {
AppModule operator = (AppModule) vm;
operator.updateVmProcessing(CloudSim.clock(), getVmAllocationPolicy().getHost(operator).getVmScheduler()
.getAllocatedMipsForVm(operator));
totalMipsAllocated += getHost().getTotalAllocatedMipsForVm(vm);
}
System.out.println("number of vm :" + getHost().getVmList().size() + " on Fogdevice :" + getName());
double timeNow = CloudSim.clock();
double currentEnergyConsumption = getEnergyConsumption();
double newEnergyConsumption = currentEnergyConsumption + (timeNow - lastUtilizationUpdateTime) * getHost().getPowerModel().getPower(lastUtilization);
setEnergyConsumption(newEnergyConsumption);
/*if(getName().equals("d-0")){
System.out.println("------------------------");
System.out.println("Utilization = "+lastUtilization);
System.out.println("Power = "+getHost().getPowerModel().getPower(lastUtilization));
System.out.println(timeNow-lastUtilizationUpdateTime);
}*/
double currentCost = getTotalCost();
double newcost = currentCost + (timeNow - lastUtilizationUpdateTime) * getRatePerMips() * lastUtilization * getHost().getTotalMips();
setTotalCost(newcost);
lastUtilization = Math.min(1, (double) (totalMipsAllocated / (double) getHost().getTotalMips()));
System.out.println("allocated mips for vm :" + totalMipsAllocated + " host total mips :" + getHost().getTotalMips());
System.out.println("Fogdevice name :" + getName() + " Utilization :" + lastUtilization);
lastUtilizationUpdateTime = timeNow;
}
Research breakthrough possible @S-Logix
