Partial Revert "Fix correlation on A100 CUTLASS GEMM Kernels (#127)" (#133)

* Partial Revert "Fix correlation on A100 CUTLASS GEMM Kernels (#127)"

This reverts commit 987a23f84f8705c0566a47aeda2132fa33a82618.

Only reverting the kernel issue part - issue_block2core.

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* Modernize latency array declarations with C++17 style

- Replace C-style arrays with std::array for type safety
- Add zero-initialization using {} for arrays
- Add explicit zero-initialization for scalar latency variables
- Add #include <array> header

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* format code

---------

Co-authored-by: Claude Opus 4.5 <[email protected]>

4 files changed, 33 insertions, 49 deletions

diff --git a/src/abstract_hardware_model.cc b/src/abstract_hardware_model.cc
index 7123c24..e8ddf95 100644
--- a/src/abstract_hardware_model.cc
+++ b/src/abstract_hardware_model.cc
@@ -782,7 +782,6 @@ kernel_info_t::kernel_info_t(dim3 gridDim, dim3 blockDim,
       num_blocks() * entry->gpgpu_ctx->device_runtime->g_TB_launch_latency;
 
   cache_config_set = false;
-  allocated_ctas = 0;
 }
 
 /*A snapshot of the texture mappings needs to be stored in the kernel's info as
@@ -816,7 +815,6 @@ kernel_info_t::kernel_info_t(
   cache_config_set = false;
   m_NameToCudaArray = nameToCudaArray;
   m_NameToTextureInfo = nameToTextureInfo;
-  allocated_ctas = 0;
 }
 
 kernel_info_t::~kernel_info_t() {
diff --git a/src/abstract_hardware_model.h b/src/abstract_hardware_model.h
index b2a360d..06c3082 100644
--- a/src/abstract_hardware_model.h
+++ b/src/abstract_hardware_model.h
@@ -369,7 +369,6 @@ class kernel_info_t {
 
   // Jin: kernel timing
  public:
-  unsigned allocated_ctas;
   unsigned long long launch_cycle;
   unsigned long long start_cycle;
   unsigned long long end_cycle;
diff --git a/src/gpgpu-sim/shader.cc b/src/gpgpu-sim/shader.cc
index d388801..7a4ff37 100644
--- a/src/gpgpu-sim/shader.cc
+++ b/src/gpgpu-sim/shader.cc
@@ -34,6 +34,7 @@
 #include <float.h>
 #include <limits.h>
 #include <string.h>
+#include <array>
 #include "../../libcuda/gpgpu_context.h"
 #include "../cuda-sim/cuda-sim.h"
 #include "../cuda-sim/ptx-stats.h"
@@ -3633,11 +3634,11 @@ unsigned int shader_core_config::max_cta(const kernel_info_t &k) const {
 void shader_core_config::set_pipeline_latency() {
   // calculate the max latency  based on the input
 
-  unsigned int_latency[6];
-  unsigned fp_latency[5];
-  unsigned dp_latency[5];
-  unsigned sfu_latency;
-  unsigned tensor_latency;
+  std::array<unsigned, 6> int_latency{};
+  std::array<unsigned, 5> fp_latency{};
+  std::array<unsigned, 5> dp_latency{};
+  unsigned sfu_latency = 0;
+  unsigned tensor_latency = 0;
 
   /*
    * [0] ADD,SUB
@@ -4542,54 +4543,41 @@ unsigned simt_core_cluster::get_n_active_sms() const {
 }
 
 unsigned simt_core_cluster::issue_block2core() {
-  const unsigned max_pending_ctas = 4;
-  for (unsigned core = 0; core < m_config->n_simt_cores_per_cluster; core++) {
-    if (m_core[core]->pending_ctas.size() < max_pending_ctas) {
-      kernel_info_t *kernel;
-      // Jin: fetch kernel according to concurrent kernel setting
-      if (m_config->gpgpu_concurrent_kernel_sm) {  // concurrent kernel on sm
-        // always select latest issued kernel
-        kernel_info_t *k = m_gpu->select_kernel();
-        kernel = k;
-      } else {
-        // first select core kernel, if no more cta, get a new kernel
-        // only when core completes
-        kernel = m_core[core]->get_kernel();
-        if (!m_gpu->kernel_more_cta_left(kernel)) {
-          // wait till current kernel finishes
-          if (m_core[core]->get_not_completed() == 0) {
-            kernel_info_t *k = m_gpu->select_kernel();
-            if (k) m_core[core]->set_kernel(k);
-            kernel = k;
-          }
-        }
-      }
-      if (kernel) {
-        if (kernel->allocated_ctas < kernel->num_blocks()) {
-          m_core[core]->pending_ctas.push_back(kernel);
-          kernel->allocated_ctas++;
-        }
-      }
-    }
-  }
-
   unsigned num_blocks_issued = 0;
   for (unsigned i = 0; i < m_config->n_simt_cores_per_cluster; i++) {
     unsigned core =
         (i + m_cta_issue_next_core + 1) % m_config->n_simt_cores_per_cluster;
 
-    if (m_core[core]->pending_ctas.size() > 0) {
-      kernel_info_t *pending_cta = m_core[core]->pending_ctas.front();
-      if (m_core[core]->can_issue_1block(*pending_cta)) {
-        m_core[core]->issue_block2core(*pending_cta);
-        m_core[core]->pending_ctas.pop_front();
-        num_blocks_issued++;
-        m_cta_issue_next_core = core;
-        break;
+    kernel_info_t *kernel;
+    // Jin: fetch kernel according to concurrent kernel setting
+    if (m_config->gpgpu_concurrent_kernel_sm) {  // concurrent kernel on sm
+      // always select latest issued kernel
+      kernel_info_t *k = m_gpu->select_kernel();
+      kernel = k;
+    } else {
+      // first select core kernel, if no more cta, get a new kernel
+      // only when core completes
+      kernel = m_core[core]->get_kernel();
+      if (!m_gpu->kernel_more_cta_left(kernel)) {
+        // wait till current kernel finishes
+        if (m_core[core]->get_not_completed() == 0) {
+          kernel_info_t *k = m_gpu->select_kernel();
+          if (k) m_core[core]->set_kernel(k);
+          kernel = k;
+        }
       }
     }
-  }
 
+    if (m_gpu->kernel_more_cta_left(kernel) &&
+        //            (m_core[core]->get_n_active_cta() <
+        //            m_config->max_cta(*kernel)) ) {
+        m_core[core]->can_issue_1block(*kernel)) {
+      m_core[core]->issue_block2core(*kernel);
+      num_blocks_issued++;
+      m_cta_issue_next_core = core;
+      break;
+    }
+  }
   return num_blocks_issued;
 }
 
diff --git a/src/gpgpu-sim/shader.h b/src/gpgpu-sim/shader.h
index 6bf020b..5922d24 100644
--- a/src/gpgpu-sim/shader.h
+++ b/src/gpgpu-sim/shader.h
@@ -2564,7 +2564,6 @@ class shader_core_ctx : public core_t {
 
   // Jin: concurrent kernels on a sm
  public:
-  std::deque<kernel_info_t *> pending_ctas;
   bool can_issue_1block(kernel_info_t &kernel);
   bool occupy_shader_resource_1block(kernel_info_t &kernel, bool occupy);
   void release_shader_resource_1block(unsigned hw_ctaid, kernel_info_t &kernel);