最新章節(jié)
- Summary
- Debugging GPGPU applications
- Potential issues
- Latency
- GPGPU and multithreading
- GPU memory management
品牌：中圖公司
上架時(shí)間：2021-07-15 17:00:55
出版社：Packt Publishing
本書數(shù)字版權(quán)由中圖公司提供，并由其授權(quán)上海閱文信息技術(shù)有限公司制作發(fā)行
- Summary 更新時(shí)間：2021-07-15 17:34:39
- Debugging GPGPU applications
- Potential issues
- Latency
- GPGPU and multithreading
- GPU memory management
- A basic OpenCL application
- OS X/MacOS
- Windows
- Linux
- Setting up a development environment
- OpenCL 2.2
- OpenCL 2.1
- OpenCL 2.0
- OpenCL 1.2
- OpenCL 1.1
- OpenCL 1.0
- OpenCL versions
- Common OpenCL applications
- OpenCL
- Implementations
- The GPGPU processing model
- Multithreading with GPGPU
- Summary
- Potential issues
- MPI versus threads
- Scattering and gathering
- Broadcasting
- Advanced communication
- Basic communication
- Custom types
- MPI data types
- MPI communication
- Using a cluster scheduler
- Running the job
- Creating the MPI host file
- Setting up an MPI node
- Distributing jobs across nodes
- Windows
- Linux and BSDs
- Installing Open MPI
- The cluster hardware
- Compiling MPI applications
- Using MPI
- Implementations
- MPI
- Distributed computing in a nutshell
- Multithreading with Distributed Computing
- Summary
- Volatile keyword
- Sequentially-consistent ordering
- Release-consume ordering
- Release-acquire ordering
- Relaxed ordering
- Memory order
- Atomic flag
- Example
- Non-class functions
- Example
- C++11 atomics
- Other compilers
- Memory order
- GCC
- Visual C++
- Atomic operations
- Atomic Operations - Working with the Hardware
- Summary
- Static order of initialization
- Threads versus the future
- Locks are fancy mutexes
- Mutexes aren't magic
- Being careless - data races
- Wrongful expectations - deadlocks
- Proper multithreading
- Best Practices
- Summary
- C++11 threads support
- Features
- Basic use
- DRD
- Data races
- Lock order problems
- Misuse of the pthreads API
- Basic use
- Helgrind
- Memory leak detection
- Fishy argument values
- Overlapping source and destination
- Mismatched deallocation
- Illegal frees
- Uninitialized or unaddressable system call values
- Use of uninitialized values
- Illegal read / illegal write errors
- Error types
- Basic use
- Memcheck
- Alternatives
- Limitations
- Dynamic analysis tools
- Back traces
- Breakpoints
- Debugging multithreaded code
- GDB
- The humble debugger
- When to start debugging
- Debugging Multithreaded Code
- Summary
- Atomics
- Launch policy
- Async
- Packaged_task
- Shared future
- Promise
- Future
- Notify all at thread exit
- Condition_variable_any
- Condition variable
- Shared timed mutex
- Shared mutex
- Recursive timed mutex
- Recursive mutex
- Scoped lock
- Unique lock
- Lock guard
- Timed mutex
- Non-blocking locking
- Basic use
- Mutex
- Swap
- Detach
- Yield
- Sleeping
- Thread ID
- Moving threads
- Return value
- Passing parameters
- Basic use
- Thread class
- STL organization
- C++17
- C++14
- The 2011 standard
- Boost.Thread API
- The STL threading API
- Native C++ Threads and Primitives
- Summary
- Using shared pointers
- Using r/w-locks
- Sharing data
- Output
- Makefile
- Dispatcher
- Worker class
- Request class
- Implementation
- High-level view
- The scheduler
- Safety first
- Thread Synchronization and Communication
- Summary
- Putting it together
- C++ threads
- Synchronization
- Thread local storage (TLS)
- Thread pool
- Thread class
- POCO
- Thread local storage
- QtConcurrent
- Synchronization
- Thread pools
- QThread
- Qt
- Boost
- Thread local storage
- Condition variables
- Synchronization
- Advanced management
- Thread management
- Windows threads
- Thread local storage (TLC)
- Semaphores
- Synchronization
- Condition variables
- Mutexes
- PThreads thread management
- Windows support
- POSIX threads
- API overview
- C++ Multithreading APIs
- Summary
- Software
- Hardware
- Mutual exclusion implementations
- Tracing the demo application
- Schedulers
- Simultaneous multithreading (SMT)
- Temporal multithreading
- Multithreading types
- Combining multiprocessing with multithreading
- Loosely and tightly coupled multiprocessing
- Symmetric versus asymmetric multiprocessing
- Flynn's taxonomy
- Defining multithreading
- The stack
- Process state in ARM
- Tasks in x86 (32-bit and 64-bit)
- Defining processes and threads
- Multithreading Implementation on the Processor and OS
- Summary
- Other applications
- Makefile
- The multithreaded application
- Getting started
- Revisiting Multithreading
- Questions
- Piracy
- Errata
- Downloading the example code
- Reader feedback
- Conventions
- Who this book is for
- What you need for this book
- What this book covers
- Preface
- Customer Feedback
- Why subscribe?
- www.PacktPub.com
- About the Reviewer
- About the Author
- Credits
- Mastering C++ Multithreading
- Copyright
- Title Page
- cover
- cover
- Title Page
- Copyright
- Mastering C++ Multithreading
- Credits
- About the Author
- About the Reviewer
- www.PacktPub.com
- Why subscribe?
- Customer Feedback
- 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 更新時(shí)間：2021-07-15 17:34:39
作者還寫過(guò)
