Skip to content

Instantly share code, notes, and snippets.

@songouyang songouyang/csim.c
Last active Dec 20, 2018

Embed
What would you like to do?
csapp cache lab
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <getopt.h>
#include "cachelab.h"
typedef struct arguments {
int h;
int v;
int s;
int E;
int b;
char * t;
} Arguments;
typedef struct cache_line {
int valid_bit;
int tag_bit;
int times;
} CacheLine;
typedef CacheLine * CacheSet;
typedef CacheSet * Cache;
void get_args(Arguments * args, int argc, char ** argv) {
int opt;
while(-1 != (opt = getopt(argc, argv, "hvs:E:b:t:"))) {
switch(opt) {
case 'h':
args->h = 1;
break;
case 'v':
args->v = 1;
break;
case 's':
args->s = atoi(optarg);
break;
case 'E':
args->E = atoi(optarg);
break;
case 'b':
args->b = atoi(optarg);
break;
case 't':
args->t = (char*)malloc(sizeof(char) * strlen(optarg));
strcpy(args->t, optarg);
break;
default:
fprintf(stderr, "wrong argument\n");
exit(0);
break;
}
}
}
void process_help(Arguments args) {
if(args.h == 1 || args.s == -1 ||
args.E == -1 || args.b == -1 ||
args.t == NULL) {
FILE * fp = fopen("help.txt", "rt");
char c;
while(fscanf(fp, "%c", &c) != EOF) {
putchar(c);
}
fclose(fp);
exit(0);
}
}
int hit_count = 0;
int miss_count = 0;
int eviction_count = 0;
void init_args(Arguments * args) {
args->h = 0;
args->v = 0;
args->s = -1;
args->E = -1;
args->b = -1;
args->t = NULL;
}
void init_cache(Cache * cache, Arguments * args) {
int set_size = 1 << args->s;
int num_lines = args->E;
*cache = (CacheSet *)malloc(sizeof(CacheSet) * set_size);
for(int i =0; i<set_size; ++i) {
(*cache)[i] = (CacheLine*)malloc(sizeof(CacheLine)*num_lines);
for(int j = 0; j<num_lines; ++j) {
(*cache)[i][j].valid_bit = 0;
(*cache)[i][j].tag_bit = -1;
(*cache)[i][j].times = 0;
}
}
}
void process(Cache * cache, Arguments * args, int address) {
address >>= args->b;
int set_index = 0;
int tag_bits, i;
long mask = 0xffffffffffffffff >> (64 - args->s);
set_index = mask & address;
address >>= args->s;
tag_bits = address;
CacheSet set = (*cache)[set_index];
for (i = 0; i < args->E; ++i) {
if (set[i].valid_bit == 1) {
set[i].times++;
}
}
for (i = 0; i < args->E; ++i) {
if (set[i].valid_bit == 1 && set[i].tag_bit == tag_bits) {
if(args->v) printf(" hit");
set[i].times = 0;
++hit_count;
return;
}
}
++miss_count;
if(args->v) printf(" miss");
for (i = 0; i < args->E; ++i) {
if (set[i].valid_bit == 0) {
set[i].tag_bit = tag_bits;
set[i].valid_bit = 1;
set[i].times = 0;
return;
}
}
++eviction_count;
if(args->v) printf(" eviction");
int max_index = 0, max_time = set[0].times;
for (i = 0; i < args->E; ++i) {
if (set[i].times > max_time) {
max_index = i;
max_time = set[i].times;
}
}
set[max_index].tag_bit = tag_bits;
set[max_index].times = 0;
}
int main(int argc, char ** argv) {
Arguments args;
init_args(&args);
get_args(&args, argc, argv);
process_help(args);
Cache cache;
init_cache(&cache, &args);
FILE * fp = fopen(args.t, "r");
if(fp == NULL) {
printf("%s: No such file or directory\n", args.t);
exit(1);
}
char op;
unsigned address;
int size = -1;
while(fscanf(fp, " %c %x,%d", &op, &address, &size) > 0) {
if(size==-1) continue;
switch(op) {
case 'I':
break;
case 'M':
if(args.v) printf("M, %x, %d", address, size);
process(&cache, &args, address);
process(&cache, &args, address);
if(args.v) printf("\n");
break;
case 'L':
if(args.v) printf("L, %x, %d", address, size);
process(&cache, &args, address);
if(args.v) printf("\n");
break;
case 'S':
if(args.v) printf("S, %x, %d", address, size);
process(&cache, &args, address);
if(args.v) printf("\n");
break;
default:
printf("Error: invalid operation.");
exit(0);
}
}
fclose(fp);
printSummary(hit_count, miss_count, eviction_count);
for(int i = 0; i<(1<<args.s); ++i) {
free(cache[i]);
}
free(cache);
return 0;
}
/*
* trans.c - Matrix transpose B = A^T
*
* Each transpose function must have a prototype of the form:
* void trans(int M, int N, int A[N][M], int B[M][N]);
*
* A transpose function is evaluated by counting the number of misses
* on a 1KB direct mapped cache with a block size of 32 bytes.
*/
#include <stdio.h>
#include "cachelab.h"
int is_transpose(int M, int N, int A[N][M], int B[M][N]);
/*
* transpose_submit - This is the solution transpose function that you
* will be graded on for Part B of the assignment. Do not change
* the description string "Transpose submission", as the driver
* searches for that string to identify the transpose function to
* be graded.
*/
char transpose_submit_desc[] = "Transpose submission";
void transpose_submit(int M, int N, int A[N][M], int B[M][N]) {
int i, j, k, h;
int a1, a2, a3, a4, a5, a6, a7, a8;
if(N==32&&M==32) {
for (i = 0; i < N; i+=8) {
for (j = 0; j < M; j+=8) {
for(k=i; k<i+8; ++k) {
a1 = A[k][j];
a2 = A[k][j+1];
a3 = A[k][j+2];
a4 = A[k][j+3];
a5 = A[k][j+4];
a6 = A[k][j+5];
a7 = A[k][j+6];
a8 = A[k][j+7];
B[j][k] = a1;
B[j+1][k] = a2;
B[j+2][k] = a3;
B[j+3][k] = a4;
B[j+4][k] = a5;
B[j+5][k] = a6;
B[j+6][k] = a7;
B[j+7][k] = a8;
}
}
}
} else if(N==64&&M==64) {
for(i=0; i<N; i+=8) {
for(j=0; j<M; j+=8) {
for(k=j; k<j+4; ++k) {
a1=A[k][i];
a2=A[k][i+1];
a3=A[k][i+2];
a4=A[k][i+3];
a5=A[k][i+4];
a6=A[k][i+5];
a7=A[k][i+6];
a8=A[k][i+7];
B[i][k]=a1;
B[i][k+4]=a5;
B[i+1][k]=a2;
B[i+1][k+4]=a6;
B[i+2][k]=a3;
B[i+2][k+4]=a7;
B[i+3][k]=a4;
B[i+3][k+4]=a8;
}
for(k=i; k<i+4; ++k) {
a1=B[k][j+4];
a2=B[k][j+5];
a3=B[k][j+6];
a4=B[k][j+7];
a5=A[j+4][k];
a6=A[j+5][k];
a7=A[j+6][k];
a8=A[j+7][k];
B[k][j+4]=a5;
B[k][j+5]=a6;
B[k][j+6]=a7;
B[k][j+7]=a8;
B[k+4][j]=a1;
B[k+4][j+1]=a2;
B[k+4][j+2]=a3;
B[k+4][j+3]=a4;
}
for(k=i+4; k<i+8; ++k) {
a1=A[j+4][k];
a2=A[j+5][k];
a3=A[j+6][k];
a4=A[j+7][k];
B[k][j+4]=a1;
B[k][j+5]=a2;
B[k][j+6]=a3;
B[k][j+7]=a4;
}
}
}
} else if(M==61&&N==67) {
for(i=0; i<N; i+=16) {
for(j=0; j<M; j+=16) {
for(k=i; k<i+16&&k<N; ++k) {
for(h=j; h<j+16&&h<M; ++h) {
B[h][k] = A[k][h];
}
}
}
}
}
}
/*
* You can define additional transpose functions below. We've defined
* a simple one below to help you get started.
*/
/*
* trans - A simple baseline transpose function, not optimized for the cache.
*/
char trans_desc[] = "Simple row-wise scan transpose";
void trans(int M, int N, int A[N][M], int B[M][N]) {
int i, j, tmp;
for (i = 0; i < N; i++) {
for (j = 0; j < M; j++) {
tmp = A[i][j];
B[j][i] = tmp;
}
}
}
/*
* registerFunctions - This function registers your transpose
* functions with the driver. At runtime, the driver will
* evaluate each of the registered functions and summarize their
* performance. This is a handy way to experiment with different
* transpose strategies.
*/
void registerFunctions() {
/* Register your solution function */
registerTransFunction(transpose_submit, transpose_submit_desc);
/* Register any additional transpose functions */
registerTransFunction(trans, trans_desc);
}
/*
* is_transpose - This helper function checks if B is the transpose of
* A. You can check the correctness of your transpose by calling
* it before returning from the transpose function.
*/
int is_transpose(int M, int N, int A[N][M], int B[M][N]) {
int i, j;
for (i = 0; i < N; i++) {
for (j = 0; j < M; ++j) {
if (A[i][j] != B[j][i]) {
return 0;
}
}
}
return 1;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.