// ========== Copyright Header Begin ========================================== // // OpenSPARC T2 Processor File: sparcParams.vr // Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved // 4150 Network Circle, Santa Clara, California 95054, U.S.A. // // * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. // // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; version 2 of the License. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // For the avoidance of doubt, and except that if any non-GPL license // choice is available it will apply instead, Sun elects to use only // the General Public License version 2 (GPLv2) at this time for any // software where a choice of GPL license versions is made // available with the language indicating that GPLv2 or any later version // may be used, or where a choice of which version of the GPL is applied is // otherwise unspecified. // // Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, // CA 95054 USA or visit www.sun.com if you need additional information or // have any questions. // // ========== Copyright Header End ============================================ #include #include // defines #include #include #include #include // classes #include #include class Params extends BaseParams { local string className = "paramsClass"; local StandardDisplay dbg; // Temporary/scratch variables local string tempstr, tempstr2; local reg [2048:0] getstr; local integer i; local bit [63:0] tmp; // misc integer coreCount = 0; /////////////////////////////////////// // variables that only come in as +args (not in a config file) string paramPath = null; string paramFile = null; string forceParamFile = null; string dv_root = null; // reg [63:0] thread_enables = 1; // CCX reg ccxPktPrint [5]; // print packets reg [16:0] ccxPktPrintMask = 0; reg ccxPktPrintOn = 0; // MCU reg mcuMemPrint [2]; reg mcuMemPrintOn = 0; string veraDiagName = null; string asmDiagName = null; // /////////////////////////////////////// /////////////////////////////////////// // config file paramaters (can also be +args) // -- SPC2 specific reg stub_l1_enable; // if 0, disable tag table updates in ccx stub reg [7:0] min_ccx_gnt_delay; reg [7:0] max_ccx_gnt_delay; reg rand_ccx_gnt_enable; reg l2latOn; // To use L2 latency values from file reg l2lat_fixed; // Allow L2 latency to vary integer l2lat_value; // L2 latency between gnt and gnt_data // file names string l2lat_in = null; integer FPl2lat; // Used for file pointers // SPC2 debug testing reg noDebugDrv; reg noDebugChecks; reg noDebugModes; reg showDebugCounts; reg wmrVecMask; integer ssModeFreq; integer ssModeMaxSessions; integer ssModeInterleaveWeight; reg [7:0] ssModeTidMask; integer ssModeMin; integer ssModeMax; integer ssModeBurstMin; integer ssModeBurstMax; integer ssModeHolesMin; integer ssModeHolesMax; integer doModeFreq; integer doModeMaxSessions; reg [7:0] doModeTidMask; integer doModeLenMin; integer doModeLenMax; integer softStopFreq; integer softStopMaxSessions; reg [7:0] softStopTidMask; integer softStopLenMin; integer softStopLenMax; reg nodebugParkExit; // POR/WMR/MBIST/LBIST reg por_enable; reg lbist_enable; reg [2:0] mbist_mode; reg mbist_enable; reg mbist_errinj; reg [7:0] user_loop_count; reg user_loop_mode; reg [15:0] lbist_abort_count; reg [2:0] lbist_run_count; reg lbist_pgm; reg [23:0] mbist_fail_count; //err integer err_freq; integer err_burst_freq; integer err_burst_len_min; integer err_burst_len_max; integer err_ce_wt; integer err_nd_wt; reg rand_err; reg err_itlb_on; integer err_itlb_freq; reg err_dtlb_on; integer err_dtlb_freq; reg err_ic_on; integer err_ic_freq; reg err_dc_on; integer err_dc_freq; reg err_irf_on; integer err_irf_freq; reg err_frf_on; integer err_frf_freq; reg err_stb_on; integer err_stb_freq; reg err_sca_on; integer err_sca_freq; reg err_tcc_on; integer err_tcc_freq; reg err_tsa_on; integer err_tsa_freq; reg err_mra_on; integer err_mra_freq; reg err_l2c_on; integer err_l2c_freq; reg err_mamem_on; integer err_mamem_freq; // -- end SPC2 specific // Coverage Vars reg coverage_on; reg coverage_off; reg force_save_cov; // CMP regs reg [63:0] coreAvilableReg; reg [63:0] coreEnableReg; // copies reduced to 8 reg [7:0] coreAvilable; reg [7:0] coreEnable; reg [2:0] coreMax = 0; // max/highest core number (0-7) reg [3:0] bank_set_mask = 4'hf; reg [7:0] banksMask = 8'hff; // MCU BFM (CMP bench) integer mcuReq2ackDelayMin; integer mcuReq2ackDelayMax; integer mcuAck2dataDelayMin; integer mcuAck2dataDelayMax; integer mcuIntraDataDelayMin; integer mcuIntraDataDelayMax; integer mcuWrReq2ackDelayMin; integer mcuWrReq2ackDelayMax; integer mcuWrReq2ackFullDelay; // CCX BFMs (CMP/CCM bench) reg [7:0] enableSpcBFM; // instantiate if set reg [7:0] enableMemBFM; // instantiate if set integer stallStart; // start stalling when this many outstanding requests integer stallStop; // stop stalling when this many outstanding requests integer hitRate; // percent of time that shorter "hit" latencies will be used integer hitDelayMin; // min value of latency if "hit" integer hitDelayMax; // max value of latency if "hit" integer missDelayMin; // min value of latency if NOT "hit" integer missDelayMax; // max value of latency if NOT "hit" integer pkt2DelayMin; // min value of latency for second pkt of pair integer pkt2DelayMax; // max value of latency for second pkt of pair integer evictFloodFreq; integer evictFloodAmount; reg [7:0] evictFloodTargets; integer bufferFloodFreq; integer bufferFloodAmount; integer bufferFloodTarget; integer burstAmount; integer burstHoldoff; integer burstSync; // misc reg hash_on; integer por_delay_min; // # clocks between POR packets integer por_delay_max; // # clocks between POR packets reg pokeCorners; // concentrate randoms on corner cases. reg show_store; // Display store data to logfile reg show_load; // Display load data to logfile integer inval_rate; // evict # times per 10000 reg [2:0] inval_type; reg[39:0] inval_pa_min; // eviction pa range reg[39:0] inval_pa_max; reg[1:0] l2miss_type; // 0,1,2 - off, on, random reg forcePORstate; // interrupts integer intr_tid; // 1st TID that get Interrupt packet integer intr_delay; // # clocks between Intr packets integer intr_wait; // # clocks before Intr packets reg [1:0] intr_type; // Ext Intr type value reg [5:0] intr_vect; // Ext Intr vector value reg [63:0] intr_en; // Threads that are enabled to send ext Intr // simulation integer maxCycle; // max clks integer timeOut; // idle reg [63:0] finishMask; task new(StandardDisplay dbgin); task getCfg(string fileName); local task getPlus(); task check4conflict(); } task Params::new(StandardDisplay dbgin) { integer i; this.dbg = dbgin; for (i=0;i<5;i++) ccxPktPrint[i] = 0; for (i=0;i<2;i++) mcuMemPrint[i] = 0; this.getPlus(); this.getCfg(paramFile); } // This is where it all happens. Put all knobs, +args here. // Paramater precedence is: // highest) If paramater is a +arg passed into vcs. // middle) If paramater is in the config/param file. // last) Default value given in getParam call. // There will always be a value. // // Any vera testcase can change knobs on the fly, after the fact, // by calling getCfg(path/testcaseTestConfig.cfg); task Params::getCfg(string fileName = null) { integer i; // check to see if fileName is null or bogus // if so, we will be using defaults only. if (fileName.len() < 3) fileName = null; // "open" config/param/knob file for the testcase, even if null! openFile(fileName); // CMP regs coreAvilableReg = getParam(HEX, "ASI_CORE_AVILABLE", 0, 64'hFFFFFFFFFFFFFFFF, 64'hFF); for (i=0;i<8;i++) if (coreAvilableReg[i*8+7:i*8]) { coreAvilable[i] = 1; coreMax = i; } else coreAvilable[i] = 0; coreEnableReg = getParam(HEX, "ASI_CORE_ENABLE", 0, 64'hFFFFFFFFFFFFFFFF, 64'hFF); for (i=0;i<8;i++) if (coreEnableReg[i*8+7:i*8]) { coreEnable[i] = 1; coreCount++; } else coreEnable[i] = 0; // getParam(type,name,min,max,default,RANDOK) // see base class // partial banks bank_set_mask = getParam(HEX, "bank_set_mask", 1, 4'hf, 4'hf); banksMask[1:0] = {bank_set_mask[0],bank_set_mask[0]}; banksMask[3:2] = {bank_set_mask[1],bank_set_mask[1]}; banksMask[5:4] = {bank_set_mask[2],bank_set_mask[2]}; banksMask[7:6] = {bank_set_mask[3],bank_set_mask[3]}; #ifdef CMP_BENCH // MCU // delay from read request to read ack mcuReq2ackDelayMin = getParam(DEC, "mcuReq2ackDelayMin", 1, 500, 1); mcuReq2ackDelayMax = getParam(DEC, "mcuReq2ackDelayMax", 1, 500, 8); // delay from read ack to read data returning mcuAck2dataDelayMin = getParam(DEC, "mcuAck2dataDelayMin", 1, 500, 4); mcuAck2dataDelayMax = getParam(DEC, "mcuAck2dataDelayMax", 1, 500, 11); // delay between the 4 read data chunks mcuIntraDataDelayMin = getParam(DEC, "mcuIntraDataDelayMin", 1, 16, 1); mcuIntraDataDelayMax = getParam(DEC, "mcuIntraDataDelayMax", 1, 16, 9); // delay from write request to write ack mcuWrReq2ackDelayMin = getParam(DEC, "mcuWrReq2ackDelayMin", 1, 500, 2); mcuWrReq2ackDelayMax = getParam(DEC, "mcuWrReq2ackDelayMax", 1, 500, 5); // every 64 writes, really extend the ack delay as if the 8 write buffers are full. mcuWrReq2ackFullDelay = getParam(DEC, "mcuWrReq2ackFullDelay", 1, 500, 6); #endif // CCX BFMs instantiate if set enableSpcBFM = getParam(HEX, "enableSpcBFM", 0, 8'hff, 8'h00); enableMemBFM = getParam(HEX, "enableMemBFM", 0, 8'hff, 8'h00); // CCX BFMs // getArray(DEC, "knobName", min, max, default, variableName, elementCount); // // percent of time that shorter "hit" latencies will be used hitRate = getParam(DEC, "hitRate", 1, 100, 90); // min value of latency if "hit" hitDelayMin = getParam(DEC, "hitDelayMin", 1, 30, 1); // max value of latency if "hit" hitDelayMax = getParam(DEC, "hitDelayMax", 2, 60, 5); // min value of latency if NOT "hit" missDelayMin = getParam(DEC, "missDelayMin", 1, 100, 10); // max value of latency if NOT "hit" missDelayMax = getParam(DEC, "missDelayMax", 2, 500, 20); // min value of latency for second pkt of pair pkt2DelayMin = getParam(DEC, "pkt2DelayMin", 1, 3, 1); // max value of latency for second pkt of pair pkt2DelayMax = getParam(DEC, "pkt2DelayMax", 1, 5, 3); // start stalling when this many outstanding requests // Number of cores * 8 (should be based on # cores) stallStart = getParam(DEC, "stallStart", 4, 50, coreCount*8); // stallStartNcu = (DEC, "stallStartNcu", 4, 50, coreCount*12); // stop stalling when this many outstanding requests // Number of cores * 8 - 2 (should be based on # cores) stallStop = getParam(DEC, "stallStop", 2, 45, (coreCount*8)-3); // make responses bursty. Will burst once there are this many responses held up. burstAmount = getParam(DEC, "burstAmount", 0, 35, 0); // Will always burst when this many clocks have elapsed. Prevents starvation. burstHoldoff = getParam(DEC, "burstHoldoff", 10, 500, 150); // Setting burstSync will cause all banks to burst at once // if possible. All banks will follow the master bank when it bursts. // +burstSync=master <0-16> port number burstSync = getParam(DEC, "burstSync", 0, 16, 99); // CCX coverage/irritator activity. Flood of bogus evictions. evictFloodFreq = getParam(DEC, "evictFloodFreq", 0, 100000, 0); evictFloodAmount = getParam(DEC, "evictFloodAmount", 1, 100, 10); evictFloodTargets = getParam(HEX, "evictFloodTargets", 1, 8'hff, 1); // CCX coverage/irritator activity. ifills followed by evictions. // Will target any SPC port that does not have a real core. bufferFloodFreq = getParam(DEC, "bufferFloodFreq", 0, 100000, 0); bufferFloodAmount = getParam(DEC, "bufferFloodAmount", 1, 100, 10); bufferFloodTarget = getParam(HEX, "bufferFloodTarget", 0, 7, 7); hash_on = getParam(FLAG, "hash_on", 0, 1, 0); // clocks between POR por_delay_min = getParam(DEC, "por_delay_min", 1, 10000, 25); por_delay_max = getParam(DEC, "por_delay_max", 1, 20000, 200); // FC like state for SPC forcePORstate = getParam(FLAG, "forcePORstate", 0, 1, 0); // concentrate randoms on corner cases (if you coded it that way). pokeCorners = getParam(DEC, "pokeCorners", 0, 1, 0); // interrupts (from spc) // 1st TID that get Interrupt packet intr_tid = getParam(DEC,"intr_tid", 0, 63, RAND, RANDOK); // # clocks between Intr packets intr_delay = getParam(DEC,"intr_delay", 0, 100000, 10); // # clocks before Intr packets intr_wait = getParam(DEC,"intr_wait", 0, 100000, 3000); // Ext Intr type value intr_type = getParam(HEX, "intr_type", 0, 32'hffffffff, INTR_RESET); // Ext Intr vector value intr_vect = getParam(HEX, "intr_vect", 0, 32'hffffffff, INTR_XIR); // Threads that are enabled to send ext Intr intr_en = getParam(HEX, "intr_en", 0, 64'hFFFFFFFFFFFFFFFF, 0); // # times per 10000 to evict inval_rate = getParam(DEC, "inval_rate", 0, 10000, 0); // Default OFF inval_type = getParam(DEC, "inval_type", 1, 7, 1); // Default evict only inval_pa_min = getParam(HEX, "inval_pa_min", 0, 40'hffffffffff, 0); inval_pa_max = getParam(HEX, "inval_pa_max", 0, 40'hffffffffff, 40'hffffffffff); // value that CCX stub will use for l2miss l2miss_type = getParam(HEX, "l2miss_type", 0, 2'h2, 2'h2); // sim maxCycle = getParam(DEC,"max_cycle", 0, MAXINT,MAXINT);//,*,NOWARN); // max clks timeOut = getParam(DEC,"TIMEOUT", 0, MAXINT,MAXINT);//,*,NOWARN); // idle timmer show_store = getParam(FLAG, "show_store", 0, 1, 0); show_load = getParam(FLAG, "show_load", 0, 1, 0); // coverage force_save_cov = getParam(FLAG, "force_save_cov", 0, 1, 0); coverage_on = getParam(FLAG, "coverage_on", 0, 1, 0); coverage_on = ~getParam(FLAG, "coverage_off", 0, 1, 0); // // // debug logic testing // // // #ifdef SPC_BENCH // enable warm reset vector wmrVecMask = getParam(FLAG, "wmrVecMask", 0, 1, 0); // enable fast boot wmrVecMask = getParam(FLAG, "fast_boot", 0, 1, 0); // alias // do not use showDebugCounts = getParam(FLAG, "showDebugCounts", 0, 1, 0); // no vera driver noDebugDrv = getParam(FLAG, "noDebugDrv", 0, 1, 0); #endif // no verilog checker noDebugChecks = getParam(FLAG, "noDebugChecks", 0, 1, 0); // cancel all use of debug knobs. for diags that can not do debug. noDebugModes = getParam(FLAG, "noDebugModes", 0, 1, 0); // ssModeFreq = initiate SS session every freq clocks. ssModeFreq = getParam(DEC, "ssModeFreq", 0, 100000, 0); // ssModeMaxSessions = limit SS sessions to this many sessions ssModeMaxSessions = getParam(DEC, "ssModeMaxSessions", 0, 100, 50); // ssModeInterleaveWeight = do interleaving or not within SS session based on weight ssModeInterleaveWeight = getParam(DEC, "ssModeInterleaveWeight", 0, 100, 40); // ssModeTidMask = which tids to involve in SS sessions ssModeTidMask = getParam(HEX, "ssModeTidMask", 0, 8'hff, 0); // ssModeBurstMin,ssModeBurstMax = how many steps to take per tid interleave ssModeBurstMin = getParam(DEC, "ssModeBurstMin", 0, 500, 10); ssModeBurstMax = getParam(DEC, "ssModeBurstMax", 1, 500, 250); // ssModeMin,ssModeMax = how many total steps to take per SS session ssModeMin = getParam(DEC, "ssModeMin", 0, 5000, 20+ssModeBurstMin); ssModeMax = getParam(DEC, "ssModeMax", 1, 5000, 500+ssModeBurstMax); // let dead clks pass before next SS req in session ssModeHolesMin = getParam(DEC, "ssModeHolesMin", 0, 500, 0); ssModeHolesMax = getParam(DEC, "ssModeHolesMax", 1, 500, 10); // doModeFreq = initiate session every freq clocks. doModeFreq = getParam(DEC, "doModeFreq", 0, 100000, 0); // doModeMaxSessions = limit DO sessions to this many sessions doModeMaxSessions = getParam(DEC, "doModeMaxSessions", 0, 100, 50); // doModeTidMask = which tids to involve in sessions doModeTidMask = getParam(DEC, "doModeTidMask", 0, 8'hff, 0); // doModeLenMin,doModeLenMax = how many total clocks to run per session doModeLenMin = getParam(DEC, "doModeLenMin", 1, 5000000, 200); doModeLenMax = getParam(DEC, "doModeLenMax", 1, 5000000, 5000); // softStopFreq = initiate session every freq clocks. softStopFreq = getParam(DEC, "softStopFreq", 1000, 100000, 0); // softStopMaxSessions = limit sessions to this many sessions softStopMaxSessions = getParam(DEC, "softStopMaxSessions", 0, 100, 50); // doModeTidMask = which tids to involve in sessions softStopTidMask = getParam(DEC, "softStopTidMask", 0, 8'hff, 0); // softStopLenMin,doModeLenMax = how many total clocks to run per session softStopLenMin = getParam(DEC, "softStopLenMin", 0, 500, 50); softStopLenMax = getParam(DEC, "softStopLenMax", 1, 600, 500); // exit diag if it parks and we are doing do/ss/softStop nodebugParkExit = getParam(FLAG, "nodebugParkExit", 0, 1, 0); // // // end debug logic testing // // // #ifdef SPC_BENCH // ccx stub rand_ccx_gnt_enable = getParam(FLAG, "random_ccx_gnt", 0, 1, 0); min_ccx_gnt_delay = getParam(DEC, "min_ccx_gnt_delay", 0, 1000, 0); max_ccx_gnt_delay = getParam(DEC, "max_ccx_gnt_delay", 0, 1000, 0); stub_l1_enable = getParam(FLAG, "stub_l1_disable", 0, 1, 1); l2lat_value = getParam(DEC, "l2lat_value", 0, 500, 6); l2lat_fixed = getParam(FLAG, "l2lat_fixed", 0, 1, 0); l2lat_in = getStringParam("latmom"); // POR/WMR/LBIST/MBISI por_enable = getParam(FLAG, "por_enable", 0, 1, 0); lbist_enable = getParam(FLAG, "lbist_enable", 0, 1, 0); mbist_mode = getParam(DEC, "mbist_mode", 0, 7, 0); mbist_enable = mbist_mode[2]; mbist_errinj = getParam(FLAG, "mbist_errinj", 0, 1, 0); user_loop_mode = getParam(DEC, "user_loop_mode", 0, 1, 0); user_loop_count = getParam(DEC, "user_loop_count", 0, 256, 3); lbist_abort_count = getParam(DEC, "lbist_abort_count", 0, 65000, 0); lbist_run_count = getParam(HEX, "lbist_run_count", 1, 7, 1); lbist_pgm = getParam(DEC, "lbist_pgm",0, 1, 0); mbist_fail_count = getParam(DEC, "mbist_fail_count", 0, 16777000, 0); //err err_freq = getParam(DEC, "err_freq", 0, 100, 10); err_burst_freq = getParam(DEC, "err_burst_freq", 0, 100, 5); err_burst_len_min = getParam(DEC, "err_burst_len_min", 0, 10, 1); err_burst_len_max = getParam(DEC, "err_burst_len_max", 1, 50, 10); err_ce_wt = getParam(DEC, "err_ce_wt", 0, 100, 50); err_nd_wt = getParam(DEC, "err_nd_wt", 0, 100, 25); rand_err = getParam(FLAG, "rand_err", 0, 1, 0); err_itlb_on = getParam(FLAG, "err_itlb_on", 0, 1, 0); err_itlb_freq = getParam(DEC, "err_itlb_freq", 0, 100, 20); err_dtlb_on = getParam(FLAG, "err_dtlb_on", 0, 1, 0); err_dtlb_freq = getParam(DEC, "err_dtlb_freq", 0, 100, 5); err_ic_on = getParam(FLAG, "err_ic_on", 0, 1, 0); err_ic_freq = getParam(DEC, "err_ic_freq", 0, 100, 20); err_dc_on = getParam(FLAG, "err_dc_on", 0, 1, 0); err_dc_freq = getParam(DEC, "err_dc_freq", 0, 100, 5); err_irf_on = getParam(FLAG, "err_irf_on", 0, 1, 0); err_irf_freq = getParam(DEC, "err_irf_freq", 0, 100, 20); err_frf_on = getParam(FLAG, "err_frf_on", 0, 1, 0); err_frf_freq = getParam(DEC, "err_frf_freq", 0, 100, 20); err_stb_on = getParam(FLAG, "err_stb_on", 0, 1, 0); err_stb_freq = getParam(DEC, "err_stb_freq", 0, 100, 20); err_sca_on = getParam(FLAG, "err_sca_on", 0, 1, 0); err_sca_freq = getParam(DEC, "err_sca_freq", 0, 100, 20); err_tcc_on = getParam(FLAG, "err_tcc_on", 0, 1, 0); err_tcc_freq = getParam(DEC, "err_tcc_freq", 0, 100, 20); err_tsa_on = getParam(FLAG, "err_tsa_on", 0, 1, 0); err_tsa_freq = getParam(DEC, "err_tsa_freq", 0, 100, 4); err_mra_on = getParam(FLAG, "err_mra_on", 0, 1, 0); err_mra_freq = getParam(DEC, "err_mra_freq", 0, 100, 20); err_l2c_on = getParam(FLAG, "err_l2c_on", 0, 1, 0); err_l2c_freq = getParam(DEC, "err_l2c_freq", 0, 100, 20); err_mamem_on = getParam(FLAG, "err_mamem_on", 0, 1, 0); err_mamem_freq = getParam(DEC, "err_mamem_freq", 0, 100, 20); #endif // add more here... closeFile(fileName); check4conflict(); } // things that are ONLY gotten from +args, not in config/paramaters file. // strings mostly. // Put all "knobs" in getCfg task above!!! task Params::getPlus() { // +dv_root is passed in by sims. Everything lives below that. // +dv_root=path if (mChkPlusarg(dv_root=)) { mGetPlusargStr(dv_root=,getstr); tempstr.bittostr (getstr); dv_root = tempstr; //printf("\n%7d paramsClass::getPlus dv_root = %s\n",get_cycle(),dv_root); } // If all param files are in one dir or are along one path, why not // get that partial path and then go from there? If you set it, you // should use it. // Put in bench.config as vcs_run_arg=+paramPath=verif/diag/bench. // Will prepend dv_root. +paramPath=path if (mChkPlusarg(paramPath=)) { mGetPlusargStr(paramPath=,getstr); tempstr.bittostr (getstr); paramPath = tempstr; } // You could pass in the default location (in bench.config) for a // default paramFile that will be used when none other is given, either // on the command line or in the testlist (which becomes the command line). // +defaultParam // Look for +paramFile= to append to +paramPath=path // +paramFile=file.cfg if (mChkPlusarg(paramFile=)) { mGetPlusargStr(paramFile=,getstr); tempstr.bittostr (getstr); paramFile = tempstr; //printf("%7d paramsClass::getPlus paramFile = %s\n",get_cycle(),paramFile); } // Look for +forceParamFile= so user can force a param/config/knobs file. // Will ignore +paramPath= and +paramFile= and +dv_root= // +forceParamFile=FULLPATH/slowMem.cfg if (mChkPlusarg(forceParamFile=)) { mGetPlusargStr(forceParamFile=,getstr); tempstr.bittostr (getstr); forceParamFile = tempstr; printf("\n%7d paramsClass::getPlus forceParamFile = %s\n",get_cycle(),forceParamFile); } // OK make sense of it... if (forceParamFile !== null) { printf("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); printf("using forceParamFile: %s\n",forceParamFile); printf("You probably need to repeat this to reproduce failures!\n"); printf("Use -vcs_run_args=+forceParamFile=%s to do that!\n",forceParamFile); printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); } else if (paramFile !== null) { printf("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); printf("using paramFile: %s\n",paramFile); printf("You may need to repeat this to reproduce failures!\n"); printf("Use -vcs_run_args=+paramFile=%s (or +forceParamFile=) to do that!\n",paramFile); printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); } // now use paramFile. May be null and if so, default params will be used. if (paramFile !== null) { paramFile = {paramPath,paramFile}; } if (forceParamFile !== null) { paramFile = forceParamFile; } // what kind of diags are running? if (mChkPlusarg(vera_diag_name=)) { mGetPlusargStr(vera_diag_name=,getstr); tempstr.bittostr (getstr); veraDiagName = tempstr; } if (mChkPlusarg(asm_diag_name=)) { mGetPlusargStr(asm_diag_name=,getstr); tempstr.bittostr (getstr); asmDiagName = tempstr; } // only Verilog knows what this is because it can be randomized in verilog. // Use gUtil.getThreadEnables or sparcBenchUtils_if.th_check_enable // if (mChkPlusarg(thread=)) { // mGetPlusargStr(thread=,getstr); // tempstr.bittostr(getstr); // if (tempstr == "all") getstr = 64'hffffffffffffffff; // special case // else getstr = tempstr.atohex(); // thread_enables = getstr; // } // CCX packet print if (mChkPlusarg(ccxPktPrint=)) { mGetPlusargStr(ccxPktPrint=,getstr); tempstr.bittostr (getstr); if (tempstr == "all") { ccxPktPrint[PP_PCX] = 1; ccxPktPrint[PP_CPX] = 1; } else if (tempstr == "pcx") ccxPktPrint[PP_PCX] = 1; else if (tempstr == "cpx") ccxPktPrint[PP_CPX] = 1; else if (tempstr == "mem") ccxPktPrint[PP_MEM] = 1; else if (tempstr == "spc") ccxPktPrint[PP_SPC] = 1; else if (tempstr == "targets") ccxPktPrint[PP_TRG] = 1; else if (tempstr == "target") ccxPktPrint[PP_TRG] = 1; else ccxPktPrintMask = tempstr.atohex(); ccxPktPrintOn = 1; } // MCU mem print if (mChkPlusarg(mcuMemPrint=)) { mGetPlusargStr(mcuMemPrint=,getstr); tempstr.bittostr (getstr); if (tempstr == "all") { mcuMemPrint[READ] = 1; mcuMemPrint[WRITE] = 1; } else if (tempstr == "rd" || tempstr == "read") mcuMemPrint[READ] = 1; else if (tempstr == "wr" || tempstr == "write") mcuMemPrint[WRITE] = 1; mcuMemPrintOn = 1; } if (mChkPlusarg(finish_mask=)) { mGetPlusargStr(finish_mask=,getstr); tempstr.bittostr (getstr); if (tempstr == "all") tmp = 64'hffffffffffffffff; // special case else tmp = tempstr.atohex(); finishMask = tmp; } else if (mChkPlusarg(threads=)) { mGetPlusargStr(threads=,getstr); tempstr.bittostr (getstr); if (tempstr == "all") tmp = 64'hffffffffffffffff; // special case else tmp = tempstr.atohex(); finishMask = tmp; } else finishMask = 1; // you probably don't want to add here, see task getCfg above. } // This task will try to resolve conflicts in paramaters // PROVIDED that someone has thought of them. task Params::check4conflict() { integer i; intr_en = intr_en & coreEnableReg; finishMask = finishMask & coreEnableReg & coreAvilableReg; }