Industrial Data

ISSN: 1560-9146
iifi@unmsm.edu.pe
Universidad Nacional Mayor de San Marcos
Per

Ruiz L., Edgar; Raffo L., Eduardo

Simulacin de la Memoria Cache
Industrial Data, vol. 6, nm. 2, diciembre, 2003, pp. 48-55
Universidad Nacional Mayor de San Marcos
Lima, Per

Disponible en: http://www.redalyc.org/articulo.oa?id=81660207

Cmo citar el artculo

Nmero completo
Sistema de Informacin Cientfica
Ms informacin del artculo Red de Revistas Cientficas de Amrica Latina, el Caribe, Espaa y Portugal
Pgina de la revista en redalyc.org Proyecto acadmico sin fines de lucro, desarrollado bajo la iniciativa de acceso abierto
 Vol. (6) 2: pp. 48-55

SIMULACIN DE LA
M EMORIA CACHE
* Edgar Ruiz L.
* Eduardo Raffo L.

RESUMEN
El artculo presenta un programa
que simula la memoria cache
considerando el porcentaje de
xitos y el tiempo medio de acceso
del sistema. El programa
encuentra el tamao ptimo de la
memoria cache con respecto a l
tamao de la memoria RAM el cual
puede utilizarse como un criterio
vlido para cuestiones del diseo
de ambas memorias en una
computadora.
Palabras Claves: Memoria
cache. Memoria RAM. Distribucin
uniforme. Tiempo de acceso
medio.
ABSTRACT
INTRODUCCIN
El trabajo consiste, en un programa escrito en lenguaje C++; utilizando un compilador Borland
C++ v.3.5 para Windows y DOS. La carta de estructuras para el programa se muestra en la
Figura 1.
OBJETIVO
Simular el porcentaje de aciertos acerca de que un dato se encuentre o no en la cache, as como,
estimar el tiempo de acceso medio a la cache
El mdulo principal del programa es el archivo fuente cache.cpp el cual pide como datos:
1. Ingresar tamao de la memoria.
2. Ingresar tamao de la cache
Luego se inicializa la cache, la cual es modelada como una estructura de datos del tipo
FIFO(del ingles First In First Out), ms conocida como una cola. Finalmente, simula una
distribucin uniforme de los bloques de memoria principal los cuales tendrn la misma oportunidad
de ingresar a la memoria cache e imprime el porcentaje de xitos y calcula el tiempo de acceso
medio a la cache.

This article presents a program

simulating the Cache Memory, by cache.cpp
considering the system's success
percentage and average access
time.The program finds the
Cache Memory's optimal size
with regard to the RAM Memory
queue2.h random.h standart.h
size, which can be used as a
valid criterion in designing both
kinds of Memory within a Figura 1. Carta de estructuras para el programa que simula la memoria cache
computer.

Key Words: Cache memory.

RAM memory. Uniform
distribution. Average access time. * Instituto de Investigacin
Facultad de Ingeniera Industrial, UNMSM
E-mail: eraffol@unmsm.edu.pe

48 INGENIERA DE S ISTEMAS E INFORMTICA diciembre 2003

>>> SIMULACIN DE LA MEMORIA CACHE

Cuadro 1. Elementos de diseo de la memoria cache

CPU
Tamao de la Cache
Funcin de Correspondencia
Transferencia I) Directa
de palabras II) Asociativa
III) Asociativa por conjuntos
Memoria
Algoritmo de Sustitucin
Cache IV) Utilizado menos recientemente
(LAN)
Transferencia V) Primero en entrar - Primero en
de bloques salir (FIFO)
VI) Utilizado menos frecuentemente
(LFU)
VII) Aleatorio

Poltica de escritura
Memoria VIII) Escritura inmediata
Principal IX) Post- escritura
X) Escritura nica

Tamao del bloque

Nmero de caches
XI) Uno o dos niveles
Figura 2. Memoria pricipal y cache XII) Unificada o partida

FUNDAMENTOS TERICOS 1 EL PROGRAMA DE SIMULACIN

Debido a que la memoria principal es relativamente ms grande y
ms lenta, la memoria cache se disea para que sea ms pequea
y rpida. La cache tiene una copia de partes de la memoria
principal. Cuando la CPU intenta leer una palabra de la memoria,
se hace una comprobacin para determinar si la palabra est en
la cache. Si es as se entrega dicha palabra a la CPU. Si no; un
bloque de memoria principal, consistente en un cierto nmero de
palabras, se transfiere a la cache y despus la palabra es
entregada a la CPU. La Figura 2 muestra la idea bsica de las
memorias principal y cache.
Como ya se indico en la introduccin el programa est escrito en
lenguaje de programacin C++, bajo el paradigma de la
programacin orientada al objeto, y donde se hace uso de libreras
(archivos *.h) escritos por los autores, que pueden servir para
este y otros programas. La Figura 3 muestra el diagrama de flujo
del programa.
Despus de leer los datos: tamao de memoria (variable
nmemoria) y tamao del cache (variable ncache) se inicializa
o llena la cache invocando el procedimiento inicia cuya tarea
consiste en insertar el bloque en la cola.

CRITERIOS PARA EL DISEO DE LA CACHE
Adems del costo total medio por bit para encontrar el tamao
"optimo" de la cache, existen las siguientes alternativas de diseo
de la cache mostradas en el Cuadro 1.
Para el programa se asume una funcin de correspondencia
directa donde cada bloque K de la RAM tiene la misma oportunidad
que otro de ser ingresado a la cache. El algoritmo de sustitucin
empleado es una estructura del tipo FIFO que se traduce en un
Tipo Abstracto de Datos conocido como TAD Cola.
La funcin simula genera muestras para las posiciones en la
memoria RAM utilizando una distribucin uniforme de
probabilidades y as ubicar el bloque j en la cache (ver Figura 5),
luego averigua si el bloque j pertenece a la cache, de ser as se
incrementa el nmero de aciertos o hit, caso contrario se remueve
el bloque de la cola y se inserta el bloque j.
El sustento de la distribucin uniforme (archivo random.h), est
dado por la siguiente definicin:
Sea:

1
Los fundamentos tericos han sido tomados de la referencia (2)
x ? ?a,b?
citada en la bibliografa.

diciembre 2003 INGENIERA DE S ISTEMAS E INFORMTICA 49

 Edgar Ruiz L. y Eduardo Raffo L.>>>

Inicio
front
rear

Inicializar
...
Cache
1 2 ncache

NULL

muestra NO Reporte
Figura 4. El TAD Cola
< 5000

FIN
SI

Generar una Donde cualquier valor de x tiene igual oportunidad de ser elegido,
posicin en
memoria RAM luego:

?x x?a
x x

j pertenece NO
F ( x) ? ? f ( x)?x ? ?b ? a ? b ? a
a a
a la cache

F ( X ) ? ?0,1? , entonces r ? F ( x) , r ? ? ?0,1?

Remover Cola
insertar el
SI
bloque j como
x ? a , con lo cual:
r?
hit = hit + 1
y
b? a

x ? a ? r * (b ? a )
Figura 3. Diagrama de flujo del programa

RAM

1
2 Bloque 1
2
3

.
.
.

ncache
.
. Bloque

. t

Memoria = 2n -1 Bloque
a=1 x b = nmemoria M

Figura 5. Memoria RAM, memoria cache y distribucin uniforme

50 INGENIERA DE S ISTEMAS E INFORMTICA diciembre 2003

>>> SIMULACIN DE LA MEMORIA CACHE

La funcin rnd( ), permite generar un nmero aleatorio de la

// Archivo fuente: cache.cpp forma lineal dado por L(G).
// simulacion de la memoria cache
#include <iostream.h>
Zn ? 1 ? aZn * (mod m)
#include <iomanip.h>
#include "a:queue2.h" Zn ? 1 ? residuo ( a * Z n, m )
#include "a:standart.h"
#include "a:random.h"
Si m = 2b y a = 8k + 3
void inicio(int); a = 8k+5 donde perodo = 2b-2; entonces
double simule(int); m = HIGHVALUE = 215 - 1 por lo tanto los residuos estn entre
(0,215 - 1) es decir (0,32767)
Queue<int> cache;
const int BLOQUES=20;
void main() // cache.cpp Todo este proceso se repite para 5 000 muestras, con lo cual se
{ prepara el reporte para indicar el porcentaje de xitos mediante
int nmemoria,ncache; // nmemoria = tamanno memoria la frmula hit*100 y estimar el tiempo de acceso medio del sistema
// ncache = tamanno de la cache con:
cout << "ingrese el tamao de la memoria > ";
cin >> nmemoria; tacceso ? T 1 * hit ? (1 ? hit) * T 1
cout << "ingrese el tamao del cache > ";
cin >> ncache;
inicio(ncache); // llamar a inicio Donde se asume que el tiempo de acceso medio M es de 10
// reporte unidades.
double hit=simule(nmemoria);
cout << endl << setw(10) << setprecision(4) A continuacin se presenta el cdigo del programa completo
<< "porcentaje de exitos " << (hit*100)
<< endl; cache.cpp y el de las libreras queue2.h, random.h, y standart.h
// se asume un tiempo de acceso T=10
double tacceso=1*hit+(1-hit)*10;
cout << endl << setw(10) << setprecision(4)
// queue2.h
<< "el tiempo de acceso es " << tacceso
<< " Useg." << endl; #ifndef QUEUE_H
} #define QUEUE_H
void inicio(int ncache) #include <iostream.h>
{ #include <assert.h>
for(int i=1;i<=ncache;i++) #include "standart.h"
cache.insert(i); // Node
} #define NODE Node<T>*
double simule(int nmemoria)
{ template <class T>
int n=0,m; class Node {
for(int i=1;i<=5000;i++){ T info;
// unifr=distribucion uniforme NODE next;
m=unifr(1,nmemoria); public :
int j=(m/BLOQUES)+1; Node():next(0){};
if(cache.search(j))
Node(const T&);
n++;
else { NODE getnext()const;
cache.remove(); // sobrecargando flujo de salida
cache.insert(j); friend ostream& operator<<(ostream&,const Node<T>&);
} friend class Queue<T>;
} };
return (double)n/5000; template <class T>
} Node<T>::Node(const T& a):info(a)

Figura 6. Listado del archivo cache.cpp Figura 7a. Listado del archivo queue2.h

diciembre 2003 INGENIERA DE S ISTEMAS E INFORMTICA 51

 Edgar Ruiz L. y Eduardo Raffo L.>>>

{ NODE p=new Node<T>(a);

next=0; if(rear==0)
} front=p;
template <class T> else
NODE Node<T>::getnext()const rear->next=p;
{ rear=p;
return next; }
} // sacar bloque de cola
//sobrecarga del operador << template <class T>
template <class T> T Queue<T>::remove()
ostream& operator<<(ostream& os,const Node<T>& p) {
{ NODE p;
os << p.info << "->"; p=front->next;
return os; T x=front->info;
} delete front;
// Queue front=p;
template <class T> if(front==0)
class Queue { rear==0;
NODE front; return x;
NODE rear; }
public: // buscar si el bloque esta o no en la cola
// Inicializacion template <class T>
Queue(); Boolean Queue<T>::search(const T& p)
// Acceso y Modificacion {
void insert(const T&); NODE q=front;
T remove(); while(q)
Boolean empty()const; if(q->info==p)
Boolean search(const T&); return TRUE;
// Salida else
friend ostream& operator<<(ostream&,const q=q->getnext();
Queue<T>&); return FALSE;
}; }
template <class T> template <class T>
Queue<T>::Queue() // Inicializando ostream& operator<<(ostream& os,const Queue<T>& p)
{ {
front=0; if(p.empty())
rear=0; return os;
} NODE q=p.front;
template <class T> while(q) {
Boolean Queue<T>::empty()const os << *q ;
{ q=q->getnext();
return (rear==0); }
} os << endl;
// insertar bloque en la cola return os;
template <class T> }
void Queue<T>::insert(const T& a) #endif
{

Figura 7b. Listado del archivo queue2.h

52 INGENIERA DE S ISTEMAS E INFORMTICA diciembre 2003

>>> SIMULACIN DE LA MEMORIA CACHE

// random.h {
#ifndef RANDOM_H double suma=0;
#define RANDOM_H for(int i=1;i<=12;i++)
#include <math.h> suma+=rnd();
#include "standart.h" return ex+std*(suma-6.0);
double rnd() }
{ // distribucion en forma polar
static int ix=1; double polar(float ex,float std,double& x1,int& flag)
ix*=899; {
if(ix<0) double r1,r2,v1,v2,w,y,pol;
ix+=32767+1; if(!flag) {
return ix/32768.0; do {
} r1=rnd();
// metodo del cuadrado central r2=rnd();
int midsqr(int& ix) // middle_square v1=2*r1-1;
{ v2=2*r2-1;
long int iy; w=pow(v1,2)+pow(v2,2);
iy=(long)ix*ix; }while(!(w<1 && w>0));
iy/=100; y=sqrt(-2*log(w)/w);
ix=(int)iy%1000; pol=v1*y;
return ix; x1=v2*y;
} flag=TRUE;
// metodo de la distribucion uniforme }
double unifr(float a,float b) else {
{ pol=x1;
return a+rnd()*(b-a); flag=FALSE;
} }
// metodo de la distribucion exponencial return ex+std*pol;
double expon(float ex) }
{ double empirica(float* x,float* fx)
double r; {
do { double r=rnd();
r=rnd(); int i=0;
}while(r==0); while(r>=fx[i])
return -ex*log(r); i++;
} return x[i];
// metodo de la distribucion normal }
double normal(float ex,float std) #endif

Figura 8. Listado del archivo random.h

diciembre 2003 INGENIERA DE S ISTEMAS E INFORMTICA 53

 Edgar Ruiz L. y Eduardo Raffo L.>>>

ANLISIS Y DISCUSIN DE RESULTADOS

// standart.h
#ifndef STANDART_H A continuacin se presenta una corrida del programa para los
#define STANDART_H datos nmemoria = 64 000 y ncache = 128

#define NELEM(x) sizeof(x)/sizeof(*x)

// definicion de un tipo enum para devolver valor de verdad o
falso
enum {FALSE,TRUE}; // FALSE=0, TRUE=1
class Boolean { //clase Boolean
int boolean;
public :
Boolean(int b=0){boolean=b!=0;} // constructor
operator int(){return boolean!=0;}// sobrecarga al tipo int
};
// Comparacion
template <class T> Figura 10. Una corrida del programa cache.cpp
int Cmp(T a,T b)
{
if (a<b)
return -1; El programa ha sido corrido para un determinado tamao de
else if (a==b) memoria, variando el tamao de la cache. Los resultados se
return 0; muestran en los cuadros 2, 3 y 4.
else
return 1;
}
// El maximo Cuadro 2. Anlisis de Resultados (64000 Mb)
template <class T> Tamao de Tamao de Tiempo de
% de xitos
T Max(T a,T b) Memoria RAM Cache Acceso
64000 32 40.92 6.317 seg.
{ 64000 64 82.26 2.597 seg.
64000 128 98.46 1.139 seg.
return (a>b)?a:b; 64000 256 98.46 1.139 seg.
} 64000 512 98.46 1.139 seg.

// El minimo
template <class T> Cuadro 3. Anlisis de Resultados (128000 Mb)
T Min(T a,T b)
{ Tamao de Tamao de
% de xitos
Tiempo de
Memoria RAM Cache Acceso
return (a<b)?a:b; 128000 32 20.48 8.157 seg.
} 128000 64 40.26 6.377 seg.
128000 128 80.24 2.778 seg.
// Swaping: Algoritmo de intercambio 128000 256 96.92 1.277 seg.
128000 512 96.92 1.277 seg.
template <class T> 128000 1024 96.92 1.277 seg.
void SwapTo(T& a,T& b)
{
T temp=a;
Cuadro 3. Anlisis de Resultados (256000 Mb)
a=b; Tamao de Tamao de Tiempo de
% de xitos
b=temp; Memoria RAM Cache Acceso
256000 32 10.32 9.071 seg.
} 256000 64 19.96 8.204 seg.
#endif 256000 128 40.16 6.386 seg.
256000 256 79.14 2.877 seg.
256000 512 93.84 1.554 seg.
256000 1024 93.84 1.554 seg.
Figura 9. Listado del archivo standart.h 256000 2048 93.84 1.554 seg.

54 INGENIERA DE S ISTEMAS E INFORMTICA diciembre 2003

>>> SIMULACIN DE LA MEMORIA CACHE

Como puede verse en las tablas de resultados se encuentra que
para un determinado tamao de memoria RAM, existe un tamao
de cache "ptimo" a partir del cual el porcentaje de xitos y el
tiempo de acceso medio del sistema no vara; es decir, permanece
constante aunque se aumente el tamao de la cache. Dichos
resultados a modo de resumen se presentan en la Cuadro 5.
que para un determinado tamao de memoria RAM, existe un
tamao de memoria cache ptimo, asociado por encima del cual
el porcentaje de xitos no mejora. De all que no es conveniente
aumentar el tamao de la cache por encima del ptimo pues no se
consigue mejora en el porcentaje de xitos ni en el tiempo de
acceso y el costo de implementar un tamao de cache mayor en
la tarjeta madre aumenta considerablemente.

Cuadro 5. Resumen de resultados ptimos de la cache El programa puede tambin utilizarse para probar con ms de
obtenidos con el programa una cache utilizando la frmula adecuada para los aciertos y los
tiempos medios de acceso a cada uno de ellos.
Tamao de Tamaode Tiempo de
% de xitos
Memoria Cache optimo Acceso
64000 128 98.46 1.139 seg.
128000 256 96.92 1.277 seg. BIBLIOGRAFA
256000 512 93.84 1.554 seg.

1. Raffo Lecca, Eduardo. (1998). Algoritmos y Estructuras

A decir verdad, el tamao de la cache depende de otras variables.
como el costo por bit para implementar en la tarjeta madre. Sin
embargo, el programa presentado da una buena aproximacin
de las cuestiones tericas inmersas en el diseo.
de Datos con C++. 1ra Edic. Raffo Lecca Editores. Lima,
Per.
2. Stallings, William. (2003). Computer Organization and
Architecture: Designing for Performance. 6ta Edic. Editorial
Prentice Hall International, USA.

CONCLUSIONES Y RECOMENDACIONES 3. Stroustrup, Bjarne. (2002). El Lenguaje de Programacin

C++ Edicin especial. 3ra Edic. Espaa. Addison Wesley -
El programa de simulacin de la cache implementado muestra Pearson Educacin S.A. Espaa.

diciembre 2003 INGENIERA DE S ISTEMAS E INFORMTICA 55