¿Por qué usar bzero sobre memset?

En una clase de Programación de Sistemas que tomé este semestre anterior, tuvimos que implementar un cliente / servidor básico en C. Al inicializar las estructuras, me gusta sock_addr_ino buffers de char (que solíamos enviar datos de un lado a otro entre el cliente y el servidor), el profesor nos indicó que solo los usemos bzeroy no los memsetinicialicemos. Nunca explicó por qué, y tengo curiosidad si hay una razón válida para esto.

Veo aquí: http://fdiv.net/2009/01/14/memset-vs-bzero-ultimate-showdown que bzeroes más eficiente debido al hecho de que solo habrá cero memoria, por lo que no tiene que hacer cualquier verificación adicional que memsetpueda hacer. Sin embargo, eso no necesariamente parece ser una razón para no usar absolutamente memsetpara poner a cero la memoria.

bzerose considera obsoleto y, además, no es una función estándar de C. De acuerdo con el manual, memsetse prefiere bzeropor esta razón. Así que ¿por qué desea utilizar aún bzeromás memset? ¿Solo por las ganancias de eficiencia, o es algo más? Del mismo modo, ¿cuáles son los beneficios de memsetOver bzeroque la convierten en la opción preferida de facto para los programas más nuevos?

No veo ninguna razón para preferir bzerosobre memset.

memsetes una función estándar de C mientras que bzeronunca ha sido una función estándar de C. La razón es probablemente porque puede lograr exactamente la misma funcionalidad utilizando la memsetfunción.

Ahora con respecto a la eficiencia, los compiladores gccusan implementaciones incorporadas para las memsetcuales cambian a una implementación particular cuando 0se detecta una constante . Lo mismo para glibccuando los builtins están deshabilitados.

Supongo que usaste (o tu maestro fue influenciado por) la programación de la red UNIX por W. Richard Stevens. Él usa con bzerofrecuencia en lugar de memset, incluso en la edición más actualizada. El libro es tan popular que creo que se ha convertido en una expresión idiomática en la programación de redes, por lo que todavía lo ves usado.

Me quedaría con memsetsimplemente porque bzeroestá en desuso y reduce la portabilidad. Dudo que vea ganancias reales al usar uno sobre el otro.

La única ventaja que creo que bzero()tiene memset()para establecer la memoria en cero es que hay una posibilidad reducida de cometer un error.

Más de una vez me encontré con un error que se parecía a:

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

El compilador no se quejará (aunque quizás aumenten algunos niveles de advertencia en algunos compiladores) y el efecto será que no se borrará la memoria. Debido a que esto no destruye el objeto, solo lo deja solo, hay una posibilidad decente de que el error no se manifieste en algo obvio.

El hecho de que bzero()no sea estándar es un irritante menor. (FWIW, no me sorprendería si la mayoría de las llamadas a funciones en mis programas no son estándar; de hecho, escribir esas funciones es mi trabajo).

En un comentario a otra respuesta aquí, Aaron Newton citó lo siguiente de Unix Network Programming, Volumen 1, 3ra Edición de Stevens, et al., Sección 1.2 (énfasis agregado):

bzerono es una función ANSI C. Se deriva del código de red de Berkely temprano. Sin embargo, lo usamos en todo el texto, en lugar de la memsetfunción ANSI C , porque bzeroes más fácil de recordar (con solo dos argumentos) que memset(con tres argumentos). Casi todos los proveedores que admiten la API de sockets también proporcionan bzero, y si no, proporcionamos una definición de macro en nuestro unp.hencabezado.

De hecho, el autor de TCPv3 [TCP / IP Ilustrado, Volumen 3 - Stevens 1996] cometió el error de intercambiar el segundo y el tercer argumento por memset10 ocurrencias en la primera impresión . El compilador de CA no puede detectar este error porque ambos argumentos son del mismo tipo. (En realidad, el segundo argumento es un inty el tercer argumento es size_t, que generalmente es un unsigned int, pero los valores especificados, 0 y 16, respectivamente, todavía son aceptables para el otro tipo de argumento). La llamada a memsettodavía funcionó, porque solo un Algunas de las funciones de socket realmente requieren que los 8 bytes finales de una estructura de dirección de socket de Internet se establezcan en 0. Sin embargo, fue un error y uno que podría evitarse utilizando bzero, porque intercambiar los dos argumentos bzerosiempre será captado por el compilador de C si se utilizan prototipos de funciones.

También creo que la gran mayoría de las llamadas a memset()son de memoria cero, entonces, ¿por qué no usar una API que se adapte a ese caso de uso?

Un posible inconveniente bzero()es que es probable que los compiladores se optimicen más memcpy()porque es estándar y, por lo tanto, podrían escribirse para reconocerlo. Sin embargo, tenga en cuenta que el código correcto sigue siendo mejor que el código incorrecto que se ha optimizado. En la mayoría de los casos, el uso bzero()no causará un impacto notable en el rendimiento de su programa, y ​​eso bzero()puede ser una función macro o en línea que se expande memcpy().

Quería mencionar algo sobre el argumento bzero vs. memset. Instale ltrace y luego compare lo que hace debajo del capó. En Linux con libc6 (2.19-0ubuntu6.6), las llamadas realizadas son exactamente las mismas (vía 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)

Me han dicho que a menos que esté trabajando en las profundidades de libc o en cualquier número de interfaz kernel / syscall, no tengo que preocuparme por ellos. Todo lo que debería preocuparme es que la llamada satisfaga el requisito de poner a cero el búfer. Otros han mencionado sobre cuál es preferible sobre el otro, así que me detendré aquí.

Probablemente no deberías usar bzero, en realidad no es C estándar, fue una cosa POSIX.

Y tenga en cuenta que la palabra "era": se desaprobó en POSIX.1-2001 y se eliminó en POSIX.1-2008 en deferencia a memset, por lo que es mejor que use la función C estándar.

Para la función memset, el segundo argumento es an inty el tercer argumento es size_t,

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

que normalmente es un unsigned int, pero si los valores como, 0 and 16para el segundo y el tercer argumento, respectivamente, se ingresan en un orden incorrecto como 16 y 0, entonces, tal llamada a memset aún puede funcionar, pero no hará nada. Porque el número de bytes para inicializar se especifica como 0.

void bzero(void *s, size_t n)

Tal error puede evitarse usando bzero, porque intercambiar los dos argumentos a bzero siempre será captado por el compilador de C si se utilizan prototipos de funciones.

En resumen: memset requieren más operaciones de montaje entonces bzero.

Esta es la fuente: http://fdiv.net/2009/01/14/memset-vs-bzero-ultimate-showdown

Hazlo como quieras. :-)

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

Tenga en cuenta que:

1. El original bzerono devuelve nada, memsetdevuelve el puntero vacío ( d). Esto se puede solucionar agregando el typecast para anular en la definición.
2. #ifndef bzerono le impide ocultar la función original, incluso si existe. Prueba la existencia de una macro. Esto puede causar mucha confusión.
3. Es imposible crear un puntero de función a una macro. Cuando se usan los bzeropunteros de función, esto no funcionará.

memset toma 3 parámetros, bzero toma 2 en la memoria restringida, ese parámetro adicional tomaría 4 bytes más y la mayoría de las veces se usará para configurar todo a 0