C++ high performance: boost and optimize the performance of your C++ 17 code

Cover......Page 1
Title Page......Page 2
Copyright and Credits......Page 3
Packt Upsell......Page 4
Foreword......Page 5
Contributors......Page 7
Table of Contents......Page 9
Preface......Page 18
  Zero-cost abstractions......Page 24
   Programming languages and machine code abstractions......Page 25
  Robustness......Page 27
 C++ compared with other languages......Page 28
  Competing languages and performance......Page 29
   Value semantics......Page 32
   Const correctness......Page 34
  Avoiding null objects using C++ references......Page 35
  Drawbacks of C++......Page 37
  Strict class interfaces......Page 38
  Error handling and resource acquisition......Page 39
   Preserving the valid state......Page 40
   Resource acquisition......Page 41
 Libraries used in this book......Page 42
 Summary......Page 43
  Using auto in function signatures......Page 44
  Using auto for variables......Page 45
   Const reference......Page 46
   Conclusion......Page 47
  Basic syntax of a C++ lambda function......Page 48
  The capture block......Page 49
   Capture by reference versus capture by value......Page 50
   Similarities between a Lambda and a class......Page 51
   Mutating lambda member variables......Page 52
   Capture all......Page 54
  Lambdas and std::function......Page 56
   Implementing a simple Button class with std::function......Page 57
    Invoking an std::function requires a few more operations than a lambda......Page 59
  The polymorphic lambda......Page 60
   Creating reusable polymorphic lambdas......Page 61
 Const propagation for pointers......Page 63
   Copy-constructing an object......Page 65
    Swapping two objects......Page 66
  Resource acquisition and the rule of three......Page 67
   Implementing the rule of three......Page 68
    Constructor......Page 69
   Limitations of the rule of three......Page 70
  Introducing move semantics......Page 71
  Named variables and r-values......Page 73
   Accept arguments by move when applicable......Page 74
  Default move semantics and the rule of zero......Page 75
   Rule of zero in a real code base......Page 76
    A note on empty destructors......Page 77
   A common pitfall - moving non-resources......Page 78
  Optional return values......Page 80
  Optional member variables......Page 81
  Sorting and comparing std::optional......Page 82
  Performance of std::any......Page 83
 Summary......Page 84
Chapter 3: Measuring Performance......Page 85
 Asymptotic complexity and big O notation......Page 86
  Growth rates......Page 91
  Amortized time complexity......Page 92
 What to measure?......Page 94
  Performance properties......Page 96
 Knowing your code and hot spots......Page 97
  Profilers......Page 98
   Instrumentation profilers......Page 99
   Sampling profilers......Page 101
 Summary......Page 103
 Properties of computer memory......Page 104
 STL containers......Page 107
   Vector and array......Page 108
   List and forward_list......Page 111
  Associative containers......Page 112
   Ordered sets and maps......Page 113
   Unordered sets and maps......Page 114
    Hash and equals......Page 115
  Container adaptors......Page 117
   Priority queues......Page 118
 Parallel arrays......Page 120
 Summary......Page 128
 The iterator concept......Page 129
  Iterator categories......Page 130
  Pointer-mimicking syntax......Page 131
  Iterators as generators......Page 133
  Iterator traits......Page 134
   Implementing a function using iterator categories......Page 135
  Practical example – iterating floating point values within a range......Page 136
   Illustrated usage examples......Page 137
   Utility functions......Page 138
   How to construct a linear range iterator......Page 139
    Iterator usage example......Page 140
    The make_linear_range convenience function......Page 141
   Linear range usage examples......Page 142
 Summary......Page 143
  STL algorithm concepts......Page 144
   Implementing a generic algorithm that can be used with any container......Page 145
   Algorithms do not change the size of the container......Page 147
   Algorithms with output require allocated data......Page 148
   Algorithms use operator== and operator< by default......Page 149
    General-purpose predicates......Page 150
   Algorithms require move operators not to throw......Page 151
   Algorithms have complexity guarantees......Page 152
  STL algorithms versus handcrafted for-loops......Page 153
    Real-world code base example......Page 154
   Usage examples of STL algorithms versus handcrafted for-loops......Page 155
    Example 1 – Unfortunate exceptions and performance problems......Page 156
    Example 2 – STL has subtle optimizations even in simple algorithms......Page 158
   Sorting only for the data you need to retrieve......Page 160
    Use cases......Page 161
    Performance evaluation......Page 162
  Limitations of the iterators in STL......Page 163
  Introduction to the ranges library......Page 166
   Composability and pipeability......Page 168
  Actions, views, and algorithms......Page 169
   Actions......Page 170
   Views......Page 171
 Summary......Page 173
Chapter 7: Memory Management......Page 174
  Memory pages......Page 175
 Process memory......Page 177
  Stack memory......Page 178
  Heap memory......Page 181
  Creating and deleting objects......Page 182
   Placement new......Page 183
   The new and delete operators......Page 184
  Memory alignment......Page 186
  Padding......Page 188
 Memory ownership......Page 190
  Handling resources implicitly......Page 191
   Unique pointer......Page 193
   Shared pointer......Page 194
   Weak pointer......Page 195
 Small size optimization......Page 196
 Custom memory management......Page 199
  Building an arena......Page 200
  A custom memory allocator......Page 204
 Summary......Page 209
 Introduction to template metaprogramming......Page 210
  Using integers as template parameters......Page 212
  How the compiler handles a template function......Page 213
  Type trait categories......Page 214
  Using type traits......Page 215
  Receiving the type of a variable with decltype......Page 216
  Conditionally enable functions based on types with std::enable_if_t......Page 217
  Introspecting class members with std::is_detected......Page 219
   Usage example of is_detected and enable_if_t combined......Page 220
 The constexpr keyword......Page 222
  Verify compile-time computation using std::integral_constant......Page 223
  The if constexpr statement......Page 224
   Comparison with runtime polymorphism......Page 225
   Example of generic modulus function using if constexpr......Page 226
   The std::tuple container......Page 227
    Accessing the members of a tuple......Page 228
    Iterating std::tuple......Page 229
    Unrolling the tuple......Page 230
    Implementing other algorithms for tuples......Page 231
   Accessing tuple elements......Page 232
    Structured bindings......Page 233
    An example of a function with variadic number of arguments......Page 234
    How to construct a variadic parameter pack......Page 235
   Using std::any as the base for a dynamic-size heterogenous container......Page 236
 The std::variant......Page 238
  Visiting variants......Page 239
  Heterogenous container of variants......Page 240
  Accessing the values in our variant container......Page 241
  Example 1 – Reflection......Page 242
   Using the reflection......Page 243
    Evaluating the assembler output of the reflection......Page 244
  Conditionally overloading global functions......Page 245
   Testing reflection capabilities......Page 247
  Example 2 – Creating a generic safe cast function......Page 249
  Example 3 – Hash strings at compile time......Page 252
   The advantages of compile-time hash sum calculation......Page 253
   Constructing a PrehashedString class......Page 254
   Evaluating PrehashedString......Page 256
   Evaluating get_bitmap_resource() with PrehashedString......Page 257
 Summary......Page 258
  Lazy versus eager evaluation......Page 259
  Comparing concatenated strings using a proxy......Page 261
  Implementing the proxy......Page 262
  The r-value modifier......Page 264
  A simple two-dimensional point class......Page 265
  The underlying mathematics......Page 266
  Implementing the DistProxy object......Page 268
  Expanding DistProxy to something more useful......Page 270
  Calculating distances with DistProxy......Page 271
   Preventing the misuse of DistProxy......Page 272
 Creative operator overloading and proxy objects......Page 273
   The pipe operator......Page 274
  The infix operator......Page 275
 Summary......Page 277
Chapter 10: Concurrency......Page 278
 What makes concurrent programming hard?......Page 279
 Concurrency and parallelism......Page 280
  Time slicing......Page 281
  Shared memory......Page 282
  Data races......Page 284
  Mutex......Page 285
  Deadlock......Page 287
  Synchronous and asynchronous tasks......Page 288
   Threads......Page 289
   Thread states......Page 292
   Protecting critical sections......Page 293
   Avoiding deadlocks......Page 295
   Condition variables......Page 296
   Returning data and handling errors......Page 298
   Tasks......Page 299
  Atomic support in C++......Page 301
   Using shared_ptr in a multithreaded environment......Page 302
  C++ memory model......Page 305
   Instruction reordering......Page 306
   Atomics and memory orders......Page 307
 Lock-free programming......Page 309
  Lock-free queue example......Page 310
  Avoid contention......Page 312
  Number of threads/CPU cores......Page 313
  Thread affinity......Page 314
  False sharing......Page 315
 Summary......Page 316
Chapter 11: Parallel STL......Page 317
 Parallel algorithms......Page 318
   Naive implementation......Page 319
    Performance evaluation......Page 320
   Shortcomings of the naive implementation......Page 321
   Divide and conquer......Page 323
    Performance evaluation......Page 324
  Implementing parallel std::count_if......Page 326
  Implementing parallel std::copy_if......Page 327
    Inner function......Page 328
   Approach two – Split algorithm into two parts......Page 329
    Part one – Copy elements in parallel into the destination range......Page 330
    Part two – Move the sparse range sequentially into a continuous range......Page 331
   Performance evaluation......Page 332
  Execution policies......Page 333
   Parallel policy......Page 334
   std::accumulate and std::reduce......Page 335
   std::for_each......Page 337
  Parallelizing an index-based for-loop......Page 338
   Simplifying construction via a wrapper......Page 339
   Programmable GPUs......Page 340
 Boost Compute......Page 341
  Initializing Boost Compute......Page 342
  Transfer a simple transform-reduce algorithm to Boost Compute......Page 343
    Adapting the circle struct for use with Boost Compute......Page 344
    Converting circle_area_cpu to Boost Compute......Page 345
    Implementing the transform-reduction algorithm on the GPU......Page 346
  Using predicates with Boost Compute......Page 347
  Using a custom kernel in Boost Compute......Page 348
   Box filter......Page 349
   Parallelizing for two dimensions......Page 350
  Summary......Page 352
Other Books You May Enjoy......Page 354
 Leave a review - let other readers know what you think......Page 356
Index......Page 357