How to modify or create a struct depending on argument? - c

Question

I must further develop a simulator using C, capable of simulating different cache types (direct, n-way associative, fully associative). Right now my code works in the sense that it can simulate a direct-mapped cache, however it cannot simulate any other type.
My Code
My C file:
/*
* CS3375 Computer Architecture
* Course Project
* Cache Simulator Design and Development
* FALL 2017
* By Yong Chen
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <math.h>
#include "cachesim.h"
int main(int argc, char *argv[])
{
char type;
if (argc != 3) {
printf("Usage: %s <direct> <trace file name>\n", argv[0]);
return 1;
}
#ifdef DBG
printf("BLOCK SIZE = %d Bytes\n", BLOCK_SIZE);
printf("%d-WAY\n", WAY_SIZE);
printf("CACHE SIZE = %d Bytes\n", CACHE_SIZE);
printf("NUMBER OF BLOCKS = %d\n", NUM_BLOCKS);
printf("NUMBER OF SETS = %d\n", 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; i<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(&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 Cache\n");
printf("==================================\n");
printf("Cache Hits: %d\n", d_cache.hits);
printf("Cache Misses: %d\n", d_cache.misses);
printf("Cache Hit Rate: %f\n", hit_rate);
printf("Cache Miss Rate: %f\n", 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] <= '9' && memory_addr[i] >= '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 %llu\n", memory_addr, binary);
#endif
return binary;
}
void direct_mapped_cache_access(struct direct_mapped_cache *cache, uint64_t address)
{
uint64_t block_addr = address >> (unsigned)log2(BLOCK_SIZE);
uint64_t index = block_addr % NUM_BLOCKS;
uint64_t tag = block_addr >> (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->valid_field[index] && cache->tag_field[index] == tag) { /* Cache hit */
cache->hits += 1;
#ifdef DBG
printf("Hit!\n");
#endif
} else {
/* Cache miss */
cache->misses += 1;
#ifdef DBG
printf("Miss!\n");
#endif
if (cache->valid_field[index] && cache->dirty_field[index]) {
/* Write the cache block back to memory */
}
cache->tag_field[index] = tag;
cache->valid_field[index] = 1;
cache->dirty_field[index] = 0;
}
}
My .h file:
/*
* CS3375 Computer Architecture
* Course Project
* Cache Simulator Design and Development
* FALL 2017
* By Yong Chen
*/
#include <stdio.h>
/* 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);
What I've Tried
Admittedly, I am a beginner when it comes to the C language, so my solution may be simpler than I think, but I've been unable to find any answers thus far. I've considered changing where the cache variables were defined using "#define" depending on the argument, but I have learned that "#define" is run by pre-processing, so this won't work.
I've also tried creating multiple struct classes for each type of cache that needs to be simulated, but since struct variables in C cannot be initialized within the class, I can't get this to work either.
To my understanding, structs in C cannot have constructors either, as I've looked into this as well.
Any help or step in the right direction will be greatly appreciated.

Answer 1

first there is a you are mistaken about struct : they are not object but a data layout which mean no constructor or destructor (if you need those feature you will need dedicated function)
next your actual question: "can i have a variable amount of memory in my struct ?"
Answer:
Yes, but not directly, you will need to use function like malloc and free to dynamically allocate and deallocate memory, i won't make a full explanation about them you will find how to use them very easily online.
You will need to do something like :
#include<stdlib.h>
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->size = s;
//allocate the variable size array
ms->memory = malloc(sizeof(unsigned) * s);
return ms;
}
void mystruct_destructor(mystruct * ms) {
free(ms->memory);
free(ms);
}
just know that malloc don't initialize the space so the data within are unknown (and likely not zero).
as for the why you can't define variable size struct is because you need compile time array (those like unsigned var[X]) to have a compile time defined size, because when you make such array the struct actually contain X element of the array type.
which mean:
#define N whatever_value_you_want
struct {
unsigned item[N + 1]; // valid because it can be known at compile-time
};
has the same (under normal condition) layout as:
struct {
unsigned item_0;
unsigned item_1;
unsigned item_2;
...
unsigned item_N;
}