示例#1
0
        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);
        }
示例#2
0
文件: Mem.cs 项目: hoangt/NOCulator
        /**
         * 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
示例#3
0
        /**
         * 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
示例#4
0
        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;
        }