如何通过键有效地合并 k 个排序的成对键/值向量？

Question

我想通过键合并k个排序的成对键/值向量。 通常，向量的大小n非常大（例如， n >= 4,000,000,000 ）。

考虑以下k = 2的示例：

// Input
keys_1 = [1, 2, 3, 4], values_1 = [11, 12, 13, 14]
keys_2 = [3, 4, 5, 6], values_2 = [23, 24, 25, 26]

// Output
merged_keys = [1, 2, 3, 3, 4, 4, 5, 6], merged_values = [11, 12, 13, 23, 14, 24, 25, 26]

由于__gnu_parallel::multiway_merge是一种高效的k路合并算法，我尝试利用最先进的 zip 迭代器 ( https://github.com/dpellegr/ZipIterator ) 来“组合”键值对向量。

#include <iostream>
#include <vector>
#include <parallel/algorithm>

#include "ZipIterator.hpp"

int main(int argc, char* argv[]) {
  std::vector<int> keys_1   = {1, 2, 3, 4};
  std::vector<int> values_1 = {11, 12, 13, 14};
  std::vector<int> keys_2   = {3, 4, 5, 6};
  std::vector<int> values_2 = {23, 24, 25, 26};

  std::vector<int> merged_keys(8);
  std::vector<int> merged_values(8);

  auto kv_it_1 = Zip(keys_1, values_1);
  auto kv_it_2 = Zip(keys_2, values_2);
  auto mkv_it = Zip(merged_keys, merged_values);

  auto it_pairs = {std::make_pair(kv_it_1.begin(), kv_it_1.end()),
                   std::make_pair(kv_it_2.begin(), kv_it_2.end())};

  __gnu_parallel::multiway_merge(it_pairs.begin(), it_pairs.end(), mkv_it.begin(), 8, std::less<>());
  
  for (size_t i = 0; i < 8; ++i) {
    std::cout << merged_keys[i] << ":" << merged_values[i] << (i == 7 ? "\n" : ", ");
  }

  return 0;
}

但是，我收到各种编译错误（使用-O3构建）：

错误：无法绑定类型为 std::__iterator_traits<ZipIter<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator >>, __gnu_cxx::__normal_iterator<int*, std 的非常量左值引用::vector<int, std::allocator >> >, void>::value_type&' {aka 'std::tuple<int, int>&'} 到 std::tuple<int, int> 类型的右值'

错误：无法转换 'ZipIter<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator >>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator >> >::reference*' {aka 'ZipRef<int, int> '} 到 '_ValueType ' {aka 'std::tuple<int, int>*'}

是否可以修改ZipIterator使其工作？

或者是否有一种更有效的方法来通过键合并k个排序的成对键/值向量？

考虑替代方案

1. 使用int key和int value成员以及operator<和operator<=运算符定义KeyValuePair struct 。 将键/值向量的元素移动到std::vector<KeyValuePair>中。 在std::vector<KeyValuePair>上调用__gnu_parallel::multiway_merge 。 将合并的元素移回键/值向量中。 [判决：执行缓慢，memory 高开销，即使使用-O3 ]
2. 使用std::merge(std::execution::par_unseq, kv_it_1.begin(), kv_it_1.end(), kv_it_2.begin(), kv_it_2.end(), mkv_it.begin()); 而不是__gnu_parallel::multiway_merge 。 [结论：仅支持两个键/值向量]

Answer 1

是否可以修改 ZipIterator 使其工作？

是的，但它需要修补__gnu_parallel::multiway_merge 。 错误的来源是这一行：

      /** @brief Dereference operator.
      *  @return Referenced element. */
      typename std::iterator_traits<_RAIter>::value_type&
      operator*() const
      { return *_M_current; }

这是 _GuardedIterator 的成员_GuardedIterator - multiway_merge实现中使用的辅助结构。 它包装_RAIter class ，在您的情况下是ZipIter 。 根据定义，当迭代器被取消引用时 ( *_M_current )，返回表达式的类型应该是reference类型。 但是，此代码期望它是value_type& 。 在大多数情况下，这些是相同的类型。 事实上，当您取消引用一个项目时，您希望获得对这个项目的引用。 但是，使用 zip 迭代器是不可能的，因为它的元素是虚拟的，它们是动态创建的。 这就是为什么ZipIter的reference类型根本不是引用类型，它实际上是一个名为ZipRef的值类型：

  using reference = ZipRef<std::remove_reference_t<typename std::iterator_traits<IT>::reference>...>;

与（非常讨厌的） vector<bool>一起使用的做法有点相同。

因此， ZipIterator或您如何使用该算法没有问题，这是对算法本身的重要要求。 下一个问题是，我们能摆脱它吗？

答案是肯定的。 您可以更改_GuardedIterator::operator*()以返回reference而不是value_type& 。 然后你会在这一行有一个编译错误：

      // Default value for potentially non-default-constructible types.
      _ValueType* __arbitrary_element = 0;

      for (_SeqNumber __t = 0; __t < __k; ++__t)
        {
          if(!__arbitrary_element
             && _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__t]) > 0)
            __arbitrary_element = &(*__seqs_begin[__t].first);
        }

这里元素的地址被用于一些__arbitrary_element 。 我们可以存储此元素的副本，因为我们知道ZipRef的复制成本很低，而且它是默认构造的：

      // Local copy of the element
      _ValueType __arbitrary_element_val;
      _ValueType* __arbitrary_element = 0;

      for (_SeqNumber __t = 0; __t < __k; ++__t)
        {
          if(!__arbitrary_element
             && _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__t]) > 0) {
            __arbitrary_element_val = *__seqs_begin[__t].first;
            __arbitrary_element = &__arbitrary_element_val;
          }
        }

之后，您可以将__gnu_parallel::multiway_merge与ZipIterator一起使用。

Answer 2

由于您需要较低的 memory 开销，一种可能的解决方案是让multiway_merge算法仅对唯一范围标识符和范围索引进行操作，并将比较和复制运算符作为 lambda 函数提供。 这样，合并算法就完全独立于实际使用的容器类型和键值类型。

这是一个 C++17 解决方案，它基于此处描述的基于堆的算法：

#include <cstdint>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <queue>
#include <vector>

using range_type = std::pair<std::uint32_t,std::size_t>;

void multiway_merge(
    std::initializer_list<std::size_t> range_sizes,
    std::function<bool(const range_type&, const range_type&)> compare_func,
    std::function<void(const range_type&)> copy_func)
{
    // lambda compare function for priority queue of ranges
    auto queue_less = [&](const range_type& range1, const range_type& range2) {
        // reverse comparison order of range1 and range2 here,
        // because we require the smallest element to be on top
        return compare_func(range2, range1);
    };
    // create priority queue from all non-empty ranges
    std::priority_queue<
        range_type, std::vector<range_type>, 
        decltype(queue_less)> queue{ queue_less };
    for (std::uint32_t range_id = 0; range_id < range_sizes.size(); ++range_id) {
        if (std::data(range_sizes)[range_id] > 0) {
            queue.emplace(range_id, 0);
        }
    }
    // merge ranges until priority queue is empty
    while (!queue.empty()) {
        range_type top_range = queue.top();
        queue.pop();
        copy_func(top_range);
        if (++top_range.second != std::data(range_sizes)[top_range.first]) {
            // re-insert non-empty range
            queue.push(top_range);
        }
    }
}


int main() {
    std::vector<int> keys_1   = { 1, 2, 3, 4 };
    std::vector<int> values_1 = { 11, 12, 13, 14 };
    std::vector<int> keys_2   = { 3, 4, 5, 6, 7 };
    std::vector<int> values_2 = { 23, 24, 25, 26, 27 };

    std::vector<int> merged_keys;
    std::vector<int> merged_values;

    multiway_merge(
        { keys_1.size(), keys_2.size() },
        [&](const range_type& left, const range_type& right) {
            if (left == right) return false;
            switch (left.first) {
                case 0:
                    return keys_1[left.second] < keys_2[right.second];
                case 1:
                    return keys_2[right.second] < keys_1[left.second];
            }
            return false;
        },
        [&](const range_type& range) {
            switch (range.first) {
                case 0:
                    merged_keys.push_back(keys_1[range.second]);
                    merged_values.push_back(values_1[range.second]);
                    break;
                case 1:
                    merged_keys.push_back(keys_2[range.second]);
                    merged_values.push_back(values_2[range.second]);
                    break;
            }
        });
    // copy result to stdout
    std::cout << "keys: ";
    std::copy(
        merged_keys.cbegin(), merged_keys.cend(), 
        std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\nvalues: ";
    std::copy(
        merged_values.cbegin(), merged_values.cend(), 
        std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\n";
}

该算法的时间复杂度为O(n log(k)) ，空间复杂度为O(k) ，其中n是所有范围的总大小， k是范围的数量。

所有输入范围的大小都需要作为初始化列表传递。 该示例仅传递示例中的两个输入范围。 将示例扩展到两个以上的范围很简单。

Answer 3

因为我在路上，所以没有时间测试这个。 它只是一段简洁的代码来说明一种可能的解决方案：

class Solution{
    
    std::unordered_map<int,std::set<int>> keyValues;
    std::set<int> outputKeys;
    int outputVectorSize = 0;
    
public:
    
    void addKeyValueSet(const std::vector<int>& keys,const std::vector<int>& values){
        for(int i=0;i<keys.size();i++){
            const int& key = keys.at(i);
            outputKeys.insert(keys.at(i));
            if(keyValues.find(key)==keyValues.end()){
                std::set<int> newSet;
                keyValues[key] = newSet;
            }
            auto& newSet = keyValues[key];
            newSet.insert(values.at(i));
        }
    }
};

看起来您想对两件事进行排序：

• 按键
• 如果有多个具有相同键的键值对，也对值进行排序。

这意味着，如果有多个具有相同键的键值对，则需要对键和值进行排序。

有序集将在您插入值时对其进行排序。 添加所有值后，您可以遍历键并按排序顺序提取该键的相应值集。

Memory 明智的做法是，您将所有值存储一次，将键存储两次。 性能将取决于有序集中的插入。

Answer 4

你将不得不实施一个适合你所拥有的确切情况的人，并且如果你有能力分配 arrays 的完整副本或接近完整副本，那么具有如此大的 arrays 多重威胁可能不是那么好，你可以做的一个优化是使用大页面并确保您正在访问的 memory 未被分页（如果您计划满负荷运行，则不进行交换是不理想的）。

这个简单的低 memory 示例工作得很好，很难击败顺序i/o ，它的主要瓶颈是realloc的使用，当将使用的值从arrs转移到ret时，每个step_size进行多次reallocs但是只有一个很昂贵， ret.reserve()会消耗“大量”时间，因为缩短缓冲区始终可用，但扩展缓冲区可能不可用，操作系统可能需要进行多次 memory 移动。

#include <vector>
#include <chrono>
#include <stdio.h>

template<typename Pair, typename bool REVERSED = true>
std::vector<Pair> multi_merge_lm(std::vector<std::vector<Pair>>& arrs, float step){
    size_t final_size = 0, max, i;
    for (i = 0; i < arrs.size(); i++){
        final_size += arrs[i].size();
    }

    float original = (float)final_size;
    size_t step_size = (size_t)((float)(final_size) * step);

    printf("Merge of %zi (%zi bytes) with %zi step size \n", 
        final_size, sizeof(Pair), step_size
    );
    printf("Merge operation size %.*f mb + %.*f mb \n",
        3, ((float)(sizeof(Pair) * (float)final_size) / 1000000),
        3, ((float)(sizeof(Pair) * (float)final_size * step) / 1000000)
    );

    std::vector<Pair> ret;
    while (final_size --> 0){

        for (max = 0, i = 0; i < arrs.size(); i++){
            // select the next biggest item from all the arrays
            if (arrs[i].back().first > arrs[max].back().first){
                max = i;
            }
        }

        // This does not actualy resize the vector 
        // unless the capacity is too small
        ret.push_back(arrs[max].back());
        arrs[max].pop_back();

        // This check could be extracted of the while
        // with a unroll and sort to little
        for (i = 0; i < arrs.size(); i++){
            if (arrs[i].empty()){
                arrs[i] = arrs.back();
                arrs.pop_back();
                break;
            }
        }

        if (ret.size() == ret.capacity()) {
            // Remove the used memory from the arrs and
            // realloc more to the ret
            for (std::vector<Pair>& chunk : arrs){
                chunk.shrink_to_fit();
            }
            ret.reserve(ret.size() + step_size);

            // Dont move this to the while loop, it will slow down
            // the execution, leave it just for debugging
            printf("\rProgress %i%c / Merge size %zi", 
                (int)((1 - ((float)final_size / original) ) * 100), 
                '%', ret.size()
            );
        }
    }

    printf("\r%*c\r", 40, ' ');
    ret.shrink_to_fit();
    arrs.clear();

    if (REVERSED){
        std::reverse(ret.begin(), ret.end());
    }

    return ret;
}

int main(void) {

    typedef std::pair<uint64_t, uint64_t> Pair;

    int inc = 1;
    int increment = 100000;
    int test_size = 40000000;
    float step_size = 0.05f;

    auto arrs = std::vector<std::vector<Pair>>(5);
    for (auto& chunk : arrs){

        // makes the arrays big and asymmetric and adds 
        // some data to check if it works
        chunk.resize(test_size + increment * inc++);
        for (int i = 0; i < chunk.size(); i++){
            chunk[i] = std::make_pair(i, i * -1);
        }

    }
    printf("Generation done \n");

    auto start = std::chrono::steady_clock::now();
    auto merged = multi_merge_lm<Pair>(arrs, step_size);
    auto end = std::chrono::steady_clock::now();

    printf("Time taken: %lfs \n", 
        (std::chrono::duration<double>(end - start)).count()
    );
    for (size_t i = 1; i < merged.size(); i++){
        if (merged[i - 1] > merged[i]){
            printf("Miss placed at index: %zi \n", i - 1);
        }
    }

    merged.clear();
    return 0;
}

Merge of 201500000 (16 bytes) with 10075000 step size
Merge operation size 3224.000 mb + 161.200 mb
Time taken: 166.197639s

通过探查器（在我的例子中是ANDuProf ）运行它表明调整大小非常昂贵，您使step_size越大，它变得越有效。

（名称是重复的，因为它们来自调用相同函数的代码的不同部分，在本例中，是标准函数进行的调用）

这次重新运行是 0.5 倍，它快了约 2 倍，但现在 function 消耗的 memory 比以前多 10 倍，你应该记住这个值不是通用的，它们可能会根据你运行的硬件而改变，但比例不会会改变那么多。

Merge of 201500000 (16 bytes) with 100750000 step size
Merge operation size 3224.000 mb + 1612.000 mb
Time taken: 72.062857s

你不应该忘记的另外两件事是std::vector是动态的，它的实际大小可能更大， O2不能真正对堆 memory 访问做很多优化，如果你不能让它安全，那么指令只能等待。

Answer 5

我几乎不记得这个，但你可能会发现它有帮助 - 我很确定我已经看到合并 K 排序链表问题。 它使用类似于分而治之的东西，并且接近对数时间复杂度。 我怀疑是否有可能获得更好的时间复杂度。

这背后的逻辑是尽量减少对合并列表的迭代。 如果您合并第一个和第二个列表，那么将它与第三个列表合并需要遍历更长的合并列表。 此方法通过首先合并所有小列表，然后通过合并 1 次合并列表移动到（我喜欢称之为）“第二层合并”来避免这种情况。

这样，如果列表的平均长度为 n，则最多需要执行 logn 个迭代器，从而导致 K*log(n) 复杂度，其中 K 是列表的数量。

抱歉有点“不太精确”，但我认为您可能会发现这条信息很有帮助。 虽然，我不熟悉 gnu 的multiway_merge ，所以无论我说什么也可能毫无用处。