Откуда такое большое потребление оперативной памяти?

Question

[onimor]

Через gRPC пытаюсь отправить на сервер файл частями:

private const int _maxSize = 3 * 1024 * 1024;
private byte[] _part = new byte[_maxSize];
private FileRequest _fileRequest;
 
 private async void UploadFiles(InputFileChangeEventArgs e)
 {
       
        foreach (var file in e.GetMultipleFiles())
        {
            try
            {
 
                using var call = GreeterClient.DownloadFile();
                ShowMessage($"Началась загрузка: {file.Name}",Severity.Normal);
                using (var ms = file.OpenReadStream(file.Size))
                {
 
                    while (ms.Length - ms.Position > 0)
                    {
                        if (ms.Length - ms.Position <= _maxSize)
                            _part = new byte[ms.Length - ms.Position];
 
                        await ms.ReadAsync(_part, 0, _part.Length);
                        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                        //отправка не сервер. Google.Protobuf.UnsafeByteOperations.UnsafeWrap Съедает оперативу. хотя он не копирует данные,
                        //в отличии от обычного метода Google.Protobuf.ByteString.CopyFrom, который съедает примерно так же...
                        _fileRequest = new FileRequest { FileName = file.Name, FileBytes = Google.Protobuf.UnsafeByteOperations.UnsafeWrap(_part) };
                        await call.RequestStream.WriteAsync(_fileRequest);
                        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                        _fileRequest = null; 
                        
                    }
                    await ms.DisposeAsync();
                }
            
                await call.RequestStream.CompleteAsync();
                var response = await call;
                var status = response.Status;
                ShowMessage(status,Severity.Success);
 
                call.Dispose();
            }
            catch(Exception ex)
            {
                ShowMessage(ex.Message, Severity.Error);
            }
            StateHasChanged();
        }
       
    }

Если оставить код, делящий файл на части - то съедает чуть больше самого файла. Хотя должен же 3мб.
С отправкой на сервер сжирает х10 от размера файла(
Не понимаю почему

Comments

[AndromedaStar]

А зачем вам одновременно using и Dispose?

[onimor]

AndromedaStar, попробовал на всякий случай. Потому что я уже не знаю что придумать.

[none7]

Добавь вывод в лог значений ms.Length и ms.Position на каждой итерации цикла. Тут тебя может ждать сюрприз.

[profesor08]

Как устанавливается ms.Position? А _fileRequest точно подчищается? Может попробовать передавать _part по ссылке явно?

[onimor]

profesor08

Как устанавливается ms.Position?

меняется при чтении.

А _fileRequest точно подчищается

_fileRequest=null я хз как еще отчистить.

Может попробовать передавать _part по ссылке явно?

не совсем понял.

[onimor]

none7 , какой сюрприз?

[onimor]

Вот тестовый проект , Скачивание супер медленное, но оперативы уходит мало. А вот загрузка быстрая, но ест много оперативы. Может кто-то что-то подскажет (

Answer 1

[Виталий Качан]

1. Не понятно, в каком именно моменте времени проблема. Занимаемая оперативная память увеличилась на 3мб ПОСЛЕ отправки всего файла, В МОМЕНТ отправки файла?
2. То, что съедает чуть больше самого файла - так все правильно, есть же еще память, которая тратится на сопутствующие объекты кода - создание FileRequest, внутри других методов всякие обертки (как для UnsafeWrap). Если по итогам закачки файла память занимаемая увеличилась на 3мб - значит еще Garabge Collector не очистил массив _part
3. Для чего нужно делать

FileBytes = Google.Protobuf.UnsafeByteOperations.UnsafeWrap(_part)

? Ведь итак и так отправляется массив байт? Вроде по описанию там просто объект обертки создается для масива.
4 Ну и сама утечка _part = new byte[ms.Length - ms.Position]; - тут при медленной скорости может создаваться массив несколько раз.

Comments

[onimor]

1) В МОМЕНТ отправки файла постепенно возрастает.

2) Файл 100 мб съедает 1 гиг. Не сказал бы, что это чуть больше.

3) Отправляется через gRPC он понимает только bytes

message FileRequest {
    string FileName = 1;
    bytes FileBytes =2;

По этому приходится конвертировать. По дефолту это делается так
Google.Protobuf.ByteString.CopyFrom(byte[])
Но это метод все время делает новую копию массива, по этому используется UnsafeWrap.

4)Если больше то происходит чтение в массив 3мб
await ms.ReadAsync(_part, 0, _part.Length);
А этот if просто что бы поймать остаток файла. Как только части по 3 мб кончатся и останется последний кусочек меньше 3 мб то для него создается новый массив размером с остаток и передается последняя часть файла.

5) как раз для этого и выделяется новый кусок и он меньше 3 мб, и он выделяется только 1 раз. Разве это утечка?