Exemplo n.º 1
0
        public void ChangeLoad(LoadChangeAction changeAction)
        {
            var finalLoad = LoadFactory.GetUpdatedContainerLoad(this.ContainerId, changeAction, NeededLoad);

            switch (Global.LoadChangeStrategy)
            {
            case LoadChangeStrategy.Force:
                NeededLoad = finalLoad;
                break;

            case LoadChangeStrategy.Incremental:
                Task t = new Task(async() =>
                {
                    var initalLoad = NeededLoad;
                    int steps      = Global.Steps;
                    for (int i = 1; i <= steps; i++)
                    {
                        var newCurrent = (finalLoad - initalLoad) * i / steps + initalLoad;
                        lock (lck)
                        {
                            NeededLoad = newCurrent;
                        }
                        await Task.Delay(10 * Global.Second);
                    }
                });
                t.Start();
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Exemplo n.º 2
0
 public RunConfiguration(SimulationSize simulationSize,
                         StartUtilizationPercent startPercent,
                         LoadChangeAction changeAction,
                         LoadPrediction loadPrediction,
                         Strategies strategy,
                         AuctionTypes pushAuctionType, AuctionTypes pullAuctionType,
                         SchedulingAlgorithm schedulingAlgorithm,
                         TestedHosts testedHosts,
                         ContainersType containersType,
                         bool networkDealy,
                         int trialId)
 {
     LoadPrediction      = loadPrediction;
     SimulationSize      = simulationSize;
     StartPercent        = startPercent;
     Strategy            = strategy;
     PushAuctionType     = pushAuctionType;
     PullAuctionType     = pullAuctionType;
     SchedulingAlgorithm = schedulingAlgorithm;
     ChangeAction        = changeAction;
     TestedHosts         = testedHosts;
     ContainersType      = containersType;
     NetworkDealy        = networkDealy;
     TrialId             = trialId;
 }
Exemplo n.º 3
0
 public void ChangeAllContainersLoad(LoadChangeAction changeMethod, Func <Container, bool> condition)
 {
     //lock (_hostLock)
     {
         var containerslist = _containerTable.GetAllContainers().Where(condition);
         foreach (var container in containerslist)
         {
             container.ChangeLoad(changeMethod);
         }
     }
 }
Exemplo n.º 4
0
        private void StartWaveSimmulationAction(LoadChangeAction changeMethod, Func <Machine, bool> hostsFunc,
                                                Func <Container, bool> contsFunc)
        {
            var machines = MachineTableObject.GetAllMachines().Skip(1).Where(x => x.MachineId < int.MaxValue).Where(hostsFunc).ToList();

            for (int i = 0; i < machines.Count; i++)
            {
                var host = machines[i] as HostMachine;
                host.ChangeAllContainersLoad(changeMethod, contsFunc);
            }
        }
Exemplo n.º 5
0
        //public static Load GetStartLoad(int conId)
        //{
        //    //switch (Global.LoadCreationStrategy)
        //    //{
        //    //    case LoadCreationStrategy.Fixed:
        //    //        return GetFixedLoad();
        //    //    case LoadCreationStrategy.Selected:
        //    //        return GetSelectedLoad(conId);
        //    //    case LoadCreationStrategy.Random:
        //    //        return GetRandomLoadInRange();
        //    //    default:
        //    //        throw new ArgumentOutOfRangeException();
        //    //}

        //}

        public static Load GetUpdatedContainerLoad(int conId, LoadChangeAction changeMethod, Load old)
        {
            var x = 1.0 + ((int)changeMethod / 100.0);

            return(old * x);
        }
        public MeasureValueHolder ReadDataFromDisk(string mainFile)
        {
            var                     config         = mainFile.Split('\\');
            SimulationSize          simulationSize = (SimulationSize)Convert.ToInt32(config[3]);
            StartUtilizationPercent perecent       =
                (StartUtilizationPercent)Enum.Parse(typeof(StartUtilizationPercent), config[4].Split('_')[0]);
            LoadChangeAction changeAction =
                (LoadChangeAction)Enum.Parse(typeof(LoadChangeAction), config[4].Split('_')[1]);

            LoadPrediction      loadPrediction      = (LoadPrediction)Enum.Parse(typeof(LoadPrediction), config[5]);
            SchedulingAlgorithm schedulingAlgorithm = (SchedulingAlgorithm)Enum.Parse(typeof(SchedulingAlgorithm), config[6]);
            Strategies          strategy            = (Strategies)Enum.Parse(typeof(Strategies), config[7].Split('_')[0]);
            ContainersType      containerType       = (ContainersType)Enum.Parse(typeof(ContainersType), config[7].Split('_')[1]);
            AuctionTypes        pushAuctionType     = (AuctionTypes)Enum.Parse(typeof(AuctionTypes), config[8].Split('_')[0]);
            AuctionTypes        pullAuctionType     = (AuctionTypes)Enum.Parse(typeof(AuctionTypes), config[8].Split('_')[1]);
            TestedHosts         testedHosts         = (TestedHosts)Enum.Parse(typeof(TestedHosts), config[9]);
            bool delay = bool.Parse(config[10]);

            int TrialId = int.Parse(config[11]);
            var conf    = new RunConfiguration(simulationSize, perecent, changeAction, loadPrediction, strategy, pushAuctionType, pullAuctionType, schedulingAlgorithm, testedHosts, containerType, delay, TrialId);
            MeasureValueHolder holder =
                new MeasureValueHolder(conf);

            using (StreamReader reader = new StreamReader(mainFile))
            {
                reader.ReadLine();
                while (!reader.EndOfStream)
                {
                    var    line                        = reader.ReadLine().Split(',');
                    int    i                           = Convert.ToInt32(line[0]);
                    double entropy                     = Convert.ToDouble(line[1]);
                    double predictedEntropy            = Convert.ToDouble(line[2]);
                    double avgRealVolume               = Convert.ToDouble(line[3]);
                    double avgPredictedVolume          = Convert.ToDouble(line[4]);
                    double idealHostCount              = Convert.ToDouble(line[5]);
                    double noHosts                     = Convert.ToDouble(line[6]);
                    double underHosts                  = Convert.ToDouble(line[7]);
                    double overHosts                   = Convert.ToDouble(line[8]);
                    double normalHosts                 = Convert.ToDouble(line[9]);
                    double evacuatingHosts             = Convert.ToDouble(line[10]);
                    double migrations                  = Convert.ToDouble(line[11]);
                    double pushRequests                = Convert.ToDouble(line[12]);
                    double pushLoadAvailabilityRequest = Convert.ToDouble(line[13]);
                    double pullRequests                = Convert.ToDouble(line[14]);
                    double pullLoadAvailabilityRequest = Convert.ToDouble(line[15]);
                    double totalMessages               = Convert.ToDouble(line[16]);
                    double slaViolationsCount          = Convert.ToDouble(line[17]);
                    double slaViolationsPercent        = Convert.ToDouble(line[18]);

                    double         minNeeded        = Convert.ToDouble(line[19]);
                    double         maxNeeded        = Convert.ToDouble(line[20]);
                    double         power            = Convert.ToDouble(line[21]);
                    double         stdDev           = Convert.ToDouble(line[22]);
                    double         imagePulls       = Convert.ToDouble(line[23]);
                    double         communicatedSize = Convert.ToDouble(line[24]);
                    MeasuresValues m = new MeasuresValues(pushRequests, pullRequests, idealHostCount, noHosts,
                                                          migrations,
                                                          totalMessages, entropy, predictedEntropy, pushLoadAvailabilityRequest,
                                                          pullLoadAvailabilityRequest,
                                                          avgRealVolume, avgPredictedVolume, minNeeded, maxNeeded,
                                                          underHosts, overHosts, normalHosts, evacuatingHosts,
                                                          slaViolationsCount, slaViolationsPercent,
                                                          power, stdDev, imagePulls, communicatedSize);
                    holder.MeasuredValuesList.Add(m);
                }
            }

            var nfile = mainFile.Replace("All", "ConMig");

            using (StreamReader reader = new StreamReader(new FileStream(nfile, FileMode.Open)))
            {
                reader.ReadLine();
                while (!reader.EndOfStream)
                {
                    var    line  = reader.ReadLine().Split(',');
                    int    conId = Convert.ToInt32(line[0]);
                    double count = Convert.ToDouble(line[1]);
                    double time  = Convert.ToDouble(line[2]);
                    holder.ContainerMeasureValuesList.Add(conId, new ContainerMeasureValue(conId, count, time));
                }
            }

            nfile = mainFile.Replace("All", "Hosts");
            using (StreamReader reader = new StreamReader(new FileStream(nfile, FileMode.Open)))
            {
                List <HostLoadInfo> list = new List <HostLoadInfo>();
                int current = 0;
                reader.ReadLine();
                while (!reader.EndOfStream)
                {
                    //iteration,Id,cpu,mem,io,concount,cpuutil,memutil,ioutil,
                    var    line        = reader.ReadLine().Split(',');
                    int    it          = Convert.ToInt32(line[0]);
                    int    hostId      = Convert.ToInt32(line[1]);
                    double cpu         = Convert.ToDouble(line[2]);
                    double mem         = Convert.ToDouble(line[3]);
                    double io          = Convert.ToDouble(line[4]);
                    int    concount    = Convert.ToInt32(line[5]);
                    double cpuutil     = Convert.ToDouble(line[6]);
                    double memutil     = Convert.ToDouble(line[7]);
                    double ioutil      = Convert.ToDouble(line[8]);
                    double dataSizeOut = Convert.ToDouble(line[9]);
                    double dataSizeIn  = Convert.ToDouble(line[10]);

                    var linfo = new HostLoadInfo(hostId, new Load(cpu, mem, io), concount, cpuutil, memutil, ioutil, dataSizeOut, dataSizeIn);
                    if (it == current)
                    {
                        list.Add(linfo);
                    }
                    else
                    {
                        holder.HostMeasureValuesList.Add(new HostMeasureValues(list));
                        list.Clear();
                        list.Add(linfo);
                        current++;
                    }
                }
            }
            if (containerType == ContainersType.D)
            {
                nfile = mainFile.Replace("All", "PullsPerImage");
                using (StreamReader reader = new StreamReader(new FileStream(nfile, FileMode.Open)))
                {
                    reader.ReadLine();
                    while (!reader.EndOfStream)
                    {
                        var line    = reader.ReadLine().Split(',');
                        int ImageId = Convert.ToInt32(line[0]);
                        int Pulls   = Convert.ToInt32(line[1]);
                        holder.PullsPerImage.Add(ImageId, Pulls);
                    }
                }
            }

            return(holder);
        }