RegCount NITER calculation

Differential Revision: D59405012

Author: Esteban Padilla Cerdio

backends/vulkan/runtime/api/vk_api/QueryPool.cpp

@@ -239,14 +239,20 @@ void QueryPool::print_results() {
 }
 
 unsigned long QueryPool::get_total_shader_ns(std::string kernel_name) {
+  uint64_t total_ns = 0;
+  uint32_t count = 0;
   for (ShaderDuration& entry : shader_durations_) {
     if (entry.kernel_name == kernel_name) {
       std::chrono::duration<size_t, std::nano> exec_duration_ns(
           entry.execution_duration_ns);
-      return exec_duration_ns.count();
+      total_ns += exec_duration_ns.count();
+      count++;
     }
   }
-  return 0;
+  if (count == 0){
+    return 0;
+  }
+  return total_ns / count;
 }
 } // namespace vkapi
 } // namespace vkcompute

backends/vulkan/runtime/api/vk_api/QueryPool.h

@@ -103,6 +103,10 @@ class QueryPool final {
   void print_results();
   unsigned long get_total_shader_ns(std::string kernel_name);
 
+  uint32_t max_query_count() {
+    return config_.max_query_count;
+  }
+
   operator bool() const {
     return querypool_ != VK_NULL_HANDLE;
   }

backends/vulkan/tools/.gitignore

@@ -0,0 +1 @@
+/ArchProbe/

backends/vulkan/tools/gpuinfo/build_gpuinfo.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# 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.
+
+buck2 build //xplat/executorch/backends/vulkan/tools/gpuinfo:vulkan_gpuinfo --target-platforms=ovr_config//platform/android:arm64-fbsource --show-output -c ndk.static_linking=true -c ndk.debug_info_level=1 -c executorch.event_tracer_enabled=true
+adb push ~/fbsource/buck-out/v2/gen/fbsource/f292370ff0e539e9/xplat/executorch/backends/vulkan/tools/gpuinfo/__vulkan_gpuinfo__/vulkan_gpuinfo /data/local/tmp

backends/vulkan/tools/gpuinfo/glsl/reg_count.glsl

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * 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.
+ */
+
+#version 450 core
+
+#define PRECISION ${PRECISION}
+
+#define VEC4_T ${buffer_gvec_type(DTYPE, 4)}
+
+layout(std430) buffer;
+
+layout(set = 0, binding = 0) buffer  PRECISION restrict writeonly Buffer {
+  VEC4_T data[];
+}
+buffer_in;
+
+layout(set = 0, binding = 1) uniform PRECISION restrict Params {
+  int len;
+}
+params;
+
+layout(local_size_x_id = 0, local_size_y_id = 1, local_size_z_id = 2) in;
+
+layout(constant_id = 3) const int niter = 1;
+
+void main() {
+  float reg_data0 = float(niter) + 0;
+  int i = 0;
+  for (; i < niter; ++i) {
+    reg_data0 *= reg_data0;
+  }
+  i = i >> 31;
+  buffer_in.data[0 * i][0] = reg_data0;
+}

backends/vulkan/tools/gpuinfo/glsl/reg_count.yaml

@@ -0,0 +1,17 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# 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.
+
+reg_count:
+  parameter_names_with_default_values:
+    DTYPE: float
+    STORAGE: buffer
+  generate_variant_forall:
+    DTYPE:
+      - VALUE: float
+    STORAGE:
+      - VALUE: buffer
+  shader_variants:
+    - NAME: reg_count

backends/vulkan/tools/gpuinfo/include/utils.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * 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 <executorch/backends/vulkan/runtime/api/api.h>
+
+using namespace vkcompute;
+using namespace api;
+
+#define QP context()->querypool()
+
+auto benchmark_on_gpu(
+    std::string shader_id,
+    uint32_t niter,
+    std::function<void()> run_kernel) {
+  auto fence = context()->fences().get_fence();
+
+  // /2 because there are two timestamp queries per kernel
+  uint32_t max_query_count = QP.max_query_count() / 2;
+  uint32_t runs = std::min(niter, max_query_count);
+  uint64_t count = 0;
+
+  for (int i = 0; i < runs; ++i) {
+    run_kernel();
+    context()->submit_cmd_to_gpu(fence.get_submit_handle());
+  };
+  fence.wait();
+  QP.extract_results();
+  count += QP.get_total_shader_ns(shader_id);
+  QP.reset_state();
+  context()->descriptor_pool().flush();
+  
+  return count / 1000.f;
+}
+
+void ensure_min_niter(
+    double min_time_us,
+    uint32_t& niter,
+    std::function<double()> run) {
+  const uint32_t DEFAULT_NITER = 100;
+  niter = DEFAULT_NITER;
+  for (uint32_t i = 0; i < 100; ++i) {
+    double t = run();
+    if (t > min_time_us * 0.99) {
+      return;
+    }
+    niter = uint32_t(niter * min_time_us / t);
+  }
+}

backends/vulkan/tools/gpuinfo/src/app.cpp

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * 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 <executorch/backends/vulkan/runtime/api/api.h>
+#include <executorch/backends/vulkan/runtime/graph/ops/utils/StagingUtils.h>
+#include <iostream>
+
+#include "utils.h"
+
+void reg_count() {
+  const uint32_t NREG_MIN = 1;
+
+  uint32_t NITER;
+
+  auto bench = [&](uint32_t nthread, uint32_t ngrp, uint32_t nreg) {
+    size_t len = sizeof(float);
+    StorageBuffer buffer(context(), vkapi::kFloat, len);
+    ParamsBuffer params(context(), int32_t(len));
+    vkapi::PipelineBarrier pipeline_barrier{};
+
+    auto time = benchmark_on_gpu("reg_count_float_buffer", NITER, [&]() {
+      context()->submit_compute_job(
+          VK_KERNEL(reg_count_float_buffer),
+          pipeline_barrier,
+          {nthread, ngrp, 1},
+          {nthread, 1, 1},
+          {SV(NITER)},
+          VK_NULL_HANDLE,
+          0,
+          buffer.buffer(),
+          params.buffer());
+    });
+    return time;
+  };
+
+  ensure_min_niter(1000, NITER, [&]() { return bench(1, 1, NREG_MIN); });
+  std::cout << "NITER: " << NITER << std::endl;
+}
+
+int main(int argc, const char** argv) {
+  context()->initialize_querypool();
+
+  reg_count();
+
+  return 0;
+}

backends/vulkan/tools/gpuinfo/targets.bzl

@@ -0,0 +1,94 @@
+load("@fbsource//xplat/executorch/build:runtime_wrapper.bzl", "runtime")
+load(
+    "@fbsource//tools/build_defs:platform_defs.bzl",
+    "ANDROID",
+)
+
+def get_vulkan_compiler_flags():
+    return ["-Wno-missing-prototypes", "-Wno-global-constructors"]
+
+def vulkan_spv_shader_lib(name, spv_filegroups, is_fbcode = False):
+    gen_vulkan_spv_target = "//executorch/backends/vulkan:gen_vulkan_spv_bin"
+    glslc_path = "//caffe2/fb/vulkan/dotslash:glslc"
+    if is_fbcode:
+        glslc_path = "//caffe2/fb/vulkan/tools:glslc"
+
+    glsl_paths = []
+
+    # TODO(ssjia): remove the need for subpath once subdir_glob is enabled in OSS
+    for target, subpath in spv_filegroups.items():
+        glsl_paths.append("$(location {})/{}".format(target, subpath))
+
+    genrule_cmd = [
+        "$(exe {})".format(gen_vulkan_spv_target),
+        "--glsl-paths {}".format(" ".join(glsl_paths)),
+        "--output-path $OUT",
+        "--glslc-path=$(exe {})".format(glslc_path),
+        "--tmp-dir-path=$OUT",
+    ]
+
+    genrule_name = "gen_{}_cpp".format(name)
+    runtime.genrule(
+        name = genrule_name,
+        outs = {
+            "{}.cpp".format(name): ["spv.cpp"],
+        },
+        cmd = " ".join(genrule_cmd),
+        default_outs = ["."],
+        labels = ["uses_dotslash"],
+    )
+
+    runtime.cxx_library(
+        name = name,
+        srcs = [
+            ":{}[{}.cpp]".format(genrule_name, name),
+        ],
+        compiler_flags = get_vulkan_compiler_flags(),
+        define_static_target = False,
+        # Static initialization is used to register shaders to the global shader registry,
+        # therefore link_whole must be True to make sure unused symbols are not discarded.
+        # @lint-ignore BUCKLINT: Avoid `link_whole=True`
+        link_whole = True,
+        # Define a soname that can be used for dynamic loading in Java, Python, etc.
+        soname = "lib{}.$(ext)".format(name),
+        exported_deps = [
+            "//executorch/backends/vulkan:vulkan_compute_api",
+        ],
+    )
+
+
+
+def define_targets():
+    runtime.filegroup(
+        name = "gpuinfo_shaders",
+        srcs = glob([
+            "glsl/*",
+        ]),
+
+    )
+
+    vulkan_spv_shader_lib(
+        name = "gpuinfo_shader_lib",
+        spv_filegroups = {
+            ":gpuinfo_shaders": "glsl",
+        },
+    )
+    runtime.cxx_binary(
+        name = "vulkan_gpuinfo",
+        srcs = glob([
+            "**/*.cpp",
+        ]),
+        headers = glob([
+            "**/*.h",
+        ]),
+        header_namespace = "/include",
+        include_directories = ["/include"],
+        platforms = ANDROID,
+        raw_headers = glob([
+            "**/*.h",
+        ]),
+        deps = [
+            ":gpuinfo_shader_lib",
+            "//executorch/backends/vulkan:vulkan_graph_runtime",
+        ],
+    )