Por que usar bzero sobre memset?

Em uma aula de Programação de Sistemas que fiz neste semestre anterior, tivemos que implementar um cliente / servidor básico em C. Ao inicializar estruturas, como sock_addr_inou buffers de char (que usamos para enviar dados entre cliente e servidor), o professor nos instruiu a usar apenas bzeroe não memsetinicializá-los. Ele nunca explicou o porquê e estou curioso para saber se existe uma razão válida para isso.

Vejo aqui: http://fdiv.net/2009/01/14/memset-vs-bzero-ultimate-showdown que bzeroé mais eficiente devido ao fato de que apenas zerará a memória, por isso não precisa fazer qualquer verificação adicional que memsetpossa fazer. Isso ainda não parece necessariamente uma razão para absolutamente não usar memsetpara zerar a memória.

bzeroé considerado obsoleto e, além disso, não é uma função C padrão. De acordo com o manual, memseté preferível a bzeroesse motivo. Então, por que você iria querer ainda usam bzeromais memset? Apenas pelos ganhos de eficiência, ou é algo mais? Da mesma forma, quais são os benefícios do memsetexcesso bzeroque o tornam a opção preferida de fato para programas mais recentes?

Não vejo qualquer razão para preferir bzeromais memset.

memseté uma função C padrão, embora bzeronunca tenha sido uma função padrão C. A lógica é provavelmente porque você pode obter exatamente a mesma funcionalidade usando a memsetfunção

Agora, com relação à eficiência, os compiladores gccusam implementações embutidas paramemset quais alternam para uma implementação específica quando uma constante 0é detectada. O mesmo para glibcquando os recursos internos estão desativados.

Acho que você usou (ou seu professor foi influenciado por) UNIX Network Programming por W. Richard Stevens. Ele usa com bzerofrequência, em vez de memset, mesmo na edição mais atualizada. O livro é tão popular que acho que se tornou um idioma na programação de redes, e é por isso que você ainda o vê sendo usado.

Eu ficaria com memsetsimplesmente porque bzeroé preterido e reduz a portabilidade. Duvido que você tenha algum ganho real ao usar um sobre o outro.

A única vantagem que acho bzero()que sobrou memset()para configurar a memória como zero é que há uma chance reduzida de cometer um erro.

Mais de uma vez me deparei com um bug que parecia:

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

O compilador não irá reclamar (embora talvez aumente alguns níveis de aviso em alguns compiladores) e o efeito será que a memória não é limpa. Como isso não descarta o objeto - apenas o deixa em branco - há uma chance decente de que o bug não se manifeste em nada óbvio.

O fato de bzero()não ser padrão é um irritante menor. (FWIW, eu não ficaria surpreso se a maioria das chamadas de função nos meus programas não fosse padrão; de fato, escrever essas funções é o meu trabalho).

Em um comentário a outra resposta aqui, Aaron Newton citou o seguinte em Unix Network Programming, Volume 1, 3rd Edition por Stevens, et al., Seção 1.2 (ênfase adicionada):

bzeronão é uma função ANSI C. É derivado do código de rede Berkely antigo. No entanto, nós o usamos em todo o texto, em vez da memsetfunção ANSI C , porque bzeroé mais fácil de lembrar (com apenas dois argumentos) do que memset(com três argumentos). Quase todos os fornecedores que oferecem suporte à API de soquetes também fornecem bzeroe, se não, fornecemos uma definição de macro em nosso unp.hcabeçalho.

De fato, o autor do TCPv3 [TCP / IP Illustrated, Volume 3 - Stevens 1996] cometeu o erro de trocar o segundo e o terceiro argumentos memsetem 10 ocorrências na primeira impressão . O compilador CA não pode capturar esse erro porque os dois argumentos são do mesmo tipo. (Na verdade, o segundo argumento é um inte o terceiro argumento é size_t, que geralmente é um unsigned int, mas os valores especificados, 0 e 16, respectivamente, ainda são aceitáveis ​​para o outro tipo de argumento.) A chamada para memsetainda funcionou, porque apenas um algumas das funções de soquete realmente exigem que os 8 bytes finais de uma estrutura de endereço de soquete da Internet sejam definidos como 0. No entanto, foi um erro e que poderia ser evitado usando bzero, porque a troca dos dois argumentos bzerosempre será capturada pelo compilador C se protótipos de função forem usados.

Também acredito que a grande maioria das chamadas para memset()a memória é zero, então por que não usar uma API que é personalizada para esse caso de uso?

Uma possível desvantagem bzero()é que é mais provável que os compiladores otimizem memcpy()porque é padrão e, portanto, eles podem ser escritos para reconhecê-lo. No entanto, lembre-se de que o código correto ainda é melhor que o código incorreto que foi otimizado. Na maioria dos casos, o uso bzero()não causará um impacto perceptível no desempenho do programa e bzero()pode ser uma função macro ou embutida que se expande para memcpy().

Queria mencionar algo sobre o argumento bzero vs. memset. Instale o ltrace e compare o que ele faz sob o capô. No Linux com libc6 (2.19-0ubuntu6.6), as chamadas feitas são exatamente as mesmas (via 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)

Foi-me dito que, a menos que eu esteja trabalhando nas entranhas profundas da libc ou em qualquer número de interfaces kernel / syscall, não preciso me preocupar com elas. Tudo o que me preocupa é que a chamada atenda ao requisito de zerar o buffer. Outros mencionaram sobre qual é preferível em relação ao outro, então vou parar por aqui.

Você provavelmente não deveria usar bzero, não é realmente C padrão, era uma coisa do POSIX.

E observe que a palavra "was" - foi preterida no POSIX.1-2001 e removida no POSIX.1-2008 em deferência ao memset, para que você esteja melhor usando a função C padrão.

Para a função memset, o segundo argumento é um int e o terceiro argumento é size_t,

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

que normalmente é um unsigned int , mas se os valores como, 0 and 16para o segundo e terceiro argumento, respectivamente, forem inseridos na ordem errada como 16 e 0, essa chamada para memset ainda poderá funcionar, mas não fará nada. Porque o número de bytes a inicializar são especificados como 0.

void bzero(void *s, size_t n)

Esse erro pode ser evitado usando o bzero, porque a troca dos dois argumentos pelo bzero sempre será capturada pelo compilador C se forem utilizados protótipos de função.

Em resumo: memset exija mais operações de montagem bzero.

Esta é a fonte: http://fdiv.net/2009/01/14/memset-vs-bzero-ultimate-showdown

Faça como quiser. :-)

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

Observe que:

1. O original bzeronão retorna nada, memsetretorna o ponteiro nulo ( d). Isso pode ser corrigido adicionando o typecast a anular na definição.
2. #ifndef bzeronão impede que você esconda a função original, mesmo que ela exista. Ele testa a existência de uma macro. Isso pode causar muita confusão.
3. É impossível criar um ponteiro de função para uma macro. Ao usar bzeroponteiros de função, isso não funcionará.

O memset usa 3 parâmetros, o bzero ocupa 2 na memória restrita, que o parâmetro extra levaria mais 4 bytes e na maioria das vezes será usado para definir tudo como 0