Perché usare bzero su memset?

In una lezione di Programmazione di sistemi ho preso questo semestre precedente, abbiamo dovuto implementare un client / server di base in C. All'inizializzazione delle strutture, come sock_addr_in, o char buffer (che usavamo per inviare i dati avanti e indietro tra client e server) il professore ci ha indicato di utilizzare bzeroe non solo memsetdi inizializzarli. Non ha mai spiegato perché, e sono curioso di sapere se esiste una ragione valida per questo?

Vedo qui: http://fdiv.net/2009/01/14/memset-vs-bzero-ultimate-showdown che bzeroè più efficiente a causa del fatto che sarà sempre azzeramento della memoria, quindi non lo fa deve fare qualsiasi controllo aggiuntivo che memsetpuò fare. memsetTuttavia, ciò non sembra necessariamente un motivo per non utilizzare assolutamente per azzerare la memoria.

bzeroè considerato obsoleto e inoltre non è una funzione C standard. Secondo il manuale, memsetè preferito rispetto bzeroa questo motivo. Allora perché si vuole utilizzare ancora bzerosopra memset? Solo per i guadagni di efficienza o è qualcosa di più? Allo stesso modo, quali sono i vantaggi di memsetOver bzeroche la rendono di fatto l'opzione preferita per i programmi più recenti?

Non vedo alcuna ragione per preferire bzerosopra memset.

memsetè una funzione C standard mentre bzeronon è mai stata una funzione C standard. La logica è probabilmente perché puoi ottenere esattamente la stessa funzionalità usando la memsetfunzione.

Ora per quanto riguarda l'efficienza, i compilatori come gccusano implementazioni integrate per le memsetquali passano a un'implementazione particolare quando 0viene rilevata una costante . Lo stesso glibcvale per i builtin disabilitati.

Immagino che tu abbia usato (o che il tuo insegnante sia stato influenzato da) UNIX Network Programming di W. Richard Stevens. Usa bzerospesso invece di memset, anche nell'edizione più aggiornata. Il libro è così popolare, penso che sia diventato un linguaggio nella programmazione di rete ed è per questo che lo vedi ancora usato.

Vorrei attenermi memsetsemplicemente perché bzeroè deprecato e riduce la portabilità. Dubito che vedresti dei veri guadagni dall'usare l'uno sull'altro.

L'unico vantaggio che penso bzero()abbia rispetto memset()all'impostazione della memoria su zero è che c'è una possibilità ridotta di errore.

Più di una volta mi sono imbattuto in un bug che sembrava:

memset(someobject, size_of_object, 0);    // clear object

Il compilatore non si lamenterà (anche se forse alzare alcuni livelli di avviso su alcuni compilatori) e l'effetto sarà che la memoria non viene cancellata. Perché questo non distrugge l'oggetto - lo lascia solo e solo - c'è una buona possibilità che il bug non si manifesti in qualcosa di ovvio.

Il fatto che bzero()non sia standard è un irritante minore. (FWIW, non sarei sorpreso se la maggior parte delle chiamate di funzione nei miei programmi non sono standard; in realtà scrivere tali funzioni è un po 'il mio lavoro).

In un commento a un'altra risposta qui, Aaron Newton ha citato quanto segue da Unix Network Programming, Volume 1, 3rd Edition di Stevens, et al., Sezione 1.2 (enfasi aggiunta):

bzeronon è una funzione ANSI C. È derivato dal primo codice di rete Berkely. Tuttavia, lo usiamo in tutto il testo, anziché nella memsetfunzione ANSI C , perché bzeroè più facile da ricordare (con solo due argomenti) che memset(con tre argomenti). Quasi tutti i fornitori che supportano l'API socket forniscono anche bzero, e in caso contrario, forniamo una definizione macro nella nostra unp.hintestazione.

In effetti, l'autore di TCPv3 [TCP / IP Illustrated, Volume 3 - Stevens 1996] ha commesso l'errore di scambiare il secondo e il terzo argomento memsetin 10 occorrenze nella prima stampa . Il compilatore CA non può rilevare questo errore perché entrambi gli argomenti sono dello stesso tipo. (In realtà, il secondo argomento è un inte il terzo argomento è size_t, che in genere è un unsigned int, ma i valori specificati, 0 e 16, rispettivamente, sono ancora accettabili per l'altro tipo di argomento.) La chiamata a ha memsetfunzionato ancora, perché solo un alcune delle funzioni del socket richiedono effettivamente che gli 8 byte finali di una struttura dell'indirizzo del socket Internet siano impostati su 0. Tuttavia, si è trattato di un errore e si può evitare usando bzero, perché scambiando i due argomenti con bzerosaranno sempre catturati dal compilatore C se vengono utilizzati i prototipi di funzione.

Credo anche che la stragrande maggioranza delle chiamate verso memset()sia a zero memoria, quindi perché non utilizzare un'API su misura per quel caso d'uso?

Un possibile svantaggio bzero()è che i compilatori potrebbero essere più propensi a ottimizzare memcpy()perché è standard e quindi potrebbero essere scritti per riconoscerlo. Tuttavia, tieni presente che il codice corretto è ancora meglio del codice errato che è stato ottimizzato. Nella maggior parte dei casi, l'utilizzo bzero()non causerà un impatto notevole sulle prestazioni del programma e bzero()può essere una funzione macro o incorporata che si espande memcpy().

Volevo menzionare qualcosa sull'argomento bzero vs. memset. Installa ltrace e confronta ciò che fa sotto il cofano. Su Linux con libc6 (2.19-0ubuntu6.6), le chiamate effettuate sono esattamente le stesse (tramite ltrace ./test123):

long m[] = {0}; // generates a call to memset(0x7fffefa28238, '\0', 8)
int* p;
bzero(&p, 4);   // generates a call to memset(0x7fffefa28230, '\0', 4)

Mi è stato detto che a meno che non stia lavorando nelle viscere profonde di libc o in qualsiasi numero di interfaccia kernel / syscall, non devo preoccuparmi di loro. Tutto ciò di cui dovrei preoccuparmi è che la chiamata soddisfi il requisito di azzerare il buffer. Altri hanno menzionato quale è preferibile rispetto all'altro, quindi mi fermo qui.

Probabilmente non dovresti usare bzero, non è in realtà lo standard C, era una cosa POSIX.

E nota che la parola "era" - è stata deprecata in POSIX.1-2001 e rimossa in POSIX.1-2008 in riferimento al memset, quindi stai meglio usando la funzione C standard.

Per la funzione memset, il secondo argomento è un inte il terzo argomento è size_t,

void *memset(void *s, int c, size_t n);

che in genere è un unsigned int, ma se i valori simili, rispettivamente 0 and 16per il secondo e il terzo argomento, sono inseriti in un ordine errato come 16 e 0, allora una tale chiamata a memset può ancora funzionare, ma non farà nulla. Perché il numero di byte da inizializzare è specificato come 0.

void bzero(void *s, size_t n)

Un tale errore può essere evitato usando bzero, poiché lo scambio dei due argomenti in bzero verrà sempre intercettato dal compilatore C se vengono utilizzati i prototipi di funzione.

In breve: memset richiedono quindi più operazioni di assemblaggio bzero.

Questa è la fonte: http://fdiv.net/2009/01/14/memset-vs-bzero-ultimate-showdown

Fallo nel modo che preferisci. :-)

#ifndef bzero
#define bzero(d,n) memset((d),0,(n))
#endif

Nota che:

1. L'originale bzeronon restituisce nulla, memsetrestituisce il puntatore vuoto ( d). Questo può essere risolto aggiungendo il typecast a void nella definizione.
2. #ifndef bzeronon ti impedisce di nascondere la funzione originale anche se esiste. Verifica l'esistenza di una macro. Ciò può causare molta confusione.
3. È impossibile creare un puntatore a una macro. Quando si utilizza bzerotramite i puntatori a funzione, questo non funzionerà.

memset accetta 3 parametri, bzero ne prende 2 in memoria vincolata che un parametro aggiuntivo richiederebbe 4 byte in più e il più delle volte verrà usato per impostare tutto su 0