C++中更快地执行两个程序的可能解释(使用 Python 比较)?

Possible explanation for faster execution of two programs in C++ (with Python comparison)?

本文关键字:能解释 使用 Python 比较 程序 两个 执行 C++      更新时间:2023-10-16

>更新:C++程序(如下所示)在没有其他标志的情况下编译,即g++ program.cpp.然而,提高优化水平并不能改变蛮力比记忆技术运行得更快的事实(在我的机器上为 0.1 秒 VS 1 秒)。

上下文

我尝试计算具有最长 Collatz 序列的数字(<100 万)。我编写了一个蛮力算法,并将其与建议的优化程序(基本上使用记忆)进行了比较。

我的问题是:蛮力执行速度比C++中所谓的优化(记忆)版本更快的原因可能是什么?

在我在我的机器(Macbook Air)上的比较下方;时间在注释中的程序代码开头。

C++(蛮力)

/**
* runs in 1 second
*/
#include <iostream>
#include <vector>
unsigned long long nextSequence(unsigned long long n)
{
if (n % 2 == 0)
return n / 2;
else
{
return 3 * n + 1;
}
}
int main()
{
int max_counter = 0;
unsigned long long result;
for (size_t i = 1; i < 1000000; i++)
{
int counter = 1;
unsigned long long n = i;
while (n != 1)
{
n = nextSequence(n);
counter++;
}
if (counter > max_counter)
{
max_counter = counter;
result = i;
}
}
std::cout << result << " has " << max_counter << " sequences." << std::endl;
return 0;
}

C++(记忆)

/**
* runs in 2-3 seconds 
*/
#include <iostream>
#include <unordered_map>
int countSequence(uint64_t n, std::unordered_map<uint64_t, uint64_t> &cache)
{
if (cache.count(n) == 1)
return cache[n];
if (n % 2 == 0)
cache[n] = 1 + countSequence(n / 2, cache);
else
cache[n] = 2 + countSequence((3 * n + 1) / 2, cache);
return cache[n];
}
int main()
{
uint64_t max_counter = 0;
uint64_t result;
std::unordered_map<uint64_t, uint64_t> cache;
cache[1] = 1;
for (uint64_t i = 500000; i < 1000000; i++)
{
if (countSequence(i, cache) > max_counter)
{
max_counter = countSequence(i, cache);
result = i;
}
}
std::cout << result << std::endl;
return 0;
}

在Python中,记忆技术确实运行得更快。

蟒蛇(记忆)

# runs in 1.5 seconds
def countChain(n):
if n in values:
return values[n]
if n % 2 == 0:
values[n] = 1 + countChain(n / 2)
else:
values[n] = 2 + countChain((3 * n + 1) / 2)
return values[n]

values = {1: 1}
longest_chain = 0
answer = -1
for number in range(500000, 1000000):
if countChain(number) > longest_chain:
longest_chain = countChain(number)
answer = number
print(answer)

蟒蛇(蛮力)

# runs in 30 seconds

def countChain(n):
if n == 1:
return 1
if n % 2 == 0:
return 1 + countChain(n / 2)
return 2 + countChain((3 * n + 1) / 2)

longest_chain = 0
answer = -1
for number in range(1, 1000000):
temp = countChain(number)
if temp > longest_chain:
longest_chain = temp
answer = number
print(answer)

我知道你的问题是关于两个C++变体之间的区别,而不是关于复制的C++和解释的python之间的区别。 果断地回答它需要在启用优化的情况下编译代码并分析其执行。并明确编译器目标是 64 位还是 32 位。

但是考虑到两个版本的C++代码之间的数量级,快速检查已经表明您的记忆消耗的资源多于获得的资源。

这里的一个重要性能瓶颈是无序映射的内存管理。unordered_map适用于物品桶。映射会在必要时调整存储桶的数量,但这需要内存分配(并可能移动内存块,具体取决于存储桶的实现方式)。

现在,如果您在缓存初始化之后和显示结果之前添加以下语句,您将看到分配的存储桶数量发生了巨大变化:

std::cout << "Bucket count: "<<cache.bucket_count()<<"/"<<cache.max_bucket_count()<<std::endl; 

为了避免与此相关的开销,您可以在构建时预先分配存储桶数量:

std::unordered_map<uint64_t, uint64_t> cache(3000000);

在 ideone 上进行小型和非正式测试时,可以节省近 50% 的性能。

但是不... 在unordered_map中存储和查找对象需要计算由大量算术运算组成的哈希代码。 所以我猜这些操作比做蛮力计算要重。

主内存访问比计算慢得多,以至于当需要关心时,您应该将极少数(取决于 CPU 模型)的 meg 中的任何内容视为从 I/O 或网络设备检索。

与整数运算相比,即使从 L1 获取也是昂贵的。

很久很久以前,这不是真的。 几十年来,计算和内存访问至少处于同一领域,因为晶体管预算中根本没有足够的空间来制作足够大的快速缓存来支付费用。

因此,人们计算CPU操作,只是假设内存或多或少可以跟上。

如今,它只是...不能。 CPU 缓存未命中的惩罚是数百个整数操作,而您的百万 16 字节条目哈希映射几乎可以保证不仅会破坏 CPU 的内存缓存,还会破坏 TLB,这会将延迟损失从痛苦变为毁灭性。