Exemplo n.º 1
0
void PowerModel::dumpDeviceTypes()
/* dumpDeviceTypes {{{1 */
{
    // elnaz, dump device types as specified in .xml file of mcpat
    if (dumppwth) {
        char *fname_devTypes = static_cast<char *>(malloc(1023));
        sprintf(fname_devTypes, "deviceTypes_%s", Report::getNameID());
        logDeviceTypes = fopen(fname_devTypes, "w");
        GMSG(logDeviceTypes == 0, "ERROR: could not open logDeviceTypes file \"%s\" (ignoring it)", fname_devTypes);
        free(fname_devTypes);

        for (size_t ii = 0; ii < energyBundle->cntrs.size(); ii++) {
            fprintf(logDeviceTypes, "%s\t", energyBundle->cntrs[ii].getName());
        }
        fprintf(logDeviceTypes, "\n");

        for (size_t i = 0; i < energyBundle->cntrs.size(); i++) {
            fprintf(logDeviceTypes, "%i\t", energyBundle->cntrs[i].getDevType());
        }

        fprintf(logDeviceTypes, "\n");
        if (logDeviceTypes) {
            fclose(logDeviceTypes);
            logDeviceTypes = NULL;
        }
    }
}
Exemplo n.º 2
0
GFlow::GFlow(int32_t i, int32_t cId, GMemorySystem *gmem)
    : fid(i),
      cpuId(cId),
      gms(gmem),
      gmos(gmem->getMemoryOS())
{

    //gproc = osSim->id2GProcessor(cpuId);

    if (trainCache == 0) {
        if (SescConf->checkCharPtr("cpucore","trainCache", cId)) {
            const char *cpuSection = SescConf->getCharPtr("", "cpucore", cId);
            std::vector<char *> vPars = SescConf->getSplitCharPtr(cpuSection, "trainCache");

            if (vPars.size() != 2) {
                MSG("Required format: trainCache = \"descriptionSection name\"\n");
                return;
            }

            const char *cacheSection = vPars[0];
            const char *cacheName = vPars[1];

            trainCache = gms->searchMemoryObj(true, cacheSection, cacheName);
            if(trainCache == 0) {
                // Maybe it got privatized
                char *ret=(char*)malloc(strlen(cacheName) + 20);
                sprintf(ret,"P(%i)_%s", cId, cacheName);

                trainCache = gms->searchMemoryObj(false, cacheSection, ret);
            }
            GMSG(trainCache==0,"Unknown cache to train [%s:%s]",cacheName, cacheSection);
        }
    }
}
Exemplo n.º 3
0
void SMPSystemBus::access(MemRequest *mreq)
{
  GMSG(mreq->getPAddr() < 1024,
       "mreq dinst=0x%p paddr=0x%x vaddr=0x%x memOp=%d",
       mreq->getDInst(),
       (unsigned int) mreq->getPAddr(),
       (unsigned int) mreq->getVaddr(),
       mreq->getMemOperation());
  
  I(mreq->getPAddr() > 1024); 

#ifdef SESC_ENERGY
  busEnergy->inc();
#endif

  switch(mreq->getMemOperation()){
  case MemRead:     read(mreq);      break;
  case MemReadW:    
  case MemWrite:    write(mreq);     break;
  case MemPush:     push(mreq);      break;
  default:          specialOp(mreq); break;
  }

  // for reqs coming from upper level:
  // MemRead means I need to read the data, but I don't have it
  // MemReadW means I need to write the data, but I don't have it
  // MemWrite means I need to write the data, but I don't have permission
  // MemPush means I don't have space to keep the data, send it to memory
}
Exemplo n.º 4
0
void SMPCache::access(MemRequest *mreq)
{
  PAddr addr;
  IS(addr = mreq->getPAddr());

  GMSG(mreq->getPAddr() < 1024,
       "mreq dinst=0x%p paddr=0x%x vaddr=0x%x memOp=%d ignored",
       mreq->getDInst(),
       (unsigned int) mreq->getPAddr(),
       (unsigned int) mreq->getVaddr(),
       mreq->getMemOperation());
  
  I(addr > 1024); 

  switch(mreq->getMemOperation()){
  case MemRead:  read(mreq);          break; 
  case MemWrite: /*I(cache->findLine(mreq->getPAddr())); will be transformed
		   to MemReadW later */
  case MemReadW: write(mreq);         break; 
  case MemPush:  I(0);                break; // assumed write-through upperlevel
  default:       specialOp(mreq);     break;
  }

  // for reqs coming from upper level:
  // MemRead  means "I want to read"
  // MemReadW means "I want to write, and I missed"
  // MemWrite means "I want to write, and I hit"
  // MemPush  means "I am writing data back" 
  // (this will never happen if upper level is write-through cache,
  // which is what we are assuming)
}
Exemplo n.º 5
0
void PowerModel::dumpLeakage()
/* dumpLeakage {{{1 */
{
    // eka, For each interval, cal this function if you want
    // have the power dumped into a different file

    // elnaz, separated dump leakage from dynamic power

    if (dumppwth) {
        char *fname_pwr_lkg = static_cast<char *>(malloc(1023));
        sprintf(fname_pwr_lkg, "power_lkg_%s", Report::getNameID());
        logpwrlkg = fopen(fname_pwr_lkg, "w");
        GMSG(logpwrlkg == 0, "ERROR: could not open logpwrlkg file \"%s\" (ignoring it)", fname_pwr_lkg);
        free(fname_pwr_lkg);

        if (totalPowerSamples <= 2) { // also write the header
            for (size_t ii = 0; ii < energyBundle->cntrs.size(); ii++) {
                fprintf(logpwrlkg, "%s\t", energyBundle->cntrs[ii].getName());
            }
            fprintf(logpwrlkg, "\n");
        }

        for (size_t i = 0; i < energyBundle->cntrs.size(); i++) {
            fprintf(logpwrlkg, "%e\t", energyBundle->cntrs[i].getLkg());
        }
        fprintf(logpwrlkg, "\n");
        if (logpwrlkg) {
            fclose(logpwrlkg);
            logpwrlkg = NULL;
        }
    }
}
Exemplo n.º 6
0
Resource::~Resource()
{
  GMSG(!EventScheduler::empty(), "Resources destroyed with %Zu pending instructions"
       ,EventScheduler::size());
  
  if(gen)
    gen->unsubscribe();
}
Exemplo n.º 7
0
void PowerModel::plug(const char* section)
/* plug {{{1 */
{
    I(sescThermWrapper);
    I(pwrCntrRepo);
    I(ipcRepo);
    I(temperatures);
    I(mcpatWrapper);
    I(energyBundle);

#ifdef ENABLE_PEQ
    PeqParser peq_parser;
//  peq_parser.getGeneralParams();
//  peq_parser.getCoreParams();
//  peq_parser.getMemParams();
//  peq_parser.testParser();
    SRAM my_sram;
    my_sram.testSRAM();
#endif

    avgTimingIPC  = 1;

    powerGlue.plug(section, energyBundle);

    logfile = 0;
    if (SescConf->checkCharPtr(section, "logfile")) {
        filename = SescConf->getCharPtr(section, "logfile");
        logfile = fopen(filename, "w");
        GMSG(logfile == 0, "ERROR: could not open logfile \"%s\" (ignoring it)", filename);
    }

    powerGlue.createStatCounters();
    //checkStatCounters(section);

    //Parse conf file to get stats information
    //Format in conf file is: stats[i] = pwrstat +gstat1 -gstat2 ...
    readStatsFromConfFile(section);

    genIndeces();

    readPowerConfig(section);
    initPowerModel(section);
    readTempConfig(section);
    initTempModel(section);

    //plugStackingValidator();

//Initialize logfile
    if (logfile == NULL) return;

    avgPowerValid = false;
    fprintf(logfile, "#IPC\t");
    for (size_t i = 0; i < stats->size(); i++) {
        fprintf(logfile, "%s\t", stats->at(i)->getName());
    }
    fprintf(logfile, "Total access all\n");
}
Exemplo n.º 8
0
exportTemplate template < class Data, class Time > TQueue < Data, Time >
::~TQueue()
{
    GMSG(nNodes, "Destroying TQueue %d with pending nodes", nNodes);

    free(accessTail);

    free(access);
}
Exemplo n.º 9
0
void ThermTrace::initLoglkg(const char* tfilename){
 
  FILE *tmploglkg; 
  char *lkgfname = (char *) alloca(256);
  sprintf (lkgfname, "scaled_lkg_%s", tfilename);
  tmploglkg   = fopen(lkgfname,"w");  
  GMSG(tmploglkg==0,"ERROR: could not open loglkg file \"%s\" (ignoring it)",lkgfname);

}  
Exemplo n.º 10
0
void PowerModel::getPowerDumpFile()
/* getPowerDumpFile {{{1 */
{
    dumppwthSplit = true;
    totalPowerSamples = 0;
    nPowerCall++;
    if (dumppwth && dumppwthSplit) {
        char *fname_prf           = static_cast<char *>(malloc(1023));
        char *fname_pwr_dyn       = static_cast<char *>(malloc(1023));
        sprintf(fname_prf,     "perf_%d_%s",      nPowerCall, Report::getNameID());
        sprintf(fname_pwr_dyn, "power_dyn_%d_%s", nPowerCall, Report::getNameID());
        logprf         = fopen(fname_prf, "w");
        logpwrdyn      = fopen(fname_pwr_dyn, "w");
        GMSG(logprf    == 0, "ERROR: could not open logprf file \"%s\" (ignoring it)",    fname_prf);
        GMSG(logpwrdyn == 0, "ERROR: could not open logpwrdyn file \"%s\" (ignoring it)", fname_pwr_dyn);
        free(fname_pwr_dyn);
        free(fname_prf);
    }
}
Exemplo n.º 11
0
FILE *SamplerBase::genReportFileNameAndOpen(const char *str) {
  FILE *fp;
  char *fname = (char *) alloca(1023);
  strcpy(fname, str);
  strcat(fname, Report::getNameID());
  fp = fopen(fname,"w");
  if(fp==0) {
    GMSG(fp==0,"ERROR: could not open file \"%s\"",fname);
    exit(-1);
  }

  return fp;
}
Exemplo n.º 12
0
void EmuSampler::beginTiming(EmuMode mod)
  /* Start sampling a new mode  */
{
  //I(stopJustCalled);
  stopJustCalled = false;
  phasenInst         = 0;
  mode = mod;

  clock_gettime(CLOCK_REALTIME,&startTime);

  const char *mode2name[] = { "Init","Rabbit","Warmup","Detail","Timing","InvalidValue"};
  GMSG(mode!=mod,"Sampler %s: starting %s mode", name, mode2name[mod]);
}
Exemplo n.º 13
0
void ThermTrace::initDumpLeakage(){

  if (dumppwth){
    char *fname_lkg = (char *) malloc(1023);
    sprintf(fname_lkg, "sesctherm_scaled_lkg_%s",Report::getNameID());
    loglkg = fopen(fname_lkg,"w");
    GMSG(loglkg==0,"ERROR: could not open loglkg file \"%s\" (ignoring it)",fname_lkg);
		if (loglkg) {
			for (size_t ii = 0; ii < energyBundle->cntrs.size(); ii++) {
				fprintf(loglkg, "%s\t", energyBundle->cntrs[ii].getName());
			}
			fprintf(loglkg, "\n");
		}
  }
  return;

}
Exemplo n.º 14
0
void PowerModel::plugStackingValidator() {
    // read the solution
    if (SescConf->checkCharPtr("", "stackingSol")) {
        const char * solution = SescConf->getCharPtr("", "stackingSol");
        uint32_t ii = 0;
        // mark each solution in the Bundle
        while (solution[ii] != '\0') {
            energyBundle->cntrs[ii].setSPart(solution[ii]);
            ii++;
        }
        I(ii == energyBundle->cntrs.size());
    }

    char *fname_dpower = static_cast<char *>(malloc(1023));
    sprintf(fname_dpower, "dpower_%s", Report::getNameID());
    dpowerf = fopen(fname_dpower, "w");
    GMSG(dpowerf == 0, "ERROR: could not open dpower file \"%s\".", fname_dpower);
    free(fname_dpower);
}
Exemplo n.º 15
0
MemObj *GMemorySystem::finishDeclareMemoryObj(std::vector<char *> vPars, char* name_suffix) {
  bool shared = false; // Private by default
  bool privatized = false;

  const char *device_descr_section = vPars[0];
  char *device_name = (vPars.size() > 1) ? vPars[1] : 0;

  if (vPars.size() > 2) {

    if (strcasecmp(vPars[2], "shared") == 0) {

      I(vPars.size() == 3);
      shared = true;

    } else if (strcasecmp(vPars[2], "sharedBy") == 0) {

      I(vPars.size() == 4);
      int32_t sharedBy = atoi(vPars[3]);
      //delete[] vPars[3];
      GMSG(sharedBy <= 0, "ERROR: SharedBy should be bigger than zero (field %s)", device_name);

      int32_t nId = coreId / sharedBy;
      device_name = privatizeDeviceName(device_name, nId);
      shared = true;
      privatized = true;
    }



  } else if (device_name) {

    if (strcasecmp(device_name, "shared") == 0) {
      //delete[] device_name;
      //device_name = 0;
      shared = true;
    }

  }

  SescConf->isCharPtr(device_descr_section, "deviceType");
  const char *device_type = SescConf->getCharPtr(device_descr_section, "deviceType");

  /* If the device has been given a name, we may be refering to an
   * already existing device in the system, so let's search
   * it. Anonymous devices (no name given) are always unique, and only
   * one reference to them may exist in the system.
   */

  if (device_name) {

    if (!privatized) {
      if (shared)
        device_name = privatizeDeviceName(device_name, 0);
      else {
        device_name = privatizeDeviceName(device_name, coreId);
      }
    }
    //device_name = privatizeDeviceName(device_name, priv_counter++);
    char *final_dev_name = device_name;

    if (name_suffix != NULL){
      final_dev_name =new char[strlen(device_name) + strlen(name_suffix)+8];
      sprintf(final_dev_name,"%s%s",device_name,name_suffix);
    } 
    
    device_name = final_dev_name;

    MemObj *memdev = searchMemoryObj(shared, device_descr_section, device_name); 

    if (memdev) {
      //delete[] device_name;
      //delete[] device_descr_section;
      return memdev;
    }

  } else
    device_name = buildUniqueName(device_type);

  MemObj *newMem = buildMemoryObj(device_type,
      device_descr_section,
      device_name);

  if (newMem) // Would be 0 in known-error mode
    getMemoryObjContainer(shared)->addMemoryObj(device_name, newMem);

  return newMem;
}
Exemplo n.º 16
0
PortGeneric::~PortGeneric()
{
  GMSG(nUsers != 0, "Not enough destroys for FUGenUnit");
}
Exemplo n.º 17
0
DInst::DInst()
  :doAtSimTimeCB(this)
  ,doAtSelectCB(this)
  ,doAtExecutedCB(this)
{
  pend[0].init(this);
  pend[1].init(this);
  I(MAX_PENDING_SOURCES==2);
  nDeps = 0;
#ifdef DINST_TRACK_PHYS
  static ushort max_preg = 1;
  preg = max_preg++;
  GMSG(max_preg>10240,"WARNING: Too many physical register created [%d]",max_preg);
#endif
  
#ifdef SESC_BAAD
  if (avgFetch1QTime == 0) {
    int32_t maxType = static_cast<int>(MaxInstType);
    avgFetch1QTime = (GStatsHist **)malloc(sizeof(GStatsHist *)*maxType);
    avgFetch2QTime = (GStatsHist **)malloc(sizeof(GStatsHist *)*maxType);
    avgIssueQTime  = (GStatsHist **)malloc(sizeof(GStatsHist *)*maxType);
    avgSchedQTime  = (GStatsHist **)malloc(sizeof(GStatsHist *)*maxType);
    avgExeQTime    = (GStatsHist **)malloc(sizeof(GStatsHist *)*maxType);
    avgRetireQTime = (GStatsHist **)malloc(sizeof(GStatsHist *)*maxType);
    for(int32_t i = 1; i < maxType ; i++) {
      avgFetch1QTime[i] = new GStatsHist("BAAD_%sFetch1QTime",Instruction::opcode2Name(static_cast<InstType>(i)));
      avgFetch2QTime[i] = new GStatsHist("BAAD_%sFetch2QTime",Instruction::opcode2Name(static_cast<InstType>(i)));
      avgIssueQTime[i]  = new GStatsHist("BAAD_%sDepQTime"   ,Instruction::opcode2Name(static_cast<InstType>(i)));
      avgSchedQTime[i]  = new GStatsHist("BAAD_%sSchQTime"   ,Instruction::opcode2Name(static_cast<InstType>(i)));
      avgExeQTime[i]    = new GStatsHist("BAAD_%sExeQTime"   ,Instruction::opcode2Name(static_cast<InstType>(i)));
      avgRetireQTime[i] = new GStatsHist("BAAD_%sComRetQTime",Instruction::opcode2Name(static_cast<InstType>(i)));
    }

    fetch1QHist1 = new GStatsTimingHist("BAAD_Fetch1QHist1");
    fetch2QHist1 = new GStatsTimingHist("BAAD_Fetch2QHist1");
    issueQHist1  = new GStatsTimingHist("BAAD_DepQHist1");
    schedQHist1  = new GStatsTimingHist("BAAD_SchQHist1");
    exeQHist1    = new GStatsTimingHist("BAAD_ExeQHist1");
    retireQHist1 = new GStatsTimingHist("BAAD_ComRetQHist1");

    fetch1QHist2 = new GStatsHist("BAAD_Fetch1QHist2");
    fetch2QHist2 = new GStatsHist("BAAD_Fetch2QHist2");
    issueQHist2  = new GStatsHist("BAAD_DepQHist2");
    schedQHist2  = new GStatsHist("BAAD_SchQHist2");
    exeQHist2    = new GStatsHist("BAAD_ExeQHist2");
    retireQHist2 = new GStatsHist("BAAD_ComRetQHist2");

    fetch1QHistUp = new GStatsHist("BAAD_Fetch1QHistUp");
    fetch2QHistUp = new GStatsHist("BAAD_Fetch2QHistUp");
    issueQHistUp  = new GStatsHist("BAAD_DepQHistUp");
    schedQHistUp  = new GStatsHist("BAAD_SchQHistUp");
    exeQHistUp    = new GStatsHist("BAAD_ExeQHistUp");
    retireQHistUp = new GStatsHist("BAAD_ComRetQHistUp");

    fetch1QHistDown = new GStatsHist("BAAD_Fetch1QHistDown");
    fetch2QHistDown = new GStatsHist("BAAD_Fetch2QHistDown");
    issueQHistDown  = new GStatsHist("BAAD_DepQHistDown");
    schedQHistDown  = new GStatsHist("BAAD_SchQHistDown");
    exeQHistDown    = new GStatsHist("BAAD_ExeQHistDown");
    retireQHistDown = new GStatsHist("BAAD_ComRetQHistDown");

    brdistHist1  = new GStatsHist("BAAD_BrDistHist1");
  }
#endif
}
Exemplo n.º 18
0
MarkovPrefetcher::MarkovPrefetcher(MemorySystem* current
				     ,const char *section
				     ,const char *name)
  : MemObj(section, name)
  ,gms(current)
  ,halfMiss("%s:halfMiss", name)
  ,miss("%s:miss", name)
  ,hit("%s:hits", name)
  ,predictions("%s:predictions", name)
  ,accesses("%s:accesses", name)
{
  MemObj *lower_level = NULL;


  SescConf->isInt(section, "depth");
  depth = SescConf->getInt(section, "depth");

  SescConf->isInt(section, "width");
  width = SescConf->getInt(section, "width");

  const char *Section = SescConf->getCharPtr(section, "nextLevel");
  if (Section) {
    lineSize = SescConf->getInt(Section, "bsize");
  }

  const char *buffSection = SescConf->getCharPtr(section, "buffCache");
  if (buffSection) {
    buff = BuffType::create(buffSection, "", name);
    
    SescConf->isInt(buffSection, "numPorts");
    numBuffPorts = SescConf->getInt(buffSection, "numPorts");
    
    SescConf->isInt(buffSection, "portOccp");
    buffPortOccp = SescConf->getInt(buffSection, "portOccp");
  }

  const char *streamSection = SescConf->getCharPtr(section, "streamCache");
  if (streamSection) {
    char tableName[128];
    sprintf(tableName, "%sPrefTable", name);
    table = MarkovTable::create(streamSection, "", tableName);

    GMSG(tEntrySize != SescConf->getInt(streamSection, "BSize"),
	 "The prefetch buffer streamBSize field in the configuration file should be %d.", tEntrySize);

    SescConf->isInt(streamSection, "numPorts");
    numTablePorts = SescConf->getInt(streamSection, "numPorts");

    SescConf->isInt(streamSection, "portOccp");
    tablePortOccp = SescConf->getInt(streamSection, "portOccp");
  }

  defaultMask  = ~(buff->getLineSize()-1);

  char portName[128];
  sprintf(portName, "%s_buff", name);
  buffPort  = PortGeneric::create(portName, numBuffPorts, buffPortOccp);

  sprintf(portName, "%s_table", name);
  tablePort = PortGeneric::create(portName, numTablePorts, tablePortOccp);

  ptr = 0;
  lastAddr = 0;  
  
  I(current);
  lower_level = current->declareMemoryObj(section, k_lowerLevel);   
  if (lower_level != NULL)
    addLowerLevel(lower_level);

}
Exemplo n.º 19
0
StridePrefetcher::StridePrefetcher(MemorySystem* current ,const char *section ,const char *name)
  /* constructor {{{1 */
  :MemObj(section, name)
  ,halfMiss("%s:halfMiss", name)
  ,miss("%s:miss", name)
  ,hit("%s:hits", name)
  ,predictions("%s:predictions", name)
  ,accesses("%s:accesses", name)
  ,unitStrideStreams("%s:unitStrideStreams", name)
  ,nonUnitStrideStreams("%s:nonUnitStrideStreams", name)
  ,ignoredStreams("%s:ignoredStreams", name)
{
  MemObj *lower_level = NULL;

  // If MemLatency is 200 and busOcc is 10, then there can be at most 20
  // requests without saturating the bus. (VERIFY???) something like half sound
  // conservative (10 pending requests)
  MaxPendingRequests = 8; // FIXME: SescConf

  SescConf->isInt(section, "depth");
  depth = SescConf->getInt(section, "depth");

  SescConf->isInt(section, "missWindow");
  missWindow = SescConf->getInt(section, "missWindow");

  SescConf->isInt(section, "maxStride");
  maxStride = SescConf->getInt(section, "maxStride");

  SescConf->isInt(section, "hitDelay");
  hitDelay = SescConf->getInt(section, "hitDelay");

  SescConf->isInt(section, "missDelay");
  missDelay = SescConf->getInt(section, "missDelay");

  SescConf->isInt(section, "learnHitDelay");
  learnHitDelay = SescConf->getInt(section, "learnHitDelay");

  SescConf->isInt(section, "learnMissDelay");
  learnMissDelay = SescConf->getInt(section, "learnMissDelay");

  I(depth > 0);

  const char *buffSection = SescConf->getCharPtr(section, "buffCache");
  if (buffSection) {
    buff = BuffType::create(buffSection, "", name);

    SescConf->isInt(buffSection, "bknumPorts");
    numBuffPorts = SescConf->getInt(buffSection, "bknumPorts");

    SescConf->isInt(buffSection, "bkportOccp");
    buffPortOccp = SescConf->getInt(buffSection, "bkportOccp");
  }

  const char *streamSection = SescConf->getCharPtr(section, "streamCache");
  if (streamSection) {
    char tableName[128];
    sprintf(tableName, "%sPrefTable", name);
    table = PfTable::create(streamSection, "", tableName);

    GMSG(pEntrySize != SescConf->getInt(streamSection, "BSize"),
   "The prefetch buffer streamBSize field in the configuration file should be %d.", pEntrySize);

    SescConf->isInt(streamSection, "bknumPorts");
    numTablePorts = SescConf->getInt(streamSection, "bknumPorts");

    SescConf->isInt(streamSection, "bkportOccp");
    tablePortOccp = SescConf->getInt(streamSection, "bkportOccp");
  }

  char portName[128];
  sprintf(portName, "%s_buff", name);
  buffPort  = PortGeneric::create(portName, numBuffPorts, buffPortOccp);
  sprintf(portName, "%s_table", name);
  tablePort = PortGeneric::create(portName, numTablePorts, tablePortOccp);

  defaultMask  = ~(buff->getLineSize()-1);

  I(current);
  lower_level = current->declareMemoryObj(section, "lowerLevel");
  if (lower_level != NULL)
    addLowerLevel(lower_level);


  //Is this the memory  
  isMemoryBus = false; 
}
Exemplo n.º 20
0
StridePrefetcher::StridePrefetcher(MemorySystem* current
	 ,const char *section
	 ,const char *name)
  : MemObj(section, name)
  ,halfMiss("%s:halfMiss", name)
  ,miss("%s:miss", name)
  ,hit("%s:hits", name)
  ,predictions("%s:predictions", name)
  ,accesses("%s:accesses", name)
  ,unitStrideStreams("%s:unitStrideStreams", name)
  ,nonUnitStrideStreams("%s:nonUnitStrideStreams", name)
  ,ignoredStreams("%s:ignoredStreams", name)
{
  MemObj *lower_level = NULL;

  SescConf->isInt(section, "depth");
  depth = SescConf->getInt(section, "depth");

  SescConf->isInt(section, "missWindow");
  missWindow = SescConf->getInt(section, "missWindow");

  SescConf->isInt(section, "maxStride");
  maxStride = SescConf->getInt(section, "maxStride");

  SescConf->isInt(section, "hitDelay");
  hitDelay = SescConf->getInt(section, "hitDelay");

  SescConf->isInt(section, "missDelay");
  missDelay = SescConf->getInt(section, "missDelay");

  SescConf->isInt(section, "learnHitDelay");
  learnHitDelay = SescConf->getInt(section, "learnHitDelay");

  SescConf->isInt(section, "learnMissDelay");
  learnMissDelay = SescConf->getInt(section, "learnMissDelay");

  I(depth > 0);

  const char *buffSection = SescConf->getCharPtr(section, "buffCache");
  if (buffSection) {
    buff = BuffType::create(buffSection, "", name);
    
    SescConf->isInt(buffSection, "numPorts");
    numBuffPorts = SescConf->getInt(buffSection, "numPorts");
    
    SescConf->isInt(buffSection, "portOccp");
    buffPortOccp = SescConf->getInt(buffSection, "portOccp");
  }

  const char *streamSection = SescConf->getCharPtr(section, "streamCache");
  if (streamSection) {
    char tableName[128];
    sprintf(tableName, "%sPrefTable", name);
    table = PfTable::create(streamSection, "", tableName);

    GMSG(pEntrySize != SescConf->getInt(streamSection, "BSize"),
	 "The prefetch buffer streamBSize field in the configuration file should be %d.", pEntrySize);

    SescConf->isInt(streamSection, "numPorts");
    numTablePorts = SescConf->getInt(streamSection, "numPorts");

    SescConf->isInt(streamSection, "portOccp");
    tablePortOccp = SescConf->getInt(streamSection, "portOccp");
  }

  char portName[128];
  sprintf(portName, "%s_buff", name);
  buffPort  = PortGeneric::create(portName, numBuffPorts, buffPortOccp);
  sprintf(portName, "%s_table", name);
  tablePort = PortGeneric::create(portName, numTablePorts, tablePortOccp);

  defaultMask  = ~(buff->getLineSize()-1);

  I(current);
  lower_level = current->declareMemoryObj(section, k_lowerLevel);   
  if (lower_level != NULL)
    addLowerLevel(lower_level);
}