@grain/stdlib 0.6.2 → 0.6.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.6.4](https://github.com/grain-lang/grain/compare/stdlib-v0.6.3...stdlib-v0.6.4) (2024-06-27)
+
+
+### Features
+
+* **stdlib:** Faster memory allocator ([#2124](https://github.com/grain-lang/grain/issues/2124)) ([03e10c4](https://github.com/grain-lang/grain/commit/03e10c49d204a488f8bd56c7b7262e717ee61762))
+
+## [0.6.3](https://github.com/grain-lang/grain/compare/stdlib-v0.6.2...stdlib-v0.6.3) (2024-04-06)
+
+
+### Miscellaneous Chores
+
+* **stdlib:** Synchronize Grain versions
+
 ## [0.6.2](https://github.com/grain-lang/grain/compare/stdlib-v0.6.1...stdlib-v0.6.2) (2024-04-01)
 
 

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2023 Oscar Spencer <oscar@grain-lang.org> and Philip Blair <philip@grain-lang.org>
+Copyright (c) 2017-2024 Oscar Spencer <oscar@grain-lang.org> and Philip Blair <philip@grain-lang.org>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/int16.gr

@@ -2,6 +2,9 @@
  * Utilities for working with the Int16 type.
  * @example from "int16" include Int16
  *
+ * @example 1S
+ * @example -1S
+ *
  * @since v0.6.0
  */
 module Int16
@@ -51,6 +54,8 @@ let signExtend = x => (x << _DATA_OFFSET) >> _DATA_OFFSET
  * @param number: The value to convert
  * @returns The Uint16 represented as an Int16
  *
+ * @example Int16.fromUint16(1uS) == 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -67,6 +72,9 @@ provide let fromUint16 = (number: Uint16) => {
  * @param value: The value to increment
  * @returns The incremented value
  *
+ * @example Int16.incr(1S) == 2S
+ * @example Int16.incr(-2S) == -1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -83,6 +91,9 @@ provide let incr = (value: Int16) => {
  * @param value: The value to decrement
  * @returns The decremented value
  *
+ * @example Int16.decr(2S) == 1S
+ * @example Int16.decr(0S) == -1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -100,6 +111,10 @@ provide let decr = (value: Int16) => {
  * @param y: The second operand
  * @returns The sum of the two operands
  *
+ * @example
+ * use Int16.{ (+) }
+ * assert 1S + 1S == 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -121,6 +136,10 @@ provide let (+) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns The difference of the two operands
  *
+ * @example
+ * use Int16.{ (-) }
+ * assert 2S - 1S == 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -139,6 +158,10 @@ provide let (-) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns The product of the two operands
  *
+ * @example
+ * use Int16.{ (*) }
+ * assert 2S * 2S == 4S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -156,6 +179,10 @@ provide let (*) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns The quotient of its operands
  *
+ * @example
+ * use Int16.{ (/) }
+ * assert 8S / 2S == 4S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -174,6 +201,8 @@ provide let (/) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns The remainder of its operands
  *
+ * @example Int16.rem(8S, 3S) == 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -202,6 +231,10 @@ let abs = n => {
  *
  * @throws ModuloByZero: When `y` is zero
  *
+ * @example
+ * use Int16.{ (%) }
+ * assert -5S % 3S == 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -233,6 +266,10 @@ provide let (%) = (x: Int16, y: Int16) => {
  * @param amount: The number of bits to shift by
  * @returns The shifted value
  *
+ * @example
+ * use Int16.{ (<<) }
+ * assert (5S << 1S) == 10S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -252,6 +289,10 @@ provide let (<<) = (value: Int16, amount: Int16) => {
  * @param amount: The amount to shift by
  * @returns The shifted value
  *
+ * @example
+ * use Int16.{ (>>) }
+ * assert (5S >> 1S) == 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -271,6 +312,10 @@ provide let (>>) = (value: Int16, amount: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is equal to the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (==) }
+ * assert 1S == 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -287,6 +332,10 @@ provide let (==) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is not equal to the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (!=) }
+ * assert 1S != 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -303,6 +352,10 @@ provide let (!=) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is less than the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (<) }
+ * assert 1S < 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -319,6 +372,10 @@ provide let (<) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is greater than the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (>) }
+ * assert 2S > 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -335,6 +392,13 @@ provide let (>) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is less than or equal to the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (<=) }
+ * assert 1S <= 2S
+ * @example
+ * use Int16.{ (<=) }
+ * assert 1S <= 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -351,6 +415,13 @@ provide let (<=) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is greater than or equal to the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (>=) }
+ * assert 2S >= 1S
+ * @example
+ * use Int16.{ (>=) }
+ * assert 1S >= 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -366,6 +437,8 @@ provide let (>=) = (x: Int16, y: Int16) => {
  * @param value: The given value
  * @returns Containing the inverted bits of the given value
  *
+ * @example Int16.lnot(-5S) == 4S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -381,6 +454,10 @@ provide let lnot = (value: Int16) => {
  * @param y: The second operand
  * @returns Containing a `1` in each bit position for which the corresponding bits of both operands are `1`
  *
+ * @example
+ * use Int16.{ (&) }
+ * assert (3S & 4S) == 0S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -399,6 +476,10 @@ provide let (&) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns Containing a `1` in each bit position for which the corresponding bits of either or both operands are `1`
  *
+ * @example
+ * use Int16.{ (|) }
+ * assert (3S | 4S) == 7S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -417,6 +498,10 @@ provide let (|) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns Containing a `1` in each bit position for which the corresponding bits of either but not both operands are `1`
  *
+ * @example
+ * use Int16.{ (^) }
+ * assert (3S ^ 5S) == 6S
+ *
  * @since v0.6.0
  */
 @unsafe

package/int16.md

@@ -13,6 +13,14 @@ No other changes yet.
 from "int16" include Int16
 ```
 
+```grain
+1S
+```
+
+```grain
+-1S
+```
+
 ## Values
 
 Functions and constants included in the Int16 module.
@@ -92,6 +100,12 @@ Returns:
 |----|-----------|
 |`Int16`|The Uint16 represented as an Int16|
 
+Examples:
+
+```grain
+Int16.fromUint16(1uS) == 1S
+```
+
 ### Int16.**incr**
 
 <details disabled>
@@ -117,6 +131,16 @@ Returns:
 |----|-----------|
 |`Int16`|The incremented value|
 
+Examples:
+
+```grain
+Int16.incr(1S) == 2S
+```
+
+```grain
+Int16.incr(-2S) == -1S
+```
+
 ### Int16.**decr**
 
 <details disabled>
@@ -142,6 +166,16 @@ Returns:
 |----|-----------|
 |`Int16`|The decremented value|
 
+Examples:
+
+```grain
+Int16.decr(2S) == 1S
+```
+
+```grain
+Int16.decr(0S) == -1S
+```
+
 ### Int16.**(+)**
 
 <details disabled>
@@ -168,6 +202,13 @@ Returns:
 |----|-----------|
 |`Int16`|The sum of the two operands|
 
+Examples:
+
+```grain
+use Int16.{ (+) }
+assert 1S + 1S == 2S
+```
+
 ### Int16.**(-)**
 
 <details disabled>
@@ -194,6 +235,13 @@ Returns:
 |----|-----------|
 |`Int16`|The difference of the two operands|
 
+Examples:
+
+```grain
+use Int16.{ (-) }
+assert 2S - 1S == 1S
+```
+
 ### Int16.**(*)**
 
 <details disabled>
@@ -220,6 +268,13 @@ Returns:
 |----|-----------|
 |`Int16`|The product of the two operands|
 
+Examples:
+
+```grain
+use Int16.{ (*) }
+assert 2S * 2S == 4S
+```
+
 ### Int16.**(/)**
 
 <details disabled>
@@ -246,6 +301,13 @@ Returns:
 |----|-----------|
 |`Int16`|The quotient of its operands|
 
+Examples:
+
+```grain
+use Int16.{ (/) }
+assert 8S / 2S == 4S
+```
+
 ### Int16.**rem**
 
 <details disabled>
@@ -272,6 +334,12 @@ Returns:
 |----|-----------|
 |`Int16`|The remainder of its operands|
 
+Examples:
+
+```grain
+Int16.rem(8S, 3S) == 2S
+```
+
 ### Int16.**(%)**
 
 <details disabled>
@@ -305,6 +373,13 @@ Throws:
 
 * When `y` is zero
 
+Examples:
+
+```grain
+use Int16.{ (%) }
+assert -5S % 3S == 1S
+```
+
 ### Int16.**(<<)**
 
 <details disabled>
@@ -331,6 +406,13 @@ Returns:
 |----|-----------|
 |`Int16`|The shifted value|
 
+Examples:
+
+```grain
+use Int16.{ (<<) }
+assert (5S << 1S) == 10S
+```
+
 ### Int16.**(>>)**
 
 <details disabled>
@@ -357,6 +439,13 @@ Returns:
 |----|-----------|
 |`Int16`|The shifted value|
 
+Examples:
+
+```grain
+use Int16.{ (>>) }
+assert (5S >> 1S) == 2S
+```
+
 ### Int16.**(==)**
 
 <details disabled>
@@ -383,6 +472,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (==) }
+assert 1S == 1S
+```
+
 ### Int16.**(!=)**
 
 <details disabled>
@@ -409,6 +505,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is not equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (!=) }
+assert 1S != 2S
+```
+
 ### Int16.**(<)**
 
 <details disabled>
@@ -435,6 +538,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is less than the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (<) }
+assert 1S < 2S
+```
+
 ### Int16.**(>)**
 
 <details disabled>
@@ -461,6 +571,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (>) }
+assert 2S > 1S
+```
+
 ### Int16.**(<=)**
 
 <details disabled>
@@ -487,6 +604,18 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is less than or equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (<=) }
+assert 1S <= 2S
+```
+
+```grain
+use Int16.{ (<=) }
+assert 1S <= 1S
+```
+
 ### Int16.**(>=)**
 
 <details disabled>
@@ -513,6 +642,18 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than or equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (>=) }
+assert 2S >= 1S
+```
+
+```grain
+use Int16.{ (>=) }
+assert 1S >= 1S
+```
+
 ### Int16.**lnot**
 
 <details disabled>
@@ -538,6 +679,12 @@ Returns:
 |----|-----------|
 |`Int16`|Containing the inverted bits of the given value|
 
+Examples:
+
+```grain
+Int16.lnot(-5S) == 4S
+```
+
 ### Int16.**(&)**
 
 <details disabled>
@@ -564,6 +711,13 @@ Returns:
 |----|-----------|
 |`Int16`|Containing a `1` in each bit position for which the corresponding bits of both operands are `1`|
 
+Examples:
+
+```grain
+use Int16.{ (&) }
+assert (3S & 4S) == 0S
+```
+
 ### Int16.**(|)**
 
 <details disabled>
@@ -590,6 +744,13 @@ Returns:
 |----|-----------|
 |`Int16`|Containing a `1` in each bit position for which the corresponding bits of either or both operands are `1`|
 
+Examples:
+
+```grain
+use Int16.{ (|) }
+assert (3S | 4S) == 7S
+```
+
 ### Int16.**(^)**
 
 <details disabled>
@@ -616,3 +777,10 @@ Returns:
 |----|-----------|
 |`Int16`|Containing a `1` in each bit position for which the corresponding bits of either but not both operands are `1`|
 
+Examples:
+
+```grain
+use Int16.{ (^) }
+assert (3S ^ 5S) == 6S
+```
+

package/int8.gr

@@ -433,7 +433,7 @@ provide let (>=) = (x: Int8, y: Int8) => {
  * @param value: The given value
  * @returns Containing the inverted bits of the given value
  *
- * @example Int.lnot(-5s) == 4s
+ * @example Int8.lnot(-5s) == 4s
  *
  * @since v0.6.0
  */

package/int8.md

@@ -682,7 +682,7 @@ Returns:
 Examples:
 
 ```grain
-Int.lnot(-5s) == 4s
+Int8.lnot(-5s) == 4s
 ```
 
 ### Int8.**(&)**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grain/stdlib",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "The standard library for the Grain language.",
   "license": "MIT",
   "homepage": "https://grain-lang.org",

package/runtime/malloc.gr

@@ -3,8 +3,6 @@ module Malloc
 
 /*
  * This module implements a generic memory allocator.
- * The algorithm is quite simple, being based on the memory allocator
- * from pages 185-188 of K&R C (2nd edition).
  */
 
 from "runtime/unsafe/wasmi32" include WasmI32
@@ -20,6 +18,8 @@ use WasmI32.{
   (>>>),
   (==),
   (!=),
+  (&),
+  (^),
 }
 from "runtime/exception" include Exception
 
@@ -32,44 +32,64 @@ primitive (||) = "@or"
 
 primitive heapStart = "@heap.start"
 
-/* UNDERSTANDING THE STRUCTURE OF THE FREE LIST
- * The original K&R definition for the free list entry type was the following:
+/* UNDERSTANDING THE STRUCTURE OF THE FREE LISTS
  *
- *     union header {
- *         struct {
- *             union header *ptr;
- *             unsigned size;
- *         } s;
- *         long x; // <- forces 8-byte alignment
- *     };
+ * `malloc` allocates memory and `free` releases this memory. Two separate free
+ * lists are maintained, one for small blocks of 64 bytes, and one for larger
+ * blocks of multiples of 64 bytes. Each block has an 8-byte header and 8-byte
+ * footer to keep track of block sizes and maintain the free list.
+ * 
+ * Most allocations in programs are small, so the separate free lists allow us
+ * to implement `malloc` and `free` in O(1) for small allocations and O(n)
+ * `malloc` and O(1) `free` for large allocations, where `n` is the size of the
+ * free list for large blocks.
+ * 
+ * The small blocks are able to service:
+ *  - Numbers (with the exception of large BigInts/Rationals)
+ *  - Tuples/Arrays up to 8 elements
+ *  - Records up to 6 elements
+ *  - Variants up to 5 elements
+ *  - Closures up to 6 elements
+ *  - Bytes/Strings up to length 32
+ * 
+ * Blocks in memory look like this:
  *
- * In memory, this is really just two ints (assuming we're working in 32-bit mode).
- * As such, we manually lay out the entries on the heap as follows (note that we
- * use helpers to facilitate accessing and setting these values):
+ *       8 bytes              8 bytes       64n - 16 bytes       8 bytes            8 bytes
+ * ┌─────────────────────┬────────────────┬─────────────────┬────────────────┬─────────────────────┐
+ * │ <prev block footer> │ <block header> │ <block content> │ <block footer> │ <next block header> │
+ * └─────────────────────┴────────────────┴─────────────────┴────────────────┴─────────────────────┘
  *
- *   Grain             C Equivalent
- *   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *   let ptr      ===  union header *ptr
- *   getNext(ptr) ===  ptr->s.ptr
- *   getSize(ptr) ===  ptr->s.size
+ * Block headers look like this:
+ * ┌───────────────────────┬──────────────┐
+ * │ <prev free block ptr> │ <block size> │
+ * └───────────────────────┴──────────────┘
+ *
+ * Block footers look like this:
+ * ┌───────────────────────┬──────────────┐
+ * │ <next free block ptr> │ <block size> │
+ * └───────────────────────┴──────────────┘
+ *
+ * The size is kept in the header and footer to allow us to quickly combine
+ * free blocks when blocks are freed.
+ * 
+ * Pointers to the previous/next free blocks give us doubly-linked free lists,
+ * which makes it possible to remove blocks from the free list in constant
+ * time.
+ * 
+ * A block is considered in use when the previous/next pointers are both zero.
  */
 
 /**
- * Pointer to the start of the free list. This is always a multiple of
+ * Pointers to the start of the free lists. This is always a multiple of
  * 8, with the exception of its initial value (used as a sentinel).
  */
-let mut freePtr = 1n
+let mut smallBlockFreePtr = 1n
+let mut largeBlockFreePtr = 1n
 
 /**
  * Size (in bytes) of entries in the free list.
  */
-let mallocHeaderSize = 8n
-
-/**
- * log_2(mallocHeaderSize) (multiplication by the header
- * size is equivalent to left-shifting by this amount)
- */
-let logMallocHeaderSize = 3n
+let _HEADER_FOOTER_SIZE = 8n
 
 /**
  * The current size (in bytes) of the heap.
@@ -87,9 +107,9 @@ let _BASE = heapStart() + _RESERVED_RUNTIME_SPACE
 /**
  * The start pointer of the heap.
  */
-let _HEAP_START = _BASE + mallocHeaderSize
+let _HEAP_START = _BASE + _HEADER_FOOTER_SIZE
 
-let _NEXT_OFFSET = 0n
+let _PREV_NEXT_OFFSET = 0n
 let _SIZE_OFFSET = 4n
 
 /**
@@ -97,33 +117,65 @@ let _SIZE_OFFSET = 4n
  */
 let _PAGE_SIZE = 65536n
 
-let getNext = (ptr: WasmI32) => {
-  WasmI32.load(ptr, _NEXT_OFFSET)
+/**
+ * Size (in bytes) of blocks allocated by the allocator
+ */
+let _UNIT_SIZE = 64n
+
+/**
+ * log_2(_UNIT_SIZE) (multiplication by the header
+ * size is equivalent to left-shifting by this amount)
+ */
+let logUnitSize = 6n
+
+let headerGetPrevious = (headerPtr: WasmI32) => {
+  WasmI32.load(headerPtr, _PREV_NEXT_OFFSET)
+}
+
+let headerSetPrevious = (headerPtr: WasmI32, val: WasmI32) => {
+  WasmI32.store(headerPtr, val, _PREV_NEXT_OFFSET)
+}
+
+let headerGetSize = (headerPtr: WasmI32) => {
+  WasmI32.load(headerPtr, _SIZE_OFFSET)
+}
+
+let headerSetSize = (headerPtr: WasmI32, val: WasmI32) => {
+  WasmI32.store(headerPtr, val, _SIZE_OFFSET)
 }
 
-let setNext = (ptr: WasmI32, val: WasmI32) => {
-  WasmI32.store(ptr, val, _NEXT_OFFSET)
+// These functions are no different than the ones above, but exist to make the
+// code much easier to follow
+
+let footerGetNext = (footerPtr: WasmI32) => {
+  WasmI32.load(footerPtr, _PREV_NEXT_OFFSET)
+}
+
+let footerSetNext = (footerPtr: WasmI32, val: WasmI32) => {
+  WasmI32.store(footerPtr, val, _PREV_NEXT_OFFSET)
 }
 
-let getSize = (ptr: WasmI32) => {
-  WasmI32.load(ptr, _SIZE_OFFSET)
+let footerGetSize = (footerPtr: WasmI32) => {
+  WasmI32.load(footerPtr, _SIZE_OFFSET)
 }
 
-let setSize = (ptr: WasmI32, val: WasmI32) => {
-  WasmI32.store(ptr, val, _SIZE_OFFSET)
+let footerSetSize = (footerPtr: WasmI32, val: WasmI32) => {
+  WasmI32.store(footerPtr, val, _SIZE_OFFSET)
 }
 
 /**
- * Requests that the heap be grown by the given number of bytes.
+ * Requests that the heap be grown by the given number of units.
  *
- * @param nbytes: The number of bytes requested
+ * @param nunits: The number of units requested
  * @returns The pointer to the beginning of the extended region if successful or -1 otherwise
  */
-let growHeap = (nbytes: WasmI32) => {
+let growHeap = (nunits: WasmI32) => {
   let mut reqSize = 0n
   let mut reqResult = 0n
   let mut origSize = heapSize
 
+  let nbytes = nunits << logUnitSize
+
   // If the size has not been initialized, do so.
   if (heapSize == 0n) {
     heapSize = memorySize() * _PAGE_SIZE - _HEAP_START
@@ -131,8 +183,7 @@ let growHeap = (nbytes: WasmI32) => {
       // More bytes requested than the initial heap size,
       // so we need to request more anyway.
       reqSize = nbytes - heapSize
-      reqSize = reqSize >>> 16n
-      reqSize += 1n
+      reqSize = (reqSize + _PAGE_SIZE - 1n) >>> 16n
       reqResult = memoryGrow(reqSize)
       if (reqResult == -1n) {
         -1n
@@ -161,49 +212,105 @@ let growHeap = (nbytes: WasmI32) => {
   }
 }
 
+let removeFromFreeList = (blockPtr: WasmI32) => {
+  let blockSize = headerGetSize(blockPtr)
+  let blockFooterPtr = blockPtr + blockSize * _UNIT_SIZE - _HEADER_FOOTER_SIZE
+  let nextPtr = footerGetNext(blockFooterPtr)
+
+  let prevPtr = headerGetPrevious(blockPtr)
+  if (prevPtr == 1n) {
+    // this block was the start of the free list
+    if (blockSize == 1n) {
+      smallBlockFreePtr = nextPtr
+    } else {
+      largeBlockFreePtr = nextPtr
+    }
+
+    headerSetPrevious(nextPtr, prevPtr)
+  } else {
+    let prevSize = headerGetSize(prevPtr)
+    let prevFooterPtr = prevPtr + prevSize * _UNIT_SIZE - _HEADER_FOOTER_SIZE
+    footerSetNext(prevFooterPtr, nextPtr)
+    headerSetPrevious(nextPtr, prevPtr)
+  }
+}
+
 /**
  * Frees the given allocated pointer.
  *
  * @param ap: The pointer to free
  */
 provide let free = (ap: WasmI32) => {
-  let mut blockPtr = ap - 8n // 8 bytes for malloc header
-  let mut p = freePtr
-
-  // Edge case: for the first free (called by morecore), the free pointer
-  // is actually already pointing to this node, so we don't do anything.
-  if (blockPtr != freePtr) {
-    // Find the location to insert this block into the free list
-    while (true) {
-      let nextp = getNext(p)
-      if (
-        blockPtr > p && blockPtr < nextp ||
-        p >= nextp && (blockPtr > p || blockPtr < nextp)
-      ) {
-        break
-      }
-      p = nextp
+  let mut blockPtr = ap - _HEADER_FOOTER_SIZE
+  let mut blockSize = headerGetSize(blockPtr)
+
+  let nextBlockPtr = blockPtr + blockSize * _UNIT_SIZE
+  if (headerGetPrevious(nextBlockPtr) > 0n) {
+    // adjacent block is free, so merge
+    removeFromFreeList(nextBlockPtr)
+
+    let nextBlockSize = headerGetSize(nextBlockPtr)
+    blockSize += nextBlockSize
+    headerSetSize(blockPtr, blockSize)
+
+    let footerPtr = blockPtr + blockSize * _UNIT_SIZE - _HEADER_FOOTER_SIZE
+    footerSetSize(footerPtr, blockSize)
+  }
+
+  let prevBlockFooterPtr = blockPtr - _HEADER_FOOTER_SIZE
+  if (footerGetNext(prevBlockFooterPtr) > 0n) {
+    // (prev) adjacent block is free, so merge
+    let prevBlockSize = footerGetSize(prevBlockFooterPtr)
+    let prevBlockPtr = blockPtr - prevBlockSize * _UNIT_SIZE
+
+    if (prevBlockSize == 1n) {
+      // Since we merged, this block is already a part of the free list. If
+      // the old block was size 1, it needs to be switched to the large list.
+      removeFromFreeList(prevBlockPtr)
     }
 
-    // Merge the block into the adjacent free list entry above, if needed
-    let blockPtrSize = getSize(blockPtr)
-    let next = getNext(p)
-    if (blockPtr + blockPtrSize == next) {
-      setSize(blockPtr, blockPtrSize + getSize(next))
-      setNext(blockPtr, getNext(next))
-    } else {
-      setNext(blockPtr, next)
+    blockPtr = prevBlockPtr
+
+    blockSize += prevBlockSize
+    headerSetSize(blockPtr, blockSize)
+
+    let footerPtr = blockPtr + blockSize * _UNIT_SIZE - _HEADER_FOOTER_SIZE
+    footerSetSize(footerPtr, blockSize)
+    footerSetNext(footerPtr, footerGetNext(prevBlockFooterPtr))
+
+    if (prevBlockSize == 1n) {
+      if (largeBlockFreePtr != 1n) {
+        headerSetPrevious(largeBlockFreePtr, blockPtr)
+      }
+
+      let footerPtr = blockPtr + blockSize * _UNIT_SIZE - _HEADER_FOOTER_SIZE
+      footerSetNext(footerPtr, largeBlockFreePtr)
+      headerSetPrevious(blockPtr, 1n)
+
+      largeBlockFreePtr = blockPtr
     }
-    // Merge the previous (adjacent) free list entry into this block, if needed
-    let pSize = getSize(p)
-    if (p + pSize == blockPtr) {
-      setSize(p, pSize + getSize(blockPtr))
-      setNext(p, getNext(blockPtr))
+  } else {
+    if (blockSize == 1n) {
+      if (smallBlockFreePtr != 1n) {
+        headerSetPrevious(smallBlockFreePtr, blockPtr)
+      }
+
+      let footerPtr = blockPtr + _UNIT_SIZE - _HEADER_FOOTER_SIZE
+      footerSetNext(footerPtr, smallBlockFreePtr)
+      headerSetPrevious(blockPtr, 1n)
+
+      smallBlockFreePtr = blockPtr
     } else {
-      setNext(p, blockPtr)
+      if (largeBlockFreePtr != 1n) {
+        headerSetPrevious(largeBlockFreePtr, blockPtr)
+      }
+
+      let footerPtr = blockPtr + blockSize * _UNIT_SIZE - _HEADER_FOOTER_SIZE
+      footerSetNext(footerPtr, largeBlockFreePtr)
+      headerSetPrevious(blockPtr, 1n)
+
+      largeBlockFreePtr = blockPtr
     }
-    // Set the free list head to this block
-    freePtr = p
   }
 }
 
@@ -215,25 +322,48 @@ provide let free = (ap: WasmI32) => {
  * @param nbytes: The number of bytes to try to grow the heap by
  * @returns A pointer to the start of the free list if successful or -1 otherwise
  */
-let morecore = (nbytes: WasmI32) => {
+let morecore = (nunits: WasmI32) => {
   let origSize = heapSize
-  let mut cp = growHeap(nbytes)
+
+  let cp = growHeap(nunits + 1n) // include an extra unit for 4 headers/footers
 
   // If there was an error, fail
   if (cp == -1n) {
     Exception.panic("OutOfMemory: Maximum memory size exceeded")
   } else {
-    // Set the size of the new block to the amount the
-    // heap was grown.
+    // Set up the block. We'll add dummy headers/footers before and after the
+    // block to avoid unnecessary bounds checks elsewhere in the code.
     let grownAmount = heapSize - origSize
-    setSize(cp, grownAmount)
+    let units = (grownAmount >>> logUnitSize) - 1n
+
+    let dummyFooter = cp
+    footerSetSize(dummyFooter, 0n)
+    footerSetNext(dummyFooter, 0n)
+
+    let blockHeader = dummyFooter + _HEADER_FOOTER_SIZE
+    headerSetSize(blockHeader, units)
+    headerSetPrevious(blockHeader, 0n)
+
+    let blockFooter = blockHeader + units * _UNIT_SIZE - _HEADER_FOOTER_SIZE
+    footerSetSize(blockFooter, units)
+    footerSetNext(blockFooter, 0n)
+
+    let dummyHeader = blockFooter + _HEADER_FOOTER_SIZE
+    headerSetSize(dummyHeader, 0n)
+    headerSetPrevious(dummyHeader, 0n)
+
     // Call free() with the new block to add it to the free list.
-    free(cp + 8n)
+    free(blockHeader + _HEADER_FOOTER_SIZE)
+
     // Return the free list pointer.
-    freePtr
+    largeBlockFreePtr
   }
 }
 
+let roundBytesToUnits = bytes => {
+  (bytes + _UNIT_SIZE - 1n) >>> logUnitSize
+}
+
 /**
  * Allocates the requested number of bytes, returning a pointer.
  *
@@ -241,70 +371,74 @@ let morecore = (nbytes: WasmI32) => {
  * @returns The pointer to the allocated region (8-byte aligned) or -1 if the allocation failed
  */
 provide let malloc = (nbytes: WasmI32) => {
-  let mut nbytes = nbytes
-  let mut prevp = freePtr
+  let mut nunits = roundBytesToUnits(nbytes + _HEADER_FOOTER_SIZE * 2n)
 
-  // Set nbytes to the next multiple of mallocHeaderSize greater
-  // than the given size
-  let mut nunits = (nbytes + mallocHeaderSize - 1n) / mallocHeaderSize + 1n
-  nbytes = nunits << logMallocHeaderSize // multiply by header size
+  // Fast path for small blocks
+  if (nunits == 1n && smallBlockFreePtr != 1n) {
+    let blockPtr = smallBlockFreePtr
+    headerSetPrevious(blockPtr, 0n)
+    let footer = blockPtr + _UNIT_SIZE - _HEADER_FOOTER_SIZE
+    let next = footerGetNext(footer)
+    footerSetNext(footer, 0n)
 
-  // Handle initialization
-  if (heapSize == 0n) {
-    WasmI32.store(_BASE, _BASE, _NEXT_OFFSET)
-    freePtr = _BASE
-    prevp = _BASE
-    WasmI32.store(_BASE, 0n, _SIZE_OFFSET)
+    headerSetPrevious(next, 1n)
+    smallBlockFreePtr = next
+
+    return blockPtr + _HEADER_FOOTER_SIZE
   }
 
-  let mut ret = -1n
-
-  // Search the freelist for any blocks large enough.
-  for (let mut p = getNext(prevp);; {
-    prevp = p
-    p = getNext(p)
-  }) {
-    let size = getSize(p)
-    if (size >= nbytes) {
-      // If this block is big enough, allocate from it.
-      if (size == nbytes) {
-        // It's exactly the right size!
-        setNext(prevp, getNext(p))
-      } else {
-        // Shrink it as needed
-        let newSize = size - nbytes
-        setSize(p, newSize)
-        p += newSize
-        setSize(p, nbytes)
-      }
-      // Update the pointer to the free list.
-      freePtr = prevp
+  // Find a large enough block
+  let mut freeBlockPtr = largeBlockFreePtr
+  while (true) {
+    // Free list is empty; grow the heap
+    if (freeBlockPtr == 1n) {
+      freeBlockPtr = morecore(nunits)
+    }
+
+    let blockSize = headerGetSize(freeBlockPtr)
+    let footerPtr = freeBlockPtr + blockSize * _UNIT_SIZE - _HEADER_FOOTER_SIZE
 
-      // Return region past the header
-      ret = p + 8n
-      break
+    // Perfectly sized block, or one unit larger to avoid leaving size 1 blocks
+    // in the large block free list
+    if (blockSize == nunits || blockSize == nunits + 1n) {
+      let blockPtr = freeBlockPtr
+
+      removeFromFreeList(blockPtr)
+      headerSetPrevious(blockPtr, 0n)
+      footerSetNext(footerPtr, 0n)
+
+      return blockPtr + _HEADER_FOOTER_SIZE
     }
 
-    // We've reached the end of the free list. Time to grow the heap.
-    if (p == freePtr) {
-      // Attempt to grow the heap
-      p = morecore(nbytes)
-      // If growing the heap failed, return -1.
-      if (p == -1n) {
-        ret = -1n
-        break
-      }
+    // Take a chunk of this larger block
+    if (blockSize > nunits) {
+      let blockPtr = freeBlockPtr
+
+      let newSize = blockSize - nunits
+      headerSetSize(blockPtr, newSize)
+      let newFooterPtr = blockPtr + newSize * _UNIT_SIZE - _HEADER_FOOTER_SIZE
+      footerSetSize(newFooterPtr, newSize)
+      footerSetNext(newFooterPtr, footerGetNext(footerPtr))
+
+      let newBlockPtr = newFooterPtr + _HEADER_FOOTER_SIZE
+      headerSetSize(newBlockPtr, nunits)
+      headerSetPrevious(newBlockPtr, 0n)
+      footerSetSize(footerPtr, nunits)
+      footerSetNext(footerPtr, 0n)
+
+      return newBlockPtr + _HEADER_FOOTER_SIZE
     }
+
+    freeBlockPtr = footerGetNext(footerPtr)
   }
-  ret
+
+  return -1n
 }
 
 /**
- * Returns the current free list pointer.
- * Used for debugging.
- *
- * @returns The free list pointer
+ * Leaks all memory in all free lists; used for testing.
  */
-provide let getFreePtr = () => {
-  freePtr
+provide let leakAll = () => {
+  smallBlockFreePtr = 1n
+  largeBlockFreePtr = 1n
 }

package/runtime/malloc.md

@@ -46,18 +46,11 @@ Returns:
 |----|-----------|
 |`WasmI32`|The pointer to the allocated region (8-byte aligned) or -1 if the allocation failed|
 
-### Malloc.**getFreePtr**
+### Malloc.**leakAll**
 
 ```grain
-getFreePtr : () => WasmI32
+leakAll : () => Void
 ```
 
-Returns the current free list pointer.
-Used for debugging.
-
-Returns:
-
-|type|description|
-|----|-----------|
-|`WasmI32`|The free list pointer|
+Leaks all memory in all free lists; used for testing.
 

package/set.gr

@@ -445,11 +445,6 @@ provide let intersect = (set1, set2) => {
       add(key, set)
     }
   }, set1)
-  forEach(key => {
-    if (contains(key, set1)) {
-      add(key, set)
-    }
-  }, set2)
   set
 }
 

package/wasi/process.gr

@@ -145,16 +145,17 @@ provide let argv = () => {
   }
 
   let argc = WasmI32.load(argcPtr, 0n)
-  Memory.free(argcPtr)
 
   let argsLength = argc * 4n
   let arr = allocateArray(argc)
 
   if (WasmI32.eqz(argsLength)) {
+    Memory.free(argcPtr)
     return Ok(WasmI32.toGrain(arr): Array<String>)
   }
 
   let argvBufSize = WasmI32.load(argvBufSizePtr, 0n)
+  Memory.free(argcPtr)
 
   let argvPtr = Memory.malloc(argc * 4n)
   let argvBufPtr = Memory.malloc(argvBufSize)