SIMD 코드가 스칼라 코드보다 느리게 실행됩니다.

Question

elma 및 elmc은 모두 unsigned long 어레이입니다. 따라서 res1 및 res2입니다.

unsigned long simdstore[2]; 
__m128i *p, simda, simdb, simdc; 
p = (__m128i *) simdstore; 

for (i = 0; i < _polylen; i++) 
{ 
    u1 = (elma[i] >> l) & 15; 
    u2 = (elmc[i] >> l) & 15; 
    for (k = 0; k < 20; k++) 
    { 
     //res1[i + k] ^= _mulpre1[u1][k]; 
     //res2[i + k] ^= _mulpre2[u2][k];    

     simda = _mm_set_epi64x (_mulpre2[u2][k], _mulpre1[u1][k]); 
     simdb = _mm_set_epi64x (res2[i + k], res1[i + k]); 
     simdc = _mm_xor_si128 (simda, simdb); 
     _mm_store_si128 (p, simdc); 
     res1[i + k] = simdstore[0]; 
     res2[i + k] = simdstore[1];      
    }  
} 

for 루프 내에는 요소의 XOR의 비 simd 및 simd 버전이 모두 포함됩니다. 두 번째 for 루프 내의 처음 두 행은 명시 적 XOR을 수행하지만 나머지는 동일한 연산의 simd 버전을 구현합니다.

이 루프는 외부에서 수백 번 호출되므로이 루프를 최적화하면 총 계산 시간이 단축됩니다.

문제는 simd 코드가 스칼라 코드보다 느린 속도로 실행됩니다.

편집 : 부분 완료

__m128i *p1, *p2, *p3, *p4; 
p1 = (__m128i *) simdstore1; 
p2 = (__m128i *) simdstore2; 
p3 = (__m128i *) simdstore3; 
p4 = (__m128i *) simdstore4; 

for (i = 0; i < 20; i++) 
{ 
    u1 = (elma[i] >> l) & 15; 
    u2 = (elmc[i] >> l) & 15; 
    for (k = 0; k < 20; k = k + 4) 
    { 
     simda1 = _mm_set_epi64x (_mulpre2[u2][k], _mulpre1[u1][k]); 
     simda2 = _mm_set_epi64x (_mulpre2[u2][k + 1], _mulpre1[u1][k + 1]); 
     simda3 = _mm_set_epi64x (_mulpre2[u2][k + 2], _mulpre1[u1][k + 2]); 
     simda4 = _mm_set_epi64x (_mulpre2[u2][k + 3], _mulpre1[u1][k + 3]); 

     simdb1 = _mm_set_epi64x (res2[i + k], res1[i + k]); 
     simdb2 = _mm_set_epi64x (res2[i + k + 1], res1[i + k + 1]); 
     simdb3 = _mm_set_epi64x (res2[i + k + 2], res1[i + k + 2]); 
     simdb4 = _mm_set_epi64x (res2[i + k + 3], res1[i + k + 3]); 

     simdc1 = _mm_xor_si128 (simda1, simdb1); 
     simdc2 = _mm_xor_si128 (simda2, simdb2); 
     simdc3 = _mm_xor_si128 (simda3, simdb3); 
     simdc4 = _mm_xor_si128 (simda4, simdb4); 

     _mm_store_si128 (p1, simdc1); 
     _mm_store_si128 (p2, simdc2); 
     _mm_store_si128 (p3, simdc3); 
     _mm_store_si128 (p4, simdc4); 

     res1[i + k]= simdstore1[0]; 
     res2[i + k]= simdstore1[1]; 
     res1[i + k + 1]= simdstore2[0]; 
     res2[i + k + 1]= simdstore2[1]; 
     res1[i + k + 2]= simdstore3[0]; 
     res2[i + k + 2]= simdstore3[1]; 
     res1[i + k + 3]= simdstore4[0]; 
     res2[i + k + 3]= simdstore4[1]; 
    } 
} 

그러나이 결과는 많이 변경되지 않습니다 줄이기; 여전히 스칼라 코드의 두 배가 걸립니다.

Answer 1

면책 조항 : 저는 PowerPC 배경에서 왔으므로 여기에서 말하고있는 것은 완전한 호그 워쉬 일 수 있습니다. 그러나 결과에 즉시 액세스하려고하기 때문에 벡터 파이프 라인을 지연시키고 있습니다.

모든 것을 벡터 파이프 라인에 보관하는 것이 가장 좋습니다. vector에서 int 또는 float로 변환하거나 메모리에 결과를 저장하면 즉시 stalling됩니다.

SSE 또는 VMX를 처리 할 때 가장 적합한 작동 모드는로드, 프로세스, 저장입니다. 벡터 레지스터에 데이터를로드하고 모든 벡터 처리를 수행 한 다음 메모리에 저장하십시오.

다음과 같이 권장합니다. 여러 개의 __m128i 레지스터를 예약하고 루프를 여러 번 언로드 한 다음 저장하십시오.

편집 : 또한 언 롤링하고 res1과 res2를 16 바이트로 정렬하면이 simdstore 간접 참조 (아마도 LHS 및 다른 정지)를 거치지 않고 결과를 메모리에 직접 저장할 수 있습니다.

편집 : 명백한 것을 잊어 버렸습니다. 폴리 라인이 일반적으로 큰 경우 모든 반복에서 데이터 캐시 프리 페치를 수행하는 것을 잊지 마십시오.

Answer 2

저는 SIMD 전문가도 아니지만 데이터를 프리 페치하고 EboMike가 언급 한 데로 인해 이익을 얻을 수있는 것처럼 보입니다. res1과 res2를 하나의 정렬 된 배열 (구조체의 다른 용도에 따라 다름)에 병합 한 다음 추가 복사가 필요하지 않은 경우 res1 및 res2를 직접 병합하면 도움이 될 수도 있습니다.

Answer 3

코드가 res1과 res2로 보이는 방식은 완전히 독립적 인 것으로 보입니다. 그러나 이들을 xor에 등록 할 때 같은 레지스터에 넣습니다.

다른 레지스터를 다음과 같이 사용할 것입니다 ( 벡터가 모두 정렬되어야 함).

__m128i x0, x1, x2, x3; 
for (i = 0; i < _polylen; i++) 
{ 

    u1 = (elma[i] >> l) & 15; 
    u2 = (elmc[i] >> l) & 15; 
    for (k = 0; k < 20; k+=2) 
    {  
     //res1[i + k] ^= _mulpre1[u1][k]; 
     x0= _mm_load_si128(&_mulpre1[u1][k]); 
     x1= _mm_load_si128(&res1[i + k]); 
     x0= _mm_xor_si128 (x0, x1); 
     _mm_store_si128 (&res1[i + k], x0); 
     //res2[i + k] ^= _mulpre2[u2][k];    
     x2= _mm_load_si128(&_mulpre2[u2][k]); 
     x3= _mm_load_si128(&res2[i + k]); 
     x2= _mm_xor_si128 (x2, x3); 
     _mm_store_si128 (&res2[i + k], x2); 
    }  
} 

참고 4 개의 레지스터 만 사용하고 있습니다. x86_64에서 x86 이상의 8 개 레지스터를 모두 사용하도록 수동으로 언로드 할 수 있습니다.

Answer 4

수행중인로드 및 저장 장치의 수에 비례하여 계산이 거의 필요하지 않으므로 결과가 거의 없습니다. SIMD.이 경우 특히 64 비트 모드에서 사용할 수있는 x86-64 CPU가있는 경우 스칼라 코드를 사용하는 것이 더 유용 할 것입니다. 이렇게하면로드 및 저장 횟수가 줄어들어 현재 성능에서 가장 중요한 요인이됩니다.

(참고 :. 당신은 코어 2 이상을 사용하는 경우 특히 당신은 아마, 루프를 풀다하지한다)