mica.cpp

/*
 * This file is part of MICA, a Pin tool to collect
 * microarchitecture-independent program characteristics using the Pin
 * instrumentation framework.
 *
 * Please see the README.txt file distributed with the MICA release for more
 * information.
 */

/*************************************************************************
 *                                                                       *
 *   MICA: Microarchitecture-Independent Characterization of Workloads   *
 *                                                                       *
 *************************************************************************
 *
 * implementation by Kenneth Hoste (Ghent University, Belgium), December 2006 - March 2011
 * based on code written by Lieven Eeckhout (for ATOM on Alpha)
 *
 * PLEASE DO NOT REDISTRIBUTE THIS CODE WITHOUT INFORMING THE AUTHORS.
 *
 * contact: kenneth.hoste@ugent.be , lieven.eeckhout@elis.ugent.be
 *
 */

/* MICA includes */
#include "mica.h"
#include "mica_init.h"
#include "mica_utils.h"

#include "mica_all.h"
#include "mica_ilp.h"
#include "mica_itypes.h"
#include "mica_ppm.h"
#include "mica_reg.h"
#include "mica_stride.h"
#include "mica_memfootprint.h"
#include "mica_memstackdist.h"
#include "mica_fullmemstackdist.h"
#include "mica_linecount.h"

#include <sstream>
#include <iostream>
#include <iomanip>
#include <unistd.h>
using namespace std;

/* *** Variables *** */

/* global */
INT64 interval_size; // interval size chosen
INT64 interval_ins_count;
INT64 interval_ins_count_for_hpc_alignment;
INT64 total_ins_count;
INT64 total_ins_count_for_hpc_alignment;

ins_buffer_entry* ins_buffer[MAX_MEM_TABLE_ENTRIES];

/* ILP */
UINT32 _ilp_win_size;
char* _itypes_spec_file;

/* ILP, MEMFOOTPRINT, MEMSTACKDIST */
UINT32 _block_size;

/* MEMFOOTPRINT */
UINT32 _page_size;

/* for multiprocess binaries */
int append_pid;

/* helper */
int thread_count = 0;

static bool use_magic_instruction = false;
static bool start_monitoring = false;

/**********************************************
 *                    MAIN                    *
 **********************************************/

//FILE* log;
ofstream log;


/* append <pid>_pin.out to name if necessary */
const char *mkfilename(const char *name)
{
	stringstream ret;
	if (append_pid)
		ret << name << "_" << setfill('0') << setw(5) << getpid() << "_pin.out";
	else
		ret << name << "_pin.out";
	return ret.str().c_str();
}

// find buffer entry for instruction at given address in a hash table
ins_buffer_entry* findInsBufferEntry(ADDRINT a){

	ins_buffer_entry* e;
	INT64 key = a % MAX_MEM_TABLE_ENTRIES;

	e = ins_buffer[key];

	if(e != NULL){
		do{
			if(e->insAddr == a)
				break;
			e = e->next;
		} while(e->next != (ins_buffer_entry*)NULL);

		/* ins address not found, installing */
		if(e == NULL){
			e = (ins_buffer_entry*)checked_malloc(sizeof(ins_buffer_entry));
			e->insAddr = a;
			e->regReadCnt = 0;
			e->regsRead = NULL;
			e->regWriteCnt = 0;
			e->regsWritten = NULL;
			e->next = NULL;
			e->setRead = false;
			e->setWritten = false;
			e->setRegOpCnt = false;

			ins_buffer_entry* tmp = e = ins_buffer[key];
			while(tmp->next != (ins_buffer_entry*)NULL)
				tmp = tmp->next;
			tmp->next = e;
		}
	}
	else{
		/* new entry in hash table */
		e = (ins_buffer_entry*)checked_malloc(sizeof(ins_buffer_entry));
		e->insAddr = a;
		e->regOpCnt = 0;
		e->regReadCnt = 0;
		e->regsRead = NULL;
		e->regWriteCnt = 0;
		e->regsWritten = NULL;
		e->next = NULL;
		e->setRead = false;
		e->setWritten = false;
	}

	return e;
}

static void instrument_start_monitoring(INS ins, VOID* v) {
	if (use_magic_instruction) {
		if (INS_IsXchg(ins) && INS_OperandReg(ins, 0) == INS_OperandReg(ins, 1)) {
			start_monitoring ^= true;
		}
	}
}

static void instrument_instruction_count(INS ins, VOID* v) {
	if(interval_size == -1)	{
		if(INS_HasRealRep(ins)){
			INS_InsertIfCall(ins, IPOINT_BEFORE, (AFUNPTR)returnArg, IARG_FIRST_REP_ITERATION, IARG_END);
			INS_InsertThenCall(ins, IPOINT_BEFORE, (AFUNPTR)all_instr_full_count_for_hpc_alignment_with_rep, IARG_REG_VALUE, INS_RepCountRegister(ins), IARG_END);
		}
		else{
			INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)all_instr_full_count_for_hpc_alignment_no_rep, IARG_END);
		}
		INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)all_instr_full_count_always, IARG_END);
	}
	else{
		if(INS_HasRealRep(ins)){
			INS_InsertIfCall(ins, IPOINT_BEFORE, (AFUNPTR)returnArg, IARG_FIRST_REP_ITERATION, IARG_END);
			INS_InsertThenCall(ins, IPOINT_BEFORE, (AFUNPTR)all_instr_intervals_count_for_hpc_alignment_with_rep, IARG_REG_VALUE, INS_RepCountRegister(ins), IARG_END);
		}
		else{
			INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)all_instr_intervals_count_for_hpc_alignment_no_rep, IARG_END);
		}
		INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)all_instr_intervals_count_always, IARG_END);
	}

}

/* ALL */
VOID Instruction_all(INS ins, VOID* v) {
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);

		ADDRINT insAddr = INS_Address(ins);
		ins_buffer_entry* e = findInsBufferEntry(insAddr);

		//instrument_ilp_all(ins, e);
		//instrument_itypes(ins, v);
		//instrument_ppm(ins, v);
		//instrument_reg(ins, e);
		//instrument_stride(ins, v);
		//instrument_memfootprint(ins, v);
		//instrument_memstackdist(ins, v);
		instrument_all(ins, v, e);
	}
}

VOID Fini_all(INT32 code, VOID* v){
	fini_ilp_all(code, v);
	fini_itypes(code, v);
	fini_ppm(code, v);
	fini_reg(code, v);
	fini_stride(code, v);
	fini_memfootprint(code, v);
	fini_memstackdist(code, v);
	fini_fullmemstackdist(code, v);
	fini_linecount(code, v);
}

/* ILP */
VOID Instruction_ilp_all_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		ADDRINT insAddr = INS_Address(ins);
		ins_buffer_entry* e = findInsBufferEntry(insAddr);
		instrument_ilp_all(ins, e);
	}
}

VOID Fini_ilp_all_only(INT32 code, VOID* v){
	fini_ilp_all(code, v);
}

/* ILP_ONE */
VOID Instruction_ilp_one_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		ADDRINT insAddr = INS_Address(ins);
		ins_buffer_entry* e = findInsBufferEntry(insAddr);
		instrument_ilp_one(ins, e);
	}
}

VOID Fini_ilp_one_only(INT32 code, VOID* v){
	fini_ilp_one(code, v);
}

/* ITYPES */
VOID Instruction_itypes_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		instrument_itypes(ins, v);
	}
}

VOID Fini_itypes_only(INT32 code, VOID* v){
	fini_itypes(code, v);
}

/* PPM */
VOID Instruction_ppm_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		instrument_ppm(ins, v);
	}
}

VOID Fini_ppm_only(INT32 code, VOID* v){
	fini_ppm(code, v);
}

/* REG */
VOID Instruction_reg_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		ADDRINT insAddr = INS_Address(ins);
		ins_buffer_entry* e = findInsBufferEntry(insAddr);
		instrument_reg(ins, e);
	}
}

VOID Fini_reg_only(INT32 code, VOID* v){
	fini_reg(code, v);
}

/* STRIDE */
VOID Instruction_stride_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		instrument_stride(ins, v);
	}
}

VOID Fini_stride_only(INT32 code, VOID* v){
	fini_stride(code, v);
}

/* MEMFOOTPRINT */
VOID Instruction_memfootprint_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		instrument_memfootprint(ins, v);
	}
}

VOID Fini_memfootprint_only(INT32 code, VOID* v){
	fini_memfootprint(code, v);
}

/* LINECOUNT */
VOID Instruction_linecount_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		instrument_linecount(ins, v);
	}
}

VOID Fini_linecount_only(INT32 code, VOID* v){
	fini_linecount(code, v);
}

/* MEMSTACKDIST */
VOID Instruction_memstackdist_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		instrument_memstackdist(ins, v);
	}
}

VOID Fini_memstackdist_only(INT32 code, VOID* v){
	fini_memstackdist(code, v);
}

/* FULLMEMSTACKDIST */
VOID Instruction_fullmemstackdist_only(INS ins, VOID* v){
	instrument_start_monitoring(ins, v);
	if (start_monitoring) {
		instrument_instruction_count(ins, v);
		instrument_fullmemstackdist(ins, v);
	}
}

VOID Fini_fullmemstackdist_only(INT32 code, VOID* v){
	fini_fullmemstackdist(code, v);
}



/* MY TYPE */
VOID Instruction_custom(INS ins, VOID* v){
	instrument_instruction_count(ins, v);

	cerr << "Please choose a subset of characteristics you want to use, and remove this message (along with the exit call)" << endl;
	exit(1);
	// Choose subset of characteristics, and make the same adjustments in Fini_custom and init_custom below

	//ADDRINT insAddr = INS_Address(ins);
	//ins_buffer_entry* e = findInsBufferEntry(insAddr);

	//instrument_ilp_all(ins, e);
	//instrument_ilp_one(ins, e);
	//instrument_itypes(ins, v);
	//instrument_ppm(ins, v);
	//instrument_reg(ins, e);
	//instrument_stride(ins, v);
	//instrument_memfootprint(ins, v);
	//instrument_memstackdist(ins, v);
}

VOID Fini_custom(INT32 code, VOID* v){
	//fini_ilp_all(code, v);
	//fini_ilp_one(code, v);
	//fini_itypes(code, v);
	//fini_ppm(code, v);
	//fini_reg(code, v);
	//fini_stride(code, v);
	//fini_memfootprint(code, v);
	//fini_memstackdist(code, v);
}

void init_custom(){
	//init_ilp_all();
	//init_ilp_one();
	//init_itypes();
	//init_ppm();
	//init_reg();
	//init_stride();
	//init_memfootprint();
	//init_memstackdist();
}


VOID ThreadStart(THREADID id, CONTEXT *context, INT32 flags, VOID *data)
{
	if (__sync_fetch_and_add(&thread_count, 1))
	{
		LOG_MSG("WARNING: Thread creation detected, results can be corrupted!\n");
		WARNING_MSG("Thread creation detected, results can be corrupted!");
	}
}


/************
 *   MAIN   *
 ************/
int main(int argc, char* argv[]){

	int i;
	MODE mode;

	setup_mica_log(&log);

	read_config(&log, &interval_size, &mode, &_ilp_win_size, &_block_size, &_page_size, &_itypes_spec_file, &append_pid, &use_magic_instruction);
    start_monitoring = !use_magic_instruction;

	cerr << "interval_size: " << interval_size << ", mode: " << mode << endl;

	interval_ins_count = 0;
	interval_ins_count_for_hpc_alignment = 0;
	total_ins_count = 0;
	total_ins_count_for_hpc_alignment = 0;

	for(i=0; i < MAX_MEM_TABLE_ENTRIES; i++){
		ins_buffer[i] = (ins_buffer_entry*)NULL;
	}

	switch(mode){
		case MODE_ALL:
			init_all();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_all, 0);
			PIN_AddFiniFunction(Fini_all, 0);
			break;
		case MODE_ILP:
			init_ilp_all();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_ilp_all_only, 0);
			PIN_AddFiniFunction(Fini_ilp_all_only, 0);
			break;
		case MODE_ILP_ONE:
			init_ilp_one();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_ilp_one_only, 0);
			PIN_AddFiniFunction(Fini_ilp_one_only, 0);
			break;
		case MODE_ITYPES:
			init_itypes();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_itypes_only, 0);
			PIN_AddFiniFunction(Fini_itypes_only, 0);
			break;
		case MODE_PPM:
			init_ppm();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_ppm_only, 0);
			PIN_AddFiniFunction(Fini_ppm_only, 0);
			break;
		case MODE_REG:
			init_reg();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_reg_only, 0);
			PIN_AddFiniFunction(Fini_reg_only, 0);
			break;
		case MODE_STRIDE:
			init_stride();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_stride_only, 0);
			PIN_AddFiniFunction(Fini_stride_only, 0);
			break;
		case MODE_MEMFOOTPRINT:
			init_memfootprint();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_memfootprint_only, 0);
			PIN_AddFiniFunction(Fini_memfootprint_only, 0);
			break;
		case MODE_LINECOUNT:
			init_linecount();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_linecount_only, 0);
			PIN_AddFiniFunction(Fini_linecount_only, 0);
			break;
		case MODE_MEMSTACKDIST:
			init_memstackdist();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_memstackdist_only, 0);
			PIN_AddFiniFunction(Fini_memstackdist_only, 0);
			break;
		case MODE_FULLMEMSTACKDIST:
			init_fullmemstackdist();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_fullmemstackdist_only, 0);
			PIN_AddFiniFunction(Fini_fullmemstackdist_only, 0);
			break;
		case MODE_CUSTOM:
			init_custom();
			PIN_Init(argc, argv);
			INS_AddInstrumentFunction(Instruction_custom, 0);
			PIN_AddFiniFunction(Fini_custom, 0);
			break;
		default:
			cerr << "FATAL ERROR: Unknown mode while trying to allocate memory for Pin tool!" << endl;
			log << "FATAL ERROR: Unknown mode while trying to allocate memory for Pin tool!" << endl;
			exit(1);
	}

	// The tool does not handle multithreaded programs.
	// Since results might be bogus, we print a warning
	// when presence of multiple threads is detected by PIN.
	PIN_AddThreadStartFunction(ThreadStart, NULL);

	// starts program, never returns
	PIN_StartProgram();
}