perfectmem.c

一个用在mips体系结构中的操作系统

      return DoMemRequest(cpunum, transId, addr, MEMSYS_SHARED,data,dmalen);

   case MEMSYS_GETX:
      if( cpunum>=0 ) 
         perfStats[cpunum].getxs++;
      return DoMemRequest(cpunum, transId, addr, MEMSYS_EXCLUSIVE,data,dmalen);
      
   case MEMSYS_UPGRADE:
      if( cpunum >= 0 )
         perfStats[cpunum].upgrades++;
      return DoMemRequest(cpunum, transId, addr, MEMSYS_EXCLUSIVE,data,dmalen);

   case MEMSYS_UNCWRITE:
      perfStats[cpunum].uncwrites++;
      return DoUncachedRequest(cpunum, transId, addr, 
                               MEMSYS_UNCWRITE, data, writeback);

   case MEMSYS_UNCWRITE_ACCELERATED:
      perfStats[cpunum].uncaccwrites++;
      return DoUncachedRequest(cpunum, transId, addr, 
                               MEMSYS_UNCWRITE_ACCELERATED, data, writeback);

   case MEMSYS_UNCREAD:
      perfStats[cpunum].uncreads++;
      return DoUncachedRequest(cpunum, transId, addr, 
                               MEMSYS_UNCREAD, data, writeback);

   default:
      CPUError("perfectmem_interface.c: Bad memsys command\n");
      break;
   }
   
   return FAILURE;   /* notreached */
}

static Result
DoMemRequest(int cpunum, int transId, PA paddr, int mode, byte *data, int dmalen)
{
   int machine = M_FROM_CPU(cpunum);
   int result = DoInvalidates(cpunum, transId, paddr, mode);      
   if( dmalen ) { 
      if( mode & MEMSYS_EXCLUSIVE ) {
#ifdef DEBUG
         CPUPrint("MEM: DMA write, copying %08x from %08x to %08x\n",
                  paddr, data, DATA_ADDR(machine, paddr));
#endif
         bcopy(data,DATA_ADDR(machine, paddr),dmalen);
      } else { 
#ifdef DEBUG
         CPUPrint("MEM: DMA read, copying %08x from %08x to %08x\n",
                  paddr, DATA_ADDR(machine, paddr), data);
#endif
         bcopy(DATA_ADDR(machine, paddr),data,dmalen);
      }
   } else {
#ifdef DATA_HANDLING
#ifdef DEBUG
      CPUPrint("MEM: Memory request, copying %08x from %08x to %08x\n",
               paddr, DATA_ADDR(machine, paddr), data);
#endif
      bcopy(DATA_ADDR(machine, paddr),data,dmalen);
#endif
   }
   CacheCmdDone(cpunum, transId, mode, MEMSYS_STATUS_SUCCESS, result, data);
   return SUCCESS;
}

static Result
DoUncachedRequest(int cpunum, int transId, PA paddr, uint mcmd, 
                  byte *data, int len)
{
   /* For now, all uncached requests occur immediately */
#ifdef SOLO
   bcopy(data, (char *)paddr, len); 
#else
   Result ret;
#ifdef DEBUG
   CPUPrint("MEM: Uncached %s to address %08x len %d buffer %08x\n",
            (mcmd == MEMSYS_UNCREAD) ? "read" : "write", paddr, len, data);
#endif
   ASSERT(CPUVec.UncachedPIO);
   ret = CPUVec.UncachedPIO(cpunum, paddr, (mcmd == MEMSYS_UNCREAD) ? 1 : 0,
                        len, data);
   ASSERT(ret == SUCCESS);
#endif
   return SUCCESS;
}

/*****************************************************************
 * DoInvalidates
 *****************************************************************/

static int
DoInvalidates(int cpunum, int transId, PA paddr, int mode)
{
   int numinval;
   int result = 0;
   register int i;
   int machine = M_FROM_CPU(cpunum);
   byte *data = (byte*) DATA_ADDR(machine, paddr & ~(SCACHE_LINE_SIZE-1));
   int way;
   
   numinval = 0;
   for (i = FIRST_CPU(machine); i <= LAST_CPU(machine); i++) {
      if (i == cpunum && transId>=0) { 
         /* transId>=0 --> not a DMA request, but a CPU request
          * The requesting CPU is (obviously) not invalidated
          */
         continue;
      }
      if (IsInSCache(i, BACKMAP_PADDR(paddr,i), MEMSYS_SHARED, 
                     (char**)&data, &way)) {
         if (mode == MEMSYS_EXCLUSIVE) {
            int wasDirty;
#ifdef DEBUG
            CPUPrint("MEM: CacheExtract cpu %d addr %08x buffer %08x\n", 
                     i, paddr, data);
#endif
            if (CacheExtract(i, BACKMAP_PADDR(paddr,i), SCACHE_LINE_SIZE, 
                             &wasDirty, data)) {
               perfStats[i].invalidates++;
               numinval++;
               result |= MEMSYS_RESULT_INVALIDATE;
               if (wasDirty) {
                  result |= MEMSYS_RESULT_CACHE;
                  perfStats[i].invalwritebacks++;
               }
            }
         } else {
#ifdef DEBUG
            CPUPrint("MEM: CacheWriteback cpu %d addr %08x buffer %08x\n", 
                     i, paddr, data);
#endif
            if (CacheWriteback(i, BACKMAP_PADDR(paddr,i), SCACHE_LINE_SIZE, data)) {
               perfStats[i].sharingwritebacks++;
               numinval++;
               result |= MEMSYS_RESULT_DOWNGRADE;
               result |= MEMSYS_RESULT_CACHE;
            }
         }
      }
   }
   if (cpunum >= 0) {
      if (numinval == 0) perfStats[cpunum].memreads++;
      if (mode == MEMSYS_EXCLUSIVE) {
         perfStats[cpunum].invalHist[numinval]++;
      }
   }
   if (result == 0) {
      result |= MEMSYS_RESULT_NOTRANSITION;
   }
   if (! (result & MEMSYS_RESULT_CACHE)) {
      result |= MEMSYS_RESULT_MEMORY;
   }
#ifdef DEBUG
   CPUPrint("MEM: request done with result %d\n", result);
#endif
   return result;
}

static struct PerfMemStats lmdstats[SIM_MAXCPUS];

/*****************************************************************
 * PerfectMemDumpStats
 *****************************************************************/
static void 
PerfectMemDumpStats(void)
{
   int i, j;
   double numbytes;
   struct PerfMemStats total, itotal;

   CPUPrint("********* Memory System Stats **********\n");

   bzero((char *) &total, sizeof(total));
   bzero((char *) &itotal, sizeof(itotal));
   numbytes = 0.0;

   for (i = 0; i < TOTAL_CPUS; i++) {          
      numbytes +=  (perfStats[i].gets+perfStats[i].getxs)*(double)SCACHE_LINE_SIZE;
      itotal.gets += (total.gets += perfStats[i].gets) - lmdstats[i].gets;
      itotal.igets += (total.igets += perfStats[i].igets) - lmdstats[i].igets;
      itotal.getxs += (total.getxs += perfStats[i].getxs) - lmdstats[i].getxs;

      itotal.upgrades += 
         (total.upgrades += perfStats[i].upgrades) - lmdstats[i].upgrades;

      itotal.invalidates += 
         (total.invalidates += perfStats[i].invalidates) - lmdstats[i].invalidates;

      itotal.sharingwritebacks += 
         (total.sharingwritebacks += perfStats[i].sharingwritebacks) - 
         lmdstats[i].sharingwritebacks;

      total.uncreads += perfStats[i].uncreads;
      total.uncwrites += perfStats[i].uncwrites;
      total.uncaccwrites += perfStats[i].uncaccwrites;

      for (j = 0; j < TOTAL_CPUS; j++) {
         total.invalHist[j] += perfStats[i].invalHist[j];
      }
      
      itotal.naks += (total.naks += perfStats[i].naks) - lmdstats[i].naks;
      lmdstats[i] = perfStats[i];
   }
   
   CPUPrint("Totals - GETs: %lld (%3.1f%% Ifetch) GETXs: %lld Upgrades: %lld\n",
            (uint64)itotal.gets, (itotal.igets*100.0)/itotal.gets, 
            (uint64)itotal.getxs, (uint64)itotal.upgrades);
   CPUPrint("Totals - Uncached reads: %lld  Uncached writes: %lld  "
            "Uncached accelerated writes: %lld\n",
            (uint64)total.uncreads,
            (uint64)total.uncwrites,
            (uint64)total.uncaccwrites);
   CPUPrint("Totals - Kbytes: %6.2f SharingWritebacks %lld\n",
              numbytes/1000.0, (uint64)itotal.sharingwritebacks);

   for (i = 0; i < TOTAL_CPUS; i++) { 
      CPUPrint("Inval[%d] %lld\n", i, (uint64)total.invalHist[i]);
   }
   
   CPUPrint("Memsys - Invals %d (Avg %4.2f) SharingWritebacks %d NAKs %d\n", 
              itotal.invalidates, 
              itotal.invalidates/(double)(itotal.getxs+itotal.upgrades),
              itotal.sharingwritebacks, itotal.naks);
   
}

static struct PerfMemStats lstats[SIM_MAXCPUS];
/*****************************************************************
 * PerfectMemStatus
 *****************************************************************/
static void
PerfectMemStatus(void)
{
}
#ifdef notdef
static char *
PerfectMemStatus(int cpunum) 
{
   static char buffer[32];

   int i;
   SimCounter memMisses, cacheMisses, invals;
   SimCounter fromCache, lastFromCache, fromMem, lastFromMem;

   memMisses = cacheMisses = invals = 0;

   i = cpunum;
   fromCache = perfStats[i].invalwritebacks + perfStats[i].sharingwritebacks;
   lastFromCache = lstats[i].invalwritebacks + lstats[i].sharingwritebacks;
   fromMem = perfStats[i].memreads;
   lastFromMem = lstats[i].memreads;
   memMisses = (fromMem - lastFromMem);
   cacheMisses = (fromCache - lastFromCache);
   invals = (perfStats[i].invalidates - lstats[i].invalidates);
   invals += (perfStats[i].sharingwritebacks - lstats[i].sharingwritebacks);

   lstats[i] = perfStats[i];

   sprintf(buffer, "M %lld $ %lld I %lld", 
           (uint64)memMisses, 
           (uint64)cacheMisses, 
           (uint64)invals);
   return buffer;
}
#endif
static  void
InitStats(void)
{
   bzero((char *) &lstats, sizeof(lstats));
   bzero((char *) &lmdstats, sizeof(lmdstats));
}

static void
PerfectMemDone(void)
{
   CPUPrint("Done with perfect memory system with latency %d pclocks\n",
              PERFECTMEM_LATENCY);
   PerfectMemDumpStats();
}