create a macro to reduce the head strain of getting the width of a type

makefile

@@ -1,5 +1,5 @@
 CC      ?= cc
-CFLAGS  += -Wall -Wextra -Wpedantic -O3 -MD -MP -std=gnu99
+CFLAGS  += -Wall -Wextra -Wpedantic -O3 -MD -MP -std=gnu99 -DNDEBUG
 LDFLAGS +=
 
 SRC = $(shell find src/ -name '*.c')

src/main.c

@@ -13,6 +13,8 @@
 		exit(ret);                                     \
 	} while (0)
 
+#define WIDTHOF(x) (sizeof(x) * 8)
+
 typedef unsigned long long ull;
 
 typedef struct dynrdat {
@@ -20,17 +22,21 @@ typedef struct dynrdat {
 	ull dat[];
 } dynrdat;
 
+dynrdat* rdat = NULL;
+
 static inline ull pow2_ceil(ull x) {
-	x -= !!x;                        // if x=0, remains 0; else x -= 1
-	int lz = __builtin_clzll(x | 1); // get leading zeroes
-	return (~0ULL >> lz) + 1;        // bit-shift the maximum value by this amount of leading zeroes
+	x -= !!x; // if x=0, remains 0; else x -= 1
+	return 1ULL << (WIDTHOF(ull) - __builtin_clzll(x | 1));
+}
+
+static void quit(void) {
+	free(rdat);
 }
 
 int main(int argc, char** argv) {
 	// return the result if no input
-	if (argc <= 1) return printf("%s\n", (rand() & 1) ? "heads" : "tails");
-
-	dynrdat* rdat = NULL;
+	if (argc <= 1) return printf("%s\n", (clock() & 1) ? "heads" : "tails");
+	atexit(quit);
 
 	// loop through arguments
 	for (unsigned i = 1; i < (unsigned)argc; ++i) {
@@ -40,24 +46,22 @@ int main(int argc, char** argv) {
 		if (errno != 0) error(errno, "parse error for string: '%s'\n", argv[i]);
 
 		// acquire random data (compiler will optimize MOD and DIV away since they're both base-2 constant values)
-		ull mod = c % (sizeof(ull) * 8); // get the remainder of the available random bits
-		c = c / (sizeof(ull) * 8);       // compute our "word count"
+		int mod = c % WIDTHOF(ull); // get the remainder of the available random bits
+		c = c / WIDTHOF(ull);       // compute our "word count"
 
 		// dynamically scale the array to our needs, ensuring 2^n scaling
 		size_t cap = pow2_ceil(c + !!mod);
 		if (!rdat || rdat->cap < cap) {
 			void* ptr = realloc(rdat, sizeof(dynrdat) + sizeof(ull) * cap);
-			if (!ptr) {
-				free(rdat);
-				error(1, "insufficient memory\n", );
-			}
+			if (!ptr) error(1, "insufficient memory\n", );
 
 			rdat = ptr;
 			rdat->cap = cap;
 		}
 
 		// populate the array with random data
-		getrandom(rdat->dat, c + !!mod, 0);
+		if (getrandom(rdat->dat, (c + !!mod) * sizeof(ull), 0) < 0)
+			error(1, "failed to acquire random data!\n", );
 
 		// perform for the input count
 		ull headsc = 0; // amount of heads
@@ -68,7 +72,7 @@ int main(int argc, char** argv) {
 		for (; n < (rdat->dat + c); n++) {
 			int cnt = __builtin_popcountll(*n); // counts the set bits
 			headsc += cnt;
-			tailsc += sizeof(ull) * 8 - cnt;
+			tailsc += WIDTHOF(ull) - cnt;
 		}
 
 		// if there is a remainder, use the last N to get this
@@ -76,14 +80,12 @@ int main(int argc, char** argv) {
 			ull msk = (1 << mod) - 1; // get a mask with the set word size
 			int cnt = __builtin_popcountll(*n & msk);
 			headsc += cnt;
-			tailsc += c - cnt;
+			tailsc += mod - cnt;
 		}
 
 		// print the results of this cycle
 		printf("results:\n heads: %llu\n tails: %llu\n", headsc, tailsc);
 	}
 
-	free(rdat);
-
 	return 0;
 }