Download modules/gapi/src/executor/gthreadedexecutor.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 19.2 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/executor/gthreadedexecutor.cpp
- Command line
-
hf download hf://tgollogly/test/modules/gapi/src/executor/gthreadedexecutor.cpp
-
curl -L -o gthreadedexecutor.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/executor/gthreadedexecutor.cpp
19.2 kB
| // This file is part of OpenCV project. | |
| // It is subject to the license terms in the LICENSE file found in the top-level directory | |
| // of this distribution and at http://opencv.org/license.html. | |
| // | |
| // Copyright (C) 2024 Intel Corporation | |
| namespace cv { | |
| namespace gimpl { | |
| namespace magazine { | |
| namespace { | |
| void bindInArgExec(Mag& mag, const RcDesc &rc, const GRunArg &arg) { | |
| if (rc.shape != GShape::GMAT) { | |
| bindInArg(mag, rc, arg); | |
| return; | |
| } | |
| auto& mag_rmat = mag.template slot<cv::RMat>()[rc.id]; | |
| switch (arg.index()) { | |
| case GRunArg::index_of<Mat>() : | |
| mag_rmat = make_rmat<RMatOnMat>(util::get<Mat>(arg)); | |
| break; | |
| case GRunArg::index_of<cv::RMat>() : | |
| mag_rmat = util::get<cv::RMat>(arg); | |
| break; | |
| default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); | |
| } | |
| // FIXME: has to take extra care about meta here for this particuluar | |
| // case, just because this function exists at all | |
| mag.meta<cv::RMat>()[rc.id] = arg.meta; | |
| } | |
| void bindOutArgExec(Mag& mag, const RcDesc &rc, const GRunArgP &arg) { | |
| if (rc.shape != GShape::GMAT) { | |
| bindOutArg(mag, rc, arg); | |
| return; | |
| } | |
| auto& mag_rmat = mag.template slot<cv::RMat>()[rc.id]; | |
| switch (arg.index()) { | |
| case GRunArgP::index_of<Mat*>() : | |
| mag_rmat = make_rmat<RMatOnMat>(*util::get<Mat*>(arg)); break; | |
| case GRunArgP::index_of<cv::RMat*>() : | |
| mag_rmat = *util::get<cv::RMat*>(arg); break; | |
| default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); | |
| } | |
| } | |
| cv::GRunArgP getObjPtrExec(Mag& mag, const RcDesc &rc) { | |
| if (rc.shape != GShape::GMAT) { | |
| return getObjPtr(mag, rc); | |
| } | |
| return GRunArgP(&mag.slot<cv::RMat>()[rc.id]); | |
| } | |
| void writeBackExec(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg) { | |
| if (rc.shape != GShape::GMAT) { | |
| writeBack(mag, rc, g_arg); | |
| return; | |
| } | |
| switch (g_arg.index()) { | |
| case GRunArgP::index_of<cv::Mat*>() : { | |
| // If there is a copy intrinsic at the end of the graph | |
| // we need to actually copy the data to the user buffer | |
| // since output runarg was optimized to simply point | |
| // to the input of the copy kernel | |
| // FIXME: | |
| // Rework, find a better way to check if there should be | |
| // a real copy (add a pass to StreamingBackend?) | |
| // NB: In case RMat adapter not equal to "RMatOnMat" need to | |
| // copy data back to the host as well. | |
| auto& out_mat = *util::get<cv::Mat*>(g_arg); | |
| const auto& rmat = mag.template slot<cv::RMat>().at(rc.id); | |
| auto* adapter = rmat.get<RMatOnMat>(); | |
| if ((adapter != nullptr && out_mat.data != adapter->data()) || | |
| (adapter == nullptr)) { | |
| auto view = rmat.access(RMat::Access::R); | |
| asMat(view).copyTo(out_mat); | |
| } | |
| break; | |
| } | |
| case GRunArgP::index_of<cv::RMat*>() : /* do nothing */ break; | |
| default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); | |
| } | |
| } | |
| void assignMetaStubExec(Mag& mag, const RcDesc &rc, const cv::GRunArg::Meta &meta) { | |
| switch (rc.shape) { | |
| case GShape::GARRAY: mag.meta<cv::detail::VectorRef>()[rc.id] = meta; break; | |
| case GShape::GOPAQUE: mag.meta<cv::detail::OpaqueRef>()[rc.id] = meta; break; | |
| case GShape::GSCALAR: mag.meta<cv::Scalar>()[rc.id] = meta; break; | |
| case GShape::GFRAME: mag.meta<cv::MediaFrame>()[rc.id] = meta; break; | |
| case GShape::GMAT: | |
| mag.meta<cv::Mat>() [rc.id] = meta; | |
| mag.meta<cv::RMat>()[rc.id] = meta; | |
| mag.meta<cv::UMat>()[rc.id] = meta; | |
| break; | |
| default: util::throw_error(std::logic_error("Unsupported GShape type")); break; | |
| } | |
| } | |
| } // anonymous namespace | |
| }}} // namespace cv::gimpl::magazine | |
| cv::gimpl::StreamMsg cv::gimpl::GThreadedExecutor::Input::get() { | |
| std::lock_guard<std::mutex> lock{m_state.m}; | |
| cv::GRunArgs res; | |
| for (const auto &rc : desc()) { res.emplace_back(magazine::getArg(m_state.mag, rc)); } | |
| return cv::gimpl::StreamMsg{std::move(res)}; | |
| } | |
| cv::gimpl::GThreadedExecutor::Input::Input(cv::gimpl::GraphState &state, | |
| const std::vector<RcDesc> &rcs) | |
| : m_state(state) { | |
| set(rcs); | |
| }; | |
| cv::GRunArgP cv::gimpl::GThreadedExecutor::Output::get(int idx) { | |
| std::lock_guard<std::mutex> lock{m_state.m}; | |
| auto r = magazine::getObjPtrExec(m_state.mag, desc()[idx]); | |
| // Remember the output port for this output object | |
| m_out_idx[cv::gimpl::proto::ptr(r)] = idx; | |
| return r; | |
| } | |
| void cv::gimpl::GThreadedExecutor::Output::post(cv::GRunArgP&&, const std::exception_ptr& e) { | |
| if (e) { | |
| m_eptr = e; | |
| } | |
| } | |
| void cv::gimpl::GThreadedExecutor::Output::post(Exception&& ex) { | |
| m_eptr = std::move(ex.eptr); | |
| } | |
| void cv::gimpl::GThreadedExecutor::Output::meta(const GRunArgP &out, const GRunArg::Meta &m) { | |
| const auto idx = m_out_idx.at(cv::gimpl::proto::ptr(out)); | |
| std::lock_guard<std::mutex> lock{m_state.m}; | |
| magazine::assignMetaStubExec(m_state.mag, desc()[idx], m); | |
| } | |
| cv::gimpl::GThreadedExecutor::Output::Output(cv::gimpl::GraphState &state, | |
| const std::vector<RcDesc> &rcs) | |
| : m_state(state) { | |
| set(rcs); | |
| } | |
| void cv::gimpl::GThreadedExecutor::Output::verify() { | |
| if (m_eptr) { | |
| std::rethrow_exception(m_eptr); | |
| } | |
| } | |
| void cv::gimpl::GThreadedExecutor::initResource(const ade::NodeHandle &nh, const ade::NodeHandle &orig_nh) { | |
| const Data &d = m_gm.metadata(orig_nh).get<Data>(); | |
| if ( d.storage != Data::Storage::INTERNAL | |
| && d.storage != Data::Storage::CONST_VAL) { | |
| return; | |
| } | |
| // INTERNALS+CONST only! no need to allocate/reset output objects | |
| // to as it is bound externally (e.g. already in the m_state.mag) | |
| switch (d.shape) { | |
| case GShape::GMAT: | |
| if (d.storage == Data::Storage::CONST_VAL) { | |
| auto rc = RcDesc{d.rc, d.shape, d.ctor}; | |
| magazine::bindInArgExec(m_state.mag, rc, m_gm.metadata(orig_nh).get<ConstValue>().arg); | |
| } else { | |
| // Let island allocate it's outputs if it can, | |
| // allocate cv::Mat and wrap it with RMat otherwise | |
| GAPI_Assert(!nh->inNodes().empty()); | |
| const auto desc = util::get<cv::GMatDesc>(d.meta); | |
| auto& exec = m_gim.metadata(nh->inNodes().front()).get<IslandExec>().object; | |
| auto& rmat = m_state.mag.slot<cv::RMat>()[d.rc]; | |
| if (exec->allocatesOutputs()) { | |
| rmat = exec->allocate(desc); | |
| } else { | |
| Mat mat; | |
| createMat(desc, mat); | |
| rmat = make_rmat<RMatOnMat>(mat); | |
| } | |
| } | |
| break; | |
| case GShape::GSCALAR: | |
| if (d.storage == Data::Storage::CONST_VAL) { | |
| auto rc = RcDesc{d.rc, d.shape, d.ctor}; | |
| magazine::bindInArg(m_state.mag, rc, m_gm.metadata(orig_nh).get<ConstValue>().arg); | |
| } | |
| break; | |
| case GShape::GARRAY: | |
| if (d.storage == Data::Storage::CONST_VAL) { | |
| auto rc = RcDesc{d.rc, d.shape, d.ctor}; | |
| magazine::bindInArg(m_state.mag, rc, m_gm.metadata(orig_nh).get<ConstValue>().arg); | |
| } | |
| break; | |
| case GShape::GOPAQUE: | |
| // Constructed on Reset, do nothing here | |
| break; | |
| case GShape::GFRAME: { | |
| // Should be defined by backend, do nothing here | |
| break; | |
| } | |
| default: | |
| GAPI_Error("InternalError"); | |
| } | |
| } | |
| cv::gimpl::IslandActor::IslandActor(const std::vector<RcDesc> &in_objects, | |
| const std::vector<RcDesc> &out_objects, | |
| std::shared_ptr<GIslandExecutable> isl_exec, | |
| cv::gimpl::GraphState &state) | |
| : m_isl_exec(isl_exec), | |
| m_inputs(state, in_objects), | |
| m_outputs(state, out_objects) { | |
| } | |
| void cv::gimpl::IslandActor::run() { | |
| m_isl_exec->run(m_inputs, m_outputs); | |
| } | |
| void cv::gimpl::IslandActor::verify() { | |
| m_outputs.verify(); | |
| }; | |
| class cv::gimpl::Task { | |
| friend class TaskManager; | |
| public: | |
| using Ptr = std::shared_ptr<Task>; | |
| Task(TaskManager::F&& f, std::vector<Task::Ptr> &&producers); | |
| struct ExecutionState { | |
| cv::gapi::own::ThreadPool& tp; | |
| cv::gapi::own::Latch& latch; | |
| }; | |
| void run(ExecutionState& state); | |
| bool isLast() const { return m_consumers.empty(); } | |
| void reset() { m_ready_producers.store(0u); } | |
| private: | |
| TaskManager::F m_f; | |
| const uint32_t m_num_producers; | |
| std::atomic<uint32_t> m_ready_producers; | |
| std::vector<Task*> m_consumers; | |
| }; | |
| cv::gimpl::Task::Task(TaskManager::F &&f, | |
| std::vector<Task::Ptr> &&producers) | |
| : m_f(std::move(f)), | |
| m_num_producers(static_cast<uint32_t>(producers.size())) { | |
| for (auto producer : producers) { | |
| producer->m_consumers.push_back(this); | |
| } | |
| } | |
| void cv::gimpl::Task::run(ExecutionState& state) { | |
| // Execute the task | |
| m_f(); | |
| // Notify every consumer about completion one of its dependencies | |
| for (auto* consumer : m_consumers) { | |
| const auto num_ready = | |
| consumer->m_ready_producers.fetch_add(1, std::memory_order_relaxed) + 1; | |
| // The last completed producer schedule the consumer for execution | |
| if (num_ready == consumer->m_num_producers) { | |
| state.tp.schedule([&state, consumer](){ | |
| consumer->run(state); | |
| }); | |
| } | |
| } | |
| // If tasks has no consumers this is the last task | |
| // Execution lasts until all last tasks are completed | |
| // Decrement the latch to notify about completion | |
| if (isLast()) { | |
| state.latch.count_down(); | |
| } | |
| } | |
| std::shared_ptr<cv::gimpl::Task> | |
| cv::gimpl::TaskManager::createTask(cv::gimpl::TaskManager::F &&f, | |
| std::vector<std::shared_ptr<cv::gimpl::Task>> &&producers) { | |
| const bool is_initial = producers.empty(); | |
| auto task = std::make_shared<cv::gimpl::Task>(std::move(f), | |
| std::move(producers)); | |
| m_all_tasks.emplace_back(task); | |
| if (is_initial) { | |
| m_initial_tasks.emplace_back(task); | |
| } | |
| return task; | |
| } | |
| void cv::gimpl::TaskManager::scheduleAndWait(cv::gapi::own::ThreadPool& tp) { | |
| // Reset the number of ready dependencies for all tasks | |
| for (auto& task : m_all_tasks) { task->reset(); } | |
| // Count the number of last tasks | |
| auto isLast = [](const std::shared_ptr<Task>& task) { return task->isLast(); }; | |
| const auto kNumLastsTasks = | |
| std::count_if(m_all_tasks.begin(), m_all_tasks.end(), isLast); | |
| // Initialize the latch, schedule initial tasks | |
| // and wait until all lasts tasks are done | |
| cv::gapi::own::Latch latch(kNumLastsTasks); | |
| Task::ExecutionState state{tp, latch}; | |
| for (auto task : m_initial_tasks) { | |
| state.tp.schedule([&state, task](){ task->run(state); }); | |
| } | |
| latch.wait(); | |
| } | |
| cv::gimpl::GThreadedExecutor::GThreadedExecutor(const uint32_t num_threads, | |
| std::unique_ptr<ade::Graph> &&g_model) | |
| : GAbstractExecutor(std::move(g_model)), | |
| m_thread_pool(num_threads) { | |
| auto sorted = m_gim.metadata().get<ade::passes::TopologicalSortData>(); | |
| std::unordered_map< ade::NodeHandle | |
| , std::shared_ptr<Task> | |
| , ade::HandleHasher<ade::Node>> m_tasks_map; | |
| for (auto nh : sorted.nodes()) | |
| { | |
| switch (m_gim.metadata(nh).get<NodeKind>().k) | |
| { | |
| case NodeKind::ISLAND: | |
| { | |
| std::vector<RcDesc> input_rcs; | |
| std::vector<RcDesc> output_rcs; | |
| input_rcs.reserve(nh->inNodes().size()); | |
| output_rcs.reserve(nh->outNodes().size()); | |
| auto xtract = [&](ade::NodeHandle slot_nh, std::vector<RcDesc> &vec) { | |
| const auto orig_data_nh | |
| = m_gim.metadata(slot_nh).get<DataSlot>().original_data_node; | |
| const auto &orig_data_info | |
| = m_gm.metadata(orig_data_nh).get<Data>(); | |
| vec.emplace_back(RcDesc{ orig_data_info.rc | |
| , orig_data_info.shape | |
| , orig_data_info.ctor}); | |
| }; | |
| for (auto in_slot_nh : nh->inNodes()) xtract(in_slot_nh, input_rcs); | |
| for (auto out_slot_nh : nh->outNodes()) xtract(out_slot_nh, output_rcs); | |
| auto actor = std::make_shared<IslandActor>(std::move(input_rcs), | |
| std::move(output_rcs), | |
| m_gim.metadata(nh).get<IslandExec>().object, | |
| m_state); | |
| m_actors.push_back(actor); | |
| std::unordered_set<ade::NodeHandle, ade::HandleHasher<ade::Node>> producer_nhs; | |
| for (auto slot_nh : nh->inNodes()) { | |
| for (auto island_nh : slot_nh->inNodes()) { | |
| GAPI_Assert(m_gim.metadata(island_nh).get<NodeKind>().k == NodeKind::ISLAND); | |
| producer_nhs.emplace(island_nh); | |
| } | |
| } | |
| std::vector<std::shared_ptr<Task>> producers; | |
| producers.reserve(producer_nhs.size()); | |
| for (auto producer_nh : producer_nhs) { | |
| producers.push_back(m_tasks_map.at(producer_nh)); | |
| } | |
| auto task = m_task_manager.createTask( | |
| [actor](){actor->run();}, std::move(producers)); | |
| m_tasks_map.emplace(nh, task); | |
| } | |
| break; | |
| case NodeKind::SLOT: | |
| { | |
| const auto orig_data_nh | |
| = m_gim.metadata(nh).get<DataSlot>().original_data_node; | |
| initResource(nh, orig_data_nh); | |
| m_slots.emplace_back(DataDesc{nh, orig_data_nh}); | |
| } | |
| break; | |
| default: | |
| GAPI_Error("InternalError"); | |
| break; | |
| } // switch(kind) | |
| } // for(gim nodes) | |
| prepareForNewStream(); | |
| } | |
| void cv::gimpl::GThreadedExecutor::run(cv::gimpl::GRuntimeArgs &&args) { | |
| const auto proto = m_gm.metadata().get<Protocol>(); | |
| // Basic check if input/output arguments are correct | |
| // FIXME: Move to GCompiled (do once for all GExecutors) | |
| if (proto.inputs.size() != args.inObjs.size()) { // TODO: Also check types | |
| util::throw_error(std::logic_error | |
| ("Computation's input protocol doesn\'t " | |
| "match actual arguments!")); | |
| } | |
| if (proto.outputs.size() != args.outObjs.size()) { // TODO: Also check types | |
| util::throw_error(std::logic_error | |
| ("Computation's output protocol doesn\'t " | |
| "match actual arguments!")); | |
| } | |
| namespace util = ade::util; | |
| // ensure that output Mat parameters are correctly allocated | |
| // FIXME: avoid copy of NodeHandle and GRunRsltComp ? | |
| for (auto index : util::iota(proto.out_nhs.size())) { | |
| auto& nh = proto.out_nhs.at(index); | |
| const Data &d = m_gm.metadata(nh).get<Data>(); | |
| if (d.shape == GShape::GMAT) { | |
| using cv::util::get; | |
| const auto desc = get<cv::GMatDesc>(d.meta); | |
| auto check_rmat = [&desc, &args, &index]() { | |
| auto& out_mat = *get<cv::RMat*>(args.outObjs.at(index)); | |
| GAPI_Assert(desc.canDescribe(out_mat)); | |
| }; | |
| // Building as part of OpenCV - follow OpenCV behavior In | |
| // the case of cv::Mat if output buffer is not enough to | |
| // hold the result, reallocate it | |
| if (cv::util::holds_alternative<cv::Mat*>(args.outObjs.at(index))) { | |
| auto& out_mat = *get<cv::Mat*>(args.outObjs.at(index)); | |
| createMat(desc, out_mat); | |
| } | |
| // In the case of RMat check to fit required meta | |
| else { | |
| check_rmat(); | |
| } | |
| // Building standalone - output buffer should always exist, | |
| // and _exact_ match our inferred metadata | |
| if (cv::util::holds_alternative<cv::Mat*>(args.outObjs.at(index))) { | |
| auto& out_mat = *get<cv::Mat*>(args.outObjs.at(index)); | |
| GAPI_Assert(out_mat.data != nullptr && | |
| desc.canDescribe(out_mat)); | |
| } | |
| // In the case of RMat check to fit required meta | |
| else { | |
| check_rmat(); | |
| } | |
| } | |
| } | |
| // Update storage with user-passed objects | |
| for (auto it : ade::util::zip(ade::util::toRange(proto.inputs), | |
| ade::util::toRange(args.inObjs))) { | |
| magazine::bindInArgExec(m_state.mag, std::get<0>(it), std::get<1>(it)); | |
| } | |
| for (auto it : ade::util::zip(ade::util::toRange(proto.outputs), | |
| ade::util::toRange(args.outObjs))) { | |
| magazine::bindOutArgExec(m_state.mag, std::get<0>(it), std::get<1>(it)); | |
| } | |
| // Reset internal data | |
| for (auto &sd : m_slots) { | |
| const auto& data = m_gm.metadata(sd.data_nh).get<Data>(); | |
| magazine::resetInternalData(m_state.mag, data); | |
| } | |
| m_task_manager.scheduleAndWait(m_thread_pool); | |
| for (auto actor : m_actors) { | |
| actor->verify(); | |
| } | |
| for (auto it : ade::util::zip(ade::util::toRange(proto.outputs), | |
| ade::util::toRange(args.outObjs))) { | |
| magazine::writeBackExec(m_state.mag, std::get<0>(it), std::get<1>(it)); | |
| } | |
| } | |
| bool cv::gimpl::GThreadedExecutor::canReshape() const { | |
| for (auto actor : m_actors) { | |
| if (actor->exec()->canReshape()) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| void cv::gimpl::GThreadedExecutor::reshape(const GMetaArgs& inMetas, const GCompileArgs& args) { | |
| GAPI_Assert(canReshape()); | |
| auto& g = *m_orig_graph.get(); | |
| ade::passes::PassContext ctx{g}; | |
| passes::initMeta(ctx, inMetas); | |
| passes::inferMeta(ctx, true); | |
| // NB: Before reshape islands need to re-init resources for every slot. | |
| for (auto slot : m_slots) { | |
| initResource(slot.slot_nh, slot.data_nh); | |
| } | |
| for (auto actor : m_actors) { | |
| actor->exec()->reshape(g, args); | |
| } | |
| } | |
| void cv::gimpl::GThreadedExecutor::prepareForNewStream() { | |
| for (auto actor : m_actors) { | |
| actor->exec()->handleNewStream(); | |
| } | |
| } | |