Async VFS file writing

Author: martindevans

Wazzy/Interop/Buffer.cs

@@ -53,4 +53,39 @@ public Span<T> GetSpan(Caller caller)
     {
         return GetSpan(caller.GetMemory("memory")!);
     }
+}
+
+internal static class BufferExtensions
+{
+    public static uint TotalLength<T>(this Buffer<Buffer<T>> buffers, Caller caller)
+        where T : unmanaged
+    {
+        var length = 0u;
+        foreach (var inner in buffers.GetSpan(caller))
+            length += inner.Length;
+        return length;
+    }
+
+    public static uint TotalLength<T>(this ReadonlyBuffer<ReadonlyBuffer<T>> buffers, Caller caller)
+        where T : unmanaged
+    {
+        var length = 0u;
+        foreach (var inner in buffers.GetSpan(caller))
+            length += inner.Length;
+        return length;
+    }
+
+    public static Memory<T> Flatten<T>(this ReadonlyBuffer<ReadonlyBuffer<T>> buffers, Caller caller, T[] dest)
+        where T : unmanaged
+    {
+        var ptr = 0;
+        foreach (var buffer in buffers.GetSpan(caller))
+        {
+            var inner = buffer.GetSpan(caller);
+            inner.CopyTo(dest.AsSpan(ptr));
+            ptr += inner.Length;
+        }
+
+        return dest.AsMemory(0, ptr);
+    }
 }

Wazzy/WasiSnapshotPreview1/FileSystem/IWasiFileSystem.cs

@@ -1,5 +1,4 @@
-using System.Text;
-using Wasmtime;
+using Wasmtime;
 using Wazzy.Interop;
 
 namespace Wazzy.WasiSnapshotPreview1.FileSystem;
@@ -83,9 +82,9 @@ public interface IWasiFileSystem
     /// <param name="caller">Context for this call</param>
     /// <param name="fd">File descriptor to write to</param>
     /// <param name="iovs">set of buffers to write</param>
-    /// <param name="nwritten">total number of bytes written</param>
+    /// <param name="nwrittenPtr">total number of bytes written</param>
     /// <returns></returns>
-    public WasiError Write(Caller caller, FileDescriptor fd, ReadonlyBuffer<ReadonlyBuffer<byte>> iovs, out uint nwritten);
+    public WasiError Write(Caller caller, FileDescriptor fd, ReadonlyBuffer<ReadonlyBuffer<byte>> iovs, Pointer<uint> nwrittenPtr);
 
     /// <summary>
     /// Write to a given file descriptor without updating the offset
@@ -96,7 +95,7 @@ public interface IWasiFileSystem
     /// <param name="offset"></param>
     /// <param name="nwrittenOutput"></param>
     /// <returns></returns>
-    public WasiError PWrite(Caller caller, FileDescriptor fd, ReadonlyBuffer<ReadonlyBuffer<byte>> iovs, long offset, out uint nwrittenOutput);
+    public WasiError PWrite(Caller caller, FileDescriptor fd, ReadonlyBuffer<ReadonlyBuffer<byte>> iovs, long offset, Pointer<uint> nwrittenPtr);
 
     /// <summary>
     /// Get a "FileStat" object for the given file descriptor
@@ -487,7 +486,7 @@ void IWasiFeature.DefineOn(Linker linker)
                 c,
                 new FileDescriptor(fd),
                 new ReadonlyBuffer<ReadonlyBuffer<byte>>(iovsAddr, (uint)iovsCount),
-                out new Pointer<uint>(nwrittenAddr).Deref(c)
+                new Pointer<uint>(nwrittenAddr)
             )
         );
 
@@ -497,7 +496,7 @@ void IWasiFeature.DefineOn(Linker linker)
                 new FileDescriptor(fd),
                 new ReadonlyBuffer<ReadonlyBuffer<byte>>(iovsAddr, (uint)iovsCount),
                 offset,
-                out new Pointer<uint>(nwrittenAddr).Deref(c)
+                new Pointer<uint>(nwrittenAddr)
             )
         );
 

Wazzy/WasiSnapshotPreview1/FileSystem/Implementations/NullFilesystem.cs

@@ -9,9 +9,9 @@ namespace Wazzy.WasiSnapshotPreview1.FileSystem.Implementations;
 public class NullFilesystem
     : IWasiFileSystem
 {
-    public WasiError Write(Caller caller, FileDescriptor fd, ReadonlyBuffer<ReadonlyBuffer<byte>> iovs, out uint nwritten)
+    public WasiError Write(Caller caller, FileDescriptor fd, ReadonlyBuffer<ReadonlyBuffer<byte>> iovs, Pointer<uint> nwritten)
     {
-        nwritten = 0;
+        nwritten.Deref(caller) = 0;
 
         // Check if it's stdout or stderr
         if (fd.Handle != 1 && fd.Handle != 2)
@@ -22,7 +22,7 @@ public WasiError Write(Caller caller, FileDescriptor fd, ReadonlyBuffer<Readonly
         for (var i = 0; i < iovecs.Length; i++)
         {
             var span = iovecs[i].GetSpan(caller);
-            nwritten += (uint)span.Length;
+            nwritten.Deref(caller) += (uint)span.Length;
         }
 
         // Done
@@ -62,9 +62,9 @@ public WasiError PathCreateDirectory(Caller caller, FileDescriptor fd, ReadOnlyS
         return WasiError.EBADF;
     }
 
-    public WasiError PWrite(Caller caller, FileDescriptor fd, ReadonlyBuffer<ReadonlyBuffer<byte>> iovs, long offset, out uint nread)
+    public WasiError PWrite(Caller caller, FileDescriptor fd, ReadonlyBuffer<ReadonlyBuffer<byte>> iovs, long offset, Pointer<uint> nwritten)
     {
-        nread = 0;
+        nwritten.Deref(caller) = 0;
         return WasiError.EBADF;
     }
 

Wazzy/WasiSnapshotPreview1/FileSystem/Implementations/VirtualFileSystem/Builder/VirtualFileSystemBuilder.cs

@@ -18,6 +18,7 @@ public class VirtualFileSystemBuilder
     private bool _readonly;
     private bool _blocking;
     private readonly List<string> _preopens = [];
+    private int _seed = 17;
 
     private void ThrowClosed([CallerMemberName] string name = "")
     {
@@ -41,7 +42,8 @@ public VirtualFileSystem Build()
             _stdout ?? new ZeroFile(),
             _stderr ?? new ZeroFile(),
             root,
-            _preopens
+            _preopens,
+            _seed
         );
     }
 
@@ -118,4 +120,10 @@ internal VirtualFileSystemBuilder WithPreopen(string path)
         _preopens.Add(path);
         return this;
     }
+
+    public VirtualFileSystemBuilder Seed(int seed)
+    {
+        _seed = seed;
+        return this;
+    }
 }

Wazzy/WasiSnapshotPreview1/FileSystem/Implementations/VirtualFileSystem/Files/ConsoleLog.cs

@@ -42,13 +42,13 @@ public override void Truncate(ulong timestamp, long size)
             throw new NotSupportedException("Cannot truncate ConsoleLog");
         }
 
-        public override uint Write(ReadOnlySpan<byte> bytes, ulong timestamp)
+        public override Task<uint> Write(ReadOnlyMemory<byte> bytes, ulong timestamp)
         {
             File.AccessTime = timestamp;
             File.ModificationTime = timestamp;
             File.ChangeTime = timestamp;
 
-            _builder.AddRange(bytes);
+            _builder.AddRange(bytes.Span);
 
             if (_builder.Count >= File._maxBufferSize)
             {
@@ -67,7 +67,7 @@ public override uint Write(ReadOnlySpan<byte> bytes, ulong timestamp)
                 }
             }
 
-            return (uint)bytes.Length;
+            return Task.FromResult((uint)bytes.Length);
         }
 
         private void WriteToLog(int count)

Wazzy/WasiSnapshotPreview1/FileSystem/Implementations/VirtualFileSystem/Files/IFileHandle.cs

@@ -1,7 +1,4 @@
-using Wasmtime;
-using Wazzy.Interop;
-
-namespace Wazzy.WasiSnapshotPreview1.FileSystem.Implementations.VirtualFileSystem.Files;
+namespace Wazzy.WasiSnapshotPreview1.FileSystem.Implementations.VirtualFileSystem.Files;
 
 /// <summary>
 /// Base interface for a handle to an open file
@@ -35,7 +32,7 @@ public interface IFileHandle
     /// <param name="bytes">Bytes to write</param>
     /// <param name="timestamp">Timestamp of "now", used to update file metadata</param>
     /// <returns>Count of written bytes</returns>
-    uint Write(ReadOnlySpan<byte> bytes, ulong timestamp);
+    Task<uint> Write(ReadOnlyMemory<byte> bytes, ulong timestamp);
 
     /// <summary>
     /// Read bytes from the file into the buffer
@@ -114,31 +111,6 @@ SeekResult Seek(long offset, Whence whence, out ulong finalOffset)
     ulong PollReadableBytes();
 
     ulong PollWritableBytes();
-
-    /// <summary>
-    /// Write all of the iovs one by one
-    /// </summary>
-    /// <param name="caller"></param>
-    /// <param name="iovs"></param>
-    /// <param name="timestamp"></param>
-    /// <returns>bytes written</returns>
-    uint Write(Caller caller, ReadonlyBuffer<ReadonlyBuffer<byte>> iovs, ulong timestamp)
-    {
-        var nwrittenOutput = 0u;
-
-        var iovecs = iovs.GetSpan(caller);
-        for (var i = 0; i < iovecs.Length; i++)
-        {
-            var span = iovecs[i].GetSpan(caller);
-            var written = Write(span, timestamp);
-            nwrittenOutput += written;
-
-            if (written != span.Length)
-                break;
-        }
-
-        return nwrittenOutput;
-    }
 }
 
 public abstract class BaseFileHandle<T>
@@ -192,7 +164,7 @@ public WasiError SetFlags(FdFlags flags)
 
     public abstract void Truncate(ulong timestamp, long size);
 
-    public abstract uint Write(ReadOnlySpan<byte> bytes, ulong timestamp);
+    public abstract Task<uint> Write(ReadOnlyMemory<byte> bytes, ulong timestamp);
 
     public abstract void Dispose();
 

Wazzy/WasiSnapshotPreview1/FileSystem/Implementations/VirtualFileSystem/Files/InMemoryFile.cs

@@ -49,20 +49,20 @@ public override Task<uint> Read(Memory<byte> memory, ulong timestamp)
             return Task.FromResult((uint)read);
         }
 
-        public override uint Write(ReadOnlySpan<byte> bytes, ulong timestamp)
+        public override Task<uint> Write(ReadOnlyMemory<byte> bytes, ulong timestamp)
         {
             TryWrite(timestamp);
 
             if ((Flags & FdFlags.Append) != 0)
                 _position = File._memory.Length;
 
             File._memory.Seek(_position, SeekOrigin.Begin);
-            File._memory.Write(bytes);
+            File._memory.Write(bytes.Span);
 
             var written = bytes.Length;
             _position += written;
 
-            return (uint)written;
+            return Task.FromResult((uint)written);
         }
 
         private void TryRead(ulong timestamp)

Wazzy/WasiSnapshotPreview1/FileSystem/Implementations/VirtualFileSystem/Files/MappedFile.cs

@@ -62,11 +62,13 @@ public override void Truncate(ulong timestamp, long size)
             }
         }
 
-        public override uint Write(ReadOnlySpan<byte> bytes, ulong timestamp)
+        public override async Task<uint> Write(ReadOnlyMemory<byte> bytes, ulong timestamp)
         {
-            _stream.Write(bytes);
+            await _stream.WriteAsync(bytes);
+
             if (_flushWrites)
-                _stream.Flush();
+                await _stream.FlushAsync();
+
             return (uint)bytes.Length;
         }
 

Wazzy/WasiSnapshotPreview1/FileSystem/Implementations/VirtualFileSystem/Files/MappedZipEntryFile.cs

@@ -37,7 +37,7 @@ public override ulong Position
 
         public override ulong Size => _file.Size;
 
-        public override uint Write(ReadOnlySpan<byte> bytes, ulong timestamp)
+        public override Task<uint> Write(ReadOnlyMemory<byte> bytes, ulong timestamp)
         {
             throw new NotSupportedException();
         }

Wazzy/WasiSnapshotPreview1/FileSystem/Implementations/VirtualFileSystem/Files/StringBuilderLog.cs

@@ -39,7 +39,7 @@ public override void Truncate(ulong timestamp, long size)
             throw new NotSupportedException("Cannot truncate StringBuilderLog");
         }
 
-        public override uint Write(ReadOnlySpan<byte> bytes, ulong timestamp)
+        public override Task<uint> Write(ReadOnlyMemory<byte> bytes, ulong timestamp)
         {
             File.AccessTime = timestamp;
             File.ModificationTime = timestamp;
@@ -52,17 +52,17 @@ public override uint Write(ReadOnlySpan<byte> bytes, ulong timestamp)
                 const int CHUNK_SIZE = 128;
                 if (bytes.Length < CHUNK_SIZE)
                 {
-                    bytesWritten += WriteBytes(bytes);
+                    bytesWritten += WriteBytes(bytes.Span);
                     break;
                 }
 
-                var chunk = bytes[..CHUNK_SIZE];
+                var chunk = bytes[..CHUNK_SIZE].Span;
                 bytesWritten += WriteBytes(chunk);
 
                 bytes = bytes[CHUNK_SIZE..];
             }
 
-            return bytesWritten;
+            return Task.FromResult(bytesWritten);
         }
 
         private uint WriteBytes(ReadOnlySpan<byte> bytes)