14#ifndef NODEGRAPH2_NODEGRAPH_HPP
15#define NODEGRAPH2_NODEGRAPH_HPP
27#include "rpnx/result.hpp"
28#include "rpnx/typelist.hpp"
36#include <condition_variable>
55#include <shared_mutex>
56#include <source_location>
68#include "rpnx/serialization4.hpp"
70#ifdef RPNX_QUERYGRAPH_USE_CONC_UNORDERED_MAP
71#include "rpnx/sharded_unordered_map.hpp"
75#define RPNX_DEBUGONLY(x)
76#define RPNX_RELEASEONLY(x) x
78#define RPNX_DEBUGONLY(x) x
79#define RPNX_RELEASEONLY(x)
84RPNX_ENUM(rpnx::querygraph,
memory_class, std::uint8_t, unknown, tiny, small, medium, large, huge);
103namespace rpnx::querygraph
116 using fast_cv = std::condition_variable_any;
133 template <
typename T >
135 typename T::input_type;
136 typename T::output_type;
137 { T::query_id } -> std::convertible_to< std::string >;
149 template <
typename T >
151 typename T::parent_query;
152 typename T::input_type;
153 typename T::output_type;
155 { T::subquery_id } -> std::convertible_to< std::string >;
160 template < query_spec_c QuerySpec, rpnx::typelist_c Deps, rpnx::typelist_c ProducedSubqueries = rpnx::typelist<> >
161 struct query_handler_spec
163 using query = QuerySpec;
164 using dependencies = Deps;
165 using produced_subqueries = ProducedSubqueries;
175 template <
typename T >
178 typename T::dependencies;
182 template <
typename T >
184 typename T::produced_subqueries;
185 } && rpnx::typelist_c< typename T::produced_subqueries >;
191 template <
typename T >
195 template <
typename T >
202 template <
typename T >
210 template < query_handler_produced_subqueries_struct_c T >
218 template < query_handler_spec_struct_c T >
230 template < query_handler_spec_c HandlerSpec >
234 template < query_handler_spec_c HandlerSpec >
238 template < query_handler_spec_c HandlerSpec >
242 template < query_handler_spec_c HandlerSpec >
246 template < query_handler_spec_c HandlerSpec >
250 template <
typename T >
265 template <
typename T >
275 std::vector< std::byte > buffer;
276 rpnx::serial4::serialize_iter(value, std::back_inserter(buffer));
296 template <
typename T >
298 { t.to_debug_string() } -> std::convertible_to< std::string >;
310 template <
typename T >
318 return value.to_debug_string();
320 else if constexpr (std::formattable< T, char >)
322 return std::format(
"{}", value);
326 return "<no debug string available>";
338 return std::format(
"{:?}", value);
349 return "std::monostate{}";
373 template <
typename... Ts >
374 debug_message(std::format_string< Ts... > format_string, Ts&&... args) :
message(std::format(format_string, std::forward< Ts >(args)...))
406 std::function< std::vector< std::byte >(std::any
const&) >
m_serialize;
408 std::function< std::string(std::any
const&) >
m_message;
429 template <
typename Error >
432 static_assert(std::derived_from< Error, std::exception >,
"Canonical errors must derive from std::exception");
433 static_assert(std::copy_constructible< Error >,
"Canonical errors must be copy constructible");
436 storage.
m_error_typesig = rpnx::serial4::get_type_typesig_hash16< Error >();
440 throw std::any_cast< Error const& >(value);
446 storage.
m_message = [](std::any
const& value)
448 return std::string(std::any_cast< Error const& >(value).what());
462 std::optional< canonical_error_storage > m_canonical_error;
463 std::exception_ptr m_unexpected_exception;
512 template <
typename T >
515 std::optional< T > m_value;
535 if (m_error.has_error())
537 m_error.throw_error();
545 assert(m_value.has_value());
546 return m_value.value();
553 assert(m_value.has_value());
554 return m_value.value();
561 assert(m_value.has_value());
562 return std::move(m_value.value());
569 assert(m_value.has_value());
570 return std::move(m_value.value());
588 return std::move(*this).get();
594 return std::move(*this).get();
601 m_value = std::move(
value);
608 m_error = std::move(error);
626 return m_value.has_value() || m_error.has_error();
632 return m_value.has_value();
638 return m_error.has_error();
650 return m_error.has_canonical_error();
656 return m_error.has_unexpected_exception();
668 return m_error.make_exception_ptr();
674 if (m_value.has_value())
676 return status::completed;
678 return m_error.result_status();
682 explicit operator bool()
const
692 bool m_has_value =
false;
707 if (m_error.has_error())
709 m_error.throw_error();
719 throw std::logic_error(
"No value");
740 m_error = std::move(error);
758 return m_has_value || m_error.has_error();
770 return m_error.has_error();
782 return m_error.has_canonical_error();
788 return m_error.has_unexpected_exception();
800 return m_error.make_exception_ptr();
808 return status::completed;
810 return m_error.result_status();
814 explicit operator bool()
const
820 inline namespace RPNX_DEBUGONLY(debug_abi) RPNX_RELEASEONLY(release_abi)
835 template < query_spec_c QuerySpec >
856 template < query_spec_c QuerySpec >
878 template < subquery_spec_c SubquerySpec >
906 template < subquery_spec_c SubquerySpec >
929 std::string m_subquery_id;
930 std::string m_message;
950 return m_subquery_id;
956 m_message = std::format(
"Subquery does not exist: {}", m_subquery_id);
960 char const*
what() const noexcept
override
962 return m_message.c_str();
974 std::string m_subquery_id;
987 return m_subquery_id;
997 class recursive_dependency_error :
public std::logic_error
1000 recursive_dependency_error() : std::logic_error(
"recursive dependency")
1019 template <
typename Result >
1020 struct query_result;
1022 template < subquery_spec_c SubquerySpec >
1023 struct subquery_query_result;
1025 template < query_handler_spec_c HandlerSpec >
1029 template < query_handler_spec_c HandlerSpec,
typename Ret >
1030 class cosubroutine_impl;
1072 std::function< void(std::string
const&) >
timing_logger = [](std::string
const& message)
1074 std::cerr << message;
1079 bool m_enable_node_debug_io_capture =
false;
1080 bool m_enable_node_serialization =
true;
1084 std::size_t m_active_groups = 0;
1086 std::size_t m_queued_work = 0;
1088 std::mutex m_descriptor_mutex;
1089 std::mutex m_diagnostic_mutex;
1091 static constexpr std::size_t long_running_input_max_length = 200;
1113 struct promise_base;
1118 promise_base* m_promise =
nullptr;
1119 std::coroutine_handle< void > handle;
1123 template <
typename Result >
1124 friend struct query_result;
1125 template < subquery_spec_c SubquerySpec >
1126 friend struct subquery_query_result;
1127 template < query_handler_spec_c HandlerSpec >
1129 template < query_handler_spec_c HandlerSpec,
typename Ret >
1130 friend class cosubroutine_impl;
1135 struct alignas(std::hardware_destructive_interference_size) worker
1139 graph* m_graph =
nullptr;
1140 RPNX_DEBUGONLY(std::thread::id m_id);
1142 std::deque< resumption > m_runnables;
1143 RPNX_DEBUGONLY(
bool m_idle =
false;)
1145 static constexpr std::size_t workgroup_threshold = 128;
1149 worker(worker
const& other) =
delete;
1151 void check_legal_access();
1155 void declare_runnable(std::coroutine_handle< void > h, promise_base* ptr,
bool immediate);
1157 void declare_runnable(resumption r,
bool immediate);
1159 bool try_exec_one();
1161 std::vector< resumption > try_steal(std::size_t max_items);
1165 class submission_scope
1172 submission_scope(
graph& owning_graph, worker& submitting_worker);
1174 ~submission_scope();
1176 submission_scope(submission_scope
const&) =
delete;
1178 submission_scope& operator=(submission_scope
const&) =
delete;
1182 std::mutex m_request_mutex;
1184 std::map< query_node*, std::function< void(worker*, std::exception_ptr) > > m_pending_requests;
1187 template <
typename Output >
1188 void track_request(query_node* node)
1190 std::unique_lock node_lock(node->m_mutex);
1191 if (std::any_cast< result< Output >
const& >(node->m_result).has_result())
1195 std::unique_lock request_lock(m_request_mutex);
1196 m_pending_requests.try_emplace(node, [
this, node](worker* current_worker, std::exception_ptr exception)
1198 abort_query_node_with_unexpected_exception< Output >(node, current_worker, exception);
1200 node->m_external_request =
true;
1204 void publish_work(worker& submitting_worker);
1207 void wait_for_quiescence();
1210 template < query_spec_c QuerySpec >
1211 auto execute_request(
typename QuerySpec::input_type
const& input) -> query_result< typename QuerySpec::output_type >
1213 worker submitting_worker(&m_scheduler);
1214 query_result< typename QuerySpec::output_type > query_result = [&]()
1216 submission_scope submission(*
this, submitting_worker);
1217 query_descriptor< QuerySpec >& desc = get_query_descriptor< QuerySpec >();
1218 rpnx::querygraph::query_result< typename QuerySpec::output_type > requested = desc.m_get(&submitting_worker, input,
false);
1219 track_request< typename QuerySpec::output_type >(requested.m_node);
1222 if (query_result.started_by_current_request())
1224 wait_for_quiescence();
1226 query_result.wait();
1227 return query_result;
1250 template < query_spec_c QuerySpec >
1251 auto make_request(
typename QuerySpec::input_type input) ->
typename QuerySpec::output_type
1253 query_result< typename QuerySpec::output_type > query_result = execute_request< QuerySpec >(input);
1254 return query_result.await_resume();
1273 template < query_spec_c QuerySpec >
1274 auto async_make_request(
typename QuerySpec::input_type input) -> std::future< typename QuerySpec::output_type >
1276 worker submitting_worker(&m_scheduler);
1277 submission_scope submission(*
this, submitting_worker);
1278 query_descriptor< QuerySpec >& desc = get_query_descriptor< QuerySpec >();
1279 query_result< typename QuerySpec::output_type > requested = desc.m_get(&submitting_worker, input,
false);
1280 track_request< typename QuerySpec::output_type >(requested.m_node);
1282 std::promise< typename QuerySpec::output_type > promise;
1283 std::future< typename QuerySpec::output_type > future = promise.get_future();
1284 std::unique_lock node_lock(requested.m_node->m_mutex);
1291 promise.set_value(res.
value());
1295 promise.set_exception(std::current_exception());
1300 if (!requested.m_node->m_request_completion)
1302 requested.m_node->m_request_completion = std::make_unique< typed_request_completion< typename QuerySpec::output_type > >();
1304 typed_request_completion< typename QuerySpec::output_type >& completion =
static_cast< typed_request_completion< typename QuerySpec::output_type >&
>(*requested.m_node->m_request_completion);
1305 completion.m_promises.push_back(std::move(promise));
1324 template < subquery_spec_c SubquerySpec >
1325 auto make_subquery_request(
typename SubquerySpec::parent_query::input_type parent_input,
typename SubquerySpec::input_type input) ->
typename SubquerySpec::output_type
1327 worker submitting_worker(&m_scheduler);
1328 subquery_query_result< SubquerySpec > query_result = [&]()
1330 submission_scope submission(*
this, submitting_worker);
1332 std::unique_lock lock(m_descriptor_mutex);
1333 register_subquery_descriptors< SubquerySpec >();
1335 query_descriptor< typename SubquerySpec::parent_query >& desc = get_query_descriptor< typename SubquerySpec::parent_query >();
1336 rpnx::querygraph::query_result< typename SubquerySpec::parent_query::output_type > parent_result = desc.m_get(&submitting_worker, parent_input,
false);
1337 track_request< typename SubquerySpec::parent_query::output_type >(parent_result.m_node);
1338 return get_subquery_result< SubquerySpec >(&submitting_worker, parent_result.m_node, input);
1340 query_result.wait();
1341 return query_result.await_resume();
1358 template < query_spec_c QuerySpec >
1359 auto dump_query_to_file(std::filesystem::path output_path,
typename QuerySpec::input_type input) -> std::filesystem::path
1361 query_result< typename QuerySpec::output_type > query_result = execute_request< QuerySpec >(input);
1363 std::vector< std::byte >
const marshaled_dump =
marshall(query_result.m_node);
1364 std::ofstream out(output_path, std::ios::binary | std::ios::trunc);
1367 throw std::runtime_error(std::format(
"Failed to open dump file for writing: {}", output_path.string()));
1370 if (!marshaled_dump.empty())
1372 out.write(
reinterpret_cast< char const*
>(marshaled_dump.data()),
static_cast< std::streamsize
>(marshaled_dump.size()));
1376 throw std::runtime_error(std::format(
"Failed to write dump file: {}", output_path.string()));
1405 template < subquery_spec_c SubquerySpec >
1406 struct subquery_slot
1410 std::string m_input_string;
1411 std::string m_output_string;
1412 std::vector< resumption > waiters;
1415 template < subquery_spec_c SubquerySpec >
1416 struct subquery_state
1418 std::map< typename SubquerySpec::input_type, subquery_slot< SubquerySpec > > m_instances;
1421 struct subquery_state_any
1424 std::type_index m_input_type = std::type_index(
typeid(
void));
1425 std::type_index m_output_type = std::type_index(
typeid(
void));
1426 std::string m_subquery_id;
1427 std::function< std::vector< resumption >(std::any&) > m_finalize_missing;
1428 std::function< std::vector< resumption >(std::any&, error_result
const&) > m_finalize_parent_failed;
1429 std::function< void(std::any&, std::function<
void(std::any&, std::any&) >) > m_iterate_all;
1433 struct request_completion
1436 virtual ~request_completion() =
default;
1438 virtual void complete(std::any
const& stored_result) = 0;
1442 template <
typename Output >
1443 struct typed_request_completion : request_completion
1446 std::vector< std::promise< Output > > m_promises;
1449 void complete(std::any
const& stored_result)
override
1451 result< Output >
const& res = std::any_cast< result< Output >
const& >(stored_result);
1452 for (std::promise< Output >& promise : m_promises)
1456 promise.set_value(res.value());
1460 promise.set_exception(std::current_exception());
1468 std::shared_mutex m_mutex;
1469 std::condition_variable_any m_external_cv;
1471 std::type_index m_query_type =
typeid(void);
1472 std::string m_input_string;
1473 std::string m_output_string;
1481 std::vector< resumption > waiters;
1483 std::unique_ptr< request_completion > m_request_completion;
1485 bool m_external_request =
false;
1486 std::vector< debug_message > m_messages;
1487 std::set< query_node* > dependencies;
1488 std::set< query_node* > dependents;
1489 std::map< std::type_index, subquery_state_any > m_subquery_states;
1490 std::atomic< std::chrono::nanoseconds::rep > m_self_time = 0;
1491 std::atomic< bool > m_long_running_threshold_reported =
false;
1492 std::atomic< bool > m_long_running_completion_reported =
false;
1493 std::atomic< bool > m_finished =
false;
1495 void unblock_waiters(worker* worker);
1497 void unblock_waiters(worker* worker, std::unique_lock< std::shared_mutex >& lock);
1499 void abort_waiters(worker* worker, std::unique_lock< std::shared_mutex >& lock, std::exception_ptr exception);
1502 static void declare_dependency(query_node* dependent, query_node* dependency);
1504 template < query_spec_c HandlerSpec >
1505 struct query_descriptor;
1510 graph* m_graph =
nullptr;
1511 worker* m_worker =
nullptr;
1512 query_node* m_node =
nullptr;
1513 std::mutex m_run_mutex;
1515 std::any* m_coroutine_storage =
nullptr;
1517 virtual std::string query_name()
const = 0;
1519 virtual std::string input_text()
const = 0;
1520 virtual void abort_with_unexpected_exception(worker* worker, std::exception_ptr exception) = 0;
1521 virtual ~promise_base() =
default;
1524 template < query_spec_c QuerySpec >
1525 struct query_descriptor
1527 std::function< query_result< typename QuerySpec::output_type >(worker*,
typename QuerySpec::input_type
const&,
bool) > m_get;
1528 std::any m_query_handler_impl;
1531 struct query_descriptor_any
1533 std::function< void(std::function<
void(query_node& node) >) > m_iterate_all;
1534 std::type_index m_input_type = std::type_index(
typeid(
void));
1535 std::type_index m_output_type = std::type_index(
typeid(
void));
1536 std::string m_query_id;
1539 template <
typename T >
1540 struct dependency_descriptor_type;
1542 template < query_spec_c QuerySpec >
1543 struct dependency_descriptor_type< QuerySpec >
1545 using type = query_descriptor< QuerySpec >*;
1548 template < subquery_spec_c SubquerySpec >
1549 struct dependency_descriptor_type< SubquerySpec >
1551 using type = query_descriptor< typename SubquerySpec::parent_query >*;
1554 template <
typename T >
1555 struct dependency_descriptor_table;
1557 template <
typename... Ts >
1558 struct dependency_descriptor_table< rpnx::typelist< Ts... > >
1560 using type = std::tuple< typename dependency_descriptor_type< Ts >::type... >;
1563 template < rpnx::typelist_c Typelist >
1564 using dependency_descriptor_table_from_typelist =
typename dependency_descriptor_table< Typelist >::type;
1566 template <
typename T >
1567 std::string datavalue_to_string(T
const& input)
1569 auto desc = this->m_text_descriptors.get_or_create(std::type_index(
typeid(T)),
1572 return text_descriptor{};
1575 if (desc.m_to_string ==
nullptr)
1577 return "<no to_string available>";
1580 return desc.m_to_string(std::any(input), std::any());
1583 template < query_handler_spec_c HandlerSpec >
1584 struct query_handler_descriptor_memoized_impl
1586#ifdef RPNX_QUERYGRAPH_USE_CONC_UNORDERED_MAP
1587 rpnx::conc_sharded_unordered_map< query_handler_input_t< HandlerSpec >, query_node, hasher< query_handler_input_t< HandlerSpec > > > m_mt_cache;
1589 std::shared_mutex mutex;
1590 std::map< query_handler_input_t< HandlerSpec >, query_node > cache;
1593 graph* m_graph =
nullptr;
1594 query_descriptor< query_handler_query_t< HandlerSpec > >* m_handler_entry =
nullptr;
1596 dependency_descriptor_table_from_typelist< query_handler_dependencies_t< HandlerSpec > > dependency_descriptors = {};
1598 std::function< coroutine< HandlerSpec >(query_handler_input_t< HandlerSpec >
const&) > m_startup;
1600#ifdef RPNX_QUERYGRAPH_USE_CONC_UNORDERED_MAP
1601 query_result< query_handler_output_t< HandlerSpec > > get(worker* current_worker, query_handler_input_t< HandlerSpec >
const& input_ask,
bool immediate)
1603 std::coroutine_handle< void > cr;
1604 bool started =
false;
1605 promise_base* pbase =
nullptr;
1606 auto& node = m_mt_cache.get_or_init_iter(input_ask,
1607 [&](query_handler_input_t< HandlerSpec >
const& key, query_node& node)
1610 node.m_query_type = std::type_index(
typeid(query_handler_query_t< HandlerSpec >));
1612 node.m_input.emplace< query_handler_input_t< HandlerSpec >
const* >(&key);
1614 if (m_graph->m_enable_node_debug_io_capture)
1616 node.m_input_string = m_graph->datavalue_to_string(input_ask);
1618 coroutine< HandlerSpec > co = m_startup(key);
1619 node.m_result = result< query_handler_output_t< HandlerSpec > >();
1621 co.m_promise->m_graph = m_graph;
1622 co.m_promise->m_node = &node;
1623 co.m_promise->m_coroutine_storage = &node.m_cort;
1624 co.m_promise->m_handler_entry = m_handler_entry;
1625 cr = std::coroutine_handle< typename coroutine< HandlerSpec >::promise_type >::from_promise(*co.m_promise);
1626 pbase = co.m_promise;
1627 node.m_cort = std::make_shared< coroutine< HandlerSpec > >(std::move(co));
1633 current_worker->declare_runnable(cr, pbase, immediate);
1636 return query_result< query_handler_output_t< HandlerSpec > >(&node, started);
1639 void iterate_all(std::function<
void(query_node& node) > func)
1641 auto iter = m_mt_cache.range_exclusive();
1642 for (
auto it = iter.begin(); it != iter.end(); ++it)
1649 query_result< query_handler_output_t< HandlerSpec > > get(worker* current_worker, query_handler_input_t< HandlerSpec >
const& input_ask,
bool immediate)
1651 std::shared_lock lock(mutex);
1652 typename std::map< query_handler_input_t< HandlerSpec >, query_node >::iterator it = cache.find(input_ask);
1653 if (it != cache.end())
1655 return query_result< query_handler_output_t< HandlerSpec > >(&it->second,
false);
1658 std::unique_lock ulock(mutex);
1660 it = cache.find(input_ask);
1661 if (it != cache.end())
1663 return query_result< query_handler_output_t< HandlerSpec > >(&it->second,
false);
1665 auto [node_it, inserted] = cache.try_emplace(input_ask);
1667 coroutine< HandlerSpec > co = m_startup(node_it->first);
1668 query_node& node = node_it->second;
1670 node.m_query_type = std::type_index(
typeid(query_handler_query_t< HandlerSpec >));
1671 node.m_input.emplace< query_handler_input_t< HandlerSpec >
const* >(&node_it->first);
1672 if (m_graph->m_enable_node_debug_io_capture)
1674 node.m_input_string = m_graph->datavalue_to_string(input_ask);
1676 node.m_result = result< query_handler_output_t< HandlerSpec > >();
1677 co.m_promise->m_graph = m_graph;
1678 co.m_promise->m_node = &node;
1679 co.m_promise->m_coroutine_storage = &node.m_cort;
1680 co.m_promise->m_handler_entry = m_handler_entry;
1681 std::coroutine_handle< void > cr = std::coroutine_handle< typename coroutine< HandlerSpec >::promise_type >::from_promise(*co.m_promise);
1682 promise_base* pbase = co.m_promise;
1683 node.m_cort = std::make_shared< coroutine< HandlerSpec > >(std::move(co));
1685 current_worker->declare_runnable(cr, pbase, immediate);
1686 return query_result< query_handler_output_t< HandlerSpec > >(&node,
true);
1689 template < query_spec_c QuerySpec >
1690 auto get_dependency_descriptor() -> query_descriptor< QuerySpec >&
1692 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< QuerySpec >(),
"Failed to resolve index of dependency descriptor: QuerySpec is not listed in the HandlerSpec dependencies, no entry in dependency_descriptors exists");
1694 constexpr std::size_t index = *query_handler_dependencies_t< HandlerSpec >::template index_of< QuerySpec >();
1698 return *std::get< index >(dependency_descriptors);
1701 template < subquery_spec_c SubquerySpec >
1702 auto get_subquery_parent_descriptor() -> query_descriptor< typename SubquerySpec::parent_query >&
1704 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< SubquerySpec >(),
"Failed to resolve index of subquery descriptor: SubquerySpec is not listed in HandlerSpec dependencies");
1705 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< typename SubquerySpec::parent_query >(),
"Making a subquery request requires declaring the subquery's parent query in HandlerSpec dependencies");
1707 constexpr std::size_t index = *query_handler_dependencies_t< HandlerSpec >::template index_of< SubquerySpec >();
1709 return *std::get< index >(dependency_descriptors);
1712 void bind(graph* graph)
1714 bind_spec< 0 >(graph);
1717 template <
size_t N >
1718 void bind_spec(graph* graph)
1720 if constexpr (N < query_handler_dependencies_t< HandlerSpec >::size)
1722 using dep = query_handler_dependencies_t< HandlerSpec >::template type_at< N >;
1723 if constexpr (query_spec_c< dep >)
1725 query_descriptor< dep >& dep_descriptor = graph->get_query_descriptor< dep >();
1726 std::get< N >(dependency_descriptors) = &dep_descriptor;
1728 else if constexpr (subquery_spec_c< dep >)
1730 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< typename dep::parent_query >(),
"A handler that depends on a subquery must also list the subquery's parent query in HandlerSpec dependencies");
1731 query_descriptor< typename dep::parent_query >& dep_descriptor = graph->get_query_descriptor<
typename dep::parent_query >();
1732 std::get< N >(dependency_descriptors) = &dep_descriptor;
1734 bind_spec< N + 1 >(graph);
1739 struct text_descriptor
1741 std::function< std::string(std::any, std::any) > m_to_string;
1744 struct binary_descriptor
1746 struct result_binary_data
1748 std::vector< std::byte > m_output_data;
1749 status m_status = status::pending;
1750 std::optional< canonical_error_result_data > m_error_result;
1753 std::function< std::vector< std::byte >(std::any&) > m_serialize_from_cptr;
1754 std::function< result_binary_data(std::any&) > m_serialize_from_result;
1756 std::function< std::any(std::vector< std::byte >
const&) > m_deserialize;
1758 std::array< std::byte, 16 > m_typesig;
1761 struct canonical_error_descriptor
1763 std::function< error_result(std::exception
const&) > m_capture;
1766 std::map< std::type_index, std::any > query_handler_registry;
1767 std::map< std::type_index, query_descriptor_any > query_descriptor_any_registry;
1768 std::vector< std::function< void(graph*) > > m_pending_binds;
1769 rpnx::conc_sharded_unordered_map< std::type_index, text_descriptor, hasher< std::type_index > > m_text_descriptors;
1770 std::map< std::type_index, binary_descriptor > m_binary_descriptors;
1771 std::map< std::type_index, canonical_error_descriptor > m_canonical_error_descriptors;
1772 std::map< std::type_index, std::string > m_query_names;
1775 auto long_running_node_description(promise_base* promise) -> std::string;
1778 void log_long_running_node_progress_diagnostic(promise_base* promise);
1781 void log_long_running_node_completion_diagnostic(promise_base* promise, std::chrono::nanoseconds self_time);
1784 void print_noncanonical_exception_diagnostic(promise_base* promise, error_result
const& error);
1786 static void declare_resumptions(worker* worker, std::vector< resumption > waiters);
1788 static void abort_resumptions(worker* worker, std::vector< resumption > waiters, std::exception_ptr exception);
1790 template < subquery_spec_c SubquerySpec >
1791 static std::vector< resumption > take_subquery_waiters(subquery_slot< SubquerySpec >& slot)
1793 std::vector< resumption > waiters;
1794 waiters.assign(std::make_move_iterator(slot.waiters.begin()), std::make_move_iterator(slot.waiters.end()));
1795 slot.waiters.clear();
1799 static canonical_error_storage make_subquery_parent_failed_storage(std::string subquery_id, error_result parent_error);
1801 static error_result make_subquery_does_not_exist_error(std::string subquery_id);
1803 static error_result make_subquery_parent_failed_error(std::string subquery_id, error_result
const& parent_error);
1805 template < subquery_spec_c SubquerySpec >
1806 static auto make_subquery_state_any() -> subquery_state_any
1808 subquery_state_any state_any;
1809 state_any.m_state.emplace< subquery_state< SubquerySpec > >();
1810 state_any.m_input_type = std::type_index(
typeid(
typename SubquerySpec::input_type));
1811 state_any.m_output_type = std::type_index(
typeid(
typename SubquerySpec::output_type));
1812 state_any.m_subquery_id = std::string(SubquerySpec::subquery_id);
1813 state_any.m_finalize_missing = [](std::any& state_value) -> std::vector< resumption >
1815 std::vector< resumption > waiters;
1816 subquery_state< SubquerySpec >& state = std::any_cast< subquery_state< SubquerySpec >& >(state_value);
1817 for (
auto& [input, slot] : state.m_instances)
1819 result< typename SubquerySpec::output_type >& res = std::any_cast< result< typename SubquerySpec::output_type >& >(slot.m_result);
1820 if (!res.has_result())
1822 res.set_error(make_subquery_does_not_exist_error(std::string(SubquerySpec::subquery_id)));
1823 std::vector< resumption > slot_waiters = take_subquery_waiters< SubquerySpec >(slot);
1824 waiters.insert(waiters.end(), std::make_move_iterator(slot_waiters.begin()), std::make_move_iterator(slot_waiters.end()));
1829 state_any.m_finalize_parent_failed = [](std::any& state_value, error_result
const& parent_error) -> std::vector< resumption >
1831 std::vector< resumption > waiters;
1832 subquery_state< SubquerySpec >& state = std::any_cast< subquery_state< SubquerySpec >& >(state_value);
1833 for (
auto& [input, slot] : state.m_instances)
1835 result< typename SubquerySpec::output_type >& res = std::any_cast< result< typename SubquerySpec::output_type >& >(slot.m_result);
1836 if (!res.has_result())
1838 res.set_error(make_subquery_parent_failed_error(std::string(SubquerySpec::subquery_id), parent_error));
1839 std::vector< resumption > slot_waiters = take_subquery_waiters< SubquerySpec >(slot);
1840 waiters.insert(waiters.end(), std::make_move_iterator(slot_waiters.begin()), std::make_move_iterator(slot_waiters.end()));
1845 state_any.m_iterate_all = [](std::any& state_value, std::function< void(std::any&, std::any&) > callback)
1847 subquery_state< SubquerySpec >& state = std::any_cast< subquery_state< SubquerySpec >& >(state_value);
1848 for (
auto& [input, slot] : state.m_instances)
1850 callback(slot.m_input, slot.m_result);
1856 template < subquery_spec_c SubquerySpec >
1857 auto get_or_create_subquery_slot_locked(query_node* parent_node,
typename SubquerySpec::input_type
const& input) -> subquery_slot< SubquerySpec >&
1859 std::type_index
const state_key = std::type_index(
typeid(SubquerySpec));
1860 auto state_it = parent_node->m_subquery_states.find(state_key);
1861 if (state_it == parent_node->m_subquery_states.end())
1863 auto [inserted_it, inserted] = parent_node->m_subquery_states.emplace(state_key, make_subquery_state_any< SubquerySpec >());
1865 state_it = inserted_it;
1868 subquery_state< SubquerySpec >& state = std::any_cast< subquery_state< SubquerySpec >& >(state_it->second.m_state);
1869 auto [slot_it, inserted] = state.m_instances.try_emplace(input);
1870 subquery_slot< SubquerySpec >& slot = slot_it->second;
1873 slot.m_input.template emplace< typename SubquerySpec::input_type const* >(&slot_it->first);
1874 slot.m_result.template emplace< result< typename SubquerySpec::output_type > >();
1875 if (node_debug_io_capture_enabled())
1877 slot.m_input_string = datavalue_to_string(input);
1883 template < subquery_spec_c SubquerySpec >
1884 std::vector< resumption > complete_subquery_from_parent_result_locked(query_node* parent_node, subquery_slot< SubquerySpec >& slot)
1886 std::vector< resumption > waiters;
1887 result< typename SubquerySpec::output_type >& subquery_res = std::any_cast< result< typename SubquerySpec::output_type >& >(slot.m_result);
1888 if (subquery_res.has_result())
1893 result< typename SubquerySpec::parent_query::output_type >
const& parent_res = std::any_cast< result< typename SubquerySpec::parent_query::output_type >
const& >(parent_node->m_result);
1894 if (parent_res.has_value())
1896 subquery_res.set_error(make_subquery_does_not_exist_error(std::string(SubquerySpec::subquery_id)));
1897 waiters = take_subquery_waiters< SubquerySpec >(slot);
1899 else if (parent_res.has_exception())
1901 subquery_res.set_error(make_subquery_parent_failed_error(std::string(SubquerySpec::subquery_id), parent_res.get_error_result()));
1902 waiters = take_subquery_waiters< SubquerySpec >(slot);
1907 template < subquery_spec_c SubquerySpec >
1908 auto get_subquery_result(worker* worker, query_node* parent_node,
typename SubquerySpec::input_type
const& input) -> subquery_query_result< SubquerySpec >
1910 std::unique_lock lock(parent_node->m_mutex);
1911 subquery_slot< SubquerySpec >& slot = get_or_create_subquery_slot_locked< SubquerySpec >(parent_node, input);
1912 std::vector< resumption > waiters = complete_subquery_from_parent_result_locked< SubquerySpec >(parent_node, slot);
1913 bool const abort_waiters = std::any_cast< result< typename SubquerySpec::output_type >
const& >(slot.m_result).has_unexpected_exception();
1914 std::exception_ptr
const unexpected_exception = abort_waiters ? std::any_cast< result< typename SubquerySpec::output_type >
const& >(slot.m_result).get_error_result().unexpected_exception() :
nullptr;
1918 abort_resumptions(worker, std::move(waiters), unexpected_exception);
1922 declare_resumptions(worker, std::move(waiters));
1924 return subquery_query_result< SubquerySpec >(parent_node, &slot);
1927 template < subquery_spec_c SubquerySpec >
1928 void set_subquery_result(worker* worker, query_node* parent_node,
typename SubquerySpec::input_type input,
typename SubquerySpec::output_type output)
1930 std::unique_lock lock(parent_node->m_mutex);
1931 subquery_slot< SubquerySpec >& slot = get_or_create_subquery_slot_locked< SubquerySpec >(parent_node, input);
1932 result< typename SubquerySpec::output_type >& subquery_res = std::any_cast< result< typename SubquerySpec::output_type >& >(slot.m_result);
1933 if (subquery_res.has_result())
1935 throw std::logic_error(std::format(
"Subquery result already produced: {}", std::string(SubquerySpec::subquery_id)));
1937 if (node_debug_io_capture_enabled())
1939 slot.m_output_string = datavalue_to_string(output);
1941 subquery_res.set_value(std::move(output));
1942 std::vector< resumption > waiters = take_subquery_waiters< SubquerySpec >(slot);
1944 parent_node->m_external_cv.notify_all();
1945 declare_resumptions(worker, std::move(waiters));
1948 std::vector< resumption > finalize_missing_subqueries_locked(query_node* node);
1950 std::vector< resumption > finalize_parent_failed_subqueries_locked(query_node* node, error_result
const& parent_error);
1952 template < subquery_spec_c SubquerySpec >
1953 void register_subquery_descriptors()
1955 register_inputoutput_text_descriptor< typename SubquerySpec::input_type >();
1956 register_inputoutput_text_descriptor< typename SubquerySpec::output_type >();
1957 register_binary_descriptors< typename SubquerySpec::input_type >();
1958 register_binary_descriptors< typename SubquerySpec::output_type >();
1961 template < rpnx::typelist_c Typelist, std::
size_t N = 0 >
1962 void register_subquery_descriptors_from_typelist()
1964 if constexpr (N < Typelist::size)
1966 using dep =
typename Typelist::template type_at< N >;
1967 if constexpr (subquery_spec_c< dep >)
1969 register_subquery_descriptors< dep >();
1971 register_subquery_descriptors_from_typelist< Typelist, N + 1 >();
1975 std::optional< error_result > capture_subquery_parent_failed(subquery_parent_failed
const& exception)
const;
1977 error_result capture_exception(std::exception_ptr exception)
const;
1979 error_result capture_current_exception()
const;
1981 template <
typename Output >
1982 void abort_query_node_with_unexpected_exception(query_node* node, worker* worker, std::exception_ptr exception)
1984 std::vector< resumption > subquery_waiters;
1986 std::unique_lock lock(node->m_mutex);
1987 result< Output >& res = std::any_cast< result< Output >& >(node->m_result);
1988 if (res.has_result())
1992 res.set_error(error_result::unexpected(exception));
1993 subquery_waiters = finalize_parent_failed_subqueries_locked(node, res.get_error_result());
1994 node->abort_waiters(worker, lock, exception);
1996 abort_resumptions(worker, std::move(subquery_waiters), exception);
2012 template <
typename Error >
2015 static_assert(std::derived_from< Error, std::exception >,
"Canonical errors must derive from std::exception");
2016 static_assert(std::copy_constructible< Error >,
"Canonical errors must be copy constructible");
2018 canonical_error_descriptor descriptor;
2019 descriptor.m_capture = [](std::exception
const& exception)
2023 m_canonical_error_descriptors[std::type_index(
typeid(Error))] = std::move(descriptor);
2035 template <
typename T >
2038 m_text_descriptors.get_or_init(std::type_index(
typeid(T)),
2039 [](text_descriptor& desc)
2041 desc.m_to_string = [](std::any val, std::any codec) -> std::string
2059 template <
typename T >
2062 binary_descriptor desc;
2063 desc.m_serialize_from_cptr = [](std::any& val) -> std::vector< std::byte >
2065 T
const* value = std::any_cast< T const* >(val);
2068 desc.m_serialize_from_result = [](std::any& val) -> binary_descriptor::result_binary_data
2070 result< T >& res = std::any_cast< result< T >& >(val);
2074 return binary_descriptor::result_binary_data{
2075 .m_output_data = std::move(data),
2076 .m_status = status::completed,
2077 .m_error_result = std::nullopt,
2082 std::vector< std::byte > data;
2083 std::string str =
"Exception: ";
2087 data.push_back(std::byte(c));
2089 return binary_descriptor::result_binary_data{
2090 .m_output_data = std::move(data),
2095 return binary_descriptor::result_binary_data{
2096 .m_output_data = {},
2097 .m_status = status::pending,
2098 .m_error_result = std::nullopt,
2101 desc.m_deserialize = [](std::vector< std::byte >
const& data) -> std::any
2104 rpnx::serial4::deserialize_iter(value, data.begin(), data.end());
2105 return std::any(std::move(value));
2107 desc.m_typesig = rpnx::serial4::get_type_typesig_hash16< T >();
2109 m_binary_descriptors[std::type_index(
typeid(T))] = desc;
2123 template < query_handler_spec_c QuerySpec >
2130 auto it = handler_map->find(input);
2131 if (it == handler_map->end())
2133 throw std::logic_error(
"No handler found for the given input in handler map");
2135 co_return it->second;
2144 template < query_handler_spec_c HandlerSpec >
2145 requires std::same_as< query_handler_input_t< HandlerSpec >, std::monostate >
2165 template < query_spec_c QuerySpec >
2166 requires std::same_as< typename QuerySpec::input_type, std::monostate >
2188 template < query_handler_spec_c HandlerSpec,
typename Handler >
2192 if (query_handler_registry.find(query_index) != query_handler_registry.end())
2194 throw std::logic_error(
"Handler already registered");
2196 query_handler_registry[query_index].emplace< query_descriptor< query_handler_query_t< HandlerSpec > > >();
2197 query_descriptor_any& qd_any = query_descriptor_any_registry[query_index];
2199 query_descriptor< query_handler_query_t< HandlerSpec > >& descriptor = std::any_cast< query_descriptor< query_handler_query_t< HandlerSpec > >& >(query_handler_registry[query_index]);
2200 descriptor.m_query_handler_impl = std::make_shared< query_handler_descriptor_memoized_impl< HandlerSpec > >();
2201 query_handler_descriptor_memoized_impl< HandlerSpec >& memoized_impl = *std::any_cast< std::shared_ptr< query_handler_descriptor_memoized_impl< HandlerSpec > >& >(descriptor.m_query_handler_impl);
2202 memoized_impl.m_graph =
this;
2203 memoized_impl.m_startup = std::move(h);
2204 memoized_impl.m_handler_entry = &descriptor;
2209 return memoized_impl.get(current_worker, input_ask, immediate);
2212 qd_any.m_iterate_all = [&memoized_impl](std::function< void(query_node&) > callback)
2214 memoized_impl.iterate_all(std::move(callback));
2225 register_subquery_descriptors_from_typelist< query_handler_dependencies_t< HandlerSpec > >();
2226 register_subquery_descriptors_from_typelist< query_handler_produced_subqueries_t< HandlerSpec > >();
2230 m_pending_binds.push_back(
2231 [&memoized_impl](
graph* exec)
2233 memoized_impl.bind(exec);
2238 template < query_spec_c QuerySpec >
2239 auto get_query_descriptor() -> query_descriptor< QuerySpec >&
2241 auto it = query_handler_registry.find(std::type_index(
typeid(QuerySpec)));
2242 if (it == query_handler_registry.end())
2244 throw std::logic_error(
"No handler registered for the requested query spec");
2246 return std::any_cast< query_descriptor< QuerySpec >& >(it->second);
2271 template <
typename Visitor >
2274 for (
auto const& [type_index, binary_desc] : m_binary_descriptors)
2276 auto text_desc = m_text_descriptors.get_or_create(type_index,
2279 return text_descriptor{};
2282 visitor(binary_desc.m_typesig, binary_desc.m_deserialize, text_desc.m_to_string);
2303 std::vector< std::byte >
marshall(query_node* start_node);
2352 friend struct graph::worker;
2355 static std::size_t default_worker_count();
2357 std::size_t global_workitems_to_publish(std::size_t available_items)
const;
2359 std::size_t global_workitems_to_take(std::size_t queued_work)
const;
2361 void push_group(std::vector< graph::resumption > vals);
2363 void release_graph(graph& owning_graph, graph::worker& current_worker);
2365 void try_steal_work();
2367 std::vector< graph::resumption > get_work(graph::worker* current_worker);
2369 std::size_t m_total_workers = 0;
2370 std::size_t m_idle_workers = 0;
2371 std::atomic< std::size_t > m_global_workitems = 0;
2372 std::size_t m_global_workitem_threshold = 0;
2374 std::deque< graph::worker > m_workers;
2375 std::vector< std::thread > m_worker_threads;
2376 std::deque< graph::resumption > m_runnables;
2378 bool m_stopping =
false;
2380 static constexpr std::size_t taskgroup_max_size = 1024;
2383 template <
typename Result >
2386 graph::query_node* m_node;
2387 bool m_started_by_current_request =
false;
2390 explicit query_result(graph::query_node* node_ptr,
bool started_by_current_request =
false) : m_node(node_ptr), m_started_by_current_request(started_by_current_request)
2394 bool started_by_current_request() const noexcept
2396 return m_started_by_current_request;
2399 bool available()
const
2401 std::shared_lock lock(m_node->m_mutex);
2402 result< Result >
const& res = std::any_cast< result< Result >
const& >(m_node->m_result);
2403 return res.has_result();
2408 std::unique_lock lock(m_node->m_mutex);
2409 m_node->m_external_cv.wait(lock,
2412 result< Result >
const& res = std::any_cast< result< Result >
const& >(m_node->m_result);
2413 return res.has_result();
2419 std::shared_lock lock(m_node->m_mutex);
2420 result< Result >
const& res = std::any_cast< result< Result >
const& >(m_node->m_result);
2421 return res.has_result() && !res.has_unexpected_exception();
2424 bool await_ready([[maybe_unused]] std::unique_lock< std::shared_mutex >& lock)
2426 return std::any_cast< result< Result >& >(m_node->m_result).has_result();
2429 bool await_ready([[maybe_unused]] std::shared_lock< std::shared_mutex >& lock)
2431 return std::any_cast< result< Result >
const& >(m_node->m_result).has_result();
2434 template <
typename U >
2435 void await_suspend(std::coroutine_handle< U > h)
2437 await_suspend_helper< typename U::coroutine_type >(h.promise(), h);
2440 template <
typename C >
2441 void await_suspend_helper(
typename C::promise_type& p, std::coroutine_handle< typename C::promise_type > h)
2443 await_suspend_helper2< C, typename C::spec_type >(p, h);
2446 template <
typename C,
typename HandlerSpec >
2447 void await_suspend_helper2(
typename C::promise_type& p, std::coroutine_handle< typename C::promise_type > h)
2449 std::unique_lock lock(m_node->m_mutex);
2451 graph::worker* current_worker = p.m_worker;
2452 assert(current_worker !=
nullptr);
2453 current_worker->check_legal_access();
2455 if (await_ready(lock))
2457 result< Result >
const& res = std::any_cast< result< Result >
const& >(m_node->m_result);
2458 if (res.has_unexpected_exception())
2460 std::exception_ptr unexpected_exception = res.get_error_result().unexpected_exception();
2462 p.abort_with_unexpected_exception(current_worker, unexpected_exception);
2466 current_worker->declare_runnable(graph::resumption{.m_promise = &p, .handle = h},
false);
2471 m_node->waiters.push_back(graph::resumption{.m_promise = &p, .handle = h});
2475 Result
const& await_resume()
2477 std::shared_lock lock(m_node->m_mutex);
2478 auto& res = std::any_cast< result< Result >
const& >(m_node->m_result);
2483 template < subquery_spec_c SubquerySpec >
2484 struct subquery_query_result
2486 graph::query_node* m_parent_node;
2487 graph::subquery_slot< SubquerySpec >* m_slot;
2490 subquery_query_result(graph::query_node* parent_node, graph::subquery_slot< SubquerySpec >* slot) : m_parent_node(parent_node), m_slot(slot)
2494 bool available()
const
2496 std::shared_lock lock(m_parent_node->m_mutex);
2497 result< typename SubquerySpec::output_type >
const& res = std::any_cast< result< typename SubquerySpec::output_type >
const& >(m_slot->m_result);
2498 return res.has_result();
2503 std::unique_lock lock(m_parent_node->m_mutex);
2504 m_parent_node->m_external_cv.wait(lock,
2507 result< typename SubquerySpec::output_type >
const& res = std::any_cast< result< typename SubquerySpec::output_type >
const& >(m_slot->m_result);
2508 return res.has_result();
2514 std::shared_lock lock(m_parent_node->m_mutex);
2515 result< typename SubquerySpec::output_type >
const& res = std::any_cast< result< typename SubquerySpec::output_type >
const& >(m_slot->m_result);
2516 return res.has_result() && !res.has_unexpected_exception();
2519 bool await_ready([[maybe_unused]] std::unique_lock< std::shared_mutex >& lock)
2521 return std::any_cast< result< typename SubquerySpec::output_type >& >(m_slot->m_result).has_result();
2524 bool await_ready([[maybe_unused]] std::shared_lock< std::shared_mutex >& lock)
2526 return std::any_cast< result< typename SubquerySpec::output_type >
const& >(m_slot->m_result).has_result();
2529 template <
typename U >
2530 void await_suspend(std::coroutine_handle< U > h)
2532 await_suspend_helper< typename U::coroutine_type >(h.promise(), h);
2535 template <
typename C >
2536 void await_suspend_helper(
typename C::promise_type& p, std::coroutine_handle< typename C::promise_type > h)
2538 std::unique_lock lock(m_parent_node->m_mutex);
2540 graph::worker* current_worker = p.m_worker;
2541 assert(current_worker !=
nullptr);
2542 current_worker->check_legal_access();
2544 if (await_ready(lock))
2546 result< typename SubquerySpec::output_type >
const& res = std::any_cast< result< typename SubquerySpec::output_type >
const& >(m_slot->m_result);
2547 if (res.has_unexpected_exception())
2549 std::exception_ptr unexpected_exception = res.get_error_result().unexpected_exception();
2551 p.abort_with_unexpected_exception(current_worker, unexpected_exception);
2555 current_worker->declare_runnable(graph::resumption{.m_promise = &p, .handle = h},
false);
2560 m_slot->waiters.push_back(graph::resumption{.m_promise = &p, .handle = h});
2564 typename SubquerySpec::output_type
const& await_resume()
2566 std::shared_lock lock(m_parent_node->m_mutex);
2567 result< typename SubquerySpec::output_type >
const& res = std::any_cast< result< typename SubquerySpec::output_type >
const& >(m_slot->m_result);
2584 template < query_handler_spec_c HandlerSpec >
2598 template <
typename Ret >
2602 struct promise_type :
public graph::promise_base
2607 typename graph::template query_descriptor< query_handler_query_t< HandlerSpec > >* m_handler_entry =
nullptr;
2610 std::string query_name()
const override
2615 std::string input_text()
const override
2618 input_type
const* input = std::any_cast< input_type const* >(m_node->m_input);
2619 return m_graph->datavalue_to_string(*input);
2622 template < query_spec_c QuerySpec >
2623 auto await_transform(
request< QuerySpec > a) -> query_result< typename QuerySpec::output_type >
2626 assert(m_worker !=
nullptr);
2627 assert(m_node !=
nullptr);
2629 typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec >& handler_impl = *std::any_cast< std::shared_ptr< typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec > >& >(m_handler_entry->m_query_handler_impl);
2631 typename graph::template query_descriptor< QuerySpec >& dep_query_descriptor = handler_impl.template get_dependency_descriptor< QuerySpec >();
2633 query_result< typename QuerySpec::output_type > await_obj = dep_query_descriptor.m_get(m_worker, a.
m_input,
false);
2635 graph::query_node* await_node = await_obj.m_node;
2636 graph::declare_dependency(m_node, await_node);
2640 template < subquery_spec_c SubquerySpec >
2645 assert(m_worker !=
nullptr);
2646 assert(m_node !=
nullptr);
2648 typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec >& handler_impl = *std::any_cast< std::shared_ptr< typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec > >& >(m_handler_entry->m_query_handler_impl);
2650 typename graph::template query_descriptor< typename SubquerySpec::parent_query >& parent_query_descriptor = handler_impl.template get_subquery_parent_descriptor< SubquerySpec >();
2652 query_result< typename SubquerySpec::parent_query::output_type > parent_await_obj = parent_query_descriptor.m_get(m_worker, a.m_parent_input,
false);
2654 graph::query_node* parent_node = parent_await_obj.m_node;
2655 graph::declare_dependency(m_node, parent_node);
2656 return m_graph->template get_subquery_result< SubquerySpec >(m_worker, parent_node, a.
m_input);
2659 template < query_spec_c QuerySpec >
2663 assert(m_worker !=
nullptr);
2664 assert(m_node !=
nullptr);
2666 typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec >& handler_impl = *std::any_cast< std::shared_ptr< typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec > >& >(m_handler_entry->m_query_handler_impl);
2667 typename graph::template query_descriptor< QuerySpec >& dep_query_descriptor = handler_impl.template get_dependency_descriptor< QuerySpec >();
2668 query_result< typename QuerySpec::output_type > await_obj = dep_query_descriptor.m_get(m_worker, dep.
m_request.m_input,
true);
2669 graph::query_node* await_node = await_obj.m_node;
2670 graph::declare_dependency(m_node, await_node);
2671 return std::suspend_never{};
2674 template < subquery_spec_c SubquerySpec >
2678 static_assert(std::same_as< typename SubquerySpec::parent_query, query_handler_query_t< HandlerSpec > >,
"A handler can only yield subqueries whose parent_query is the handler query");
2679 assert(m_worker !=
nullptr);
2680 assert(m_node !=
nullptr);
2682 m_graph->template set_subquery_result< SubquerySpec >(m_worker, m_node, std::move(res.
m_input), std::move(res.
m_output));
2683 return std::suspend_never{};
2686 template <
typename Ret >
2689 assert(m_node !=
nullptr);
2690 auto* sub_promise = sub.m_promise;
2691 sub_promise->m_graph = m_graph;
2692 sub_promise->m_node = m_node;
2693 sub_promise->m_handler_entry = m_handler_entry;
2700 assert(m_node !=
nullptr);
2701 std::unique_lock lock(m_node->m_mutex);
2703 if (m_graph->node_debug_io_capture_enabled())
2705 m_node->m_output_string = m_graph->datavalue_to_string(value);
2708 std::vector< graph::resumption > subquery_waiters = m_graph->finalize_missing_subqueries_locked(m_node);
2709 m_node->unblock_waiters(m_worker, lock);
2710 graph::declare_resumptions(m_worker, std::move(subquery_waiters));
2713 auto initial_suspend()
2715 return std::suspend_always{};
2718 auto final_suspend()
noexcept
2720 std::unique_lock lock(m_node->m_mutex);
2722 if (!res.
has_result() && m_node->dependencies.empty())
2724 std::exception_ptr exception = std::make_exception_ptr(
bad_continuation());
2726 std::vector< graph::resumption > subquery_waiters = m_graph->finalize_parent_failed_subqueries_locked(m_node, res.
get_error_result());
2727 m_node->abort_waiters(m_worker, lock, exception);
2728 graph::abort_resumptions(m_worker, std::move(subquery_waiters), exception);
2730 return std::suspend_always{};
2733 auto get_return_object()
2736 assert(m_coroutine == &co);
2737 assert(co.m_promise ==
this);
2741 auto yield_value(
debug_message msg, std::source_location loc = std::source_location::current())
2743 assert(m_node !=
nullptr);
2744 std::unique_lock lock(m_node->m_mutex);
2746 m_node->m_messages.push_back(std::move(msg));
2747 return std::suspend_never{};
2750 auto unhandled_exception()
2752 assert(m_node !=
nullptr);
2753 assert(m_worker !=
nullptr);
2754 std::unique_lock lock(m_node->m_mutex);
2756 error_result captured_error = m_graph->capture_current_exception();
2758 if (unexpected_exception !=
nullptr)
2760 m_graph->print_noncanonical_exception_diagnostic(
this, captured_error);
2762 res.
set_error(std::move(captured_error));
2763 std::vector< graph::resumption > subquery_waiters = m_graph->finalize_parent_failed_subqueries_locked(m_node, res.
get_error_result());
2764 if (unexpected_exception !=
nullptr)
2766 m_node->abort_waiters(m_worker, lock, unexpected_exception);
2767 graph::abort_resumptions(m_worker, std::move(subquery_waiters), unexpected_exception);
2771 m_node->unblock_waiters(m_worker, lock);
2772 graph::declare_resumptions(m_worker, std::move(subquery_waiters));
2776 void abort_with_unexpected_exception(graph::worker* worker, std::exception_ptr exception)
override
2778 this->m_worker = worker;
2779 assert(m_node !=
nullptr);
2780 m_graph->template abort_query_node_with_unexpected_exception< query_handler_output_t< HandlerSpec > >(m_node, worker, exception);
2783 template <
typename Res >
2784 void await_suspend_on(query_result< Res > q)
2786 std::unique_lock lock(q.m_node->m_mutex);
2788 graph::worker* current_worker = m_worker;
2789 assert(current_worker !=
nullptr);
2790 current_worker->check_legal_access();
2791 auto h = std::coroutine_handle< promise_type >::from_promise(*
this);
2793 if (q.await_ready(lock))
2795 result< Res > const& res = std::any_cast< result< Res >
const& >(q.m_node->m_result);
2800 abort_with_unexpected_exception(current_worker, unexpected_exception);
2805 current_worker->declare_runnable(graph::resumption{.m_promise =
this, .handle = h},
false);
2810 q.m_node->waiters.push_back(graph::resumption{.m_promise =
this, .handle = h});
2817 promise_type* m_promise =
nullptr;
2819 coroutine() noexcept : m_promise(
nullptr)
2827 m_promise = other.m_promise;
2828 other.m_promise =
nullptr;
2831 m_promise->m_coroutine =
this;
2839 m_promise->m_coroutine =
nullptr;
2840 std::coroutine_handle< promise_type >::from_promise(*m_promise).destroy();
2844 coroutine(promise_type* p) : m_promise(p)
2846 assert(p->m_coroutine ==
nullptr);
2847 p->m_coroutine =
this;
2853 template < query_handler_spec_c HandlerSpec,
typename Ret >
2854 class cosubroutine_impl
2856 friend struct promise_type;
2857 friend struct coroutine< HandlerSpec >;
2858 template < query_handler_spec_c OtherHandlerSpec,
typename OtherRet >
2859 friend class cosubroutine_impl;
2862 using spec_type = HandlerSpec;
2863 struct promise_type :
public graph::promise_base
2865 using root_coroutine_type = coroutine< HandlerSpec >;
2866 using coroutine_type = cosubroutine_impl< HandlerSpec, Ret >;
2870 typename graph::template query_descriptor< query_handler_query_t< HandlerSpec > >* m_handler_entry =
nullptr;
2871 cosubroutine_impl* m_srt =
nullptr;
2872 result< Ret > m_result;
2873 std::optional< graph::resumption > m_waiter;
2875 std::string query_name()
const override
2877 return std::string(query_handler_query_t< HandlerSpec >::query_id);
2880 std::string input_text()
const override
2882 using input_type = query_handler_input_t< HandlerSpec >;
2883 input_type
const* input = std::any_cast< input_type const* >(m_node->m_input);
2884 return m_graph->datavalue_to_string(*input);
2887 auto get_return_object()
2889 return cosubroutine_impl(
this);
2892 auto initial_suspend()
2894 return std::suspend_always{};
2897 void return_value(Ret value)
2899 assert(m_node !=
nullptr);
2900 assert(this->m_worker !=
nullptr);
2903 std::unique_lock lock(m_mutex);
2904 m_result.set_value(std::move(value));
2905 unblock_waiter(lock);
2909 auto yield_value(debug_message msg, std::source_location loc = std::source_location::current())
2911 assert(m_node !=
nullptr);
2912 std::unique_lock lock(m_node->m_mutex);
2914 m_node->m_messages.push_back(std::move(msg));
2915 return std::suspend_never{};
2919 template < query_spec_c QuerySpec >
2920 auto yield_value(dependency< QuerySpec > dep)
2922 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< QuerySpec >(),
"Making a request to a query which is not listed in the HandlerSpec::dependencies");
2923 assert(m_worker !=
nullptr);
2924 assert(m_node !=
nullptr);
2926 typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec >& handler_impl = *std::any_cast< std::shared_ptr< typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec > >& >(m_handler_entry->m_query_handler_impl);
2927 typename graph::template query_descriptor< QuerySpec >& dep_query_descriptor = handler_impl.template get_dependency_descriptor< QuerySpec >();
2928 query_result< typename QuerySpec::output_type > await_obj = dep_query_descriptor.m_get(m_worker, dep.m_request.m_input,
true);
2929 graph::query_node* await_node = await_obj.m_node;
2930 graph::declare_dependency(m_node, await_node);
2931 return std::suspend_never{};
2934 auto final_suspend() noexcept
2936 std::unique_lock lock(m_mutex);
2937 assert(m_result.has_result());
2938 return std::suspend_always{};
2941 auto unhandled_exception()
2943 std::unique_lock lock(m_mutex);
2944 assert(m_node !=
nullptr);
2945 assert(this->m_worker !=
nullptr);
2946 m_result.set_error(m_graph->capture_current_exception());
2947 unblock_waiter(lock);
2950 void abort_with_unexpected_exception(graph::worker* worker, std::exception_ptr exception)
override
2952 this->m_worker = worker;
2954 std::unique_lock lock(m_mutex);
2955 if (!m_result.has_result())
2957 m_result.set_error(error_result::unexpected(exception));
2960 assert(m_node !=
nullptr);
2961 m_graph->template abort_query_node_with_unexpected_exception< query_handler_output_t< HandlerSpec > >(m_node, worker, exception);
2964 auto unblock_waiter(std::unique_lock< std::mutex >& lock)
2966 if (m_waiter.has_value())
2968 auto resumption = m_waiter.value();
2970 m_worker->check_legal_access();
2971 m_worker->declare_runnable(resumption,
false);
2977 template <
typename Ret2 >
2978 auto await_transform(
typename coroutine< HandlerSpec >::template cosubroutine< Ret2 >&& sub)
2980 assert(m_node !=
nullptr);
2981 sub.m_promise->m_graph = m_graph;
2982 sub.m_promise->m_node = m_node;
2983 sub.m_promise->m_handler_entry = m_handler_entry;
2984 m_worker->declare_runnable(std::coroutine_handle<
typename coroutine< HandlerSpec >::template cosubroutine< Ret2 >::promise_type >::from_promise(*sub.m_promise), sub.m_promise,
false);
2985 return typename coroutine< HandlerSpec >::template cosubroutine< Ret2 >::awaitable(sub.m_promise);
2988 template < query_spec_c QuerySpec >
2989 auto await_transform(request< QuerySpec > a) -> query_result< typename QuerySpec::output_type >
2991 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< QuerySpec >(),
"Making a request to a query which is not listed in the HandlerSpec::dependencies");
2992 assert(m_worker !=
nullptr);
2993 assert(m_node !=
nullptr);
2995 typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec >& handler_impl = *std::any_cast< std::shared_ptr< typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec > >& >(m_handler_entry->m_query_handler_impl);
2997 typename graph::template query_descriptor< QuerySpec >& dep_query_descriptor = handler_impl.template get_dependency_descriptor< QuerySpec >();
2999 query_result< typename QuerySpec::output_type > await_obj = dep_query_descriptor.m_get(m_worker, a.m_input,
false);
3001 graph::query_node* await_node = await_obj.m_node;
3002 graph::declare_dependency(m_node, await_node);
3006 template < subquery_spec_c SubquerySpec >
3007 auto await_transform(subquery_request< SubquerySpec > a) -> subquery_query_result< SubquerySpec >
3009 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< SubquerySpec >(),
"Making a subquery request requires listing the subquery in query_handler_dependencies_t< HandlerSpec >");
3010 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< typename SubquerySpec::parent_query >(),
"Making a subquery request requires listing the subquery parent query in query_handler_dependencies_t< HandlerSpec >");
3011 assert(m_worker !=
nullptr);
3012 assert(m_node !=
nullptr);
3014 typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec >& handler_impl = *std::any_cast< std::shared_ptr< typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec > >& >(m_handler_entry->m_query_handler_impl);
3016 typename graph::template query_descriptor< typename SubquerySpec::parent_query >& parent_query_descriptor = handler_impl.template get_subquery_parent_descriptor< SubquerySpec >();
3018 query_result< typename SubquerySpec::parent_query::output_type > parent_await_obj = parent_query_descriptor.m_get(m_worker, a.m_parent_input,
false);
3020 graph::query_node* parent_node = parent_await_obj.m_node;
3021 graph::declare_dependency(m_node, parent_node);
3022 return m_graph->template get_subquery_result< SubquerySpec >(m_worker, parent_node, a.m_input);
3025 template < subquery_spec_c SubquerySpec >
3026 auto yield_value(subquery_result< SubquerySpec > res)
3028 static_assert(query_handler_produced_subqueries_t< HandlerSpec >::template contains< SubquerySpec >(),
"Yielding a subquery result requires listing the subquery in query_handler_produced_subqueries_t< HandlerSpec >");
3029 static_assert(std::same_as< typename SubquerySpec::parent_query, query_handler_query_t< HandlerSpec > >,
"A handler can only yield subqueries whose parent_query is the handler query");
3030 assert(m_worker !=
nullptr);
3031 assert(m_node !=
nullptr);
3033 m_graph->template set_subquery_result< SubquerySpec >(m_worker, m_node, std::move(res.m_input), std::move(res.m_output));
3034 return std::suspend_never{};
3039 assert(m_srt ==
nullptr);
3045 promise_type* m_promise;
3048 awaitable(promise_type* promise) : m_promise(promise)
3054 std::unique_lock lck(m_promise->m_mutex);
3055 return await_ready(lck);
3058 bool await_ready([[maybe_unused]] std::unique_lock< std::mutex >& lock)
noexcept
3060 assert(m_promise !=
nullptr);
3061 return m_promise->m_result.has_result();
3066 std::unique_lock lck(m_promise->m_mutex);
3067 assert(m_promise !=
nullptr);
3068 assert(m_promise->m_result.has_result());
3069 return m_promise->m_result.value();
3072 template <
typename U >
3073 void await_suspend(std::coroutine_handle< U > h)
3075 await_suspend_helper< typename U::coroutine_type >(h.promise(), h);
3078 template <
typename C >
3079 void await_suspend_helper(
typename C::promise_type& p, std::coroutine_handle< typename C::promise_type > h)
3081 assert(m_promise !=
nullptr);
3083 graph::worker* current_worker = p.m_worker;
3084 assert(current_worker !=
nullptr);
3085 current_worker->check_legal_access();
3087 graph::resumption r{.m_promise = &h.promise(), .handle = h};
3088 std::unique_lock lck(m_promise->m_mutex);
3090 if (await_ready(lck))
3092 p.m_worker->declare_runnable(r,
false);
3096 assert(m_promise->m_waiter.has_value() ==
false);
3097 m_promise->m_waiter = r;
3103 promise_type* m_promise;
3106 cosubroutine_impl(promise_type* p) : m_promise(p)
3108 assert(p->m_srt ==
nullptr);
3112 cosubroutine_impl(
const cosubroutine_impl&) =
delete;
3113 cosubroutine_impl& operator=(
const cosubroutine_impl&) =
delete;
3115 ~cosubroutine_impl()
3119 std::unique_lock lock(m_promise->m_run_mutex);
3122 m_promise->m_srt =
nullptr;
3123 std::coroutine_handle< promise_type >::from_promise(*m_promise).destroy();
3128 template < query_handler_spec_c HandlerSpec >
3129 class cosubroutine_impl< HandlerSpec, void >
3131 friend struct promise_type;
3132 friend struct coroutine< HandlerSpec >;
3133 template < query_handler_spec_c OtherHandlerSpec,
typename OtherRet >
3134 friend class cosubroutine_impl;
3137 using spec_type = HandlerSpec;
3138 struct promise_type :
public graph::promise_base
3140 using root_coroutine_type = coroutine< HandlerSpec >;
3141 using coroutine_type = cosubroutine_impl< HandlerSpec, void >;
3145 typename graph::template query_descriptor< query_handler_query_t< HandlerSpec > >* m_handler_entry =
nullptr;
3146 cosubroutine_impl* m_srt =
nullptr;
3147 result< void > m_result;
3148 std::optional< graph::resumption > m_waiter;
3150 std::string query_name()
const override
3152 return std::string(query_handler_query_t< HandlerSpec >::query_id);
3155 std::string input_text()
const override
3157 using input_type = query_handler_input_t< HandlerSpec >;
3158 input_type
const* input = std::any_cast< input_type const* >(m_node->m_input);
3159 return m_graph->datavalue_to_string(*input);
3162 auto get_return_object()
3164 return cosubroutine_impl(
this);
3167 auto initial_suspend()
3169 return std::suspend_always{};
3174 assert(m_node !=
nullptr);
3175 assert(this->m_worker !=
nullptr);
3178 std::unique_lock lock(m_mutex);
3179 m_result.set_value();
3180 unblock_waiter(lock);
3184 auto yield_value(debug_message msg, std::source_location loc = std::source_location::current())
3186 assert(m_node !=
nullptr);
3187 std::unique_lock lock(m_node->m_mutex);
3189 m_node->m_messages.push_back(std::move(msg));
3190 return std::suspend_never{};
3194 template < query_spec_c QuerySpec >
3195 auto yield_value(dependency< QuerySpec > dep)
3197 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< QuerySpec >(),
"Making a request to a query which is not listed in the HandlerSpec::dependencies");
3198 assert(m_worker !=
nullptr);
3199 assert(m_node !=
nullptr);
3201 typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec >& handler_impl = *std::any_cast< std::shared_ptr< typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec > >& >(m_handler_entry->m_query_handler_impl);
3202 typename graph::template query_descriptor< QuerySpec >& dep_query_descriptor = handler_impl.template get_dependency_descriptor< QuerySpec >();
3203 query_result< typename QuerySpec::output_type > await_obj = dep_query_descriptor.m_get(m_worker, dep.m_request.m_input,
true);
3204 graph::query_node* await_node = await_obj.m_node;
3205 graph::declare_dependency(m_node, await_node);
3206 return std::suspend_never{};
3209 auto final_suspend() noexcept
3211 std::unique_lock lock(m_mutex);
3212 assert(m_result.has_result());
3213 return std::suspend_always{};
3216 auto unhandled_exception()
3218 std::unique_lock lock(m_mutex);
3219 assert(m_node !=
nullptr);
3220 assert(this->m_worker !=
nullptr);
3221 m_result.set_error(m_graph->capture_current_exception());
3222 unblock_waiter(lock);
3225 void abort_with_unexpected_exception(graph::worker* worker, std::exception_ptr exception)
override
3227 this->m_worker = worker;
3229 std::unique_lock lock(m_mutex);
3230 if (!m_result.has_result())
3232 m_result.set_error(error_result::unexpected(exception));
3235 assert(m_node !=
nullptr);
3236 m_graph->template abort_query_node_with_unexpected_exception< query_handler_output_t< HandlerSpec > >(m_node, worker, exception);
3239 auto unblock_waiter(std::unique_lock< std::mutex >& lock)
3241 if (m_waiter.has_value())
3243 auto resumption = m_waiter.value();
3245 m_worker->check_legal_access();
3246 m_worker->declare_runnable(resumption,
false);
3252 template <
typename Ret2 >
3253 auto await_transform(
typename coroutine< HandlerSpec >::template cosubroutine< Ret2 >&& sub)
3255 assert(m_node !=
nullptr);
3256 sub.m_promise->m_graph = m_graph;
3257 sub.m_promise->m_node = m_node;
3258 sub.m_promise->m_handler_entry = m_handler_entry;
3259 m_worker->declare_runnable(std::coroutine_handle<
typename coroutine< HandlerSpec >::template cosubroutine< Ret2 >::promise_type >::from_promise(*sub.m_promise), sub.m_promise,
false);
3260 return typename coroutine< HandlerSpec >::template cosubroutine< Ret2 >::awaitable(sub.m_promise);
3263 template < query_spec_c QuerySpec >
3264 auto await_transform(request< QuerySpec > a) -> query_result< typename QuerySpec::output_type >
3266 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< QuerySpec >(),
"Making a request to a query which is not listed in the HandlerSpec::dependencies");
3267 assert(m_worker !=
nullptr);
3268 assert(m_node !=
nullptr);
3270 typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec >& handler_impl = *std::any_cast< std::shared_ptr< typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec > >& >(m_handler_entry->m_query_handler_impl);
3272 typename graph::template query_descriptor< QuerySpec >& dep_query_descriptor = handler_impl.template get_dependency_descriptor< QuerySpec >();
3274 query_result< typename QuerySpec::output_type > await_obj = dep_query_descriptor.m_get(m_worker, a.m_input,
false);
3276 graph::query_node* await_node = await_obj.m_node;
3277 graph::declare_dependency(m_node, await_node);
3281 template < subquery_spec_c SubquerySpec >
3282 auto await_transform(subquery_request< SubquerySpec > a) -> subquery_query_result< SubquerySpec >
3284 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< SubquerySpec >(),
"Making a subquery request requires listing the subquery in query_handler_dependencies_t< HandlerSpec >");
3285 static_assert(query_handler_dependencies_t< HandlerSpec >::template contains< typename SubquerySpec::parent_query >(),
"Making a subquery request requires listing the subquery parent query in query_handler_dependencies_t< HandlerSpec >");
3286 assert(m_worker !=
nullptr);
3287 assert(m_node !=
nullptr);
3289 typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec >& handler_impl = *std::any_cast< std::shared_ptr< typename graph::template query_handler_descriptor_memoized_impl< HandlerSpec > >& >(m_handler_entry->m_query_handler_impl);
3291 typename graph::template query_descriptor< typename SubquerySpec::parent_query >& parent_query_descriptor = handler_impl.template get_subquery_parent_descriptor< SubquerySpec >();
3293 query_result< typename SubquerySpec::parent_query::output_type > parent_await_obj = parent_query_descriptor.m_get(m_worker, a.m_parent_input,
false);
3295 graph::query_node* parent_node = parent_await_obj.m_node;
3296 graph::declare_dependency(m_node, parent_node);
3297 return m_graph->template get_subquery_result< SubquerySpec >(m_worker, parent_node, a.m_input);
3300 template < subquery_spec_c SubquerySpec >
3301 auto yield_value(subquery_result< SubquerySpec > res)
3303 static_assert(query_handler_produced_subqueries_t< HandlerSpec >::template contains< SubquerySpec >(),
"Yielding a subquery result requires listing the subquery in query_handler_produced_subqueries_t< HandlerSpec >");
3304 static_assert(std::same_as< typename SubquerySpec::parent_query, query_handler_query_t< HandlerSpec > >,
"A handler can only yield subqueries whose parent_query is the handler query");
3305 assert(m_worker !=
nullptr);
3306 assert(m_node !=
nullptr);
3308 m_graph->template set_subquery_result< SubquerySpec >(m_worker, m_node, std::move(res.m_input), std::move(res.m_output));
3309 return std::suspend_never{};
3314 assert(m_srt ==
nullptr);
3320 promise_type* m_promise;
3323 awaitable(promise_type* promise) : m_promise(promise)
3329 std::unique_lock lck(m_promise->m_mutex);
3330 return await_ready(lck);
3333 bool await_ready([[maybe_unused]] std::unique_lock< std::mutex >& lock)
noexcept
3335 assert(m_promise !=
nullptr);
3336 return m_promise->m_result.has_result();
3341 std::unique_lock lck(m_promise->m_mutex);
3342 assert(m_promise !=
nullptr);
3343 assert(m_promise->m_result.has_result());
3344 m_promise->m_result.test();
3347 template <
typename U >
3348 void await_suspend(std::coroutine_handle< U > h)
3350 await_suspend_helper< typename U::coroutine_type >(h.promise(), h);
3353 template <
typename C >
3354 void await_suspend_helper(
typename C::promise_type& p, std::coroutine_handle< typename C::promise_type > h)
3356 assert(m_promise !=
nullptr);
3358 graph::worker* current_worker = p.m_worker;
3359 assert(current_worker !=
nullptr);
3360 current_worker->check_legal_access();
3362 graph::resumption r{.m_promise = &h.promise(), .handle = h};
3363 std::unique_lock lck(m_promise->m_mutex);
3365 if (await_ready(lck))
3367 p.m_worker->declare_runnable(r,
false);
3371 assert(m_promise->m_waiter.has_value() ==
false);
3372 m_promise->m_waiter = r;
3378 promise_type* m_promise;
3381 cosubroutine_impl(promise_type* p) : m_promise(p)
3383 assert(p->m_srt ==
nullptr);
3387 cosubroutine_impl(
const cosubroutine_impl&) =
delete;
3388 cosubroutine_impl& operator=(
const cosubroutine_impl&) =
delete;
3390 ~cosubroutine_impl()
3394 std::unique_lock lock(m_promise->m_run_mutex);
3397 m_promise->m_srt =
nullptr;
3398 std::coroutine_handle< promise_type >::from_promise(*m_promise).destroy();
Indicates that a handler completed without a continuation outcome.
Owns handler registrations, memoized nodes, and query execution.
~graph()
Drain this graph's scheduled work before releasing cached nodes. All external calls on this graph mus...
bool node_debug_io_capture_enabled() const noexcept
Return whether human-readable node input/output capture is enabled.
void register_handler_singleton(query_handler_output_t< HandlerSpec > value)
Register a constant result for a handler with monostate input.
void register_binary_descriptors()
Register serialization operations and a type signature.
void register_handler_map(std::map< query_handler_input_t< QuerySpec >, query_handler_output_t< QuerySpec > > handler_map)
Register a finite map as a query handler.
void register_canonical_error()
Register an exception type for canonical capture and dumping.
void register_handler_singleton(typename QuerySpec::output_type value)
Register a constant result directly from a query spec.
auto make_subquery_request(typename SubquerySpec::parent_query::input_type parent_input, typename SubquerySpec::input_type input) -> typename SubquerySpec::output_type
Execute or reuse a subquery request from an external thread.
void for_each_marshaled_type_descriptor(Visitor visitor)
Visit the serialization and text descriptors of registered types.
auto async_make_request(typename QuerySpec::input_type input) -> std::future< typename QuerySpec::output_type >
Submit a query and return a future without waiting for evaluation.
void register_handler_function(Handler h)
Register the coroutine function implementing a query.
graph(scheduler &execution_scheduler, options configuration)
Construct a graph with timing options and built-in subquery errors.
graph(scheduler &execution_scheduler)
Construct an empty graph using a scheduler that outlives it.
void register_inputoutput_text_descriptor()
Register the diagnostic text conversion for a value type.
std::vector< std::byte > marshall()
Serialize a snapshot of every memoized node.
auto make_request(typename QuerySpec::input_type input) -> typename QuerySpec::output_type
Execute or reuse a top-level query and return its value.
void bind_handlers()
Resolve every registered handler's declared dependencies.
graph_data dump()
Snapshot every currently memoized query node.
auto dump_query_to_file(std::filesystem::path output_path, typename QuerySpec::input_type input) -> std::filesystem::path
Evaluate a root query and write its reachable graph to disk.
Owns a persistent worker pool shared by independently cached graphs.
scheduler(options configuration)
Start a worker pool using the supplied scheduling options.
scheduler & operator=(scheduler const &)=delete
Keep each scheduler's worker pool bound to its original owner.
~scheduler()
Stop and join the worker threads after all graphs are destroyed.
scheduler()
Start a worker pool using default scheduling options.
scheduler(scheduler const &)=delete
Schedulers have stable worker addresses and cannot be copied.
subquery_does_not_exist()
Construct an empty instance for deserialization.
subquery_does_not_exist(std::string subquery_id)
Construct an error naming the missing subquery.
void post_serialize()
Rebuild the derived human-readable message after deserialization.
std::string const & subquery_id() const noexcept
Return the stable identifier of the missing subquery.
char const * what() const noexcept override
Return the derived error message.
std::string const & subquery_id() const noexcept
Return the stable identifier of the affected subquery.
subquery_parent_failed(std::string subquery_id)
Construct an error naming the affected subquery.
Discriminated error state used by query and subquery results.
std::exception_ptr make_exception_ptr() const
Materialize either error representation as an exception pointer.
std::exception_ptr unexpected_exception() const
Return the unexpected exception pointer, if present.
status result_status() const
Return the dump status represented by this error state.
std::string message() const
Return the error message, or an empty string for no error.
bool has_error() const
Return whether either error representation is present.
std::optional< canonical_error_result_data > canonical_dump() const
Return serializable data only when the error is canonical.
static error_result canonical(canonical_error_storage error)
Construct an error state from canonical storage.
bool has_unexpected_exception() const
Return whether an unexpected exception is present.
static error_result unexpected(std::exception_ptr exception)
Construct an error state from an unexpected exception.
void throw_error() const
Rethrow the stored error; do nothing when the state is empty.
bool has_canonical_error() const
Return whether a serializable canonical error is present.
error_result()=default
Construct an empty error state.
void get() const
Verify successful completion or throw the stored error.
result()=default
Construct a pending result.
bool has_exception() const
Compatibility spelling for has_error().
status result_status() const
Return the status used when serializing this result.
void test() const
Rethrow the stored error, if one exists.
bool has_result() const
Return whether evaluation produced success or an error.
void set_exception(std::exception_ptr exception)
Compatibility spelling for set_error(exception).
void set_value()
Replace any prior state with successful completion.
bool has_canonical_error() const
Return whether the result contains a canonical error.
bool has_unexpected_exception() const
Return whether the result contains an unexpected exception.
void set_error(error_result error)
Replace any prior state with error.
error_result const & get_error_result() const
Return the stored error state without throwing.
bool has_value() const
Return whether evaluation completed successfully.
void set_error(std::exception_ptr exception)
Replace any prior state with an unexpected exception.
std::exception_ptr get_error() const
Materialize the stored error as an exception pointer.
void value() const
Alias for get().
bool has_error() const
Return whether evaluation completed with an error.
result(std::exception_ptr exception)
Construct a failed result from an unexpected exception.
Internal value-or-error state shared by query awaitables and dumps.
T & get() &
Return the value or throw the stored error.
bool has_exception() const
Compatibility spelling for has_error().
void set_error(error_result error)
Replace any prior state with error.
void set_error(std::exception_ptr exception)
Replace any prior state with an unexpected exception.
T && get() &&
Return the value or throw the stored error.
status result_status() const
Return the status used when serializing this result.
T const & value() const &
Alias for get() preserving the value category.
void set_exception(std::exception_ptr exception)
Compatibility spelling for set_error(exception).
result()=default
Construct a pending result.
T const & get() const &
Return the value or throw the stored error.
bool has_unexpected_exception() const
Return whether the result contains an unexpected exception.
bool has_value() const
Return whether evaluation completed successfully.
T const && value() const &&
Alias for get() preserving the value category.
void test() const
Rethrow the stored error, if one exists.
T & value() &
Alias for get() preserving the value category.
void set_value(T value)
Replace any prior state with a completed value.
error_result const & get_error_result() const
Return the stored error state without throwing.
T && value() &&
Alias for get() preserving the value category.
bool has_canonical_error() const
Return whether the result contains a canonical error.
std::exception_ptr get_error() const
Materialize the stored error as an exception pointer.
bool has_result() const
Return whether evaluation produced either a value or an error.
bool has_error() const
Return whether evaluation completed with an error.
result(std::exception_ptr exception)
Construct a failed result from an unexpected exception.
result(T value)
Construct a completed result from value.
T const && get() const &&
Return the value or throw the stored error.
Identifies handler specs that explicitly list produced subqueries.
Identifies a complete query handler specification.
Identifies the required structural portion of a handler spec.
Identifies a type that describes a memoized query.
Identifies a result class produced within a parent query node.
Detects a value-provided to_debug_string() operation.
Serializable data model for QueryGraph diagnostic dumps.
std::array< std::byte, 16 > tsig
Fixed-size RPNXSerialization type-signature digest.
status
Terminal or in-progress state recorded for a dumped result.
Default hashing customization point for memoized query inputs.
std::condition_variable fast_cv
Condition variable compatible with fast_mutex.
std::mutex fast_mutex
Platform-selected mutex used by scheduler queues.
typename query_handler_query_t< HandlerSpec >::output_type query_handler_output_t
Output type of the query implemented by HandlerSpec.
std::string format_debug_message_with_source(debug_message const &msg)
Prefix a diagnostic message with its source file and line.
typename query_handler_query_t< HandlerSpec >::input_type query_handler_input_t
Input type of the query implemented by HandlerSpec.
typename query_handler_traits< HandlerSpec >::query query_handler_query_t
Normalized query type implemented by HandlerSpec.
typename query_handler_traits< HandlerSpec >::produced_subqueries query_handler_produced_subqueries_t
Subquery result classes that HandlerSpec may yield.
memory_class
Coarse estimate of a query node's peak memory requirement.
std::shared_mutex shared_mutex
Shared mutex type used by query result awaitables.
typename query_handler_traits< HandlerSpec >::dependencies query_handler_dependencies_t
Declared query and subquery dependencies of HandlerSpec.
canonical_error_storage make_canonical_error_storage(Error const &error)
Capture a concrete exception in canonical type-erased storage.
static std::vector< std::byte > serialize_to_binary(std::monostate const &)
Return the unique empty encoding of a monostate value.
Binary serialization customization point for dumpable values.
static std::vector< std::byte > serialize_to_binary(T const &value)
Serialize one value into a byte vector.
Serializable representation of a registered canonical error.
Type-erased, copyable storage for a registered exception value.
std::function< void(std::any const &) > m_throw_copy
Operation that throws a copy of m_error_value.
void throw_copy() const
Throw a copy of the stored concrete exception.
std::any m_error_value
Type-erased concrete exception value.
tsig m_error_typesig
Type signature of the concrete exception type.
std::function< std::string(std::any const &) > m_message
Operation that obtains the concrete exception message.
canonical_error_result_data dump() const
Convert the error to its serializable dump representation.
std::string message() const
Return the stored exception's human-readable message.
std::function< std::vector< std::byte >(std::any const &) > m_serialize
Operation that serializes m_error_value.
std::exception_ptr make_exception_ptr() const
Return an exception_ptr holding a copy of the error.
Owning coroutine return object for a registered query handler.
HandlerSpec spec_type
Handler specification associated with this coroutine.
cosubroutine_impl< HandlerSpec, Ret > cosubroutine
Coroutine-aware, non-memoized sub-operation return type.
Coroutine yield value that schedules a dependency without waiting.
dependency(request< QuerySpec > request)
Wrap a request for use with co_yield.
request< QuerySpec > m_request
Request to schedule without immediately awaiting it.
Configure cumulative node self-time diagnostics.
std::chrono::nanoseconds long_running_node_threshold
Completion diagnostics require self-time greater than this duration.
std::chrono::nanoseconds long_running_progress_threshold
Progress diagnostics additionally require this much self-time. Progress is checked after coroutine re...
std::function< void(std::string const &) > timing_logger
Receive complete timing messages, including a trailing newline. The default writes to standard error....
bool enable_timing
Collect node self-time and emit timing diagnostics when enabled.
Awaitable request for a memoized query value.
QuerySpec::input_type m_input
Input value used to locate or create the requested node.
request(typename QuerySpec::input_type input)
Construct a request by taking ownership of its input.
Configure the shared worker pool and runnable queue.
std::optional< std::size_t > global_workitem_threshold
Target shared queue depth; defaults to the resolved worker count.
std::optional< std::size_t > thread_count
Worker count; defaults to twice hardware concurrency, or two.
Awaitable request for a subquery value produced by a parent node.
subquery_request(typename SubquerySpec::parent_query::input_type parent_input, typename SubquerySpec::input_type input)
Construct a request scoped to one parent input.
SubquerySpec::parent_query::input_type m_parent_input
Input identifying the parent query node.
SubquerySpec::input_type m_input
Input identifying the subquery slot within the parent.
Coroutine yield value that publishes one subquery result.
subquery_result(typename SubquerySpec::input_type input, typename SubquerySpec::output_type output)
Construct a subquery input/output pair to publish.
SubquerySpec::input_type m_input
Input identifying the produced subquery slot.
SubquerySpec::output_type m_output
Output to publish for the identified slot.
A diagnostic emitted by a running query handler.
debug_message(std::format_string< Ts... > format_string, Ts &&... args)
Construct and format a diagnostic message.
std::string message
Already-formatted diagnostic text.
debug_message(debug_message const &other)=default
Copy a message and its recorded location.
std::source_location location
Source location assigned at the handler's co_yield site.
static std::string to_debug_string(std::monostate const &)
Return the literal std::monostate{}.
static std::string to_debug_string(std::string const &value)
Return the C++ debug-format representation of value.
Human-readable formatting customization point for query values.
static std::string to_debug_string(T const &value)
Convert value to diagnostic text.
Complete serializable snapshot of a QueryGraph instance.
Boolean trait equivalent of query_handler_spec_c.
typename T::produced_subqueries produced_subqueries
Subquery specifications the handler may publish.
Supplies an empty produced-subquery list when a handler omits it.
rpnx::typelist<> produced_subqueries
Default empty list used when T has no declaration.
typename T::query query
Query specification implemented by the handler.
typename query_handler_produced_subquery_traits< T >::produced_subqueries produced_subqueries
Declared produced subqueries, or an empty typelist.
typename T::dependencies dependencies
Declared query and subquery dependencies.
Normalizes the nested types of a handler specification.