스트림 내장 함수가 성능을 저하시킵니다.

Question

_mm_stream_ps 내장 함수를 가지고 놀고 있는데 성능을 이해하는 데 어려움이 있습니다. 정말 퍼즐 무엇

2.3 GHz Core i7 (I7-3615QM) (Laptop): 
    305.176 MB allocated 
    Bandwidth (non-temporal): 24.2242 GB/s 
    Bandwidth: 21.4136 GB/s 

Xeon(R) CPU E5-2650 0 @ 2.00GHz (cluster (exclusive job)): 
    305.176 MB allocated 
    Bandwidth (non-temporal): 8.33133 GB/s 
    Bandwidth: 8.20684 GB/s 

내가 더 나은 성능을 볼 수 있다는 것입니다 - :

#include <stdio.h> 
#include <stdint.h> 
#include <stdlib.h> 
#include <omp.h> 

#include <immintrin.h> 

#define NUM_ELEMENTS 10000000L 

static void copy_temporal(float* restrict x, float* restrict y) 
{ 
    for(uint64_t i = 0; i < NUM_ELEMENTS/2; ++i){ 
     _mm_store_ps(y,_mm_load_ps(x)); 
     _mm_store_ps(y+4,_mm_load_ps(x+4)); 
     x+=8; 
     y+=8; 
    } 
} 
static void copy_nontemporal(float* restrict x, float* restrict y) 
{ 
    for(uint64_t i = 0; i < NUM_ELEMENTS/2; ++i){ 
     _mm_stream_ps(y,_mm_load_ps(x)); 
     _mm_stream_ps(y+4,_mm_load_ps(x+4)); 
     x+=8; 
     y+=8; 
    } 
} 

int main(int argc, char** argv) 
{ 
    uint64_t sizeX = sizeof(float) * 4 * NUM_ELEMENTS; 
    float *x = (float*) _mm_malloc(sizeX,32); 
    float *y = (float*) _mm_malloc(sizeX,32); 

    //initialization 
    for(uint64_t i = 0 ; i < 4 * NUM_ELEMENTS; ++i){ 
     x[i] = (float)rand()/RAND_MAX; 
     y[i] = 0; 
    } 

    printf("%g MB allocated\n",(2 * sizeX)/1024.0/1024.0); 

    double start = omp_get_wtime(); 
    copy_nontemporal(x, y); 
    double time = omp_get_wtime() - start; 
    printf("Bandwidth (non-temporal): %g GB/s\n",((3 * sizeX)/1024.0/1024.0/1024.0)/time); 

    start = omp_get_wtime(); 
    copy_temporal(x, y); 
    time = omp_get_wtime() - start; 
    printf("Bandwidth: %g GB/s\n",((3 * sizeX)/1024.0/1024.0/1024.0)/time); 

    _mm_free(x); 
    _mm_free(y); 

    return 0; 
} 

성능 결과 :

여기

은 ... 스트림 버전 내가 함께 일하고 있어요 코드 조각입니다 - Xeon CPU (랩탑에 있지 않음) - 정렬되지 않은로드 및 저장소 (예 : storeu_ps/loadu_ps)를 사용하는 경우 :

y의 중복로드로 인해 스트림 버전이 비 스트림 버전보다 빠르다고 기대합니다. 그러나 측정 결과 스트림 버전이 실제로 비 스트림 버전보다 2 배 느린 것으로 나타났습니다.

설명이 있으십니까?

사용 된 컴파일러 : Intel 14.0.1; 컴파일러 플래그 : -O3 -restrict -xAVX; CPU 사용 : Intel Xeon E5-2650;

감사합니다.

Answer 1

ScottD가 지적했듯이 질문에 대한 대답은 생성 된 어셈블리 코드에 있습니다. 분명히 인텔 컴파일러는 액세스 패턴을 감지 할만큼 똑똑하고 임시 버전의 경우에도 비 시간로드를 자동으로 생성합니다. 여기

는 시간적 버전의 컴파일러가 생성 한 어셈블리 코드입니다 :

..___tag_value___Z13copy_temporalPfS_.35:      # 
     xor  edx, edx          #22.4 
     xor  eax, eax          # 
..B2.2:       # Preds ..B2.2 ..B2.1 
     vmovups xmm0, XMMWORD PTR [rax+rdi]     #23.34 
     inc  rdx           #22.4 
     vmovntps XMMWORD PTR [rax+rsi], xmm0     #23.20 
     vmovups xmm1, XMMWORD PTR [16+rax+rdi]    #24.36 
     vmovntps XMMWORD PTR [16+rax+rsi], xmm1    #24.20 
     vmovups xmm2, XMMWORD PTR [32+rax+rdi]    #23.34 
     vmovntps XMMWORD PTR [32+rax+rsi], xmm2    #23.20 
     vmovups xmm3, XMMWORD PTR [48+rax+rdi]    #24.36 
     vmovntps XMMWORD PTR [48+rax+rsi], xmm3    #24.20 
     add  rax, 64          #22.4 
     cmp  rdx, 5000000         #22.4 
     jb  ..B2.2  # Prob 99%      #22.4 

여전히이 다음과 같다 남아있는 질문 :

왜 비 정렬 시간 버전이 수행하는 것보다 더 나은 CPU E5-2650의 비 임시 버전 (위 참조). 이미 생성 된 어셈블리 코드를 살펴 보았고 컴파일러는 실제로 존재하지 않는 정렬로 인해 vmovups 명령어를 생성합니다.

Answer 2

스트림 변형은 DRAM에 직접 파이프 라인 된 버스트 쓰기를 만듭니다. 속도는 대략 DRAM 속도와 일치해야합니다. 표준 저장소는 캐시에 씁니다 (그러나 데이터가 캐시에없는 경우 먼저 캐시로 읽습니다). 데이터가 이미 캐시에있는 경우 표준 저장소는 캐시 쓰기 속도로 실행됩니다. 일반적으로 마지막 레벨 캐시 크기보다 훨씬 큰 크기의 쓰기는 stream 메소드를 사용하는 것이 훨씬 빠릅니다. 작은 글씨는 종종 표준 상점을 사용하면 더 빠릅니다. 2GB의 버퍼 크기를 사용하여 테스트를 실행 해보십시오. 스트림 메소드가 더 빨라야합니다. 인텔 코어 i7-2600K에서

#define __USE_MINGW_ANSI_STDIO 1 
#include <stdlib.h> 
#include <intrin.h> 
#include <windows.h> 
#include <stdio.h> 
#include <stdint.h> 

//----------------------------------------------------------------------------- 
// 
// queryPerformanceCounter - similar to QueryPerformanceCounter, but returns 
//       count directly. 

uint64_t queryPerformanceCounter (void) 
    { 
    LARGE_INTEGER int64; 
    QueryPerformanceCounter (&int64); 
    return int64.QuadPart; 
    } 

//----------------------------------------------------------------------------- 
// 
// queryPerformanceFrequency - same as QueryPerformanceFrequency, but returns count direcly. 

uint64_t queryPerformanceFrequency (void) 
    { 
    LARGE_INTEGER int64; 

    QueryPerformanceFrequency (&int64); 
    return int64.QuadPart; 
    } 

//--------------------------------------------------------------------------- 

static void testNontemporal (float *x, float *y, uint64_t numberOfVectors) 
    { 
    uint64_t i; 
    for(i = 0; i < numberOfVectors/2; ++i) 
     { 
     _mm_stream_ps(y,_mm_load_ps(x)); 
     _mm_stream_ps(y+4,_mm_load_ps(x+4)); 
     y+=8; x+=8; 
     } 
    } 

//--------------------------------------------------------------------------- 

static void testTemporal (float *x, float *y, uint64_t numberOfVectors) 
    { 
    uint64_t i; 
    for(i = 0; i < numberOfVectors/2; ++i) 
     { 
     _mm_store_ps(y,_mm_load_ps(x)); 
     _mm_store_ps(y+4,_mm_load_ps(x+4)); 
     y+=8; x+=8; 
     } 
    } 

//--------------------------------------------------------------------------- 

static void runtests (int nonTemporal) 
    { 
    uint64_t startCount, elapsed, index; 
    float *x, *y; 
    uint64_t numberOfBytes = 400 * 0x100000ull; 
    uint64_t numberOfFloats = numberOfBytes/sizeof *x; 
    uint64_t numberOfVectors = numberOfFloats/4; 
    double gbPerSecond; 

    x = _mm_malloc (numberOfBytes, 32); 
    y = _mm_malloc (numberOfBytes, 32); 
    if (x == NULL || y == NULL) exit (1); 

    // put valid floating point data into the source buffer 
    // to avoid performance penalty 
    for (index = 0; index < numberOfFloats; index++) 
     x [index] = (float) index, y [index] = 0; 

    startCount = queryPerformanceCounter(); 
    if (nonTemporal) 
     testNontemporal (x, y, numberOfVectors); 
    else 
     testTemporal (x, y, numberOfVectors); 
    elapsed = queryPerformanceCounter() - startCount; 
    gbPerSecond = (double) numberOfBytes/0x40000000 * queryPerformanceFrequency()/elapsed; 
    printf ("%.2f GB/s\n", gbPerSecond); 
    _mm_free (x); 
    _mm_free (y); 
    } 

//--------------------------------------------------------------------------- 

int main (void) 
    { 
    // raise our priority to increase measurement accuracy 
    SetPriorityClass (GetCurrentProcess(), REALTIME_PRIORITY_CLASS); 

    printf ("using temporal stores\n"); 
    runtests (0); 
    printf ("using non-temporal stores\n"); 
    runtests (1); 
    return 0; 
    } 

//--------------------------------------------------------------------------- 

출력 : 여기서

입증하는 벤치 마크

using temporal stores 
5.57 GB/s 
using non-temporal stores 
8.35 GB/s 

Answer 3

AFAIK 비 일시적인 저장 모든 캐시로부터 타겟 캐시 라인을 드롭. 라인이 자연적으로 떨어지기 전에 다시 터치되면, 당신은 꽤 열심히 길을 잃었습니다.