GC & OpenGL

As discussed in the previous chapter, GC finalization occurs on the finalizer thread. This poses some problems on OpenGL resource deallocation, since the context used to create the resources is not available in the finalizer thread!

Since OpenGL functions cannot be called in finalizers, a different methodology must be followed. By implementing the disposable pattern, we can use the Dispose() method to deterministaclly destroy OpenGL resources in the main thread. By modifying the finalizer logic we can provide a way to flag resources as 'dead', and destroy them from the main thread. Last, by extending the concept of the OpenGL context, we can be notified of context destruction, to release all related resources.

The following code describes the implementation of the "OpenGL disposable pattern" in OpenTK, but it is easy to adapt this code to any managed OpenGL project:

// The OpenGL disposable pattern
class GLResource : IDisposable
{
    int resource_handle;    // The OpenGL handle to the resource
    GLContext context;      // The context which owns this resource

    public GLResource()
    {
        // Obtain the current OpenGL context, and allocate the resource
        context = GLContext.CurrentContext;
        if (context == null)
            throw new InvalidOperationException(String.Format(
                "No OpenGL context available in thread {0}.",
                System.Threading.Thread.CurrentThread.ManagedThreadId));

        resource_handle = [...];

        context.Destroy += DisposeProxy;
    }

    #region --- Disposable Pattern ---

    private void DisposeProxy(IGLContext sender, EventArgs e)
    {
         context.Destroy -= DisposeProxy;
         Dispose();
    }

    public Dispose()
    {
         Dispose(false);
         GC.SuppressFinalize(this);
    }

    private Dispose(bool manual)
    {
         if (!disposed)
         {
              if (!context.IsCurrent || !manual)
              {
                   GC.KeepAlive(this);
                   context.RegisterForDisposal(this);
              }
              else
              {
                   // Destroy resource_handle through OpenGL
                   disposed = true;
              }
         }
    }

    ~GLResource()
    {
         Dispose(false);
    }

    #endregion
}

In OpenTK, each GLContext class maintains a queue of OpenGL resources that need to be destroyed. Resources are added to this queue through the RegisterForDisposal() call, and they are destroyed through the DisposeResources() method. The whole process is deterministic: it is your responsibility to call DisposeResources at appropriate time intervals (or setup up a timer event to do this for you).

Resource creation takes a small performance hit due to the call to GLContext.CurrentContext, while garbage collect-able OpenGL resources consume slightly more memory (due to the reference to the GLContext). Prefer calling the Dispose() method to destroy resources instead of relying on the GC, as finalizable resources are only collected on a generation 1 or 2 GC sweep.

The current implementation in OpenTK does not take shared contexts into account - this will be taken care of in the near future.