System.Text.Json.JsonSerializer DeserializeAsyncEnumerable works slowly with large json files (10+mb)

[olehrechukh]

I'm using HttpClient to make request, HttpConnection.ChunkedEncodingReadStream as input stream from the response, and JsonSerializer.DeserializeAsyncEnumerable to asynchronously deserialize-enumerate, but unfortunately, it works very slowly for large json objects.

await using var fileStream = File.OpenRead(filePath);
using var content = new MultipartFormDataContent();
using var streamContent = new StreamContent(fileStream);
streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
    Name = "file",
    FileName = Path.GetFileName(filePath)
};
content.Add(streamContent);

var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, "api/v1/streaming")
{
    Content = content
};

var response = await httpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead,
    cancellationToken);

var responseStream = await response.Content.ReadAsStreamAsync(cancellationToken);
var streamWrapper = new StreamWrapper(responseStream);

var bufferSize = 10 * 1024 * 1024;
var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true,
    Converters = {new JsonElementToObjectConverter()},
    DefaultBufferSize = bufferSize
};

await foreach (var batchPart in JsonSerializer.DeserializeAsyncEnumerable<BatchPart>(streamWrapper, options,
                   cancellationToken))
{
}

After investigation, I discovered that JsonSerializer is trying to read DefaultBufferSize, but the server/input still does not have enough data to fill it. After this, it tries to deserialize the object, not expecting the buffer to be filled. It works very slowly when taking into account thousands of iterations.

Time            Iteration #N            Buffer to read          Read bytes
12:35:45.145            1               16777216                535
12:35:49.327            2               16777216                4090
12:35:49.33             3               16773126                10671
12:35:49.33             4               16762455                4088
12:35:49.331            5               16758367                10673
...
12:36:04.751            882             24051345                4088
12:36:04.789            883             24047257                10658
12:36:04.827            884             24036599                4088
12:36:04.871            885             24032511                10667
...

In general, it takes ~15 minutes, but the same case only takes ~2 seconds if I am not using chunked-reading.

var response = await httpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseContentRead,
    cancellationToken);

The inner implementation explicitly uses fillBuffer: false for deserialization.

runtime/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Read.Stream.cs

Line 492 in 3bae822

bufferState = await bufferState.ReadFromStreamAsync(utf8Json, cancellationToken, fillBuffer: false).ConfigureAwait(false);

1. Why fillBuffer parameter is hard-coded? Should it be configurable from JsonSerializerOptions?
2. How I can fix performance issue for large json?

[MihaZupan]

Marking as answered since there's a tracking issue for this now: #100582