add 2 kernel metrics (#185)

Summary:
1. Update "warps per sm" to "blocks per sm".
2. Add "occupancy" per kernel.

Pull Request resolved: #185

Reviewed By: chaekit

Differential Revision: D28120846

Pulled By: gdankel

fbshipit-source-id: c7ce33b1421b60ae4323c66d38bba5eb175b105b

Author: gaoteng-git

libkineto/libkineto_defs.bzl

@@ -17,6 +17,7 @@ def get_libkineto_srcs(with_api = True):
         "src/ActivityProfilerProxy.cpp",
         "src/Config.cpp",
         "src/ConfigLoader.cpp",
+        "src/CudaDeviceProperties.cpp",
         "src/CuptiActivityInterface.cpp",
         "src/CuptiEventInterface.cpp",
         "src/CuptiMetricInterface.cpp",

libkineto/src/CudaDeviceProperties.cpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) Kineto Contributors
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "CudaDeviceProperties.h"
+
+#include <vector>
+
+#include <cuda_runtime.h>
+#include <cuda_occupancy.h>
+
+#include "Logger.h"
+
+namespace KINETO_NAMESPACE {
+
+std::vector<cudaOccDeviceProp> createOccDeviceProps() {
+  std::vector<cudaOccDeviceProp> occProps;
+  int device_count;
+  cudaError_t error_id = cudaGetDeviceCount(&device_count);
+  // Return empty vector if error.
+  if (error_id != cudaSuccess) {
+    return occProps;
+  }
+  for (int i = 0; i < device_count; ++i) {
+    cudaDeviceProp prop;
+    error_id = cudaGetDeviceProperties(&prop, i);
+    // Return empty vector if any device property fail to get.
+    if (error_id != cudaSuccess) {
+      return occProps;
+    }
+    cudaOccDeviceProp occProp;
+    occProp = prop;
+    occProps.push_back(occProp);
+  }
+  return occProps;
+}
+
+const std::vector<cudaOccDeviceProp>& occDeviceProps() {
+  static std::vector<cudaOccDeviceProp> occProps = createOccDeviceProps();
+  return occProps;
+}
+
+float kernelOccupancy(
+    uint32_t deviceId,
+    uint16_t registersPerThread,
+    int32_t staticSharedMemory,
+    int32_t dynamicSharedMemory,
+    int32_t blockX,
+    int32_t blockY,
+    int32_t blockZ,
+    float blocksPerSm) {
+  // Calculate occupancy
+  float occupancy = -1.0;
+  const std::vector<cudaOccDeviceProp> &occProps = occDeviceProps();
+  if (deviceId < occProps.size()) {
+    cudaOccFuncAttributes occFuncAttr;
+    occFuncAttr.maxThreadsPerBlock = INT_MAX;
+    occFuncAttr.numRegs = registersPerThread;
+    occFuncAttr.sharedSizeBytes = staticSharedMemory;
+    occFuncAttr.partitionedGCConfig = PARTITIONED_GC_OFF;
+    occFuncAttr.shmemLimitConfig = FUNC_SHMEM_LIMIT_DEFAULT;
+    occFuncAttr.maxDynamicSharedSizeBytes = 0;
+    const cudaOccDeviceState occDeviceState = {};
+    int blockSize = blockX * blockY * blockZ;
+    size_t dynamicSmemSize = dynamicSharedMemory;
+    cudaOccResult occ_result;
+    cudaOccError status = cudaOccMaxActiveBlocksPerMultiprocessor(
+          &occ_result, &occProps[deviceId], &occFuncAttr, &occDeviceState,
+          blockSize, dynamicSmemSize);
+    if (status == CUDA_OCC_SUCCESS) {
+      if (occ_result.activeBlocksPerMultiprocessor < blocksPerSm) {
+        blocksPerSm = occ_result.activeBlocksPerMultiprocessor;
+      }
+      occupancy = blocksPerSm * blockSize /
+          (float) occProps[deviceId].maxThreadsPerMultiprocessor;
+    } else {
+      LOG_EVERY_N(ERROR, 1000) << "Failed to calculate occupancy, status = "
+                               << status;
+    }
+  }
+  return occupancy;
+}
+
+} // namespace KINETO_NAMESPACE

libkineto/src/CudaDeviceProperties.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) Kineto Contributors
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+namespace KINETO_NAMESPACE {
+
+float kernelOccupancy(
+    uint32_t deviceId,
+    uint16_t registersPerThread,
+    int32_t staticSharedMemory,
+    int32_t dynamicSharedMemory,
+    int32_t blockX,
+    int32_t blockY,
+    int32_t blockZ,
+    float blocks_per_sm);
+
+} // namespace KINETO_NAMESPACE

libkineto/src/output_json.cpp

@@ -17,6 +17,7 @@
 #include "CuptiActivity.h"
 #include "CuptiActivity.tpp"
 #include "CuptiActivityInterface.h"
+#include "CudaDeviceProperties.h"
 #endif // HAS_CUPTI
 #include "Demangle.h"
 #include "TraceSpan.h"
@@ -307,12 +308,27 @@ void ChromeTraceLogger::handleGpuActivity(
   const CUpti_ActivityKernel4* kernel = &activity.raw();
   const TraceActivity& ext = *activity.linkedActivity();
   constexpr int threads_per_warp = 32;
+  float blocks_per_sm = -1.0;
   float warps_per_sm = -1.0;
   if (smCount_) {
-    warps_per_sm = (kernel->gridX * kernel->gridY * kernel->gridZ) *
-        (kernel->blockX * kernel->blockY * kernel->blockZ) /
-        (float) threads_per_warp / smCount_;
+    blocks_per_sm =
+        (kernel->gridX * kernel->gridY * kernel->gridZ) / (float) smCount_;
+    warps_per_sm =
+        blocks_per_sm * (kernel->blockX * kernel->blockY * kernel->blockZ)
+        / threads_per_warp;
   }
+
+  // Calculate occupancy
+  float occupancy = KINETO_NAMESPACE::kernelOccupancy(
+      kernel->deviceId,
+      kernel->registersPerThread,
+      kernel->staticSharedMemory,
+      kernel->dynamicSharedMemory,
+      kernel->blockX,
+      kernel->blockY,
+      kernel->blockZ,
+      blocks_per_sm);
+
   // clang-format off
   traceOf_ << fmt::format(R"JSON(
   {{
@@ -322,9 +338,11 @@ void ChromeTraceLogger::handleGpuActivity(
       "stream": {}, "correlation": {}, "external id": {},
       "registers per thread": {},
       "shared memory": {},
+      "blocks per SM": {},
       "warps per SM": {},
       "grid": [{}, {}, {}],
-      "block": [{}, {}, {}]
+      "block": [{}, {}, {}],
+      "theoretical occupancy %": {}
     }}
   }},)JSON",
       traceActivityJson(activity, "stream "),
@@ -333,9 +351,11 @@ void ChromeTraceLogger::handleGpuActivity(
       kernel->streamId, kernel->correlationId, ext.correlationId(),
       kernel->registersPerThread,
       kernel->staticSharedMemory + kernel->dynamicSharedMemory,
+      blocks_per_sm,
       warps_per_sm,
       kernel->gridX, kernel->gridY, kernel->gridZ,
-      kernel->blockX, kernel->blockY, kernel->blockZ);
+      kernel->blockX, kernel->blockY, kernel->blockZ,
+      (int) (0.5 + occupancy * 100.0));
   // clang-format on
 
   handleLinkEnd(activity);