Wiring SharedMemory with it's corresponding bindings

wasmtime/__init__.py

@@ -31,6 +31,7 @@
 from ._instance import Instance
 from ._wasi import WasiConfig
 from ._linker import Linker
+from ._sharedmemory import SharedMemory
 
 __all__ = [
     'wat2wasm',
@@ -50,6 +51,7 @@
     'Caller',
     'Table',
     'Memory',
+    'SharedMemory',
     'Global',
     'Trap',
     'TrapCode',

wasmtime/_extern.py

@@ -5,7 +5,7 @@
 
 
 def wrap_extern(ptr: ffi.wasmtime_extern_t) -> AsExtern:
-    from wasmtime import Func, Table, Global, Memory, Module, Instance
+    from wasmtime import Func, Table, Global, Memory, SharedMemory, Module, Instance
 
     if ptr.kind == ffi.WASMTIME_EXTERN_FUNC.value:
         return Func._from_raw(ptr.of.func)
@@ -15,6 +15,8 @@ def wrap_extern(ptr: ffi.wasmtime_extern_t) -> AsExtern:
         return Global._from_raw(ptr.of.global_)
     if ptr.kind == ffi.WASMTIME_EXTERN_MEMORY.value:
         return Memory._from_raw(ptr.of.memory)
+    if ptr.kind == ffi.WASMTIME_EXTERN_SHAREDMEMORY.value:
+        return SharedMemory._from_raw(ptr.of.sharedmemory)
     if ptr.kind == ffi.WASMTIME_EXTERN_INSTANCE.value:
         return Instance._from_raw(ptr.of.instance)
     if ptr.kind == ffi.WASMTIME_EXTERN_MODULE.value:
@@ -23,14 +25,16 @@ def wrap_extern(ptr: ffi.wasmtime_extern_t) -> AsExtern:
 
 
 def get_extern_ptr(item: AsExtern) -> ffi.wasmtime_extern_t:
-    from wasmtime import Func, Table, Global, Memory, Module, Instance
+    from wasmtime import Func, Table, Global, Memory, SharedMemory, Module, Instance
 
     if isinstance(item, Func):
         return item._as_extern()
     elif isinstance(item, Global):
         return item._as_extern()
     elif isinstance(item, Memory):
         return item._as_extern()
+    elif isinstance(item, SharedMemory):
+        return item._as_extern()
     elif isinstance(item, Table):
         return item._as_extern()
     elif isinstance(item, Module):

wasmtime/_ffi.py

@@ -53,6 +53,7 @@
 WASMTIME_EXTERN_GLOBAL = c_uint8(1)
 WASMTIME_EXTERN_TABLE = c_uint8(2)
 WASMTIME_EXTERN_MEMORY = c_uint8(3)
+WASMTIME_EXTERN_SHAREDMEMORY = c_uint8(4)
 WASMTIME_EXTERN_INSTANCE = c_uint8(4)
 WASMTIME_EXTERN_MODULE = c_uint8(5)
 

wasmtime/_sharedmemory.py

@@ -0,0 +1,74 @@
+from . import _ffi as ffi
+from ctypes import *
+import ctypes
+from wasmtime import MemoryType, WasmtimeError, Engine, Managed
+from ._store import Storelike
+
+
+
+class SharedMemory(Managed["ctypes._Pointer[ffi.wasmtime_sharedmemory_t]"]):
+    def __init__(self, engine: Engine, ty: MemoryType):
+        """
+        Creates a new shared memory in `store` with the given `ty`
+        """
+
+        sharedmemory = ffi.wasmtime_sharedmemory_t()
+        ptr = POINTER(ffi.wasmtime_sharedmemory_t)()
+        error = ffi.wasmtime_sharedmemory_new(engine.ptr(), ty.ptr(), byref(ptr))
+        if error:
+            raise WasmtimeError._from_ptr(error)
+        self._set_ptr(sharedmemory)
+
+    @classmethod
+    def _from_raw(cls, sharedmemory: ffi.wasmtime_sharedmemory_t) -> "SharedMemory":
+        ty: "SharedMemory" = cls.__new__(cls)
+        ty._set_ptr(sharedmemory)
+        return ty
+
+    def type(self) -> MemoryType:
+        """
+        Gets the type of this memory as a `MemoryType`
+        """
+
+        ptr = ffi.wasmtime_sharedmemory_type(byref(self._sharedmemory))
+        return MemoryType._from_ptr(ptr, None)
+
+    def grow(self, delta: int) -> int:
+        """
+        Grows this memory by the given number of pages
+        """
+
+        if delta < 0:
+            raise WasmtimeError("cannot grow by negative amount")
+        prev = ffi.c_uint64(0)
+        error = ffi.wasmtime_sharedmemory_grow(byref(self.ptr()), delta, byref(prev))
+        if error:
+            raise WasmtimeError._from_ptr(error)
+        return prev.value
+
+    def size(self) -> int:
+        """
+        Returns the size, in WebAssembly pages, of this shared memory.
+        """
+
+        return ffi.wasmtime_sharedmemory_size(byref(self.ptr()))
+
+    def data_ptr(self) -> "ctypes._Pointer[c_ubyte]":
+        """
+        Returns the raw pointer in memory where this wasm shared memory lives.
+
+        Remember that all accesses to wasm shared memory should be bounds-checked
+        against the `data_len` method.
+        """
+        return ffi.wasmtime_sharedmemory_data(byref(self.ptr()))
+
+    def data_len(self) -> int:
+        """
+        Returns the raw byte length of this memory.
+        """
+
+        return ffi.wasmtime_sharedmemory_data_size(byref(self.ptr()))
+
+    def _as_extern(self) -> ffi.wasmtime_extern_t:
+        union = ffi.wasmtime_extern_union(sharedmemory=pointer(self.ptr()))
+        return ffi.wasmtime_extern_t(ffi.WASMTIME_EXTERN_SHAREDMEMORY, union)

wasmtime/_types.py

@@ -282,7 +282,7 @@ def _as_extern(self) -> "ctypes._Pointer[ffi.wasm_externtype_t]":
 
 
 class MemoryType(Managed["ctypes._Pointer[ffi.wasm_memorytype_t]"]):
-    def __init__(self, limits: Limits, is_64: bool = False):
+    def __init__(self, limits: Limits, is_64: bool = False, shared: bool = True):
         if not isinstance(limits, Limits):
             raise TypeError("expected Limits")
         if is_64:
@@ -296,7 +296,8 @@ def __init__(self, limits: Limits, is_64: bool = False):
         ptr = ffi.wasmtime_memorytype_new(limits.min,
                                           limits.max is not None,
                                           limits.max if limits.max else 0,
-                                          is_64)
+                                          is_64,
+                                          shared)
         if not ptr:
             raise WasmtimeError("failed to allocate MemoryType")
         self._set_ptr(ptr)
@@ -331,10 +332,18 @@ def is_64(self) -> bool:
         Returns whether or not this is a 64-bit memory
         """
         return ffi.wasmtime_memorytype_is64(self.ptr())
+
+    @property
+    def is_shared(self) -> bool:
+        """
+        Returns whether or not this is a shared memory
+        """
+        return ffi.wasmtime_memorytype_isshared(self.ptr())
+
 
     def _as_extern(self) -> "ctypes._Pointer[ffi.wasm_externtype_t]":
         return ffi.wasm_memorytype_as_externtype_const(self.ptr())
-
+    
 
 def wrap_externtype(ptr: "ctypes._Pointer[ffi.wasm_externtype_t]", owner: Optional[Any]) -> "AsExternType":
     if not isinstance(ptr, POINTER(ffi.wasm_externtype_t)):