gpt4 book ai didi

c++ - 为什么 C++ 编译器不优化读取和写入结构数据成员而不是不同的局部变量?

转载 作者:可可西里 更新时间:2023-11-01 18:35:26 25 4
gpt4 key购买 nike

我正在尝试用固定的 double 创建一些 POD 值的本地数组(例如 max_size )在编译时已知,然后读取运行时 size值 ( size <= max_size ) 并首先处理 size该数组中的元素。

问题是,为什么编译器在arr时不消除堆栈读写?和 size被放入同一个 struct/class , 而不是 arr 的情况和 size是自变量吗?

这是我的代码:

#include <cstddef>
constexpr std::size_t max_size = 64;

extern void process_value(double& ref_value);

void test_distinct_array_and_size(std::size_t size)
{
double arr[max_size];
std::size_t arr_size = size;

for (std::size_t i = 0; i < arr_size; ++i)
process_value(arr[i]);
}

void test_array_and_size_in_local_struct(std::size_t size)
{
struct
{
double arr[max_size];
std::size_t size;
} array_wrapper;
array_wrapper.size = size;

for (std::size_t i = 0; i < array_wrapper.size; ++i)
process_value(array_wrapper.arr[i]);
}

test_distinct_array_and_size 的汇编输出来自带有 -O3 的 Clang:

test_distinct_array_and_size(unsigned long): # @test_distinct_array_and_size(unsigned long)
push r14
push rbx
sub rsp, 520
mov r14, rdi
test r14, r14
je .LBB0_3
mov rbx, rsp
.LBB0_2: # =>This Inner Loop Header: Depth=1
mov rdi, rbx
call process_value(double&)
add rbx, 8
dec r14
jne .LBB0_2
.LBB0_3:
add rsp, 520
pop rbx
pop r14
ret

test_array_and_size_in_local_struct 的汇编输出:

test_array_and_size_in_local_struct(unsigned long): # @test_array_and_size_in_local_struct(unsigned long)
push r14
push rbx
sub rsp, 520
mov qword ptr [rsp + 512], rdi
test rdi, rdi
je .LBB1_3
mov r14, rsp
xor ebx, ebx
.LBB1_2: # =>This Inner Loop Header: Depth=1
mov rdi, r14
call process_value(double&)
inc rbx
add r14, 8
cmp rbx, qword ptr [rsp + 512]
jb .LBB1_2
.LBB1_3:
add rsp, 520
pop rbx
pop r14
ret

最新的 GCC 和 MSVC 编译器在堆栈读写方面做的事情基本相同。

如我们所见,读取和写入 array_wrapper.size在后一种情况下,堆栈上的变量不会被优化掉。有写 size值到位置[rsp + 512]在循环开始之前,并在每次 迭代之后从该位置读取。

所以,编译器有点期待我们想要修改 array_wrapper.size来自 process_value(array_wrapper.arr[i])调用(通过获取当前数组元素的地址并对其应用一些奇怪的偏移量?)

但是,如果我们尝试从那个调用中这样做,那不是未定义的行为吗?

当我们按照以下方式重写循环时

for (std::size_t i = 0, sz = array_wrapper.size; i < sz; ++i)
process_value(array_wrapper.arr[i]);

,每次迭代结束时那些不必要的读取将消失。但是初始写入[rsp + 512]将保留,这意味着编译器仍然希望我们能够访问 array_wrapper.size来自这些 process_value 的那个位置的变量调用(通过做一些奇怪的基于偏移的魔法)。

为什么?

这只是现代编译器实现中的一个小缺点(希望很快会得到修复)吗?还是 C++ 标准确实需要这样的行为,导致每当我们将数组及其大小放入同一个类时生成效率较低的代码?

附言

我意识到我上面的代码示例可能看起来有点做作。但考虑一下:我想使用轻量级 boost::container::static_vector -like 我的代码中的类模板,用于使用 POD 元素的伪动态数组进行更安全、更方便的“C++ 风格”操作。所以我的 PODVector将包含一个数组和一个 size_t在同一个类(class):

template<typename T, std::size_t MaxSize>
class PODVector
{
static_assert(std::is_pod<T>::value, "T must be a POD type");

private:
T _data[MaxSize];
std::size_t _size = 0;

public:
using iterator = T *;

public:
static constexpr std::size_t capacity() noexcept
{
return MaxSize;
}

constexpr PODVector() noexcept = default;

explicit constexpr PODVector(std::size_t initial_size)
: _size(initial_size)
{
assert(initial_size <= capacity());
}

constexpr std::size_t size() const noexcept
{
return _size;
}

constexpr void resize(std::size_t new_size)
{
assert(new_size <= capacity());
_size = new_size;
}

constexpr iterator begin() noexcept
{
return _data;
}

constexpr iterator end() noexcept
{
return _data + _size;
}

constexpr T & operator[](std::size_t position)
{
assert(position < _size);
return _data[position];
}
};

用法:

void test_pod_vector(std::size_t size)
{
PODVector<double, max_size> arr(size);

for (double& val : arr)
process_value(val);
}

如果上述问题确实是 C++ 标准强制执行的(并且不是编译器编写者的错),那么 PODVector永远不会像原始使用数组和“不相关”的大小变量那样有效。这对于 C++ 作为一种需要零开销抽象的语言来说是非常糟糕的。

最佳答案

这是因为 void process_value(double& ref_value); 通过引用接受参数。编译器/优化器假定别名,即 process_value 函数可以更改通过引用 ref_value 访问的内存,因此可以更改数组后面的 size 成员。

编译器假设因为 arraysize 是同一个对象的成员 array_wrapper 函数 process_value 可以可能将对第一个元素的引用(在第一次调用时)转换为对对象的引用(并将其存储在其他地方)并将对象转换为 unsigned char 并读取或替换其整个表示形式。这样在函数返回后必须从内存中重新加载对象的状态。

size 是堆栈上的独立对象时,编译器/优化器假定没有其他对象可能有指向它的引用/指针并将其缓存在寄存器中。

Chandler Carruth: Optimizing the Emergent Structures of C++他解释了为什么优化器在调用接受引用/指针参数的函数时遇到困难。仅在绝对必要时才使用引用/指针函数参数。

如果您想更改该值,性能更高的选项是:

double process_value(double value);

然后:

array_wrapper.arr[i] = process_value(array_wrapper.arr[i]);

此更改导致 optimal assembly :

.L23:
movsd xmm0, QWORD PTR [rbx]
add rbx, 8
call process_value2(double)
movsd QWORD PTR [rbx-8], xmm0
cmp rbx, rbp
jne .L23

或者:

for(double& val : arr)
val = process_value(val);

关于c++ - 为什么 C++ 编译器不优化读取和写入结构数据成员而不是不同的局部变量?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/48303172/

25 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com