Блог

Я должен продолжить разработку симулятора с использованием C, способного имитировать различные типы кэша (прямой, n-образный ассоциативный, полностью ассоциативный). Прямо сейчас мой код работает в том смысле, что он может имитировать кэш с прямым отображением, однако он не может имитировать какой-либо другой тип.

Мой код Мой файл на C:

 /*  * CS3375 Computer Architecture  * Course Project  * Cache Simulator Design and Development  * FALL 2017  * By Yong Chen  */  #include lt;stdio.hgt; #include lt;stdint.hgt; #include lt;string.hgt; #include lt;math.hgt; #include "cachesim.h" int main(int argc, char *argv[]) {  char type;  if (argc != 3) {  printf("Usage: %s lt;directgt; lt;trace file namegt;n", argv[0]);  return 1;  }  #ifdef DBG  printf("BLOCK SIZE = %d Bytesn", BLOCK_SIZE);  printf("%d-WAYn", WAY_SIZE);  printf("CACHE SIZE = %d Bytesn", CACHE_SIZE);  printf("NUMBER OF BLOCKS = %dn", NUM_BLOCKS);  printf("NUMBER OF SETS = %dn", NUM_SETS);  printf("n"); #endif  struct direct_mapped_cache d_cache;  char* trace_file_name = argv[2];  char mem_request[20];  uint64_t address;  FILE *fp;    /* Initialization */  for (int i=0; ilt;NUM_BLOCKS; i  ) {  d_cache.valid_field[i] = 0;  d_cache.dirty_field[i] = 0;  d_cache.tag_field[i] = 0;  }   d_cache.hits = 0;  d_cache.misses = 0;   /* Opening the memory trace file */  fp = fopen(trace_file_name, "r");   /*Checks if argument specified direct-mapped cache*/  if (strncmp(argv[1], "direct", 6)==0) { /* Simulating direct-mapped cache */  /* Read the memory request address and access the cache */  while (fgets(mem_request, 20, fp)!= NULL) {  address = convert_address(mem_request);  direct_mapped_cache_access(amp;d_cache, address);  }  /*Calculate Hit and Miss Rate*/  double hit_rate = ((1.0 * d_cache.hits)/(d_cache.hits   d_cache.misses));  double miss_rate = ((1.0 * d_cache.misses)/(d_cache.hits   d_cache.misses));  /*Print out the results*/  printf("n==================================n");  printf("Cache type: Direct-Mapped Cachen");  printf("==================================n");  printf("Cache Hits: %dn", d_cache.hits);  printf("Cache Misses: %dn", d_cache.misses);  printf("Cache Hit Rate: %fn", hit_rate);  printf("Cache Miss Rate: %fn", miss_rate);  printf("n");  }   fclose(fp);   return 0; }  uint64_t convert_address(char memory_addr[]) /* Converts the physical 32-bit address in the trace file to the "binary" \  * (a uint64 that can have bitwise operations on it) */ {  uint64_t binary = 0;  int i = 0;   while (memory_addr[i] != 'n') {  if (memory_addr[i] lt;= '9' amp;amp; memory_addr[i] gt;= '0') {  binary = (binary*16)   (memory_addr[i] - '0');  } else {  if(memory_addr[i] == 'a' || memory_addr[i] == 'A') {  binary = (binary*16)   10;  }  if(memory_addr[i] == 'b' || memory_addr[i] == 'B') {  binary = (binary*16)   11;  }  if(memory_addr[i] == 'c' || memory_addr[i] == 'C') {  binary = (binary*16)   12;  }  if(memory_addr[i] == 'd' || memory_addr[i] == 'D') {  binary = (binary*16)   13;  }  if(memory_addr[i] == 'e' || memory_addr[i] == 'E') {  binary = (binary*16)   14;  }  if(memory_addr[i] == 'f' || memory_addr[i] == 'F') {  binary = (binary*16)   15;  }  }  i  ;  }  #ifdef DBG  printf("%s converted to %llun", memory_addr, binary); #endif  return binary; }  void direct_mapped_cache_access(struct direct_mapped_cache *cache, uint64_t address) {  uint64_t block_addr = address gt;gt; (unsigned)log2(BLOCK_SIZE);  uint64_t index = block_addr % NUM_BLOCKS;  uint64_t tag = block_addr gt;gt; (unsigned)log2(NUM_BLOCKS);  #ifdef DBG  printf("Memory address: %llu, Block address: %llu, Index: %llu, Tag: %llu ", address, block_addr, index, tag); #endif   if (cache-gt;valid_field[index] amp;amp; cache-gt;tag_field[index] == tag) { /* Cache hit */  cache-gt;hits  = 1; #ifdef DBG  printf("Hit!n"); #endif  } else {  /* Cache miss */  cache-gt;misses  = 1; #ifdef DBG  printf("Miss!n"); #endif  if (cache-gt;valid_field[index] amp;amp; cache-gt;dirty_field[index]) {  /* Write the cache block back to memory */  }  cache-gt;tag_field[index] = tag;  cache-gt;valid_field[index] = 1;  cache-gt;dirty_field[index] = 0;  } }  

Мой файл .h:

 /*  * CS3375 Computer Architecture  * Course Project  * Cache Simulator Design and Development  * FALL 2017  * By Yong Chen  */  #include lt;stdio.hgt; /* Cache block size (or cache line size) in bytes*/ #define BLOCK_SIZE 64 /*(must be power of 2). 4 Bytes = 1 Word NOTE: MUST CHANGE DEPENDING ON TYPE*/ #define WAY_SIZE 1 /* Associativity; 1-way = direct-mapped MUST CHANGE DEPENDING ON TYPE*/ #define CACHE_SIZE 32768 /* Cache capacity in bytes (must be power of 2) THIS WILL STAY FIXED*/  #define NUM_BLOCKS (CACHE_SIZE / BLOCK_SIZE) #define NUM_SETS (BLOCK_SIZE/WAY_SIZE) /*For fully associative, num sets is equal to num blocks because way size is equal to num blocks. */  /*MAY TRY LEAVING THESE VARIABLES UNDEFINED, AND THEY WILL BE SET DEPENDING ON USER INPUT.*/  #define DBG /*Prints debugging information*/  /*The data structure of direct-mapped cache*/ struct direct_mapped_cache {  unsigned valid_field[NUM_BLOCKS]; /* Valid field */  unsigned dirty_field[NUM_BLOCKS]; /* Dirty field; since we don't distinguish writes and \  reads in this project yet, this field doesn't really matter */  uint64_t tag_field[NUM_BLOCKS]; /* Tag field */  char data_field[NUM_BLOCKS][BLOCK_SIZE]; /* Data field; since we don't really fetch data, \  this field doesn't really matter */  int hits; /* Hit count */  int misses; /* Miss count */ };   /*Read the memory traces and convert it to binary*/ uint64_t convert_address(char memory[]);  /*Simulate the direct-mapped cache*/ void direct_mapped_cache_access(struct direct_mapped_cache *cache, uint64_t address);   

Что я пробовал По общему признанию, я новичок, когда дело доходит до языка Си, поэтому мое решение может быть проще, чем я думаю, но до сих пор я не смог найти никаких ответов. Я рассматривал возможность изменения того, где переменные кэша были определены с помощью «#define» в зависимости от аргумента, но я узнал, что «#define» запускается предварительной обработкой, поэтому это не сработает.

Я также пытался создать несколько классов структур для каждого типа кэша, который необходимо смоделировать, но, поскольку переменные структуры в C не могут быть инициализированы внутри класса, я также не могу заставить это работать.

Насколько я понимаю, структуры в C также не могут иметь конструкторов, поскольку я также изучал это.

Любая помощь или шаг в правильном направлении будут высоко оценены.

во-первых, вы ошибаетесь в отношении структуры : это не объект, а макет данных, который не означает конструктора или деструктора (если вам нужны эти функции, вам понадобится специальная функция).

следующий ваш актуальный вопрос: «Могу ли я иметь переменный объем памяти в своей структуре ?»

Ответ:

Да, но не напрямую, вам нужно будет использовать такие функции, как malloc и free для динамического выделения и освобождения памяти, я не буду подробно объяснять их, вы найдете, как их очень легко использовать в Интернете.

Вам нужно будет сделать что-то вроде :

 #includelt;stdlib.hgt;  struct mystruct {  unsigned size;  unsigned * memory; };  typedef struct mystruct mystruct;  mystruct * mystruct_constructor(unsigned s) {  //allocate the space of struct itself  mystruct * ms = malloc(sizeof(mystruct));   ms-gt;size = s;   //allocate the variable size array  ms-gt;memory = malloc(sizeof(unsigned) * s);   return ms; }  void mystruct_destructor(mystruct * ms) {  free(ms-gt;memory);  free(ms); }  

просто знайте, что malloc не инициализирует пространство, поэтому данные внутри неизвестны (и, скорее всего, не равны нулю).

что касается причины, по которой вы не можете определить структуру переменного размера, заключается в том, что вам нужен массив времени компиляции (например unsigned var[X] ), чтобы иметь размер, определенный во время компиляции, потому что, когда вы создаете такой массив, структура фактически содержит элемент X типа массива.

что означает:

 #define N whatever_value_you_want  struct {  unsigned item[N   1]; // valid because it can be known at compile-time };  

имеет ту же (при нормальных условиях) компоновку, что и:

 struct {  unsigned item_0;  unsigned item_1;  unsigned item_2;  ...  unsigned item_N; }