Merge bf8f14054c into 10efe291af

include/mimalloc/atomic.h

@@ -373,7 +373,7 @@ static inline void mi_atomic_yield(void) {
 static inline void mi_atomic_yield(void) {
   smt_pause();
 }
-#elif defined(__wasi__)
+#elif defined(__wasm__)
 #include <sched.h>
 static inline void mi_atomic_yield(void) {
   sched_yield();

include/mimalloc/internal.h

@@ -40,10 +40,6 @@ terms of the MIT license. A copy of the license can be found in the file
 #define mi_decl_cache_align
 #endif
 
-#if defined(__EMSCRIPTEN__) && !defined(__wasi__)
-#define __wasi__
-#endif
-
 #if defined(__cplusplus)
 #define mi_decl_externc       extern "C"
 #else
@@ -51,7 +47,7 @@ terms of the MIT license. A copy of the license can be found in the file
 #endif
 
 // pthreads
-#if !defined(_WIN32) && !defined(__wasi__)
+#if !defined(_WIN32) && !defined(__wasm__)
 #define  MI_USE_PTHREADS
 #include <pthread.h>
 #endif
@@ -311,6 +307,14 @@ static inline uintptr_t _mi_align_down(uintptr_t sz, size_t alignment) {
   }
 }
 
+ __attribute__((__unused__)) static void* mi_align_up_ptr(void* p, size_t alignment) {
+  return (void*)_mi_align_up((uintptr_t)p, alignment);
+}
+
+ __attribute__((__unused__)) static void* mi_align_down_ptr(void* p, size_t alignment) {
+  return (void*)_mi_align_down((uintptr_t)p, alignment);
+}
+
 // Divide upwards: `s <= _mi_divide_up(s,d)*d < s+d`.
 static inline uintptr_t _mi_divide_up(uintptr_t size, size_t divider) {
   mi_assert_internal(divider != 0);

include/mimalloc/prim.h

@@ -12,7 +12,7 @@ terms of the MIT license. A copy of the license can be found in the file
 // --------------------------------------------------------------------------
 // This file specifies the primitive portability API.
 // Each OS/host needs to implement these primitives, see `src/prim`
-// for implementations on Window, macOS, WASI, and Linux/Unix.
+// for implementations on Window, macOS, wasm, and Linux/Unix.
 //
 // note: on all primitive functions, we always have result parameters != NUL, and:
 //  addr != NULL and page aligned

src/alloc-override.c

@@ -264,7 +264,7 @@ int   reallocarr(void* p, size_t count, size_t size)    { return mi_reallocarr(p
 void* memalign(size_t alignment, size_t size)           { return mi_memalign(alignment, size); }
 void* _aligned_malloc(size_t alignment, size_t size)    { return mi_aligned_alloc(alignment, size); }
 
-#if defined(__wasi__)
+#if defined(__wasm__)
   // forward __libc interface (see PR #667)
   void* __libc_malloc(size_t size)                      MI_FORWARD1(mi_malloc, size)
   void* __libc_calloc(size_t count, size_t size)        MI_FORWARD2(mi_calloc, count, size)

src/alloc.c

@@ -823,7 +823,7 @@ mi_decl_nodiscard mi_decl_restrict char* mi_strndup(const char* s, size_t n) mi_
   return mi_heap_strndup(mi_prim_get_default_heap(),s,n);
 }
 
-#ifndef __wasi__
+#ifndef __wasm__
 // `realpath` using mi_malloc
 #ifdef _WIN32
 #ifndef PATH_MAX

src/arena.c

@@ -13,7 +13,7 @@ threads and need to be accessed using atomic operations.
 
 Arenas are used to for huge OS page (1GiB) reservations or for reserving
 OS memory upfront which can be improve performance or is sometimes needed
-on embedded devices. We can also employ this with WASI or `sbrk` systems 
+on embedded devices. We can also employ this with wasm or `sbrk` systems
 to reserve large arenas upfront and be able to reuse the memory more effectively.
 
 The arena allocation needs to be thread safe and we use an atomic bitmap to allocate.
@@ -939,4 +939,3 @@ int mi_reserve_huge_os_pages(size_t pages, double max_secs, size_t* pages_reserv
   if (err==0 && pages_reserved!=NULL) *pages_reserved = pages;
   return err;
 }
-

src/os.c

@@ -73,14 +73,6 @@ void _mi_os_init(void) {
 bool _mi_os_decommit(void* addr, size_t size, mi_stats_t* stats);
 bool _mi_os_commit(void* addr, size_t size, bool* is_zero, mi_stats_t* tld_stats);
 
-static void* mi_align_up_ptr(void* p, size_t alignment) {
-  return (void*)_mi_align_up((uintptr_t)p, alignment);
-}
-
-static void* mi_align_down_ptr(void* p, size_t alignment) {
-  return (void*)_mi_align_down((uintptr_t)p, alignment);
-}
-
 
 /* -----------------------------------------------------------
   aligned hinting

src/prim/prim.c

@@ -14,9 +14,9 @@ terms of the MIT license. A copy of the license can be found in the file
 #elif defined(__APPLE__)
 #include "osx/prim.c"      // macOSX (actually defers to mmap in unix/prim.c)
 
-#elif defined(__wasi__)
+#elif defined(__wasm__)
 #define MI_USE_SBRK
-#include "wasi/prim.c"     // memory-grow or sbrk (Wasm)
+#include "wasm/prim.c"     // memory-grow or sbrk (Wasm)
 
 #else
 #include "unix/prim.c"     // mmap() (Linux, macOSX, BSD, Illumnos, Haiku, DragonFly, etc.)

src/prim/readme.md

@@ -3,7 +3,7 @@
 This is the portability layer where all primitives needed from the OS are defined.
 
 - `include/mimalloc/prim.h`: primitive portability API definition.
-- `prim.c`: Selects one of `unix/prim.c`, `wasi/prim.c`, or `windows/prim.c` depending on the host platform
+- `prim.c`: Selects one of `unix/prim.c`, `wasm/prim.c`, or `windows/prim.c` depending on the host platform
             (and on macOS, `osx/prim.c` defers to `unix/prim.c`).
 
 Note: still work in progress, there may still be places in the sources that still depend on OS ifdef's.

src/prim/unix/prim.c

@@ -642,7 +642,7 @@ void _mi_prim_process_info(mi_process_info_t* pinfo)
 
 #else
 
-#ifndef __wasi__
+#ifndef __wasm__
 // WebAssembly instances are not processes
 #pragma message("define a way to get process info")
 #endif

src/prim/wasm/prim.c

@@ -7,6 +7,10 @@ terms of the MIT license. A copy of the license can be found in the file
 
 // This file is included in `src/prim/prim.c`
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
 #include "mimalloc.h"
 #include "mimalloc/internal.h"
 #include "mimalloc/atomic.h"
@@ -30,32 +34,23 @@ void _mi_prim_mem_init( mi_os_mem_config_t* config ) {
 
 int _mi_prim_free(void* addr, size_t size ) {
   MI_UNUSED(addr); MI_UNUSED(size);
-  // wasi heap cannot be shrunk
+  // wasm linear memory cannot be shrunk
   return 0;
 }
 
 
 //---------------------------------------------
-// Allocation: sbrk or memory_grow
+// Allocation: sbrk
 //---------------------------------------------
 
-#if defined(MI_USE_SBRK)
-  static void* mi_memory_grow( size_t size ) {
+static void* mi_memory_grow( size_t size ) {
   void* p = sbrk(size);
   if (p == (void*)(-1)) return NULL;
-    #if !defined(__wasi__) // on wasi this is always zero initialized already (?)
+#if !defined(__wasm__) // on wasm this is always zero initialized already.
   memset(p,0,size);
-    #endif
-    return p;
-  }
-#elif defined(__wasi__)
-  static void* mi_memory_grow( size_t size ) {
-    size_t base = (size > 0 ? __builtin_wasm_memory_grow(0,_mi_divide_up(size, _mi_os_page_size()))
-                            : __builtin_wasm_memory_size(0));
-    if (base == SIZE_MAX) return NULL;
-    return (void*)(base * _mi_os_page_size());
-  }
 #endif
+  return p;
+}
 
 #if defined(MI_USE_PTHREADS)
 static pthread_mutex_t mi_heap_grow_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -96,7 +91,7 @@ static void* mi_prim_mem_grow(size_t size, size_t try_alignment) {
     if (base != NULL) {
       p = mi_align_up_ptr(base, try_alignment);
       if ((uint8_t*)p + size > (uint8_t*)base + alloc_size) {
-        // another thread used wasm_memory_grow/sbrk in-between and we do not have enough
+        // another thread used sbrk in-between and we do not have enough
         // space after alignment. Give up (and waste the space as we cannot shrink :-( )
         // (in `mi_os_mem_alloc_aligned` this will fall back to overallocation to align)
         p = NULL;
@@ -105,7 +100,7 @@ static void* mi_prim_mem_grow(size_t size, size_t try_alignment) {
   }
   /*
   if (p == NULL) {
-    _mi_warning_message("unable to allocate sbrk/wasm_memory_grow OS memory (%zu bytes, %zu alignment)\n", size, try_alignment);
+    _mi_warning_message("unable to allocate sbrk OS memory (%zu bytes, %zu alignment)\n", size, try_alignment);
     errno = ENOMEM;
     return NULL;
   }
@@ -114,7 +109,7 @@ static void* mi_prim_mem_grow(size_t size, size_t try_alignment) {
   return p;
 }
 
-// Note: the `try_alignment` is just a hint and the returned pointer is not guaranteed to be aligned.
+// Note: the `try_alignment` argument is respected by over-allocating.
 int _mi_prim_alloc(size_t size, size_t try_alignment, bool commit, bool allow_large, bool* is_large, bool* is_zero, void** addr) {
   MI_UNUSED(allow_large); MI_UNUSED(commit);
   *is_large = false;
@@ -254,7 +249,8 @@ bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
 //----------------------------------------------------------------
 
 bool _mi_prim_random_buf(void* buf, size_t buf_len) {
-  return false;
+  int r = getentropy(buf, buf_len);
+  return r == 0;
 }
 
 

src/random.c

@@ -175,7 +175,7 @@ static void mi_random_init_ex(mi_random_ctx_t* ctx, bool use_weak) {
   if (use_weak || !_mi_prim_random_buf(key, sizeof(key))) {
     // if we fail to get random data from the OS, we fall back to a
     // weak random source based on the current time
-    #if !defined(__wasi__)
+    #if !defined(__wasm__)
     if (!use_weak) { _mi_warning_message("unable to use secure randomness\n"); }
     #endif
     uintptr_t x = _mi_os_random_weak(0);