- parameter memory and active threads now part of kernel_info_t:

  Parameters are finalized at kernel launch, which means the contents
  of parameter memory are initialized. Kernel arguement names have a
  fixed order, hence same address should be assigned on subsequent
  kernel launches of same kernel in other streams provided the data size
  param_t::size of arguments for each kernel launch is identical (an
  assertion has been added to check this is true).

- passing regression

[git-p4: depot-paths = "//depot/gpgpu_sim_research/fermi/distribution/": change = 8303]

4 files changed, 31 insertions, 15 deletions

diff --git a/src/gpgpu-sim/gpu-sim.cc b/src/gpgpu-sim/gpu-sim.cc
index 9ae05d8..05a9b55 100644
--- a/src/gpgpu-sim/gpu-sim.cc
+++ b/src/gpgpu-sim/gpu-sim.cc
@@ -309,9 +309,9 @@ void increment_x_then_y_then_z( dim3 &i, const dim3 &bound)
    }
 }
 
-void gpgpu_sim::launch( kernel_info_t &kinfo )
+void gpgpu_sim::launch( kernel_info_t *kinfo )
 {
-   unsigned cta_size = kinfo.threads_per_cta();
+   unsigned cta_size = kinfo->threads_per_cta();
    if ( cta_size > m_shader_config->n_thread_per_shader ) {
       printf("Execution error: Shader kernel CTA (block) size is too large for microarch config.\n");
       printf("                 CTA size (x*y*z) = %u, max supported = %u\n", cta_size, 
@@ -322,7 +322,7 @@ void gpgpu_sim::launch( kernel_info_t &kinfo )
    }
    unsigned n=0;
    for(n=0; n < m_running_kernels.size(); n++ ) {
-       if( m_running_kernels[n].done() ) {
+       if( (NULL==m_running_kernels[n]) || m_running_kernels[n]->done() ) {
            m_running_kernels[n] = kinfo;
            break;
        }
@@ -333,7 +333,7 @@ void gpgpu_sim::launch( kernel_info_t &kinfo )
 bool gpgpu_sim::can_start_kernel()
 {
    for(unsigned n=0; n < m_running_kernels.size(); n++ ) {
-       if( m_running_kernels[n].done() ) 
+       if( (NULL==m_running_kernels[n]) || m_running_kernels[n]->done() ) 
            return true;
    }
    return false;
@@ -346,7 +346,7 @@ bool gpgpu_sim::get_more_cta_left() const
           return false;
    }
    for(unsigned n=0; n < m_running_kernels.size(); n++ ) {
-       if( m_running_kernels[n].valid() && !m_running_kernels[n].no_more_ctas_to_run() ) 
+       if( m_running_kernels[n] && !m_running_kernels[n]->no_more_ctas_to_run() ) 
            return true;
    }
    return false;
@@ -356,9 +356,9 @@ kernel_info_t *gpgpu_sim::select_kernel()
 {
     for(unsigned n=0; n < m_running_kernels.size(); n++ ) {
         unsigned idx = (n+m_last_issued_kernel+1)%m_config.max_concurrent_kernel;
-        if( m_running_kernels[idx].valid() && !m_running_kernels[idx].no_more_ctas_to_run() ) {
+        if( m_running_kernels[idx] && !m_running_kernels[idx]->no_more_ctas_to_run() ) {
             m_last_issued_kernel=idx;
-            return &m_running_kernels[idx];
+            return m_running_kernels[idx];
         }
     }
     return NULL;
@@ -373,6 +373,20 @@ unsigned gpgpu_sim::finished_kernel()
     return result;
 }
 
+void gpgpu_sim::set_kernel_done( kernel_info_t *kernel ) 
+{ 
+    unsigned uid = kernel->get_uid();
+    m_finished_kernel.push_back(uid);
+    std::vector<kernel_info_t*>::iterator k;
+    for( k=m_running_kernels.begin(); k!=m_running_kernels.end(); k++ ) {
+        if( *k == kernel ) {
+            *k = NULL;
+            break;
+        }
+    }
+    assert( k != m_running_kernels.end() ); 
+}
+
 void set_ptx_warp_size(const struct core_config * warp_size);
 
 gpgpu_sim::gpgpu_sim( const gpgpu_sim_config &config ) 
@@ -404,7 +418,7 @@ gpgpu_sim::gpgpu_sim( const gpgpu_sim_config &config )
     time_vector_create(NUM_MEM_REQ_STAT);
     fprintf(stdout, "GPGPU-Sim uArch: performance model initialization complete.\n");
 
-    m_running_kernels.resize( config.max_concurrent_kernel );
+    m_running_kernels.resize( config.max_concurrent_kernel, NULL );
     m_last_issued_kernel = 0;
     m_last_cluster_issue = 0;
 }
diff --git a/src/gpgpu-sim/gpu-sim.h b/src/gpgpu-sim/gpu-sim.h
index 5631ab9..f229965 100644
--- a/src/gpgpu-sim/gpu-sim.h
+++ b/src/gpgpu-sim/gpu-sim.h
@@ -242,10 +242,10 @@ public:
 
    void set_prop( struct cudaDeviceProp *prop );
 
-   void launch( kernel_info_t &kinfo );
+   void launch( kernel_info_t *kinfo );
    bool can_start_kernel();
    unsigned finished_kernel();
-   void set_kernel_done( unsigned uid ) { m_finished_kernel.push_back(uid); }
+   void set_kernel_done( kernel_info_t *kernel );
 
    void init();
    void cycle();
@@ -289,7 +289,7 @@ private:
    class simt_core_cluster **m_cluster;
    class memory_partition_unit **m_memory_partition_unit;
 
-   std::vector<kernel_info_t> m_running_kernels;
+   std::vector<kernel_info_t*> m_running_kernels;
    unsigned m_last_issued_kernel;
 
    std::list<unsigned> m_finished_kernel;
diff --git a/src/gpgpu-sim/shader.cc b/src/gpgpu-sim/shader.cc
index 07aeb6d..2380bcf 100644
--- a/src/gpgpu-sim/shader.cc
+++ b/src/gpgpu-sim/shader.cc
@@ -1207,11 +1207,12 @@ void shader_core_ctx::register_cta_thread_exit( unsigned cta_num )
       if( m_n_active_cta == 0 ) {
           assert( m_kernel != NULL );
           m_kernel->dec_running();
-          printf("GPGPU-Sim uArch: Shader %u empty.\n", m_sid );
+          printf("GPGPU-Sim uArch: Shader %u empty (release kernel %u \'%s\').\n", m_sid, m_kernel->get_uid(),
+                 m_kernel->name().c_str() );
           if( m_kernel->no_more_ctas_to_run() ) {
               if( !m_kernel->running() ) {
-                  m_gpu->set_kernel_done( m_kernel->get_uid() );
                   printf("GPGPU-Sim uArch: GPU detected kernel \'%s\' finished on shader %u.\n", m_kernel->name().c_str(), m_sid );
+                  m_gpu->set_kernel_done( m_kernel );
               }
           }
           m_kernel=NULL;
diff --git a/src/gpgpu-sim/shader.h b/src/gpgpu-sim/shader.h
index 7f41cfe..2b834a6 100644
--- a/src/gpgpu-sim/shader.h
+++ b/src/gpgpu-sim/shader.h
@@ -1123,8 +1123,9 @@ public:
     {
         assert(k);
         m_kernel=k; 
-        if(k) k->inc_running(); 
-        printf("GPGPU-Sim uArch: Shader %d kernel = 0x%p\n", m_sid, m_kernel );
+        k->inc_running(); 
+        printf("GPGPU-Sim uArch: Shader %d bind to kernel %u \'%s\'\n", m_sid, m_kernel->get_uid(),
+                 m_kernel->name().c_str() );
     }
     
     // accessors