C++ High Performance / Sehr, Viktor.

Format:

Book

Author/Creator:

Sehr, Viktor, author.

Andrist, Björn, author.

Language:

English

Subjects (All):

C++ (Computer program language).

Application software--Development.

Application software.

Physical Description:

1 online resource (374 pages)

Edition:

1st edition

Other Title:

C plus plus high performance

Place of Publication:

Packt Publishing, 2018.

System Details:

text file

Biography/History:

Andrist Bjorn: Bjorn Andrist is a freelance software consultant currently focusing on audio applications. For more than 15 years, he has been working professionally with C++ in projects ranging from UNIX server applications to real-time audio applications on desktop and mobile. In the past, he has also taught courses in algorithms and data structures, concurrent programming, and programming methodologies. Bjorn holds a BS in computer engineering and an MS in computer science from KTH Royal Institute of Technology. Sehr Viktor: Viktor Sehr is the founder and main developer of the small game studio Toppluva AB. At Toppluva he develops a custom graphics engine which powers the open-world skiing game Grand Mountain Adventure. He has 13 years of professional experience using C++, with real-time graphics, audio, and architectural design as his focus areas. Through his career, he has developed medical visualization software at Mentice and Raysearch Laboratories as well as real-time audio applications at Propellerhead Software. Viktor holds an M. S. in media science from Linkoping University.

Summary:

Write code that scales across CPU registers, multi-core, and machine clusters About This Book Explore concurrent programming in C++ Identify memory management problems Use SIMD and STL containers for performance improvement Who This Book Is For If you're a C++ developer looking to improve the speed of your code or simply wanting to take your skills up to the next level, then this book is perfect for you. What You Will Learn Find out how to use exciting new tools that will help you improve your code Identify bottlenecks to optimize your code Develop applications that utilize GPU computation Reap the benefits of concurrent programming Write code that can protect against application errors using error handling Use STL containers and algorithms effciently Extend your toolbox with Boost containers Achieve effcient memory management by using custom memory allocators In Detail C++ is a highly portable language and can be used to write complex applications and performance-critical code. It has evolved over the last few years to become a modern and expressive language. This book will guide you through optimizing the performance of your C++ apps by allowing them to run faster and consume fewer resources on the device they're running on. The book begins by helping you to identify the bottlenecks in C++. It then moves on to measuring performance, and you'll see how this affects the way you write code. Next, you'll see the importance of data structure optimization and how it can be used efficiently. After that, you'll see which algorithm should be used to achieve faster execution, followed by how to use STL containers. Moving on, you'll learn how to improve memory management in C++. You'll get hands on experience making use of multiple cores to enable more efficient and faster execution. The book ends with a brief overview of utilizing the capabilities of your GPU by using Boost Compute and OpenCL. Style and approach This easy-to-follow guide is full of examples and self-sufficient code snippets that help you with high performance programming with C++. You'll get your hands dirty with this all-inclusive guide that uncovers hidden performance improvement areas for any C++ code. Downloading the example code for this book You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the files e...

Contents:

Cover

Title Page

Copyright and Credits

Packt Upsell

Foreword

Contributors

Table of Contents

Preface

Chapter 1: A Brief Introduction to C++

Why C++?

Zero-cost abstractions

Programming languages and machine code abstractions

Abstractions in other languages

Portability

Robustness

C++ of today

The aim of this book

Expected knowledge of the reader

C++ compared with other languages

Competing languages and performance

Non-performance-related C++ language features

Value semantics

Const correctness

Object ownership and garbage collection in C++

Avoiding null objects using C++ references

Drawbacks of C++

Class interfaces and exceptions

Strict class interfaces

Error handling and resource acquisition

Preserving the valid state

Resource acquisition

Exceptions versus error codes

Libraries used in this book

Summary

Chapter 2: Modern C++ Concepts

Automatic type deduction with the auto keyword

Using auto in function signatures

Using auto for variables

Const reference

Mutable reference

Forwarding reference

Conclusion

The lambda function

Basic syntax of a C++ lambda function

The capture block

Capture by reference versus capture by value

Similarities between a Lambda and a class

Initializing variables in capture

Mutating lambda member variables

Mutating member variables from the compiler's perspective

Capture all

Assigning C function pointers to lambdas

Lambdas and std::function

Assigning lambdas to std::functions

Implementing a simple Button class with std::function

Performance consideration of std::function

An std::function cannot be inlined

An std::function heap allocates and captures variables

Invoking an std::function requires a few more operations than a lambda

The polymorphic lambda.

Creating reusable polymorphic lambdas

Const propagation for pointers

Move semantics explained

Copy-construction, swap, and move

Copy-constructing an object

Swapping two objects

Move-constructing an object

Resource acquisition and the rule of three

Implementing the rule of three

Constructor

Limitations of the rule of three

Avoiding copies without move semantics

Introducing move semantics

Named variables and r-values

Accept arguments by move when applicable

Default move semantics and the rule of zero

Rule of zero in a real code base

A note on empty destructors

A common pitfall - moving non-resources

Applying the &amp

&amp

modifier to class member functions

Representing optional values with std::optional

Optional return values

Optional member variables

Sorting and comparing std::optional

Representing dynamic values with std::any

Performance of std::any

Chapter 3: Measuring Performance

Asymptotic complexity and big O notation

Growth rates

Amortized time complexity

What to measure?

Performance properties

Performance testing - best practices

Knowing your code and hot spots

Profilers

Instrumentation profilers

Sampling profilers

Chapter 4: Data Structures

Properties of computer memory

STL containers

Sequence containers

Vector and array

Deque

List and forward_list

The basic_string

Associative containers

Ordered sets and maps

Unordered sets and maps

Hash and equals

Hash policy

Container adaptors

Priority queues

Parallel arrays

Chapter 5: A Deeper Look at Iterators

The iterator concept

Iterator categories

Pointer-mimicking syntax

Iterators as generators

Iterator traits

Implementing a function using iterator categories.

Extending the IntIterator to bidirectional

Practical example - iterating floating point values within a range

Illustrated usage examples

Utility functions

How to construct a linear range iterator

Iterator usage example

Generalizing the iterator pair to a range

The make_linear_range convenience function

Linear range usage examples

Chapter 6: STL Algorithms and Beyond

Using STL algorithms as building blocks

STL algorithm concepts

Algorithms operate on iterators

Implementing a generic algorithm that can be used with any container

Iterators for a range point to the first element and the element after the last

Algorithms do not change the size of the container

Algorithms with output require allocated data

Algorithms use operator== and operator&lt

by default

Custom comparator function

General-purpose predicates

Algorithms require move operators not to throw

Algorithms have complexity guarantees

Algorithms perform just as well as C library function equivalents

STL algorithms versus handcrafted for-loops

Readability and future-proofing

Real-world code base example

Usage examples of STL algorithms versus handcrafted for-loops

Example 1 - Unfortunate exceptions and performance problems

Example 2 - STL has subtle optimizations even in simple algorithms

Sorting only for the data you need to retrieve

Use cases

Performance evaluation

The future of STL and the ranges library

Limitations of the iterators in STL

Introduction to the ranges library

Composability and pipeability

Actions, views, and algorithms

Actions

Views

Algorithms

Chapter 7: Memory Management

Computer memory

The virtual address space

Memory pages

Thrashing

Process memory

Stack memory

Heap memory

Objects in memory.

Creating and deleting objects

Placement new

The new and delete operators

Memory alignment

Padding

Memory ownership

Handling resources implicitly

Containers

Smart pointers

Unique pointer

Shared pointer

Weak pointer

Small size optimization

Custom memory management

Building an arena

A custom memory allocator

Chapter 8: Metaprogramming and Compile-Time Evaluation

Introduction to template metaprogramming

Using integers as template parameters

How the compiler handles a template function

Using static_assert to trigger errors at compile time

Type traits

Type trait categories

Using type traits

Receiving the type of a variable with decltype

Conditionally enable functions based on types with std::enable_if_t

Introspecting class members with std::is_detected

Usage example of is_detected and enable_if_t combined

The constexpr keyword

Constexpr functions in a runtime context

Verify compile-time computation using std::integral_constant

The if constexpr statement

Comparison with runtime polymorphism

Example of generic modulus function using if constexpr

Heterogeneous containers

Static-sized heterogenous containers

The std::tuple container

Accessing the members of a tuple

Iterating std::tuple

Unrolling the tuple

Implementing other algorithms for tuples

Accessing tuple elements

Structured bindings

The variadic template parameter pack

An example of a function with variadic number of arguments

How to construct a variadic parameter pack

Dynamic-sized heterogenous containers

Using std::any as the base for a dynamic-size heterogenous container

The std::variant

Visiting variants

Heterogenous container of variants

Accessing the values in our variant container

Global function std::get.

Real world examples of metaprogramming

Example 1 - Reflection

Making a class reflect its members

C++ libraries which simplifies reflection

Using the reflection

Evaluating the assembler output of the reflection

Conditionally overloading global functions

Testing reflection capabilities

Example 2 - Creating a generic safe cast function

Example 3 - Hash strings at compile time

The advantages of compile-time hash sum calculation

Implement and verify a compile-time hash function

Constructing a PrehashedString class

Forcing PrehashedString to only accept compile time string literals

Evaluating PrehashedString

Evaluating get_bitmap_resource() with PrehashedString

Chapter 9: Proxy Objects and Lazy Evaluation

An introduction to lazy evaluation and proxy objects

Lazy versus eager evaluation

Proxy objects

Comparing concatenated strings using a proxy

Implementing the proxy

The r-value modifier

Assigning a concatenated proxy

Postponing an sqrt computation when comparing distances

A simple two-dimensional point class

The underlying mathematics

Implementing the DistProxy object

Expanding DistProxy to something more useful

Comparing distances with DistProxy

Calculating distances with DistProxy

Preventing the misuse of DistProxy

Creative operator overloading and proxy objects

The pipe operator as an extension method

The pipe operator

The infix operator

Further reading

Chapter 10: Concurrency

Understanding the basics of concurrency

What makes concurrent programming hard?

Concurrency and parallelism

Time slicing

Shared memory

Data races

Mutex

Deadlock

Synchronous and asynchronous tasks

Concurrent programming in C++

The thread support library

Threads.

Thread states.

Notes:

Online resource; Title from title page (viewed January 31, 2018)

ISBN:

1-78712-477-0

OCLC:

1024148075