Parallel and Concurrent Programming in Haskell. Techniques for Multicore and Multithreaded Programming

Spis treści ebooka

• Parallel and Concurrent Programming in Haskell
• Preface
  • Audience
  • How to Read This Book
  • Conventions Used in This Book
  • Using Sample Code
  • Safari Books Online
  • How to Contact Us
  • Acknowledgments
• 1. Introduction
  • Terminology: Parallelism and Concurrency
  • Tools and Resources
  • Sample Code
• I. Parallel Haskell
  • 2. Basic Parallelism: The Eval Monad
    • Lazy Evaluation and Weak Head Normal Form
    • The Eval Monad, rpar, and rseq
    • Example: Parallelizing a Sudoku Solver
    • Deepseq
  • 3. Evaluation Strategies
    • Parameterized Strategies
    • A Strategy for Evaluating a List in Parallel
    • Example: The K-Means Problem
      • Parallelizing K-Means
      • Performance and Analysis
      • Visualizing Spark Activity
      • Granularity
    • GCd Sparks and Speculative Parallelism
    • Parallelizing Lazy Streams with parBuffer
    • Chunking Strategies
    • The Identity Property
  • 4. Dataflow Parallelism: The Par Monad
    • Example: Shortest Paths in a Graph
    • Pipeline Parallelism
      • Rate-Limiting the Producer
      • Limitations of Pipeline Parallelism
    • Example: A Conference Timetable
      • Adding Parallelism
    • Example: A Parallel Type Inferencer
    • Using Different Schedulers
    • The Par Monad Compared to Strategies
  • 5. Data Parallel Programming with Repa
    • Arrays, Shapes, and Indices
    • Operations on Arrays
    • Example: Computing Shortest Paths
      • Parallelizing the Program
    • Folding and Shape-Polymorphism
    • Example: Image Rotation
    • Summary
  • 6. GPU Programming with Accelerate
    • Overview
    • Arrays and Indices
    • Running a Simple Accelerate Computation
    • Scalar Arrays
    • Indexing Arrays
    • Creating Arrays Inside Acc
    • Zipping Two Arrays
    • Constants
    • Example: Shortest Paths
      • Running on the GPU
      • Debugging the CUDA Backend
    • Example: A Mandelbrot Set Generator
• II. Concurrent Haskell
  • 7. Basic Concurrency: Threads and MVars
    • A Simple Example: Reminders
    • Communication: MVars
    • MVar as a Simple Channel: A Logging Service
    • MVar as a Container for Shared State
    • MVar as a Building Block: Unbounded Channels
    • Fairness
  • 8. Overlapping Input/Output
    • Exceptions in Haskell
    • Error Handling with Async
    • Merging
  • 9. Cancellation and Timeouts
    • Asynchronous Exceptions
    • Masking Asynchronous Exceptions
    • The bracket Operation
    • Asynchronous Exception Safety for Channels
    • Timeouts
    • Catching Asynchronous Exceptions
    • mask and forkIO
    • Asynchronous Exceptions: Discussion
  • 10. Software Transactional Memory
    • Running Example: Managing Windows
    • Blocking
    • Blocking Until Something Changes
    • Merging with STM
    • Async Revisited
    • Implementing Channels with STM
      • More Operations Are Possible
      • Composition of Blocking Operations
      • Asynchronous Exception Safety
    • An Alternative Channel Implementation
    • Bounded Channels
    • What Can We Not Do with STM?
    • Performance
    • Summary
  • 11. Higher-Level Concurrency Abstractions
    • Avoiding Thread Leakage
    • Symmetric Concurrency Combinators
      • Timeouts Using race
    • Adding a Functor Instance
    • Summary: The Async API
  • 12. Concurrent Network Servers
    • A Trivial Server
    • Extending the Simple Server with State
      • Design One: One Giant Lock
      • Design Two: One Chan Per Server Thread
      • Design Three: Use a Broadcast Chan
      • Design Four: Use STM
      • The Implementation
    • A Chat Server
      • Architecture
      • Client Data
      • Server Data
      • The Server
      • Setting Up a New Client
      • Running the Client
      • Recap
  • 13. Parallel Programming Using Threads
    • How to Achieve Parallelism with Concurrency
    • Example: Searching for Files
      • Sequential Version
      • Parallel Version
      • Performance and Scaling
      • Limiting the Number of Threads with a Semaphore
      • The ParIO monad
  • 14. Distributed Programming
    • The Distributed-Process Family of Packages
    • Distributed Concurrency or Parallelism?
    • A First Example: Pings
      • Processes and the Process Monad
      • Defining a Message Type
      • The Ping Server Process
      • The Master Process
      • The main Function
      • Summing Up the Ping Example
    • Multi-Node Ping
      • Running with Multiple Nodes on One Machine
      • Running on Multiple Machines
    • Typed Channels
      • Merging Channels
    • Handling Failure
      • The Philosophy of Distributed Failure
    • A Distributed Chat Server
      • Data Types
      • Sending Messages
      • Broadcasting
      • Distribution
      • Testing the Server
      • Failure and Adding/Removing Nodes
    • Exercise: A Distributed Key-Value Store
  • 15. Debugging, Tuning, and Interfacing with Foreign Code
    • Debugging Concurrent Programs
      • Inspecting the Status of a Thread
      • Event Logging and ThreadScope
      • Detecting Deadlock
    • Tuning Concurrent (and Parallel) Programs
      • Thread Creation and MVar Operations
      • Shared Concurrent Data Structures
      • RTS Options to Tweak
    • Concurrency and the Foreign Function Interface
      • Threads and Foreign Out-Calls
      • Asynchronous Exceptions and Foreign Calls
      • Threads and Foreign In-Calls
  • Index
• About the Author
• Colophon
• Copyright

pokaż cały spis treści

ukryj recenzje