merge from dev

include/mimalloc.h

@@ -322,32 +322,31 @@ typedef enum mi_option_e {
   mi_option_show_stats,               // print statistics on termination
   mi_option_verbose,                  // print verbose messages
   // the following options are experimental (see src/options.h)
-  mi_option_eager_commit,
-  mi_option_arena_eager_commit,
-  mi_option_purge_decommits,
-  mi_option_allow_large_os_pages,     // enable large (2MiB) OS pages, implies eager commit
-  mi_option_reserve_huge_os_pages,    // reserve N huge OS pages (1GiB) at startup
+  mi_option_eager_commit,             // eager commit segments? (after `eager_commit_delay` segments) (=1)
+  mi_option_arena_eager_commit,       // eager commit arenas? Use 2 to enable just on overcommit systems (=2)
+  mi_option_purge_decommits,          // should a memory purge decommit (or only reset) (=1)
+  mi_option_allow_large_os_pages,     // allow large (2MiB) OS pages, implies eager commit
+  mi_option_reserve_huge_os_pages,    // reserve N huge OS pages (1GiB/page) at startup
   mi_option_reserve_huge_os_pages_at, // reserve huge OS pages at a specific NUMA node
-  mi_option_reserve_os_memory,        // reserve specified amount of OS memory at startup
+  mi_option_reserve_os_memory,        // reserve specified amount of OS memory in an arena at startup
   mi_option_deprecated_segment_cache,
   mi_option_deprecated_page_reset,
-  mi_option_abandoned_page_purge,
-  mi_option_deprecated_segment_reset,
-  mi_option_eager_commit_delay,
-  mi_option_purge_delay,
-  mi_option_use_numa_nodes,           // 0 = use available numa nodes, otherwise use at most N nodes.
-  mi_option_limit_os_alloc,           // 1 = do not use OS memory for allocation (but only reserved arenas)
-  mi_option_os_tag,
-  mi_option_max_errors,
-  mi_option_max_warnings,
-  mi_option_max_segment_reclaim,
-  mi_option_destroy_on_exit,
-  mi_option_arena_reserve,
-  mi_option_arena_purge_mult,
-  mi_option_allow_purge,
+  mi_option_abandoned_page_purge,     // immediately purge delayed purges on thread termination
+  mi_option_deprecated_segment_reset, 
+  mi_option_eager_commit_delay,       
+  mi_option_purge_delay,              // memory purging is delayed by N milli seconds; use 0 for immediate purging or -1 for no purging at all.
+  mi_option_use_numa_nodes,           // 0 = use all available numa nodes, otherwise use at most N nodes.
+  mi_option_limit_os_alloc,           // 1 = do not use OS memory for allocation (but only programmatically reserved arenas)
+  mi_option_os_tag,                   // tag used for OS logging (macOS only for now)
+  mi_option_max_errors,               // issue at most N error messages
+  mi_option_max_warnings,             // issue at most N warning messages
+  mi_option_max_segment_reclaim,      
+  mi_option_destroy_on_exit,          // if set, release all memory on exit; sometimes used for dynamic unloading but can be unsafe.
+  mi_option_arena_reserve,            // initial memory size in KiB for arena reservation (1GiB on 64-bit)
+  mi_option_arena_purge_mult,         
   mi_option_purge_extend_delay,
   _mi_option_last,
-  // legacy options
+  // legacy option names
   mi_option_large_os_pages = mi_option_allow_large_os_pages,
   mi_option_eager_region_commit = mi_option_arena_eager_commit,
   mi_option_reset_decommits = mi_option_purge_decommits,

include/mimalloc/atomic.h

@@ -39,7 +39,11 @@ terms of the MIT license. A copy of the license can be found in the file
 #include <stdatomic.h>
 #define  mi_atomic(name)        atomic_##name
 #define  mi_memory_order(name)  memory_order_##name
-#define  MI_ATOMIC_VAR_INIT(x)  ATOMIC_VAR_INIT(x)
+#if !defined(ATOMIC_VAR_INIT) || (__STDC_VERSION__ >= 201710L) // c17, see issue #735
+ #define MI_ATOMIC_VAR_INIT(x) x
+#else
+ #define MI_ATOMIC_VAR_INIT(x) ATOMIC_VAR_INIT(x)
+#endif
 #endif
 
 // Various defines for all used memory orders in mimalloc

src/arena.c

@@ -425,6 +425,7 @@ void* mi_arena_area(mi_arena_id_t arena_id, size_t* size) {
 ----------------------------------------------------------- */
 
 static long mi_arena_purge_delay(void) {
+  // <0 = no purging allowed, 0=immediate purging, >0=milli-second delay
   return (mi_option_get(mi_option_purge_delay) * mi_option_get(mi_option_arena_purge_mult));
 }
 
@@ -463,9 +464,9 @@ static void mi_arena_purge(mi_arena_t* arena, size_t bitmap_idx, size_t blocks,
 // Note: assumes we (still) own the area as we may purge immediately
 static void mi_arena_schedule_purge(mi_arena_t* arena, size_t bitmap_idx, size_t blocks, mi_stats_t* stats) {
   mi_assert_internal(arena->blocks_purge != NULL);
-  if (!mi_option_is_enabled(mi_option_allow_purge)) return;
-
   const long delay = mi_arena_purge_delay();
+  if (delay < 0) return;  // is purging allowed at all?
+
   if (_mi_preloading() || delay == 0) {
     // decommit directly
     mi_arena_purge(arena, bitmap_idx, blocks, stats);    
@@ -566,7 +567,7 @@ static bool mi_arena_try_purge(mi_arena_t* arena, mi_msecs_t now, bool force, mi
 }
 
 static void mi_arenas_try_purge( bool force, bool visit_all, mi_stats_t* stats ) {
-  if (_mi_preloading() || !mi_option_is_enabled(mi_option_allow_purge) || mi_arena_purge_delay() == 0) return;  // nothing will be scheduled
+  if (_mi_preloading() || mi_arena_purge_delay() <= 0) return;  // nothing will be scheduled
 
   const size_t max_arena = mi_atomic_load_acquire(&mi_arena_count);
   if (max_arena == 0) return;

src/options.c

@@ -88,8 +88,7 @@ static mi_option_desc_t options[_mi_option_last] =
   #else
   {  128L * 1024L, UNINIT, MI_OPTION(arena_reserve) },
   #endif
-  { 10,  UNINIT, MI_OPTION(arena_purge_mult) },         // purge delay multiplier for arena's
-  { 1,   UNINIT, MI_OPTION(allow_purge) },              // allow decommit/reset to free (physical) memory back to the OS
+  { 10,  UNINIT, MI_OPTION(arena_purge_mult) },        // purge delay multiplier for arena's
   { 1,   UNINIT, MI_OPTION_LEGACY(purge_extend_delay, decommit_extend_delay) },
 };
 

src/os.c

@@ -465,14 +465,14 @@ bool _mi_os_reset(void* addr, size_t size, mi_stats_t* stats) {
 // to be recommitted if it is to be re-used later on.
 bool _mi_os_purge_ex(void* p, size_t size, bool allow_reset, mi_stats_t* stats)
 {
-  if (!mi_option_is_enabled(mi_option_allow_purge)) return false;
+  if (mi_option_get(mi_option_purge_delay) < 0) return false;  // is purging allowed?
   _mi_stat_counter_increase(&stats->purge_calls, 1);
   _mi_stat_increase(&stats->purged, size);
 
   if (mi_option_is_enabled(mi_option_purge_decommits) &&   // should decommit?
       !_mi_preloading())                                   // don't decommit during preloading (unsafe)
   {
-    bool needs_recommit;
+    bool needs_recommit = true;
     mi_os_decommit_ex(p, size, &needs_recommit, stats);
     return needs_recommit;   
   }
@@ -480,7 +480,7 @@ bool _mi_os_purge_ex(void* p, size_t size, bool allow_reset, mi_stats_t* stats)
     if (allow_reset) {  // this can sometimes be not allowed if the range is not fully committed
       _mi_os_reset(p, size, stats);
     }
-    return false;  // not decommitted
+    return false;  // needs no recommit
   }
 }
 

src/segment.c

@@ -843,7 +843,7 @@ static mi_segment_t* mi_segment_os_alloc( size_t required, size_t page_alignment
   mi_track_mem_undefined(segment, (*pinfo_slices) * MI_SEGMENT_SLICE_SIZE); // todo: should not be necessary?
   segment->memid = memid;
   segment->allow_decommit = !memid.is_pinned;
-  segment->allow_purge = segment->allow_decommit && mi_option_is_enabled(mi_option_allow_purge);
+  segment->allow_purge = segment->allow_decommit && (mi_option_get(mi_option_purge_delay) >= 0);
   segment->segment_size = segment_size;
   segment->commit_mask = commit_mask;
   segment->purge_expire = 0;