programacion - Fugas de memoria en el programa GTK hello_world

recoleccion de basura en programacion

Question

Entonces ... Estoy tratando de eliminar algunas pérdidas de memoria de mi programa GTK + 3. Pensé que sería una buena idea echar un vistazo a algunos ejemplos simples para ver si hay algo de limpieza que estoy olvidando, pero el programa hello_world provisto en la documentación también tiene filtraciones. (Salida Valgrind a continuación).

¿Son estas fugas aceptables? Si es así, ¿hay alguna otra aplicación que debería usar para depurar programas GTK?

==13717== Memcheck, a memory error detector
==13717== Copyright (C) 2002-2012, and GNU GPL''d, by Julian Seward et al.
==13717== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==13717== Command: ./a
==13717==
Hello World
==13717==
==13717== HEAP SUMMARY:
==13717== in use at exit: 1,578,162 bytes in 11,614 blocks
==13717== total heap usage: 45,699 allocs, 34,085 frees, 6,461,970 bytes allocated
==13717==
==13717== LEAK SUMMARY:
==13717== definitely lost: 2,560 bytes in 5 blocks
==13717== indirectly lost: 6,656 bytes in 207 blocks
==13717== possibly lost: 363,228 bytes in 1,937 blocks
==13717== still reachable: 1,205,718 bytes in 9,465 blocks
==13717== suppressed: 0 bytes in 0 blocks
==13717== Rerun with --leak-check=full to see details of leaked memory
==13717==
==13717== For counts of detected and suppressed errors, rerun with: -v
==13717== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)

Código:

#include <gtk/gtk.h>
/* This is a callback function. The data arguments are ignored
* in this example. More on callbacks below.
*/
static void
print_hello (GtkWidget *widget,
gpointer data)
{
g_print ("Hello World/n");
}
static gboolean
on_delete_event (GtkWidget *widget,
GdkEvent *event,
gpointer data)
{
/* If you return FALSE in the "delete_event" signal handler,
* GTK will emit the "destroy" signal. Returning TRUE means
* you don''t want the window to be destroyed.
*
* This is useful for popping up ''are you sure you want to quit?''
* type dialogs.
*/
g_print ("delete event occurred/n");
return TRUE;
}
int
main (int argc,
char *argv[])
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *button;
/* This is called in all GTK applications. Arguments are parsed
* from the command line and are returned to the application.
*/
gtk_init (&argc, &argv);
/* create a new window, and set its title */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Hello");
/* When the window emits the "delete-event" signal (which is emitted
* by GTK+ in response to an event coming from the window manager,
* usually as a result of clicking the "close" window control), we
* ask it to call the on_delete_event() function as defined above.
*
* The data passed to the callback function is NULL and is ignored
* in the callback function.
*/
g_signal_connect (window, "delete-event", G_CALLBACK (on_delete_event), NULL);
/* Here we connect the "destroy" event to the gtk_main_quit() function.
*
* This signal is emitted when we call gtk_widget_destroy() on the window,
* or if we return FALSE in the "delete_event" callback.
*/
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* Creates a new button with the label "Hello World". */
button = gtk_button_new_with_label ("Hello World");
/* When the button receives the "clicked" signal, it will call the
* function print_hello() passing it NULL as its argument.
*
* The print_hello() function is defined above.
*/
g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
/* The g_signal_connect_swapped() function will connect the "clicked" signal
* of the button to the gtk_widget_destroy() function; instead of calling it
* using the button as its argument, it will swap it with the user data
* argument. This will cause the window to be destroyed by calling
* gtk_widget_destroy() on the window.
*/
g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
/* This packs the button into the window. A GtkWindow inherits from GtkBin,
* which is a special container that can only have one child
*/
gtk_container_add (GTK_CONTAINER (window), button);
/* The final step is to display this newly created widget... */
gtk_widget_show (button);
/* ... and the window */
gtk_widget_show (window);
/* All GTK applications must have a gtk_main(). Control ends here
* and waits for an event to occur (like a key press or a mouse event),
* until gtk_main_quit() is called.
*/
gtk_main ();
return 0;
}

Answer 1

Para depurar programas glib / gtk usaría este comando:

G_SLICE=debug-blocks valgrind --tool=memcheck --leak-check=full <gtk program>

G_SLICE = debug-blocks desactivará la gestión de memoria avanzada de gtk para permitir que valgrind muestre los resultados correctos.

--leak-check = full mostrará trazados de pila para los bloques de memoria filtrados.

También puede usar --show-alcanzatable = yes para ver los seguimientos de la pila de todos los bloques de memoria que no han estado libres cuando el programa sale.

También existe la herramienta valgrind macizo que rastrea el uso de la memoria para mostrar qué partes del programa están usando la mayor cantidad de memoria.

Ejecutar programa bajo macizo:

G_SLICE=always-malloc valgrind --tool=massif --detailed-freq=2 --max-snapshots=400 --num-callers=20 <gtk program>

Mostrar resultados:

ms_print massif.out.<pid>

Answer 2

Esta respuesta se compila a partir de las respuestas a la misma pregunta en www.gtkfourms.com.

http://www.gtkforums.com/viewtopic.php?f=3&t=178517 (usuario errol)

GTK + es bastante flojo cuando se trata de asignar y desasignar los búferes internos necesarios durante el tiempo de vida de la aplicación. Por ejemplo, puede asignar un área de memoria para una tabla de búsqueda durante la inicialización, que es necesaria para la vida de la aplicación. GTK + nunca desasignará esto. Para Valgrind, esto parece una pérdida de memoria (que técnicamente es) pero, como optimización, GTK + no lo desasigna ya que se desasignará durante la salida de la aplicación y, por lo tanto, no será un error. Es por eso que necesita archivos de supresión para que Valgrind pueda ignorarlos. El problema es que tendrá que cambiar estos con la mayoría de los cambios de la versión GTK +.

Repositorio de archivos de supresión: https://github.com/dtrebbien/GNOME.supp

Después de clonar el repositorio, puede generar los archivos de supresión (también viene con glib, gdk y otros) con "make" y luego referir valgrind a ellos de la siguiente manera:

valgrind ./a --suppression=/path/to/gtk3.supp