ArrayPool clearing not working with many tasks

[ssambi]

Description

With a high number of tasks, ArrayPool.Shared.Return(), with the clearArray argument set to true, fails to clear the array

Reproduction Steps

Unit test:

 [Fact]
 public async Task Test()
 {
     const int TasksCount = 100000;
     const int ArrayLength = 10000;
     List<Task> tasks = new List<Task>();
     for (int i = 0; i < TasksCount; i++)
     {
         tasks.Add(Task.Run(() =>
         {
             int[] a = ArrayPool<int>.Shared.Rent(ArrayLength);
             Assert.True(a.Take(ArrayLength).All(e => e == 0));

             for (int j = 0; j < ArrayLength; j++)
             {
                 a[j] = 1;
             }
             Assert.True(a.Take(ArrayLength).All(e => e == 1));

             ArrayPool<int>.Shared.Return(a, true);
         }));
     }
     await Task.WhenAll(tasks);
 }

Expected behavior

It's expected that the following assert, that checks that the rented array is cleared, always succeeds:

Assert.True(a.Take(ArrayLength).All(e => e == 0));

Actual behavior

The assert sometimes fails

Regression?

No response

Known Workarounds

No response

Configuration

SDK .net 9.0.101
Windows 10 22H2

Other information

Maybe the cause is that ArrayPool.Shared is thread-safe, since the shared implementation stores the array instances in a ThreadStatic structure. But it's not "await/task safe" as a task could switch the thread it's executing on.

[huoyaoyuan]

The shared array pool is used by a lot of components, including LINQ. Other components can return uncleared array into the pool and get rented by your code.

Code shouldn't depend on existing content of rented array. In the proposed stress debug mode, the pool will always fill the array with garbage.

[stephentoub]

The shared array pool is used by a lot of components, including LINQ. Other components can return uncleared array into the pool and get rented by your code.

Code shouldn't depend on existing content of rented array. In the proposed stress debug mode, the pool will always fill the array with garbage.

It also currently uses GC.AllocateUninitializedArray when a new array is needed:

runtime/src/libraries/System.Private.CoreLib/src/System/Buffers/SharedArrayPool.cs

Line 110 in dae8909

buffer = GC.AllocateUninitializedArray<T>(minimumLength);