コード例 #1
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;
 }
コード例 #2
0
        public MasterMachine(NetworkSwitch networkSwitch, IMachinePowerController powerController,
                             UtilizationTable holder, Strategies strategy, AuctionTypes pushAuctionType, AuctionTypes pullAuctionType,
                             SchedulingAlgorithm scheduling,
                             TestedHosts testedHosts)
            : base(0, networkSwitch)
        {
            switch (strategy)
            {
            case Strategies.WAshraf2017Auction:
                _handler = new AuctionManagement(CommunicationModule, powerController, holder, testedHosts);
                break;

            case Strategies.WAshraf2017:
                _handler = new InorderPropingManagement(CommunicationModule, powerController, holder);
                break;

            case Strategies.Zhao:
                _handler = new NoMasterHandlerModule(CommunicationModule);
                break;

            case Strategies.ForsmanPush:
                _handler = new NoMasterHandlerModule(CommunicationModule);
                break;

            case Strategies.ForsmanPull:
                _handler = new NoMasterHandlerModule(CommunicationModule);
                break;

            case Strategies.Proposed2018:

                _handler = new ProposedMasterHandler(CommunicationModule, powerController, holder, testedHosts, pushAuctionType, pullAuctionType);
                break;

            default:

                throw new ArgumentOutOfRangeException(nameof(strategy), strategy, null);
            }

            Holder = holder;
            //StartMachine();
            switch (scheduling)
            {
            case SchedulingAlgorithm.FF:
                scheduler = new FirstFitScheduler(holder, CommunicationModule, powerController);
                break;

            case SchedulingAlgorithm.MFull:
            case SchedulingAlgorithm.LFull:
                scheduler = new AuctionScheduler(holder, CommunicationModule, powerController, scheduling);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(scheduling), scheduling, null);
            }
        }
コード例 #3
0
ファイル: Options.cs プロジェクト: nicknash/RelaSharp
 public Options(bool help, bool quietMode, bool selfTest, string testTag, int iterations, bool listExamples, SchedulingAlgorithm scheduling, ulong liveLockLimit, int yieldLookbackPenalty)
 {
     Help                 = help;
     QuietMode            = quietMode;
     SelfTest             = selfTest;
     TestTag              = testTag;
     Iterations           = iterations;
     ListExamples         = listExamples;
     Scheduling           = scheduling;
     LiveLockLimit        = liveLockLimit;
     YieldLookbackPenalty = yieldLookbackPenalty;
 }
コード例 #4
0
 public MasterFactory(NetworkSwitch networkSwitchObject,
                      MachineController machineControllerObject,
                      UtilizationTable utilizationTable,
                      Strategies currentStrategy,
                      AuctionTypes pushAuctionType,
                      AuctionTypes pullAuctionType,
                      SchedulingAlgorithm schedulingAlgorithm,
                      TestedHosts testedHostsCount) : base(networkSwitchObject)
 {
     this.networkSwitchObject     = networkSwitchObject;
     this.machineControllerObject = machineControllerObject;
     this.utilizationTable        = utilizationTable;
     this.currentStrategy         = currentStrategy;
     PushAuctionType          = pushAuctionType;
     PullAuctionType          = pullAuctionType;
     this.schedulingAlgorithm = schedulingAlgorithm;
     this.testedHostsCount    = testedHostsCount;
 }
コード例 #5
0
ファイル: Options.cs プロジェクト: nicknash/RelaSharp
        public static Options GetOptions(string[] args)
        {
            Func <string, int, string> takeTrim = (arg, idx) => arg.Contains('=') ? arg.Split('=')[idx].Trim() : arg.Trim();
            var   argMap               = args.ToDictionary(a => takeTrim(a, 0), a => takeTrim(a, 1));
            bool  quietMode            = argMap.ContainsKey("--quiet");
            int   iterations           = GetOptionValue("--iterations", argMap, Int32.Parse, DefaultIterations, Console.Error);
            ulong liveLockLimit        = GetOptionValue("--live-lock", argMap, UInt64.Parse, DefaultLiveLockLimit, Console.Error);
            int   yieldLookbackPenalty = GetOptionValue("--yield-penalty", argMap, Int32.Parse, DefaultYieldLookbackPenalty, Console.Error);


            bool   selfTest = argMap.ContainsKey("--self-test");
            string testTag  = GetOptionValue("--tag", argMap, s => s, null, Console.Error);

            bool listExamples = argMap.ContainsKey("--list-examples");
            bool help         = argMap.ContainsKey("--help");
            SchedulingAlgorithm scheduling = GetOptionValue("--scheduling", argMap, s => (SchedulingAlgorithm)Enum.Parse(typeof(SchedulingAlgorithm), s, true), DefaultScheduling, Console.Error);

            return(new Options(help, quietMode, selfTest, testTag, iterations, listExamples, scheduling, liveLockLimit, yieldLookbackPenalty));
        }
コード例 #6
0
        public void TestCasesShouldPassForDifference()
        {
            var result = SchedulingAlgorithm.Run("c:\\temp\\homework2_1_test1.txt", (w, l) => w - l);

            Assert.AreEqual(688647, result);
        }
コード例 #7
0
        public void TestCasesShouldPassForRatio()
        {
            var result = SchedulingAlgorithm.Run("c:\\temp\\homework2_1_test1.txt", (w, l) => w / l);

            Assert.AreEqual(674634, result);
        }
コード例 #8
0
        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);
        }
コード例 #9
0
 public override void ExecuteAlgorithm()
 {
     SchedulingAlgorithm.ApplyAlgorithm();
     Console.WriteLine("in Windows 32 Api...");
 }
コード例 #10
0
 public override void ExecuteAlgorithm()
 {
     SchedulingAlgorithm.ApplyAlgorithm();
     Console.WriteLine("in Linux kernel...");
 }
コード例 #11
0
 public AuctionScheduler(UtilizationTable holder, NetworkInterfaceCard communicationModule, IMachinePowerController powerContoller, SchedulingAlgorithm schedulingAlgorithm) : base(holder, communicationModule, powerContoller)
 {
     this.schedulingAlgorithm = schedulingAlgorithm;
 }