lzhangzz 46bfe0ac87
[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

90 lines
2.5 KiB
C++

// Copyright (c) OpenMMLab. All rights reserved.
#ifndef MMDEPLOY_CSRC_EXECUTION_EXPAND_H_
#define MMDEPLOY_CSRC_EXECUTION_EXPAND_H_
#include "closure.h"
#include "concepts.h"
#include "utility.h"
namespace mmdeploy {
namespace _expand {
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 _Receiver {
struct type;
};
template <typename Sender, typename Receiver>
using receiver_t = typename _Receiver<Sender, Receiver>::type;
template <typename Sender, typename Receiver>
struct _Receiver<Sender, Receiver>::type {
operation_t<Sender, Receiver>* op_state_;
template <class Tuple>
friend void tag_invoke(set_value_t, type&& self, Tuple&& tup) noexcept {
std::apply(
[&](auto&&... args) {
SetValue((Receiver &&) self.op_state_->receiver_, (decltype(args)&&)args...);
},
(Tuple &&) tup);
}
};
template <typename Sender, typename Receiver>
struct _Operation<Sender, Receiver>::type {
connect_result_t<Sender, receiver_t<Sender, Receiver>> op_state2_;
Receiver receiver_;
template <typename Sender2>
type(Sender2&& sender, Receiver&& receiver)
: op_state2_(Connect((Sender2 &&) sender, receiver_t<Sender, Receiver>{this})),
receiver_((Receiver &&) receiver) {}
friend void tag_invoke(start_t, type& op_state) { Start(op_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 value_types = std::tuple_element_t<0, completion_signatures_of_t<Sender>>;
Sender sender_;
template <typename Self, typename Receiver, _decays_to<Self, type, bool> = true>
friend auto tag_invoke(connect_t, Self&& self, Receiver&& receiver)
-> operation_t<Sender, Receiver> {
return operation_t<Sender, Receiver>(((Self &&) self).sender_, (Receiver &&) receiver);
}
};
struct expand_t {
template <typename Sender, std::enable_if_t<_is_sender<Sender>, int> = 0>
auto operator()(Sender&& sender) const {
return sender_t<Sender>{(Sender &&) sender};
}
_BinderBack<expand_t> operator()() const { return {{}, {}, {}}; }
};
} // namespace _expand
using _expand::expand_t;
inline constexpr expand_t Expand{};
} // namespace mmdeploy
#endif // MMDEPLOY_CSRC_EXECUTION_EXPAND_H_