CABI: switch from asyncio.Condition to asyncio.Event

Author: lukewagner

design/mvp/canonical-abi/definitions.py

@@ -222,21 +222,20 @@ class ComponentInstance:
   table: Table
   may_leave: bool
   backpressure: bool
+  unblocked: asyncio.Event
   calling_sync_export: bool
-  calling_sync_import: bool
   pending_tasks: list[tuple[Task, asyncio.Future]]
   starting_pending_task: bool
-  async_waiting_tasks: asyncio.Condition
 
   def __init__(self):
     self.table = Table()
     self.may_leave = True
     self.backpressure = False
+    self.unblocked = asyncio.Event()
+    self.unblocked.set()
     self.calling_sync_export = False
-    self.calling_sync_import = False
     self.pending_tasks = []
     self.starting_pending_task = False
-    self.async_waiting_tasks = asyncio.Condition(scheduler)
 
 #### Table State
 
@@ -519,7 +518,7 @@ def trap_if_on_the_stack(self, inst):
 
   def may_enter(self, pending_task):
     return not self.inst.backpressure and \
-           not self.inst.calling_sync_import and \
+           self.inst.unblocked.is_set() and \
            not (self.inst.calling_sync_export and pending_task.opts.sync)
 
   def maybe_start_pending_task(self):
@@ -536,23 +535,22 @@ async def sync_wait(self, awaitable) -> None:
     awaitable = asyncio.ensure_future(awaitable)
     if awaitable.done() and not DETERMINISTIC_PROFILE and random.randint(0,1):
       return
-    assert(not self.inst.calling_sync_import)
-    self.calling_sync_import = True
+    assert(self.inst.unblocked.is_set())
+    self.inst.unblocked.clear()
     if await self.on_block(awaitable) == Cancelled.TRUE:
       assert(self.state == Task.State.INITIAL)
       self.state = Task.State.PENDING_CANCEL
       assert(await self.on_block(awaitable) == Cancelled.FALSE)
-    self.inst.calling_sync_import = False
-    self.inst.async_waiting_tasks.notify_all()
+    self.inst.unblocked.set()
 
   async def async_wait(self, awaitable) -> Cancelled:
     self.maybe_start_pending_task()
     awaitable = asyncio.ensure_future(awaitable)
     if awaitable.done() and not DETERMINISTIC_PROFILE and random.randint(0,1):
       return Cancelled.FALSE
     cancelled = await self.on_block(awaitable)
-    while self.inst.calling_sync_import:
-      cancelled |= await self.on_block(self.inst.async_waiting_tasks.wait())
+    while not self.inst.unblocked.is_set():
+      cancelled |= await self.on_block(self.inst.unblocked.wait())
     if cancelled:
       awaitable.cancel()
     return cancelled
@@ -565,11 +563,10 @@ async def sync_on_block(awaitable):
         assert(await self.on_block(awaitable) == Cancelled.FALSE)
       return Cancelled.FALSE
 
-    assert(not self.inst.calling_sync_import)
-    self.inst.calling_sync_import = True
+    assert(self.inst.unblocked.is_set())
+    self.inst.unblocked.clear()
     await callee(self, on_start, on_return, sync_on_block)
-    self.inst.calling_sync_import = False
-    self.inst.async_waiting_tasks.notify_all()
+    self.inst.unblocked.set()
 
   async def wait_for_event(self, wset, sync) -> EventTuple:
     if self.state == Task.State.PENDING_CANCEL: