[hipDNN] Plugin SDK + Device Properties Infrastructure (RFC 0007 - Part 1/3)

[cderb]

Motivation

hipDNN currently uses hard-coded engine selection heuristics embedded in the backend, making it difficult for users to customize selection behavior or experiment with new ordering strategies. This inflexibility limits performance tuning opportunities and prevents domain-specific optimizations.

RFC 0007 introduces a pluggable heuristics framework that allows users to:

• Write custom engine selection policies as loadable plugins
• Override default ordering logic without modifying hipDNN source
• Experiment with performance tuning strategies (e.g., architecture-specific ordering, tuning database lookups, ML-based selection)
• Chain multiple policies with fallback behavior

This PR (Part 1/3) establishes the foundational plugin infrastructure required for the heuristics framework, including the complete C ABI, backend wrappers, resource management, device property serialization format, and comprehensive test coverage. Integration tests with real plugins are included (originally scoped without full framework logic or default plugins).

Technical Overview

Architecture

The heuristics plugin system introduces a separate C ABI distinct from the existing engine plugin API:

• Engine plugins provide compute implementations (e.g., convolution kernels)
• Heuristic plugins provide engine ordering/selection logic
• A single plugin library (.so on Linux, .dll on Windows) is either an engine plugin OR a heuristic plugin, never both

Plugin Infrastructure Sharing:

• Both plugin types share common management code via PluginResourceManagerBase<> (CRTP pattern)
• Separate static storage (paths, configs, plugin managers) for each type
• Unified patterns for loading, unloading, path configuration, log level propagation

Key Components

1. Plugin SDK API (plugin_sdk/include/hipdnn_plugin_sdk/HeuristicsPluginApi.h)

Terminology Note: This document uses "policy name" in prose, policy_name for C API parameters, and policyName() for C++ method names.

Exported Functions (C ABI):

// Module metadata
hipdnnPluginStatus_t hipdnnHeuristicGetApiVersion(const char** version);
hipdnnPluginStatus_t hipdnnHeuristicGetPolicyName(const char** name); // Required (not optional)
hipdnnPluginStatus_t hipdnnHeuristicGetPluginVersion(const char** version);

// NOTE: Policy ID is computed by backend via engineNameToId(policy_name), not exported by plugin

// Logging (shared with engine plugins)
hipdnnPluginStatus_t hipdnnHeuristicSetLoggingCallback(hipdnnCallback_t callback);
hipdnnPluginStatus_t hipdnnHeuristicSetLogLevel(hipdnnSeverity_t level); // Optional
void hipdnnHeuristicGetLastErrorString(const char** error_str);

// Session lifecycle
hipdnnPluginStatus_t hipdnnHeuristicHandleCreate(hipdnnHeuristicHandle_t* handle);
hipdnnPluginStatus_t hipdnnHeuristicHandleDestroy(hipdnnHeuristicHandle_t handle);
hipdnnPluginStatus_t hipdnnHeuristicHandleSetDeviceProperties(
    hipdnnHeuristicHandle_t handle,
    const hipdnnPluginConstData_t* serialized_device_properties);

// Policy descriptor lifecycle
hipdnnPluginStatus_t hipdnnHeuristicPolicyDescriptorCreate(
    hipdnnHeuristicHandle_t handle,
    hipdnnHeuristicPolicyDescriptor_t* descriptor);
hipdnnPluginStatus_t hipdnnHeuristicPolicyDescriptorDestroy(
    hipdnnHeuristicPolicyDescriptor_t descriptor);

// Policy execution
hipdnnPluginStatus_t hipdnnHeuristicPolicySetEngineIds(
    hipdnnHeuristicPolicyDescriptor_t descriptor,
    const int64_t* engine_ids,
    size_t count);
hipdnnPluginStatus_t hipdnnHeuristicPolicySetSerializedGraph(
    hipdnnHeuristicPolicyDescriptor_t descriptor,
    const hipdnnPluginConstData_t* serialized_graph);
hipdnnPluginStatus_t hipdnnHeuristicPolicyFinalize(
    hipdnnHeuristicPolicyDescriptor_t descriptor,
    int32_t* out_applied);
hipdnnPluginStatus_t hipdnnHeuristicPolicyGetSortedEngineIds(
    hipdnnHeuristicPolicyDescriptor_t descriptor,
    int64_t* engine_ids,
    size_t* count);  // Type-consistent with SetEngineIds

Design Decisions:

• Two-phase execution: SetEngineIds + SetSerializedGraph → Finalize → GetSortedEngineIds
• Session handles per hipdnnHandle store plugin state (caches, tuning data)
• Policy descriptors per EngineHeuristicDescriptor isolate per-graph selection state
• FlatBuffer serialization for device properties and operation graphs (cross-ABI compatibility)
• One policy per plugin module: Each plugin library exports exactly one policy name. Policy ID is computed by backend using engineNameToId(policy_name) (RFC 0007 §5.3, §8.2)
• Type consistency: Both SetEngineIds and GetSortedEngineIds use size_t for counts

2. Device Properties (backend/src/heuristics/DeviceProperties.{hpp,cpp}) (FlatBuffers Schema: flatbuffers_sdk/schemas/device_properties.fbs)

Purpose: Define serialization format for device characteristics to be passed to heuristic plugins.

FlatBuffer Schema (flatbuffers_sdk/schemas/device_properties.fbs):

table DeviceProperties {
    device_id: int = -1;               // HIP device ID
    multi_processor_count: int = 0;    // Number of compute units
    total_global_mem: ulong = 0;       // Total GPU memory (bytes)
    architecture_name: string;         // GPU arch (e.g., "gfx90a", "gfx942")
    // Future optional fields (additive evolution):
    // wavefront_size: int;
    // max_threads_per_block: int;
}

Versioning: Pre-generated headers for FlatBuffers v24.12.23 and v25.9.23 ensure compatibility across PyTorch and hipDNN builds.

Part 1 Includes:

• FlatBuffer schema and generated headers (40 lines schema, ~270 lines per generated header)
• ABI entry point: hipdnnHeuristicHandleSetDeviceProperties()
• Backend method: setDevicePropertiesOnAllHandles(const hipdnnPluginConstData_t*)
• Integration tests manually create DevicePropertiesT objects and serialize them using FlatBuffers API to validate the format

Revision During Review: Early commits included C++ helper functions in backend/src/heuristics/DeviceProperties.{cpp,hpp} with dedicated unit tests, removed in commit 1b97bb9. Current approach: Part 1 uses the FlatBuffers SDK DevicePropertiesT type directly (flatbuffers_sdk/schemas/device_properties.fbs). Integration tests demonstrate the serialization format works correctly. Future work may add helper functions for convenience, but automatic device property querying is deferred to Part 2.

3. Plugin Resource Management

Base Class (backend/src/plugin/PluginResourceManagerBase.hpp):

Purpose: CRTP base class providing shared infrastructure for both engine and heuristic plugin management.

Template Signature:

template <typename Derived, typename PluginManagerType, typename PluginType>
class PluginResourceManagerBase;

Shared Static Methods (via CRTP):

• setPluginPaths(paths, loadingMode) - Configure plugin search directories
• getPluginPaths() - Retrieve current search paths
• setPluginUnloadingMode(mode) - Configure EAGER/LAZY unloading
• setPluginLogLevel(level) - Propagate log level to all loaded plugins
• getOrCreatePluginManager() - Lazy initialization with weak_ptr/persistent_ptr pattern

Shared Instance Method:

• getLoadedPluginFiles(numPlugins, pluginPaths, maxStringLen) - Query loaded plugin file paths

Derived Class (backend/src/plugin/HeuristicPluginResourceManager.{hpp,cpp}):

Responsibilities:

• Load heuristic plugin libraries from HIPDNN_HEURISTIC_PLUGIN_DIR
• Validate plugin ABI compatibility and metadata
• Manage plugin lifecycle per hipdnnHandle
• Create hipdnnHeuristicHandle_t session objects
• Resolve policy IDs to plugin modules
• Enforce policy ID ↔ policy name consistency (RFC 0007 §11, §5.3.1)

Key Methods:

class HeuristicPluginResourceManager
    : public PluginResourceManagerBase<HeuristicPluginResourceManager,
                                       HeuristicPluginManager,
                                       HeuristicPlugin> {
    // Instance methods
    virtual hipdnnHeuristicHandle_t getHeuristicHandleForPolicyId(int64_t policyId) const;
    virtual const HeuristicPlugin* getPluginForPolicyId(int64_t policyId) const;
    virtual std::vector<HeuristicPolicyInfo> getHeuristicPolicyInfos() const;
    virtual void setDevicePropertiesOnAllHandles(const hipdnnPluginConstData_t* devicePropsSerialized) const;
    virtual std::string toString() const;  // Includes plugin paths and policy metadata

    // Inherited static methods (via CRTP base):
    static void setPluginPaths(...);
    static std::set<std::filesystem::path> getPluginPaths();
    static void setPluginUnloadingMode(...);
    static void setPluginLogLevel(...);

    // Compatibility aliases:
    static void setHeuristicPluginPaths(...) { setPluginPaths(...); }
    static std::set<std::filesystem::path> getHeuristicPluginPaths() { return getPluginPaths(); }
};

Error Handling:

• Missing plugins: Warning logged, continues loading other plugins
• ABI mismatch: Plugin rejected, logged as error
• Duplicate policy IDs: Plugin rejected with HipdnnException
• Destructor safety: Catches all exceptions (std::exception + ...) when destroying handles, logs warnings (not errors)

4. Plugin Wrapper (backend/src/plugin/HeuristicPlugin.{hpp,cpp})

Purpose: C++ RAII wrapper around C ABI plugin functions.

Lifecycle:

class HeuristicPlugin {
    SharedLibrary _lib;  // RAII dlopen/dlclose wrapper
    // Function pointers to plugin exports

    explicit HeuristicPlugin(SharedLibrary&& lib);
    ~HeuristicPlugin() override = default;

    // Metadata queries
    std::string_view apiVersion() const override;
    virtual int64_t policyId() const;  // Computed via engineNameToId(policyName()), cached at load
    virtual std::string_view policyName() const;  // Calls hipdnnHeuristicGetPolicyName
    virtual std::string_view pluginVersion() const;

    // Session management
    virtual hipdnnHeuristicHandle_t createHandle() const;
    virtual void destroyHandle(hipdnnHeuristicHandle_t handle) const;
    virtual void setDeviceProperties(hipdnnHeuristicHandle_t handle, const hipdnnPluginConstData_t* devicePropsSerialized) const;

    // Policy descriptor management
    virtual hipdnnHeuristicPolicyDescriptor_t createPolicyDescriptor(hipdnnHeuristicHandle_t pluginHandle) const;
    virtual void destroyPolicyDescriptor(hipdnnHeuristicPolicyDescriptor_t desc) const;

    // Policy execution
    virtual void setEngineIds(hipdnnHeuristicPolicyDescriptor_t desc, const int64_t* engineIds, size_t engineIdCount) const;
    virtual void setSerializedGraph(hipdnnHeuristicPolicyDescriptor_t desc, const hipdnnPluginConstData_t* serializedGraph) const;
    virtual bool finalize(hipdnnHeuristicPolicyDescriptor_t desc) const;
    virtual std::vector<int64_t> getSortedEngineIds(hipdnnHeuristicPolicyDescriptor_t desc) const;

    // Logging
    hipdnnPluginStatus_t setLoggingCallback(hipdnnCallback_t) const;
    hipdnnPluginStatus_t setLogLevel(hipdnnSeverity_t) const;  // May be missing
};

5. Plugin Manager (backend/src/plugin/HeuristicPluginManager.hpp)

Purpose: Manages loading and validation of heuristic plugins, inherits from PluginManagerBase<HeuristicPlugin>.

Responsibilities:

• Scan directories for plugin libraries
• Load and validate plugins via HeuristicPlugin wrapper
• Validate API version compatibility (major version must match)
• Enforce policy ID uniqueness
• Provide plugin lookup by policy ID

Key Validation (in validateBeforeAdding()):

// Validate heuristic C ABI major version
if (Version{plugin.apiVersion()}.major != HIPDNN_HEURISTIC_API_VERSION_MAJOR) {
    throw HipdnnException(HIPDNN_STATUS_PLUGIN_ERROR, "ABI version mismatch");
}

// Validate unique policy ID
if (_policyIds.find(policyId) != _policyIds.end()) {
    throw HipdnnException(HIPDNN_STATUS_PLUGIN_ERROR, "Duplicate policy ID");
}

// Validate policy name is non-empty (RFC 0007 requirement)
if (policyName.empty()) {
    throw HipdnnException(HIPDNN_STATUS_PLUGIN_ERROR, "Policy name required");
}

6. Handle Integration (backend/src/handle/Handle.{hpp,cpp})

Changes:

• Handle::Handle() now instantiates HeuristicPluginResourceManager and loads plugins
• Handle::~Handle() cleans up plugin resources via RAII
• Added getHeuristicPluginResourceManager() accessor

Note: Part 1 provides the plugin resource manager infrastructure and device properties API (setDevicePropertiesOnAllHandles). Automatic device property querying (e.g., calling hipGetDeviceProperties) and propagation during handle initialization is not included in Part 1.

6. Environment Variables (docs/Environment.md)

Documented Variables:

• HIPDNN_PLUGIN_DIR - Search directory for engine plugins (default: hipdnn_plugins/engines/)
• HIPDNN_HEURISTIC_PLUGIN_DIR - Search directory for heuristic plugins (default: hipdnn_plugins/heuristics/)

Files Added/Modified

Plugin SDK (3 files):

• plugin_sdk/include/hipdnn_plugin_sdk/HeuristicsPluginApi.h (404 lines, complete C ABI with full documentation)
• plugin_sdk/include/hipdnn_plugin_sdk/heuristic_api_version.h (API version macro HIPDNN_HEURISTIC_API_VERSION)
• plugin_sdk/include/hipdnn_plugin_sdk/PluginApiDataTypes.h (Modified: added HIPDNN_PLUGIN_TYPE_HEURISTIC and two new status codes)

Backend - Plugin Infrastructure (6 new files + 2 modified):

New files:

• backend/src/plugin/HeuristicPlugin.{hpp,cpp} (158 + 234 = 392 lines, C++ wrapper around C ABI)
• backend/src/plugin/HeuristicPluginManager.hpp (96 lines, inherits from PluginManagerBase)
• backend/src/plugin/HeuristicPluginResourceManager.{hpp,cpp} (181 + 312 = 493 lines, inherits from PluginResourceManagerBase)
• backend/src/plugin/PluginResourceManagerBase.hpp (337 lines, CRTP base for common plugin management)

Modified files:

• backend/src/plugin/EnginePluginResourceManager.{hpp,cpp} (now inherits from PluginResourceManagerBase)
• backend/src/handle/Handle.{hpp,cpp} (added HeuristicPluginResourceManager member)

FlatBuffers SDK (3 files, device properties schema migrated from data_sdk in commit 1b97bb9):

• flatbuffers_sdk/schemas/device_properties.fbs (40 lines)
• flatbuffers_sdk/include/.../v25_9_23/.../device_properties_generated.h (~269 lines)
• flatbuffers_sdk/include/.../v24_12_23/.../device_properties_generated.h (~269 lines)

Backend Tests (6 files):

• backend/tests/TestHeuristicPlugin.cpp (233 lines, mock-based unit tests)
• backend/tests/TestHeuristicPluginManager.cpp (392 lines, manager unit tests)
• backend/tests/TestHeuristicPluginResourceManager.cpp (475 lines, resource manager unit tests)
• backend/tests/TestHeuristicPluginIntegration.cpp (957 lines, integration tests with real plugins)
• backend/tests/descriptors/mocks/MockHeuristicPlugin.hpp (71 lines, gmock-based mock plugin)
• backend/tests/descriptors/mocks/MockHeuristicPluginResourceManager.hpp (33 lines, gmock-based mock resource manager)

Test Plugins (3 files):

• tests/test_plugins/TestGoodHeuristicPlugin.cpp (307 lines, complete working plugin)
• tests/test_plugins/TestNoOptionalHeuristicPlugin.cpp (254 lines, plugin without optional functions)
• tests/test_plugins/TestIncompleteHeuristicApiPlugin.cpp (137 lines, negative test missing required functions)

Documentation (1 file):

• docs/Environment.md (Modified: documented HIPDNN_PLUGIN_DIR and HIPDNN_HEURISTIC_PLUGIN_DIR)

Total: ~5,000+ lines across 26 files (expanded from initial 24 files with addition of integration tests and test plugins)

Test Plan

Unit Tests (120 heuristic plugin tests)

TestHeuristicPlugin (9 tests)

• Mock plugin lifecycle (create/destroy handles, descriptors)
• Policy ID caching
• Empty/long policy names handling
• Return value handling (null handles/descriptors)

TestHeuristicPluginManager (30 tests)

• Plugin loading from directories
• Multiple plugin instances independence
• Plugin validation (API version, policy IDs, policy names)
• Environment variable path handling (HIPDNN_HEURISTIC_PLUGIN_DIR)
• Policy ID uniqueness enforcement
• Error handling (missing files, invalid plugins)
• Default search paths
• Multiple load/unload cycles

TestHeuristicPluginResourceManager (37 tests)

• Factory method (create())
• Move semantics (constructor/assignment)
• Policy lookup by ID (handle and plugin pointer)
• Device properties propagation API
• Plugin path configuration (static methods via CRTP base)
• Unloading modes (EAGER/LAZY)
• Log level propagation
• getLoadedPluginFiles() implementation
• toString() with plugin information and file paths
• Multiple instances coexistence
• Destructor cleanup

IntegrationHeuristicPlugin (31 tests)

• Real plugin loading from test plugins
• Complete handle lifecycle
• Policy descriptor workflow:
  • Create descriptor
  • Set engine IDs (candidate list)
  • Set serialized graph
  • Finalize policy
  • Get sorted engine IDs
• Device properties serialization:
  • Create mock DevicePropertiesT objects
  • Serialize using FlatBuffers
  • Pass as hipdnnPluginConstData_t* to plugins
  • Validate no exceptions thrown
• Optional function handling:
  • Plugins without hipdnnHeuristicGetPolicyName (returns empty string)
  • Plugins without hipdnnPluginSetLogLevel hipdnnHeuristicSetLogLevel (returns INVALID_VALUE)
• Error handling:
  • Plugin with missing required functions (negative test)
  • Invalid device properties buffers
  • Empty engine ID lists

TestHeuristicPluginLoadedGood (13 tests)

• Loaded plugin metadata queries
• Policy workflow with real plugin
• Policy ID consistency
• Complete handle and descriptor lifecycle

Mock Classes: GoogleMock-based mocks (MockHeuristicPlugin, MockHeuristicPluginResourceManager) are provided for descriptor-level unit tests, though integration tests primarily use real test plugins.

Integration Testing (Included in Part 1)

Test Plugins Provided:

1. TestGoodHeuristicPlugin - Complete working implementation

   • Implements all required and optional functions
   • Validates device properties format
   • Implements simple sorting logic
   • Policy name: "TestGoodHeuristicPolicy"

2. TestNoOptionalHeuristicPlugin - Plugin without optional functions

   • Missing hipdnnHeuristicGetPolicyName (uses generated name from policy ID)
   • Missing hipdnnHeuristicSetLogLevel
   • Tests graceful degradation when optional functions absent

3. TestIncompleteHeuristicApiPlugin - Negative test

   • Missing required function hipdnnHeuristicPolicyDescriptorCreate
   • Tests that backend rejects incomplete plugins

Part 1 Test Coverage:

• Plugin library loading from HIPDNN_HEURISTIC_PLUGIN_DIR
• Policy metadata queries (policy ID, name, version)
• Session handle creation and destruction
• Device properties serialization format (manually created DevicePropertiesT objects passed to plugins)
• Engine ID sorting workflow (SetEngineIds → Finalize → GetSortedEngineIds)
• Optional function handling
• Error handling (incomplete plugins, invalid inputs)

Validation Checklist

Before merging, verify:

• All backend tests pass - 2542 tests passed (+120 heuristic plugin tests, -11 removed TestDeviceProperties tests from baseline 2433)
• Mock classes compile and link - Successfully built with hipdnn_backend_tests
• FlatBuffer headers identical - v24.12.23 and v25.9.23 generate same code (modulo version strings)
• Plugin SDK C/C++ compatible - Proper extern "C" guards, no C++ features in ABI
• No symbol collisions - hipdnnHeuristic* vs hipdnnEnginePlugin* namespaces are distinct
• RFC 0007 references consistent - All references include "RFC 0007" prefix
• ASAN validation - All 2542 tests pass with AddressSanitizer, NO MEMORY LEAKS detected
• CRTP base class tested - PluginResourceManagerBase shared between Engine and Heuristic managers
• Type consistency - GetSortedEngineIds uses size_t* matching SetEngineIds
• Error handling - Plugin destructors catch all exceptions (std::exception + ...), log warnings
• Environment variables documented - HIPDNN_PLUGIN_DIR and HIPDNN_HEURISTIC_PLUGIN_DIR in docs/Environment.md
• Integration tests with real plugins - 3 test plugins, 31 integration tests validating complete workflows
• Device properties schema defined - FlatBuffer schema with pre-generated headers for both FlatBuffers versions

Migration Impact

Backward Compatibility: Full

• Existing hipdnnHandle code works unchanged
• Plugin loading is automatic and transparent
• Missing HIPDNN_HEURISTIC_PLUGIN_DIR logs warning but continues
• No changes to existing engine plugin behavior

API Stability:

• Plugin SDK ABI: Versioned via hipdnnHeuristicGetApiVersion() (current: 1 HIPDNN_HEURISTIC_API_VERSION = "0.0.1")
• Internal C++ APIs: Subject to change (not user-facing)

Scope

This PR (Part 1/3) provides:

• Complete heuristic plugin C ABI definition
• Backend plugin loading and management infrastructure
• Device property serialization format (FlatBuffers schema)
• Comprehensive test coverage with 120 tests including integration tests with real plugins

This PR does NOT include:

• EngineHeuristicDescriptor::finalize() implementation (policy chaining)
• Default heuristic plugins (StaticOrdering, Config, etc.)
• Frontend API wrappers
• Automatic device property querying or propagation

Follow-Up Work (Parts 2 & 3)

Part 2: Default Plugins

• EngineHeuristicDescriptor::finalize() - Policy chaining logic (iterate plugins, merge results)
• Default heuristic plugin implementations:
  • StaticOrdering plugin (user-specified engine order)
  • Config plugin (load policies from configuration files)
  • Additional default plugins TBD based on RFC 0007 scope
• Integration with engine configuration workflow
• End-to-end backend tests validating policy execution during graph finalization

Part 3: Frontend API & Documentation

• Frontend C++ API wrappers for heuristic plugin management
• Public API for configuring plugin paths and loading modes
• Plugin development guide and tutorials
• Example plugin implementations demonstrating common patterns
• Performance benchmarking framework for comparing policies

References

• RFC 0007: Engine Selection Heuristics Framework (internal documentation)
• Section References:
  • §5.3: Policy order resolution
  • §6: Device properties
  • §7: Plugin API design
  • §11: Policy metadata and validation
  • §13: Serialization protocols

[codecov-commenter]

Codecov Report

❌ Patch coverage is 65.29032% with 269 lines in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
...ers_sdk/data_objects/device_properties_generated.h	29.61%	106 Missing and 1 partial ⚠️
...kend/src/plugin/HeuristicPluginResourceManager.cpp	75.94%	44 Missing and 7 partials ⚠️
...ects/hipdnn/backend/src/plugin/HeuristicPlugin.cpp	77.24%	14 Missing and 19 partials ⚠️
...pdnn/backend/src/plugin/HeuristicPluginManager.hpp	29.27%	26 Missing and 3 partials ⚠️
...n/backend/src/plugin/PluginResourceManagerBase.hpp	79.29%	23 Missing and 6 partials ⚠️
...backend/src/plugin/EnginePluginResourceManager.cpp	80.56%	7 Missing ⚠️
...ects/hipdnn/backend/src/plugin/HeuristicPlugin.hpp	73.08%	6 Missing and 1 partial ⚠️
projects/hipdnn/backend/src/handle/Handle.cpp	25.00%	3 Missing ⚠️
...ojects/hipdnn/backend/src/plugin/SharedLibrary.cpp	60.00%	2 Missing ⚠️
.../include/hipdnn_plugin_sdk/heuristic_api_version.h	50.00%	1 Missing ⚠️

❌ Your project status has failed because the head coverage (47.50%) is below the target coverage (80.00%). You can increase the head coverage or adjust the target coverage.

Additional details and impacted files

@@             Coverage Diff             @@
##           develop    #6467      +/-   ##
===========================================
+ Coverage    65.87%   69.85%   +3.98%     
===========================================
  Files         1472     1828     +356     
  Lines       255621   270797   +15176     
  Branches     36134    35629     -505     
===========================================
+ Hits        168374   189140   +20766     
+ Misses       72731    69758    -2973     
+ Partials     14516    11899    -2617     

Flag	Coverage Δ		*Carryforward flag
hipBLAS	90.67% <ø> (+0.02%)	⬆️	Carriedforward from 72a83c0
hipBLASLt	39.95% <ø> (-0.05%)	⬇️	Carriedforward from 72a83c0
hipCUB	82.21% <ø> (ø)		Carriedforward from 72a83c0
hipDNN	80.27% <65.29%> (-0.20%)	⬇️
hipFFT	55.00% <ø> (?)		Carriedforward from 72a83c0
hipRAND	76.12% <ø> (?)		Carriedforward from 72a83c0
hipSOLVER	?
rocBLAS	?
rocFFT	47.50% <ø> (-2.42%)	⬇️	Carriedforward from 72a83c0
rocPRIM	38.96% <ø> (?)		Carriedforward from 72a83c0
rocRAND	57.09% <ø> (?)		Carriedforward from 72a83c0
rocSPARSE	71.52% <ø> (-0.13%)	⬇️	Carriedforward from 72a83c0
rocThrust	91.37% <ø> (?)		Carriedforward from 72a83c0

*This pull request uses carry forward flags. Click here to find out more.

Files with missing lines	Coverage Δ
projects/hipdnn/backend/src/handle/Handle.hpp	25.00% <ø> (ø)
projects/hipdnn/backend/src/logging/Logging.hpp	88.24% <ø> (ø)
...kend/src/plugin/HeuristicPluginResourceManager.hpp	100.00% <100.00%> (ø)
...nclude/hipdnn_plugin_sdk/PluginDataTypeHelpers.hpp	100.00% <100.00%> (ø)
.../include/hipdnn_plugin_sdk/heuristic_api_version.h	50.00% <50.00%> (ø)
...ojects/hipdnn/backend/src/plugin/SharedLibrary.cpp	73.81% <60.00%> (-1.19%)	⬇️
projects/hipdnn/backend/src/handle/Handle.cpp	69.70% <25.00%> (-6.17%)	⬇️
...backend/src/plugin/EnginePluginResourceManager.cpp	71.88% <80.56%> (-1.36%)	⬇️
...ects/hipdnn/backend/src/plugin/HeuristicPlugin.hpp	73.08% <73.08%> (ø)
...pdnn/backend/src/plugin/HeuristicPluginManager.hpp	29.27% <29.27%> (ø)
... and 4 more

... and 1200 files with indirect coverage changes

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[BrianHarrisonAMD]

LGTM.

Feedback addressed.

Some minor clean-up to consider:

• HeuristicsPluginApi.h:82-89 — empty @defgroup HeuristicPluginExtensions block (leftover; remove or populate).
• HeuristicsPluginApi.h:297 — header names parameter num_engines, implementations name it count — consistent type,
  inconsistent naming.

[cderb]

Some minor clean-up to consider:

• HeuristicsPluginApi.h:82-89 — empty @defgroup HeuristicPluginExtensions block (leftover; remove or populate).
• HeuristicsPluginApi.h:297 — header names parameter num_engines, implementations name it count — consistent type,
  inconsistent naming.

I'll roll this into the part2 PR