245 lines
8.6 KiB
Java
245 lines
8.6 KiB
Java
package org.fog.utils;
|
|
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileReader;
|
|
import java.math.BigDecimal;
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
|
|
import org.cloudbus.cloudsim.Host;
|
|
import org.cloudbus.cloudsim.Pe;
|
|
import org.cloudbus.cloudsim.Storage;
|
|
import org.cloudbus.cloudsim.power.PowerHost;
|
|
import org.cloudbus.cloudsim.power.models.PowerModelLinear;
|
|
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;
|
|
import org.cloudbus.cloudsim.sdn.overbooking.BwProvisionerOverbooking;
|
|
import org.cloudbus.cloudsim.sdn.overbooking.PeProvisionerOverbooking;
|
|
import org.fog.entities.Actuator;
|
|
import org.fog.entities.FogDevice;
|
|
import org.fog.entities.FogDeviceCharacteristics;
|
|
import org.fog.entities.PhysicalTopology;
|
|
import org.fog.entities.Sensor;
|
|
import org.fog.policy.AppModuleAllocationPolicy;
|
|
import org.fog.scheduler.StreamOperatorScheduler;
|
|
import org.fog.utils.distribution.DeterministicDistribution;
|
|
import org.fog.utils.distribution.Distribution;
|
|
import org.fog.utils.distribution.NormalDistribution;
|
|
import org.fog.utils.distribution.UniformDistribution;
|
|
import org.json.simple.JSONArray;
|
|
import org.json.simple.JSONObject;
|
|
import org.json.simple.JSONValue;
|
|
|
|
public class JsonToTopology {
|
|
|
|
private static List<FogDevice> fogDevices = new ArrayList<FogDevice>();
|
|
private static List<Sensor> sensors = new ArrayList<Sensor>();
|
|
private static List<Actuator> actuators = new ArrayList<Actuator>();
|
|
|
|
private static boolean isFogDevice(String name){
|
|
for(FogDevice fogDevice : fogDevices){
|
|
if(fogDevice.getName().equalsIgnoreCase(name))
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
private static FogDevice getFogDevice(String name){
|
|
for(FogDevice fogDevice : fogDevices){
|
|
if(fogDevice.getName().equalsIgnoreCase(name))
|
|
return fogDevice;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static boolean isActuator(String name){
|
|
for(Actuator actuator : actuators){
|
|
if(actuator.getName().equalsIgnoreCase(name))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static Actuator getActuator(String name){
|
|
for(Actuator actuator : actuators){
|
|
if(actuator.getName().equalsIgnoreCase(name))
|
|
return actuator;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static boolean isSensor(String name){
|
|
for(Sensor sensor : sensors){
|
|
if(sensor.getName().equalsIgnoreCase(name))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static Sensor getSensor(String name){
|
|
for(Sensor sensor : sensors){
|
|
if(sensor.getName().equalsIgnoreCase(name))
|
|
return sensor;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static PhysicalTopology getPhysicalTopology(int userId, String appId, String physicalTopologyFile) throws Exception{
|
|
|
|
fogDevices = new ArrayList<FogDevice>();
|
|
sensors = new ArrayList<Sensor>();
|
|
actuators = new ArrayList<Actuator>();
|
|
|
|
|
|
try {
|
|
JSONObject doc = (JSONObject) JSONValue.parse(new FileReader(physicalTopologyFile));
|
|
JSONArray nodes = (JSONArray) doc.get("nodes");
|
|
@SuppressWarnings("unchecked")
|
|
Iterator<JSONObject> iter =nodes.iterator();
|
|
while(iter.hasNext()){
|
|
JSONObject node = iter.next();
|
|
String nodeType = (String) node.get("type");
|
|
String nodeName = (String) node.get("name");
|
|
|
|
if(nodeType.equalsIgnoreCase("FOG_DEVICE")){
|
|
long mips = (Long) node.get("mips");
|
|
int ram = new BigDecimal((Long)node.get("ram")).intValueExact();
|
|
long upBw = new BigDecimal((Long)node.get("upBw")).intValueExact();
|
|
long downBw = new BigDecimal((Long)node.get("downBw")).intValueExact();
|
|
int level = new BigDecimal((Long)node.get("level")).intValue();
|
|
double ratePerMips = new BigDecimal((Double)node.get("ratePerMips")).doubleValue();
|
|
|
|
FogDevice fogDevice = createFogDevice(nodeName, mips, ram, upBw, downBw, level, ratePerMips);
|
|
fogDevice.setParentId(-1);
|
|
|
|
fogDevices.add(fogDevice);
|
|
|
|
} else if(nodeType.equals("SENSOR")){
|
|
String sensorType = node.get("sensorType").toString();
|
|
int distType = new BigDecimal((Long)node.get("distribution")).intValue();
|
|
Distribution distribution = null;
|
|
if(distType == Distribution.DETERMINISTIC)
|
|
distribution = new DeterministicDistribution(new BigDecimal((Double)node.get("value")).doubleValue());
|
|
else if(distType == Distribution.NORMAL){
|
|
distribution = new NormalDistribution(new BigDecimal((Double)node.get("mean")).doubleValue(),
|
|
new BigDecimal((Double)node.get("stdDev")).doubleValue());
|
|
} else if(distType == Distribution.UNIFORM){
|
|
distribution = new UniformDistribution(new BigDecimal((Double)node.get("min")).doubleValue(),
|
|
new BigDecimal((Double)node.get("max")).doubleValue());
|
|
}
|
|
System.out.println("Sensor type : "+sensorType);
|
|
sensors.add(new Sensor(nodeName, sensorType, userId, appId, distribution));
|
|
} else if(nodeType.equals("ACTUATOR")){
|
|
String actuatorType = node.get("actuatorType").toString();
|
|
actuators.add(new Actuator(nodeName, userId, appId, actuatorType));
|
|
}
|
|
}
|
|
|
|
JSONArray links = (JSONArray) doc.get("links");
|
|
@SuppressWarnings("unchecked")
|
|
Iterator<JSONObject> linksIter =links.iterator();
|
|
while(linksIter.hasNext()){
|
|
JSONObject link = linksIter.next();
|
|
String src = (String) link.get("source");
|
|
String dst = (String) link.get("destination");
|
|
double lat = (Double) link.get("latency");
|
|
|
|
connectEntities(src, dst, lat);
|
|
}
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
}
|
|
PhysicalTopology physicalTopology = new PhysicalTopology();
|
|
physicalTopology.setFogDevices(fogDevices);
|
|
physicalTopology.setActuators(actuators);
|
|
physicalTopology.setSensors(sensors);
|
|
return physicalTopology;
|
|
}
|
|
private static FogDevice createFogDevice(String nodeName, long mips,
|
|
int ram, long upBw, long downBw, int level, double ratePerMips) {
|
|
|
|
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 PowerModelLinear(107.339, 83.4333)
|
|
);
|
|
|
|
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 void connectEntities(String src, String dst, double lat) {
|
|
if(isFogDevice(src) && isFogDevice(dst)){
|
|
FogDevice srcDev = getFogDevice(src);
|
|
FogDevice destDev = getFogDevice(dst);
|
|
FogDevice southernDev = (srcDev.getLevel() > destDev.getLevel())?srcDev:destDev;
|
|
FogDevice northernDev = (srcDev.getLevel() > destDev.getLevel())?destDev:srcDev;
|
|
southernDev.setUplinkLatency(lat);
|
|
southernDev.setParentId(northernDev.getId());
|
|
} else if(isFogDevice(src) && isSensor(dst)){
|
|
FogDevice srcDev = getFogDevice(src);
|
|
Sensor sensor = getSensor(dst);
|
|
sensor.setLatency(lat);
|
|
sensor.setGatewayDeviceId(srcDev.getId());
|
|
} else if(isSensor(src) && isFogDevice(dst)){
|
|
FogDevice fogDevice = getFogDevice(dst);
|
|
Sensor sensor = getSensor(src);
|
|
sensor.setLatency(lat);
|
|
sensor.setGatewayDeviceId(fogDevice.getId());
|
|
} else if(isFogDevice(src) && isActuator(dst)){
|
|
FogDevice fogDevice = getFogDevice(src);
|
|
Actuator actuator = getActuator(dst);
|
|
actuator.setLatency(lat);
|
|
actuator.setGatewayDeviceId(fogDevice.getId());
|
|
} else if(isActuator(src) && isFogDevice(dst)){
|
|
FogDevice fogDevice = getFogDevice(dst);
|
|
Actuator actuator = getActuator(src);
|
|
actuator.setLatency(lat);
|
|
actuator.setGatewayDeviceId(fogDevice.getId());
|
|
}
|
|
|
|
}
|
|
}
|