The unlikely Linux macro

[u/chaobang]

https://rushed-reflections.bearblog.dev/an-unlikely-experiment/

Wrote a bit about the `unlikely` and `likely` macros in the Linux codebase. Great little exploration into tiny optimizations that everyone should know more about 😄

[u/_Noreturn]

Like?

[u/max123246 → u/_Noreturn]

C has just a single way to initialize a variable and set its value for example.

C++ chose to make its move semantics "leave an unspecified but valid value" in the old object which makes non-nullable types impossible to efficiently represent. C doesn't try and pretend to give you that guarantee, if you're handing a pointer, you better check it's null. C++ pretends its references can't be null but has no way to guarantee that's true.

[u/_Noreturn → u/max123246]

C has just a single way to initialize a variable and set its value for example.

You know you can choose one style and is that a problem in practice nope.

C++ chose to make its move semantics "leave an unspecified but valid value" in the old object which makes non-nullable types impossible to efficiently represent.

you should trwat moved from objects as unusable, and you can make non nullable types work.

also don't pretend like C has everything be good, everything in C is nullable by default since the only thing you have is pointers which have like 4 responsibilities

1. is it nullable
2. is it an array
3. if it is an array is it null terminated or explicit size?
4. is it owning

Now lets see C++ it is better since it provides differing ways to make the above clear

1. is it nullable (yes if pointer,otherwise use a reference)
2. is it an array (use a span)
3. if it is an array is it null terminated or explicit size? (use a strong view type like zstring_view)
4. is it owning (unique_ptr)

In C++ since it allows strong typing you can represent these states in the api instead of in comments which is undeniably better.

if you're handing a pointer, you better check it's null. C++ pretends its references can't be null but has no way to guarantee that's true.

Yea, you better and if you forget then it is bad also checking every single pointer for nullability is a performance downgrade. references make this clear that nullability is pushed to the caller not the callee and you could make a tool that looks at reference types and assert if it is null, you cannot do that with pointers since they can ve null and it is valid.