Reduce Memory allocation of an import window

[SirZeeno]

This is a stack trace of an import window I have been working on, and most of the allocation you are seeing is just a stack trace of me executing a function that searches a SQL database for specific data and displays that data.

That data contains a bunch of images and small amounts of data that get displayed as text. my issue is that once the images and text have been loaded into memory to display, it's allocated more the 100mb of memory.

It doesn't matter how small the image is, and where the image gets pulled from, like from the web or from storage itself, it's always allocating that much memory. And that amount of allocation seems excessive when I think about having to do that for thousands of images and text down the line. And it comes even worse than that, when I close the import window, and return to the main window of the program, the allocation stays, and garbage collection isn't removing it either, which is a significant memory leak.

So I am here to ask what could be causing that amount of allocation and how I can reduce it and purge it once I am done with it?

[stevemonaco]

Be mindful that when your images are displayed on screen (ie. backed by IBitmap), they aren't compressed like PNG/JPG so you will see a higher memory footprint. You will likely want to rely on virtualization/caching/thumbnails/paging if you're dealing with hundreds or thousands of images.

You don't purge memory in .NET. That's the job of the GC. 50-100MB is a drop in the bucket on a modern system. No memory pressure on the GC means it's unlikely to wake up and collect. Now if you keep entering/exiting the import, get several GBs of memory footprint, and it's not collecting...that's more indicative of an actual leak. Memory profiling tools in Rider / VS can assist in debugging these sort of issues.

[stevemonaco]

Footprint is higher for .NET techs than a language which requires manual memory management, has no runtime/JIT, uses shared OS dependencies etc. You will have more memory pressure in a 1GB environment that won't be there on a 32GB desktop, so the GC should be more responsive though it's never instant. These premature optimizations are typically not worth doing, especially up-front. Run it on your actual environment and measure if it affects performance. Also be sure to measure on a release build and not a debug build. You can use your IDE's memory profiler to see what types are taking up the most memory. On desktop, I'm around 41MB for a freshly created Avalonia app in Release build.

If the footprint doesn't increase upon relaunching the import, then you probably have it inadvertently referenced (cached), not leaked. Either way, the major selling point of using .NET is that you don't worry about memory management. You can call GC.Collect to "force" a collection, but it's not recommended.

[BAndysc]

I'd recommend using dotMemory to analyse the memory usage and see what exactly occupies the memory. You can also easily analyse if there is a memory leak or not in dotMemory. Unfortunately, memory leaks happen in Avalonia (not necessarily in this case, it is also easy to cause a memory leak manually).

[SirZeeno]

so I just did a bunch of profiling to dig deeper into the issue, and a lot of memory is being allocated when I am creating the nested item controls that are supposed to display my results. I am unsure if it has to do with the images themselves since the bitmaps get loaded into memory and into a list once they are pulled and put into the right format.

After all that is done, it gets displayed, which then causes a huge memory spike of 60 to 65mb even in the release built. But when I close the window I have it now clear out the lists of those results, clear out anything that has to do with the window, and potentially referenced objects that could keep memory high, then run a GC, but only about 5mb gets shaven off.

if I reopen the window and run the function again it goes up 40mb every time, but those get removed right after I close the window. It's the initial 60-65mb that stays allocated and it has something to do with the Layoutable measure function and the mediacontext. And going into the object types that are allocating a lot it's the ServerCompositeDrawListVisual, and it seems to cache off of them even after the window is closed but also doesn't let go of them at any point later, they stay allocated indefinitely in all of the above-mentioned objects and functions.

So my question now is, how do I deal with that? because I am at a point where I will need to make those optimizations because I will be putting everything into scale and into the tens of thousands of those item templates and be expecting those allocations to disappear after a while and to get allocated and unallocated while I am scrolling through the lists. I am open to any ideas that anyone has :)

[thevortexcloud]

There is some further discussion here about memory usage and bitmaps.

#14304

But in general as long as you are using a virtualised list, are not showing a huge amount of them at once, all the bit maps are the same size, and you lazy load everything, memory usage should stay fairly solid when scrolling through the list and be somewhat reasonable. I was able to get memory usage down even further in my case by force disposing bitmaps in my codebehind when they were removed from the virtualised list. Using Bitmap.Decode also seems to make memory usage far worse than just resizing them ahead of time and then caching the result to disk.

a thumbnail and just the normal image would be, I'll take a look at it.

A thumbnail will typically be much smaller (generally <200px). As such it needs less memory to actually display anything.

EDIT: This discussion also contains some information about how to set up lazy loading.

#13931

[SirZeeno]

Thank you, I'll take a look at the discussions and see what I can find out.

I am not using Bitmap.Decode in any way, at most I am using skiasharp to apply a blur effect to an image for post-processing and using the SKBitmap.Decode function there to get the skiabitmap stream so I can start applying filters to it, but that's not being used in the tens of thousands of images but just on 5 images at a given time.

I am already using a thumbnail image then to display the images because I am getting the smallest image I can get out of the selection and putting that on the screen to save processing power.