book

Professional Multicore Programming: Design and Implementation for C++ Developers

Name: Professional Multicore Programming: Design and Implementation for C++ Developers
ISBN: 9780470289624

by Cameron Hughes, Tracey Hughes

September 2008

Intermediate to advanced

647 pages

16h 4m

English

Wrox

Read now

Unlock full access

Copyright
About the Authors
Credits
Acknowledgments
Introduction
Learn Multicore ProgrammingDifferent Points of ViewMultiparadigm Approaches are the SolutionWhy C++?UML DiagramsDevelopment Environments SupportedProgram ProfilesTesting and Code ReliabilityConventionsSource CodeErratap2p.wrox.com
1. The New Architecture
1.1. What Is a Multicore?1.2. Multicore Architectures1.2.1. Hybrid Multicore Architectures1.3. The Software Developer's Viewpoint1.3.1. The Basic Processor Architecture1.3.2. The CPU (Instruction Set)1.3.3. Memory Is the Key1.3.4. Registers1.3.5. Cache1.3.5.1. Level 1 Cache1.3.5.2. Level 2 Cache1.3.5.3. Compiler Switches for Cache?1.3.6. Main Memory1.4. The Bus Connection1.5. From Single Core to Multicore1.5.1. Multiprogramming and Multiprocessing1.5.2. Parallel Programming1.5.3. Multicore Application Design and Implementation1.6. Summary
2. Four Effective Multicore Designs
2.1. The AMD Multicore Opteron2.1.1. Opteron's Direct Connect and HyperTransport2.1.1.1. The Direct Connect Architecture2.1.1.2. HyperTransport Technology2.1.2. System Request Interface and Crossbar2.1.3. The Opteron Is NUMA2.1.4. Cache and the Multiprocessor Opteron2.2. The Sun UltraSparc T1 Multiprocessor2.2.1. Program Profile 2-12.2.1.1. Program Name:2.2.1.2. Description:2.2.1.3. Libraries Required:2.2.1.4. Headers Required:2.2.1.5. Compile and Link Instructions:2.2.1.6. Test Environment:2.2.1.7. Hardware:2.2.1.8. Execution Instructions:2.2.1.9. Notes:2.2.2. UltraSparc T1 Cores2.2.3. Cross Talk and The Crossbar2.2.4. DDRAM Controller and L2 Cache2.2.5. UltraSparc T1 and the Sun and GNU gcc Compilers2.3. The IBM Cell Broadband Engine2.3.1. CBE and Linux2.3.2. CBE Memory Models2.3.3. Hidden from the Operating System2.3.4. Synergistic Processor Unit2.4. Intel Core 2 Duo Processor2.4.1. Northbridge and Southbridge2.4.2. Intel's PCI Express2.4.3. Core 2 Duo's Instruction Set2.5. Summary
3. The Challenges of Multicore Programming
3.1. What Is the Sequential Model?3.2. What Is Concurrency?3.3. Software Development3.3.1. Challenge #1: Software Decomposition3.3.1.1. An Example of Decomposition3.3.1.1.1. Decomposition #13.3.1.1.2. Decomposition #23.3.1.2. Finding the Right Model3.3.1.2.1. What Is a Model?3.3.1.2.2. Procedural Models or Declarative Models?3.3.1.2.3. One Room at a Time or All at Once?3.3.2. Challenge #2: Task-to-Task Communication3.3.2.1. Managing IPC Mechanisms3.3.2.2. How Will the Painters Communicate?3.3.3. Challenge #3: Concurrent Access to Data or Resources by Multiple Tasks or Agents3.3.3.1. Problem #1: Data Race3.3.3.2. Problem #2: Deadlock3.3.3.3. Problem #3: Indefinite Postponement3.3.4. Challenge #4: Identifying the Relationships between Concurrently Executing Tasks3.3.4.1. The Basic Synchronization Relationships3.3.4.2. Timing Considerations3.3.5. Challenge #5: Controlling Resource Contention Between Tasks3.3.6. Challenge #6: How Many Processes or Threads Are Enough?3.3.7. Challenges #7 and #8: Finding Reliable and Reproducible Debugging and Testing3.3.7.1. Finding the Right Debugger and Profiler3.3.8. Challenge #9: Communicating a Design That Has Multiprocessing Components3.3.9. Challenge #10: Implementing Multiprocessing and Multithreading in C++3.4. C++ Developers Have to Learn New Libraries3.5. Processor Architecture Challenges3.6. Summary
4. The Operating System's Role
4.1. What Part Does the Operating System Play?4.1.1. Providing a Consistent Interface4.1.2. Managing Hardware Resources and Other Software Applications4.1.3. The Developer's Interaction with the Operating System4.1.4. Core Operating System Services4.1.4.1. How Do You Get from Tasks to Processes?4.1.4.2. Using the Thread Approach4.1.4.3. How Do You Get from Tasks to Threads?4.1.5. The Application Programmer's Interface4.1.5.1. What Is POSIX and Why Use It?4.1.5.2. Process Management4.1.5.3. Process Management Example: The Game Scenario4.1.5.4. Program Profile 4-14.1.5.4.1. Program Name:4.1.5.4.2. Description:4.1.5.4.3. Libraries Required:4.1.5.4.4. User-Defined Headers Required:4.1.5.4.5. Compile and Link Instructions:4.1.5.4.6. Test Environment:4.1.5.4.7. Processors:4.1.5.4.8. Notes:4.1.5.5. Program Profile 4-24.1.5.5.1. Program Name:4.1.5.5.2. Description:4.1.5.5.3. Libraries Required:4.1.5.5.4. User-Defined Headers Required:4.1.5.5.5. Compile and Link Instructions:4.1.5.5.6. Test Environment:4.1.5.5.7. Processors:4.1.5.5.8. Notes:4.2. Decomposition and the Operating System's Role4.3. Hiding the Operating System's Role4.3.1. Taking Advantage of C++ Power of Abstraction and Encapsulation4.3.2. Interface Classes for the POSIX APIs4.3.2.1. Program Profile 4-34.3.2.1.1. Program Name:4.3.2.1.2. Description:4.3.2.1.3. Libraries Required:4.3.2.1.4. Additional Source Files Needed:4.3.2.1.5. User-Defined Headers Required:4.3.2.1.6. Compile and Link Instructions:4.3.2.1.7. Test Environment:4.3.2.1.8. Processors:4.3.2.1.9. Notes:4.3.2.2. Program Profile 4-44.3.2.2.1. Program Name:4.3.2.2.2. Description:4.3.2.2.3. Libraries Required:4.3.2.2.4. Additional Source Files Needed:4.3.2.2.5. User-Defined Headers Required:4.3.2.2.6. Compile Instructions:4.3.2.2.7. Test Environment:4.3.2.2.8. Processors:4.3.2.2.9. Notes:4.4. Summary
5. Processes, C++ Interface Classes, and Predicates
5.1. We Say Multicore, We Mean Multiprocessor5.2. What Is a Process?5.3. Why Processes and Not Threads?5.4. Using posix_spawn()5.4.1. The file_actions Parameter5.4.2. The attrp Parameter5.4.3. A Simple posix_spawn() Example5.4.4. The guess_it Program Using posix_spawn5.5. Who Is the Parent? Who Is the Child?5.6. Processes: A Closer Look5.6.1. Process Control Block5.6.2. Anatomy of a Process5.6.3. Process States5.6.4. How Are Processes Scheduled?5.7. Monitoring Processes with the ps Utility5.8. Setting and Getting Process Priorities5.9. What Is a Context Switch?5.10. The Activities in Process Creation5.10.1. Using the fork() Function Call5.10.2. Using the exec() Family of System Calls5.10.2.1. The execl() Functions5.10.2.2. The execv() Functions5.10.2.3. Determining the Restrictions of exec() Functions5.11. Working with Process Environment Variables5.12. Using system() to Spawn Processes5.13. Killing a Process5.13.1. The exit(), and abort() Calls5.13.2. The kill() Function5.14. Process Resources5.14.1. Types of Resources5.14.2. POSIX Functions to Set Resource Limits5.15. What Are Asynchronous and Synchronous Processes5.15.1. Synchronous vs. Asynchronous Processes for fork(), posix_spawn(), system(), and exec()5.16. The wait() Function Call5.17. Predicates, Processes, and Interface Classes5.17.1. Program Profile 5-15.17.1.1. Program Name:5.17.1.2. Description:5.17.1.3. Libraries Required:5.17.1.4. Additional Source Files Needed:5.17.1.5. User-Defined Headers Required:5.17.1.6. Compile and Link Instructions:5.17.1.7. Test Environment:5.17.1.8. Processors:5.17.1.9. Notes:5.18. Summary

6. Multithreading
6.1. What Is a Thread?6.1.1. User- and Kernel-Level Threads6.1.2. Thread Context6.1.3. Hardware Threads and Software Threads6.1.4. Thread Resources6.2. Comparing Threads to Processes6.2.1. Context Switching6.2.2. Throughput6.2.3. Communicating between Entities6.2.4. Corrupting Process Data6.2.5. Killing the Entire Process6.2.6. Reuse by Other Programs6.2.7. Key Similarities and Differences between Threads and Processes6.3. Setting Thread Attributes6.4. The Architecture of a Thread6.4.1. Thread States6.4.2. Scheduling and Thread Contention Scope6.4.3. Scheduling Policy and Priority6.4.4. Scheduling Allocation Domains6.5. A Simple Threaded Program6.5.1. Compiling and Linking Threaded Programs6.6. Creating Threads6.6.1. Passing Arguments to a Thread6.6.2. Program Profile 6-16.6.2.1. Program Name:6.6.2.2. Description:6.6.2.3. Libraries Required:6.6.2.4. Headers Required:6.6.2.5. Compile and Link Instructions:6.6.2.6. Test Environment:6.6.2.7. Processors:6.6.2.8. Execution Instructions:6.6.2.9. Notes:6.6.3. Joining Threads6.6.4. Getting the Thread Id6.6.4.1. Comparing Thread Ids6.6.5. Using the Pthread Attribute Object6.6.5.1. Default Values for the Attribute Object6.6.5.2. Creating Detached Threads Using the Pthread Attribute Object6.7. Managing Threads6.7.1. Terminating Threads6.7.1.1. Self-Termination6.7.1.2. Terminating Peer Threads6.7.1.3. Understanding the Cancellation Process6.7.1.3.1. Using Cancellation Points6.7.1.3.2. Taking Advantage of Cancellation-Safe Library Functions and System Calls6.7.1.3.3. Cleaning Up before Termination6.7.2. Managing the Thread's Stack6.7.2.1. Setting the Size of the Stack6.7.2.2. Setting the Location of the Thread's Stack6.7.2.3. Setting Stack Size and Location with One Function6.7.3. Setting Thread Scheduling and Priorities6.7.4. Setting Contention Scope of a Thread6.7.5. Using sysconf()6.7.6. Thread Safety and Libraries6.7.6.1. Using Multithreaded Versions of Libraries and Functions6.7.6.2. Thread Safe Standard Out6.8. Extending the Thread Interface Class6.8.1. Program Profile 6-26.8.1.1. Program Name:6.8.1.2. Description:6.8.1.3. Libraries Required:6.8.1.4. Headers Required:6.8.1.5. Compile & Link Instructions:6.8.1.6. Test Environment:6.8.1.7. Processors:6.8.1.8. Execution Instructions:6.9. Summary
7. Communication and Synchronization of Concurrent Tasks
7.1. Communication and Synchronization7.1.1. Dependency Relationships7.1.1.1. Communication Dependencies7.1.1.2. Cooperation Dependencies7.1.2. Counting Tasks Dependencies7.1.3. What Is Interprocess Communication?7.1.3.1. Persistence of IPC7.1.3.2. Environment Variables and Command-Line Arguments7.1.3.3. Files7.1.3.4. File Descriptors7.1.3.5. Shared Memory7.1.3.6. Using POSIX Shared Memory7.1.3.7. Pipes7.1.3.7.1. Using Named Pipes (FIFO)7.1.3.8. Program Profile 7-17.1.3.8.1. Program Name:7.1.3.8.2. Description:7.1.3.8.3. Libraries Required:7.1.3.8.4. Headers Required:7.1.3.8.5. Compile and Link Instructions:7.1.3.8.6. Test Environment:7.1.3.8.7. Processors:7.1.3.8.8. Execution Instructions:7.1.3.8.9. Notes:7.1.3.8.10. FIFO Interface Class7.1.3.9. Message Queue7.1.3.9.1. Using a Message Queue7.1.3.9.2. posix_queue: The Message Queue Interface Class7.1.4. What Are Interthread Communications?7.1.4.1. Global Data, Variables, and Data Structures7.1.4.2. Program Profile 7-27.1.4.2.1. Program Name:7.1.4.2.2. Description:7.1.4.2.3. Libraries Required:7.1.4.2.4. Headers Required:7.1.4.2.5. Compile and Link Instructions:7.1.4.2.6. Test Environment:7.1.4.2.7. Processors:7.1.4.2.8. Execution Instructions:7.1.4.2.9. Notes:7.1.4.3. Parameters for Interthread Communication7.1.4.4. Program Profile 7-37.1.4.4.1. Program Name:7.1.4.4.2. Description:7.1.4.4.3. Libraries Required:7.1.4.4.4. Headers Required:7.1.4.4.5. Compile and Link Instructions:7.1.4.4.6. Test Environment:7.1.4.4.7. Processors:7.1.4.4.8. Execution Instructions:7.1.4.4.9. Notes:7.1.4.5. File Handles for Interthread Communication7.2. Synchronizing Concurrency7.2.1. Types of Synchronization7.2.2. Synchronizing Access to Data7.2.2.1. Critical Sections7.2.2.2. PRAM Model7.2.2.2.1. Concurrent and Exclusive Memory Access7.2.2.2.2. Concurrent Tasks: Coordinating Order of Execution7.2.2.2.3. Relationships between Cooperating Tasks7.2.2.2.4. Start-to-Start (SS) Relationship7.2.2.2.5. Finish-to-Start (FS) Relationship7.2.2.2.6. Start-to-Finish Relationship7.2.2.2.7. Finish-to-Finish Relationship7.2.3. Synchronization Mechanisms7.2.3.1. Semaphores7.2.3.1.1. Basic Semaphore Operations7.2.3.1.2. Posix Semaphores7.2.3.2. Program Profile 7-47.2.3.2.1. Program Name:7.2.3.2.2. Description:7.2.3.2.3. Libraries Required:7.2.3.2.4. Headers Required:7.2.3.2.5. Compile and Link Instructions:7.2.3.2.6. Test Environment:7.2.3.2.7. Processors:7.2.3.2.8. Execution Instructions:7.2.3.2.9. Notes:7.2.3.2.10. Mutex Semaphores7.2.3.2.11. Using the Mutex Attribute Object7.2.3.2.12. Using Mutex Semaphores to Manage Critical Sections7.2.3.3. Read-Write Locks7.2.3.3.1. Using Read-Write Locks to Implement Access Policy7.2.3.3.2. Object-Oriented Mutex Class7.2.3.4. Program Profile 7-57.2.3.4.1. Program Name:7.2.3.4.2. Description:7.2.3.4.3. Libraries Required:7.2.3.4.4. Headers Required:7.2.3.4.5. Compile and Link Instructions:7.2.3.4.6. Test Environment:7.2.3.4.7. Processors:7.2.3.4.8. Execution Instructions:7.2.3.4.9. Notes:7.2.3.5. Condition Variables7.2.3.5.1. Using Condition Variables to Manage Synchronization Relationships7.2.3.6. Program Profile 7-67.2.3.6.1. Program Name:7.2.3.6.2. Description:7.2.3.6.3. Libraries Required:7.2.3.6.4. Headers Required:7.2.3.6.5. Compile and Link Instructions:7.2.3.6.6. Test Environment:7.2.3.6.7. Processors:7.2.3.6.8. Execution Instructions:7.2.3.6.9. Notes:7.2.3.7. Thread-Safe Data Structures7.3. Thread Strategy Approaches7.3.1. Delegation Model7.3.2. Peer-to-Peer Model7.3.3. Producer-Consumer Model7.3.4. Pipeline Model7.3.5. SPMD and MPMD for Threads7.4. Decomposition and Encapsulation of Work7.4.1. Problem Statement7.4.2. Strategy7.4.3. Observation7.4.4. Problem and Solution7.4.5. Simple Agent Model Example of a Pipeline7.5. Summary
8. PADL and PBS: Approaches to Application Design
8.1. Designing Applications for Massive Multicore Processors8.2. What Is PADL?8.2.1. Layer 5: Application Architecture Selection8.2.1.1. What Are Agents?8.2.1.2. What Is a Multiagent Architecture?8.2.1.3. From Problem Statements to Multiagent Architectures8.2.1.3.1. The Strategy8.2.1.3.2. An Observation8.2.1.3.3. Problem and Solution Model as Multiagents8.2.1.4. Blackboard Architectures8.2.1.5. Approaches to Structuring the Blackboard8.2.1.5.1. A "Question and Answer Browser" Blackboard Example8.2.1.5.2. Where's the Parallelism? Where's the Blackboard?8.2.1.5.3. Components of the Solution8.2.1.5.4. Knowledge Sources for the Browser Program8.2.1.5.5. Is a Blackboard a Good Fit?8.2.1.5.6. The Blackboard as an Iterative Shared Solution Space8.2.1.6. The Anatomy of a Knowledge Source8.2.1.7. Concurrency Flexibility of the Application Architecture8.2.2. Layer 4: Concurrency Models in PADL8.2.3. Layer 3: The Implementation Model of PADL8.2.3.1. C++ Components to the Rescue8.2.3.1.1. The C++0x or C++09 Standard8.2.3.1.2. A C++0x (C++09) Mutex Interface Class8.2.3.1.3. Obtaining Early Implementations of the C++0x Concurrent Programming Libraries8.2.3.2. The Intel Threading Building Blocks8.2.3.2.1. Blackboard: A Critical Section8.2.3.3. Program Profile 8-18.2.3.3.1. Program Name:8.2.3.3.2. Description:8.2.3.3.3. Libraries Required:8.2.3.3.4. Additional Source Files Needed:8.2.3.3.5. User-Defined Headers Required:8.2.3.3.6. Compile and Link Instructions:8.2.3.3.7. Test Environment:8.2.3.3.8. Processors:8.2.3.3.9. Notes:8.2.3.3.10. Obtaining the TBB library8.2.3.4. The Parallel STL Library8.2.3.5. The "Implementation Layer" Mapping8.2.3.6. PADL: Layer 3 Type Control Strategies8.3. The Predicate Breakdown Structure (PBS)8.3.1. An Example: PBS for the "Guess-My-Code" Game8.3.2. Connecting PBS, PADL, and the SDLC8.3.3. Coding the PBS8.4. Summary
9. Modeling Software Systems That Require Concurrency
9.1. What Is UML?9.2. Modeling the Structure of a System9.2.1. The Class Model9.2.2. Visualizing Classes9.2.2.1. Visualizing Class Attributes, Services, and Responsibilities9.2.2.2. Using Attribute and Operation Properties9.2.3. Ordering the Attributes and Services9.2.4. Visualizing Instances of a Class9.2.5. Visualizing Template Classes9.2.6. Showing the Relationship between Classes and Objects9.2.7. Visualizing Interface Classes9.2.8. The Organization of Interactive Objects9.3. UML and Concurrent Behavior9.3.1. Collaborating Objects9.3.2. Multitasking and Multithreading with Processes and Threads9.3.2.1. Diagramming Active Objects9.3.2.2. Showing the Multiple Flows of Control and Communication9.3.3. Message Sequences between Objects9.3.4. The Activities of Objects9.3.5. State Machines9.3.5.1. Representing the Parts of a State9.3.5.2. Diagramming Concurrent Substates9.4. Visualizing the Whole System9.5. Summary
10. Testing and Logical Fault Tolerance for Parallel Programs
10.1. Can You Just Skip the Testing?10.2. Five Concurrency Challenges That Must Be Checked during Testing10.3. Failure: The Result of Defects and Faults10.3.1. Basic Testing Types10.3.2. Defect Removal versus Defect Survival10.4. How Do You Approach Defect Removal for Parallel Programs?10.4.1. The Problem Statement10.4.2. A Simple Strategy and Rough-Cut Solution Model10.4.3. A Revised Solution Model Using Layer 5 from PADL10.4.3.1. Revised Agent Model10.4.3.2. The Concurrency Model for the Agents10.4.4. The PBS of the Agent Solution Model10.4.4.1. Declarative Implementation of the PBS10.4.4.2. Program Profile 10-110.4.4.2.1. Program Name:10.4.4.2.2. Description:10.4.4.2.3. Libraries Required:10.4.4.2.4. Additional Source Files Needed:10.4.4.2.5. User-Defined Headers Required:10.4.4.2.6. Compile and Link Instructions:10.4.4.2.7. Test Environment:10.4.4.2.8. Processors:10.4.4.2.9. Notes:10.4.4.3. How Do You Know This Code Works?10.5. What Are the Standard Software Engineering Tests?10.5.1. Software Verification and Validation10.5.2. The Code Doesn't Work — Now What?10.5.3. What Is Logical Fault Tolerance?10.5.3.1. The Exception Handler10.5.3.1.1. The runtime_error Classes10.5.3.1.2. The logic_error Classes10.5.3.1.3. Deriving New Exception Classes10.5.3.1.4. Protecting the Exception Classes from Exceptions10.5.3.2. A Simple Strategy for Implementing Logical Fault Tolerance10.5.3.3. Testing and Logical Fault Tolerance10.5.4. Predicate Exceptions and Possible Worlds10.5.5. What Is Model Checking?10.6. Summary
A. UML for Concurrent Design
A.1. Class and Object DiagramsA.2. Interaction DiagramsA.2.1. Collaboration DiagramsA.2.2. Sequence DiagramsA.2.3. Activity DiagramsA.3. State DiagramsA.4. Package Diagrams
B. Concurrency Models
B.1. Interprocess and Interthread CommunicationB.2. Boss/Worker Approach 1 with ThreadsB.3. Boss/Worker Approach 1 with ProcessesB.4. Boss/Worker Approach 2 with ThreadsB.5. Boss/Worker Approach 3 with ThreadsB.6. Peer-to-Peer Approach 1 with ThreadsB.7. Peer-to-Peer Approach 1 with ProcessesB.8. Peer-to-Peer Approach 2 with ThreadsB.9. Peer-to-Peer Approach 2 with ProcessesB.10. Workpile Approach 1B.11. Workpile Approach 2B.12. Pipeline Approach with ThreadsB.13. Producer/Consumer Approach 1 with ThreadsB.14. Producer/Consumer Approach 2 with ThreadsB.15. Producer/Consumer Approach 3 with ThreadsB.16. Monitor ApproachB.17. Blackboard Approach with ThreadsB.18. Data Level Parallelism: SIMD ApproachB.19. Data Level Parallelism: MIMD ApproachB.20. PRAM ModelB.20.1. CRCW — Concurrent Read Concurrent WriteB.20.2. EREW — Exclusive Read Exclusive WriteB.20.3. ERCW — Exclusive Read Concurrent WriteB.20.4. CREW — Concurrent Read Exclusive Write
C. POSIX Standard for Thread Management
pthread_atfork()
pthread_attr_destroy()
pthread_attr_getdetachstate()
pthread_attr_getguardsize()
pthread_attr_getinheritsched()
pthread_attr_getschedparam()
pthread_attr_getschedpolicy()
pthread_attr_getscope()
pthread_attr_getstack()
pthread_attr_getstackaddr()
pthread_attr_getstacksize()
pthread_attr_init()
pthread_attr_setdetachstate()
pthread_attr_setguardsize()
pthread_attr_setinheritsched()
pthread_attr_setschedparam()
pthread_attr_setschedpolicy()
pthread_attr_setscope()
pthread_attr_setstack()
pthread_attr_setstackaddr()
pthread_attr_setstacksize()
pthread_cancel()
pthread_cond_broadcast()
pthread_cond_destroy()
pthread_cond_signal()
pthread_cond_timedwait()
pthread_condattr_destroy()
pthread_condattr_getclock()
pthread_condattr_getpshared()
pthread_condattr_init()
pthread_condattr_setclock()
pthread_condattr_setpshared()
pthread_create()
pthread_detach()
pthread_equal()
pthread_exit()
pthread_getconcurrency()
pthread_getcpuclockid()
pthread_getschedparam()
pthread_getspecific()
pthread_join()
pthread_kill()
pthread_mutex_destroy()
pthread_mutex_getprioceiling()
pthread_mutex_init()
pthread_mutex_lock()
pthread_mutex_setprioceiling()
pthread_mutex_timedlock()
pthread_mutex_trylock()
pthread_mutexattr_destroy()
pthread_mutexattr_getprioceiling()
pthread_mutexattr_getprotocol()
pthread_mutexattr_getpshared()
pthread_mutexattr_gettype()
pthread_mutexattr_init()
pthread_mutexattr_setprioceiling()
pthread_mutexattr_setprotocol()
pthread_mutexattr_setpshared()
pthread_mutexattr_settype()
pthread_once()
pthread_rwlock_destroy()
pthread_rwlock_rdlock()
pthread_rwlock_timedrdlock()
pthread_rwlock_timedwrlock()
pthread_rwlock_tryrdlock()
pthread_rwlock_trywrlock()
pthread_rwlock_unlock()
pthread_rwlock_wrlock()
pthread_rwlockattr_destroy()
pthread_rwlockattr_getpshared()
pthread_rwlockattr_init()
pthread_rwlockattr_setpshared()
pthread_self()
pthread_setcancelstate()
pthread_setconcurrency()
pthread_setschedparam()
Pthread_setschedprio()
pthread_setspecific()
pthread_testcancel()
D. POSIX Standard for Process Management
posix_spawn()
posix_spawn_file_actions_addclose()
posix_spawn_file_actions_adddup2()
posix_spawn_file_actions_addopen()
posix_spawn_file_actions_destroy()
posix_spawnattr_destroy()
posix_spawnattr_getflags()
posix_spawnattr_getpgroup()
pisix_spawnattr_getschedparam()
posix_spawnattr_getschedpolicy()
Bibliography

Content preview from Professional Multicore Programming: Design and Implementation for C++ Developers

Chapter 3. The Challenges of Multicore Programming

	Assume we're facing multiple enemies and disperse the sets ... Split up into four groups and activate the threshold triggers!
	--Shirow Masamune, Ghost in the Shell

Until recently, the most accessible tools and techniques used for software development were centered on notions from the sequential model of computer program execution. The basic (and often unstated) assumption in Information Technology (IT) and Computer Science programs at universities, colleges, and technical schools was that the software developer would be working in the context of single processor computers. This is evidenced by the fact that until recently educational institutions placed very little emphasis on the ideas of parallel programming. Two of the primary reasons for the lack of focus on parallel programming were cost and tradition.

Cost: First, single processor computers were considerably cheaper and enjoyed a much wider availability than multiple-processor computers. Cost and availability made single processor computers the configuration of choice for most businesses, academic institutions, and government agencies.
Tradition: Second, the fundamental ideas behind software development and computer programming were worked out decades ago within the constraints of single processor environments. Basic algorithms for searching, sorting, counting, parsing, and retrieving were developed, refined, and perfected under a sequential programming model. These same basic ...

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

Pro TBB: C++ Parallel Programming with Threading Building Blocks

Publisher Resources

ISBN: 9780470289624Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Professional Multicore Programming: Design and Implementation for C++ Developers

by Cameron Hughes, Tracey Hughes

Chapter 3. The Challenges of Multicore Programming

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.