////////import org.fog.application.

AppModule;
////////import org.fog.entities.FogDevice;
////////import org.fog.entities.Tuple;
////////import org.fog.placement.ModulePlacementFirstFit;
////////import org.fog.scheduler.StreamOperatorScheduler;
////////import org.fog.utils.FogUtils;
////////import org.fog.utils.TimeKeeper;
////////import org.fog.utils.distribution.DeterministicDistribution;
////////import org.fog.utils.distribution.Distribution;
////////
////////import java.util.ArrayList;
////////import java.util.Calendar;
////////import java.util.List;
////////
////////public class FirstFitTaskSchedulingExample {
////////
//////// public static void main(String[] args) {
//////// // Create Fog devices
//////// List<FogDevice> fogDevices = createFogDevices();
////////
//////// // Create Fog applications
//////// List<AppModule> appModules = createAppModules();
////////
//////// // Set up placement and scheduling policy
//////// ModulePlacementFirstFit modulePlacement = new
ModulePlacementFirstFit(fogDevices, appModules);
//////// StreamOperatorScheduler scheduler = new StreamOperatorScheduler();
////////
//////// // Assign modules to Fog devices using First Fit
//////// modulePlacement.placeModules(appModules, fogDevices, scheduler);
////////
//////// // Simulate the execution of tasks
//////// simulateTasks(fogDevices);
//////// }
////////
//////// private static List<FogDevice> createFogDevices() {
//////// List<FogDevice> fogDevices = new ArrayList<>();
////////
//////// // Create Fog devices
//////// FogDevice cloud = createFogDevice("cloud", 50000, 4000, 10000, 100,
16);
//////// fogDevices.add(cloud);
////////
//////// FogDevice proxy = createFogDevice("proxy-server", 10000, 1000,
5000, 50, 4);
//////// fogDevices.add(proxy);
////////
//////// FogDevice edge = createFogDevice("edge-device", 2000, 500, 2000,
10, 1);
//////// fogDevices.add(edge);
////////
//////// return fogDevices;
//////// }
////////
//////// private static FogDevice createFogDevice(String name, int mips, int
ram, int storage, int bw, int level) {
//////// return new FogDevice(name, mips, ram, storage, bw, level);
//////// }
////////
//////// private static List<AppModule> createAppModules() {
//////// List<AppModule> appModules = new ArrayList<>();
////////
//////// // Create application modules
//////// AppModule module1 = new AppModule("Module1", 100, 1024, 1000, 1);
//////// AppModule module2 = new AppModule("Module2", 200, 2048, 2000, 2);
////////
//////// appModules.add(module1);
//////// appModules.add(module2);
////////
//////// return appModules;
//////// }
////////
//////// private static void simulateTasks(List<FogDevice> fogDevices) {
////////
TimeKeeper.getInstance().setSimulationStartTime(Calendar.getInstance().getTimeInMil
lis());
////////
//////// // Create a deterministic distribution
//////// Distribution distribution = new DeterministicDistribution();
////////
//////// // Create tasks and submit them to Fog devices
//////// for (int i = 0; i < 10; i++) {
//////// Tuple tuple = new Tuple("Task" + i, FogUtils.generateTupleId(),
1000, 1, distribution);
//////// FogDevice device = fogDevices.get(i % fogDevices.size());
////////
device.getModuleByName("Module1").getSelectivityMap().put(tuple.getDestModuleName()
, 1.0);
//////// tuple.setModuleCopyMap(FogUtils.moduleCopyMap(fogDevices.get(i
% fogDevices.size()), device.getModuleByName("Module1")));
//////// device.receiveTuple(tuple.getDestModuleName(), tuple);
////////
TimeKeeper.getInstance().updateGlobalTupleProcessingEnd(Math.max(TimeKeeper.getInst
ance().getGlobalTupleProcessingEnd(),
device.getNextTupleSink().get(tuple.getDestModuleName()).get(0)));
//////// }
////////
//////// // Start simulation
////////
TimeKeeper.getInstance().setSimulationEndTime(TimeKeeper.getInstance().getGlobalTup
leProcessingEnd());
//////// System.out.println("Simulation started!");
////////
//////// // Run the simulation
//////// try {
//////// CloudSim.startSimulation();
//////// CloudSim.stopSimulation();
//////// } catch (Exception e) {
//////// e.printStackTrace();
//////// }
////////
//////// System.out.println("Simulation completed!");
//////// }
////////}
//////
//////import org.cloudbus.cloudsim.Log;
//////import org.cloudbus.cloudsim.core.CloudSim;
//////import org.fog.application.AppModule;
//////import org.fog.application.Application;
//////import org.fog.entities.Actuator;
//////import org.fog.entities.FogDevice;
//////import org.fog.entities.Sensor;
//////import org.fog.entities.Tuple;
//////import org.fog.scheduler.StreamOperatorScheduler;
//////import org.fog.utils.FogLinearPowerModel;
//////import org.fog.utils.FogUtils;
//////import org.fog.utils.distribution.DeterministicDistribution;
//////import org.fog.utils.distribution.Distribution;
//////
//////import java.util.ArrayList;
//////import java.util.Calendar;
//////import java.util.LinkedList;
//////import java.util.List;
//////
//////public class firstfit {
////// static List<FogDevice> fogDevices = new ArrayList<FogDevice>();
////// static List<Sensor> sensors = new ArrayList<Sensor>();
////// static List<Actuator> actuators = new ArrayList<Actuator>();
////// static int numOfAreas = 1;
////// static int numOfCamerasPerArea = 4;
//////
////// private static boolean CLOUD = false;
//////
////// public static void main(String[] args) {
////// // Your existing main method code here
//////
////// try {
////// // Your existing code here
//////
////// Application application = createApplication(appId,
broker.getId());
////// application.setUserId(broker.getId());
//////
////// // Task creation
////// List<Task> tasks = new ArrayList<>();
////// tasks.add(new Task("Task1", 100, 1024));
////// tasks.add(new Task("Task2", 200, 512));
////// tasks.add(new Task("Task3", 150, 768));
////// // Add more tasks if needed
//////
////// // Allocate tasks to fog devices using First Fit algorithm
////// allocateTasksFirstFit(application, tasks);
//////
////// // Your existing code here
//////
////// CloudSim.startSimulation();
//////
////// // Your existing code here
//////
////// } catch (Exception e) {
////// e.printStackTrace();
////// Log.printLine("Unwanted errors happen");
////// }
////// }
//////
////// // Existing methods here
//////
////// private static void allocateTasksFirstFit(Application application,
List<Task> tasks) {
////// for (Task task : tasks) {
////// boolean taskAllocated = false;
////// for (FogDevice fogDevice : fogDevices) {
////// if (fogDevice.getCharacteristics().getAvailableMips() >=
task.getMips()
////// && fogDevice.getCharacteristics().getAvailableRam()
>= task.getRam()) {
////// AppModule appModule = new AppModule(task.getName(), 10,
1024, task.getMips(), new AppModuleAllocationPolicy(fogDevice.getHostList()), new
StreamOperatorScheduler(new ArrayList<Pe>()));
////// application.addAppModule(appModule);
////// taskAllocated = true;
////// break;
////// }
////// }
////// if (!taskAllocated) {
////// System.out.println("Task " + task.getName() + " could not be
allocated to any fog device.");
////// }
////// }
////// }
//////
////// static class Task {
////// private String name;
////// private long mips;
////// private int ram;
//////
////// public Task(String name, long mips, int ram) {
////// this.name = name;
////// this.mips = mips;
////// this.ram = ram;
////// }
//////
////// public String getName() {
////// return name;
////// }
//////
////// public long getMips() {
////// return mips;
////// }
//////
////// public int getRam() {
////// return ram;
////// }
////// }
//////}
////
//////
////
////package org.fog.test.perfeval;
////
////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.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.FogLinearPowerModel;
////import org.fog.utils.FogUtils;
////import org.fog.utils.TimeKeeper;
////import org.fog.utils.distribution.DeterministicDistribution;
////import org.fog.scheduler.StreamOperatorScheduler;
////import org.cloudbus.cloudsim.schedulers
////
////
////import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
////
////import java.util.ArrayList;
////import java.util.Calendar;
////import java.util.List;
////
////public class firstfit {
//// static List<FogDevice> fogDevices = new ArrayList<>();
//// static int numOfAreas = 1;
//// static int numOfCamerasPerArea = 4;
////
//// private static boolean CLOUD = false;
////
//// public static void main(String[] args) {
//// Log.printLine("Starting DCNS...");
////
//// try {
//// int num_user = 1; // number of cloud users
//// CloudSim.init(num_user, Calendar.getInstance(), false);
////
//// String appId = "dcns"; // identifier of the application
////
//// Application application = createApplication(appId);
//// int brokerId = CloudSim.getEntityId("broker");
//// FogBroker broker = new FogBroker("broker");
////
//// createFogDevices(brokerId, appId);
////
//// application.setUserId(brokerId);
////
//// // Create tasks
//// List<Task> tasks = createTasks();
////
//// // Allocate tasks to fog devices using First Fit algorithm
//// allocateTasksFirstFit(application, tasks);
////
//// broker.addApplication(application);
////
//// CloudSim.startSimulation();
////
//// CloudSim.stopSimulation();
////
//// Log.printLine("DCNS finished!");
//// } catch (Exception e) {
//// e.printStackTrace();
//// Log.printLine("Unwanted errors happen");
//// }
//// }
////
//// private static void createFogDevices(int brokerId, String appId) {
//// // Create fog nodes
//// // Cloud node
//// FogDevice cloud = createFogDevice("cloud", 44800, 40000, 100, 10000, 0,
0.01, 16 * 103, 16 * 83.25);
//// cloud.setParentId(-1);
//// fogDevices.add(cloud);
////
//// // Proxy server node
//// 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);
////
//// // Area nodes and Camera nodes
//// for (int i = 0; i < numOfAreas; i++) {
//// FogDevice area = createFogDevice("area-" + i, 2800, 4000, 10000,
10000, 2, 0.0, 107.339, 83.4333);
//// area.setParentId(proxy.getId());
//// area.setUplinkLatency(2); // latency of connection between area and
proxy server is 2 ms
//// fogDevices.add(area);
////
//// for (int j = 0; j < numOfCamerasPerArea; j++) {
//// FogDevice camera = createFogDevice("camera-" + i + "-" + j,
500, 1000, 10000, 10000, 3, 0, 87.53, 82.44);
//// camera.setParentId(area.getId());
//// camera.setUplinkLatency(2); // latency of connection between
camera and area is 2 ms
//// fogDevices.add(camera);
//// }
//// }
//// }
////
//// private static FogDevice createFogDevice(String name, long mips, int ram,
long upBw, long downBw, int level, double ratePerMips, double busyPower, double
idlePower) {
//// List<Pe> peList = new ArrayList<>();
//// peList.add(new Pe(0, new PeProvisionerSimple(mips)));
////
//// long storage = 1000000; // host storage
//// int bw = 10000;
////
//// return new FogDevice(name, peList, new
CloudletSchedulerSpaceShared(peList),
//// new FogDeviceCharacteristics(mips, ram, upBw, downBw, 0,
ratePerMips, busyPower, idlePower),
//// new StreamOperatorScheduler(peList), new
FogLinearPowerModel(busyPower, idlePower));
//// }
////
//// private static Application createApplication(String appId) {
//// Application application = Application.createApplication(appId);
////
//// // Add modules
//// AppModule objectDetector = new AppModule("object_detector", 10, 1024,
2000, new StreamOperatorScheduler(new ArrayList<Pe>()));
//// application.addAppModule(objectDetector);
////
//// AppModule motionDetector = new AppModule("motion_detector", 10, 1024,
2000, new StreamOperatorScheduler(new ArrayList<Pe>()));
//// application.addAppModule(motionDetector);
////
//// // Connect modules
//// application.addAppEdge("CAMERA", "motion_detector", 1000, 20000,
"CAMERA", Tuple.UP, AppEdge.SENSOR);
//// application.addAppEdge("motion_detector", "object_detector", 2000,
2000, "MOTION_VIDEO_STREAM", Tuple.UP, AppEdge.MODULE);
////
//// return application;
//// }
////
//// private static List<Task> createTasks() {
//// List<Task> tasks = new ArrayList<>();
////
//// tasks.add(new Task("Task1", 100, 1024));
//// tasks.add(new Task("Task2", 200, 512));
//// tasks.add(new Task("Task3", 150, 768));
//// // Add more tasks if needed
////
//// return tasks;
//// }
////
//// private static void allocateTasksFirstFit(Application application,
List<Task> tasks) {
//// for (Task task : tasks) {
//// boolean allocated = false;
//// for (FogDevice fogDevice : fogDevices) {
//// if (fogDevice.getCharacteristics().getAvailableMips() >=
task.getMips() &&
//// fogDevice.getCharacteristics().getAvailableRam() >=
task.getRam()) {
//// application.addAppModule(new AppModule(task.getName(), 10,
task.getRam(), task.getMips(),
//// new StreamOperatorScheduler(new ArrayList<>())));
//// allocated = true;
//// break;
//// }
//// }
//// if (!allocated) {
//// Log.printLine("Task " + task.getName() + " cannot be allocated
to any fog device.");
//// }
//// }
//// }
////}
////
////class Task {
//// private String name;
//// private double mips;
//// private int ram;
////
//// public Task(String name, double mips, int ram) {
//// this.name = name;
//// this.mips = mips;
//// this.ram = ram;
//// }
////
//// public String getName() {
//// return name;
//// }
////
//// public double getMips() {
//// return mips;
//// }
////
//// public int getRam() {
//// return ram;
//// }
////}
//
////
//import java.util.ArrayList;
//import java.util.Calendar;
//import java.util.LinkedList;
//import java.util.List;
//
//import org.cloudbus.cloudsim.core.CloudSim;
//import org.cloudbus.cloudsim.Host;
//import org.cloudbus.cloudsim.Pe;
//import org.cloudbus.cloudsim.Storage;
//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.Application;
//import org.fog.entities.Actuator;
//import org.fog.entities.FogBroker;
//import org.fog.entities.FogDevice;
//import org.fog.entities.Sensor;
//import org.fog.scheduler.TupleScheduler;
//import org.fog.utils.FogLinearPowerModel;
//import org.fog.utils.FogUtils;
//import org.fog.utils.TimeKeeper;
//import org.fog.utils.distribution.DeterministicDistribution;
//import org.fog.entities.Tuple;
//public class firstfit {
// static List<FogDevice> fogDevices = new ArrayList<FogDevice>();
// static List<Sensor> sensors = new ArrayList<Sensor>();
// static List<Actuator> actuators = new ArrayList<Actuator>();
// static int numOfAreas = 1;
// static int numOfCamerasPerArea = 4;
//
// private static boolean CLOUD = false;
//
// public static void main(String[] args) {
//
// System.out.println("Starting DCNS...");
//
// try {
// 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);
//
// FirstFitScheduler firstFitScheduler = new
FirstFitScheduler("FirstFitScheduler", 1, null, broker.getId(), appId);
// // Set First-Fit scheduler for fog devices
// for (FogDevice fogDevice : fogDevices) {
// fogDevice.setVmScheduler(new
FirstFitScheduler("FirstFitScheduler", fogDevice.getId(), null, broker.getId(),
appId));
// }
//
//
TimeKeeper.getInstance().setSimulationStartTime(Calendar.getInstance().getTimeInMil
lis());
//
// CloudSim.startSimulation();
//
// CloudSim.stopSimulation();
//
// System.out.println("DCNS finished!");
// } catch (Exception e) {
// e.printStackTrace();
// System.out.println("Unwanted errors happen");
// }
// }
//
// 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);
//
// // Create tasks and connect with sensors
// createTasksAndEdges(camera, appId);
// }
// 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;
// }
//
// private static FogDevice createFogDevice(String nodeName, long mips,
// int ram, long upBw, long downBw, int
level, double ratePerMips, double busyPower, double idlePower) {
//
// List<Pe> peList = new ArrayList<Pe>();
//
// peList.add(new Pe(0, new PeProvisionerOverbooking(mips)));
//
// int hostId = FogUtils.generateEntityId();
// long storage = 1000000; // host storage
// int bw = 10000;
//
// Host host = new Host(
// hostId,
// new RamProvisionerSimple(ram),
// new BwProvisionerOverbooking(bw),
// storage,
// peList,
// new TupleScheduler(peList)
// );
//
// List<Host> hostList = new ArrayList<Host>();
// hostList.add(host);
//
// String arch = "x86";
// String os = "Linux";
// String vmm = "Xen";
// double time_zone = 10.0;
// double cost = 3.0;
// double costPerMem = 0.05;
// double costPerStorage = 0.001;
// double costPerBw = 0.0;
// LinkedList<Storage> storageList = new LinkedList<Storage>();
//
// FogDevice fogdevice = null;
// try {
// fogdevice = new FogDevice(nodeName, arch, os, vmm, host, storageList,
time_zone, cost, costPerMem,
// costPerStorage, costPerBw);
// } catch (Exception e) {
// e.printStackTrace();
// }
//
// fogdevice.setLevel(level);
// return fogdevice;
// }
//
// private static Application createApplication(String appId, int userId) {
//
// Application application = Application.createApplication(appId, userId);
//
// application.addAppModule("task1", 10);
// application.addAppModule("task2", 10);
// application.addAppModule("task3", 10);
// // Add more tasks if needed
//
// // Define edges between tasks
// application.addAppEdge("task1", "task2", 100, 100, "DATA", "");
// application.addAppEdge("task2", "task3", 100, 100, "DATA", "");
// // Add more edges if needed
//
// // Define input-output relationships
// application.addTupleMapping("task1", "CAMERA", "DATA", "");
// // Add more tuple mappings if needed
//
// return application;
// }
//
// private static void createTasksAndEdges(FogDevice camera, String appId) {
// List<Task> tasks = new ArrayList<>();
// tasks.add(new Task("task1", 1000, 100));
// tasks.add(new Task("task2", 2000, 200));
// tasks.add(new Task("task3", 3000, 300));
// // Add more tasks if needed
//
// for (int i = 0; i < tasks.size(); i++) {
// Task task = tasks.get(i);
// AppEdge edge = new AppEdge(task.getName(), task.getName(),
task.getMips(), task.getRam(), task.getName(), "");
// edge.setTupleType(task.getName());
// Application application = CloudSim.getEntity(appId);
// application.addAppEdge(edge);
// }
// }
//
// static class FirstFitScheduler extends TupleScheduler {
//
// public FirstFitScheduler(String name, int tupleSchedulerId, List<Tuple>
tuples, int userId, String appId) {
// super(name, tupleSchedulerId, tuples, userId, appId);
// }
//
// @Override
// public void run() {
// for (FogDevice fogDevice : getFogDevices()) {
// if (fogDevice.getAvailableMips() >= getTuple().getMips()
// && fogDevice.getAvailableRam() >= getTuple().getRam()
// && fogDevice.getAvailableBw() >= getTuple().getUpBw()) {
// setDestinationDeviceId(fogDevice.getId());
// break;
// }
// }
// }
// }
//
// static class Task {
// private String name;
// private double mips;
// private int ram;
//
// public Task(String name, double mips, int ram) {
// this.name = name;
// this.mips = mips;
// this.ram = ram;
// }
//
// public String getName() {
// return name;
// }
//
// public double getMips() {
// return mips;
// }
//
// public int getRam() {
// return ram;
// }
// }
//}

package org.fog.test.perfeval;

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.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.FogLinearPowerModel;
import org.fog.utils.FogUtils;
import org.fog.utils.TimeKeeper;
import org.fog.utils.distribution.DeterministicDistribution;
import org.cloudbus.cloudsim.Datacenter;

public class firstfit {

static List<FogDevice> fogDevices = new ArrayList<>();
static List<Sensor> sensors = new ArrayList<Sensor>();
static List<Actuator> actuators = new ArrayList<Actuator>();
static int numOfAreas = 1;
static int numOfCamerasPerArea = 4;

private static boolean CLOUD = false;

public static void main(String[] args) {

 Log.printLine("Starting DCNS...");

try {
int num_user = 1; // number of cloud users
CloudSim.init(num_user, Calendar.getInstance(), false);

String appId = "dcns"; // identifier of the application

int brokerId = CloudSim.getEntityId("broker");

FogBroker broker = new FogBroker("broker");

Application application = createApplication(appId, broker.getId());

application.setUserId(broker.getId());

createFogDevices(broker.getId(), appId);

// Create tasks
List<Task> tasks = createTasks();

// Allocate tasks to fog devices using First Fit algorithm

allocateTasksFirstFit(application, tasks,fogDevices);

CloudSim.startSimulation();

CloudSim.stopSimulation();

Log.printLine("DCNS finished!");
} catch (Exception e) {
e.printStackTrace();
Log.printLine("Unwanted errors happen");
}
}
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<Pe> peList = new ArrayList<Pe>();

// 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<Host> hostList = new ArrayList<Host>();

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<Storage> storageList = new LinkedList<Storage>(); // 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;
}
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<String>()
{{add("motion_detector");add("object_detector");add("object_tracker");}});
final AppLoop loop2 = new AppLoop(new ArrayList<String>()
{{add("object_tracker");add("PTZ_CONTROL");}});
List<AppLoop> loops = new ArrayList<AppLoop>()
{{add(loop1);add(loop2);}};

application.setLoops(loops);
return application;
}

private static List<Task> createTasks() {

List<Task> tasks = new ArrayList<>();

tasks.add(new Task("Task1", 100, 1024));

tasks.add(new Task("Task2", 200, 512));
tasks.add(new Task("Task3", 150, 768));
// Add more tasks if needed
 return tasks;
}

private static void allocateTasksFirstFit(Application application, List<Task>

tasks, List<FogDevice> fogDevices) {
for (Task task : tasks) {
boolean allocated = false;
for (FogDevice fogDevice : fogDevices) {
FogDeviceCharacteristics characteristics =
fogDevice.getCharacteristics();
if (characteristics.getAvailableMips() >= task.getMips() &&
characteristics.getAvailableRam() >= task.getRam()) {
application.addAppModule(new AppModule(task.getName(), 10,
task.getRam(), task.getMips(),
new StreamOperatorScheduler(new ArrayList<>())));
allocated = true;
break;
}
}
if (!allocated) {
Log.printLine("Task " + task.getName() + " cannot be allocated to
any fog device.");
}
}
}

class Task {
private String name;
private double mips;
private int ram;

public Task(String name, double mips, int ram) {

this.name = name;
this.mips = mips;
this.ram = ram;
}

public String getName() {

return name;
}

public double getMips() {

return mips;
}

public int getRam() {

return ram;
}
}