Add test to print device information (#126)

Rbiessy · hjabird · web-flow · commit c71814f5dc76 · 2024-01-04T10:52:12.000Z
* Add test to print device information

* Do not create queue

Co-authored-by: HJA Bird &lt;9040797+hjabird@users.noreply.github.com&gt;

* Rename file and test

---------

Co-authored-by: HJA Bird &lt;9040797+hjabird@users.noreply.github.com&gt;
diff --git a/test/bench/utils/device_context.hpp b/test/bench/utils/device_context.hpp
@@ -25,55 +25,29 @@
 
 #include <benchmark/benchmark.h>
 
+#include "common/sycl_utils.hpp"
+
 void add_device_context(sycl::queue queue) {
   namespace info = sycl::info::device;
-  using sycl::info::device_type;
   sycl::device dev = queue.get_device();
   sycl::platform platform = dev.get_info<info::platform>();
 
-  std::string device_type_str;
-  switch (dev.get_info<info::device_type>()) {
-    case device_type::cpu:
-      device_type_str = "CPU";
-      break;
-    case device_type::gpu:
-      device_type_str = "GPU";
-      break;
-    case device_type::accelerator:
-      device_type_str = "accelerator";
-      break;
-    case device_type::custom:
-      device_type_str = "custom";
-      break;
-    case device_type::host:
-      device_type_str = "host";
-      break;
-    default:
-      device_type_str = "unknown";
-      break;
-  };
-
-  bool supports_double = dev.get_info<info::double_fp_config>().empty();
-
-  auto subgroup_sizes = dev.get_info<info::sub_group_sizes>();
-  std::stringstream subgroup_sizes_str;
-  subgroup_sizes_str << "[";
-  for (std::size_t i = 0; i < subgroup_sizes.size(); ++i) {
-    if (i > 0) {
-      subgroup_sizes_str << ", ";
-    }
-    subgroup_sizes_str << subgroup_sizes[i];
-  }
-  subgroup_sizes_str << "]";
+  std::string device_type_str = get_device_type(dev);
+  std::string supports_double_str = dev.has(sycl::aspect::fp64) ? "yes" : "no";
+  std::string supports_usm_str = dev.has(sycl::aspect::usm_device_allocations) ? "yes" : "no";
+  std::string subgroup_sizes_str = get_device_subgroup_sizes(dev);
+  std::string local_memory_size_str = std::to_string(dev.get_info<sycl::info::device::local_mem_size>()) + "B";
 
   benchmark::AddCustomContext("Device type", device_type_str);
   benchmark::AddCustomContext("Platform", platform.get_info<sycl::info::platform::name>());
   benchmark::AddCustomContext("Name", dev.get_info<info::name>());
   benchmark::AddCustomContext("Vendor", dev.get_info<info::vendor>());
   benchmark::AddCustomContext("Version", dev.get_info<info::version>());
   benchmark::AddCustomContext("Driver version", dev.get_info<info::driver_version>());
-  benchmark::AddCustomContext("Double supported", (supports_double ? "no" : "yes"));
-  benchmark::AddCustomContext("Subgroup sizes", subgroup_sizes_str.str());
+  benchmark::AddCustomContext("Double supported", supports_double_str);
+  benchmark::AddCustomContext("USM supported", supports_usm_str);
+  benchmark::AddCustomContext("Subgroup sizes", subgroup_sizes_str);
+  benchmark::AddCustomContext("Local memory size", local_memory_size_str);
 }
 
 #endif  // PORTFFT_TEST_BENCH_UTILS_DEVICE_CONTEXT_HPP
diff --git a/test/common/sycl_utils.hpp b/test/common/sycl_utils.hpp
@@ -22,6 +22,8 @@
 #define PORTFFT_TEST_COMMON_SYCL_UTILS_HPP
 
 #include <memory>
+#include <sstream>
+#include <string>
 
 #include <sycl/sycl.hpp>
 
@@ -40,4 +42,44 @@ inline std::shared_ptr<T> make_shared(std::size_t size, sycl::queue queue) {
   });
 }
 
+/**
+ * Return the device type as a string
+ * @param dev SYCL device
+ */
+std::string get_device_type(sycl::device dev) {
+  using sycl::info::device_type;
+  switch (dev.get_info<sycl::info::device::device_type>()) {
+    case device_type::cpu:
+      return "CPU";
+    case device_type::gpu:
+      return "GPU";
+    case device_type::accelerator:
+      return "accelerator";
+    case device_type::custom:
+      return "custom";
+    case device_type::host:
+      return "host";
+    default:
+      return "unknown";
+  };
+}
+
+/**
+ * Return the list of supported subgroup sizes as a string
+ * @param dev SYCL device
+ */
+std::string get_device_subgroup_sizes(sycl::device dev) {
+  auto subgroup_sizes = dev.get_info<sycl::info::device::sub_group_sizes>();
+  std::stringstream subgroup_sizes_str;
+  subgroup_sizes_str << "[";
+  for (std::size_t i = 0; i < subgroup_sizes.size(); ++i) {
+    if (i > 0) {
+      subgroup_sizes_str << ", ";
+    }
+    subgroup_sizes_str << subgroup_sizes[i];
+  }
+  subgroup_sizes_str << "]";
+  return subgroup_sizes_str.str();
+}
+
 #endif  // PORTFFT_TEST_COMMON_SYCL_UTILS_HPP
diff --git a/test/unit_test/CMakeLists.txt b/test/unit_test/CMakeLists.txt
@@ -36,9 +36,10 @@ set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 FetchContent_MakeAvailable(googletest)
 
 set(PORTFFT_UNIT_TESTS
-    fft_float.cpp
-    transfers.cpp
+    print_device_info.cpp
     descriptor.cpp
+    transfers.cpp
+    fft_float.cpp
 )
 if(PORTFFT_ENABLE_DOUBLE_BUILDS)
     list(APPEND PORTFFT_UNIT_TESTS
diff --git a/test/unit_test/fft_test_utils.hpp b/test/unit_test/fft_test_utils.hpp
@@ -392,18 +392,15 @@ std::enable_if_t<TestMemory == test_memory::buffer> check_fft(
  */
 template <test_memory TestMemory, typename FType, direction Dir, complex_storage Storage>
 void run_test(const test_params& params) {
-  std::vector<sycl::aspect> queue_aspects;
-  if constexpr (std::is_same_v<FType, double>) {
-    queue_aspects.push_back(sycl::aspect::fp64);
-  }
-  if constexpr (TestMemory == test_memory::usm) {
-    queue_aspects.push_back(sycl::aspect::usm_device_allocations);
-  }
+  // Use default selector to match with the device printed
   sycl::queue queue;
-  try {
-    queue = sycl::queue(sycl::aspect_selector(queue_aspects));
-  } catch (sycl::exception& e) {
-    GTEST_SKIP() << e.what();
+  sycl::device dev = queue.get_device();
+  if (std::is_same_v<FType, double> && !dev.has(sycl::aspect::fp64)) {
+    GTEST_SKIP() << "Device does not support double precision";
+    return;
+  }
+  if (TestMemory == test_memory::usm && !dev.has(sycl::aspect::usm_device_allocations)) {
+    GTEST_SKIP() << "Device does not support USM";
     return;
   }
 
diff --git a/test/unit_test/print_device_info.cpp b/test/unit_test/print_device_info.cpp
@@ -0,0 +1,54 @@
+/***************************************************************************
+ *
+ *  Copyright (C) Codeplay Software Ltd.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  Codeplay's portFFT
+ *
+ **************************************************************************/
+
+#include <gtest/gtest.h>
+
+#include "sycl_utils.hpp"
+
+/**
+ * Print information of the device selected by the default selector.
+ * Use this as a test to print the information once when using ctest.
+ */
+void print_device_info() {
+  namespace info = sycl::info::device;
+  sycl::device dev;
+  sycl::platform platform = dev.get_info<info::platform>();
+
+  std::string device_type_str = get_device_type(dev);
+  std::string supports_double_str = dev.has(sycl::aspect::fp64) ? "yes" : "no";
+  std::string supports_usm_str = dev.has(sycl::aspect::usm_device_allocations) ? "yes" : "no";
+  std::string subgroup_sizes_str = get_device_subgroup_sizes(dev);
+  auto local_memory_size = dev.get_info<sycl::info::device::local_mem_size>();
+
+  std::cout << "Running tests on:\n";
+  std::cout << "  Device type: " << device_type_str << "\n";
+  std::cout << "  Platform: " << platform.get_info<sycl::info::platform::name>() << "\n";
+  std::cout << "  Name: " << dev.get_info<info::name>() << "\n";
+  std::cout << "  Vendor: " << dev.get_info<info::vendor>() << "\n";
+  std::cout << "  Version: " << dev.get_info<info::version>() << "\n";
+  std::cout << "  Driver version: " << dev.get_info<info::driver_version>() << "\n";
+  std::cout << "  Double supported: " << supports_double_str << "\n";
+  std::cout << "  USM supported: " << supports_usm_str << "\n";
+  std::cout << "  Subgroup sizes: " << subgroup_sizes_str << "\n";
+  std::cout << "  Local memory size: " << local_memory_size << "B\n";
+  std::cout << std::endl;
+}
+
+TEST(print_info, device) { print_device_info(); }
