Move Fence creation logic into static create() factories

Make constructors private and expose static create() methods on
DXFence, VulkanFence, and MTLFence that return
Expected<unique_ptr<...>>. This keeps all platform-specific resource
creation encapsulated in each type, matching the pattern used for
CommandBuffer.

Each Device::createFence override now simply delegates to the
respective Fence::create(). Also adds native accessors
(getNativeFence, getNativeSemaphore, getNativeEvent) to replace direct
member access.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: MarijnS95

lib/API/DX/Device.cpp

@@ -294,6 +294,13 @@ class DXBuffer : public offloadtest::Buffer {
 };
 
 class DXFence : public offloadtest::Fence {
+#ifdef _WIN32
+  DXFence(ComPtr<ID3D12Fence> Fence, HANDLE Event, llvm::StringRef Name)
+#else // WSL
+  DXFence(ComPtr<ID3D12Fence> Fence, int Event, llvm::StringRef Name)
+#endif
+      : Name(Name), Fence(Fence), Event(Event) {}
+
 public:
   std::string Name;
   ComPtr<ID3D12Fence> Fence;
@@ -303,6 +310,35 @@ class DXFence : public offloadtest::Fence {
   int Event;
 #endif
 
+  static llvm::Expected<std::unique_ptr<DXFence>>
+  create(ID3D12Device *Device, llvm::StringRef Name) {
+    ComPtr<ID3D12Fence> Fence;
+    if (auto Err = HR::toError(
+            Device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&Fence)),
+            "Failed to create Fence."))
+      return Err;
+
+#ifdef _WIN32
+    HANDLE Event = CreateEventA(nullptr, false, false, nullptr);
+    if (!Event)
+#else // WSL
+    int Event = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
+    if (Event == -1)
+#endif
+      return llvm::createStringError(std::errc::device_or_resource_busy,
+                                     "Failed to create event.");
+
+    return std::make_unique<DXFence>(DXFence(std::move(Fence), Event, Name));
+  }
+
+  ~DXFence() {
+#ifdef _WIN32
+    CloseHandle(Event);
+#else // WSL
+    close(Event);
+#endif
+  }
+
   uint64_t getFenceValue() override { return Fence->GetCompletedValue(); }
 
   llvm::Error waitForCompletion(uint64_t SignalValue) override {
@@ -330,21 +366,6 @@ class DXFence : public offloadtest::Fence {
 #endif
     return llvm::Error::success();
   }
-
-#ifdef _WIN32
-  DXFence(ComPtr<ID3D12Fence> Fence, HANDLE Event, llvm::StringRef Name)
-#else // WSL
-  DXFence(ComPtr<ID3D12Fence> Fence, int Event, llvm::StringRef Name)
-#endif
-      : Name(Name), Fence(Fence), Event(Event) {}
-
-  ~DXFence() {
-#ifdef _WIN32
-    CloseHandle(Event);
-#else // WSL
-    close(Event);
-#endif
-  }
 };
 
 class DXQueue : public offloadtest::Queue {
@@ -429,23 +450,7 @@ class DXDevice : public offloadtest::Device {
 
   llvm::Expected<std::unique_ptr<offloadtest::Fence>>
   createFence(llvm::StringRef Name) override {
-    ComPtr<ID3D12Fence> Fence;
-    if (auto Err = HR::toError(
-            Device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&Fence)),
-            "Failed to create Fence."))
-      return Err;
-
-#ifdef _WIN32
-    HANDLE Event = CreateEventA(nullptr, false, false, nullptr);
-    if (!Event)
-#else // WSL
-    int Event = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
-    if (Event == -1)
-#endif
-      return llvm::createStringError(std::errc::device_or_resource_busy,
-                                     "Failed to create event.");
-
-    return std::make_unique<DXFence>(Fence, Event, Name);
+    return DXFence::create(Device.Get(), Name);
   }
 
   llvm::Expected<std::shared_ptr<offloadtest::Buffer>>

lib/API/MTL/MTLDevice.cpp

@@ -84,10 +84,27 @@ class MTLQueue : public offloadtest::Queue {
 };
 
 class MTLFence : public offloadtest::Fence {
+  MTLFence(MTL::SharedEvent *Event, llvm::StringRef Name)
+      : Name(Name), Event(Event) {}
+
 public:
   std::string Name;
   MTL::SharedEvent *Event;
 
+  static llvm::Expected<std::unique_ptr<MTLFence>>
+  create(MTL::Device *Device, llvm::StringRef Name) {
+    MTL::SharedEvent *Event = Device->newSharedEvent();
+    if (!Event)
+      return llvm::createStringError(std::errc::device_or_resource_busy,
+                                     "Failed to create shared event.");
+    return std::make_unique<MTLFence>(MTLFence(Event, Name));
+  }
+
+  ~MTLFence() {
+    if (Event)
+      Event->release();
+  }
+
   uint64_t getFenceValue() override { return Event->signaledValue(); }
 
   llvm::Error waitForCompletion(uint64_t SignalValue) override {
@@ -96,14 +113,6 @@ class MTLFence : public offloadtest::Fence {
                                      "Timed out waiting on shared event.");
     return llvm::Error::success();
   }
-
-  MTLFence(MTL::SharedEvent *Event, llvm::StringRef Name)
-      : Name(Name), Event(Event) {}
-
-  ~MTLFence() {
-    if (Event)
-      Event->release();
-  }
 };
 
 class MTLBuffer : public offloadtest::Buffer {
@@ -600,11 +609,7 @@ class MTLDevice : public offloadtest::Device {
 
   llvm::Expected<std::unique_ptr<offloadtest::Fence>>
   createFence(llvm::StringRef Name) override {
-    MTL::SharedEvent *Event = Device->newSharedEvent();
-    if (!Event)
-      return llvm::createStringError(std::errc::device_or_resource_busy,
-                                     "Failed to create shared event.");
-    return std::make_unique<MTLFence>(Event, Name);
+    return MTLFence::create(Device, Name);
   }
 
   llvm::Expected<std::shared_ptr<offloadtest::Buffer>>

lib/API/VK/Device.cpp

@@ -392,11 +392,35 @@ class VulkanBuffer : public offloadtest::Buffer {
 };
 
 class VulkanFence : public offloadtest::Fence {
+  VulkanFence(VkDevice Device, VkSemaphore Semaphore, llvm::StringRef Name)
+      : Name(Name), Device(Device), Semaphore(Semaphore) {}
+
 public:
   std::string Name;
   VkDevice Device;
   VkSemaphore Semaphore;
 
+  static llvm::Expected<std::unique_ptr<VulkanFence>>
+  create(VkDevice Device, llvm::StringRef Name) {
+    VkSemaphoreTypeCreateInfo TypeCreateInfo = {};
+    TypeCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
+    TypeCreateInfo.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
+
+    VkSemaphoreCreateInfo CreateInfo = {};
+    CreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+    CreateInfo.pNext = &TypeCreateInfo;
+
+    VkSemaphore Semaphore = VK_NULL_HANDLE;
+    if (vkCreateSemaphore(Device, &CreateInfo, nullptr, &Semaphore))
+      return llvm::createStringError(std::errc::device_or_resource_busy,
+                                     "Failed to create Semaphore.");
+
+    return std::make_unique<VulkanFence>(
+        VulkanFence(Device, Semaphore, Name));
+  }
+
+  ~VulkanFence() { vkDestroySemaphore(Device, Semaphore, nullptr); }
+
   uint64_t getFenceValue() override {
     uint64_t Value = 0;
     [[maybe_unused]] VkResult Ret =
@@ -418,11 +442,6 @@ class VulkanFence : public offloadtest::Fence {
 
     return llvm::Error::success();
   }
-
-  VulkanFence(VkDevice Device, VkSemaphore Semaphore, llvm::StringRef Name)
-      : Name(Name), Device(Device), Semaphore(Semaphore) {}
-
-  ~VulkanFence() { vkDestroySemaphore(Device, Semaphore, nullptr); }
 };
 
 class VulkanQueue : public offloadtest::Queue {
@@ -687,20 +706,7 @@ class VulkanDevice : public offloadtest::Device {
 
   llvm::Expected<std::unique_ptr<offloadtest::Fence>>
   createFence(llvm::StringRef Name) override {
-    VkSemaphoreTypeCreateInfo TypeCreateInfo = {};
-    TypeCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
-    TypeCreateInfo.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
-
-    VkSemaphoreCreateInfo CreateInfo = {};
-    CreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-    CreateInfo.pNext = &TypeCreateInfo;
-
-    VkSemaphore Semaphore = VK_NULL_HANDLE;
-    if (vkCreateSemaphore(Device, &CreateInfo, nullptr, &Semaphore))
-      return llvm::createStringError(std::errc::device_or_resource_busy,
-                                     "Failed to create Semaphore.");
-
-    return std::make_unique<VulkanFence>(Device, Semaphore, Name);
+    return VulkanFence::create(Device, Name);
   }
 
   llvm::Expected<std::shared_ptr<offloadtest::Buffer>>