It is known that C++
bools must be at least 1 byte in size so that pointers can be created for each [https://stackoverflow.com/a/2064565/7154924]. But there are no pointers to primitive types in Java. Yet, they still take up at least 1 byte [https://stackoverflow.com/a/383597/7154924].
Why is this the case – why can’t Java
booleans be 1 bit in size? Computation time aside, if one has a large
boolean array, surely one could conceive a compiler that does the appropriate shifting to retrieve the individual bit corresponding to a
There is no reason why a boolean must be one byte in size. In fact, is likely that booleans already aren’t 1 byte in (effective) size in some scenarios: when packed next to other elements larger than 1 byte on the stack or in an object, they are likely to be larger (i.e., adding them to an object may cause the size to grow by more than one byte).
Any JVM is free to implement booleans as 1 bit, but as far as know none choose to do so, probably largely because:
Accessing one bit is often more expensive than accessing a byte, particularly when writing.
To read a bit, a CPU using a “classic RISC” instruction set would often need need an additional
andinstruction to extract the relevant bit out of a packed byte (or larger word) of boolean bits. Some might even need a additional instruction to load a constant to
and. In the case of indexing an array of
boolean, where the bit-index isn't fixed at compile-time, you'd need a variable shift. Some CPUs such as x86 have an easier time since they have memory sourcetest
instructions, including specific bit-test instructions taking a variable position such asbt`. Such a CPU probably has similar read performance in both representations.
Writing is worse: rather than a simple byte write to set a
booleanvalue you now need to read the value, modify the appropriate bit and write it back. Some platforms such as x86 have memory source-and-destination RMW instructions such as
orthat will help, but these are still significantly more expensive than plain writes. In the worst case, repeatedly writing the same element will result in a dependency chain through memory that could slow your code down by an order of magnitude (a series of plain stores can’t form a dependency chain).
Even worse, the write method above is totally thread-unsafe. Two threads working on “independent” booleans might clobber each other, so the runtime would have to use atomic update operations just to write a bit for any field where the object cannot be proven local to the thread.
The space savings outside of arrays is usually very small, and is often zero: alignment concerns mean that a single bit will often end up taking the same space as a byte on the stack or in the layout for an object. Only if you had many primitive
booleanvalues on the stack or an object would you see a savings (for example, objects are typically aligned to 8-byte boundaries, so if you have an object whose non-boolean fields are
intor larger, you’d need at least 4
booleanvalues to save any space, and often you’d need 8).
This leaves the last remaining “big win” for bit-representation
booleanin arrays of
boolean, where you could have an asymptotic 8x space savings for large arrays. In fact, this case was motivating enough in the C++ world that
vector<bool>there has a “special” implementation where each
booltakes one bit – a never ending source of headaches due to all the required special cases and non-intuitive behavior (and often used as an example of a mis-feature that can’t be removed now).
If it weren’t for the memory model I could imagine a world where Java
implemented arrays of
booleanin a bit-wise manner. They don’t have
the same issues as
vector<bool>(mostly because of the extra layer of abtraction provided by the JIT and also because an array provides a simpler interface than
vector) and it could be done efficiently, I think. There is that pesky memory model though. That model allows writes to different array elements to be safe if done by different threads (i.e,. they act as independent variables for the purpose of the memory model). All common CPUs support this directly if you implement
booleanas a byte, since they have independent byte accesses. No CPUs offer independent bit-access though: you are stuck using atomic operations (x86 offers the
lock bt*operations, but these are slow: other platforms have even worse options). That would destroy the performance of any boolean array implemented as a bit-array.
Finally, as described above, implementing
boolean as a bit has significant downsides – but what about the upside?
As it turns out, if the user really wants this bit-packed representation of for boolean they can do so themselves! They can pack 8 boolean values into a
byte (or 32 values into an
int or whatever) in an object (and this is common for flags, etc) and the generated accessor code should be about efficient as efficient as if the JVM natively supported boolean-as-bit. In fact, when you know you want an array-of-bits representation for a large number of booleans, you can simply use
BitSet – this has the representation you want and sidesteps the atomic issues by not offering any thread-safety guarantees. So by implementing
boolean as a byte, you sidestep all the problems above, but still let the user “opt-in” to bit-level representation if they want, without much runtime penalty.