small optimizations, use bitwise aligne

include/mimalloc-internal.h

@@ -39,7 +39,6 @@ bool       _mi_preloading();  // true while the C runtime is not ready
 
 // os.c
 size_t     _mi_os_page_size(void);
-uintptr_t  _mi_align_up(uintptr_t sz, size_t alignment);
 void       _mi_os_init(void);                                      // called from process init
 void*      _mi_os_alloc(size_t size, mi_stats_t* stats);           // to allocate thread local data
 void       _mi_os_free(void* p, size_t size, mi_stats_t* stats);   // to free thread local data
@@ -165,6 +164,20 @@ static inline bool mi_mul_overflow(size_t size, size_t count, size_t* total) {
 #endif
 }
 
+// Align upwards
+static inline uintptr_t _mi_is_power_of_two(uintptr_t x) {
+  return ((x & (x - 1)) == 0);
+}
+static inline uintptr_t _mi_align_up(uintptr_t sz, size_t alignment) {
+  uintptr_t mask = alignment - 1;
+  if ((alignment & mask) == 0) {  // power of two?
+    return ((sz + mask) & ~mask);
+  }
+  else {
+    return (((sz + mask)/alignment)*alignment);
+  }
+}
+
 // Align a byte size to a size in _machine words_,
 // i.e. byte size == `wsize*sizeof(void*)`.
 static inline size_t _mi_wsize_from_size(size_t size) {
@@ -324,12 +337,23 @@ static inline void mi_block_set_nextx(uintptr_t cookie, mi_block_t* block, mi_bl
 }
 
 static inline mi_block_t* mi_block_next(mi_page_t* page, mi_block_t* block) {
+  #if MI_SECURE
   return mi_block_nextx(page->cookie,block);
+  #else
+  UNUSED(page);
+  return mi_block_nextx(0, block);
+  #endif
 }
 
 static inline void mi_block_set_next(mi_page_t* page, mi_block_t* block, mi_block_t* next) {
+  #if MI_SECURE
   mi_block_set_nextx(page->cookie,block,next);
+  #else
+  UNUSED(page);
+  mi_block_set_nextx(0, block, next);
+  #endif
 }
+
 // -------------------------------------------------------------------
 // Getting the thread id should be performant
 // as it is called in the fast path of `_mi_free`,

include/mimalloc-types.h

@@ -132,10 +132,9 @@ typedef union mi_page_flags_u {
 } mi_page_flags_t;
 
 // Thread free list.
-// We use bottom 2 bits of the pointer for mi_delayed_t flags
+// We use the bottom 2 bits of the pointer for mi_delayed_t flags
 typedef uintptr_t mi_thread_free_t;
 
-
 // A page contains blocks of one specific size (`block_size`).
 // Each page has three list of free blocks:
 // `free` for blocks that can be allocated,
@@ -165,9 +164,11 @@ typedef struct mi_page_s {
   mi_page_flags_t       flags;
   uint16_t              capacity;          // number of blocks committed
   uint16_t              reserved;          // number of blocks reserved in memory
-
+  
   mi_block_t*           free;              // list of available free blocks (`malloc` allocates from this list)
+  #if MI_SECURE
   uintptr_t             cookie;            // random cookie to encode the free lists
+  #endif
   size_t                used;              // number of blocks in use (including blocks in `local_free` and `thread_free`)
 
   mi_block_t*           local_free;        // list of deferred free blocks by this thread (migrates to `free`)
@@ -182,9 +183,9 @@ typedef struct mi_page_s {
 
 // improve page index calculation
 #if MI_INTPTR_SIZE==8
-  //void*                 padding[1];        // 10 words on 64-bit
+  //void*                 padding[1];        // 12 words on 64-bit
 #elif MI_INTPTR_SIZE==4
-  void*                 padding[1];          // 12 words on 32-bit
+  void*                 padding[1];         // 12 words on 32-bit
 #endif
 } mi_page_t;
 

include/mimalloc.h

@@ -52,8 +52,8 @@ terms of the MIT license. A copy of the license can be found in the file
   #define mi_attr_alloc_size2(s1,s2)
   #else
   #define mi_attr_alloc_size(s)       __attribute__((alloc_size(s)))
-  #define mi_attr_alloc_size2(s1,s2)  __attribute__((alloc_size(s1,s2)))  
-  #define mi_cdecl                    // leads to warnings... __attribute__((cdecl))  
+  #define mi_attr_alloc_size2(s1,s2)  __attribute__((alloc_size(s1,s2)))
+  #define mi_cdecl                    // leads to warnings... __attribute__((cdecl))
   #endif
 #else
   #define mi_decl_thread              __thread
@@ -62,7 +62,7 @@ terms of the MIT license. A copy of the license can be found in the file
   #define mi_attr_malloc
   #define mi_attr_alloc_size(s)
   #define mi_attr_alloc_size2(s1,s2)
-  #define mi_cdecl                   
+  #define mi_cdecl
 #endif
 
 // ------------------------------------------------------