Merge branch 'jain156-dev-purdue-integration' into dev-purdue-integration

13 files changed, 124 insertions, 38 deletions

diff --git a/configs/3.x-cfgs/GTX480/gpgpusim.config b/configs/3.x-cfgs/GTX480/gpgpusim.config
index 436cb41..eb25bc3 100644
--- a/configs/3.x-cfgs/GTX480/gpgpusim.config
+++ b/configs/3.x-cfgs/GTX480/gpgpusim.config
@@ -1,5 +1,5 @@
 # functional simulator specification
--gpgpu_ptx_instruction_classification 0
+-gpgpu_ptx_instruction_classification 1
 -gpgpu_ptx_sim_mode 0
 -gpgpu_ptx_force_max_capability 20 
 
diff --git a/src/abstract_hardware_model.h b/src/abstract_hardware_model.h
index e708fa7..35f289c 100644
--- a/src/abstract_hardware_model.h
+++ b/src/abstract_hardware_model.h
@@ -808,6 +808,7 @@ public:
             arch_reg.dst[i] = -1;
         }
         isize=0;
+        op_classification = 0;
     }
     bool valid() const { return m_decoded; }
     virtual void print_insn( FILE *fp ) const 
@@ -826,6 +827,7 @@ public:
     address_type pc;        // program counter address of instruction
     unsigned isize;         // size of instruction in bytes 
     op_type op;             // opcode (uarch visible)
+    int op_classification;  // classification of opcode for statistics purpopses
 
     barrier_type bar_type;
     reduction_type red_type;
@@ -1033,6 +1035,11 @@ public:
     	return cycles > 0;
     }
 
+    unsigned get_cycles()
+    {
+        return cycles;
+    }
+
     void print( FILE *fout ) const;
     unsigned get_uid() const { return m_uid; }
 
diff --git a/src/cuda-sim/cuda-sim.cc b/src/cuda-sim/cuda-sim.cc
index 93bbc1d..02cd395 100644
--- a/src/cuda-sim/cuda-sim.cc
+++ b/src/cuda-sim/cuda-sim.cc
@@ -52,8 +52,10 @@
 
 int gpgpu_ptx_instruction_classification;
 void ** g_inst_classification_stat = NULL;
+void ** g_inst_mem_classification_stat = NULL;
 void ** g_inst_op_classification_stat= NULL;
 int g_ptx_kernel_count = -1; // used for classification stat collection purposes 
+int g_ptx_kernel_count_prev = -1; // used for classification stat collection purposes 
 int g_debug_execution = 0;
 int g_debug_thread_uid = 0;
 addr_t g_debug_pc = 0xBEEF1518;
@@ -1241,12 +1243,16 @@ void init_inst_classification_stat()
    #define MAX_CLASS_KER 1024
    char kernelname[MAX_CLASS_KER] ="";
    if (!g_inst_classification_stat) g_inst_classification_stat = (void**)calloc(MAX_CLASS_KER, sizeof(void*));
-   snprintf(kernelname, MAX_CLASS_KER, "Kernel %d Classification\n",g_ptx_kernel_count  );         
+   snprintf(kernelname, MAX_CLASS_KER, "Kernel %d INST Classification",g_ptx_kernel_count  );         
    assert( g_ptx_kernel_count < MAX_CLASS_KER ) ; // a static limit on number of kernels increase it if it fails! 
    g_inst_classification_stat[g_ptx_kernel_count] = StatCreate(kernelname,1,20);
+   if (!g_inst_mem_classification_stat) g_inst_mem_classification_stat = (void**)calloc(MAX_CLASS_KER, sizeof(void*));
+   snprintf(kernelname, MAX_CLASS_KER, "Kernel %d MEM Classification",g_ptx_kernel_count  );         
+   g_inst_mem_classification_stat[g_ptx_kernel_count] = StatCreate(kernelname,1,20);
    if (!g_inst_op_classification_stat) g_inst_op_classification_stat = (void**)calloc(MAX_CLASS_KER, sizeof(void*));
-   snprintf(kernelname, MAX_CLASS_KER, "Kernel %d OP Classification\n",g_ptx_kernel_count  );         
+   snprintf(kernelname, MAX_CLASS_KER, "Kernel %d OP Classification",g_ptx_kernel_count  );         
    g_inst_op_classification_stat[g_ptx_kernel_count] = StatCreate(kernelname,1,100);
+   g_ptx_kernel_count_prev++;
 }
 
 static unsigned get_tex_datasize( const ptx_instruction *pI, ptx_thread_info *thread )
@@ -1324,6 +1330,17 @@ void ptx_thread_info::ptx_exec_inst( warp_inst_t &inst, unsigned lane_id)
       delete pJ;
       pI = pI_saved;
       
+      if ( gpgpu_ptx_instruction_classification ) {
+         init_inst_classification_stat();
+         if (op_classification) {
+            StatAddSample( g_inst_classification_stat[g_ptx_kernel_count],  op_classification);
+            inst.op_classification = op_classification;
+         }
+         if (pI->get_space().get_type())
+            StatAddSample( g_inst_mem_classification_stat[g_ptx_kernel_count], ( int )pI->get_space().get_type());
+         StatAddSample( g_inst_op_classification_stat[g_ptx_kernel_count], (int)  pI->get_opcode() );
+      }
+
       // Run exit instruction if exit option included
       if(pI->is_exit())
          exit_impl(pI,this);
@@ -1409,27 +1426,6 @@ void ptx_thread_info::ptx_exec_inst( warp_inst_t &inst, unsigned lane_id)
    if(!(this->m_functionalSimulationMode))
        ptx_file_line_stats_add_exec_count(pI);
    
-   if ( gpgpu_ptx_instruction_classification ) {
-      init_inst_classification_stat();
-      unsigned space_type=0;
-      switch ( pI->get_space().get_type() ) {
-      case global_space: space_type = 10; break;
-      case local_space:  space_type = 11; break; 
-      case tex_space:    space_type = 12; break; 
-      case surf_space:   space_type = 13; break; 
-      case param_space_kernel:
-      case param_space_local:
-                         space_type = 14; break; 
-      case shared_space: space_type = 15; break; 
-      case const_space:  space_type = 16; break;
-      default: 
-         space_type = 0 ;
-         break;
-      }
-      StatAddSample( g_inst_classification_stat[g_ptx_kernel_count],  op_classification);
-      if (space_type) StatAddSample( g_inst_classification_stat[g_ptx_kernel_count], ( int )space_type);
-      StatAddSample( g_inst_op_classification_stat[g_ptx_kernel_count], (int)  pI->get_opcode() );
-   }
    if ( (g_ptx_sim_num_insn % 100000) == 0 ) {
       dim3 ctaid = get_ctaid();
       dim3 tid = get_tid();
@@ -1849,8 +1845,10 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
 
    //******PRINTING*******
    printf( "GPGPU-Sim: Done functional simulation (%u instructions simulated).\n", g_ptx_sim_num_insn );
+   fflush(stdout); 
    if ( gpgpu_ptx_instruction_classification ) {
-      StatDisp( g_inst_classification_stat[g_ptx_kernel_count]);
+      StatDisp ( g_inst_classification_stat[g_ptx_kernel_count]);
+      StatDisp ( g_inst_mem_classification_stat[g_ptx_kernel_count]);
       StatDisp ( g_inst_op_classification_stat[g_ptx_kernel_count]);
    }
 
diff --git a/src/cuda-sim/cuda-sim.h b/src/cuda-sim/cuda-sim.h
index 958daba..ef9549f 100644
--- a/src/cuda-sim/cuda-sim.h
+++ b/src/cuda-sim/cuda-sim.h
@@ -44,8 +44,10 @@ extern int g_ptx_sim_mode;
 extern int g_debug_execution;
 extern int g_debug_thread_uid;
 extern void ** g_inst_classification_stat;
+extern void ** g_inst_mem_classification_stat;
 extern void ** g_inst_op_classification_stat;
 extern int g_ptx_kernel_count; // used for classification stat collection purposes 
+extern int g_ptx_kernel_count_prev; // used for classification stat collection purposes 
 
 void ptx_opcocde_latency_options (option_parser_t opp);
 extern class kernel_info_t *gpgpu_opencl_ptx_sim_init_grid(class function_info *entry,
diff --git a/src/cuda-sim/opcodes.def b/src/cuda-sim/opcodes.def
index e1b1422..ccf64d8 100644
--- a/src/cuda-sim/opcodes.def
+++ b/src/cuda-sim/opcodes.def
@@ -35,7 +35,9 @@ SFU 4
 Mem(except Tex) 5
 Tex 6
 Nop 7
+Breakpoint 9
 Other 10
+Scalar video 11
 */
 OP_DEF(ABS_OP,abs_impl,"abs",1,1)
 OP_DEF(ADD_OP,add_impl,"add",1,1)
diff --git a/src/gpgpu-sim/gpu-sim.cc b/src/gpgpu-sim/gpu-sim.cc
index 08d4525..e437c63 100644
--- a/src/gpgpu-sim/gpu-sim.cc
+++ b/src/gpgpu-sim/gpu-sim.cc
@@ -463,7 +463,7 @@ void gpgpu_sim_config::reg_options(option_parser_t opp)
                 "1");
    option_parser_register(opp, "-gpgpu_ptx_instruction_classification", OPT_INT32, 
                &gpgpu_ptx_instruction_classification, 
-               "if enabled will classify ptx instruction types per kernel (Max 255 kernels now)", 
+               "if enabled will classify ptx instruction types per kernel (Max 1024 kernels now)", 
                "0");
    option_parser_register(opp, "-gpgpu_ptx_sim_mode", OPT_INT32, &g_ptx_sim_mode, 
                "Select between Performance (default) or Functional simulation (1)", 
@@ -686,7 +686,7 @@ gpgpu_sim::gpgpu_sim( const gpgpu_sim_config &config )
     m_memory_partition_unit = new memory_partition_unit*[m_memory_config->m_n_mem];
     m_memory_sub_partition = new memory_sub_partition*[m_memory_config->m_n_mem_sub_partition];
     for (unsigned i=0;i<m_memory_config->m_n_mem;i++) {
-        m_memory_partition_unit[i] = new memory_partition_unit(i, m_memory_config, m_memory_stats);
+        m_memory_partition_unit[i] = new memory_partition_unit(i, m_memory_config, m_memory_stats, this);
         for (unsigned p = 0; p < m_memory_config->m_n_sub_partition_per_memory_channel; p++) {
             unsigned submpid = i * m_memory_config->m_n_sub_partition_per_memory_channel + p; 
             m_memory_sub_partition[submpid] = m_memory_partition_unit[i]->get_sub_partition(p); 
@@ -1069,6 +1069,7 @@ void gpgpu_sim::gpu_print_stat()
    shader_print_scheduler_stat( stdout, false );
 
    m_shader_stats->print(stdout);
+   m_power_stats->print(stdout);
 #ifdef GPGPUSIM_POWER_MODEL
    if(m_config.g_power_simulation_enabled){
 	   m_gpgpusim_wrapper->print_power_kernel_stats(gpu_sim_cycle, gpu_tot_sim_cycle, gpu_tot_sim_insn + gpu_sim_insn, kernel_info_str, true );
@@ -1121,8 +1122,9 @@ void gpgpu_sim::gpu_print_stat()
       insn_warp_occ_print(stdout);
    }
    if ( gpgpu_ptx_instruction_classification ) {
-      StatDisp( g_inst_classification_stat[g_ptx_kernel_count]);
-      StatDisp( g_inst_op_classification_stat[g_ptx_kernel_count]);
+      StatDisp( g_inst_classification_stat[g_ptx_kernel_count_prev]);
+      StatDisp( g_inst_mem_classification_stat[g_ptx_kernel_count_prev]);
+      StatDisp( g_inst_op_classification_stat[g_ptx_kernel_count_prev]);
    }
 
 #ifdef GPGPUSIM_POWER_MODEL
diff --git a/src/gpgpu-sim/gpu-sim.h b/src/gpgpu-sim/gpu-sim.h
index 1778008..f9b5dad 100644
--- a/src/gpgpu-sim/gpu-sim.h
+++ b/src/gpgpu-sim/gpu-sim.h
@@ -36,6 +36,7 @@
 #include <iostream>
 #include <fstream>
 #include <list>
+#include <unordered_set>
 #include <stdio.h>
 
 
@@ -428,6 +429,8 @@ public:
 
     void perf_memcpy_to_gpu( size_t dst_start_addr, size_t count );
 
+   std::unordered_set<unsigned long long> data_footprint_stats;
+
    //The next three functions added to be used by the functional simulation function
    
    //! Get shader core configuration
diff --git a/src/gpgpu-sim/l2cache.cc b/src/gpgpu-sim/l2cache.cc
index 25da107..596e07c 100644
--- a/src/gpgpu-sim/l2cache.cc
+++ b/src/gpgpu-sim/l2cache.cc
@@ -62,15 +62,16 @@ mem_fetch * partition_mf_allocator::alloc(new_addr_type addr, mem_access_type ty
 
 memory_partition_unit::memory_partition_unit( unsigned partition_id, 
                                               const struct memory_config *config,
-                                              class memory_stats_t *stats )
-: m_id(partition_id), m_config(config), m_stats(stats), m_arbitration_metadata(config) 
+                                              class memory_stats_t *stats,
+                                              class gpgpu_sim *gpu)
+: m_id(partition_id), m_config(config), m_stats(stats), m_arbitration_metadata(config), m_gpu(gpu)
 {
     m_dram = new dram_t(m_id,m_config,m_stats,this);
 
     m_sub_partition = new memory_sub_partition*[m_config->m_n_sub_partition_per_memory_channel]; 
     for (unsigned p = 0; p < m_config->m_n_sub_partition_per_memory_channel; p++) {
         unsigned sub_partition_id = m_id * m_config->m_n_sub_partition_per_memory_channel + p; 
-        m_sub_partition[p] = new memory_sub_partition(sub_partition_id, m_config, stats); 
+        m_sub_partition[p] = new memory_sub_partition(sub_partition_id, m_config, stats, m_gpu); 
     }
 }
 
@@ -310,11 +311,13 @@ void memory_partition_unit::print( FILE *fp ) const
 
 memory_sub_partition::memory_sub_partition( unsigned sub_partition_id, 
                                             const struct memory_config *config,
-                                            class memory_stats_t *stats )
+                                            class memory_stats_t *stats ,
+                                            class gpgpu_sim *gpu)
 {
     m_id = sub_partition_id;
     m_config=config;
     m_stats=stats;
+    m_gpu=gpu;
     m_memcpy_cycle_offset = 0;
 
     assert(m_id < m_config->m_n_mem_sub_partition); 
@@ -411,6 +414,15 @@ void memory_sub_partition::cache_cycle( unsigned cycle )
                 bool read_sent = was_read_sent(events);
                 MEM_SUBPART_DPRINTF("Probing L2 cache Address=%llx, status=%u\n", mf->get_addr(), status); 
 
+                if ( (mf->get_access_type() == GLOBAL_ACC_R) ||
+                     (mf->get_access_type() == GLOBAL_ACC_W) ||
+                     (mf->get_access_type() == LOCAL_ACC_R)  ||
+                     (mf->get_access_type() == LOCAL_ACC_W)  ||
+                     (mf->get_access_type() == CONST_ACC_R) ) {
+                    if (!m_gpu->data_footprint_stats.count(mf->get_addr()))
+                        m_gpu->data_footprint_stats.insert(mf->get_addr());
+                }
+
                 if ( status == HIT ) {
                     if( !write_sent ) {
                         // L2 cache replies
diff --git a/src/gpgpu-sim/l2cache.h b/src/gpgpu-sim/l2cache.h
index 18c0a8b..685b1d3 100644
--- a/src/gpgpu-sim/l2cache.h
+++ b/src/gpgpu-sim/l2cache.h
@@ -58,7 +58,7 @@ private:
 class memory_partition_unit
 {
 public: 
-   memory_partition_unit( unsigned partition_id, const struct memory_config *config, class memory_stats_t *stats );
+   memory_partition_unit( unsigned partition_id, const struct memory_config *config, class memory_stats_t *stats , class gpgpu_sim *gpu);
    ~memory_partition_unit(); 
 
    bool busy() const;
@@ -93,6 +93,8 @@ public:
 
    unsigned get_mpid() const { return m_id; }
 
+   gpgpu_sim *m_gpu;
+
 private: 
 
    unsigned m_id;
@@ -145,7 +147,7 @@ private:
 class memory_sub_partition
 {
 public:
-   memory_sub_partition( unsigned sub_partition_id, const struct memory_config *config, class memory_stats_t *stats );
+   memory_sub_partition( unsigned sub_partition_id, const struct memory_config *config, class memory_stats_t *stats, class gpgpu_sim *gpu);
    ~memory_sub_partition(); 
 
    unsigned get_id() const { return m_id; } 
@@ -186,6 +188,8 @@ public:
         m_memcpy_cycle_offset += 1;
    }
 
+   gpgpu_sim *m_gpu;
+
 private:
 // data
    unsigned m_id;  //< the global sub partition ID
diff --git a/src/gpgpu-sim/shader.cc b/src/gpgpu-sim/shader.cc
index 0e2e1c2..80ac07e 100644
--- a/src/gpgpu-sim/shader.cc
+++ b/src/gpgpu-sim/shader.cc
@@ -438,6 +438,22 @@ void shader_core_stats::print( FILE* fout ) const
     fprintf(fout,"gpgpu_n_mem_texture = %d\n", gpgpu_n_mem_texture);
     fprintf(fout,"gpgpu_n_mem_const = %d\n", gpgpu_n_mem_const);
 
+    fprintf(fout,"gpgpu_mem_divergence_hist ");
+    gpgpu_mem_divergence_hist->fprint(fout);
+    fprintf(fout,"\n");
+    fprintf(fout,"gpgpu_gmem_ld_divergence_hist ");
+    gpgpu_gmem_ld_divergence_hist->fprint(fout);
+    fprintf(fout,"\n");
+    fprintf(fout,"gpgpu_gmem_st_divergence_hist ");
+    gpgpu_gmem_st_divergence_hist->fprint(fout);
+    fprintf(fout,"\n");
+    fprintf(fout,"gpgpu_shmem_divergence_hist ");
+    gpgpu_shmem_divergence_hist->fprint(fout);
+    fprintf(fout,"\n");
+    fprintf(fout,"warp_inst_classification ");
+    warp_inst_classification->fprint(fout);
+    fprintf(fout,"\n");
+
    fprintf(fout, "gpgpu_n_load_insn  = %d\n", gpgpu_n_load_insn);
    fprintf(fout, "gpgpu_n_store_insn = %d\n", gpgpu_n_store_insn);
    fprintf(fout, "gpgpu_n_shmem_insn = %d\n", gpgpu_n_shmem_insn);
@@ -740,9 +756,26 @@ void shader_core_ctx::fetch()
 
 void shader_core_ctx::func_exec_inst( warp_inst_t &inst )
 {
+    unsigned starting_queue_size;
     execute_warp_inst_t(inst);
-    if( inst.is_load() || inst.is_store() )
+    if (inst.op_classification) {
+        m_stats->warp_inst_classification->add2bin(inst.op_classification);
+    }
+    if( inst.is_load() || inst.is_store() ) {
+        starting_queue_size = inst.accessq_count();
         inst.generate_mem_accesses();
+        if ( inst.space.get_type() == global_space ) {
+        	if (inst.is_load())
+        		m_stats->gpgpu_gmem_ld_divergence_hist->add2bin(inst.accessq_count() - starting_queue_size);
+        	else if (inst.is_store())
+        		m_stats->gpgpu_gmem_st_divergence_hist->add2bin(inst.accessq_count() - starting_queue_size);
+        }
+        else if ( inst.space.get_type() == shared_space ) {
+            m_stats->gpgpu_shmem_divergence_hist->add2bin(inst.get_cycles());
+        }
+
+        m_stats->gpgpu_mem_divergence_hist->add2bin(inst.accessq_count() - starting_queue_size);
+    }
 }
 
 void shader_core_ctx::issue_warp( register_set& pipe_reg_set, const warp_inst_t* next_inst, const active_mask_t &active_mask, unsigned warp_id )
diff --git a/src/gpgpu-sim/shader.h b/src/gpgpu-sim/shader.h
index e07096e..6a40aee 100644
--- a/src/gpgpu-sim/shader.h
+++ b/src/gpgpu-sim/shader.h
@@ -53,6 +53,8 @@
 #include "stats.h"
 #include "gpu-cache.h"
 #include "traffic_breakdown.h"
+#include "histogram.h"
+
 
 
 
@@ -1478,7 +1480,15 @@ struct shader_core_stats_pod {
     int gpgpu_n_mem_read_global;
     int gpgpu_n_mem_write_global;
     int gpgpu_n_mem_read_inst;
-    
+
+    //warps combined memory divergence histogram
+    linear_histogram* gpgpu_mem_divergence_hist;
+    linear_histogram* gpgpu_gmem_ld_divergence_hist;
+    linear_histogram* gpgpu_gmem_st_divergence_hist;
+    linear_histogram* gpgpu_shmem_divergence_hist;
+
+    linear_histogram* warp_inst_classification;
+
     int gpgpu_n_mem_l2_writeback;
     int gpgpu_n_mem_l1_write_allocate; 
     int gpgpu_n_mem_l2_write_allocate;
@@ -1547,6 +1557,12 @@ public:
         m_incoming_traffic_stats = new traffic_breakdown("memtocore"); 
 
         gpgpu_n_shmem_bank_access = (unsigned *)calloc(config->num_shader(), sizeof(unsigned));
+        gpgpu_mem_divergence_hist = new linear_histogram(1, "", config->warp_size+1);
+        gpgpu_gmem_ld_divergence_hist = new linear_histogram(1, "", config->warp_size+1);
+        gpgpu_gmem_st_divergence_hist = new linear_histogram(1, "", config->warp_size+1);
+        gpgpu_shmem_divergence_hist = new linear_histogram(1, "", config->warp_size+1);
+
+        warp_inst_classification = new linear_histogram(1, "", 12);
 
         m_shader_dynamic_warp_issue_distro.resize( config->num_shader() );
         m_shader_warp_slot_issue_distro.resize( config->num_shader() );
@@ -1561,6 +1577,10 @@ public:
         free(m_n_diverge); 
         free(shader_cycle_distro);
         free(last_shader_cycle_distro);
+        free(gpgpu_mem_divergence_hist);
+        free(gpgpu_gmem_ld_divergence_hist);
+        free(gpgpu_gmem_st_divergence_hist);
+        free(warp_inst_classification);
     }
 
     void new_grid()
diff --git a/src/gpgpusim_entrypoint.cc b/src/gpgpusim_entrypoint.cc
index 52e2f5e..a18e956 100644
--- a/src/gpgpusim_entrypoint.cc
+++ b/src/gpgpusim_entrypoint.cc
@@ -163,6 +163,8 @@ void *gpgpu_sim_thread_concurrent(void*)
            printf("GPGPU-Sim: ** STOP simulation thread (no work) **\n");
            fflush(stdout);
         }
+        //g_the_gpu->print_stats();
+
         if(sim_cycles) {
             g_the_gpu->print_stats();
             g_the_gpu->update_stats();
@@ -270,6 +272,7 @@ void print_simulation_time()
    s = difference - 60*(m + 60*(h + 24*d));
 
    fflush(stderr);
+   printf("gpgpu_data_footprint = %u requests at L2\n", g_the_gpu->data_footprint_stats.size());
    printf("\n\ngpgpu_simulation_time = %u days, %u hrs, %u min, %u sec (%u sec)\n",
           (unsigned)d, (unsigned)h, (unsigned)m, (unsigned)s, (unsigned)difference );
    printf("gpgpu_simulation_rate = %u (inst/sec)\n", (unsigned)(g_the_gpu->gpu_tot_sim_insn / difference) );
diff --git a/src/stream_manager.cc b/src/stream_manager.cc
index 3b6cbd5..21115c6 100644
--- a/src/stream_manager.cc
+++ b/src/stream_manager.cc
@@ -230,7 +230,7 @@ bool stream_manager::operation( bool * sim)
 {
     bool check=check_finished_kernel();
     pthread_mutex_lock(&m_lock);
-//    if(check)m_gpu->print_stats();
+    if(check)m_gpu->print_stats();
     stream_operation op =front();
     if(!op.do_operation( m_gpu )) //not ready to execute
     {