From ba8132345cbae5b749b4a01deda732ad6f8251a0 Mon Sep 17 00:00:00 2001 From: Gangzheng Tong Date: Mon, 22 Sep 2025 15:46:42 -0700 Subject: Add RHI Device Caching and Test Prefix Exclusion (#8448) # Add RHI Device Caching and Test Prefix Exclusion ## Summary This PR introduces two key improvements to the Slang test infrastructure: 1. **RHI Device Caching**: Implements device caching to significantly speed up test execution by reusing graphics devices across tests, **RHI Device Caching reduces slang-test execution time from ~15 minutes to ~5 minutes in Windows release builds** 2. **Test Prefix Exclusion**: Adds `-exclude-prefix` option to skip tests matching specified path prefixes ## Changes ### RHI Device Caching - **New `DeviceCache` class** (`slang-test-device-cache.h/cpp`): Thread-safe device cache with LRU eviction (max 10 devices) - **Cache control option**: `-cache-rhi-device` flag in both `slang-test` and `render-test` - Default: **enabled** in slang-test, **disabled** in render-test when run standalone - Automatically skips caching for CUDA devices (due to driver issues) - **Performance benefit**: Eliminates expensive device creation/destruction cycles, especially beneficial for Vulkan on Tegra platforms ### Test Prefix Exclusion - **New `-exclude-prefix ` option** in slang-test - Allows excluding entire test directories or patterns from execution - Complements existing `-category` and individual test filtering options ### Usage Examples ```bash # Enable device caching (default) slang-test # Disable device caching slang-test -cache-rhi-device false # Exclude tests from specific directories slang-test -exclude-prefix tests/problematic/ slang-test -exclude-prefix tests/slow/ -exclude-prefix tests/experimental/ ``` This change should significantly improve test execution performance, particularly in CI environments with frequent device operations. This is needed for running the GPU test in aarch64, where repeated device creation/destroy is causing driver issues. Needed by: https://github.com/shader-slang/slang/issues/8346 --------- Co-authored-by: slangbot Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com> --- tools/render-test/slang-test-device-cache.cpp | 160 ++++++++++++++++++++++++++ 1 file changed, 160 insertions(+) create mode 100644 tools/render-test/slang-test-device-cache.cpp (limited to 'tools/render-test/slang-test-device-cache.cpp') diff --git a/tools/render-test/slang-test-device-cache.cpp b/tools/render-test/slang-test-device-cache.cpp new file mode 100644 index 000000000..a486ee3f3 --- /dev/null +++ b/tools/render-test/slang-test-device-cache.cpp @@ -0,0 +1,160 @@ +#include "slang-test-device-cache.h" + +#include + +// Static member accessor functions (Meyer's singleton pattern) +// This ensures proper destruction order - function-local statics are destroyed +// in reverse order of first access, avoiding the static destruction order fiasco +std::mutex& DeviceCache::getMutex() +{ + static std::mutex instance; + return instance; +} + +std::unordered_map< + DeviceCache::DeviceCacheKey, + DeviceCache::CachedDevice, + DeviceCache::DeviceCacheKeyHash>& +DeviceCache::getDeviceCache() +{ + static std::unordered_map instance; + return instance; +} + +uint64_t& DeviceCache::getNextCreationOrder() +{ + static uint64_t instance = 0; + return instance; +} + +bool DeviceCache::DeviceCacheKey::operator==(const DeviceCacheKey& other) const +{ + return deviceType == other.deviceType && enableValidation == other.enableValidation && + enableRayTracingValidation == other.enableRayTracingValidation && + profileName == other.profileName && requiredFeatures == other.requiredFeatures; +} + +std::size_t DeviceCache::DeviceCacheKeyHash::operator()(const DeviceCacheKey& key) const +{ + std::size_t h1 = std::hash{}(static_cast(key.deviceType)); + std::size_t h2 = std::hash{}(key.enableValidation); + std::size_t h3 = std::hash{}(key.enableRayTracingValidation); + std::size_t h4 = std::hash{}(key.profileName); + + std::size_t h5 = 0; + for (const auto& feature : key.requiredFeatures) + { + h5 ^= std::hash{}(feature) + 0x9e3779b9 + (h5 << 6) + (h5 >> 2); + } + + return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 3) ^ (h5 << 4); +} + +DeviceCache::CachedDevice::CachedDevice() + : creationOrder(0) +{ +} + +void DeviceCache::evictOldestDeviceIfNeeded() +{ + auto& deviceCache = getDeviceCache(); + if (deviceCache.size() < MAX_CACHED_DEVICES) + return; + + // Find the oldest device to evict + auto oldestIt = deviceCache.end(); + uint64_t oldestCreationOrder = UINT64_MAX; + + for (auto it = deviceCache.begin(); it != deviceCache.end(); ++it) + { + if (it->second.creationOrder < oldestCreationOrder) + { + oldestCreationOrder = it->second.creationOrder; + oldestIt = it; + } + } + + // Remove the oldest device - ComPtr will handle the actual device release + if (oldestIt != deviceCache.end()) + { + deviceCache.erase(oldestIt); + } +} + +SlangResult DeviceCache::acquireDevice(const rhi::DeviceDesc& desc, rhi::IDevice** outDevice) +{ + if (!outDevice) + return SLANG_E_INVALID_ARG; + + *outDevice = nullptr; + + // Skip caching for CUDA devices due to crashes + if (desc.deviceType == rhi::DeviceType::CUDA) + { + return rhi::getRHI()->createDevice(desc, outDevice); + } + + std::lock_guard lock(getMutex()); + auto& deviceCache = getDeviceCache(); + auto& nextCreationOrder = getNextCreationOrder(); + + // Create cache key + DeviceCacheKey key; + key.deviceType = desc.deviceType; + key.enableValidation = desc.enableValidation; + key.enableRayTracingValidation = desc.enableRayTracingValidation; + key.profileName = desc.slang.targetProfile ? desc.slang.targetProfile : "Unknown"; + + // Add required features to key + for (int i = 0; i < desc.requiredFeatureCount; ++i) + { + key.requiredFeatures.push_back(desc.requiredFeatures[i]); + } + std::sort(key.requiredFeatures.begin(), key.requiredFeatures.end()); + + // Evict oldest device if we've reached the limit + evictOldestDeviceIfNeeded(); + + // Check if we have a cached device + auto it = deviceCache.find(key); + if (it != deviceCache.end()) + { + // Return the cached device - COM reference counting handles the references + *outDevice = it->second.device.get(); + if (*outDevice) + { + (*outDevice)->addRef(); + return SLANG_OK; + } + } + + // Create new device + Slang::ComPtr device; + auto result = rhi::getRHI()->createDevice(desc, device.writeRef()); + if (SLANG_FAILED(result)) + { + return result; + } + + // Cache the device + CachedDevice& cached = deviceCache[key]; + cached.device = device; + cached.creationOrder = nextCreationOrder++; + + // Return the device with proper reference counting + *outDevice = device.get(); + if (*outDevice) + { + (*outDevice)->addRef(); + } + + return SLANG_OK; +} + + +void DeviceCache::cleanCache() +{ + std::lock_guard lock(getMutex()); + auto& deviceCache = getDeviceCache(); + deviceCache.clear(); +} -- cgit v1.2.3