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;
}
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);
}
}
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;
}
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;
}
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));
}
public void TestCasesShouldPassForDifference()
{
var result = SchedulingAlgorithm.Run("c:\\temp\\homework2_1_test1.txt", (w, l) => w - l);
Assert.AreEqual(688647, result);
}
public void TestCasesShouldPassForRatio()
{
var result = SchedulingAlgorithm.Run("c:\\temp\\homework2_1_test1.txt", (w, l) => w / l);
Assert.AreEqual(674634, result);
}
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);
}
public override void ExecuteAlgorithm()
{
SchedulingAlgorithm.ApplyAlgorithm();
Console.WriteLine("in Windows 32 Api...");
}
public override void ExecuteAlgorithm()
{
SchedulingAlgorithm.ApplyAlgorithm();
Console.WriteLine("in Linux kernel...");
}
public AuctionScheduler(UtilizationTable holder, NetworkInterfaceCard communicationModule, IMachinePowerController powerContoller, SchedulingAlgorithm schedulingAlgorithm) : base(holder, communicationModule, powerContoller)
{
this.schedulingAlgorithm = schedulingAlgorithm;
}