Medir de forma precisa el crecimiento del montículo
Estoy intentando medir la evolución del número de objetos asignados en el montón antes y después de llamar a una función. Estoy forzando runtime.GC() y usando runtime.ReadMemStats para medir el número de objetos asignados en el montón que tengo antes y después.
El problema que tengo es que a veces veo un crecimiento inesperado del montón. Y es diferente después de cada ejecución.
A continuación, un ejemplo simple donde siempre esperaría ver un crecimiento de cero objetos asignados en el montón.
https://go.dev/play/p/FBWfXQHClaG
var mem1_before, mem2_before, mem1_after, mem2_after runtime.MemStats
func measure_nothing(before, after *runtime.MemStats) {
runtime.GC()
runtime.ReadMemStats(before)
runtime.GC()
runtime.ReadMemStats(after)
}
func main() {
measure_nothing(&mem1_before, &mem1_after)
measure_nothing(&mem2_before, &mem2_after)
log.Printf("Diferencia de objetos asignados en el montón = %d", int64(mem1_after.HeapObjects-mem1_before.HeapObjects))
log.Printf("Diferencia de heapAlloc = %d", int64(mem1_after.HeapAlloc-mem1_before.HeapAlloc))
log.Printf("Diferencia de objetos asignados en el montón = %d", int64(mem2_after.HeapObjects-mem2_before.HeapObjects))
log.Printf("Diferencia de heapAlloc = %d", int64(mem2_after.HeapAlloc-mem2_before.HeapAlloc))
}
Salida de ejemplo:
2009/11/10 23:00:00 Diferencia de objetos asignados en el montón = 0
2009/11/10 23:00:00 Diferencia de heapAlloc = 0
2009/11/10 23:00:00 Diferencia de objetos asignados en el montón = 4
2009/11/10 23:00:00 Diferencia de heapAlloc = 1864
¿Es práctico lo que estoy intentando hacer? Supongo que el tiempo de ejecución está realizando acciones que asignan / liberan memoria en el montón. ¿Puedo indicarle que se detenga para hacer mis mediciones? (esto es para una prueba que busca fugas de memoria, no es código de producción)
davy.ai
No es raro ver un crecimiento inesperado del montón al medir la evolución de los objetos asignados al montón antes y después de llamar a una función. Esto se debe a que el tiempo de ejecución de Go está constantemente realizando acciones que asignan o liberan memoria en el montón, como la recolección de basura, el barrido en segundo plano o la asignación de memoria para estructuras de datos internas. Estas operaciones pueden hacer que el número de objetos asignados al montón fluctúe, lo que a veces resulta en un crecimiento inesperado.
En el ejemplo proporcionado, la salida muestra que no hay crecimiento en los objetos asignados al montón para la primera llamada a
measure_nothing, pero se asignan cuatro objetos nuevos para la segunda llamada. Se llama a la funciónruntime.GC()antes y después de medir las estadísticas de memoria para forzar la recolección de basura, pero los resultados aún no son consistentes.Para mitigar esto, es posible controlar manualmente algunas de las operaciones de tiempo de ejecución que asignan memoria. Una forma de hacer esto es utilizar la función
debug.SetGCPercent()para establecer el porcentaje de montón que desencadena la recolección de basura. Establecer un valor alto significa que la recolección de basura será menos frecuente, lo que puede reducir la asignación en segundo plano de nueva memoria. Sin embargo, esto puede afectar el rendimiento del programa y es importante restablecer el porcentaje de recolección de basura después de que se haya completado la prueba.Otro enfoque es ejecutar el programa con la variable de entorno
GODEBUGestablecida en"gcstoptheworld=1"o"gctrace=1". Estas configuraciones pueden pausar el mundo durante la recolección de basura, lo que proporciona mediciones de memoria más estables. Sin embargo, esto solo debe usarse con fines de prueba y no en código de producción, ya que puede afectar significativamente el rendimiento.En general, medir la evolución de los objetos asignados al montón de una manera que proporcione resultados precisos y consistentes puede ser un desafío, pero se puede lograr con un control cuidadoso del entorno y las configuraciones de tiempo de ejecución.