public Disassembler(VM target)
: base("Disassembler", Handle.GetContextByID(target.HandleID).DeepCopy(), HandleParameters.DISASSEMBLE | HandleParameters.NOJMP | HandleParameters.NOBREAK)
{
// Target will hold a reference to the VM
Target = target;
// Create a new address range to disassemble(the loaded instructions)
Map = new AddressMap();
Map.AddRange(new AddressRange(Target.GetMemory().SegmentMap[".main"].Range.Start, Target.GetMemory().SegmentMap[".main"].Range.End));
// When the target VM calls flash(), the context reference will change, so it is necessary to listen for this and update accordingly.
target.Flash += UpdateTarget;
// When the target finishes execution, update the address marked as RIP and the new RIP.
target.RunComplete += (status) =>
{
// These conditions will only pass if the address is present. It would be perfectly normal for it not to,
// for example when all the instructions have been executed, $RIP is out of the disassembly.
if ((Map.Search(status.InitialRIP).Info | AddressMap.BinarySearchResult.ResultInfo.PRESENT) == Map.Search(status.InitialRIP).Info)
{
ToggleSetting(status.InitialRIP, AddressInfo.RIP);
}
if ((Map.Search(status.EndRIP).Info | AddressMap.BinarySearchResult.ResultInfo.PRESENT) == Map.Search(status.InitialRIP).Info)
{
ToggleSetting(status.EndRIP, AddressInfo.RIP);
}
};
// Listen for changes to breakpoints on the target VM.
target.Breakpoints.OnAdd += (addr, index) => ToggleSetting(addr, AddressInfo.BREAKPOINT);
target.Breakpoints.OnRemove += (addr, index) => ToggleSetting(addr, AddressInfo.BREAKPOINT);
}
private void button2_Click(object sender, EventArgs e)
{
if (listBox1.SelectedIndex > -1)
{
AddressMap map = listBox1.Tag as AddressMap;
AddressAndPort f = MapManager.ParseFrom(listBox1.Items[listBox1.SelectedIndex].ToString());
int id = map[f].Item1;
AddressAndPort from = new AddressAndPort()
{
Address = textBox1.Text.Trim(), Port = (int)numericUpDown1.Value
};
List <AddressAndPort> to = MapManager.ParseTo(listBox2.Items[listBox1.SelectedIndex].ToString());
if (MapManager.UpdateMap(id, new KeyValuePair <AddressAndPort, List <AddressAndPort> >(from, to), textBox3.Text.Trim()))
{
map[f] = new Tuple <int, List <AddressAndPort>, string>(id, to, textBox3.Text.Trim());
listBox1.Items[listBox1.SelectedIndex] = from;
MessageBox.Show("修改映射成功！");
}
else
{
MessageBox.Show("修改映射失败！");
}
MapManager.Dispose();
}
else
{
MessageBox.Show("请选定一个映射！");
}
}
private AddressMap.AddressRegion TryCreateRegion(AddressMap.AddressRegion delRegion,
int offset, int length, int addr, out AddressMap.AddResult result)
{
AddressMap tmpMap = mProject.AddrMap.Clone();
if (delRegion != null && !tmpMap.RemoveEntry(delRegion.Offset, delRegion.Length))
{
Debug.Assert(false, "Failed to remove existing region");
result = AddressMap.AddResult.InternalError;
return(null);
}
result = tmpMap.AddEntry(offset, length, addr);
if (result != AddressMap.AddResult.Okay)
{
return(null);
}
AddressMap.AddressRegion newRegion = tmpMap.FindRegion(offset, length);
if (newRegion == null)
{
// Shouldn't happen.
Debug.Assert(false, "Failed to find region we just created");
result = AddressMap.AddResult.InternalError;
return(null);
}
return(newRegion);
}
private static void UpdateHomeCacheDataByAddressMap(AddressMap addressMap)
{
if (addressMap != null)
{
UpdateHomeCacheData(addressMap.AddressSysNo);
}
}
private void LoadMaps()
{
listBox1.Items.Clear();
listBox2.Items.Clear();
try
{
MapManager.LoadMap();
AddressMap map = MapManager.Map;
foreach (AddressAndPort from in map.Froms)
{
listBox1.Items.Add(from.ToString());
List <AddressAndPort> tos = map[from].Item2;
StringBuilder sb = new StringBuilder();
tos.ForEach(e => sb.Append(e.ToString() + "|"));
string sbb = sb.ToString();
if (sb.Length > 0)
{
sbb = sbb.Substring(0, sbb.Length - 1);
}
listBox2.Items.Add(sbb);
}
listBox1.Tag = map;
}
catch (Exception ex)
{
MessageBox.Show("载入映射失败：" + ex.Message);
}
finally
{
MapManager.Dispose();
}
}
/// <summary>
/// Remove All IPConfig
/// </summary>
public static void RemoveAllConfigIP()
{
AddressMap.Clear();
MACMap.Clear();
IPConfig.RemoveAll();
NetworkConfig.Clear();
}
private void button3_Click(object sender, EventArgs e)
{
if (listBox1.SelectedIndex > -1)
{
if (MessageBox.Show("确定要删除该映射么？", "删除提醒", MessageBoxButtons.OKCancel) == DialogResult.OK)
{
Tuple <int, List <AddressAndPort> > tos = listBox1.Tag as Tuple <int, List <AddressAndPort> >;
int id = tos.Item1;
AddressAndPort from = new AddressAndPort()
{
Address = textBox1.Text.Trim(), Port = (int)numericUpDown1.Value
};
if (MapManager.DeleteMap(id))
{
AddressMap map = listBox1.Tag as AddressMap;
map.RemoveFrom(from);
listBox1.Items.RemoveAt(listBox1.SelectedIndex);
listBox2.Items.RemoveAt(listBox1.SelectedIndex);
MessageBox.Show("删除成功！");
}
else
{
MessageBox.Show("删除失败！");
}
MapManager.Dispose();
}
}
else
{
MessageBox.Show("请选定一个映射！");
}
}
/// <summary>
/// 更新AddressMap信息
/// </summary>
public static void UpdateAddressMapImg(AddressMap entity)
{
DataCommand cmd = new DataCommand("UpdateAddressMapImg");
cmd.SetParameter <AddressMap>(entity);
cmd.ExecuteNonQuery();
}
protected override bool setSpecialParameter(string flag_type, string flag_val)
{
// string[] values = new string[Config.Ng];
// char[] splitter = { ',' };
// TODO: this is meaningless right now
switch (flag_type)
{
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;
default:
return(false);
}
return(true);
}
/// <summary>
/// Set ConfigIP for NetworkDevice
/// </summary>
/// <param name="nic">Network device.</param>
/// /// <param name="config">IP Config</param>
private static void SetConfigIP(NetworkDevice nic, IPConfig config)
{
NetworkConfig.Add(nic, config);
AddressMap.Add(config.IPAddress.Hash, nic);
MACMap.Add(nic.MACAddress.Hash, nic);
IPConfig.Add(config);
nic.DataReceived = HandlePacket;
}
public JsonResult InsertOrUpdateAddressMapImg(AddressMap data)
{
SetEntityBaseUserInfo(data);
data.SysNo = AddressMapService.InsertOrUpdateAddressMapImg(data);
return(Json(new AjaxResult {
Success = true, Data = data
}));
}
public static void RemoveIPConfig(NetworkDevice nic)
{
IPV4.Config config = NetworkConfig.Get(nic);
AddressMap.Remove(config.IPAddress.Hash);
MACMap.Remove(nic.MACAddress.Hash);
IPV4.Config.Remove(config);
NetworkConfig.Remove(nic);
}
public static int InsertAddressMap(AddressMap entity)
{
var sysNo = AddressMapDA.InsertAddressMap(entity);
UpdateHomeCacheData(entity.AddressSysNo);
return(sysNo);
}
/// <summary>
/// 创建AddressMap信息
/// </summary>
public static int InsertAddressMap(AddressMap entity)
{
DataCommand cmd = new DataCommand("InsertAddressMap");
cmd.SetParameter <AddressMap>(entity);
int result = cmd.ExecuteScalar <int>();
return(result);
}
public virtual AddressMap ParseCustomAddressMap(AddressMap input, List <string> columns, IXLTableRow row)
{
if (input == null)
{
input = new AddressMap();
}
return(input);
}
public AddressMapTests()
{
var context = new TestIwsContext();
addressMap = new AddressMap(context);
context.Countries.Add(TestableCountry.UnitedKingdom);
context.Countries.Add(TestableCountry.Switzerland);
context.Countries.Add(TestableCountry.France);
}
private OrganisationUserMap MakeTestOrganisationUserMap()
{
var addressMapper = new AddressMap();
var contactMapper = new ContactMap();
var userMapper = new UserMap();
var orgMapper = new OrganisationMap(addressMapper, contactMapper);
return(new OrganisationUserMap(orgMapper, userMapper));
}
/// <summary>
/// 获取单个AddressMap信息
/// </summary>
public static AddressMap LoadAddressMap(int sysNo)
{
DataCommand cmd = new DataCommand("LoadAddressMap");
cmd.SetParameter("@SysNo", DbType.Int32, sysNo);
AddressMap result = cmd.ExecuteEntity <AddressMap>();
return(result);
}
public TinyRTC(II2CBus bus, byte clockI2CAddress = 0x68, byte eepromI2CAddress = 0x50, int clockRateKhz = 100)
{
_clock = new DS1307(bus, clockI2CAddress, clockRateKhz);
//_eeprom = new _eeprom(bus, eepromI2CAddress, clockRateKhz);
_addressedMemoryMap = new AddressMap();
// 4k byte of ram on eeprom >> Virtual Address 0..3999
// 56 byte of ram on clock >> Virtual Address 5000..5055
_addressedMemoryMap.MapRange(0, 3999, address => address, _eeprom);
}
public AddressMapTests()
{
var context = new TestIwsContext();
addressMap = new AddressMap(context);
context.Countries.Add(TestableCountry.UnitedKingdom);
context.Countries.Add(TestableCountry.Switzerland);
context.Countries.Add(TestableCountry.France);
}
public ulong GetAdress(AppModel model)
{
if (model == null)
{
return(0x0);
}
AddressMap map = model.GetAddressMap();
ulong adress = map.Where(k => k.Value is AppMethod).FirstOrDefault(m => ((AppMethod)m.Value).Method == ((MethodBase)Il2CppMethod)).Key;
return(adress);
}
/// <summary>
/// Invokes the Prepare() method on all active plugins.
/// </summary>
/// <param name="appRef">Reference to host object providing app services.</param>
/// <param name="addrEntries">Serialized AddressMap entries.</param>
/// <param name="plSyms">SymbolTable contents, converted to PlSymbol.</param>
public void PreparePlugins(IApplication appRef,
List<AddressMap.AddressMapEntry> addrEntries, List<PlSymbol> plSyms)
{
AddressMap addrMap = new AddressMap(addrEntries);
AddressTranslate addrTrans = new AddressTranslate(addrMap);
foreach (KeyValuePair<string, IPlugin> kvp in mActivePlugins) {
IPlugin ipl = kvp.Value;
ipl.Prepare(appRef, mFileData, addrTrans);
if (ipl is IPlugin_SymbolList) {
((IPlugin_SymbolList)ipl).UpdateSymbolList(plSyms);
}
}
}
public async Task CreateBillingInformation(BillingInformation billingInformation)
{
var insertAddress = new AddressMap(billingInformation.BillingAddress);
insertAddress.AddressId = Guid.NewGuid().ToString();
await _addressCollection.InsertOneAsync(insertAddress);
var insertBillingInformation = new BillingInformationMap(billingInformation);
insertBillingInformation.BillingInformationId = Guid.NewGuid().ToString();
insertBillingInformation.ReferenceBillingAddressId = insertAddress.AddressId;
await _billingInformationCollection.InsertOneAsync(insertBillingInformation);
}
/// <summary>
/// Configure a IP configuration on the given network device.
/// <remarks>Multiple IP Configurations can be made, like *nix environments</remarks>
/// </summary>
/// <param name="nic"><see cref="NetworkDevice"/> that will have the assigned configuration</param>
/// <param name="config"><see cref="IPV4.Config"/> instance that defines the IP Address, Subnet
/// Mask and Default Gateway for the device</param>
public static void ConfigIP(NetworkDevice nic, IPV4.Config config)
{
if (NetworkConfig.ContainsKey(nic))
{
Console.WriteLine("Config Exists!");
IPV4.Config toremove = NetworkConfig.Get(nic);
AddressMap.Remove(toremove.IPAddress.Hash);
MACMap.Remove(nic.MACAddress.Hash);
IPV4.Config.Remove(config);
NetworkConfig.Remove(nic);
SetConfigIP(nic, config);
}
else
{
SetConfigIP(nic, config);
}
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
listBox2.SelectedIndex = listBox1.SelectedIndex;
AddressMap map = listBox1.Tag as AddressMap;
AddressAndPort from = MapManager.ParseFrom(listBox1.Items[listBox1.SelectedIndex].ToString());
textBox1.Text = from.Address;
numericUpDown1.Value = from.Port;
textBox3.Text = map.GetRemark(from);
List <AddressAndPort> tos = MapManager.ParseTo(listBox2.Items[listBox1.SelectedIndex].ToString());
if (tos.Count > 0)
{
AddressAndPort to = tos[0];
textBox2.Text = to.Address;
numericUpDown2.Value = to.Port;
}
}
public static int InsertOrUpdateAddressMapImg(AddressMap entity)
{
var addressMaps = AddressMapDA.QueryAddressMapList(new AddressMapFilter {
AddressSysNo = entity.AddressSysNo, PageSize = 100
}).data;
if (addressMaps.Count > 0)
{
entity.SysNo = addressMaps.First().SysNo;
AddressMapDA.UpdateAddressMapImg(entity);
UpdateHomeCacheData(entity.AddressSysNo);
}
else
{
entity.SysNo = InsertAddressMap(entity);
}
return(entity.SysNo);
}
/// <summary>
/// Invokes the Prepare() method on all active plugins.
/// </summary>
/// <param name="appRef">Reference to host object providing app services.</param>
/// <param name="spanLength">Length of data spanned by address map.</param>
/// <param name="addrEntries">Serialized AddressMap entries.</param>
/// <param name="plSyms">SymbolTable contents, converted to PlSymbol.</param>
public void PreparePlugins(IApplication appRef, int spanLength,
List <AddressMap.AddressMapEntry> addrEntries, List <PlSymbol> plSyms)
{
AddressMap addrMap = new AddressMap(spanLength, addrEntries);
AddressTranslate addrTrans = new AddressTranslate(addrMap);
foreach (KeyValuePair <string, IPlugin> kvp in mActivePlugins)
{
IPlugin ipl = kvp.Value;
ipl.Prepare(appRef, mFileData, addrTrans);
if (ipl is IPlugin_SymbolList)
{
try {
((IPlugin_SymbolList)ipl).UpdateSymbolList(plSyms);
} catch (Exception ex) {
throw new Exception("Failed in UpdateSymbolList(" + kvp.Key + ")", ex);
}
}
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
var map = AddressMap.GetAddressMap(Debugger);
if (Address != 0)
{
foreach (var region in AddressMap.GetMemoryRegionsForAddress(Debugger, Address))
{
WriteObject(region);
}
}
else
{
foreach (var region in map.Regions)
{
WriteObject(region);
}
}
}
public void InheritTest()
{
var addressMap = new AddressMap()
{
VariableName = "1"
};
var wrapper = new AddressDataWrapper()
{
VariableName = "1"
};
var addressMaps = new List <AddressMap> {
addressMap, wrapper
};
var wrappers = new List <AddressDataWrapper> {
wrapper
};
//var a = wrappers.ConvertAll<AddressMap>();
InheritMethod1(wrapper);
InheritMethod2(addressMaps);
}
protected override bool setSpecialParameter(string flag_type, string flag_val)
{
// string[] values = new string[Config.Ng];
// char[] splitter = { ',' };
// TODO: this is meaningless right now
switch (flag_type)
{
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;
default:
return false;
}
return true;
}
public void ScanString(string str, ref int referenceAddress, IDictionary <byte, string> charLookup, bool scanCodesOnly,
out IList <string> references, out ISet <IControlCode> controlCodes)
{
references = new List <string>();
controlCodes = new HashSet <IControlCode>();
for (int i = 0; i < str.Length;)
{
if (str[i] == '[')
{
if (str.IndexOf(']', i + 1) == -1)
{
throw new Exception("Opening bracket has no matching closing bracket: position " + i);
}
string[] codeStrings = str.Substring(i + 1, str.IndexOf(']', i + 1) - i - 1)
.Split(' ');
IControlCode code = ControlCodes.FirstOrDefault(c => c.IsMatch(codeStrings));
if (!controlCodes.Contains(code))
{
controlCodes.Add(code);
}
foreach (var codeString in codeStrings)
{
if (codeString[0] == '_')
{
if (codeString[codeString.Length - 1] != '_')
{
throw new Exception("Reference has no closing underscore: position " + i);
}
if (codeString.Length <= 2)
{
throw new Exception("Reference is empty: position " + i);
}
if (!scanCodesOnly)
{
referenceAddress += 4;
}
references.Add(codeString.Substring(1, codeString.Length - 2));
}
else if (IsHexByte(codeString))
{
if (!scanCodesOnly)
{
referenceAddress++;
}
}
else
{
throw new Exception(String.Format(
"Encountered invalid code string at position {0}: {1}", i, codeString));
}
}
i = str.IndexOf(']', i + 1) + 1;
}
else if (str[i] == ']')
{
throw new Exception("Closing bracket has no matching opening bracket: position " + i);
}
else if (str[i] == '^')
{
if (str.IndexOf('^', i + 1) == -1)
{
throw new Exception("Label has no matching closing caret: position " + i);
}
string label = str.Substring(i + 1, str.IndexOf('^', i + 1) - i - 1);
if (AddressMap.ContainsKey(label))
{
throw new Exception("Label already defined: position " + i);
}
if (!scanCodesOnly)
{
AddressMap.Add(label, referenceAddress);
}
i = str.IndexOf('^', i + 1) + 1;
}
else
{
if (!(str[i] == '\r') && !(str[i] == '\n'))
{
if (!scanCodesOnly)
{
GetByte(str[i], charLookup); // just check if it's valid
referenceAddress++;
}
}
i++;
}
}
}
private void InheritMethod1(AddressMap addressMap)
{
}
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;
}
private OrganisationUserMap MakeTestOrganisationUserMap()
{
var addressMapper = new AddressMap();
var contactMapper = new ContactMap();
var userMapper = new UserMap();
var orgMapper = new OrganisationMap(addressMapper, contactMapper);
return new OrganisationUserMap(orgMapper, userMapper);
}
