/// <summary>
/// Gets the complete infos of this variable, given a data type
/// </summary>
/// <param name="dataType">data type to get infos</param>
/// <returns>prefix info</returns>
public PrefixInfo PrefixInfo(EnumDataType dataType)
{
if (this.prefixes.ContainsKey(dataType))
{
return(this.prefixes[dataType]);
}
else
{
throw new ArgumentException("Le type de données '" + dataType.ToString() + "' demandé n'existe pas pour la variable '" + this.Name + "'");
}
}
/// <summary>
/// Use this data type as the current data type value
/// </summary>
/// <param name="dataType">current data type</param>
public void UseThis(EnumDataType dataType)
{
if (this.prefixes.ContainsKey(dataType))
{
this.type = dataType;
}
else
{
throw new ArgumentException("Le type de données '" + dataType.ToString() + "' demandé n'existe pas pour la variable '" + this.Name + "'");
}
}
public static void CloudSimulation(TuplePost tuple, string policy, int _service, List <string> datacenter)
{
resultList = new ConcurrentBag <Results>();
Random rnd = new Random();
var result = new Results();
#region Cloud
bool[] bit = { true };
var b = rnd.Next(bit.Length);
// create service
var service = ServicesUtility.GetServices()[_service];
#endregion Cloud
if (FogSimulator.tupleList.Count == 0)
{
if (tuple.TupleData.RAM != 0)
{
#region Tuple
for (int i = 0; i < tuple.TupleSize; i++)
{
Array values = Enum.GetValues(typeof(EnumDataType));
EnumDataType randomDataType = (EnumDataType)values.GetValue(rnd.Next(values.Length));
Array NodeTypevalues = Enum.GetValues(typeof(EnumNodeType));
EnumNodeType randomNodeType = (EnumNodeType)NodeTypevalues.GetValue(rnd.Next(NodeTypevalues.Length));
tupleList.Add(new Models.Tuple(
Guid.NewGuid(),
1,
tuple.TupleData.MIPS,
tuple.TupleData.NumberOfPes,
tuple.TupleData.RAM,
tuple.TupleData.BW,
tuple.TupleData.Size,
"T-" + i,
randomDataType.ToString(),
100,
0.0,
"medium",
new CloudletScheduler(),
GeoDistance.RandomGeoLocation(rnd),
false,
randomNodeType.ToString(), 0, 0)
);
}
#endregion Tuple
}
else
{
#region Tuple
for (int i = 0; i < tuple.TupleSize; i++)
{
int[] randomRam = { 10, 25, 50, 100, 150, 200 };
var randomRamIndex = rnd.Next(randomRam.Length);
int[] randomMips = { 100, 150, 300, 400, 500, 700 };
var randomMipsIndex = rnd.Next(randomMips.Length);
int[] randomPe = { 1 };
var randomPeIndex = rnd.Next(randomPe.Length);
int[] randomSize = { 10, 20, 50, 70, 100 };
var randomSizeIndex = rnd.Next(randomSize.Length);
int[] randomBW = { 10, 30, 50, 80, 100 };
var randomBWIndex = rnd.Next(randomBW.Length);
string[] _priority = { "medium", "low" };
var _priorityIndex = rnd.Next(_priority.Length);
Array values = Enum.GetValues(typeof(EnumDataType));
EnumDataType randomDataType = (EnumDataType)values.GetValue(rnd.Next(values.Length));
bool MedORLB = randomDataType.ToString() == "Medical" || randomDataType.ToString() == "LocationBased";
Array NodeTypevalues = Enum.GetValues(typeof(EnumNodeType));
EnumNodeType randomNodeType = (EnumNodeType)NodeTypevalues.GetValue(rnd.Next(NodeTypevalues.Length));
tupleList.Add(new Models.Tuple(
Guid.NewGuid(),
1,
randomMips[randomMipsIndex],
randomPe[randomPeIndex],
randomRam[randomRamIndex],
randomBW[randomBWIndex],
randomSize[randomSizeIndex],
"T-" + i,
randomDataType.ToString(),
100,
0.0,
MedORLB == true ? "high" : _priority[_priorityIndex],
new CloudletScheduler(),
GeoDistance.RandomGeoLocation(rnd),
false,
randomNodeType.ToString(), 0, 0)
);
}
#endregion Tuple
}
}
else
{
tupleList = FogSimulator.tupleList;
}
List <Task> myTaskList = new List <Task>();
if (policy == "1")
{
watch.Start();
foreach (var item in tupleList)
{
item.QueueDelay = watch.Elapsed.Milliseconds;
CloudUtility.CloudSim(item, service, datacenter);
}
watch.Stop();
}
else if (policy == "2")
{
var localtupleList = tupleList.OrderBy(x => x.MIPS).ToList();
watch.Start();
foreach (var item in localtupleList)
{
item.QueueDelay = watch.Elapsed.Milliseconds;
CloudUtility.CloudSim(item, service, datacenter);
}
watch.Stop();
}
else if (policy == "3")
{
var localtupleList = tupleList.OrderByDescending(x => x.MIPS).ToList();
watch.Start();
foreach (var item in localtupleList)
{
item.QueueDelay = watch.Elapsed.Milliseconds;
CloudUtility.CloudSim(item, service, datacenter);
}
watch.Stop();
}
else
{
var split = LinqExtensions.Split(tupleList, 16).ToList();
watch.Start();
for (int j = 0; j < split.Count(); j++)
{
foreach (var item in split[j])
{
//commented task section by Ali for testing
//myTaskList.Add(Task.Factory.StartNew(() =>
//{
item.QueueDelay = watch.Elapsed.Milliseconds;
CloudUtility.CloudSim(item, service, datacenter);
//}));
}
}
watch.Stop();
Task.WaitAll(myTaskList.ToArray());
}
Excel.CreateExcelSheetForCloud(resultList.ToList());
resultList = new ConcurrentBag <Results>();
tupleList = new List <Models.Tuple>();
}
public IHttpActionResult createDS(FogSimulationPost model)
{
try
{
Random rnd = new Random();
FogPost fog = model.FogPost;
Models.TuplePost tuple = model.TuplePost;
bool F_homo_hetro = true; //true means Homogenious Fogs
bool T_homo_hetro = true; //true mean Homogenious Tuples
long FogSize = fog.FogSize;
List <FogDevice> fogList = new List <FogDevice>();
List <Models.Tuple> tupleList = new List <Models.Tuple>();
#region create Fog dataSet
if (fog.FogDevice.RAM != 0)
{
#region Fog
F_homo_hetro = true;
for (int i = 0; i < FogSize; i++)
{
bool[] bit = { true, false };
var b = rnd.Next(bit.Length);
Array NodeTypevalues = Enum.GetValues(typeof(EnumNodeType));
EnumNodeType randomDataType = (EnumNodeType)NodeTypevalues.GetValue(rnd.Next(NodeTypevalues.Length));
fogList.Add(new FogDevice(
Guid.NewGuid(),
1,
fog.FogDevice.MIPS,
fog.FogDevice.NumberOfPes,
fog.FogDevice.RAM,
fog.FogDevice.UpBW,
fog.FogDevice.DownBW,
fog.FogDevice.Size,
fog.FogDevice.Storage,
fog.FogDevice.Name + "-" + i,
randomDataType.ToString(),
new CloudletScheduler(),
GeoDistance.RandomGeoLocation(rnd),
bit[b],
0,
PowerUtility.SetIdlePower(), 15)
);
}
#endregion Fog
}
else
{
#region Fog
F_homo_hetro = false;
for (int i = 0; i < FogSize; i++)
{
bool[] bit = { true };
var b = rnd.Next(bit.Length);
int[] randomRam = { 4096, 6144, 8192, 10240, 12288, 16384 };
// var randomRamIndex = rnd.Next(randomRam.Length);
var index = rnd.Next(randomRam.Length);
///commented original values
int[] randomMips = { 25000, 50000, 75000, 85000, 95000, 110000 };
//these smaller mips were added by ali for testing
//int[] randomMips = { 4000, 5000, 10000, 12000, 15000,3000 };
var randomMipsIndex = rnd.Next(randomMips.Length);
int[] randomPe = { 1, 1, 2, 2, 3, 4 };
var randomPeIndex = rnd.Next(randomPe.Length);
int[] randomSize = { 7000, 10000, 12000, 15000, 20000, 25000 };
var randomSizeIndex = rnd.Next(randomSize.Length);
int[] randomDownBW = { 500, 700, 1000, 1200, 1500, 1700 };
var randomDownBWIndex = rnd.Next(randomDownBW.Length);
int[] randomUpBW = { 700, 1000, 1200, 1500, 2000, 2500 };
var randomUpBWIndex = rnd.Next(randomUpBW.Length);
int[] randomStorage = { 5000, 10000, 12000, 15000, 20000, 25000 };
var randomStorageIndex = rnd.Next(randomStorage.Length);
//processor burst time is random since it is OS defined and processor defined and it is not calculated
int[] timeSlice = { 15, 20, 25, 30 };
var timeSliceIndex = rnd.Next(timeSlice.Length);
Array NodeTypevalues = Enum.GetValues(typeof(EnumNodeType));
EnumNodeType randomDataType = (EnumNodeType)NodeTypevalues.GetValue(rnd.Next(NodeTypevalues.Length));
fogList.Add(new FogDevice(
Guid.NewGuid(),
1,
randomMips[index],
randomPe[index],
randomRam[index],
randomUpBW[index],
randomDownBW[index],
randomSize[index],
randomStorage[index],
fog.FogDevice.Name + "-" + i,
randomDataType.ToString(),
new CloudletScheduler(),
GeoDistance.RandomGeoLocation(rnd),
bit[b],
0,
PowerUtility.SetIdlePower(), timeSlice[timeSliceIndex])
);
}
// for writing Json file
#endregion Fog
}
#endregion
#region Create Tuple data Set
if (tuple.TupleData.RAM != 0)
{
T_homo_hetro = true;
for (int i = 0; i < tuple.TupleSize; i++)
{
Array values = Enum.GetValues(typeof(EnumDataType));
EnumDataType randomDataType = (EnumDataType)values.GetValue(rnd.Next(values.Length));
Array NodeTypevalues = Enum.GetValues(typeof(EnumNodeType));
EnumNodeType randomNodeType = (EnumNodeType)NodeTypevalues.GetValue(rnd.Next(NodeTypevalues.Length));
tupleList.Add(new Models.Tuple(
Guid.NewGuid(),
1,
tuple.TupleData.MIPS,
tuple.TupleData.NumberOfPes,
tuple.TupleData.RAM,
tuple.TupleData.BW,
tuple.TupleData.Size,
"T-" + i,
randomDataType.ToString(),
100,
0.0,
"Medium",//its medium temporarly
new CloudletScheduler(),
GeoDistance.RandomGeoLocation(rnd),
false,
randomNodeType.ToString(), 20, 0)
);
}
}
else
{
T_homo_hetro = false;
for (int i = 0; i < tuple.TupleSize; i++)
{
Array values = Enum.GetValues(typeof(EnumDataType));
EnumDataType randomDataType = (EnumDataType)values.GetValue(rnd.Next(values.Length));
var randomMipsIndex = 0;
bool BulkOrLarge = false;
List <int> randomMips = new List <int>();
bool MedORLB = randomDataType.ToString() == "Medical" || randomDataType.ToString() == "LocationBased";
switch (randomDataType.ToString())
{
case "Bulk":
randomMips.Add(700);
randomMips.Add(900);
randomMips.Add(1000);
randomMips.Add(1200);
BulkOrLarge = true;
randomMipsIndex = rnd.Next(randomMips.Count) + 2;
break;
case "Large":
randomMips.Add(500);
randomMips.Add(700);
randomMips.Add(900);
randomMips.Add(1000);
BulkOrLarge = true;
randomMipsIndex = rnd.Next(randomMips.Count) + 2;
break;
default:
randomMips.Add(50);
randomMips.Add(75);
randomMips.Add(100);
randomMips.Add(150);
randomMips.Add(200);
randomMips.Add(250);
randomMipsIndex = rnd.Next(randomMips.Count);
break;
}
//MB
int[] randomRam = { 100, 150, 200, 300, 500, 1024 };
// var randomRamIndex = rnd.Next(randomRam.Length);
var index = rnd.Next(randomRam.Length);
int[] randomPe = { 1, 1, 1, 1, 1, 1 };
var randomPeIndex = rnd.Next(randomPe.Length);
//MB
int[] randomSize = { 80, 120, 170, 220, 270, 300 };
var randomSizeIndex = rnd.Next(randomSize.Length);
//bit/sec
int[] randomBW = { 20, 50, 80, 90, 100, 150 };
var randomBWIndex = rnd.Next(randomBW.Length);
string[] _priority = { "medium", "low" };
var _priorityIndex = rnd.Next(_priority.Length);
double[] randomTupleBurstTimes = { 20, 40, 60 };
var randomBusrtIndex = rnd.Next(randomTupleBurstTimes.Length);
Array NodeTypevalues = Enum.GetValues(typeof(EnumNodeType));
EnumNodeType randomNodeType = (EnumNodeType)NodeTypevalues.GetValue(rnd.Next(NodeTypevalues.Length));
//if(BulkOrLarge) randomMipsIndex
var tupleMips = BulkOrLarge == true ? randomMips[randomMipsIndex - 2] : randomMips[randomMipsIndex];
double burstTimeForTuple = 0.0;
if (tupleMips <= 100)
{
burstTimeForTuple = 10;
}
else if (tupleMips > 100 && tupleMips <= 300)
{
burstTimeForTuple = 15;
}
else if (tupleMips > 300 && tupleMips < 500)
{
burstTimeForTuple = 20;
}
else if (tupleMips > 500 && tupleMips < 700)
{
burstTimeForTuple = 25;
}
else if (tupleMips > 700 && tupleMips < 900)
{
burstTimeForTuple = 30;
}
else if (tupleMips > 900 && tupleMips <= 1200)
{
burstTimeForTuple = 35;
}
tupleList.Add(new Models.Tuple(Guid.NewGuid(),
1,
BulkOrLarge == true ? randomMips[randomMipsIndex - 2] : randomMips[randomMipsIndex],
randomPe[randomMipsIndex],
randomRam[randomMipsIndex],
randomBW[randomMipsIndex],
randomSize[randomMipsIndex],
"T-" + i,
randomDataType.ToString(),
100,
0.0,
//adding medical, location based and shortest jobs to high priority
MedORLB == true ? "high" : BulkOrLarge == true?"low":tupleMips <= 100?"high": _priority[_priorityIndex],
new CloudletScheduler(),
GeoDistance.RandomGeoLocation(rnd),
false,
randomNodeType.ToString(), burstTimeForTuple, 0)
);
}
}
#endregion
if (fogList != null && tupleList != null)
{
if (F_homo_hetro)
{
SimJson.WriteJson(fogList, "H**o", "JsonFog.txt");
}
else
{
SimJson.WriteJson(fogList, "Hetro", "JsonFog.txt");
}
if (T_homo_hetro)
{
SimJson.WriteJson(tupleList, "H**o", "JsonTuple.txt");
}
else
{
SimJson.WriteJson(tupleList, "Hetro", "JsonTuple.txt");
}
}
return(Ok("ok"));
}
catch (Exception ex)
{
return(Ok(ex.Message.ToString()));
}
}
