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);
}
/**
* A
*/
public static MemSched alloc_sched(Bank[] bank, int buf_size, MemSchedAlgo mem_sched_algo, bool wb_special_sched)
{
if (wb_special_sched)
switch (mem_sched_algo) {
case MemSchedAlgo.FairMemScheduler:
return new Ideal_MM_MemoryScheduler_WB(buf_size, bank);
case MemSchedAlgo.FRFCFS:
return new FR_FCFS_WB(buf_size, bank);
case MemSchedAlgo.FCFS:
return new FCFS_MemoryScheduler_WB(buf_size, bank);
case MemSchedAlgo.NesbitBasic:
return new Nesbit_Basic_MemoryScheduler_WB(buf_size, bank);
case MemSchedAlgo.NesbitFull:
return new Nesbit_Full_MemoryScheduler_WB(buf_size, bank);
case MemSchedAlgo.FairMemMicro:
return new Ideal_MICRO_MemoryScheduler_WB(buf_size, bank);
case MemSchedAlgo.FR_FCFS_Cap:
return new FR_FCFS_Cap_WB(buf_size, bank);
default:
Debug.Assert(false);
return null;
}
switch (mem_sched_algo) {
//LAS_BA --- start
case MemSchedAlgo.LAS_BA_FR:
return new LAS_BA_FR(buf_size, bank);
case MemSchedAlgo.FR_LAS_BA:
return new FR_LAS_BA(buf_size, bank);
case MemSchedAlgo.LAS_BA2_FR:
return new LAS_BA2_FR(buf_size, bank);
//LAS_BA --- end
case MemSchedAlgo.FairMemScheduler:
return new Ideal_MM_MemoryScheduler(buf_size, bank);
case MemSchedAlgo.LAS_FCFS_F1:
return new LAS_FCFS_F1(buf_size, bank);
case MemSchedAlgo.LAS_FCFS_F2:
return new LAS_FCFS_F2(buf_size, bank);
case MemSchedAlgo.LAS_FCFS:
return new LAS_FCFS(buf_size, bank);
case MemSchedAlgo.LAS_FR_FCFS:
return new LAS_FR_FCFS(buf_size, bank);
case MemSchedAlgo.LAS_QT_FCFS:
return new LAS_QT_FCFS(buf_size, bank);
case MemSchedAlgo.LAS_QT_FR_FCFS:
return new LAS_QT_FR_FCFS(buf_size, bank);
case MemSchedAlgo.FR_LAS_QT_FCFS:
return new FR_LAS_QT_FCFS(buf_size, bank);
case MemSchedAlgo.FR_SLACK_LAS_QT_FCFS:
return new FR_SLACK_LAS_QT_FCFS(buf_size, bank);
case MemSchedAlgo.OUR:
return new OUR(buf_size, bank);
case MemSchedAlgo.LAS_FR_FCFS_FAIR_TS:
return new LAS_FR_FCFS_FAIR_TS(buf_size, bank);
case MemSchedAlgo.LAS_FCFS_FAIR_TS:
return new LAS_FCFS_FAIR_TS(buf_size, bank);
case MemSchedAlgo.FR_LAS_FCFS:
return new FR_LAS_FCFS(buf_size, bank);
case MemSchedAlgo.FRFCFS:
Console.WriteLine("FRFCFS initiated");
return new FR_FCFS(buf_size, bank);
case MemSchedAlgo.FCFS:
Console.WriteLine("FCFS initiated");
return new FCFS(buf_size, bank);
case MemSchedAlgo.PLL:
Console.WriteLine("PLL initiated");
return new PLL_MemoryScheduler(buf_size, bank);
case MemSchedAlgo.PURE_PRIORITY_SCHEME:
return new PURE_PRIORITY_SCHEME_MemoryScheduler(buf_size, bank);
case MemSchedAlgo.STATIC_BATCH:
return new STATIC_BATCH(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo);
case MemSchedAlgo.FULL_BATCH:
return new FULL_BATCH(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo);
case MemSchedAlgo.FULL_BATCH_RV:
return new FULL_BATCH_RV(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo);
case MemSchedAlgo.PERBANK_FULL_BATCH:
return new PERBANK_FULL_BATCH_MemoryScheduler(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo);
case MemSchedAlgo.EMPTY_SLOT_FULL_BATCH:
return new EMPTY_SLOT_FULL_BATCH_MemoryScheduler(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo);
case MemSchedAlgo.STATIC_BATCH_WITH_PRIORITIES:
return new STATIC_BATCH_WITH_PRIORITIES_MemoryScheduler(buf_size, bank, Config.memory.ranking_algo);
case MemSchedAlgo.FULL_BATCH_WITH_PRIORITIES:
return new FULL_BATCH_WITH_PRIORITIES_MemoryScheduler(buf_size, bank, Config.memory.ranking_algo);
case MemSchedAlgo.NesbitBasic:
return new Nesbit_Basic_MemoryScheduler(buf_size, bank);
case MemSchedAlgo.NesbitFull:
return new Nesbit_Full_MemoryScheduler(buf_size, bank);
case MemSchedAlgo.FairMemMicro:
return new Ideal_MICRO_MemoryScheduler(buf_size, bank);
case MemSchedAlgo.FR_FCFS_Cap:
return new FR_FCFS_Cap(buf_size, bank);
default:
Debug.Assert(false);
return null;
}//switch
}//alloc_sched
/**
* A
*/
public static MemSched alloc_sched(Bank[] bank, int buf_size, MemSchedAlgo mem_sched_algo, bool wb_special_sched)
{
if (wb_special_sched)
{
switch (mem_sched_algo)
{
case MemSchedAlgo.FairMemScheduler:
return(new Ideal_MM_MemoryScheduler_WB(buf_size, bank));
case MemSchedAlgo.FRFCFS:
return(new FR_FCFS_WB(buf_size, bank));
case MemSchedAlgo.FCFS:
return(new FCFS_MemoryScheduler_WB(buf_size, bank));
case MemSchedAlgo.NesbitBasic:
return(new Nesbit_Basic_MemoryScheduler_WB(buf_size, bank));
case MemSchedAlgo.NesbitFull:
return(new Nesbit_Full_MemoryScheduler_WB(buf_size, bank));
case MemSchedAlgo.FairMemMicro:
return(new Ideal_MICRO_MemoryScheduler_WB(buf_size, bank));
case MemSchedAlgo.FR_FCFS_Cap:
return(new FR_FCFS_Cap_WB(buf_size, bank));
default:
Debug.Assert(false);
return(null);
}
}
switch (mem_sched_algo)
{
//LAS_BA --- start
case MemSchedAlgo.LAS_BA_FR:
return(new LAS_BA_FR(buf_size, bank));
case MemSchedAlgo.FR_LAS_BA:
return(new FR_LAS_BA(buf_size, bank));
case MemSchedAlgo.LAS_BA2_FR:
return(new LAS_BA2_FR(buf_size, bank));
//LAS_BA --- end
case MemSchedAlgo.FairMemScheduler:
return(new Ideal_MM_MemoryScheduler(buf_size, bank));
case MemSchedAlgo.LAS_FCFS_F1:
return(new LAS_FCFS_F1(buf_size, bank));
case MemSchedAlgo.LAS_FCFS_F2:
return(new LAS_FCFS_F2(buf_size, bank));
case MemSchedAlgo.LAS_FCFS:
return(new LAS_FCFS(buf_size, bank));
case MemSchedAlgo.LAS_FR_FCFS:
return(new LAS_FR_FCFS(buf_size, bank));
case MemSchedAlgo.LAS_QT_FCFS:
return(new LAS_QT_FCFS(buf_size, bank));
case MemSchedAlgo.LAS_QT_FR_FCFS:
return(new LAS_QT_FR_FCFS(buf_size, bank));
case MemSchedAlgo.FR_LAS_QT_FCFS:
return(new FR_LAS_QT_FCFS(buf_size, bank));
case MemSchedAlgo.FR_SLACK_LAS_QT_FCFS:
return(new FR_SLACK_LAS_QT_FCFS(buf_size, bank));
case MemSchedAlgo.OUR:
return(new OUR(buf_size, bank));
case MemSchedAlgo.LAS_FR_FCFS_FAIR_TS:
return(new LAS_FR_FCFS_FAIR_TS(buf_size, bank));
case MemSchedAlgo.LAS_FCFS_FAIR_TS:
return(new LAS_FCFS_FAIR_TS(buf_size, bank));
case MemSchedAlgo.FR_LAS_FCFS:
return(new FR_LAS_FCFS(buf_size, bank));
case MemSchedAlgo.FRFCFS:
Console.WriteLine("FRFCFS initiated");
return(new FR_FCFS(buf_size, bank));
case MemSchedAlgo.FCFS:
Console.WriteLine("FCFS initiated");
return(new FCFS(buf_size, bank));
case MemSchedAlgo.PLL:
Console.WriteLine("PLL initiated");
return(new PLL_MemoryScheduler(buf_size, bank));
case MemSchedAlgo.PURE_PRIORITY_SCHEME:
return(new PURE_PRIORITY_SCHEME_MemoryScheduler(buf_size, bank));
case MemSchedAlgo.STATIC_BATCH:
return(new STATIC_BATCH(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo));
case MemSchedAlgo.FULL_BATCH:
return(new FULL_BATCH(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo));
case MemSchedAlgo.FULL_BATCH_RV:
return(new FULL_BATCH_RV(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo));
case MemSchedAlgo.PERBANK_FULL_BATCH:
return(new PERBANK_FULL_BATCH_MemoryScheduler(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo));
case MemSchedAlgo.EMPTY_SLOT_FULL_BATCH:
return(new EMPTY_SLOT_FULL_BATCH_MemoryScheduler(buf_size, bank, Config.memory.ranking_algo, Config.memory.batch_sched_algo));
case MemSchedAlgo.STATIC_BATCH_WITH_PRIORITIES:
return(new STATIC_BATCH_WITH_PRIORITIES_MemoryScheduler(buf_size, bank, Config.memory.ranking_algo));
case MemSchedAlgo.FULL_BATCH_WITH_PRIORITIES:
return(new FULL_BATCH_WITH_PRIORITIES_MemoryScheduler(buf_size, bank, Config.memory.ranking_algo));
case MemSchedAlgo.NesbitBasic:
return(new Nesbit_Basic_MemoryScheduler(buf_size, bank));
case MemSchedAlgo.NesbitFull:
return(new Nesbit_Full_MemoryScheduler(buf_size, bank));
case MemSchedAlgo.FairMemMicro:
return(new Ideal_MICRO_MemoryScheduler(buf_size, bank));
case MemSchedAlgo.FR_FCFS_Cap:
return(new FR_FCFS_Cap(buf_size, bank));
default:
Debug.Assert(false);
return(null);
} //switch
} //alloc_sched
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;
}
