C int dizisini sıfırlayın: en hızlı yol?

Sahip olduğumuzu varsayarsak T myarray[100]T = int, unsigned int, long long int veya unsigned long int ile sahip tüm içeriğini sıfırlamanın en hızlı yolu nedir (sadece başlatma için değil, aynı zamanda içeriği programımda birkaç kez sıfırlamak için) ? Belki memset ile?

Gibi dinamik bir dizi için aynı soru T *myarray = new T[100].

memset(kimden <string.h>) muhtemelen en hızlı standart yoldur, çünkü genellikle doğrudan montajda yazılan ve elle optimize edilen bir rutindir.

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

Bu arada, C ++ 'da deyimsel yol std::fill(from <algorithm>) kullanmak olacaktır :

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

ki edilebilir bir halinde otomatik olarak optimize edilebilir memset; İyileştirici yeterince akıllı değilse, daha küçük türler için biraz daha kötü performans gösterirken, s memsetiçin olduğu kadar hızlı çalışacağından oldukça eminim int. Yine de, şüphe duyduğunuzda profil.

Bu soru, oldukça eski olmasına rağmen, en deyimsel yolu ya da en az sayıda satırla yazılabilecek yolu değil, en hızlı yolu istediği için bazı ölçütlere ihtiyaç duyar . Ve bu soruyu gerçek bir test yapmadan cevaplamak aptalca. Bu yüzden, dört çözümü karşılaştırdım, memset ile std :: fill ve SIFIR'ın AnT cevabı ile AVX intrinsics kullanarak yaptığım bir çözüm.

Bu çözümün genel olmadığını, yalnızca 32 veya 64 bitlik veriler üzerinde çalıştığını unutmayın. Bu kod yanlış bir şey yapıyorsa lütfen yorum yapın.

#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;\
};\
}\
}

Düşük seviye optimizasyon uzmanı olmadığım için bunun en hızlı yöntem olduğunu iddia etmeyeceğim. Aksine, memset'ten daha hızlı olan doğru bir mimariye bağlı uygulama örneğidir.

Şimdi sonuçlara bakalım. Boyut 100 int ve uzun uzun diziler için performansı hem statik hem de dinamik olarak tahsis edilmiş olarak hesapladım, ancak statik dizilerde ölü kodu ortadan kaldıran msvc dışında, sonuçlar son derece karşılaştırılabilirdi, bu nedenle yalnızca dinamik dizi performansını göstereceğim. Zaman işaretleri, time.h'nin düşük hassasiyetli saat işlevi kullanılarak 1 milyon yineleme için ms'dir.

clang 3.8 (clang-cl ön ucunu kullanarak, optimizasyon bayrakları = / 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 (optimizasyon işaretleri: -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 (optimizasyon işaretleri: / 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

Burada çok ilginç şeyler oluyor: llvm, MSVC'nin tipik sivilceli optimizasyonları olan gcc'yi öldürüyor (statik dizilerde etkileyici bir ölü kod ortadan kaldırıyor ve ardından doldurma için korkunç bir performansa sahip). Uygulamam önemli ölçüde daha hızlı olsa da, bunun nedeni bit temizlemenin diğer ayar işlemlerinden çok daha az ek yüke sahip olduğunu fark etmesi olabilir.

Clang'ın uygulaması, önemli ölçüde daha hızlı olduğu için daha fazla bakmayı hak ediyor. Bazı ek testler, memset'in aslında 400 baytlık dizi için sıfır olmayan - sıfır olmayan memset'ler için özelleştirilmiş olduğunu, çok daha yavaş (~ 220ms) ve gcc'lerle karşılaştırılabilir olduğunu gösteriyor. Bununla birlikte, 800 baytlık bir diziyle sıfırdan farklı memsetting hız farkı yaratmaz, bu nedenle muhtemelen bu durumda, onların memset'leri benim uygulamamdan daha kötü performansa sahiptir - uzmanlık yalnızca küçük diziler içindir ve kesme değeri yaklaşık 800 bayttır. Ayrıca, gcc 'doldurma' ve 'SIFIR'ın memset için optimizasyon yapmadığını (üretilen koda bakarak), gcc'nin aynı performans özelliklerine sahip kod ürettiğini unutmayın.

Sonuç: memset, bu görev için gerçekten optimize edilmemiştir ve insanların öyle olduğunu düşündüğü gibi (aksi takdirde gcc ve msvc ve llvm'nin memset'i aynı performansa sahip olacaktır). Performans önemliyse, memset, özellikle bu garip orta büyüklükteki diziler için nihai bir çözüm olmamalıdır, çünkü bit temizleme için özel değildir ve derleyicinin kendi başına yapabileceğinden daha iyi elle optimize edilmemiştir.

Kimden memset():

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

Derleme zamanında sizeof(myarray)boyutu myarraybiliniyorsa kullanabilirsiniz . Aksi takdirde, mallocveya aracılığıyla elde edilenler gibi dinamik boyutlu bir dizi kullanıyorsanız new, uzunluğu takip etmeniz gerekecektir.

Kullanabilirsiniz memset, ancak yalnızca tür seçimimiz integral türleriyle sınırlı olduğu için.

Genel olarak C'de bir makro uygulamak mantıklıdır

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

Bu size C ++ benzeri bir işlevsellik sunarak, herhangi bir türden nesneyi, gibi hack'lere başvurmak zorunda kalmadan "sıfırlara sıfırlamanıza" izin verecektir memset. Temel olarak, bu, tür bağımsız değişkenini açıkça belirtmeniz gerekmesi dışında, C ++ işlev şablonunun bir C analogudur.

Üstelik bozunmayan diziler için bir "şablon" oluşturabilirsiniz.

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

Örneğinizde şu şekilde uygulanacaktır

int a[100];

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

Ayrıca özellikle skaler türdeki nesneler için türden bağımsız bir makro uygulanabileceğini belirtmek gerekir.

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

ve

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

yukarıdaki örneği

 int a[100];

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

Statik bildirim için şunu kullanabileceğinizi düşünüyorum:

T myarray[100] = {0};

Dinamik bildirim için aynı yolu öneriyorum: memset

zero(myarray); ihtiyacınız olan tek şey C ++ 'da.

Bunu bir başlığa eklemeniz yeterli:

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

İşte kullandığım işlev:

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);
}

Şöyle diyebilirsiniz:

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

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

Yukarıda memset kullanmaktan daha C ++ 11 yolu var. Ayrıca boyutu belirterek dinamik dizi kullanırsanız derleme zamanı hatası alırsınız.