![\"\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/03\/cheetah.jpg\")
<\/p>\nToday, I will write about the remaining ten rules of performance. Ten rules seem to be a lot, but only two have content.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
Here are the remaining rules to performance:<\/p>\n
Let’s have a closer look at rule Per.11 and rule Per.19.<\/p>\n
The example shows the simple gcd algorithm calculates the greatest common divisior at runtime. gcd uses for its calculation the euclidean algorithm<\/a>.<\/p>\n <\/p>\n By declaring gcd<\/span> as constexpr<\/span> gcd<\/span> can quite easily make a function that can run at compile time. There are only a few restrictions on constexpr<\/span> functions in C++14. gcd<\/span> must not use static or thread_local<\/span> variables, exception handling, or goto statements, and all variables must be initialized. Additionally, variables have to be of literal type. <\/a><\/p>\n Let’s try it out.<\/p>\n <\/p>\n Declaring gcd<\/span> to a constexpr<\/span> function does not mean that it has to run at compile time. It means that gcd<\/span> has the potential to run at compile time. A constexpr function has to be executed at compile if used in a constant expression. (1) is a constant expression because I ask for the result with a contexpr<\/span> variable res <\/span>(2). (3) is not a constant expression because res2<\/span> is not. When I change res2<\/span> to constexpr auto res2<\/span>, I will get an error: val<\/span> is not a constant expression. Here is the output of the program.<\/p>\n Once more, here is the critical observation. You can use a constexpr<\/span> function at runtime and at compile time. To use it at compile, its arguments have to be constant expressions.<\/strong><\/p>\n Don’t believe that line (1) will be executed at compile time? Here is the proof: the assembler instructions to line (1) generated from GCC 7.3 with maximum optimization level. I created the output with the help of the Compiler Explorer<\/a> from Matt Godbolt. <\/p>\n The function call gcd(121, 11)<\/span> boils down to its result: 11.<\/p>\n Templates are often used to decide at compile time. There is an excellent example of this idea in the C++ Core Guidelines. A popular technique is to provide a handle for storing small objects on the stack and big objects on the heap. Here is an example:<\/p>\n <\/p>\n <\/p>\n How does it work? std::conditional<\/span> in line (1) is a ternary operator from the type-traits library. <\/a> In contrast to the ternary operator at runtime ( What does that mean? If you read an int<\/span> from memory, more than the size of one int<\/span> is read from memory. An entire cache line is read from memory and stored in a cache. On modern architectures, a cache line typically has 64 bytes. If you now request an additional variable from memory and this variable is on the previous cache, the read directly uses this cache, and the operation is much faster.<\/p>\n A data structure such as std::vector<\/span>, which stores its data in a contiguous memory block, is a cache line data structure because each element in the cache line will typically be used. A std::vector has a size and a capacity and can grow only in one direction. The capacity is greater than its size and indicates when it is necessary to allocate memory. This argumentation also applies to std::vector<\/span> and std::array<\/span>, although std::array has no capacity.<\/p>\n My argumentation to std::vector<\/span> will not hold for a std::list<\/span> or a std::forward_list<\/span>. Both containers consist of nodes that are double or single-linked.<\/p>\n The std::forward_list can only grow in one direction.<\/p>\n std::deque<\/span> is in between because it is a double-linked list of small arrays.<\/p>\n This was the theory of cache lines. Now I’m curious. Does it make a difference to read and accumulate all elements from std::vector, a std::deque, std::list, and<\/span> std::forward_list<\/span>. The minor program should answer.<\/p>\n\nint<\/span> gcd<\/span>(int<\/span> a, int<\/span> b){\r\n while<\/span> (b !=<\/span> 0<\/span>){\r\n auto<\/span> t=<\/span> b;\r\n b=<\/span> a %<\/span> b;\r\n a=<\/span> t;\r\n }\r\n return<\/span> a;\r\n}\r\n<\/pre>\n<\/div>\n\n\/\/ gcd.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nconstexpr int<\/span> gcd<\/span>(int<\/span> a, int<\/span> b){\r\n while<\/span> (b !=<\/span> 0<\/span>){\r\n auto<\/span> t=<\/span> b;\r\n b=<\/span> a %<\/span> b;\r\n a=<\/span> t;\r\n }\r\n return<\/span> a;\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n constexpr auto<\/span> res =<\/span> gcd(121<\/span>, 11<\/span>); \/\/ (1)<\/span>\r\n std::<\/span>cout <<<\/span> \"gcd(121, 11) = \"<\/span> <<<\/span> res <<<\/span> std::<\/span>endl;\r\n\r\n auto<\/span> val =<\/span> 121<\/span>; \/\/ (3)<\/span>\r\n auto<\/span> res2 =<\/span> gcd(val, 11<\/span>); \/\/ (2)<\/span>\r\n std::<\/span>cout <<<\/span> \"gcd(val, 11) = \"<\/span> <<<\/span> res2 <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n![\"gcd\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/10\/gcd.png\")
<\/p>\n![\"gcdAssembler\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/04\/gcdAssembler.png\")
<\/p>\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nstruct<\/span> Scoped { \/\/ store a T in Scoped<\/span>\r\n \/\/ ...<\/span>\r\n T obj;\r\n};\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nstruct<\/span> On_heap { \/\/ store a T on the free store<\/span>\r\n \/\/ ...<\/span>\r\n T*<\/span> objp;\r\n};\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nusing<\/span> Handle =<\/span> typename<\/span> std::<\/span>conditional<<\/span>(sizeof<\/span>(T) <=<\/span> on_stack_max), \/\/ (1)<\/span>\r\n Scoped<<\/span>T><\/span>, \/\/ first alternative (2)<\/span>\r\n On_heap<<\/span>T><\/span> \/\/ second alternative (3)<\/span>\r\n >::<\/span>type;\r\n\r\nvoid<\/span> f<\/span>()\r\n{\r\n Handle<<\/span>double<\/span>><\/span> v1; \/\/ the double goes on the stack<\/span>\r\n Handle<<\/span>std::<\/span>array<<\/span>double<\/span>, 200<\/span>>><\/span> v2; \/\/ the array goes on the free store<\/span>\r\n \/\/ ...<\/span>\r\n}\r\n<\/pre>\n<\/div>\na ? b : c<\/code>) std::condition<\/span> will be executed at compile time. This means if std::<\/span>conditional<<\/span>(sizeof<\/span>(T) <=<\/span> on_stack_max) is <\/span>evaluated to true, the first alternative is used at runtime. If not, the second alternative. <\/p>\n<\/p>\nPer.19: Access memory predictably<\/a><\/h3>\n
![\"vector\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/04\/vector.png\")
<\/p>\n![\"list\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/04\/list.png\")
<\/p>\n![\"forward](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/04\/forward_list.png\")
<\/p>\n![\"deque\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/02\/deque.png\")
<\/p>\n\n\/\/ memoryAccess.cpp<\/span>\r\n\r\n#include <forward_list><\/span>\r\n#include <chrono><\/span>\r\n#include <deque><\/span>\r\n#include <iomanip><\/span>\r\n#include <iostream><\/span>\r\n#include <list><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n#include <numeric><\/span>\r\n#include <random><\/span>\r\n\r\nconst<\/span> int<\/span> SIZE =<\/span> 100<\/span>'<\/span>000<\/span>'<\/span>000<\/span>; \r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nvoid<\/span> sumUp(T&<\/span> t, const<\/span> std::<\/span>string&<\/span> cont){ \/\/ (5)<\/span>\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>fixed <<<\/span> std::<\/span>setprecision(10<\/span>);\r\n\r\n auto<\/span> begin=<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now();\r\n std::<\/span>size_t<\/span> res =<\/span> std::<\/span>accumulate(t.begin(), t.end(), 0LL<\/span>);\r\n std::<\/span>chrono::<\/span>duration<<\/span>double<\/span>><\/span> last=<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now() -<\/span> begin;\r\n std::<\/span>cout <<<\/span> cont <<<\/span> std::<\/span>endl;\r\n std