标签: tbb

我试图并行化使用TBB在OpenCV中编写的一些图像匹配代码.问题是,根据我的匹配(在左图像中创建一个5x5窗口并在右边逐个像素地查找匹配)本质上是一个只读操作,目前我正在尝试并行化内部循环(即在给定高度.我指定不同的像素到不同的线程).令我惊讶的是,cvSetImageROI当并行完成时命令会中断.这是代码.

//Code below just carves out a window(5x5) at a current width which is to be matched
cvSetImageROI(leftImageROI, cvRect(curWidth - 2, 0, 5, 5));
IplImage* currentROI = cvCreateImage(cvSize(5, 5), leftImageROI->depth, leftImageROI->nChannels);
cvCopy(leftImageROI, currentROI);                   
cvResetImageROI(leftImageROI);

现在这一切对我来说都是安全的,因为它们只是在读取图像.但是代码崩溃了.如果我在一开始就放锁,虽然它有效.有人可以帮忙吗？

我知道TBB(Thread Building Blocks)声称拥有一个复杂的引擎,但从算法的角度来看:

如果我们有一个工作队列(在Linux上说)N的工作线程(POSIX线程,N是核心数量)和任务的互斥体同步队列,每个工作线程然后从队列中取任务时空闲的,也有一些同步调用,还有什么可以TBB提供,不算好C++语法？我没有看到比核心任务贪婪更好的算法.

我是英特尔TBB的新手.我正在使用concurrent_queue,以便在我的项目中实现细粒度的并行性.我几乎没有怀疑.这就是我的实施方式.

   thread_fun(arguments) {
      while(concurrent_queue.try_pop(v))
          operation on v;  //each thread executes its own operation(seperate v for each thread)
   }
   main() {
      for(..)
         concurrent_queue.push(); //fill the queue
      _beginthreadex(..); //create 8 win32 threads and pass concurrent_queue as an argument
   }

1. 我明确提到了线程的数量.我读到TBB将根据处理器核心数创建线程.我怎样才能实现这一目标？所以我不需要使用_beginthreadex函数显式创建线程？

2. 我是否通过使用concurrent_queue实现了细粒度的并行性？

3. 任务级并行性是什么意思？你如何用intel tbb实现任务级并行？我从队列中弹出元素.流行操作是否被视为一项任务？这意味着,所有弹出操作都被视为不同的任务.我用8个线程一次弹出8个元素.这意味着,我正在实现任务级并行性.我对么？

4. 如果我在四核处理器(支持8个线程)上将线程数增加到32,那么concurrent_queue如何工作？是否只有8个线程同时在队列上执行或共32个线程同时执行？

请帮我.

TBB的文档提供了这个例子中使用与parallel_for时lambda表达式,但不提供使用与lambda表达式的例子tbb::task::enqueue.

我正在寻找一个tbb::task::enqueue使用lambda表达式的简单示例.

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

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

下面是一个简单的并行程序，用于使用 tbb 计算标准向量中的元素之和。
有人可以帮我理解为什么它输出错误的结果吗？

#include  <iostream>
#include <algorithm>
#include <numeric>

#include <tbb/tbb.h>

struct Sum {
    int value;

    Sum() : value(0) {}
    Sum(Sum&s, tbb::split) : value(0) {}

    void operator()(const tbb::blocked_range<std::vector<int>::iterator>& r) {

        value = std::accumulate(r.begin(), r.end(), 0);
    }

    void join(Sum& rhs) { value += rhs.value; }
};


int main()
{   
    std::vector<int> a(100);
    std::fill(a.begin(), a.end(), 1);

    Sum sum;
    tbb::parallel_reduce(tbb::blocked_range<std::vector<int>::iterator>(a.begin(), a.end()), sum);

    std::cout << sum.value << std::endl;

    return 0;  
}

我最近读了这个问题如何静态链接到TBB？我仍然不明白使用tbb作为静态链接库的问题(如果你这样做,可以使用它们的makefile make extra_inc=big_iron.inc tbb)

答案似乎是说问题在于单个程序中可能存在多个单例,单个子的所有(大多数？)实现都不会让这种情况发生.我不明白这背后的原因.

问题在于,当您进行fork()另一个处理时,单例会在两个单独的进程中成为两个独立的单例吗？那是"程序"的意思吗？如果就是这样,为什么他们不能mmap()共享内存并将其用作通信媒介？

也不动态链接只意味着库本身在内存中共享,即代码段？

谢谢!

我做了一个测试来比较 golang 通道和 C++ tbb 并发队列性能，我设置了 8 个写入器和 1 个读取器，它们位于不同的线程中。结果显示 golang 比 C++ 版本快得多（无论延迟和整体发送/接收速度如何），是是真的？或者我的代码有什么错误？

golang 结果，单位是微秒

延迟最大值：1505，平均：1073 发送开始：1495593677683232，接收结束：1495593677901854，时间：218622

package main

import (
    "flag"
    "time"
    "fmt"
    "sync"
    "runtime"
)

var (
    producer = flag.Int("producer", 8, "producer")
    consumer = flag.Int("consumer", 1, "consumer")
    start_signal sync.WaitGroup
)

const (
    TEST_NUM = 1000000
)

type Item struct  {
    id int
    sendtime int64
    recvtime int64
}

var g_vec[TEST_NUM] Item

func sender(out chan int, begin int, end int) {
    start_signal.Wait()
    runtime.LockOSThread()
    println("i am in sender", begin, end) …

我有代码,我必须并行地运行parallel_for(彼此独立).

代码是这样的:

tbb::parallel_for(range1,func1());//first

tbb::parallel_for(range2,func2());//second

tbb::parallel_for(range3,func3());//third

我尝试过使用task_group.还有其他方法吗？

我的问题是,正如标题所说:在一般水平上(易用性,对发生的事情的控制程度等)你会推荐哪一个小型并行程序？微软的TPL还是英特尔的TBB？

先感谢您