C++ Super Optimization: 1000X Faster

[@DavesGarage]

Thanks to everyone for the kind words on the intro... I was a little worried about using it, but had fun making it, so went out on a limb!

[@c4cypher]

Entertaining and informative, thank you.

[@NoLoseJustLearn]

Loved it

[@systemloc]

I laughed SO HARD when constexpr popped up. I haven't laughed that hard in awhile. Thank you for that.

[@jstro-hobbytech]

Dave. Can you do me a favor. I'll even donate 100cad to a charity of your choice. In the fastled library there's a udl in the tetris game written by Aaron liddement. I for the life of me do not understand the bitwise based udl code he has written to define the tertris blocks. I get what he's doing but can't find any other similar cases of the bitwise code using hex to and unsigned long data like the way he's done it. Scott Manley made a wearable matrix using his code years ago which made me see what was going on under the hood. I don't like using code I don't understand and it's driven me nuts ever since. I too am on the spectrum and have a software degree I never used until I had to medically retire a while back. I love your channel and have been around since the beginning and even if you could have a quick look and reccomend a book or something if you don't have the time to make a video. It's one of those things that gets stuck in my head from time to time and it kills me that I do not understand what he's doing fully. I suspect it's intentionally obfuscated and as someone who spends his retirement doing charity work and learning it's been a thorn in my side. I am 45 and plan on using my past credits toward a compsci or ee degree (as a bucket list item and to help me tutor programmers and develop free courses for a local non-profit makerspace). I've googled, bought books, stopped short of chatgpt because I don't want the info handed to me on a silver platter because I prefer to learn hands on. I understand how transistors perform math using different binary rules because I like to do things by coding and then trying the same wirh passive circuit components. He rewrote the sprite class so it no longer uses the udl but it still drives me nuts that I can't figure it out. I'm also a fellow Canadian but I hail from the ns side od the nfld ferry. I'm waiting for approval for funding for a 7 week inpatient program for how to live with ptsd and I'd like to spend my free time coding c++ while I'm away. I was going to bring a guitar but I'd rather work on a skill that I'm not as good at as I'm deciding which degree to pursue. I have a year and a half of credits which transfer to compsci or ee but I don't want to drag around my overpriced ee lab when I could write code instead with a decently powerful laptop. I plan to travel to Utah this summer to camp under the milky way before I hit the books again. I've spent the last 4 years donating half my disposable income from my pension to others so they can learn and put a proper electronics section in the local makerspace. My ptsd keeps me from being able to leave the house and teach there in person or attend the labs I'll have to attend when I go back to school. Sorry. I ramble. I figured you'd get what I mean when something is stuck in your head and can't move past it. I could link the git repository if you like. Id be extremely thankful and would make good on my donation.

[@egeres14]

Omg, my sides 😂, that intro was so good

[@unclerojelio6320]

KZbin kept recommending this to me and I was starting to get annoyed until I finally noticed it was a Dave’s Garage video.

[@EricBRowell]

😂

[@DavesGarage]

I was wondering about that, but sticking my head in the thumbnail seemed weird... maybe I should at first?

[@unclerojelio6320]

@@DavesGarage Yeah, the lack of your mug is why I didn’t immediately click on the video.

[@JamesPotts]

​@@DavesGaragequick work!

[@danwilson7581]

@DavesGarage it's much better than sticking your head in other places.

[@taltal1122]

Please note: constexpr just declares that it is POSSIBLE to calculate at compile time. It does not actually guarantee it unless the context demands it (as a template argument for example). The compiler will do its best but it might just call the function. c++20 added consteval which forces compile time evaluation.

[@skilz8098]

Thank you for pointing that out! I'm sure many are aware of this, yet there are just as many who aren't and for those who are new to it, this is really good information to be aware of. As a side note, this could also potentially be compiler dependent (implementation defined). I'm not 100% sure on this based on the literature of the standard so don't quote me on it. However, using MSVC vs Clang, vs GCC, vs Intel, vs MingW, etc... may provide the same results if they support and implement this feature of the language which by now I'm sure all major compilers do. Yet their methods of doing so can and will vary which also depends on the various compiler flags that are being used during compilation. It all depends on how each compiler parses, tokenizes and analyzes or handles the source code it is given to compile as well as how the programmer - user instructs the compiler or gives hints to the compiler to do its job. For simple expressions I would assume that almost all compilers would generate the same assembly, binary results. However for more complex expressions, the results may and can vary. Again, this is a really good and underrated comment. It is truly good advice to give!

[@ColinBroderickMaths]

It is guaranteed if you just constexpr the result. That is guaranteed to calculate at compile time or be a compile error.

[@skilz8098]

@@ColinBroderickMathsSure when the assignment operator is involved for a specific type. Now as for the evaluation of an expression, mileage may vary.

[@AlexandreA-w5c]

Is this really you, cpt. Obvious?

[@StupidusMaximusTheFirst]

They should give it some other name, it's confusing. Something like fconstexpr would be better.

[@hopperpl]

We use constexpr a lot for FIR/DCT/DFT (fourier transforms, wavelets) constant generation; this removes literally thousands of magic float numbers in the code, that are so error prone. Miss a number, flip a digit, mixup digit order. No code reviewer would ever notice if the 17th digit of PI is 3 or 2. The code generation only uses sqrt/sin/cos etc for which we have constexpr implementations. constexpr simply guarantees that the value is never ever calculated at runtime, and that's the real beauty of it.

[@serhii-ratz]

thank's for sharing practical example

[@sergeykolesnik1171]

this is not an optimization, this is meta programming. Your algorithm doesn't become faster because of the constexpr. It runs just as slow, but during compilation.

[@Dom-zy1qy]

​@@sergeykolesnik1171That was my takeaway

[@privateger]

​@@sergeykolesnik1171Precomputation absolutely is an optimization. You don't tend to compile as often as you run.

[@ra2enjoyer708]

@@sergeykolesnik1171 Algorithms don't have "speed", only complexity. "Fast" algos merely trade time complexity in exchange for space complexity and shit themselves the moment you start to hit RAM limits. I.e. a typical hash table has assumptions about the maximum size of the key storage and upon hitting this limit in best case scenario crashes, in the worst case rears its ugly side effects.

[@bobthemagicmoose]

I had a VERILOG class where a question on the exam was: create a component that calculates the factorial of 32 (or some number, I don’t remember). I hardcoded the result and returned the value :) got an A

[@NinjaRunningWild]

😂 Doesn't speak highly of grading in classes.

[@Divine_Evil]

Yeah typical unclear requirements... It should have been more generic. Something like: Having an 8bit input N, handshake start/result_rdy interface, clk, reset and an output 31 bit... Calculate the N! when start is asserted and then assert result_rdy when the correct value is done.

[@NotMarkKnopfler]

🤣🤣@@Divine_Evil

[@pilotashish]

don’t ask stupid questions if you don’t want stupid answers

[@muggzzzzz]

@@pilotashish Actually, there was nothing stupid in this question. The question was to compute a factorial of 32, not to make a function that computes a factorial for any given integer number (32 in particular case), and the program did exactly that.

[@Evan490BC]

I think it would be more accurate if we said that the `constexpr` specifier indicates that the expression *may* be evaluated at compile time, in a constant expression context, but not necessarily. And a `constexpr` function specifier may return such a value. If we want to force the function to produce a compile time constant expression (under some constraints), we must use `consteval`.

[@Malaka1802]

Why would you ever not want a function that can be evaluated at runtime or compile time? Just because the size of the binary?

[@Evan490BC]

@@Malaka1802 I'm not sure I understand your question. Compile-time evaluation is completely different than run-time: you must know every value beforehand. The size of the binary is not the main concern here, the goal is to pre-compute as much as you can before the runtime stage. Think of it as a _kind of_ "memoisation".

[@SforSamPlays]

⁠@@Malaka1802yes-ish, you generally want to compute everything in compile time if you can. Sometimes you just can’t know the values in runtime (like using user input or data from a file, etc), or it’s a functional only function (the point isn’t the result, it’s what’s doing, like `main()`, or `println()`)

[@Malaka1802]

@@SforSamPlays Thanks for the reply, so the compiler accepts the expression being constant but checks wether it is altered during runtime and then makes it a variable? So basically "make it constant if possible" ?

[@nunyobiznez875]

It's also worth mentioning that C23, which ironically should have just been submitted for final publication..today as a matter of fact, is adding 'constexpr' to C as well.

[@aniketbisht2823]

Nope, just constexpr variables not expression/function. So it's not that useful. Also C doesn't have "if constexpr" like C++ to make compile time code path decisions.

[@nunyobiznez875]

@@aniketbisht2823 Nope what? It would have taken you much less time to go to google and type "c23 constexpr".

[@zsomborgyenge4359]

@@aniketbisht2823 macro magic can do this in c

[@lpprogrammingllc]

Aside from performance gains, the best use of constexpr is unit testing. First, it's important to note that, unlike inlined internal functions, the constexpr functions themselves _are_ included in the program itself, unless stripped by a later step (such as `--whole-program` in g++), so you can have a program that uses constexpr to automatically return any values below some threshold and fall back to runtime evaluation _of the same code_ if in excess of that value. This means you can write fairly complicated state machines (first case I saw was a complete 6502 emulator) with a complete set of unit tests using `constexpr`. Then, they'll read the "real" data at runtime. By embedding the unit tests in the main compilation unit, you get the neat property that if it compiles, it's correct (so long as you don't encounter a compiler bug). You can even give it simple integration tests (like 10 steps of Conway's game of life on the virtual 6502).

[@JohnMullee]

Nice

[@ThePC007]

Doesn't that just mean that compiling now takes just as long as running the actual test would?

[@craigslist6988]

very cool and pretty well explained, thanks!

[@AnttiBrax]

​@@ThePC007That was implied in the latter part of the comment: "if it compiles, it is correct". So instead of running compile && test you just run compile.

[@ThePC007]

@@AnttiBrax But then, what do you gain from doing that? Since unit tests are compiled once, and the run once, there shouldn’t really be much of a performance differnce. I guess you might benefit from your IDE showing the error right inside your code, though, assuming it can actually catch such bugs.

[@ernestg.harveyjr7087]

That opening was fkn hilarious

[@drewwilson8756]

Thumbnail was pretty good as well.

[@Avighna]

Agreed!!!

[@DM-qm5sc]

Its from "Better call Saul" if you didnt know. Good show!

[@Roboprogs]

@@DM-qm5scso, Steven Ogg (I think I got “Trevor”’s real name right) had a guest bit? My wife used to watch Sol, but I only sampled a few episodes.

[@isodoublet]

To me, the biggest benefit of constexpr is that it significantly simplifies some stuff that previously would have to be written with template metaprogramming. Thanks to constexpr, just about anything that could be a regular operation on values can now be done in mostly ordinary-looking C++ instead of template stuff, which makes it much more likely to be done at all -- nobody wants to maintain template metaprograms.

[@johnshaw6702]

Well I wouldn't necessarily say that. I created my own meta templates before they became part of the standard. It was quite fascinating at the time and a very productive learning experience. The introduction of 'constexpr' was an extension of what some people were doing with templates already. It just allows you to write them in a more easily understood manor.

[@isodoublet]

@@johnshaw6702 It's true, templates were already Turing-complete so there was nothing you couldn't do before that you can now. But template metaprogramming is very hard to teach, and the syntax makes the code rather difficult to understand and debug. It's also purely functional (excepting the stateful template instantations thing which IMO should not be used in serious code), which is a completely different paradigm to normal C++. So constexpr stuff, while not giving any strictly "new" capabilities, makes the existing capabilities easy enough to use that I can convince my team to use them, for example, and be confident that people will "get it" and continue to get it over time. I don't shy away from template metaprogramming myself and there's some great tricks you can still only do using it, but the more that can be done using familiar syntax and patterns, the better.

[@sietzethebest]

Mostly used constexpr to generate lookup tables at compile time. I remember writing a cloth physics simulation that could use a lookup table of size 256 to avoid multiple multiplications and divisions. And as the table is small it will most likely be stored in a cache somewhere so it was really fast. Got an A+ on that assignment. :)

[@revenevan11]

That's a great example of a use for that, feel like I just understood the practicality a lot better now. Thanks!

[@jennalove6755]

Thats not a simulation then

[@germanassasin1046]

My favorite application of constexpr is compile time regular expression library, it evaluates your regex at compile time so you don’t have to worry about runtime cost of creating a regex. Also pretty cool one is in the fmt library where it checks whether the format string you provided is valid, btw this library partially made it into c++20 and was mostly completed in c++23 and I love it. Man, people are so creative.

[@TomMinnick]

Probably one of my favorite scenes in Better call Saul. Steven Ogg is awesome. I also live your mashup here with it!

[@w花b]

Big shots in that show

[@yarost12]

We had a C++ logging library that ran on embedded hardware, it was used to convert numerical debug level values into strings. There was a heap of functions that converted different log message types into readable strings. A few developers from the customer side complained that this lib alone could use the CPU to 100% when debugging was enabled slightly above default. We made those conversions constexpr and switched them to literal types and dropped the load quite significantly. What has to be mentioned is that constexpr functions will consume more stack space and programms will be larger, so you have to be careful with that. Sometimes it can be worth it, when you're fighting for kilobytes.

[@MorebitsUK]

Hi Dave, I've been trying constexpr and static constexpr lately, in a calculator for room heating ratings. Instead of having an array load in at runtime, I made the array static constexpr; low and behold the lookups were instantaneous and the it was 10x faster than the one that didn't do that. On a side note, a C++ Guru showed how it works in that case and all the array elements are coded as a lookup table in the code, making it 100x quicker. Great video as usual, keep up the content. 😃

[@Pedantic2025]

two things on this: 1. the [[assume(expr)]] attribute in C++ does something similar (it indicates to the compiler that it can assume expr holds. 2. using C++20's requires for templates, you can achieve a similar effect, but have the code detect how deep it has recursed and switch to a runtime implementation

[@Evan490BC]

Nice! I regard C++20's Concepts more as *declarative* type constraints (so I prefer `constexpr` for this case). In essence, you are suggesting something similar to Rust's procedural macros, if I'm not mistaken.

[@gabydewilde]

You can hard code the results in any language of course but if you want to enjoy some time off while compiling it's perfect.

[@attilatorok5767]

constexpr can never be as powerful as a python script that generates some code called in your makefile. It's dirty but it works.

[@tommclean9208]

@@attilatorok5767no

[@zamf]

constexpr is so powerful that if you go far enough in theory you can have your binary contain every possible state that your program can be in (calculated at compile-time) and then just "jump" to that program state based on your inputs that are only known at runtime. Of course, this would mean the binary could grow to an unimaginable size but in theory it would run in a split second. For example, Jason Turner (a big proponent of constexpr in the C++ community) suggested a game engine where all the states of the game are calculated at compile time using constexpr functions and then the whole game would be a sequence of pre-drawn frames that appear on the screen based on user input. And in this theoretical engine the FPS could reach the CPU frequency.

[@floatx86]

You are one of the reasons I started learning C/C++. I am extremely grateful for this channel, I love your content! Programming is just great.

[@clemensschotte]

During the era of the Commodore 64, we relied on precalculated paths utilizing sine and cosine functions, which were too slow for real-time usage in demos and games. Consequently, when you observe sprites gracefully traversing the screen, it's all precalculated. Today, you can adopt a similar approach, such as with a website, where you generate as much content as possible beforehand and serve the already existing pages.

[@snemarch]

Even on a 486 (with hardware FPU support for SIN/COS), which is some order of magnitude faster than the C=64, there was a lot of speed to gain by using lookup tables. But at least we could do LUT + interpolation instead of fully pre-calculated paths :P

[@revenevan11]

This makes me chuckle a bit, thinking about how people used to look up the trig tables in the back of their math book to evaluate something, and I grew up thankful I never really had to beyond an exercise, because we have computers to evaluate those for any value for us... only to know realize that in some cases the fastest way for a computer to do so is sometimes to make a table ahead of time it can look up to get the answer! (or part of the answer at least) 😅

[@Loanshark753]

The old way was to use tables, especially logarithm tables combined with slide rules for computations.

[@0ADVISOR0]

Man, let me tell you, this exact screen 1:49 is one of the reasons I love this Channel. The code neatly on the left the face not too big not too small and rounded soft edges on the right, THIS is quality!

[@nezbrun872]

"Recursion: a sexy computer science concept that's rarely practical in real life" Ain't that the truth. Furthermore, recursive solutions are also typically write-only. Ex colleague of mine came up with a SQL Server recursive algo to write check amounts in words, very clever I thought, although it was left to me to debug it when it crashed the production server one day... it'd eaten up a couple of 100GB of RAM. Turns out he hadn't written it at all, it'd been copy and pasted from Stack Overflow.

[@TheNewFaceOfHSP]

Aren't they always? I've been doing this for 10+ years and every single time I think of something clever, somebody has usually already made it (to one degree or another).

[@NinjaRunningWild]

There's a reason NASA doesn't allow it in their coding though. Error-prone & hard to debug.

[@JohnDoe-sq5nv]

You're missing the most important part of recursion: They are FUN! Nah, but seriously I often solve problems by recursion because it is easier for me to think that way. The benefit when you write something recursively is that you through smart use of parameters can easily control the data in every context, that is in every call in the recursion. I understand, however, that they are more complicated to debug for others who aren't used to thinking recursively. Therefore it is, as always, extremely important to properly test your recursive functions for all possible inputs that can come through the public interface, and never, ever, have them read or write data not in the input parameters.

[@isodoublet]

@@NinjaRunningWild No, that's not why. Recursive solutions in fact tend to be much easier to understand and debug than iterative solutions. The problem is that they don't fail gracefully: try to solve too big a problem and you'll get a literal stack overflow, whereas an iterative solution would typically run just fine.

[@fantasypvp]

Recursive solutions generally use up a lot more memory than iterative ones due to each function call adding memory to the stack

[@ljw4103]

If you made a c++ tutorial I would buy it.

[@theograice8080]

I concur! I've wanted to learn C++ for ages. I started to try to grok the low-level details of systems programming years ago as a teen, but modern OS UIs abstract away so much of what is really happening that any program seems like a miracle to me.

[@NinjaRunningWild]

@@theograice8080Try game programming & write your own engine in DirectX, OpenGL, or SDL. You'll learn all you need to know along the way.

[@theintjengineer]

@@theograice8080, get the book Beginning C++23 by Ivor Norton and start there.

[@lennymclennington]

@@theograice8080 if you actually want to learn C++, use learncpp. It is a good tutorial that is suitable to teach you about software development in C++ from zero prior knowledge about programming. If you already know some programming languages you can still use it and just skip a few of the first chapters.

[@BartoszZasieczny]

Once I got a task to implement loading some lookup table that was supposed to be loaded form a csv file. There was an equation and argument values were a discrete finite set with even intervals between values. I threw out the CSV file and jsut implemented a constexpr function what would calculate the lookup table at compile-time, put all the values inside a vector and then just read them. Awesome stufff.

[@an_wobbly]

Last thing I expected: Dave using a Breaking Bad meme to introduce his video... Being able to talk to our compilers directly is one of the reasons I love systems languages! Have you explored Rust very much, Dave? It has some of the most impressive metaprogramming features I've seen - including full on injection into its AST to create custom syntax.

[@mgancarzjr]

"I bet it's constexpr." If I'm remembering correctly, constexpr had some other very interesting effects. It may be in the book C++ High Performance by Andrist and Sehr.

[@blackcitadel37]

there's constexpr young brother too, consteval.

[@TheVoiceofTheProphetElizer]

As goofy as it may sound, I dream of a day where the LLMs get so proficient at ASM for the X86 architecture that we can go back and optimize everything and show ourselves we don't need to continually increase chip horsepower.

[@monawoka97]

Constexpr is really amazing from a compiler tech perspective, but it's still hard to think of circumstances where it enables something genuinely new. These examples are effectively using constexpr to bake a lookup table into the exe. It's really cool that this is possible, but you could achieve this in C. It's obviously more tedious. Either an executable as part of your build script that code gens the lookup table as a pre-process if you want it bundled into the executable - or just loading in an external file at runtime with the lookup table. It's still pretty neat. Definitely ergonomic.

[@Ch40zz]

constexpr is very useful for code obfuscation, string encryption etc. enjoy doing that in C

[@mgancarzjr]

If you can throw constexpr in front of a function, you turn it, potentially, into a lookup table without having to find and replace all the code where the function is called.

[@strehlow]

@@mgancarzjr or just re-code the function to do the lookup rather than compute the result. The calling code wouldn't need any changes.

[@mgancarzjr]

@@strehlow how do you propose letting each instance of the function know where to look for the lookup table? Genuinely curious. I can only think of static class members being able to automatically access the same memory.

[@strehlow]

@@mgancarzjr The function definition has the lookup table. The calling code doesn't know or care how the function produces the result. It doesn't need direct access to the lookup table. This is no different than refactoring a function with a more efficient algorithm, or any other optimizations. As long as it still produces the same mapping of input to output, why would the calling code need any changes?

[@johnshaw6702]

I loved your coverage of this. Many years ago I fell in love with templates, especially meta expressions. The introduction of 'constexpr' just simplified what I already was doing. If you understand templates, then you see the limitations of the C++ language up close and personal, as well as the power. I believe your examples could be done using templates alone, it just wont be as clean. I created template code that doesn't directly know the integral type being used. When an 'int' was 16 bits and a 'long' was 32 bits, and you wanted the minimum of a 32 bit integer, it would result in a 'long' integer. But when a compiler came with a standard library that said an 'int' was 32 bits, that was chosen instead. I realy didn't like to depend on the standard library to determine the choice, but it's the only way I knew how to do it. Letting the compiler dertermine something at complie time is a great way to reduce runtime overhead.

[@emjizone]

Good to understand and remember. I'm much more used to writing static code than programming the final compiler to build static code, but this promises a level of machine-level optimization that I've too often neglected. *Thank you* Dave from @DavesGarage for this valuable lesson. In any case, I would never calculate functions such as fibonacci or factorial by top-down recursion in production, of course, not even with memorization. This silly approach only serves to demonstrate concepts.

[@XzatonJW]

Constexpr in C++20 is amazing, youre also allowed to do dynamic allocations provided you dont leak the memory out of the constexpr context. For example, you can use std vector, and so long as you copy the data into an array, or similar, its totally allowed

[@AJMansfield1]

If you do some tricky stuff with arena allocators, even that's not necessarily impossible either. You can absolutely have a constexpr function returning pointers into an rodata segment of the compiled binary.

[@mbnqpl]

Wait, so I can make my hello world 1000x faster?

[@feel65]

print(“hi”)

[@HassanIQ777]

​@@feel65printf("hi"); 😡💢

[@ribbonmusha]

​@@HassanIQ777 std::println("hi"); (⁠≧⁠▽⁠≦⁠)

[@jett4603]

​@@HassanIQ777 write(STDOUT_FILENO, "hi", 3); 🤬

[@Carstuff111]

That opening.....man this is just one of the great bonuses to this channel! Here to learn and got a great laugh as a bonus right off the bat!

[@johnmckown1267]

So the compile time becomes O(2^n)?

[@michaelfuller34]

Only if your compile environment has the requisite resources 😂

[@Obscurai]

Yep, it's a cheat. Trading compile time for run time.

[@Bolidoo]

Well that finonacci implementation is horrible. A simple iterative one can get you O(n), a smarter one O(log n) and an aproximate one (using the formula for the nth finonacci number) runs in O(1). Also constexpr is not really needed, if you run the compiler with optimizations activated (O3) it will probably do this by itself.

[@dismuter_yt]

Yes, but you can get O(1) both for runtime and compile time by calculating the value once on the side and putting it in manually in the code. So if it actually never changes, you'll have paid for the computation only once, and not at every compilation.

[@AnttiBrax]

​@@ObscuraiIt sounds like a cheat if you only concentrate on the drag race example. The benefits to constexpr were really badly sold in the vid I think. There are a lot of better examples of great real world applications in the comments.

[@Hadzz95]

Great video Dave! Would love to see more videos about algorithms

[@jonathanlapierre8620]

Unless I do not understand here what you are basically saying is that Program A aka the compiler, does the heavy lifting of compute and pre-resolve the sieve which is pushed in the binaries of Program B aka the actual competition submission. Although this is a "clever" niched solution, it's no more useful than having the sieve solution injected from a JSON that was pre-calculated by another program before. I am no C++ guru and I love that I have learned something but it seems this is no different than compilers environment variables logics. As for the sieve, I totally get why it would not be included in the competition. Big fan. Awesome stuff. I should have started with that. Ciao!

[@bretthunter2828]

I thought the same - if you want fib(35) hard coded why bother even using a constexp "function" but just put the value in directly - you are just as likely mistype the functional code as you would type the exact number in from google or calculator. The only upside would be if you are unsure at the time of writing the main program what fib number you want to use - and hence easy to change to say fib(22)

[@MatthewMakesAU]

​@@bretthunter2828it's a lot easier to review code for errors than a magic number

[@germanassasin1046]

⁠@@bretthunter2828what you experience is what is called a failure of imagination. I also thought like you, but when I saw what kind of sorcery people came up with I was shocked. For example I saw a compile time regex parser library, if you know regex it can construct state machine at compile time which is an incredible speed up. And it was simple to use!

[@-_James_-]

To give a concrete example to what M-FeD was saying, if you have a string and you need to know which of one possible values it contains, you can switch on the runtime-calculated hash of the string and have case statements of compile-time calculated hashes of possible strings to compare against. The alternative would be a ton of if...else if... statements and a bazillion string compares. E.g.: switch( hash( str )) { case hash( "colour" ): break; case hash( "size" ): break; //etc... } All you need is a couple of hash functions that can hash strings or string literals, and you're good to go.

[@ensuretime]

@@bretthunter2828 No, it creates magic numbers and maintenance becomes a problem. Imagine that you call the fibonacci function in different places, but with different values (constants) that do NOT depend on user input. Why on earth would you hardcode the result returned from each function call, since the function will be evaluated at compile-time? When you change the value of the argument passed to it, the value is naturally recalculated without the need for you to do it manually, remember, nobody deserves code with “magic numbers”. I often see constexpr used to lookup tables based on arguments and/or templates, all the memory will be stored in .rdata and will be totally read-only, just modify 1 argument to create a totally different lookup table without the need to do it manually

[@xnadave]

So, I can stop writing code generators for LUTs? Very cool. I was already vaguely aware of how this worked, but seeing a concrete analysis is very helpful. Thanks for sharing.

[@JamieBainbridge]

Awesome video. I'm a C99 grognard but had always wondered what this keyword meant. Your presentation is information dense but easy to understand with lots of laughs too. Thanks!

[@erroneum]

Another great thing about constexpr is that you don't need to pass only constant arguments in (unlike non-type template parameters or consteval functions), but if you have even basic optimizations turned on, when you do pass in constant arguments, the compiler should evaluate the result and substitute it in. As an example, I'm writing a calculator, but I want to be able to use machine integers for speed, but switch to GMP when they get too large. To do so, I needed to implement the logic to check if there would be an overflow/underflow, so I made 3 functions, willOverflowAddition, willOverflowSubtraction, and willOverflowMultiplication, which are template constexpr functions for two signed integers. In practice they won't be being used in constant expressions, but for the optimizer it's helpful to afford it any opportunities to simplify the code you can.

[@JxH]

In a sense, it's a small step away from just working out the answer in advance, and then just outputting the answer at "Run" (sic) time.

[@bowiemtl]

I went from learning about tidbits of early windows programs to learning about relevant code features. Thank you sir!

[@jbuchan12]

This is awesome Dave thanks, I'm a c# software engineer, and I am learning c++ atm. This is very good timing.

[@Polygarden]

Great video! The most insane thing I have seen was a median filter function done in the pre-compiler. The syntax itself looked like voodoo to me. (it was however in GLSL, but the concept is the same)

[@oblivion_2852]

My favourite video on this topic is "Rich code for tiny computers" where Jason Turner writes very complex C++ functions that generate all sorts of tables for the c64.

[@DoinThatRag]

Very cool. So many small things make a huge difference. It's a shame most people don't actually learn assembly/compilers anymore. I myself am no expert, but trying to look at building a recompiler for emulation purposes really makes things like this important. It's crazy how results differ between compilers like MSVC, gcc, and clang (hint, clang seems to win most of the time on Windows). "The more you know, the more you realize you don't know"

[@firiasu]

You're awesome man! Like C++ itself!

[@jeffscheeler2532]

Most of this went way over my head!

[@corvinyt]

This is just shifting the algorithm runtime from program run time to compile time.

[@diogeneslaertius3365]

Exactly my thought. Why doesn't he just hard-code the result of the function, this way we don't even need to bother the compiler. "Hey folks, I optimized the program so it runs 1000000 times faster when you call factorial(1e7). How? I hard-coded the constant with the result."

[@eDoc2020]

@@diogeneslaertius3365 Because then you have hardcoded magic values in your code. If that magic value is incorrect how will you know? If it's done with code you can fix errors more easily.

[@AelfricLake]

Yeah in a complex program you'll just hold every possible result in memory? What...

[@eDoc2020]

@@AelfricLake Not every possible result, only hardcoded results for specific constant inputs given at compile time. It's of limited usefulness because most inputs won't be known at compile time.

[@futuza]

Sure, but it's still a useful tool no?

[@damindra]

Great video, just wrote a fibonacci program in c++ as I am learning , and this will be great to test against your constexpr code! Love your videos keep them coming

[@ACCPhil]

Using tail recursion massively speeds things up. I wonder if I can paste code __int64 Fibtail(__int64 n, __int64 p = 0, __int64 c =1) { if (n == 0) return p; else if (n == 1) return c; else return Fibtail(n - 1, c, p+c); }

[@IamSholiSJ]

I am not coding anymore, but this is something I would tried in during my college days for coding competitions, good content 🎉

[@marksmit6086]

I use constexpr with a hash method for strings. That way in a switch/case statement strings can be used as a selector. This makes code more readable, I love that.

[@pleasurewasmine3173]

i envy your memory and general cognitive ability Dave. You are a fortunate person to have such a beautiful mind. in a world where everything seems to be a race against time, you have seen this over the years and better yet you were able to keep up with it.

[@gehirndoper]

Another main use for constexpr is to allow template initialisation with more complicated values. E. g. you can use something like std::array where iexp(3, 10) computes 3 to the power of 10.

[@terminalfx]

Instructions Unclear; was playing Tool - Lateralus at 105 dB on repeat.

[@KillerMZE]

"if constexpr" is super useful for making templated functions that act mostly the same except for a small snippet. For example I've successfully used it for a container that needed both a Peek and a Read function, that did pretty much the same thing with the difference of either advancing an internal variable or not

[@BoyCcns]

A practical use-case: My ui engine uses constexpr crc32 to make string comparison of keywords in the css evaluator a LOT faster.

[@MikesGoAcademy]

I was once asked in a job interview to write conversion to roman numerals and about midway i realized, it can be a constexper and showed to to the interviewer, he was blown away

[@aniketbisht2823]

You can also use the entirety of (C++23) and allocate at compile time (C++20) to perform arbitrary computations at compile time. Constexpr should be the reason alone for many C bois to consider using C++ (another compelling features being RAII, templates and type-safety).

[@hhlavacs]

Nice video about an important topic. Thanks Dave! constexpr is really a super power! People have implemented constexpr ray tracers! Just one side note: There is a closed form formula for Fibonacci numbers (no recursion required), which can be evaluated in microseconds as well, without any computational limitations on the number. It is based on linear algebra, eigenvectors and the eigenvalues (1+sqrt(5))/2 and (1-sqrt(5))/2.

[@milanstevic8424]

in other words, phi and 1-phi where phi is defined as phi = 1+1/phi (or phi^2 = phi+1) and is known as golden ratio and 1-phi is known as a golden ratio conjugate (1-phi = -1/phi) phi can be declared as a constant phi = 1.6180339887498948482045868343656 whereas 1-phi = -0.6180339887498948482045868343656 so due to how floating point numbers work, it's best to instead define apc = 0.6180339887498948482045868343656 (absolute phi conjugate) and then apply that by doing 1.0+apc (instead of phi) and -apc (instead of conjugate)

[@HritikV]

the starting scene was magnetic ! taught so much by baiting us all

[@AdvancedSoul]

The coolest compile time practical code I've seen in use in the wild is Zig's regex compiler

[@mahdiramezani8536]

Great video. The time complexity of the naïve Fibonacci implementation is actually O(((1 + sqrt(5)) / 2)^n), which is approx. O(1.62^n).

[@DavesGarage]

Every reference I could find said 2^n and ChatGPT did as well, so you'd have to explain that one in more detail!

[@mahdiramezani8536]

@DavesGarage If you draw the recursion tree (as you did in the video), you see that it is not a perfect binary tree since all leaves are not at the same level. This causes the time complexity to be less than 2^n. More accurately, the time it takes to compute f(n) is equal to the time it takes to compute f(n-1) and f(n-2) plus O(1). This is very similar to the recursive formula for the Fibonacci sequence itself! So the runtime has the following value for constants a and b: a(((1-sqrt(5))/2)^n) + b(((1+sqrt(5))/2)^n) (1-sqrt(5))/2 is between -1 and 0, so the first term's absolute value gets smaller as you increase n. Therefore, the second term is the dominant term, which gives us O(((1+sqrt(5))/2)^n).

[@hhlavacs]

One is the complexity of the computational effort of the recursive implementation (size of a binary tree required for the recursion), the other is the order of magnitude of the Fibonacci numbers themselves, since the closed form solution is based on powers of (1+sqrt(5))/2 and (1-sqrt(5))/2.

[@pete540Z]

Thanks, Dave. I look forward to a video on the ct_sqrt function mentioned.

[@samanthajarosek9756]

I love this channel, I am always learning amazing things

[@CremeDeLaCoulee]

For the sieve prime problem, it shouldn't be necessary to separately calculate the square root of the upper bound before starting the algorithm. It seems like a more efficient algorithm might be ... As we're marking off the multiples of primes, keep track of the multiplier in a local variable incremented at each pass, and if the multiplier is less than or equal to prime itself after we've passed the upper bound, then we know we are at/past the square root of the upper bound and can call it quits on marking off more multiples of primes. The cost of this approach is two new operations -- incrementing the multiplier in the inner loop (while crossing off each multiple of the prime) and a comparison at the end of each prime loop to check whether this multiplier is less than or equal to the prime itself (and if so, then break from the outer loop). The second operation is a substitute for comparison against the pre-calculated square root, so isn't really an additional operation, it is just placed after rather than before. So, unless the upper bound is the square of a prime, we will have to run one additional prime to know we have reached this point, as compared to the pre-calculated square root which will tell us before we run that prime. The time-saving on this approach would depend partially on the efficiency of the dedicated square root algorithm (I'm skeptical on the efficiency of the one shown...). And the relative cost of the increment operation that's tracking the multiplier. My instinct is that since the multiplier is a local variable on the stack whereas crossing out the prime multiples is an array/memory operation presumably on the heap, its likely the increment will be done concurrently by the CPU while waiting for the memory-write operation to complete, and thus the cost will be nonexistent in practice on a modern CPU. I could be wrong... in which case the additional cost of this incrementing would grow O(n^2) with n = the upper bound... but then what is the complexity of the recursive square root??? Plus there's no chance of optimizing that with concurrent memory operations that need to be done anyways... hmmmmmm?????

[@oglothenerd]

Can you please bring back the outro with the chairs and the couch?

[@harleyspeedthrust4013]

I can't believe i just watched trevor try to get finger to write him some C. truly one of the moments of all time

[@tyeadel]

Used to program C++ with MFC Windows back in the '90's (Petzold et al). However preferred C (Kernighan & Ritchie) because structured programs often hid issues that were difficult to debug.

[@AnnatarTheMaia]

Kinda funny you mention constexpr; a colleague used it not two weeks ago, and as soon as he mentioned it, I knew exactly what he did.

[@mogenshansen7210]

btw - a couple of notes for the video: * constexpr was added in C++11 (not C++14) * the same constexpr function can also be used with runtime variable values - but then of course evaluated at runtime. Same function - 2 uses * constexpr can not have undefined behavior. UB will be detected at compile time * C++20 adds consteval - which enforces compile time only evaluation

[@codeinnovator]

I guess the limitation is that the input should also be something that can be deterministically determined before hand.

[@johanrojassoderman5590]

Lol, my first intuition was something like: arr[] = {0,1}; for(i

[@drewmortenson]

I'm being brought onto a project with an associate professor at my university, he needs me to write a GUI and optimize his python code. I'll be re-writing it in C++, and there are a lot of physics calculations so I'm certain this will be helpful for setting constants needed in those calculations.

[@michaelbauers8800]

I pre upvoted due to this (a) being Dave's Garage which I respect, (b) C++, and (c) constant expressions, which I love. const expressions are easier to understand than some crazy template metaprogramming to generate primes :)

[@DavidLindes]

This is cool. And wasn't there when I learned C++ (which I know a bit of, but don't use super often for the kinds of work I do), so... I'd missed the memo! Thanks for sharing!

[@ycombinator765]

So constexpr just compiles my code before I hit the compile button? noice! Thanks for this banger

[@mario50000]

no constant expressions are evaluated at compile time the point is that the expression is constant and thus won't need to be calculated during runtime as it was already evaluated and baked in during compilation

[@oneeyedphotographer]

1975 or thereabouts I was a student programmer, and we were set a problem to solve recursively. There was some I/O processing required, and I went to the college library to read up on Burroughs Fortran. I discovered that Fortrain, on the B5500, supported recursive access to files, and so that's what I did. The lecturer was quite surprised by my approach. On reflection, I think he was likely ND, he was undoubtedly gifted, had a peculiar view on things, and was physically awkward. Not like Chloe Hayden, but similarly lacking full control.

[@stke1982]

Well, in practice the performance improvements could have also be achieved otherwise, but constexpr allowed for a lot clearer code and less magic numbers or handcrafted LUT, thus less errors. However if you work on a big project you want to keep compile times reasonably small and should be careful with constexpr that take very long to compile (or have a compile toggle to use the expensive ones)

[@von_nobody]

C++20 it even more powerful as you can allocate memory, and only limit is that this memory can't leave `constexpr` context. One use I find for `constexpr` is for populating "decoding tables" used in parsers like `if (decoding[nextChar].isChar)` instead of `if ('A'

[@JPeachyDev]

Hi Dave! I work with Qt C++ right now and your videos are helping me make the quality of my work better! Thanks again! Do you think you'll do any more videos on compile-time execution, i.e. template arguments and properly using constexpr in class definitions?

[@mikeh_nz]

Neat! I loved the breaking bad intro and hadn’t heard of constexpr, so googled when it was the throat shot I hadn’t heard of this - I must be somewhat ancient back at the original c++ versions Yeah I guess the downside is the that timebuild is broken due to some intern doing a fib(2^100) in their code. Love the video

[@yephick]

Writing embedded code (a USB camera) this `constexpr` allows me to pre-determine many things, including building the complete USB descriptors' set, and just "bake it in" into firmware image

[@l.piekha100]

Your videos are simply awesome and perfect, thank you so much.

[@The_Pariah]

It is intimidating how well you understand code.

[@ForcefighterX2]

Working for John Deere has taught me one thing: Some of us C++ devs. think about optimizing code for performance; but many other C++ devs. write unmaintainable horribly slow code which only works because modern embedded systems are rather fast compared to 20 years ago. I seriously wish there were more C++ devs. who'd focus on coding quality and architecture, rather than getting some more or less relevant performance improvement which may or may not translate to any measurable outcome.

[@SoapSoapCrayon]

If you're wondering (and on windows) the main reason this took 38 microseconds was due to std::endl. It has an implicit os.flush() which can take a while on most platforms, especially windows. You can just output a " " which shouldn't flush. It won't change the outcome much (though it's loads faster), constexpr is amazing, and this video is great. If you're looking at very time sensitive things, it's probably better to sample the clock before/after the calculation then print it all in one big go, rather than measure the print too! Sorry for nitpicking!

[@BGFutureBG]

Small addition: constexpr functions do NOT guarantee execution at runtime, they enable it. constexpr functions can be invoked with runtime values for which they will compute the result during runtime. This is why the C++20 standard introduced the "consteval" keyword, which actually forces the compiler to never execute a function during runtime.

[@kensmith5694]

Thoughts on using this: 1) It could be used to precompute the twiddle factors for an FFT if you are working to make the FFT really fast. It is an alternative to writing a program to compute them and then including the text into your C++ source. 2) In a hardware thing I needed to know the best combination of what was loaded into two registers of a device. One register could selected between 7 clock sources and the other was the (integer) factor to divide by. The goal was to hit an exact frequency as best I could. I solved this again by writing code that figured it out and spit it out as text to include.

[@palaashatri]

Hahaha love the intro, and the video. Will definitely share it with my colleagues!

[@yurisich]

One interesting approach is to use this technique in Python or Node by writing a text file to disk containing precomputed outputs, and later claim O(n) complexity to look up the answer in benchmarks.

[@hongkongcantonese501]

I never thought a C++ joke(!) would be so gd funny! Gonna re-read Petzhold for the gags. :)

[@natemaher1389]

Haha what!? I didn't realize this was a Dave's garage video, I thought it was just a short edit. I was like "whoever did the voice dubbing sounds like Dave" 😂

[@AlanHMartin]

IIRC, on some new fastest VAX back in the day, VMS Pascal generated a divide check when fed a trivial program and a listing was requested with the /SHOW:STATISTICS switch; because it would compile in less than a clock quantum and the Lines Per Second stat divided by zero, LOL. So I feel your pain.

[@OZtwo]

This is cool! Or another way to think of it is that constexpr is more or less converting you code into an executable script.

[@dutchdykefinger]

yeah it's like evaluating the code, then pasting the output back as constants lol

[@JBirdBobbyJ]

I don't code or know how to. However, I often find myself opening up code to look for specific values, keywords, true/false settings, etc... I do so especially while I'm troubleshooting mods for games but always end up staying much longer than I need to because it's like a fun puzzle. Fun because I need to learn what I don't know to keep going deeper. I don't know if I should just learn some more math and commit to learning a coding language. Channels like this one would allow for easy and extensive understanding.

[@mathymathhandle]

This is the first programming language feature that seems useful and less esoteric past C++11's smart pointers.

[@TheEragonFreak]

stuff like string view can be useful too

[@justdoityourself7134]

Wrong.

[@landspide]

You can take the Dave out of Microsoft, but you cant take the Developer Developer Developer out of Dave. Great Job on modern C++ !

[@phizc]

7:31 for the constexpr time you just measured how long std:out takes. You should have recorded the time before any printing. 40ish microseconds is actually impressive compared to how slow Console.WriteLine is in C#, especially when it has to scroll the console too. I think the correct value is closer to 0.4ns (assuming 1 instruction at 2GHz). There. Made the code 100,000 times faster on top of the original 1000 😊.

[@greebly6011]

I feel like constexpr can be incredibly useful in shaders, I'm not sure if it is a thing in them but holy crap it would save so much. If they don't already have constexpr you could implement it in a precompiler.

[@steve_main]

I have no reason why it bugs me so much but the open brackets on their own lines drives me nuts. It's a waste of a line lol... really it does not matter but my brain is so trained to put it at the end of the line it's hard to see it done differently! Awesome video Dave, as a simple lowly JS, and PHP programmer I had no clue optimizations like this!!

[@-_James_-]

I hate people who put opening braces on the ends of lines. 😛 When they're on their own line, the opening and closing braces are vertically aligned, code isn't automatically scrunched up together as if screen real estate was going out of fashion, and putting braces within case statements actually makes sense. Add to that a lot of coding style guides mix between braces on their own line (namespaces, classes, and functions), and braces on the end of the current line (if, for, while, et al.) - just pick a style already. Even Kernighan and Ritchie in their book The C Programming Language (which is where pretty much everyone got this style from) stated that they only used it in their book due to lack of space on the page.

[@PaulTheFox1988]

It makes finding missing curly braces/brackets so much easier imo, code highlighting can help, but there's been times where code highlighting has made the task of fixing errors harder for me personally, so having the braces on a new line vertically aligned with its closing brace is a better fit for me and many others It's all down to personal preference and whatever is standard for the company you work for at the end of the day. There's really no right or wrong answer as long as the code works correctly