Skip to content

Foundations of Multithreaded, Parallel, and Distributed Programming

Best in textbook rentals since 2012!

ISBN-10: 0201357526

ISBN-13: 9780201357523

Edition: 2000

Authors: Gregory Andrews

List price: $139.99
Blue ribbon 30 day, 100% satisfaction guarantee!
what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!

Foundations of Multithreaded, Parallel, and Distributed Programming covers, and then applies, the core concepts and techniques needed for an introductory course in this subject. Its emphasis is on the practice and application of parallel systems, using real-world examples throughout. Greg Andrews teaches the fundamental concepts of multithreaded, parallel and distributed computing and relates them to the implementation and performance processes. He presents the appropriate breadth of topics and supports these discussions with an emphasis on performance.
Customers also bought

Book details

List price: $139.99
Copyright year: 2000
Publisher: Pearson Education
Publication date: 11/30/1999
Binding: Paperback
Pages: 688
Size: 7.52" wide x 9.25" long x 1.57" tall
Weight: 2.706

The Concurrent Computing Landscape
The Essence of Concurrent Programming
Hardware Architectures
Single Processor Machines
Shared-Memory Multiprocessors
Multicomputers Networks
Applications and Programming Styles
Iterative Parallelism: Matrix Multiplication
Recursive Parallelism: Adaptive Quadrature
Producers and Consumers: Unix Pipes
Clients and Servers: Remote Files
Peers: Distributed Matrix Multiplication
Summary of Programming Notation
Declarations Sequential Statements
Concurrent Statements and Process Declarations
Comments
Shared Variable Programming
Processes and Synchronization
States, Actions, Histories, and Properties
Parallelization: Finding Patterns in Files
Synchronization: The Maximum of an Array
Atomic Actions and Await Statements
Fine-Grained Atomicity
Specifying Synchronization: The Await Statement
Finding Patterns in a File Revisited
A Synopsis of Axiomatic Semantics
Formal Logical Systems
A Programming Logic
Semantics of Concurrent Execution
Techniques for Avoiding Interference
Disjoint Variables Weakened Assertions
Global Invariants
Synchronization
An Example: The Array Copy Problem Revisited
Safety and Liveness Properties
Proving Safety Properties
Scheduling Policies and Fairness
Locks and Barriers
The Critical Section Problem
Critical Sections: Spin Locks
Test and Set
Test and Test and Set
Implementing Await Statements
Critical Sections: Fair Solutions
The Tie-Breaker Algorithm
The Ticket al.gorithm
The Bakery Algorithm
Barrier Synchronization
Shared Counter
Flags and Coordinators
Symmetric Barriers
Data Parallel Algorithms
Parallel Prefix Computations
Operations on Linked Lists
Grid Computations: Laplace's Equation
Synchronous Multiprocessors
Parallel Computing with a Bag of Tasks
Matrix Multiplication
Adaptive Quadrature
Semaphores
Syntax and Semantics
Basic Problems and Techniques
Critical Sections: Mutual Exclusion
Barriers: Signaling Events
Producers and Consumers: Split Binary Semaphores
Bounded Buffers: Resource Counting
The Dining Philosophers
Readers and Writers
Readers/Writers as an Exclusion Problem
Readers/Writers Using Condition Synchronization
The Technique of Passing the Baton
Alternative Scheduling Policies
Resource Allocation and Scheduling
Problem Definition and General Solution Pattern
Shortest-Job-Next Allocation
Case Study: Pthreads
Thread Creation
Semaphores
Example: A Simple Producer and Consumer
Monitors
Syntax and Semantics
Mutual Exclusion
Condition Variables
Signaling Disciplines
Additional Operations on Condition Variables
Synchronization Techniques
Bounded Buffers: Basic Condition Synchronization
Readers and Writers: Broadcast Signal
Shortest-Job-Next Allocation: Priority Wait
Interval Timer: Covering Conditions
The Sleeping Barber: Rendezvous
Disk Scheduling: Program Structures
Scheduler as a Separate Monitor
Scheduler as an Intermediary
Scheduler as a Nested Monitor
Case Study: Java
The Threads Class
Synchronized Methods
Parallel Readers/Writers
Exclusive Readers/Writers
True Readers/Writers
Case Study: Pthreads
Locks and Condition Variables
Example: Summing the Elements of a Matrix
Implementations
A Single-Processor Kernel
A Multiprocessor Kernel
Implementing Semaphores in a Kernel
Implementing Monitors in a Kernel
Implementing Monitors Using Semaphores
Distributed Programming
Message Passing
Asynchronous Message Passing
Filters: A Sorting Network
Clients and Servers
Active Monitors
A Self-Scheduling Disk Driver
File Servers: Conversational Continuity
Interacting Peers: Exchanging Values
Synchronous Message Passing
Case Study: CSP
Communication Statements
Guarded Communication
Example: The Sieve of Eratosthenes
Case Study: Linda
Tuple Space and Process Interaction
Example: Prime Numbers with a Bag of Tasks
Case Study: MPI
Basic Functions
Global Communication and Synchronization
Case Study: Java
Networks and Sockets
Example: A Remote File Reader
RPC and Rendezvous
Remote Proc