标准上的 OMP 和并行操作：：set<...>：：迭代器

给定基于下图的数据结构：

std::map<int, std::set<std::vector<int>>> cliques;

其中键指示其上包含的向量的大小。

一开始，地图只有一个键(例如[3])，其中包含输入向量(例如{1, 3, 5}和{2, 4, 6})。

我的函数获取存储在映射最大键中的向量，并将它们分解为具有较少元素的所有可能组合，并将它们存储在与新向量大小相对应的键中(例如[2] = {1,3} {1,5} {3,5} {2,4} {2,6} {4,6} and [1] = {1} {3} {5} {2} {4} {6})。

我不知道我的解决方案是否是最有效的，但它运行良好。但是由于我的项目旨在处理大量数据，因此我需要并行化我的代码，这导致我实现以下实现：

/// Declare data structure
std::map<int, std::set<std::vector<int>>> cliques;
/// insert "input" vectors
cliques[5] = {{1, 3, 5, 7, 9}};
cliques[4] = {{1, 2, 3, 4}};
/// set boundaries
int kMax = 5;
int kMin = 1;
/// enable/disable parallel execution
bool parallelExec = true;
/// "decompose" source vectors:
for (int k = kMax; k > kMin; k--)
{
std::set<std::vector<int>>::iterator it = cliques[k].begin();
#pragma omp parallel num_threads(max_threads) if(parallelExec)
{
for(int s = 0; s < cliques[k].size(); ++s)
{
std::vector<int> clique;
/// maybe should be "omp critical"?
/// maybe "clique" should be private? (or is it already??) 
#pragma omp single
{ 
clique = *it;
}
for (int v = 0; v < clique.size(); ++v)
{
int& vertex = clique[v];
std::vector<int> new_clique;
std::copy_if(clique.begin(), clique.end(), std::back_inserter(new_clique), [vertex](const int& elem) { return elem != vertex; });
int kNew = k - 1;
#pragma omp critical
{ 
cliques[kNew].insert(new_clique);
}
}
#pragma omp single
{
it++;
}
}
}
}
/// Display results
for(int i = cliques.size(); i > 0 ; i--)
{
auto kSet = cliques[i];
std::cout << "[" << i << "]: ";  
for(auto& vec : kSet)
{
std::cout << "{";
for(auto& elem : vec)
{
std::cout << elem << " ";  
}
std::cout << "} ";
}
std::cout << std::endl;
}

使用"omp parallel"和"ompsingle"(而不是"ompfor")可以安全地访问数据结构，同时允许所有其他操作并行运行。代码几乎完美运行，几乎...因为它在最终结果中错过了一些(很少)子向量(如果禁用 OMP 则成功生成)。

是否有任何"OMP专家">可以帮助我解决这个问题？提前谢谢你。

---------------

更新

最小完整可验证示例