async_node.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include "shared_storage.hpp"
#include <uni20/common/demangle.hpp>
#include <uni20/config.hpp>
#include <uni20/core/scalar_io.hpp>
 
#include <atomic>
#include <cstddef>
#include <mutex>
#include <string>
#include <string_view>
#include <type_traits>
#include <unordered_map>
 
namespace uni20::async
{
 
enum class NodeValueState
{
  Invalid,       
  Unconstructed, 
  Constructed,   
};
 
namespace detail
{
 
void uni20_async_debug_value();
 
template <typename T>
concept HasAdlAsyncDebugValue = requires(T const& value) { std::string{uni20_async_debug_value(value)}; };
 
template <typename Extents> std::string format_shape_debug_info(Extents const& extents)
{
  using extents_type = std::remove_cvref_t<Extents>;
  std::string out = "shape=(";
  for (std::size_t axis = 0; axis < static_cast<std::size_t>(extents_type::rank()); ++axis)
  {
    if (axis != 0) out += ", ";
    out += std::to_string(static_cast<unsigned long long>(extents.extent(axis)));
  }
  out += ")";
  return out;
}
 
template <typename T>
concept HasMdspanExtents = requires(T const& value, std::size_t axis) {
  std::remove_cvref_t<decltype(value.mdspan().extents())>::rank();
  value.mdspan().extents().extent(axis);
};
 
template <typename T>
concept HasExtents = requires(T const& value, std::size_t axis) {
  std::remove_cvref_t<decltype(value.extents())>::rank();
  value.extents().extent(axis);
};
 
inline std::string sanitize_debug_value(std::string value)
{
  for (char& ch : value)
  {
    if (ch == '\n' || ch == '\r' || ch == '\t') ch = ' ';
  }
  return value;
}
 
template <typename T> std::string scalar_debug_info(T const& value)
{
  using value_type = std::remove_cvref_t<T>;
  if constexpr (std::is_same_v<value_type, bool>)
  {
    return value ? "true" : "false";
  }
  else if constexpr (std::is_same_v<value_type, char>)
  {
    return std::string{"'"} + value + "'";
  }
  else if constexpr (std::is_integral_v<value_type>)
  {
    if constexpr (std::is_signed_v<value_type>)
      return std::to_string(static_cast<long long>(value));
    else
      return std::to_string(static_cast<unsigned long long>(value));
  }
  else if constexpr (uni20::RealOrComplex<value_type>)
  {
    return uni20::format_scalar(value);
  }
  else if constexpr (std::is_enum_v<value_type>)
  {
    using underlying_type = std::underlying_type_t<value_type>;
    return scalar_debug_info(static_cast<underlying_type>(value));
  }
  else
  {
    return {};
  }
}
 
template <typename T> std::string default_debug_value(T const& value)
{
  if constexpr (HasMdspanExtents<T>)
  {
    auto span = value.mdspan();
    return format_shape_debug_info(span.extents());
  }
  else if constexpr (HasExtents<T>)
  {
    return format_shape_debug_info(value.extents());
  }
  else
  {
    return scalar_debug_info(value);
  }
}
 
template <typename T> std::string debug_value_for_value(T const& value)
{
  if constexpr (HasAdlAsyncDebugValue<T>)
  {
    return sanitize_debug_value(std::string{uni20_async_debug_value(value)});
  }
  else
  {
    return sanitize_debug_value(default_debug_value(value));
  }
}
 
} // namespace detail
 
class NodeInfo {
  public:
    NodeInfo() = delete;
 
    [[nodiscard]] void const* address() const
    {
      return value_address_observer_ ? value_address_observer_(storage_address_) : fallback_value_address_;
    }
 
    [[nodiscard]] void const* storage_address() const { return storage_address_; }
 
    [[nodiscard]] NodeValueState value_state() const noexcept
    {
      if (value_constructed_observer_)
      {
        if (!storage_address_) return NodeValueState::Invalid;
        return value_constructed_observer_(storage_address_) ? NodeValueState::Constructed
                                                             : NodeValueState::Unconstructed;
      }
      return fallback_value_address_ ? NodeValueState::Constructed : NodeValueState::Invalid;
    }
 
    [[nodiscard]] std::string_view value_state_label() const noexcept
    {
      switch (this->value_state())
      {
        case NodeValueState::Invalid:
          return "invalid";
        case NodeValueState::Unconstructed:
          return "unconstructed";
        case NodeValueState::Constructed:
          return "constructed";
      }
      return "invalid";
    }
 
    [[nodiscard]] bool value_constructed() const noexcept { return this->value_state() == NodeValueState::Constructed; }
 
    [[nodiscard]] std::string value_text() const
    {
      auto const state = this->value_state();
      if (state != NodeValueState::Constructed) return {};
      if (!value_text_observer_) return {};
      auto const* context = value_constructed_observer_ ? storage_address_ : fallback_value_address_;
      return value_text_observer_(context);
    }
 
    [[nodiscard]] std::string_view type() const
    {
      std::lock_guard<std::mutex> lock(map_mutex_);
      auto [it, inserted] = map_.try_emplace(type_key_, uni20::demangle::demangle(type_key_));
      return std::string_view(it->second);
    }
 
    [[nodiscard]] uint64_t global_index() const { return global_index_; }
 
#if 0 && UNI20_HAS_STACKTRACE
    std::stacktrace const& stack() const { return stack_; }
#endif
 
    // Keep the diagnostic-only allocation frame visible to sanitizer symbolizers.
    // GCC's libbacktrace can omit inlined frames even with full debug information.
    template <typename T> [[gnu::noinline]] static NodeInfo const* create(T const* value)
    {
      return new NodeInfo(value);
    }
 
    template <typename T> [[gnu::noinline]] static NodeInfo const* create(shared_storage<T> const& storage)
    {
      return new NodeInfo(storage);
    }
 
  private:
    using ValueAddressObserver = void const* (*)(void const*) noexcept;
    using ValueConstructedObserver = bool (*)(void const*) noexcept;
    using ValueTextObserver = std::string (*)(void const*);
 
    template <typename T> static std::string text_for_raw_value(void const* value)
    {
      return value ? detail::debug_value_for_value(*static_cast<T const*>(value)) : std::string{};
    }
 
    template <typename T> static std::string text_for_storage_value(void const* control)
    {
      auto const* value = static_cast<T const*>(shared_storage<T>::diagnostic_value_address_from_control(control));
      return value ? detail::debug_value_for_value(*value) : std::string{};
    }
 
    template <typename T>
    NodeInfo(T const* value)
        : fallback_value_address_(static_cast<void const*>(value)), type_key_(typeid(T).name()),
          value_text_observer_(&NodeInfo::text_for_raw_value<T>), global_index_(next_global_++)
#if 0 && UNI20_HAS_STACKTRACE
          ,
          stack_(std::stacktrace::current())
#endif
    {}
 
    template <typename T>
    explicit NodeInfo(shared_storage<T> const& storage)
        : storage_address_(storage.control_address()), fallback_value_address_(static_cast<void const*>(storage.get())),
          type_key_(typeid(T).name()),
          value_address_observer_(&shared_storage<T>::diagnostic_value_address_from_control),
          value_constructed_observer_(&shared_storage<T>::diagnostic_constructed_from_control),
          value_text_observer_(&NodeInfo::text_for_storage_value<T>), global_index_(next_global_++)
#if 0 && UNI20_HAS_STACKTRACE
          ,
          stack_(std::stacktrace::current())
#endif
    {}
 
    // global data for the map of mangled name to demangled name (protected by map_mutex_), and the global index
    inline static std::unordered_map<const char*, std::string> map_;
    inline static std::mutex map_mutex_;
    inline static std::atomic<uint64_t> next_global_ = 0;
 
    // Per-instance data:
    void const* storage_address_{nullptr};                  
    void const* fallback_value_address_{nullptr};           
    char const* type_key_;                                  
    ValueAddressObserver value_address_observer_{};         
    ValueConstructedObserver value_constructed_observer_{}; 
    ValueTextObserver value_text_observer_{};               
    uint64_t global_index_;                                 
#if 0 && UNI20_HAS_STACKTRACE
    std::stacktrace stack_; 
#endif
};
 
} // namespace uni20::async