小编Ant*_*ton的帖子

我一直在 OpenMP 中调用它

#pragma omp parallel for num_threads(totalThreads)
for(unsigned i=0; i<totalThreads; i++)
{
workOnTheseEdges(startIndex[i], endIndex[i]);
}

这在 C++11 std::threads 中（我相信这些只是 pthreads）

vector<thread> threads;
for(unsigned i=0; i<totalThreads; i++)
{
threads.push_back(thread(workOnTheseEdges,startIndex[i], endIndex[i])); 
}
for (auto& thread : threads)
{
 thread.join();
}

但是，OpenMP 实现的速度是原来的 2 倍——更快！我本来期望 C++11 线程更快，因为它们更底层。注意：上面的代码不仅被调用一次，而且可能在循环中被调用 10,000 次，所以也许这与它有关？

编辑：为了澄清，在实践中，我要么使用 OpenMP 要么使用 C++11 版本——而不是同时使用两者。当我使用 OpenMP 代码时，需要 45 秒，当我使用 C++11 时，需要 100 秒。

测试程序：

#include <tbb/parallel_invoke.h>

int main(void)
{
    tbb::parallel_invoke([]{},[]{});
    return 0;
}

1. 编译使用 g++ -std=c++11 tmp.cpp -ltbb

2. 检查过

   valgrind --tool=memcheck --track-origins=yes \
            --leak-check=full --log-file=report ./a.out`
   

   Run Code Online (Sandbox Code Playgroud)

3. libtbb版本：4.0，valgrind版本：3.8.1。

以上部分测试结果：

possibly lost: 1,980 bytes in 6 blocks

问题是：

这是一个TBB错误吗？

或者这possible lost实际上是安全的，这只是 valgrind 认为不安全的一些代码？

我知道当链接到多个静态库或目标文件时,顺序很重要(依赖库应该在它们的依赖项之前列出).我想知道,在创建库文件时ar,是否应用此相同规则并且库中的顺序很重要,或者在同一.a文件中它是否有所作为.
我正在打包200多个带有复杂依赖关系图的目标文件,并且这样做

ar rcs mylib.a objs/*.o

然后以正确的顺序列出它们要容易得多.

我正在使用gcc,如果它有所作为.

我目前正在测试 tbb 的流程图功能。为了使用它，我必须能够中止图中某个节点的执行，包括所有依赖它的子节点，但让其他不依赖它的子节点执行。从主体抛出异常或调用 task::cancel_group_execution() 会中止所有节点的执行。

#include <cstdio>
#include "tbb/flow_graph.h"

using namespace tbb::flow;

struct body
{   std::string my_name;
    body( const char *name ) : my_name(name)
    {
    }
    void operator()( continue_msg ) const
    {   if (my_name == "B")
            tbb::task::self().group()->cancel_group_execution();
        else
        {   sleep(1);
            printf("%s\n", my_name.c_str());
        }
    }
};

int main()
{
    graph g;

    broadcast_node< continue_msg > start(g);
    continue_node<continue_msg> a( g, body("A"));
    continue_node<continue_msg> b( g, body("B"));
    continue_node<continue_msg> c( g, body("C"));
    continue_node<continue_msg> d( g, body("D"));
    continue_node<continue_msg> e( g, body("E"));

    make_edge( start, a );
    make_edge( start, …

我目前正在使用tbb的并发哈希映射来执行并发插入哈希映射.每个键都是一个字符串,值是整数的向量.我想实现以下内容:在插入期间,如果密钥不存在,我插入它并将值添加到其向量.如果存在,我只需将值添加到其向量中.

在检查tbb并发哈希映射API之后,我注意到find和insert函数都只返回布尔值.那么如果它存在,如何返回指向键的指针呢？

只是好奇，是否有可能从模板类继承并在派生类的构造函数中调用基类的构造函数，该构造函数也是模板化的并且没有参数来推断其类型？

template<typename T>
struct Base {
    template<typename D>
    Base() {                // no argument of type D to infer from
        static_assert(std::is_same<T,D>::value, "");
    }
};

struct Derived : Base<int> {
    Derived()  : Base<int>::Base<int>() {} // is there a way to write it correctly?
};

在我的特定情况下，我可以用模板方法替换模板构造函数，但这仍然是一个关于语言灵活性的有趣问题。

使用：VC++ 2013

concurrency::concurrent_vector<datanode*> dtnodelst

有时，当我这样做时dtnodelst->at(i).... 我收到一个无效地址 (0XCDCD.. ofc) 这不应该是我推回后的原因，我从不删除或删除任何它（即使我删除它应该已返回已删除的旧地址...但我从未删除，因此情况并非如此）

dtnodelst itm = new dtnodelst ();
....
dtnodelst->push_back(itm);

关于可能发生什么的任何想法？

ps 我正在使用 Windows 线程池。有时.. 我可以做 800 万次插入和查找，一切顺利......但有时甚至 200 次插入和查找都会失败。我有点失落。任何帮助将不胜感激！

感谢和最好的问候

实际代码作为参考

ps 我是否遗漏了某些东西，或者使用正确的格式对过去的代码感到痛苦？我记得它之前是自动对齐的... -_-

struct datanode {       
     volatile int nodeval;
     T val;
};
concurrency::concurrent_vector<datanode*> lst
inline T find(UINT32 key)
{
    for (int i = 0; i < lst->size(); i++)
    {
       datanode* nd = lst->at(i);
       //nd is invalid sometimes
       if (nd)  
       if (nd->nodeval == key)
       {
         return (nd->val);
       }
    }
    return …

我正在使用迭代器遍历整个tbb并发哈希映射并检查每个(键,值)对.

for (MAP::pair = myHashTable.begin(); myHashTable.end(); pair++)

如何并行化这个迭代器？

我从英特尔的 TBB 网站下载了英特尔 TBB 的预构建标头和库。我更新了 ldconfig 以将 tbb 共享库添加到 /usr/lib。然而，在使用 -tbb 编译时，使用 g++ ld 的代码返回 -1，因为它无法找到 libtbb

libtbb.so.2 存在于 /usr/lib/ 中

这是我完整的 g++ 输出

g++ hellotbb.cpp  -o htbb -I$HOME/libs/tbb43/include  -v  -ltbb 

Using built-in specs.
COLLECT_GCC=g++
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/4.8/lto-wrapper
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu 4.8.2-19ubuntu1' --with-bugurl=file:///usr/share/doc/gcc-4.8/README.Bugs --enable-languages=c,c++,java,go,d,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-4.8 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --with-gxx-include-dir=/usr/include/c++/4.8 --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --enable-gnu-unique-object --disable-libmudflap --enable-plugin --with-system-zlib --disable-browser-plugin --enable-java-awt=gtk --enable-gtk-cairo --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64/jre --enable-java-home --with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64 --with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-4.8-amd64 --with-arch-directory=amd64 --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --enable-objc-gc --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --with-tune=generic …

我在集群上运行英特尔 TBB。但是，我不知道如何检查有多少线程处于活动状态并正在运行。有办法检查吗？

假设我有 16 个核心，所以我想知道我的 TBB 代码中是否使用了所有 16 个核心。这将确保我的系统没有问题。

可以动态地控制TBB流图中的执行路径,使用节点的输出作为条件变量来确定是否应该启动另一个节点？

局部变量在Java中是线程安全的.hashmap在方法线程中使用声明是否安全？例如-

void usingHashMap()
{
    HashMap<Integer> map = new HashMap<integer>();
}