small optimizations, use bitwise aligne

src/alloc.c

@@ -237,9 +237,9 @@ void mi_free(void* p) mi_attr_noexcept
 #endif
 
   // adjust if it might be an un-aligned block
-  if (mi_likely(page->flags.value==0)) {  // note: merging both tests (local | value) does not matter for performance
+  if (mi_likely(page->flags.value==0)) {  // not full or aligned
     mi_block_t* block = (mi_block_t*)p;
-    if (mi_likely(local)) {
+    if (mi_likely(local)) {  // note: merging both tests (local | value) does not matter for performance
       // owning thread can free a block directly
       mi_block_set_next(page, block, page->local_free);  // note: moving this write earlier does not matter for performance
       page->local_free = block;
@@ -248,7 +248,7 @@ void mi_free(void* p) mi_attr_noexcept
     }
     else {
       // use atomic operations for a multi-threaded free
-      _mi_free_block_mt(page, block);
+      _mi_free_block_mt(page, block);      
     }
   }
   else {

src/init.c

@@ -12,9 +12,11 @@ terms of the MIT license. A copy of the license can be found in the file
 
 // Empty page used to initialize the small free pages array
 const mi_page_t _mi_page_empty = {
-  0, false, false, false, {0},
-  0, 0,
-  NULL, 0, 0,   // free, used, cookie
+  0, false, false, false, {0}, 0, 0, 
+  NULL, 0,   // free, used
+  #if MI_SECURE
+  0,
+  #endif
   NULL, 0, 0,
   0, NULL, NULL, NULL
   #if (MI_INTPTR_SIZE==4)

src/os.c

@@ -34,13 +34,6 @@ terms of the MIT license. A copy of the license can be found in the file
 ----------------------------------------------------------- */
 bool _mi_os_decommit(void* addr, size_t size, mi_stats_t* stats);
 
-uintptr_t _mi_align_up(uintptr_t sz, size_t alignment) {
-  uintptr_t x = (sz / alignment) * alignment;
-  if (x < sz) x += alignment;
-  if (x < sz) return 0; // overflow
-  return x;
-}
-
 static void* mi_align_up_ptr(void* p, size_t alignment) {
   return (void*)_mi_align_up((uintptr_t)p, alignment);
 }

src/page.c

@@ -93,7 +93,9 @@ static bool mi_page_is_valid_init(mi_page_t* page) {
 
 bool _mi_page_is_valid(mi_page_t* page) {
   mi_assert_internal(mi_page_is_valid_init(page));
+  #if MI_SECURE
   mi_assert_internal(page->cookie != 0);
+  #endif
   if (page->heap!=NULL) {
     mi_segment_t* segment = _mi_page_segment(page);
     mi_assert_internal(!_mi_process_is_initialized || segment->thread_id == page->heap->thread_id);
@@ -119,7 +121,7 @@ void _mi_page_use_delayed_free(mi_page_t* page, mi_delayed_t delay  ) {
     else if (mi_unlikely(mi_tf_delayed(tfree) == MI_DELAYED_FREEING)) {
       mi_atomic_yield(); // delay until outstanding MI_DELAYED_FREEING are done.
       continue;          // and try again
-    }    
+    }
   }
   while((mi_tf_delayed(tfreex) !=  mi_tf_delayed(tfree)) && // avoid atomic operation if already equal
         !mi_atomic_compare_exchange((volatile uintptr_t*)&page->thread_free, tfreex, tfree));
@@ -258,7 +260,7 @@ void _mi_heap_delayed_free(mi_heap_t* heap) {
     mi_block_t* next = mi_block_nextx(heap->cookie,block);
     // use internal free instead of regular one to keep stats etc correct
     if (!_mi_free_delayed_block(block)) {
-      // we might already start delayed freeing while another thread has not yet 
+      // we might already start delayed freeing while another thread has not yet
       // reset the delayed_freeing flag; in that case delay it further by reinserting.
       mi_block_t* dfree;
       do {
@@ -498,7 +500,7 @@ static void mi_page_extend_free(mi_heap_t* heap, mi_page_t* page, mi_stats_t* st
   if (page->capacity >= page->reserved) return;
 
   size_t page_size;
-  _mi_page_start(_mi_page_segment(page), page, &page_size);  
+  _mi_page_start(_mi_page_segment(page), page, &page_size);
   _mi_stat_increase(&stats->pages_extended, 1);
 
   // calculate the extend count
@@ -533,7 +535,9 @@ static void mi_page_init(mi_heap_t* heap, mi_page_t* page, size_t block_size, mi
   page->block_size = block_size;
   mi_assert_internal(page_size / block_size < (1L<<16));
   page->reserved = (uint16_t)(page_size / block_size);
+  #if MI_SECURE
   page->cookie = _mi_heap_random(heap) | 1;
+  #endif
 
   mi_assert_internal(page->capacity == 0);
   mi_assert_internal(page->free == NULL);
@@ -543,7 +547,9 @@ static void mi_page_init(mi_heap_t* heap, mi_page_t* page, size_t block_size, mi
   mi_assert_internal(page->next == NULL);
   mi_assert_internal(page->prev == NULL);
   mi_assert_internal(page->flags.has_aligned == false);
+  #if MI_SECURE
   mi_assert_internal(page->cookie != 0);
+  #endif
   mi_assert_expensive(mi_page_is_valid_init(page));
 
   // initialize an initial free list
@@ -683,7 +689,7 @@ static mi_page_t* mi_huge_page_alloc(mi_heap_t* heap, size_t size) {
     mi_assert_internal(mi_page_immediate_available(page));
     mi_assert_internal(page->block_size == block_size);
     mi_heap_stat_increase( heap, huge, block_size);
-  }  
+  }
   return page;
 }
 

src/segment.c

@@ -235,8 +235,8 @@ static void mi_segment_os_free(mi_segment_t* segment, size_t segment_size, mi_se
 
 
 // The thread local segment cache is limited to be at most 1/8 of the peak size of segments in use,
-// and no more than 4.
-#define MI_SEGMENT_CACHE_MAX      (4)
+// and no more than 2.
+#define MI_SEGMENT_CACHE_MAX      (2)
 #define MI_SEGMENT_CACHE_FRACTION (8)
 
 // note: returned segment may be partially reset
@@ -252,7 +252,7 @@ static mi_segment_t* mi_segment_cache_pop(size_t segment_size, mi_segments_tld_t
 }
 
 static bool mi_segment_cache_full(mi_segments_tld_t* tld) {
-  if (tld->cache_count < MI_SEGMENT_CACHE_MAX &&
+  if (tld->cache_count <  MI_SEGMENT_CACHE_MAX &&
       tld->cache_count < (1 + (tld->peak_count / MI_SEGMENT_CACHE_FRACTION))) { // always allow 1 element cache
     return false;
   }
@@ -318,7 +318,7 @@ static mi_segment_t* mi_segment_alloc(size_t required, mi_page_kind_t page_kind,
   size_t page_size = (page_kind == MI_PAGE_HUGE ? segment_size : (size_t)1 << page_shift);
 
   // Try to get it from our thread local cache first
-  bool commit = mi_option_is_enabled(mi_option_eager_commit) || (page_kind > MI_PAGE_MEDIUM); 
+  bool commit = mi_option_is_enabled(mi_option_eager_commit) || (page_kind > MI_PAGE_MEDIUM);
   bool protection_still_good = false;
   mi_segment_t* segment = mi_segment_cache_pop(segment_size, tld);
   if (segment != NULL) {
@@ -702,10 +702,10 @@ static mi_page_t* mi_segment_huge_page_alloc(size_t size, mi_segments_tld_t* tld
 
 mi_page_t* _mi_segment_page_alloc(size_t block_size, mi_segments_tld_t* tld, mi_os_tld_t* os_tld) {
   mi_page_t* page;
-  if (block_size <= (MI_SMALL_PAGE_SIZE/16)*3) {
+  if (block_size <= (MI_SMALL_PAGE_SIZE/4)) {
     page = mi_segment_small_page_alloc(tld,os_tld);
   }
-  else if (block_size <= (MI_MEDIUM_PAGE_SIZE/16)*3) {
+  else if (block_size <= (MI_MEDIUM_PAGE_SIZE/4)) {
     page = mi_segment_medium_page_alloc(tld, os_tld);
   }
   else if (block_size < (MI_LARGE_SIZE_MAX - sizeof(mi_segment_t))) {