int main()
{
char *env_input;
char path[4096];
/* CGI initial print */
printf("Content-type: text/html\n\n");
/* create trace/log */
trace_init("list.log");
/* get GET content from environment variable */
env_input = getenv("QUERY_STRING");
if (env_input == NULL) {
trace(WEB, "No env variable: QUERY_STRING.\n", NULL);
goto exit;
}
/* extract page number from GET content */
sscanf(env_input, "p=%s", path);
/* echo HTML */
cat("head.cat");
printf("file: %s <br/>", basename(path));
printf("[dmath]%s[/dmath]", first_line(path));
cat("neck.cat");
echo_tex_li(path);
cat("ass.cat");
cat("tail.cat");
exit:
/* delete trace/log */
trace_unfree();
trace_uninit();
return 0;
}
int main(int argc, char **argv)
{
char *trace_file_name;
int trace_view_on = 0;
int branch_prediction_method = 0;
unsigned int cycle_number = 0;
// Parse Inputs
if (argc == 2) {
trace_file_name = argv[1];
trace_view_on = 0;
branch_prediction_method = 0;
} else if (argc == 4) {
trace_file_name = argv[1];
trace_view_on = atoi(argv[2]);
branch_prediction_method = (atoi(argv[3]) == 1) ? 1 : 0;
} else {
fprintf(stdout, "\nUSAGE: tv <trace_file> <switch - any character> <branch_prediction - 0|1>\n");
fprintf(stdout, "\n(switch) to turn on or off individual item view.\n");
fprintf(stdout, "(branch_prediction) sets the branch prediction method as \'assume not taken\' (0), or a 1-bit branch predictor (1)\n\n");
exit(0);
}
// debug - print parsed options
char dbg_msg[200];
sprintf(dbg_msg,
"\n-debug- parsed inputs. file=%s, view_trace=%d, branch_pred=%d\n",
trace_file_name,
(trace_view_on == 0) ? 0 : 1,
(branch_prediction_method == 0) ? 0 : 1
);
debug_print(dbg_msg);
// Open the trace file.
fprintf(stdout, "\n ** opening file %s\n", trace_file_name);
trace_fd = fopen(trace_file_name, "rb");
if (!trace_fd) {
fprintf(stdout, "\ntrace file %s not opened.\n\n", trace_file_name);
exit(0);
}
trace_init();
// store what instruction is in each stage of the pipeline (can be no-ops)
struct trace_item new_instruction;
struct trace_item if_stage;
struct trace_item id_stage;
struct trace_item ex_stage;
struct trace_item mem_stage;
struct trace_item wb_stage;
zero_buf(&new_instruction);
zero_buf(&if_stage);
zero_buf(&id_stage);
zero_buf(&ex_stage);
zero_buf(&mem_stage);
zero_buf(&wb_stage);
memset(&btb_table, 0, sizeof(short) * BTB_ENTRIES);
int instructions_left = 5;
while(instructions_left) {
cycle_number++;
if(trace_view_on) {
print_finished_instruction(&wb_stage, cycle_number);
}
int hazard = 0;
//detection of non-happy
if(branch_prediction_method == 0 && ex_stage.type == ti_BRANCH){
if(ex_stage.PC + 4 != id_stage.PC){
hazard = 2; //incorrect no prediction
debug_print("[HAZARD] Incorrect default (not taken) prediciton\n");
}
}
else if(ex_stage.type == ti_JTYPE|| ex_stage.type == ti_JRTYPE){
hazard = 2; //jump
debug_print("[HAZARD] jump\n");
}
else if(branch_prediction_method == 1 && ex_stage.type == ti_BRANCH){
if(ex_stage.PC +4 == id_stage.PC){ // not taken
if(get_btb_value(ex_stage.PC) == 1){ //predict taken
hazard = 2; //branch
debug_print("[HAZARD] predicted taken when not taken\n");
set_btb_value(ex_stage.PC, 0);
}
}
else{ //taken
if(get_btb_value(ex_stage.PC) == 0){ //predict not taken
hazard = 2; //branch
debug_print("[HAZARD] predicted not taken when taken\n");
set_btb_value(ex_stage.PC, 1);
}
}
}
else if(ex_stage.type == ti_LOAD){
if(ex_stage.dReg == id_stage.sReg_a || ex_stage.dReg == id_stage.sReg_b){
hazard = 1; //forward
debug_print("[HAZARD] forward\n");
}
}
wb_stage = mem_stage;
mem_stage = ex_stage;
switch(hazard) {
case 0: //happy path
ex_stage = id_stage;
id_stage = if_stage;
if(!read_instruction(&if_stage)) {
instructions_left--;
zero_buf(&if_stage);
}
break;
case 1: //forward
zero_buf(&ex_stage);
break;
case 2: //branch resolve/jump resolve
add_queued_instruction(&id_stage);
add_queued_instruction(&if_stage);
zero_buf(&id_stage);
zero_buf(&if_stage);
ex_stage = id_stage;
id_stage = if_stage;
if(!read_instruction(&if_stage)) {
instructions_left--;
zero_buf(&if_stage);
}
break;
default:
printf("f**k.\n");
exit(1);
}
}
printf("+ Simulation terminates at cycle : %u\n", cycle_number);
trace_uninit();
exit(0);
}
int main()
{
struct list_it li_subpath = LIST_NULL;
struct subpath *p;
struct searcher *se;
struct score_cache *cache;
struct score_tr *st;
struct brw brw;
brw.pin[1] = 0;
brw.fan[0] = 1;
brw.fan[1] = 0;
printf("size=%ld\n", sizeof(struct score_tr) +
sizeof(struct searcher) + sizeof(struct score_cache));
trace_init("test-score.log");
p = cp_malloc(sizeof(struct subpath));
strcpy(p->dir, "a dir");
p->brw.symbol_id = S_Alpha;
p->brw.pin[0] = 2;
p->brw.fan[0] = 1;
p->brw.pin[1] = 0;
p->brw.fan[1] = 0;
LIST_NODE_CONS(p->ln);
list_insert_one_at_tail(&p->ln, &li_subpath, NULL, NULL);
p = cp_malloc(sizeof(struct subpath));
strcpy(p->dir, "b dir");
p->brw.symbol_id = S_Alpha;
p->brw.pin[0] = 1;
p->brw.fan[0] = 1;
p->brw.pin[1] = 0;
p->brw.fan[1] = 0;
LIST_NODE_CONS(p->ln);
list_insert_one_at_tail(&p->ln, &li_subpath, NULL, NULL);
p = cp_malloc(sizeof(struct subpath));
strcpy(p->dir, "a dir");
p->brw.symbol_id = S_Beta;
p->brw.pin[0] = 3;
p->brw.fan[0] = 1;
p->brw.pin[1] = 0;
p->brw.fan[1] = 0;
LIST_NODE_CONS(p->ln);
list_insert_one_at_tail(&p->ln, &li_subpath, NULL, NULL);
//subpaths_print(&li_subpath, stdout);
/* transfer subpath into searcher */
se = searcher_new();
searcher_cons(se, &li_subpath);
subpaths_free(&li_subpath);
/* score tree construction */
st = score_tr_new();
score_tr_setup(st, se->n_qpath);
cache = cp_malloc(sizeof(struct score_cache));
{ /* search loop */
brw.symbol_id = S_alpha;
brw.pin[0] = 12;
score_push(st, se, cache, 0, &brw, 0);
brw.symbol_id = S_beta;
brw.pin[0] = 21;
score_push(st, se, cache, 0, &brw, 0);
brw.symbol_id = S_alpha;
brw.pin[0] = 22;
score_push(st, se, cache, 1, &brw, 0);
printf(C_MAGENTA "before calc:\n" C_RST);
score_tr_print(st, stdout);
searcher_print(se, stdout);
score_calc(st, se, cache, 0);
printf(C_CYAN "score = %d\n" C_RST, st->score);
score_tr_clear(st);
searcher_clear(se);
printf(C_MAGENTA "after clear:\n" C_RST);
score_tr_print(st, stdout);
searcher_print(se, stdout);
/* redundance */
brw.symbol_id = S_alpha;
brw.pin[0] = 1;
score_push(st, se, cache, 0, &brw, 0);
brw.symbol_id = S_beta;
brw.pin[0] = 2;
score_push(st, se, cache, 1, &brw, 0);
brw.symbol_id = S_alpha;
brw.pin[0] = 3;
score_push(st, se, cache, 0, &brw, 0);
brw.symbol_id = S_beta;
brw.pin[0] = 4;
score_push(st, se, cache, 0, &brw, 0);
brw.symbol_id = S_alpha;
brw.pin[0] = 5;
score_push(st, se, cache, 1, &brw, 0);
printf(C_MAGENTA "before calc:\n" C_RST);
score_tr_print(st, stdout);
searcher_print(se, stdout);
score_calc(st, se, cache, 0);
printf(C_CYAN "score = %d\n" C_RST, st->score);
score_tr_clear(st);
searcher_clear(se);
printf(C_MAGENTA "after clear:\n" C_RST);
score_tr_print(st, stdout);
searcher_print(se, stdout);
}
cp_free(cache);
cp_free(st);
searcher_empty(se);
cp_free(se);
trace_unfree();
trace_uninit();
return 0;
}
int main(int argc, char **argv)
{
struct trace_item *tr_entry;
size_t size;
char *trace_file_name;
int trace_view_on ;
if (argc == 1) {
fprintf(stdout, "\nUSAGE: tv <trace_file> <switch - any character>\n");
fprintf(stdout, "\n(switch) to turn on or off individual item view.\n\n");
exit(0);
}
// here you should extract the cache parameters from the command line
trace_file_name = argv[1];
trace_view_on = atoi(argv[2]);
cache_size = atoi(argv[3]);
block_size = atoi(argv[4]);
associativity = atoi(argv[5]);
policy = atoi(argv[6]);
double log = log2(cache_size);
cache_size = pow(2, 10) * pow(2,log );
size = cache_size;
printf("size of cache is %d\n block size is %d\n associativity is %d\n", size, block_size, associativity);
fprintf(stdout, "\n ** opening file %s\n", trace_file_name);
trace_fd = fopen(trace_file_name, "rb");
if (!trace_fd) {
fprintf(stdout, "\ntrace file %s not opened.\n\n", trace_file_name);
exit(0);
}
trace_init();
// here should call cache_create(cache_size, block_size, associativity, replacement_policy)
struct cache_t *cp = cache_create(size, block_size, associativity, policy);
while(1) {
size = trace_get_item(&tr_entry);
if (!size) { /* no more instructions to simulate */
printf("+ number of accesses : %d \n", accesses);
printf("+ number of reads : %d \n", read_accesses);
printf("+ number of writes : %d \n", write_accesses);
printf("+ number of hits : %d \n", hits);
printf("+ number of misses : %d \n", misses);
printf("+ number of misses with write back : %d \n", misses_with_writeback);
break;
}
else{ /* process only loads and stores */;
if (tr_entry->type == ti_LOAD) {
if (trace_view_on) printf("LOAD %x \n",tr_entry->Addr) ;
accesses ++;
read_accesses++ ;
load = cache_access(cp, tr_entry->Addr, 0, cycles);
}
if (tr_entry->type == ti_STORE) {
if (trace_view_on) printf("STORE %x \n",tr_entry->Addr) ;
accesses ++;
write_accesses++ ;
store = cache_access(cp, tr_entry->Addr, 1, cycles);
}
// based on the value returned, update the statisctics for hits, misses and misses_with_writeback
if(load == 0)
{
hits++;
load = -1;
}
if(store == 0)
{
hits++;
store = -1;
}
if(load == 1)
{
misses++;
load = -1;
}
if(store == 1)
{
misses++;
store = -1;
}
if(load == 2)
{
misses_with_writeback++;
load = -1;
}
if(store == 2)
{
misses_with_writeback++;
store = -1;
}
}
cycles++;
}
trace_uninit();
exit(0);
}
int main(int argc, char **argv)
{
struct trace_item *tr_entry;
size_t size;
char *trace_file_name;
int trace_view_on, cache_size, block_size;
int associativity, replacement_policy;
enum cache_policy policy;
struct cache_t *cp;
struct timeval gettimeofdayreturnstruct;
unsigned long long timestamp_in_microsec;
int cache_access_status;
FILE *file_results; //we will be writing our results out to a file
//define default
trace_view_on = 1;
cache_size = 1; //1 KB
block_size = 4; //4 bytes = 1 word
associativity = 1; //1-way associativity
replacement_policy = 0; //0 for LRU, 1 for FIFO
if (argc == 1) {
fprintf(stdout, "nUSAGE: tv <trace_file> <switch - any character>n");
fprintf(stdout, "n(switch) to turn on or off individual item view.nn");
exit(0);
}
trace_file_name = argv[1];
// here you should extract the cache parameters from the command line
if (argc == 7)
{
trace_view_on = atoi(argv[2]) ;
// here you should extract the cache parameters from the command line
cache_size = atoi(argv[3]); //in kilobytes
block_size = atoi(argv[4]);
associativity = atoi(argv[5]);
if ((cache_size != (cache_size & -cache_size)) || (block_size != (block_size & -block_size)) || (associativity != (associativity & -associativity))) { //should be restricted to the power of 2
fprintf(stdout, "Cache size, block size, and block associativity have to be a power of 2. (For example: 1, 2, 4, 8, 16, ...");
exit(0);
}
replacement_policy = atoi(argv[6]);
if ( !(replacement_policy == 0 || replacement_policy == 1) ){
fprintf(stdout, "\nMake sure that you pick either 0 for LRU replacement or 1 for FIFO replacement.");
fprintf(stdout, " %d is not a valid number.", replacement_policy);
exit(0);
}
}
if(replacement_policy){
policy = FIFO;
}
else{
policy = LRU;
}
fprintf(stdout, "n ** opening file %sn", trace_file_name);
trace_fd = fopen(trace_file_name, "rb");
if (!trace_fd) {
fprintf(stdout, "ntrace file %s not opened.nn", trace_file_name);
exit(0);
}
trace_init();
file_results = fopen("./results.txt", "w"); //open text file for writing out results
//print back all the parameters
printf("Parameters:");
fprintf(file_results,"\n\nParameters:");
printf("\nTrace Name: %s", trace_file_name);
fprintf(file_results, "\nTrace Name: %s", trace_file_name);
printf("\nCache Size: %d KBYTES", cache_size);
fprintf(file_results, "\nCache Size: %d KBYTES", cache_size);
printf("\nBlock Size: %d BYTES", block_size);
fprintf(file_results, "\nBlock Size: %d BYTES", block_size);
printf("\nAssociativity: %d", associativity);
fprintf(file_results, "\nAssociativity: %d", associativity);
if (replacement_policy == 0) {
printf("\nReplacement Policy: LRU");
fprintf(file_results, "\nReplacement Policy: LRU");
}
else {
printf("\nReplacement Policy: FIFO");
fprintf(file_results, "\nReplacement Policy: FIFO");
}
// here should call cache_create(cache_size, block_size, associativity, replacement_policy)
cp = cache_create(cache_size, block_size, associativity, policy);
while(1) {
size = trace_get_item(&tr_entry);
if (!size) { /* no more instructions to simulate */
printf("\n\nResults:");
fprintf(file_results, "\n\nResults:");
printf("\nCache Accesses: %d", accesses);
fprintf(file_results, "\nCache Accesses: %d", accesses);
printf("\nCache Read Accesses: %d", read_accesses);
fprintf(file_results, "\nCache Read Accesses: %d", read_accesses);
printf("\nCache Write Accesses: %d", write_accesses);
fprintf(file_results, "\nCache Write Accesses: %d", write_accesses);
printf("\nCache Hits: %d", hits);
fprintf(file_results, "\nCache Hits: %d", hits);
printf("\nCache Misses: %d", misses);
fprintf(file_results, "\nCache Misses: %d", misses);
printf("\nCache Writebacks: %d", misses_with_writeback);
fprintf(file_results, "\nCache Writebacks: %d", misses_with_writeback);
break;
}
else{ /* process only loads and stores */;
gettimeofday(&gettimeofdayreturnstruct, NULL);
timestamp_in_microsec = (unsigned long long)(1000000ULL * gettimeofdayreturnstruct.tv_sec + gettimeofdayreturnstruct.tv_usec);
if (tr_entry->type == ti_LOAD) {
if (trace_view_on) {
printf("\n\nLOAD %x n",tr_entry->Addr);
fprintf(file_results, "\n\nLOAD %x n",tr_entry->Addr);
}
// call cache_access(struct cache_t *cp, tr_entry->Addr, access_type)
cache_access_status = cache_access(cp, tr_entry->Addr, tr_entry->type, file_results, trace_view_on, timestamp_in_microsec);
read_accesses = read_accesses + 1;
accesses = accesses + 1;
}
else if (tr_entry->type == ti_STORE) {
if (trace_view_on) {
printf("\n\nSTORE %x n",tr_entry->Addr) ;
fprintf(file_results, "\n\nSTORE %x n",tr_entry->Addr) ;
}
// call cache_access(struct cache_t *cp, tr_entry->Addr, access_type)
cache_access_status = cache_access(cp, tr_entry->Addr, tr_entry->type, file_results, trace_view_on, timestamp_in_microsec);
write_accesses = write_accesses + 1;
accesses = accesses + 1;
}
else {
cache_access_status = 100; //not a load or store
}
// based on the value returned, update the statisctics for hits, misses and misses_with_writeback
if(cache_access_status == 0){ //0 if a hit, 1 if a miss or 2 if a miss_with_write_back
hits = hits + 1;
if (trace_view_on) {
printf("\nStatus: hit");
fprintf(file_results, "\nStatus: hit");
}
}
else if (cache_access_status == 1) {
misses = misses + 1;
if (trace_view_on) {
printf("\nStatus: miss");
fprintf(file_results, "\nStatus: miss");
}
}
else if (cache_access_status == 2) {
misses_with_writeback = misses_with_writeback + 1;
if (trace_view_on) {
printf("\nStatus: miss with writeback");
fprintf(file_results, "\nStatus: miss with writeback");
}
}
}
}
fclose(file_results); //close output file
trace_uninit();
exit(0);
}
int main(int argc, char* argv[])
{
char *frml = NULL, *url = NULL;
struct list_it li_subpath;
void *db_formula;
void *db_webpage;
void *db_textree;
BOOL bad_parse = 0;
int subpath_err;
uint64_t records;
CP_ID id_new;
CP_NBRW n_brw;
int c;
/* log file initialize */
trace_init("index.log");
/* open key-value database files */
db_formula = db_init(CONFIG_FORMULA_DB_NAME, DB_OMOD_WR);
db_webpage = db_init(CONFIG_WEBPAGE_DB_NAME, DB_OMOD_WR);
db_textree = db_init(CONFIG_TEXTREE_DB_NAME, DB_OMOD_WR);
/* set parser_root to NULL initially */
/* or "go to exit" might free a random address. */
parser_root = NULL;
/* handle program arguments */
while ((c = getopt(argc, argv, "hf:u:")) != -1) {
switch (c) {
case 'h':
printf("DESCRIPTION:\n");
printf("index raw collection.\n");
printf("\n");
printf("SYNOPSIS:\n");
printf("%s -h | "
"-f <formula string> "
"-u <url> "
"\n",
argv[0]);
goto exit;
case 'f':
frml = cp_strdup(optarg);
break;
case 'u':
url = cp_strdup(optarg);
break;
default:
goto exit;
}
}
if (frml == NULL || url == NULL) {
printf("bad argument.\n");
goto exit;
}
printf("index... (`" C_RED "%s" C_RST "' @ %s)\n", frml, url);
/* before parsing, it is necessary to substitute possible
* carriage return(s) with space. Because a Mathjax content
* $ a\<^M>b $ will be interpreted as $ a\ b $, we infer a
* line-feed or carriage return should be replaced by a space.
*/
sub_cr_space(frml);
/* parse formula string */
if (!cp_parse(frml))
goto exit;
/* handle parser error */
if (parser_err_flg) {
parser_err_flg = 0;
printf("parser: %s\n", parser_err_msg);
bad_parse = 1;
goto exit;
}
/* check parser root */
if (NULL == parser_root) {
trace(INDEX, "NULL parser root.\n", NULL);
bad_parse = 1;
goto exit;
}
/* assign new formula ID in order */
records = (CP_ID)db_num_records(db_formula);
if (0 != records % 3)
trace(INDEX, "bad records number: %u.\n", records);
if (records / 3 + 1 >= MAX_CP_ID) {
trace(INDEX, "NO available ID to assign.\n", NULL);
goto exit;
} else {
id_new = records / 3 + 1;
printf("assign ID = %u\n", id_new);
}
/* prepare posting file */
n_brw = tex_tr_update(parser_root);
if (n_brw == 0) {
trace(INDEX, "tex_tr_update() fails.\n", NULL);
goto exit;
}
li_subpath = tex_tr_subpaths(parser_root, &subpath_err);
if (subpath_err) {
trace(INDEX, "tex_tr_subpaths() fails.\n", NULL);
subpaths_free(&li_subpath);
goto exit;
}
/* write posting file */
posting_write(&li_subpath, id_new);
subpaths_free(&li_subpath);
/* index formula */
if (db_formula) {
if (!index_formula(db_formula, id_new, frml, url, n_brw))
goto exit;
} else {
trace(INDEX, "fail to open %s for writing.\n",
CONFIG_FORMULA_DB_NAME);
goto exit;
}
/* index URL */
if (db_webpage) {
index_webpage(db_webpage, url, id_new);
}
/* index tree shape */
if (db_textree) {
index_textree(db_textree, id_new);
}
exit:
/* releases textree */
if (parser_root) {
tex_tr_release(parser_root);
parser_root = NULL;
}
/* free program argument string */
if (frml)
cp_free(frml);
if (url)
cp_free(url);
/* database release */
if (db_formula)
db_release(db_formula);
if (db_webpage)
db_release(db_webpage);
if (db_textree)
db_release(db_textree);
/* unfree trace */
if (0 != trace_unfree()) {
for (c = 0; c < argc; c ++) {
trace(UNFREE, "%s \n", argv[c]);
}
trace(UNFREE, "\n", NULL);
}
/* log release */
trace_uninit();
return bad_parse;
}
