hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/devices/cuda.h

@@ -0,0 +1,464 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_CUDA_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_CUDA_H
+
+#include "../rl_tools.h"
+#include "../utils/generic/typing.h"
+#include "../containers/matrix/matrix.h"
+#include "devices.h"
+#include "cpu.h"
+#include "cuda_streams.h"
+#include <cublas_v2.h>
+#ifdef RL_TOOLS_BACKEND_ENABLE_CUDNN
+#include <cudnn.h>
+#endif
+#include <vector>
+#include <unordered_map>
+#include <curand_kernel.h>
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices{
+    namespace cuda{
+        struct Base{
+            static constexpr DeviceId DEVICE_ID = DeviceId::CUDA;
+            using index_t = unsigned int;
+            static constexpr index_t MAX_INDEX = static_cast<index_t>(-1);
+        };
+    }
+    namespace math{
+        struct CUDA: cuda::Base{
+            static constexpr Type TYPE = Type::math;
+        };
+    }
+    namespace random{
+        struct CUDA:devices::random::Generic<devices::math::CUDA>, cuda::Base{
+            static constexpr Type TYPE = Type::random;
+            template <typename T_TI, T_TI T_NUM_RNGS, typename T_CURAND_TYPE=curandState>
+            struct Specification{
+                using TI = T_TI;
+                static constexpr TI NUM_RNGS = T_NUM_RNGS;
+                using CURAND_TYPE = T_CURAND_TYPE;
+            };
+            template <typename SPEC = Specification<cuda::Base::index_t, 1024>>
+            struct ENGINE{
+                using TI = typename SPEC::TI;
+                static constexpr TI NUM_RNGS = SPEC::NUM_RNGS;
+                Matrix<matrix::Specification<typename SPEC::CURAND_TYPE, TI, 1, NUM_RNGS, true>> states;
+            };
+        };
+    }
+    namespace logging{
+        struct CUDA: cuda::Base{
+            static constexpr Type TYPE = Type::logging;
+        };
+    }
+    namespace cuda{
+        template <typename T_SPEC>
+        struct CUDA_FAT: Device<T_SPEC>, cuda::Base{
+            template <typename OTHER_DEVICE>
+            static constexpr bool compatible = OTHER_DEVICE::DEVICE_ID == DeviceId::CUDA;
+            using SPEC = T_SPEC;
+            typename SPEC::LOGGING* logger = nullptr;
+            cublasHandle_t handle = nullptr;
+            bool graph_capture_active = false;
+            cudaStream_t stream = nullptr;
+            cudaStream_t owned_stream = nullptr;  // created by init and destroyed by free; set_stream rebinds stream
+            cudaEvent_t ordering_event = nullptr;
+            bool dynamic_memory_allocation_allowed = true;
+#ifdef RL_TOOLS_BACKEND_ENABLE_CUDNN
+            cudnnHandle_t cudnn_handle = nullptr;
+            void* cudnn_workspace = nullptr;
+            size_t cudnn_workspace_size = 0;
+#endif
+#ifdef RL_TOOLS_DEBUG_CONTAINER_COUNT_MALLOC
+            index_t malloc_counter = 0;
+#endif
+#ifdef RL_TOOLS_DEBUG_DEVICE_CUDA_CHECK_INIT
+            bool initialized = false;
+#endif
+        };
+    }
+    // there is a "FAT" version (containing logger pointer and other context) and a "TAG" version that can be  just used for tag dispatch without runtime overhead
+    template <typename T_SPEC>
+    struct CUDA: utils::typing::conditional_t<T_SPEC::TAG, cuda::Base, cuda::CUDA_FAT<T_SPEC>>{
+        using SPEC = T_SPEC;
+        typename SPEC::MATH math;
+        typename SPEC::RANDOM random;
+        static constexpr bool TAG = SPEC::TAG;
+        static constexpr bool KERNEL = SPEC::KERNEL;
+    };
+    namespace cuda{
+//        template <typename DEVICE, typename std::enable_if<sizeof(CUDA<typename DEVICE::SPEC, true>) == 0>::type* = nullptr>
+        template <typename SPEC, bool T_KERNEL=false>
+        struct TAG_SPEC: SPEC{
+            static constexpr bool TAG = true;
+            static constexpr bool KERNEL = T_KERNEL;
+        };
+        template <typename DEVICE, bool KERNEL = false>
+        using _TAG = CUDA<TAG_SPEC<typename DEVICE::SPEC, KERNEL>>;
+#ifdef _MSC_VER
+        template <typename DEVICE, bool KERNEL = false>
+#else
+        template <typename DEVICE, bool KERNEL = false, typename utils::typing::enable_if<sizeof(_TAG<DEVICE, KERNEL>) == 3>::type* = nullptr> // size three because C++ requires a size of at least one byte per struct (for distinct addresses) and since it has two empty member structs (random and math device structs)
+#endif
+        using TAG = _TAG<DEVICE, KERNEL>;
+
+        struct CUDA_KERNEL_SPEC{
+            struct RANDOM{
+                template <typename T_ENGINE = curandState>
+                using ENGINE = T_ENGINE;
+            };
+            using MATH = devices::math::CUDA;
+            using LOGGING = logging::CUDA;
+        };
+        template <typename T_SPEC>
+        struct CUDA_KERNEL{
+            using SPEC = T_SPEC;
+            using index_t = unsigned int;
+            devices::random::CUDA random;
+            typename SPEC::MATH math;
+            typename SPEC::LOGGING* logger = nullptr;
+        };
+
+    }
+
+    struct DefaultCUDASpecification{
+//        using MATH_HOST = devices::math::CPU;
+        using MATH = devices::math::CUDA;
+        using MATH_DEVICE_ACCURATE = math::CUDA;
+        using RANDOM = random::CUDA;
+        using LOGGING = logging::CUDA;
+        static constexpr bool TAG = false;
+        static constexpr bool KERNEL = false;
+        // Optional strict checking for external CUDA/cuBLAS/cuDNN calls.
+        // When enabled, each guarded call synchronizes the stream to surface async failures early.
+        static constexpr bool CHECK_EXTERNAL_CALL_STATUS = false;
+    };
+    using DefaultCUDA = CUDA<DefaultCUDASpecification>;
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#include <iostream>
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace devices::cuda::detail{
+        template<typename T, typename = void>
+        struct has_check_external_call_status: std::false_type{};
+        template<typename T>
+        struct has_check_external_call_status<T, std::void_t<decltype(T::CHECK_EXTERNAL_CALL_STATUS)>>: std::true_type{};
+    }
+    template<typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT constexpr bool cuda_external_call_check_enabled(){
+        if constexpr(devices::cuda::detail::has_check_external_call_status<SPEC>::value){
+            return SPEC::CHECK_EXTERNAL_CALL_STATUS;
+        }
+        else{
+            return false;
+        }
+    }
+    template<typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void sync_external_cuda_call_if_enabled(devices::CUDA<SPEC>& device, const char* api_name, const char* call_name){
+#ifdef __CUDA_ARCH__
+        (void)device;
+        (void)api_name;
+        (void)call_name;
+#else
+        if constexpr(cuda_external_call_check_enabled<SPEC>()){
+            if(!device.graph_capture_active){
+                cudaError_t sync_stat = cudaStreamSynchronize(device.stream);
+                if(sync_stat != cudaSuccess){
+                    std::cerr << api_name << " call \"" << call_name << "\" stream sync failed: " << cudaGetErrorString(sync_stat) << std::endl;
+                    std::exit(101);
+                }
+            }
+        }
+#endif
+    }
+    template<typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void check_cuda_call(devices::CUDA<SPEC>& device, cudaError_t status, const char* call_name){
+#ifdef __CUDA_ARCH__
+        (void)device;
+        (void)status;
+        (void)call_name;
+#else
+        if(status != cudaSuccess){
+            std::cerr << "CUDA call \"" << call_name << "\" failed: " << cudaGetErrorString(status) << std::endl;
+            std::exit(101);
+        }
+        sync_external_cuda_call_if_enabled(device, "CUDA", call_name);
+#endif
+    }
+#ifdef RL_TOOLS_BACKEND_ENABLE_CUDNN
+    template<typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void check_cudnn_call(devices::CUDA<SPEC>& device, cudnnStatus_t status, const char* call_name){
+#ifdef __CUDA_ARCH__
+        (void)device;
+        (void)status;
+        (void)call_name;
+#else
+        if(status != CUDNN_STATUS_SUCCESS){
+            std::cerr << "cuDNN call \"" << call_name << "\" failed: " << cudnnGetErrorString(status) << std::endl;
+            std::exit(101);
+        }
+        sync_external_cuda_call_if_enabled(device, "cuDNN", call_name);
+#endif
+    }
+#endif
+    template<typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void check_cublas_call(devices::CUDA<SPEC>& device, cublasStatus_t status, const char* call_name){
+#ifdef __CUDA_ARCH__
+        (void)device;
+        (void)status;
+        (void)call_name;
+#else
+        if(status != CUBLAS_STATUS_SUCCESS){
+            std::cerr << "cuBLAS call \"" << call_name << "\" failed: " << cublasGetStatusString(status) << std::endl;
+            std::exit(101);
+        }
+        sync_external_cuda_call_if_enabled(device, "cuBLAS", call_name);
+#endif
+    }
+
+    template <typename SPEC>
+    void init(devices::CUDA<SPEC>& device){
+        cudaError_t stat;
+        stat = cudaStreamCreate(&device.owned_stream);
+        device.stream = device.owned_stream;
+        if (stat != cudaSuccess) {
+//            log(device.logger, (const char*)"CUBLAS initialization failed ", cublasGetStatusString(stat));
+            std::cout << "CUDA Stream initialization failed " << cudaGetErrorString(stat) << std::endl;
+        }
+        stat = cudaEventCreateWithFlags(&device.ordering_event, cudaEventDisableTiming);
+        if (stat != cudaSuccess) {
+            std::cout << "CUDA ordering event creation failed " << cudaGetErrorString(stat) << std::endl;
+        }
+        cublasStatus_t cublas_stat;
+        cublas_stat = cublasCreate(&device.handle);
+        if (cublas_stat != CUBLAS_STATUS_SUCCESS) {
+//            log(device.logger, (const char*)"CUBLAS initialization failed ", cublasGetStatusString(stat));
+            std::cout << "CUBLAS initialization failed " << cublasGetStatusString(cublas_stat) << std::endl;
+        }
+        cublas_stat = cublasSetStream(device.handle, device.stream);
+        if (cublas_stat != CUBLAS_STATUS_SUCCESS) {
+            std::cout << "CUBLAS setting stream failed " << cublasGetStatusString(cublas_stat) << std::endl;
+        }
+#ifdef RL_TOOLS_DEBUG_DEVICE_CUDA_CHECK_INIT
+        if(device.initialized){
+            std::cerr << "CUDA device already initialized" << std::endl;
+        }
+        device.initialized = true;
+#endif
+#ifdef RL_TOOLS_BACKEND_ENABLE_CUDNN
+        {
+            cudnnStatus_t cudnn_stat;
+            cudnn_stat = cudnnCreate(&device.cudnn_handle);
+            if(cudnn_stat != CUDNN_STATUS_SUCCESS){
+                std::cout << "cuDNN initialization failed: " << cudnnGetErrorString(cudnn_stat) << std::endl;
+            }
+            cudnn_stat = cudnnSetStream(device.cudnn_handle, device.stream);
+            if(cudnn_stat != CUDNN_STATUS_SUCCESS){
+                std::cout << "cuDNN setting stream failed: " << cudnnGetErrorString(cudnn_stat) << std::endl;
+            }
+        }
+#endif
+    }
+    // rebinds the execution stream every operation enqueues on (e.g. a caller's stream); work
+    // enqueued on the previous one so far comes first
+    template <typename SPEC>
+    void set_stream(devices::CUDA<SPEC>& device, cudaStream_t stream){
+        devices::cuda::order_after(device.ordering_event, device.stream, stream);
+        device.stream = stream;
+        cublasSetStream(device.handle, stream);
+#ifdef RL_TOOLS_BACKEND_ENABLE_CUDNN
+        cudnnSetStream(device.cudnn_handle, stream);
+#endif
+    }
+    template <typename SPEC>
+    void free(devices::CUDA<SPEC>& device){
+#ifdef RL_TOOLS_BACKEND_ENABLE_CUDNN
+        if(device.cudnn_workspace != nullptr){
+            cudaFree(device.cudnn_workspace);
+            device.cudnn_workspace = nullptr;
+            device.cudnn_workspace_size = 0;
+        }
+        if(device.cudnn_handle != nullptr){
+            cudnnDestroy(device.cudnn_handle);
+            device.cudnn_handle = nullptr;
+        }
+#endif
+        if(device.handle != nullptr){
+            cublasDestroy(device.handle);
+            device.handle = nullptr;
+        }
+        if(device.ordering_event != nullptr){
+            cudaEventDestroy(device.ordering_event);
+            device.ordering_event = nullptr;
+        }
+        if(device.owned_stream != nullptr){
+            cudaStreamDestroy(device.owned_stream);
+            device.owned_stream = nullptr;
+        }
+        device.stream = nullptr;
+#ifdef RL_TOOLS_DEBUG_DEVICE_CUDA_CHECK_INIT
+        device.initialized = false;
+#endif
+    }
+    namespace nn::cuda{
+#ifdef RL_TOOLS_BACKEND_ENABLE_CUDNN
+        template<typename T>
+        constexpr RL_TOOLS_FUNCTION_PLACEMENT cudnnDataType_t get_cudnn_dtype(){
+            if constexpr(utils::typing::is_same_v<T, float>){
+                return CUDNN_DATA_FLOAT;
+            }
+            else if constexpr(utils::typing::is_same_v<T, __nv_bfloat16>){
+                return CUDNN_DATA_BFLOAT16;
+            }
+            else{
+                static_assert(utils::typing::is_same_v<T, double>);
+                return CUDNN_DATA_DOUBLE;
+            }
+        }
+#endif
+    }
+#ifdef RL_TOOLS_BACKEND_ENABLE_CUDNN
+    template <typename SPEC>
+    void ensure_cudnn_workspace(devices::CUDA<SPEC>& device, size_t required_size){
+        if(required_size > device.cudnn_workspace_size){
+            if(device.cudnn_workspace){
+                cudaFree(device.cudnn_workspace);
+            }
+            auto result = cudaMalloc(&device.cudnn_workspace, required_size);
+            if(result != cudaSuccess){
+                std::cerr << "Failed to allocate cuDNN workspace (" << required_size << " bytes): " << cudaGetErrorString(result) << std::endl;
+                device.cudnn_workspace = nullptr;
+                device.cudnn_workspace_size = 0;
+                return;
+            }
+            device.cudnn_workspace_size = required_size;
+        }
+    }
+#endif
+    template <typename SPEC>
+    auto host_check_status(devices::CUDA<SPEC>& device){
+#ifdef RL_TOOLS_DEBUG_DEVICE_CUDA_CHECK_INIT
+        if(!device.initialized){
+            std::cerr << "CUDA device not initialized" << std::endl;
+        }
+#endif
+#ifdef RL_TOOLS_DEBUG_DEVICE_CUDA_SYNCHRONIZE_STATUS_CHECK
+        if (!device.graph_capture_active){
+            cudaDeviceSynchronize();
+            cudaStreamSynchronize(device.stream);
+        }
+        cudaError_t cudaStatus = cudaGetLastError();
+        if (cudaStatus != cudaSuccess){
+            std::string error_string = cudaGetErrorString(cudaStatus);
+            std::cerr << "cuda failed: " << error_string << std::endl;
+            std::exit(100);
+        }
+#endif
+    }
+    template <typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void check_status(devices::CUDA<SPEC>& device){
+        RL_TOOLS_HOST_ONLY(host_check_status(device));
+    }
+    template <typename DEV_SPEC, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void count_malloc(devices::CUDA<DEV_SPEC>& device, TI size){
+#ifdef RL_TOOLS_DEBUG_CONTAINER_COUNT_MALLOC
+        device.malloc_counter += size;
+#endif
+    }
+    template <typename DEV_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void set_dynamic_memory_allocation_allowed(devices::CUDA<DEV_SPEC>& device, bool allowed){
+        device.dynamic_memory_allocation_allowed = allowed;
+    }
+    template <typename DEV_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void disable_dynamic_memory_allocation(devices::CUDA<DEV_SPEC>& device){
+        set_dynamic_memory_allocation_allowed(device, false);
+    }
+    template <typename DEV_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void enable_dynamic_memory_allocation(devices::CUDA<DEV_SPEC>& device){
+        set_dynamic_memory_allocation_allowed(device, true);
+    }
+
+    void print_graph(cudaGraph_t graph){
+
+        // Step 8: Retrieve and list nodes and dependencies
+        // Get all nodes
+        size_t numNodes = 0;
+        cudaGraphGetNodes(graph, nullptr, &numNodes);
+        std::vector<cudaGraphNode_t> nodes(numNodes);
+        cudaGraphGetNodes(graph, nodes.data(), &numNodes);
+
+        // Assign indices to nodes
+        std::unordered_map<cudaGraphNode_t, int> nodeMap;
+        for(int i = 0; i < numNodes; ++i){
+            nodeMap[nodes[i]] = i;
+        }
+
+        // Get all edges (dependencies)
+        size_t numEdges = 0;
+#if CUDART_VERSION >= 13000
+        cudaGraphGetEdges(graph, nullptr, nullptr, nullptr, &numEdges);
+#else
+        cudaGraphGetEdges(graph, nullptr, nullptr, &numEdges);
+#endif
+        std::vector<cudaGraphNode_t> srcNodes(numEdges);
+        std::vector<cudaGraphNode_t> dstNodes(numEdges);
+        if(numEdges > 0){
+#if CUDART_VERSION >= 13000
+            cudaGraphGetEdges(graph, srcNodes.data(), dstNodes.data(), nullptr, &numEdges);
+#else
+            cudaGraphGetEdges(graph, srcNodes.data(), dstNodes.data(), &numEdges);
+#endif
+        }
+
+        // Map dependencies: destination node -> list of source nodes
+        std::vector<std::vector<int>> dependencies(numNodes, std::vector<int>());
+        for(int i = 0; i < numEdges; ++i){
+            int src = nodeMap[srcNodes[i]];
+            int dst = nodeMap[dstNodes[i]];
+            dependencies[dst].push_back(src);
+        }
+
+        // Print nodes and their dependencies
+        std::cout << "CUDA Graph Nodes and Dependencies:\n";
+        for(int i = 0; i < numNodes; ++i){
+            std::cout << "Node " << i << ": ";
+            cudaGraphNodeType nodeType;
+            cudaGraphNodeGetType(nodes[i], &nodeType);
+
+            std::string typeName;
+            switch(nodeType){
+            case cudaGraphNodeTypeKernel:
+                typeName = "Kernel";
+                break;
+            case cudaGraphNodeTypeMemcpy:
+                typeName = "Memcpy";
+                break;
+            case cudaGraphNodeTypeMemset:
+                typeName = "Memset";
+                break;
+                // Add other cases as needed
+            default:
+                typeName = "Other";
+                break;
+            }
+            std::cout << typeName << " ";
+            if(dependencies[i].empty()){
+                std::cout << "No dependencies";
+            }
+            else{
+                std::cout << "Depends on Node(s): ";
+                for(auto &dep : dependencies[i]){
+                    std::cout << dep << " ";
+                }
+            }
+            std::cout << "\n";
+        }
+    }
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/devices/cuda_streams.h

@@ -0,0 +1,23 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_CUDA_STREAMS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_CUDA_STREAMS_H
+
+#include "../rl_tools.h"
+#include <cuda_runtime.h>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices::cuda{
+    // orders consumer after the work enqueued so far on producer; the wait captures the record on
+    // the spot, so one event serves every join
+    inline void order_after(cudaEvent_t event, cudaStream_t producer, cudaStream_t consumer){
+        if(producer == consumer){
+            return;
+        }
+        cudaEventRecord(event, producer);
+        cudaStreamWaitEvent(consumer, event, 0);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/devices/devices.h

@@ -0,0 +1,105 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_DEVICES_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_DEVICES_H
+
+#include "../rl_tools.h"
+
+#include "../utils/generic/typing.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace devices {
+        struct ExecutionHints{};
+        namespace detail {
+            template <typename SPEC, typename = void>
+            struct Extension {};
+            template <typename SPEC>
+            struct Extension<SPEC, utils::typing::void_t<typename SPEC::DEVICE_EXTENSION>>: SPEC::DEVICE_EXTENSION {};
+        }
+        template <typename DEV_SPEC>
+        struct Device: detail::Extension<DEV_SPEC> {};
+        // todo: deprecate the global device id and move it to the cpu devices which sometimes need compatibility checks
+        enum class DeviceId{
+            Generic,
+            Dummy,
+            CPU,
+            CPU_BLAS,
+            CPU_MKL,
+            CPU_OPENBLAS,
+            CPU_ACCELERATE,
+            CPU_TENSORBOARD,
+            CUDA,
+            ARM,
+            ESP32,
+            WASM32
+        };
+        enum class Type {
+            math,
+            random,
+            logging
+        };
+        namespace logging{
+            enum class Verbosity{
+                error,
+                warning,
+                info,
+                debug
+            };
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices{
+    namespace generic{
+        namespace random{
+            template <typename T_MATH_DEVICE>
+            struct ENGINE{
+                using STATE_TYPE = typename T_MATH_DEVICE::index_t;
+                STATE_TYPE state;
+            };
+            // Portable RNG element with fixed 32-bit state for cross-device (CPU/CUDA) determinism
+            struct PortableState{
+                using STATE_TYPE = unsigned int;
+                STATE_TYPE state;
+            };
+            // Forward declaration; full definition in random/operations_generic_array.h
+            template <typename T_TI, T_TI T_NUM_RNGS, bool T_DYNAMIC_ALLOCATION = true>
+            struct ArraySpecification;
+            template <typename T_SPEC>
+            struct ArrayENGINE;
+        }
+    }
+    namespace random{
+        template <typename T_MATH_DEVICE>
+        struct Generic{
+            static constexpr Type TYPE = Type::random;
+            using MATH_DEVICE = T_MATH_DEVICE;
+            template <typename T_NOTHING = void>
+            using ENGINE = devices::generic::random::ENGINE<MATH_DEVICE>;
+        };
+    }
+    namespace math{
+        struct Generic{
+            static constexpr Type TYPE = Type::math;
+        };
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEV_SPEC>
+    void malloc(devices::Device<DEV_SPEC>& device){}
+    template <typename DEV_SPEC>
+    void init(devices::Device<DEV_SPEC>& device){}
+    template <typename DEV_SPEC, typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT void count_malloc(devices::Device<DEV_SPEC>& device, T){}
+    template <typename DEV_SPEC>
+    void free(devices::Device<DEV_SPEC>& device){}
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/devices/dummy.h

@@ -0,0 +1,55 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_DUMMY_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_DUMMY_H
+
+#include "../utils/generic/typing.h"
+#include "devices.h"
+#include <cstdint>
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices{
+    namespace dummy{
+        struct Base{
+            static constexpr DeviceId DEVICE_ID = DeviceId::Dummy;
+            using index_t = unsigned long long;
+            static constexpr index_t MAX_INDEX = static_cast<index_t>(-1);
+        };
+    }
+    namespace math{
+        struct Dummy: dummy::Base{
+            static constexpr Type TYPE = Type::math;
+        };
+    }
+    namespace random{
+        struct Dummy:devices::random::Generic<devices::math::Dummy>, dummy::Base{
+            static constexpr Type TYPE = Type::random;
+            template <typename T_ENGINE = void>
+            struct ENGINE{
+                unsigned state;
+            };
+        };
+    }
+    namespace logging{
+        struct Dummy: dummy::Base{
+            static constexpr Type TYPE = Type::logging;
+        };
+    }
+    template <typename T_SPEC>
+    struct Dummy: Device<T_SPEC>, dummy::Base{
+        template <typename OTHER_DEVICE>
+        static constexpr bool compatible = utils::typing::is_same_v<OTHER_DEVICE, Dummy<T_SPEC>>;
+        using SPEC = T_SPEC;
+        typename SPEC::LOGGING logger;
+        typename SPEC::MATH math;
+        typename SPEC::RANDOM random;
+    };
+    struct DefaultDummySpecification{
+        using MATH = math::Dummy;
+        using RANDOM = random::Dummy;
+        using LOGGING = logging::Dummy;
+    };
+    using DefaultDummy = Dummy<DefaultDummySpecification>;
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif