Ask for how to implement asynchronous requests

[ZhangHuan0407]

Hi all.
I was learning how to get involved in the development of the file system, but I ran into some problems. Network latency leads to having to think about how to do asynchronous reads and writes

I have simply implemented a cloud disk program, using the DokenNet.IDokanOperations2 interface, and locking as much as possible before waiting for the server tcp to return.

In the native test:
IP 127.0.0.1:Port
Disk continuous read/write > 2000MB/s
After mounting Dokan, 1k small files can be copied / read 70 times /s, and 1g large files can be copied at 200 mb / s

But on weak performance devices:
IP x.x.x.x:Port
The network bandwidth is 5M (625kb/s)
Disk continuous read/write 100MB/s
The ping latency ranges from 100ms to 150ms
After mounting Dokan, 1k small files can be copied / read 2 times /s, The transfer speed is lower than 400 kb / s

I know that the low transmission bandwidth is the reason for the network bandwidth.
However, IDokanOperations2.ReadFile will cause the explorer interface to become unresponsive if it does not return.
I expect to know how to prioritize returns when a file is slow to read and write, and asynchronously write data to the caller's stream. I couldn't find an asynchronous interface for DokanNet.

To make it easier for you to understand my intentions, I have uploaded some of my code.
When Explorer opens a folder with more images, it will try to read the images inside to generate thumbnails. If an image is 1mb in size, my current implementation will cause the explorer to freeze for 3 seconds. (150ms latency + 1mb / 400kb/s = 2.71 s)

        public NtStatus ReadFile(ReadOnlyNativeMemory<char> fileName, NativeMemory<byte> buffer, out int bytesRead,
                                 long offset, ref DokanFileInfo info)
        {
            string filePath = fileName.Span.ToString();
            ConnectWrapper serverConnect = PickServerConnect();

            ReadFileReqModel reqModel = new ReadFileReqModel()
            {
                FilePath = filePath,
                Offset = offset,
                BufferLength = buffer.Span.Length,
                ContextID = info.Context as long?,
            };
            bytesRead = 0;

            lock (serverConnect)
            {
                m_FileDataCacheMap.TryGetValue(filePath, out FileDataCacheModel? fileDataCache);
                if (reqModel.Offset < DriveSettingModel.ProtocolBufferLength &&
                    fileDataCache != null &&
                    fileDataCache.Data == null && // first time read cache
                    info.Context != null) // if server open file stream, the file could not be modified by others
                {
                    int cacheLength;
                    if (fileDataCache.FileTotalLength <= DriveSettingModel.TransferStringLimit)
                        cacheLength = DriveSettingModel.TransferStringLimit; // 256kb
                    else if (fileDataCache.FileTotalLength <= DriveSettingModel.ProtocolBufferLength)
                        cacheLength = DriveSettingModel.ProtocolBufferLength; // 1mb
                    else
                        cacheLength = DriveSettingModel.ProtocolBigBufferLength; // 4mb

                    ReadFileReqModel cacheReqModel = new ReadFileReqModel()
                    {
                        FilePath = filePath,
                        Offset = 0,
                        BufferLength = cacheLength,
                        ContextID = info.Context as long?,
                    };
                    serverConnect.SendModel(cacheReqModel);
                    ReadFileRespModel cacheRespModel = serverConnect.RecieveModel<ReadFileRespModel>();
                    if (cacheRespModel.Result != DokanResult.Success)
                        return cacheRespModel.Result;
                    fileDataCache.Data = ArrayPool<byte>.Shared.Rent(cacheLength);
                    fileDataCache.DataFillLength = cacheRespModel.BytesRead;
                    fileDataCache.CacheTime = DateTime.Now;
                    serverConnect.NetworkStream.ReadExactly(fileDataCache.Data, 0, cacheRespModel.BytesRead);
                }
                if (fileDataCache != null &&
                    fileDataCache.Data != null &&
                    reqModel.Offset < fileDataCache.DataFillLength)
                {
                    int copyLength = Math.Min(reqModel.BufferLength, (int)(fileDataCache.DataFillLength - reqModel.Offset));
                    new Span<byte>(fileDataCache.Data, (int)reqModel.Offset, copyLength).CopyTo(buffer.Span.Slice(bytesRead));
                    reqModel.Offset += copyLength;
                    reqModel.BufferLength -= copyLength;
                    bytesRead += copyLength;
                    if (reqModel.BufferLength == 0 ||
                        reqModel.Offset == fileDataCache.FileTotalLength)
                        return DokanResult.Success;
                }
            }
            if (reqModel.BufferLength == 0)
                return DokanResult.Success;
            else if (reqModel.BufferLength < 0)
                throw new ArgumentException($"reqModel.BufferLength: {reqModel.BufferLength} less than 0");

            ReadFileRespModel respModel;
            lock (serverConnect)
            {
                serverConnect.SendModel(reqModel);
                respModel = serverConnect.RecieveModel<ReadFileRespModel>();
                if (respModel.Result == NtStatus.Success)
                    serverConnect.NetworkStream.ReadExactly(buffer.Span.Slice(bytesRead, respModel.BytesRead));
            }
            bytesRead += respModel.BytesRead;
            return respModel.Result;
        }

Here's my earlier implementation, when in high latency (150ms), because of the maximum 64kb (buffer.span.length, transmission is time-consuming 64kb / 400kb/s = 160ms) transferred every 310ms, a 1mb size picture would cause the explorer to freeze for longer. (1mb / 64kb * 310ms = 4960ms)

        public NtStatus ReadFile(ReadOnlyNativeMemory<char> fileName, NativeMemory<byte> buffer, out int bytesRead,
                                 long offset, ref DokanFileInfo info)
        {
            string filePath = fileName.Span.ToString();
            ConnectWrapper serverConnect = PickServerConnect();

            ReadFileReqModel reqModel = new ReadFileReqModel()
            {
                FilePath = filePath,
                Offset = offset,
                BufferLength = buffer.Span.Length,
                ContextID = info.Context as long?,
            };
            bytesRead = 0;
            if (reqModel.BufferLength < 0)
                throw new ArgumentException($"reqModel.BufferLength: {reqModel.BufferLength} less than 0");

            ReadFileRespModel respModel;
            lock (serverConnect)
            {
                serverConnect.SendModel(reqModel);
                respModel = serverConnect.RecieveModel<ReadFileRespModel>();
                if (respModel.Result == NtStatus.Success)
                    serverConnect.NetworkStream.ReadExactly(buffer.Span.Slice(bytesRead, respModel.BytesRead));
            }
            bytesRead += respModel.BytesRead;
            return respModel.Result;
        }

I saw NtStatus.Pending in the code, but I don't know how to use it. I didn't find a sample code that uses this.
I would appreciate it if someone could point out where the code is available for me to learn.

Here's the code I wrote by feeling to express my intentions. Is pending used this way? When I still don't have the data ready, go straight back to pending until the data is ready

        public NtStatus ReadFile(ReadOnlyNativeMemory<char> fileName, NativeMemory<byte> buffer, out int bytesRead,
                                 long offset, ref DokanFileInfo info)
        {
            string filePath = fileName.Span.ToString();
            ConnectWrapper serverConnect = PickServerConnect();

            ReadFileReqModel reqModel = new ReadFileReqModel()
            {
                FilePath = filePath,
                Offset = offset,
                BufferLength = buffer.Span.Length,
                ContextID = info.Context as long?,
            };
            bytesRead = 0;

            // From here the difference begins -----------------
            m_FileDataCacheMap.TryGetValue(filePath, out FileDataCacheModel? fileDataCache);
            if (needSendCacheRequest)
            {
                Task.Run(() =>
                {
                    lock (serverConnect)
                    {
                        if (needSendCacheRequest)
                        {
                            Send();
                            RecieveCache();
                            needSendCacheRequest = false;
                        }
                    }
                });
                return NtStatus.Pending;
            }
            // copy cache to buffer
            lock (m_CloudConnect)
            {
                if (fileDataCache != null &&
                    fileDataCache.Data != null &&
                    reqModel.Offset < fileDataCache.DataFillLength)
                {
                    int copyLength = Math.Min(reqModel.BufferLength, (int)(fileDataCache.DataFillLength - reqModel.Offset));
                    new Span<byte>(fileDataCache.Data, (int)reqModel.Offset, copyLength).CopyTo(buffer.Span.Slice(bytesRead));
                    reqModel.Offset += copyLength;
                    reqModel.BufferLength -= copyLength;
                    bytesRead += copyLength;
                    if (reqModel.BufferLength == 0 ||
                        reqModel.Offset == fileDataCache.FileTotalLength)
                        return DokanResult.Success;
                }
            }
            // -----------------------------------
            if (reqModel.BufferLength == 0)
                return DokanResult.Success;
            else if (reqModel.BufferLength < 0)
                throw new ArgumentException($"reqModel.BufferLength: {reqModel.BufferLength} less than 0");

            ReadFileRespModel respModel;
            lock (serverConnect)
            {
                serverConnect.SendModel(reqModel);
                respModel = serverConnect.RecieveModel<ReadFileRespModel>();
                if (respModel.Result == NtStatus.Success)
                    serverConnect.NetworkStream.ReadExactly(buffer.Span.Slice(bytesRead, respModel.BytesRead));
            }
            bytesRead += respModel.BytesRead;
            return respModel.Result;
        }

How should pending be used? As long as the explorer doesn't get stuck, the transfer speed is secondary

Thanks!!

[ZhangHuan0407]

After I happily implemented my "toy software cloud drive", I opened a folder with 10MB of images.
Subsequently, Explorer gets stuck for about a minute.
The smile disappeared from my face like water.
:(

[LTRData]

There is currently no true asynchronous interface for Dokan, so you cannot return NtStatus.Pending from your implementation. There are a few ideas around about how to add support for that, but it requires large changes to native libraries and so far, I think nobody has been able to complete it.

Anyway. I see a few other issues with your design. First of all, you use blocking lock around much of the code which causes further read requests to get stuck there just waiting. I would recommend that you either try to handle several read requests at a time or specify single thread operation when mounting so that you do not need to care about this at all in your implementation. Also, for operations that take a long time to complete, it is useful to reset timeout using DokanFileInfo.TryResetTimeout with a few seconds between while for example waiting for network operations to complete.

[ZhangHuan0407]

Yes, as you said, global locking is not a good idea.
But in my target version, after locking a global lock, the native thread quickly finishes executing what needs to be serialized.
Quite a file will be slowed down by a single thread, but it will not get stuck.
Currently only 6 functions are still locked waiting for a remote reply and I don't know how to modify them,
In the case of making a compatibility and "allow failure" concession, there is only one necessity lock waiting for the remote server to return：
ReadFile

[ZhangHuan0407]

Leave the information to future generations who may see this request:
I modified the parameters when Dokan started. DokanOptions.NetworkDrive With this option added, Explorer will not "freeze" even if it is globally locked and waiting for the remote server to return.
Explorer is slow to respond when the API does not return, but the user has the option to try switching folders immediately, or close Explorer.

DokanInstanceBuilder dokanBuilder = new DokanInstanceBuilder(dokan)
                                        .ConfigureOptions(options =>
                                        {
                                            options.Options = DokanOptions.NetworkDrive;
                                            options.MountPoint = DriveSettingModel.Instance.LocalDriveClientMountPath;
                                        });