41,99 €
Mehr erfahren.
- Herausgeber: Packt Publishing
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Englisch
Master multithreading and concurrent processing with C++
About This Book
- Delve into the fundamentals of multithreading and concurrency and find out how to implement them
- Explore atomic operations to optimize code performance
- Apply concurrency to both distributed computing and GPGPU processing
Who This Book Is For
This book is for intermediate C++ developers who wish to extend their knowledge of multithreading and concurrent processing. You should have basic experience with multithreading and be comfortable using C++ development toolchains on the command line.
What You Will Learn
- Deep dive into the details of the how various operating systems currently implement multithreading
- Choose the best multithreading APIs when designing a new application
- Explore the use of mutexes, spin-locks, and other synchronization concepts and see how to safely pass data between threads
- Understand the level of API support provided by various C++ toolchains
- Resolve common issues in multithreaded code and recognize common pitfalls using tools such as Memcheck, CacheGrind, DRD, Helgrind, and more
- Discover the nature of atomic operations and understand how they can be useful in optimizing code
- Implement a multithreaded application in a distributed computing environment
- Design a C++-based GPGPU application that employs multithreading
In Detail
Multithreaded applications execute multiple threads in a single processor environment, allowing developers achieve concurrency. This book will teach you the finer points of multithreading and concurrency concepts and how to apply them efficiently in C++.
Divided into three modules, we start with a brief introduction to the fundamentals of multithreading and concurrency concepts. We then take an in-depth look at how these concepts work at the hardware-level as well as how both operating systems and frameworks use these low-level functions.
In the next module, you will learn about the native multithreading and concurrency support available in C++ since the 2011 revision, synchronization and communication between threads, debugging concurrent C++ applications, and the best programming practices in C++.
In the final module, you will learn about atomic operations before moving on to apply concurrency to distributed and GPGPU-based processing. The comprehensive coverage of essential multithreading concepts means you will be able to efficiently apply multithreading concepts while coding in C++.
Style and approach
This book is filled with examples that will help you become a master at writing robust concurrent and parallel applications in C++.
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 268
Veröffentlichungsjahr: 2017
Ähnliche
BIRMINGHAM - MUMBAI
< html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
Mastering C++ Multithreading
Copyright © 2017 Packt Publishing
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.
First published: July 2017
Production reference: 1270717
ISBN 978-1-78712-170-6
www.packtpub.com
Credits
Author
Maya Posch
Copy Editor
Sonia Mathur
Reviewer
Louis E. Mauget
Project Coordinator
Vaidehi Sawant
Commissioning Editor
Aaron Lazar
Proofreader
Safis Editing
Acquisition Editor
Chaitanya Nair
Indexer
Francy Puthiry
Content Development Editor
Rohit Kumar Singh
Graphics
Abhinash Sahu
Technical Editors
Ketan Kamble
Production Coordinator
Nilesh Mohite
About the Author
Maya Posch is a software engineer by trade and a self-professed electronics, robotics, and AI nut, running her own software development company, Nyanko, with her good friend, Trevor Purdy, where she works on various game development projects and some non-game projects. Apart from this, she does various freelance jobs for companies around the globe. You can visit her LinkedIn profile for more work-related details.
Aside from writing software, she likes to play with equations and write novels, such as her awesome reimagining of the story of the Nintendo classic, Legend of Zelda: Ocarina of Time, and the survival-horror novel she recently started, Viral Desire. You can check out her Scribd profile for a full listing of her writings.
Maya is also interested in biochemistry, robotics, and reverse-engineering of the human body. To know more about her, visit her blog, Artificial Human. If there's anything she doesn't lack, it has to be sheer ambition, it seems.
About the Reviewer
Louis E. Mauget learned to program a long time ago at the Michigan State University as a physics major learning to use software in designing a cyclotron. Later, he worked for 34 years at IBM. He went on to work for several consulting firms, including a long-term engagement with the railroad industry.He is currently consulting for Keyhole Software at Leawood, Kansas.
Lou has coded in C++, Java, JavaScript, Python, and newer languages, as each was conceived. His current interests include reactive functional programming, containers, Node JS, NoSQL, geospatial systems, mobile, and so on, in any new language or framework.
He occasionally blogs about software technology for Keyhole Software.He has coauthored three computer books and authored two IBM DeveloperWorks XML tutorials and a WebSphere Journal LDAP tutorial. Lou co-wrote several J2EE certification tests for IBM. He has also worked as a reviewer for Packt Publishing and others.
www.PacktPub.com
For support files and downloads related to your book, please visit www.PacktPub.com.
Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at [email protected] for more details.
At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks.
https://www.packtpub.com/mapt
Get the most in-demand software skills with Mapt. Mapt gives you full access to all Packt books and video courses, as well as industry-leading tools to help you plan your personal development and advance your career.
Why subscribe?
Fully searchable across every book published by Packt
Copy and paste, print, and bookmark content
On demand and accessible via a web browser
Customer Feedback
Thanks for purchasing this Packt book. At Packt, quality is at the heart of our editorial process. To help us improve, please leave us an honest review on this book's Amazon page at https://www.amazon.com/dp/1787121704.
If you'd like to join our team of regular reviewers, you can e-mail us at [email protected]. We award our regular reviewers with free eBooks and videos in exchange for their valuable feedback. Help us be relentless in improving our products!
Table of Contents
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Downloading the example code
Errata
Piracy
Questions
Revisiting Multithreading
Getting started
The multithreaded application
Makefile
Other applications
Summary
Multithreading Implementation on the Processor and OS
Defining processes and threads
Tasks in x86 (32-bit and 64-bit)
Process state in ARM
The stack
Defining multithreading
Flynn's taxonomy
Symmetric versus asymmetric multiprocessing
Loosely and tightly coupled multiprocessing
Combining multiprocessing with multithreading
Multithreading types
Temporal multithreading
Simultaneous multithreading (SMT)
Schedulers
Tracing the demo application
Mutual exclusion implementations
Hardware
Software
Summary
C++ Multithreading APIs
API overview
POSIX threads
Windows support
PThreads thread management
Mutexes
Condition variables
Synchronization
Semaphores
Thread local storage (TLC)
Windows threads
Thread management
Advanced management
Synchronization
Condition variables
Thread local storage
Boost
Qt
QThread
Thread pools
Synchronization
QtConcurrent
Thread local storage
POCO
Thread class
Thread pool
Thread local storage (TLS)
Synchronization
C++ threads
Putting it together
Summary
Thread Synchronization and Communication
Safety first
The scheduler
High-level view
Implementation
Request class
Worker class
Dispatcher
Makefile
Output
Sharing data
Using r/w-locks
Using shared pointers
Summary
Native C++ Threads and Primitives
The STL threading API
Boost.Thread API
The 2011 standard
C++14
C++17
STL organization
Thread class
Basic use
Passing parameters
Return value
Moving threads
Thread ID
Sleeping
Yield
Detach
Swap
Mutex
Basic use
Non-blocking locking
Timed mutex
Lock guard
Unique lock
Scoped lock
Recursive mutex
Recursive timed mutex
Shared mutex
Shared timed mutex
Condition variable
Condition_variable_any
Notify all at thread exit
Future
Promise
Shared future
Packaged_task
Async
Launch policy
Atomics
Summary
Debugging Multithreaded Code
When to start debugging
The humble debugger
GDB
Debugging multithreaded code
Breakpoints
Back traces
Dynamic analysis tools
Limitations
Alternatives
Memcheck
Basic use
Error types
Illegal read / illegal write errors
Use of uninitialized values
Uninitialized or unaddressable system call values
Illegal frees
Mismatched deallocation
Overlapping source and destination
Fishy argument values
Memory leak detection
Helgrind
Basic use
Misuse of the pthreads API
Lock order problems
Data races
DRD
Basic use
Features
C++11 threads support
Summary
Best Practices
Proper multithreading
Wrongful expectations - deadlocks
Being careless - data races
Mutexes aren't magic
Locks are fancy mutexes
Threads versus the future
Static order of initialization
Summary
Atomic Operations - Working with the Hardware
Atomic operations
Visual C++
GCC
Memory order
Other compilers
C++11 atomics
Example
Non-class functions
Example
Atomic flag
Memory order
Relaxed ordering
Release-acquire ordering
Release-consume ordering
Sequentially-consistent ordering
Volatile keyword
Summary
Multithreading with Distributed Computing
Distributed computing, in a nutshell
MPI
Implementations
Using MPI
Compiling MPI applications
The cluster hardware
Installing Open MPI
Linux and BSDs
Windows
Distributing jobs across nodes
Setting up an MPI node
Creating the MPI host file
Running the job
Using a cluster scheduler
MPI communication
MPI data types
Custom types
Basic communication
Advanced communication
Broadcasting
Scattering and gathering
MPI versus threads
Potential issues
Summary
Multithreading with GPGPU
The GPGPU processing model
Implementations
OpenCL
Common OpenCL applications
OpenCL versions
OpenCL 1.0
OpenCL 1.1
OpenCL 1.2
OpenCL 2.0
OpenCL 2.1
OpenCL 2.2
Setting up a development environment
Linux
Windows
OS X/MacOS
A basic OpenCL application
GPU memory management
GPGPU and multithreading
Latency
Potential issues
Debugging GPGPU applications
Summary
Preface
Multithreaded applications execute multiple threads in a single processor environment, to achieve. Filled with practical examples, this book will help you become a master at writing robust concurrent and parallel applications in C++. In this book, you will delve into the fundamentals of multithreading and concurrency and find out how to implement them. While doing so, you will explore atomic operations to optimize code performance and also apply concurrency to both distributed computing and GPGPU processing.
What this book covers
Chapter 1, Revisiting Multithreading, summarizes multithreading in C++, revisiting all the concepts you should already be familiar with and going through a basic example of multithreading using the native threading support added in the 2011 revision of C++.
Chapter 2, Multithreading Implementation on the Processor and OS, builds upon the fundamentals provided by the hardware implementations discussed in the preceding chapter, showing how OSes have used the capabilities to their advantage and made them available to applications. It also discusses how processes and threads are allowed to use the memory and processor in order to prevent applications and threads from interfering with each other.
Chapter 3, C++ Multithreading APIs, explores the wide variety of multithreading APIs available as OS-level APIs (for example, Win32 and POSIX) or as provided by a framework (for example, Boost, Qt, and POCO). It briefly runs through each API, listing the differences compared to the others as well as the advantages and disadvantages it may have for your application.
Chapter 4, Thread Synchronization and Communication, takes the topics learned in the previous chapters and explores an advanced multithreading implementation implemented using C++ 14's native threading API, which allows multiple threads to communicate without any thread-safety issues. It also covers the differences between the many types of synchronization mechanisms, including mutexes, locks, and condition variables.
Chapter 5, Native C++ Threads and Primitives, includes threads, concurrency, local storage, as well as thread-safety supported by this API. Building upon the example in the preceding chapter, it discusses and explores extending and optimizing thread-safty using the features offered by the full feature set in C++ 11 and C++ 14.
Chapter 6, Debugging Multithreaded Code, teaches you how to use tools such as Valgrind (Memcheck, DRD, Helgrind, and so on) to analyze the multithreaded performance of an application, find hotspots, and resolve or prevent issues resulting from concurrent access.
Chapter 7, Best Practices, covers common pitfalls and gotchas and how to spot them before they come back to haunt you. It also explores a number of common and less common scenarios using examples.
Chapter 8, Atomic Operations – Working with the Hardware, covers atomic operations in detail: what they are and how they are best used. Compiler support is looked at across CPU architectures and an evaluation is made of when it is worth to invest time in implementing atomic operations in your code. It also looks at how such optimizations will limit the portability of your code.
Chapter 9, Multithreading with Distributed Computing, takes many of the lessons learned in the preceding chapters and applies them on a multi-system, cluster-level scale. Using an OpenMPI-based example, it shows how multithreading can be done across multiple systems, such as the nodes in a computer cluster.
Chapter 10, Multithreading with GPGPU, shows the use of multithreading in GPGPU applications (for example, CUDA and OpenCL). Using an OpenCL-based example, a basic multithreaded application is explored that can execute tasks in parallel. This chapter takes lessons learned in the preceding chapters and applies them to processing on video cards and derived hardware (for example, rack-mounted vector processor hardware).
What you need for this book
To follow the instructions in this book, you will need any OS (Windows, Linux, or macOS) and any C++ compiler installed on your systems.
Who this book is for
This book is for intermediate C++ developers who wish to extend their knowledge of multithreading and concurrent processing. You should have basic experience with multithreading and be comfortable using C++ development toolchains on the command line.
Conventions
In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.
Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "The randGen() method takes two parameters, defining the range of the returned value:"
A block of code is set as follows:
cout_mtx.lock(); cout << "Thread " << tid << " adding " << rval << ". New value: " << val << ".\n"; cout_mtx.unlock(); values_mtx.lock(); values.push_back(val); values_mtx.unlock();}
When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:
cout_mtx.lock(); cout << "Thread " << tid << " adding " << rval << ". New value: " << val << ".\n"; cout_mtx.unlock(); values_mtx.lock();
values.push_back(val);
values_mtx.unlock();}
Any command-line input or output is written as follows:
$ make
g++ -o ch01_mt_example -std=c++11 ch01_mt_example.cpp
New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text.
Reader feedback
Feedback from our readers is always welcome. Let us know what you think about this book-what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of. To send us general feedback, simply e-mail [email protected], and mention the book's title in the subject of your message. If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.
Downloading the example code
You can download the example code files for this book 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-mailed directly to you. You can download the code files by following these steps:
Log in or register to our website using your e-mail address and password.
Hover the mouse pointer on the
SUPPORT
tab at the top.
Click on
Code Downloads & Errata
.
Enter the name of the book in the
Search
box.
Select the book for which you're looking to download the code files.
Choose from the drop-down menu where you purchased this book from.
Click on
Code Download
.
Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:
WinRAR / 7-Zip for Windows
Zipeg / iZip / UnRarX for Mac
7-Zip / PeaZip for Linux
The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Mastering-CPP-Multithreading. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!
Errata
Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books-maybe a mistake in the text or the code-we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title. To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the book in the search field. The required information will appear under the Errata section.
Piracy
Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy. Please contact us at [email protected] with a link to the suspected pirated material. We appreciate your help in protecting our authors and our ability to bring you valuable content.
Questions
If you have a problem with any aspect of this book, you can contact us at [email protected], and we will do our best to address the problem.
Revisiting Multithreading
Chances are that if you're reading this book, you have already done some multithreaded programming in C++, or, possibly, other languages. This chapter is meant to recap the topic purely from a C++ point of view, going through a basic multithreaded application, while also covering the tools we'll be using throughout the book. At the end of this chapter, you will have all the knowledge and information needed to proceed with the further chapters.
Topics covered in this chapter include the following:
Basic multithreading in C++ using the native API
Writing basic makefiles and usage of GCC/MinGW
Compiling a program using
make
and executing it on the command-line
Getting started
During the course of this book, we'll be assuming the use of a GCC-based toolchain (GCC or MinGW on Windows). If you wish to use alternative toolchains (clang, MSVC, ICC, and so on), please consult the documentation provided with these for compatible commands.
To compile the examples provided in this book, makefiles will be used. For those unfamiliar with makefiles, they are a simple but powerful text-based format used with the make tool for automating build tasks including compiling source code and adjusting the build environment. First released in 1977, make remains among the most popular build automation tools today.
Familiarity with the command line (Bash or equivalent) is assumed, with MSYS2 (Bash on Windows) recommended for those using Windows.
Makefile
In order to compile the code described earlier, one could use an IDE, or type the command on the command line. As mentioned in the beginning of this chapter, we'll be using makefiles for the examples in this book. The big advantages of this are that one does not have to repeatedly type in the same extensive command, and it is portable to any system which supports make.
Further advantages include being able to have previous generated artifacts removed automatically and to only compile those source files which have changed, along with a detailed control over build steps.
The makefile for this example is rather basic:
GCC := g++OUTPUT := ch01_mt_exampleSOURCES := $(wildcard *.cpp)CCFLAGS := -std=c++11 -pthreadall: $(OUTPUT)$(OUTPUT): $(GCC) -o $(OUTPUT) $(CCFLAGS) $(SOURCES)clean: rm $(OUTPUT).PHONY: all
From the top down, we first define the compiler that we'll use (g++), set the name of the output binary (the .exe extension on Windows will be post-fixed automatically), followed by the gathering of the sources and any important compiler flags.
The wildcard feature allows one to collect the names of all files matching the string following it in one go without having to define the name of each source file in the folder individually.
For the compiler flags, we're only really interested in enabling the c++11 features, for which GCC still requires one to supply this compiler flag.
For the all method, we just tell make to run g++ with the supplied information. Next we define a simple clean method which just removes the produced binary, and finally, we tell make to not interpret any folder or file named all in the folder, but to use the internal method with the .PHONY section.
When we run this makefile, we see the following command-line output:
$ make
g++ -o ch01_mt_example -std=c++11 ch01_mt_example.cpp
Afterwards, we find an executable file called ch01_mt_example (with the .exe extension attached on Windows) in the same folder. Executing this binary will result in a command-line output akin to the following:
$ ./ch01_mt_example.exe
Starting thread 1.
Thread 1 adding 8. New value: 50.
Starting thread 2.
Thread 2 adding 2. New value: 44.
Starting thread 3.
Starting thread 4.
Thread 3 adding 0. New value: 42.
Thread 4 adding 8. New value: 50.
Input: 42, Result 1: 50, Result 2: 44, Result 3: 42, Result 4: 50
What one can see here already is the somewhat asynchronous nature of threads and their output. While threads 1 and 2 appear to run synchronously, starting and quitting seemingly in order, threads 3 and 4 clearly run asynchronously as both start simultaneously before logging their action. For this reason, and especially in longer-running threads, it's virtually impossible to say in which order the log output and results will be returned.
While we use a simple vector to collect the results of the threads, there is no saying whether Result 1 truly originates from the thread which we assigned ID 1 in the beginning. If we need this information, we need to extend the data we return by using an information structure with details on the processing thread or similar.
One could, for example, use struct like this:
struct result { int tid; int result;};
The vector would then be changed to contain result instances rather than integer instances. One could pass the initial integer value directly to the thread as part of its parameters, or pass it via some other way.
Other applications
The example in this chapter is primarily useful for applications where data or tasks have to be handled in parallel. For the earlier mentioned use case of a GUI-based application with business logic and network-related features, the basic setup of a main application, which launches the required threads, would remain the same. However, instead of having each thread to be the same, each would be a completely different method.
For this type of application, the thread layout would look like this:
As the graphic shows, the main thread would launch the GUI, network, and business logic thread, with the latter communicating with the network thread to send and receive data. The business logic thread would also receive user input from the GUI thread, and send updates back to be displayed on the GUI.
Summary
In this chapter, we went over the basics of a multithreaded application in C++ using the native threading API. We looked at how to have multiple threads perform a task in parallel, and also explored how to properly use the random number API in the STL within a multithreaded application.
In the next chapter, we'll discuss how multithreading is implemented both in hardware and in operating systems. We'll see how this implementation differs per processor architecture and operating system, and how this affects our multithreaded application.
Multithreading Implementation on the Processor and OS
The foundation of any multithreaded application is formed by the implementation of the required features by the hardware of the processor, as well as by the way these features are translated into an API for use by applications by the operating system. An understanding of this foundation is crucial for developing an intuitive understanding of how to best implement a multithreaded application.
This chapter looks at how hardware and operating systems have evolved over the years to arrive at the current implementations and APIs as they are in use today. It shows how the example code of the previous chapter ultimately translates into commands to the processor and related hardware.
Topics covered in this chapter include the following:
The evolution of processor hardware in order to support multithreading concepts
How operating systems changed to use these hardware features
Concepts behind memory safety and memory models in various architectures
Differences between various process and threading models by OSes
Defining processes and threads
Essentially, to the operating system (OS
