Download modules/gapi/src/compiler/gmodel.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 9.19 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/compiler/gmodel.cpp
- Command line
-
hf download hf://tgollogly/test/modules/gapi/src/compiler/gmodel.cpp
-
curl -L -o gmodel.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/compiler/gmodel.cpp
9.19 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) 2018-2020 Intel Corporation | |
| namespace cv { namespace gimpl { | |
| ade::NodeHandle GModel::mkOpNode(GModel::Graph &g, | |
| const GKernel &k, | |
| const std::vector<GArg> &args, | |
| const cv::util::any ¶ms, | |
| const std::string &island) | |
| { | |
| ade::NodeHandle op_h = g.createNode(); | |
| g.metadata(op_h).set(NodeType{NodeType::OP}); | |
| //These extra empty {} are to please GCC (-Wmissing-field-initializers) | |
| g.metadata(op_h).set(Op{k, args, {}, {}, params}); | |
| if (!island.empty()) | |
| g.metadata(op_h).set(Island{island}); | |
| return op_h; | |
| } | |
| ade::NodeHandle GModel::mkDataNode(GModel::Graph &g, const GOrigin& origin) | |
| { | |
| ade::NodeHandle data_h = g.createNode(); | |
| const auto id = g.metadata().get<DataObjectCounter>().GetNewId(origin.shape); | |
| g.metadata(data_h).set(NodeType{NodeType::DATA}); | |
| GMetaArg meta; | |
| Data::Storage storage = Data::Storage::INTERNAL; // By default, all objects are marked INTERNAL | |
| if (origin.node.shape() == GNode::NodeShape::CONST_BOUNDED) | |
| { | |
| auto value = value_of(origin); | |
| meta = descr_of(value); | |
| storage = Data::Storage::CONST_VAL; | |
| g.metadata(data_h).set(ConstValue{value}); | |
| } | |
| // FIXME: Sometimes a GArray-related node may be created w/o the | |
| // associated host-type constructor (e.g. when the array is | |
| // somewhere in the middle of the graph). | |
| auto ctor_copy = origin.ctor; | |
| g.metadata(data_h).set(Data{origin.shape, id, meta, ctor_copy, origin.kind, storage}); | |
| return data_h; | |
| } | |
| ade::NodeHandle GModel::mkDataNode(GModel::Graph &g, const GShape shape) | |
| { | |
| ade::NodeHandle data_h = g.createNode(); | |
| g.metadata(data_h).set(NodeType{NodeType::DATA}); | |
| const auto id = g.metadata().get<DataObjectCounter>().GetNewId(shape); | |
| GMetaArg meta; | |
| HostCtor ctor; | |
| Data::Storage storage = Data::Storage::INTERNAL; // By default, all objects are marked INTERNAL | |
| cv::detail::OpaqueKind kind = cv::detail::OpaqueKind::CV_UNKNOWN; | |
| g.metadata(data_h).set(Data{shape, id, meta, ctor, kind, storage}); | |
| return data_h; | |
| } | |
| ade::EdgeHandle GModel::linkIn(Graph &g, ade::NodeHandle opH, ade::NodeHandle objH, std::size_t in_port) | |
| { | |
| // Check if input is already connected | |
| for (const auto& in_e : opH->inEdges()) | |
| { | |
| GAPI_Assert(g.metadata(in_e).get<Input>().port != in_port); | |
| } | |
| auto &op = g.metadata(opH).get<Op>(); | |
| auto &gm = g.metadata(objH).get<Data>(); | |
| // FIXME: check validity using kernel prototype | |
| GAPI_Assert(in_port < op.args.size()); | |
| ade::EdgeHandle eh = g.link(objH, opH); | |
| g.metadata(eh).set(Input{in_port}); | |
| // Replace an API object with a REF (G* -> GOBJREF) | |
| op.args[in_port] = cv::GArg(RcDesc{gm.rc, gm.shape, {}}); | |
| return eh; | |
| } | |
| ade::EdgeHandle GModel::linkOut(Graph &g, ade::NodeHandle opH, ade::NodeHandle objH, std::size_t out_port) | |
| { | |
| // FIXME: check validity using kernel prototype | |
| // Check if output is already connected | |
| for (const auto& out_e : opH->outEdges()) | |
| { | |
| GAPI_Assert(g.metadata(out_e).get<Output>().port != out_port); | |
| } | |
| auto &op = g.metadata(opH).get<Op>(); | |
| auto &gm = g.metadata(objH).get<Data>(); | |
| GAPI_Assert(objH->inNodes().size() == 0u); | |
| ade::EdgeHandle eh = g.link(opH, objH); | |
| g.metadata(eh).set(Output{out_port}); | |
| // TODO: outs must be allocated according to kernel protocol! | |
| const auto storage_with_port = ade::util::checked_cast<std::size_t>(out_port+1); | |
| const auto min_out_size = std::max(op.outs.size(), storage_with_port); | |
| op.outs.resize(min_out_size, RcDesc{-1,GShape::GMAT,{}}); // FIXME: Invalid shape instead? | |
| op.outs[out_port] = RcDesc{gm.rc, gm.shape, {}}; | |
| return eh; | |
| } | |
| std::vector<ade::NodeHandle> GModel::orderedInputs(const ConstGraph &g, ade::NodeHandle nh) | |
| { | |
| std::vector<ade::NodeHandle> sorted_in_nhs(nh->inEdges().size()); | |
| for (const auto& in_eh : nh->inEdges()) | |
| { | |
| const auto port = g.metadata(in_eh).get<cv::gimpl::Input>().port; | |
| GAPI_Assert(port < sorted_in_nhs.size()); | |
| sorted_in_nhs[port] = in_eh->srcNode(); | |
| } | |
| return sorted_in_nhs; | |
| } | |
| std::vector<ade::NodeHandle> GModel::orderedOutputs(const ConstGraph &g, ade::NodeHandle nh) | |
| { | |
| std::vector<ade::NodeHandle> sorted_out_nhs(nh->outEdges().size()); | |
| for (const auto& out_eh : nh->outEdges()) | |
| { | |
| const auto port = g.metadata(out_eh).get<cv::gimpl::Output>().port; | |
| GAPI_Assert(port < sorted_out_nhs.size()); | |
| sorted_out_nhs[port] = out_eh->dstNode(); | |
| } | |
| return sorted_out_nhs; | |
| } | |
| void GModel::init(Graph& g) | |
| { | |
| g.metadata().set(DataObjectCounter()); | |
| } | |
| void GModel::log(Graph &g, ade::NodeHandle nh, std::string &&msg, ade::NodeHandle updater) | |
| { | |
| std::string s = std::move(msg); | |
| if (updater != nullptr) | |
| { | |
| std::stringstream fmt; | |
| fmt << " (via " << updater << ")"; | |
| s += fmt.str(); | |
| } | |
| if (g.metadata(nh).contains<Journal>()) | |
| { | |
| g.metadata(nh).get<Journal>().messages.push_back(s); | |
| } | |
| else | |
| { | |
| g.metadata(nh).set(Journal{{s}}); | |
| } | |
| } | |
| // FIXME: | |
| // Unify with GModel::log(.. ade::NodeHandle ..) | |
| void GModel::log(Graph &g, ade::EdgeHandle eh, std::string &&msg, ade::NodeHandle updater) | |
| { | |
| std::string s = std::move(msg); | |
| if (updater != nullptr) | |
| { | |
| std::stringstream fmt; | |
| fmt << " (via " << updater << ")"; | |
| s += fmt.str(); | |
| } | |
| if (g.metadata(eh).contains<Journal>()) | |
| { | |
| g.metadata(eh).get<Journal>().messages.push_back(s); | |
| } | |
| else | |
| { | |
| g.metadata(eh).set(Journal{{s}}); | |
| } | |
| } | |
| void GModel::log_clear(Graph &g, ade::NodeHandle node) | |
| { | |
| if (g.metadata(node).contains<Journal>()) | |
| { | |
| // according to documentation, clear() doesn't deallocate (__capacity__ of vector preserved) | |
| g.metadata(node).get<Journal>().messages.clear(); | |
| } | |
| } | |
| ade::NodeHandle GModel::detail::dataNodeOf(const ConstLayoutGraph &g, const GOrigin &origin) | |
| { | |
| // FIXME: Does it still work with graph transformations, e.g. redirectWriter()?? | |
| return g.metadata().get<Layout>().object_nodes.at(origin); | |
| } | |
| std::vector<ade::EdgeHandle> GModel::redirectReaders(Graph &g, ade::NodeHandle from, ade::NodeHandle to) | |
| { | |
| std::vector<ade::EdgeHandle> ehh(from->outEdges().begin(), from->outEdges().end()); | |
| std::vector<ade::EdgeHandle> ohh; | |
| ohh.reserve(ehh.size()); | |
| for (auto e : ehh) | |
| { | |
| auto dst = e->dstNode(); | |
| auto input = g.metadata(e).get<Input>(); | |
| g.erase(e); | |
| ohh.push_back(linkIn(g, dst, to, input.port)); | |
| } | |
| return ohh; | |
| } | |
| ade::EdgeHandle GModel::redirectWriter(Graph &g, ade::NodeHandle from, ade::NodeHandle to) | |
| { | |
| GAPI_Assert(from->inEdges().size() == 1); | |
| auto e = from->inEdges().front(); | |
| auto op = e->srcNode(); | |
| auto output = g.metadata(e).get<Output>(); | |
| g.erase(e); | |
| return linkOut(g, op, to, output.port); | |
| } | |
| GMetaArgs GModel::collectInputMeta(const GModel::ConstGraph &cg, ade::NodeHandle node) | |
| { | |
| GAPI_Assert(cg.metadata(node).get<NodeType>().t == NodeType::OP); | |
| GMetaArgs in_meta_args(cg.metadata(node).get<Op>().args.size()); | |
| for (const auto &e : node->inEdges()) | |
| { | |
| const auto& in_data = cg.metadata(e->srcNode()).get<Data>(); | |
| in_meta_args[cg.metadata(e).get<Input>().port] = in_data.meta; | |
| } | |
| return in_meta_args; | |
| } | |
| ade::EdgeHandle GModel::getInEdgeByPort(const GModel::ConstGraph& cg, | |
| const ade::NodeHandle& nh, | |
| std::size_t in_port) | |
| { | |
| auto inEdges = nh->inEdges(); | |
| const auto& edge = ade::util::find_if(inEdges, [&](ade::EdgeHandle eh) { | |
| return cg.metadata(eh).get<Input>().port == in_port; | |
| }); | |
| GAPI_Assert(edge != inEdges.end()); | |
| return *edge; | |
| } | |
| GMetaArgs GModel::collectOutputMeta(const GModel::ConstGraph &cg, ade::NodeHandle node) | |
| { | |
| GAPI_Assert(cg.metadata(node).get<NodeType>().t == NodeType::OP); | |
| GMetaArgs out_meta_args(cg.metadata(node).get<Op>().outs.size()); | |
| for (const auto &e : node->outEdges()) | |
| { | |
| const auto& out_data = cg.metadata(e->dstNode()).get<Data>(); | |
| out_meta_args[cg.metadata(e).get<Output>().port] = out_data.meta; | |
| } | |
| return out_meta_args; | |
| } | |
| bool GModel::isActive(const GModel::Graph &cg, const cv::gapi::GBackend &backend) | |
| { | |
| return ade::util::contains(cg.metadata().get<ActiveBackends>().backends, | |
| backend); | |
| } | |
| }} // cv::gimpl | |