Cairo.Surface is leaking... How to debug it with Monodevelop?

Question

I have many doubts related with Cairo and GTK# (that runs on .NET and Mono). I'm developing a GTK# application for MS Windows and Linux. I'm using GTK# 2.12 over .NET right now while I'm working on the application.

I've created a custom widget that uses Cairo.ImageSurface and Cairo.Context objects. As far as I know, I'm calling the Dispose method of every ImageSurface object and every Context object I create inside the widget code.

The widget responds to the "MouseOver" event, redrawing some parts of its DrawingArea.

The (first) problem: almost every redrawing operation increases a little bit the amount of used memory. When the amount of used memory has increased 3 or 4 Kbytes the Monodevelop tracelog panel shows me the following message:

Cairo.Surface is leaking, programmer is missing a call to Dispose Set MONO_CAIRO_DEBUG_DISPOSE to track allocation traces

The code that redraws a part of the widget is something like:

// SRGB is a custom struct, not from Gdk nor Cairo
void paintSingleBlock(SRGB color, int i)
{
    using (Cairo.Context g = CairoHelper.Create (GdkWindow)) {
        paintSingleBlock (g, color, i);

        // We do this to avoid memory leaks. Cairo does not work well with the GC.
        g.GetTarget().Dispose ();
        g.Dispose ();
    }
}

void paintSingleBlock(Cairo.Context g, SRGB color, int i)
{
    var scale = Math.Pow (10.0, TimeScale);

    g.Save();
    g.Rectangle (x(i), y(i), w(i), h(i));
    g.ClosePath ();
    g.Restore ();

    // We don't directly use stb.Color because in some cases we need more flexibility
    g.SetSourceRGB (color.R, color.G, color.B);
    g.LineWidth = 0;
    g.Fill ();
}

The (second) problem: Ok, Monodevelop tells me that I should set MONO_CAIRO_DEBUG_DISPOSE to "track allocation traces" (In order to find the leak, I suppose)... but I don't know how to set this environment variable (I'm in Windows). I've tried using bash and executing something like:

MONO_CAIRO_DEBUG_DISPOSE=1 ./LightCreator.exe

But nothing appears in stderr nor stdout... (neither the messages that appear in the Monodevelop's applicationt trace panel). I also don't know how to get the debugging messages that see inside Monodevelop but without Monodevelop.

There's anyone with experience debugging GTK# or Cairo# memory leaks?

Thanks in advance.

Answer 1

Just wanted to throw my 2c here as I was fighting a similar leak problem in Cairo with surfaces. What I noticed is that if I create a Surface object the ReferenceCount property becomes 1 and if I attach this surface to a Context if becomes not 2 but 3. After disposing the Context the ReferenceCount comes back but to 2.

So I used some reflection to call the native methods in Cairo to decrease the ReferenceCount when I really want to Dispose a surface. I use this code:

public static void HardDisposeSurface (this Surface surface)
{
    var handle = surface.Handle;
    long refCount = surface.ReferenceCount;
    surface.Dispose ();
    refCount--;
    if (refCount <= 0)
        return;

    var asm = typeof (Surface).Assembly;
    var nativeMethods = asm.GetType ("Cairo.NativeMethods");
    var surfaceDestroy = nativeMethods.GetMethod ("cairo_surface_destroy", BindingFlags.Static | BindingFlags.NonPublic);
    for (long i = refCount; i > 0; i--)
        surfaceDestroy.Invoke (null, new object [] { handle });
}

After using it I still have some leaks, but they seem to be related to other parts of Cairo and not with the surfaces.

Answer 2

I have found that a context created with CairoHelper.Create() will have a reference count of two.

A call to dispose reduces the reference count by one. Thus the context is never freed and keeps its target alive, too.

The native objects have manual reference counting, but the Gtk# wrappers want to keep a native object alive as long as there is a C# instance referencing it.

If a native object is created for a C# wrapper instance it does not need to increment the reference count because the wrapper instance 'owns' the native object and the reference count has the correct value of one. But if a wrapper instance is created for an already existing native object the reference count of the native object needs to be manually incremented to keep the object alive.

This is decided by a bool parameter when a wrapper instance is created.

Looking at the code for CairoHelper.Create() will show something like this

public static Cairo.Context Create(Gdk.Window window) {
            IntPtr raw_ret = gdk_cairo_create(window == null ? IntPtr.Zero : window.Handle);
            Cairo.Context ret = new Cairo.Context (raw_ret, false);
            return ret;
        }

Even though the native context was just created 'owned' will be false and the C# context will increment the reference count.

There is no fixed version right now, it can only be corrected by fixing the source and building Gtk# yourself.

CairoHelper is an auto-generated file, to change the parameter to true this attribute must be included in gdk/Gdk.metadata.

<attr path="/api/namespace/class[@cname='GdkCairo_']/method[@name='Create']/return-type" name="owned">true</attr>

Everything to build Gtk# can be found here. https://github.com/mono/gtk-sharp