From d7105c20a9020116bd5bdbacaa61e9458f53ea52 Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Tue, 21 Dec 2021 12:39:17 +0100 Subject: [PATCH 01/22] Move test macros/helpers to a separate header --- test/test-api.c | 34 ++------------------------------ test/testhelper.h | 49 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+), 32 deletions(-) create mode 100644 test/testhelper.h diff --git a/test/test-api.c b/test/test-api.c index f057799a..8ecd31a1 100644 --- a/test/test-api.c +++ b/test/test-api.c @@ -23,7 +23,6 @@ we therefore test the API over various inputs. Please add more tests :-) [1] https://github.com/daanx/mimalloc-bench */ -#include #include #include #include @@ -36,33 +35,7 @@ we therefore test the API over various inputs. Please add more tests :-) #include "mimalloc.h" // #include "mimalloc-internal.h" -// --------------------------------------------------------------------------- -// Test macros: CHECK(name,predicate) and CHECK_BODY(name,body) -// --------------------------------------------------------------------------- -static int ok = 0; -static int failed = 0; - -#define CHECK_BODY(name,body) \ - do { \ - fprintf(stderr,"test: %s... ", name ); \ - bool result = true; \ - do { body } while(false); \ - if (!(result)) { \ - failed++; \ - fprintf(stderr, \ - "\n FAILED: %s:%d:\n %s\n", \ - __FILE__, \ - __LINE__, \ - #body); \ - /* exit(1); */ \ - } \ - else { \ - ok++; \ - fprintf(stderr,"ok.\n"); \ - } \ - } while (false) - -#define CHECK(name,expr) CHECK_BODY(name,{ result = (expr); }) +#include "testhelper.h" // --------------------------------------------------------------------------- // Test functions @@ -219,10 +192,7 @@ int main(void) { // --------------------------------------------------- // Done // ---------------------------------------------------[] - fprintf(stderr,"\n\n---------------------------------------------\n" - "succeeded: %i\n" - "failed : %i\n\n", ok, failed); - return failed; + return print_test_summary(); } // --------------------------------------------------- diff --git a/test/testhelper.h b/test/testhelper.h new file mode 100644 index 00000000..46d63a00 --- /dev/null +++ b/test/testhelper.h @@ -0,0 +1,49 @@ +/* ---------------------------------------------------------------------------- +Copyright (c) 2018-2020, 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. +-----------------------------------------------------------------------------*/ +#ifndef TESTHELPER_H_ +#define TESTHELPER_H_ + +#include + +// --------------------------------------------------------------------------- +// Test macros: CHECK(name,predicate) and CHECK_BODY(name,body) +// --------------------------------------------------------------------------- +static int ok = 0; +static int failed = 0; + +#define CHECK_BODY(name,body) \ + do { \ + fprintf(stderr,"test: %s... ", name ); \ + bool result = true; \ + do { body } while(false); \ + if (!(result)) { \ + failed++; \ + fprintf(stderr, \ + "\n FAILED: %s:%d:\n %s\n", \ + __FILE__, \ + __LINE__, \ + #body); \ + /* exit(1); */ \ + } \ + else { \ + ok++; \ + fprintf(stderr,"ok.\n"); \ + } \ + } while (false) + +#define CHECK(name,expr) CHECK_BODY(name,{ result = (expr); }) + +// Print summary of test. Return value can be directly use as a return value for main(). +static inline int print_test_summary(void) +{ + fprintf(stderr,"\n\n---------------------------------------------\n" + "succeeded: %i\n" + "failed : %i\n\n", ok, failed); + return failed; +} + +#endif // TESTHELPER_H_ From 51271ba8ea47e250d22fe6b7a2f6813c07336cca Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Tue, 21 Dec 2021 12:54:15 +0100 Subject: [PATCH 02/22] Replace redundant CMake code for tests with a loop --- CMakeLists.txt | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4d52a72d..5a682bf7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -373,21 +373,17 @@ endif() # ----------------------------------------------------------------------------- if (MI_BUILD_TESTS) - add_executable(mimalloc-test-api test/test-api.c) - target_compile_definitions(mimalloc-test-api PRIVATE ${mi_defines}) - target_compile_options(mimalloc-test-api PRIVATE ${mi_cflags}) - target_include_directories(mimalloc-test-api PRIVATE include) - target_link_libraries(mimalloc-test-api PRIVATE mimalloc ${mi_libraries}) - - add_executable(mimalloc-test-stress test/test-stress.c) - target_compile_definitions(mimalloc-test-stress PRIVATE ${mi_defines}) - target_compile_options(mimalloc-test-stress PRIVATE ${mi_cflags}) - target_include_directories(mimalloc-test-stress PRIVATE include) - target_link_libraries(mimalloc-test-stress PRIVATE mimalloc ${mi_libraries}) - enable_testing() - add_test(test_api, mimalloc-test-api) - add_test(test_stress, mimalloc-test-stress) + + foreach(TEST_NAME api stress) + add_executable(mimalloc-test-${TEST_NAME} test/test-${TEST_NAME}.c) + target_compile_definitions(mimalloc-test-${TEST_NAME} PRIVATE ${mi_defines}) + target_compile_options(mimalloc-test-${TEST_NAME} PRIVATE ${mi_cflags}) + target_include_directories(mimalloc-test-${TEST_NAME} PRIVATE include) + target_link_libraries(mimalloc-test-${TEST_NAME} PRIVATE mimalloc ${mi_libraries}) + + add_test(NAME test-${TEST_NAME} COMMAND mimalloc-test-${TEST_NAME}) + endforeach() endif() # ----------------------------------------------------------------------------- From 969f3a6998c194d3f359072e5e6067b1581965e7 Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Sun, 19 Dec 2021 19:45:39 +0100 Subject: [PATCH 03/22] Add tests for zero-initialization functions --- CMakeLists.txt | 2 +- test/test-api-fill.c | 180 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 181 insertions(+), 1 deletion(-) create mode 100644 test/test-api-fill.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 5a682bf7..47366c49 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -375,7 +375,7 @@ endif() if (MI_BUILD_TESTS) enable_testing() - foreach(TEST_NAME api stress) + foreach(TEST_NAME api api-fill stress) add_executable(mimalloc-test-${TEST_NAME} test/test-${TEST_NAME}.c) target_compile_definitions(mimalloc-test-${TEST_NAME} PRIVATE ${mi_defines}) target_compile_options(mimalloc-test-${TEST_NAME} PRIVATE ${mi_cflags}) diff --git a/test/test-api-fill.c b/test/test-api-fill.c new file mode 100644 index 00000000..404dcb7f --- /dev/null +++ b/test/test-api-fill.c @@ -0,0 +1,180 @@ +/* ---------------------------------------------------------------------------- +Copyright (c) 2018-2020, 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. +-----------------------------------------------------------------------------*/ +#include "mimalloc.h" +#include "mimalloc-types.h" + +#include "testhelper.h" + +// --------------------------------------------------------------------------- +// Helper functions +// --------------------------------------------------------------------------- +bool check_zero_init(uint8_t* p, size_t size); + +// --------------------------------------------------------------------------- +// Main testing +// --------------------------------------------------------------------------- +int main(void) { + mi_option_disable(mi_option_verbose); + + // --------------------------------------------------- + // Zeroing allocation + // --------------------------------------------------- + CHECK_BODY("zeroinit-zalloc-small", { + size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size); + result = check_zero_init(p, zalloc_size); + mi_free(p); + }); + CHECK_BODY("zeroinit-zalloc-large", { + size_t zalloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size); + result = check_zero_init(p, zalloc_size); + mi_free(p); + }); + CHECK_BODY("zeroinit-zalloc_small", { + size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_zalloc_small(zalloc_size); + result = check_zero_init(p, zalloc_size); + mi_free(p); + }); + + CHECK_BODY("zeroinit-calloc-small", { + size_t calloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1); + result = check_zero_init(p, calloc_size); + mi_free(p); + }); + CHECK_BODY("zeroinit-calloc-large", { + size_t calloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1); + result = check_zero_init(p, calloc_size); + mi_free(p); + }); + + CHECK_BODY("zeroinit-rezalloc-small", { + size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size); + result = check_zero_init(p, zalloc_size); + zalloc_size *= 3; + p = (uint8_t*)mi_rezalloc(p, zalloc_size); + result &= check_zero_init(p, zalloc_size); + mi_free(p); + }); + CHECK_BODY("zeroinit-rezalloc-large", { + size_t zalloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size); + result = check_zero_init(p, zalloc_size); + zalloc_size *= 3; + p = (uint8_t*)mi_rezalloc(p, zalloc_size); + result &= check_zero_init(p, zalloc_size); + mi_free(p); + }); + + CHECK_BODY("zeroinit-recalloc-small", { + size_t calloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1); + result = check_zero_init(p, calloc_size); + calloc_size *= 3; + p = (uint8_t*)mi_recalloc(p, calloc_size, 1); + result &= check_zero_init(p, calloc_size); + mi_free(p); + }); + CHECK_BODY("zeroinit-recalloc-large", { + size_t calloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1); + result = check_zero_init(p, calloc_size); + calloc_size *= 3; + p = (uint8_t*)mi_recalloc(p, calloc_size, 1); + result &= check_zero_init(p, calloc_size); + mi_free(p); + }); + + // --------------------------------------------------- + // Zeroing in aligned API + // --------------------------------------------------- + CHECK_BODY("zeroinit-zalloc_aligned-small", { + size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2); + result = check_zero_init(p, zalloc_size); + mi_free(p); + }); + CHECK_BODY("zeroinit-zalloc_aligned-large", { + size_t zalloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2); + result = check_zero_init(p, zalloc_size); + mi_free(p); + }); + + CHECK_BODY("zeroinit-calloc_aligned-small", { + size_t calloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); + result = check_zero_init(p, calloc_size); + mi_free(p); + }); + CHECK_BODY("zeroinit-calloc_aligned-large", { + size_t calloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); + result = check_zero_init(p, calloc_size); + mi_free(p); + }); + + CHECK_BODY("zeroinit-rezalloc_aligned-small", { + size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2); + result = check_zero_init(p, zalloc_size); + zalloc_size *= 3; + p = (uint8_t*)mi_rezalloc_aligned(p, zalloc_size, MI_MAX_ALIGN_SIZE * 2); + result &= check_zero_init(p, zalloc_size); + mi_free(p); + }); + CHECK_BODY("zeroinit-rezalloc_aligned-large", { + size_t zalloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2); + result = check_zero_init(p, zalloc_size); + zalloc_size *= 3; + p = (uint8_t*)mi_rezalloc_aligned(p, zalloc_size, MI_MAX_ALIGN_SIZE * 2); + result &= check_zero_init(p, zalloc_size); + mi_free(p); + }); + + CHECK_BODY("zeroinit-recalloc_aligned-small", { + size_t calloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); + result = check_zero_init(p, calloc_size); + calloc_size *= 3; + p = (uint8_t*)mi_recalloc_aligned(p, calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); + result &= check_zero_init(p, calloc_size); + mi_free(p); + }); + CHECK_BODY("zeroinit-recalloc_aligned-large", { + size_t calloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); + result = check_zero_init(p, calloc_size); + calloc_size *= 3; + p = (uint8_t*)mi_recalloc_aligned(p, calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); + result &= check_zero_init(p, calloc_size); + mi_free(p); + }); + + // --------------------------------------------------- + // Done + // ---------------------------------------------------[] + return print_test_summary(); +} + +// --------------------------------------------------------------------------- +// Helper functions +// --------------------------------------------------------------------------- +bool check_zero_init(uint8_t* p, size_t size) { + if(!p) + return false; + bool result = true; + for (size_t i = 0; i < size; ++i) { + result &= p[i] == 0; + } + return result; +} From 1cf7ca021da6535df41746b3d9445571c7a0ebc2 Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Sun, 19 Dec 2021 21:56:52 +0100 Subject: [PATCH 04/22] Add tests for debug mode "uninit fill" behaviour --- test/test-api-fill.c | 124 +++++++++++++++++++++++++++++++++++++++++++ test/test-api.c | 1 + 2 files changed, 125 insertions(+) diff --git a/test/test-api-fill.c b/test/test-api-fill.c index 404dcb7f..39f6f881 100644 --- a/test/test-api-fill.c +++ b/test/test-api-fill.c @@ -13,6 +13,9 @@ terms of the MIT license. A copy of the license can be found in the file // Helper functions // --------------------------------------------------------------------------- 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); +#endif // --------------------------------------------------------------------------- // Main testing @@ -160,6 +163,114 @@ int main(void) { mi_free(p); }); +#if MI_DEBUG >= 2 + // --------------------------------------------------- + // Debug filling + // --------------------------------------------------- + CHECK_BODY("uninit-malloc-small", { + size_t malloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_malloc(malloc_size); + result = check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + CHECK_BODY("uninit-malloc-large", { + size_t malloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_malloc(malloc_size); + result = check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + + CHECK_BODY("uninit-malloc_small", { + size_t malloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_malloc_small(malloc_size); + result = check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + + CHECK_BODY("uninit-realloc-small", { + size_t malloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_malloc(malloc_size); + result = check_debug_fill_uninit(p, malloc_size); + malloc_size *= 3; + p = (uint8_t*)mi_realloc(p, malloc_size); + result &= check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + CHECK_BODY("uninit-realloc-large", { + size_t malloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_malloc(malloc_size); + result = check_debug_fill_uninit(p, malloc_size); + malloc_size *= 3; + p = (uint8_t*)mi_realloc(p, malloc_size); + result &= check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + + CHECK_BODY("uninit-mallocn-small", { + size_t malloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1); + result = check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + CHECK_BODY("uninit-mallocn-large", { + size_t malloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1); + result = check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + + CHECK_BODY("uninit-reallocn-small", { + size_t malloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1); + result = check_debug_fill_uninit(p, malloc_size); + malloc_size *= 3; + p = (uint8_t*)mi_reallocn(p, malloc_size, 1); + result &= check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + CHECK_BODY("uninit-reallocn-large", { + size_t malloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1); + result = check_debug_fill_uninit(p, malloc_size); + malloc_size *= 3; + p = (uint8_t*)mi_reallocn(p, malloc_size, 1); + result &= check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + + CHECK_BODY("uninit-malloc_aligned-small", { + size_t malloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2); + result = check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + CHECK_BODY("uninit-malloc_aligned-large", { + size_t malloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2); + result = check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + + CHECK_BODY("uninit-realloc_aligned-small", { + size_t malloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2); + result = check_debug_fill_uninit(p, malloc_size); + malloc_size *= 3; + p = (uint8_t*)mi_realloc_aligned(p, malloc_size, MI_MAX_ALIGN_SIZE * 2); + result &= check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); + CHECK_BODY("uninit-realloc_aligned-large", { + size_t malloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2); + result = check_debug_fill_uninit(p, malloc_size); + malloc_size *= 3; + p = (uint8_t*)mi_realloc_aligned(p, malloc_size, MI_MAX_ALIGN_SIZE * 2); + result &= check_debug_fill_uninit(p, malloc_size); + mi_free(p); + }); +#endif + // --------------------------------------------------- // Done // ---------------------------------------------------[] @@ -178,3 +289,16 @@ bool check_zero_init(uint8_t* p, size_t size) { } return result; } + +#if MI_DEBUG >= 2 +bool check_debug_fill_uninit(uint8_t* p, size_t size) { + if(!p) + return false; + + bool result = true; + for (size_t i = 0; i < size; ++i) { + result &= p[i] == MI_DEBUG_UNINIT; + } + return result; +} +#endif diff --git a/test/test-api.c b/test/test-api.c index 8ecd31a1..7ce6f111 100644 --- a/test/test-api.c +++ b/test/test-api.c @@ -34,6 +34,7 @@ we therefore test the API over various inputs. Please add more tests :-) #include "mimalloc.h" // #include "mimalloc-internal.h" +#include "mimalloc-types.h" // for MI_DEBUG #include "testhelper.h" From 691eb0d8edc17fbb4850a704244fed302282f931 Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Sun, 19 Dec 2021 21:57:06 +0100 Subject: [PATCH 05/22] Add tests to check "freed memory fill" behaviour in debug mode --- test/test-api-fill.c | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/test/test-api-fill.c b/test/test-api-fill.c index 39f6f881..0e5a65dc 100644 --- a/test/test-api-fill.c +++ b/test/test-api-fill.c @@ -15,6 +15,7 @@ terms of the MIT license. A copy of the license can be found in the file 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); +bool check_debug_fill_freed(uint8_t* p, size_t size); #endif // --------------------------------------------------------------------------- @@ -269,6 +270,22 @@ int main(void) { result &= check_debug_fill_uninit(p, malloc_size); mi_free(p); }); + + + CHECK_BODY("fill-freed-small", { + size_t malloc_size = MI_SMALL_SIZE_MAX / 2; + uint8_t* p = (uint8_t*)mi_malloc(malloc_size); + mi_free(p); + // First sizeof(void*) bytes will contain housekeeping data, skip these + result = check_debug_fill_freed(p + sizeof(void*), malloc_size - sizeof(void*)); + }); + CHECK_BODY("fill-freed-large", { + size_t malloc_size = MI_SMALL_SIZE_MAX * 2; + uint8_t* p = (uint8_t*)mi_malloc(malloc_size); + mi_free(p); + // First sizeof(void*) bytes will contain housekeeping data, skip these + result = check_debug_fill_freed(p + sizeof(void*), malloc_size - sizeof(void*)); + }); #endif // --------------------------------------------------- @@ -301,4 +318,15 @@ bool check_debug_fill_uninit(uint8_t* p, size_t size) { } return result; } + +bool check_debug_fill_freed(uint8_t* p, size_t size) { + if(!p) + return false; + + bool result = true; + for (size_t i = 0; i < size; ++i) { + result &= p[i] == MI_DEBUG_FREED; + } + return result; +} #endif From 164b3a9667f472367f84851cfabc87ab08df26f6 Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Tue, 21 Dec 2021 13:07:39 +0100 Subject: [PATCH 06/22] Pass build config to CMake invocation in Windows pipeline jobs --- azure-pipelines.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/azure-pipelines.yml b/azure-pipelines.yml index 8bd51ab0..cfaf1876 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -43,7 +43,7 @@ jobs: solution: $(BuildType)/libmimalloc.sln configuration: '$(MSBuildConfiguration)' msbuildArguments: -m - - script: ctest --verbose --timeout 120 + - script: ctest --verbose --timeout 120 -C $(MSBuildConfiguration) workingDirectory: $(BuildType) displayName: CTest #- script: $(BuildType)\$(BuildType)\mimalloc-test-stress From 3d91c0e73717a8da64c4edbf08066e2d7cd506eb Mon Sep 17 00:00:00 2001 From: akarin Date: Sun, 26 Dec 2021 18:17:53 +0900 Subject: [PATCH 07/22] cmake: export mimalloc-static as well Otherwise a static only build would not be usable as cmake package (as mimalloc.cmake wouldn't be generated). Signed-off-by: akarin --- CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 87f4cddd..93686cef 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -330,6 +330,7 @@ if (MI_BUILD_STATIC) endif() install(TARGETS mimalloc-static EXPORT mimalloc DESTINATION ${mi_install_libdir} LIBRARY) + install(EXPORT mimalloc DESTINATION ${mi_install_cmakedir}) endif() # install include files From d24262f4773ff3ef0308665c332107c5c01d3dcd Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Tue, 28 Dec 2021 14:54:15 +0100 Subject: [PATCH 08/22] Prefer MSVC 'data section magic' over C++ static initialization --- src/init.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/src/init.c b/src/init.c index e06fa6b9..25de0301 100644 --- a/src/init.c +++ b/src/init.c @@ -557,20 +557,6 @@ static void mi_process_done(void) { return TRUE; } -#elif defined(__cplusplus) - // C++: use static initialization to detect process start - static bool _mi_process_init(void) { - mi_process_load(); - return (_mi_heap_main.thread_id != 0); - } - static bool mi_initialized = _mi_process_init(); - -#elif defined(__GNUC__) || defined(__clang__) - // GCC,Clang: use the constructor attribute - static void __attribute__((constructor)) _mi_process_init(void) { - mi_process_load(); - } - #elif defined(_MSC_VER) // MSVC: use data section magic for static libraries // See @@ -586,9 +572,23 @@ static void mi_process_done(void) { __pragma(comment(linker, "/include:" "__mi_msvc_initu")) #endif #pragma data_seg(".CRT$XIU") - _crt_cb _mi_msvc_initu[] = { &_mi_process_init }; + extern "C" _crt_cb _mi_msvc_initu[] = { &_mi_process_init }; #pragma data_seg() +#elif defined(__cplusplus) + // C++: use static initialization to detect process start + static bool _mi_process_init(void) { + mi_process_load(); + return (_mi_heap_main.thread_id != 0); + } + static bool mi_initialized = _mi_process_init(); + +#elif defined(__GNUC__) || defined(__clang__) + // GCC,Clang: use the constructor attribute + static void __attribute__((constructor)) _mi_process_init(void) { + mi_process_load(); + } + #else #pragma message("define a way to call mi_process_load on your platform") #endif From f456bc75ead42e71680fc6d1111ffa16e85b1425 Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Tue, 28 Dec 2021 14:59:32 +0100 Subject: [PATCH 09/22] Perform thread cleanup for main threads as late as possible for Windows static builds --- src/init.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/init.c b/src/init.c index 25de0301..47aa2b23 100644 --- a/src/init.c +++ b/src/init.c @@ -493,6 +493,11 @@ void mi_process_init(void) mi_attr_noexcept { #endif _mi_verbose_message("secure level: %d\n", MI_SECURE); mi_thread_init(); +#if defined(_WIN32) && !defined(MI_SHARED_LIB) + // When building as a static lib FLS cleanup happens to early for the main thread. + // Make it a no-op and perform it explicitly later. + FlsSetValue(mi_fls_key, NULL); +#endif mi_stats_reset(); // only call stat reset *after* thread init (or the heap tld == NULL) if (mi_option_is_enabled(mi_option_reserve_huge_os_pages)) { @@ -522,6 +527,8 @@ static void mi_process_done(void) { process_done = true; #if defined(_WIN32) && !defined(MI_SHARED_LIB) + // Explicitly clean up main thread + _mi_thread_done(_mi_heap_default); FlsSetValue(mi_fls_key, NULL); // don't call main-thread callback FlsFree(mi_fls_key); // call thread-done on all threads to prevent dangling callback pointer if statically linked with a DLL; Issue #208 #endif From 2b1990805745dad1a7f85c5aa17c2d5dca7903a8 Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Sun, 2 Jan 2022 13:40:59 +0100 Subject: [PATCH 10/22] Expand comment on 'FLS early cleanup avoidance' in mi_process_init() --- src/init.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/init.c b/src/init.c index 47aa2b23..19519151 100644 --- a/src/init.c +++ b/src/init.c @@ -494,8 +494,11 @@ void mi_process_init(void) mi_attr_noexcept { _mi_verbose_message("secure level: %d\n", MI_SECURE); mi_thread_init(); #if defined(_WIN32) && !defined(MI_SHARED_LIB) - // When building as a static lib FLS cleanup happens to early for the main thread. - // Make it a no-op and perform it explicitly later. + /* When building as a static lib the FLS cleanup happens to early for the main thread. + * To avoid that set the FLS value for the main thread to NULL; the eventual + * mi_fls_done() execution won't call _mi_thread_done(). + * The latter function is later called explicitly from mi_process_done(). + * See GitHub issue #508 for more background and explanation. */ FlsSetValue(mi_fls_key, NULL); #endif mi_stats_reset(); // only call stat reset *after* thread init (or the heap tld == NULL) @@ -527,7 +530,7 @@ static void mi_process_done(void) { process_done = true; #if defined(_WIN32) && !defined(MI_SHARED_LIB) - // Explicitly clean up main thread + // Explicitly clean up main thread. See comment in mi_process_init() for reason _mi_thread_done(_mi_heap_default); FlsSetValue(mi_fls_key, NULL); // don't call main-thread callback FlsFree(mi_fls_key); // call thread-done on all threads to prevent dangling callback pointer if statically linked with a DLL; Issue #208 From 17762a7eb124a6dd43644166db985a3d2263c30b Mon Sep 17 00:00:00 2001 From: Frank Richter Date: Sun, 2 Jan 2022 13:41:16 +0100 Subject: [PATCH 11/22] Remove a redundant FlsSetValue() --- src/init.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/init.c b/src/init.c index 19519151..ee347081 100644 --- a/src/init.c +++ b/src/init.c @@ -532,7 +532,6 @@ static void mi_process_done(void) { #if defined(_WIN32) && !defined(MI_SHARED_LIB) // Explicitly clean up main thread. See comment in mi_process_init() for reason _mi_thread_done(_mi_heap_default); - FlsSetValue(mi_fls_key, NULL); // don't call main-thread callback FlsFree(mi_fls_key); // call thread-done on all threads to prevent dangling callback pointer if statically linked with a DLL; Issue #208 #endif From d66ba0b95a0b8e9f1344993ac54fd6771335f636 Mon Sep 17 00:00:00 2001 From: Urs Hanselmann Date: Wed, 5 Jan 2022 12:05:32 +0100 Subject: [PATCH 12/22] fix unused macro name for emscripten build --- src/os.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/os.c b/src/os.c index ee6e92c0..431c15ce 100644 --- a/src/os.c +++ b/src/os.c @@ -638,11 +638,11 @@ static void* mi_os_mem_alloc(size_t size, size_t try_alignment, bool commit, boo if (commit) flags |= MEM_COMMIT; p = mi_win_virtual_alloc(NULL, size, try_alignment, flags, false, allow_large, is_large); #elif defined(MI_USE_SBRK) - KK_UNUSED(allow_large); + MI_UNUSED(allow_large); *is_large = false; p = mi_sbrk_heap_grow(size, try_alignment); #elif defined(__wasi__) - KK_UNUSED(allow_large); + MI_UNUSED(allow_large); *is_large = false; p = mi_wasm_heap_grow(size, try_alignment); #else From 0353fc38dd575903a9a2d80c9ddfff245d3c579f Mon Sep 17 00:00:00 2001 From: Christian Heimes Date: Wed, 5 Jan 2022 13:11:44 +0100 Subject: [PATCH 13/22] Allow overrides of MI_DEBUG memory constants CPython and Windows CRT debug builds use different values for uninit, freed, and padding bytes. Make ``MI_DEBUG_*`` constants conditional to allow embedders to override the constants. Windows dbgheap: ``` _bNoMansLandFill = 0xFD _bDeadLandFill = 0xDD _bCleanLandFill = 0xCD ``` Python memory debug ``` PYMEM_CLEANBYTE 0xCD PYMEM_DEADBYTE 0xDD PYMEM_FORBIDDENBYTE 0xFD ``` Signed-off-by: Christian Heimes --- include/mimalloc-types.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/include/mimalloc-types.h b/include/mimalloc-types.h index b349dfc3..6eeffeb8 100644 --- a/include/mimalloc-types.h +++ b/include/mimalloc-types.h @@ -393,9 +393,15 @@ struct mi_heap_s { // Debug // ------------------------------------------------------ +#if !defined(MI_DEBUG_UNINIT) #define MI_DEBUG_UNINIT (0xD0) +#endif +#if !defined(MI_DEBUG_FREED) #define MI_DEBUG_FREED (0xDF) +#endif +#if !defined(MI_DEBUG_PADDING) #define MI_DEBUG_PADDING (0xDE) +#endif #if (MI_DEBUG) // use our own assertion to print without memory allocation From 8c50aa65eec76eff0684a0730b29247cff3644c0 Mon Sep 17 00:00:00 2001 From: daan Date: Mon, 10 Jan 2022 15:26:22 -0800 Subject: [PATCH 14/22] fix warnings on Solaris, issue #520 --- src/os.c | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/src/os.c b/src/os.c index c31df757..4e0715b1 100644 --- a/src/os.c +++ b/src/os.c @@ -242,7 +242,7 @@ static void os_detect_overcommit(void) { #if defined(__linux__) int fd = open("/proc/sys/vm/overcommit_memory", O_RDONLY); if (fd < 0) return; - char buf[128]; + char buf[32]; ssize_t nread = read(fd, &buf, sizeof(buf)); close(fd); // @@ -274,6 +274,17 @@ void _mi_os_init() { #endif +#if defined(MADV_NORMAL) +static int mi_madvise(void* addr, size_t length, int advice) { + #if defined(__sun) + return madvise((caddr_t)addr, length, advice); // Solaris needs cast (issue #520) + #else + return madvise(addr, length, advice); + #endif +} +#endif + + /* ----------------------------------------------------------- free memory -------------------------------------------------------------- */ @@ -477,7 +488,7 @@ static void* mi_unix_mmapx(void* addr, size_t size, size_t try_alignment, int pr } #elif defined(MAP_ALIGN) // Solaris if (addr == NULL && try_alignment > 1 && (try_alignment % _mi_os_page_size()) == 0) { - void* p = mmap(try_alignment, size, protect_flags, flags | MAP_ALIGN, fd, 0); + void* p = mmap((void*)try_alignment, size, protect_flags, flags | MAP_ALIGN, fd, 0); // addr parameter is the required alignment if (p!=MAP_FAILED) return p; // fall back to regular mmap } @@ -589,7 +600,7 @@ static void* mi_unix_mmap(void* addr, size_t size, size_t try_alignment, int pro // However, some systems only allow THP if called with explicit `madvise`, so // when large OS pages are enabled for mimalloc, we call `madvise` anyways. if (allow_large && use_large_os_page(size, try_alignment)) { - if (madvise(p, size, MADV_HUGEPAGE) == 0) { + if (mi_madvise(p, size, MADV_HUGEPAGE) == 0) { *is_large = true; // possibly }; } @@ -598,7 +609,7 @@ static void* mi_unix_mmap(void* addr, size_t size, size_t try_alignment, int pro struct memcntl_mha cmd = {0}; cmd.mha_pagesize = large_os_page_size; cmd.mha_cmd = MHA_MAPSIZE_VA; - if (memcntl(p, size, MC_HAT_ADVISE, (caddr_t)&cmd, 0, 0) == 0) { + if (memcntl((caddr_t)p, size, MC_HAT_ADVISE, (caddr_t)&cmd, 0, 0) == 0) { *is_large = true; } } @@ -900,7 +911,7 @@ static bool mi_os_commitx(void* addr, size_t size, bool commit, bool conservativ err = mprotect(start, csize, (PROT_READ | PROT_WRITE)); if (err != 0) { err = errno; } //#if defined(MADV_FREE_REUSE) - // while ((err = madvise(start, csize, MADV_FREE_REUSE)) != 0 && errno == EAGAIN) { errno = 0; } + // while ((err = mi_madvise(start, csize, MADV_FREE_REUSE)) != 0 && errno == EAGAIN) { errno = 0; } //#endif } #else @@ -966,16 +977,16 @@ static bool mi_os_resetx(void* addr, size_t size, bool reset, mi_stats_t* stats) static _Atomic(size_t) advice = ATOMIC_VAR_INIT(MADV_FREE); int oadvice = (int)mi_atomic_load_relaxed(&advice); int err; - while ((err = madvise(start, csize, oadvice)) != 0 && errno == EAGAIN) { errno = 0; }; + while ((err = mi_madvise(start, csize, oadvice)) != 0 && errno == EAGAIN) { errno = 0; }; if (err != 0 && errno == EINVAL && oadvice == MADV_FREE) { // if MADV_FREE is not supported, fall back to MADV_DONTNEED from now on mi_atomic_store_release(&advice, (size_t)MADV_DONTNEED); - err = madvise(start, csize, MADV_DONTNEED); + err = mi_madvise(start, csize, MADV_DONTNEED); } #elif defined(__wasi__) int err = 0; #else - int err = madvise(start, csize, MADV_DONTNEED); + int err = mi_madvise(start, csize, MADV_DONTNEED); #endif if (err != 0) { _mi_warning_message("madvise reset error: start: %p, csize: 0x%zx, errno: %i\n", start, csize, errno); From 807a7ff08dc7bf160a8ae0d9f8d416ab3f096558 Mon Sep 17 00:00:00 2001 From: Daan Leijen Date: Mon, 10 Jan 2022 15:39:49 -0800 Subject: [PATCH 15/22] improve commit/decommit on Linux --- src/os.c | 42 +++++++++++++++++++++++++++++------------- 1 file changed, 29 insertions(+), 13 deletions(-) diff --git a/src/os.c b/src/os.c index 4e0715b1..1939156c 100644 --- a/src/os.c +++ b/src/os.c @@ -889,8 +889,7 @@ static bool mi_os_commitx(void* addr, size_t size, bool commit, bool conservativ #if defined(_WIN32) if (commit) { - // if the memory was already committed, the call succeeds but it is not zero'd - // *is_zero = true; + // *is_zero = true; // note: if the memory was already committed, the call succeeds but the memory is not zero'd void* p = VirtualAlloc(start, csize, MEM_COMMIT, PAGE_READWRITE); err = (p == start ? 0 : GetLastError()); } @@ -900,23 +899,40 @@ static bool mi_os_commitx(void* addr, size_t size, bool commit, bool conservativ } #elif defined(__wasi__) // WebAssembly guests can't control memory protection - #elif defined(MAP_FIXED) - if (!commit) { - // use mmap with MAP_FIXED to discard the existing memory (and reduce commit charge) - void* p = mmap(start, csize, PROT_NONE, (MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE), -1, 0); - if (p != start) { err = errno; } - } - else { - // for commit, just change the protection + #elif 0 && defined(MAP_FIXED) && !defined(__APPLE__) + // Linux: disabled for now as mmap fixed seems much more expensive than MADV_DONTNEED (and splits VMA's?) + if (commit) { + // commit: just change the protection err = mprotect(start, csize, (PROT_READ | PROT_WRITE)); if (err != 0) { err = errno; } + } + else { + // decommit: use mmap with MAP_FIXED to discard the existing memory (and reduce rss) + const int fd = mi_unix_mmap_fd(); + void* p = mmap(start, csize, PROT_NONE, (MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE), fd, 0); + if (p != start) { err = errno; } + } + #else + // Linux, macOSX and others. + if (commit) { + // commit: ensure we can access the area + err = mprotect(start, csize, (PROT_READ | PROT_WRITE)); + if (err != 0) { err = errno; } + } + else { + #if defined(MADV_DONTNEED) && MI_DEBUG == 0 && MI_SECURE == 0 + // decommit: use MADV_DONTNEED as it decreases rss immediately (unlike MADV_FREE) + // (on the other hand, MADV_FREE would be good enough.. it is just not reflected in the stats :-( ) + err = madvise(start, csize, MADV_DONTNEED); + #else + // decommit: just disable access (also used in debug and secure mode to trap on illegal access) + err = mprotect(start, csize, PROT_NONE); + if (err != 0) { err = errno; } + #endif //#if defined(MADV_FREE_REUSE) // while ((err = mi_madvise(start, csize, MADV_FREE_REUSE)) != 0 && errno == EAGAIN) { errno = 0; } //#endif } - #else - err = mprotect(start, csize, (commit ? (PROT_READ | PROT_WRITE) : PROT_NONE)); - if (err != 0) { err = errno; } #endif if (err != 0) { _mi_warning_message("%s error: start: %p, csize: 0x%zx, err: %i\n", commit ? "commit" : "decommit", start, csize, err); From 5bc9a1c95f5d058af707543b9220ed6e4156de15 Mon Sep 17 00:00:00 2001 From: Daan Leijen Date: Mon, 10 Jan 2022 16:06:34 -0800 Subject: [PATCH 16/22] update redirection dll's for windows 11 (issue #498) --- bin/mimalloc-redirect.dll | Bin 55808 -> 56832 bytes bin/mimalloc-redirect.lib | Bin 2874 -> 2874 bytes bin/mimalloc-redirect32.dll | Bin 39424 -> 40448 bytes bin/mimalloc-redirect32.lib | Bin 2928 -> 2928 bytes 4 files changed, 0 insertions(+), 0 deletions(-) diff --git a/bin/mimalloc-redirect.dll b/bin/mimalloc-redirect.dll index b7bf1d099681fc73d15ee8dd1b86a48de0aca1d1..83b6bd4f379ba4d9c0fcdf6b846c3b60867a31d1 100644 GIT binary patch delta 7841 zcmb_heOOf0x?g+C$bcZ@2Qr|@3=BF7(g-T!2d6Pnx5~*;$*8Ob(}Y4C6%0-9j46qS zD0Fp-bML8!4`KL{(J39R+ZoFgON~06vX7^xQ{6L!)p*P2TKAmG{jI&%VA1*W@I3GO z{noqQ_g(LL*WPRIJvd(+;e2I8{Q@CyC~uLJacJMbme4o8u*_<>da6wBU-dl*e80N? z)I&0UbE;g%u|5UAll!YnA1GnIhxFQM*2RQucs!DPasHEH!v8`fRX0i;olMq2p%rB9 zibFr%AEm1z%S(t07;#)HU1NE?r0QS)* z#i_!3^aR?Eyq}6=g~Jge9Vb!<>Hj7Z%~*uWp*6)$_mPFPBv>chfg zbX=4pMO*^2j9#hsjC3&HV3KO{4R&cR*!C&X-n;-k7F9I5cJYu+UF;5;5S@~=7K>(+ z8w+Yxt1(=V@!GQ5zJfYc9<@fNh{iO8kn$fb`Z&*&o@-C?b-K=;RaBMtA1BS$b$=g5rS0rw4smfTwSdGUP6Kk zzZo2?_8(43q+1du#PSisMhIP%Fpa*P5VwkHtNj&;Kl6PXcS&&kRV)ny(U>oj%{QQC z421044Xk7XCf1b)Ow1(i1XOgQHp#)~a}L(x&kEbms>wI#n4=DprTr|6 z4a|4vz|AboLs{TDm$NV{Su7Zex`0Q`GAuw?JqxR^_QzH0BYs_>cozR9#IN?#=d_dP z|7jECwD;Y}k#ogf^R?yk>GGB7q@n59ttc;As!?U0`1KSnoK``jJcS&xV92u|>{;;h z< z>->I$lbPdB!nKM=5i@WU8mgqaCk#&Xg6}iCgZmBj=oH{auPUfjoTS>PWhDZRVga9G zhIOhGHV5n*V2`ejcU?+%8t=N5ZZ_|Fl>oE9~egPl$vo3P&1+u^VxDy42)PlP3 zEb(91U{L#nA%qnNSM!W(U@76qU`XQjx3O+ryoSYuDboh8|BWq9brshpo&;aAOSED_ zoCEhz8m@!bp^*ESU0wVh8zHAyQG*{tfkV)avfD{T6uawE;W0T(Vo;So-37ysV0cco z50Qm|Y0O%zoPer>z9TX5{ z{&IoPtxG0S&*Vt;UvOCFTnNsgf10d~c?lh5#pAxBaWVH&OG;$SVx|;X8JfS8m7Wxf z*zy4V@03MiD3j*uUJy5B(kr@vSe!vm>$Ak%4EnWxkvJiP-je!nV%2oolX^kOq&w5n z1+({sG>0HQe;?JQFBf~J(z5i72{lu3t<@D6%msCL#^k)4b73&P|6W+c)7R3iV&qgh ze#&P;4*g-uw+|N@G}6HWgId~m)r?{q+3OKd2ViJm$if(;I`))CRAW$|&aRBz1`DZ( zL5Xzo0}Q2LI*C+_gU*mXI7mpXpAAVEg33q(acML#HBK!4m|mOubWYpd0>MR~gO`r% zQT0cn%-Aj6N>pb1N9@YVhcBirlA{d9@3`CRGp-d<=lm8H!iS25nazr0UDaRB{4t+7 zsHdjshADr?;mKlH*tV;F3isGE*MfO|gd+IT6}oHsDdT!QbImst)mlohI5od=RCBqL zO%5@?fZmfaF*1ue9{+&u$+#$P|ADT^Oc8T+-m=Wgf_UyddM(R9ZCTdH1;le%e1lnjOTwnGj)e{2b*&I4b+M1) zsTn-U0@TGjz*$67@H7|$@s~vv%5otgLls5_k2s_CQ%1JI)ReselG81;T z7!gT+#^cqYGBNzH-~TvG9mDBj3C*IEX0D=wfOy zFOIzPH}I^wK%X#givN6uKq@0WLjR8lfrPCGRhMUY)pI+A*?XDU^>Zv~wqYzT-pzZ1 z7nq9e(m*S_(M+ULgTg$_tS6nP!FkD%2k=H4JbsSG%%2#!nCS!OXx4nYXgo(<^Cvm1 z^Oc>n2CWE%8cxMd-ouqraNrGjzvsz{-r!^3E7R!)cEc=x$anlr-$g^dJ&Nyi?z?2j z7q@r3Q89BEtida=;}d5LId4~-$8zWBA!qi*4l%?d4xXF)i#eDw^*UrVOnNShL$O8%##JCo_=W$%lJPtwK9mx}jKqE9YQ z67wg~j^!I?-8)AhgX#CnZL!=wAh#Rkc9Yze%I(8)yBV!_;fi@116E*STb!Q`Y&ou20r^WL=Q!)O4#O7df(cy4RIiEwau;5B>3ER1w!z$vQjJ3H5Z< zW48((nO~%<_9amJ-ayos+%iOq_kO1*XO&oLj#`eq;KWb&KL3F}lWWZ!EyJvwvXzx< zi#V1HvkJ*pPOh!z=o)6#CtJP9wSJC$!>kD1`@#oN0j>>E{lV{|)Nh1$V@&NJ)z${1 ztXyNGV`{(C+j-B)v7X~E*Xrh4A4mT%D|xLn_@p*UV^!v}vs`H4Da{!3IleP|#KlJR zR<5;iv~vutRIIJcYGw`BHgF7QWx7+b3isXNC{#Fnex{H2dWU(rhIw7#<5kRy`l)&v zIsePJrlMc=wS3&kJYtQ!XJ$yRi390Yt|I!+jVauo@K7#wK;k)!2-g9yEaSZ2Y5BsGD!Xp=yh&qm8 z%lfcoqQpmvhFJt?anonXC0tuIY}C41sl>)8(yom|_%F`SQ;&TRiI z-NUuL9D^L|d9^*^TIkhp@oI52aty~)_Swv}R*oecf35v52FMSs4uo_ z6w=`5)&md?xCi*aI6`#b^}x>{T5$HL{SSx)-Us~s1VXIfp#(zi)?yso3H%-s+J;z( zguDz1f`@>clkiOgn|k1fNyI^}umNdMgODn46L2ZS25tpD4=DlnXE+EMor!?V2si+_ z0;C;Xq*@V=9+kw||utIR#EJEIe^n!yTr8@LJRIIs`~=;&_4YdF3IO29+F%lO_f zfot%+Re|p{BX}Qh*;4E!Cbk2glu&l)1He9fV}_vDEXPDEun_27Kt}<#3EU6-E5r^S z0w(+xTT_Ak*MTgBI5A)a?uOKW*8@*N>X|bz0BK;(z_GU@IJgdY8^jH61#W|Qz@5N0 zh!5NY`~>0$4*~V~rtbwe0oSd>{`a9{N2d{Tg*gB}hXj}dP;JGE!SO&O*^m&p1y}~T z0qz7IgOEzdDnfE0YH%yC1fl`A0}n&A;4a`rhz>m902#R&zO;vJO%NZU;6(Y~UW?Cy)~G5HO|?RBUV?GEh{grSXjQjbWO#!((+B@UApH|ig1xWcPV9D6)D)T zZRy5}{IW8sxO_v|M!Z+PeJOEbD)WQ>_KLO28~yE-o7aO8vW50vnwTFBKKZ0NLi zRdqSL>bpw1?cG(~HQlzOB}a>TY(2y!&qu7TBA3)?ZL~B=P1Yt`leyW_EHxK3n_A2* zmKLeS+G0FnI$}OzIU*g=wHjMZt>#ustF}$oW@@vvNo^Xp)@^i~-4?gHUDK{>H?^DF zNr$@QMu&r~S=$+sSFPy^%Ij8l2jrFC=q5+6VD)|S+Cyyh9$ZO)UU~IFmmllD(&)qb z`)Tiz+-;t=8h5?h<#x8C9`jKUS9?_l vD@j9#y%QxtMd~|Cx|EvKblJK~P?MsgtS0uORY$EotTH7%_8vTGE#m(JmELN) delta 7427 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 ibSPbsI&_@|bS1rub;a0a>e6^$$2I{W z+sVNLl$~tLDmB@cJ(ihEecj}>>^oud+Az6|9N8?by^~)}R^Tk*X7Tj>q`|r(iq)HE{ie+*?m+0gGMvlp9+#&$}976>F diff --git a/bin/mimalloc-redirect32.dll b/bin/mimalloc-redirect32.dll index 7ba303af50079c0f0fed334190abf896674d9806..2892d459fc5302190558bb941046049b87488271 100644 GIT binary patch delta 6189 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 delta 5878 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 diff --git a/bin/mimalloc-redirect32.lib b/bin/mimalloc-redirect32.lib index 66173060fc557427e54f5b3ecae5ecbdbb20c591..7dadab3d657e82efecf90d288b13df7d1ffab7a2 100644 GIT binary patch delta 175 zcmew$_Caie84JtnFDi#7Te0k7k!9FfI$4WdeX=~O9n;Rz&GD>;jGSgqmpneoz`(#X z*`7su@)outm@<8!lF9L`Qj<&BV>!E@9lG)ms>*D#AV)n+mGtEG92_u}mpO7-OdNk- zpX|a}!E*e9*p0~tfDA)3s{@m5xT;vn^R13e-o;hHnO($ozz}E}%jErBVw3rq*(Qf` GO9B9sr8-9d delta 175 zcmew$_Caie84JsQAed~$vWrE4VOHj3Eq3+E@~n1Dvobfwvl=pTf@F^}FfcGpwr7!^ zyoId@rc58GWO6*K)Z|k3Sg@*xP*rA=1v%;yv&gcvCW0E0>U@|W7u$2 cK}2?ORe()11e(S&c|VufWPWD0$>H3R0ABk>+5i9m From 320f95f6cdc9b73e7cbb9acf37e0948f545ecdd0 Mon Sep 17 00:00:00 2001 From: Daan Leijen Date: Mon, 10 Jan 2022 16:07:22 -0800 Subject: [PATCH 17/22] further fixes to allow statically linking mimalloc in DLL modules (issue #508) --- src/init.c | 22 ++++++++++------------ src/region.c | 2 +- test/main-override.cpp | 4 ++-- 3 files changed, 13 insertions(+), 15 deletions(-) diff --git a/src/init.c b/src/init.c index e69208dd..1f1b2729 100644 --- a/src/init.c +++ b/src/init.c @@ -493,14 +493,14 @@ void mi_process_init(void) mi_attr_noexcept { #endif _mi_verbose_message("secure level: %d\n", MI_SECURE); mi_thread_init(); -#if defined(_WIN32) && !defined(MI_SHARED_LIB) - /* When building as a static lib the FLS cleanup happens to early for the main thread. - * To avoid that set the FLS value for the main thread to NULL; the eventual - * mi_fls_done() execution won't call _mi_thread_done(). - * The latter function is later called explicitly from mi_process_done(). - * See GitHub issue #508 for more background and explanation. */ + + #if defined(_WIN32) && !defined(MI_SHARED_LIB) + // When building as a static lib the FLS cleanup happens to early for the main thread. + // To avoid this, set the FLS value for the main thread to NULL so the fls cleanup + // will not call _mi_thread_done on the (still executing) main thread. See issue #508. FlsSetValue(mi_fls_key, NULL); -#endif + #endif + mi_stats_reset(); // only call stat reset *after* thread init (or the heap tld == NULL) if (mi_option_is_enabled(mi_option_reserve_huge_os_pages)) { @@ -530,9 +530,7 @@ static void mi_process_done(void) { process_done = true; #if defined(_WIN32) && !defined(MI_SHARED_LIB) - // Explicitly clean up main thread. See comment in mi_process_init() for reason - _mi_thread_done(_mi_heap_default); - FlsFree(mi_fls_key); // call thread-done on all threads to prevent dangling callback pointer if statically linked with a DLL; Issue #208 + FlsFree(mi_fls_key); // call thread-done on all threads (except the main thread) to prevent dangling callback pointer if statically linked with a DLL; Issue #208 #endif #if (MI_DEBUG != 0) || !defined(MI_SHARED_LIB) @@ -573,7 +571,7 @@ static void mi_process_done(void) { mi_process_load(); return 0; } - typedef int(*_crt_cb)(void); + typedef int(*_mi_crt_callback_t)(void); #if defined(_M_X64) || defined(_M_ARM64) __pragma(comment(linker, "/include:" "_mi_msvc_initu")) #pragma section(".CRT$XIU", long, read) @@ -581,7 +579,7 @@ static void mi_process_done(void) { __pragma(comment(linker, "/include:" "__mi_msvc_initu")) #endif #pragma data_seg(".CRT$XIU") - extern "C" _crt_cb _mi_msvc_initu[] = { &_mi_process_init }; + extern "C" _mi_crt_callback_t _mi_msvc_initu[] = { &_mi_process_init }; #pragma data_seg() #elif defined(__cplusplus) diff --git a/src/region.c b/src/region.c index f864f73b..2d73025e 100644 --- a/src/region.c +++ b/src/region.c @@ -94,7 +94,7 @@ typedef struct mem_region_s { mi_bitmap_field_t commit; // track if committed per block mi_bitmap_field_t reset; // track if reset per block _Atomic(size_t) arena_memid; // if allocated from a (huge page) arena - size_t padding; // round to 8 fields + _Atomic(size_t) padding; // round to 8 fields (needs to be atomic for msvc, see issue #508) } mem_region_t; // The region map diff --git a/test/main-override.cpp b/test/main-override.cpp index e1795ecb..f748c75a 100644 --- a/test/main-override.cpp +++ b/test/main-override.cpp @@ -46,7 +46,7 @@ int main() { tsan_numa_test(); strdup_test(); - //test_mt_shutdown(); + test_mt_shutdown(); //fail_aslr(); mi_stats_print(NULL); return 0; @@ -71,7 +71,7 @@ public: static void various_tests() { atexit(free_p); void* p1 = malloc(78); - void* p2 = mi_malloc_aligned(16, 24); + void* p2 = mi_malloc_aligned(24, 16); free(p1); p1 = malloc(8); char* s = mi_strdup("hello\n"); From dd4518f510121a74c15070d5a87c3af58df3431d Mon Sep 17 00:00:00 2001 From: Daan Leijen Date: Mon, 10 Jan 2022 16:09:20 -0800 Subject: [PATCH 18/22] treat exe as binary --- .gitattributes | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitattributes b/.gitattributes index 1534e778..0332e031 100644 --- a/.gitattributes +++ b/.gitattributes @@ -9,3 +9,4 @@ *.patch binary *.dll binary *.lib binary +*.exe binary From f45935cf347723ee24e6419cebe76a6d6f27eef9 Mon Sep 17 00:00:00 2001 From: Daan Leijen Date: Mon, 10 Jan 2022 16:09:42 -0800 Subject: [PATCH 19/22] add mimalloc injection utility for windows --- bin/minject.exe | Bin 0 -> 20992 bytes bin/minject32.exe | Bin 0 -> 17920 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 bin/minject.exe create mode 100644 bin/minject32.exe diff --git a/bin/minject.exe b/bin/minject.exe new file mode 100644 index 0000000000000000000000000000000000000000..e576c71f3021a7f313b06a1f9925dcdba982a522 GIT binary patch literal 20992 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 QapZ|hD}IIfub_ed1z*HtcK`qY literal 0 HcmV?d00001 diff --git a/bin/minject32.exe b/bin/minject32.exe new file mode 100644 index 0000000000000000000000000000000000000000..1eb8a75daef6328e611bb431118eb6f9a701c322 GIT binary patch literal 17920 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�gobE~@2UnXu1Y}+RK?6?jf_x<<822V7ywAtdp31o;B)|pr*N?+Ri z9Z-vL==GJ0{3)2u z{?5!D*-PpE*3~ZhrN)_~fs`PaBwxTUReIXJF>2TS4Qht#ct7;S=br#>|9fI}Kz!oO z0gNKH*?q1Zh~e8r|8(QbW*fiTh1gZ%4$+M-6G+WV9sWws4)1o+w^RtYid$*PFfVO) zxc%Z%VbwGp)2c5Y#k6V`Po`DV!lAoqRa|eV%r@c|*OGC@M2jkGdDiBvTeI%XdLrw$ zS^p#JPg(P_Q?m`(o3iiEekWU(b45;m&ZeC1oDXt7&B-@xH+*cc=l(SJ*ST-!&R?Cf z`l{7)^RCWI&$}b9C%-@c+5%(2i2_~W^1`yh&cfY=`wQBYH!U$`nAVtnYT!JJ`UZEiMqnS0D3^S$O@n4dBqH@{&% zZB|>Zu%ubCEk%|p%SKDPWvAtK%fDHkunbyWw!CNgUlvW#rA5~ktt_f7l8Sy_^llLo z;Fs{p%d%>+Zp->j)}OPk%WllRBl}SHx$IA~FUd*Gse?>njwh!-=YgDooU=LSa}o?X zLycjl;Vr|w+^ch!&)}#_2k`}*PkcnJ&^ZA z-qU%9@?Oh(E3bS_-I{N&39mW2=H!~wYd%;rH@`UlTlt&w+w$+se=>hCegLtrW2-jOz)c}O)B#e^Y!KebE&z}++yx9-)!zP|FiiX^N-9wG5>e-W9BE#&zPS# zA2q*f{=NAf^BMC8=1< z5z8;2&!;RymQl+~mRBurTHdz&!7^_7z;fR5nMGYRuSj3CsOXxa?-%``2u_1@C{)a{ vvh%acvMaK;WVdB6HVfuu=3a1v1}puT2mX~cmNk{d_<0`He?0$%H1K}_r@M&h literal 0 HcmV?d00001 From 2cc400d600597428ff9b07a9842a26bbb2a4b983 Mon Sep 17 00:00:00 2001 From: Daan Leijen Date: Mon, 10 Jan 2022 16:53:19 -0800 Subject: [PATCH 20/22] update comment --- CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 84164aa2..5ed8474f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -231,7 +231,7 @@ endif() # ----------------------------------------------------------------------------- # dynamic/shared library and symlinks always go to /usr/local/lib equivalent -set(mi_install_libdir "${CMAKE_INSTALL_LIBDIR}") +set(mi_install_libdir "${CMAKE_INSTALL_LIBDIR}") # static libraries and object files, includes, and cmake config files # are either installed at top level, or use versioned directories for side-by-side installation (default) @@ -360,7 +360,7 @@ if (MI_BUILD_OBJECT) ) # the following seems to lead to cmake warnings/errors on some systems, disable for now :-( - # install(TARGETS mimalloc-obj EXPORT mimalloc DESTINATION ${mi_install_libdir}) + # install(TARGETS mimalloc-obj EXPORT mimalloc DESTINATION ${mi_install_objdir}) # the FILES expression can also be: $ # but that fails cmake versions less than 3.10 so we leave it as is for now From 7a4104b3a99832c9a06ac7d9c2602675817867fa Mon Sep 17 00:00:00 2001 From: Daan Leijen Date: Tue, 11 Jan 2022 15:42:27 -0800 Subject: [PATCH 21/22] avoid using atexit in a Windows dll; potential fix for #512 --- src/init.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/init.c b/src/init.c index 1f1b2729..f21f3518 100644 --- a/src/init.c +++ b/src/init.c @@ -446,7 +446,9 @@ static void mi_process_load(void) { MI_UNUSED(dummy); #endif os_preloading = false; - atexit(&mi_process_done); + #if !(defined(_WIN32) && defined(MI_SHARED_LIB)) // use Dll process detach (see below) instead of atexit (issue #521) + atexit(&mi_process_done); + #endif _mi_options_init(); mi_process_init(); //mi_stats_reset();- @@ -558,9 +560,14 @@ static void mi_process_done(void) { if (reason==DLL_PROCESS_ATTACH) { mi_process_load(); } - else if (reason==DLL_THREAD_DETACH) { - if (!mi_is_redirected()) mi_thread_done(); + else if (reason==DLL_PROCESS_DETACH) { + mi_process_done(); } + else if (reason==DLL_THREAD_DETACH) { + if (!mi_is_redirected()) { + mi_thread_done(); + } + } return TRUE; } From 0c814775b68d8a526f9a82e96ddb7e81aeac609f Mon Sep 17 00:00:00 2001 From: Daan Leijen Date: Wed, 12 Jan 2022 16:59:32 -0800 Subject: [PATCH 22/22] fix extern C declaration for msvc (issue #523) --- src/init.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/init.c b/src/init.c index f21f3518..90990cd4 100644 --- a/src/init.c +++ b/src/init.c @@ -586,7 +586,7 @@ static void mi_process_done(void) { __pragma(comment(linker, "/include:" "__mi_msvc_initu")) #endif #pragma data_seg(".CRT$XIU") - extern "C" _mi_crt_callback_t _mi_msvc_initu[] = { &_mi_process_init }; + mi_decl_externc _mi_crt_callback_t _mi_msvc_initu[] = { &_mi_process_init }; #pragma data_seg() #elif defined(__cplusplus)