BUG: concurrent kernels on same SM may occupy warps from running CTAs

3 files changed, 31 insertions, 11 deletions

diff --git a/src/gpgpu-sim/gpu-sim.cc b/src/gpgpu-sim/gpu-sim.cc
index 10c4ccf..81c9c9a 100644
--- a/src/gpgpu-sim/gpu-sim.cc
+++ b/src/gpgpu-sim/gpu-sim.cc
@@ -1092,7 +1092,7 @@ bool shader_core_ctx::can_issue_1block(kernel_info_t & kernel) {
    return occupy_shader_resource_1block(kernel, false);
 }
 
-int shader_core_ctx::find_available_hwtid(unsigned int cta_size) {
+int shader_core_ctx::find_available_hwtid(unsigned int cta_size, bool occupy) {
    
    unsigned int step;
    for(step = 0; step < m_config->n_thread_per_shader; 
@@ -1101,7 +1101,7 @@ int shader_core_ctx::find_available_hwtid(unsigned int cta_size) {
         unsigned int hw_tid;
         for(hw_tid = step; hw_tid < step + cta_size;
             hw_tid++) {
-            if(m_active_threads.test(hw_tid))
+            if(m_occupied_hwtid.test(hw_tid))
                 break;
         }
         if(hw_tid == step + cta_size) //consecutive non-active
@@ -1109,8 +1109,14 @@ int shader_core_ctx::find_available_hwtid(unsigned int cta_size) {
    }
    if(step >= m_config->n_thread_per_shader) //didn't find
      return -1;
-   else
+   else {
+     if(occupy) {
+        for(unsigned hw_tid = step; hw_tid < step + cta_size;
+            hw_tid++)
+            m_occupied_hwtid.set(hw_tid);
+     }
      return step;
+   }
 }
 
 bool shader_core_ctx::occupy_shader_resource_1block(kernel_info_t & k, bool occupy) {
@@ -1124,7 +1130,7 @@ bool shader_core_ctx::occupy_shader_resource_1block(kernel_info_t & k, bool occu
    if(m_occupied_n_threads + padded_cta_size > m_config->n_thread_per_shader)
      return false;
 
-   if(find_available_hwtid(padded_cta_size) == -1)
+   if(find_available_hwtid(padded_cta_size, false) == -1)
      return false;
 
    const struct gpgpu_ptx_sim_kernel_info *kernel_info = ptx_sim_kernel_info(kernel);
@@ -1152,7 +1158,7 @@ bool shader_core_ctx::occupy_shader_resource_1block(kernel_info_t & k, bool occu
    return true;
 }
 
-void shader_core_ctx::release_shader_resource_1block(kernel_info_t & k) {
+void shader_core_ctx::release_shader_resource_1block(unsigned hw_ctaid, kernel_info_t & k) {
    unsigned threads_per_cta  = k.threads_per_cta();
    const class function_info *kernel = k.entry();
    unsigned int padded_cta_size = threads_per_cta;
@@ -1163,6 +1169,13 @@ void shader_core_ctx::release_shader_resource_1block(kernel_info_t & k) {
    assert(m_occupied_n_threads >= padded_cta_size);
    m_occupied_n_threads -= padded_cta_size;
 
+   int start_thread = m_occupied_cta_to_hwtid[hw_ctaid];
+
+   for(unsigned hwtid = start_thread; hwtid < start_thread + padded_cta_size;
+    hwtid++)
+       m_occupied_hwtid.reset(hwtid);
+   m_occupied_cta_to_hwtid.erase(hw_ctaid);
+
    const struct gpgpu_ptx_sim_kernel_info *kernel_info = ptx_sim_kernel_info(kernel);
 
    assert(m_occupied_shmem >= (unsigned int)kernel_info->smem);
@@ -1211,9 +1224,11 @@ void shader_core_ctx::issue_block2core( kernel_info_t &kernel )
     int padded_cta_size = cta_size; 
     if (cta_size%m_config->warp_size)
       padded_cta_size = ((cta_size/m_config->warp_size)+1)*(m_config->warp_size);
-    unsigned int start_thread = find_available_hwtid(padded_cta_size);
+    unsigned int start_thread = find_available_hwtid(padded_cta_size, true);
     assert((int)start_thread != -1);
     unsigned int end_thread = start_thread + cta_size;
+    assert(m_occupied_cta_to_hwtid.find(free_cta_hw_id) == m_occupied_cta_to_hwtid.end());
+    m_occupied_cta_to_hwtid[free_cta_hw_id]= start_thread;
 //    unsigned start_thread = free_cta_hw_id * padded_cta_size;
 //    unsigned end_thread  = start_thread +  cta_size;
 
diff --git a/src/gpgpu-sim/shader.cc b/src/gpgpu-sim/shader.cc
index 8ce2146..b9caf18 100644
--- a/src/gpgpu-sim/shader.cc
+++ b/src/gpgpu-sim/shader.cc
@@ -302,6 +302,8 @@ shader_core_ctx::shader_core_ctx( class gpgpu_sim *gpu,
     m_occupied_shmem = 0;
     m_occupied_regs = 0;
     m_occupied_ctas = 0;
+    m_occupied_hwtid.reset();
+    m_occupied_cta_to_hwtid.clear();
 }
 
 void shader_core_ctx::reinit(unsigned start_thread, unsigned end_thread, bool reset_not_completed ) 
@@ -315,6 +317,8 @@ void shader_core_ctx::reinit(unsigned start_thread, unsigned end_thread, bool re
        m_occupied_shmem = 0;
        m_occupied_regs = 0;
        m_occupied_ctas = 0;
+       m_occupied_hwtid.reset();
+       m_occupied_cta_to_hwtid.clear();
 
    }
    for (unsigned i = start_thread; i<end_thread; i++) {
@@ -893,7 +897,6 @@ void scheduler_unit::cycle()
                                     else //cudaLaunchDeviceV2 and cudaGetParameterBufferV2
                                         warp(warp_id).m_cdp_latency = cdp_latency[pI->m_is_cdp - 1]
                                             + cdp_latency[pI->m_is_cdp] * active_mask.count();
-                                    printf("set latency %d\n", warp(warp_id).m_cdp_latency);
                                     warp(warp_id).m_cdp_dummy = true;
                                     break;
                                 }
@@ -1980,7 +1983,7 @@ void shader_core_ctx::register_cta_thread_exit( unsigned cta_num, kernel_info_t
       }
 
       //Jin: for concurrent kernels on sm
-      release_shader_resource_1block(*kernel);
+      release_shader_resource_1block(cta_num, *kernel);
       kernel->dec_running();
       if( !m_gpu->kernel_more_cta_left(kernel) ) {
           if( !kernel->running() ) {
diff --git a/src/gpgpu-sim/shader.h b/src/gpgpu-sim/shader.h
index 882868e..bdd8dbe 100644
--- a/src/gpgpu-sim/shader.h
+++ b/src/gpgpu-sim/shader.h
@@ -1766,7 +1766,7 @@ public:
     virtual void checkExecutionStatusAndUpdate(warp_inst_t &inst, unsigned t, unsigned tid);
     address_type next_pc( int tid ) const;
     void fetch();
-    void register_cta_thread_exit( unsigned cta_num, kernel_info_t * kernel );
+    void register_cta_thread_exit(unsigned cta_num, kernel_info_t * kernel );
 
     void decode();
     
@@ -1853,13 +1853,15 @@ public:
 public:
     bool can_issue_1block(kernel_info_t & kernel);
     bool occupy_shader_resource_1block(kernel_info_t & kernel, bool occupy);
-    void release_shader_resource_1block(kernel_info_t & kernel);
-    int find_available_hwtid(unsigned int cta_size);
+    void release_shader_resource_1block(unsigned hw_ctaid, kernel_info_t & kernel);
+    int find_available_hwtid(unsigned int cta_size, bool occupy);
 private:
     unsigned int m_occupied_n_threads; 
     unsigned int m_occupied_shmem; 
     unsigned int m_occupied_regs;
     unsigned int m_occupied_ctas;
+    std::bitset<MAX_THREAD_PER_SM> m_occupied_hwtid;
+    std::map<unsigned int, unsigned int> m_occupied_cta_to_hwtid; 
 
 
 };