标签: tbb

我已经使用parallel_for 实现了该算法。但大多数情况下我使用同步部分，所以我没有利润。也许有更好的选择？

    tbb::parallel_for (tbb::blocked_range<int>(1, m * n), apply_transform(d, j, this, m, n));

    void apply_transformation(int * d, int i, int j, int n){
        int elem1 = (*v1)[i];
        int elem2 = (*v2)[j];
        if(elem1 == elem2){
            dLock.acquire(dMutex);
            d[i*n + j] = d[(i-1)*n + j-1];       // no operation required
            dLock.release();
        } else {
            dLock.acquire(dMutex);
            d[i*n + j] = std::min(std::min(d[(i-1)*n + j] + 1, //deletion
                    d[i*n + j-1] + 1), //insertion
                    d[(i-1)*n + j-1] + 1); //substitution
            dLock.release();
        }
    }

    class apply_transform{
        int * array; …

#include <tbb/concurrent_vector.h>
#include <tbb/parallel_for.h>
#include <random>

#define N 1000000

int main()
{
    tbb::concurrent_vector<u_int32_t> v(N);

    std::mt19937 mt;
    std::uniform_int_distribution<u_int32_t> dist(0,499);

    tbb::parallel_for( tbb::blocked_range<tbb::concurrent_vector<u_int32_t>>(v.begin(),v.end()),[&]{return dist(mt);});

    return(0);

}

我不明白为什么这不起作用，据我了解，此接口parallel_for应包括容器的起点、终点以及应在循环的每次迭代中执行的步骤的大小，最后一次参数是将要执行的函数。

现在tbb::blocked_range它用于分割容器（对吗？），所以在这种情况下它应该很有用，我无法让它工作，而且我不明白为什么这不能以更简单的方式与迭代器一起工作。 ..

我对两个用来自梅森扭曲器的伪随机整数填充给定向量的程序进行了一些比较，重点是 TBB 版本非常慢，当 TBB 需要时，std 版本在大约 0.6 秒内执行任务至少1.1秒。

我还注意到 TBB 并没有真正提供优化的算法来处理容器，但它只提供通用构造（parallel_for、parallel_for_each 和类似的）来处理通用任务，其中 std 提供的在这种情况下std::generate是一个更好、更干净的解决方案。

你可以在这里下载我的小测试，其中包含 2 个小源文件 + gcc 的 Makefile http://www.sendspace.com/file/ew73h8

我在这里做错了什么？我增加这个向量的大小越多，TBB 就越慢，我使用的是 Ubuntu 13.04 64 位和 Intel Q6600。

TBB 版本在某些方面可以做得更好吗？

编辑：这两个文件的完整源代码

配置文件

#define N 10000000

标准cpp

#include <random>
#include <iostream>
#include <vector>
#include <algorithm>

#include "config.hpp"

int main() {

    std::vector<u_int32_t> v(N);

    std::mt19937 mt;
    std::uniform_int_distribution<u_int32_t> dist(0,499);

    std::generate(v.begin(),v.end(),[&]{return dist(mt);});

    return(0);
}

待定.cpp

#include <tbb/concurrent_vector.h>
#include <tbb/parallel_for_each.h>

#include <random>
#include <iostream>

#include "config.hpp"

int main()
{
  tbb::concurrent_vector<u_int32_t> v(N);
  std::mt19937 …

我正在尝试使用英特尔TBB parallel_reduce来获取由双精度组成的数组元素的总和.但是,与OpenMP减少实现相比,结果是不同的.

这是OpenMP的一个:

double dAverageTemp = 0.0;
#pragma omp parallel for reduction(+:dAverageTemp)
for (int i = 0; i < sCartesianSize; i++)
    dAverageTemp += pdTempCurr[i];

此代码返回正确的值"317.277 493 "; 但是这个TBB代码:

double dAverageTemp = tbb::parallel_reduce(tbb::blocked_range<double*>(pdTempCurr, pdTempCurr + sCartesianSize - 1),
                                        0.0,
                                        [](const tbb::blocked_range<double*> &r, double value) -> double {
                                            return std::accumulate(r.begin(), r.end(), value);
                                        },
                                        std::plus<double>()
                                        );

坚持认为结果是"317.277 193 ".

我在这里错过了什么？

我想使用 TBB parallel_for 我在我的代码中进行了测试

#include <tbb/parallel_for.h>
#include <tbb/blocked_range.h>
#include <tbb/tbb.h>

std::vector<std::tuple<std::string, unsigned int, std::string>> commands;
auto n = commands.size();
tbb::parallel_for(0, n, [&](int i) {
    const auto &tuple = commands[i];
} );

我的编译行是：

g++ -std=c++11 -Wall -Wextra -g -Og TextMiningApp.cpp -ltbb -o TextMiningApp

我的编译器错误是：

TextMiningApp.cpp: In function ‘int main(int, char**)’:
TextMiningApp.cpp:184:7: error: no matching function for call to ‘parallel_for(int, long unsigned int&, main(int, char**)::<lambda(int)>)’
     } );
       ^
In file included from TextMiningApp.cpp:15:0:
/usr/include/tbb/parallel_for.h:185:6: note: candidate: template<class Range, class Body> void tbb::parallel_for(const …

在英特尔 TBB 中，我尝试： 1. 创建一组任务 2. 让它们运行 3. 当其中一个任务完成时，我从中得到一些结果并杀死其他任务。

我怎样才能做到这一点 ？我只能看到 API 等待所有而不仅仅是单个......

谢谢。

我有以下代码:

标题:

class Counter
{
public:
    Conuter(const std::string& fileName);
    boost::uint16_t getCounter();
private:
    tbb::atomic<boost::uint32_t> counter;
    std::string counterFileName;
};

cpp:

Counter::Counter(const std::string& fileName) : counter(), counterFileName(fileName)
{  
    std::string line;
    std::ifstream counterFile (fileName.c_str());  
    if (counterFile.is_open())
    {
        getline (counterFile, line);
        counterFile.close();
    }

    boost::uint32_t temp = std::stoul (line,nullptr,0);
    counter = temp;
}

boost::uint32_t Counter::getCounter()
{
    if (counter > 1000)
    {
        counter = 0;
    }

    assert( counter < 1000);

    const boost::uint32_t ret = counter++;

    if ((counter % 10) == 0)
    {
        // write the counter back …