【发布时间】：2019-11-29 23:35:39
【问题描述】：
我正在尝试测量folly hashmap 中并发插入的性能。这里提供了一个用于这种插入的程序的简化版本：
#include <folly/concurrency/ConcurrentHashMap.h>
#include <chrono>
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
const int kNumMutexLocks = 2003;
std::unique_ptr<std::mutex[]> mutices(new std::mutex[kNumMutexLocks]);
__inline__ void
concurrentInsertion(unsigned int threadId, unsigned int numInsertionsPerThread,
unsigned int numInsertions, unsigned int numUniqueKeys,
folly::ConcurrentHashMap<int, int> &follyMap) {
int base = threadId * numInsertionsPerThread;
for (int i = 0; i < numInsertionsPerThread; i++) {
int idx = base + i;
if (idx >= numInsertions)
break;
int val = idx;
int key = val % numUniqueKeys;
mutices[key % kNumMutexLocks].lock();
auto found = follyMap.find(key);
if (found != follyMap.end()) {
int oldVal = found->second;
if (oldVal < val) {
follyMap.assign(key, val);
}
} else {
follyMap.insert(key, val);
}
mutices[key % kNumMutexLocks].unlock();
}
}
void func(unsigned int numInsertions, float keyValRatio) {
const unsigned int numThreads = 12; // Simplified just for this post
unsigned int numUniqueKeys = numInsertions * keyValRatio;
unsigned int numInsertionsPerThread = ceil(numInsertions * 1.0 / numThreads);
std::vector<std::thread> insertionThreads;
insertionThreads.reserve(numThreads);
folly::ConcurrentHashMap<int, int> follyMap;
auto start = std::chrono::steady_clock::now();
for (int i = 0; i < numThreads; i++) {
insertionThreads.emplace_back(std::thread([&, i] {
concurrentInsertion(i, numInsertionsPerThread, numInsertions,
numUniqueKeys, follyMap);
}));
}
for (int i = 0; i < numThreads; i++) {
insertionThreads[i].join();
}
auto end = std::chrono::steady_clock::now();
auto diff = end - start;
float insertionTimeMs =
std::chrono::duration<double, std::milli>(diff).count();
std::cout << "i: " << numInsertions << "\tj: " << keyValRatio
<< "\ttime: " << insertionTimeMs << std::endl;
}
int main() {
std::vector<float> js = {0.5, 0.25};
for (auto j : js) {
std::cout << "-------------" << std::endl;
for (int i = 2048; i < 4194304 * 8; i *= 2) {
func(i, j);
}
}
}
问题是在 main 中使用这个循环会突然增加func 函数中的测量时间。也就是说，如果我直接从 main 调用该函数而没有任何循环（如下所示），某些情况下的测量时间会突然减少 100 倍以上。
int main() {
func(2048, 0.25); // ~ 100X faster now that the loop is gone.
}
可能的原因
- 我在构建 hasmap 时分配了大量内存。我相信当我在循环中运行代码时，在执行循环的第二次迭代时，计算机正忙于为第一次迭代释放内存。因此，程序变得慢得多。如果是这种情况，我将不胜感激，如果有人能提出一个改变，我可以通过循环获得相同的结果。
更多详情
请注意，如果我在 main 中展开循环，我也会遇到同样的问题。也就是下面的程序也有同样的问题：
int main() {
performComputation(input A);
...
performComputation(input Z);
}
样本输出
第一个程序的输出如下所示：
i: 2048 j: 0.5 time: 1.39932
...
i: 16777216 j: 0.5 time: 3704.33
-------------
i: 2048 j: 0.25 time: 277.427 <= sudden increase in execution time
i: 4096 j: 0.25 time: 157.236
i: 8192 j: 0.25 time: 50.7963
i: 16384 j: 0.25 time: 133.151
i: 32768 j: 0.25 time: 8.75953
...
i: 2048 j: 0.25 time: 162.663
使用i=2048 和j=0.25 在main 中单独运行func 会产生：
i: 2048 j: 0.25 time: 1.01
非常感谢任何评论/见解。
【问题讨论】：
-
我不清楚你在问什么。您是在问为什么，还是为了更好的解决方案？
-
感谢@Chipster 的评论。我在问为什么以及如何找到解决方案。
-
有很多可能性，比如与缓存位置相关的事情，或者与您的想法类似的事情——在操作系统中触发与大内存区域的分配/解除分配相关的事情。不太可能有人可以远程诊断。我首先删除/跳过“B”中发生的事情的块，然后比较单个调用和多个调用，看看删除其中的某些内容是否会使执行时间的差异消失。
-
感谢@SamVarshavchik 的评论。可能不是缓存问题，因为我可以非常随机地访问大量内存占用。我希望有人建议一个函数调用，可以强制程序在每次循环迭代后释放所有资源。你的建议很棒。我一直在这样做，并将继续努力。谢谢。
-
delete和free删除所有分配的内存。向量的析构函数会这样做，因为您提到您正在通过向量分配内存。在这个主题上，没有其他事情可以做。