长阵列性能问题答案

【问题标题】：Long array performance issue长阵列性能问题
【发布时间】：2011-10-26 01:35:18
【问题描述】：

我有一个长度为 175,000 的 char 指针数组。每个指针指向一个长度为 100 的 c 字符串数组，每个字符要么是 1 要么是 0。我需要比较字符串之间的差异。

char* arr[175000];

到目前为止，我有两个 for 循环，我将每个字符串与其他每个字符串进行比较。比较函数基本上采用两个 c 字符串并返回一个整数，该整数是数组的差异数。

这在我的 4 核机器上需要很长时间。上次我让它运行了 45 分钟，但它从未完成执行。请告知更快的解决方案或一些优化。

例子：

000010
000001

由于最后两位不匹配，因此相差 2。

在我计算出差异后，我将值存储在另一个数组中

                int holder;

                for(int x = 0;x < UsedTableSpace; x++){
                    int min = 10000000;

                    for(int y = 0; y < UsedTableSpace; y++){

                        if(x != y){
                            //compr calculates difference between two c-string arrays
                            int tempDiff =compr(similarity[x]->matrix, similarity[y]->matrix);

                            if(tempDiff < min){
                                min = tempDiff;
                                holder = y;
                            }
                        }       
                    }
                    similarity[holder]->inbound++;

                }

【问题讨论】：

"我有一个长度为 175,000 的 char 指针数组。每个指针指向一个长度为 100 的 c 字符串数组，每个字符为 1 或 0。"这个设计可以修改吗？这似乎极其效率低下。
答案完全取决于“比较字符串之间的差异”的确切含义。平等？更大？还有什么？
还有：C 还是 C++？它们不可互换。
第一：使用bitset/dynamic_bitset；第二：你在比较什么，结果在哪里？（无论如何，结果是什么？）根据这一点，您也许可以使用常见的优化全文搜索算法
你需要知道所有对之间的距离，还是别的什么？例如，找到与目标字符串的编辑距离为 n 的所有字符串的快速方法有用吗？

标签： c++ c performance algorithm optimization

【解决方案1】：

有了更多信息，我们可能会给你更好的建议，但根据我对这个问题的理解，这里有一些想法：

由于您使用每个字符来表示 1 或 0，因此您使用的内存是您需要使用的数倍，这在缓存等方面会产生很大的性能影响。取而代之的是，您可以使用数字值来表示您的数据，您可以将其视为一系列位。
一旦你实现了#1，你可以一次抓取一个整数或长整数，然后进行按位异或运算，得到一个在两个数字没有的地方都有一个 1 的数字相同的值。然后你可以使用一些the tricks mentioned here 来快速计算这些位。
在一定程度上“展开”循环以避免必要的跳转次数。例如以下代码：
```
total = total + array[i];
total = total + array[i + 1];
total = total + array[i + 2];
```
... 会比只循环 total = total + array[i] 三次更快。跳转很昂贵，并且会干扰处理器的流水线。 更新：我应该提一下，您的编译器可能已经为您完成了一些工作——您可以检查编译后的代码来查看。
将您的整个数据集分解成块，这样您就可以充分利用缓存。将您的问题想象成一个“正方形”，一个轴上的i 索引和另一个轴上的j 轴。如果您从一个i 开始并遍历所有175000 个j 值，那么当您到达行尾时，您访问的第一个j 值将从缓存中消失。另一方面，如果您从左上角从 j=0 转到 256，则在您循环以将它们与 i= 进行比较时，j 轴上的大多数值仍将位于低级缓存中0、1、2 等。

最后，虽然这不言而喻，但我想值得一提：确保您的编译器设置为优化！

【讨论】：

将两个字符串转换为长整数、异或和做一些位魔术对我来说似乎比只比较两个数组要慢。
@vz0：GMan 是对的。理想情况下，您可以首先将它们表示为数值。但即使不是，将它们转换为整数也需要一次通过数组，这将是整个函数成本的 (1/175000)th。因此，如果按位魔法使事情变得快 2 倍，那将产生巨大的影响。我的猜测是这些技术的组合将使事情变得快几倍。

【解决方案2】：

一个简单的优化是只比较字符串一次。如果A 和B 之间的差是12，那么B 和A 之间的差也是12。您的运行时间将减少近一半。

在代码中：

int compr(const char* a, const char* b) {
  int d = 0, i;
  for (i=0; i < 100; ++i)
    if (a[i] != b[i]) ++d;
  return d;
}

void main_function(...) {

    for(int x = 0;x < UsedTableSpace; x++){
        int min = 10000000;

        for(int y = x + 1; y < UsedTableSpace; y++){

            //compr calculates difference between two c-string arrays
            int tempDiff = compr(similarity[x]->matrix, similarity[y]->matrix);

            if(tempDiff < min){
                min = tempDiff;
                holder = y;
            }
        }
        similarity[holder]->inbound++;
    }
}

注意第二个for 循环，我已经更改了开始索引。

其他一些优化是在单独的线程上运行 run 方法以利用您的 4 个内核。

【讨论】：

感谢您的回复，请详细说明。运行运行命令。
我在你发布双循环代码之前回复了。我已经更新了我的答案。
+1：这个单一的优化可能会以最少的努力提供最大的改进。

【解决方案3】：

你的目标是什么，即在你得到Hamming Distances（它们是什么）之后，你想做什么？例如，如果您正在寻找最近的对或最远的对，您可能可以获得 O(n ln n) 算法，而不是目前建议的 O(n^2) 方法。（在 n=175000 时，n^2 是 n ln n 的 15000 倍。）

例如，您可以用 8 个 4 位数字（即 m 的 8 段中设置的位数）来表征每个 100 位数字 m，并将生成的 32 位签名按升序排序。最近对的签名很可能在排序列表中附近。如果两个数字的签名不同，则很容易降低两个数字之间的距离，从而在找到距离更小的数字时提供有效的分支定界过程。

【讨论】：