[lit][offloader][ninja] Add ability to toggle gpu by name (#646)

This change allows you to set an enviornment variable to pick which gpu
the offloader will use. For example say I have an Intel GPU I can do:
```
set "OFFLOADTEST_GPU_NAME=Intel(R) Arc(TM) A770 Graphics" && ninja -C ..\llvm-build\ check-hlsl-clang-d3d12
```
Or if I just want to specify the vendor I can do
```
set "OFFLOADTEST_GPU_NAME=Intel" && ninja -C ..\llvm-build\ check-hlsl-clang-d3d12
```

This was made via `llvm::regex` so you can use any casing. Say on linux
we would do

```bash
vulkaninfo --summary | grep deviceName
        deviceName         = NVIDIA GeForce RTX 4070 Ti (NVK AD104)
        deviceName         = llvmpipe (LLVM 20.1.2, 256 bits)
OFFLOADTEST_GPU_NAME=nvidia ninja -C ../llvm_builds/llvm_rel_with_debug_offload/ check-hlsl-clang-vk
OFFLOADTEST_GPU_NAME=llvmpipe ninja -C ../llvm_builds/llvm_rel_with_debug_offload/ check-hlsl-clang-vk
```

I am also adding a way to use the adapter index because in testing I
found typing out even just the substring can be more annoying than a
single char for the gpu index. The index is just the order we see them
in the device array.

I am also adding the ability to toggle between vulkan drivers on the
mac. To do this we just needed to encode the driver name into the
Description. Since `KosmicKrisp` is apple silicon only I limit its usage
to `if defined(__APPLE__) && defined(__aarch64__)`.

```bash
OFFLOADTEST_GPU_NAME=KosmicKrisp ninja -C ../builds/llvm_relwithdebinfo_offload check-hlsl-clang-vk
```
This change was useful for me to pick between multiple discrete gpus on
a single rig, egpus, and integrated gpus. It works now for both DirectX
and Vulkan devices.

Author: farzonl

lib/API/VK/Device.cpp

@@ -268,6 +268,8 @@ class VKDevice : public offloadtest::Device {
 private:
   VkPhysicalDevice Device;
   VkPhysicalDeviceProperties Props;
+  VkPhysicalDeviceProperties2 Props2;
+  VkPhysicalDeviceDriverProperties DriverProps;
   Capabilities Caps;
   using LayerVector = std::vector<VkLayerProperties>;
   LayerVector Layers;
@@ -377,9 +379,20 @@ class VKDevice : public offloadtest::Device {
 public:
   VKDevice(VkPhysicalDevice D) : Device(D) {
     vkGetPhysicalDeviceProperties(Device, &Props);
-    const uint64_t StrSz =
+    const uint64_t DeviceNameSz =
         strnlen(Props.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
-    Description = std::string(Props.deviceName, StrSz);
+    Description = std::string(Props.deviceName, DeviceNameSz);
+#if defined(__APPLE__) && defined(__aarch64__)
+    DriverProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+    DriverProps.pNext = nullptr;
+    Props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+    Props2.pNext = &DriverProps;
+    vkGetPhysicalDeviceProperties2(Device, &Props2);
+    const uint64_t DriverNameSz =
+        strnlen(DriverProps.driverName, VK_MAX_DRIVER_NAME_SIZE);
+    Description +=
+        " (" + std::string(DriverProps.driverName, DriverNameSz) + ")";
+#endif
   }
   VKDevice(const VKDevice &) = default;
 

test/lit.cfg.py

@@ -41,6 +41,11 @@
 # Tweak the PATH to include the tools dir.
 llvm_config.with_environment("PATH", config.llvm_tools_dir, append_path=True)
 
+# Environment equivalents (useful for ninja):
+#   OFFLOADTEST_GPU_NAME
+GPUName = os.environ.get("OFFLOADTEST_GPU_NAME", "")
+ShouldSearchByGPuName = len(GPUName) > 0
+
 tools = [
     ToolSubst("FileCheck", FindTool("FileCheck")),
     ToolSubst("split-file", FindTool("split-file")),
@@ -138,7 +143,8 @@ def setDeviceFeatures(config, device, compiler):
     offloader_args.append("-debug-layer")
 if config.offloadtest_enable_validation:
     offloader_args.append("-validation-layer")
-
+if ShouldSearchByGPuName:
+    offloader_args.extend([f'-adapter-regex="{GPUName}"'])
 tools.append(
     ToolSubst("%offloader", command=FindTool("offloader"), extra_args=offloader_args)
 )
@@ -197,19 +203,29 @@ def setDeviceFeatures(config, device, compiler):
 query_string = subprocess.check_output(api_query)
 devices = yaml.safe_load(query_string)
 target_device = None
-
 # Find the right device to configure against
+pattern = re.compile(GPUName, re.IGNORECASE)
 for device in devices["Devices"]:
     is_warp = "Microsoft Basic Render Driver" in device["Description"]
+    is_gpu_name_match = bool(pattern.search(device["Description"]))
     if device["API"] == "DirectX" and config.offloadtest_enable_d3d12:
-        if is_warp and config.offloadtest_test_warp:
+        if ShouldSearchByGPuName and is_gpu_name_match:
+            target_device = device
+        elif is_warp and config.offloadtest_test_warp:
             target_device = device
-        elif not is_warp and not config.offloadtest_test_warp:
+        elif (
+            not ShouldSearchByGPuName
+            and not is_warp
+            and not config.offloadtest_test_warp
+        ):
             target_device = device
     if device["API"] == "Metal" and config.offloadtest_enable_metal:
         target_device = device
     if device["API"] == "Vulkan" and config.offloadtest_enable_vulkan:
-        target_device = device
+        if ShouldSearchByGPuName and is_gpu_name_match:
+            target_device = device
+        elif not ShouldSearchByGPuName:
+            target_device = device
     # Bail from the loop if we found a device that matches what we're looking for.
     if target_device:
         break

tools/offloader/offloader.cpp

@@ -63,6 +63,12 @@ static cl::opt<bool> Validation("validation-layer",
 
 static cl::opt<bool> UseWarp("warp", cl::desc("Use warp"));
 
+static cl::opt<std::string> AdapterRegex(
+    "adapter-regex",
+    cl::desc(
+        "Case-insensitive regular expression to match GPU adapter description"),
+    cl::value_desc("<regex>"), cl::init(""));
+
 static std::unique_ptr<MemoryBuffer> readFile(const std::string &Path) {
   const ExitOnError ExitOnErr("gpu-exec: error: ");
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
@@ -84,6 +90,12 @@ int main(int ArgC, char **ArgV) {
   return 0;
 }
 
+static bool matchesRegexIgnoreCase(StringRef GPUDescription,
+                                   StringRef SearchExpr) {
+  const llvm::Regex R(SearchExpr, llvm::Regex::IgnoreCase);
+  return R.isValid() && R.match(GPUDescription);
+}
+
 int run() {
   const ExitOnError ExitOnErr("gpu-exec: error: ");
   const DeviceConfig Config = {Debug, Validation};
@@ -141,6 +153,9 @@ int run() {
       continue;
     if (UseWarp && D->getDescription() != "Microsoft Basic Render Driver")
       continue;
+    if (!AdapterRegex.empty() &&
+        !matchesRegexIgnoreCase(D->getDescription(), AdapterRegex))
+      continue;
     ExitOnErr(D->executeProgram(PipelineDesc));
 
     // check the results