[C#] Remove WaitableSet and its global. Tidy <T> in codegen (#1552)

yowl · web-flow · commit 9b0965c82df2 · 2026-03-10T13:15:27.000Z
* Remove WaitableSet and its global.  Tidy &lt;T&gt; in codegen

* address feedback, comment use of unsafe, refactor repeated code.
diff --git a/crates/csharp/src/AsyncSupport.cs b/crates/csharp/src/AsyncSupport.cs
@@ -21,25 +21,13 @@ public enum CallbackCode : uint
     //#define TEST_CALLBACK_CODE_WAIT(set) (2 | (set << 4))
 }
 
-public class WaitableSet(int handle) : IDisposable
+// The context that we will create in unmanaged memory and pass to context_set.
+// TODO: C has world specific types for these pointers, perhaps C# would benefit from those also.
+[StructLayout(LayoutKind.Sequential)]
+public struct ContextTask
 {
-    public int Handle { get; } = handle;
-
-    void Dispose(bool _disposing)
-    {
-        AsyncSupport.WaitableSetDrop(handle);
-    }
-
-    public void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
-    ~WaitableSet()
-    {
-        Dispose(false);
-    }
+    public int WaitableSetHandle;
+    public int FutureHandle;
 }
 
 public static class AsyncSupport
@@ -51,9 +39,6 @@ internal static class PollWasmInterop
         internal static extern void wasmImportPoll(nint p0, int p1, nint p2);
     }
 
-    // TODO: How do we allow multiple waitable sets?
-    internal static WaitableSet WaitableSet;
-
     private static class Interop
     {
         [global::System.Runtime.InteropServices.DllImport("$root", EntryPoint = "[waitable-set-new]"), global::System.Runtime.InteropServices.WasmImportLinkageAttribute]
@@ -69,7 +54,7 @@ private static class Interop
         internal static unsafe extern uint WaitableSetPoll(int waitable, uint* waitableHandlePtr);
 
         [global::System.Runtime.InteropServices.DllImport("$root", EntryPoint = "[waitable-set-drop]"), global::System.Runtime.InteropServices.WasmImportLinkageAttribute]
-        internal static unsafe extern void WaitableSetDrop(int waitable);
+        internal static extern void WaitableSetDrop(int waitable);
 
         [global::System.Runtime.InteropServices.DllImport("$root", EntryPoint = "[context-set-0]"), global::System.Runtime.InteropServices.WasmImportLinkageAttribute]
         internal static unsafe extern void ContextSet(ContextTask* waitable);
@@ -78,13 +63,14 @@ private static class Interop
         internal static unsafe extern ContextTask* ContextGet();
     }
 
-    public static WaitableSet WaitableSetNew() 
+    public static int WaitableSetNew() 
     {
         var waitableSet  = Interop.WaitableSetNew();
         Console.WriteLine($"WaitableSet created with number {waitableSet}");
-        return new WaitableSet(waitableSet);
+        return waitableSet;
     }
 
+    // unsafe because we are using pointers.
     public static unsafe void WaitableSetPoll(int waitableHandle) 
     {
         var error  = Interop.WaitableSetPoll(waitableHandle, null);
@@ -94,16 +80,16 @@ public static unsafe void WaitableSetPoll(int waitableHandle)
         }
     }
 
-    internal static void Join(SubtaskStatus subtask, WaitableSet set, WaitableInfoState waitableInfoState) 
+    internal static void Join(SubtaskStatus subtask, int waitableSetHandle, WaitableInfoState waitableInfoState) 
     {
-        AddTaskToWaitables(set.Handle, subtask.Handle, waitableInfoState);
-        Interop.WaitableJoin(subtask.Handle, set.Handle);
+        AddTaskToWaitables(waitableSetHandle, subtask.Handle, waitableInfoState);
+        Interop.WaitableJoin(subtask.Handle, waitableSetHandle);
     }
 
-    internal static void Join(int readerWriterHandle, WaitableSet set, WaitableInfoState waitableInfoState) 
+    internal static void Join(int readerWriterHandle, int waitableHandle, WaitableInfoState waitableInfoState) 
     {
-        AddTaskToWaitables(set.Handle, readerWriterHandle, waitableInfoState);
-        Interop.WaitableJoin(readerWriterHandle, set.Handle);
+        AddTaskToWaitables(waitableHandle, readerWriterHandle, waitableInfoState);
+        Interop.WaitableJoin(readerWriterHandle, waitableHandle);
     }
 
     // TODO: Revisit this to see if we can remove it.
@@ -120,10 +106,11 @@ private static void AddTaskToWaitables(int waitableSetHandle, int waitableHandle
         waitableSetOfTasks[waitableHandle] = waitableInfoState;
     }
 
-    public unsafe static EventWaitable WaitableSetWait(WaitableSet set) 
+    // unsafe because we use a fixed size buffer.
+    public static unsafe EventWaitable WaitableSetWait(int waitableSetHandle) 
     {
         uint* buffer = stackalloc uint[2];
-        var eventCode = (EventCode)Interop.WaitableSetWait(set.Handle, buffer);
+        var eventCode = (EventCode)Interop.WaitableSetWait(waitableSetHandle, buffer);
         return new EventWaitable(eventCode, buffer[0], buffer[1]);
     }
 
@@ -132,34 +119,25 @@ public static void WaitableSetDrop(int handle)
         Interop.WaitableSetDrop(handle);
     }
 
-    // The context that we will create in unmanaged memory and pass to context_set.
-    // TODO: C has world specific types for these pointers, perhaps C# would benefit from those also.
-    [StructLayout(LayoutKind.Sequential)]
-    public struct ContextTask
-    {
-        public int Set;
-        public int FutureHandle;
-    }
-
+    // unsafe because we are using pointers.
     public static unsafe void ContextSet(ContextTask* contextTask)
     {
         Interop.ContextSet(contextTask);
     }
 
+    // unsafe because we are using pointers.
     public static unsafe ContextTask* ContextGet()
     {
-        ContextTask* contextTaskPtr = Interop.ContextGet();
-        if(contextTaskPtr == null)
-        {
-            throw new Exception("null context returned.");
-        }
-        return contextTaskPtr;
+        return Interop.ContextGet();
     }
 
+    // unsafe because we are using pointers.
     public static unsafe uint Callback(EventWaitable e, ContextTask* contextPtr, Action taskReturn)
     {
         Console.WriteLine($"Callback Event code {e.EventCode} Code {e.Code} Waitable {e.Waitable} Waitable Status {e.WaitableStatus.State}, Count {e.WaitableCount}");
-        var waitables = pendingTasks[WaitableSet.Handle];
+        ContextTask* contextTaskPtr = ContextGet();
+
+        var waitables = pendingTasks[contextTaskPtr->WaitableSetHandle];
         var waitableInfoState = waitables[e.Waitable];
 
         if (e.IsDropped)
@@ -195,32 +173,36 @@ public static unsafe uint Callback(EventWaitable e, ContextTask* contextPtr, Act
 
             if (waitables.Count == 0)
             {
-                Console.WriteLine($"No more waitables for waitable {e.Waitable} in set {WaitableSet.Handle}");
+                Console.WriteLine($"No more waitables for waitable {e.Waitable} in set {contextTaskPtr->WaitableSetHandle}");
                 taskReturn();
+                ContextSet(null);
+                Marshal.FreeHGlobal((IntPtr)contextTaskPtr);
                 return (uint)CallbackCode.Exit;
             }
 
             Console.WriteLine("More waitables in the set.");
-            return (uint)CallbackCode.Wait | (uint)(WaitableSet.Handle << 4);
+            return (uint)CallbackCode.Wait | (uint)(contextTaskPtr->WaitableSetHandle << 4);
         }
 
-        throw new NotImplementedException($"WaitableStatus not implemented {e.WaitableStatus.State} in set {WaitableSet.Handle}");
+        throw new NotImplementedException($"WaitableStatus not implemented {e.WaitableStatus.State} in set {contextTaskPtr->WaitableSetHandle}");
     }
 
-    public static Task TaskFromStatus(uint status)
+    // This method is unsafe because we are using unmanaged memory to store the context.
+    internal static unsafe Task TaskFromStatus(uint status)
     {
         var subtaskStatus = new SubtaskStatus(status);
         status = status & 0xF;
 
         if (subtaskStatus.IsSubtaskStarting || subtaskStatus.IsSubtaskStarted)
         {
-            if (WaitableSet == null) {
-                WaitableSet = WaitableSetNew();
-                Console.WriteLine($"TaskFromStatus creating WaitableSet {WaitableSet.Handle}");
+            ContextTask* contextTaskPtr = ContextGet();
+            if (contextTaskPtr == null) {
+                contextTaskPtr = AllocateAndSetNewContext();
+                Console.WriteLine($"TaskFromStatus creating WaitableSet {contextTaskPtr->WaitableSetHandle}");
             }
 
             TaskCompletionSource tcs = new TaskCompletionSource();
-            AsyncSupport.Join(subtaskStatus, WaitableSet, new WaitableInfoState(tcs));
+            Join(subtaskStatus, contextTaskPtr->WaitableSetHandle, new WaitableInfoState(tcs));
             return tcs.Task;
         }
         else if (subtaskStatus.IsSubtaskReturned)
@@ -233,7 +215,8 @@ public static Task TaskFromStatus(uint status)
         }
     }
 
-    public static Task<T> TaskFromStatus<T>(uint status, Func<T> liftFunc)
+    // unsafe because we are using pointers.
+    public static unsafe Task<T> TaskFromStatus<T>(uint status, Func<T> liftFunc)
     {
         var subtaskStatus = new SubtaskStatus(status);
         status = status & 0xF;
@@ -242,9 +225,12 @@ public static Task<T> TaskFromStatus<T>(uint status, Func<T> liftFunc)
         var tcs = new TaskCompletionSource<T>();
         if (subtaskStatus.IsSubtaskStarting || subtaskStatus.IsSubtaskStarted)
         {
-            if (WaitableSet == null) {
+            ContextTask* contextTaskPtr = ContextGet();
+            if (contextTaskPtr == null) {
+                contextTaskPtr = (ContextTask *)Marshal.AllocHGlobal(Marshal.SizeOf<ContextTask>());
                 Console.WriteLine("TaskFromStatus<T> creating WaitableSet");
-                WaitableSet = AsyncSupport.WaitableSetNew();
+                contextTaskPtr->WaitableSetHandle = WaitableSetNew();
+                ContextSet(contextTaskPtr);
             }
 
             return tcs.Task;
@@ -259,6 +245,15 @@ public static Task<T> TaskFromStatus<T>(uint status, Func<T> liftFunc)
             throw new Exception($"unexpected subtask status: {status}");
         }
     }
+
+    // unsafe because we are working with native memory.
+    internal static unsafe ContextTask* AllocateAndSetNewContext()
+    {
+        var contextTaskPtr = (ContextTask *)Marshal.AllocHGlobal(Marshal.SizeOf<ContextTask>());
+        contextTaskPtr->WaitableSetHandle = AsyncSupport.WaitableSetNew();
+        AsyncSupport.ContextSet(contextTaskPtr);
+        return contextTaskPtr;
+    }
 }
 
 
@@ -371,6 +366,7 @@ internal int TakeHandle()
 
     internal abstract uint VTableRead(IntPtr bufferPtr, int length);
 
+    // unsafe as we are working with pointers.
     internal unsafe Task<int> ReadInternal(Func<GCHandle?> liftBuffer, int length)
     {
         if (Handle == 0)
@@ -389,14 +385,15 @@ internal unsafe Task<int> ReadInternal(Func<GCHandle?> liftBuffer, int length)
         {
             Console.WriteLine("Read Blocked");
             var tcs = new TaskCompletionSource<int>();
-            if(AsyncSupport.WaitableSet == null)
+            ContextTask* contextTaskPtr = AsyncSupport.ContextGet();
+            if(contextTaskPtr == null)
             {
                 Console.WriteLine("FutureReader Read Blocked creating WaitableSet");
-                AsyncSupport.WaitableSet = AsyncSupport.WaitableSetNew();
+                contextTaskPtr = AsyncSupport.AllocateAndSetNewContext();
             }
             Console.WriteLine("blocked read before join");
 
-            AsyncSupport.Join(Handle, AsyncSupport.WaitableSet, new WaitableInfoState(tcs, this));
+            AsyncSupport.Join(Handle, contextTaskPtr->WaitableSetHandle, new WaitableInfoState(tcs, this));
             Console.WriteLine("blocked read after join");
             return tcs.Task;
         }
@@ -470,7 +467,7 @@ public class FutureReader<T>(int handle, FutureVTable vTable) : ReaderBase(handl
 {
     public FutureVTable VTable { get; private set; } = vTable;
 
-    private GCHandle LiftBuffer<T>(T buffer)
+    private GCHandle LiftBuffer(T buffer)
     {
         if(typeof(T) == typeof(byte))
         {
@@ -483,7 +480,7 @@ private GCHandle LiftBuffer<T>(T buffer)
         }
     }
 
-    public unsafe Task Read<T>(T buffer)
+    public Task Read(T buffer)
     {
         return ReadInternal(() => LiftBuffer(buffer), 1);
     }
@@ -508,7 +505,7 @@ public StreamReader(int handle, StreamVTable vTable) : base(handle)
 
     public StreamVTable VTable { get; private set; }
 
-    public unsafe Task Read(int length)
+    public Task Read(int length)
     {
         return ReadInternal(() => null, length);
     }
@@ -528,7 +525,7 @@ public class StreamReader<T>(int handle, StreamVTable vTable) :  ReaderBase(hand
 {
     public StreamVTable VTable { get; private set; } = vTable;
 
-    private GCHandle LiftBuffer<T>(T[] buffer)
+    private GCHandle LiftBuffer(T[] buffer)
     {
         if(typeof(T) == typeof(byte))
         {
@@ -541,7 +538,7 @@ private GCHandle LiftBuffer<T>(T[] buffer)
         }
     }
 
-    public unsafe Task<int> Read<T>(T[] buffer)
+    public Task<int> Read(T[] buffer)
     {
         return ReadInternal(() => LiftBuffer(buffer), buffer.Length);
     }
@@ -582,6 +579,7 @@ internal int TakeHandle()
 
     internal abstract uint VTableWrite(IntPtr bufferPtr, int length);
 
+    // unsafe as we are working with pointers.
     internal unsafe Task<int> WriteInternal(Func<GCHandle?> lowerPayload, int length)
     {
         if (Handle == 0)
@@ -600,12 +598,13 @@ internal unsafe Task<int> WriteInternal(Func<GCHandle?> lowerPayload, int length
         {
             Console.WriteLine("blocked write");
             var tcs = new TaskCompletionSource<int>();
-            if(AsyncSupport.WaitableSet == null)
+            ContextTask* contextTaskPtr = AsyncSupport.ContextGet();
+            if(contextTaskPtr == null)
             {
-                AsyncSupport.WaitableSet = AsyncSupport.WaitableSetNew();
+                contextTaskPtr = AsyncSupport.AllocateAndSetNewContext();
             }
             Console.WriteLine("blocked write before join");
-            AsyncSupport.Join(Handle, AsyncSupport.WaitableSet, new WaitableInfoState(tcs, this));
+            AsyncSupport.Join(Handle, contextTaskPtr->WaitableSetHandle, new WaitableInfoState(tcs, this));
             Console.WriteLine("blocked write after join");
             return tcs.Task;
         }
@@ -679,7 +678,6 @@ public class FutureWriter<T>(int handle, FutureVTable vTable) : WriterBase(handl
     // TODO: Generate per type for this instrinsic.
     public Task Write()
     {
-        // TODO: Lower T
         return WriteInternal(() => null, 1);
     }
 
@@ -719,7 +717,7 @@ public class StreamWriter<T>(int handle, StreamVTable vTable) : WriterBase(handl
     private GCHandle bufferHandle;
     public StreamVTable VTable { get; private set; } = vTable;
 
-    private GCHandle LowerPayload<T>(T[] payload)
+    private GCHandle LowerPayload(T[] payload)
     {
         if (VTable.Lower == null)
         {
diff --git a/crates/csharp/src/function.rs b/crates/csharp/src/function.rs
@@ -1163,7 +1163,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     }});
                     
                     // TODO: Defer dropping borrowed resources until a result is returned.
-                    return (uint)CallbackCode.Wait | (uint)(AsyncSupport.WaitableSet.Handle << 4);
+                    ContextTask* contextTaskPtr = AsyncSupport.ContextGet();
+                    return (uint)CallbackCode.Wait | (uint)(contextTaskPtr->WaitableSetHandle << 4);
                     "#);
                 }
 
diff --git a/crates/csharp/src/interface.rs b/crates/csharp/src/interface.rs
@@ -880,7 +880,7 @@ var {async_status_var} = {raw_name}({wasm_params});
                 uwriteln!(
                     self.csharp_interop_src,
                     r#"
-                    return (uint)AsyncSupport.Callback(e, (AsyncSupport.ContextTask *)IntPtr.Zero, () => {camel_name}TaskReturn());
+                    return (uint)AsyncSupport.Callback(e, (ContextTask *)IntPtr.Zero, () => {camel_name}TaskReturn());
                 }}
                 "#
                 );

Original file line number	Diff line number	Diff line change
`@@ -21,25 +21,13 @@ public enum CallbackCode : uint`
`21`	`21`	`//#define TEST_CALLBACK_CODE_WAIT(set) (2 \| (set << 4))`
`22`	`22`	`}`
`23`	`23`
`24`		`-public class WaitableSet(int handle) : IDisposable`
	`24`	`+// The context that we will create in unmanaged memory and pass to context_set.`
	`25`	`+// TODO: C has world specific types for these pointers, perhaps C# would benefit from those also.`
	`26`	`+[StructLayout(LayoutKind.Sequential)]`
	`27`	`+public struct ContextTask`
`25`	`28`	`{`
`26`		`- public int Handle { get; } = handle;`
`27`		`-`
`28`		`- void Dispose(bool _disposing)`
`29`		`- {`
`30`		`- AsyncSupport.WaitableSetDrop(handle);`
`31`		`- }`
`32`		`-`
`33`		`- public void Dispose()`
`34`		`- {`
`35`		`- Dispose(true);`
`36`		`- GC.SuppressFinalize(this);`
`37`		`- }`
`38`		`-`
`39`		`- ~WaitableSet()`
`40`		`- {`
`41`		`- Dispose(false);`
`42`		`- }`
	`29`	`+ public int WaitableSetHandle;`
	`30`	`+ public int FutureHandle;`
`43`	`31`	`}`
`44`	`32`
`45`	`33`	`public static class AsyncSupport`
`@@ -51,9 +39,6 @@ internal static class PollWasmInterop`
`51`	`39`	`internal static extern void wasmImportPoll(nint p0, int p1, nint p2);`
`52`	`40`	`}`
`53`	`41`
`54`		`- // TODO: How do we allow multiple waitable sets?`
`55`		`- internal static WaitableSet WaitableSet;`
`56`		`-`
`57`	`42`	`private static class Interop`
`58`	`43`	`{`
`59`	`44`	`[global::System.Runtime.InteropServices.DllImport("$root", EntryPoint = "[waitable-set-new]"), global::System.Runtime.InteropServices.WasmImportLinkageAttribute]`
`@@ -69,7 +54,7 @@ private static class Interop`
`69`	`54`	`internal static unsafe extern uint WaitableSetPoll(int waitable, uint* waitableHandlePtr);`
`70`	`55`
`71`	`56`	`[global::System.Runtime.InteropServices.DllImport("$root", EntryPoint = "[waitable-set-drop]"), global::System.Runtime.InteropServices.WasmImportLinkageAttribute]`
`72`		`- internal static unsafe extern void WaitableSetDrop(int waitable);`
	`57`	`+ internal static extern void WaitableSetDrop(int waitable);`
`73`	`58`
`74`	`59`	`[global::System.Runtime.InteropServices.DllImport("$root", EntryPoint = "[context-set-0]"), global::System.Runtime.InteropServices.WasmImportLinkageAttribute]`
`75`	`60`	`internal static unsafe extern void ContextSet(ContextTask* waitable);`
`@@ -78,13 +63,14 @@ private static class Interop`
`78`	`63`	`internal static unsafe extern ContextTask* ContextGet();`
`79`	`64`	`}`
`80`	`65`
`81`		`- public static WaitableSet WaitableSetNew()`
	`66`	`+ public static int WaitableSetNew()`
`82`	`67`	`{`
`83`	`68`	`var waitableSet = Interop.WaitableSetNew();`
`84`	`69`	`Console.WriteLine($"WaitableSet created with number {waitableSet}");`
`85`		`- return new WaitableSet(waitableSet);`
	`70`	`+ return waitableSet;`
`86`	`71`	`}`
`87`	`72`
	`73`	`+ // unsafe because we are using pointers.`
`88`	`74`	`public static unsafe void WaitableSetPoll(int waitableHandle)`
`89`	`75`	`{`
`90`	`76`	`var error = Interop.WaitableSetPoll(waitableHandle, null);`
`@@ -94,16 +80,16 @@ public static unsafe void WaitableSetPoll(int waitableHandle)`
`94`	`80`	`}`
`95`	`81`	`}`
`96`	`82`
`97`		`- internal static void Join(SubtaskStatus subtask, WaitableSet set, WaitableInfoState waitableInfoState)`
	`83`	`+ internal static void Join(SubtaskStatus subtask, int waitableSetHandle, WaitableInfoState waitableInfoState)`
`98`	`84`	`{`
`99`		`- AddTaskToWaitables(set.Handle, subtask.Handle, waitableInfoState);`
`100`		`- Interop.WaitableJoin(subtask.Handle, set.Handle);`
	`85`	`+ AddTaskToWaitables(waitableSetHandle, subtask.Handle, waitableInfoState);`
	`86`	`+ Interop.WaitableJoin(subtask.Handle, waitableSetHandle);`
`101`	`87`	`}`
`102`	`88`
`103`		`- internal static void Join(int readerWriterHandle, WaitableSet set, WaitableInfoState waitableInfoState)`
	`89`	`+ internal static void Join(int readerWriterHandle, int waitableHandle, WaitableInfoState waitableInfoState)`
`104`	`90`	`{`
`105`		`- AddTaskToWaitables(set.Handle, readerWriterHandle, waitableInfoState);`
`106`		`- Interop.WaitableJoin(readerWriterHandle, set.Handle);`
	`91`	`+ AddTaskToWaitables(waitableHandle, readerWriterHandle, waitableInfoState);`
	`92`	`+ Interop.WaitableJoin(readerWriterHandle, waitableHandle);`
`107`	`93`	`}`
`108`	`94`
`109`	`95`	`// TODO: Revisit this to see if we can remove it.`
`@@ -120,10 +106,11 @@ private static void AddTaskToWaitables(int waitableSetHandle, int waitableHandle`
`120`	`106`	`waitableSetOfTasks[waitableHandle] = waitableInfoState;`
`121`	`107`	`}`
`122`	`108`
`123`		`- public unsafe static EventWaitable WaitableSetWait(WaitableSet set)`
	`109`	`+ // unsafe because we use a fixed size buffer.`
	`110`	`+ public static unsafe EventWaitable WaitableSetWait(int waitableSetHandle)`
`124`	`111`	`{`
`125`	`112`	`uint* buffer = stackalloc uint[2];`
`126`		`- var eventCode = (EventCode)Interop.WaitableSetWait(set.Handle, buffer);`
	`113`	`+ var eventCode = (EventCode)Interop.WaitableSetWait(waitableSetHandle, buffer);`
`127`	`114`	`return new EventWaitable(eventCode, buffer[0], buffer[1]);`
`128`	`115`	`}`
`129`	`116`
`@@ -132,34 +119,25 @@ public static void WaitableSetDrop(int handle)`
`132`	`119`	`Interop.WaitableSetDrop(handle);`
`133`	`120`	`}`
`134`	`121`
`135`		`- // The context that we will create in unmanaged memory and pass to context_set.`
`136`		`- // TODO: C has world specific types for these pointers, perhaps C# would benefit from those also.`
`137`		`- [StructLayout(LayoutKind.Sequential)]`
`138`		`- public struct ContextTask`
`139`		`- {`
`140`		`- public int Set;`
`141`		`- public int FutureHandle;`
`142`		`- }`
`143`		`-`
	`122`	`+ // unsafe because we are using pointers.`
`144`	`123`	`public static unsafe void ContextSet(ContextTask* contextTask)`
`145`	`124`	`{`
`146`	`125`	`Interop.ContextSet(contextTask);`
`147`	`126`	`}`
`148`	`127`
	`128`	`+ // unsafe because we are using pointers.`
`149`	`129`	`public static unsafe ContextTask* ContextGet()`
`150`	`130`	`{`
`151`		`- ContextTask* contextTaskPtr = Interop.ContextGet();`
`152`		`- if(contextTaskPtr == null)`
`153`		`- {`
`154`		`- throw new Exception("null context returned.");`
`155`		`- }`
`156`		`- return contextTaskPtr;`
	`131`	`+ return Interop.ContextGet();`
`157`	`132`	`}`
`158`	`133`
	`134`	`+ // unsafe because we are using pointers.`
`159`	`135`	`public static unsafe uint Callback(EventWaitable e, ContextTask* contextPtr, Action taskReturn)`
`160`	`136`	`{`
`161`	`137`	`Console.WriteLine($"Callback Event code {e.EventCode} Code {e.Code} Waitable {e.Waitable} Waitable Status {e.WaitableStatus.State}, Count {e.WaitableCount}");`
`162`		`- var waitables = pendingTasks[WaitableSet.Handle];`
	`138`	`+ ContextTask* contextTaskPtr = ContextGet();`
	`139`	`+`
	`140`	`+ var waitables = pendingTasks[contextTaskPtr->WaitableSetHandle];`
`163`	`141`	`var waitableInfoState = waitables[e.Waitable];`
`164`	`142`
`165`	`143`	`if (e.IsDropped)`
`@@ -195,32 +173,36 @@ public static unsafe uint Callback(EventWaitable e, ContextTask* contextPtr, Act`
`195`	`173`
`196`	`174`	`if (waitables.Count == 0)`
`197`	`175`	`{`
`198`		`- Console.WriteLine($"No more waitables for waitable {e.Waitable} in set {WaitableSet.Handle}");`
	`176`	`+ Console.WriteLine($"No more waitables for waitable {e.Waitable} in set {contextTaskPtr->WaitableSetHandle}");`
`199`	`177`	`taskReturn();`
	`178`	`+ ContextSet(null);`
	`179`	`+ Marshal.FreeHGlobal((IntPtr)contextTaskPtr);`
`200`	`180`	`return (uint)CallbackCode.Exit;`
`201`	`181`	`}`
`202`	`182`
`203`	`183`	`Console.WriteLine("More waitables in the set.");`
`204`		`- return (uint)CallbackCode.Wait \| (uint)(WaitableSet.Handle << 4);`
	`184`	`+ return (uint)CallbackCode.Wait \| (uint)(contextTaskPtr->WaitableSetHandle << 4);`
`205`	`185`	`}`
`206`	`186`
`207`		`- throw new NotImplementedException($"WaitableStatus not implemented {e.WaitableStatus.State} in set {WaitableSet.Handle}");`
	`187`	`+ throw new NotImplementedException($"WaitableStatus not implemented {e.WaitableStatus.State} in set {contextTaskPtr->WaitableSetHandle}");`
`208`	`188`	`}`
`209`	`189`
`210`		`- public static Task TaskFromStatus(uint status)`
	`190`	`+ // This method is unsafe because we are using unmanaged memory to store the context.`
	`191`	`+ internal static unsafe Task TaskFromStatus(uint status)`
`211`	`192`	`{`
`212`	`193`	`var subtaskStatus = new SubtaskStatus(status);`
`213`	`194`	`status = status & 0xF;`
`214`	`195`
`215`	`196`	`if (subtaskStatus.IsSubtaskStarting \|\| subtaskStatus.IsSubtaskStarted)`
`216`	`197`	`{`
`217`		`- if (WaitableSet == null) {`
`218`		`- WaitableSet = WaitableSetNew();`
`219`		`- Console.WriteLine($"TaskFromStatus creating WaitableSet {WaitableSet.Handle}");`
	`198`	`+ ContextTask* contextTaskPtr = ContextGet();`
	`199`	`+ if (contextTaskPtr == null) {`
	`200`	`+ contextTaskPtr = AllocateAndSetNewContext();`
	`201`	`+ Console.WriteLine($"TaskFromStatus creating WaitableSet {contextTaskPtr->WaitableSetHandle}");`
`220`	`202`	`}`
`221`	`203`
`222`	`204`	`TaskCompletionSource tcs = new TaskCompletionSource();`
`223`		`- AsyncSupport.Join(subtaskStatus, WaitableSet, new WaitableInfoState(tcs));`
	`205`	`+ Join(subtaskStatus, contextTaskPtr->WaitableSetHandle, new WaitableInfoState(tcs));`
`224`	`206`	`return tcs.Task;`
`225`	`207`	`}`
`226`	`208`	`else if (subtaskStatus.IsSubtaskReturned)`
`@@ -233,7 +215,8 @@ public static Task TaskFromStatus(uint status)`
`233`	`215`	`}`
`234`	`216`	`}`
`235`	`217`
`236`		`- public static Task<T> TaskFromStatus<T>(uint status, Func<T> liftFunc)`
	`218`	`+ // unsafe because we are using pointers.`
	`219`	`+ public static unsafe Task<T> TaskFromStatus<T>(uint status, Func<T> liftFunc)`
`237`	`220`	`{`
`238`	`221`	`var subtaskStatus = new SubtaskStatus(status);`
`239`	`222`	`status = status & 0xF;`
`@@ -242,9 +225,12 @@ public static Task<T> TaskFromStatus<T>(uint status, Func<T> liftFunc)`
`242`	`225`	`var tcs = new TaskCompletionSource<T>();`
`243`	`226`	`if (subtaskStatus.IsSubtaskStarting \|\| subtaskStatus.IsSubtaskStarted)`
`244`	`227`	`{`
`245`		`- if (WaitableSet == null) {`
	`228`	`+ ContextTask* contextTaskPtr = ContextGet();`
	`229`	`+ if (contextTaskPtr == null) {`
	`230`	`+ contextTaskPtr = (ContextTask *)Marshal.AllocHGlobal(Marshal.SizeOf<ContextTask>());`
`246`	`231`	`Console.WriteLine("TaskFromStatus<T> creating WaitableSet");`
`247`		`- WaitableSet = AsyncSupport.WaitableSetNew();`
	`232`	`+ contextTaskPtr->WaitableSetHandle = WaitableSetNew();`
	`233`	`+ ContextSet(contextTaskPtr);`
`248`	`234`	`}`
`249`	`235`
`250`	`236`	`return tcs.Task;`
`@@ -259,6 +245,15 @@ public static Task<T> TaskFromStatus<T>(uint status, Func<T> liftFunc)`
`259`	`245`	`throw new Exception($"unexpected subtask status: {status}");`
`260`	`246`	`}`
`261`	`247`	`}`
	`248`	`+`
	`249`	`+ // unsafe because we are working with native memory.`
	`250`	`+ internal static unsafe ContextTask* AllocateAndSetNewContext()`
	`251`	`+ {`
	`252`	`+ var contextTaskPtr = (ContextTask *)Marshal.AllocHGlobal(Marshal.SizeOf<ContextTask>());`
	`253`	`+ contextTaskPtr->WaitableSetHandle = AsyncSupport.WaitableSetNew();`
	`254`	`+ AsyncSupport.ContextSet(contextTaskPtr);`
	`255`	`+ return contextTaskPtr;`
	`256`	`+ }`
`262`	`257`	`}`
`263`	`258`
`264`	`259`
`@@ -371,6 +366,7 @@ internal int TakeHandle()`
`371`	`366`
`372`	`367`	`internal abstract uint VTableRead(IntPtr bufferPtr, int length);`
`373`	`368`
	`369`	`+ // unsafe as we are working with pointers.`
`374`	`370`	`internal unsafe Task<int> ReadInternal(Func<GCHandle?> liftBuffer, int length)`
`375`	`371`	`{`
`376`	`372`	`if (Handle == 0)`
`@@ -389,14 +385,15 @@ internal unsafe Task<int> ReadInternal(Func<GCHandle?> liftBuffer, int length)`
`389`	`385`	`{`
`390`	`386`	`Console.WriteLine("Read Blocked");`
`391`	`387`	`var tcs = new TaskCompletionSource<int>();`
`392`		`- if(AsyncSupport.WaitableSet == null)`
	`388`	`+ ContextTask* contextTaskPtr = AsyncSupport.ContextGet();`
	`389`	`+ if(contextTaskPtr == null)`
`393`	`390`	`{`
`394`	`391`	`Console.WriteLine("FutureReader Read Blocked creating WaitableSet");`
`395`		`- AsyncSupport.WaitableSet = AsyncSupport.WaitableSetNew();`
	`392`	`+ contextTaskPtr = AsyncSupport.AllocateAndSetNewContext();`
`396`	`393`	`}`
`397`	`394`	`Console.WriteLine("blocked read before join");`
`398`	`395`
`399`		`- AsyncSupport.Join(Handle, AsyncSupport.WaitableSet, new WaitableInfoState(tcs, this));`
	`396`	`+ AsyncSupport.Join(Handle, contextTaskPtr->WaitableSetHandle, new WaitableInfoState(tcs, this));`
`400`	`397`	`Console.WriteLine("blocked read after join");`
`401`	`398`	`return tcs.Task;`
`402`	`399`	`}`
`@@ -470,7 +467,7 @@ public class FutureReader<T>(int handle, FutureVTable vTable) : ReaderBase(handl`
`470`	`467`	`{`
`471`	`468`	`public FutureVTable VTable { get; private set; } = vTable;`
`472`	`469`
`473`		`- private GCHandle LiftBuffer<T>(T buffer)`
	`470`	`+ private GCHandle LiftBuffer(T buffer)`
`474`	`471`	`{`
`475`	`472`	`if(typeof(T) == typeof(byte))`
`476`	`473`	`{`
`@@ -483,7 +480,7 @@ private GCHandle LiftBuffer<T>(T buffer)`
`483`	`480`	`}`
`484`	`481`	`}`
`485`	`482`
`486`		`- public unsafe Task Read<T>(T buffer)`
	`483`	`+ public Task Read(T buffer)`
`487`	`484`	`{`
`488`	`485`	`return ReadInternal(() => LiftBuffer(buffer), 1);`
`489`	`486`	`}`
`@@ -508,7 +505,7 @@ public StreamReader(int handle, StreamVTable vTable) : base(handle)`
`508`	`505`
`509`	`506`	`public StreamVTable VTable { get; private set; }`
`510`	`507`
`511`		`- public unsafe Task Read(int length)`
	`508`	`+ public Task Read(int length)`
`512`	`509`	`{`
`513`	`510`	`return ReadInternal(() => null, length);`
`514`	`511`	`}`
`@@ -528,7 +525,7 @@ public class StreamReader<T>(int handle, StreamVTable vTable) : ReaderBase(hand`
`528`	`525`	`{`
`529`	`526`	`public StreamVTable VTable { get; private set; } = vTable;`
`530`	`527`
`531`		`- private GCHandle LiftBuffer<T>(T[] buffer)`
	`528`	`+ private GCHandle LiftBuffer(T[] buffer)`
`532`	`529`	`{`
`533`	`530`	`if(typeof(T) == typeof(byte))`
`534`	`531`	`{`
`@@ -541,7 +538,7 @@ private GCHandle LiftBuffer<T>(T[] buffer)`
`541`	`538`	`}`
`542`	`539`	`}`
`543`	`540`
`544`		`- public unsafe Task<int> Read<T>(T[] buffer)`
	`541`	`+ public Task<int> Read(T[] buffer)`
`545`	`542`	`{`
`546`	`543`	`return ReadInternal(() => LiftBuffer(buffer), buffer.Length);`
`547`	`544`	`}`
`@@ -582,6 +579,7 @@ internal int TakeHandle()`
`582`	`579`
`583`	`580`	`internal abstract uint VTableWrite(IntPtr bufferPtr, int length);`
`584`	`581`
	`582`	`+ // unsafe as we are working with pointers.`
`585`	`583`	`internal unsafe Task<int> WriteInternal(Func<GCHandle?> lowerPayload, int length)`
`586`	`584`	`{`
`587`	`585`	`if (Handle == 0)`
`@@ -600,12 +598,13 @@ internal unsafe Task<int> WriteInternal(Func<GCHandle?> lowerPayload, int length`
`600`	`598`	`{`
`601`	`599`	`Console.WriteLine("blocked write");`
`602`	`600`	`var tcs = new TaskCompletionSource<int>();`
`603`		`- if(AsyncSupport.WaitableSet == null)`
	`601`	`+ ContextTask* contextTaskPtr = AsyncSupport.ContextGet();`
	`602`	`+ if(contextTaskPtr == null)`
`604`	`603`	`{`
`605`		`- AsyncSupport.WaitableSet = AsyncSupport.WaitableSetNew();`
	`604`	`+ contextTaskPtr = AsyncSupport.AllocateAndSetNewContext();`
`606`	`605`	`}`
`607`	`606`	`Console.WriteLine("blocked write before join");`
`608`		`- AsyncSupport.Join(Handle, AsyncSupport.WaitableSet, new WaitableInfoState(tcs, this));`
	`607`	`+ AsyncSupport.Join(Handle, contextTaskPtr->WaitableSetHandle, new WaitableInfoState(tcs, this));`
`609`	`608`	`Console.WriteLine("blocked write after join");`
`610`	`609`	`return tcs.Task;`
`611`	`610`	`}`
`@@ -679,7 +678,6 @@ public class FutureWriter<T>(int handle, FutureVTable vTable) : WriterBase(handl`
`679`	`678`	`// TODO: Generate per type for this instrinsic.`
`680`	`679`	`public Task Write()`
`681`	`680`	`{`
`682`		`- // TODO: Lower T`
`683`	`681`	`return WriteInternal(() => null, 1);`
`684`	`682`	`}`
`685`	`683`
`@@ -719,7 +717,7 @@ public class StreamWriter<T>(int handle, StreamVTable vTable) : WriterBase(handl`
`719`	`717`	`private GCHandle bufferHandle;`
`720`	`718`	`public StreamVTable VTable { get; private set; } = vTable;`
`721`	`719`
`722`		`- private GCHandle LowerPayload<T>(T[] payload)`
	`720`	`+ private GCHandle LowerPayload(T[] payload)`
`723`	`721`	`{`
`724`	`722`	`if (VTable.Lower == null)`
`725`	`723`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1163,7 +1163,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {`
`1163`	`1163`	`}});`
`1164`	`1164`
`1165`	`1165`	`// TODO: Defer dropping borrowed resources until a result is returned.`
`1166`		`- return (uint)CallbackCode.Wait \| (uint)(AsyncSupport.WaitableSet.Handle << 4);`
	`1166`	`+ ContextTask* contextTaskPtr = AsyncSupport.ContextGet();`
	`1167`	`+ return (uint)CallbackCode.Wait \| (uint)(contextTaskPtr->WaitableSetHandle << 4);`
`1167`	`1168`	`"#);`
`1168`	`1169`	`}`
`1169`	`1170`