175 lines
5.3 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.
// Modified from
// https://github.com/brycelelbach/wg21_p2300_std_execution/blob/main/include/execution.hpp
#ifndef MMDEPLOY_CSRC_EXPERIMENTAL_EXECUTION_SPLIT_H_
#define MMDEPLOY_CSRC_EXPERIMENTAL_EXECUTION_SPLIT_H_
#include "closure.h"
#include "concepts.h"
#include "utility.h"
namespace mmdeploy {
namespace __split {
template <typename SharedState>
struct _Receiver {
struct type;
};
template <typename SharedState>
using receiver_t = typename _Receiver<SharedState>::type;
struct _OperationBase {
_OperationBase* next_;
void (*notify_)(_OperationBase*) noexcept;
};
template <typename SharedState>
struct _Receiver<SharedState>::type {
SharedState& shared_state_;
template <typename... As>
friend void tag_invoke(set_value_t, type&& self, As&&... as) noexcept {
auto& state = self.shared_state_;
state.data_.emplace((As &&) as...);
state._Notify();
}
};
template <typename Sender>
struct _SharedState {
std::optional<completion_signatures_of_t<Sender>> data_;
using Receiver = receiver_t<_SharedState>;
connect_result_t<Sender, Receiver> op_state2_;
std::atomic<void*> head_{nullptr};
explicit _SharedState(Sender& sender)
: op_state2_(Connect((Sender &&) sender, Receiver{*this})) {}
void _Notify() noexcept {
void* const completion_state = static_cast<void*>(this);
void* old = head_.exchange(completion_state, std::memory_order_acq_rel);
auto* op_state = static_cast<_OperationBase*>(old);
while (op_state != nullptr) {
_OperationBase* next = op_state->next_;
op_state->notify_(op_state);
op_state = next;
}
}
};
template <typename Sender, typename Receiver>
struct _Operation {
struct type;
};
template <typename Sender, typename Receiver>
using operation_t = typename _Operation<Sender, remove_cvref_t<Receiver>>::type;
template <typename Sender, typename Receiver>
struct _Operation<Sender, Receiver>::type : _OperationBase {
Receiver receiver_;
std::shared_ptr<_SharedState<Sender>> shared_state_;
type(Receiver&& receiver, std::shared_ptr<_SharedState<Sender>> shared_state)
: _OperationBase{nullptr, _Notify},
receiver_(std::move(receiver)),
shared_state_(std::move(shared_state)) {}
static void _Notify(_OperationBase* self) noexcept {
auto op = static_cast<type*>(self);
std::apply([&](const auto&... args) { SetValue(std::move(op->receiver_), args...); },
op->shared_state_->data_.value());
}
friend void tag_invoke(start_t, type& self) {
auto shared_state = self.shared_state_.get();
std::atomic<void*>& head = shared_state->head_;
void* const completion_state = static_cast<void*>(shared_state);
void* old = head.load(std::memory_order_acquire);
do {
if (old == completion_state) {
self._Notify(&self);
return;
}
self.next_ = static_cast<_OperationBase*>(old);
} while (!head.compare_exchange_weak(old, static_cast<void*>(&self), std::memory_order_release,
std::memory_order_acquire));
if (old == nullptr) {
Start(shared_state->op_state2_);
}
}
};
template <typename Sender>
struct _Sender {
struct type;
};
template <typename Sender>
using sender_t = typename _Sender<remove_cvref_t<Sender>>::type;
template <typename Sender>
struct _Sender<Sender>::type {
using SharedState = _SharedState<Sender>;
template <typename Receiver>
using _operation_t = operation_t<Sender, Receiver>;
using value_types = completion_signatures_of_t<Sender>;
Sender sender_;
std::shared_ptr<SharedState> shared_state_;
explicit type(Sender sender)
: sender_(std::move(sender)), shared_state_{std::make_shared<SharedState>(sender_)} {}
template <typename Self, typename Receiver, _decays_to<Self, type, int> = 0>
friend auto tag_invoke(connect_t, Self&& self, Receiver&& receiver) -> _operation_t<Receiver> {
return _operation_t<Receiver>((Receiver &&) receiver, self.shared_state_);
}
};
struct split_t {
template <
typename Sender,
std::enable_if_t<
_is_sender<Sender> && _tag_invocable_with_completion_scheduler<split_t, Sender>, int> = 0>
auto operator()(Sender&& sender) const {
auto scheduler = GetCompletionScheduler(sender);
return tag_invoke(split_t{}, std::move(scheduler), (Sender &&) sender);
}
template <typename Sender,
std::enable_if_t<_is_sender<Sender> &&
!_tag_invocable_with_completion_scheduler<split_t, Sender> &&
tag_invocable<split_t, Sender>,
int> = 0>
auto operator()(Sender&& sender) const {
return tag_invoke(split_t{}, (Sender &&) sender);
}
template <typename Sender,
std::enable_if_t<_is_sender<Sender> &&
!_tag_invocable_with_completion_scheduler<split_t, Sender> &&
!tag_invocable<split_t, Sender>,
int> = 0>
sender_t<Sender> operator()(Sender&& sender) const {
return sender_t<Sender>{(Sender &&) sender};
}
_BinderBack<split_t> operator()() const { return {{}, {}, {}}; }
};
} // namespace __split
using __split::split_t;
inline constexpr split_t Split{};
} // namespace mmdeploy
#endif // MMDEPLOY_CSRC_EXPERIMENTAL_EXECUTION_SPLIT_H_