support added for file interface. microops can be written to trace files in the ROB, and trace files can be read in runnablethread and fed into the pipelines

.gitignore

@@ -1,9 +1,12 @@
 **/bin
 **/obj-pin
 **/obj-comm
-/.classpath
+**/.classpath
-/.cproject
+**/.cproject
-/.project
+**/.project
-/.settings
+**/.settings
 **/hs_err*
 **/*.swp
+**/*.swo
+**/*.swn
+**/*.trc

src/simulator/config/XMLParser.java

@@ -246,8 +246,10 @@ public class XMLParser
 		
 		checkIfTraceFileAlreadyExists();
 		
+		//Emulator emulator = new Emulator(EmulatorConfig.PinTool, EmulatorConfig.PinInstrumentor, 
+		//	Main.getBenchmarkArguments(), EmulatorConfig.basenameForTraceFiles);
 		Emulator emulator = new Emulator(EmulatorConfig.PinTool, EmulatorConfig.PinInstrumentor, 
-			Main.getBenchmarkArguments(), EmulatorConfig.basenameForTraceFiles);
+			Main.getBenchmarkArguments(), "");
 		
 		emulator.waitForEmulator();
 		

src/simulator/emulatorinterface/RunnableThread.java

@@ -4,22 +4,30 @@
 
 package emulatorinterface;
 
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.InputStreamReader;
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.TreeMap;
 import java.util.Vector;
+import java.util.zip.GZIPInputStream;
 
 import main.ArchitecturalComponent;
+import main.CustomObjectPool;
 import main.Main;
 import memorysystem.Cache;
 import memorysystem.MemorySystem;
 import pipeline.PipelineInterface;
+import pipeline.outoforder.OutOrderExecutionEngine;
 import config.CommunicationType;
 import config.EmulatorConfig;
 import config.EmulatorType;
 import config.MainMemoryConfig;
+import config.SimulationConfig;
 import config.SystemConfig;
 import emulatorinterface.ThreadBlockState.blockState;
 import emulatorinterface.communication.Encoding;
@@ -32,9 +40,13 @@ import emulatorinterface.translator.x86.objparser.ObjParser;
 import generic.BarrierTable;
 import generic.CircularPacketQueue;
 import generic.Core;
+import generic.CustomInstructionPool;
 import generic.GenericCircularQueue;
 import generic.GlobalClock;
 import generic.Instruction;
+import generic.Operand;
+import generic.OperandType;
+import generic.OperationType;
 import generic.Statistics;
 
 /* MaxNumThreads threads are created from this class. Each thread
@@ -56,7 +68,7 @@ public class RunnableThread implements Encoding, Runnable {
 	static EmulatorThreadState[] emulatorThreadState;// = new EmulatorThreadState[EMUTHREADS];
 	static ThreadBlockState[] threadBlockState;//=new ThreadBlockState[EMUTHREADS];
 	GenericCircularQueue<Instruction>[] inputToPipeline;
-	FileWrite obj=new FileWrite(1,EmulatorConfig.basenameForTraceFiles);
+	//FileWrite obj=new FileWrite(1,EmulatorConfig.basenameForTraceFiles);
 	// static long ignoredInstructions = 0;
 
 	// QQQ re-arrange packets for use by translate instruction.
@@ -86,7 +98,8 @@ public class RunnableThread implements Encoding, Runnable {
 	long RAMclock;
 	long CoreClock;
 
-
+	BufferedReader[] traceReaders;
+	boolean[] tracesDoneReading;
 
 	/*
 	 * This keeps on reading from the appropriate index in the shared memory
@@ -95,8 +108,147 @@ public class RunnableThread implements Encoding, Runnable {
 	 * break if the threads which started do not call threadfini in the PIN (in
 	 * case of unclean termination). Although the problem is easily fixable.
 	 */
+	Operand retOp(String str1, String str2){
+		//System.out.println(str1.substring(1, str1.length()-1)+" "+str2);
+		Operand op= new Operand(OperandType.valueOf(str1.substring(1, str1.length()-1)),Long.parseLong(str2));
+		return op;
+	}
 	public void run() {
 
+		if (EmulatorConfig.emulatorType == EmulatorType.none
+				&& EmulatorConfig.communicationType == CommunicationType.file) {
+			//trace-file based simulation
+
+			for(int core = 0; core < maxCoreAssign; core++)
+			{
+				ArchitecturalComponent.getCore(core).getExecEngine().setExecutionBegun(true);
+			}
+			
+			long microOpsReadFromFile = 0;
+			long microOpsSentToPipelines = 0;
+			while(true)
+			{
+				for(int core = 0; core < maxCoreAssign; core++)
+				{
+					if(tracesDoneReading[core] == false)
+					{
+						for(int insCount = 0; insCount < 1000; insCount++)
+						{
+							if(inputToPipeline[core].spaceLeft()==0)
+								break;
+							
+							Instruction iNew = null;
+							String line = null;
+							try {
+								line = traceReaders[core].readLine();
+							}
+							catch (Exception e) {
+								e.printStackTrace();
+								misc.Error.showErrorAndExit(e.getMessage());
+							}
+							
+							if(line==null)
+								iNew =Instruction.getInvalidInstruction();
+							else
+							{
+								microOpsReadFromFile++;
+								if(microOpsReadFromFile < SimulationConfig.NumInsToIgnore)
+								{
+									continue;
+								}
+								
+								if(SimulationConfig.subsetSimulation == true
+										&& microOpsReadFromFile > (SimulationConfig.NumInsToIgnore + SimulationConfig.subsetSimSize))
+								{
+									iNew =Instruction.getInvalidInstruction();
+									line = null;
+								}
+								else
+								{
+									String[] splited = line.split(" ");
+									iNew = CustomObjectPool.getInstructionPool().borrowObject();
+									iNew.setCISCProgramCounter(Long.parseLong(splited[0]));
+									iNew.setOperationType(OperationType.valueOf(splited[1]));
+									Operand ops[] =  new Operand[9];
+									int i=2;
+									for(int k=0; k<9;k++){
+										if(!splited[i].equals("null")){
+											ops[k] = retOp(splited[i], splited[i+1]);
+											if(k!=8) i+=2;
+										} else{
+											ops[k]=null;
+											if(k!=8) i+=1;
+										}
+									}
+									i+=1;
+									if(ops[0]!=null){
+										ops[0].setMemoryLocationFirstOperand(ops[1]);
+										ops[0].setMemoryLocationSecondOperand(ops[2]);
+									}
+									if(ops[3]!=null){
+										ops[3].setMemoryLocationFirstOperand(ops[4]);
+										ops[3].setMemoryLocationSecondOperand(ops[5]);
+									}
+									if(ops[6]!=null){
+										ops[6].setMemoryLocationFirstOperand(ops[7]);
+										ops[6].setMemoryLocationSecondOperand(ops[8]);
+									}
+									iNew.setSourceOperand1(ops[0]);
+									iNew.setSourceOperand2(ops[3]);
+									iNew.setDestinationOperand(ops[6]);
+									iNew.setSourceOperand1MemValue(Long.parseLong(splited[i]));
+									iNew.setSourceOperand2MemValue(Long.parseLong(splited[i+1]));
+									iNew.setDestinationOperandMemValue(Long.parseLong(splited[i+2]));
+									iNew.setBranchTargetAddress(Long.parseLong(splited[i+3]));
+									iNew.setBranchTaken(Boolean.parseBoolean(splited[i+4]));
+									//iNew.setSerialNo(Long.parseLong(splited[i+6]));
+								}
+							}
+							
+							inputToPipeline[core].enqueue(iNew);
+							microOpsSentToPipelines++;
+							if(line==null)
+							{
+								tracesDoneReading[core] = true;
+								try
+								{
+									traceReaders[core].close();
+								}
+								catch(Exception e)
+								{
+									e.printStackTrace();
+									misc.Error.showErrorAndExit(e.getMessage());
+								}
+								break;
+							}
+						}
+					}
+				}
+				
+				runPipelines();
+				
+				boolean allTracesDoneReading = true;
+				for(int core = 0; core < maxCoreAssign; core++)
+				{
+					if(tracesDoneReading[core] == false)
+					{
+						allTracesDoneReading = false;
+						break;
+					}
+				}
+				
+				if(allTracesDoneReading == true)
+				{
+					finishAllPipelines();
+					break;
+				}
+			}
+		}
+		
+		else
+		{
+			//PIN-based simulation
+			
 			// create pool for emulator packets
 			ArrayList<CircularPacketQueue> fromEmulatorAll = new ArrayList<CircularPacketQueue>(EMUTHREADS);
 			for(int i=0; i<EMUTHREADS; i++) {
@@ -185,7 +337,7 @@ public class RunnableThread implements Encoding, Runnable {
 					while(fromEmulator.isEmpty() == false) {
 						pnew = fromEmulator.dequeue();
 						
-					if(EmulatorConfig.emulatorType==EmulatorType.pin && EmulatorConfig.communicationType==CommunicationType.sharedMemory && EmulatorConfig.storeExecutionTraceInAFile==true) {
+						/*if(EmulatorConfig.emulatorType==EmulatorType.pin && EmulatorConfig.communicationType==CommunicationType.sharedMemory && EmulatorConfig.storeExecutionTraceInAFile==true) {
 						try {
 							try {
 								obj.analysisFn(javaTid, pnew.ip, pnew.value, pnew.tgt,null);
@@ -201,7 +353,7 @@ public class RunnableThread implements Encoding, Runnable {
 						
 						else {
 							
-					}
+						}*/
 						
 						v = pnew.value;
 						
@@ -295,6 +447,23 @@ public class RunnableThread implements Encoding, Runnable {
 				sorted_map.putAll(unHandledCount);
 				System.out.println(sorted_map);
 			}
+			
+			if(EmulatorConfig.storeExecutionTraceInAFile == true)
+			{
+				for(int rob = 0; rob < ArchitecturalComponent.getCores().length; rob++)
+				{
+					try
+					{
+						((OutOrderExecutionEngine)ArchitecturalComponent.getCore(rob).getExecEngine()).getReorderBuffer().bw.close();
+					}
+					catch(Exception e)
+					{
+						e.printStackTrace();
+						misc.Error.showErrorAndExit(e.getMessage());
+					}
+				}
+			}
+		}
 	}
 
 //	void errorCheck(int tidApp, int emuid, int queue_size,
@@ -389,6 +558,64 @@ public class RunnableThread implements Encoding, Runnable {
 		//added later by kush
 		if(SystemConfig.memControllerToUse==true)
 			RAMclock = (long) (1 / (SystemConfig.mainMemoryConfig.tCK) * 1000000000);
+		
+		if (EmulatorConfig.emulatorType == EmulatorType.none
+				&& EmulatorConfig.communicationType == CommunicationType.file) {
+			//trace-file based simulation
+
+			int numTotalThreads = 0;
+			for (int benchmark=0; benchmark < Main.getTraceFileBasename().length; benchmark++)
+			{
+				for (int tid=0; ;tid++)
+				{
+					String inputFileName = Main.getTraceFileBasename()[benchmark] + "_" + tid + ".gz";
+					
+					try
+					{
+						File f = new File(inputFileName);
+						if(f.exists() && !f.isDirectory())
+						{
+							numTotalThreads++;
+						}
+						else
+						{
+							break;
+						}
+					}
+					catch (Exception e)
+					{
+						break;
+					}
+				}
+			}
+			maxCoreAssign = numTotalThreads;
+			traceReaders = new BufferedReader[maxCoreAssign];
+			tracesDoneReading = new boolean[maxCoreAssign];
+			
+			int index = 0;
+			for (int benchmark=0; benchmark < Main.getTraceFileBasename().length; benchmark++)
+			{
+				for (int tid=0; ;tid++)
+				{
+					String inputFileName = Main.getTraceFileBasename()[benchmark] + "_" + tid + ".gz";
+
+					try {
+						FileInputStream f = new FileInputStream(inputFileName);
+						GZIPInputStream g = new GZIPInputStream(f);
+						InputStreamReader i = new InputStreamReader(g);
+						traceReaders[index++] = new BufferedReader(i);
+					} catch (Exception e) {
+						if(tid==0) {
+							// not able to find first file is surely an error.
+							misc.Error.showErrorAndExit("Error in reading input packet file " + inputFileName);
+						} else {
+							System.out.println("Number of threads for benchmark " + Main.getTraceFileBasename()[benchmark] + " : " + tid);
+							break;
+						}
+					}
+				}
+			}
+		}
 	}
 
 	protected void runPipelines() {

src/simulator/emulatorinterface/communication/filePacket/FilePacket.java

@@ -36,6 +36,7 @@ public class FilePacket extends IpcBase implements Encoding {
 	String []basenameForBenchmarks;
 	
 	public FilePacket(String []basenameForBenchmarks) {
+		/*
 		this.maxApplicationThreads = SystemConfig.maxNumJavaThreads*SystemConfig.numEmuThreadsPerJavaThread;
 		this.basenameForBenchmarks = basenameForBenchmarks;
 		
@@ -95,6 +96,7 @@ public class FilePacket extends IpcBase implements Encoding {
 				}
 			}
 		}
+		*/
 	}
 
 	public void initIpc() {
@@ -102,7 +104,7 @@ public class FilePacket extends IpcBase implements Encoding {
 	}
 
 	public int fetchManyPackets(int tidApp, CircularPacketQueue fromEmulator) {
-		
+		/*
 		if(tidApp>=maxApplicationThreads) {
 			misc.Error.showErrorAndExit("FilePacket cannot handle tid = " + tidApp);
 		}
@@ -204,6 +206,8 @@ public class FilePacket extends IpcBase implements Encoding {
 		}
 		
 		return maxSize;
+		*/
+		return 0;
 	}
 
 	public void errorCheck(int tidApp, long totalReads) {
@@ -211,6 +215,7 @@ public class FilePacket extends IpcBase implements Encoding {
 	}
 	
 	public void finish() {
+		/*
 		for(int i=0; i<maxApplicationThreads; i++) {
 			try {
 				if(inputBufferedReader[i] != null) {
@@ -220,5 +225,6 @@ public class FilePacket extends IpcBase implements Encoding {
 				e.printStackTrace();
 			}
 		}
+		*/
 	}
 }

src/simulator/main/Main.java

@@ -31,6 +31,7 @@ public class Main {
 	public static volatile boolean statFileWritten = false;
 	
 	private static  String emulatorFile = " ";
+	private static  String[] traceFileBasename;
 	
 	public static int pid;
 	public static IpcBase ipcBase;
@@ -53,23 +54,30 @@ public class Main {
 		Runtime.getRuntime().addShutdownHook(new ShutDownHook());
 		
 		checkCommandLineArguments(arguments);
-		setEmulatorFile(arguments[2]);
 
-		// Read the command line arguments
 		String configFileName = arguments[0];
 		SimulationConfig.outputFileName = arguments[1];
 		
-		executableAndArguments = new String[arguments.length-2];
+		// Parse the command line arguments
+		XMLParser.parse(configFileName);
+		printStatisticsOnAsynchronousTermination = true;
 
+		if(EmulatorConfig.communicationType==CommunicationType.file){
+			traceFileBasename = new String[arguments.length - 2];
+			for(int i = 2; i < arguments.length; i++)
+				setTraceFileBasename(arguments[i], i-2);
+		} 
+		if(EmulatorConfig.emulatorType==EmulatorType.pin){
+			//pin mode
+			setEmulatorFile(arguments[2]);
+			// Read the command line arguments
+			executableAndArguments = new String[arguments.length-2];
 			// read the command line arguments for the benchmark (not emulator) here.
 			for(int i=2; i < arguments.length; i++) {
 				executableAndArguments[i-2] = arguments[i]; 
 				benchmarkArguments = benchmarkArguments + " " + arguments[i];
 			}
-		
+		}
-		// Parse the command line arguments
-		XMLParser.parse(configFileName);
-		printStatisticsOnAsynchronousTermination = true;
 		
 		// Initialize the statistics
 		Statistics.initStatistics();
@@ -81,9 +89,9 @@ public class Main {
 		// Create a hash-table for the static representation of the executable
 		if(EmulatorConfig.emulatorType==EmulatorType.pin) {
 			ObjParser.buildStaticInstructionTable(getEmulatorFile());
-		} else if(EmulatorConfig.emulatorType==EmulatorType.none) {
+		} /*else if(EmulatorConfig.emulatorType==EmulatorType.none) {
 			ObjParser.initializeThreadMicroOpsList(SystemConfig.numEmuThreadsPerJavaThread);
-		}
+		}*/
 		
 		ObjParser.initializeDynamicInstructionBuffer(SystemConfig.numEmuThreadsPerJavaThread*SystemConfig.numEmuThreadsPerJavaThread);
 		ObjParser.initializeControlMicroOps();
@@ -94,12 +102,10 @@ public class Main {
 		// Start communication channel before starting emulator
 		// PS : communication channel must be started before starting the emulator
 		ipcBase = startCommunicationChannel();
-		benchmarkThreadMapping = new BenchmarkThreadMapping(getExecutableAndArguments());
+		benchmarkThreadMapping = new BenchmarkThreadMapping(getTraceFileBasename());
 		
 		runners = new RunnableThread[SystemConfig.maxNumJavaThreads];
 		
-		String emulatorArguments = constructEmulatorArguments(benchmarkArguments);
-		
 		//added by harveenk
 		//uncomment for printing debug info
 		//debugPrinter = new DebugPrinter("kush_event_log");
@@ -108,7 +114,10 @@ public class Main {
 		//outputLog = new DebugPrinter("output_log_CMDQ");
 		
 		// start emulator
+		if(EmulatorConfig.emulatorType==EmulatorType.pin){
+			String emulatorArguments = constructEmulatorArguments(benchmarkArguments);
 			startEmulator(emulatorArguments, ipcBase);
+		}
 
 		for (int i=0; i<SystemConfig.maxNumJavaThreads; i++) {
 			runners[i] = new RunnableThread("thread"+Integer.toString(i),i, ipcBase, ArchitecturalComponent.getCores());
@@ -180,7 +189,7 @@ public class Main {
  			ipcBase = new FilePacket(getExecutableAndArguments());
  		} else {
  			ipcBase = null;
- 			misc.Error.showErrorAndExit("Incorrect coomunication type : " + EmulatorConfig.communicationType);
+ 			misc.Error.showErrorAndExit("Incorrect communication type : " + EmulatorConfig.communicationType);
  		}
 		
 		return ipcBase;
@@ -280,6 +289,14 @@ public class Main {
 		Main.emulatorFile = emulatorFile;
 	}
 
+	public static String[] getTraceFileBasename() {
+		return traceFileBasename;
+	}
+
+	public static void setTraceFileBasename(String inputFile, int index) {
+		traceFileBasename[index] = inputFile;
+	}
+
 	public static String[] getExecutableAndArguments() {
 		return executableAndArguments;
 	}

src/simulator/pipeline/outoforder/ReorderBuffer.java

@@ -12,10 +12,16 @@ import generic.RequestType;
 import generic.SimulationElement;
 import generic.Statistics;
 
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.util.zip.GZIPOutputStream;
 
 import main.CustomObjectPool;
+import config.EmulatorConfig;
 import config.EnergyConfig;
 import config.SimulationConfig;
 
@@ -43,6 +49,8 @@ public class ReorderBuffer extends SimulationElement{
 	
 	long numAccesses;
 	
+	public BufferedWriter bw;
+	
 	public ReorderBuffer(Core _core, OutOrderExecutionEngine execEngine)
 	{
 		super(PortType.Unlimited, -1, -1, -1, -1);
@@ -68,6 +76,24 @@ public class ReorderBuffer extends SimulationElement{
 		mispredCount = 0;
 		branchCount = 0;
 		lastValidIPSeen = -1;
+		
+		if(EmulatorConfig.storeExecutionTraceInAFile == true)
+		{
+	        try
+			{
+	        	File f = new File(EmulatorConfig.basenameForTraceFiles + "_" + core.getCore_number() + ".gz");
+				if(f.exists() && !f.isDirectory())
+				{
+					misc.Error.showErrorAndExit("Trace file already present : " + EmulatorConfig.basenameForTraceFiles + " !!" + 
+							"\nKindly rename the trace file and start collecting trace again.");
+				}
+				bw = new BufferedWriter(new OutputStreamWriter(new GZIPOutputStream(new FileOutputStream(EmulatorConfig.basenameForTraceFiles + "_" + core.getCore_number() + ".gz"))));
+			}
+			catch (IOException e) {
+	            e.printStackTrace();
+            	misc.Error.showErrorAndExit(e.getMessage());
+	        }
+		}
 	}
 	
 	//creates a  new ROB entry, initialises it, and returns it
@@ -257,6 +283,11 @@ public class ReorderBuffer extends SimulationElement{
 					execEngine.getCoreMemorySystem().issueLSQCommit(first);
 				}
 				
+				if(EmulatorConfig.storeExecutionTraceInAFile == true)
+				{
+					writeInstructionToFile(firstInstruction);
+				}
+				
 				//free ROB entry
 				retireInstructionAtHead();
 				
@@ -358,6 +389,40 @@ public class ReorderBuffer extends SimulationElement{
 		}
 	}
 	
+	private void writeInstructionToFile(Instruction instruction) {
+        
+		try {
+		 
+            Instruction tmp = instruction;
+            bw.write(tmp.getCISCProgramCounter()+" "+tmp.getOperationType());
+            if(tmp.getSourceOperand1()!=null) {
+                bw.write(" "+tmp.getSourceOperand1()+" "+tmp.getSourceOperand1().getMemoryLocationFirstOperand()+" "+
+                tmp.getSourceOperand1().getMemoryLocationSecondOperand());
+            }
+            else bw.write(" null null null");
+            if(tmp.getSourceOperand2()!=null) {
+                bw.write(" "+tmp.getSourceOperand2()+" "+tmp.getSourceOperand2().getMemoryLocationFirstOperand()+" "+
+                tmp.getSourceOperand2().getMemoryLocationSecondOperand());
+            }
+            else bw.write(" null null null");
+            if(tmp.getDestinationOperand()!=null) {
+                bw.write(" "+tmp.getDestinationOperand()+" "+tmp.getDestinationOperand().getMemoryLocationFirstOperand()+" "+
+                tmp.getDestinationOperand().getMemoryLocationSecondOperand());
+            }
+            else bw.write(" null null null");
+            bw.write(" "+tmp.getSourceOperand1MemValue()+" "+
+            tmp.getSourceOperand2MemValue()+" "+tmp.getDestinationOperandMemValue()+" "+
+            tmp.getBranchTargetAddress()+" "+tmp.isBranchTaken()+" "+tmp.getThreadID()+" "+tmp.getSerialNo()+"\n");
+        }
+		catch(Exception e)
+		{
+			e.printStackTrace();
+        	misc.Error.showErrorAndExit(e.getMessage());
+		}        
+    }
+
+
+	
 	//debug helper - print contents of ROB
 	public void dump()
 	{