Array of booleans

[John Rose]

Here is some deep background on boolean normalization:

https://mail.openjdk.java.net/pipermail/hotspot-compiler-dev/2016-August/024263.html

TL;DR: It’s important to the Java JIT that Java booleans are
conditioned (normalized, canonicalized) to 0 or 1, even though
containers that hold booleans are 8 bits (in Java heap, or 32 bits,
on the JVM stack).  HotSpot and JNI (and java.lang.invoke)
have a delicate web of normalizations to ensure this, using
either x!=0 or else x&1.

Java booleans are stored in 1-byte containers on all JVMs I know
of.  The JVMS strongly encourages this by using the same baload
instruction for both byte[] and boolean[]; packed boolean arrays
would therefore require a dynamic test.  And it would also be
hard for a packed boolean array to satisfy the JMM, since no
hardware we deploy on have bitwise concurrent access to memory,
short of using CAS-like algorithms.  So, T_BOOLEAN is a byte
which contains either 0 or 1, or (at worst) has access methods
which perform either x!=0 or x&1 normalizations.

On Mar 18, 2021, at 10:07 AM, Paul Sandoz <paul.sandoz at oracle.com<mailto:paul.sandoz at oracle.com>> wrote:



On Mar 18, 2021, at 9:57 AM, David Lloyd <david.lloyd at redhat.com<mailto:david.lloyd at redhat.com>> wrote:

Out of curiosity, semantically would these vector operations be more like splaying the bits of the bytes into booleans, or more like mapping each byte into a true/false value?


The latter:

 false -> 0b; true -> 1b

There would be some normalization the other way around e.g.

 0b -> false; otherwise -> true

(Internally HotSpot storage mapping would be 0b -> 0b; otherwise -> 1b, IIRC what Unsafe does.)

Paul.