C int 배열을 0으로 재설정 : 가장 빠른 방법?

T myarray[100]with T = int, unsigned int, long long int 또는 unsigned long long int 가 있다고 가정하면 모든 내용을 0으로 재설정하는 가장 빠른 방법은 무엇입니까 (초기화뿐만 아니라 내 프로그램에서 내용을 여러 번 재설정) ? 아마도 memset과 함께?

같은 동적 배열에 대한 동일한 질문입니다 T *myarray = new T[100].

memset(from <string.h>)은 일반적으로 어셈블리로 직접 작성되고 수작업으로 최적화되는 루틴이기 때문에 아마도 가장 빠른 표준 방법 일 것입니다.

memset(myarray, 0, sizeof(myarray)); // for automatically-allocated arrays
memset(myarray, 0, N*sizeof(*myarray)); // for heap-allocated arrays, where N is the number of elements

그건 그렇고, C ++에서 관용적 인 방법은 std::fill(from <algorithm>) 을 사용하는 것입니다 .

std::fill(myarray, myarray+N, 0);

어떤 수 (A) 내로 자동으로 최적화 memset; 나는 확신이 최대한 빨리 작동 할 것이라고 해요 memset위한 int최적화 스마트 충분이 아닌 경우가 더 작은 유형에 대해 약간 더 수행 할 수있는 반면,의. 여전히 의심 스러울 때 프로필.

그렇지 않은 가장 관용적 인 방법, 또는 라인의 가장 적은 수에 기록 할 수있는 방법,하지만 요청으로이 질문은 오히려 오래된 있지만, 몇 가지 벤치 마크를 필요로 가장 빠른 방법입니다. 그리고 실제 테스트없이 그 질문에 대답하는 것은 어리석은 일입니다. 그래서 저는 memset 대 std :: fill 대 AnT의 답변의 ZERO 대 AVX 내장 함수를 사용하여 만든 솔루션의 네 가지 솔루션을 비교했습니다.

이 솔루션은 일반적이지 않으며 32 비트 또는 64 비트의 데이터에서만 작동합니다. 이 코드가 잘못된 작업을 수행하는 경우 의견을 보내주십시오.

#include<immintrin.h>
#define intrin_ZERO(a,n){\
size_t x = 0;\
const size_t inc = 32 / sizeof(*(a));/*size of 256 bit register over size of variable*/\
for (;x < n-inc;x+=inc)\
    _mm256_storeu_ps((float *)((a)+x),_mm256_setzero_ps());\
if(4 == sizeof(*(a))){\
    switch(n-x){\
    case 3:\
        (a)[x] = 0;x++;\
    case 2:\
        _mm_storeu_ps((float *)((a)+x),_mm_setzero_ps());break;\
    case 1:\
        (a)[x] = 0;\
        break;\
    case 0:\
        break;\
    };\
}\
else if(8 == sizeof(*(a))){\
switch(n-x){\
    case 7:\
        (a)[x] = 0;x++;\
    case 6:\
        (a)[x] = 0;x++;\
    case 5:\
        (a)[x] = 0;x++;\
    case 4:\
        _mm_storeu_ps((float *)((a)+x),_mm_setzero_ps());break;\
    case 3:\
        (a)[x] = 0;x++;\
    case 2:\
        ((long long *)(a))[x] = 0;break;\
    case 1:\
        (a)[x] = 0;\
        break;\
    case 0:\
        break;\
};\
}\
}

저수준 최적화 전문가가 아니기 때문에 이것이 가장 빠른 방법이라고 주장하지 않겠습니다. 오히려 그것은 memset보다 빠른 올바른 아키텍처 종속 구현의 예입니다.

이제 결과에. 정적으로 및 동적으로 할당 된 크기 100 int 및 long long 배열의 성능을 계산했지만, 정적 배열에서 데드 코드 제거를 수행 한 msvc를 제외하고는 결과가 매우 비슷했기 때문에 동적 배열 성능 만 보여 드리겠습니다. time.h의 낮은 정밀도 시계 기능을 사용하여 시간 표시는 1 백만 회 반복에 대한 ms입니다.

clang 3.8 (clang-cl 프런트 엔드 사용, 최적화 플래그 = / OX / arch : AVX / Oi / Ot)

int:
memset:      99
fill:        97
ZERO:        98
intrin_ZERO: 90

long long:
memset:      285
fill:        286
ZERO:        285
intrin_ZERO: 188

gcc 5.1.0 (최적화 플래그 : -O3 -march = native -mtune = native -mavx) :

int:
memset:      268
fill:        268
ZERO:        268
intrin_ZERO: 91
long long:
memset:      402
fill:        399
ZERO:        400
intrin_ZERO: 185

msvc 2015 (최적화 플래그 : / OX / arch : AVX / Oi / Ot) :

int
memset:      196
fill:        613
ZERO:        221
intrin_ZERO: 95
long long:
memset:      273
fill:        559
ZERO:        376
intrin_ZERO: 188

여기에는 llvm killing gcc, MSVC의 일반적인 반점 최적화 (정적 배열에서 인상적인 데드 코드 제거를 수행 한 다음 채우기 성능이 끔찍함)가 있습니다. 내 구현이 훨씬 빠르지 만 비트 지우기가 다른 설정 작업보다 훨씬 적은 오버 헤드를 가지고 있음을 인식하기 때문일 수 있습니다.

Clang의 구현은 훨씬 더 빠르기 때문에 더 많이 볼 가치가 있습니다. 일부 추가 테스트에서는 memset이 실제로 0에 특화되어 있음을 보여줍니다 .400 바이트 배열의 경우 0이 아닌 memset은 훨씬 느리고 (~ 220ms) gcc와 비슷합니다. 그러나 800 바이트 배열을 사용하는 0이 아닌 memsetting은 속도 차이가 없습니다. 이것이 아마도이 경우 memset이 내 구현보다 성능이 떨어지는 이유 일 것입니다. 전문화는 작은 배열에만 해당되며 컷오프는 800 바이트 정도입니다. 또한 gcc 'fill'및 'ZERO'는 memset (생성 된 코드보기)에 최적화되지 않으며 gcc는 단순히 동일한 성능 특성을 가진 코드를 생성합니다.

결론 : memset은 실제로이 작업에 최적화되어 있지 않으며 사람들이 그렇게 생각할 것입니다 (그렇지 않으면 gcc와 msvc 및 llvm의 memset의 성능이 동일합니다). 성능이 중요하다면 memset은 특히 이러한 어색한 중간 크기의 배열에 대한 최종 솔루션이되어서는 안됩니다. 이는 비트 지우기에 특화되지 않았고 컴파일러가 자체적으로 수행 할 수있는 것보다 더 잘 최적화되지 않았기 때문입니다.

에서 memset():

memset(myarray, 0, sizeof(myarray));

컴파일 타임에 sizeof(myarray)의 크기를 myarray알고 있으면 사용할 수 있습니다 . 당신은을 통해 얻은 같은 동적 크기의 배열을 사용하는 경우 그렇지 않은 경우, malloc또는 new, 당신은 길이를 추적해야합니다.

를 사용할 수 memset있지만 유형 선택이 정수 유형으로 제한되기 때문입니다.

일반적으로 C의 경우 매크로를 구현하는 것이 합리적입니다.

#define ZERO_ANY(T, a, n) do{\
   T *a_ = (a);\
   size_t n_ = (n);\
   for (; n_ > 0; --n_, ++a_)\
     *a_ = (T) { 0 };\
} while (0)

이것은 당신에게 C ++와 같은 기능을 제공하여 memset. 기본적으로 이것은 유형 인수를 명시 적으로 지정해야한다는 점을 제외하고는 C ++ 함수 템플릿의 C 아날로그입니다.

그 위에 부패되지 않은 배열을위한 "템플릿"을 만들 수 있습니다.

#define ARRAY_SIZE(a) (sizeof (a) / sizeof *(a))
#define ZERO_ANY_A(T, a) ZERO_ANY(T, (a), ARRAY_SIZE(a))

귀하의 예에서는 다음과 같이 적용됩니다.

int a[100];

ZERO_ANY(int, a, 100);
// or
ZERO_ANY_A(int, a);

특히 스칼라 유형의 객체에 대해 유형 독립적 매크로를 구현할 수 있다는 점도 주목할 가치가 있습니다.

#define ZERO(a, n) do{\
   size_t i_ = 0, n_ = (n);\
   for (; i_ < n_; ++i_)\
     (a)[i_] = 0;\
} while (0)

과

#define ZERO_A(a) ZERO((a), ARRAY_SIZE(a))

위의 예를

 int a[100];

 ZERO(a, 100);
 // or
 ZERO_A(a);

정적 선언의 경우 다음을 사용할 수 있다고 생각합니다.

T myarray[100] = {0};

동적 선언의 경우 동일한 방법을 제안합니다. memset

zero(myarray); C ++에서 필요한 모든 것입니다.

헤더에 다음을 추가하십시오.

template<typename T, size_t SIZE> inline void zero(T(&arr)[SIZE]){
    memset(arr, 0, SIZE*sizeof(T));
}

내가 사용하는 기능은 다음과 같습니다.

template<typename T>
static void setValue(T arr[], size_t length, const T& val)
{
    std::fill(arr, arr + length, val);
}

template<typename T, size_t N>
static void setValue(T (&arr)[N], const T& val)
{
    std::fill(arr, arr + N, val);
}

다음과 같이 부를 수 있습니다.

//fixed arrays
int a[10];
setValue(a, 0);

//dynamic arrays
int *d = new int[length];
setValue(d, length, 0);

위는 memset을 사용하는 것보다 더 많은 C ++ 11 방식입니다. 또한 크기를 지정하여 동적 배열을 사용하면 컴파일 시간 오류가 발생합니다.