@amxts/core 0.2.3 → 0.3.0

package/runtime/patches/README.md

@@ -30,7 +30,74 @@ unions of string literals, closures, optional properties and `undefined`,
 `?.`, `??`, destructuring, `Record` and index signatures with `in`, `delete`,
 `Object.keys` and `for...in`, `try`/`catch`/`finally`, typed `JSON`, text joined
 with a number by `+`, `async`/`await`, overloads, object types in place,
-return types read off the body, `Date` in the server's time zone.
+return types read off the body (a returned literal is the interface of its
+file), `flatMap`, a `sort` comparator whose number orders by its sign
+(`(a, b) => a - b` on fractions), a handler typed `Context & Player` that takes either,
+`Date` in the server's time zone.
+
+It also tunes the runtime (`std/assembly/rt/`) for a plugin, which makes
+many small objects over a small live heap: a small block freed (up to 124
+bytes) goes on a list of its size, and the next allocation of that size
+takes it without TLSF's search, split or merge; and the incremental collector
+starts a cycle only once the heap has doubled and grown 1 MB more
+(`ASC_GC_IDLEGAP`), not 1 KB, since a cycle visits every root and every
+live object. `ASC_GC_STRESS` steps the collector on every allocation, for
+the tests of what the shadow stack keeps.
+
+And it makes a plugin's many small calls cheaper:
+
+- a function that can reach no collection - no allocation, no import (a
+  native may call back into the plugin) other than one marked `@leaf`, no
+  call through a function value - keeps no shadow-stack frame, and a call
+  to it no slots for its arguments; in one that can, a local gets a slot
+  only if it holds a value across such a call (`src/passes/shadowstack.ts`) -
+  a template's parts are read again after its join, which takes them from
+  a static array the collector never visits;
+- the check for an error on its way to a catch after a call is kept only
+  where the callee may throw, which is known once the whole program is
+  compiled;
+- a variable a closure captured is read and written in place, not through
+  a call.
+
+And it allocates less:
+
+- an array subclass can keep its elements in its own object (`new
+  Array(length, true)` leaves it without a buffer for the subclass to point
+  at room of its own, as `Vector` does): one allocation, its own buffer
+  until it grows past that room;
+- an object that never leaves the function that makes it - its fields read
+  and written there, its address given only to an import that keeps none or
+  to a function that keeps none of it - is made in that function's part of
+  the shadow stack, with the header of a static object the collector never
+  frees (`src/passes/stackobjects.ts`, run by the build on the optimized
+  module, `makeStackObjects`). Which parameters a function keeps is worked
+  out for the whole program first: stored into the heap or a global,
+  returned, captured, given on to a function or an import that keeps it.
+  An object literal is made where it is written, not by a call, and an
+  array literal is one allocation, its elements in its own object, so
+  `player.showHud(text, { color: [255, 40, 40] })` allocates nothing; an
+  object stored into another made in the same frame stays there with it.
+  The collector reads the references in such an object when it reads the
+  stack, so a store into one needs no barrier; a function an async
+  function's coroutine may park in is left alone;
+- null stored into a reference field is a plain store, without the
+  collector's barrier, and a field that starts at zero is not written again
+  in a constructor: the incremental runtime's allocation is zeroed;
+- a constructor inlined as a super call does not check again whether
+  `this` was allocated.
+
+And it keeps a whole number in an integer: a `number` local that can only
+ever hold a whole number within i32 - a loop's counter, an index, a
+remainder, a product or a sum of such - gets an i32 local in its place, and
+the arithmetic and the comparisons over it are i32's
+(`src/passes/wholenumbers.ts`, run by the build on the optimized module,
+`keepWholeNumbers`). It is proven by an interval analysis of each function
+with a loop, where a value is a whole number within a range - never NaN, an
+infinity or -0 - or anything; a loop is solved to a fixpoint, and a
+comparison narrows the locals it compares in the branch it guards, `x * x <=
+n` included. What is not proven stays an f64: `7 / 2` is 3.5, a sum past
+2^31 is exact, `-6 % 3` is -0. The check a `%` makes that its numbers are
+whole is seen to hold there, and only i32's remainder is left.
 
 After changing `src/` or `std/` in `runtime/deps/assemblyscript`, rebuild it
 and write the patch back from there:
@@ -50,9 +117,28 @@ version`.
   native as a direct call;
 - the warning about a signature that disagrees with its import, which WAMR
   compiles out of its own compiler;
+- on i386, a double made a 64-bit integer with saturation (`i64.trunc_sat_f64_s`,
+  what every number made a cell becomes) through SSE2 when it fits in 32 bits,
+  and through the x87 only when it does not;
+- on i386 with SSE2, a double made a 32-bit integer with saturation
+  (`i32.trunc_sat_f64_s`, what a `%` checks its numbers are whole with) as
+  `cvttsd2si` itself: only its answer for NaN and a number out of range,
+  `0x80000000`, takes the branch that saturates, not three branches around
+  every conversion;
 - the i386 symbols the loader did not resolve, which LLVM spells with one
   underscore: the float and vector constant pools (`_real@...`, `_xmm@...`)
   and, on Windows, the 64-bit division helpers (`_alldiv`, `_aullrem`, ...);
+- `wasm_runtime_take_trap_frames`: the frames a trap left, for the module to
+  print its own way rather than WAMR printing them to stdout;
+- `wasm_runtime_memory_view`: where the plugin's memory is and its size, in
+  one call, for a native's thunk that reads and writes it;
+- a direct call (`wasm_runtime_direct_entry`, `_begin`, `_end`): the machine
+  code of an AOT function, which the module calls itself with the C types of
+  its parameters - what `wasm_runtime_call_wasm` does on every call, less
+  what it asks of a function it has not seen; the frame and the trap are
+  handled as that call handles them. `_begin` is written into the module's
+  call by the link-time optimisation of either compiler (`__forceinline`,
+  `always_inline`);
 - two build fixes for building `wamrc` against a prebuilt LLVM: a stub
   `LibXml2::LibXml2` target, and repointing `LLVMDebugInfoPDB`, whose
   exported target carries the DIA SDK path of the machine that built the