public BatchMemSchedHelper bhelper; //ranking algorithm helper
/**
* Constructor
*/
public BatchMemSched(int buf_size, Bank[] bank, RankAlgo rank_algo, BatchSchedAlgo batch_sched_algo)
: base(buf_size, bank)
{
//stat
bstat = new BatchMemSchedStat(this);
//components
this.rank_algo = rank_algo;
this.batch_sched_algo = batch_sched_algo;
rank_to_proc = new int[Config.N];
proc_to_rank = new int[Config.N];
for (int p = 0; p < Config.N; p++) {
rank_to_proc[p] = p;
proc_to_rank[p] = Config.N - 1;
}
//batch formulation; marking
markable = new MemoryRequest[Config.N][][];
for (int p = 0; p < Config.N; p++) {
markable[p] = new MemoryRequest[bank_max][];
for (int b = 0; b < bank_max; b++) {
markable[p][b] = new MemoryRequest[markable_len];
}
}
markable_cnt = new int[Config.N][];
for (int p = 0; p < Config.N; p++) {
markable_cnt[p] = new int[bank_max];
}
markable_cnt_unbound = new int[Config.N][];
for (int p = 0; p < Config.N; p++) {
markable_cnt_unbound[p] = new int[bank_max];
}
//marked requests per processor
cur_marked_per_proc = new int[Config.N];
cur_period_marked_per_proc = new int[Config.N];
//marked requests per processor, bank
cur_marked_per_procbank = new int[Config.N, bank_max];
cur_period_marked_per_procbank = new int[Config.N, bank_max];
//bhelper
bhelper = new BatchMemSchedHelper(this);
Console.WriteLine("Initialized BATCH_MemoryScheduler");
Console.WriteLine("Ranking Scheme: " + rank_algo.ToString());
Console.WriteLine("WithinBatch Priority: " + batch_sched_algo.ToString());
Console.WriteLine("BatchingCap: " + Config.memory.batch_cap);
}
public BATCH_WITH_PRIORITIES_MemoryScheduler(int totalSize, Bank[] bank, RankAlgo rankingScheme)
: base(totalSize, bank)
{
this.rankingScheme = rankingScheme;
procRank = new int[Config.N];
Rank = new int[Config.N];
markedReqThisBatchPerPriority = new int[Config.memory.prio_max];
curMarkedPerProc = new int[Config.N];
curMarkedPerProcBank = new int[Config.N, Config.memory.bank_max_per_mem];
exceedsBatchingCap = new bool[Config.N, Config.memory.bank_max_per_mem];
threadPriority = new int[Config.N];
minimumPriorityLevel = Config.memory.prio_max + 1;
for (int p = 0; p < Config.N; p++)
{
threadPriority[p] = (int)Config.memory.weight[p]; // TODO: Properly rescale between weights and priorities!
Console.WriteLine("Processor " + p + " has priority-level: " + threadPriority[p]);
if (threadPriority[p] < minimumPriorityLevel)
{
minimumPriorityLevel = threadPriority[p];
}
}
avgNumReqPerProcRemark = new double[Config.N];
avgMaxReqPerProcRemark = new double[Config.N];
avgNumReqPerProcRecomp = new ulong[Config.N];
avgMaxReqPerProcRecomp = new ulong[Config.N];
avgMarkedReqAtBatchEnd = new ulong[Config.N];
avgNumMarkedReqPerProcRemark = new double[Config.N];
avgMaxMarkedReqPerProcRemark = new double[Config.N];
finalavgNumMarkedReqPerProcRemark = new double[Config.N];
finalavgMaxMarkedReqPerProcRemark = new double[Config.N];
markCountPerPriority = new ulong[Config.memory.prio_max];
finalmarkCountPerPriority = new ulong[Config.N];
finalavgNumReqPerProcRemark = new double[Config.N];
finalavgMaxReqPerProcRemark = new double[Config.N];
finalavgNumReqPerProcRecomp = new double[Config.N];
finalavgMaxReqPerProcRecomp = new double[Config.N];
finalavgMarkedReqAtBatchEnd = new double[Config.N];
avgFullBatchingDuration = new ulong[Config.N];
finalavgFullBatchingDuration = new double[Config.N];
batchStart = new ulong[Config.memory.prio_max];
for (int i = 0; i < Config.N; i++)
{
procRank[i] = i;
Rank[i] = Config.N - 1;
}
Console.WriteLine("Initialized BATCH_WITH_PRIORITIES_MemoryScheduler");
Console.WriteLine("Ranking Scheme: " + rankingScheme.ToString());
}
public BATCH_WITH_PRIORITIES_MemoryScheduler(int totalSize, Bank[] bank, RankAlgo rankingScheme)
: base(totalSize, bank)
{
this.rankingScheme = rankingScheme;
procRank = new int[Config.N];
Rank = new int[Config.N];
markedReqThisBatchPerPriority = new int[Config.memory.prio_max];
curMarkedPerProc = new int[Config.N];
curMarkedPerProcBank = new int[Config.N, Config.memory.bank_max_per_mem];
exceedsBatchingCap = new bool[Config.N, Config.memory.bank_max_per_mem];
threadPriority = new int[Config.N];
minimumPriorityLevel = Config.memory.prio_max + 1;
for (int p = 0; p < Config.N; p++) {
threadPriority[p] = (int)Config.memory.weight[p]; // TODO: Properly rescale between weights and priorities!
Console.WriteLine("Processor " + p + " has priority-level: " + threadPriority[p]);
if (threadPriority[p] < minimumPriorityLevel) minimumPriorityLevel = threadPriority[p];
}
avgNumReqPerProcRemark = new double[Config.N];
avgMaxReqPerProcRemark = new double[Config.N];
avgNumReqPerProcRecomp = new ulong[Config.N];
avgMaxReqPerProcRecomp = new ulong[Config.N];
avgMarkedReqAtBatchEnd = new ulong[Config.N];
avgNumMarkedReqPerProcRemark = new double[Config.N];
avgMaxMarkedReqPerProcRemark = new double[Config.N];
finalavgNumMarkedReqPerProcRemark = new double[Config.N];
finalavgMaxMarkedReqPerProcRemark = new double[Config.N];
markCountPerPriority = new ulong[Config.memory.prio_max];
finalmarkCountPerPriority = new ulong[Config.N];
finalavgNumReqPerProcRemark = new double[Config.N];
finalavgMaxReqPerProcRemark = new double[Config.N];
finalavgNumReqPerProcRecomp = new double[Config.N];
finalavgMaxReqPerProcRecomp = new double[Config.N];
finalavgMarkedReqAtBatchEnd = new double[Config.N];
avgFullBatchingDuration = new ulong[Config.N];
finalavgFullBatchingDuration = new double[Config.N];
batchStart = new ulong[Config.memory.prio_max];
for (int i = 0; i < Config.N; i++) {
procRank[i] = i;
Rank[i] = Config.N - 1;
}
Console.WriteLine("Initialized BATCH_WITH_PRIORITIES_MemoryScheduler");
Console.WriteLine("Ranking Scheme: " + rankingScheme.ToString());
}
public STATIC_BATCH(int buf_size, Bank[] bank,
RankAlgo rank_algo, BatchSchedAlgo batch_sched_algo)
: base(buf_size, bank, rank_algo, batch_sched_algo)
{
Console.WriteLine("Initialized STATIC_BATCH_MemoryScheduler");
}
public FULL_BATCH_WITH_PRIORITIES_MemoryScheduler(int totalSize, Bank[] bank, RankAlgo rankingScheme)
: base(totalSize, bank, rankingScheme)
{
Console.WriteLine("Initialized FULL_WITH_PRIORITIES_BATCH_MemoryScheduler");
}
public FULL_BATCH_WITH_PRIORITIES_MemoryScheduler(int totalSize, Bank[] bank, RankAlgo rankingScheme)
: base(totalSize, bank, rankingScheme)
{
Console.WriteLine("Initialized FULL_WITH_PRIORITIES_BATCH_MemoryScheduler");
}
public FULL_BATCH(int total_size, Bank[] bank, RankAlgo rank_algo, BatchSchedAlgo batch_sched_algo)
: base(total_size, bank, rank_algo, batch_sched_algo)
{
Console.WriteLine("Initialized FULL_BATCH_MemoryScheduler");
}
public FULL_BATCH_RV(int total_size, Bank[] bank, RankAlgo rank_algo, BatchSchedAlgo batch_sched_algo)
: base(total_size, bank, rank_algo, batch_sched_algo)
{
Console.WriteLine("Initialized FULL_BATCH_RV_MemoryScheduler");
}
public List <Coord> MCLocations = new List <Coord>(); //summary> List of node coordinates with an MC </summary>
protected override bool setSpecialParameter(string flag_type, string flag_val)
{
string[] values = new string[Config.N];
char[] splitter = { ',' };
switch (flag_type)
{
//LAS_BA --- start
case "batch_cycles":
LAS_BA_batch_cycles = int.Parse(flag_val); break;
case "threshold_cycles":
LAS_BA_threshold_cycles = int.Parse(flag_val); break;
case "OUR_threshold_cycles":
OUR_threshold_cycles = int.Parse(flag_val); break;
case "miniframe_cycles":
OUR_miniframe_cycles = int.Parse(flag_val); break;
case "frame_cycles":
OUR_frame_cycles = int.Parse(flag_val); break;
case "history_weight":
LAS_BA_history_weight = double.Parse(flag_val); break;
//LAS_BA --- end
case "TimeDecay":
time_decay = int.Parse(flag_val); break;
case "AddressMap":
switch (flag_val)
{
case "BMR":
address_mapping = AddressMap.BMR; break;
case "BRM":
address_mapping = AddressMap.BRM; break;
case "MBR":
address_mapping = AddressMap.MBR; break;
case "MRB":
address_mapping = AddressMap.MRB; break;
default:
Console.WriteLine("AddressMap " + flag_val + " not found");
Environment.Exit(-1);
break;
}
break;
case "MaxWait":
max_wait_thresh = int.Parse(flag_val); break;
/*
* case "NrOfMemBits":
* mem_bit = int.Parse(flag_val); break;
* case "NrOfCacheLineBits":
* row_bit = int.Parse(flag_val); break;
* case "NrOfBankIndexBits":
* bank_bit = int.Parse(flag_val); break;
* case "NumberOfMemory":
* mem_max = int.Parse(flag_val); break;
*/
case "IsSharedMC":
is_shared_MC = bool.Parse(flag_val); break;
case "BufferSizePerThread":
buf_size_per_proc = int.Parse(flag_val); break;
case "TotalBufferSize":
buf_size_per_mem = int.Parse(flag_val); break;
case "ClosedRowBufferTime":
row_closed_latency = (int)(int.Parse(flag_val)); break;
case "RowBufferHit":
row_hit_latency = (int)(int.Parse(flag_val)); break;
case "RowCap": // old CapThreshold parameter except enforces a cap based on number of row hits serviced before a conflict
row_hit_cap = (int)(int.Parse(flag_val)); break;
case "BankConflictTime":
row_conflict_latency = (int)(int.Parse(flag_val)); break;
case "RowBufferDisabled":
row_same_latency = (bool)(bool.Parse(flag_val)); Console.WriteLine("Row buffer " + row_same_latency); break;
case "Alpha":
alpha = double.Parse(flag_val, NumberStyles.Float); break;
case "Beta":
beta = ulong.Parse(flag_val); break;
case "MinNrOfSamples":
sample_min = int.Parse(flag_val); break;
case "ParallelismFactor":
paral_factor = double.Parse(flag_val, NumberStyles.Float); break;
case "MinimumBatchLength":
full_batch_min_batch_length = ulong.Parse(flag_val); break;
case "IgnoreParallelism":
ignore_paral = int.Parse(flag_val); break;
case "IgnoreWritebacks":
ignore_wb = int.Parse(flag_val); break;
case "UseWeights":
use_weight = int.Parse(flag_val); break;
case "RecomputationPeriod":
recomp_interval = (ulong.Parse(flag_val)); Console.WriteLine(recomp_interval); break;
case "MarkingPeriod":
mark_interval = (ulong.Parse(flag_val)); Console.WriteLine(mark_interval); break;
case "CapThreshold":
prio_inv_thresh = (ulong.Parse(flag_val)); break;
case "WBFillFraction":
wb_full_ratio = double.Parse(flag_val, NumberStyles.Float); break;
case "WBSpecialScheduling":
int temp = int.Parse(flag_val);
if (temp == 0)
{
wb_special_sched = false;
}
else if (temp == 1)
{
wb_special_sched = true;
}
break;
case "IdlenessFrequency":
values = flag_val.Split(splitter);
for (int p = 0; p < values.Length; p++)
{
idle_freq[p] = int.Parse(values[p]);
}
for (int p = values.Length; p < Config.N; p++)
{
idle_freq[p] = 0;
}
break;
case "IdlenessDuration":
values = flag_val.Split(splitter);
for (int p = 0; p < values.Length; p++)
{
idle_duration[p] = int.Parse(values[p]);
}
for (int p = values.Length; p < Config.N; p++)
{
idle_duration[p] = 0;
}
break;
case "Weights":
values = flag_val.Split(splitter);
for (int p = 0; p < values.Length; p++)
{
weight[p] = double.Parse(values[p], NumberStyles.Float);
}
break;
case "IdlenessStartShift":
values = flag_val.Split(splitter);
for (int p = 0; p < values.Length; p++)
{
idle_start_shift[p] = int.Parse(values[p]);
}
for (int p = values.Length; p < Config.N; p++)
{
idle_start_shift[p] = 0;
}
break;
case "BatchingCap":
batch_cap = int.Parse(flag_val); break;
case "LoadBalance0":
load_balance0 = bool.Parse(flag_val); break;
case "LoadBalance1":
load_balance1 = bool.Parse(flag_val); break;
case "ConstantRerank":
constant_rerank = bool.Parse(flag_val); break;
//Ranking Algorithm
case "RankingScheme":
switch (flag_val)
{
case "ect":
ranking_algo = RankAlgo.ECT_RANKING;
break;
case "ect-rv":
ranking_algo = RankAlgo.ECT_RV_RANKING;
break;
case "max-tot":
ranking_algo = RankAlgo.MAX_TOT_RANKING;
break;
case "tot-max":
ranking_algo = RankAlgo.TOT_MAX_RANKING;
break;
case "max-tot-reverse":
ranking_algo = RankAlgo.MAX_TOT_REVERSE_RANKING;
break;
case "round-robin":
ranking_algo = RankAlgo.ROUND_ROBIN_RANKING;
break;
case "random":
ranking_algo = RankAlgo.RANDOM_RANKING;
break;
case "no-ranking":
ranking_algo = RankAlgo.NO_RANKING;
break;
case "rba-max-tot":
ranking_algo = RankAlgo.ROW_BUFFER_AWARE_MAX_RANKING;
break;
case "lp":
ranking_algo = RankAlgo.PERBANK_LP_RANKING;
break;
case "sjf":
ranking_algo = RankAlgo.PERBANK_SJF_RANKING;
break;
default:
Console.WriteLine("Ranking Scheme " + flag_val + " not found");
Environment.Exit(-1);
break;
}
break;
//Within Batch Priority
case "WithinBatchPriority":
switch (flag_val)
{
case "rank-fr-fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_RANK_FR_FCFS;
break;
case "fr-rank-fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_FR_RANK_FCFS;
break;
case "rank-fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_RANK_FCFS;
break;
case "fr-fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_FR_FCFS;
break;
case "fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_FCFS;
break;
default:
Console.WriteLine("WithinBatchPriority " + flag_val + " not found");
Environment.Exit(-1);
break;
}
break;
case "ACTSampleInterval":
ACTSamplingBatchInterval = int.Parse(flag_val); break;
case "kValue":
k_value = int.Parse(flag_val); break;
/*********************
* Scheduling Algorithm
********************/
case "LasReset":
las_reset = bool.Parse(flag_val); break;
case "ServiceOverlap":
service_overlap = bool.Parse(flag_val); break;
case "LasPeriodicReset":
las_periodic_reset = ulong.Parse(flag_val); break;
case "RamAlgorithm":
mem_sched_algo = (MemSchedAlgo)Enum.Parse(typeof(MemSchedAlgo), flag_val); break;
case "MCLocations":
parseMCLocations(flag_val); break;
default:
return(false);
}
return(true);
}
public PERBANK_BATCH_MemoryScheduler(int totalSize, Bank[] bank,
RankAlgo rankingScheme, BatchSchedAlgo withinBatchPriority)
: base(totalSize, bank)
{
this.rankingScheme = rankingScheme;
this.withinBatchPriority = withinBatchPriority;
procRank = new int[Config.N];
Rank = new int[Config.N];
perBankprocRank = new int[Config.N, Config.memory.bank_max_per_mem];
perBankRank = new int[Config.N, Config.memory.bank_max_per_mem];
curMarkedPerProc = new int[Config.N];
thisPeriodMarkedPerProc = new int[Config.N];
avgNumReqPerProcRemark = new double[Config.N];
avgMaxReqPerProcRemark = new double[Config.N];
avgNumMarkedReqPerProcRemark = new double[Config.N];
avgMaxMarkedReqPerProcRemark = new double[Config.N];
avgNumReqPerProcRecomp = new ulong[Config.N];
avgMaxReqPerProcRecomp = new ulong[Config.N];
avgMarkedReqAtBatchEnd = new ulong[Config.N];
totalBatchCompletionTime = new ulong[Config.N];
numberOfActiveBatches = new ulong[Config.N];
sample_totalBatchCompletionTime = new ulong[Config.N];
sample_numberOfActiveBatches = new ulong[Config.N];
LPoptimal_totalBatchCompletionTime = new ulong[Config.N];
LPoptimal_numberOfActiveBatches = new ulong[Config.N];
nrTotalMarkedRequests = new ulong[Config.N];
nrTotalRequests = new ulong[Config.N];
finalavgNumReqPerProcRemark = new double[Config.N];
finalavgMaxReqPerProcRemark = new double[Config.N];
finalavgNumMarkedReqPerProcRemark = new double[Config.N];
finalavgMaxMarkedReqPerProcRemark = new double[Config.N];
finalavgNumReqPerProcRecomp = new double[Config.N];
finalavgMaxReqPerProcRecomp = new double[Config.N];
finalavgMarkedReqAtBatchEnd = new double[Config.N];
finaltotalBatchCompletionTime = new ulong[Config.N];
finalnumberOfActiveBatches = new ulong[Config.N];
final_sample_totalBatchCompletionTime = new ulong[Config.N];
final_sample_numberOfActiveBatches = new ulong[Config.N];
final_LPoptimal_totalBatchCompletionTime = new ulong[Config.N];
final_LPoptimal_numberOfActiveBatches = new ulong[Config.N];
finalnrTotalMarkedRequests = new ulong[Config.N];
finalnrTotalRequests = new ulong[Config.N];
curMarkedPerProcBank = new int[Config.N, Config.memory.bank_max_per_mem];
thisPeriodMarkedPerProcBank = new int[Config.N, Config.memory.bank_max_per_mem];
exceedsBatchingCap = new bool[Config.N, Config.memory.bank_max_per_mem];
thisPeriodMarkedMaxPerProc = new int[Config.N];
thisPeriodMarkedTotalPerProc = new int[Config.N];
for (int i = 0; i < Config.N; i++)
{
procRank[i] = i;
Rank[i] = Config.N - 1;
for (int b = 0; b < Config.memory.bank_max_per_mem; b++)
{
perBankprocRank[i, b] = i;
perBankRank[i, b] = Config.N - 1;
}
}
Console.WriteLine("Initialized PERBANK_BATCH_MemoryScheduler");
Console.WriteLine("Ranking Scheme: " + rankingScheme.ToString() + " Sampling: " + Config.memory.ACTSamplingBatchInterval);
Console.WriteLine("WithinBatch Priority: " + withinBatchPriority.ToString());
Console.WriteLine("BatchingCap: " + Config.memory.batch_cap);
}
public EMPTY_SLOT_FULL_BATCH_MemoryScheduler(int totalSize, Bank[] bank,
RankAlgo rankingScheme, BatchSchedAlgo withinBatchPriority)
: base(totalSize, bank, rankingScheme, withinBatchPriority)
{
Console.WriteLine("Initialized EMPTY_SLOT_FULL_BATCH_MemoryScheduler");
}
public List<Coord> MCLocations = new List<Coord>(); //summary> List of node coordinates with an MC </summary>
protected override bool setSpecialParameter(string flag_type, string flag_val)
{
string[] values = new string[Config.N];
char[] splitter = { ',' };
switch (flag_type)
{
//LAS_BA --- start
case "batch_cycles":
LAS_BA_batch_cycles = int.Parse(flag_val); break;
case "threshold_cycles":
LAS_BA_threshold_cycles = int.Parse(flag_val); break;
case "OUR_threshold_cycles":
OUR_threshold_cycles = int.Parse(flag_val); break;
case "miniframe_cycles":
OUR_miniframe_cycles = int.Parse(flag_val); break;
case "frame_cycles":
OUR_frame_cycles = int.Parse(flag_val); break;
case "history_weight":
LAS_BA_history_weight = double.Parse(flag_val); break;
//LAS_BA --- end
case "TimeDecay":
time_decay = int.Parse(flag_val); break;
case "AddressMap":
switch (flag_val) {
case "BMR":
address_mapping = AddressMap.BMR; break;
case "BRM":
address_mapping = AddressMap.BRM; break;
case "MBR":
address_mapping = AddressMap.MBR; break;
case "MRB":
address_mapping = AddressMap.MRB; break;
default:
Console.WriteLine("AddressMap " + flag_val + " not found");
Environment.Exit(-1);
break;
}
break;
case "MaxWait":
max_wait_thresh = int.Parse(flag_val); break;
/*
case "NrOfMemBits":
mem_bit = int.Parse(flag_val); break;
case "NrOfCacheLineBits":
row_bit = int.Parse(flag_val); break;
case "NrOfBankIndexBits":
bank_bit = int.Parse(flag_val); break;
case "NumberOfMemory":
mem_max = int.Parse(flag_val); break;
*/
case "IsSharedMC":
is_shared_MC = bool.Parse(flag_val); break;
case "BufferSizePerThread":
buf_size_per_proc = int.Parse(flag_val); break;
case "TotalBufferSize":
buf_size_per_mem = int.Parse(flag_val); break;
case "ClosedRowBufferTime":
row_closed_latency = (int)(int.Parse(flag_val)); break;
case "RowBufferHit":
row_hit_latency = (int)(int.Parse(flag_val)); break;
case "RowCap": // old CapThreshold parameter except enforces a cap based on number of row hits serviced before a conflict
row_hit_cap = (int)(int.Parse(flag_val)); break;
case "BankConflictTime":
row_conflict_latency = (int)(int.Parse(flag_val)); break;
case "RowBufferDisabled":
row_same_latency = (bool)(bool.Parse(flag_val)); Console.WriteLine("Row buffer " + row_same_latency); break;
case "Alpha":
alpha = double.Parse(flag_val, NumberStyles.Float); break;
case "Beta":
beta = ulong.Parse(flag_val); break;
case "MinNrOfSamples":
sample_min = int.Parse(flag_val); break;
case "ParallelismFactor":
paral_factor = double.Parse(flag_val, NumberStyles.Float); break;
case "MinimumBatchLength":
full_batch_min_batch_length = ulong.Parse(flag_val); break;
case "IgnoreParallelism":
ignore_paral = int.Parse(flag_val); break;
case "IgnoreWritebacks":
ignore_wb = int.Parse(flag_val); break;
case "UseWeights":
use_weight = int.Parse(flag_val); break;
case "RecomputationPeriod":
recomp_interval = (ulong.Parse(flag_val)); Console.WriteLine(recomp_interval); break;
case "MarkingPeriod":
mark_interval = (ulong.Parse(flag_val)); Console.WriteLine(mark_interval); break;
case "CapThreshold":
prio_inv_thresh = (ulong.Parse(flag_val)); break;
case "WBFillFraction":
wb_full_ratio = double.Parse(flag_val, NumberStyles.Float); break;
case "WBSpecialScheduling":
int temp = int.Parse(flag_val);
if (temp == 0)
wb_special_sched = false;
else if (temp == 1)
wb_special_sched = true;
break;
case "IdlenessFrequency":
values = flag_val.Split(splitter);
for (int p = 0; p < values.Length; p++)
{
idle_freq[p] = int.Parse(values[p]);
}
for (int p = values.Length; p < Config.N; p++)
{
idle_freq[p] = 0;
}
break;
case "IdlenessDuration":
values = flag_val.Split(splitter);
for (int p = 0; p < values.Length; p++)
{
idle_duration[p] = int.Parse(values[p]);
}
for (int p = values.Length; p < Config.N; p++)
{
idle_duration[p] = 0;
}
break;
case "Weights":
values = flag_val.Split(splitter);
for (int p = 0; p < values.Length; p++)
{
weight[p] = double.Parse(values[p], NumberStyles.Float);
}
break;
case "IdlenessStartShift":
values = flag_val.Split(splitter);
for (int p = 0; p < values.Length; p++)
{
idle_start_shift[p] = int.Parse(values[p]);
}
for (int p = values.Length; p < Config.N; p++)
{
idle_start_shift[p] = 0;
}
break;
case "BatchingCap":
batch_cap = int.Parse(flag_val); break;
case "LoadBalance0":
load_balance0 = bool.Parse(flag_val); break;
case "LoadBalance1":
load_balance1 = bool.Parse(flag_val); break;
case "ConstantRerank":
constant_rerank = bool.Parse(flag_val); break;
//Ranking Algorithm
case "RankingScheme":
switch (flag_val) {
case "ect":
ranking_algo = RankAlgo.ECT_RANKING;
break;
case "ect-rv":
ranking_algo = RankAlgo.ECT_RV_RANKING;
break;
case "max-tot":
ranking_algo = RankAlgo.MAX_TOT_RANKING;
break;
case "tot-max":
ranking_algo = RankAlgo.TOT_MAX_RANKING;
break;
case "max-tot-reverse":
ranking_algo = RankAlgo.MAX_TOT_REVERSE_RANKING;
break;
case "round-robin":
ranking_algo = RankAlgo.ROUND_ROBIN_RANKING;
break;
case "random":
ranking_algo = RankAlgo.RANDOM_RANKING;
break;
case "no-ranking":
ranking_algo = RankAlgo.NO_RANKING;
break;
case "rba-max-tot":
ranking_algo = RankAlgo.ROW_BUFFER_AWARE_MAX_RANKING;
break;
case "lp":
ranking_algo = RankAlgo.PERBANK_LP_RANKING;
break;
case "sjf":
ranking_algo = RankAlgo.PERBANK_SJF_RANKING;
break;
default:
Console.WriteLine("Ranking Scheme " + flag_val + " not found");
Environment.Exit(-1);
break;
}
break;
//Within Batch Priority
case "WithinBatchPriority":
switch (flag_val) {
case "rank-fr-fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_RANK_FR_FCFS;
break;
case "fr-rank-fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_FR_RANK_FCFS;
break;
case "rank-fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_RANK_FCFS;
break;
case "fr-fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_FR_FCFS;
break;
case "fcfs":
batch_sched_algo = BatchSchedAlgo.MARKED_FCFS;
break;
default:
Console.WriteLine("WithinBatchPriority " + flag_val + " not found");
Environment.Exit(-1);
break;
}
break;
case "ACTSampleInterval":
ACTSamplingBatchInterval = int.Parse(flag_val); break;
case "kValue":
k_value = int.Parse(flag_val); break;
/*********************
* Scheduling Algorithm
********************/
case "LasReset":
las_reset = bool.Parse(flag_val); break;
case "ServiceOverlap":
service_overlap = bool.Parse(flag_val); break;
case "LasPeriodicReset":
las_periodic_reset = ulong.Parse(flag_val); break;
case "RamAlgorithm":
mem_sched_algo = (MemSchedAlgo)Enum.Parse(typeof(MemSchedAlgo), flag_val); break;
case "MCLocations":
parseMCLocations(flag_val); break;
default:
return false;
}
return true;
}
