Andrei Alexandrescu's CppCon 2019 talk revisits sorting, showing how branchless tricks, hybrid strategies and a cost metric can speed up std::sort-style algorithms on modern hardware.
Why Hacker News points people here: HN recommends it as an entertaining talk that starts simple and goes deep on practical performance optimization.
“At first he is just showing simple stuff, but stay with it, he goes deep.”HN comment, 2023
“they're entertaining, approachable, and inspiring”
Entertaining, approachable, inspiring keynote on sorting performance
Full comment
Not exactly a lecture series, but Andrei Alexandrescu has had some fantastic keynote presentations at CppCon. I don't even program in C++ any more, but I've watched these more than once, they're entertaining, approachable, and inspiring: Speed Is Found In The Minds of People this video std::allocator Is to Allocation what std::vector Is to Vexation link An actual lecture series I've enjoyed watching is "The WE-Heraeus International Winter School on Gravity and Light", which covers General Relativity using modern mathematical approaches: link Again, I haven't done physics in 20 years, but I've found it surprisingly easy to follow because it is so clearly presented.
Strongly recommendsbborehamDec 2023
“At first he is just showing simple stuff, but stay with it, he goes deep.”
Starts simple then goes deep on performance
Full comment
I really enjoyed “Speed Is Found In The Minds Of People”, a talk by Andrei Alexandrescu. At first he is just showing simple stuff, but stay with it, he goes deep. this video
RecommendsUnited857Oct 2019
“Andrei Alexandrescu gave a great talk at this year's CppCon about practical sorting”
Practical sorting and when to leave quicksort
Full comment
If you're interested in these types of implementation/optimization details, Andrei Alexandrescu gave a great talk at this year's CppCon about practical sorting, e.g. when to break out of quicksort to something else: this video
RecommendsplanteenOct 2019
“I saw a great talk at CppCon 2019 by Andrei Alexandrescu about speeding up std::sort.”
Speeding up std::sort with branchless tricks
Full comment
The article is C++, so not sure why you are bringing up AOT/JIT since it doesn't apply here. And clearly there is a large gain possible by doing a calculation rather than a conditional with a high entropy result, otherwise, the article's mentioned speedup wouldn't have happened. A PGO feedback loop isn't going to do anything on a high entropy conditional. I saw a great talk at CppCon 2019 by Andrei Alexandrescu about speeding up std::sort. He does this same trick among others to speed up the C++ std library sort routine. this video
RecommendsnestorDNov 2019
“If this question intress you, it is worth watching.”
Optimizing sort for medium vectors, with closing thoughts
Full comment
In his talk "Speed Is Found In The Minds of People" [0], Andrei Alexandrescu tries to make a sort really fast for medium sized vector and then closes on thoughts on this precise distinction. If this question intress you, it is worth watching. [0]: this video
RecommendsjacobolusJan 2020
“I enjoyed Alexandrescu’s CppCon 2019 talk”
Optimizing generic sorting for modern hardware
Full comment
I enjoyed Alexandrescu’s CppCon 2019 talk “Speed Is Found In The Minds of People” About optimizing generic sorting routines for modern hardware. this video
Recommendsr_sreeramSep 2023
“Here's an excellent example of what GP said”
Shows more code can be faster than less code
Full comment
Here's an excellent example of what GP said: this video (long video, skip to 26:00 if you are in a hurry) The key is that code isn't running in a vacuum. It's operating on data (or controlling systems, etc). A smaller amount of code may be operating on the data in an inefficient manner, whereas a larger amount may be doing it more efficiently. In the above talk, this contrast is very stark, because the "more code" version does some stuff and then does the exact thing the "less code" version does, yet is faster. This kind of thing is common enough (albeit less stark than in the above example), that "less code is faster" is not a great "default" assumption to make.
Cites itjeffreygoestoApr 2020
Generic implementations cannot exploit data properties
Full comment
Well, this argument goes both ways, a generic implementation can never leverage special properties of your data. See i.e. Alexandrecu's talk [0] at about 1:05ff. If as a company you have special use cases or guidelines, you may easily benefit from libraries using these properties. [0] this video
Cites itlumberjackstianMay 2020
Proposes a sorting cost metric including access distance
Full comment
I'm not sure about much analysis and theory that explicitly captures branch prediction, but in last year's cppcon keynote Andrei offered a possible metric [0] where he takes into account the average "distance" between two subsequent array accesses. It's basically, (C(n) + M(n) + kD(n)) / n Where M is moves, C is comparisons, k is a some constant, and D is "distance". [0]: this video
Cites itthomas43Jun 2020
Listed among assorted links on optimization
Full comment
Do you have some more detaile about your app? I use perf, sysprof, trace32, visual studio profiler for profiling, but this highly depends on your environment. These assorted links might be interesting to you: - link - this video - link - link
Cites itjiggawattsMar 2024
Small std library optimizations done at Facebook
Full comment
The FAANGS certainly have people doing this kind of work. For example, Andrei Alexandrescu has a bunch of keynote talks at CPPCon where he talks about 1-4% speed optimisations he makes to the std library at Facebook. this video I also like the talk by Nicholas Ormrod “The strange details of std::string at Facebook": link
