C++ High Performance - Second Edition

Kup polskie wydanie:

Spis treści książki

• Preface
  • Who this book is for
  • What this book covers
  • Get the most out of this book
    • Download the example code files
    • Download the color images
    • Conventions used
  • Get in touch
    • Reviews
• A Brief Introduction to C++
  • Why C++?
    • Zero-cost abstractions
      • Programming languages and machine code abstractions
      • Abstractions in other languages
      • The zero-overhead principle
    • Portability
    • Robustness
    • C++ of today
  • C++ compared with other languages
    • Competing languages and performance
    • Non-performance-related C++ language features
      • Value semantics
      • Const correctness
      • Object ownership
      • Deterministic destruction in C++
      • Avoiding null objects using C++ references
    • Drawbacks of C++
  • Libraries and compilers used in this book
  • Summary
• Essential C++ Techniques
  • Automatic type deduction with the auto keyword
    • Using auto in function signatures
      • Forwarding the return type using decltype(auto)
    • Using auto for variables
      • A const reference
      • A mutable reference
      • A forwarding reference
      • Practices for ease of use
    • Const propagation for pointers
  • Move semantics explained
    • Copy-construction, swap, and move
      • Copy-constructing an object
    • Resource acquisition and the rule of five
    • Named variables and rvalues
    • Default move semantics and the rule of zero
      • Rule of zero in a real code base
      • A common pitfall moving non-resources
    • Applying the && modifier to class member functions
    • Dont move when copies are elided anyway
    • Pass by value when applicable
      • Cases where pass-by-value is not applicable
      • Moving constructor parameters
  • Designing interfaces with error handling
    • Contracts
      • Class invariants
      • Maintaining contracts
    • Error handling
      • Programming error or runtime error?
      • Programming errors (bugs)
      • Recoverable runtime errors
  • Function objects and lambda expressions
    • The basic syntax of a C++ lambda
    • The capture clause
      • Capture by reference versus capture by value
      • Similarities between a lambda and a class
      • Initializing variables in capture
      • Mutating lambda member variables
      • Capture all
    • Assigning C function pointers to lambdas
    • Lambda types
    • Lambdas and std::function
      • Implementing a simple Button class with std::function
      • Performance consideration of std::function
    • Generic lambdas
  • Summary
• Analyzing and Measuring Performance
  • Asymptotic complexity and big O notation
    • Growth rates
    • Amortized time complexity
  • What to measure and how?
    • Performance properties
    • Speedup of execution time
    • Performance counters
    • Performance testing best practices
  • Knowing your code and hot spots
    • Instrumentation profilers
    • Sampling profilers
  • Microbenchmarking
    • Amdahl's law
    • Pitfalls of microbenchmarking
    • A microbenchmark example
  • Summary
• Data Structures
  • The properties of computer memory
  • The standard library containers
    • Sequence containers
      • Vectors and arrays
      • Deque
      • List and forward_list
      • The basic_string
    • Associative containers
      • Ordered sets and maps
      • Unordered sets and maps
    • Container adaptors
      • Priority queues
  • Using views
    • Avoiding copies with string_view
      • Eliminating array decay with std::span
  • Some performance considerations
    • Balancing between complexity guarantees and overhead
    • Knowing and using the appropriate API functions
  • Parallel arrays
  • Summary
• Algorithms
  • Introducing the standard library algorithms
    • Evolution of the standard library algorithms
    • Solving everyday problems
      • Iterating over a sequence
      • Generating elements
      • Sorting elements
      • Finding elements
      • Finding using binary search
      • Testing for certain conditions
      • Counting elements
      • Minimum, maximum, and clamping
  • Iterators and ranges
    • Introducing iterators
    • Sentinel values and past-the-end iterators
    • Ranges
    • Iterator categories
  • Features of the standard algorithms
    • Algorithms do not change the size of the container
    • Algorithms with output require allocated data
    • Algorithms use operator==() and operator<() by default
      • Custom comparator functions
    • Constrained algorithms use projections
    • Algorithms require move operators not to throw
    • Algorithms have complexity guarantees
    • Algorithms perform just as well as C library function equivalents
  • Writing and using generic algorithms
    • Non-generic algorithms
    • Generic algorithms
    • Data structures that can be used by generic algorithms
  • Best practices
    • Using the constrained algorithms
    • Sorting only for the data you need to retrieve
      • Use cases
      • Performance evaluation
    • Use standard algorithms over raw for-loops
      • Example 1: Readability issues and mutable variables
      • Example 2: Unfortunate exceptions and performance problems
      • Example 3: Exploiting the standard library optimizations
    • Avoiding container copies
  • Summary
• Ranges and Views
  • The motivation for the Ranges library
    • Limitations of the Algorithm library
  • Understanding views from the Ranges library
    • Views are composable
    • Range views come with range adaptors
    • Views are non-owning ranges with complexity guarantees
    • Views don't mutate the underlying container
    • Views can be materialized into containers
    • Views are lazy evaluated
  • Views in the standard library
    • Range views
      • Generating views
      • Transforming views
      • Sampling views
      • Utility views
    • Revisiting std::string_view and std::span
  • The future of the Ranges library
  • Summary
• 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 object optimization
  • Custom memory management
    • Building an arena
    • A custom memory allocator
    • Using polymorphic memory allocators
    • Implementing a custom memory resource
  • Summary
• Compile-Time Programming
  • Introduction to template metaprogramming
    • Creating templates
    • Using integers as template parameters
    • Providing specializations of a template
    • How the compiler handles a template function
    • Abbreviated function templates
    • Receiving the type of a variable with decltype
  • Type traits
    • Type trait categories
    • Using type traits
  • Programming with constant expressions
    • Constexpr functions in a runtime context
    • Declaring immediate functions using consteval
    • The if constexpr statement
      • Comparison with runtime polymorphism
      • Example of the generic modulus function using if constexpr
    • Checking programming errors at compile time
      • Using assert to trigger errors at runtime
      • Using static_assert to trigger errors at compile time
  • Constraints and concepts
    • An unconstrained version of a Point2D template
      • Generic interfaces and bad error messages
    • A syntactic overview of constraints and concepts
      • Defining new concepts
      • Constraining types with concepts
      • Function overloading
    • A constrained version of the Point2D template
    • Adding constraints to your code
    • Concepts in the standard library
  • Real-world examples of metaprogramming
    • Example 1: creating a generic safe cast function
    • Example 2: hash strings at compile time
      • The advantages of the compile-time hash sum calculation
      • Implementing and verifying a compile-time hash function
      • Constructing a PrehashedString class
      • Evaluating PrehashedString
      • Evaluating get_bitmap_resource() with PrehashedString
  • Summary
• Essential Utilities
  • Representing optional values with std::optional
    • Optional return values
    • Optional member variables
    • Avoiding empty states in enums
    • Sorting and comparing std::optional
  • Fixed size heterogenous collections
    • Using std::pair
    • The std::tuple
      • Accessing the members of a tuple
      • Iterating std::tuple members
      • Unrolling the tuple
      • Accessing tuple elements
      • The variadic template parameter pack
  • Dynamically sized heterogenous collections
    • The std::variant
      • Exception safety of std::variant
      • Visiting variants
    • Heterogenous collections using variant
    • Accessing the values in our variant container
      • Global function std::get()
  • Some real-world examples
    • Example 1: projections and comparison operators
    • Example 2: reflection
      • Making a class reflect its members
      • C++ libraries that simplify reflection
      • Using reflection
      • Conditionally overloading global functions
      • Testing reflection capabilities
  • Summary
• Proxy Objects and Lazy Evaluation
  • Introducing lazy evaluation and proxy objects
    • Lazy versus eager evaluation
    • Proxy objects
  • Avoiding constructing objects using proxy objects
    • Comparing concatenated strings using a proxy
    • Implementing the proxy
    • The rvalue modifier
    • Assigning a concatenated proxy
    • Performance evaluation
  • Postponing sqrt computations
    • A simple two-dimensional vector class
    • The underlying mathematics
    • Implementing the LengthProxy object
    • Comparing lengths with LengthProxy
    • Calculating length with LengthProxy
      • Preventing the misuse of LengthProxy
    • Performance evaluation
  • Creative operator overloading and proxy objects
    • The pipe operator as an extension method
      • The pipe operator
  • Summary
• Concurrency
  • Understanding the basics of concurrency
  • What makes concurrent programming hard?
  • Concurrency and parallelism
    • Time slicing
    • Shared memory
    • Data races
      • Example: A data race
      • Avoiding data races
    • Mutex
    • Deadlock
    • Synchronous and asynchronous tasks
  • Concurrent programming in C++
    • The thread support library
      • Threads
      • Thread states
      • Joinable thread
      • Protecting critical sections
      • Avoiding deadlocks
      • Condition variables
      • Returning data and handling errors
      • Tasks
    • Additional synchronization primitives in C++20
      • Using latches
      • Using barriers
      • Signalling and resource counting using semaphores
    • Atomic support in C++
      • The lock-free property
      • Atomic flags
      • Atomic wait and notify
      • Using shared_ptr in a multithreaded environment
      • Atomic references
    • The C++ memory model
      • Instruction reordering
      • Atomics and memory orders
  • Lock-free programming
    • Example: A lock-free queue
  • Performance guidelines
    • Avoid contention
    • Avoid blocking operations
    • Number of threads/CPU cores
    • Thread priorities
    • Thread affinity
    • False sharing
  • Summary
• Coroutines and Lazy Generators
  • A few motivating examples
  • The coroutine abstraction
    • Subroutines and coroutines
    • Executing subroutines and coroutines on the CPU
      • CPU registers, instructions, and the stack
      • Call and return
      • Suspend and resume
    • Stackless versus stackful coroutines
      • Performance cost
      • Memory footprint
      • Context switching
    • What you have learned so far
  • Coroutines in C++
    • What's included in standard C++ (and what's not)?
    • What makes a C++ function a coroutine?
    • A minimal but complete example
      • The coroutine return object
      • The promise type
      • Awaitable types
      • Passing our coroutine around
    • Allocating the coroutine state
    • Avoiding dangling references
      • Passing parameters to coroutines
      • Member functions that are coroutines
      • Lambdas that are coroutines
      • Guidelines to prevent dangling references
    • Handling errors
    • Customization points
  • Generators
    • Implementing a generator
    • Using the Generator class
      • Solving generator problems
      • An iterator implementation
      • A solution using the Ranges library
      • Conclusion
    • A real-world example using generators
      • The problem
      • Delta encoding
  • Performance
  • Summary
• Asynchronous Programming with Coroutines
  • Awaitable types revisited
    • The implicit suspend points
  • Implementing a rudimentary task type
    • Handling return values and exceptions
    • Resuming an awaiting coroutine
    • Supporting void tasks
    • Synchronously waiting for a task to complete
      • Implementing sync_wait()
      • Implementing SyncWaitTask
    • Testing asynchronous tasks with sync_wait()
  • Wrapping a callback-based API
  • A concurrent server using Boost.Asio
    • Implementing the server
    • Running and connecting to the server
    • What we have achieved with the server (and what we haven't)
  • Summary
• Parallel Algorithms
  • The importance of parallelism
  • Parallel algorithms
    • Evaluating parallel algorithms
    • Amdahl's law revisited
    • Implementing parallel std::transform()
      • Naive implementation
      • Divide and conquer
    • Implementing parallel std::count_if()
    • Implementing parallel std::copy_if()
      • Approach 1: Use a synchronized write position
      • Approach 2: Split the algorithm into two parts
      • Performance evaluation
  • Parallel standard library algorithms
    • Execution policies
      • Sequenced policy
      • Parallel policy
      • Unsequenced policy
      • Parallel unsequenced policy
    • Exception handling
    • Additions and changes to parallel algorithms
      • std::accumulate() and std::reduce()
      • std::for_each()
    • Parallelizing an index-based for-loop
      • Combining std::for_each() with std::views::iota()
      • Simplifying construction via a wrapper
  • Executing algorithms on the GPU
    • Summary
• Other Books You May Enjoy
• Index

pokaż cały spis treści

ukryj recenzje