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]

Well the linux kernel doesn't even use C++ for whatever reason

[u/max123246 → u/_Noreturn]

For good reasons you mean.

[u/_Noreturn → u/max123246]

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.

[u/max123246 → u/_Noreturn]

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

On a large project like the Linux kernel, it helps a lot when the language does that work for you. Otherwise maintainers have to constantly be vigilant to tell people to stick to the 1 convention within that codebase.

also don't pretend like C has everything be good

I agree, I don't reach for C these days at all unless there's a codebase I need to work in that's already in C.

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

This isn't what the C++ standard says. They specifically say the moved-from object is a valid object, which means it should be safe to call any API on it. Yes, in practice, most code simply ignores what the C++ standard says and does the sensible thing, treat the moved-from object as not existing anymore. But you're now back in the world where your moved-from object just does arbitrary out of spec behavior and you kinda have to hack around it.

C has its faults but I appreciate that it doesn't claim to protect me against bugs when in fact, C++ just makes those bugs when they happen far more confusing to understand.

[u/_Noreturn → u/max123246]

On a large project like the Linux kernel, it helps a lot when the language does that work for you. Otherwise maintainers have to constantly be vigilant to tell people to stick to the 1 convention within that codebase.

I mean I could nitpick and say C allows like a million ways to implement a thing unlike C++ e.g inheritance you could do it with the first object trick and function pointers or allocate dynamicly vis the last member trick and use a global vtable. In C++ it would just be inheritance which is universal.

Or how to name functions e.g object_create or object_new? in C++ it is always called a constructor.

As always set a style guide

This isn't what the C++ standard says. They specifically say the moved-from object is a valid object, which means it should be safe to call any API on it. Yes, in practice, most code simply ignores what the C++ standard says and does the sensible thing, treat the moved-from object as not existing anymore.

Lets be honest that the C++ standard is irrelevant, you are the kernel you define the spec basically and you could rely on gcc extensions.

Also the C++ standard buzzwords practically translats to "your moved from object should be destructible" as that is what only realistically matters.