[SYCL][UnitTest] Test device global initializer cleanup on program removal

Author: kweronsx

sycl/source/detail/context_impl.hpp

@@ -200,6 +200,11 @@ class context_impl : public std::enable_shared_from_this<context_impl> {
   removeDeviceGlobalInitializer(ur_program_handle_t Program,
                                 const RTDeviceBinaryImage *BinImage = nullptr);
 
+  /// Returns the number of programs with device globals not yet initialized.
+  size_t getDeviceGlobalNotInitializedCnt() const {
+    return MDeviceGlobalNotInitializedCnt.load(std::memory_order_relaxed);
+  }
+
   /// Initializes device globals for a program on the associated queue.
   std::vector<ur_event_handle_t>
   initializeDeviceGlobals(ur_program_handle_t NativePrg, queue_impl &QueueImpl,

sycl/unittests/program_manager/Cleanup.cpp

@@ -369,4 +369,65 @@ TEST(ImageRemoval, NativePrograms) {
   EXPECT_TRUE(PM.getNativePrograms().count(ProgramA) > 0);
   EXPECT_TRUE(PM.getNativePrograms().count(ProgramB) > 0);
 }
+
+// Verify that removeImages cleans up device global initializer entries so that
+// a reused program handle does not collide with stale state.
+TEST(ImageRemoval, DeviceGlobalInitializerCleanupOnRemoveImages) {
+  ProgramManagerExposed PM;
+
+  // An image with device globals that we will add and then remove.
+  sycl_device_binary_struct NativeImagesForRemoval[ImagesToRemove.size()];
+  sycl_device_binaries_struct TestBinaries;
+  convertAndAddImages(PM, ImagesToRemove, NativeImagesForRemoval, TestBinaries);
+
+  PM.addOrInitDeviceGlobalEntry(&DeviceGlobalC,
+                                generateRefName("C", "DeviceGlobal").c_str());
+
+  sycl::platform Plt = sycl::platform();
+  const sycl::device Dev = Plt.get_devices()[0];
+  sycl::queue Queue{Dev};
+  auto Ctx = Queue.get_context();
+  auto CtxImpl = sycl::detail::getSyclObjImpl(Ctx);
+
+  // Grab the RTDeviceBinaryImage* for the "C" image that was just added.
+  ASSERT_EQ(PM.getDeviceImages().size(), 1u);
+  const sycl::detail::RTDeviceBinaryImage *BinImg =
+      PM.getDeviceImages().begin()->second.get();
+
+  ur_program_handle_t FakeProgram =
+      reinterpret_cast<ur_program_handle_t>(static_cast<uintptr_t>(0xDEADBEEF));
+
+  // Register the fake program in NativePrograms so that removeImages can find
+  // it and trigger removeDeviceGlobalInitializer, mirroring what
+  // ProgramManager::build() does.
+  PM.getNativePrograms().insert({FakeProgram, {CtxImpl, BinImg}});
+
+  CtxImpl->addDeviceGlobalInitializer(FakeProgram, CtxImpl->getDevices(),
+                                      BinImg);
+
+  EXPECT_EQ(CtxImpl->getDeviceGlobalNotInitializedCnt(), 1u)
+      << "Counter should be 1 after adding the initializer";
+
+  // Simulate program teardown.
+  PM.removeImages(&TestBinaries);
+
+  EXPECT_EQ(CtxImpl->getDeviceGlobalNotInitializedCnt(), 0u)
+      << "Counter should be 0 after removeImages cleans up the initializer";
+
+  // Re-add the same BinImg under the same (reused) program handle — this is
+  // what happens when the adapter allocates a fresh program with the same
+  // handle value. The counter must go back up to 1 cleanly.
+  sycl_device_binary_struct NativeImagesSecond[ImagesToRemove.size()];
+  sycl_device_binaries_struct TestBinariesSecond;
+  convertAndAddImages(PM, ImagesToRemove, NativeImagesSecond,
+                      TestBinariesSecond);
+  const sycl::detail::RTDeviceBinaryImage *BinImgSecond =
+      PM.getDeviceImages().begin()->second.get();
+
+  CtxImpl->addDeviceGlobalInitializer(FakeProgram, CtxImpl->getDevices(),
+                                      BinImgSecond);
+
+  EXPECT_EQ(CtxImpl->getDeviceGlobalNotInitializedCnt(), 1u)
+      << "Counter should be 1 after re-registering the reused program handle";
+}
 } // anonymous namespace