What is faster, 'bool' or an integer type?

EDITED 2021-12-16 19:07: Show comparison against both uint and uchar, and also show both GCC and Clang. Add -march=native to compiler flags. Now the results seem to show that bool is as good as other integer types, but some compilers produce sub-optimal code.

EDITED 2022-01-11 18:56: After some tests, slightly changing the code can show important performance problems, more likely to be present with _Bool than uint.

For my tests, I chose unsigned types, since that's what the project was using instead of bool, but I expect signed types to behave similarly.

I'll show here the tests with unsigned char, since bool is 1 byte in my system and that reduces the difference in assembly output, and also unsigned int to compare different widths.

I tested storing an integer into one of these types (bool, unsigned char, and unsigned int), using one of these types to control a selection statement, and using one of this types as a parameter of a function.

Source code:

// repeat.h:

#pragma once #define repeat2(e) (e);(e) #define repeat4(e) repeat2(e);repeat2(e) #define repeat8(e) repeat4(e);repeat4(e) #define repeat16(e) repeat8(e);repeat8(e) #define repeat32(e) repeat16(e);repeat16(e) #define repeat64(e) repeat32(e);repeat32(e) #define repeat128(e) repeat64(e);repeat64(e) #define repeat256(e) repeat128(e);repeat128(e) #define repeat512(e) repeat256(e);repeat256(e) #define repeat1024(e) repeat512(e);repeat512(e) #define repeat(e) do \ { \ repeat16(e); \ } while (0) 

// store_bool.h:

#pragma once _Bool store_bool(long n, int x); 

// store_bool.c:

#include "store_bool.h" #include "repeat.h" _Bool store_bool(long n, volatile int x) { volatile _Bool b; for (long i = 0; i < n; i++) repeat(b = x); return b; } 

// store_uchar.h:

#pragma once unsigned char store_uchar(long n, int x); 

// store_uchar.c:

#include "store_uchar.h" #include "repeat.h" unsigned char store_uchar(long n, volatile int x) { volatile unsigned char c; for (long i = 0; i < n; i++) repeat(c = x); return c; } 

// store_uint.h:

#pragma once unsigned int store_uint(long n, int x); 

// store_uint.c:

#include "store_uint.h" #include "repeat.h" unsigned int store_uint(long n, volatile int x) { volatile unsigned int u; for (long i = 0; i < n; i++) repeat(u = x); return u; } 

// consume_bool.h:

#pragma once int consume_bool(long n, _Bool b); 

// consume_bool.c:

#include "consume_bool.h" #include "repeat.h" int consume_bool(long n, volatile _Bool b) { volatile int x = 5; for (long i = 0; i < n; i++) repeat({if (b) x = 3;}); return x; } 

// consume_uchar.h:

#pragma once int consume_uchar(long n, unsigned char u); 

// consume_uchar.c:

#include "consume_uchar.h" #include "repeat.h" int consume_uchar(long n, volatile unsigned char c) { volatile int x = 5; for (long i = 0; i < n; i++) repeat({if (c) x = 3;}); return x; } 

// consume_uint.h:

#pragma once int consume_uint(long n, unsigned int u); 

// consume_uint.c:

#include "consume_uint.h" #include "repeat.h" int consume_uint(long n, volatile unsigned int u) { volatile int x = 5; for (long i = 0; i < n; i++) repeat({if (u) x = 3;}); return x; } 

// param_bool_.h:

#pragma once int param_bool_(_Bool x); 

// param_bool_.c:

#include "param_bool_.h" int param_bool_(_Bool b) { return b ? 3 : 5; } 

// param_bool.h:

#pragma once void param_bool(long n, _Bool b); 

// param_bool.c:

#include "param_bool.h" #include "param_bool_.h" #include "repeat.h" void param_bool(long n, volatile _Bool b) { for (long i = 0; i < n; i++) repeat(param_bool_(b)); } 

// param_uchar_.h:

#pragma once int param_uchar_(unsigned char c); 

// param_uchar_.c:

#include "param_uchar_.h" int param_uchar_(unsigned char c) { return c ? 3 : 5; } 

// param_uchar.h:

#pragma once void param_uchar(long n, unsigned char c); 

// param_uchar.c:

#include "param_uchar.h" #include "param_uchar_.h" #include "repeat.h" void param_uchar(long n, volatile unsigned char c) { for (long i = 0; i < n; i++) repeat(param_bool_(c)); } 

// param_uint_.h:

#pragma once int param_uint_(unsigned int u); 

// param_uint_.c:

#include "param_uint_.h" int param_uint_(unsigned int u) { return u ? 3 : 5; } 

// param_uint.h:

#pragma once void param_uint(long n, unsigned int u); 

// param_uint.c:

#include "param_uint.h" #include "param_uint_.h" #include "repeat.h" void param_uint(long n, volatile unsigned int u) { for (long i = 0; i < n; i++) repeat(param_bool_(u)); } 

// main.c:

#include <stdio.h> #include <time.h> #include "store_bool.h" #include "store_uchar.h" #include "store_uint.h" #include "consume_bool.h" #include "consume_uchar.h" #include "consume_uint.h" #include "param_bool.h" #include "param_uchar.h" #include "param_uint.h" #define measure(e) \ ({ \ clock_t t0, t1; \ double t; \ \ t0 = clock(); \ e; \ t1 = clock(); \ \ t = (double) (t1 - t0) / CLOCKS_PER_SEC; \ t; \ }) int main(int argc, char *argv[]) { double sb, sc, su; double cb, cc, cu; double pb, pc, pu; long n; if (argc != 2) exit(2); n = atol(argv[1]); sb = measure(store_bool(n, 1)); sc = measure(store_uchar(n, 1)); su = measure(store_uint(n, 1)); cb = measure(consume_bool(n, 1)); cc = measure(consume_uchar(n, 1)); cu = measure(consume_uint(n, 1)); pb = measure(param_bool(n, 1)); pc = measure(param_uchar(n, 1)); pu = measure(param_uint(n, 1)); printf("n: %li\n", n); putchar('\n'); printf("store bool: %lf\n", sb); printf("store uchar: %lf\n", sc); printf("store uint: %lf\n", su); putchar('\n'); printf("consume bool: %lf\n", cb); printf("consume uchar: %lf\n", cc); printf("consume uint: %lf\n", cu); putchar('\n'); printf("param bool: %lf\n", pb); printf("param uchar: %lf\n", pc); printf("param uint: %lf\n", pu); } 

I used volatile for some variables, to avoid the compiler optimizing out the multiple assignments and tests.

Since the compiler will not unroll the loops, as they are huge, I used many (16) repeated expressions in each loop (see the repeat() macro), to reduce the impact of the loop overhead (jump instructions) in the total benchmark time.

Compiling:

$ cc -Wall -Wextra -O3 -march=native -S *.c $ cc -O3 -march=native *.s $ 

Assembly:

I'll cherry-pick a single one of the 16 repetitions, to simplify. If you want to see full assembly files, you can compile them yourself (I gave here enough instructions).

// store_bool.s (GCC):

 movl -20(%rsp), %edx testl %edx, %edx setne %dl movb %dl, -1(%rsp) 

// store_bool.s (Clang):

 cmpl $0, -4(%rsp) setne -5(%rsp) 

// sotre_uchar.s (GCC):

 movl -20(%rsp), %edx movb %dl, -1(%rsp) 

// store_uchar.s (Clang):

 movl -4(%rsp), %ecx movb %cl, -5(%rsp) 

// store_uint.s (GCC):

 movl -20(%rsp), %edx movl %edx, -4(%rsp) 

// store_uint.s (Clang):

 movl -4(%rsp), %ecx movl %ecx, -8(%rsp) 

From the above, uchar and uint are likely to be the same. bool has two instructions too on Clang, but they are different; that may or may not make a difference. On GCC, it clearly has 2 extra instructions compared to uchar which makes it slower.

// consume_bool.s (GCC):

 movzbl -20(%rsp), %edx testb %dl, %dl je .L2 movl $3, -4(%rsp) .L2: 

// consume_bool.s (Clang):

.LBB0_5: # in Loop: Header=BB0_1 Depth=1 testb $1, -5(%rsp) jne .LBB0_6 [...] .LBB0_6: # in Loop: Header=BB0_1 Depth=1 movl $3, -4(%rsp) testb $1, -5(%rsp) je .LBB0_9 

(LBB0_9 is similar to LBB0_5)

// consume_uchar.s (GCC):

 movzbl -20(%rsp), %edx testb %dl, %dl je .L2 movl $3, -4(%rsp) .L2: 

// consume_uchar.s (Clang):

 cmpb $0, -5(%rsp) je .LBB0_3 # %bb.2: # in Loop: Header=BB0_1 Depth=1 movl $3, -4(%rsp) .LBB0_3: # in Loop: Header=BB0_1 Depth=1 

// consume_uint.s (GCC):

 movl -20(%rsp), %edx testl %edx, %edx je .L2 movl $3, -4(%rsp) .L2: 

// consume_uint.s (Clang):

 cmpl $0, -4(%rsp) je .LBB0_3 # %bb.2: # in Loop: Header=BB0_1 Depth=1 movl $3, -8(%rsp) .LBB0_3: # in Loop: Header=BB0_1 Depth=1 

In these cases, the assembly produced by GCC is almost identical for the 3 types, so I don't expect any difference. In Clang, bool has different code, but since it's very different, it's hard to predict if it will be faster or slower than the integers.

// param_bool_.s (GCC):

param_bool_: .LFB0: .cfi_startproc cmpb $1, %dil sbbl %eax, %eax andl $2, %eax addl $3, %eax ret .cfi_endproc .LFE0: 

// param_bool_.s (Clang):

param_bool_: # @param_bool_ .cfi_startproc # %bb.0: xorb $1, %dil movzbl %dil, %eax addl %eax, %eax addl $3, %eax retq .Lfunc_end0: 

// param_bool.s (GCC):

 movzbl 12(%rsp), %edi call param_bool_@PLT 

// param_bool.s (Clang):

 movzbl 15(%rsp), %edi andl $1, %edi callq param_bool_ 

// param_uchar_.s (GCC):

param_uchar_: .LFB0: .cfi_startproc cmpb $1, %dil sbbl %eax, %eax andl $2, %eax addl $3, %eax ret .cfi_endproc .LFE0: 

// param_uchar_.s (Clang):

param_uchar_: # @param_uchar_ .cfi_startproc # %bb.0: xorl %eax, %eax testl %edi, %edi sete %al addl %eax, %eax addl $3, %eax retq .Lfunc_end0: 

// param_uchar.s (GCC):

 movzbl 12(%rsp), %edi call param_uchar_@PLT 

// param_uchar.s (Clang):

 movzbl 15(%rsp), %edi callq param_uchar_ 

// param_uint_.s (GCC):

param_uint_: .LFB0: .cfi_startproc cmpl $1, %edi sbbl %eax, %eax andl $2, %eax addl $3, %eax ret .cfi_endproc .LFE0: 

// param_uint_.s (Clang):

param_uint_: # @param_uint_ .cfi_startproc # %bb.0: xorl %eax, %eax testl %edi, %edi sete %al addl %eax, %eax addl $3, %eax retq .Lfunc_end0: 

// param_uint.s (GCC):

 movl 12(%rsp), %edi call param_uint_@PLT 

// param_uint.s (Clang):

 movl 12(%rsp), %edi callq param_uint_ 

In this case, bool should be the same as uchar since the only important thing should be the width, and we might see (or not) a difference with uint. A part from zero extending, there's not much difference. There are slight differences between GCC and Clang, however, Clang producing larger code, so I expect Clang to run slightly slower than GCC.

Timing:

// amd64, gcc-11, i5-5675C:

$ ./a.out 1073741824 store bool: 4.928789 store uchar: 4.795028 store uint: 4.803893 consume bool: 4.795776 consume uchar: 4.794873 consume uint: 4.794079 param bool: 17.713958 param uchar: 17.611229 param uint: 17.688909 

// amd64, clang-13, i5-5675C:

$ ./a.out 1073741824 store bool: 4.806418 store uchar: 4.802943 store uint: 4.800172 consume bool: 4.805537 consume uchar: 4.799858 consume uint: 4.799462 param bool: 19.095543 param uchar: 17.708014 param uint: 17.782490 

In 'store', as we expected, bool is slower than the other types with GCC (around 1~10%). With Clang, there's no significant difference (I've seen bool consistently be a bit slower than the others, but less than 0.5%).

In 'consume', we see no difference between types or compilers.

In 'param', times vary a lot between runs, and there's no consistency: sometimes bool is slower, and sometimes it's faster. However, GCC is consistently faster than Clang.

Slight changes in the code can lead to compilers missing important optimizations. Using the following code in consume_<type>.c, leads to some important performance loss:

 repeat(x = b ? 3 : x); 

Note that just by changing an if to a ternary operator, makes the compiler slow down to the following times:

GCC:

$ ./a.out 1073741824 n: 1073741824 ... consume bool: 8.684662 consume uchar: 8.683915 consume uint: 8.086806 ... 

Clang:

$ ./a.out 1073741824 n: 1073741824 ... consume bool: 8.161896 consume uchar: 5.422896 consume uint: 5.127165 ... 

Clang slows down considerably for _Bool, while maintaining a reasonable speed for other types. GCC seems to generate quite bad code for all the types.

Conclusion:

Programmers should consider a few things:

Performance: Even though _Bool may be theoretically as fast as unsigned int, compilers are far from being ideal, and it is likely that your compiler will miss some optimizations, which in some cases may be quite important.

Maintainability/readability/correctness: Some may argue that _Bool is safer due to autonormalization; others may argue that it is less safe due to autonormalization; just know what you're using, and form your own opinion.

Supporting pre-C99 code: If that's the case, you have no choice but using unsigned int.