std :: unordered_map:多线程插入?

时间:2018-12-16 04:44:37

标签: c++ multithreading dictionary unordered

我有一堆数据(0到ULLONG_MAX之间的整数列表),我想提取所有唯一值。我的方法是创建一个unordered_map,使用整数列表值作为键,并为映射值使用一次性布尔值。我遍历列表,并为每个键插入一次性的值。最后,我迭代地图以获取所有唯一键。非常简单。

但是,我的列表太大(亿),因此我想对该进程进行多线程处理。我知道天真的线程化方法行不通,因为unordered_map插入会影响基础数据结构,因此它不是线程安全的。并且在每个插入周围添加锁将很慢,并且可能会抵消任何线程加速。

但是,大概不是每个插入都会改变数据结构(只有那些不能容纳在现有已分配存储桶中的数据结构吗?)。有没有一种方法可以在插入之前检查是否需要对特定插入进行unordered_map重新分配?这样,我只能在更改映射时锁定线程,而不是在每次插入期间都锁定。然后,在每次插入之前,线程仅检查是否存在锁...而不是进行完全锁定/解锁。有可能吗?

1 个答案:

答案 0 :(得分:3)

并行化的基本规则将工作分解,分解成碎片,然后组合碎片。

哈希/项查找是整个shebang中最昂贵的部分,因此我们将重点关注并行化。

如果您绝对需要将结果用作哈希表,那么我对您来说有个坏消息:您必须自己编写。话虽如此,让我们开始吧。

首先,让我们依次解决问题。这很简单。下面的函数带有一个向量和一个回调。我们将使用向量,将其转换为unordered_set,并将unordered_set给予回调。简单?是。

现在,因为我们要在线程上执行此操作,所以不能立即执行此操作。相反,我们将返回不带参数的lambda。调用该lambda时,即会创建unordered_set并将其提供给回调。这样,我们可以将每个lambda分配给它自己的线程,并且每个线程都将通过调用lambda来运行该作业。

template<class Vector, class Callback>
auto lazyGetUnique(Vector& vector, Callback callback) {
    using Iterator = decltype(vector.begin());
    auto begin = vector.begin();
    auto end = vector.end();
    using elem_t = typename std::iterator_traits<Iterator>::value_type;

    //We capture begin, end, and callback
    return [begin, end, callback]() {
        callback(std::unordered_set<elem_t>(begin, end));
    };
}

现在-此回调应该做什么?答案很简单:回调应将unordered_set的内容分配给向量。为什么?因为我们要合并结果,所以合并向量要比合并unordered_set快得多。

让我们写一个函数给我们回调:

template<class Vector>
auto assignTo(Vector& v) {
    return [&](auto&& contents) {
        v.assign(contents.begin(), contents.end());
    };
}

假设我们要获取向量的唯一元素,然后将它们分配回该向量。现在,这真的很简单:

std::vector<int> v = /* stuff */;
auto new_thread = std::thread( lazyGetUnique(v, assignTo(v)) ); 

在此示例中,当new_thread完成执行时,v将仅包含唯一元素。

让我们看一下完成所有功能的完整功能。

template<class Iterator>
auto getUnique(Iterator begin, Iterator end) {
    using elem_t = typename std::iterator_traits<Iterator>::value_type;

    std::vector<elem_t> blocks[4];

    //Split things up into blocks based on the last 4 bits
    //Of the number. This allows us to guarantee that no two blocks
    //share numbers. 
    for(; begin != end; ++begin) {
        auto val = *begin; 
        blocks[val & 0x3].push_back(val); 
    }

    //Each thread will run their portion of the problem.
    //Once it's found all unique elements, it'll stick the result in the block used as input
    auto thread_0 = std::thread( lazyGetUnique(blocks[0], assignTo(blocks[0])) );
    auto thread_1 = std::thread( lazyGetUnique(blocks[1], assignTo(blocks[1])) );
    auto thread_2 = std::thread( lazyGetUnique(blocks[2], assignTo(blocks[2])) );

    //We are thread_3, so we can just invoke it directly
    lazyGetUnique(blocks[3], assignTo(blocks[3]))(); //Here, we invoke it immediately

    //Join the other threads
    thread_0.join();
    thread_1.join();
    thread_2.join(); 

    std::vector<elem_t> result;
    result.reserve(blocks[0].size() + blocks[1].size() + blocks[2].size() + blocks[3].size());

    for(int i = 0; i < 4; ++i) {
        result.insert(result.end(), blocks[i].begin(), blocks[i].end());
    }

    return result;
}

此函数将内容分解为4个块,每个块不相交。它在4个块中的每个块中找到唯一元素,然后将结果合并。输出是向量。