@shd101wyy/yo 0.1.24 → 0.1.25

package/vendor/mimalloc/src/threadlocal.c

@@ -1,5 +1,5 @@
 /* ----------------------------------------------------------------------------
-Copyright (c) 2019-2025, Microsoft Research, Daan Leijen
+Copyright (c) 2019-2026, Microsoft Research, Daan Leijen
 This is free software; you can redistribute it and/or modify it under the
 terms of the MIT license. A copy of the license can be found in the file
 "LICENSE" at the root of this distribution.
@@ -16,21 +16,60 @@ that can be allocated.
 #include "mimalloc/prim.h"
 
 /* -----------------------------------------------------------
-Each thread can have (a dynamically expanding) array of
-thread-local values.
+  Each thread can have (a dynamically expanding) array of
+  thread-local values. Each slot has a value and a version.
+  The version is used to safely reuse slots.
 ----------------------------------------------------------- */
+typedef struct mi_tls_slot_s {
+  size_t  version;
+  void*   value;
+} mi_tls_slot_t;
 
 typedef struct mi_thread_locals_s {
-  size_t count;
-  void*  slots[1];
+  size_t        count;
+  mi_tls_slot_t slots[1];
 } mi_thread_locals_t;
 
-static mi_thread_locals_t mi_thread_locals_empty = { 0, {NULL} };
+static mi_thread_locals_t mi_thread_locals_empty = { 0, {{0,NULL}} };
 
 mi_decl_thread mi_thread_locals_t* mi_thread_locals = &mi_thread_locals_empty;  // always point to a valid `mi_thread_locals_t`
 
+
+/* -----------------------------------------------------------
+  Each key consists of the slot index in the lower bits,
+  and its version it the top bits. When we get a value
+  the version must match or we return NULL. When we set
+  a value, we also set the version of the key.
+----------------------------------------------------------- */
+
+#if MI_SIZE_BITS < 64
+#define MI_TLS_IDX_BITS     (MI_SIZE_BITS/2)      // half for the index, half for the version
+#else
+#define MI_TLS_IDX_BITS     (MI_SIZE_BITS/4)      // 16 bits for the index, 48 bits for the version
+#endif
+#define MI_TLS_IDX_MASK     ((MI_ZU(1)<<MI_TLS_IDX_BITS)-1)
+#define MI_TLS_IDX_MAX      MI_TLS_IDX_MASK
+#define MI_TLS_VERSION_MAX  ((MI_ZU(1)<<(MI_SIZE_BITS - MI_TLS_IDX_BITS))-1)
+
+static size_t mi_key_index( size_t key ) {
+  return (key & MI_TLS_IDX_MASK);
+}
+
+static size_t mi_key_version( size_t key ) {
+  return (key >> MI_TLS_IDX_BITS);
+}
+
+static mi_thread_local_t mi_key_create( size_t index, size_t version ) {
+  mi_assert_internal(version != 0 && version <= MI_TLS_VERSION_MAX);
+  mi_assert_internal(index <= MI_TLS_IDX_MAX);
+  const mi_thread_local_t key = ((version << MI_TLS_IDX_BITS) | index);
+  mi_assert_internal(key != 0);
+  return key;
+}
+
+
 // dynamically reallocate the thread local slots when needed
-static mi_thread_locals_t* mi_thread_locals_expand(mi_thread_local_t atleast) {
+static mi_thread_locals_t* mi_thread_locals_expand(size_t least_idx) {
   mi_thread_locals_t* tls_old = mi_thread_locals;
   const size_t count_old = tls_old->count;
   size_t count;
@@ -44,10 +83,11 @@ static mi_thread_locals_t* mi_thread_locals_expand(mi_thread_local_t atleast) {
   else {
     count = 2*count_old;       // and double initially
   }
-  if (count <= atleast) {
-    count = atleast + 1;
+  if (count <= least_idx) {   
+    count = least_idx + 1;
   }
-  mi_thread_locals_t* tls = (mi_thread_locals_t*)mi_rezalloc(tls_old, sizeof(mi_thread_locals_t) + count*sizeof(void*));
+  if (count > MI_TLS_IDX_MAX) { return NULL; }  // too large
+  mi_thread_locals_t* tls = (mi_thread_locals_t*)mi_rezalloc(tls_old, sizeof(mi_thread_locals_t) + count*sizeof(mi_tls_slot_t));
   if mi_unlikely(tls==NULL) return NULL;
   tls->count = count;
   mi_thread_locals = tls;
@@ -56,11 +96,13 @@ static mi_thread_locals_t* mi_thread_locals_expand(mi_thread_local_t atleast) {
 
 static mi_decl_noinline bool mi_thread_local_set_expand( mi_thread_local_t key, void* val ) {
   if (val==NULL) return true;
-  mi_thread_locals_t* tls = mi_thread_locals_expand(key);
+  const size_t idx = mi_key_index(key);  
+  mi_thread_locals_t* tls = mi_thread_locals_expand(idx);
   if (tls==NULL) return false;
-  mi_assert_internal(key < tls->count);
   mi_assert_internal(tls == mi_thread_locals);
-  tls->slots[key] = val;
+  mi_assert_internal(idx < tls->count);
+  tls->slots[idx].value = val;
+  tls->slots[idx].version = mi_key_version(key);
   return true;
 }
 
@@ -69,8 +111,11 @@ static mi_decl_noinline bool mi_thread_local_set_expand( mi_thread_local_t key,
 bool _mi_thread_local_set( mi_thread_local_t key, void* val ) {
   mi_thread_locals_t* tls = mi_thread_locals;
   mi_assert_internal(tls!=NULL);
-  if mi_likely(key < tls->count) {
-    tls->slots[key] = val;
+  mi_assert_internal(key!=0);
+  const size_t idx = mi_key_index(key);
+  if mi_likely(idx < tls->count) {
+    tls->slots[idx].value = val;
+    tls->slots[idx].version = mi_key_version(key);
     return true;
   }
   else {
@@ -82,11 +127,13 @@ bool _mi_thread_local_set( mi_thread_local_t key, void* val ) {
 void* _mi_thread_local_get( mi_thread_local_t key ) {
   const mi_thread_locals_t* const tls = mi_thread_locals;
   mi_assert_internal(tls!=NULL);
-  if mi_likely(key < tls->count) {
-    return tls->slots[key];
+  mi_assert_internal(key!=0);
+  const size_t idx = mi_key_index(key);
+  if mi_likely(idx < tls->count && mi_key_version(key) == tls->slots[idx].version) {
+    return tls->slots[idx].value;
   }
   else {
-    return NULL;
+    return NULL;  
   }
 }
 
@@ -105,6 +152,7 @@ Create and free fresh TLS key's
 
 static mi_lock_t    mi_thread_locals_lock;    // we need a lock in order to re-allocate the slot bits
 static mi_bitmap_t* mi_thread_locals_free;    // reuse an arena bitmap to track which slots were assigned (1=free, 0=in-use)
+static size_t       mi_thread_locals_version; // version to be able to reuse slots safely
 
 void _mi_thread_locals_init(void) {
   mi_lock_init(&mi_thread_locals_lock);
@@ -119,43 +167,56 @@ void _mi_thread_locals_done(void) {
 }
 
 // strange signature but allows us to reuse the arena code for claiming free pages
-static bool mi_thread_local_claim(size_t _slice_index, mi_arena_t* _arena, bool* keep_set) {
+static bool mi_thread_local_claim_fun(size_t _slice_index, mi_arena_t* _arena, bool* keep_set) {
   MI_UNUSED(_slice_index); MI_UNUSED(_arena);
   *keep_set = false;
   return true;
 }
 
-static mi_thread_local_t mi_thread_local_create_expand(void) {
-  size_t key = 0;
-  mi_bitmap_t* slots = mi_thread_locals_free;
+// When we claim a free slot, we increase the global version counter 
+// (so if we reuse a slot it will be returning NULL initially when a thread tries to get it)
+static mi_thread_local_t mi_thread_local_claim(void) {
+  size_t idx = 0;
+  if (mi_thread_locals_free != NULL && mi_bitmap_try_find_and_claim(mi_thread_locals_free,0,&idx,&mi_thread_local_claim_fun,NULL)) {
+    mi_thread_locals_version++;
+    if (mi_thread_locals_version >= MI_TLS_VERSION_MAX) { mi_thread_locals_version = 1; }  /* wrap around the version */
+    return mi_key_create( idx, mi_thread_locals_version);
+  }
+  else {
+    return 0;
+  }
+}
+
+static bool mi_thread_local_create_expand(void) {
+  mi_bitmap_t* const slots = mi_thread_locals_free;
   // 1024 bits at a time
   const size_t oldcount = (slots==NULL ? 0 : mi_bitmap_max_bits(slots));
   const size_t newcount = 1024 + oldcount;
+  if (newcount > MI_TLS_IDX_MAX) { return false; }
   const size_t newsize = mi_bitmap_size( newcount, NULL );
-  slots = (mi_bitmap_t*)mi_realloc_aligned(slots, newsize, MI_BCHUNK_SIZE);
-  if (slots != NULL) {
-    mi_bitmap_init(slots, newcount, true /* or otherwise we would zero all old entries */);
-    mi_bitmap_unsafe_setN(slots, oldcount, newcount - oldcount);
-    mi_thread_locals_free = slots;
-    size_t idx = 0;
-    if mi_likely(slots!=NULL && mi_bitmap_try_find_and_claim(slots,0,&idx,&mi_thread_local_claim,NULL)) {
-      key = idx+1;
-    }
+  mi_bitmap_t* newslots = (mi_bitmap_t*)mi_zalloc_aligned(newsize, MI_BCHUNK_SIZE);
+  if (newslots==NULL) { return false; }
+  if (slots!=NULL) {
+    // copy over the previous bitmap
+    _mi_memcpy_aligned(newslots, slots, mi_bitmap_size(oldcount, NULL)); 
+    mi_free(slots);
   }
-  return key;
+  mi_bitmap_init(newslots, newcount, true /* pretend already zero'd so we do not zero out the copied old entries */);
+  mi_bitmap_unsafe_setN(newslots, oldcount, newcount - oldcount);  /* set the new expanded slots as available */
+  mi_thread_locals_free = newslots;
+  return true;
 }
 
+
 // create a fresh key
 mi_thread_local_t _mi_thread_local_create(void) {
   mi_thread_local_t key = 0;
   mi_lock(&mi_thread_locals_lock) {
-    mi_bitmap_t* slots = mi_thread_locals_free;
-    size_t idx = 0;
-    if mi_likely(slots!=NULL && mi_bitmap_try_find_and_claim(slots,0,&idx,&mi_thread_local_claim,NULL)) {
-      key = idx+1;
-    }
-    else {
-      key = mi_thread_local_create_expand();
+    key = mi_thread_local_claim();
+    if (key==0) {
+      if (mi_thread_local_create_expand()) {
+        key = mi_thread_local_claim();
+      }
     }
   }
   return key;
@@ -164,11 +225,11 @@ mi_thread_local_t _mi_thread_local_create(void) {
 // free a key
 void _mi_thread_local_free(mi_thread_local_t key) {
   if (key==0) return;
-  const size_t idx = key-1;
+  const size_t idx = mi_key_index(key);
   mi_lock(&mi_thread_locals_lock) {
     mi_bitmap_t* const slots = mi_thread_locals_free;
     if (slots!=NULL && idx < mi_bitmap_max_bits(slots)) {
-      mi_bitmap_set(slots,key-1);
+      mi_bitmap_set(slots,idx);
     }
   }
 }

package/vendor/mimalloc/test/main-override-static.c

@@ -28,11 +28,20 @@ static void test_canary_leak(void);
 static void test_manage_os_memory(void);
 // static void test_large_pages(void);
 
+#if _WIN32
+#include "main-static-dep.h"
+static void test_dep();               // test static mimalloc in a separate DLL
+#else
+static void test_dep() {};
+#endif
+
 
 int main() {
   mi_version();
   mi_stats_reset();
 
+  test_dep();
+
   // mi_bins();
 
   // test_manage_os_memory();
@@ -190,10 +199,10 @@ static void test_process_info(void) {
 }
 
 static void test_reserved(void) {
-#define KiB 1024ULL
+#define KiB 1024UL
 #define MiB (KiB*KiB)
 #define GiB (MiB*KiB)
-  mi_reserve_os_memory(3*GiB, false, true);
+  mi_reserve_os_memory(3500*MiB, false, true);
   void* p1 = malloc(100);
   void* p2 = malloc(100000);
   void* p3 = malloc(2*GiB);
@@ -276,6 +285,26 @@ static void test_manage_os_memory(void) {
 }
 #endif
 
+#if _WIN32
+
+static void call_library(void) {
+  HMODULE dll = LoadLibraryA("mimalloc-test-static-dep.dll");
+  if (dll != NULL) {
+    TestFun fun = (TestFun)GetProcAddress(dll, "Test");
+    if (fun != NULL) {
+      fun();
+    }
+    bool ok = FreeLibrary(dll);
+    if (!ok) printf("unable to free library: %i\n", ok);
+  }
+}
+
+static void test_dep(void) {
+  call_library();
+  call_library();
+}
+#endif
+
 // Experiment with huge OS pages
 #if 0
 

package/vendor/mimalloc/test/main-override.c

@@ -2,35 +2,48 @@
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
-
-#include <mimalloc-override.h>
+#include <mimalloc.h>
+// #include <mimalloc-override.h>
 
 int main() {
   mi_version();       // ensure mimalloc library is linked
   void* p1 = malloc(78);
+  _expand(p1, 100);
+  if (!mi_is_in_heap_region(p1)) {
+     printf("p1: malloc failed to allocate in heap region\n");
+     return 1;
+  }
+  
+
   void* p2 = malloc(24);
+  if (!mi_is_in_heap_region(p2)) {
+     printf("p2: malloc failed to allocate in heap region\n");
+     return 1;
+  }
   free(p1);
   p1 = malloc(8);
-  //char* s = strdup("hello\n");
+  char* s = strdup("hello\n");
   free(p2);
   p2 = malloc(16);
-  p1 = realloc(p1, 32);
+  void* p3 = realloc(p1, 32); if (p3!=NULL) { p1 = p3; }
   free(p1);
   free(p2);
-  //free(s);
+  free(s);
   //mi_collect(true);
 
   /* now test if override worked by allocating/freeing across the api's*/
-  //p1 = mi_malloc(32);
-  //free(p1);
-  //p2 = malloc(32);
-  //mi_free(p2);
-  p1 = malloc(24);
-  p2 = reallocarray(p1, 16, 16);
-  free(p2);
-  p1 = malloc(24);
-  assert(reallocarr(&p1, 16, 16) == 0);
+  p1 = mi_malloc(32);
   free(p1);
+  p2 = malloc(32);
+  mi_free(p2);
+
+  //p1 = malloc(24);
+  //p2 = reallocarray(p1, 16, 16);
+  //free(p2);
+  //p1 = malloc(24);
+  //assert(reallocarr(&p1, 16, 16) == 0);
+  //free(p1);
+
   mi_stats_print(NULL);
   return 0;
 }

package/vendor/mimalloc/test/main-static-dep.cpp

@@ -0,0 +1,46 @@
+// test allocation in a DLL that is statically linked to mimalloc
+#include <string>
+#include <iostream>
+#include "main-static-dep.h"
+#include <mimalloc.h>
+
+class Static {
+private:
+  void* p;
+public:
+  Static() {
+    printf("static-dep: static constructor\n");
+    p = mi_malloc(64);
+    return;
+  }
+  ~Static() {
+    mi_free(p);
+    printf("static-dep: static destructor\n");
+    return;
+  }
+};
+
+static Static s = Static();
+
+void Test(void) {
+  char* s = mi_mallocn_tp(char, 128);
+  strcpy_s(s, 128, "hello world!");
+  printf("message from static dll: %s\n", s);
+  mi_free(s);
+}
+
+
+#include <windows.h>
+
+BOOL WINAPI DllMain(HINSTANCE module, DWORD reason, LPVOID reserved) {
+  (void)(reserved);
+  (void)(module);
+  if (reason==DLL_PROCESS_ATTACH) {
+    printf("static-dep: dll attach\n");
+  }
+  else if (reason==DLL_PROCESS_DETACH) {
+    mi_option_enable(mi_option_destroy_on_exit);
+    printf("static-dep: dll detach\n");
+  }
+  return TRUE;
+}

package/vendor/mimalloc/test/main-static-dep.h

@@ -0,0 +1,11 @@
+#pragma once
+
+typedef void (__stdcall * TestFun)(void);
+
+#if __cplusplus
+extern "C" 
+#endif
+__declspec(dllexport) void __cdecl Test(void);
+
+
+

package/vendor/mimalloc/test/test-api-fill.c

@@ -310,7 +310,7 @@ bool check_zero_init(uint8_t* p, size_t size) {
 
 #if MI_DEBUG >= 2
 bool check_debug_fill_uninit(uint8_t* p, size_t size) {
-#if MI_TRACK_VALGRIND || MI_TRACK_ASAN
+#if MI_TRACK_VALGRIND || MI_TRACK_ASAN || MI_GUARDED
   (void)p; (void)size;
   return true; // when compiled with valgrind we don't init on purpose
 #else
@@ -326,7 +326,7 @@ bool check_debug_fill_uninit(uint8_t* p, size_t size) {
 }
 
 bool check_debug_fill_freed(uint8_t* p, size_t size) {
-#if MI_TRACK_VALGRIND
+#if MI_TRACK_VALGRIND || MI_GUARDED
   (void)p; (void)size;
   return true; // when compiled with valgrind we don't fill on purpose
 #else

package/vendor/mimalloc/test/test-stress.c

@@ -360,8 +360,8 @@ int main(int argc, char** argv) {
     mi_option_enable(mi_option_visit_abandoned);
   #endif
   #if !defined(NDEBUG) && !defined(USE_STD_MALLOC)
-    mi_option_set(mi_option_arena_reserve, 32 * 1024 /* in kib = 32MiB */);
-    mi_option_set(mi_option_purge_delay,1);
+    mi_option_set(mi_option_arena_reserve, mi_arena_min_size()/1024 /* in KiB ! */);
+    mi_option_set(mi_option_purge_delay,1);    
   #endif
   #if defined(NDEBUG) && !defined(USE_STD_MALLOC)
     // mi_option_set(mi_option_purge_delay,-1);
@@ -422,7 +422,7 @@ int main(int argc, char** argv) {
   //  fputs(json,stderr);
   //  mi_free(json);
   //}
-  #endif
+  #endif  
   mi_collect(true);
   mi_stats_print(NULL);
 #endif

package/vendor/mimalloc/test/test-wrong.c

@@ -53,8 +53,11 @@ terms of the MIT license. A copy of the license can be found in the file
 #endif
 
 int main(int argc, char** argv) {
+  (void)(argc);
+  (void)(argv);
   int* p = (int*)mi(malloc)(3*sizeof(int));
-
+  p[0] = 1;
+  
   int* r = (int*)mi_malloc_aligned(8,16);
   mi_free(r);
 
@@ -64,19 +67,20 @@ int main(int argc, char** argv) {
   mi(free)(c);
 
   // undefined access
-  int* q = (int*)mi(malloc)(sizeof(int));
-  printf("undefined: %d\n", *q);
+  long* q = (long*)mi(malloc)(sizeof(long));
+  printf("undefined: %ld\n", *q);
 
   // illegal int read
-  printf("invalid: over: %d, under: %d\n", q[1], q[-1]);
+  printf("invalid: over: %ld, under: %ld\n", q[1], q[-1]);
 
   *q = 42;
 
   // buffer overflow
   q[1] = 43;
+  q[2] = 44;
 
   // buffer underflow
-  q[-1] = 44;
+  q[-1] = 41;
 
   mi(free)(q);
 
@@ -84,9 +88,9 @@ int main(int argc, char** argv) {
   mi(free)(q);
 
   // use after free
-  printf("use-after-free: %d\n", *q);
+  printf("use-after-free: %ld\n", *q);
 
   // leak p
   // mi_free(p)
   return 0;
-}
+}