initial commit

Author: mejbah

Makefile

@@ -0,0 +1,25 @@
+
+CC = g++
+LD = $(CC)
+TARGET = cache_sim
+
+
+SRCS = $(wildcard *.cpp)
+OBJS = $(patsubst %.cpp,%.o,$(SRCS))
+
+#OBJECTS_AS := $(patsubst %.s,%.o,$(wildcard *.S))
+#OBJECTS_AS = lowlevellock.o
+all: $(TARGET) CSCOPE
+
+$(TARGET) : $(OBJS)
+	  $(LD) -o $@ $^ $(LDFLAGS)
+%.o : %.cpp 
+	  $(CC) $(CFLAGS)  -c $<
+
+CSCOPE:
+	  `find -name '*.c' -o -name '*.cpp' -o -name '*.h' -name '*.hh'> cscope.files`
+		  `cscope -b -q -k`
+
+clean:
+	  rm -f $(TARGET) *.o
+

cache.hh

@@ -0,0 +1,126 @@
+#ifndef _CACHE_LINE_
+#define _CACHE_LINE_
+
+
+#define ADDR_SIZE 32
+#define CACHE_SIZE_KB 32
+#define BLOCK_SIZE 32
+#define ASSOC 4
+
+
+enum STATE { MODIFIED, EXCLUSIVE, SHARED,  INVALID};
+
+
+// 19bit tag | 8bit set | 5bit block
+
+
+class CacheLine {
+
+private:
+  STATE state; 
+  unsigned int tag;
+  bool valid;
+
+
+public:
+  CacheLine(){
+    tag = 0;
+    state = INVALID;
+    valid = false;
+  }
+  ~CacheLine(){};
+
+  unsigned int getTag(){return tag;}
+  void setTag(unsigned int _tag ) { tag = _tag; }
+
+  bool getValid(){ return valid; }
+  void setValid(bool _valid){ valid = _valid; }
+
+  STATE getState(){ return state; }
+  void setState( STATE _state ) { state =_state; }
+
+};
+
+
+class CacheSet {
+
+private:
+  CacheLine _cache_line[ASSOC];
+  int MRU; // most recent used bit for replacement
+  //std::list<CacheLine>_cache_line;
+
+public:
+  CacheSet(){ //LRU = 0;
+  };
+  ~CacheSet(){};
+  
+  int getMRU() { return MRU; }
+  
+  CacheLine* getLine(int assoc){return &_cache_line[assoc];}
+
+  CacheLine* access( unsigned int tag ){
+    bool hit = false;
+    for(int i=0; i<ASSOC; i++){
+      //TODO: check valid
+      if(_cache_line[i].getTag() == tag){
+        fprintf(stderr, "Hit %d\n", i);
+        hit = true;
+        MRU = i;
+        break;
+      }
+    }
+    if(!hit){
+
+      if(MRU != (ASSOC-1)){
+        MRU  = MRU + 1;
+      }
+      else {
+        MRU = 0;
+      }
+      fprintf(stderr, "Miss %d\n", MRU);
+      _cache_line[MRU].setTag(tag);
+
+    }
+    return &_cache_line[MRU];
+
+  }
+#if 0
+  CacheLine* getLRU() { return _cache_line.back(); }
+
+  void check( unsigned int tag ){
+    std::list<CacheLine>::iterator it;
+    bool hit = false;
+    for(it = _cache_line.begin(); it != _cache_line.end(); it++){
+      if(it->getTag()== tag){
+        hit = true;
+        if(it != _cache_line.begin()){
+          _cache_line.erase(it);
+          _cache_line.push_front(it);
+        }
+      }
+    }
+  }
+#endif
+
+};
+
+
+class CacheL1 {
+
+private:
+  CacheSet *sets;
+public:
+  
+  CacheL1(){
+    int no_of_blocks = (CACHE_SIZE_KB * 1024) / BLOCK_SIZE;
+    int no_of_sets = no_of_blocks / ASSOC;
+    sets = new CacheSet[no_of_sets];   
+  }
+
+  CacheSet* getSet( int set_index ){
+    return &sets[set_index];
+  }
+  
+
+};
+#endif

cache_core.hh

@@ -0,0 +1,49 @@
+#ifndef _COCHE_CORE_H_
+
+#include "cache.hh"
+#include "cache_util.hh"
+
+class CacheCore{
+
+private:
+  CacheL1 *_cache;
+  CacheCore(){};
+
+public:
+  static CacheCore& getInstance(){
+    static char buf[sizeof(CacheCore)];
+    static CacheCore *singleObject = new (buf) CacheCore();
+    return *singleObject;
+  }
+
+  void initialize(int cores ){
+    _cache = new CacheL1[cores];
+  }
+
+  void read( unsigned int address, int core ){
+    access(address, core);
+    
+  }
+  void write( unsigned int address, int core){
+    access(address, core);
+  }
+  void access( unsigned int address, int core){
+    unsigned int setIndex = CacheUtil::getInstance().getSetIndex(address);
+    unsigned int tag = CacheUtil::getInstance().getTag(address);
+    bool hit = 0;
+    fprintf(stderr, "setIndex %d\n", setIndex);
+    CacheSet *set = _cache[core].getSet(setIndex);
+    CacheLine *line = set->access(tag);
+
+    fprintf(stderr, "tag %u foundtag %u\n", tag, line->getTag());
+    
+  }
+
+  
+
+
+
+};
+
+
+#endif

cache_util.hh

@@ -0,0 +1,63 @@
+#ifndef _CACHE_UTIL_
+#define _CACHE_UTIL_
+
+#include "cache.hh"
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h> 
+#include <assert.h>
+#include <math.h>
+#include <new>
+
+#define LOG2(x) ((int) rint((log((double) (x))) / (log(2.0))))
+
+class CacheUtil{
+
+private:
+  int block_offset; //bits
+  int set_index; //bits
+  int tag; //bits 
+
+
+  CacheUtil(){}
+
+public:
+#if 1
+  static CacheUtil& getInstance(){
+    static char buf[sizeof(CacheUtil)];
+    static CacheUtil *theOneTrueObject = new (buf) CacheUtil();
+    return *theOneTrueObject;
+  }
+#endif 
+  //CacheUtil(){}
+
+  void initialize(){
+
+    int no_of_blocks = (CACHE_SIZE_KB * 1024) / BLOCK_SIZE;
+    int no_of_sets = no_of_blocks / ASSOC;
+    
+    block_offset = LOG2(BLOCK_SIZE);
+    set_index  = LOG2(no_of_sets);
+    tag = ADDR_SIZE - (set_index + block_offset); 
+     
+    printf(" %d - %d - %d\n", tag, set_index, block_offset);
+
+  }
+  
+  unsigned int getSetIndex( unsigned int address ){
+    unsigned int setIndex = (address << tag) >> (tag+block_offset);
+    return setIndex;    
+  }
+
+  unsigned int getTag( unsigned int address ){
+    unsigned int tag  = address >> (set_index+block_offset);
+    return tag;    
+  }
+
+};
+
+
+
+
+#endif

main.cpp

@@ -0,0 +1,31 @@
+#include<stdio.h>
+
+#include "cache_util.hh"
+#include "cache_core.hh"
+
+int main(){
+
+  CacheUtil::getInstance().initialize();
+  unsigned int val = 0xf000f001;
+  //printf("addr %u set %u tag %u\n", val, CacheUtil::getInstance().getSetIndex(val), CacheUtil::getInstance().getTag(val));
+  CacheCore::getInstance().initialize(1);
+
+  CacheCore::getInstance().read(val, 0);
+
+  CacheCore::getInstance().read(val, 0);
+
+  CacheCore::getInstance().read(val, 0);
+
+  val = 0xf000f101;
+
+  CacheCore::getInstance().read(val, 0);
+
+  val = 0xf010f101;
+
+  CacheCore::getInstance().read(val, 0);
+
+  val = 0xf010f001;
+
+  CacheCore::getInstance().read(val, 0);
+
+}