7 files changed, 138 insertions, 154 deletions

diff --git a/src/gpgpu-sim/gpu-cache.h b/src/gpgpu-sim/gpu-cache.h
index be281ce..673e128 100644
--- a/src/gpgpu-sim/gpu-cache.h
+++ b/src/gpgpu-sim/gpu-cache.h
@@ -915,10 +915,10 @@ private:
 /// Simple struct to maintain cache accesses, misses, pending hits, and reservation fails.
 ///
 struct cache_sub_stats{
-	unsigned long long accesses;
-	unsigned long long misses;
-	unsigned long long pending_hits;
-	unsigned long long res_fails;
+    unsigned long long accesses;
+    unsigned long long misses;
+    unsigned long long pending_hits;
+    unsigned long long res_fails;
 
     unsigned long long port_available_cycles; 
     unsigned long long data_port_busy_cycles; 
diff --git a/src/gpgpu-sim/gpu-sim.cc b/src/gpgpu-sim/gpu-sim.cc
index 3f1fc7e..89c6695 100644
--- a/src/gpgpu-sim/gpu-sim.cc
+++ b/src/gpgpu-sim/gpu-sim.cc
@@ -479,9 +479,6 @@ void shader_core_config::reg_options(class OptionParser * opp)
                 "Support concurrent kernels on a SM (default = disabled)", 
                 "0");
 
-    option_parser_register(opp, "-fast_execution_mode", OPT_BOOL, &fast_execution_mode,
-                "fast_execution_mode (default = disabled)",
-                "0");
 }
 
 void gpgpu_sim_config::reg_options(option_parser_t opp)
diff --git a/src/gpgpu-sim/icnt_wrapper.cc b/src/gpgpu-sim/icnt_wrapper.cc
index 075e371..3dc1786 100644
--- a/src/gpgpu-sim/icnt_wrapper.cc
+++ b/src/gpgpu-sim/icnt_wrapper.cc
@@ -116,12 +116,12 @@ static unsigned intersim2_get_flit_size()
 
 static void LocalInterconnect_create(unsigned int n_shader, unsigned int n_mem)
 {
-	g_localicnt_interface->CreateInterconnect(n_shader, n_mem);
+   g_localicnt_interface->CreateInterconnect(n_shader, n_mem);
 }
 
 static void LocalInterconnect_init()
 {
-	g_localicnt_interface->Init();
+   g_localicnt_interface->Init();
 }
 
 static bool LocalInterconnect_has_buffer(unsigned input, unsigned int size)
@@ -131,7 +131,7 @@ static bool LocalInterconnect_has_buffer(unsigned input, unsigned int size)
 
 static void LocalInterconnect_push(unsigned input, unsigned output, void* data, unsigned int size)
 {
-	g_localicnt_interface->Push(input, output, data, size);
+   g_localicnt_interface->Push(input, output, data, size);
 }
 
 static void* LocalInterconnect_pop(unsigned output)
@@ -141,7 +141,7 @@ static void* LocalInterconnect_pop(unsigned output)
 
 static void LocalInterconnect_transfer()
 {
-	g_localicnt_interface->Advance();
+   g_localicnt_interface->Advance();
 }
 
 static bool LocalInterconnect_busy()
@@ -151,17 +151,17 @@ static bool LocalInterconnect_busy()
 
 static void LocalInterconnect_display_stats()
 {
-	g_localicnt_interface->DisplayStats();
+   g_localicnt_interface->DisplayStats();
 }
 
 static void LocalInterconnect_display_overall_stats()
 {
-	g_localicnt_interface->DisplayOverallStats();
+   g_localicnt_interface->DisplayOverallStats();
 }
 
 static void LocalInterconnect_display_state(FILE *fp)
 {
-	g_localicnt_interface->DisplayState(fp);
+   g_localicnt_interface->DisplayState(fp);
 }
 
 static unsigned LocalInterconnect_get_flit_size()
diff --git a/src/gpgpu-sim/local_interconnect.cc b/src/gpgpu-sim/local_interconnect.cc
index 21b44ed..66d6648 100644
--- a/src/gpgpu-sim/local_interconnect.cc
+++ b/src/gpgpu-sim/local_interconnect.cc
@@ -1,5 +1,5 @@
-// Copyright (c) 2009-2013, Tor M. Aamodt, Dongdong Li, Ali Bakhoda
-// The University of British Columbia
+// Copyright (c) 2019, Mahmoud Khairy
+// Purdue University
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -40,30 +40,30 @@ xbar_router::xbar_router(unsigned router_id, enum Interconnect_type m_type, unsi
 {
 	m_id=router_id;
 	router_type=m_type;
-   _n_mem = n_mem;
-   _n_shader = n_shader;
-   total_nodes = n_shader+n_mem;
-   in_buffers.resize(total_nodes);
-   out_buffers.resize(total_nodes);
-   next_node=0;
-   in_buffer_limit = m_in_buffer_limit;
-   out_buffer_limit = m_out_buffer_limit;
-   if(m_type == REQ_NET) {
-	   active_in_buffers=n_shader;
-	   active_out_buffers=n_mem;
-   }
-   else if(m_type == REPLY_NET) {
-	   active_in_buffers=n_mem;
-	   active_out_buffers=n_shader;
-   }
+	_n_mem = n_mem;
+	_n_shader = n_shader;
+	total_nodes = n_shader+n_mem;
+	in_buffers.resize(total_nodes);
+	out_buffers.resize(total_nodes);
+	next_node=0;
+	in_buffer_limit = m_in_buffer_limit;
+	out_buffer_limit = m_out_buffer_limit;
+	if(m_type == REQ_NET) {
+		active_in_buffers=n_shader;
+		active_out_buffers=n_mem;
+	}
+	else if(m_type == REPLY_NET) {
+		active_in_buffers=n_mem;
+		active_out_buffers=n_shader;
+	}
 
-   cycles = 0;
-   conflicts= 0;
-   out_buffer_full=0;
-   in_buffer_full=0;
-   out_buffer_util=0;
-   in_buffer_util=0;
-   packets_num=0;
+	cycles = 0;
+	conflicts= 0;
+	out_buffer_full=0;
+	in_buffer_full=0;
+	out_buffer_util=0;
+	in_buffer_util=0;
+	packets_num=0;
 }
 
 
@@ -165,41 +165,36 @@ bool xbar_router::Busy() const {
 LocalInterconnect* LocalInterconnect::New(const struct inct_config& m_localinct_config)
 {
 
-  LocalInterconnect* icnt_interface = new LocalInterconnect(m_localinct_config);
+	LocalInterconnect* icnt_interface = new LocalInterconnect(m_localinct_config);
 
-  return icnt_interface;
+	return icnt_interface;
 }
 
-LocalInterconnect::LocalInterconnect(const struct inct_config& m_localinct_config): m_inct_config(m_localinct_config)
-{
+LocalInterconnect::LocalInterconnect(const struct inct_config& m_localinct_config): m_inct_config(m_localinct_config){
 	n_shader=0;
 	n_mem=0;
 	n_subnets = m_localinct_config.subnets;
-
 }
 
-LocalInterconnect::~LocalInterconnect()
-{
-  for (int i=0; i<m_inct_config.subnets; ++i) {
-    delete net[i];
-  }
+LocalInterconnect::~LocalInterconnect(){
+	for (int i=0; i<m_inct_config.subnets; ++i) {
+		delete net[i];
+	}
 }
 
-void LocalInterconnect::CreateInterconnect(unsigned m_n_shader, unsigned m_n_mem)
-{
-  n_shader = m_n_shader;
-  n_mem = m_n_mem;
+void LocalInterconnect::CreateInterconnect(unsigned m_n_shader, unsigned m_n_mem){
+	n_shader = m_n_shader;
+	n_mem = m_n_mem;
 
-  net.resize(n_subnets);
-  for (unsigned i = 0; i < n_subnets; ++i) {
-    net[i] = new xbar_router( i, static_cast<Interconnect_type>(i), m_n_shader, m_n_mem, m_inct_config.in_buffer_limit, m_inct_config.out_buffer_limit );
-  }
+	net.resize(n_subnets);
+	for (unsigned i = 0; i < n_subnets; ++i) {
+		net[i] = new xbar_router( i, static_cast<Interconnect_type>(i), m_n_shader, m_n_mem, m_inct_config.in_buffer_limit, m_inct_config.out_buffer_limit );
+	}
 
 }
 
 
 void LocalInterconnect::Init() {
-
 	//empty
 	//there is nothing to do
 
@@ -208,63 +203,63 @@ void LocalInterconnect::Init() {
 void LocalInterconnect::Push(unsigned input_deviceID, unsigned output_deviceID, void* data, unsigned int size){
 
 	unsigned subnet;
-	  if (n_subnets == 1) {
+	if (n_subnets == 1) {
 		subnet = 0;
-	  } else {
+	} else {
 		if (input_deviceID < n_shader ) {
-		  subnet = 0;
+			subnet = 0;
 		} else {
-		  subnet = 1;
+			subnet = 1;
 		}
-	  }
+	}
 
-	 // it should have free buffer
-	  //assume all the packets have size of one
-	  //no flits are implemented
-	  assert(net[subnet]->Has_Buffer_In(input_deviceID, 1));
+	// it should have free buffer
+	//assume all the packets have size of one
+	//no flits are implemented
+	assert(net[subnet]->Has_Buffer_In(input_deviceID, 1));
 
-	  net[subnet]->Push(input_deviceID, output_deviceID, data, size);
+	net[subnet]->Push(input_deviceID, output_deviceID, data, size);
 
 }
 
 void* LocalInterconnect::Pop(unsigned ouput_deviceID){
 
 	// 0-_n_shader-1 indicates reply(network 1), otherwise request(network 0)
-	  int subnet = 0;
-	  if (ouput_deviceID < n_shader)
-	    subnet = 1;
+	int subnet = 0;
+	if (ouput_deviceID < n_shader)
+		subnet = 1;
 
-	  return net[subnet]->Pop(ouput_deviceID);
+	return net[subnet]->Pop(ouput_deviceID);
 
 }
 
 void LocalInterconnect::Advance(){
 
 	for (unsigned i = 0; i < n_subnets; ++i) {
-	    net[i]->Advance();
-	  }
+		net[i]->Advance();
+	}
 
 }
 
 bool  LocalInterconnect::Busy() const{
 
 	for (unsigned i = 0; i < n_subnets; ++i) {
-		 if(net[i]->Busy())
-			 return true;
+		if(net[i]->Busy())
+			return true;
 	}
 	return false;
 }
 
 bool  LocalInterconnect::HasBuffer(unsigned deviceID, unsigned int size) const{
 
-	 bool has_buffer = false;
+	bool has_buffer = false;
 
-	  if ((n_subnets>1) && deviceID >= n_shader) // deviceID is memory node
-		  has_buffer = net[REPLY_NET]->Has_Buffer_In(deviceID, 1, true);
-	  else
-		  has_buffer = net[REQ_NET]->Has_Buffer_In(deviceID, 1, true);
+	if ((n_subnets>1) && deviceID >= n_shader) // deviceID is memory node
+		has_buffer = net[REPLY_NET]->Has_Buffer_In(deviceID, 1, true);
+	else
+		has_buffer = net[REQ_NET]->Has_Buffer_In(deviceID, 1, true);
 
-	  return has_buffer;
+	return has_buffer;
 
 }
 
@@ -301,6 +296,6 @@ unsigned  LocalInterconnect::GetFlitSize() const{
 
 void  LocalInterconnect::DisplayState(FILE* fp) const{
 
-	  fprintf(fp, "GPGPU-Sim uArch: ICNT:Display State: Under implementation\n");
+	fprintf(fp, "GPGPU-Sim uArch: ICNT:Display State: Under implementation\n");
 }
 
diff --git a/src/gpgpu-sim/local_interconnect.h b/src/gpgpu-sim/local_interconnect.h
index 0f83d05..502c80d 100644
--- a/src/gpgpu-sim/local_interconnect.h
+++ b/src/gpgpu-sim/local_interconnect.h
@@ -1,5 +1,5 @@
-// Copyright (c) 2009-2013, Tor M. Aamodt, Dongdong Li, Ali Bakhoda
-// The University of British Columbia
+// Copyright (c) 2019, Mahmoud Khairy
+// Purdue University
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -51,74 +51,74 @@ enum Interconnect_type {
 class xbar_router {
 
 public:
-  xbar_router(unsigned router_id, enum Interconnect_type m_type, unsigned n_shader, unsigned n_mem, unsigned m_in_buffer_limit, unsigned m_out_buffer_limit);
-  ~xbar_router();
-   void Push(unsigned input_deviceID, unsigned output_deviceID, void* data, unsigned int size);
-   void* Pop(unsigned ouput_deviceID);
-   void Advance();
-   bool Busy() const;
-   bool Has_Buffer_In(unsigned input_deviceID, unsigned size, bool update_counter=false);
-   bool Has_Buffer_Out(unsigned output_deviceID, unsigned size);
+	xbar_router(unsigned router_id, enum Interconnect_type m_type, unsigned n_shader, unsigned n_mem, unsigned m_in_buffer_limit, unsigned m_out_buffer_limit);
+	~xbar_router();
+	void Push(unsigned input_deviceID, unsigned output_deviceID, void* data, unsigned int size);
+	void* Pop(unsigned ouput_deviceID);
+	void Advance();
+	bool Busy() const;
+	bool Has_Buffer_In(unsigned input_deviceID, unsigned size, bool update_counter=false);
+	bool Has_Buffer_Out(unsigned output_deviceID, unsigned size);
 
-   //some stats
-   unsigned long long cycles;
-   unsigned long long conflicts;
-   unsigned long long out_buffer_full;
-   unsigned long long out_buffer_util;
-   unsigned long long in_buffer_full;
-   unsigned long long in_buffer_util;
-   unsigned long long packets_num;
+	//some stats
+	unsigned long long cycles;
+	unsigned long long conflicts;
+	unsigned long long out_buffer_full;
+	unsigned long long out_buffer_util;
+	unsigned long long in_buffer_full;
+	unsigned long long in_buffer_util;
+	unsigned long long packets_num;
 
 private:
-  struct Packet{
-	  Packet(void* m_data, unsigned m_output_deviceID) {
-		  data = m_data;
-		  output_deviceID = m_output_deviceID;
-	  }
-	  void* data;
-	  unsigned output_deviceID;
-  };
-  vector<queue<Packet> > in_buffers;
-  vector<queue<Packet> > out_buffers;
-  unsigned _n_shader, _n_mem, total_nodes;
-  unsigned in_buffer_limit, out_buffer_limit;
-  unsigned next_node;
-  unsigned m_id;
-  enum Interconnect_type router_type;
-  unsigned active_in_buffers,active_out_buffers;
+	struct Packet{
+		Packet(void* m_data, unsigned m_output_deviceID) {
+			data = m_data;
+			output_deviceID = m_output_deviceID;
+		}
+		void* data;
+		unsigned output_deviceID;
+	};
+	vector<queue<Packet> > in_buffers;
+	vector<queue<Packet> > out_buffers;
+	unsigned _n_shader, _n_mem, total_nodes;
+	unsigned in_buffer_limit, out_buffer_limit;
+	unsigned next_node;
+	unsigned m_id;
+	enum Interconnect_type router_type;
+	unsigned active_in_buffers,active_out_buffers;
 
-  friend class LocalInterconnect;
+	friend class LocalInterconnect;
 
 };
 
 class LocalInterconnect {
 public:
-  LocalInterconnect(const struct inct_config& m_localinct_config);
-  ~LocalInterconnect();
-  static LocalInterconnect* New(const struct inct_config& m_inct_config);
-  void CreateInterconnect(unsigned n_shader, unsigned n_mem);
-  
-  //node side functions
-  void Init();
-  void Push(unsigned input_deviceID, unsigned output_deviceID, void* data, unsigned int size);
-  void* Pop(unsigned ouput_deviceID);
-  void Advance();
-  bool Busy() const;
-  bool HasBuffer(unsigned deviceID, unsigned int size) const;
-  void DisplayStats() const;
-  void DisplayOverallStats() const;
-  unsigned GetFlitSize() const;
-  
-  void DisplayState(FILE* fp) const;
-  
-  
+	LocalInterconnect(const struct inct_config& m_localinct_config);
+	~LocalInterconnect();
+	static LocalInterconnect* New(const struct inct_config& m_inct_config);
+	void CreateInterconnect(unsigned n_shader, unsigned n_mem);
+
+	//node side functions
+	void Init();
+	void Push(unsigned input_deviceID, unsigned output_deviceID, void* data, unsigned int size);
+	void* Pop(unsigned ouput_deviceID);
+	void Advance();
+	bool Busy() const;
+	bool HasBuffer(unsigned deviceID, unsigned int size) const;
+	void DisplayStats() const;
+	void DisplayOverallStats() const;
+	unsigned GetFlitSize() const;
+
+	void DisplayState(FILE* fp) const;
+
+
 protected:
 
-  const inct_config& m_inct_config;
-  
-  unsigned n_shader, n_mem;
-  unsigned n_subnets;
-  vector<xbar_router *> net;
+	const inct_config& m_inct_config;
+
+	unsigned n_shader, n_mem;
+	unsigned n_subnets;
+	vector<xbar_router *> net;
 
 };
 
diff --git a/src/gpgpu-sim/shader.cc b/src/gpgpu-sim/shader.cc
index 09be1f6..d8949ab 100644
--- a/src/gpgpu-sim/shader.cc
+++ b/src/gpgpu-sim/shader.cc
@@ -1896,7 +1896,7 @@ void tensor_core::issue( register_set& source_reg )
 unsigned pipelined_simd_unit::get_active_lanes_in_pipeline(){
 	active_mask_t active_lanes;
 	active_lanes.reset();
-	 if(!m_config->fast_execution_mode || active_insts_in_pipeline){
+	 if(m_core->get_gpu()->get_config().g_power_simulation_enabled){
 		for( unsigned stage=0; (stage+1)<m_pipeline_depth; stage++ ){
 			if( !m_pipeline_reg[stage]->empty() )
 				active_lanes|=m_pipeline_reg[stage]->get_active_mask();
@@ -2014,7 +2014,7 @@ void pipelined_simd_unit::cycle()
         assert(active_insts_in_pipeline > 0);
         active_insts_in_pipeline--;
     }
-    if(!m_config->fast_execution_mode || active_insts_in_pipeline){
+    if(active_insts_in_pipeline){
 		for( unsigned stage=0; (stage+1)<m_pipeline_depth; stage++ )
 			move_warp(m_pipeline_reg[stage], m_pipeline_reg[stage+1]);
     }
@@ -3000,7 +3000,6 @@ unsigned int shader_core_config::max_cta( const kernel_info_t &k ) const
 
 void shader_core_config::set_pipeline_latency() {
 
-    if(fast_execution_mode) {
 		//calculate the max latency  based on the input
 
 		unsigned int_latency[5];
@@ -3038,19 +3037,12 @@ void shader_core_config::set_pipeline_latency() {
 		max_int_latency = int_latency[1];
 		max_dp_latency = dp_latency[1];
 		max_tensor_core_latency = tensor_latency;
-    } else {
-    	max_sfu_latency = 512;
-		max_sp_latency = 32;
-		max_int_latency = 32;
-		max_dp_latency = 512;
-		max_tensor_core_latency = 64;
-    }
 
 }
 
 void shader_core_ctx::cycle()
 {
-	if(m_config->fast_execution_mode && !isactive() && get_not_completed() == 0)
+	if(!isactive() && get_not_completed() == 0)
 		return;
 
 	m_stats->shader_cycles[m_sid]++;
diff --git a/src/gpgpu-sim/shader.h b/src/gpgpu-sim/shader.h
index 2204697..a0c2b63 100644
--- a/src/gpgpu-sim/shader.h
+++ b/src/gpgpu-sim/shader.h
@@ -1519,7 +1519,7 @@ struct shader_core_config : public core_config
     bool gpgpu_concurrent_kernel_sm;
 
     bool adpative_volta_cache_config;
-    bool fast_execution_mode;
+
 };
 
 struct shader_core_stats_pod {