C int Array auf Null zurücksetzen: der schnellste Weg?

Angenommen, wir haben ein T myarray[100]mit T = int, unsigned int, long long int oder unsigned long long int, was ist der schnellste Weg, um den gesamten Inhalt auf Null zurückzusetzen (nicht nur zur Initialisierung, sondern um den Inhalt in meinem Programm mehrmals zurückzusetzen). ? Vielleicht mit Memset?

Gleiche Frage für ein dynamisches Array wie T *myarray = new T[100].

memset(von <string.h>) ist wahrscheinlich der schnellste Standardweg, da es sich normalerweise um eine Routine handelt, die direkt in der Montage geschrieben und von Hand optimiert wird.

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

Übrigens wäre in C ++ der idiomatische Weg, std::fill(von <algorithm>) zu verwenden:

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

das kann automatisch in eine optimiermemset ; Ich bin mir ziemlich sicher, dass es so schnell wie memsetbei ints funktioniert , während es bei kleineren Typen etwas schlechter abschneidet, wenn der Optimierer nicht intelligent genug ist. Trotzdem, wenn Sie Zweifel haben, Profil.

Diese Frage ist zwar ziemlich alt, erfordert jedoch einige Benchmarks, da sie nicht den idiomatischsten oder den Weg erfordert, der in der geringsten Anzahl von Zeilen geschrieben werden kann, sondern den schnellsten Weg. Und es ist albern, diese Frage ohne tatsächliche Tests zu beantworten. Also habe ich vier Lösungen verglichen, memset vs. std :: fill vs. ZERO der Antwort von AnT mit einer Lösung, die ich mit AVX intrinsics erstellt habe.

Beachten Sie, dass diese Lösung nicht generisch ist, sondern nur mit Daten von 32 oder 64 Bit funktioniert. Bitte kommentieren Sie, wenn dieser Code etwas falsch macht.

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

Ich werde nicht behaupten, dass dies die schnellste Methode ist, da ich kein Experte für Optimierung auf niedriger Ebene bin. Es ist vielmehr ein Beispiel für eine korrekte architekturabhängige Implementierung, die schneller als memset ist.

Nun zu den Ergebnissen. Ich habe die Leistung für Arrays der Größe 100 int und long long berechnet, sowohl statisch als auch dynamisch zugewiesen. Mit Ausnahme von msvc, das bei statischen Arrays eine Eliminierung des toten Codes durchgeführt hat, waren die Ergebnisse äußerst vergleichbar, sodass nur die Leistung dynamischer Arrays angezeigt wird. Zeitmarkierungen sind ms für 1 Million Iterationen unter Verwendung der niedrigpräzisen Uhrfunktion von time.h.

clang 3.8 (Mit dem clang-cl-Frontend Optimierungsflags = / 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 (Optimierungsflags: -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 (Optimierungsflags: / 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

Hier ist viel Interessantes los: llvm töten gcc, MSVCs typische fleckige Optimierungen (es führt eine beeindruckende Eliminierung von totem Code auf statischen Arrays durch und hat dann eine schreckliche Leistung beim Füllen). Obwohl meine Implementierung erheblich schneller ist, kann dies nur daran liegen, dass das Löschen von Bits viel weniger Aufwand verursacht als jede andere Einstellungsoperation.

Die Implementierung von Clang verdient mehr Aufmerksamkeit, da sie erheblich schneller ist. Einige zusätzliche Tests zeigen, dass sein Memset tatsächlich auf Null-Nicht-Null-Memsets für 400-Byte-Arrays spezialisiert ist, die viel langsamer sind (~ 220 ms) und mit gccs vergleichbar sind. Das Memsetting ungleich Null mit einem 800-Byte-Array macht jedoch keinen Geschwindigkeitsunterschied, weshalb in diesem Fall das Memset wahrscheinlich eine schlechtere Leistung aufweist als meine Implementierung - die Spezialisierung gilt nur für kleine Arrays, und der Cuttoff liegt bei etwa 800 Byte. Beachten Sie auch, dass gcc 'fill' und 'ZERO' nicht für memset optimiert sind (unter Berücksichtigung des generierten Codes). Gcc generiert einfach Code mit identischen Leistungsmerkmalen.

Fazit: memset ist nicht wirklich für diese Aufgabe optimiert, so wie es die Leute vorgeben würden (andernfalls hätten das memset von gcc und msvc und llvm die gleiche Leistung). Wenn es auf die Leistung ankommt, sollte memset keine endgültige Lösung sein, insbesondere für diese umständlichen mittelgroßen Arrays, da es nicht auf das Löschen von Bits spezialisiert ist und nicht besser von Hand optimiert wird, als es der Compiler alleine tun kann.

Von memset():

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

Sie können verwenden, sizeof(myarray)wenn die Größe von myarrayzur Kompilierungszeit bekannt ist. Andernfalls müssen Sie die Länge verfolgen , wenn Sie ein Array mit dynamischer Größe verwenden, z. B. über mallocoder new.

Sie können verwenden memset, aber nur, weil unsere Auswahl an Typen auf integrale Typen beschränkt ist.

Im Allgemeinen ist es in C sinnvoll, ein Makro zu implementieren

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

Auf diese Weise erhalten Sie C ++ - ähnliche Funktionen, mit denen Sie ein Array von Objekten eines beliebigen Typs auf Null zurücksetzen können, ohne auf Hacks wie zurückgreifen zu müssen memset. Grundsätzlich ist dies ein C-Analogon der C ++ - Funktionsvorlage, außer dass Sie das Typargument explizit angeben müssen.

Darüber hinaus können Sie eine "Vorlage" für nicht verfallene Arrays erstellen

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

In Ihrem Beispiel würde es als angewendet

int a[100];

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

Es ist auch erwähnenswert, dass speziell für Objekte von Skalartypen ein typunabhängiges Makro implementiert werden kann

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

und

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

das obige Beispiel in verwandeln

 int a[100];

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

Für die statische Deklaration könnten Sie Folgendes verwenden:

T myarray[100] = {0};

Für die dynamische Deklaration schlage ich den gleichen Weg vor: memset

zero(myarray); ist alles was Sie in C ++ brauchen.

Fügen Sie dies einfach einem Header hinzu:

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

Hier ist die Funktion, die ich benutze:

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

Sie können es so nennen:

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

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

Oben ist mehr C ++ 11 als die Verwendung von Memset. Außerdem wird ein Fehler bei der Kompilierung angezeigt, wenn Sie ein dynamisches Array mit Angabe der Größe verwenden.