Parallel and Concurrent Programming in Haskell

Preface

1. Introduction
-Terminology: Parallelism and Concurrency
-Tools and Resources
-Sample Code

Part 1: 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
-GC'd 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
-Example: A Conference Timetable
-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
-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
-Example: A Mandelbrot Set Generator

Part 2: 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
-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
-Adding a Functor Instance
-Summary: The Async API

12. Concurrent Network Servers
-A Trivial Server
-Extending the Simple Server with State
-A Chat Server

13. Parallel Programming Using Threads
-How to Achieve Parallelism with Concurrency
-Example: Searching for Files

14. Distributed Programming
-The Distributed-Process Family of Packages
-Distributed Concurrency or Parallelism?
-A First Example: Pings
-Multi-Node Ping
-Typed Channels
-Handling Failure
-A Distributed Chat Server
-Exercise: A Distributed Key-Value Store

15. Debugging, Tuning, and Interfacing with Foreign Code
-Debugging Concurrent Programs
-Tuning Concurrent (and Parallel) Programs
-Concurrency and the Foreign Function Interface

Index