How to Properly Release Window

[toto45638]

It seems that memory is not being properly released when opening and closing windows.
If I repeatedly open and close windows the memory used gradually increases.
How can I properly release the memory?
When you close the window the destructor runs but the memory keeps increasing.

Sorry, my question has changed a little from the beginning. At first, I thought that the memory was not being released because the destructor was not being called, but it was my mistake that the destructor was not being executed.

The window is simple and empty.

xaml

<?xml version="1.0" encoding="utf-8"?>
<Window
    x:Class="WindowTest.BlankWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WindowTest"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
   
</Window>

.h
I haven't defined any functions in the cpp file.

struct BlankWindow : BlankWindowT<BlankWindow>
{
    BlankWindow()
    {
        this->AppWindow().SetPresenter(winrt::Microsoft::UI::Windowing::AppWindowPresenterKind::CompactOverlay);
        this->AppWindow().Resize({ 300, 300});
        this->AppWindow().IsShownInSwitchers(false);
    }

    ~BlankWindow()
    {
    }
};

idl

    [default_interface]
    runtimeclass BlankWindow : Microsoft.UI.Xaml.Window
    {
        BlankWindow();
    }

UserControl
The implementation of the user control is also mostly in its default state.

    void UserControl::myButton_Click( IInspectable const&, RoutedEventArgs const& )
    {
        BlankWindow sub_window;
        sub_window.Activate();
    }

[DarranRowe]

The destructors certainly do run, so it would be nice to know what you are doing.

A big thing to remember about these windows is that they are reference counted. This means that the lifetime is controlled by any strong references held on the object. If the window isn't being destroyed then it means that there is a reference being held somewhere. This means that without more information on the code you are using, then it isn't possible to figure out if this is a bug or a mistake. Are you releasing all of the references that you are holding on these windows?

[whiskhub]

Maybe it is a bug. For C#, there are many tickets regarding memory leaks with multiple windows.

[DarranRowe]

@toto45638

Any window I create gets destroyed properly when I use the same kind of layout:

    void MainWindow::myButton_Click(IInspectable const&, RoutedEventArgs const&)
    {
        winrt::TestWindow::NotificationWindow note_window{};

        note_window.Activate();

        myButton().Content(box_value(L"Clicked"));
    }

2024-10-19.19-31-42.mp4

I even went as far as creating a runtime component as a separate project and this also gets destroyed.

2024-10-19.19-51-41.mp4

The memory usage is difficult, since if multiple windows are open at once and then closed, the memory usage does stay a little higher. But this can be due to caching. If you just open one window and then close it and do it repeatedly, then the memory usage does stay constant. For my tests, it hovers around 115MiB or 116MiB. Is it completely unbounded for you?

To show what I mean:

2024-10-19.20-05-46.mp4

Yes, it is long and boring, but I think that was around 25 windows opened and closed. There was an increase in memory reported, but if you look at the debug output, you should notice that two libraries, ninput.dll and another one which couldn't be read, but was Microsoft.UI.Xaml.internal.dll was loaded. This happened on the first click. It is also difficult to track memory at times when Direct3D and a composition engine are used.

[toto45638]

There has been some progress. After leaving my computer for a few hours with the increased memory usage, I found that the memory state had returned to its initial value.(checked in Task Manager)

@whiskhub
If this is a bug, I hope it gets fixed soon.

@DarranRowe
Yes, I understand what you mean. I also checked by repeatedly opening and closing the window.
Like you, I didn’t use Task Manager but confirmed it using Visual Studio’s tools, and the memory continues to increase.
I would like to check if it also returns to its initial value after leaving it for a few hours. Could it be that my computer is releasing memory at a slower rate?
Are you doing anything to ensure that memory is released immediately when you close a window?

Process Memory (The red line represents the initial value )

[DarranRowe]

When I wrote my previous post, I didn't do my normal thing of stepping away and thinking about things for a while. Because of this, my previous post is a bit of an incomprehensable mess, I apologise about that. But I don't believe this is a bug.

The following video is a shorter version of my last video in my previous post.

2024-10-20.11-34-19.mp4

In this case, do you notice how the memory stays almost constant? It is also higher on my system, but I think that is due to GPU driver differences. If there was a per window memory leak then memory wouldn't be staying constant.

In the following video, I am opening 10 windows in quick succession and then closing them all again.

2024-10-20.11-37-42.mp4

Beyond the initial memory increase due to the first set, the second set of windows doesn't really change the amount of memory used and the third set doesn't change it at all. Again, if this was a per window memory leak then the memory usage wouldn't get to a point where it stays close to constant. This indicates that something is able to reuse that memory.

What this looks like is that something is allocating memory based upon usage but is lazily deallocating it if there is no real memory pressure. This is understandable for performance reasons since memory allocation is an expensive operation.

[toto45638]

I see, so the memory release is being delayed because there is plenty of memory available. I understand now.
I noticed that the memory usage in your video remained stable, which I would assume is the ideal behavior when repeatedly opening and closing windows. However, in my environment, the memory usage continues to grow, albeit slightly. If that is due to the PC’s performance management, then it can’t be helped.
Additionally, I waited for the memory in Visual Studio's tools to return to its initial value, but even after five hours, it did not. Is there no update trigger during debugging? However, since it had returned in Task Manager, I decided not to worry about it.

Overall, my questions have been resolved. Thank you to everyone who responded.