C++ performance

---

constexpr

constexpr specifies that the value of an object or a function can be evaluated at compile time and the expression can be used in other constant expressions. For example, in below code product() is evaluated at compile time.

// constexpr function for product of two numbers. 
// By specifying constexpr, we suggest compiler to 
// to evaluate value at compiler time 
constexpr int product(int x, int y) 
{ 
	return (x * y); 
} 

int main() 
{ 
	const int x = product(10, 20); 
	cout << x; 
	return 0; 
} 

A function be declared as constexpr

• In C++ 11, a constexpr function should contain only one return statement. C++ 14 allows more than one statements.
• constexpr function should refer only constant global variables.
• constexpr function can call only other constexpr function not simple function.
• Function should not be of void type and some operator like prefix increment (++v) are not allowed in constexpr function.

https://www.geeksforgeeks.org/understanding-constexper-specifier-in-c/

constexpr vs inline functions:

Both are for performance improvements, inline functions are request to compiler to expand at compile time and save time of function call overheads. In inline functions, expressions are always evaluated at run time. constexpr is different, here expressions are evaluated at compile time.

constexpr with constructors:

constexpr can be used in constructors and objects also. See this for all restrictions on constructors that can use constexpr.

// C++ program to demonstrate uses of constexpr in constructor 
#include <bits/stdc++.h> 
using namespace std; 

// A class with constexpr constructor and function 
class Rectangle 
{ 
	int _h, _w; 
public: 
	// A constexpr constructor 
	constexpr Rectangle (int h, int w) : _h(h), _w(w) {} 
	
	constexpr int getArea () { return _h * _w; } 
}; 

// driver program to test function 
int main() 
{ 
	// Below object is initialized at compile time 
	constexpr Rectangle obj(10, 20); 
	cout << obj.getArea(); 
	return 0; 
} 

constexpr vs const

They serve different purposes. constexpr is mainly for optimization while const is for practically const objects like value of Pi.

Both of them can be applied to member methods. Member methods are made const to make sure that there are no accidental changes by the method. On the other hand, the idea of using constexpr is to compute expressions at compile time so that time can be saved when code is run.

const can only be used with non-static member function whereas constexpr can be used with with member and non-member functions, even with constructors but with condition that argument and return type must be of literal types.

Inline Functions

The inline functions are a C++ enhancement feature to decrease the execution time (lower latency) of a program. Functions can be instructed to compiler to make them inline so that compiler can replace those function definition wherever those are being called. Compiler replaces the definition of inline functions at compile time instead of referring function definition at runtime.

Pros

1. It speeds up your program by avoiding function calling overhead.
2. It save overhead of variables push/pop on the stack, when function calling happens.
3. It save overhead of return call from a function.
4. It increases locality of reference by utilizing instruction cache.
5. By marking it as inline, you can put a function definition in a header file (i.e. it can be included in multiple compilation unit, without the linker complaining)

Cons

1. It increases the executable size due to code expansion.
2. C++ inlining is resolved at compile time. Which means if you change the code of the inlined function, you would need to recompile all the code using it to make sure it will be updated
3. When used in a header, it makes your header file larger with information which users don’t care.
4. As mentioned above it increases the executable size, which may cause thrashing in memory. More number of page fault bringing down your program performance.
5. Sometimes not useful for example in embedded system where large executable size is not preferred at all due to memory constraints.

When to use

Function can be made as inline as per programmer need. Some useful recommendation are mentioned below-

1. Use inline function when performance is needed.
2. Use inline function over macros.
3. Prefer to use inline keyword outside the class with the function definition to hide implementation details.

http://www.cplusplus.com/articles/2LywvCM9/

http://www.cs.cmu.edu/~gilpin/c++/performance.html