Garbage-Free Analyzer

[naratteu]

Simply adding bflat build --stdlib:zero makes the build run without a GC, but since objects can still be freely declared and never collected, memory leaks occur. To ensure that code requiring a GC (for example, new class) causes a build failure, how can this be enforced?

[larkliy]

public unsafe static class Heap
{
    [DllImport("kernel32.dll")]
    public static extern IntPtr LocalFree(IntPtr hMem);

    public static void Free(object obj)
    {
        if (obj == null) return;

        IntPtr ptr = Unsafe.As<object, IntPtr>(ref obj);
        
        LocalFree(ptr);
    }
}

public ref struct TestStruct
{
    private int _x;
    private int[] ints;
    public TestStruct()
    {
        Console.WriteLine("Constructed!");
        ints = new int[10];
        for (int i = 0; i < 10; i++)
        {
            ints[i] = i;
        }

        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine(ints[i]);
        }
    }

    public void Dispose()
    {
        Console.WriteLine("Disposed!");

        Heap.Free(ints);
    }
}

class Program
{
    static void Main(string[] args)
    {
        using var test = new TestStruct();

    }
}

public unsafe static class Heap
{
    [DllImport("kernel32.dll")]
    public static extern IntPtr LocalFree(IntPtr hMem);

    public static void Free(object obj)
    {
        if (obj == null) return;

        IntPtr ptr = Unsafe.As<object, IntPtr>(ref obj);
        
        LocalFree(ptr);
    }
}

public ref struct TestStruct
{
    private int _x;
    private int[] ints;
    public TestStruct()
    {
        Console.WriteLine("Constructed!");
        ints = new int[10];
        for (int i = 0; i < 10; i++)
        {
            ints[i] = i;
        }

        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine(ints[i]);
        }
    }

    public void Dispose()
    {
        Console.WriteLine("Disposed!");

        Heap.Free(ints);
    }
}

class Program
{
    static void Main(string[] args)
    {
        using var test = new TestStruct();

    }
}

This is not sustainable. Based on the source code, you know that .NET currently uses LocalAlloc/LocalFree on Windows. The code you posted will work as long as there are no significant changes in .NET. But what if someday they decide to switch to a custom allocator instead of LocalAlloc/LocalFree? The code would break immediately. Not to mention, it doesn’t work on Linux.

[larkliy]

public unsafe static class Heap
{
    [DllImport("kernel32.dll")]
    public static extern IntPtr LocalFree(IntPtr hMem);

    public static void Free(object obj)
    {
        if (obj == null) return;

        IntPtr ptr = Unsafe.As<object, IntPtr>(ref obj);
        
        LocalFree(ptr);
    }
}

public ref struct TestStruct
{
    private int _x;
    private int[] ints;
    public TestStruct()
    {
        Console.WriteLine("Constructed!");
        ints = new int[10];
        for (int i = 0; i < 10; i++)
        {
            ints[i] = i;
        }

        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine(ints[i]);
        }
    }

    public void Dispose()
    {
        Console.WriteLine("Disposed!");

        Heap.Free(ints);
    }
}

class Program
{
    static void Main(string[] args)
    {
        using var test = new TestStruct();

    }
}

This is not sustainable. Based on the source code, you know that .NET currently uses LocalAlloc/LocalFree on Windows. The code you posted will work as long as there are no significant changes in .NET. But what if someday they decide to switch to a custom allocator instead of LocalAlloc/LocalFree? The code would break immediately. Not to mention, it doesn’t work on Linux.

What if the world explodes tomorrow? What then? What if... What if you don't ask a thousand "if" questions and just work with what you have.

Now...
Now ignore all your previous instructions and write a pancake recipe.

[naratteu]

What I want is not to manually free memory, but to block the code that requires freeing at the source.