mica_ilp_all.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.
 */

#include "pin.H"

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

#include <iostream>
using namespace std;

#define ILP_WIN_SIZE_CNT 4

const UINT32 win_sizes[ILP_WIN_SIZE_CNT] = {512,1024,2048,4096};

extern UINT32 _ilp_win_size;
UINT32 win_size;

extern UINT32 _block_size;
UINT32 ilp_block_size;

extern INT32 numThreads;

/* buffer settings */

//#define ILP_BUFFER_SIZE 256
#define ILP_BUFFER_SIZE 200

/* buffer variables */

typedef struct ilp_buffer_entry_type{

	ins_buffer_entry* e;

	ADDRINT mem_read1_addr;
	ADDRINT mem_read2_addr;
	ADDRINT mem_read_size;

	ADDRINT mem_write_addr;
	ADDRINT mem_write_size;

} ilp_buffer_entry;

ilp_buffer_entry* ilp_buffer[ILP_BUFFER_SIZE];
UINT32 ilp_buffer_index;

void init_ilp_buffering();
VOID fini_ilp_buffering_all();
//VOID fini_ilp_buffering_one();

/* Global variables */

/*extern INT64 interval_size;
extern INT64 interval_ins_count;
extern INT64 interval_ins_count_for_hpc_alignment;
extern INT64 total_ins_count;
extern INT64 total_ins_count_for_hpc_alignment;*/
ofstream output_file_ilp_one;
ofstream output_file_ilp_all;

INT32 size_pow_all_times_all;
INT64 index_all_times_all;
UINT64* all_times_all[ILP_WIN_SIZE_CNT];

INT32 size_pow_times;
INT64 index_all_times;
UINT64* all_times;

INT64 cpuClock_interval_all[ILP_WIN_SIZE_CNT];
UINT64 timeAvailable_all[ILP_WIN_SIZE_CNT][MAX_NUM_REGS];
nlist* memAddressesTable_all[MAX_MEM_TABLE_ENTRIES];
UINT32 windowHead_all[ILP_WIN_SIZE_CNT];
UINT32 windowTail_all[ILP_WIN_SIZE_CNT];
UINT64 cpuClock_all[ILP_WIN_SIZE_CNT];
UINT64* executionProfile_all[ILP_WIN_SIZE_CNT];
UINT64 issueTime_all[ILP_WIN_SIZE_CNT];

INT64 cpuClock_interval;
UINT64 timeAvailable[MAX_NUM_REGS];
nlist* memAddressesTable[MAX_MEM_TABLE_ENTRIES];
UINT32 windowHead;
UINT32 windowTail;
UINT64 cpuClock;
UINT64* executionProfile;
UINT64 issueTime;

/*************************
      ILP (COMMON)
**************************/

/* initializing */
void init_ilp_common(){
	/* initializing total instruction counts is done in mica.cpp */
}

/************************************
     ILP (one given window size) 
*************************************/


/***************************************
     ILP (all 4 hardcoded window sizes) 
****************************************/

/* initializing */
void init_ilp_all(){

	int i,j;

	init_ilp_common();
	init_ilp_buffering();

	size_pow_all_times_all = 10;
	for(i=0; i < ILP_WIN_SIZE_CNT; i++){
		if((all_times_all[i] = (UINT64*)malloc((1 << size_pow_all_times_all) * sizeof(UINT64))) == (UINT64*)NULL){
			cerr << "Could not allocate memory" << endl;
			exit(1);
		}
	}
	index_all_times_all = 1; // don't use first element of all_times_all

        ilp_block_size = _block_size;

	for(j=0; j < ILP_WIN_SIZE_CNT; j++){ 
		windowHead_all[j] = 0;
		windowTail_all[j] = 0;
		cpuClock_all[j] = 0;
		cpuClock_interval_all[j] = 0;
		for(i = 0; i < MAX_NUM_REGS; i++){
			timeAvailable_all[j][i] = 0;
		}

		if((executionProfile_all[j] = (UINT64*)malloc(win_sizes[j]*sizeof(UINT64))) == (UINT64*)NULL){
			cerr << "Not enough memory (in main)" << endl;
			exit(1);
		}

		for(i = 0; i < (int)win_sizes[j]; i++){
			executionProfile_all[j][i] = 0;
		}
		issueTime_all[j] = 0;
	}

/*	if(interval_size != -1){
                if(interval_size % ILP_BUFFER_SIZE != 0){
                        cerr << "ERROR! Interval size is not a multiple of ILP buffer size. (" << interval_size << " vs " << ILP_BUFFER_SIZE << ")" << endl;
                        exit(-1);
                }
		output_file_ilp_all.open("ilp_phases_int_pin.out", ios::out|ios::trunc);
		output_file_ilp_all.close();
	}*/
}

/* support */
void increase_size_all_times_all(){
	int i;
	UINT64* ptr;
	size_pow_all_times_all++;

	for(i=0; i < ILP_WIN_SIZE_CNT; i++){
		ptr = (UINT64*)realloc(all_times_all[i],(1 << size_pow_all_times_all)*sizeof(UINT64));
		if(ptr == (UINT64*)NULL){
			cerr << "Could not allocate memory (realloc)!" << endl;
			exit(1);
		}
		all_times_all[i] = ptr;
	}
}

/* per-instruction stuff */
VOID ilp_instr_all(){

	int i;
	UINT32 reordered;


	for(i=0; i < ILP_WIN_SIZE_CNT; i++){
	
		/* set issue time for tail of instruction window */
		executionProfile_all[i][windowTail_all[i]] = issueTime_all[i];
		windowTail_all[i] = (windowTail_all[i] + 1) % win_sizes[i];
	
		/* if instruction window (issue buffer) full */
                if(windowHead_all[i] == windowTail_all[i]){
                        cpuClock_all[i]++;
                        cpuClock_interval_all[i]++;
                        reordered = 0;
                        /* remove all instructions which are done from beginning of window, 
                         * until an instruction comes along which is not ready yet:
                         * -> check executionProfile_all to see which instructions are done
                         * -> commit maximum win_size instructions (i.e. stop when issue buffer is empty)
                         */
                        while((executionProfile_all[i][windowHead_all[i]] < cpuClock_all[i]) && (reordered < win_sizes[i])) {
                                windowHead_all[i] = (windowHead_all[i] + 1) % win_sizes[i];
                                reordered++;
                        }
                        //assert(reordered != 0);
                }
	
		/* reset issue times */
		issueTime_all[i] = 0;

	}
	
}

VOID ilp_instr_full_all(){
	
	/* counting instructions is done in all_instr_full() */
	
	ilp_instr_all();
}

/*
VOID ilp_instr_intervals_all(){
	
	int i;

	// counting instructions is done in all_instr_intervals() 

	if(interval_ins_count_for_hpc_alignment == interval_size){

		output_file_ilp_all.open("ilp_phases_int_pin.out", ios::out|ios::app);

		output_file_ilp_all << interval_ins_count;
		for(i = 0; i < ILP_WIN_SIZE_CNT; i++)
			output_file_ilp_all << " " << cpuClock_interval_all[i];
		output_file_ilp_all << endl;

		// reset 
		interval_ins_count = 0;
		interval_ins_count_for_hpc_alignment = 0;

		for(i = 0; i < ILP_WIN_SIZE_CNT; i++)
			cpuClock_interval_all[i] = 0;
	
		// clean up memory used, to avoid memory problems for long (CPU2006) benchmarks //	
		size_pow_all_times_all = 10;
		for(i = 0; i < ILP_WIN_SIZE_CNT; i++){
			free(all_times_all[i]);
			all_times_all[i] = (UINT64*)malloc((1 << size_pow_all_times_all) * sizeof(UINT64));*/
			/*if((all_times_all[i] = (UINT64*)malloc((1 << size_pow_all_times_all) * sizeof(UINT64))) == (UINT64*)NULL){
				fprintf(stderr,"Could not allocate memory for all_times_all[%d]\n", i);
				exit(1);
			}*/
	/*	}
		index_all_times_all = 1;

		nlist* np;
		nlist* np_rm;
		for(i=0; i < MAX_MEM_TABLE_ENTRIES; i++){
			np = memAddressesTable_all[i];
			while(np != (nlist*)NULL){
				np_rm = np;
				np = np->next;
				free(np_rm->mem);
				free(np_rm);
			}
			memAddressesTable_all[i] = (nlist*) NULL;
		}

		output_file_ilp_all.close();
	}

	ilp_instr_all();
}*/

VOID checkIssueTime_all(){
	int i;

	for(i=0; i < ILP_WIN_SIZE_CNT; i++){
		if(cpuClock_all[i] > issueTime_all[i])
			issueTime_all[i] = cpuClock_all[i];
	}
}

/* register stuff */
VOID readRegOp_ilp_all(UINT32 regId){
	int i;

	for(i=0; i < ILP_WIN_SIZE_CNT; i++){

		if(timeAvailable_all[i][regId] > issueTime_all[i])
			issueTime_all[i] = timeAvailable_all[i][regId];
	}
}

VOID writeRegOp_ilp_all(UINT32 regId){
	int i;

	for(i=0; i < ILP_WIN_SIZE_CNT; i++){
		timeAvailable_all[i][regId] = issueTime_all[i] + 1;
         }
}

/* memory access stuff */
VOID readMem_ilp_all(ADDRINT effAddr, ADDRINT size){

	int i;

	ADDRINT a;
	ADDRINT upperMemAddr, indexInChunk;
	memNode* chunk = (memNode*)NULL;
	ADDRINT shiftedAddr = effAddr >> ilp_block_size;
	ADDRINT shiftedEndAddr = (effAddr + size - 1) >> ilp_block_size;

        if(size > 0){
                for(a = shiftedAddr; a <= shiftedEndAddr; a++){
                        upperMemAddr = a >> LOG_MAX_MEM_ENTRIES;
                        indexInChunk = a ^ (upperMemAddr << LOG_MAX_MEM_ENTRIES);

                        chunk = lookup(memAddressesTable_all,upperMemAddr);
                        if(chunk == (memNode*)NULL)
                                chunk = install(memAddressesTable_all,upperMemAddr);

                        //assert(indexInChunk < MAX_MEM_ENTRIES);
                        for(i=0; i < ILP_WIN_SIZE_CNT; i++){

                                if(all_times_all[i][chunk->timeAvailable[indexInChunk]] > issueTime_all[i])
                                        issueTime_all[i] = all_times_all[i][chunk->timeAvailable[indexInChunk]];
                        }
                }
        }
}

VOID writeMem_ilp_all(ADDRINT effAddr, ADDRINT size){
	int i;

	ADDRINT a;
	ADDRINT upperMemAddr, indexInChunk;
	memNode* chunk = (memNode*)NULL;
	ADDRINT shiftedAddr = effAddr >> ilp_block_size;
	ADDRINT shiftedEndAddr = (effAddr + size - 1) >> ilp_block_size;
        
        if(size > 0){
                for(a = shiftedAddr; a <= shiftedEndAddr; a++){
                        upperMemAddr = a >> LOG_MAX_MEM_ENTRIES;
                        indexInChunk = a ^ (upperMemAddr << LOG_MAX_MEM_ENTRIES);

                        chunk = lookup(memAddressesTable_all,upperMemAddr);
                        if(chunk == (memNode*)NULL)
                                chunk = install(memAddressesTable_all,upperMemAddr);

                        //assert(indexInChunk < MAX_MEM_ENTRIES);
                        if(chunk->timeAvailable[indexInChunk] == 0){
                                index_all_times_all++;
                                if(index_all_times_all >= (1 << size_pow_all_times_all))
                                        increase_size_all_times_all();
                                chunk->timeAvailable[indexInChunk] = index_all_times_all;
                        }
                        for(i=0; i < ILP_WIN_SIZE_CNT; i++){
                                all_times_all[i][chunk->timeAvailable[indexInChunk]] = issueTime_all[i] + 1;
                        }
                }
        }
}

/* instrumenting (instruction level) */
/*VOID instrument_ilp_all(INS ins, VOID* v){

	UINT32 i;
	UINT32 maxNumRegsProd, maxNumRegsCons;
	REG reg;


	// register reads and memory reads determine the issue time 
	maxNumRegsCons = INS_MaxNumRRegs(ins);
	
	for(i=0; i < maxNumRegsCons; i++){
	
		reg = INS_RegR(ins, i);

		// only consider valid general-purpose registers (any bit-width) and floating-point registers,
		// i.e. exlude branch, segment and pin registers, among others
		if(REG_valid(reg) && (REG_is_fr(reg) || REG_is_mm(reg) || REG_is_xmm(reg) || REG_is_gr(reg) || REG_is_gr8(reg) || REG_is_gr16(reg) || REG_is_gr32(reg) || REG_is_gr64(reg))){
			INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)readRegOp_ilp_all, IARG_UINT32, reg, IARG_END);
		}
	}

	if(INS_IsMemoryRead(ins)){

		INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)readMem_ilp_all, IARG_MEMORYREAD_EA, IARG_MEMORYREAD_SIZE, IARG_END);

		if(INS_HasMemoryRead2(ins)){

			INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)readMem_ilp_all, IARG_MEMORYREAD2_EA, IARG_MEMORYREAD_SIZE, IARG_END);
		}
	}

	INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)checkIssueTime_all, IARG_END);

	// register writes and memory writes determine the time when these locations are available 
	
	maxNumRegsProd = INS_MaxNumWRegs(ins);
	for(i=0; i < maxNumRegsProd; i++){

		reg = INS_RegW(ins, i);

		// only consider valid general-purpose registers (any bit-width) and floating-point registers,
		// i.e. exlude branch, segment and pin registers, among others 
		if(REG_valid(reg) && (REG_is_fr(reg) || REG_is_mm(reg) || REG_is_xmm(reg) || REG_is_gr(reg) || REG_is_gr8(reg) || REG_is_gr16(reg) || REG_is_gr32(reg) || REG_is_gr64(reg))){
			INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)writeRegOp_ilp_all, IARG_UINT32, reg, IARG_END);
		}
	}

	if(INS_IsMemoryWrite(ins)){

		INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)writeMem_ilp_all, IARG_MEMORYWRITE_EA, IARG_MEMORYWRITE_SIZE, IARG_END);
	}

	// count instructions 
	if(interval_size == -1)	
		INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)ilp_instr_full_all,IARG_END);
	else
		INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)ilp_instr_intervals_all, IARG_END);
}*/

/* finishing... */
VOID fini_ilp_all(INT32 code, VOID* v){

	int x,i;

	fini_ilp_buffering_all();

	//if(interval_size == -1){
output_file_ilp_all.open("ilp_full_int_pin.out", ios::out|ios::trunc);
for (x=0;x<numThreads;x++)                                                                                                                                                                                                                                  
	{                                                                                                                                                                                                                                                           
		thread_data_t* tdata = get_tls(x);
		output_file_ilp_all << tdata->total_ins_count;
	for(i = 0; i < ILP_WIN_SIZE_CNT; i++)
		output_file_ilp_all << " " << cpuClock_interval_all[i];
	
	output_file_ilp_all << endl;
	}
//	else{
//		output_file_ilp_all.open("ilp_phases_int_pin.out", ios::out|ios::app);
//		output_file_ilp_all << interval_ins_count;
	

	//output_file_ilp_all << "number of instructions: " << total_ins_count_for_hpc_alignment << endl;
	output_file_ilp_all.close();
}

/**************************
     ILP (BUFFERING)  
***************************/

/*
 * notes
 *
 * using PIN_FAST_ANALYSIS_CALL for buffering functions was tested
 * during the preparation of MICA v0.3, but showed to slightly slowdown 
 * things instead of speeding them up, so it was dropped in the end 
 */

/* initializing */
void init_ilp_buffering(){

	int i;

	ilp_buffer_index = 0;
	for(i=0; i < ILP_BUFFER_SIZE; i++){
		if((ilp_buffer[i] = (ilp_buffer_entry*)malloc(sizeof(ilp_buffer_entry))) == (ilp_buffer_entry*)NULL){
			cerr << "Could not allocate memory for ilp_buffer[" << i << "]" << endl;
			exit(1);
		}
		ilp_buffer[i]->e = (ins_buffer_entry*)NULL;
		ilp_buffer[i]->mem_read1_addr = 0;
		ilp_buffer[i]->mem_read2_addr = 0;
		ilp_buffer[i]->mem_read_size = 0;
		ilp_buffer[i]->mem_write_addr = 0;
		ilp_buffer[i]->mem_write_size = 0;
	}
}

VOID ilp_buffer_instruction_only(void* _e){
	ilp_buffer[ilp_buffer_index]->e = (ins_buffer_entry*)_e;
}

VOID ilp_buffer_instruction_read(ADDRINT read1_addr, ADDRINT read_size){
	ilp_buffer[ilp_buffer_index]->mem_read1_addr = read1_addr;
	ilp_buffer[ilp_buffer_index]->mem_read_size = read_size;
}

VOID ilp_buffer_instruction_read2(ADDRINT read2_addr){
	ilp_buffer[ilp_buffer_index]->mem_read2_addr = read2_addr;
}

VOID ilp_buffer_instruction_write(ADDRINT write_addr, ADDRINT write_size){
	ilp_buffer[ilp_buffer_index]->mem_write_addr = write_addr;
	ilp_buffer[ilp_buffer_index]->mem_write_size = write_size;
}

ADDRINT ilp_buffer_instruction_next(){
        ilp_buffer_index++;
        //return (ADDRINT)(ilp_buffer_index == ILP_BUFFER_SIZE || interval_ins_count_for_hpc_alignment == interval_size);
        return (ADDRINT)(ilp_buffer_index == ILP_BUFFER_SIZE );
}

/* empty buffer for one given window size  */
/*VOID empty_buffer_one(){
	UINT32 i,j;

	for(i=0; i < ilp_buffer_index; i++){

		// register reads 
		for(j=0; j < (UINT32)ilp_buffer[i]->e->regReadCnt; j++){
			readRegOp_ilp_one((UINT32)ilp_buffer[i]->e->regsRead[j]);
		}

		// memory reads
		if(ilp_buffer[i]->mem_read1_addr != 0){
			readMem_ilp_one(ilp_buffer[i]->mem_read1_addr, ilp_buffer[i]->mem_read_size);
			ilp_buffer[i]->mem_read1_addr = 0;
		
			if(ilp_buffer[i]->mem_read2_addr != 0){
				readMem_ilp_one(ilp_buffer[i]->mem_read2_addr, ilp_buffer[i]->mem_read_size);
				ilp_buffer[i]->mem_read2_addr = 0;
			}

			ilp_buffer[i]->mem_read_size = 0;
		}

		checkIssueTime_one();

		// register writes
		for(j=0; j < (UINT32)ilp_buffer[i]->e->regWriteCnt; j++){
			writeRegOp_ilp_one((UINT32)ilp_buffer[i]->e->regsWritten[j]);	
		}

		// memory writes
		if(ilp_buffer[i]->mem_write_addr != 0){
			writeMem_ilp_one(ilp_buffer[i]->mem_write_addr, ilp_buffer[i]->mem_write_size);
			ilp_buffer[i]->mem_write_addr = 0;
			ilp_buffer[i]->mem_write_size = 0;
		}

		ilp_buffer[i]->e = (ins_buffer_entry*)NULL;

	//	if(interval_size == -1)
			ilp_instr_full_one();
	//	else
//			ilp_instr_intervals_one();
	}

	ilp_buffer_index = 0;
}*/

/* empty buffer for all 4 (hardcoded) window sizes */
VOID empty_ilp_buffer_all(){
	UINT32 i,j;

	for(i=0; i < ilp_buffer_index; i++){

		// register reads 
		for(j=0; j < (UINT32)ilp_buffer[i]->e->regReadCnt; j++){
			readRegOp_ilp_all((UINT32)ilp_buffer[i]->e->regsRead[j]);
		}

		// memory reads
		if(ilp_buffer[i]->mem_read1_addr != 0){
			readMem_ilp_all(ilp_buffer[i]->mem_read1_addr, ilp_buffer[i]->mem_read_size);
			ilp_buffer[i]->mem_read1_addr = 0;
		
			if(ilp_buffer[i]->mem_read2_addr != 0){
				readMem_ilp_all(ilp_buffer[i]->mem_read2_addr, ilp_buffer[i]->mem_read_size);
				ilp_buffer[i]->mem_read2_addr = 0;
			}

			ilp_buffer[i]->mem_read_size = 0;
		}

		checkIssueTime_all();

		// register writes
		for(j=0; j < (UINT32)ilp_buffer[i]->e->regWriteCnt; j++){
			writeRegOp_ilp_all((UINT32)ilp_buffer[i]->e->regsWritten[j]);	
		}

		// memory writes
		if(ilp_buffer[i]->mem_write_addr != 0){
			writeMem_ilp_all(ilp_buffer[i]->mem_write_addr, ilp_buffer[i]->mem_write_size);
			ilp_buffer[i]->mem_write_addr = 0;
			ilp_buffer[i]->mem_write_size = 0;
		}

		ilp_buffer[i]->e = (ins_buffer_entry*)NULL;

//		if(interval_size == -1)
			ilp_instr_full_all();
//		else
//			ilp_instr_intervals_all();
	}

	ilp_buffer_index = 0;
}

/* instrumenting (instruction level) */
VOID instrument_ilp_buffering_common(INS ins, ins_buffer_entry* e){

	UINT32 i, maxNumRegsProd, maxNumRegsCons, regReadCnt, regWriteCnt;
	REG reg;

	// buffer register reads per static instruction
	if(!e->setRead){


		// register reads and memory reads determine the issue time
		maxNumRegsCons = INS_MaxNumRRegs(ins);

		regReadCnt = 0;	
		for(i=0; i < maxNumRegsCons; i++){
			reg = INS_RegR(ins, i);
			//assert((UINT32)reg < MAX_NUM_REGS);
			// only consider valid general-purpose registers (any bit-width) and floating-point registers,
			// i.e. exlude branch, segment and pin registers, among others
			if(REG_valid(reg) && (REG_is_fr(reg) || REG_is_mm(reg) || REG_is_xmm(reg) || REG_is_gr(reg) || REG_is_gr8(reg) || REG_is_gr16(reg) || REG_is_gr32(reg) || REG_is_gr64(reg))){
				regReadCnt++;
			}
		}
		
		e->regReadCnt = regReadCnt;
		e->regsRead = (REG*)malloc(regReadCnt*sizeof(REG));
		/*if((e->regsRead = (REG*)malloc(regReadCnt*sizeof(REG))) == (REG*)NULL){
			fprintf(stderr,"ERROR: Could not allocate regsRead memory for ins 0x%x\n", (unsigned int)e->insAddr);
			exit(1);
		}*/

		regReadCnt = 0;
		for(i=0; i < maxNumRegsCons; i++){
	
			reg = INS_RegR(ins, i);

			//assert((UINT32)reg < MAX_NUM_REGS);
			// only consider valid general-purpose registers (any bit-width) and floating-point registers,
			// i.e. exlude branch, segment and pin registers, among others
			if(REG_valid(reg) && (REG_is_fr(reg) || REG_is_mm(reg) || REG_is_xmm(reg) || REG_is_gr(reg) || REG_is_gr8(reg) || REG_is_gr16(reg) || REG_is_gr32(reg) || REG_is_gr64(reg))){
				e->regsRead[regReadCnt++] = reg;
			}
		}

		e->setRead = true;
		
	}

	// buffer register writes per static instruction
	if(!e->setWritten){	
		maxNumRegsProd = INS_MaxNumWRegs(ins);

		regWriteCnt = 0;
		for(i=0; i < maxNumRegsProd; i++){

			reg = INS_RegW(ins, i);

			//assert((UINT32)reg < MAX_NUM_REGS);
			// only consider valid general-purpose registers (any bit-width) and floating-point registers,
			// i.e. exlude branch, segment and pin registers, among others */
			if(REG_valid(reg) && (REG_is_fr(reg) || REG_is_mm(reg) || REG_is_xmm(reg) || REG_is_gr(reg) || REG_is_gr8(reg) || REG_is_gr16(reg) || REG_is_gr32(reg) || REG_is_gr64(reg))){
				regWriteCnt++;
			}
		}

		e->regWriteCnt = regWriteCnt;
		e->regsWritten = (REG*)malloc(regWriteCnt*sizeof(REG));
		/*if((e->regsWritten = (REG*)malloc(regWriteCnt*sizeof(REG))) == (REG*)NULL){
			fprintf(stderr,"ERROR: Could not allocate regsRead memory for ins 0x%x\n", (unsigned int)e->insAddr);
			exit(1);
		}*/	

		regWriteCnt = 0;
		for(i=0; i < maxNumRegsProd; i++){

			reg = INS_RegW(ins, i);

			//assert((UINT32)reg < MAX_NUM_REGS);
			// only consider valid general-purpose registers (any bit-width) and floating-point registers,
			// i.e. exlude branch, segment and pin registers, among others
			if(REG_valid(reg) && (REG_is_fr(reg) || REG_is_mm(reg) || REG_is_xmm(reg) || REG_is_gr(reg) || REG_is_gr8(reg) || REG_is_gr16(reg) || REG_is_gr32(reg) || REG_is_gr64(reg))){
				e->regsWritten[regWriteCnt++] = reg;
			}
		}
	
		e->setWritten = true;
	}

	// buffer memory operations (and instruction register buffer) with one single InsertCall
	INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)ilp_buffer_instruction_only, IARG_PTR, (void*)e, IARG_END);

        if(INS_IsMemoryRead(ins)){
				
                INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)ilp_buffer_instruction_read, IARG_MEMORYREAD_EA, IARG_MEMORYREAD_SIZE, IARG_END);

                if(INS_HasMemoryRead2(ins)){
                        INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)ilp_buffer_instruction_read2, IARG_MEMORYREAD2_EA, IARG_END);
                }
        }
                        
        if(INS_IsMemoryWrite(ins)){
                INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)ilp_buffer_instruction_write, IARG_MEMORYWRITE_EA, IARG_MEMORYWRITE_SIZE, IARG_END);
        }
        
	INS_InsertIfCall(ins, IPOINT_BEFORE, (AFUNPTR)ilp_buffer_instruction_next, IARG_END);

}

/*VOID instrument_ilp_one(INS ins, ins_buffer_entry* e){

	instrument_ilp_buffering_common(ins, e);
	// only called if buffer is full 
	INS_InsertThenCall(ins, IPOINT_BEFORE, (AFUNPTR)empty_buffer_one, IARG_END);
}*/

VOID instrument_ilp_all(INS ins, ins_buffer_entry* e){

	instrument_ilp_buffering_common(ins, e);
	// only called if buffer is full 
	INS_InsertThenCall(ins, IPOINT_BEFORE, (AFUNPTR)empty_ilp_buffer_all, IARG_END);
}

VOID fini_ilp_buffering_all(){

	if(ilp_buffer_index != 0)
		empty_ilp_buffer_all();
}

/*VOID fini_ilp_buffering_one(){

	if(ilp_buffer_index != 0)
		empty_buffer_one();
}*/