test(Sysman): Test to validate memory bandwidth counters with workload

Related-To: VLCLJ-2505

Signed-off-by: Aviral Nigam <[email protected]>

Author: aviralni

conformance_tests/sysman/test_sysman_memory/src/test_sysman_memory.cpp

@@ -224,6 +224,53 @@ uint64_t get_free_memory_state(ze_device_handle_t device) {
   return total_free_memory;
 }
 
+static void workload_for_device(ze_device_handle_t device) {
+  int m, k, n;
+  m = k = n = 5000;
+  std::vector<float> a(m * k, 1);
+  std::vector<float> b(k * n, 1);
+  std::vector<float> c(m * n, 0);
+  void *a_buffer = lzt::allocate_host_memory(m * k * sizeof(float));
+  void *b_buffer = lzt::allocate_host_memory(k * n * sizeof(float));
+  void *c_buffer = lzt::allocate_host_memory(m * n * sizeof(float));
+  ze_module_handle_t module =
+      lzt::create_module(device, "sysman_matrix_multiplication.spv",
+                         ZE_MODULE_FORMAT_IL_SPIRV, nullptr, nullptr);
+  ze_kernel_handle_t function =
+      lzt::create_function(module, "sysman_matrix_multiplication");
+  lzt::set_group_size(function, 16, 16, 1);
+  lzt::set_argument_value(function, 0, sizeof(a_buffer), &a_buffer);
+  lzt::set_argument_value(function, 1, sizeof(b_buffer), &b_buffer);
+  lzt::set_argument_value(function, 2, sizeof(m), &m);
+  lzt::set_argument_value(function, 3, sizeof(k), &k);
+  lzt::set_argument_value(function, 4, sizeof(n), &n);
+  lzt::set_argument_value(function, 5, sizeof(c_buffer), &c_buffer);
+  ze_command_list_handle_t cmd_list = lzt::create_command_list(device);
+  std::memcpy(a_buffer, a.data(), a.size() * sizeof(float));
+  std::memcpy(b_buffer, b.data(), b.size() * sizeof(float));
+  lzt::append_barrier(cmd_list, nullptr, 0, nullptr);
+  const int group_count_x = m / 16;
+  const int group_count_y = n / 16;
+  ze_group_count_t tg;
+  tg.groupCountX = group_count_x;
+  tg.groupCountY = group_count_y;
+  tg.groupCountZ = 1;
+  zeCommandListAppendLaunchKernel(cmd_list, function, &tg, nullptr, 0, nullptr);
+  lzt::append_barrier(cmd_list, nullptr, 0, nullptr);
+  lzt::close_command_list(cmd_list);
+  ze_command_queue_handle_t cmd_q = lzt::create_command_queue(device);
+  lzt::execute_command_lists(cmd_q, 1, &cmd_list, nullptr);
+  lzt::synchronize(cmd_q, UINT64_MAX);
+  std::memcpy(c.data(), c_buffer, c.size() * sizeof(float));
+  lzt::destroy_command_queue(cmd_q);
+  lzt::destroy_command_list(cmd_list);
+  lzt::destroy_function(function);
+  lzt::free_memory(a_buffer);
+  lzt::free_memory(b_buffer);
+  lzt::free_memory(c_buffer);
+  lzt::destroy_module(module);
+}
+
 ze_result_t copy_workload(ze_device_handle_t device,
                           ze_device_mem_alloc_desc_t *device_desc,
                           void *src_ptr, void *dst_ptr, int32_t local_size) {
@@ -408,4 +455,56 @@ TEST_F(
     memoryThread.join();
   }
 }
+
+TEST_F(MEMORY_TEST,
+       GivenWorkloadWhenQueryingMemoryBandwidthCountersThenCountersIncrease) {
+  for (auto device : devices) {
+    uint32_t count = 0;
+    auto mem_handles = lzt::get_mem_handles(device, count);
+
+    if (count == 0) {
+      LOG_WARNING << "No memory handles found on this device!";
+      continue;
+    }
+
+    ze_device_properties_t deviceProperties = {
+        ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, nullptr};
+#ifdef USE_ZESINIT
+    auto sysman_device_properties = lzt::get_sysman_device_properties(device);
+    ze_device_handle_t core_device =
+        lzt::get_core_device_by_uuid(sysman_device_properties.core.uuid.id);
+    EXPECT_NE(core_device, nullptr);
+    device = core_device;
+#endif // USE_ZESINIT
+    EXPECT_EQ(ZE_RESULT_SUCCESS,
+              zeDeviceGetProperties(device, &deviceProperties));
+    std::cout << "test device name " << deviceProperties.name << " uuid "
+              << lzt::to_string(deviceProperties.uuid);
+
+    for (auto mem_handle : mem_handles) {
+      ASSERT_NE(nullptr, mem_handle);
+
+      // Get initial bandwidth counters
+      zes_mem_bandwidth_t bandwidth_before = {};
+      EXPECT_EQ(ZE_RESULT_SUCCESS,
+                zesMemoryGetBandwidth(mem_handle, &bandwidth_before));
+
+      // Run the workload
+      ze_result_t result = workload_for_device(device);
+      EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+
+      // Get bandwidth counters after workload
+      zes_mem_bandwidth_t bandwidth_after = {};
+      EXPECT_EQ(ZE_RESULT_SUCCESS,
+                zesMemoryGetBandwidth(mem_handle, &bandwidth_after));
+
+      // Validate that read/write counters have increased
+      EXPECT_GE(bandwidth_after.readCounter, bandwidth_before.readCounter)
+          << "Read counter did not increase after workload";
+      EXPECT_GE(bandwidth_after.writeCounter, bandwidth_before.writeCounter)
+          << "Write counter did not increase after workload";
+      EXPECT_GE(bandwidth_after.maxBandwidth, bandwidth_before.maxBandwidth);
+    }
+  }
+}
 } // namespace