destroying a class instance doesn't kill instances it owns in vala

Question

I have a subclass of Gtk.Box that contains a GLib.Timer that fires a notification after a given interval. I have method in this class that calls this.destroy() on the Gtk.Box. The timer continues to run and fires the notification even after its parent instance has been destroyed. All instances of this class that have been destroyed exhibit this behaviour and continue to use CPU and memory untill the process is killed.

How do I fix this? How can I kill instances effectively and how do I manually free memory instead of relying on vala's garbage collection.

edit: here's an (embarrassing) mvce

// mvce_deletable
// nine
// 2017.01.11
// valac --pkg gtk+-3.0 --pkg glib-2.0 deletablebox.vala

using Gtk;
using GLib;

class RemovableBox : Gtk.Box {
    private Gtk.Button delete_button;
    private GLib.Timer timer;
    private Gtk.Label label;

    public RemovableBox () {
        delete_button = new Gtk.Button.with_label ("DESTROY");
        delete_button.clicked.connect (()=>{this.destroy();});
        this.add (delete_button);
        label = new Gtk.Label ("0000000");
        this.add (label);
        timer = new GLib.Timer ();
        timer.start ();
        Timeout.add (50, update);
        this.show_all ();
    }

    private bool update () {
        if (timer.elapsed () > 10.0f) {
            stdout.printf("and yet it breathes\n");
        }
        label.set_text ("%f".printf(timer.elapsed()));
        return true;
    }
}

int main ( string [] args ) {
    Gtk.init(ref args);
    var window = new Gtk.Window ();
    window.destroy.connect (Gtk.main_quit);
    var delete_me = new RemovableBox ();
    window.add ( delete_me );
    window.show_all();
    Gtk.main();
    return 0;
}

I added a timer_id the the RemovableBox class but it still doesn't work as desired.

class RemovableBox : Gtk.Box {
    private Gtk.Button delete_button;
    private uint timeout_id;
    private GLib.Timer timer;
    private Gtk.Label label;

    public RemovableBox () {
        delete_button = new Gtk.Button.with_label ("DESTROY");
        delete_button.clicked.connect (()=>{this.destroy();});
        this.add (delete_button);
        label = new Gtk.Label ("0000000");
        this.add (label);
        timer = new GLib.Timer ();
        timer.start ();
        timeout_id = Timeout.add (40, update);
        this.show_all ();
    }

    ~ RemovableBox () {
        Source.remove (timeout_id);
    }

    private bool update () {
        if (timer.elapsed () > 10.0f) {
            stdout.printf("and yet it breathes\n");
        }
        label.set_text ("%f".printf(timer.elapsed()));
        return true;
    }
}

Answer 1

GLib.Timer is a stopwatch that returns the elapsed time. It doesn't generate events, but GLib.Timeout does.

GLib makes use of an event loop. This is the same for GTK+, which uses the same underlying GLib event loop. GLib.Timeout is used to create one kind of event source - a timer that fires after a given interval. When your program creates the event source you are given an identifier for the source. For example:

timer_id = Timeout.add_seconds (1, my_callback_function);

What your program needs to do is store that timer identifier in the object and then when the button click handler is called you can remove the timer as a source of events:

Source.remove (timer_id);

Strictly speaking Vala doesn't have a garbage collection cycle. Other languages will collect references that are no longer used and then remove the resources allocated to them during a clean up cycle. Vala uses reference counting, but it is deterministic. So when an object is no longer used, usually when it goes out of scope, the resources allocated to the object are removed immediately. For normal objects in Vala, rather than compact classes, a destructor is also called when the object is freed. This allows for the resource allocation is initialization (RAII) pattern to be used effectively in Vala.

In general you should not be manually freeing objects, Vala's reference counting is very good. I think it is important to understand GLib's event loop and sources of events to understand what is going on. For a detailed description see GLib's documentation on its main event loop.

Now you have provided a MCVE we can look in detail at how Vala manages memory. If you want to dig deep into what is going on behind the scenes you can use the --ccode switch with valac.

The first line of interest in your program is:

Timeout.add (50, update);

Looking at the C code from valac this line uses the g-timeout-add-full () function:

g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) 50, _removable_box_update_gsource_func, g_object_ref (self), g_object_unref);

The crucial part here is g_object_ref (self). This increases the reference count for the object by one and passes a pointer to the object. This makes a lot of sense, because the update () callback passed in the Vala code makes use of the instance data from the object. Vala is doing the right thing and making sure that the instance data is kept alive while the timer is around. The 'g_object_unref' is called when the source is removed. Here's a modified version of your program putting this understanding in to practise:

// mvce_deletable
// nine
// 2017.01.11
// valac --pkg gtk+-3.0 deletablebox.vala

using Gtk;

class RemovableBox : Gtk.Box {
    private Gtk.Button delete_button;
    private uint timeout_id;
    private GLib.Timer timer;
    private Gtk.Label label;

    public RemovableBox () {
        delete_button = new Gtk.Button.with_label ("DESTROY");
        delete_button.clicked.connect (()=>{this.tidy_up_and_destroy ();});
        this.add (delete_button);
        label = new Gtk.Label ("0000000");
        this.add (label);
        timer = new GLib.Timer ();
        timer.start ();
        timeout_id = Timeout.add (40, update);
        this.show_all ();
    }

    ~ RemovableBox () {
        print ("RemovableBox destructor called\n");
    }

    private bool update () {
        if (timer.elapsed () > 10.0f) {
            stdout.printf("and yet it breathes\n");
        }
        label.set_text ("%f".printf(timer.elapsed()));
        return true;
    }

    private void tidy_up_and_destroy () {
        print ("RemovableBox.tidy_up_and_destroy called\n");
        Source.remove (timeout_id);
        this.destroy ();
    }
}

void main ( string [] args ) {
    Gtk.init(ref args);
    var window = new Gtk.Window ();
    window.window_position = WindowPosition.CENTER;
    window.resize (250,50);
    window.destroy.connect (Gtk.main_quit);
    window.add (new RemovableBox ());
    window.show_all();
    Gtk.main();
}

Previously the program still kept a reference to the RemovableBox object and so was never completely removed. By removing the event source first then calling this.destroy (); it means there are no more references and the object is removed.

There is one other important point here. The lines:

var delete_me = new RemovableBox ();
window.add ( delete_me );

in main () have been changed to:

window.add (new RemovableBox ());

Vala objects exist for the scope of the block they were created in. By assigning the object to delete_me you are keeping a reference to the object for the rest of the main () block. By changing that to be an argument of a method call it is just for the call and so is freed when the button is clicked.

By the way, GLib is automatically included when using valac so there is no need for using GLib; or compiling with --pkg glib-2.0.

Answer 2

You are confusing automatic reference couting with full garbage collection.

There is no garbage collector in GLib, but classes have a reference count instead that is increased when a GObject is used in multiple places and decreased when it is no longer used in those places, until it reaches zero. The object is then freed.

In fact in C code the reference counting is manual:

// Reference count is set to 1 on gobject_new  
gpointer obj = gobject_new (G_SOME_OBJECT, NULL);
// It can be manually increased when the object is stored in multiple places
// Let's increase the ref count to 2 here
gobject_ref (obj);
// Let's decrease it until it reaches 0
gobject_unref (obj);
gobject_unref (obj);
// Here the object is destroyed (but the pointer is still pointing to the previous memory location, e.g. it is a dangling pointer)
// gobject_clear (obj) can be used in situation where the variable is reused
// It still only unrefs the object by 1 though! In addition it will set obj to NULL

Vala adds the auto to reference counting, which makes it "automatic reference counting" (ARC). That is you don't have to worry about the reference count in Vala, it will add the appropriate ref and unref operations for you.

In full garbage collection (like in C#, Java, ...) memory deallocation is not deterministic, the object can be kept alive even if it isn't used anymore. This is done using something called a "managed heap" and a garbage collector is run in the background (i.e. as a GC thread).

Now that we have the background stuff covered to your actual problem:

You have to remove the Gtk.Box from it's parent container and also set any references you might still have in your Vala code to null in order to get the reference count to 0. It will then be unrefed.

There are of course other options, like disabling the timer, etc. You should really add an MVCE to your question for us to be able to give you some design advice on your code.

PS: Reference counting is often considered as a simple method of garbage collection. That's why I write full garbage collection (also called tracing garbage collection) in order to not confuse the two terms. See the Wikipedia article on garbage collection.