compensazione una piccola matrice integer: vs memset ciclo

Question

Ci sono due modi per azzerare una matrice integer/float:

memset(array, 0, sizeof(int)*arraysize); 

o:

for (int i=0; i <arraysize; ++i) 
    array[i]=0; 

ovviamente, memset è più veloce di grande arraysize. Tuttavia, a che punto il sovraccarico di memset è effettivamente maggiore del sovraccarico del ciclo for? Ad esempio, per un array di dimensioni 5 - quale sarebbe il migliore? Il primo, il secondo, o forse anche il non-laminati versione:

array[0] = 0; 
array[1] = 0; 
array[2] = 0; 
array[3] = 0; 
array[4] = 0; 

Answer 1

Con ogni probabilità, memset() sarà inline dal compilatore (la maggior parte dei compilatori lo trattano come un 'intrinseca', che in pratica significa che è in linea, tranne forse con le ottimizzazioni più basse o se non esplicitamente disabilitato).

Ad esempio, qui alcuni release notes from GCC 4.3: generazione

codice di blocco movimento (memcpy) e del blocco (memset) stato riscritto. GCC può ora scegliere l'algoritmo migliore (loop, loop non terminato, istruzione con prefisso o una chiamata alla libreria in base alla dimensione del blocco da copiare e la CPU è ottimizzata per. Una nuova opzione -minline-stringops-dynamically è stata aggiunta . Con questa opzione stringa le operazioni di dimensioni sconosciute sono espanse in modo tale che i blocchi piccoli sono copiati dal codice in linea, mentre per i blocchi grandi viene utilizzata una chiamata di libreria. Questo risulta in un codice più veloce di -minline-all-stringops quando l'implementazione della libreria è in grado di utilizzando hint di gerarchia della cache. L'euristica che sceglie il particolare algoritmo può essere sovrascritta tramite -mstringop-strategy. Inoltre, anche memset di valori diversi da 0 è in linea.

Potrebbe essere possibile per il compilatore fare qualcosa di simile con gli esempi alternativi che hai dato, ma scommetto che è meno probabile.

Ed è grep -able e più immediatamente evidente a colpo d'occhio quale sia l'intenzione di avviare (non che il ciclo sia particolarmente difficile da eliminare).

Answer 2

Come già detto, gcc e credo che molti altri compilatori lo ottimizzino già molto bene. Per esempio gcc trasforma questo

char arr[5]; 
memset(arr, 0, sizeof arr); 

in

movl $0x0, <arr+0x0> 
movb $0x0, <arr+0x4> 

Non c'è niente di meglio di così ...

Answer 3

Non c'è modo di risolvere la questione senza misurare. Dipenderà interamente dalle implementazioni della libreria di compilazione, cpu e runtime.

memset() può essere un po 'un "odore di codice", perché può essere soggetto a buffer overflow, inversioni di parametri e ha la sfortunata capacità di cancellare solo' byte-saggio '. Tuttavia è una scommessa sicura che sarà "il più veloce" in tutti i casi tranne che estremi.

Io tendo ad usare una macro per avvolgere questo per evitare alcuni dei problemi:

#define CLEAR(s) memset(&(s), 0, sizeof(s)) 

Questo evita i calcoli di dimensioni e rimuove il problema di scambiare i parametri di lunghezza e vlaue.

In breve, utilizzare memset() "sotto il cofano". Scrivi ciò che intendi e lascia che il compilatore si preoccupi delle ottimizzazioni. La maggior parte sono incredibilmente bravi.

Answer 4

Considerando che questo codice di per sé è già stato detto. Ma se lo consideri nel suo programma, di cui non so nulla, si può fare qualcos'altro. Ad esempio, se questo codice deve essere eseguito ogni volta per svuotare un array, è possibile eseguire un thread che assegna costantemente un nuovo array di elementi zero assegnato a una variabile globale, che il proprio codice, quando necessita dell'array da cancellare, punta semplicemente a.

Questa è una terza opzione. Naturalmente se si prevede di eseguire il codice su un processore con almeno due core e questo ha senso. Anche il codice deve essere eseguito più di una volta per vedere i benefici. Per una sola volta, è possibile dichiarare un array pieno di zeri e quindi puntarlo quando necessario.

Spero che questo possa aiutare qualcuno