mmdeploy/csrc/execution/concepts.h

136 lines
4.4 KiB
C
Raw Normal View History

[Feature] New pipeline & executor for SDK (#497) * executor prototype * add split/when_all * fix GCC build * WIP let_value * fix let_value * WIP ensure_started * ensure_started & start_detached * fix let_value + when_all combo on MSVC 142 * fix static thread pool * generic just, then, let_value, sync_wait * minor * generic split and when_all * fully generic sender adapters * when_all: workaround for GCC7 * support legacy spdlog * fix memleak * bulk * static detector * fix bulk & first pipeline * bulk for static thread pools * fix on MSVC * WIP async batch submission * WIP collation * async batch * fix detector * fix async detector * fix * fix * debug * fix cuda allocator * WIP type erased executor * better type erasure * simplify C API impl * Expand & type erase TC * deduction guide for type erased senders * fix GCC build * when_all for arrays of Value senders * WIP pipeline v2 * WIP pipeline parser * WIP timed batch operation * add registry * experiment * fix pipeline * naming * fix mem-leak * fix deferred batch operation * WIP * WIP configurable scheduler * WIP configurable scheduler * add comment * parse scheduler config * force link schedulers * WIP pipeable sender * WIP CPO * ADL isolation and dismantle headers * type erase single thread context * fix MSVC build * CPO * replace decay_t with remove_cvref_t * structure adjustment * structure adjustment * apply CPOs & C API rework * refine C API * detector async C API * adjust detector async C API * # Conflicts: # csrc/apis/c/detector.cpp * fix when_all for type erased senders * support void return for Then * async detector * fix some CPOs * minor * WIP rework capture mechanism for type erased types * minor fix * fix MSVC build * move expand.h to execution * make `Expand` pipeable * fix type erased * un-templatize `_TypeErasedOperation` * re-work C API * remove async_detector C API * fix pipeline * add flatten & unflatten * fix flatten & unflatten * add aync OCR demo * config executor for nodes & better executor API * working async OCR example * minor * dynamic batch via scheduler * dynamic batch on `Value` * fix MSVC build * type erase dynamic batch scheduler * sender as Python Awaitable * naming * naming * add docs * minor * merge tmp branch * unify C APIs * fix ocr * unify APIs * fix typo * update async OCR demo * add v3 API text recognizer * fix v3 API * fix lint * add license info & reformat * add demo async_ocr_v2 * revert files * revert files * resolve link issues * fix scheduler linkage for shared libs * fix license header * add docs for `mmdeploy_executor_split` * add missing `mmdeploy_executor_transfer_just` and `mmdeploy_executor_execute` * make `TimedSingleThreadContext` header only * fix lint * simplify type-erased sender
2022-06-01 14:10:43 +08:00
// Copyright (c) OpenMMLab. All rights reserved.
#ifndef MMDEPLOY_CSRC_EXPERIMENTAL_EXECUTION_CONCEPTS_H_
#define MMDEPLOY_CSRC_EXPERIMENTAL_EXECUTION_CONCEPTS_H_
#include "tag_invoke.h"
namespace mmdeploy {
namespace _get_completion_signatures {
struct get_completion_signatures_t {
template <typename Sender, typename ValueTypes = typename remove_cvref_t<Sender>::value_types>
constexpr identity<ValueTypes> operator()(Sender&& sender) const noexcept {
return {};
}
};
} // namespace _get_completion_signatures
using _get_completion_signatures::get_completion_signatures_t;
inline constexpr get_completion_signatures_t GetCompletionSignatures{};
template <typename Sender>
inline constexpr bool _is_sender = std::is_invocable_v<get_completion_signatures_t, Sender>&&
std::is_move_constructible_v<remove_cvref_t<Sender>>;
// GetCompletionSignatures is expected to return identity<std::tuple<Types...>>;
template <typename Sender>
using completion_signatures_of_t =
typename std::invoke_result_t<get_completion_signatures_t, Sender>::type;
namespace _set_value {
struct set_value_t {
template <typename Receiver, typename... Args,
std::enable_if_t<is_tag_invocable_v<set_value_t, Receiver, Args...>, int> = 0>
void operator()(Receiver&& receiver, Args&&... args) const noexcept {
static_assert(is_nothrow_tag_invocable_v<set_value_t, Receiver, Args...>);
(void)tag_invoke(set_value_t{}, (Receiver &&) receiver, (Args &&) args...);
}
};
} // namespace _set_value
using _set_value::set_value_t;
inline constexpr set_value_t SetValue{};
namespace _start {
struct start_t {
template <typename Operation, std::enable_if_t<tag_invocable<start_t, Operation&>, int> = 0>
void operator()(Operation& op_state) const
noexcept(is_nothrow_tag_invocable_v<start_t, Operation&>) {
(void)tag_invoke(start_t{}, op_state);
}
};
} // namespace _start
using _start::start_t;
inline constexpr start_t Start{};
namespace _connect {
struct connect_t {
template <typename Sender, typename Receiver,
std::enable_if_t<is_tag_invocable_v<connect_t, Sender, Receiver>, int> = 0>
auto operator()(Sender&& sender, Receiver&& receiver) const
-> tag_invoke_result_t<connect_t, Sender, Receiver> {
return tag_invoke(connect_t{}, (Sender &&) sender, (Receiver &&) receiver);
}
};
} // namespace _connect
using _connect::connect_t;
inline constexpr connect_t Connect{};
namespace _get_completion_scheduler {
struct get_completion_scheduler_t {
template <
typename Sender,
std::enable_if_t<is_tag_invocable_v<get_completion_scheduler_t, const Sender&>, int> = 0>
auto operator()(const Sender& sender) const noexcept
-> tag_invoke_result_t<get_completion_scheduler_t, const Sender&> {
return tag_invoke(get_completion_scheduler_t{}, sender);
}
};
} // namespace _get_completion_scheduler
using _get_completion_scheduler::get_completion_scheduler_t;
inline constexpr get_completion_scheduler_t GetCompletionScheduler{};
template <typename Sender>
inline constexpr bool _has_completion_scheduler_v =
std::is_invocable_v<get_completion_scheduler_t, Sender>;
template <typename Sender>
struct _has_completion_scheduler : std::bool_constant<_has_completion_scheduler_v<Sender>> {};
template <typename Sender>
using _completion_scheduler_for = std::invoke_result_t<get_completion_scheduler_t, Sender>;
namespace impl {
template <typename Func, typename Sender, typename TArgs, typename SFINAE = void>
struct _tag_invocable_with_completion_scheduler : std::false_type {};
template <typename Func, typename Sender, typename... Args>
struct _tag_invocable_with_completion_scheduler<
Func, Sender, std::tuple<Args...>, std::enable_if_t<_has_completion_scheduler_v<Sender>>>
: is_tag_invocable<Func, _completion_scheduler_for<Sender>, Sender, Args...> {};
} // namespace impl
template <typename Func, typename Sender, typename... Args>
inline constexpr bool _tag_invocable_with_completion_scheduler =
impl::_tag_invocable_with_completion_scheduler<Func, Sender, std::tuple<Args...>>::value;
template <typename T, typename SFINAE = void>
struct _is_range : std::false_type {};
template <typename T>
struct _is_range<T,
std::void_t<decltype(std::begin(std::declval<T>()), std::end(std::declval<T>()))>>
: std::true_type {};
template <typename T>
inline constexpr bool _is_range_v = _is_range<T>::value;
} // namespace mmdeploy
#endif // MMDEPLOY_CSRC_EXPERIMENTAL_EXECUTION_CONCEPTS_H_