How to Calculate the Fitness Function and Waiting Time in IFogSim?
Share
Condition for Calculate the Fitness Function and Waiting Time in IFogSim
Description: In iFogSim, the fitness function is used in optimization algorithms to assess how well a solution meets objectives like minimizing energy consumption, reducing task completion time, or balancing resource usage. It is calculated by evaluating performance metrics such as energy consumption, task execution time, and the number of tasks offloaded to the cloud. These metrics are combined using a weighted sum or other methods, with the fitness value guiding the optimization process. Lower or higher fitness values indicate better or worse solutions based on the defined goals. In iFogSim, waiting time refers to the duration a task spends in the queue before execution, often due to resource contention. It is calculated by measuring the time from when a task is ready to execute until it starts, considering factors like system load, task priority, and resource allocation. Optimizing waiting time can reduce delays and improve task execution efficiency.
Sample Code
FitnessFunction.java:
package fogsamples;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.SimEvent;
import org.cloudbus.cloudsim.power.PowerHost;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;
import org.cloudbus.cloudsim.sdn.overbooking.BwProvisionerOverbooking;
import org.cloudbus.cloudsim.sdn.overbooking.PeProvisionerOverbooking;
import org.fog.application.AppEdge;
import org.fog.application.AppLoop;
import org.fog.application.Application;
import org.fog.application.selectivity.FractionalSelectivity;
import org.fog.entities.Actuator;
import org.fog.entities.FogBroker;
import org.fog.entities.FogDevice;
import org.fog.entities.FogDeviceCharacteristics;
import org.fog.entities.Sensor;
import org.fog.entities.Tuple;
import org.fog.placement.Controller;
import org.fog.placement.ModuleMapping;
import org.fog.placement.ModulePlacementEdgewards;
import org.fog.placement.ModulePlacementMapping;
import org.fog.policy.AppModuleAllocationPolicy;
import org.fog.scheduler.StreamOperatorScheduler;
import org.fog.utils.Config;
import org.fog.utils.FogLinearPowerModel;
import org.fog.utils.FogUtils;
import org.fog.utils.NetworkUsageMonitor;
import org.fog.utils.TimeKeeper;
import org.fog.utils.distribution.DeterministicDistribution;
public class FitnessFunction {
static List fogDevices = new ArrayList();
static List sensors = new ArrayList();
static List actuators = new ArrayList();
static int numOfAreas = 1;
static int numOfCamerasPerArea = 4;
private static boolean CLOUD = true;
public static void main(String[] args) {
Log.printLine("Starting FitnessFunction usage...");
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 = "dcns"; // identifier of the application
FogBroker broker = new FogBroker("broker");
Application application = createApplication(appId, broker.getId());
application.setUserId(broker.getId());
createFogDevices(broker.getId(), appId);
Controller controller = null;
ModuleMapping moduleMapping = ModuleMapping.createModuleMapping(); // initializing a module mapping
for (FogDevice device : fogDevices) {
if (device.getName().startsWith("m")) { // names of all Smart Cameras start with 'm'
moduleMapping.addModuleToDevice("motion_detector", "cloud"); // fixing 1 instance of the Motion Detector module to each Smart Camera
}
}
moduleMapping.addModuleToDevice("user_interface", "cloud"); // fixing instances of User Interface module in the Cloud
if (CLOUD) {
// if the mode of deployment is cloud-based
moduleMapping.addModuleToDevice("object_detector", "cloud"); // placing all instances of Object Detector module in the Cloud
moduleMapping.addModuleToDevice("object_tracker", "cloud"); // placing all instances of Object Tracker module in the Cloud
moduleMapping.addModuleToDevice("motion_detector", "cloud");
}
controller = new Controller("master-controller", fogDevices, sensors,
actuators);
controller.submitApplication(application,
(CLOUD) ? (new ModulePlacementMapping(fogDevices, application, moduleMapping))
: (new ModulePlacementEdgewards(fogDevices, sensors, actuators, application, moduleMapping)));
TimeKeeper.getInstance().setSimulationStartTime(Calendar.getInstance().getTimeInMillis());
CloudSim.startSimulation();
CloudSim.stopSimulation();
Log.printLine("VRGame finished!");
} catch (Exception e) {
e.printStackTrace();
Log.printLine("Unwanted errors happen");
}
}
protected void processTupleArrival(SimEvent ev) {
// You can add more conditions and custom processing for different tuple types here.
}
/**
* Creates the fog devices in the physical topology of the simulation.
*
* @param userId
* @param appId
*/
private static 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 proxy = createFogDevice("proxy-server", 2800, 4000, 10000, 10000, 1, 0.0, 107.339, 83.4333);
proxy.setParentId(cloud.getId());
proxy.setUplinkLatency(100); // latency of connection between proxy server and cloud is 100 ms
fogDevices.add(proxy);
for (int i = 0; i < numOfAreas; i++) {
addArea(i + "", userId, appId, proxy.getId());
}
}
private static FogDevice addArea(String id, int userId, String appId, int parentId) {
FogDevice router = createFogDevice("d-" + id, 2800, 4000, 10000, 10000, 1, 0.0, 107.339, 83.4333);
fogDevices.add(router);
router.setUplinkLatency(2); // latency of connection between router and proxy server is 2 ms
for (int i = 0; i < numOfCamerasPerArea; i++) {
String mobileId = id + "-" + i;
FogDevice camera = addCamera(mobileId, userId, appId, router.getId()); // adding a smart camera to the physical topology. Smart cameras have been modeled as fog devices as well.
camera.setUplinkLatency(2); // latency of connection between camera and router is 2 ms
fogDevices.add(camera);
}
router.setParentId(parentId);
return router;
}
private static FogDevice addCamera(String id, int userId, String appId, int parentId) {
FogDevice camera = createFogDevice("m-" + id, 500, 1000, 10000, 10000, 3, 0, 87.53, 82.44);
camera.setParentId(parentId);
Sensor sensor = new Sensor("s-" + id, "CAMERA", userId, appId, new DeterministicDistribution(5)); // inter-transmission time of camera (sensor) follows a deterministic distribution
sensors.add(sensor);
Actuator ptz = new Actuator("ptz-" + id, userId, appId, "PTZ_CONTROL");
actuators.add(ptz);
sensor.setGatewayDeviceId(camera.getId());
sensor.setLatency(1.0); // latency of connection between camera (sensor) and the parent Smart Camera is 1 ms
ptz.setGatewayDeviceId(camera.getId());
ptz.setLatency(1.0); // latency of connection between PTZ Control and the parent Smart Camera is 1 ms
return camera;
}
/**
* 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 static 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
FogDeviceCharacteristics characteristics = new FogDeviceCharacteristics(
arch, os, vmm, host, time_zone, cost, costPerMem,
costPerStorage, costPerBw);
FogDevice fogdevice = null;
try {
fogdevice = new FogDevice(nodeName, characteristics,
new AppModuleAllocationPolicy(hostList), storageList, 10, upBw, downBw, 0, ratePerMips);
} catch (Exception e) {
e.printStackTrace();
}
fogdevice.setLevel(level);
return fogdevice;
}
/**
* Function to create the Intelligent Surveillance application in the DDF
* model.
*
* @param appId unique identifier of the application
* @param userId identifier of the user of the application
* @return
*/
@SuppressWarnings({"serial"})
private static Application createApplication(String appId, int userId) {
Application application = Application.createApplication(appId, userId);
/*
* Adding modules (vertices) to the application model (directed graph)
*/
application.addAppModule("object_detector", 10);
application.addAppModule("motion_detector", 10);
application.addAppModule("object_tracker", 10);
application.addAppModule("user_interface", 10);
/*
* Connecting the application modules (vertices) in the application model (directed graph) with edges
*/
application.addAppEdge("CAMERA", "motion_detector", 1000, 20000, "CAMERA", Tuple.UP, AppEdge.SENSOR); // adding edge from CAMERA (sensor) to Motion Detector module carrying tuples of type CAMERA
application.addAppEdge("motion_detector", "object_detector", 2000, 2000, "MOTION_VIDEO_STREAM", Tuple.UP, AppEdge.MODULE); // adding edge from Motion Detector to Object Detector module carrying tuples of type MOTION_VIDEO_STREAM
application.addAppEdge("object_detector", "user_interface", 500, 2000, "DETECTED_OBJECT", Tuple.UP, AppEdge.MODULE); // adding edge from Object Detector to User Interface module carrying tuples of type DETECTED_OBJECT
application.addAppEdge("object_detector", "object_tracker", 1000, 100, "OBJECT_LOCATION", Tuple.UP, AppEdge.MODULE); // adding edge from Object Detector to Object Tracker module carrying tuples of type OBJECT_LOCATION
application.addAppEdge("object_tracker", "PTZ_CONTROL", 100, 28, 100, "PTZ_PARAMS", Tuple.DOWN, AppEdge.ACTUATOR); // adding edge from Object Tracker to PTZ CONTROL (actuator) carrying tuples of type PTZ_PARAMS
/*
* Defining the input-output relationships (represented by selectivity) of the application modules.
*/
application.addTupleMapping("motion_detector", "CAMERA", "MOTION_VIDEO_STREAM", new FractionalSelectivity(1.0)); // 1.0 tuples of type MOTION_VIDEO_STREAM are emitted by Motion Detector module per incoming tuple of type CAMERA
application.addTupleMapping("object_detector", "MOTION_VIDEO_STREAM", "OBJECT_LOCATION", new FractionalSelectivity(1.0)); // 1.0 tuples of type OBJECT_LOCATION are emitted by Object Detector module per incoming tuple of type MOTION_VIDEO_STREAM
application.addTupleMapping("object_detector", "MOTION_VIDEO_STREAM", "DETECTED_OBJECT", new FractionalSelectivity(0.05)); // 0.05 tuples of type MOTION_VIDEO_STREAM are emitted by Object Detector module per incoming tuple of type MOTION_VIDEO_STREAM
/*
* 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("motion_detector");
add("object_detector");
add("object_tracker");
}
});
final AppLoop loop2 = new AppLoop(new ArrayList() {
{
add("object_tracker");
add("PTZ_CONTROL");
}
});
List loops = new ArrayList() {
{
add(loop1);
add(loop2);
}
};
application.setLoops(loops);
return application;
}
FogManager.java: public Map FitnessFunction(FogDevice node, Tuple tuple) {
double execTime = Double.MAX_VALUE;
Vm selectedVm = null;
for (Vm vm : node.getHost().getVmList()) {
double ct = 0;
double waittime = 0;
ct = (double) tuple.getCloudletTotalLength() / (double) (vm.getMips() * vm.getNumberOfPes());
waittime = WaitTime(node, tuple, vm);
System.out.println("IABO fitenessfunction compute time :" + ct + " waiting time " + waittime + " vm id #" + vm.getId() + " node name " + node.getName());
ct = ct + waittime + node.getUplinkLatency();
if (execTime > ct) {
execTime = ct;
selectedVm = vm;
}
}
Map nodeVmTime = new HashMap();
nodeVmTime.put(new NodeVm(node, selectedVm), new TupleTime(tuple, execTime));
return nodeVmTime;
}
public double WaitTime(FogDevice fogdevice, Tuple tuple, Vm vm) {
double wtime = 0;
NodeVm nodevm = new NodeVm(fogdevice, vm);
if (getWaitingTime().isEmpty()) {
wtime = 0.0;
} else {
for (Map.Entry waitingTimeMap : getWaitingTime().entrySet()) {
NodeVm nodevmmap = (NodeVm) waitingTimeMap.getKey();
List tupleTimelist = (List) waitingTimeMap.getValue();
if (fogdevice == nodevmmap.FogNode && vm == nodevmmap.VirtualMachine) {
for (TupleTime tuptime : tupleTimelist) {
wtime = wtime + tuptime.time;
}
break;
}
}
}
return wtime;
}
Research breakthrough possible @S-Logix
