Table of content

	Table of Contents

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
	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