bool getProfilerConfigImage()

in libkineto/src/CuptiNvPerfMetric.cpp [98:232]
107 lines of code
12 McCabe index (conditional complexity)

bool getProfilerConfigImage(
    const std::string& chipName,
    const std::vector<std::string>& metricNames,
    std::vector<uint8_t>& configImage,
    const uint8_t* counterAvailabilityImage) {

  NVPW_CUDA_MetricsContext_Create_Params metricsContextCreateParams = {
      NVPW_CUDA_MetricsContext_Create_Params_STRUCT_SIZE, nullptr};
  metricsContextCreateParams.pChipName = chipName.c_str();

  if (!NVPW_CALL(
        NVPW_CUDA_MetricsContext_Create(&metricsContextCreateParams))) {
    return false;
  }

  NVPW_MetricsContext_Destroy_Params metricsContextDestroyParams = {
      NVPW_MetricsContext_Destroy_Params_STRUCT_SIZE, nullptr};
  metricsContextDestroyParams.pMetricsContext =
      metricsContextCreateParams.pMetricsContext;

  SCOPE_EXIT([&]() {
    NVPW_MetricsContext_Destroy(
        (NVPW_MetricsContext_Destroy_Params*)&metricsContextDestroyParams);
  });

  // Get all raw metrics required for given metricNames list
  std::vector<NVPA_RawMetricRequest> rawMetricRequests;

  // note: we need a variable at this functions scope to hold the string
  // pointers for underlying C char arrays.
  std::vector<std::string> rawMetricDeps;

  if (!getRawMetricRequests(
      metricsContextCreateParams.pMetricsContext,
      metricNames,
      rawMetricDeps,
      rawMetricRequests)) {
    return false;
  }

  NVPA_RawMetricsConfigOptions metricsConfigOptions = {
      NVPA_RAW_METRICS_CONFIG_OPTIONS_STRUCT_SIZE, nullptr};
  metricsConfigOptions.activityKind = NVPA_ACTIVITY_KIND_PROFILER;
  metricsConfigOptions.pChipName = chipName.c_str();
  NVPA_RawMetricsConfig* rawMetricsConfig;
  if (!NVPW_CALL(
        NVPA_RawMetricsConfig_Create(
          &metricsConfigOptions, &rawMetricsConfig))) {
    return false;
  }

  // TODO check if this is required
  if (counterAvailabilityImage) {
    NVPW_RawMetricsConfig_SetCounterAvailability_Params
        setCounterAvailabilityParams = {
            NVPW_RawMetricsConfig_SetCounterAvailability_Params_STRUCT_SIZE, nullptr};
    setCounterAvailabilityParams.pRawMetricsConfig = rawMetricsConfig;
    setCounterAvailabilityParams.pCounterAvailabilityImage =
        counterAvailabilityImage;
    if (!NVPW_CALL(
          NVPW_RawMetricsConfig_SetCounterAvailability(
            &setCounterAvailabilityParams))) {
      return false;
    }
  }

  NVPW_RawMetricsConfig_Destroy_Params rawMetricsConfigDestroyParams = {
      NVPW_RawMetricsConfig_Destroy_Params_STRUCT_SIZE, nullptr};
  rawMetricsConfigDestroyParams.pRawMetricsConfig = rawMetricsConfig;
  SCOPE_EXIT([&]() {
    NVPW_RawMetricsConfig_Destroy(
        (NVPW_RawMetricsConfig_Destroy_Params*)&rawMetricsConfigDestroyParams);
  });

  // Start a Raw Metric Pass group
  NVPW_RawMetricsConfig_BeginPassGroup_Params beginPassGroupParams = {
      NVPW_RawMetricsConfig_BeginPassGroup_Params_STRUCT_SIZE, nullptr};
  beginPassGroupParams.pRawMetricsConfig = rawMetricsConfig;
  if (!NVPW_CALL(
        NVPW_RawMetricsConfig_BeginPassGroup(&beginPassGroupParams))) {
    return false;
  }

  // Add all raw metrics
  NVPW_RawMetricsConfig_AddMetrics_Params addMetricsParams = {
      NVPW_RawMetricsConfig_AddMetrics_Params_STRUCT_SIZE, nullptr};
  addMetricsParams.pRawMetricsConfig = rawMetricsConfig;
  addMetricsParams.pRawMetricRequests = rawMetricRequests.data();
  addMetricsParams.numMetricRequests = rawMetricRequests.size();
  if (!NVPW_CALL(
        NVPW_RawMetricsConfig_AddMetrics(&addMetricsParams))) {
    return false;
  }

  // End pass group
  NVPW_RawMetricsConfig_EndPassGroup_Params endPassGroupParams = {
      NVPW_RawMetricsConfig_EndPassGroup_Params_STRUCT_SIZE, nullptr};
  endPassGroupParams.pRawMetricsConfig = rawMetricsConfig;
  if (!NVPW_CALL(
        NVPW_RawMetricsConfig_EndPassGroup(&endPassGroupParams))) {
    return false;
  }

  // Setup Config Image generation
  NVPW_RawMetricsConfig_GenerateConfigImage_Params generateConfigImageParams = {
      NVPW_RawMetricsConfig_GenerateConfigImage_Params_STRUCT_SIZE, nullptr};
  generateConfigImageParams.pRawMetricsConfig = rawMetricsConfig;
  if (!NVPW_CALL(
        NVPW_RawMetricsConfig_GenerateConfigImage(&generateConfigImageParams))) {
    return false;
  }

  // Get the Config Image size... nearly there
  NVPW_RawMetricsConfig_GetConfigImage_Params getConfigImageParams = {
      NVPW_RawMetricsConfig_GetConfigImage_Params_STRUCT_SIZE, nullptr};
  getConfigImageParams.pRawMetricsConfig = rawMetricsConfig;
  getConfigImageParams.bytesAllocated = 0;
  getConfigImageParams.pBuffer = nullptr;
  if (!NVPW_CALL(
        NVPW_RawMetricsConfig_GetConfigImage(&getConfigImageParams))) {
    return false;
  }

  configImage.resize(getConfigImageParams.bytesCopied);

  // Write the Config image binary
  getConfigImageParams.bytesAllocated = configImage.size();
  getConfigImageParams.pBuffer = configImage.data();
  if (!NVPW_CALL(
        NVPW_RawMetricsConfig_GetConfigImage(&getConfigImageParams))) {
    return false;
  }

  return true;
}