modern_runtime/modules/runtime/io_backend.cppm at main · markushocke/modern_runtime · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
module;

#include <concepts>
#include <cstddef>
#include <stdexcept>
#include <type_traits>

export module modern.runtime:io_backend;

namespace modern::detail
{
template<class T>
inline constexpr bool io_backend_false = false;
}

export namespace modern
{
enum class io_backend_kind
{
  unknown,
  io_uring,
  epoll,
  kqueue,
};

enum class poller_backend_kind
{
  epoll,
  kqueue,
};

struct io_backend_info
{
  io_backend_kind kind = io_backend_kind::unknown;
  std::size_t submission_queue_depth = 0;
  std::size_t completion_queue_depth = 0;
};

template<class Service>
io_backend_info query_io_backend(Service& service)
{
  if constexpr (requires(Service& candidate)
  {
    { candidate.backend_info() } -> std::convertible_to<io_backend_info>;
  })
  {
    return service.backend_info();
  }
  else
  {
    io_backend_info info;

    if constexpr (requires(Service& candidate)
    {
      { candidate.backend_kind() } -> std::convertible_to<io_backend_kind>;
    })
    {
      info.kind = service.backend_kind();
    }
    else if constexpr (requires(Service& candidate)
    {
      { candidate.backend() } -> std::convertible_to<io_backend_kind>;
    })
    {
      info.kind = service.backend();
    }
    else if constexpr (requires(Service& candidate)
    {
      { candidate.kind() } -> std::convertible_to<io_backend_kind>;
    })
    {
      info.kind = service.kind();
    }
    else
    {
      static_assert(detail::io_backend_false<Service>,
        "service must expose backend_info(), backend_kind(), backend(), or kind() for backend inspection");
    }

    if constexpr (requires(Service& candidate)
    {
      { candidate.submission_queue_depth() } -> std::convertible_to<std::size_t>;
    })
    {
      info.submission_queue_depth = service.submission_queue_depth();
    }
    else if constexpr (requires(Service& candidate)
    {
      { candidate.queue_depth() } -> std::convertible_to<std::size_t>;
    })
    {
      info.submission_queue_depth = service.queue_depth();
    }

    if constexpr (requires(Service& candidate)
    {
      { candidate.completion_queue_depth() } -> std::convertible_to<std::size_t>;
    })
    {
      info.completion_queue_depth = service.completion_queue_depth();
    }
    else
    {
      info.completion_queue_depth = info.submission_queue_depth;
    }

    return info;
  }
}

template<class Service>
poller_backend_kind query_poller_backend(Service& service)
{
  auto info = modern::query_io_backend(service);

  switch (info.kind)
  {
    case io_backend_kind::epoll:
      return poller_backend_kind::epoll;
    case io_backend_kind::kqueue:
      return poller_backend_kind::kqueue;
    default:
      throw std::runtime_error("service is not poller-backed");
  }
}
} // namespace modern