🙏🏼 Memory leak in custom control drawing with WriteableBitmap

[d2phap]

Hi, I created a simple custom control called DrawingPanel contains a WriteableBitmap _bmp and encountered a memory leak issue with Avalonia v11.2.5

This is the full source code and test image files: Test_Memory_Leak.zip
contains 2 image files:

• 512.png - 512 x 512 px
• 12k.jpg - 12000 x 12000 px

The DrawingPanel contorl:

public class DrawingPanel : Control
{
    private WriteableBitmap? _bmp;

    public override void Render(DrawingContext c)
    {
        base.Render(c);
        if (_bmp == null) return;

        using (c.PushRenderOptions(new() { BitmapInterpolationMode = BitmapInterpolationMode.None }))
        {
            c.DrawImage(_bmp, new Avalonia.Rect(_bmp.Size), TopLevel.GetTopLevel(this).Bounds);
        }
    }

    public void LoadImage(string path)
    {
        _bmp?.Dispose();
        _bmp = null;

        using var fs = File.OpenRead(path);
        _bmp = WriteableBitmap.Decode(fs);

        InvalidateVisual();

        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
    }
}

Here are steps to reproduce:

1. Open 512.png file => memory is about 122MB

2. Open 12k.jpg file => memory is about 1.8 GB

3. Maximize the window and restore it to original size => memory is about 2.3 GB

4. Open 512.png file again => memory remains 1.2 GB forever!

5. If I repeat these steps, memory will keep increasing.

What should I do to resolve this memory leak?
Thanks for help!

Edit: Added videos

After some tests, I notice when I comment out the c.DrawImage() function, the issue does not happen.

// c.DrawImage(_bmp, new Avalonia.Rect(_bmp.Size), TopLevel.GetTopLevel(this).Bounds);

So I suspect the bitmap data was copied to GPU and still alive when the reference WriteableBitmap is disposed.

Memory leak with .DrawBitmap()

memory_leak_drawBitmap.mp4

No memory leak after commenting out the .DrawBitmap()

no_memory_leak.mp4

[LaurentInSeattle]

Hi,

I downloaded and ran your test project on my Windows 10 (fully patched) machine, compiled with VS2022 latest.

I swapped images, maximized, resized, etc.
=> No code change and no memory leaks.

Weird!

[d2phap]

Just tried, it remains the same!

If I use Software rendering mode, the issue is gone. I think it's because the bitmap data is not uploaded to GPU.

[LaurentInSeattle]

Then maybe a driver update could fix the issue ?

[d2phap]

It's not the case also, my NVIDIA GeForce driver is up to date.

[d2phap]

Test on MacOS, it has the same issue, so it's not about driver

[LaurentInSeattle]

Please do not forgot to post your findings if you figure out the issue or find a workaround. Thank you! (I also have an app that manages images)

Maybe one last thing to try: Run the test app in the memory profiler, it should at least tell you if the leak is native or managed.
HTH

[thevortexcloud]

Avalonia keeps bitmaps uncompressed in memory. There has been discussion in the past about this:

#14304

In addition, I did my own testing awhile back and found resizing bitmaps on the fly results in very high memory usage:

#13605

[d2phap]

Avalonia keeps bitmaps uncompressed in memory. There has been discussion in the past about this:
#14304

Probably this is the issue. I updated my post with 2 videos for my new tests. The memory leak happened when calling DrawImage(). When I comment out the line of c.DrawImage() function, it did not happen anymore.

So I suspect the bitmap data on GPU is still alive when the reference WriteableBitmap variable is disposed.

In addition, I did my own testing awhile back and found resizing bitmaps on the fly results in very high memory usage: #13605

I'm aware of this when resizing the window, the memory jumped up. But at least it went back to normal after a while. I think GC did its job.

[Gillibald]

Skia is caching bitmap data. The cache is filled up to its limit. The cache is only perged when it hits the limit.

Just because you are no longer referencing the bitmap doesn't mean anyone else is holding a reference.

Bitmaps are ref counted.

On top of all of this comes the fact that SkiaSharp isn't adding any memory pressure for the native bitmap data. So GC isn't cleaning everything up in time.

[d2phap]

Hi @Gillibald, thank you for your reply.

In another test, if I load another image file (26000 x 20000 pixels), the memory will keep increasing even more, in the below video, it's 3.1 GB. Imagine that when users browse more images from the gallery, Skia is still holding the previous bitmap data, this will soon fill up RAM and crash the app (it happened in my actual control).

Is there an efficient way to make sure the bitmap memory is completely released, or clear Skia cache before drawing a new image into the control?

memory_leak_load_more_images.mp4

[kekekeks]

Skia cache is quite limited (28 MB by default), it's likely your GPU driver reserving some memory for you based on your previous usage.

Another thing that can be holding bitmaps is Avalonia's Compositor, but it should automatically release those once no onscreen visual is referencing them, it's also not likely to be the case since your issue is gone with SW rendering.

Please, follow the "resize before rendering" advice. You can offload image resize to a thread pool to resize your images in parallel if you are concerned about resize speed.

[timunie]

Let's continue this thread please

#18524 (comment)

Hi @timunie, thanks for your reply. I'm working on porting the image viewer component from Direct2D to Avalonia in my app: https://github.com/d2phap/ImageGlass.

Using the Bitmap.DecodeToWidth() does not help in this case because once the bitmap is copied to GPU (via DrawingContext.DrawImage() or even when setting Image.Source), it remains in GPU memory until the app is closed. Calling Bitmap.Dispose() frees the managed memory but does not release the native memory. The only way to prevent this issue is to set RenderingMode = [Win32RenderingMode.Software] which means sacrificing hardware acceleration.

This inconvenience makes Avalonia less efficient for developing photo viewing or editing apps where users often switch to view different image files.

Unfortunately, I have never used Skia before. Do you have any hint for me to look into Skia instance in Avalonia? I will try if I can fix by myself.

Thank you!

#18524 (comment)

https://learn.microsoft.com/en-us/dotnet/api/skiasharp.skgraphics.purgeresourcecache?view=skiasharp-2.88#skiasharp-skgraphics-purgeresourcecache

I don't know if Skia3 can be helpful here? I think there is somewhere a thread about how to test it with Avalonia.

Off-Topic: Nice App, cool to see you want to port it to Avalonia ❤️ .

[timunie]

You could also try to lease Skia directly and probably do more finegrain rendering.

See: https://github.com/AvaloniaUI/Avalonia.Samples/tree/main/src%2FAvalonia.Samples%2FCustomControls%2FSnowflakesControlSample

[d2phap]

Thanks @timunie, @kekekeks. I followed the sample and used ICustomDrawOperation. It seems the problem is not from Skia(?).

• I queried for resource cache limit (= 32 MB) and cache used (= 0 byte), the numbers look normal to me.
• Calling SKGraphics.PurgeResourceCache() or SKGraphics.PurgeAllCaches() does not help. I guess because the cache used is 0 byte.

Another discovery, when I change the Window graphics setting for the app from "Power Saving (Intel Iris Xe)" to "High Performance (NVIDIA Geforce)", the memory is reduced (from 1.3GB down to 950MB), but it's not totally freed.

Probably I will continue this investigation in another time. Here is my custom drawing implementation:

public class DrawingPanel : Control
{
    private SKBitmap? _bitmap;
    private CustomDrawOp? _customDrawing;

    public void LoadImage(string path)
    {
        var cacheLimit = SKGraphics.GetResourceCacheTotalByteLimit(); // => 33554432 bytes = 32 MB
        var cacheUsed = SKGraphics.GetResourceCacheTotalBytesUsed(); // => 0

        _bitmap?.Dispose();
        _bitmap = null;
        _customDrawing?.Dispose();
        _customDrawing = null;

        _bitmap = SKBitmap.Decode(path);
        var bounds = TopLevel.GetTopLevel(this)!.Bounds;
        _customDrawing = new CustomDrawOp(_bitmap, bounds);

        InvalidateVisual();

        //SKGraphics.PurgeResourceCache();
        //SKGraphics.PurgeAllCaches();

        GC.Collect();
    }

    public override void Render(DrawingContext c)
    {
        base.Render(c);
        if (_customDrawing == null) return;

        _customDrawing.Bounds = TopLevel.GetTopLevel(this)!.Bounds;
        c.Custom(_customDrawing);
    }
}

class CustomDrawOp : ICustomDrawOperation
{
    public void Dispose() { }
    public Rect Bounds { get; set; }
    public bool HitTest(Point p) => true;
    public bool Equals(ICustomDrawOperation? other) => false;
    public SKBitmap _bitmap;

    public CustomDrawOp(SKBitmap bitmap, Rect bounds)
    {
        Bounds = bounds;
        _bitmap = bitmap;
    }

    public void Render(ImmediateDrawingContext c)
    {
        var leaseFeature = c.TryGetFeature<ISkiaSharpApiLeaseFeature>();
        if (leaseFeature == null) return;
        if (_bitmap == null) return;

        using var lease = leaseFeature.Lease();
        var canvas = lease.SkCanvas;
        canvas.Save();

        canvas.DrawBitmap(_bitmap,
            new SKRect(0, 0, _bitmap.Width, _bitmap.Height),
            new SKRect((int)Bounds.X, (int)Bounds.Y, (int)Bounds.Width, (int)Bounds.Height));

        canvas.Restore();
    }
}