Download modules/gapi/src/compiler/passes/helpers.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 3.27 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/compiler/passes/helpers.cpp
- Command line
-
hf download hf://tgollogly/test/modules/gapi/src/compiler/passes/helpers.cpp
-
curl -L -o helpers.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/compiler/passes/helpers.cpp
3.27 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 Intel Corporation | |
| namespace { | |
| namespace Cycles | |
| { | |
| // FIXME: This code is taken directly from ADE. | |
| // export a bool(ade::Graph) function with pass instead | |
| enum class TraverseState | |
| { | |
| visiting, | |
| visited, | |
| }; | |
| using state_t = std::unordered_map<ade::Node*, TraverseState>; | |
| bool inline checkCycle(state_t& state, const ade::NodeHandle& node) | |
| { | |
| GAPI_Assert(nullptr != node); | |
| state[node.get()] = TraverseState::visiting; | |
| for (auto adj: node->outNodes()) | |
| { | |
| auto it = state.find(adj.get()); | |
| if (state.end() == it) // not visited | |
| { | |
| // FIXME: use std::stack instead on-stack recursion | |
| if (checkCycle(state, adj)) | |
| { | |
| return true; // detected! (deeper frame) | |
| } | |
| } | |
| else if (TraverseState::visiting == it->second) | |
| { | |
| return true; // detected! (this frame) | |
| } | |
| } | |
| state[node.get()] = TraverseState::visited; | |
| return false; // not detected | |
| } | |
| bool inline hasCycles(const ade::Graph &graph) | |
| { | |
| state_t state; | |
| bool detected = false; | |
| for (auto node: graph.nodes()) | |
| { | |
| if (state.end() == state.find(node.get())) | |
| { | |
| // not yet visited during recursion | |
| detected |= checkCycle(state, node); | |
| if (detected) break; | |
| } | |
| } | |
| return detected; | |
| } | |
| } // namespace Cycles | |
| namespace TopoSort | |
| { | |
| using sorted_t = std::vector<ade::NodeHandle>; | |
| using visited_t = std::unordered_set<ade::Node*>; | |
| struct NonEmpty final | |
| { | |
| bool operator()(const ade::NodeHandle& node) const | |
| { | |
| return nullptr != node; | |
| } | |
| }; | |
| void inline visit(sorted_t& sorted, visited_t& visited, const ade::NodeHandle& node) | |
| { | |
| if (visited.end() == visited.find(node.get())) | |
| { | |
| for (auto adj: node->inNodes()) | |
| { | |
| visit(sorted, visited, adj); | |
| } | |
| sorted.push_back(node); | |
| visited.insert(node.get()); | |
| } | |
| } | |
| sorted_t inline topoSort(const ade::Graph &g) | |
| { | |
| sorted_t sorted; | |
| visited_t visited; | |
| for (auto node: g.nodes()) | |
| { | |
| visit(sorted, visited, node); | |
| } | |
| auto r = ade::util::filter<NonEmpty>(ade::util::toRange(sorted)); | |
| return sorted_t(r.begin(), r.end()); | |
| } | |
| } // namespace TopoSort | |
| } // anonymous namespace | |
| bool cv::gimpl::pass_helpers::hasCycles(const ade::Graph &g) | |
| { | |
| return Cycles::hasCycles(g); | |
| } | |
| std::vector<ade::NodeHandle> cv::gimpl::pass_helpers::topoSort(const ade::Graph &g) | |
| { | |
| return TopoSort::topoSort(g); | |
| } | |