Ejemplo n.º 1
0
 /// <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 + "'");
     }
 }
Ejemplo n.º 2
0
 /// <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 + "'");
     }
 }
Ejemplo n.º 3
0
        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>();
        }
Ejemplo n.º 4
0
        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()));
            }
        }