merge from dev

test/CMakeLists.txt

@@ -13,7 +13,7 @@ if (NOT CMAKE_BUILD_TYPE)
 endif()
 
 # Import mimalloc (if installed)
-find_package(mimalloc 1.5 REQUIRED NO_SYSTEM_ENVIRONMENT_PATH)
+find_package(mimalloc 1.6 REQUIRED NO_SYSTEM_ENVIRONMENT_PATH)
 message(STATUS "Found mimalloc installed at: ${MIMALLOC_TARGET_DIR}")
 
 # overriding with a dynamic library

test/main-override-static.c

@@ -174,6 +174,7 @@ void mi_bins() {
 static void double_free1();
 static void double_free2();
 static void corrupt_free();
+static void block_overflow1();
 
 
 int main() {
@@ -183,11 +184,12 @@ int main() {
   // double_free1();
   // double_free2();
   // corrupt_free();
+  // block_overflow1();
 
   void* p1 = malloc(78);
   void* p2 = malloc(24);
   free(p1);
-  p1 = malloc(8);
+  p1 = mi_malloc(8);
   //char* s = strdup("hello\n");
   free(p2);
   p2 = malloc(16);
@@ -207,6 +209,11 @@ int main() {
   return 0;
 }
 
+static void block_overflow1() {
+  uint8_t* p = (uint8_t*)mi_malloc(17);
+  p[18] = 0;
+  free(p);
+}
 
 // The double free samples come ArcHeap [1] by Insu Yun (issue #161)
 // [1]: https://arxiv.org/pdf/1903.00503.pdf

test/main-override.cpp

@@ -8,6 +8,33 @@
 #include <new>
 #include <vector>
 
+#include <thread>
+#include <mimalloc.h>
+#include <assert.h>
+
+#ifdef _WIN32
+#include <windows.h>
+static void msleep(unsigned long msecs) { Sleep(msecs); }
+#else
+#include <unistd.h>
+static void msleep(unsigned long msecs) { usleep(msecs * 1000UL); }
+#endif
+
+void heap_no_delete();
+void heap_late_free();
+void padding_shrink();
+void various_tests();
+
+int main() {
+  mi_stats_reset();  // ignore earlier allocations
+  // heap_no_delete();  // issue #202
+  // heap_late_free();  // issue #204
+  padding_shrink();  // issue #209
+  various_tests();
+  mi_stats_print(NULL);
+  return 0;
+}
+
 static void* p = malloc(8);
 
 void free_p() {
@@ -24,21 +51,20 @@ public:
 };
 
 
-int main() {
-  mi_stats_reset();  // ignore earlier allocations
+void various_tests() {  
   atexit(free_p);
   void* p1 = malloc(78);
   void* p2 = mi_malloc_aligned(16,24);
   free(p1);  
   p1 = malloc(8);
   char* s = mi_strdup("hello\n");
-  /*
-  char* s = _strdup("hello\n");
-  char* buf = NULL;
-  size_t len;
-  _dupenv_s(&buf,&len,"MIMALLOC_VERBOSE"); 
-  mi_free(buf);
-  */
+  
+  //char* s = _strdup("hello\n");
+  //char* buf = NULL;
+  //size_t len;
+  //_dupenv_s(&buf,&len,"MIMALLOC_VERBOSE"); 
+  //mi_free(buf);
+  
   mi_free(p2);
   p2 = malloc(16);
   p1 = realloc(p1, 32);
@@ -49,8 +75,6 @@ int main() {
   delete t;
   t = new (std::nothrow) Test(42);
   delete t;  
-  mi_stats_print(NULL);
-  return 0;
 }
 
 class Static {
@@ -84,4 +108,52 @@ bool test_stl_allocator2() {
   vec.push_back(some_struct());
   vec.pop_back();
   return vec.size() == 0;
-}
+}
+
+
+
+// Issue #202
+void heap_no_delete_worker() {
+  mi_heap_t* heap = mi_heap_new();
+  void* q = mi_heap_malloc(heap,1024);
+  // mi_heap_delete(heap); // uncomment to prevent assertion
+}
+
+void heap_no_delete() {
+  auto t1 = std::thread(heap_no_delete_worker);
+  t1.join();  
+}
+
+
+// Issue #204
+volatile void* global_p;
+
+void t1main() {
+  mi_heap_t* heap = mi_heap_new();
+  global_p = mi_heap_malloc(heap, 1024);
+  mi_heap_delete(heap);
+}
+
+void heap_late_free() {
+  auto t1 = std::thread(t1main);
+
+  msleep(2000);
+  assert(global_p);
+  mi_free((void*)global_p);
+
+  t1.join();
+}
+
+// issue  #209
+static void* shared_p;
+static void alloc0(/* void* arg */)
+{
+  shared_p = mi_malloc(8);
+}
+
+void padding_shrink(void)
+{
+  auto t1 = std::thread(alloc0);
+  t1.join();
+  mi_free(shared_p);
+}

test/test-api.c

@@ -31,7 +31,7 @@ we therefore test the API over various inputs. Please add more tests :-)
 #endif
 
 #include "mimalloc.h"
-#include "mimalloc-internal.h"
+// #include "mimalloc-internal.h"
 
 // ---------------------------------------------------------------------------
 // Test macros: CHECK(name,predicate) and CHECK_BODY(name,body)
@@ -98,38 +98,34 @@ int main() {
 
   // ---------------------------------------------------
   // Extended
-  // ---------------------------------------------------
-  #if defined(MI_MALLOC_OVERRIDE) && !defined(_WIN32)
+  // ---------------------------------------------------  
   CHECK_BODY("posix_memalign1", {
     void* p = &p;
-    int err = posix_memalign(&p, sizeof(void*), 32);
-    mi_assert((err==0 && (uintptr_t)p % sizeof(void*) == 0) || p==&p);
+    int err = mi_posix_memalign(&p, sizeof(void*), 32);
+    result = ((err==0 && (uintptr_t)p % sizeof(void*) == 0) || p==&p);
     mi_free(p);
-    result = (err==0);
   });
   CHECK_BODY("posix_memalign_no_align", {
     void* p = &p;
-    int err = posix_memalign(&p, 3, 32);
-    mi_assert(p==&p);
-    result = (err==EINVAL);
+    int err = mi_posix_memalign(&p, 3, 32);
+    result = (err==EINVAL && p==&p);
   });
   CHECK_BODY("posix_memalign_zero", {
     void* p = &p;
-    int err = posix_memalign(&p, sizeof(void*), 0);
+    int err = mi_posix_memalign(&p, sizeof(void*), 0);
     mi_free(p);
     result = (err==0);
   });
   CHECK_BODY("posix_memalign_nopow2", {
     void* p = &p;
-    int err = posix_memalign(&p, 3*sizeof(void*), 32);
+    int err = mi_posix_memalign(&p, 3*sizeof(void*), 32);
     result = (err==EINVAL && p==&p);
   });
   CHECK_BODY("posix_memalign_nomem", {
     void* p = &p;
-    int err = posix_memalign(&p, sizeof(void*), SIZE_MAX);
+    int err = mi_posix_memalign(&p, sizeof(void*), SIZE_MAX);
     result = (err==ENOMEM && p==&p);
   });
-  #endif
 
   // ---------------------------------------------------
   // Aligned API
@@ -140,12 +136,37 @@ int main() {
   CHECK_BODY("malloc-aligned2", {
     void* p = mi_malloc_aligned(48,32); result = (p != NULL && (uintptr_t)(p) % 32 == 0); mi_free(p);
   });
+  CHECK_BODY("malloc-aligned3", {
+    void* p1 = mi_malloc_aligned(48,32); bool result1 = (p1 != NULL && (uintptr_t)(p1) % 32 == 0); 
+    void* p2 = mi_malloc_aligned(48,32); bool result2 = (p2 != NULL && (uintptr_t)(p2) % 32 == 0);
+    mi_free(p2);
+    mi_free(p1);
+    result = (result1&&result2);
+  });
+  CHECK_BODY("malloc-aligned4", {
+    void* p;
+    bool ok = true;
+    for (int i = 0; i < 8 && ok; i++) {
+      p = mi_malloc_aligned(8, 16);
+      ok = (p != NULL && (uintptr_t)(p) % 16 == 0); mi_free(p);
+    }
+    result = ok;
+  });
   CHECK_BODY("malloc-aligned-at1", {
     void* p = mi_malloc_aligned_at(48,32,0); result = (p != NULL && ((uintptr_t)(p) + 0) % 32 == 0); mi_free(p);
   });
   CHECK_BODY("malloc-aligned-at2", {
     void* p = mi_malloc_aligned_at(50,32,8); result = (p != NULL && ((uintptr_t)(p) + 8) % 32 == 0); mi_free(p);
-  });
+  });  
+  CHECK_BODY("memalign1", {
+    void* p;
+    bool ok = true;
+    for (int i = 0; i < 8 && ok; i++) {
+      p = mi_memalign(16,8);
+      ok = (p != NULL && (uintptr_t)(p) % 16 == 0); mi_free(p);
+    }
+    result = ok;
+    });
 
   // ---------------------------------------------------
   // Heaps

test/test-stress.c

@@ -188,7 +188,7 @@ static void test_stress(void) {
         free_items(p);
       }
     }
-    mi_collect(false);
+    // mi_collect(false);
 #ifndef NDEBUG
     if ((n + 1) % 10 == 0) { printf("- iterations left: %3d\n", ITER - (n + 1)); }
 #endif
@@ -206,7 +206,7 @@ static void leak(intptr_t tid) {
   }
 }
 
-static void test_leak(void) {  
+static void test_leak(void) {
   for (int n = 0; n < ITER; n++) {
     run_os_threads(THREADS, &leak);
     mi_collect(false);
@@ -242,14 +242,14 @@ int main(int argc, char** argv) {
 
   // Run ITER full iterations where half the objects in the transfer buffer survive to the next round.
   srand(0x7feb352d);
-  mi_stats_reset();
+  // mi_stats_reset();
 #ifdef STRESS
     test_stress();
 #else
     test_leak();
-#endif  
+#endif
 
-  mi_collect(true);
+  // mi_collect(true);
   mi_stats_print(NULL);
   //bench_end_program();
   return 0;
@@ -262,7 +262,7 @@ static void (*thread_entry_fun)(intptr_t) = &stress;
 
 #include <windows.h>
 
-static DWORD WINAPI thread_entry(LPVOID param) {  
+static DWORD WINAPI thread_entry(LPVOID param) {
   thread_entry_fun((intptr_t)param);
   return 0;
 }