clarify needs_recommit

include/mimalloc/prim.h

@@ -47,11 +47,11 @@ int _mi_prim_alloc(size_t size, size_t try_alignment, bool commit, bool allow_la
 // For example, on Linux this would make the memory PROT_READ|PROT_WRITE.
 int _mi_prim_commit(void* addr, size_t size);
 
-// Decommit memory. Returns error code or 0 on success. The `decommitted` result is true
+// Decommit memory. Returns error code or 0 on success. The `needs_recommit` result is true
 // if the memory would need to be re-committed. For example, on Windows this is always true,
 // but on Linux we could use MADV_DONTNEED to decommit which does not need a recommit.
-// pre: decommitted != NULL
-int _mi_prim_decommit(void* addr, size_t size, bool* decommitted);
+// pre: needs_recommit != NULL
+int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit);
 
 // Reset memory. The range keeps being accessible but the content might be reset.
 // Returns error code or 0 on success.

src/os.c

@@ -377,10 +377,10 @@ bool _mi_os_commit(void* addr, size_t size, bool* is_zero, mi_stats_t* tld_stats
   return (err == 0);
 }
 
-static bool mi_os_decommit_ex(void* addr, size_t size, bool* decommitted, mi_stats_t* tld_stats) {
+static bool mi_os_decommit_ex(void* addr, size_t size, bool* needs_recommit, mi_stats_t* tld_stats) {
   MI_UNUSED(tld_stats);
   mi_stats_t* stats = &_mi_stats_main;
-  mi_assert_internal(decommitted!=NULL);
+  mi_assert_internal(needs_recommit!=NULL);
   _mi_stat_decrease(&stats->committed, size);
 
   // page align
@@ -389,8 +389,8 @@ static bool mi_os_decommit_ex(void* addr, size_t size, bool* decommitted, mi_sta
   if (csize == 0) return true; 
 
   // decommit
-  *decommitted = true;
-  int err = _mi_prim_decommit(start,csize,decommitted);  
+  *needs_recommit = true;
+  int err = _mi_prim_decommit(start,csize,needs_recommit);  
   if (err != 0) {
     _mi_warning_message("cannot decommit OS memory (error: %d (0x%x), address: %p, size: 0x%zx bytes)\n", err, err, start, csize);
   }
@@ -399,8 +399,8 @@ static bool mi_os_decommit_ex(void* addr, size_t size, bool* decommitted, mi_sta
 }
 
 bool _mi_os_decommit(void* addr, size_t size, mi_stats_t* tld_stats) {
-  bool decommitted = true;
-  return mi_os_decommit_ex(addr, size, &decommitted, tld_stats);
+  bool needs_recommit;
+  return mi_os_decommit_ex(addr, size, &needs_recommit, tld_stats);
 }
 
 
@@ -427,18 +427,18 @@ bool _mi_os_reset(void* addr, size_t size, mi_stats_t* stats) {
 }
 
 
-// either resets or decommits memory, returns true if the memory was decommitted 
-// (in the sense that it needs to be re-committed if the memory is re-used later on).
+// either resets or decommits memory, returns true if the memory needs 
+// to be recommitted if it is to be re-used later on.
 bool _mi_os_purge(void* p, size_t size, mi_stats_t* stats)
 {
   if (!mi_option_is_enabled(mi_option_allow_purge)) return false;
 
   if (mi_option_is_enabled(mi_option_purge_decommits) &&   // should decommit?
-    !_mi_preloading())                                   // don't decommit during preloading (unsafe)
+    !_mi_preloading())                                     // don't decommit during preloading (unsafe)
   {
-    bool decommitted;
-    mi_os_decommit_ex(p, size, &decommitted, stats);
-    return decommitted;   
+    bool needs_recommit;
+    mi_os_decommit_ex(p, size, &needs_recommit, stats);
+    return needs_recommit;   
   }
   else {
     _mi_os_reset(p, size, stats);

src/prim/unix/prim.c

@@ -352,16 +352,16 @@ int _mi_prim_commit(void* start, size_t size) {
   return err;
 }
 
-int _mi_prim_decommit(void* start, size_t size, bool* decommitted) {
+int _mi_prim_decommit(void* start, size_t size, bool* needs_recommit) {
   int err = 0;
   #if defined(MADV_DONTNEED) && !MI_DEBUG && !MI_SECURE
     // 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 :-( )
-    *decommitted = false;
+    *needs_recommit = false;
     err = unix_madvise(start, size, MADV_DONTNEED);
   #else
     // decommit: just disable access (also used in debug and secure mode to trap on illegal access)
-    *decommitted = true;  // needs recommit to reuse the memory
+    *needs_recommit = true;  // needs recommit to reuse the memory
     err = mprotect(start, size, PROT_NONE);
     if (err != 0) { err = errno; }
   #endif

src/prim/wasi/prim.c

@@ -131,9 +131,9 @@ int _mi_prim_commit(void* addr, size_t size) {
   return 0;
 }
 
-int _mi_prim_decommit(void* addr, size_t size, bool* decommitted) {
+int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit) {
   MI_UNUSED(addr); MI_UNUSED(size);
-  *decommitted = false;
+  *needs_recommit = false;
   return 0;
 }
 

src/prim/windows/prim.c

@@ -262,9 +262,9 @@ int _mi_prim_commit(void* addr, size_t size) {
   return (p == addr ? 0 : (int)GetLastError());  
 }
 
-int _mi_prim_decommit(void* addr, size_t size, bool* decommitted) {  
+int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit) {  
   BOOL ok = VirtualFree(addr, size, MEM_DECOMMIT);
-  *decommitted = true;  // for safetly, assume always decommitted even in the case of an error.
+  *needs_recommit = true;  // for safetly, assume always decommitted even in the case of an error.
   return (ok ? 0 : (int)GetLastError());
 }