use rich memid's to simplify the internal API's and invariants

include/mimalloc/internal.h

@@ -116,9 +116,9 @@ void       _mi_os_free_huge_pages(void* p, size_t size, mi_stats_t* stats);
 
 // arena.c
 mi_arena_id_t _mi_arena_id_none(void);
-void       _mi_arena_free(void* p, size_t size, size_t alignment, size_t align_offset, mi_memid_t memid, size_t committed, mi_stats_t* stats);
-void*      _mi_arena_alloc(size_t size, bool* commit, bool* large, bool* is_pinned, bool* is_zero, mi_arena_id_t req_arena_id, mi_memid_t* memid, mi_os_tld_t* tld);
-void*      _mi_arena_alloc_aligned(size_t size, size_t alignment, size_t align_offset, bool* commit, bool* large, bool* is_pinned, bool* is_zero, mi_arena_id_t req_arena_id, mi_memid_t* memid, mi_os_tld_t* tld);
+void       _mi_arena_free(void* p, size_t size, size_t still_committed_size, mi_memid_t memid, mi_stats_t* stats);
+void*      _mi_arena_alloc(size_t size, bool commit, bool allow_large, mi_arena_id_t req_arena_id, mi_memid_t* memid, mi_os_tld_t* tld);
+void*      _mi_arena_alloc_aligned(size_t size, size_t alignment, size_t align_offset, bool commit, bool allow_large, mi_arena_id_t req_arena_id, mi_memid_t* memid, mi_os_tld_t* tld);
 bool       _mi_arena_memid_is_suitable(mi_memid_t memid, mi_arena_id_t request_arena_id);
 bool       _mi_arena_contains(const void* p);
 void       _mi_arena_collect(bool force_purge, mi_stats_t* stats);

include/mimalloc/types.h

@@ -322,16 +322,33 @@ typedef enum mi_page_kind_e {
 
 // Memory can reside in arena's, direct OS allocated, or statically allocated. The memid keeps track of this.
 typedef enum mi_memkind_e {
-  MI_MEM_NONE,
-  MI_MEM_OS,
-  MI_MEM_STATIC,
-  MI_MEM_ARENA
+  MI_MEM_NONE,      // not allocated
+  MI_MEM_EXTERNAL,  // not owned by mimalloc but provided externally (via `mi_manage_os_memory` for example)
+  MI_MEM_STATIC,    // allocated in a static area and should not be freed (for arena meta data for example)
+  MI_MEM_OS,        // allocated from the OS
+  MI_MEM_ARENA      // allocated from an arena (the usual case)
 } mi_memkind_t;
 
+typedef struct mi_memid_os_info {
+  size_t        alignment;      // allocated with the given alignment
+  size_t        align_offset;   // the offset that was aligned (used only for huge aligned pages)
+} mi_memid_os_info_t;
+
+typedef struct mi_memid_arena_info {
+  size_t        block_index;    // index in the arena
+  mi_arena_id_t id;             // arena id (>= 1)
+  bool          is_exclusive;   // the arena can only be used for specific arena allocations
+} mi_memid_arena_info_t;
+
 typedef struct mi_memid_s {
-  size_t        arena_idx;          
-  mi_arena_id_t arena_id;           
-  bool          arena_is_exclusive;
+  union {
+    mi_memid_os_info_t    os;   // only used for MI_MEM_OS
+    mi_memid_arena_info_t arena;// only used for MI_MEM_ARENA
+  } mem;
+  bool          is_pinned;      // `true` if we cannot decommit/reset/protect in this memory (e.g. when allocated using large OS pages)
+  bool          is_large;       // `true` if the memory is in OS large (2MiB) or huge (1GiB) pages. (`is_pinned` will be true)
+  bool          was_committed;  // `true` if the memory was originally allocated as committed
+  bool          was_zero;       // `true` if the memory was originally zero initialized
   mi_memkind_t  memkind;
 } mi_memid_t;
 
@@ -340,17 +357,12 @@ typedef struct mi_memid_s {
 // the OS. Inside segments we allocated fixed size _pages_ that
 // contain blocks.
 typedef struct mi_segment_s {
-  // memory fields
+  // constant fields
   mi_memid_t           memid;            // id for the os-level memory manager
-  bool                 mem_is_pinned;    // `true` if we cannot decommit/reset/protect in this memory (i.e. when allocated using large OS pages)
-  bool                 mem_is_large;     // `true` if the memory is in OS large or huge pages. (`is_pinned` will be true)
-  bool                 mem_is_committed; // `true` if the whole segment is eagerly committed
-  size_t               mem_alignment;    // page alignment for huge pages (only used for alignment > MI_ALIGNMENT_MAX)
-  size_t               mem_align_offset; // offset for huge page alignment (only used for alignment > MI_ALIGNMENT_MAX)
-
   bool                 allow_decommit;
   bool                 allow_purge;
-
+  size_t               segment_size;     // for huge pages this may be different from `MI_SEGMENT_SIZE`
+  
   // segment fields
   _Atomic(struct mi_segment_s*) abandoned_next;
   struct mi_segment_s* next;             // must be the first segment field after abandoned_next -- see `segment.c:segment_init`
@@ -361,7 +373,6 @@ typedef struct mi_segment_s {
 
   size_t               used;             // count of pages in use (`used <= capacity`)
   size_t               capacity;         // count of available pages (`#free + used`)
-  size_t               segment_size;     // for huge pages this may be different from `MI_SEGMENT_SIZE`
   size_t               segment_info_size;// space we are using from the first page for segment meta-data and possible guard pages.
   uintptr_t            cookie;           // verify addresses in secure mode: `_mi_ptr_cookie(segment) == segment->cookie`