Subversion Repositories igor

#include <malloc.h>
#include <err.h>
#include <math.h>
 
#include "types.h"
#include "microcode.h"
#include "instructions.h"
#include "object.h"
#include "profiler.h"
#include "memory.h"
#include <string.h>
#include "io.h"
 
unsigned int *instruction_executions;
 
profile_t profile;
cache_t cache;
int profile_number;
 
/* Initialize a profil^W simulator structure */
void sim_init(char* name, int microprogram_size, int cache_size, unsigned int mem_size, unsigned int branch_buffer_size, char * branch_pred_scheme)
{
//	if(p == NULL)
//		p = &profile;
 
 
	profile.branch_buffer = calloc(branch_buffer_size, sizeof(int));
	profile.reuse = calloc(mem_size, sizeof(int));
	profile.reuse_sum = calloc(mem_size, sizeof(long long int));
	profile.instruction_execs = calloc(microprogram_size, sizeof(long long int));
	profile.memory_access = calloc(mem_size, sizeof(long long int));
	printf("initialized memory to %d\n", mem_size);
	cache_init(&cache, cache_size);
 
	profile.name = strdup(name);
	profile.mp_size = microprogram_size;
	profile.memory_size = mem_size;
	profile.total_execs = 0;
	profile.cache = &cache;
	/* branches */
	profile.branch_buffer_size = branch_buffer_size;
 
	profile.br_predict = 0;
	profile.br_mispredict = 0;
	profile.branch_pred_scheme = branch_pred_scheme;
 
	//profile.num_per_type = calloc(NUM_INSTRUCTIONS, sizeof(int));
	int i;
	for(i=0;i < NUM_INSTRUCTIONS; i++) { profile.num_per_type[i] = 0; }
 
	/* OK! */
	profile.initialized = 1;
}
 
 
void
profiler_init(int microprogram_size,  int cache_size)
{
	int i;
	profile.instruction_execs = calloc(microprogram_size, sizeof(int));
	profile.total_execs = 0;
	profile.mp_size = microprogram_size;
	for(i = 0; i < NUM_INSTRUCTIONS; i++) { profile.num_per_type[i] = 0; }
	cache_init(&cache, cache_size);
	profile_number = 0;
 
	profile.memory_size = DEFAULT_MEMORY_SIZE;
 
	/* Initialize memory */
	profile.memory_access = calloc(DEFAULT_MEMORY_SIZE, sizeof(int));
	/* Last re-use time for memory addresses */
	profile.reuse = calloc(DEFAULT_MEMORY_SIZE, sizeof(int));
	/* Sum of reuse-times for all memory addresses */
	profile.reuse_sum = calloc(DEFAULT_MEMORY_SIZE, sizeof(int));
}
 
void
profiler_new()
{
	profile_number++;
	memset(profile.instruction_execs, 0, profile.mp_size);
	profile.total_execs = 0;
	memset(profile.num_per_type, 0, NUM_INSTRUCTIONS);
 
	profile.cache->hits = 0;
	profile.cache->misses = 0;
	memset(profile.cache->storage, 0, profile.cache->size);
 
}
 
 
void
profiler_add_execution(unsigned int addr, instr_t instr, int flags)
{
	if(profile.initialized != 1) { return; }
 
	profile.instruction_execs[addr]++;
	profile.total_execs++;
	//uint32_t ls;
	int32_t ls = 0;
 
	//Add to type-count.
	profile.num_per_type[instr.op]++;
	switch(instr.op) {
		case INS_STORE:
			break;
		case INS_LOAD:
 
		 	ls = (OBJECT_DATUM(instr_get_reg(instr.r2))+instr.disp);
			if ((ls & IO_AREA_MASK) == IO_AREA_MASK) {
				break;
			}
			cache_load(profile.cache, ls);
			profile.memory_access[ls]++;
			reuse_update(&profile, ls);
			break;
		case INS_BRANCH:
		case INS_BRANCH_REG:
			if(0 == strcmp(profile.branch_pred_scheme, "taken")) {
				if ((instr.flag_mask & flags) == instr.flag_values) {
					profile.br_predict++;
				} else {
					profile.br_mispredict++;
				}
			} else if(0 == strcmp(profile.branch_pred_scheme, "2bit")) {
 
				//int branch_entry = addr%profile.branch_buffer_size;
				int branch_entry = (unsigned int)addr%(unsigned int)profile.branch_buffer_size;
 
				if(profile.branch_buffer[branch_entry] == PREDICT_TAKEN_1) {
					if ((instr.flag_mask & flags) == instr.flag_values) {
						profile.br_predict++;
						profile.branch_buffer[branch_entry] = PREDICT_TAKEN_1;
					} else {
						profile.branch_buffer[branch_entry] = PREDICT_TAKEN_2;
						profile.br_mispredict++;
					}
				} else if(profile.branch_buffer[branch_entry] == PREDICT_TAKEN_2) {
					if ((instr.flag_mask & flags) == instr.flag_values) {
						profile.br_predict++;
						profile.branch_buffer[branch_entry] = PREDICT_TAKEN_1;
					} else {
						profile.branch_buffer[branch_entry] = PREDICT_NOT_TAKEN_1;
						profile.br_mispredict++;
					}
				} else if(profile.branch_buffer[branch_entry] == PREDICT_NOT_TAKEN_1) {
						if ((instr.flag_mask & flags) == instr.flag_values) {
							profile.branch_buffer[branch_entry] = PREDICT_TAKEN_1;
							profile.br_mispredict++;
						} else {
							profile.br_predict++;
							profile.branch_buffer[branch_entry] = PREDICT_NOT_TAKEN_1;
						}
				} else if(profile.branch_buffer[branch_entry] == PREDICT_NOT_TAKEN_2) {
					if ((instr.flag_mask & flags) == instr.flag_values) {
						profile.branch_buffer[branch_entry] = PREDICT_TAKEN_1;
						profile.br_mispredict++;
					} else {
						profile.br_predict++;
						profile.branch_buffer[branch_entry] = PREDICT_NOT_TAKEN_1;
					}
				}
			}	
			break;
		default:
			break;
	}
 
 
	if (profile.total_execs==0) {
		errx(1, "instruction count overflow\n");
	}
}
 
 
void reuse_update(profile_t* p, unsigned int addr)
{
	int sample = abs(p->total_execs - p->reuse[addr]);
	p->reuse[addr] = p->total_execs;
	p->reuse_sum[addr] += sample;
}
 
 
void
profiler_dump_program(char* filename)
{
//	char filename[50];
 
//	sprintf(filename, "profile_%d.txt", profile_number);
 
	if(profile.initialized != 1) return;
	sim_write_file(&profile, filename);
	return;
}
 
 
 
 
 
/*----------------------------*/
/* - File writing functions - */
/*----------------------------*/
 
void sim_write_file(profile_t* p, const char* filename)
{
	if(filename == NULL) {
		errx(1, "no filename in write_profiler_file\n");
	}
 
	printf("Writing simulation data to disk.\n");
	FILE* f = fopen(filename, "w");
	sim_write_global_info(p, f);
	sim_write_cache_info(p, f);
	sim_write_branch_counts(p, f);
	sim_write_instr_counts(p, f);
	sim_write_reuse_info(p, f);	
	sim_write_mem_count(p, f);
	sim_write_mc_info(p, f);
	fclose(f);
}
 
void sim_write_global_info(profile_t* p, FILE* f)
{
	printf("Global information\n");
	fprintf(f, "[NAME]\n");
	fprintf(f, "%s\n", p->name);
	fprintf(f, "[TOTAL_EXECS]\n");
	fprintf(f, "%llu\n", p->total_execs);
}
 
void sim_write_cache_info(profile_t* p, FILE* f)
{
	printf("Writing cache info\n");
	fprintf(f, "[CACHESIZE]\n %u\n", p->cache->size);
	fprintf(f, "[CACHEHITS]\n %u\n", p->cache->hits);
	fprintf(f, "[CACHEMISS]\n %u\n", p->cache->misses);
}
 
void sim_write_reuse_info(profile_t* p, FILE* f)
{
	printf("Writing reuse times for memsize %d\n",p->memory_size);
	int i;
	fprintf(f, "[REUSE]\n");
	for (i = 0; i < p->memory_size; i++) {
		fprintf(f, "0x%08X %d %llu\n", i, p->reuse_sum[i], p->memory_access[i]);
	}
}
 
void sim_write_mem_count(profile_t* p, FILE* f)
{
	printf("Writing memory hit counts\n");
	int i;
	fprintf(f, "[MEMCOUNT]\n");
	for (i = 0; i < p->memory_size; i++) {
		fprintf(f, "0x%08X %llu\n", i, p->memory_access[i]);
	}
}
 
void sim_write_mc_info(profile_t* p, FILE* f)
{
	printf("Writing microprogram instruction counts\n");
	int i;
	fprintf(f, "[MICROPROGRAM]\n");
	for (i = 0; i < microcode_size(); i++) {
		fprintf(f, "0x%08X %llu\n", i, p->instruction_execs[i]);
	}
}
 
void sim_write_instr_counts(profile_t* p, FILE* f) 
{
	printf("Writing total instruction type counts\n");
	int i;
	fprintf(f, "[TYPECOUNT]\n");
	for(i = 0; i < NUM_INSTRUCTIONS; i++) {
		if(instruction_type != NULL)
			fprintf(f, "%s %llu\n", instruction_type(i), p->num_per_type[i]);
	}
}
 
void sim_write_branch_counts(profile_t* p, FILE* f) 
{
	printf("Writing branch predicts and mispredicts\n");
	fprintf(f, "[BRANCH-PREDICT]\n");
	fprintf(f, "%llu\n", p->br_predict);
 
	fprintf(f, "[BRANCH-MISPREDICT]\n");
	fprintf(f, "%llu\n", p->br_mispredict);
}
 
 
 
 
 
/*------------------*/
/* Cache simulation */
/*------------------*/
 
void cache_load(cache_t* c, unsigned int addr)
{
	/* Do cache load, register hit or miss */	
	int position = addr % c->size;
	if(c->storage[position] == addr) {
		c->hits++;
	} else {
		c->storage[position] = addr;
		c->misses++;
	}
}
 
void cache_init(cache_t* c, int size)
{
	c->storage = calloc(size, sizeof(unsigned int));	
	c->size = size;
	c->hits = 0;
	c->misses = 0;
}