"I am a person who works hard and plays hard."
Yuan Wei
Second Year Graduate Student Department of Computer Science
University of Virginia Charlottesville, VA 22903
Email: yw3f@cs.virginia.edu

Source Code Analysis

Main Page   Compound List   File List   Compound Members   File Members  

memory.h File Reference

#include <stdio.h>
#include "host.h"
#include "misc.h"
#include "machine.h"
#include "options.h"
#include "stats.h"

Include dependency graph for memory.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Compounds

Defines

Enumerations

Functions

Variables

Define Documentation

#define __UNCHK_MEM_READ (  MEM,
ADDR,
TYPE    )     (*((TYPE *)(MEM_PAGE(MEM, (md_addr_t)(ADDR)) + MEM_OFFSET(ADDR))))
 

Definition at line 199 of file memory.h.

Referenced by sim_main().

#define __UNCHK_MEM_WRITE (  MEM,
ADDR,
TYPE,
VAL    )     (*((TYPE *)(MEM_PAGE(MEM, (md_addr_t)(ADDR)) + MEM_OFFSET(ADDR))) = (VAL))
 

Definition at line 209 of file memory.h.

#define MEM_FORALL (  MEM,
ITER,
PTE    ) 
 

Value:

for ((ITER)=0; (ITER) < MEM_PTAB_SIZE; (ITER)++)                        \
    for ((PTE)=(MEM)->ptab[i]; (PTE) != NULL; (PTE)=(PTE)->next)

Definition at line 182 of file memory.h.

Referenced by eio_write_chkpt().

#define MEM_LOG_PTAB_SIZE   15
 

Definition at line 107 of file memory.h.

#define MEM_OFFSET (  ADDR    )     ((ADDR) & (MD_PAGE_SIZE - 1))
 

Definition at line 172 of file memory.h.

#define MEM_PAGE (  MEM,
ADDR    ) 
 

Value:

(       \
   ((MEM)->ptab[MEM_PTAB_SET(ADDR)]                                     \
    && (MEM)->ptab[MEM_PTAB_SET(ADDR)]->tag == MEM_PTAB_TAG(ADDR))      \
   ? (                  \
      (MEM)->ptab_accesses++,                                           \
      (MEM)->ptab[MEM_PTAB_SET(ADDR)]->page)                            \
   : (  \
      mem_translate((MEM), (ADDR))))

Definition at line 161 of file memory.h.

#define MEM_PTAB_SET (  ADDR    )     (((ADDR) >> MD_LOG_PAGE_SIZE) & (MEM_PTAB_SIZE - 1))
 

Definition at line 148 of file memory.h.

Referenced by mem_newpage(), and mem_translate().

#define MEM_PTAB_SIZE   (32*1024)
 

Definition at line 106 of file memory.h.

Referenced by mem_init().

#define MEM_PTAB_TAG (  ADDR    )     ((ADDR) >> (MD_LOG_PAGE_SIZE + MEM_LOG_PTAB_SIZE))
 

Definition at line 152 of file memory.h.

Referenced by mem_newpage(), and mem_translate().

#define MEM_PTE_ADDR (  PTE,
IDX    ) 
 

Value:

(((PTE)->tag << (MD_LOG_PAGE_SIZE + MEM_LOG_PTAB_SIZE))         \
   | ((IDX) << MD_LOG_PAGE_SIZE))

Definition at line 156 of file memory.h.

Referenced by eio_write_chkpt().

#define MEM_READ (  MEM,
ADDR,
TYPE    ) 
 

Value:

(MEM_PAGE(MEM, (md_addr_t)(ADDR))                                       \
   ? *((TYPE *)(MEM_PAGE(MEM, (md_addr_t)(ADDR)) + MEM_OFFSET(ADDR)))   \
   :   0)

Definition at line 193 of file memory.h.

#define MEM_READ_BYTE (  MEM,
ADDR    )     MEM_READ(MEM, ADDR, byte_t)
 

Definition at line 214 of file memory.h.

Referenced by mem_access(), and spec_mem_access().

#define MEM_READ_HALF (  MEM,
ADDR    )     MD_SWAPH(MEM_READ(MEM, ADDR, half_t))
 

Definition at line 216 of file memory.h.

Referenced by mem_access(), and spec_mem_access().

#define MEM_READ_SBYTE (  MEM,
ADDR    )     MEM_READ(MEM, ADDR, sbyte_t)
 

Definition at line 215 of file memory.h.

#define MEM_READ_SHALF (  MEM,
ADDR    )     MD_SWAPH(MEM_READ(MEM, ADDR, shalf_t))
 

Definition at line 217 of file memory.h.

#define MEM_READ_SWORD (  MEM,
ADDR    )     MD_SWAPW(MEM_READ(MEM, ADDR, sword_t))
 

Definition at line 219 of file memory.h.

#define MEM_READ_WORD (  MEM,
ADDR    )     MD_SWAPW(MEM_READ(MEM, ADDR, word_t))
 

Definition at line 218 of file memory.h.

Referenced by mem_access(), and spec_mem_access().

#define MEM_TICKLE (  MEM,
ADDR    ) 
 

Value:

(!MEM_PAGE(MEM, ADDR)                                                   \
   ? (                          \
      mem_newpage(MEM, ADDR))                                           \
   : (  (void)0))

Definition at line 175 of file memory.h.

#define MEM_WRITE (  MEM,
ADDR,
TYPE,
VAL    ) 
 

Value:

(MEM_TICKLE(MEM, (md_addr_t)(ADDR)),                                    \
   *((TYPE *)(MEM_PAGE(MEM, (md_addr_t)(ADDR)) + MEM_OFFSET(ADDR))) = (VAL))

Definition at line 204 of file memory.h.

#define MEM_WRITE_BYTE (  MEM,
ADDR,
VAL    )     MEM_WRITE(MEM, ADDR, byte_t, VAL)
 

Definition at line 226 of file memory.h.

Referenced by eio_read_chkpt(), and mem_access().

#define MEM_WRITE_DFLOAT (  MEM,
ADDR,
VAL    )     MEM_WRITE(MEM, ADDR, dfloat_t, MD_SWAPQ(VAL))
 

Definition at line 238 of file memory.h.

#define MEM_WRITE_HALF (  MEM,
ADDR,
VAL    )     MEM_WRITE(MEM, ADDR, half_t, MD_SWAPH(VAL))
 

Definition at line 228 of file memory.h.

Referenced by mem_access().

#define MEM_WRITE_SBYTE (  MEM,
ADDR,
VAL    )     MEM_WRITE(MEM, ADDR, sbyte_t, VAL)
 

Definition at line 227 of file memory.h.

#define MEM_WRITE_SFLOAT (  MEM,
ADDR,
VAL    )     MEM_WRITE(MEM, ADDR, sfloat_t, MD_SWAPW(VAL))
 

Definition at line 236 of file memory.h.

#define MEM_WRITE_SHALF (  MEM,
ADDR,
VAL    )     MEM_WRITE(MEM, ADDR, shalf_t, MD_SWAPH(VAL))
 

Definition at line 230 of file memory.h.

#define MEM_WRITE_SWORD (  MEM,
ADDR,
VAL    )     MEM_WRITE(MEM, ADDR, sword_t, MD_SWAPW(VAL))
 

Definition at line 234 of file memory.h.

#define MEM_WRITE_WORD (  MEM,
ADDR,
VAL    )     MEM_WRITE(MEM, ADDR, word_t, MD_SWAPW(VAL))
 

Definition at line 232 of file memory.h.

Referenced by mem_access(), and sim_load_prog().

Enumeration Type Documentation

enum mem_cmd
 

Enumeration values:
Read 
Write 

Definition at line 129 of file memory.h.

Referenced by cheetah_access_fn(), dcache_access_fn(), dl1_access_fn(), dl2_access_fn(), dlite_mem_obj(), dtlb_access_fn(), il1_access_fn(), il2_access_fn(), itlb_access_fn(), mem_access(), mem_bcopy(), mem_bcopy4(), mem_strcpy(), my_mem_fn(), simoo_mem_obj(), and spec_mem_access(). 

00129              {
00130   Read,                 /* read memory from target (simulated prog) to host */
00131   Write                 /* write memory from host (simulator) to target */
00132 };

Function Documentation

enum md_fault_type mem_access (  struct mem_t *    mem,
enum mem_cmd    cmd,
md_addr_t    addr,
void *    vp,
int    nbytes
) 
 

Definition at line 182 of file memory.c.

References byte_t, half_t, mem_cmd, MEM_READ_BYTE, MEM_READ_HALF, MEM_READ_WORD, MEM_WRITE_BYTE, MEM_WRITE_HALF, MEM_WRITE_WORD, Read, and word_t.

Referenced by cheetah_access_fn(), dcache_access_fn(), dlite_mem_obj(), ld_load_prog(), mem_dump(), and simoo_mem_obj(). 

00187 {
00188   byte_t *p = vp;
00189 
00190   /* check alignments */
00191   if (/* check size */(nbytes & (nbytes-1)) != 0
00192       || /* check max size */nbytes > MD_PAGE_SIZE)
00193     return md_fault_access;
00194 
00195   if (/* check natural alignment */(addr & (nbytes-1)) != 0)
00196     return md_fault_alignment;
00197 
00198   /* perform the copy */
00199   {
00200     if (cmd == Read)
00201       {
00202         while (nbytes-- > 0)
00203           {
00204             *((byte_t *)p) = MEM_READ_BYTE(mem, addr);
00205             p += sizeof(byte_t);
00206             addr += sizeof(byte_t);
00207           }
00208       }
00209     else
00210       {
00211         while (nbytes-- > 0)
00212           {
00213             MEM_WRITE_BYTE(mem, addr, *((byte_t *)p));
00214             p += sizeof(byte_t);
00215             addr += sizeof(byte_t);
00216           }
00217       }
00218   }
00219 
00220 #if 0
00221   switch (nbytes)
00222     {
00223     case 1:
00224       if (cmd == Read)
00225         *((byte_t *)p) = MEM_READ_BYTE(mem, addr);
00226       else
00227         MEM_WRITE_BYTE(mem, addr, *((byte_t *)p));
00228       break;
00229 
00230     case 2:
00231       if (cmd == Read)
00232         *((half_t *)p) = MEM_READ_HALF(mem, addr);
00233       else
00234         MEM_WRITE_HALF(mem, addr, *((half_t *)p));
00235       break;
00236 
00237     case 4:
00238       if (cmd == Read)
00239         *((word_t *)p) = MEM_READ_WORD(mem, addr);
00240       else
00241         MEM_WRITE_WORD(mem, addr, *((word_t *)p));
00242       break;
00243 
00244 #ifdef HOST_HAS_QWORD
00245     case 8:
00246       if (cmd == Read)
00247         *((qword_t *)p) = MEM_READ_QWORD(mem, addr);
00248       else
00249         MEM_WRITE_QWORD(mem, addr, *((qword_t *)p));
00250       break;
00251 #endif /* HOST_HAS_QWORD */
00252 
00253     default:
00254       break;
00255     }
00256 #endif
00257 
00258   /* no fault... */
00259   return md_fault_none;
00260 }

enum md_fault_type mem_bcopy (  mem_access_fn    mem_fn,
struct mem_t *    mem,
enum mem_cmd    cmd,
md_addr_t    addr,
void *    vp,
int    nbytes
) 
 

Definition at line 382 of file memory.c.

References byte_t, mem_access_fn, and mem_cmd.

Referenced by ld_load_prog(), and sys_syscall(). 

00388 {
00389   byte_t *p = vp;
00390   enum md_fault_type fault;
00391 
00392   /* copy NBYTES bytes to/from simulator memory */
00393   while (nbytes-- > 0)
00394     {
00395       fault = mem_fn(mem, cmd, addr++, p++, 1);
00396       if (fault != md_fault_none)
00397         return fault;
00398     }
00399 
00400   /* no faults... */
00401   return md_fault_none;
00402 }

enum md_fault_type mem_bcopy4 (  mem_access_fn    mem_fn,
struct mem_t *    mem,
enum mem_cmd    cmd,
md_addr_t    addr,
void *    vp,
int    nbytes
) 
 

Definition at line 408 of file memory.c.

References byte_t, mem_access_fn, mem_cmd, and word_t. 

00414 {
00415   byte_t *p = vp;
00416   int words = nbytes >> 2;              /* note: nbytes % 2 == 0 is assumed */
00417   enum md_fault_type fault;
00418 
00419   while (words-- > 0)
00420     {
00421       fault = mem_fn(mem, cmd, addr, p, sizeof(word_t));
00422       if (fault != md_fault_none)
00423         return fault;
00424 
00425       addr += sizeof(word_t);
00426       p += sizeof(word_t);
00427     }
00428 
00429   /* no faults... */
00430   return md_fault_none;
00431 }

enum md_fault_type mem_bzero (  mem_access_fn    mem_fn,
struct mem_t *    mem,
md_addr_t    addr,
int    nbytes
) 
 

Definition at line 435 of file memory.c.

References byte_t, mem_access_fn, and Write.

Referenced by ld_load_prog(). 

00439 {
00440   byte_t c = 0;
00441   enum md_fault_type fault;
00442 
00443   /* zero out NBYTES of simulator memory */
00444   while (nbytes-- > 0)
00445     {
00446       fault = mem_fn(mem, Write, addr++, &c, 1);
00447       if (fault != md_fault_none)
00448         return fault;
00449     }
00450 
00451   /* no faults... */
00452   return md_fault_none;
00453 }

struct mem_t* mem_create (  char *    name ) 
 

Definition at line 106 of file memory.c.

References fatal(), mystrdup(), and mem_t::name.

Referenced by sim_init(), and sim_load_prog(). 

00107 {
00108   struct mem_t *mem;
00109 
00110   mem = calloc(1, sizeof(struct mem_t));
00111   if (!mem)
00112     fatal("out of virtual memory");
00113 
00114   mem->name = mystrdup(name);
00115   return mem;
00116 }

enum md_fault_type mem_dump (  struct mem_t *    mem,
md_addr_t    addr,
int    len,
FILE *    stream
) 
 

Definition at line 308 of file memory.c.

References len, mem_access(), myfprintf(), Read, and word_t. 

00312 {
00313   int data;
00314   enum md_fault_type fault;
00315 
00316   if (!stream)
00317     stream = stderr;
00318 
00319   addr &= ~sizeof(word_t);
00320   len = (len + (sizeof(word_t) - 1)) & ~sizeof(word_t);
00321   while (len-- > 0)
00322     {
00323       fault = mem_access(mem, Read, addr, &data, sizeof(word_t));
00324       if (fault != md_fault_none)
00325         return fault;
00326 
00327       myfprintf(stream, "0x%08p: %08x\n", addr, data);
00328       addr += sizeof(word_t);
00329     }
00330 
00331   /* no faults... */
00332   return md_fault_none;
00333 }

void mem_init (  struct mem_t *    mem ) 
 

Definition at line 293 of file memory.c.

References MEM_PTAB_SIZE, mem_t::page_count, mem_t::ptab, mem_t::ptab_accesses, and mem_t::ptab_misses.

Referenced by sim_init(). 

00294 {
00295   int i;
00296 
00297   /* initialize the first level page table to all empty */
00298   for (i=0; i < MEM_PTAB_SIZE; i++)
00299     mem->ptab[i] = NULL;
00300 
00301   mem->page_count = 0;
00302   mem->ptab_misses = 0;
00303   mem->ptab_accesses = 0;
00304 }

void mem_newpage (  struct mem_t *    mem,
md_addr_t    addr
) 
 

Definition at line 152 of file memory.c.

References byte_t, fatal(), getcore(), MEM_PTAB_SET, MEM_PTAB_TAG, mem_pte_t::next, mem_pte_t::page, mem_t::page_count, mem_t::ptab, and mem_pte_t::tag. 

00154 {
00155   byte_t *page;
00156   struct mem_pte_t *pte;
00157 
00158   /* see misc.c for details on the getcore() function */
00159   page = getcore(MD_PAGE_SIZE);
00160   if (!page)
00161     fatal("out of virtual memory");
00162 
00163   /* generate a new PTE */
00164   pte = calloc(1, sizeof(struct mem_pte_t));
00165   if (!pte)
00166     fatal("out of virtual memory");
00167   pte->tag = MEM_PTAB_TAG(addr);
00168   pte->page = page;
00169 
00170   /* insert PTE into inverted hash table */
00171   pte->next = mem->ptab[MEM_PTAB_SET(addr)];
00172   mem->ptab[MEM_PTAB_SET(addr)] = pte;
00173 
00174   /* one more page allocated */
00175   mem->page_count++;
00176 }

void mem_reg_stats (  struct mem_t *    mem,
struct stat_sdb_t *    sdb
) 
 

Definition at line 264 of file memory.c.

References mem_t::name, mem_t::page_count, mem_t::ptab_accesses, mem_t::ptab_misses, stat_reg_counter, and stat_reg_formula().

Referenced by sim_reg_stats(). 

00266 {
00267   char buf[512], buf1[512];
00268 
00269   sprintf(buf, "%s.page_count", mem->name);
00270   stat_reg_counter(sdb, buf, "total number of pages allocated",
00271                    &mem->page_count, mem->page_count, NULL);
00272 
00273   sprintf(buf, "%s.page_mem", mem->name);
00274   sprintf(buf1, "%s.page_count * %d / 1024", mem->name, MD_PAGE_SIZE);
00275   stat_reg_formula(sdb, buf, "total size of memory pages allocated",
00276                    buf1, "%11.0fk");
00277 
00278   sprintf(buf, "%s.ptab_misses", mem->name);
00279   stat_reg_counter(sdb, buf, "total first level page table misses",
00280                    &mem->ptab_misses, mem->ptab_misses, NULL);
00281 
00282   sprintf(buf, "%s.ptab_accesses", mem->name);
00283   stat_reg_counter(sdb, buf, "total page table accesses",
00284                    &mem->ptab_accesses, mem->ptab_accesses, NULL);
00285 
00286   sprintf(buf, "%s.ptab_miss_rate", mem->name);
00287   sprintf(buf1, "%s.ptab_misses / %s.ptab_accesses", mem->name, mem->name);
00288   stat_reg_formula(sdb, buf, "first level page table miss rate", buf1, NULL);
00289 }

enum md_fault_type mem_strcpy (  mem_access_fn    mem_fn,
struct mem_t *    mem,
enum mem_cmd    cmd,
md_addr_t    addr,
char *    s
) 
 

Definition at line 338 of file memory.c.

References mem_access_fn, mem_cmd, Read, s, and Write.

Referenced by ld_load_prog(), and sys_syscall(). 

00343 {
00344   int n = 0;
00345   char c;
00346   enum md_fault_type fault;
00347 
00348   switch (cmd)
00349     {
00350     case Read:
00351       /* copy until string terminator ('\0') is encountered */
00352       do {
00353         fault = mem_fn(mem, Read, addr++, &c, 1);
00354         if (fault != md_fault_none)
00355           return fault;
00356         *s++ = c;
00357         n++;
00358       } while (c);
00359       break;
00360 
00361     case Write:
00362       /* copy until string terminator ('\0') is encountered */
00363       do {
00364         c = *s++;
00365         fault = mem_fn(mem, Write, addr++, &c, 1);
00366         if (fault != md_fault_none)
00367           return fault;
00368         n++;
00369       } while (c);
00370       break;
00371 
00372     default:
00373       return md_fault_internal;
00374   }
00375 
00376   /* no faults... */
00377   return md_fault_none;
00378 }

byte_t* mem_translate (  struct mem_t *    mem,
md_addr_t    addr
) 
 

Definition at line 120 of file memory.c.

References MEM_PTAB_SET, MEM_PTAB_TAG, mem_pte_t::next, mem_pte_t::page, mem_t::ptab, mem_t::ptab_accesses, mem_t::ptab_misses, and mem_pte_t::tag. 

00122 {
00123   struct mem_pte_t *pte, *prev;
00124 
00125   /* got here via a first level miss in the page tables */
00126   mem->ptab_misses++; mem->ptab_accesses++;
00127 
00128   /* locate accessed PTE */
00129   for (prev=NULL, pte=mem->ptab[MEM_PTAB_SET(addr)];
00130        pte != NULL;
00131        prev=pte, pte=pte->next)
00132     {
00133       if (pte->tag == MEM_PTAB_TAG(addr))
00134         {
00135           /* move this PTE to head of the bucket list */
00136           if (prev)
00137             {
00138               prev->next = pte->next;
00139               pte->next = mem->ptab[MEM_PTAB_SET(addr)];
00140               mem->ptab[MEM_PTAB_SET(addr)] = pte;
00141             }
00142           return pte->page;
00143         }
00144     }
00145 
00146   /* no translation found, return NULL */
00147   return NULL;
00148 }

Variable Documentation

enum md_fault_type(* mem_access_fn)(struct mem_t *mem, enum mem_cmd cmd, md_addr_t addr, void *p, int nbytes)
 

Definition at line 137 of file memory.h.

Referenced by eio_read_trace(), eio_write_trace(), mem_bcopy(), mem_bcopy4(), mem_bzero(), mem_strcpy(), and sys_syscall().


UVa CS Department of Computer Science
School of Engineering, University of Virginia
151 Engineer's Way, P.O. Box 400740
Charlottesville, Virginia 22904-4740
(434) 982-2200  Fax: (434) 982-2214