Parallel and Distributed Programming Using C++

Parallel and Distributed Programming Using C++
By Cameron Hughes, Tracey Hughes

Publisher : Addison Wesley
Pub Date : August 25, 2003
ISBN : 0-13-101376-9
Pages : 720

Parallel and Distributed Programming Using C++ provides an up-close look at how to build software that can take advantage of multiprocessor computers. Simple approaches for programming parallel virtual machines are presented, and the basics of cluster application development are explained. Through an easy-to-understand overview of multithreaded programming, this book also shows you how to write software components that work together over a network to solve problems and do work.

Parallel and Distributed Programming Using C++ provides an architectural approach to parallel programming for computer programmers, software developers, designers, researchers, and software architects. It will also be useful for computer science students.

Copyright
Preface
The Challenges
The Approach
Why C++?
Libraries for Parallel and Distributed Programming
The New Single UNIX Specification Standard
Who is This Book For?
Development Environments Supported
Ancillaries
Acknowledgments

Chapter 1. The Joys of Concurrent Programming
Section 1.1. What is Concurrency?
Section 1.2. The Benefits of Parallel Programming
Section 1.3. The Benefits of Distributed Programming
Section 1.4. The Minimal Effort Required
Section 1.5. The Basic Layers of Software Concurrency
Section 1.6. No Keyword Support for Parallelism in C++
Section 1.7. Programming Environments for Parallel and Distributed Programming
Summary—Toward Concurrency

Chapter 2. The Challenges of Parallel and Distributed Programming
Section 2.1. The Big Paradigm Shift
Section 2.2. Coordination Challenges
Section 2.3. Sometimes Hardware Fails and Software Quits
Section 2.4. Too Much Parallelization or Distribution Can Have Negative Consequences
Section 2.5. Selecting a Good Architecture Requires Research
Section 2.6. Different Techniques for Testing and Debugging are Required
Section 2.7. The Parallel or Distributed Design Must Be Communicated
Summary

Chapter 3. Dividing C++ Programs into Multiple Tasks
Section 3.1. Process: A Definition
Section 3.2. Anatomy of a Process
Section 3.3. Process States
Section 3.4. Process Scheduling
Section 3.5. Context Switching
Section 3.6. Creating a Process
Section 3.7. Terminating a Process
Section 3.8. Process Resources
Section 3.9. What are Asynchronous and Synchronous Processes?
Section 3.10. Dividing the Program into Tasks
Summary

Chapter 4. Dividing C++ Programs into Multiple Threads
Section 4.1. Threads: A Definition
Section 4.2. The Anatomy of a Thread
Section 4.3. Thread Scheduling
Section 4.4. Thread Resources
Section 4.5. Thread Models
Section 4.6. Introduction to the Pthread Library
Section 4.7. The Anatomy of a Simple Threaded Program
Section 4.8. Creating Threads
Section 4.9. Managing Threads
Section 4.10. Thread Safety and Libraries
Section 4.11. Dividing Your Program into Multiple Threads
Summary

Chapter 5. Synchronizing Concurrency between Tasks
Section 5.1. Coordinating Order of Execution
Section 5.2. Synchronizing Access to Data
Section 5.3. What are Semaphores?
Section 5.4. Synchronization: An Object-Oriented Approach
Summary

Chapter 6. Adding Parallel Programming Capabilities to C++ Through the PVM
Section 6.1. The Classic Parallelism Models Supported by PVM
Section 6.2. The PVM Library for C++
Section 6.3. The Basic Mechanics of the PVM
Section 6.4. Accessing Standard Input (stdin) and Standard Output (stdout) within PVM Tasks
Summary

Chapter 7. Error Handling, Exceptions, and Software Reliability
Section 7.1. What is Software Reliability?
Section 7.2. Failures in Software Layers and Hardware Components
Section 7.3. Definitions of Defects Depend on Software Specifications
Section 7.4. Recognizing Where to Handle Defects versus Where to Handle Exceptions
Section 7.5. Software Reliability: A Simple Plan
Section 7.6. Using Map Objects in Error Handling
Section 7.7. Exception Handling Mechanisms in C++
Section 7.8. Event Diagrams, Logic Expressions, and Logic Diagrams
Summary

Chapter 8. Distributed Object-Oriented Programming in C++
Section 8.1. Decomposition and Encapsulation of the Work
Section 8.2. Accessing Objects in Other Address Spaces
Section 8.3. The Anatomy of a Basic CORBA Consumer
Section 8.4. The Anatomy of a CORBA Producer
Section 8.5. The Basic Blueprint of a CORBA Application
Section 8.6. The Naming Service
Section 8.7. A Closer Look at Object Adapters
Section 8.8. Implementation and Interface Repositories
Section 8.9. Simple Distributed Web Services Using CORBA
Section 8.10. The Trading Service
Section 8.11. The Client/Server Paradigm
Summary

Chapter 9. SPMD and MPMD Using Templates and the MPI
Section 9.1. Work Breakdown Structure for the MPI
Section 9.2. Using Template Functions to Represent MPI Tasks
Section 9.3. Simplifying MPI Communications
Summary

Chapter 10. Visualizing Concurrent and Distributed System Design
Section 10.1. Visualizing Structures
Section 10.2. Visualizing Concurrent Behavior
Section 10.3. Visualizing the Whole System
Summary

Chapter 11. Designing Components That Support Concurrency
Section 11.1. Taking Advantage of Interface Classes
Section 11.2. A Closer Look at Object-Oriented Mutual Exclusion and Interface Classes
Section 11.3. Maintaining the Stream Metaphor
Section 11.4. User-Defined Classes Designed to Work with PVM Streams
Section 11.5. Object-Oriented Pipes and fifos as Low-Level Building Blocks
Section 11.6. Framework Classes Components for Concurrency
Summary

Chapter 12. Implementing Agent-Oriented Architectures
Section 12.1. What are Agents?
Section 12.2. What is Agent-Oriented Programming?
Section 12.3. Basic Agent Components
Section 12.4. Implementing Agents in C++
Section 12.5. Multiagent Systems
Summary

Chapter 13. Blackboard Architectures Using PVM, Threads, and C++ Components
Section 13.1. The Blackboard Model
Section 13.2. Approaches to Structuring the Blackboard
Section 13.3. The Anatomy of a Knowledge Source
Section 13.4. The Control Strategies for Blackboards
Section 13.5. Implementing the Blackboard Using CORBA Objects
Section 13.6. Implementing the Blackboard Using Global Objects
Section 13.7. Activating Knowledge Sources Using Pthreads
Summary

Appendix A. Diagrams
Section A.1. Class and Object Diagrams
Section A.2. Interaction Diagrams
Section A.3. State Diagrams
Section A.4. Package Diagrams

Appendix B. System Interfaces
Bibliography


Another C++ Books
Another Parallel Programming Books
Download