Add shared linear memory as prerequisite for wasip1-threads

A `shared` memory is backed by `SharedMemoryStorage`, which reserves its full address range up front so the base pointer stays stable, then commits pages on `memory.grow` under a spinlock that the SIGSEGV/SIGBUS handler also takes, so a concurrent grow cannot race an in-flight access; `memory.atomic.wait32/64` and `memory.atomic.notify` block and wake threads through `AtomicParkingLot`. Adds `SharedMemoryStorageTests` and `AtomicParkingLotTests`.

Author: MaxDesiatov

Sources/WasmKit/CMakeLists.txt

@@ -40,6 +40,7 @@ add_wasmkit_library(WasmKit
   Execution/NameRegistry.swift
   Execution/Profiler.swift
   Execution/Runtime.swift
+  Execution/SharedMemoryStorage.swift
   Execution/SignpostTracer.swift
   Execution/Store.swift
   Execution/StoreAllocator.swift

Sources/WasmKit/Execution/AtomicParkingLot.swift

@@ -80,8 +80,8 @@ public struct WasmKitException: Error, CustomStringConvertible {
 }
 
 /// A reason for a trap that occurred during execution of a WebAssembly module.
-package enum TrapReason: Error, CustomStringConvertible {
-    package struct Message {
+package enum TrapReason: Error, Equatable, CustomStringConvertible {
+    package struct Message: Equatable {
         let text: String
 
         init(_ text: String) {
@@ -158,6 +158,15 @@ extension TrapReason.Message {
     static var cannotAssignToImmutableGlobal: Self {
         Self("cannot assign to an immutable global")
     }
+    static func mmapFailed(reserveBytes: Int) -> Self {
+        Self("failed to reserve \(reserveBytes) bytes of virtual address space for shared memory")
+    }
+    static var sharedMemoryGuardRegistryFull: Self {
+        Self("shared memory guard registry is full (too many concurrent shared memories)")
+    }
+    static var atomicWaitUnsupported: Self {
+        Self("memory.atomic.wait is not supported on this platform (no thread-blocking primitive)")
+    }
     static func noGlobalExportWithName(globalName: String, instance: Instance) -> Self {
         Self("no global export with name \(globalName) in a module instance \(instance)")
     }

Sources/WasmKit/Execution/DispatchInstruction.swift

@@ -513,7 +513,13 @@ extension Execution {
             var pc = pc
             var md = md
             var ms = ms
-            let shouldUseMprotectTrapGuards = store.value.engine.configuration.memoryBoundsChecking == .mprotect
+            // Shared memory always uses software bounds checking. A guard-page fault
+            // recovered by siglongjmp would unwind the interpreter past a lock held by a
+            // concurrent grow or atomic operation, so the multi-threaded path must stay
+            // free of non-local jumps. mprotect guards are reserved for non-shared memory.
+            let isNonSharedMemory = sp.currentInstance?.memories.first?.withValue { $0.sharedStorage == nil } ?? true
+            let shouldUseMprotectTrapGuards =
+                store.value.engine.configuration.memoryBoundsChecking == .mprotect && isNonSharedMemory
             let storeValue = store.value
             while true {
                 let handler = pc.read(wasmkit_tc_exec.self)

Sources/WasmKit/Execution/Errors.swift

@@ -66,6 +66,30 @@ package struct EntityHandle<T: ~Copyable>: Equatable, Hashable, Copyable {
     }
 }
 
+/// A `Sendable` reference to a `SharedMemoryStorage` allocation.
+///
+/// `EntityHandle<T>` wraps `UnsafeMutablePointer<T>`, which is not `Sendable` in
+/// Swift 6. Shared memory is the only entity that must cross thread boundaries
+/// (via `ThreadGroup`), so this purpose-built type stores the pointer as a `UInt`
+/// bit pattern that the compiler can verify as `Sendable`.
+///
+/// The underlying `SharedMemoryStorage` must outlive all threads holding a
+/// `SharedMemoryEntity`. This is guaranteed by the `StoreAllocator`'s
+/// `BumpAllocator<SharedMemoryStorage>`, which lives as long as the parent `Store`.
+package struct SharedMemoryEntity: Sendable, Equatable, Hashable {
+    private let bits: UInt
+
+    init(unsafe pointer: UnsafeMutablePointer<SharedMemoryStorage>) {
+        self.bits = UInt(bitPattern: pointer)
+    }
+
+    @inline(__always)
+    func withValue<R>(_ body: (inout SharedMemoryStorage) throws -> R) rethrows -> R {
+        let pointer = UnsafeMutablePointer<SharedMemoryStorage>(bitPattern: bits)!
+        return try body(&pointer.pointee)
+    }
+}
+
 extension EntityHandle: ValidatableEntity where T: ValidatableEntity, T: ~Copyable {
     static func createOutOfBoundsError(index: Int, count: Int) -> WasmKitError {
         T.createOutOfBoundsError(index: index, count: count)
@@ -589,7 +613,10 @@ struct MemoryEntity: ~Copyable {
     private var storage: Storage
     let maxPageCount: UInt64
     let limit: Limits
-    let sharedMutex: Mutex<Void>?
+
+    /// If this memory is shared, the mmap-backed storage is held here.
+    /// Multiple `MemoryEntity` instances (across threads) may reference the same `SharedMemoryStorage`.
+    let sharedStorage: SharedMemoryEntity?
 
     init(_ memoryType: MemoryType, engineConfiguration: EngineConfiguration, resourceLimiter: any ResourceLimiter) throws {
         let byteSize = Int(memoryType.min) * Self.pageSize
@@ -600,26 +627,80 @@ struct MemoryEntity: ~Copyable {
         let defaultMaxPageCount = Self.maxPageCount(isMemory64: memoryType.isMemory64)
         maxPageCount = memoryType.max ?? defaultMaxPageCount
         limit = memoryType
-        sharedMutex = memoryType.shared ? Mutex<Void>(()) : nil
+        sharedStorage = nil
+    }
+
+    /// Creates a memory entity for a shared memory backed by pre-allocated `SharedMemoryStorage`.
+    ///
+    /// The inline `storage` is an empty placeholder; every accessor routes through
+    /// `sharedStorage` first.
+    init(_ memoryType: MemoryType, sharedStorage: SharedMemoryEntity) {
+        precondition(memoryType.shared)
+        // The inline storage is never accessed for shared memories (all accessors
+        // route through `sharedStorage`), so allocate an empty software-backed
+        // placeholder to avoid reserving any mprotect address space.
+        var placeholderConfiguration = EngineConfiguration()
+        placeholderConfiguration.memoryBoundsChecking = .software
+        self.storage = Storage(byteSize: 0, isMemory64: memoryType.isMemory64, engineConfiguration: placeholderConfiguration)
+        self.maxPageCount = memoryType.max ?? Self.maxPageCount(isMemory64: memoryType.isMemory64)
+        self.limit = memoryType
+        self.sharedStorage = sharedStorage
     }
 
     deinit {
+        // Only deallocate inline storage for non-shared memories.
+        // `SharedMemoryStorage` cleanup is managed by its own `BumpAllocator`.
+        guard sharedStorage == nil else { return }
         storage.deallocate()
     }
 
-    var data: UnsafeBufferPointer<UInt8> { storage.data }
+    var data: UnsafeBufferPointer<UInt8> {
+        if let sharedStorage {
+            return sharedStorage.withValue { shared in
+                let count = shared.currentByteCount.load(ordering: .acquiring)
+                return UnsafeBufferPointer(
+                    start: shared.basePointer.assumingMemoryBound(to: UInt8.self),
+                    count: count
+                )
+            }
+        }
+        return storage.data
+    }
 
-    var baseAddress: UnsafeMutableRawPointer? { storage.baseAddress }
+    var baseAddress: UnsafeMutableRawPointer? {
+        if let sharedStorage {
+            return sharedStorage.withValue { $0.basePointer }
+        }
+        return storage.baseAddress
+    }
 
-    var byteCount: Int { storage.byteCount }
+    var byteCount: Int {
+        if let sharedStorage {
+            return sharedStorage.withValue { $0.currentByteCount.load(ordering: .acquiring) }
+        }
+        return storage.byteCount
+    }
 
     var trapGuardReservationSize: Int {
-        storage.trapGuardReservationSize
+        if let sharedStorage {
+            return sharedStorage.withValue { $0.reservationSize }
+        }
+        return storage.trapGuardReservationSize
     }
 
     /// > Note:
     /// <https://webassembly.github.io/spec/core/exec/modules.html#grow-mem>
     mutating func grow(by pageCount: Int, resourceLimiter: any ResourceLimiter) throws -> Value {
+        if let sharedStorage {
+            let oldPages = try sharedStorage.withValue { shared in
+                try shared.grow(by: pageCount, resourceLimiter: resourceLimiter)
+            }
+            if oldPages < 0 {
+                return limit.isMemory64 ? .i64((-1 as Int64).unsigned) : .i32((-1 as Int32).unsigned)
+            }
+            return limit.isMemory64 ? .i64(UInt64(oldPages)) : .i32(UInt32(oldPages))
+        }
+
         let currentByteCount = byteCount
         let newPageCount = currentByteCount / Self.pageSize + pageCount
 
@@ -757,6 +838,22 @@ public struct Memory: Equatable {
         )
     }
 
+    /// The shared memory entity backing this memory, if shared.
+    package var sharedStorage: SharedMemoryEntity? {
+        handle.withValue { $0.sharedStorage }
+    }
+
+    /// Create a `Memory` in `store` that wraps an existing `SharedMemoryEntity`.
+    ///
+    /// Used by `wasi_thread_spawn` to provide the same shared memory as an
+    /// import to child `Store` instances.
+    package init(store: Store, type: MemoryType, sharedStorage: SharedMemoryEntity) {
+        self.init(
+            handle: store.allocator.allocate(memoryType: type, sharedStorage: sharedStorage),
+            allocator: store.allocator
+        )
+    }
+
     /// Returns a copy of the memory data.
     @available(*, deprecated, message: "Use `withUnsafeBufferPointer(offset:count:_:)` or `withUnsafeMutableBufferPointer(offset:count:_:)` instead")
     public var data: [UInt8] {

Sources/WasmKit/Execution/Execution.swift

@@ -565,6 +565,52 @@ enum Instruction: Equatable {
     case catchHandlers(Instruction.CatchHandlersOperand)
     /// Unregister exception handlers for a `try_table` block
     case catchHandlersEnd(Instruction.CatchHandlersEndOperand)
+    /// WebAssembly Core Instruction `i32.load` on shared memory
+    case i32LoadShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i64.load` on shared memory
+    case i64LoadShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `f32.load` on shared memory
+    case f32LoadShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `f64.load` on shared memory
+    case f64LoadShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i32.load8_s` on shared memory
+    case i32Load8SShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i32.load8_u` on shared memory
+    case i32Load8UShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i32.load16_s` on shared memory
+    case i32Load16SShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i32.load16_u` on shared memory
+    case i32Load16UShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i64.load8_s` on shared memory
+    case i64Load8SShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i64.load8_u` on shared memory
+    case i64Load8UShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i64.load16_s` on shared memory
+    case i64Load16SShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i64.load16_u` on shared memory
+    case i64Load16UShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i64.load32_s` on shared memory
+    case i64Load32SShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i64.load32_u` on shared memory
+    case i64Load32UShared(Instruction.LoadOperand)
+    /// WebAssembly Core Instruction `i32.store` on shared memory
+    case i32StoreShared(Instruction.StoreOperand)
+    /// WebAssembly Core Instruction `i64.store` on shared memory
+    case i64StoreShared(Instruction.StoreOperand)
+    /// WebAssembly Core Instruction `f32.store` on shared memory
+    case f32StoreShared(Instruction.StoreOperand)
+    /// WebAssembly Core Instruction `f64.store` on shared memory
+    case f64StoreShared(Instruction.StoreOperand)
+    /// WebAssembly Core Instruction `i32.store8` on shared memory
+    case i32Store8Shared(Instruction.StoreOperand)
+    /// WebAssembly Core Instruction `i32.store16` on shared memory
+    case i32Store16Shared(Instruction.StoreOperand)
+    /// WebAssembly Core Instruction `i64.store8` on shared memory
+    case i64Store8Shared(Instruction.StoreOperand)
+    /// WebAssembly Core Instruction `i64.store16` on shared memory
+    case i64Store16Shared(Instruction.StoreOperand)
+    /// WebAssembly Core Instruction `i64.store32` on shared memory
+    case i64Store32Shared(Instruction.StoreOperand)
 }
 
 extension Instruction {
@@ -1473,6 +1519,29 @@ extension Instruction {
         case .throwRef(let immediate): return immediate
         case .catchHandlers(let immediate): return immediate
         case .catchHandlersEnd(let immediate): return immediate
+        case .i32LoadShared(let immediate): return immediate
+        case .i64LoadShared(let immediate): return immediate
+        case .f32LoadShared(let immediate): return immediate
+        case .f64LoadShared(let immediate): return immediate
+        case .i32Load8SShared(let immediate): return immediate
+        case .i32Load8UShared(let immediate): return immediate
+        case .i32Load16SShared(let immediate): return immediate
+        case .i32Load16UShared(let immediate): return immediate
+        case .i64Load8SShared(let immediate): return immediate
+        case .i64Load8UShared(let immediate): return immediate
+        case .i64Load16SShared(let immediate): return immediate
+        case .i64Load16UShared(let immediate): return immediate
+        case .i64Load32SShared(let immediate): return immediate
+        case .i64Load32UShared(let immediate): return immediate
+        case .i32StoreShared(let immediate): return immediate
+        case .i64StoreShared(let immediate): return immediate
+        case .f32StoreShared(let immediate): return immediate
+        case .f64StoreShared(let immediate): return immediate
+        case .i32Store8Shared(let immediate): return immediate
+        case .i32Store16Shared(let immediate): return immediate
+        case .i64Store8Shared(let immediate): return immediate
+        case .i64Store16Shared(let immediate): return immediate
+        case .i64Store32Shared(let immediate): return immediate
         default: return nil
         }
     }
@@ -1757,6 +1826,29 @@ extension Instruction {
         case .throwRef: return 271
         case .catchHandlers: return 272
         case .catchHandlersEnd: return 273
+        case .i32LoadShared: return 274
+        case .i64LoadShared: return 275
+        case .f32LoadShared: return 276
+        case .f64LoadShared: return 277
+        case .i32Load8SShared: return 278
+        case .i32Load8UShared: return 279
+        case .i32Load16SShared: return 280
+        case .i32Load16UShared: return 281
+        case .i64Load8SShared: return 282
+        case .i64Load8UShared: return 283
+        case .i64Load16SShared: return 284
+        case .i64Load16UShared: return 285
+        case .i64Load32SShared: return 286
+        case .i64Load32UShared: return 287
+        case .i32StoreShared: return 288
+        case .i64StoreShared: return 289
+        case .f32StoreShared: return 290
+        case .f64StoreShared: return 291
+        case .i32Store8Shared: return 292
+        case .i32Store16Shared: return 293
+        case .i64Store8Shared: return 294
+        case .i64Store16Shared: return 295
+        case .i64Store32Shared: return 296
         }
     }
 }
@@ -2042,6 +2134,29 @@ extension Instruction {
         case 271: return .throwRef(Instruction.ThrowRefOperand.load(from: &pc))
         case 272: return .catchHandlers(Instruction.CatchHandlersOperand.load(from: &pc))
         case 273: return .catchHandlersEnd(Instruction.CatchHandlersEndOperand.load(from: &pc))
+        case 274: return .i32LoadShared(Instruction.LoadOperand.load(from: &pc))
+        case 275: return .i64LoadShared(Instruction.LoadOperand.load(from: &pc))
+        case 276: return .f32LoadShared(Instruction.LoadOperand.load(from: &pc))
+        case 277: return .f64LoadShared(Instruction.LoadOperand.load(from: &pc))
+        case 278: return .i32Load8SShared(Instruction.LoadOperand.load(from: &pc))
+        case 279: return .i32Load8UShared(Instruction.LoadOperand.load(from: &pc))
+        case 280: return .i32Load16SShared(Instruction.LoadOperand.load(from: &pc))
+        case 281: return .i32Load16UShared(Instruction.LoadOperand.load(from: &pc))
+        case 282: return .i64Load8SShared(Instruction.LoadOperand.load(from: &pc))
+        case 283: return .i64Load8UShared(Instruction.LoadOperand.load(from: &pc))
+        case 284: return .i64Load16SShared(Instruction.LoadOperand.load(from: &pc))
+        case 285: return .i64Load16UShared(Instruction.LoadOperand.load(from: &pc))
+        case 286: return .i64Load32SShared(Instruction.LoadOperand.load(from: &pc))
+        case 287: return .i64Load32UShared(Instruction.LoadOperand.load(from: &pc))
+        case 288: return .i32StoreShared(Instruction.StoreOperand.load(from: &pc))
+        case 289: return .i64StoreShared(Instruction.StoreOperand.load(from: &pc))
+        case 290: return .f32StoreShared(Instruction.StoreOperand.load(from: &pc))
+        case 291: return .f64StoreShared(Instruction.StoreOperand.load(from: &pc))
+        case 292: return .i32Store8Shared(Instruction.StoreOperand.load(from: &pc))
+        case 293: return .i32Store16Shared(Instruction.StoreOperand.load(from: &pc))
+        case 294: return .i64Store8Shared(Instruction.StoreOperand.load(from: &pc))
+        case 295: return .i64Store16Shared(Instruction.StoreOperand.load(from: &pc))
+        case 296: return .i64Store32Shared(Instruction.StoreOperand.load(from: &pc))
         default: fatalError("Unknown instruction opcode: \(opcode)")
         }
     }
@@ -2330,6 +2445,29 @@ extension Instruction {
         case 271: return "throwRef"
         case 272: return "catchHandlers"
         case 273: return "catchHandlersEnd"
+        case 274: return "i32LoadShared"
+        case 275: return "i64LoadShared"
+        case 276: return "f32LoadShared"
+        case 277: return "f64LoadShared"
+        case 278: return "i32Load8SShared"
+        case 279: return "i32Load8UShared"
+        case 280: return "i32Load16SShared"
+        case 281: return "i32Load16UShared"
+        case 282: return "i64Load8SShared"
+        case 283: return "i64Load8UShared"
+        case 284: return "i64Load16SShared"
+        case 285: return "i64Load16UShared"
+        case 286: return "i64Load32SShared"
+        case 287: return "i64Load32UShared"
+        case 288: return "i32StoreShared"
+        case 289: return "i64StoreShared"
+        case 290: return "f32StoreShared"
+        case 291: return "f64StoreShared"
+        case 292: return "i32Store8Shared"
+        case 293: return "i32Store16Shared"
+        case 294: return "i64Store8Shared"
+        case 295: return "i64Store16Shared"
+        case 296: return "i64Store32Shared"
         default: fatalError("Unknown instruction index: \(opcode)")
         }
     }