Tips for Performance Optimization in C++

A Simple Reading but Complex Working Case 1: Pass-by-Value string concatenate(string a, string b) {   return a + b; } In this implementation, the function takes its arguments by value. Here's how the compiler processes it: Argument Copying: The parameters a and b are copies of the original arguments. This means the compiler generates additional code to perform a deep copy of both strings. Performance Overhead: For large strings, copying introduces significant performance overhead due to memory allocation and duplication of data. While easy to understand and use, this approach is not efficient when dealing with large objects. Case 2: Pass-by-Reference string concatenate(string& a, string& b) {   return a + b; } Here, the function takes arguments by reference: Reference Binding: The parameters a and b are references to the original arguments. No deep copy is created, and the function operates directly on the caller’s variables. Compiler Optimization: This eliminates the overhead of copying, resulting in improved performance. Since references allow modification of the original arguments, unintended side effects can occur if the function alters the input strings. Effective for scenarios where performance is critical, but immutability is not a concern. Case 3: Pass-by-Const-Reference string concatenate(const string& a, const string& b) {   return a + b; } This version takes arguments as constant references: Reference Binding without Modification: The const keyword ensures that the original arguments cannot be modified inside the function. Compiler Optimization: Like pass-by-reference, this eliminates the overhead of copying. Immutability Guarantee: The compiler enforces that the function does not modify the input strings. Ideal for scenarios requiring both performance and safety from unintended modifications. Case 4: Inline Function with Const-References inline string concatenate(const string& a, const string& b) {   return a + b; } This implementation adds the inline specifier to the const-reference approach: Inlining Behavior: The compiler attempts to replace the function call with its body wherever it’s invoked, avoiding the overhead of a function call. Compiler’s Discretion: Modern compilers often ignore the inline specifier if they determine inlining would not improve performance. With constant references, it retains the advantages of immutability and low overhead. Suitable for performance-critical scenarios where function call overhead should be minimized. 𝗛𝗮𝗽𝗽𝘆 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴. #embedded #embeddedengineers #embeddedsystems #earlycareer  #cppwithyash

C++ optimization tip: std::endl can be a lot slower than printing out a new line character ('\n'). The reason is that std::endl flushes the stream, meaning that it takes the data stored in the stream and writes it to the underlying medium represented by the stream. This medium could be a file, console, or any other output device. Flushing the stream is usually very slow and expensive. As you can see in the benchmark I did, it's almost 100x slower for most input sizes when outputting data to a file. The bottom line is, using the empty line character ('\n') should be used in almost every situation unless flushing the stream is explicitly desired. This could be once after writing a whole bunch of data to the stream instead of once every loop iteration. The code I wrote for the benchmark: https://lnkd.in/gdErTtVq More info about std::endl: https://lnkd.in/gVymZKX7 Some additional notes: - On some platforms stdout flushed on '\n' as well. We can disable that using "std::cout.sync_with_stdio(false);" - std::cerr automatically flushes the stream after every single character written because the unitbuf flag is set. We can disable that using "std::cerr << std::nounitbuf;" Let me know what you think! :) #cplusplus #datastructuresandalgorithms #coding

Precomputing Results at Compile-Time Using constexpr in C++ C++ 11 introduced the constexpr keyword, providing powerful capabilities for performance optimization. When applied to functions, constexpr allows algorithms to be evaluated at compile-time, resulting in precomputed values that eliminate the need for calculations during program execution. This doesn't change the intrinsic complexity of the algorithm but modifies when it's evaluated. When using constexpr, the function is evaluated at compile-time. The value is precomputed and stored, eliminating the need for calculation during program execution. Therefore, the complexity of executing these precomputed values is O(1), as the algorithm has already been executed during compilation. However, there are some restrictions: - Resource Limitations: Compile-time evaluation of constexpr may be limited by the compiler. Complex functions or those requiring large amounts of memory may not be suitable for compile-time evaluation. - Constants and Literals: Arguments passed to constexpr functions must be constants or literals that can be evaluated at compile-time. Variables created at runtime won't benefit from this feature, as the function, even if constexpr, will be resolved at runtime in that case. - Recursion and Limitations: While it's possible to use recursion in constexpr functions, the number of recursive calls is limited by the compiler, which may restrict the complexity of calculations you can perform. - Longer Compilation Time: Since the algorithm is resolved at compile-time, the application will have a longer compilation time. To better understand how this works, we've prepared an example of a factorial function on Godbolt. Note that the only difference between the two versions is that one doesn't use constexpr and is calculated at runtime. In contrast, the constexpr version computes the factorial of 5 (which is 120) immediately, shifting the algorithm's complexity to compilation rather than execution. Thus, in practice, when a user runs our application, the version compiled with constexpr will have O(1) complexity instead of O(n). #cplusplus #constexpr #performanceoptimization #compiletimeevaluation #algorithm #complexityanalysis #factorialfunction #optimization #cplusplus11 #compiletimecomputations #runtimeperformance #algorithmcomplexity #compiletime #efficiency #codingtips #programmingtechniques #computerscience #programminglanguages #cppdeveloper #cppprogramming #developmenttips #softwareengineering #codinglife #compiletimebenefits #factorialexample #constexprfunctions #runtimeoptimization #compiletimecomplexity #computationalperformance #cppoptimization #algorithmicanalysis #learningcpp #computerscience #cpplearning #codeoptimization #compiletimeexecution #cplusplusprogramming #compiletimeperformance