Download modules/core/src/parallel/registry_parallel.impl.hpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 6.4 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/core/src/parallel/registry_parallel.impl.hpp
- Command line
-
hf download hf://tgollogly/test/modules/core/src/parallel/registry_parallel.impl.hpp
-
curl -L -o registry_parallel.impl.hpp https://huggingface.co/tgollogly/test/resolve/main/modules/core/src/parallel/registry_parallel.impl.hpp
6.4 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. | |
| // | |
| // Not a standalone header, part of parallel.cpp | |
| // | |
| namespace cv { namespace parallel { | |
| static | |
| std::vector<ParallelBackendInfo>& getBuiltinParallelBackendsInfo() | |
| { | |
| static std::vector<ParallelBackendInfo> g_backends | |
| { | |
| DECLARE_STATIC_BACKEND("TBB", createParallelBackendTBB) | |
| DECLARE_DYNAMIC_BACKEND("ONETBB") // dedicated oneTBB plugin (interface >= 12000, binary incompatibe with TBB 2017-2020) | |
| DECLARE_DYNAMIC_BACKEND("TBB") // generic TBB plugins | |
| DECLARE_STATIC_BACKEND("OPENMP", createParallelBackendOpenMP) | |
| DECLARE_DYNAMIC_BACKEND("OPENMP") // TODO Intel OpenMP? | |
| }; | |
| return g_backends; | |
| } | |
| static | |
| bool sortByPriority(const ParallelBackendInfo &lhs, const ParallelBackendInfo &rhs) | |
| { | |
| return lhs.priority > rhs.priority; | |
| } | |
| /** @brief Manages list of enabled backends | |
| */ | |
| class ParallelBackendRegistry | |
| { | |
| protected: | |
| std::vector<ParallelBackendInfo> enabledBackends; | |
| ParallelBackendRegistry() | |
| { | |
| enabledBackends = getBuiltinParallelBackendsInfo(); | |
| int N = (int)enabledBackends.size(); | |
| for (int i = 0; i < N; i++) | |
| { | |
| ParallelBackendInfo& info = enabledBackends[i]; | |
| info.priority = 1000 - i * 10; | |
| } | |
| CV_LOG_DEBUG(NULL, "core(parallel): Builtin backends(" << N << "): " << dumpBackends()); | |
| if (readPrioritySettings()) | |
| { | |
| CV_LOG_INFO(NULL, "core(parallel): Updated backends priorities: " << dumpBackends()); | |
| N = (int)enabledBackends.size(); | |
| } | |
| int enabled = 0; | |
| for (int i = 0; i < N; i++) | |
| { | |
| ParallelBackendInfo& info = enabledBackends[enabled]; | |
| if (enabled != i) | |
| info = enabledBackends[i]; | |
| size_t param_priority = utils::getConfigurationParameterSizeT(cv::format("OPENCV_PARALLEL_PRIORITY_%s", info.name.c_str()).c_str(), (size_t)info.priority); | |
| CV_Assert(param_priority == (size_t)(int)param_priority); // overflow check | |
| if (param_priority > 0) | |
| { | |
| info.priority = (int)param_priority; | |
| enabled++; | |
| } | |
| else | |
| { | |
| CV_LOG_INFO(NULL, "core(parallel): Disable backend: " << info.name); | |
| } | |
| } | |
| enabledBackends.resize(enabled); | |
| CV_LOG_DEBUG(NULL, "core(parallel): Available backends(" << enabled << "): " << dumpBackends()); | |
| std::sort(enabledBackends.begin(), enabledBackends.end(), sortByPriority); | |
| CV_LOG_INFO(NULL, "core(parallel): Enabled backends(" << enabled << ", sorted by priority): " << (enabledBackends.empty() ? std::string("N/A") : dumpBackends())); | |
| } | |
| static std::vector<std::string> tokenize_string(const std::string& input, char token) | |
| { | |
| std::vector<std::string> result; | |
| std::string::size_type prev_pos = 0, pos = 0; | |
| while((pos = input.find(token, pos)) != std::string::npos) | |
| { | |
| result.push_back(input.substr(prev_pos, pos-prev_pos)); | |
| prev_pos = ++pos; | |
| } | |
| result.push_back(input.substr(prev_pos)); | |
| return result; | |
| } | |
| bool readPrioritySettings() | |
| { | |
| bool hasChanges = false; | |
| cv::String prioritized_backends = utils::getConfigurationParameterString("OPENCV_PARALLEL_PRIORITY_LIST", NULL); | |
| if (prioritized_backends.empty()) | |
| return hasChanges; | |
| CV_LOG_INFO(NULL, "core(parallel): Configured priority list (OPENCV_PARALLEL_PRIORITY_LIST): " << prioritized_backends); | |
| const std::vector<std::string> names = tokenize_string(prioritized_backends, ','); | |
| for (size_t i = 0; i < names.size(); i++) | |
| { | |
| const std::string& name = names[i]; | |
| int priority = (int)(100000 + (names.size() - i) * 1000); | |
| bool found = false; | |
| for (size_t k = 0; k < enabledBackends.size(); k++) | |
| { | |
| ParallelBackendInfo& info = enabledBackends[k]; | |
| if (name == info.name) | |
| { | |
| info.priority = priority; | |
| CV_LOG_DEBUG(NULL, "core(parallel): New backend priority: '" << name << "' => " << info.priority); | |
| found = true; | |
| hasChanges = true; | |
| break; | |
| } | |
| } | |
| if (!found) | |
| { | |
| CV_LOG_INFO(NULL, "core(parallel): Adding parallel backend (plugin): '" << name << "'"); | |
| enabledBackends.push_back(ParallelBackendInfo{priority, name, createPluginParallelBackendFactory(name)}); | |
| hasChanges = true; | |
| } | |
| } | |
| return hasChanges; | |
| } | |
| public: | |
| std::string dumpBackends() const | |
| { | |
| std::ostringstream os; | |
| for (size_t i = 0; i < enabledBackends.size(); i++) | |
| { | |
| if (i > 0) os << "; "; | |
| const ParallelBackendInfo& info = enabledBackends[i]; | |
| os << info.name << '(' << info.priority << ')'; | |
| } | |
| return os.str(); | |
| } | |
| static ParallelBackendRegistry& getInstance() | |
| { | |
| static ParallelBackendRegistry g_instance; | |
| return g_instance; | |
| } | |
| inline const std::vector<ParallelBackendInfo>& getEnabledBackends() const { return enabledBackends; } | |
| }; | |
| const std::vector<ParallelBackendInfo>& getParallelBackendsInfo() | |
| { | |
| return cv::parallel::ParallelBackendRegistry::getInstance().getEnabledBackends(); | |
| } | |
| }} // namespace | |