task_registry_dummy.hpp

Go to the documentation of this file.

#pragma once
 
#include "task_registry_snapshot.hpp"
 
#include <coroutine>
#include <cstdio>
#include <exception>
#include <string>
#include <vector>
 
namespace uni20::async
{
class EpochContext;
class NodeInfo;
} // namespace uni20::async
 
namespace uni20
{
 
class TaskRegistry {
  public:
    enum class DumpMode
    {
      None,
      Basic,
      Full,
    };
 
    enum class TaskState
    {
      Constructed,
      Running,
      Suspended,
      Failed,
      Leaked,
    };
 
    enum class EpochTaskRole
    {
      Reader,
      Writer,
    };
 
    struct GraphvizDumpOptions
    {
        std::string output_dir{"/tmp"};
        std::string file_prefix{"uni20-dag"};
    };
 
    struct CoroutineExceptionDiagnosticsOptions
    {
        bool enabled{false};
        bool write_graphviz{true};
        GraphvizDumpOptions dump_options{};
    };
 
    struct DiagnosticsServiceOptions
    {
        GraphvizDumpOptions dump_options{};
        int signal_number{0};
        std::string request_file{};
        int poll_interval_ms{250};
        bool block_signal_in_calling_thread{true};
    };
 
    using StacktraceOptions = TaskRegistryStacktraceOptions;
 
    using GraphSnapshot = TaskRegistryGraphSnapshot;
 
    using GraphDiagnostics = TaskRegistryGraphDiagnostics;
 
    static constexpr void register_task(std::coroutine_handle<> h) noexcept { static_cast<void>(h); }
    static constexpr void destroy_task(std::coroutine_handle<> h) noexcept { static_cast<void>(h); }
    static constexpr void leak_task(std::coroutine_handle<> h) noexcept { static_cast<void>(h); }
    static constexpr void mark_running(std::coroutine_handle<> h) noexcept { static_cast<void>(h); }
    static constexpr void mark_suspended(std::coroutine_handle<> h) noexcept { static_cast<void>(h); }
    static constexpr void record_unhandled_exception(std::coroutine_handle<> h, std::exception_ptr exception,
                                                     bool originating_failure) noexcept
    {
      static_cast<void>(h);
      static_cast<void>(exception);
      static_cast<void>(originating_failure);
    }
    static constexpr void record_task_scheduled(std::coroutine_handle<> h) noexcept { static_cast<void>(h); }
    static constexpr void
    record_task_dependencies(std::coroutine_handle<> h, std::vector<async::NodeInfo const*> const& read_dependencies,
                             std::vector<async::NodeInfo const*> const& write_dependencies) noexcept
    {
      static_cast<void>(h);
      static_cast<void>(read_dependencies);
      static_cast<void>(write_dependencies);
    }
    static constexpr void record_await_dependency(std::coroutine_handle<> h, async::NodeInfo const* node,
                                                  EpochTaskRole role) noexcept
    {
      static_cast<void>(h);
      static_cast<void>(node);
      static_cast<void>(role);
    }
    static void name_task(std::coroutine_handle<> h, std::string const& label) noexcept
    {
      static_cast<void>(h);
      static_cast<void>(label);
    }
    static void name_async_value(async::NodeInfo const* node, std::string const& label) noexcept
    {
      static_cast<void>(node);
      static_cast<void>(label);
    }
    static constexpr void register_epoch_context(async::EpochContext const* epoch_context) noexcept
    {
      static_cast<void>(epoch_context);
    }
    static constexpr void destroy_epoch_context(async::EpochContext const* epoch_context) noexcept
    {
      static_cast<void>(epoch_context);
    }
    static constexpr void bind_epoch_task(async::EpochContext const* epoch_context, std::coroutine_handle<> h,
                                          EpochTaskRole role) noexcept
    {
      static_cast<void>(epoch_context);
      static_cast<void>(h);
      static_cast<void>(role);
    }
    static constexpr void unbind_epoch_task(async::EpochContext const* epoch_context, std::coroutine_handle<> h,
                                            EpochTaskRole role) noexcept
    {
      static_cast<void>(epoch_context);
      static_cast<void>(h);
      static_cast<void>(role);
    }
    static std::vector<std::coroutine_handle<>> epoch_reader_tasks(async::EpochContext const* epoch_context)
    {
      static_cast<void>(epoch_context);
      return {};
    }
    static std::vector<std::coroutine_handle<>> epoch_writer_tasks(async::EpochContext const* epoch_context)
    {
      static_cast<void>(epoch_context);
      return {};
    }
    static constexpr DumpMode dump_mode() noexcept { return DumpMode::None; }
    static constexpr void dump_epoch_context(async::EpochContext const* epoch_context,
                                             char const* reason = nullptr) noexcept
    {
      static_cast<void>(epoch_context);
      static_cast<void>(reason);
    }
    static constexpr void dump() noexcept {}
    static GraphSnapshot snapshot() { return GraphSnapshot{}; }
    static GraphSnapshot snapshot_best_effort() { return snapshot(); }
    static GraphDiagnostics diagnose_snapshot(GraphSnapshot const& snapshot)
    {
      static_cast<void>(snapshot);
      return GraphDiagnostics{};
    }
    static std::string graphviz_dot() { return "digraph uni20_async_dag {\n  rankdir=LR;\n}\n"; }
    static std::string graphviz_dot_best_effort() { return graphviz_dot(); }
    static std::string graphviz_dot(GraphSnapshot const& snapshot)
    {
      static_cast<void>(snapshot);
      return graphviz_dot();
    }
    static std::string graphviz_dot(GraphSnapshot const& snapshot, GraphDiagnostics const& diagnostics)
    {
      static_cast<void>(snapshot);
      static_cast<void>(diagnostics);
      return graphviz_dot();
    }
    static void dump_graphviz(std::FILE* stream = stderr)
    {
      if (!stream) return;
      auto dot = graphviz_dot();
      std::fputs(dot.c_str(), stream);
    }
    static bool dump_graphviz_file(std::string const& path)
    {
      if (auto* stream = std::fopen(path.c_str(), "w"); stream)
      {
        auto dot = graphviz_dot();
        auto const ok = std::fputs(dot.c_str(), stream) >= 0;
        return std::fclose(stream) == 0 && ok;
      }
      return false;
    }
    static bool dump_graphviz_file_best_effort(std::string const& path) { return dump_graphviz_file(path); }
    static GraphvizDumpOptions default_graphviz_dump_options() { return GraphvizDumpOptions{}; }
    static CoroutineExceptionDiagnosticsOptions default_coroutine_exception_diagnostics_options()
    {
      return CoroutineExceptionDiagnosticsOptions{};
    }
    static CoroutineExceptionDiagnosticsOptions coroutine_exception_diagnostics_options()
    {
      return CoroutineExceptionDiagnosticsOptions{};
    }
    static void
    set_coroutine_exception_diagnostics_options(CoroutineExceptionDiagnosticsOptions const& options) noexcept
    {
      static_cast<void>(options);
    }
    static constexpr void reset_coroutine_exception_diagnostics_options() noexcept {}
    static DiagnosticsServiceOptions default_diagnostics_service_options() { return DiagnosticsServiceOptions{}; }
    static StacktraceOptions default_stacktrace_options() { return StacktraceOptions{}; }
    static StacktraceOptions stacktrace_options() { return default_stacktrace_options(); }
    static void set_stacktrace_options(StacktraceOptions const& options) noexcept { static_cast<void>(options); }
    static constexpr void reset_stacktrace_options() noexcept {}
    static std::string default_graphviz_dump_path()
    {
      return default_graphviz_dump_path(default_graphviz_dump_options());
    }
    static std::string default_graphviz_dump_path(GraphvizDumpOptions const& options)
    {
      auto dir = options.output_dir.empty() ? std::string(".") : options.output_dir;
      if (!dir.empty() && dir.back() == '/') dir.pop_back();
      return dir + "/" + options.file_prefix + ".dot";
    }
    static constexpr void request_graphviz_dump() noexcept {}
    static bool service_debug_requests() noexcept { return false; }
    static bool service_debug_requests(GraphvizDumpOptions const& options) noexcept
    {
      static_cast<void>(options);
      return false;
    }
    static bool start_diagnostics_service() noexcept { return false; }
    static bool start_diagnostics_service(DiagnosticsServiceOptions const& options) noexcept
    {
      static_cast<void>(options);
      return false;
    }
    static constexpr void stop_diagnostics_service() noexcept {}
};
 
} // namespace uni20