allocator: use compiler to compute sizeof bitmap_t

Rather than hardcoding the sizeof(bitmap_t) based on `__LP64__` use the
compiler builtin `sizeof` to compute the size.

Author: compnerd

src/allocator.c

@@ -202,8 +202,8 @@ first_bitmap_in_same_page(bitmap_t *b)
 	dispatch_assert(b <  &m->maps[SUPERMAPS_PER_MAGAZINE]
 			[BITMAPS_PER_SUPERMAP]);
 #endif
-	const uintptr_t PAGE_BITMAP_MASK = (BITMAPS_PER_PAGE *
-			BYTES_PER_BITMAP) - 1;
+	const uintptr_t PAGE_BITMAP_MASK =
+		(BITMAPS_PER_PAGE * sizeof(bitmap_t)) - 1;
 	return (bitmap_t *)((uintptr_t)b & ~PAGE_BITMAP_MASK);
 }
 
@@ -601,7 +601,6 @@ _dispatch_alloc_init(void)
 	// Double-check our math. These are all compile time checks and don't
 	// generate code.
 
-	dispatch_assert(sizeof(bitmap_t) == BYTES_PER_BITMAP);
 	dispatch_assert(sizeof(bitmap_t) == BYTES_PER_SUPERMAP);
 
 	dispatch_assert(sizeof(struct dispatch_continuation_s) <=

src/allocator_internal.h

@@ -97,25 +97,20 @@
 // Use the largest type your platform is comfortable doing atomic ops with.
 // TODO: rdar://11477843
 typedef unsigned long bitmap_t;
-#if defined(__LP64__)
-#define BYTES_PER_BITMAP 8
-#else
-#define BYTES_PER_BITMAP 4
-#endif
 
 #define BITMAP_C(v) ((bitmap_t)(v))
 #define BITMAP_ALL_ONES (~BITMAP_C(0))
 
 // Stop configuring.
 
-#define CONTINUATIONS_PER_BITMAP (BYTES_PER_BITMAP * 8)
+#define CONTINUATIONS_PER_BITMAP (sizeof(bitmap_t) * 8)
 #define BITMAPS_PER_SUPERMAP (BYTES_PER_SUPERMAP * 8)
 
 #define BYTES_PER_MAGAZINE (PAGES_PER_MAGAZINE * DISPATCH_ALLOCATOR_PAGE_SIZE)
-#define CONSUMED_BYTES_PER_BITMAP (BYTES_PER_BITMAP + \
+#define CONSUMED_BYTES_PER_BITMAP (sizeof(bitmap_t) + \
 		(DISPATCH_CONTINUATION_SIZE * CONTINUATIONS_PER_BITMAP))
 
-#define BYTES_PER_SUPERMAP BYTES_PER_BITMAP
+#define BYTES_PER_SUPERMAP sizeof(bitmap_t)
 #define CONSUMED_BYTES_PER_SUPERMAP (BYTES_PER_SUPERMAP + \
 		(BITMAPS_PER_SUPERMAP * CONSUMED_BYTES_PER_BITMAP))
 
@@ -138,8 +133,8 @@ typedef unsigned long bitmap_t;
 // this will round up such that first_bitmap_in_same_page() can mask the address
 // of a bitmap_t in the maps to obtain the first bitmap for that same page
 #define ROUND_UP_TO_BITMAP_ALIGNMENT(x) \
-		(((x) + ((BITMAPS_PER_PAGE * BYTES_PER_BITMAP) - 1u)) & \
-		~((BITMAPS_PER_PAGE * BYTES_PER_BITMAP) - 1u))
+		(((x) + ((BITMAPS_PER_PAGE * sizeof(bitmap_t)) - 1u)) & \
+		~((BITMAPS_PER_PAGE * sizeof(bitmap_t)) - 1u))
 // Since these are both powers of two, we end up with not only the max alignment,
 // but happily the least common multiple, which will be the greater of the two.
 #define ROUND_UP_TO_BITMAP_ALIGNMENT_AND_CONTINUATION_SIZE(x) (ROUND_UP_TO_CONTINUATION_SIZE(ROUND_UP_TO_BITMAP_ALIGNMENT(x)))
@@ -148,7 +143,7 @@ typedef unsigned long bitmap_t;
 #define PADDING_TO_CONTINUATION_SIZE(x) (ROUND_UP_TO_CONTINUATION_SIZE(x) - (x))
 
 #define SIZEOF_SUPERMAPS (BYTES_PER_SUPERMAP * SUPERMAPS_PER_MAGAZINE)
-#define SIZEOF_MAPS (BYTES_PER_BITMAP * BITMAPS_PER_SUPERMAP * \
+#define SIZEOF_MAPS (sizeof(bitmap_t) * BITMAPS_PER_SUPERMAP * \
 		SUPERMAPS_PER_MAGAZINE)
 
 // header is expected to end on supermap's required alignment
@@ -171,7 +166,7 @@ typedef unsigned long bitmap_t;
 #define REMAINDER_IN_FIRST_PAGE (BYTES_LEFT_IN_FIRST_PAGE - \
 		(FULL_BITMAPS_IN_FIRST_PAGE * CONSUMED_BYTES_PER_BITMAP) - \
 		(FULL_BITMAPS_IN_FIRST_PAGE ? 0 : \
-		ROUND_UP_TO_CONTINUATION_SIZE(BYTES_PER_BITMAP)))
+		ROUND_UP_TO_CONTINUATION_SIZE(sizeof(bitmap_t))))
 
 #define REMAINDERED_CONTINUATIONS_IN_FIRST_PAGE \
 		(REMAINDER_IN_FIRST_PAGE / DISPATCH_CONTINUATION_SIZE)
@@ -181,7 +176,7 @@ typedef unsigned long bitmap_t;
 		(REMAINDERED_CONTINUATIONS_IN_FIRST_PAGE == 0 ? 0 : 1))
 
 #define FPMAPS_TO_FPCONTS_PADDING (PADDING_TO_CONTINUATION_SIZE(\
-		BYTES_PER_BITMAP * BITMAPS_IN_FIRST_PAGE))
+		sizeof(bitmap_t) * BITMAPS_IN_FIRST_PAGE))
 
 #else // PACK_FIRST_PAGE_WITH_CONTINUATIONS