ROCm · cderb · Apr 23, 2026 · Apr 15, 2026 · Apr 15, 2026 · Apr 15, 2026
@@ -55,6 +55,8 @@ add_library(
     FlatbufferUtilities.cpp
     plugin/EnginePlugin.cpp
     plugin/EnginePluginResourceManager.cpp
+    plugin/HeuristicPlugin.cpp
+    plugin/HeuristicPluginResourceManager.cpp
     plugin/PluginCore.cpp
     plugin/SharedLibrary.cpp
     utilities/EngineOrdering.cpp

@@ -8,6 +8,7 @@ using namespace hipdnn_backend::plugin;
 
 hipdnnHandle::hipdnnHandle()
     : _pluginResourceManager(EnginePluginResourceManager::create())
+    , _heuristicPluginResourceManager(HeuristicPluginResourceManager::create())
 {
 }
 
@@ -27,6 +28,12 @@ std::shared_ptr<EnginePluginResourceManager> hipdnnHandle::getPluginResourceMana
     return _pluginResourceManager;
 }
 
+std::shared_ptr<HeuristicPluginResourceManager>
+    hipdnnHandle::getHeuristicPluginResourceManager() const
+{
+    return _heuristicPluginResourceManager;
+}
+
 size_t hipdnnHandle::getEngineCount() const
 {
     return _pluginResourceManager->getEngineCount();

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "plugin/EnginePluginResourceManager.hpp"
+#include "plugin/HeuristicPluginResourceManager.hpp"
 #include <cstdint>
 #include <hip/hip_runtime.h>
 #include <memory>
@@ -20,13 +21,17 @@ struct hipdnnHandle // NOLINT
     virtual hipStream_t getStream() const;
     virtual std::shared_ptr<hipdnn_backend::plugin::EnginePluginResourceManager>
         getPluginResourceManager() const;
+    virtual std::shared_ptr<hipdnn_backend::plugin::HeuristicPluginResourceManager>
+        getHeuristicPluginResourceManager() const;
     virtual size_t getEngineCount() const;
     virtual std::vector<hipdnn_backend::plugin::EngineInfo> getEngineInfos() const;
     virtual std::string toString() const;
 
 private:
     hipStream_t _stream = nullptr;
     std::shared_ptr<hipdnn_backend::plugin::EnginePluginResourceManager> _pluginResourceManager;
+    std::shared_ptr<hipdnn_backend::plugin::HeuristicPluginResourceManager>
+        _heuristicPluginResourceManager;
 };
 
 template <>

@@ -49,6 +49,16 @@
             hipdnn_backend::logging::detail::K_BACKEND_LOGGER_COMPONENT_NAME,    \
             hipdnn_backend::logging::detail::formatBackendMessage(__VA_ARGS__)); \
     } while(0)
+
+// DEBUG logging - use INFO level since DEBUG doesn't exist in SDK
+#define HIPDNN_BACKEND_LOG_DEBUG(...)                                            \
+    do                                                                           \
+    {                                                                            \
+        hipdnn_backend::logging::initialize();                                   \
+        HIPDNN_SDK_LOG_INFO_WITH_COMPONENT(                                      \
+            hipdnn_backend::logging::detail::K_BACKEND_LOGGER_COMPONENT_NAME,    \
+            hipdnn_backend::logging::detail::formatBackendMessage(__VA_ARGS__)); \
+    } while(0)
 #endif // HIPDNN_BACKEND_COMPILATION
 
 namespace hipdnn_backend::logging

@@ -27,76 +27,55 @@ namespace plugin
 namespace
 {
 
-struct PluginLoadingConfig
+// Static storage for engine plugin configuration
+std::mutex gEngineMutex;
+PluginLoadingConfig gEngineConfig;
+std::weak_ptr<EnginePluginManager> gEngineWeakPtr;
+std::shared_ptr<EnginePluginManager> gEnginePersistentPtr;
+std::atomic<bool> gEngineShutdownFlag{false};
+
+// Register atexit handler to set shutdown flag
+struct EnginePluginShutdownRegistrar
 {
-    std::set<std::filesystem::path> paths;
-    hipdnnPluginLoadingMode_ext_t mode = HIPDNN_DEFAULT_PLUGIN_LOADING_MODE;
-    hipdnnPluginUnloadingMode_ext_t unloadingMode = HIPDNN_DEFAULT_PLUGIN_UNLOADING_MODE;
+    EnginePluginShutdownRegistrar()
+    {
+        std::atexit([]() { gEngineShutdownFlag.store(true, std::memory_order_release); });
+    }
 };
 
-std::mutex pluginMutex;
-PluginLoadingConfig pluginConfig;
-std::weak_ptr<EnginePluginManager> pmPtr;
-// Keeps EnginePluginManager alive in lazy unloading mode
-std::shared_ptr<EnginePluginManager> persistentPmPtr;
+EnginePluginShutdownRegistrar gEngineShutdownRegistrar;
 
 } // namespace
 
-void EnginePluginResourceManager::setPluginLogLevel(hipdnnSeverity_t level)
+// Static accessor implementations for CRTP base class
+std::mutex& EnginePluginResourceManager::getMutex()
 {
-    const std::lock_guard<std::mutex> lock(pluginMutex);
-    if(auto pm = pmPtr.lock())
-    {
-        for(const auto& plugin : pm->getPlugins())
-        {
-            auto status = plugin->setLogLevel(level);
-            if(status != HIPDNN_PLUGIN_STATUS_SUCCESS)
-            {
-                HIPDNN_BACKEND_LOG_WARN("Failed to set log level for plugin '{}': status {}",
-                                        plugin->name(),
-                                        static_cast<int>(status));
-            }
-        }
-    }
+    return gEngineMutex;
 }
 
-void EnginePluginResourceManager::setPluginPaths(
-    const std::vector<std::filesystem::path>& pluginPaths,
-    hipdnnPluginLoadingMode_ext_t loadingMode)
+PluginLoadingConfig& EnginePluginResourceManager::getConfig()
 {
-    const std::lock_guard<std::mutex> lock(pluginMutex);
-
-    auto newPathsSet = std::set<std::filesystem::path>{pluginPaths.begin(), pluginPaths.end()};
-    if(pluginConfig.paths == newPathsSet && pluginConfig.mode == loadingMode)
-    {
-        return;
-    }
-
-    // Clear persistent pointer first to allow lazy mode check to work correctly.
-    // If only persistentPmPtr is keeping plugins alive (no active handles),
-    // then pmPtr will expire after this reset.
-    persistentPmPtr.reset();
+    return gEngineConfig;
+}
 
-    THROW_IF_FALSE(pmPtr.expired(),
-                   HIPDNN_STATUS_NOT_SUPPORTED,
-                   "hipdnnSetEnginePluginPaths_ext cannot be called with an active handle.");
+std::weak_ptr<EnginePluginManager>& EnginePluginResourceManager::getWeakPtr()
+{
+    return gEngineWeakPtr;
+}
 
-    pluginConfig.mode = loadingMode;
+std::shared_ptr<EnginePluginManager>& EnginePluginResourceManager::getPersistentPtr()
+{
+    return gEnginePersistentPtr;
+}
 
-    if(loadingMode == HIPDNN_PLUGIN_LOADING_ABSOLUTE)
-    {
-        pluginConfig.paths = {pluginPaths.begin(), pluginPaths.end()};
-    }
-    else
-    {
-        pluginConfig.paths.insert(pluginPaths.begin(), pluginPaths.end());
-    }
+std::atomic<bool>& EnginePluginResourceManager::getShutdownFlag()
+{
+    return gEngineShutdownFlag;
 }
 
-std::set<std::filesystem::path> EnginePluginResourceManager::getPluginPaths()
+const char* EnginePluginResourceManager::getPluginTypeName()
 {
-    const std::lock_guard<std::mutex> lock(pluginMutex);
-    return pluginConfig.paths;
+    return "engine";
 }
 
 size_t EnginePluginResourceManager::getEngineCount() const
@@ -155,109 +134,19 @@ std::vector<EngineInfo> EnginePluginResourceManager::getEngineInfos() const
     return infos;
 }
 
-void EnginePluginResourceManager::setPluginUnloadingMode(hipdnnPluginUnloadingMode_ext_t mode)
-{
-    const std::lock_guard<std::mutex> lock(pluginMutex);
-
-    switch(mode)
-    {
-    case HIPDNN_PLUGIN_UNLOAD_EAGER:
-        // Clear persistent pointer - if no handles exist, plugins will be unloaded
-        persistentPmPtr.reset();
-        break;
-
-    case HIPDNN_PLUGIN_UNLOAD_LAZY:
-        // If plugins are already loaded, keep them alive by storing in persistent pointer
-        if(auto pm = pmPtr.lock())
-        {
-            persistentPmPtr = pm;
-        }
-        // If no plugins loaded yet, persistentPmPtr will be set when create() is called
-        break;
-
-    default:
-        throw HipdnnException(HIPDNN_STATUS_BAD_PARAM,
-                              "Invalid plugin unloading mode: " + std::to_string(mode));
-    }
-
-    pluginConfig.unloadingMode = mode;
-}
-
-void EnginePluginResourceManager::getLoadedPluginFiles(size_t* numPlugins,
-                                                       char** pluginPaths,
-                                                       size_t* maxStringLen) const
-{
-    if(!_pm)
-    {
-        *numPlugins = 0;
-        *maxStringLen = 0;
-        return;
-    }
-
-    const auto& pathSet = _pm->getLoadedPluginFiles();
-
-    size_t requiredLen = 0;
-    for(const auto& path : pathSet)
-    {
-        requiredLen = std::max(requiredLen, path.string().length() + 1);
-    }
-
-    if(pluginPaths == nullptr)
-    {
-        *numPlugins = pathSet.size();
-        *maxStringLen = requiredLen;
-        return;
-    }
-
-    if(*numPlugins < pathSet.size() || *maxStringLen < requiredLen)
-    {
-        throw HipdnnException(HIPDNN_STATUS_BAD_PARAM, "Insufficient buffer space provided.");
-    }
-
-    std::vector<std::filesystem::path> pathsVec;
-    pathsVec.reserve(pathSet.size());
-    pathsVec.assign(pathSet.begin(), pathSet.end());
-
-    for(size_t i = 0; i < pathsVec.size(); ++i)
-    {
-        if(pluginPaths[i] == nullptr)
-        {
-            throw HipdnnException(HIPDNN_STATUS_BAD_PARAM, "A plugin path string buffer is null.");
-        }
-        hipdnn_data_sdk::utilities::copyMaxSizeWithNullTerminator(
-            pluginPaths[i], pathsVec[i].string().c_str(), *maxStringLen);
-    }
-}
-
 std::shared_ptr<EnginePluginResourceManager> EnginePluginResourceManager::create()
 {
-    const std::lock_guard<std::mutex> lock(pluginMutex);
-
-    auto pm = pmPtr.lock();
-
-    if(!pm)
-    {
-        pm = std::make_shared<EnginePluginManager>();
-        pm->loadPlugins(pluginConfig.paths, pluginConfig.mode);
-        pmPtr = pm;
-
-        // In lazy mode, keep the plugin manager alive by storing in persistent pointer
-        if(pluginConfig.unloadingMode == HIPDNN_PLUGIN_UNLOAD_LAZY)
-        {
-            persistentPmPtr = pm;
-        }
-    }
-
+    auto pm = getOrCreatePluginManager();
     return std::make_shared<EnginePluginResourceManager>(pm);
 }
 
 EnginePluginResourceManager::EnginePluginResourceManager()
-    : _pm(std::make_shared<EnginePluginManager>())
+    : PluginResourceManagerBase(std::make_shared<EnginePluginManager>())
 {
 }
 
 EnginePluginResourceManager::EnginePluginResourceManager(std::shared_ptr<EnginePluginManager> pm)
-    : _pm(std::move(pm))
+    : PluginResourceManagerBase(std::move(pm))
 {
     // Helper to safely destroy a handle during error cleanup, logging any failures
     auto safeDestroyHandle = [](const EnginePlugin* plugin, hipdnnEnginePluginHandle_t handle) {
@@ -338,38 +227,52 @@ EnginePluginResourceManager::EnginePluginResourceManager(std::shared_ptr<EngineP
 
 EnginePluginResourceManager::~EnginePluginResourceManager()
 {
-    // Destroy plugin handles
-    for(const auto& [handle, plugin] : _handleToPlugin)
-    {
+    // Lambda to safely destroy a handle, catching all errors
+    auto safeDestroyHandle = [](const EnginePlugin* plugin, hipdnnEnginePluginHandle_t handle) {
         try
         {
             plugin->destroyHandle(handle);
         }
-        catch(const HipdnnException& e)
+        catch(const std::exception& e)
+        {
+            HIPDNN_BACKEND_LOG_WARN("Failed to destroy handle for plugin '{}' during cleanup: {}",
+                                    plugin->name(),
+                                    e.what());
+        }
+        catch(...)
         {
-            HIPDNN_BACKEND_LOG_ERROR(e.getMessage());
+            HIPDNN_BACKEND_LOG_WARN(
+                "Failed to destroy handle for plugin '{}' during cleanup: unknown error",
+                plugin->name());
         }
+    };
+
+    // Destroy plugin handles
+    for(const auto& [handle, plugin] : _handleToPlugin)
+    {
+        safeDestroyHandle(plugin, handle);
     }
 }
 
 EnginePluginResourceManager::EnginePluginResourceManager(
     EnginePluginResourceManager&& other) noexcept
-    : _pm(std::move(other._pm))
-    , _handleToPlugin(std::move(other._handleToPlugin))
+    : _handleToPlugin(std::move(other._handleToPlugin))
     , _engineIdToHandle(std::move(other._engineIdToHandle))
     , _cachedEngineInfos(std::move(other._cachedEngineInfos))
 {
+    // Move base class member explicitly
+    _pm = std::move(other._pm);
 }
 
 EnginePluginResourceManager&
     EnginePluginResourceManager::operator=(EnginePluginResourceManager&& other) noexcept
 {
     if(this != &other)
     {
-        _pm = std::move(other._pm);
         _handleToPlugin = std::move(other._handleToPlugin);
         _engineIdToHandle = std::move(other._engineIdToHandle);
         _cachedEngineInfos = std::move(other._cachedEngineInfos);
+        _pm = std::move(other._pm);
     }
     return *this;
 }