Tweak async lift/lower ABI to be more like sync ABI

lukewagner · lukewagner · commit 8d5e885abf69 · 2024-07-13T17:48:22.000-05:00
diff --git a/design/mvp/CanonicalABI.md b/design/mvp/CanonicalABI.md
@@ -1525,35 +1525,39 @@ MAX_FLAT_PARAMS = 16
 MAX_FLAT_RESULTS = 1
 
 def flatten_functype(opts, ft, context):
+  flat_params = flatten_types(ft.param_types())
+  flat_results = flatten_types(ft.result_types())
   if opts.sync:
-    flat_params = flatten_types(ft.param_types())
     if len(flat_params) > MAX_FLAT_PARAMS:
       flat_params = ['i32']
-
-    flat_results = flatten_types(ft.result_types())
     if len(flat_results) > MAX_FLAT_RESULTS:
       match context:
         case 'lift':
           flat_results = ['i32']
         case 'lower':
           flat_params += ['i32']
           flat_results = []
-
     return CoreFuncType(flat_params, flat_results)
   else:
     match context:
       case 'lift':
         flat_params = []
         flat_results = []
       case 'lower':
-        flat_params = ['i32', 'i32']
+        if len(flat_params) > 1:
+          flat_params = ['i32']
+        if len(flat_results) > 0:
+          flat_params += ['i32']
         flat_results = ['i32']
     return CoreFuncType(flat_params, flat_results)
 
 def flatten_types(ts):
   return [ft for t in ts for ft in flatten_type(t)]
 ```
-As shown here, the core signatures `async` functions are fixed and don't vary
+As shown here, the core signatures `async` functions use a lower limit on the
+maximum number of parameters (1) and results (0) passed as scalars before
+falling back to passing through memory.
+
 based on the function type (parameters and results are passed through memory
 pointed to by the fixed `i32` parameters).
 
@@ -1859,32 +1863,17 @@ def lower_flat_flags(v, labels):
 
 ### Lifting and Lowering Values
 
-The `lift_(sync|async)_values` functions define how to lift a list of core
-parameters or results (given by the `CoreValueIter` `vi`) into a tuple of
-component-level values with types `ts`. The sync and async variants differ in
-how much they can pass in scalar "registers" before falling back to passing
-values through linear memory: sync functions use up to `max_flat` scalars
-whereas async functions have a single fixed `i32` that is either a single
-scalar value or a pointer into linear memory:
+The `lift_flat_values` function defines how to lift a list of core
+parameters or results (given by the `CoreValueIter` `vi`) into a tuple
+of component-level values with types `ts`.
 ```python
-def lift_sync_values(cx, max_flat, vi, ts):
+def lift_flat_values(cx, max_flat, vi, ts):
   flat_types = flatten_types(ts)
   if len(flat_types) > max_flat:
     return lift_heap_values(cx, vi, ts)
   else:
     return [ lift_flat(cx, vi, t) for t in ts ]
 
-def lift_async_values(cx, vi, ts):
-  if len(ts) == 0:
-    _ = vi.next('i32')
-    return []
-  flat_types = flatten_types(ts)
-  if len(flat_types) == 1 and flat_types[0] == 'i32':
-    assert(len(ts) == 1)
-    return [ lift_flat(cx, vi, ts[0]) ]
-  else:
-    return lift_heap_values(cx, vi, ts)
-
 def lift_heap_values(cx, vi, ts):
   ptr = vi.next('i32')
   tuple_type = Tuple(ts)
@@ -1893,36 +1882,26 @@ def lift_heap_values(cx, vi, ts):
   return list(load(cx, ptr, tuple_type).values())
 ```
 
-Symmetrically, the `lower_(sync|async)_values` functions define how to lower a
-list of component-level values `vs` of types `ts` into a list of core values.
-As already described for [`flatten`](#flattening) above, lowering handles the
-greater-than-`max_flat` case by either allocating storage with `realloc` or
-accepting a caller-allocated buffer as an out-param:
+Symmetrically, the `lower_flat_values` function defines how to lower a
+list of component-level values `vs` of types `ts` into a list of core
+values. As already described for [`flatten`](#flattening) above,
+lowering handles the greater-than-`max_flat` case by either allocating
+storage with `realloc` or accepting a caller-allocated buffer as an
+out-param:
 ```python
-def lower_sync_values(cx, max_flat, vs, ts, out_param = None):
-  inst = cx.inst
-  assert(inst.may_leave)
-  inst.may_leave = False
+def lower_flat_values(cx, max_flat, vs, ts, out_param = None):
+  assert(cx.inst.may_leave)
+  cx.inst.may_leave = False
   flat_types = flatten_types(ts)
   if len(flat_types) > max_flat:
     flat_vals = lower_heap_values(cx, vs, ts, out_param)
   else:
     flat_vals = []
     for i in range(len(vs)):
       flat_vals += lower_flat(cx, vs[i], ts[i])
-  inst.may_leave = True
+  cx.inst.may_leave = True
   return flat_vals
 
-def lower_async_values(cx, vs, ts, out_param):
-  if len(ts) == 0:
-    _ = out_param.next('i32')
-    return
-  inst = cx.inst
-  assert(inst.may_leave)
-  inst.may_leave = False
-  lower_heap_values(cx, vs, ts, out_param)
-  inst.may_leave = True
-
 def lower_heap_values(cx, vs, ts, out_param):
   tuple_type = Tuple(ts)
   tuple_value = {str(i): v for i,v in enumerate(vs)}
@@ -1999,9 +1978,9 @@ async def canon_lift(opts, inst, callee, ft, caller, on_block, on_start, on_retu
     task = SyncTask(opts, inst, caller, on_block)
     await task.enter()
 
-    flat_args = lower_sync_values(task, MAX_FLAT_PARAMS, on_start(), ft.param_types())
+    flat_args = lower_flat_values(task, MAX_FLAT_PARAMS, on_start(), ft.param_types())
     flat_results = await call_and_trap_on_throw(callee, task, flat_args)
-    on_return(lift_sync_values(task, MAX_FLAT_RESULTS, CoreValueIter(flat_results), ft.result_types()))
+    on_return(lift_flat_values(task, MAX_FLAT_RESULTS, CoreValueIter(flat_results), ft.result_types()))
 
     if opts.post_return is not None:
       [] = await call_and_trap_on_throw(opts.post_return, task, flat_results)
@@ -2095,10 +2074,10 @@ async def canon_lower(opts, callee, ft, task, flat_args):
         task.on_block()
         task.on_block = None
     def on_start():
-      return lift_sync_values(subtask, MAX_FLAT_PARAMS, flat_args, ft.param_types())
+      return lift_flat_values(subtask, MAX_FLAT_PARAMS, flat_args, ft.param_types())
     def on_return(results):
       nonlocal flat_results
-      flat_results = lower_sync_values(subtask, MAX_FLAT_RESULTS, results, ft.result_types(), flat_args)
+      flat_results = lower_flat_values(subtask, MAX_FLAT_RESULTS, results, ft.result_types(), flat_args)
     await callee(task, on_block, on_start, on_return)
     task.inst.calling_sync_import = False
     subtask.finish()
@@ -2110,10 +2089,10 @@ async def canon_lower(opts, callee, ft, task, flat_args):
         eager_result.set_result('block')
       def on_start():
         subtask.start()
-        return lift_async_values(subtask, flat_args, ft.param_types())
+        return lift_flat_values(subtask, 1, flat_args, ft.param_types())
       def on_return(results):
         subtask.return_()
-        lower_async_values(subtask, results, ft.result_types(), flat_args)
+        lower_flat_values(subtask, 0, results, ft.result_types(), flat_args)
       await callee(task, on_block, on_start, on_return)
       subtask.finish()
       if not eager_result.done():
@@ -2313,7 +2292,7 @@ async def canon_task_start(task, core_ft, flat_args):
   trap_if(core_ft != flatten_functype(CanonicalOptions(), FuncType([], task.ft.params), 'lower'))
   task.start()
   args = task.on_start()
-  flat_results = lower_sync_values(task, MAX_FLAT_RESULTS, args, task.ft.param_types(), CoreValueIter(flat_args))
+  flat_results = lower_flat_values(task, MAX_FLAT_RESULTS, args, task.ft.param_types(), CoreValueIter(flat_args))
   assert(len(core_ft.results) == len(flat_results))
   return flat_results
 ```
@@ -2342,7 +2321,7 @@ async def canon_task_return(task, core_ft, flat_args):
   trap_if(task.opts.sync)
   trap_if(core_ft != flatten_functype(CanonicalOptions(), FuncType(task.ft.results, []), 'lower'))
   task.return_()
-  results = lift_sync_values(task, MAX_FLAT_PARAMS, CoreValueIter(flat_args), task.ft.result_types())
+  results = lift_flat_values(task, MAX_FLAT_PARAMS, CoreValueIter(flat_args), task.ft.result_types())
   task.on_return(results)
   assert(len(core_ft.results) == 0)
   return []
diff --git a/design/mvp/canonical-abi/definitions.py b/design/mvp/canonical-abi/definitions.py
@@ -1055,28 +1055,29 @@ def lower_borrow(cx, rep, t):
 MAX_FLAT_RESULTS = 1
 
 def flatten_functype(opts, ft, context):
+  flat_params = flatten_types(ft.param_types())
+  flat_results = flatten_types(ft.result_types())
   if opts.sync:
-    flat_params = flatten_types(ft.param_types())
     if len(flat_params) > MAX_FLAT_PARAMS:
       flat_params = ['i32']
-
-    flat_results = flatten_types(ft.result_types())
     if len(flat_results) > MAX_FLAT_RESULTS:
       match context:
         case 'lift':
           flat_results = ['i32']
         case 'lower':
           flat_params += ['i32']
           flat_results = []
-
     return CoreFuncType(flat_params, flat_results)
   else:
     match context:
       case 'lift':
         flat_params = []
         flat_results = []
       case 'lower':
-        flat_params = ['i32', 'i32']
+        if len(flat_params) > 1:
+          flat_params = ['i32']
+        if len(flat_results) > 0:
+          flat_params += ['i32']
         flat_results = ['i32']
     return CoreFuncType(flat_params, flat_results)
 
@@ -1299,55 +1300,33 @@ def lower_flat_flags(v, labels):
 
 ### Lifting and Lowering Values
 
-def lift_sync_values(cx, max_flat, vi, ts):
+def lift_flat_values(cx, max_flat, vi, ts):
   flat_types = flatten_types(ts)
   if len(flat_types) > max_flat:
     return lift_heap_values(cx, vi, ts)
   else:
     return [ lift_flat(cx, vi, t) for t in ts ]
 
-def lift_async_values(cx, vi, ts):
-  if len(ts) == 0:
-    _ = vi.next('i32')
-    return []
-  flat_types = flatten_types(ts)
-  if len(flat_types) == 1 and flat_types[0] == 'i32':
-    assert(len(ts) == 1)
-    return [ lift_flat(cx, vi, ts[0]) ]
-  else:
-    return lift_heap_values(cx, vi, ts)
-
 def lift_heap_values(cx, vi, ts):
   ptr = vi.next('i32')
   tuple_type = Tuple(ts)
   trap_if(ptr != align_to(ptr, alignment(tuple_type)))
   trap_if(ptr + elem_size(tuple_type) > len(cx.opts.memory))
   return list(load(cx, ptr, tuple_type).values())
 
-def lower_sync_values(cx, max_flat, vs, ts, out_param = None):
-  inst = cx.inst
-  assert(inst.may_leave)
-  inst.may_leave = False
+def lower_flat_values(cx, max_flat, vs, ts, out_param = None):
+  assert(cx.inst.may_leave)
+  cx.inst.may_leave = False
   flat_types = flatten_types(ts)
   if len(flat_types) > max_flat:
     flat_vals = lower_heap_values(cx, vs, ts, out_param)
   else:
     flat_vals = []
     for i in range(len(vs)):
       flat_vals += lower_flat(cx, vs[i], ts[i])
-  inst.may_leave = True
+  cx.inst.may_leave = True
   return flat_vals
 
-def lower_async_values(cx, vs, ts, out_param):
-  if len(ts) == 0:
-    _ = out_param.next('i32')
-    return
-  inst = cx.inst
-  assert(inst.may_leave)
-  inst.may_leave = False
-  lower_heap_values(cx, vs, ts, out_param)
-  inst.may_leave = True
-
 def lower_heap_values(cx, vs, ts, out_param):
   tuple_type = Tuple(ts)
   tuple_value = {str(i): v for i,v in enumerate(vs)}
@@ -1369,9 +1348,9 @@ async def canon_lift(opts, inst, callee, ft, caller, on_block, on_start, on_retu
     task = SyncTask(opts, inst, caller, on_block)
     await task.enter()
 
-    flat_args = lower_sync_values(task, MAX_FLAT_PARAMS, on_start(), ft.param_types())
+    flat_args = lower_flat_values(task, MAX_FLAT_PARAMS, on_start(), ft.param_types())
     flat_results = await call_and_trap_on_throw(callee, task, flat_args)
-    on_return(lift_sync_values(task, MAX_FLAT_RESULTS, CoreValueIter(flat_results), ft.result_types()))
+    on_return(lift_flat_values(task, MAX_FLAT_RESULTS, CoreValueIter(flat_results), ft.result_types()))
 
     if opts.post_return is not None:
       [] = await call_and_trap_on_throw(opts.post_return, task, flat_results)
@@ -1419,10 +1398,10 @@ def on_block():
         task.on_block()
         task.on_block = None
     def on_start():
-      return lift_sync_values(subtask, MAX_FLAT_PARAMS, flat_args, ft.param_types())
+      return lift_flat_values(subtask, MAX_FLAT_PARAMS, flat_args, ft.param_types())
     def on_return(results):
       nonlocal flat_results
-      flat_results = lower_sync_values(subtask, MAX_FLAT_RESULTS, results, ft.result_types(), flat_args)
+      flat_results = lower_flat_values(subtask, MAX_FLAT_RESULTS, results, ft.result_types(), flat_args)
     await callee(task, on_block, on_start, on_return)
     task.inst.calling_sync_import = False
     subtask.finish()
@@ -1434,10 +1413,10 @@ def on_block():
         eager_result.set_result('block')
       def on_start():
         subtask.start()
-        return lift_async_values(subtask, flat_args, ft.param_types())
+        return lift_flat_values(subtask, 1, flat_args, ft.param_types())
       def on_return(results):
         subtask.return_()
-        lower_async_values(subtask, results, ft.result_types(), flat_args)
+        lower_flat_values(subtask, 0, results, ft.result_types(), flat_args)
       await callee(task, on_block, on_start, on_return)
       subtask.finish()
       if not eager_result.done():
@@ -1510,7 +1489,7 @@ async def canon_task_start(task, core_ft, flat_args):
   trap_if(core_ft != flatten_functype(CanonicalOptions(), FuncType([], task.ft.params), 'lower'))
   task.start()
   args = task.on_start()
-  flat_results = lower_sync_values(task, MAX_FLAT_RESULTS, args, task.ft.param_types(), CoreValueIter(flat_args))
+  flat_results = lower_flat_values(task, MAX_FLAT_RESULTS, args, task.ft.param_types(), CoreValueIter(flat_args))
   assert(len(core_ft.results) == len(flat_results))
   return flat_results
 
@@ -1521,7 +1500,7 @@ async def canon_task_return(task, core_ft, flat_args):
   trap_if(task.opts.sync)
   trap_if(core_ft != flatten_functype(CanonicalOptions(), FuncType(task.ft.results, []), 'lower'))
   task.return_()
-  results = lift_sync_values(task, MAX_FLAT_PARAMS, CoreValueIter(flat_args), task.ft.result_types())
+  results = lift_flat_values(task, MAX_FLAT_PARAMS, CoreValueIter(flat_args), task.ft.result_types())
   task.on_return(results)
   assert(len(core_ft.results) == 0)
   return []
diff --git a/design/mvp/canonical-abi/run_tests.py b/design/mvp/canonical-abi/run_tests.py
@@ -359,13 +359,13 @@ async def callee(task, x):
 
   asyncio.run(caller_task.enter())
 
-  flat_args = lower_sync_values(caller_task, definitions.MAX_FLAT_PARAMS, [v], [t])
+  flat_args = lower_flat_values(caller_task, definitions.MAX_FLAT_PARAMS, [v], [t])
   if return_in_heap:
     flat_args += [ caller_heap.realloc(0, 0, alignment(t), elem_size(t)) ]
   flat_results = asyncio.run(canon_lower(caller_opts, lifted_callee, ft, caller_task, flat_args))
   if return_in_heap:
     flat_results = [ flat_args[-1] ]
-  [got] = lift_sync_values(caller_task, definitions.MAX_FLAT_PARAMS, CoreValueIter(flat_results), [t])
+  [got] = lift_flat_values(caller_task, definitions.MAX_FLAT_PARAMS, CoreValueIter(flat_results), [t])
   caller_task.exit()
 
   if got != v:
