hyperdrone 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,91 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_ARM_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_ARM_H
+
+#include "../utils/generic/typing.h"
+#include "devices.h"
+
+#include <cstddef>
+#include <cstdint>
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices{
+    namespace arm{
+        template <typename T_MATH, typename T_RANDOM, typename T_LOGGING>
+        struct Specification{
+            using MATH = T_MATH;
+            using RANDOM = T_RANDOM;
+            using LOGGING = T_LOGGING;
+        };
+        struct Base{
+            static constexpr DeviceId DEVICE_ID = DeviceId::ARM;
+            using index_t = size_t;
+            static constexpr index_t MAX_INDEX = -1;
+
+        };
+    }
+    namespace math{
+        struct ARM: arm::Base{
+            static constexpr Type TYPE = Type::math;
+        };
+    }
+    namespace random{
+        struct ARM: devices::random::Generic<typename math::ARM>, arm::Base{
+            static constexpr Type TYPE = Type::random;
+            template <bool T_DYNAMIC_ALLOCATION=false>
+            struct EngineSpecification{
+                static constexpr bool DYNAMIC_ALLOCATION = T_DYNAMIC_ALLOCATION;
+            };
+            template <typename SPEC = EngineSpecification<>>
+            struct ENGINE{
+                arm::Base::index_t state;
+            };
+        };
+    }
+    namespace logging{
+        struct ARM: arm::Base{
+            static constexpr Type TYPE = Type::logging;
+        };
+        struct ARDUINO: arm::Base{
+            static constexpr Type TYPE = Type::logging;
+        };
+    }
+    template <typename T_SPEC>
+    struct ARM: Device<T_SPEC>, arm::Base{
+        template <typename OTHER_DEVICE>
+        static constexpr bool compatible = OTHER_DEVICE::DEVICE == DeviceId::ARM;
+        using SPEC = T_SPEC;
+        typename SPEC::MATH math;
+        typename SPEC::RANDOM random;
+        typename SPEC::LOGGING logger;
+#ifdef RL_TOOLS_DEBUG_CONTAINER_COUNT_MALLOC
+        index_t malloc_counter = 0;
+#endif
+    };
+
+    namespace arm{
+        template <typename T_SPEC>
+        struct Generic: ARM<T_SPEC>{};
+        template <typename T_SPEC>
+        struct DSP: ARM<T_SPEC>{};
+        template <typename T_SPEC>
+        struct OPT: ARM<T_SPEC>{};
+    }
+
+    using DefaultARMSpecification = arm::Specification<math::ARM, random::ARM, logging::ARM>;
+    using DefaultARM = arm::OPT<DefaultARMSpecification>;
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+#ifdef RL_TOOLS_DEBUG_CONTAINER_COUNT_MALLOC
+    template <typename DEV_SPEC, typename TI>
+    void count_malloc(devices::ARM<DEV_SPEC>& device, TI size){
+        device.malloc_counter += size;
+    }
+#endif
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,205 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_CPU_H
+
+#include "devices.h"
+#include "../utils/generic/typing.h"
+
+#include <cstddef>
+#include <string>
+#include <algorithm>
+#include <ctime>
+#include <limits>
+#include <random>
+#include <iostream>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices{
+    namespace cpu{
+        template <typename T_MATH, typename T_RANDOM, typename T_LOGGING>
+        struct Specification{
+            using EXECUTION_HINTS = ExecutionHints;
+            using MATH = T_MATH;
+            using RANDOM = T_RANDOM;
+            using LOGGING = T_LOGGING;
+            using index_t = size_t;
+        };
+        struct Base{
+            static constexpr DeviceId DEVICE_ID = DeviceId::CPU;
+            using index_t = size_t;
+            static constexpr index_t MAX_INDEX = std::numeric_limits<index_t>::max();
+        };
+    }
+    namespace math{
+        struct CPU: cpu::Base{
+            static constexpr Type TYPE = Type::math;
+        };
+    }
+    namespace random{
+        struct CPU: devices::random::Generic<devices::math::CPU>, cpu::Base{
+            static constexpr Type TYPE = Type::random;
+            template <typename T_ENGINE = std::mt19937>
+            struct ENGINE{
+                using TYPE = T_ENGINE;
+                TYPE engine;
+            };
+        };
+    }
+    namespace logging{
+        struct CPU: cpu::Base{
+            static constexpr Type TYPE = Type::logging;
+        };
+    }
+    template <typename T_SPEC>
+    struct CPU: Device<T_SPEC>, cpu::Base{
+        using SPEC = T_SPEC;
+        using EXECUTION_HINTS = typename SPEC::EXECUTION_HINTS;
+        typename SPEC::MATH math;
+        typename SPEC::RANDOM random;
+        typename SPEC::LOGGING logger;
+        bool initialized = false;
+        index_t malloc_counter = 0;
+    };
+
+    using DefaultCPUSpecification = cpu::Specification<math::CPU, random::CPU, logging::CPU>;
+    using DefaultCPU = CPU<DefaultCPUSpecification>;
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace devices::cpu{
+        inline void display_compile_options() {
+            bool isOptimal = true;
+            const char* ANSI_RED = "\033[31m";
+            const char* ANSI_GREEN = "\033[32m";
+            const char* ANSI_YELLOW = "\033[33m";
+            const char* ANSI_RESET = "\033[0m";
+
+            // Check debug mode
+            bool isDebug =
+            #if defined(_DEBUG) || defined(DEBUG)
+                true;
+            #else
+                false;
+            #endif
+            if (isDebug) isOptimal = false;
+
+            // Check optimization
+            bool maxOpt =
+            #if defined(_MSC_VER)
+                #if defined(_FULL_OPTIMIZATION)
+                    true;
+                #else
+                    false;
+                #endif
+            #elif defined(__GNUC__) || defined(__clang__)
+                #if defined(__OPTIMIZE__)
+                    true;
+                #else
+                    false;
+                #endif
+            #else
+                false;
+            #endif
+            if (!maxOpt) isOptimal = false;
+
+            // Check fast math
+            bool fastMath =
+            #if defined(__FAST_MATH__) || defined(_M_FP_FAST)
+                true;
+            #else
+                false;
+            #endif
+            if (!fastMath) isOptimal = false;
+
+            if (!isOptimal) {
+                std::cerr << "Compiliation Options:" << std::endl;
+
+                // Output debug status
+                std::cerr << ((!isDebug) ? ANSI_GREEN : ANSI_RED) << "["
+                          << ((!isDebug) ? "OK" : "NOT OK") << "]" << ANSI_RESET
+                          << " Debug Mode: " << (isDebug ? "Yes" : "No") << std::endl;
+
+                // Output optimization status
+                std::cerr << (maxOpt ? ANSI_GREEN : ANSI_RED) << "["
+                          << (maxOpt ? "OK" : "NOT OK") << "]" << ANSI_RESET
+                          << " Optimization: " << (maxOpt ? "Yes" : "No") << std::endl;
+
+                // Output fast math status
+                std::cerr << (fastMath ? ANSI_GREEN : ANSI_RED) << "["
+                          << (fastMath ? "OK" : "NOT OK") << "]" << ANSI_RESET
+                          << " Fast Math: " << (fastMath ? "Yes" : "No") << std::endl;
+
+                // Output optimization level
+                std::cerr << "Optimization Level: "
+                #if defined(_MSC_VER)
+                    #if defined(_FULL_OPTIMIZATION)
+                          << "Full (/Ox)"
+                    #elif defined(_OPTIMIZATION_FULL)
+                          << "Full (/O2)"
+                    #elif defined(_OPTIMIZATION_SPEED)
+                          << "Speed (/O2)"
+                    #elif defined(_OPTIMIZATION_DEBUG)
+                          << "Debug (/Od)"
+                    #else
+                          << "Unknown"
+                    #endif
+                #elif defined(__clang__)
+                    #if defined(__OPTIMIZE__)
+                        #if defined(__OPTIMIZE_SIZE__)
+                              << "-Os"
+                        #elif (__OPTIMIZE__ == 1)
+                              << "-O1"
+                        #elif (__OPTIMIZE__ == 2)
+                              << "-O2"
+                        #elif (__OPTIMIZE__ == 3)
+                              << "-O3"
+                        #else
+                              << "Unknown level"
+                        #endif
+                    #else
+                          << "-O0"
+                    #endif
+                #else
+                          << "Unknown"
+                #endif
+                          << std::endl;
+
+                std::cerr << ANSI_YELLOW << "WARNING: Non-optimal configuration detected!"
+                          << ANSI_RESET << std::endl;
+                std::cerr << "For maximum performance, compile with:" << std::endl;
+                #if defined(_MSC_VER)
+                    std::cerr << "MSVC: /O2 /fp:fast /DNDEBUG" << std::endl;
+                #elif defined(__GNUC__) || defined(__clang__)
+                    std::cerr << "GCC/Clang: -Ofast (or -DCMAKE_BUILD_TYPE=Release)" << std::endl;
+                #else
+                    std::cerr << "Unknown compiler: please consult compiler documentation" << std::endl;
+                #endif
+                std::cerr << std::endl;
+            }
+        }
+    }
+    template <typename DEV_SPEC>
+    void init(devices::CPU<DEV_SPEC>& device){
+        if(!device.initialized){
+#ifndef __CLING__
+            devices::cpu::display_compile_options();
+#endif
+            device.initialized = true;
+        }
+    }
+    template <typename DEV_SPEC, typename TI>
+    void count_malloc(devices::CPU<DEV_SPEC>& device, TI size){
+        device.malloc_counter += size;
+        if (size > 100000000){
+            std::cerr << "Large malloc: " << size / 1000000 << "MB, total: " << device.malloc_counter / 1000000 << " MB" << std::endl;
+        }
+    }
+    template <typename SPEC>
+    void check_status(devices::CPU<SPEC>& device){ }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,23 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_CPU_ACCELERATE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_CPU_ACCELERATE_H
+
+#include "../utils/generic/typing.h"
+#include "devices.h"
+
+#define ACCELERATE_NEW_LAPACK
+#define ACCELERATE_LAPACK_ILP64
+#include "cpu_blas.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices{
+    template <typename T_SPEC>
+    struct CPU_ACCELERATE: CPU_BLAS<T_SPEC>{
+        static constexpr DeviceId DEVICE_ID = DeviceId::CPU_ACCELERATE;
+    };
+    using DefaultCPU_ACCELERATE = CPU_ACCELERATE<DefaultCPUSpecification>;
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,21 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_CPU_BLAS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_CPU_BLAS_H
+
+#include "../utils/generic/typing.h"
+#include "devices.h"
+
+#include "cpu.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices{
+    template <typename T_SPEC>
+    struct CPU_BLAS: CPU<T_SPEC>{
+        static constexpr DeviceId DEVICE_ID = DeviceId::CPU_BLAS;
+    };
+    using DefaultCPU_BLAS = CPU_BLAS<DefaultCPUSpecification>;
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,45 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_CPU_MKL_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_CPU_MKL_H
+
+#include "../utils/generic/typing.h"
+#include "devices.h"
+
+#include "cpu_blas.h"
+#include <iostream>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace devices{
+        template <typename T_SPEC>
+        struct CPU_MKL: CPU_BLAS<T_SPEC>{
+            static constexpr DeviceId DEVICE_ID = DeviceId::CPU_MKL;
+            void* dnnl_context = nullptr;
+        };
+        using DefaultCPU_MKL = CPU_MKL<DefaultCPUSpecification>;
+    }
+    template <typename T_SPEC>
+    void init(devices::CPU_MKL<T_SPEC>& device){
+        init(static_cast<devices::CPU_BLAS<T_SPEC>&>(device));
+        using DEVICE = devices::CPU_MKL<T_SPEC>;
+        const char* env_var_names[] = {"MKL_NUM_THREADS", "OMP_NUM_THREADS"};
+        for(const char* env_var_name : env_var_names){
+            const char *value = getenv(env_var_name);
+            bool warn = true;
+            if (value != NULL) {
+                char *endptr;
+                typename DEVICE::index_t num_threads = strtol(value, &endptr, 10);
+                if (*endptr == '\0') {
+                    warn = num_threads != 1;
+                }
+            }
+            if(warn){
+                std::cerr << "Warning: " << env_var_name << " is not set to 1. This may degrade performance." << std::endl;
+            }
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,56 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_CPU_OPENBLAS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_CPU_OPENBLAS_H
+
+#include "../utils/generic/typing.h"
+#include "devices.h"
+
+#include "cpu_blas.h"
+
+// based on: https://github.com/OpenMathLib/OpenBLAS/blob/24c5152fbd8027a39759acf261e1595326ab0114/cblas.h
+extern "C" {
+    typedef enum CBLAS_ORDER     {CblasRowMajor=101, CblasColMajor=102} CBLAS_ORDER;
+    typedef enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113, CblasConjNoTrans=114} CBLAS_TRANSPOSE;
+    #ifndef OPENBLAS_CONST
+    # define OPENBLAS_CONST const
+    #endif
+    typedef int blasint;
+    void cblas_sgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
+    void cblas_dgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
+}
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices{
+    template <typename T_SPEC>
+    struct CPU_OPENBLAS: CPU_BLAS<T_SPEC>{
+        static constexpr DeviceId DEVICE_ID = DeviceId::CPU_OPENBLAS;
+    };
+    using DefaultCPU_OPENBLAS = CPU_OPENBLAS<DefaultCPUSpecification>;
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEV_SPEC>
+    void init(devices::CPU_OPENBLAS<DEV_SPEC>& device){
+        init(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device));
+        using DEVICE = devices::CPU_OPENBLAS<DEV_SPEC>;
+        const char *env_var_name = "OPENBLAS_NUM_THREADS";
+        const char *value = getenv(env_var_name);
+        bool warn = true;
+        if (value != NULL) {
+            char *endptr;
+            typename DEVICE::index_t num_threads = strtol(value, &endptr, 10);
+            if (*endptr == '\0') {
+                warn = num_threads != 1;
+            }
+        }
+        if(warn){
+            std::cerr << "Warning: " << env_var_name << " is not set to 1. This may degrade performance." << std::endl;
+        }
+    }
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,34 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DEVICES_CPU_TENSORBOARD_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DEVICES_CPU_TENSORBOARD_H
+
+#include "devices.h"
+#include "cpu.h"
+
+#include <tensorboard_logger/tensorboard_logger.h>
+#include <mutex>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::devices{
+    namespace logging{
+        struct CPU_TENSORBOARD_FREQUENCY_EXTENSION: logging::CPU{
+            using TI = typename logging::CPU::index_t;
+            std::map<std::string, TI> topic_frequency_dict;
+        };
+        template <typename PARENT=logging::CPU>
+        struct CPU_TENSORBOARD: PARENT{
+            using TI = typename logging::CPU::index_t;
+            static constexpr DeviceId DEVICE_ID = DeviceId::CPU_TENSORBOARD;
+            static constexpr Type TYPE = Type::logging;
+            TI step = 0;
+            TensorBoardLogger* tb = nullptr;
+            std::mutex mutex;
+        };
+    }
+    using DefaultCPU_TENSORBOARDSpecification = cpu::Specification<math::CPU, random::CPU, logging::CPU_TENSORBOARD<>>;
+    using DefaultCPU_TENSORBOARD = CPU<DefaultCPU_TENSORBOARDSpecification>;
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif