register.hpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#ifndef register_h
#define register_h
 
#include <concepts>
#include <cassert>
#include <unordered_map>
#include <unordered_set>
#include <sstream>
#include <complex>
#include <type_traits>
#include <limits>
#include <charconv>
#include <array>
#include <utility>
#include <unordered_set>
 
namespace jit {
    template<typename T>
    concept complex_scalar = std::same_as<T, std::complex<float>> ||
                             std::same_as<T, std::complex<double>>;
 
    template<typename T>
    concept float_scalar = std::floating_point<T> || complex_scalar<T>;
 
    template<typename T>
    concept scalar = float_scalar<T> || std::integral<T>;
 
    template<typename T>
    concept float_base = std::same_as<T, float> ||
                         std::same_as<T, std::complex<float>>;
 
    template<typename T>
    concept double_base = std::same_as<T, double> ||
                          std::same_as<T, std::complex<double>>;
 
    static bool verbose = USE_VERBOSE;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<float_scalar T>
    std::string type_to_string() {
        if constexpr (float_base<T>) {
            return "float";
        } else {
            return "double";
        }
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    constexpr bool use_cuda() {
#ifdef USE_CUDA
        return true;
#else
        return false;
#endif
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<float_scalar T>
    constexpr bool use_metal() {
#if USE_METAL
        return float_base<T> && !complex_scalar<T>;
#else
        return false;
#endif
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<float_scalar T>
    constexpr bool use_gpu() {
        return use_cuda() || use_metal<T> ();
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<float_scalar T>
    std::string smallest_uint_type(const size_t max_size) {
        if (max_size <= std::numeric_limits<unsigned char>::max()) {
            if constexpr (jit::use_metal<T> ()) {
                return "ushort";
            } else {
                return "uint8_t";
            }
        } else if (max_size <= std::numeric_limits<unsigned short>::max()) {
            if constexpr (jit::use_metal<T> ()) {
                return "ushort";
            } else {
                return "uint16_t";
            }
        } else if (max_size <= std::numeric_limits<unsigned int>::max()) {
            if constexpr (jit::use_metal<T> ()) {
                return "uint";
            } else {
                return "uint32_t";
            }
        } else {
            if constexpr (jit::use_metal<T> ()) {
                return "uint";
            } else {
                return "size_t";
            }
        }
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<float_scalar T>
    std::string get_type_string() {
        if constexpr (complex_scalar<T>) {
            if constexpr (use_cuda()) {
                return "cuda::std::complex<" + type_to_string<T> () + ">";
            } else {
                return "std::complex<" + type_to_string<T> () + ">";
            }
        } else {
            return type_to_string<T> ();
        }
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<float_scalar T>
    void add_type(std::basic_ostream<char> &stream) {
        stream << get_type_string<T> ();
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<float_scalar T>
    constexpr int max_digits10() {
        if constexpr (float_base<T>) {
            return std::numeric_limits<float>::max_digits10;
        } else {
            return std::numeric_limits<double>::max_digits10;
        }
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<float_scalar T>
    constexpr T max_base() {
        if constexpr (float_base<T>) {
            return static_cast<T> (std::numeric_limits<float>::max());
        } else {
            return static_cast<T> (std::numeric_limits<double>::max());
        }
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<scalar T>
    std::string format_to_string(const T value) {
        std::array<char, 36> buffer;
        char *end;
        if constexpr (std::is_same<T, size_t>::value) {
            end = std::to_chars(buffer.begin(),
                                buffer.end(),
                                value, 16).ptr;
        } else if constexpr (complex_scalar<T>) {
            return format_to_string(std::real(value)) + "," +
                   format_to_string(std::imag(value));
        } else {
            end = std::to_chars(buffer.begin(), buffer.end(),
                                value, std::chars_format::general,
                                max_digits10<T> ()).ptr;
        }
        return std::string(buffer.data(), end);
    }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<class NODE>
    std::string to_string(const char prefix,
                          const NODE *pointer) {
        assert((prefix == 'r' || prefix == 'v' ||
                prefix == 'o' || prefix == 'a' ||
                prefix == 'i' || prefix == 's' ||
                prefix == 'l' || prefix == 't') &&
               "Expected a variable (v), register (r), output (o), array (a), index (i), state (s), logical (l), or (t) thread prefix.");
        return std::string(1, prefix) +
               format_to_string(reinterpret_cast<size_t> (pointer));
    }
 
    typedef std::unordered_map<void *, std::string> register_map;
    typedef std::unordered_map<void *, size_t> register_usage;
    typedef std::unordered_set<void *> visiter_map;
    typedef std::unordered_map<void *, size_t> texture1d_list;
    typedef std::unordered_map<void *, std::array<size_t,2>> texture2d_list;
    typedef std::unordered_set<std::string> preamble_map;
    typedef std::unordered_set<void *> argument_set;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<float_scalar T>
    class float_compare {
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        bool operator() (const T &left, const T &right) const {
            if constexpr (complex_scalar<T>) {
                return std::abs(left) < std::abs(right);
            } else {
                return left < right;
            }
        }
    };
}
 
#endif /* register_h */