¿Por qué malloc inicializa los valores a 0 en gcc?

El sistema operativo generalmente borrará las páginas de memoria nuevas que envía a su proceso para que no pueda ver los datos de un proceso anterior. Esto significa que la primera vez que inicializa una variable (o algo malloc) a menudo será cero, pero si alguna vez reutiliza esa memoria (liberándola y malloc-ing de nuevo, por ejemplo), entonces todas las apuestas están canceladas.

Esta inconsistencia es precisamente la razón por la que las variables no inicializadas son un error tan difícil de encontrar.

En cuanto a los gastos generales de rendimiento no deseados, evitar comportamientos no especificados es probablemente más importante. Cualquier pequeño aumento de rendimiento que pueda obtener en este caso no compensará los errores difíciles de encontrar con los que tendrá que lidiar si alguien modifica ligeramente los códigos (rompiendo las suposiciones anteriores) o los traslada a otro sistema (donde las suposiciones podrían haber sido inválidas en primer lugar).

¿Por qué asumes que malloc() se inicializa a cero? Resulta que la primera llamada a malloc() resulta en una llamada a sbrk o mmap llamadas al sistema, que asignan una página de memoria desde el sistema operativo. El sistema operativo está obligado a proporcionar memoria cero inicializada por razones de seguridad (de lo contrario, los datos de otros procesos se hacen visibles!). Así que podría pensar que hay - el sistema operativo pierde tiempo poniendo a cero la página. Pero no! En Linux, hay una página singleton especial para todo el sistema llamada 'página cero' y que page se asignará como Copy-On-Write, lo que significa que solo cuando realmente escriba en esa página, el sistema operativo asignará otra página e inicializará. Así que espero que esto responda a su pregunta sobre el rendimiento. El modelo de paginación de memoria permite que el uso de la memoria sea algo perezoso al admitir la capacidad de mapeo múltiple de la misma página más la capacidad de manejar el caso cuando se produce la primera escritura.

Si llama a free(), el asignador glibc devolverá la región a su libre listas, y cuando se llama de nuevo a malloc(), puede obtener la misma región, pero sucia con los datos anteriores. Eventualmente, free() podría devolver la memoria al sistema operativo llamando a las llamadas del sistema nuevamente.

Observe que el glibc la página de manual en malloc() dice estrictamente que la memoria no se borra, por lo que por el "contrato" en la API, no se puede asumir que se borra. Aquí está el extracto original:

Malloc () asigna bytes de tamaño y devuelve un puntero a la memoria.
La memoria no se borra. Si size es 0, entonces malloc () devuelve NULL, o un valor de puntero único que más tarde se puede pasar con éxito a free().

Si lo desea, puede leer más sobre esa documentación si está preocupado por el rendimiento u otros efectos secundarios.

Modifiqué su ejemplo para contener 2 asignaciones idénticas. Ahora es fácil ver que malloc no pone cero la memoria de inicialización.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    {
      double *a = malloc(sizeof(double)*100);
      *a = 100;
      printf("%f\n", *a);
      free(a);
    }
    {
      double *a = malloc(sizeof(double)*100);
      printf("%f\n", *a);
      free(a);
    }

    return 0;
}

Salida con gcc 4.3.4

100.000000
100.000000

El estándar no dicta que malloc() debe inicializar los valores a cero. Simplemente sucede en su plataforma que podría estar establecido en cero, o podría haber sido cero en el momento específico que lee ese valor.

Su código no demuestra que malloc inicializa su memoria a 0. Eso podría ser hecho por el sistema operativo, antes de que se inicie el programa. Para ver que shich es el caso, escribe un valor diferente a la memoria, libérala, y llama a malloc de nuevo. Probablemente obtendrá la misma dirección, pero tendrá que verificar esto. Si es así, puede mirar para ver lo que contiene. Háganoslo saber!

De gnu.org:

Los bloques muy grandes (mucho más grandes que una página) se asignan con mmap (anónimo o a través de /dev/zero) por esta implementación.

¿Sabes que definitivamente se está inicializando? ¿Es posible que el área devuelta por malloc() tenga con frecuencia 0 al principio?

Nunca nunca cuente con cualquier compilador para generar código que inicialice la memoria a cualquier cosa. malloc simplemente devuelve un puntero a n bytes de memoria en algún lugar infierno que incluso podría estar en intercambio.

Si el contenido de la memoria es crítico, inicialícelo usted mismo.