C++中SSE的内存对齐，_aligned_malloc等效

Memory alignment for SSE in C++, _aligned_malloc equivalent?

本文关键字：aligned malloc 等效 对齐 SSE 内存 C++      更新时间：2023-10-16

我想知道如何将这段C代码转换为用于内存对齐的C++。

float *pResult = (float*) _aligned_malloc(length * sizeof(float), 16);

我确实看了一下，然后试了一下float *pResult = (float*) __attribute__((aligned(16)));

和这个

float *pResult = __attribute__((aligned(16)));

但两者都给出了相似的错误。

error: expected primary-expression before '__attribute__'|
error: expected ',' or ';' before '__attribute__'|

完整代码

#include "stdafx.h"
#include <xmmintrin.h>  // Need this for SSE compiler intrinsics
#include <math.h>       // Needed for sqrt in CPU-only version
#include "stdio.h"
int main(int argc, char* argv[])
{
    printf("Starting calculation...n");
    const int length = 64000;
    // We will be calculating Y = Sin(x) / x, for x = 1->64000
    // If you do not properly align your data for SSE instructions, you may take a huge performance hit.
    float *pResult = (float*) __attribute__((aligned(16))); // align to 16-byte for SSE
    __m128 x;
    __m128 xDelta = _mm_set1_ps(4.0f);      // Set the xDelta to (4,4,4,4)
    __m128 *pResultSSE = (__m128*) pResult;

    const int SSELength = length / 4;
    for (int stress = 0; stress < 100000; stress++) // lots of stress loops so we can easily use a stopwatch
    {
#define TIME_SSE    // Define this if you want to run with SSE
#ifdef TIME_SSE
        x = _mm_set_ps(4.0f, 3.0f, 2.0f, 1.0f); // Set the initial values of x to (4,3,2,1)
        for (int i=0; i < SSELength; i++)
        {
            __m128 xSqrt = _mm_sqrt_ps(x);
            // Note! Division is slow. It's actually faster to take the reciprocal of a number and multiply
            // Also note that Division is more accurate than taking the reciprocal and multiplying
#define USE_DIVISION_METHOD
#ifdef USE_FAST_METHOD
            __m128 xRecip = _mm_rcp_ps(x);
            pResultSSE[i] = _mm_mul_ps(xRecip, xSqrt);
#endif //USE_FAST_METHOD
#ifdef USE_DIVISION_METHOD
            pResultSSE[i] = _mm_div_ps(xSqrt, x);
#endif  // USE_DIVISION_METHOD
            // NOTE! Sometimes, the order in which things are done in SSE may seem reversed.
            // When the command above executes, the four floating elements are actually flipped around
            // We have already compensated for that flipping by setting the initial x vector to (4,3,2,1) instead of (1,2,3,4)
            x = _mm_add_ps(x, xDelta);  // Advance x to the next set of numbers
        }
#endif  // TIME_SSE
#ifndef TIME_SSE
        float xFloat = 1.0f;
        for (int i=0 ; i < length; i++)
        {
            pResult[i] = sqrt(xFloat) / xFloat; // Even though division is slow, there are no intrinsic functions like there are in SSE
            xFloat += 1.0f;
        }
#endif  // !TIME_SSE
    }
    // To prove that the program actually worked
    for (int i=0; i < 20; i++)
    {
        printf("Result[%d] = %fn", i, pResult[i]);
    }
    // Results for my particular system
    // 23.75 seconds for SSE with reciprocal/multiplication method
    // 38.5 seconds for SSE with division method
    // 301.5 seconds for CPU
    return 0;
}

对于C++11，您可以使用以下内容：

struct aligned_float
{
    alignas(16) float f[4];
};
static_assert(sizeof(aligned_float) == 4 * sizeof(float), "padding issue");
int main()
{
    const int length = 64000;
    std::vector<aligned_float> pResult(length / sizeof(aligned_float));
    return 0;
}
对齐的属性只适用于编译/链接的方式。它没有运行时效果。

我所知道的解决这个问题的唯一可移植的方法是使用一个包装器，它实际上分配了超出所需的内容，并屏蔽了较低的部分，以确保它返回的内容符合有效的对齐。

请参阅此处：

http://www.gnu.org/software/libc/manual/html_node/Aligned-Memory-Blocks.html

Glibc提供aligned_alloc（）。

相关文章：