C# Using SharpDX DirectX9 Got Memory Leak Simply Create/Release Device.

Question

C# Using SharpDX DirectX9 Got Memory Leak Simply Create/Release Device.

shy akocat 21

I'm encountering a memory leak when using SharpDX DirectX9.

I have done some simple memory profiler to find out the reason, but the problem is in unmanaged memory, that's hard for me to debug.

I pack a very simple demo to a zip file. https://1drv.ms/u/s!AtJdwfH_KBJjjV3kEpLpilZNME77?e=9l0myS

If the file cannot download, following codes also do.

(Optional) Create a WPF .net framework 4.8/4.8.1 project in Visual Studio.
Using Nuget to install SharpDX , SharpDX.Mathematics and SharpDX.Direct3D9.
Create and edit code in DX.cs

public class DX
{
    int width = 1200;
    int height = 1200;
    Direct3D d3d;
    Device device;

    public DX()
    {
        d3d = new Direct3D();
        device = new Device(
            d3d,
            0,
            DeviceType.Hardware,
            IntPtr.Zero,
            CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded,
            new PresentParameters(width, height, Format.A8R8G8B8, 2, MultisampleType.None, 0, SwapEffect.Discard, IntPtr.Zero, windowed: true, enableAutoDepthStencil: true, Format.D24X8, PresentFlags.None, 0, PresentInterval.Immediate));
    }

    ~DX()
    {
        device?.Dispose();
        d3d?.Dispose();
    }
}

Test memory leak of class DX.
(Optional) Add a Button and a TextBlock in MainWindow.xaml to observe. Add Click event to button. The TextBlock is not necessary, other way to inspect memory usage also do.

private void Button_Click(object sender, RoutedEventArgs e)
{
    long memBegin, memEnd;
    memBegin = Process.GetCurrentProcess().PrivateMemorySize64;
    DX9Test();
    GC.Collect();
    GC.WaitForPendingFinalizers();
    GC.Collect();
    memEnd = Process.GetCurrentProcess().PrivateMemorySize64;
    txt.Text += $"\nmemBegin = {memBegin:n0} B, memEnd = {memEnd:n0} B";
}

public void DX9Test()
{
    var dx9 = new DX();
}

The memory usage is increasing when it create and dispose dx9 device (not every time but overall). Why? It seems I have already dispose the device and d3d in order.

Hui Liu-MSFT 48,676 Reputation points Microsoft External Staff

2023-08-28T08:28:18.7366667+00:00
Hi,@shy akocat. Welcome Microsoft Q&A. Memory leaks can occur in managed languages like C# when there are objects that are not being properly garbage collected even though you've called the Dispose method on them.

Here are a few points to consider in order to address potential memory leaks:

Avoid Finalizers: In your class DX, you have defined a finalizer (~DX()) to release the resources. However, relying on finalizers for timely resource release can be problematic. Finalizers are not guaranteed to run immediately, and this can lead to resource leaks. Instead of relying on finalizers, you should implement the IDisposable pattern.

Implement IDisposable: Implement the IDisposable interface for your DX class and ensure you manually release the resources when you're done with them. This allows you to control when resources are released without relying on finalizers. Here's an example of how you might implement it:

public class DX : IDisposable { // ... your existing code ... public void Dispose() { device?.Dispose(); d3d?.Dispose(); } }

Use using Statement: When working with objects that implement IDisposable, it's a good practice to use the using statement to ensure that resources are properly released when you're done using them. This applies to objects that hold unmanaged resources, like DirectX objects.

private void Button_Click(object sender, RoutedEventArgs e) { long memBegin, memEnd; memBegin = Process.GetCurrentProcess().PrivateMemorySize64; using (var dx9 = new DX()) { DX9Test(); } GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); memEnd = Process.GetCurrentProcess().PrivateMemorySize64; txt.Text += $"\nmemBegin = {memBegin:n0} B, memEnd = {memEnd:n0} B";

By using the using statement, you ensure that the Dispose method of the DX object is called immediately when it goes out of scope. This should help prevent memory leaks caused by the delayed finalization of resources.

1 answer

Your answer

Answer 1

It is probably incorrect to call Dispose from ~DX( ). Maybe you should implement the IDisposable interface according to Visual Studio's suggestions:

public class DX : IDisposable
{
    . . .

    private bool disposedValue;

    protected virtual void Dispose( bool disposing )
    {
        if( !disposedValue )
        {
            if( disposing )
            {
                // TODO: dispose managed state (managed objects)

                device?.Dispose( );
                d3d?.Dispose( );
            }

            // TODO: free unmanaged resources (unmanaged objects) and override finalizer

            // TODO: set large fields to null

            disposedValue = true;
        }
    }

    // TODO: override finalizer only if 'Dispose(bool disposing)' has code to free unmanaged resources
    ~DX( )
    {
        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
        Dispose( disposing: false );
    }

    public void Dispose( )
    {
        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
        Dispose( disposing: true );
        GC.SuppressFinalize( this );
    }
}

Usage:

public void DX9Test( )
{
    using( var dx9 = new DX( ) )
    {

    }
}

The leaks seem to be much smaller. See a similar issue:

https://github.com/sharpdx/SharpDX/issues/982

Probably the real code will not create such multiple objects, or the internal memory will be released after normal usage of objects.

Share via

C# Using SharpDX DirectX9 Got Memory Leak Simply Create/Release Device.

1 answer

Your answer