itrace_numpy_defines.h

Go to the documentation of this file.

#ifndef ITRACE_NUMPY_DEFINES_H
#define ITRACE_NUMPY_DEFINES_H

#include <cassert>
#include <string_view>

/* Header for all itrace numpy messages */
constexpr std::string_view itrace_numpy_header {"('thread','<i8'),('start','<u8'),('end','<u8'),('cycles', '<u8')"};

template <typename T>
inline const char* get_numpy_element()
{
    static_assert(std::is_arithmetic_v<T>, "get_numpy_element is only for arithmetic types - check numpy implementation");
    if (std::is_floating_point_v<T>) // floating point case
    {
        if (sizeof(T) > 4)
            return "<f8";
        else
            return "<f4";
    }
    else if (std::is_integral_v<T>)
    {
        if constexpr (std::is_unsigned_v<T>)
        {
            switch (sizeof(T))
            {
            case 1:
                return "<u1";
            case 2:
                return "<u2";
            case 4:
                return "<u4";
            case 8:
                return "<u8";
            }
        }
        else
        {
            switch (sizeof(T))
            {
            case 1:
                return "<i1";
            case 2:
                return "<i2";
            case 4:
                return "<i4";
            case 8:
                return "<i8";
            }
        }
    }
    assert(false);
    return "";
}

template <typename T>
struct compute_numpy_type
{
    static std::string get(const std::string& name)
    {
        return "('" + name + "','" + get_numpy_element<T>() + "')";
    }
};

template <typename EL, int SIZE>
struct compute_numpy_type<std::array<EL, SIZE>>
{
    static std::string get(const std::string& name)
    {
      const int BUFFER_SIZE = 64;
      char buffer[BUFFER_SIZE];
      int len = 0;
      if constexpr (std::is_same_v<EL,char>)
      {
         len = snprintf(buffer, sizeof(buffer), "('%s', 'S%d')", name.c_str(), SIZE);
      }
      else
      {
         len = snprintf(buffer, sizeof(buffer), "('%s', '%s', (%d,))", name.c_str(), get_numpy_element<EL>(), SIZE);
      }

      assert(len < BUFFER_SIZE);

      if (len < 0)
      {
         return {};
      }

      return { buffer, static_cast<size_t>(len) };
    }
};


#endif // ITRACE_NUMPY_DEFINES_H