Yeah but please don’t actually use this. Use a proper UUID library that works cross-platform and lets you choose the UUID type and can be seeded etc.

Catchy. Can’t imagine why “algorithm” caught on instead.

It is not. A bool in C, C++, Rust, Go, and every language that I know is 1 byte. Why are you arguing this basic very well known fact so much?

Just say “oh I was mistaken, TIL”. It’s not shameful.

but calling malloc_usable_size(malloc(1)) is giving me 24, so it at least allocated 24 bytes for my 1, plus any tracking overhead

Indeed. Padding exists. A bool is still one byte.

it’ll get 3+ extra bytes added on the next fn call.

…of padding. Jesus. Are you going to claim that uint16_t is not 2 bytes because it is sometimes followed by padding?

Wrong again. It depends on the CPU. They can absolutely read a single byte and they will do if you’re reading from non-idempotent memory.

If you’re reading from idempotent memory they won’t read a byte or a word. They’ll likely read a whole cache line (usually 64 bytes).

And if you read the ARM article you linked, it literally says so.

Where?

Thus any compiler worth their salt will align all byte variables to words for faster memory access.

No they won’t because it isn’t faster. The CPU will read the whole cache line that contains the byte.

RTFM

Well, I would but no manual says that because it’s wrong!

but if you have a single bool in a stack frame it’s probably going to be more than a byte.

Nope. - if you can’t read RISC-V assembly, look at these lines

        sb      a5,-17(s0)
...
        sb      a5,-18(s0)
...
        sb      a5,-19(s0)
...

That is it storing the bools in single bytes. Also I only used RISC-V because I’m way more familiar with it than x86, but it will do the same thing.

on the heap definitely more than a byte

Nope, you can happily malloc(1) and store a bool in it, or malloc(4) and store 4 bools in it. A bool is 1 byte. Consider this a TIL moment.

You said you can’t read one byte. I showed that you can. Where’s the confusion?

I think he’s talking about if a variable only exists in registers. In which case it is the size of a register. But that’s true of everything that gets put in registers. You wouldn’t say uint16_t is word-sized because at some point it gets put into a word-sized register. That’s dumb.

things that store it as word size for alignment purposes

Nope. bools only need to be naturally aligned, so 1 byte.

If you do

struct SomeBools {
  bool a;
  bool b;
  bool c;
  bool d;
};

its 4 bytes.

You can’t read one byte

lol what. You can absolutely read one byte: https://godbolt.org/z/TeTch8Yhd

On ARM it’s ldrb (load register byte), and on RISC-V it’s lb (load byte).

Every decent compiler will turn booleans into words.

No compiler I know of does this. I think you might be getting confused because they’re loaded into registers which are machine-word sized. But in memory a bool is always one byte.

You can’t store data in parity bits… so it’s irrelevant.

It’s not just less memory though - it might also introduce spurious data dependencies, e.g. to store a bit you now need to also read the old value of the byte that it’s in.

I don’t think so. Apart from dynamically typed languages which need to store the type with the value, it’s always 1 byte, and that doesn’t depend on architecture (excluding ancient or exotic architectures) or optimisation flags.

Which language/architecture/flags would not store a bool in 1 byte?

No it isn’t. All statically typed languages I know of use a byte. Which languages store it in an entire 32 bits? That would be unnecessarily wasteful.

Well there are containers that store booleans in single bits (e.g. std::vector<bool> - which was famously a big mistake).

But in the general case you don’t want that because it would be slower.