Professional multicore programming : design and implementation for C++ developers / Cameron Hughes, Tracey Hughes.

Enhanced descriptions from Syndetics:

Professional Multicore Programming: Design and Implementation for C++ Developers presents the basics of multicore programming in a simple, easy-to-understand manner so that you can easily apply the concepts to your everyday projects. Learn the fundamentals of programming for multiprocessor and multithreaded architecture, progress to multi-core programming and eventually become comfortable with programming techniques that otherwise can be difficult to understand. Anticipate the pitfalls and traps of concurrency programming and synchronization before you encounter them yourself by finding them outlined in this indispensable guide to multicore programming.

Table of contents provided by Syndetics

• Introduction (p. xxi)
• Chapter 1 The New Architecture (p. 1)
• What Is a Multicore? (p. 2)
• Multicore Architectures (p. 2)
• Hybrid Multicore Architectures (p. 3)
• The Software Developer's Viewpoint (p. 4)
• The Basic Processor Architecture (p. 5)
• The CPU (Instruction Set) (p. 7)
• Memory Is the Key (p. 9)
• Registers (p. 11)
• Cache (p. 12)
• Main Memory (p. 13)
• The Bus Connection (p. 14)
• From Single Core to Multicore (p. 15)
• Multiprogramming and Multiprocessing (p. 15)
• Parallel Programming (p. 15)
• Multicore Application Design and Implementation (p. 16)
• Summary (p. 17)
• Chapter 2 Four Effective Multicore Designs (p. 19)
• The AMD Multicore Opteron (p. 21)
• Opteron's Direct Connect and HyperTransport (p. 22)
• System Request Interface and Crossbar (p. 23)
• The Opteron Is NUMA (p. 24)
• Cache and the Multiprocessor Opteron (p. 25)
• The Sun UltraSparc T1 Multiprocessor (p. 25)
• Program Profile 2-1 (p. 26)
• UltraSparc T1 Cores (p. 27)
• Cross Talk and The Crossbar (p. 27)
• DDRAM Controller and L2 Cache (p. 28)
• UltraSparc T1 and the Sun and GNU gcc Compilers (p. 28)
• The IBM Cell Broadband Engine (p. 28)
• CBE and Linux (p. 29)
• CBE Memory Models (p. 29)
• Hidden from the Operating System (p. 30)
• Synergistic Processor Unit (p. 31)
• Intel Core 2 Duo Processor (p. 31)
• Northbridge and Southbridge (p. 32)
• Intel's PCI Express (p. 32)
• Core 2 Duo's Instruction Set (p. 32)
• Summary (p. 33)
• Chapter 3 The Challenges of Multicore Programming (p. 35)
• What Is the Sequential Model? (p. 36)
• What Is Concurrency? (p. 37)
• Software Development (p. 37)
• Challenge #1 Software Decomposition (p. 41)
• Challenge #2 Task-to-Task Communication (p. 47)
• Challenge #3 Concurrent Access to Data or Resources by Multiple Tasks or Agents (p. 51)
• Challenge #4 Identifying the Relationships between Concurrently Executing Tasks (p. 56)
• Challenge #5 Controlling Resource Contention Between Tasks (p. 59)
• Challenge #6 How Many Processes or Threads Are Enough? (p. 59)
• Challenges #7 and #8 Finding Reliable and Reproducible Debugging and Testing (p. 60)
• Challenge #9 Communicating a Design That Has Multiprocessing Components (p. 61)
• Challenge #10 Implementing Multiprocessing and Multithreading in C++ (p. 62)
• C++ Developers Have to Learn New Libraries (p. 63)
• Processor Architecture Challenges (p. 64)
• Summary (p. 64)
• Chapter 4 The Operating System's Role (p. 67)
• What Part Does the Operating System Play? (p. 68)
• Providing a Consistent Interface (p. 68)
• Managing Hardware Resources and Other Software Applications (p. 68)
• The Developer's Interaction with the Operating System (p. 69)
• Core Operating System Services (p. 71)
• The Application Programmer's Interface (p. 75)
• Decomposition and the Operating System's Role (p. 83)
• Hiding the Operating System's Role (p. 86)
• Taking Advantage of C++ Power of Abstraction and Encapsulation (p. 86)
• Interface Classes for the POSIX APIs (p. 86)
• Summary (p. 93)
• Chapter 5 Processes, C++ Interface Classes, and Predicates (p. 95)
• We Say Multicore, We Mean Multiprocessor (p. 96)
• What Is a Process? (p. 97)
• Why Processes and Not Threads? (p. 97)
• Using posix_spawn() (p. 98)
• The file_actions Parameter (p. 99)
• The attrp Parameter (p. 100)
• A Simple posix_spawn() Example (p. 103)
• The guess_it Program Using posix_spawn (p. 104)
• Who Is the Parent? Who Is the Child? (p. 107)
• Processes: A Closer Look (p. 108)
• Process Control Block (p. 108)
• Anatomy of a Process (p. 109)
• Process States (p. 111)
• How Are Processes Scheduled? (p. 114)
• Monitoring Processes with the ps Utility (p. 116)
• Setting and Getting Process Priorities (p. 119)
• What Is a Context Switch? (p. 121)
• The Activities in Process Creation (p. 121)
• Using the fork() Function Call (p. 122)
• Using the exec() Family of System Calls (p. 122)
• Working with Process Environment Variables (p. 126)
• Using system() to Spawn Processes (p. 127)
• Killing a Process (p. 127)
• The exit(), and abort() Calls (p. 128)
• The kill() Function (p. 128)
• Process Resources (p. 129)
• Types of Resources (p. 130)
• POSIX Functions to Set Resource Limits (p. 131)
• What Are Asynchronous and Synchronous Processes (p. 133)
• Synchronous vs. Asynchronous Processes for fork(), posix_spawn(), system(), and exec() (p. 135)
• The wait() Function Call (p. 135)
• Predicates, Processes, and Interface Classes (p. 137)
• Program Profile 5-1 (p. 138)
• Summary (p. 141)
• Chapter 6 Multithreading (p. 143)
• What Is a Thread? (p. 143)
• User- and Kernel-Level Threads (p. 144)
• Thread Context (p. 147)
• Hardware Threads and Software Threads (p. 149)
• Thread Resources (p. 149)
• Comparing Threads to Processes (p. 150)
• Context Switching (p. 150)
• Throughput (p. 150)
• Communicating between Entities (p. 150)
• Corrupting Process Data (p. 151)
• Killing the Entire Process (p. 151)
• Reuse by Other Programs (p. 151)
• Key Similarities and Differences between Threads and Processes (p. 152)
• Setting Thread Attributes (p. 153)
• The Architecture of a Thread (p. 155)
• Thread States (p. 156)
• Scheduling and Thread Contention Scope (p. 157)
• Scheduling Policy and Priority (p. 159)
• Scheduling Allocation Domains (p. 160)
• A Simple Threaded Program (p. 160)
• Compiling and Linking Threaded Programs (p. 162)
• Creating Threads (p. 162)
• Passing Arguments to a Thread (p. 163)
• Program Profile 6-1 (p. 165)
• Joining Threads (p. 165)
• Getting the Thread Id (p. 166)
• Using the Pthread Attribute Object (p. 167)
• Managing Threads (p. 171)
• Terminating Threads (p. 171)
• Managing the Thread's Stack (p. 180)
• Setting Thread Scheduling and Priorities (p. 183)
• Setting Contention Scope of a Thread (p. 187)
• Using sysconf() (p. 188)
• Thread Safety and Libraries (p. 190)
• Extending the Thread Interface Class (p. 193)
• Program Profile 6-2 (p. 200)
• Summary (p. 200)
• Chapter 7 Communication and Synchronization of Concurrent Tasks (p. 203)
• Communication and Synchronization (p. 204)
• Dependency Relationships (p. 205)
• Counting Tasks Dependencies (p. 208)
• What Is Interprocess Communication? (p. 210)
• What Are Interthread Communications? (p. 230)
• Synchronizing Concurrency (p. 238)
• Types of Synchronization (p. 239)
• Synchronizing Access to Data (p. 240)
• Synchronization Mechanisms (p. 246)
• Thread Strategy Approaches (p. 268)
• Delegation Model (p. 269)
• Peer-to-Peer Model (p. 271)
• Producer-Consumer Model (p. 272)
• Pipeline Model (p. 273)
• SPMD and MPMD for Threads (p. 274)
• Decomposition and Encapsulation of Work (p. 276)
• Problem Statement (p. 276)
• Strategy (p. 276)
• Observation (p. 277)
• Problem and Solution (p. 277)
• Simple Agent Model Example of a Pipeline (p. 278)
• Summary (p. 282)
• Chapter 8 PADL and PBS: Approaches to Application Design (p. 283)
• Designing Applications for Massive Multicore Processors (p. 284)
• What Is PADL? (p. 287)
• Layer 5 Application Architecture Selection (p. 290)
• Layer 4 Concurrency Models in PADL (p. 300)
• Layer 3 The Implementation Model of PADL (p. 304)
• The Predicate Breakdown Structure (PBS) (p. 326)
• An Example: PBS for the "Guess-My-Code" Game (p. 327)
• Connecting PBS, PADL, and the SDLC (p. 328)
• Coding the PBS (p. 328)
• Summary (p. 328)
• Chapter 9 Modeling Software Systems That Require Concurrency (p. 331)
• What Is UML? (p. 332)
• Modeling the Structure of a System (p. 334)
• The Class Model (p. 334)
• Visualizing Classes (p. 336)
• Ordering the Attributes and Services (p. 343)
• Visualizing Instances of a Class (p. 345)
• Visualizing Template Classes (p. 348)
• Showing the Relationship between Classes and Objects (p. 349)
• Visualizing Interface Classes (p. 353)
• The Organization of Interactive Objects (p. 356)
• UML and Concurrent Behavior (p. 357)
• Collaborating Objects (p. 357)
• Multitasking and Multithreading with Processes and Threads (p. 359)
• Message Sequences between Objects (p. 361)
• The Activities of Objects (p. 363)
• State Machines (p. 365)
• Visualizing the Whole System (p. 371)
• Summary (p. 372)
• Chapter 10 Testing and Logical Fault Tolerance for Parallel Programs (p. 375)
• Can You Just Skip the Testing? (p. 376)
• Five Concurrency Challenges That Must Be Checked during Testing (p. 377)
• Failure: The Result of Defects and Faults (p. 379)
• Basic Testing Types (p. 379)
• Defect Removal versus Defect Survival (p. 380)
• How Do You Approach Defect Removal for Parallel Programs? (p. 381)
• The Problem Statement (p. 382)
• A Simple Strategy and Rough-Cut Solution Model (p. 382)
• A Revised Solution Model Using Layer 5 from PADL (p. 382)
• The PBS of the Agent Solution Model (p. 383)
• What Are the Standard Software Engineering Tests? (p. 386)
• Software Verification and Validation (p. 387)
• The Code Doesn't Work - Now What? (p. 388)
• What Is Logical Fault Tolerance? (p. 391)
• Predicate Exceptions and Possible Worlds (p. 397)
• What Is Model Checking? (p. 398)
• Summary (p. 398)
• Appendix A UML for Concurrent Design (p. 401)
• Appendix B Concurrency Models (p. 411)
• Appendix C POSIX Standard for Thread Management (p. 427)
• Appendix D POSIX Standard for Process Management (p. 567)
• Bibliography (p. 593)
• Index (p. 597)

Author notes provided by Syndetics

Tracey Hughes is a senior graphics programmer at CTEST Laboratories, where she develops knowledge and information visualization software. Tracey Hughes is the lead designer for the M.I.N.D, C.R.A.I.G, and NOFAQS projects that utilize epistemic visualization at CTEST Laboratories. She regularly contributes to Linux development software efforts. She is also a team member on the GRIOT project.
Cameron and Tracey Hughes are also the authors of six books on software development, multithreaded, and parallel programming: Parallel and Distributed Programming Using C (Addison Wesley, 2003), Linux Rapid Application Development (Hungry Minds, 2000), Mastering the Standard C++ Classes (Wiley, 1999), O bject - Oriented Multithreading Using C (Wiley, 1997), Collection and Container Classes in C++ (Wiley, 1996), and Object - Oriented I/O Using C Iostreams (Wiley, 1995).