JsonSerializer deserialize big json in tasks memory leak

[zxcvqwerasdf]

Description

When you try to deserialize big json file (86kb+) in many tasks with delay you get memory leak

Reproduction Steps

        public static void BugReproduce()
        {
            var taskRequestNonAsync = new HttpClient().GetStringAsync("https://pastebin.com/raw/Dnf2mj1Y"); //86kb J
            taskRequestNonAsync.Wait();
            string readed = taskRequestNonAsync.Result;
            Stopwatch st = new Stopwatch();
            st.Start();
            Task[] tasks = new Task[1000];
            for (int x = 0; x < tasks.Length; x++)
            {
                tasks[x] = Task.Run(async () =>
                {
                    for (int i = 0; i < 10; i++)
                    {
                        var root = JsonSerializer.Deserialize<JsonElement>(readed);
                        await Task.Delay(100);
                    }

                });

            }
            Task.WaitAll(tasks);
            st.Stop();
            Console.WriteLine(st.Elapsed.ToString());
            Console.Read();
        }

Expected behavior

No memory leak

Actual behavior

Memory leak

Regression?

No response

Known Workarounds

No response

Configuration

Net 5.0, 6.0, 7.0
x64
Debug/Release

Other information

It's only leak with tasks, in one task it works without any problem. I think this is due to the simultaneous access to the JsonSerializer from several tasks.
here is memory snapshot image
As you can see there is a big Byte[] allocation

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

[stephentoub]

Can you elaborate? What exactly is the perceived leak? The screenshot is from after all the tasks finished? Did the GC subsequently run? And if so, what's rooting the arrays you expected to be collected?

[zxcvqwerasdf]

Can you elaborate? What exactly is the perceived leak? The screenshot is from after all the tasks finished? Did the GC subsequently run? And if so, what's rooting the arrays you expected to be collected?

Even force GC.Collect didn't help
image
Left one is 1 task (10.000). Right one is 1000 tasks (10 per task)

[stephentoub]

I just tried your repro. The only large byte[]s I see are in the ArrayPool. That's not a leak; over time or as there's increased memory pressure, the pool will discard those arrays. e.g.

[zxcvqwerasdf]

I just tried your repro. The only large byte[]s I see are in the ArrayPool. That's not a leak; over time or as there's increased memory pressure, the pool will discard those arrays. e.g.

So, it's normal behaviour? And i can't affect on this to force discard those arrays?

[Fabi]

Can you elaborate? What exactly is the perceived leak? The screenshot is from after all the tasks finished? Did the GC subsequently run? And if so, what's rooting the arrays you expected to be collected?

Even force GC.Collect didn't help image Left one is 1 task (10.000). Right one is 1000 tasks (10 per task)

Fun fact: Task.Delay itself is leaking memory since it exists and almost never frees it. Not much but it will grow endless when called often :D

[stephentoub]

Fun fact: Task.Delay itself is leaking memory since it exists and almost never frees it.

Huh? It allocates objects that become available for collection when the delay is reached.

[stephentoub]

So, it's normal behaviour? And i can't affect on this to force discard those arrays?

There's no API to force the shared ArrayPool to release all its arrays. With enough memory pressure / GC collections, all its arrays will eventually go away.

[Fabi]

Fun fact: Task.Delay itself is leaking memory since it exists and almost never frees it.

Huh? It allocates objects that become available for collection when the delay is reached.

I thought the same but in many tests with an endless loop it actually added a few MB of memory after a while. That was due to the usage of await task.delay. Had to switch to a new thread and thread.sleep to fix that. But that might be a topic for a new issue when i can create a repo

[stephentoub]

I thought the same but in many tests with an endless loop it actually added a few MB of memory after a while.

The GC heap may have increased in size and the GC may not have decommitted memory regions (because it saw no need to), but that's not a leak. A leak here would be if the allocated objects remain rooted. That doesn't happen. If you have evidence that it does, please open an issue.

[Fabi]

I thought the same but in many tests with an endless loop it actually added a few MB of memory after a while.

The GC heap may have increased in size and the GC may not have decommitted memory regions (because it saw no need to), but that's not a leak. A leak here would be if the allocated objects remain rooted. That doesn't happen. If you have evidence that it does, please open an issue.

Memory that is never freed after days of running and increasing the process memorusage is always a leak. Will open an issue the next days

[zxcvqwerasdf]

Can you elaborate? What exactly is the perceived leak? The screenshot is from after all the tasks finished? Did the GC subsequently run? And if so, what's rooting the arrays you expected to be collected?

Even force GC.Collect didn't help image Left one is 1 task (10.000). Right one is 1000 tasks (10 per task)

Fun fact: Task.Delay itself is leaking memory since it exists and almost never frees it. Not much but it will grow endless when called often :D

I tried to reproduce it:

            Task[] tasks = new Task[1000];
            for (int x = 0; x < tasks.Length; x++)
            {
                tasks[x] = Task.Run(async () =>
                {
                    while(true)
                    {
                        await Task.Delay(100);
                    }
                });
            }
            Task.WaitAll(tasks);

max memory usage 28 mb (was on start)
next: 23-24 mb usage

[zxcvqwerasdf]

So, it's normal behaviour? And i can't affect on this to force discard those arrays?

There's no API to force the shared ArrayPool to release all its arrays. With enough memory pressure / GC collections, all its arrays will eventually go away.

Thank you for the info