Memory leak I can't identify using Bitmap and Graphics classes

Question

I have some parallel.for one inside another.

the last parallel.for have a normal for that should Create images by combining other images.

the images are generated but the memory consumed by the process slowly increases.

I'm using net core 6, and as you can see I have dispatched all the Bitmaps and the Graphics objects.

also I'm forcing garbage collection so the memory stop growing (I ran the code for 4 hours without forcing collection and the dispatched objects were not collected)

here is the code:

using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;

Console.WriteLine("Generando!");

var count = 0;

Parallel.For(1, 11, (a) =>
{
    Parallel.For(1, 11, (b) =>
    {
        Parallel.For(1, 11, (c) =>
        {
            Parallel.For(1, 11, (d) =>
            {
                Parallel.For(1, 11, (e) =>
                {
                    for (int f = 1; f <= 10; f++)
                    {
                        Bitmap source1 = new Bitmap($"1/{a}.png");
                        Bitmap source2 = new Bitmap($"2/{b}.png");
                        Bitmap source3 = new Bitmap($"3/{c}.png");
                        Bitmap source4 = new Bitmap($"4/{d}.png");
                        Bitmap source5 = new Bitmap($"5/{e}.png");

                        Bitmap sourceBase = new Bitmap($"Rostro Base.png");
                        Bitmap source6 = new Bitmap($"6/{f}.png");
                        var target = new Bitmap(source1.Width, source1.Height, PixelFormat.Format32bppArgb);
                        var graphics = Graphics.FromImage(target);
                        graphics.CompositingMode = CompositingMode.SourceOver; // this is the default, but just to be clear
                        graphics.DrawImage(sourceBase, 0, 0);
                        graphics.DrawImage(source6, 0, 0);
                        graphics.DrawImage(source5, 0, 0);
                        graphics.DrawImage(source4, 0, 0);
                        graphics.DrawImage(source3, 0, 0);
                        graphics.DrawImage(source2, 0, 0);
                        graphics.DrawImage(source1, 0, 0);

                        count++;
                        var nombre = $"{count}_{a}-{b}-{c}-{d}-{e}-{f}";
                        var target2 = Cropimage(target);
                        target2.Save($"rostros/{nombre}.png", ImageFormat.Png);

                        source1.Dispose();
                        source2.Dispose();
                        source3.Dispose();
                        source4.Dispose();
                        source5.Dispose();
                        source6.Dispose();

                        sourceBase.Dispose();
                        target.Dispose();
                        target2.Dispose();
                        graphics.Dispose();

                        GC.Collect();
                    }
                });
                Console.Write($"\r{count} imagenes generadas                ");
            });
        });
    });
});

Bitmap Cropimage(Bitmap input)
{
    // Find the min/max non-white/transparent pixels
    Point min = new Point(int.MaxValue, int.MaxValue);
    Point max = new Point(int.MinValue, int.MinValue);

    for (int x = 0; x < input.Width; ++x)
    {
        for (int y = 0; y < input.Height; ++y)
        {
            Color pixelColor = input.GetPixel(x, y);
            if (pixelColor.A > 0)
            {
                if (x < min.X) min.X = x;
                if (y < min.Y) min.Y = y;

                if (x > max.X) max.X = x;
                if (y > max.Y) max.Y = y;
            }
        }
    }

    // Create a new bitmap from the crop rectangle
    Rectangle cropRectangle = new Rectangle(min.X, min.Y, max.X - min.X, max.Y - min.Y);

    Bitmap newBitmap = new Bitmap(cropRectangle.Width, cropRectangle.Height);
    using (Graphics g = Graphics.FromImage(newBitmap))
    {
        g.DrawImage(input, 0, 0, cropRectangle, GraphicsUnit.Pixel);
    }

    return newBitmap;

} 

Answer 1

Just few tips

• Prefer using over manual calling Dispose().
• Consumed memory isn't always busy memory, GC can free the memory anytime it want. That is OK, trust GC. Just assume that there's no leaks in managed code possible unless you manually allocated unmanaged memory.
• manual calling GC.Collect() is almost never effective but makes the app slower. The above code isn't an exception
• NEVER use GetPixel/SetPixel if you don't want to die before the app ends working, it's superslow way to deal with Bitmap
• count is shared counter, increment it thread-safely.
• No need to read the same image from disk for each Thread, lock here is more efficient.

int count = 0;
using Bitmap sourceBase = new Bitmap($"Rostro Base.png");
Parallel.For(1, 11, (a) =>
{
    using Bitmap source1 = new Bitmap($"1/{a}.png");
    Parallel.For(1, 11, (b) =>
    {
        using Bitmap source2 = new Bitmap($"2/{b}.png");
        Parallel.For(1, 11, (c) =>
        {
            using Bitmap source3 = new Bitmap($"3/{c}.png");
            Parallel.For(1, 11, (d) =>
            {
                using Bitmap source4 = new Bitmap($"4/{d}.png");
                Parallel.For(1, 11, (e) =>
                {
                    using Bitmap source5 = new Bitmap($"5/{e}.png");

                    for (int f = 1; f <= 10; f++)
                    {
                        using Bitmap source6 = new Bitmap($"6/{f}.png");
                        using Bitmap target = new Bitmap(source1.Width, source1.Height, PixelFormat.Format32bppArgb);
                        using Graphics graphics = Graphics.FromImage(target);
                        graphics.CompositingMode = CompositingMode.SourceOver; // this is the default, but just to be clear
                        lock(sourceBase) graphics.DrawImage(sourceBase, 0, 0);
                        graphics.DrawImage(source6, 0, 0);
                        graphics.DrawImage(source5, 0, 0);
                        lock(source4) graphics.DrawImage(source4, 0, 0);
                        lock(source3) graphics.DrawImage(source3, 0, 0);
                        lock(source2) graphics.DrawImage(source2, 0, 0);
                        lock(source1) graphics.DrawImage(source1, 0, 0);

                        int localCount = Interlocked.Increment(ref count);
                        string nombre = $"{localCount}_{a}-{b}-{c}-{d}-{e}-{f}";
                        using Bitmap target2 = Cropimage(target);
                        target2.Save($"rostros/{nombre}.png", ImageFormat.Png);
                    }
                });
                Console.Write($"\r{count} imagenes generadas                ");
            });
        });
    });
});

    
Bitmap Cropimage(Bitmap input)
{
    // Find the min/max non-white/transparent pixels
    Point min = new Point(int.MaxValue, int.MaxValue);
    Point max = new Point(int.MinValue, int.MinValue);

    // Retreiving bitmap data to array
    BitmapData data = input.LockBits(new Rectangle(Point.Empty, input.Size), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
    byte[] bytes = new byte[input.Height * input.Width * 4]; // 32bpp
    Marshal.Copy(data.Scan0, bytes, 0, input.Height * data.Stride); // Stride can be negative in some bitmaps but Marshal supports that.
                                                                    // In short: (Math.Abs(data.Stride) == input.Width * 4) for 32bpp is always 'true'.
    input.UnlockBits(data);

    // bytes array contains sequence of 4-byte pixels like B G R A B G R A
    for (int y = 0; y < input.Height; ++y)
    {
        int rowOffset = y * input.Width * 4;
        for (int x = 0; x < input.Width; ++x)
        {
            int colOffset = x * 4;
            if (bytes[rowOffset + colOffset + 3] > 0)
            {
                if (x < min.X) min.X = x;
                if (y < min.Y) min.Y = y;

                if (x > max.X) max.X = x;
                if (y > max.Y) max.Y = y;
            }
        }
    }

    // Create a new bitmap from the crop rectangle
    Rectangle cropRectangle = new Rectangle(min.X, min.Y, max.X - min.X, max.Y - min.Y);

    Bitmap newBitmap = new Bitmap(cropRectangle.Width, cropRectangle.Height);
    using Graphics g = Graphics.FromImage(newBitmap);
    g.DrawImage(input, 0, 0, cropRectangle, GraphicsUnit.Pixel);

    return newBitmap;
}

This might work ~100x times faster than the initial code.

It also may work without locks but I'm not sure if DrawImage uses LockBits internally and didn't try accessing single Bitmap from multiple threads. But you may try. Anyway there will be no any sensitive difference in performance. Reading same images thousands times from disk is significantly slower in comparison to reading it from memory even locked for single-threaded access.