book

C++ High Performance - Second Edition

Name: C++ High Performance - Second Edition
ISBN: 9781839216541

by Björn Andrist, Viktor Sehr

December 2020

Intermediate to advanced

544 pages

12h 45m

English

Packt Publishing

Read now

Unlock full access

Preface
Who this book is forWhat this book coversGet the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchReviews
A Brief Introduction to C++
Why C++?Zero-cost abstractionsProgramming languages and machine code abstractionsAbstractions in other languagesThe zero-overhead principlePortabilityRobustnessC++ of todayC++ compared with other languagesCompeting languages and performanceNon-performance-related C++ language featuresValue semanticsConst correctnessObject ownershipDeterministic destruction in C++Avoiding null objects using C++ referencesDrawbacks of C++Libraries and compilers used in this bookSummary
Essential C++ Techniques
Automatic type deduction with the auto keywordUsing auto in function signaturesForwarding the return type using decltype(auto)Using auto for variablesA const referenceA mutable referenceA forwarding referencePractices for ease of useConst propagation for pointersMove semantics explainedCopy-construction, swap, and moveCopy-constructing an objectResource acquisition and the rule of fiveNamed variables and rvaluesDefault move semantics and the rule of zeroRule of zero in a real code baseA common pitfall – moving non-resourcesApplying the && modifier to class member functionsDon't move when copies are elided anywayPass by value when applicableCases where pass-by-value is not applicableMoving constructor parametersDesigning interfaces with error handlingContractsClass invariantsMaintaining contractsError handlingProgramming error or runtime error?Programming errors (bugs)Recoverable runtime errorsFunction objects and lambda expressionsThe basic syntax of a C++ lambdaThe capture clauseCapture by reference versus capture by valueSimilarities between a lambda and a classInitializing variables in captureMutating lambda member variablesCapture allAssigning C function pointers to lambdasLambda typesLambdas and std::functionImplementing a simple Button class with std::functionPerformance consideration of std::functionGeneric lambdasSummary
Analyzing and Measuring Performance
Asymptotic complexity and big O notationGrowth ratesAmortized time complexityWhat to measure and how?Performance propertiesSpeedup of execution timePerformance countersPerformance testing — best practicesKnowing your code and hot spotsInstrumentation profilersSampling profilersMicrobenchmarkingAmdahl's lawPitfalls of microbenchmarkingA microbenchmark exampleSummary
Data Structures
The properties of computer memoryThe standard library containersSequence containersVectors and arraysDequeList and forward_listThe basic_stringAssociative containersOrdered sets and mapsUnordered sets and mapsContainer adaptorsPriority queuesUsing viewsAvoiding copies with string_viewEliminating array decay with std::spanSome performance considerationsBalancing between complexity guarantees and overheadKnowing and using the appropriate API functionsParallel arraysSummary
Algorithms
Introducing the standard library algorithmsEvolution of the standard library algorithmsSolving everyday problemsIterating over a sequenceGenerating elementsSorting elementsFinding elementsFinding using binary searchTesting for certain conditionsCounting elementsMinimum, maximum, and clampingIterators and rangesIntroducing iteratorsSentinel values and past-the-end iteratorsRangesIterator categoriesFeatures of the standard algorithmsAlgorithms do not change the size of the containerAlgorithms with output require allocated dataAlgorithms use operator==() and operator<() by defaultCustom comparator functionsConstrained algorithms use projectionsAlgorithms require move operators not to throwAlgorithms have complexity guaranteesAlgorithms perform just as well as C library function equivalentsWriting and using generic algorithmsNon-generic algorithmsGeneric algorithmsData structures that can be used by generic algorithmsBest practicesUsing the constrained algorithmsSorting only for the data you need to retrieveUse casesPerformance evaluationUse standard algorithms over raw for-loopsExample 1: Readability issues and mutable variablesExample 2: Unfortunate exceptions and performance problemsExample 3: Exploiting the standard library optimizationsAvoiding container copiesSummary
Ranges and Views
The motivation for the Ranges libraryLimitations of the Algorithm libraryUnderstanding views from the Ranges libraryViews are composableRange views come with range adaptorsViews are non-owning ranges with complexity guaranteesViews don't mutate the underlying containerViews can be materialized into containersViews are lazy evaluatedViews in the standard libraryRange viewsGenerating viewsTransforming views Sampling viewsUtility viewsRevisiting std::string_view and std::spanThe future of the Ranges librarySummary
Memory Management
Computer memoryThe virtual address spaceMemory pagesThrashingProcess memoryStack memoryHeap memoryObjects in memoryCreating and deleting objectsPlacement newThe new and delete operatorsMemory alignmentPaddingMemory ownershipHandling resources implicitlyContainersSmart pointersUnique pointerShared pointerWeak pointerSmall object optimizationCustom memory managementBuilding an arenaA custom memory allocatorUsing polymorphic memory allocatorsImplementing a custom memory resourceSummary
Compile-Time Programming
Introduction to template metaprogrammingCreating templatesUsing integers as template parametersProviding specializations of a templateHow the compiler handles a template functionAbbreviated function templatesReceiving the type of a variable with decltypeType traitsType trait categoriesUsing type traitsProgramming with constant expressionsConstexpr functions in a runtime contextDeclaring immediate functions using constevalThe if constexpr statementComparison with runtime polymorphismExample of the generic modulus function using if constexprChecking programming errors at compile timeUsing assert to trigger errors at runtimeUsing static_assert to trigger errors at compile timeConstraints and conceptsAn unconstrained version of a Point2D templateGeneric interfaces and bad error messagesA syntactic overview of constraints and conceptsDefining new conceptsConstraining types with conceptsFunction overloadingA constrained version of the Point2D templateAdding constraints to your codeConcepts in the standard libraryReal-world examples of metaprogrammingExample 1: creating a generic safe cast functionExample 2: hash strings at compile timeThe advantages of the compile-time hash sum calculationImplementing and verifying a compile-time hash functionConstructing a PrehashedString classEvaluating PrehashedStringEvaluating get_bitmap_resource() with PrehashedStringSummary
Essential Utilities
Representing optional values with std::optionalOptional return valuesOptional member variablesAvoiding empty states in enumsSorting and comparing std::optionalFixed size heterogenous collectionsUsing std::pairThe std::tupleAccessing the members of a tupleIterating std::tuple membersUnrolling the tupleAccessing tuple elementsThe variadic template parameter packDynamically sized heterogenous collectionsThe std::variantException safety of std::variantVisiting variantsHeterogenous collections using variantAccessing the values in our variant containerGlobal function std::get()Some real-world examplesExample 1: projections and comparison operatorsExample 2: reflectionMaking a class reflect its membersC++ libraries that simplify reflectionUsing reflectionConditionally overloading global functionsTesting reflection capabilitiesSummary

Proxy Objects and Lazy Evaluation
Introducing lazy evaluation and proxy objectsLazy versus eager evaluationProxy objectsAvoiding constructing objects using proxy objectsComparing concatenated strings using a proxyImplementing the proxyThe rvalue modifierAssigning a concatenated proxyPerformance evaluationPostponing sqrt computationsA simple two-dimensional vector classThe underlying mathematicsImplementing the LengthProxy object Comparing lengths with LengthProxy Calculating length with LengthProxyPreventing the misuse of LengthProxyPerformance evaluationCreative operator overloading and proxy objectsThe pipe operator as an extension methodThe pipe operatorSummary
Concurrency
Understanding the basics of concurrencyWhat makes concurrent programming hard?Concurrency and parallelismTime slicingShared memoryData racesExample: A data race Avoiding data racesMutexDeadlockSynchronous and asynchronous tasksConcurrent programming in C++The thread support libraryThreadsThread statesJoinable threadProtecting critical sectionsAvoiding deadlocksCondition variablesReturning data and handling errorsTasksAdditional synchronization primitives in C++20Using latchesUsing barriersSignalling and resource counting using semaphoresAtomic support in C++The lock-free propertyAtomic flagsAtomic wait and notifyUsing shared_ptr in a multithreaded environmentAtomic referencesThe C++ memory modelInstruction reorderingAtomics and memory ordersLock-free programmingExample: A lock-free queuePerformance guidelinesAvoid contentionAvoid blocking operationsNumber of threads/CPU coresThread prioritiesThread affinityFalse sharingSummary
Coroutines and Lazy Generators
A few motivating examplesThe coroutine abstractionSubroutines and coroutinesExecuting subroutines and coroutines on the CPUCPU registers, instructions, and the stackCall and returnSuspend and resumeStackless versus stackful coroutinesPerformance costMemory footprintContext switchingWhat you have learned so farCoroutines in C++What's included in standard C++ (and what's not)?What makes a C++ function a coroutine?A minimal but complete exampleThe coroutine return objectThe promise typeAwaitable typesPassing our coroutine aroundAllocating the coroutine stateAvoiding dangling referencesPassing parameters to coroutinesMember functions that are coroutinesLambdas that are coroutinesGuidelines to prevent dangling referencesHandling errorsCustomization pointsGeneratorsImplementing a generatorUsing the Generator classSolving generator problemsAn iterator implementationA solution using the Ranges libraryConclusionA real-world example using generatorsThe problemDelta encodingPerformanceSummary
Asynchronous Programming with Coroutines
Awaitable types revisitedThe implicit suspend pointsImplementing a rudimentary task typeHandling return values and exceptionsResuming an awaiting coroutineSupporting void tasksSynchronously waiting for a task to completeImplementing sync_wait()Implementing SyncWaitTaskTesting asynchronous tasks with sync_wait()Wrapping a callback-based APIA concurrent server using Boost.AsioImplementing the serverRunning and connecting to the serverWhat we have achieved with the server (and what we haven't)Summary
Parallel Algorithms
The importance of parallelismParallel algorithmsEvaluating parallel algorithmsAmdahl's law revisitedImplementing parallel std::transform()Naive implementationDivide and conquerImplementing parallel std::count_if()Implementing parallel std::copy_if()Approach 1: Use a synchronized write positionApproach 2: Split the algorithm into two partsPerformance evaluationParallel standard library algorithmsExecution policiesSequenced policyParallel policyUnsequenced policyParallel unsequenced policyException handlingAdditions and changes to parallel algorithmsstd::accumulate() and std::reduce()std::for_each()Parallelizing an index-based for-loopCombining std::for_each() with std::views::iota()Simplifying construction via a wrapperExecuting algorithms on the GPUSummary
Other Books You May Enjoy
Index

Content preview from C++ High Performance - Second Edition

3 Analyzing and Measuring Performance

Since this is a book about writing C++ code that runs efficiently, we need to cover some basics regarding how to measure software performance and estimate algorithmic efficiency. Most of the topics in this chapter are not specific to C++ and can be used whenever you are facing a problem where performance is an issue.

You will learn how to estimate algorithmic efficiency using big O notation. This is essential knowledge when choosing algorithms and data structures from the C++ standard library. If you are new to big O notation, this part might take some time to digest. But don't give up! This is a very important topic to grasp in order to understand the rest of the book, and, more importantly, to become a ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781839216541

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C++ High Performance - Second Edition

by Björn Andrist, Viktor Sehr

3

Analyzing and Measuring Performance

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.