segmentation fault core dump error cache simulator - c

Question

I am filling in code for a Cache simulator in C. How it work is you are given an input file with commands, you are to trace the results of that input simulating cache functions so that we can keep track of cache hits and misses. I have written the following code but seem to be having trouble with my ReplayTrace method. The line "accessData(addr)" throws a "segmentation fault (core dump)." I am aware that means I am trying to access something that I do not have permission to access or is no longer existing or is out of range. I have no idea how else to call this function. I am posting my whole code because I don't want to make assumptions about where the problem may lie. Can anyone tell where I am making a mistake?
/* TODO - COMPLETE THIS FUNCTION
* accessData - Access data at memory address addr.
* If it is already in cache, increase hit_count
* If it is not in cache, bring it in cache, increase miss count.
* Also increase eviction_count if a line is evicted.
*
* You will manipulate data structures allocated in initCache() here
* Implement Least-Recently-Used (LRU) cache replacement policy
*/
void accessData(mem_addr_t addr)
{
int i;
//pulling out the set and tag bits of address
mem_addr_t set = (addr >> b) & set_bits;
mem_addr_t tag = addr >> (s + b);
cache_set_t cache_set = cache[set];
/* judge if hit */
for (i = 0; i < E; ++i)
{
/* hit */
if (cache_set[i].valid && cache_set[i].tag == tag)
{
if (verbosity)
printf("hit ");
++hit_count;
/* update entry whose lru is less than the current lru (newer) */
for (int j = 0; j < E; ++j)
if (cache_set[j].valid && cache_set[j].lru < cache_set[i].lru)
++cache_set[j].lru;
cache_set[i].lru = 0;
return;
}
}
/* missed */
if (verbosity)
printf("miss ");
++miss_count;
/* find the biggest lru or the first invlaid line */
int j, maxIndex = 0;
unsigned long long maxLru = 0;
for (j = 0; j < E && cache_set[j].valid; ++j)
{
if (cache_set[j].lru >= maxLru)
{
maxLru = cache_set[j].lru;
maxIndex = j;
}
}
if (j != E)
{
/* found an invalid entry */
/* update other entries */
for (int k = 0; k < E; ++k)
if (cache_set[k].valid)
++cache_set[k].lru;
/* insert line */
cache_set[j].lru = 0;
cache_set[j].valid = 1;
cache_set[j].tag = tag;
}
else
{
/* all entry is valid, replace the oldest one*/
if (verbosity)
printf("eviction ");
++eviction_count;
for (int k = 0; k < E; ++k)
++cache_set[k].lru;
cache_set[maxIndex].lru = 0;
cache_set[maxIndex].tag = tag;
}
}
/* TODO - FILL IN THE MISSING CODE
* replayTrace - replays the given trace file against the cache
* reads the input trace file line by line
* extracts the type of each memory access : L/S/M
* YOU MUST TRANSLATE one "L" as a load i.e. 1 memory access
* YOU MUST TRANSLATE one "S" as a store i.e. 1 memory access
* YOU MUST TRANSLATE one "M" as a load followed by a store i.e. 2 memory accesses
* Ignore instruction fetch "I"
*/
void replayTrace(char* trace_fn)
{
char buf[1000];
mem_addr_t addr=0;
unsigned int len=0;
FILE* trace_fp = fopen(trace_fn, "r");
int count = 0;
if(!trace_fp){
fprintf(stderr, "%s: %s\n", trace_fn, strerror(errno));
exit(1);
}
while( fgets(buf, 1000, trace_fp) != NULL) {
if(buf[1]=='S' || buf[1]=='L' || buf[1]=='M') {
sscanf(buf+3, "%llx,%u", &addr, &len);
if(verbosity)
printf("%c %llx,%u ", buf[1], addr, len);
// TODO - MISSING CODE
// now you have:
// 1. address accessed in variable - addr
// 2. type of acccess(S/L/M) in variable - buf[1]
// call accessData function here depending on type of access
switch (buf[1])
{
case 'L':
case 'S':
accessData(addr);
++count;
break;
case 'M':
accessData(addr);
accessData(addr);
++count;
break;
default:
break;
}
if (verbosity)
printf("\n");
}
}
fclose(trace_fp);
}
--edit---
Valgrind output:
Command: ./csim -t traces/dave.trace -s 8 -E 4 -b 12
==4155737==
==4155737== Invalid read of size 8
==4155737== at 0x1095B2: accessData (csim.c:144)
==4155737== by 0x109AE3: replayTrace (csim.c:259)
==4155737== by 0x109DC6: main (csim.c:342)
==4155737== Address 0x4b9c040 is 0 bytes after a block of size 0 alloc'd
==4155737== at 0x483DD99: calloc (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==4155737== by 0x10938A: initCache (csim.c:99)
==4155737== by 0x109DB7: main (csim.c:336)
==4155737==
==4155737== Invalid read of size 1
==4155737== at 0x1095E2: accessData (csim.c:150)
==4155737== by 0x109AE3: replayTrace (csim.c:259)
==4155737== by 0x109DC6: main (csim.c:342)
==4155737== Address 0x0 is not stack'd, malloc'd or (recently) free'd
==4155737==
==4155737==
==4155737== Process terminating with default action of signal 11 (SIGSEGV)
==4155737== Access not within mapped region at address 0x0
==4155737== at 0x1095E2: accessData (csim.c:150)
==4155737== by 0x109AE3: replayTrace (csim.c:259)
==4155737== by 0x109DC6: main (csim.c:342)
==4155737== If you believe this happened as a result of a stack
==4155737== overflow in your program's main thread (unlikely but
==4155737== possible), you can try to increase the size of the
==4155737== main thread stack using the --main-stacksize= flag.
==4155737== The main thread stack size used in this run was 8388608.
==4155737==
==4155737== HEAP SUMMARY:
==4155737== in use at exit: 472 bytes in 2 blocks
==4155737== total heap usage: 3 allocs, 1 frees, 4,568 bytes allocated
==4155737==
==4155737== LEAK SUMMARY:
==4155737== definitely lost: 0 bytes in 0 blocks
==4155737== indirectly lost: 0 bytes in 0 blocks
==4155737== possibly lost: 0 bytes in 0 blocks
==4155737== still reachable: 472 bytes in 2 blocks
==4155737== suppressed: 0 bytes in 0 blocks
==4155737== Rerun with --leak-check=full to see details of leaked memory
==4155737==
==4155737== For lists of detected and suppressed errors, rerun with: -s
==4155737== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
Segmentation fault (core dumped)```