calloc v/s malloc ed efficienza temporale

Question

Ho letto con interesse il post C difference between malloc and calloc. Sto usando malloc nel mio codice e vorrei sapere quale differenza avrò usando calloc invece.

Il mio presente codice (pseudo) con malloc:

Scenario 1

int main() 
{ 
    allocate large arrays with malloc 

    INITIALIZE ALL ARRAY ELEMENTS TO ZERO 

    for loop //say 1000 times 
    do something and write results to arrays 
    end for loop 

    FREE ARRAYS with free command 

} //end main 

Se uso calloc invece di malloc, Allora dovrò:

Scenario2

int main() 
{ 

    for loop //say 1000 times 
    ALLOCATION OF ARRAYS WITH CALLOC 

    do something and write results to arrays 

    FREE ARRAYS with free command 

    end for loop 


} //end main 

Ho tre domande:

1. Quale degli scenari è più efficiente se gli array sono molto grandi?

2. Quale degli scenari sarà più efficiente in termini di tempo se gli array sono molto grandi?

3. In entrambi gli scenari, sto semplicemente scrivendo su array nel senso che per ogni iterazione data nel ciclo for, sto scrivendo ogni array in sequenza dal primo elemento all'ultimo elemento. La domanda importante: se utilizzo malloc come nello scenario 1, è necessario inizializzare gli elementi a zero? Dire con malloc che ho array z = [garbage1, garbage2, garbage 3]. Per ogni iterazione, sto scrivendo gli elementi in sequenza cioè nella prima iterazione ottengo z = [some_result, garbage2, garbage3], nella seconda iterazione che ottengo nella prima iterazione ottengo z = [some_result, another_result, garbage3] e così on, quindi ho bisogno di inizializzare in modo specifico i miei array dopo malloc?

Answer 1

Supponendo che la quantità totale di memoria in fase di inizializzazione per le due esempi è la stessa, allocando la memoria con calloc() potrebbe essere più veloce di assegnazione della memoria con malloc() e poi li azzeramento in una fase separata, soprattutto se nel caso malloc() azzeri gli elementi singolarmente iterando su di loro in un ciclo. A malloc() seguito da un memset() sarà probabilmente più veloce di calloc().

Se non si cura che gli elementi dell'array siano inutili prima di archiviare effettivamente i risultati di calcolo in essi, non è necessario inizializzare effettivamente gli array dopo lo malloc().

Answer 2

Per 1 e 2, entrambi fanno la stessa cosa: allocare e zero, quindi utilizzare gli array.

Per 3, se non è necessario azzerare prima gli array, quindi l'azzeramento non è necessario e non farlo è più veloce.

C'è una possibilità che l'azzeramento di calloc sia più efficiente del codice che scrivi, ma questa differenza sarà piccola rispetto al resto del lavoro eseguito dal programma. Il vero risparmio di calloc non è dover scrivere quel codice da soli.

Answer 3

Gli approcci calloc e memset dovrebbero essere circa lo stesso, e forse leggermente più veloce di azzerarlo da soli.

In ogni caso, è tutto relativo a ciò che fai all'interno del tuo ciclo principale, che potrebbe essere di ordini di grandezza maggiore.

Answer 4

Il punto indicato in 3. sembra indicare un caso o un'inizializzazione non necessaria. Questo è un pessimo livello di velocità, non solo il tempo speso per farlo è sprecato, ma un sacco di sfratti della cache è accaduto a causa di esso.

Fare un memset() o bzero() (che sono chiamati da calloc() in ogni caso) è un buon modo per invalidare una porzione enorme della cache. Non farlo a meno che tu non sia sicuro di non sovrascrivere tutto, ma può leggere parti del buffer che non sono state scritte (come se 0 fosse un valore predefinito accettabile). Se si scrive su tutto, comunque, non inizializzare inutilmente la memoria.

La scrittura di memoria non necessaria non solo rovinerà le prestazioni della tua app ma anche le prestazioni di tutte le applicazioni che condividono la stessa CPU con essa.

Answer 5

malloc differiscono da calloc per due motivi

1. malloc accetta un argomento che calloc prende due argomenti

2. malloc è più veloce di motivo calloc è che malloc trasformati singola matrice bidimensionale formato puntatore mentre calloc prende la matrice bidimensionale e prima di elaborarla converte in array monodimensionale e poi in formato puntatore.

Credo che, è per questo che malloc elaborazione più veloce rispetto a calloc