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.