Parallel and Concurrent Programming in Haskell

Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

! operator, Arrays, Shapes, and Indices, Arrays and Indices, Indexing Arrays

in Accelerate, Arrays and Indices

in Repa, Arrays, Shapes, and Indices

indexing arrays with, Indexing Arrays

$ operator (infix operator), MVar as a Container for Shared State

$! operator, MVar as a Container for Shared State

-02 optimization option, Example: Computing Shortest Paths

-A (RTS option), RTS Options to Tweak

-C (RTS option), RTS Options to Tweak

-ddump-cc option, Debugging the CUDA Backend

-dverbose option, Debugging the CUDA Backend

-fllvm optimization option, Example: Computing Shortest Paths

-I (RTS option), RTS Options to Tweak

-k (RTS option), Thread Creation and MVar Operations

-N(RTS option), RTS Options to Tweak

-qa (RTS option), RTS Options to Tweak

-s (RTS option), Example: Parallelizing a Sudoku Solver

-threaded option, Parallelizing the Program

/quit::, A Chat Server

:. constructor, Arrays, Shapes, and Indices, Arrays and Indices

>-> operator, Example: Shortest Paths

A

Accelerate, GPU Programming with Accelerate–Zipping Two Arrays, GPU Programming with Accelerate–GPU Programming with Accelerate, Arrays and Indices–Arrays and Indices, Arrays and Indices–Arrays and Indices, Running a Simple Accelerate Computation–Running a Simple Accelerate Computation, Running a Simple Accelerate Computation, Running a Simple Accelerate Computation, Running a Simple Accelerate Computation, Running a Simple Accelerate Computation, Creating Arrays Inside Acc–Creating Arrays Inside Acc, Constants, Example: Shortest Paths–Debugging the CUDA Backend, Debugging the CUDA Backend, Example: A Mandelbrot Set Generator–Example: A Mandelbrot Set Generator, Example: A Mandelbrot Set Generator–Example: A Mandelbrot Set Generator

Arrays class, Running a Simple Accelerate Computation

arrays in, Arrays and Indices–Arrays and Indices

conditionals, working with, Example: A Mandelbrot Set Generator–Example: A Mandelbrot Set Generator

constant function, Constants

creating arrays, Creating Arrays Inside Acc–Creating Arrays Inside Acc

debugging, Debugging the CUDA Backend

Elt class, Running a Simple Accelerate Computation

GPUs, programming with, GPU Programming with Accelerate–GPU Programming with Accelerate

implementing Floyd-Warshall algorithm, Example: Shortest Paths–Debugging the CUDA Backend

indices in, Arrays and Indices–Arrays and Indices

Mandelbrot set generator in, Example: A Mandelbrot Set Generator–Example: A Mandelbrot Set Generator

programs, executing, Running a Simple Accelerate Computation–Running a Simple Accelerate Computation

Shape class, Running a Simple Accelerate Computation

type classes in, Running a Simple Accelerate Computation

accept operation, for multiclient servers, A Trivial Server

addition, in Accelerate, Example: A Mandelbrot Set Generator

addToPointSum function, Example: The K-Means Problem

adjacency matrix, Example: Shortest Paths in a Graph, Example: Computing Shortest Paths, Folding and Shape-Polymorphism

algorithms run over, Example: Shortest Paths in a Graph

defined, Example: Computing Shortest Paths

foldS function with, Folding and Shape-Polymorphism

Amdahls law, Example: Parallelizing a Sudoku Solver

Applicative type class, Example: Shortest Paths in a Graph

arrays, Data Parallel Programming with Repa, Operations on Arrays–Operations on Arrays, Operations on Arrays, Operations on Arrays, Arrays and Indices

delayed, Operations on Arrays–Operations on Arrays

large-scale, Data Parallel Programming with Repa

manifest, Operations on Arrays

nested, Arrays and Indices

unboxed, Operations on Arrays

Arrays class (Accelerate), Running a Simple Accelerate Computation

arrays in Accelerate, Arrays and Indices–Arrays and Indices, Arrays and Indices, Arrays and Indices, Scalar Arrays, Indexing Arrays, Creating Arrays Inside Acc–Creating Arrays Inside Acc, Zipping Two Arrays, Zipping Two Arrays, Example: Shortest Paths, Example: A Mandelbrot Set Generator–Example: A Mandelbrot Set Generator

creating, Creating Arrays Inside Acc–Creating Arrays Inside Acc

indexing, Indexing Arrays

of dimensionality one, Arrays and Indices

of dimensionality zero, Arrays and Indices

of tuples, working with, Example: A Mandelbrot Set Generator–Example: A Mandelbrot Set Generator

passing inputs as, Example: Shortest Paths

scalar, Scalar Arrays

zipping, Zipping Two Arrays

zipWith function, Zipping Two Arrays

arrays in Repa, Arrays, Shapes, and Indices–Operations on Arrays, Operations on Arrays–Operations on Arrays, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism

folding, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism

operations on, Operations on Arrays–Operations on Arrays

shape-polymorphism, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism

assign function, Example: The K-Means Problem, Parallelizing K-Means

in K-Means problem, Example: The K-Means Problem

parallelizing, Parallelizing K-Means

associativity (foldP), Folding and Shape-Polymorphism

Async API, Overlapping Input/Output, mask and forkIO, Async Revisited–Async Revisited, Avoiding Thread Leakage, Avoiding Thread Leakage, How to Achieve Parallelism with Concurrency, Parallel Version

automatically canceled with thread death, Avoiding Thread Leakage

avoiding thread leakage with, Avoiding Thread Leakage

cancellation of, mask and forkIO

for asynchronous actions, Overlapping Input/Output

implementing with STM, Async Revisited–Async Revisited

to implement programs, Parallel Version

Async computations, errors inside, Parallel Version

asynchronous actions, wait function for, Overlapping Input/Output

asynchronous cancellation, Cancellation and Timeouts

asynchronous exceptions, Cancellation and Timeouts–Asynchronous Exceptions: Discussion, Asynchronous Exceptions–Asynchronous Exceptions, Asynchronous Exceptions, Masking Asynchronous Exceptions–Masking Asynchronous Exceptions, The bracket Operation, Asynchronous Exception Safety for Channels–Asynchronous Exception Safety for Channels, Timeouts–Timeouts, Catching Asynchronous Exceptions–Catching Asynchronous Exceptions, mask and forkIO–mask and forkIO, mask and forkIO–mask and forkIO, Asynchronous Exceptions: Discussion, Asynchronous Exceptions: Discussion, Asynchronous Exception Safety, Setting Up a New Client, Asynchronous Exceptions and Foreign Calls–Asynchronous Exceptions and Foreign Calls

bracket function, The bracket Operation

cancellations, Asynchronous Exceptions–Asynchronous Exceptions

catching, Catching Asynchronous Exceptions–Catching Asynchronous Exceptions

channel safety, Asynchronous Exception Safety for Channels–Asynchronous Exception Safety for Channels

defined, Asynchronous Exceptions

foreign out-calls and, Asynchronous Exceptions and Foreign Calls–Asynchronous Exceptions and Foreign Calls

forkIO function, mask and forkIO–mask and forkIO, Asynchronous Exceptions: Discussion

in STM, Asynchronous Exception Safety

mask function, mask and forkIO–mask and forkIO, Asynchronous Exceptions: Discussion

masking, Masking Asynchronous Exceptions–Masking Asynchronous Exceptions, Setting Up a New Client

timeouts and, Timeouts–Timeouts

asynchronous I/O, Overlapping Input/Output–Merging, Overlapping Input/Output–Overlapping Input/Output, Exceptions in Haskell–Exceptions in Haskell, Error Handling with Async–Error Handling with Async, Merging–Merging

exceptions, handling, Error Handling with Async–Error Handling with Async

exceptions, throwing, Exceptions in Haskell–Exceptions in Haskell

merging, Merging–Merging

MVar and, Overlapping Input/Output–Overlapping Input/Output

atomic blocks, as language construct, Software Transactional Memory

atomicModifyIORef, Limiting the Number of Threads with a Semaphore, Shared Concurrent Data Structures

B

backtracking, Example: A Conference Timetable

bandwith, saving with distributed servers, A Distributed Chat Server

bang-pattern, Limiting the Number of Threads with a Semaphore

Binary class, Defining a Message Type–Defining a Message Type

binary package, Defining a Message Type–Defining a Message Type

BlockedIndefinitelyOnMVar exception, Communication: MVars, Detecting Deadlock

blocking, Masking Asynchronous Exceptions, The bracket Operation, Timeouts, Blocking, Merging with STM, What Can We Not Do with STM?, Performance, Detecting Deadlock

and interruptible operations, Masking Asynchronous Exceptions

by throwTo, Timeouts

in STM, Blocking, What Can We Not Do with STM?, Performance

in takeMVar operation, Detecting Deadlock

with bracket function, The bracket Operation

with orElse operator, Merging with STM

BlockReason data type, Inspecting the Status of a Thread

bottlenecks, in parallel programs, Limiting the Number of Threads with a Semaphore

bound threads, Threads and Foreign Out-Calls, Threads and Foreign Out-Calls, Threads and Foreign In-Calls

foreign in-calls as, Threads and Foreign In-Calls

main threads as, Threads and Foreign Out-Calls

bounded channels, Bounded Channels–Bounded Channels

bracket function, Exceptions in Haskell, Asynchronous Exceptions, The bracket Operation, The bracket Operation, Asynchronous Exceptions: Discussion, Avoiding Thread Leakage, Setting Up a New Client

and conditional functions, Setting Up a New Client

and exceptions, Asynchronous Exceptions

defined with mask, The bracket Operation

finally function, Exceptions in Haskell

for asynchronous exception safety, Asynchronous Exceptions: Discussion

for canceling an async, Avoiding Thread Leakage

broadcast channels, Design Three: Use a Broadcast Chan, Recap

browsers, interrupting several activiites with, Cancellation and Timeouts

buffer size, with parBuffer, Parallelizing Lazy Streams with parBuffer

C

C, threading models in, Concurrency and the Foreign Function Interface

callbacks, Terminology: Parallelism and Concurrency, Threads and Foreign In-Calls

concurrency vs., Terminology: Parallelism and Concurrency

GUI, Threads and Foreign In-Calls

calls, Performance and Analysis, Example: Shortest Paths in a Graph, Adding Parallelism, The Par Monad Compared to Strategies, Masking Asynchronous Exceptions, Catching Asynchronous Exceptions, Parallel Version

foreign, Performance and Analysis

nesting, The Par Monad Compared to Strategies, Masking Asynchronous Exceptions, Parallel Version

recursive, Example: Shortest Paths in a Graph, Adding Parallelism, Catching Asynchronous Exceptions

cancel, Asynchronous Exceptions

catch function, Exceptions in Haskell, Exceptions in Haskell, Catching Asynchronous Exceptions

infix use of, Exceptions in Haskell

catchSTM, Asynchronous Exception Safety

centroids, Example: The K-Means Problem, Example: The K-Means Problem

computing, Example: The K-Means Problem

defined, Example: The K-Means Problem

Chan, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels, Merging with STM, Implementing Channels with STM

merging events into single, Merging with STM

TChan vs., Implementing Channels with STM

channel abstraction, An Alternative Channel Implementation

channels, Communication: MVars–Communication: MVars, MVar as a Simple Channel: A Logging Service–MVar as a Simple Channel: A Logging Service, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels, Asynchronous Exception Safety for Channels–Asynchronous Exception Safety for Channels, Implementing Channels with STM–Asynchronous Exception Safety, Design Two: One Chan Per Server Thread, Design Three: Use a Broadcast Chan, Typed Channels–Merging Channels, Handling Failure

adding elements to, MVar as a Building Block: Unbounded Channels

asynchronous exceptions and, Asynchronous Exception Safety for Channels–Asynchronous Exception Safety for Channels

broadcast, Design Three: Use a Broadcast Chan

ClientInput events carried by, Design Two: One Chan Per Server Thread

constructing new, MVar as a Building Block: Unbounded Channels

duplicate, MVar as a Building Block: Unbounded Channels

empty, MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels

implementing, MVar as a Simple Channel: A Logging Service–MVar as a Simple Channel: A Logging Service, Implementing Channels with STM–Asynchronous Exception Safety

one-place, Communication: MVars–Communication: MVars

pushing values on end of, MVar as a Building Block: Unbounded Channels

read and write pointers of, MVar as a Building Block: Unbounded Channels

removing values from, MVar as a Building Block: Unbounded Channels

typed channels vs., Handling Failure

typed, in distributed programming, Typed Channels–Merging Channels

unbounded, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels

chat server, A Chat Server–Recap, Architecture, Client Data, Server Data, Setting Up a New Client, Running the Client

architecture, Architecture

client data in, Client Data

implementing, A Chat Server–Recap

running client threads in, Running the Client

server data, Server Data

setting up new clients in, Setting Up a New Client

checkAddClient function, Setting Up a New Client

checkValue operation, Asynchronous Exception Safety

chunking, Example: Parallelizing a Sudoku Solver, Performance and Analysis, Granularity–Granularity, Limiting the Number of Threads with a Semaphore

and parallelizing, Example: Parallelizing a Sudoku Solver

in K-Means problem, Performance and Analysis

number of chunks and runtime, Granularity–Granularity

with granularity problems, Limiting the Number of Threads with a Semaphore

client data, in chat server, Client Data

client input events, Design Two: One Chan Per Server Thread, Design Three: Use a Broadcast Chan, Architecture

and server architecture, Architecture

carrying of, by channels, Design Two: One Chan Per Server Thread

on broadcast channels, Design Three: Use a Broadcast Chan

client threads, in chat server, Running the Client

clients, local vs. remote in distributed systems, Data Types

clientSendChan, Client Data

Closure, The Master Process

Cluster (type), Example: The K-Means Problem, Example: The K-Means Problem, Example: The K-Means Problem

from PointSum, Example: The K-Means Problem

in Lloyds algorithm, Example: The K-Means Problem

representation of, Example: The K-Means Problem

clusters, partitioning data points into, Example: The K-Means Problem–Performance and Analysis

Command constructor, Client Data

command function, The Implementation

command-line parameters, Limiting the Number of Threads with a Semaphore

communication, Communication: MVars–Communication: MVars, A Trivial Server, Distributed Programming

between distributed processes, Distributed Programming

between server and client, A Trivial Server

of threads, Communication: MVars–Communication: MVars

compilers, Example: A Parallel Type Inferencer, Detecting Deadlock

deadlock detection by, Detecting Deadlock

for functional language, Example: A Parallel Type Inferencer

complex numbers, Example: A Mandelbrot Set Generator, Example: A Mandelbrot Set Generator

addition of, Example: A Mandelbrot Set Generator

multiplication of, Example: A Mandelbrot Set Generator

composability, of STM operations, Running Example: Managing Windows

composable atomicity, Summary

composable blocking, Summary

composite operations (in STM), Composition of Blocking Operations

compute-bound program, Example: Searching for Files

computeP function, Parallelizing the Program, Parallelizing the Program–Parallelizing the Program

computeS function, Operations on Arrays, Example: Computing Shortest Paths, Parallelizing the Program–Parallelizing the Program, Parallelizing the Program

and building of adjacency matrix, Example: Computing Shortest Paths

and delayed arrays, Operations on Arrays

computeP vs., Parallelizing the Program–Parallelizing the Program, Parallelizing the Program

concurrency, Terminology: Parallelism and Concurrency–Terminology: Parallelism and Concurrency, Basic Concurrency: Threads and MVars–Fairness, Communication: MVars–MVar as a Building Block: Unbounded Channels, MVar as a Simple Channel: A Logging Service–MVar as a Simple Channel: A Logging Service, MVar as a Container for Shared State–MVar as a Container for Shared State, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels, Fairness–Fairness, Fairness–Fairness, Higher-Level Concurrency Abstractions–Summary: The Async API, Avoiding Thread Leakage–Avoiding Thread Leakage, Symmetric Concurrency Combinators–Timeouts Using race, Timeouts Using race–Timeouts Using race, Timeouts Using race–Timeouts Using race, Adding a Functor Instance–Adding a Functor Instance, How to Achieve Parallelism with Concurrency–How to Achieve Parallelism with Concurrency, Debugging Concurrent Programs–Event Logging and ThreadScope, Detecting Deadlock–Detecting Deadlock, Tuning Concurrent (and Parallel) Programs–RTS Options to Tweak, Shared Concurrent Data Structures–Shared Concurrent Data Structures, Concurrency and the Foreign Function Interface

channels, implementing, MVar as a Simple Channel: A Logging Service–MVar as a Simple Channel: A Logging Service

CPU usage and, Fairness–Fairness

data structures, shared, Shared Concurrent Data Structures–Shared Concurrent Data Structures

deadlock, detecting, Detecting Deadlock–Detecting Deadlock

debugging, Debugging Concurrent Programs–Event Logging and ThreadScope

fairness of, Fairness–Fairness

FFI and, Concurrency and the Foreign Function Interface

Functor instances and, Adding a Functor Instance–Adding a Functor Instance

MVars, Communication: MVars–MVar as a Building Block: Unbounded Channels

parallelism, achieving with, How to Achieve Parallelism with Concurrency–How to Achieve Parallelism with Concurrency

race operation, Timeouts Using race–Timeouts Using race

shared state, MVar as a Container for Shared State–MVar as a Container for Shared State

symmetric combinators, Symmetric Concurrency Combinators–Timeouts Using race

thread leakage, Avoiding Thread Leakage–Avoiding Thread Leakage

timeouts, Timeouts Using race–Timeouts Using race

tuning, Tuning Concurrent (and Parallel) Programs–RTS Options to Tweak

unbounded channels, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels

concurrent search, of multiple subdirectories, Parallel Version

concurrent web servers, Introduction

concurrently function, Symmetric Concurrency Combinators

conditional operations, in Accelerate, Example: A Mandelbrot Set Generator

constant function (Accelerate), Constants

constraint satisfaction problems, Example: A Conference Timetable–Adding Parallelism, Adding Parallelism–Adding Parallelism

parallel skeletons and, Adding Parallelism–Adding Parallelism

constructors, Rate-Limiting the Producer, Arrays, Shapes, and Indices, Arrays, Shapes, and Indices, Arrays and Indices, MVar as a Simple Channel: A Logging Service, MVar as a Simple Channel: A Logging Service, Masking Asynchronous Exceptions, Masking Asynchronous Exceptions, Masking Asynchronous Exceptions, Implementing Channels with STM

:., Arrays, Shapes, and Indices, Arrays and Indices

Fork, Rate-Limiting the Producer

MaskedInterruptible, Masking Asynchronous Exceptions

MaskedUninterruptible, Masking Asynchronous Exceptions

Message, MVar as a Simple Channel: A Logging Service

Stop, MVar as a Simple Channel: A Logging Service

TNil, Implementing Channels with STM

Unmasked, Masking Asynchronous Exceptions

Z, Arrays, Shapes, and Indices

contention, MVar and, Limiting the Number of Threads with a Semaphore

context-switch performance, efficiency of, Thread Creation and MVar Operations

Control.Deepseq module, Deepseq–Deepseq

converted sparks, Example: Parallelizing a Sudoku Solver

cost model of STM, Performance

CPUs, GPUs vs., GPU Programming with Accelerate

Ctrl+C, A Trivial Server

CUDA language, GPU Programming with Accelerate, Running on the GPU, Debugging the CUDA Backend

debugging, Debugging the CUDA Backend

support in Accelerate for, Running on the GPU

D

data dependencies, Dataflow Parallelism: The Par Monad

data parallelism, Pipeline Parallelism, Limitations of Pipeline Parallelism

defined, Pipeline Parallelism

pipeline parallelism vs., Limitations of Pipeline Parallelism

data structure(s), Lazy Evaluation and Weak Head Normal Form, Communication: MVars, MVar as a Container for Shared State, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels, Asynchronous Exception Safety for Channels, An Alternative Channel Implementation, Performance, Shared Concurrent Data Structures–Shared Concurrent Data Structures

evaluating compuations with, Lazy Evaluation and Weak Head Normal Form

invariants of, Asynchronous Exception Safety for Channels

MVar as building blocks for, Communication: MVars, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels

MVar wrappers for, MVar as a Container for Shared State

representing channel contents, An Alternative Channel Implementation

shared concurrent, Shared Concurrent Data Structures–Shared Concurrent Data Structures

to store logs, Performance

dataflow, Dataflow Parallelism: The Par Monad–The Par Monad Compared to Strategies, Example: Shortest Paths in a Graph–Example: Shortest Paths in a Graph, Pipeline Parallelism–Limitations of Pipeline Parallelism, Example: A Conference Timetable–Adding Parallelism, Example: A Parallel Type Inferencer–Example: A Parallel Type Inferencer

and constraint satisfaction problems, Example: A Conference Timetable–Adding Parallelism

and Floyd-Warshall algorithm, Example: Shortest Paths in a Graph–Example: Shortest Paths in a Graph

pipleline paralellism and, Pipeline Parallelism–Limitations of Pipeline Parallelism

type inference engines, Example: A Parallel Type Inferencer–Example: A Parallel Type Inferencer

dataflow graphs, Dataflow Parallelism: The Par Monad

deadlock, MVar as a Building Block: Unbounded Channels, Error Handling with Async, Bounded Channels, Detecting Deadlock

and empty channels, MVar as a Building Block: Unbounded Channels

caused by writeTBQueue, Bounded Channels

error codes vs., Error Handling with Async

mutual, Detecting Deadlock

deadlock detection, Communication: MVars, Detecting Deadlock–Detecting Deadlock, Detecting Deadlock

and MVar, Communication: MVars

of mutual deadlock, Detecting Deadlock

death, thread, Higher-Level Concurrency Abstractions, Avoiding Thread Leakage

debugging, Debugging the CUDA Backend, Debugging the CUDA Backend, Masking Asynchronous Exceptions, Handling Failure, Handling Failure, Debugging Concurrent Programs–Event Logging and ThreadScope, Inspecting the Status of a Thread–Inspecting the Status of a Thread, Event Logging and ThreadScope–Event Logging and ThreadScope, Event Logging and ThreadScope–Event Logging and ThreadScope, Detecting Deadlock–Detecting Deadlock

Accelerate programs, Debugging the CUDA Backend

concurrent programs, Debugging Concurrent Programs–Event Logging and ThreadScope

CUDA, Debugging the CUDA Backend

deadlock, detecting, Detecting Deadlock–Detecting Deadlock

event logging, Event Logging and ThreadScope–Event Logging and ThreadScope

monitor function, Handling Failure

thread status, inspecting, Inspecting the Status of a Thread–Inspecting the Status of a Thread

ThreadScope, Event Logging and ThreadScope–Event Logging and ThreadScope

with getMaskingState function, Masking Asynchronous Exceptions

withMonitor function, Handling Failure

decrypt function, Pipeline Parallelism

deeply-embedded domain-specific languages, Overview

DeepSeq (Control module), Deepseq–Deepseq

degrees of evaluation, Deepseq

delayed arrays, Operations on Arrays, Operations on Arrays, Operations on Arrays, Operations on Arrays

computeS function and, Operations on Arrays

defined, Operations on Arrays

from fromFunction operation, Operations on Arrays

indexing, Operations on Arrays

depth threshold, Adding Parallelism, Limiting the Number of Threads with a Semaphore

for divide-and-conquer algorithms, Limiting the Number of Threads with a Semaphore

for tree-shaped parallelism, Adding Parallelism

DeriveGeneric extension (Binary class), Defining a Message Type

Desktops, Running Example: Managing Windows, Running Example: Managing Windows

for displays, Running Example: Managing Windows

MVars for, Running Example: Managing Windows

deterministic parallel programming, Terminology: Parallelism and Concurrency–Terminology: Parallelism and Concurrency

DevIL library, Example: Image Rotation–Summary

Dining Philosophers problem, Running Example: Managing Windows, Bounded Channels

Direct scheduler (monad-par library), Using Different Schedulers

distributed fault-tolerant key-value store, Exercise: A Distributed Key-Value Store

distributed programming, Distributed Programming–Exercise: A Distributed Key-Value Store, A First Example: Pings–Summing Up the Ping Example, A First Example: Pings–Summing Up the Ping Example, The Ping Server Process–The Ping Server Process, The Master Process–The Master Process, The main Function–The main Function, Multi-Node Ping–Running on Multiple Machines, Typed Channels–Merging Channels, Handling Failure–The Philosophy of Distributed Failure, A Distributed Chat Server–Failure and Adding/Removing Nodes, Data Types

clients, local vs. remote, Data Types

failures, handling, Handling Failure–The Philosophy of Distributed Failure

implementing, A First Example: Pings–Summing Up the Ping Example

main function and, The main Function–The main Function

master process for, The Master Process–The Master Process

multi-node, Multi-Node Ping–Running on Multiple Machines

ping example, A First Example: Pings–Summing Up the Ping Example

server process for, The Ping Server Process–The Ping Server Process

server, implementing, A Distributed Chat Server–Failure and Adding/Removing Nodes

typed channels and, Typed Channels–Merging Channels

distributed servers, implementing, A Distributed Chat Server–Failure and Adding/Removing Nodes, Data Types–Data Types, Sending Messages, Broadcasting–Broadcasting, Distribution–Distribution, Testing the Server, Failure and Adding/Removing Nodes–Failure and Adding/Removing Nodes, Failure and Adding/Removing Nodes–Failure and Adding/Removing Nodes

broadcasting messages, Broadcasting–Broadcasting

data types for, Data Types–Data Types

failures, handling, Failure and Adding/Removing Nodes–Failure and Adding/Removing Nodes

handling distribution, Distribution–Distribution

messages, sending, Sending Messages

nodes, adding/removing, Failure and Adding/Removing Nodes–Failure and Adding/Removing Nodes

testing, Testing the Server

distributed-process framework, Distributed Programming–Exercise: A Distributed Key-Value Store, The Distributed-Process Family of Packages–The Distributed-Process Family of Packages, Distributed Concurrency or Parallelism?, A First Example: Pings–Summing Up the Ping Example, Processes and the Process Monad

packages in, The Distributed-Process Family of Packages–The Distributed-Process Family of Packages

parallelism vs., Distributed Concurrency or Parallelism?

Process monad, Processes and the Process Monad

usage, A First Example: Pings–Summing Up the Ping Example

distributed-process-simplelocalnet package, The main Function

divide-and-conquer algorithms, Example: A Conference Timetable, Limiting the Number of Threads with a Semaphore

defined, Example: A Conference Timetable

depth threshold for, Limiting the Number of Threads with a Semaphore

doesDirectoryExist, How to Achieve Parallelism with Concurrency–How to Achieve Parallelism with Concurrency

duds (sparks), Example: Parallelizing a Sudoku Solver

dupChan operation, MVar as a Building Block: Unbounded Channels

duplicate channels, creating, MVar as a Building Block: Unbounded Channels

dynamic partitioning, Example: Parallelizing a Sudoku Solver

E

effectful code, Terminology: Parallelism and Concurrency

effects, interleaving of, Basic Concurrency: Threads and MVars

efficiency, Thread Creation and MVar Operations–Thread Creation and MVar Operations, Thread Creation and MVar Operations

of concurrency operations, Thread Creation and MVar Operations–Thread Creation and MVar Operations

of context-switch performance, Thread Creation and MVar Operations

elapsed time, Example: Parallelizing a Sudoku Solver

Elt class (Accelerate), Running a Simple Accelerate Computation

empty channels, MVar as a Building Block: Unbounded Channels, MVar as a Building Block: Unbounded Channels

encrypt function, Pipeline Parallelism

enumFromN operation, Creating Arrays Inside Acc

enumFromStepN operation, Creating Arrays Inside Acc

Env data type, Example: A Parallel Type Inferencer

environment, in programming language, Example: A Parallel Type Inferencer

Erlang (programming language), The Philosophy of Distributed Failure

error codes, deadlocking vs., Error Handling with Async

error handling, Overlapping Input/Output, Error Handling with Async, The ParIO monad

and ParIO, The ParIO monad

and propagating exceptions, Error Handling with Async

in concurrent programming, Overlapping Input/Output

ErrorCall, Exceptions in Haskell

Eval computation, Evaluation Strategies

Eval monad, The Eval Monad, rpar, and rseq, The Eval Monad, rpar, and rseq, The Eval Monad, rpar, and rseq, Evaluation Strategies

rpar operation, The Eval Monad, rpar, and rseq

rseq operation, The Eval Monad, rpar, and rseq

Strategy function in, Evaluation Strategies

evalList Strategy, A Strategy for Evaluating a List in Parallel–A Strategy for Evaluating a List in Parallel

evalPair Strategy, Parameterized Strategies

evaluation(s), Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form, Lazy Evaluation and Weak Head Normal Form, The Eval Monad, rpar, and rseq, Deepseq, MVar as a Container for Shared State, Shared Concurrent Data Structures

degrees of, Deepseq

in Haskell, Lazy Evaluation and Weak Head Normal Form

lazy, Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form, MVar as a Container for Shared State, Shared Concurrent Data Structures

sequential, The Eval Monad, rpar, and rseq

event loops, Terminology: Parallelism and Concurrency, A Trivial Server

concurrency vs., Terminology: Parallelism and Concurrency

web server implementations with, A Trivial Server

eventlog file, Event Logging and ThreadScope–Event Logging and ThreadScope

Exception data type, Exceptions in Haskell

exception handlers, Exceptions in Haskell, Catching Asynchronous Exceptions, Catching Asynchronous Exceptions, Catching Asynchronous Exceptions, Avoiding Thread Leakage

and asynchronous exceptions, Catching Asynchronous Exceptions

hidden inside try, Catching Asynchronous Exceptions

higher-level combinators as, Exceptions in Haskell

installing, for Async, Avoiding Thread Leakage

tail-calling of, Catching Asynchronous Exceptions

exception handling, Error Handling with Async–Error Handling with Async, mask and forkIO, Inspecting the Status of a Thread

and forkFinally, mask and forkIO

by forkIO function, Inspecting the Status of a Thread

in asynchronous I/O, Error Handling with Async–Error Handling with Async

Exception type class, Exceptions in Haskell

exceptions, Communication: MVars, Exceptions in Haskell–Exceptions in Haskell, Exceptions in Haskell, Exceptions in Haskell, Exceptions in Haskell, Exceptions in Haskell, Error Handling with Async, Asynchronous Exceptions, Asynchronous Exception Safety, Timeouts Using race, Inspecting the Status of a Thread, Detecting Deadlock

and thread status, Inspecting the Status of a Thread

BlockedIndefinitelyOnMVar, Communication: MVars, Detecting Deadlock

catch function for, Exceptions in Haskell

catching, Exceptions in Haskell, Exceptions in Haskell

in STM, Asynchronous Exception Safety

propagating, with error-handling code, Error Handling with Async

re-throwing, Exceptions in Haskell

ThreadKilled, Asynchronous Exceptions

throwing, Exceptions in Haskell–Exceptions in Haskell

with timeouts, Timeouts Using race

expect function, The Ping Server Process, Typed Channels

extent operation for shapes, Arrays, Shapes, and Indices

F

F representation type (Repa), Example: Image Rotation

fairness, Basic Concurrency: Threads and MVars, Fairness–Fairness, What Can We Not Do with STM?, What Can We Not Do with STM?

in MVar, What Can We Not Do with STM?

in TMVar implementation, What Can We Not Do with STM?

policy, Basic Concurrency: Threads and MVars

FFI (foreign function interface), Concurrency and the Foreign Function Interface, Threads and Foreign Out-Calls–Threads and Foreign Out-Calls, Threads and Foreign In-Calls

foreign in-calls, Threads and Foreign In-Calls

threads and, Threads and Foreign Out-Calls–Threads and Foreign Out-Calls

fib function, Dataflow Parallelism: The Par Monad

FIFO order, What Can We Not Do with STM?

filesystem-searching program (example), Example: Searching for Files, The ParIO monad

fill operation, Creating Arrays Inside Acc

finally function, Exceptions in Haskell, Asynchronous Exceptions

and exceptions, Asynchronous Exceptions

as bracket function, Exceptions in Haskell

find function, How to Achieve Parallelism with Concurrency–How to Achieve Parallelism with Concurrency, Parallel Version, Limiting the Number of Threads with a Semaphore, The ParIO monad

and NBSem, Limiting the Number of Threads with a Semaphore

as recursive, How to Achieve Parallelism with Concurrency–How to Achieve Parallelism with Concurrency

in ParIO monad, The ParIO monad

to create new Async, Parallel Version

findpar, Performance and Scaling, Limiting the Number of Threads with a Semaphore

findseq vs., Performance and Scaling

NBSem vs., Limiting the Number of Threads with a Semaphore

findseq, Performance and Scaling

fixed division, of work, Example: Parallelizing a Sudoku Solver

fizzled sparks, Example: Parallelizing a Sudoku Solver

floating-point addition, Folding and Shape-Polymorphism

Floyd-Warshall algorithm, Example: Shortest Paths in a Graph–Example: Shortest Paths in a Graph, Example: Computing Shortest Paths–Parallelizing the Program, Example: Computing Shortest Paths, Example: Computing Shortest Paths, Example: Shortest Paths–Debugging the CUDA Backend

Accelerate, implementing in, Example: Shortest Paths–Debugging the CUDA Backend

over dense graphs, Example: Computing Shortest Paths

pseudocode definition of, Example: Computing Shortest Paths

Repa, using over dense graphs, Example: Computing Shortest Paths–Parallelizing the Program

fmap operation, Adding a Functor Instance

folding, of concurrently function over a list, Symmetric Concurrency Combinators

foldl function, Example: Shortest Paths in a Graph

foldP, folding in parallel with, Folding and Shape-Polymorphism

folds, Example: Shortest Paths in a Graph, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism

over arrays, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism

parallelized, Example: Shortest Paths in a Graph

foldS function, Folding and Shape-Polymorphism

force function, Example: Parallelizing a Sudoku Solver

foreign calls, Performance and Analysis

foreign in-calls, Threads and Foreign In-Calls

foreign out-calls, Threads and Foreign Out-Calls–Threads and Foreign Out-Calls, Asynchronous Exceptions and Foreign Calls–Asynchronous Exceptions and Foreign Calls

asynchronous exceptions and, Asynchronous Exceptions and Foreign Calls–Asynchronous Exceptions and Foreign Calls

threads and, Threads and Foreign Out-Calls–Threads and Foreign Out-Calls

fork(s), Dataflow Parallelism: The Par Monad, Pipeline Parallelism, Rate-Limiting the Producer, Rate-Limiting the Producer, How to Achieve Parallelism with Concurrency, How to Achieve Parallelism with Concurrency

achieving parallelism with, How to Achieve Parallelism with Concurrency

defined, Pipeline Parallelism

in Par computations, Dataflow Parallelism: The Par Monad

number of, How to Achieve Parallelism with Concurrency

producing lists with, Rate-Limiting the Producer

forkFinally function, mask and forkIO, A Trivial Server

forkIO function, Basic Concurrency: Threads and MVars, mask and forkIO–mask and forkIO, mask and forkIO, Asynchronous Exceptions: Discussion, Data Types, Inspecting the Status of a Thread

defined, Basic Concurrency: Threads and MVars

exception handling by, Inspecting the Status of a Thread

Process monad and, Data Types

variant of, mask and forkIO

forkOS, Threads and Foreign Out-Calls, Threads and Foreign Out-Calls

freeVars function, Example: A Parallel Type Inferencer

fromFunction operation, Operations on Arrays, Example: Computing Shortest Paths

delayed arrays from, Operations on Arrays

fromListUnboxed function, Arrays, Shapes, and Indices, Arrays and Indices

building arrays in Accelerate with, Arrays and Indices

functional language, compiler for, Example: A Parallel Type Inferencer

Functor instances, Adding a Functor Instance–Adding a Functor Instance

fusion (in Repa), Operations on Arrays

G

garbage collector, A Trivial Server, Detecting Deadlock

closing of Handle by, A Trivial Server

heap objects and, Detecting Deadlock

garbage-collected (GCd) sparks, Example: Parallelizing a Sudoku Solver, GC’d Sparks and Speculative Parallelism

generate function, Example: A Conference Timetable, Creating Arrays Inside Acc

in Accelerate, Creating Arrays Inside Acc

in Timetable example, Example: A Conference Timetable

get operation, Dataflow Parallelism: The Par Monad

getDirectoryContents, How to Achieve Parallelism with Concurrency–How to Achieve Parallelism with Concurrency

getMaskingState function, Masking Asynchronous Exceptions

getNumCapabilities, Limiting the Number of Threads with a Semaphore

getSelfNode function, The Master Process

getWindows, Blocking Until Something Changes

GHC Users Guide, Tools and Resources

ghc-events program, displaying raw event streams with, Event Logging and ThreadScope

global locks, Performance

GPUs (graphics processing units), GPU Programming with Accelerate–GPU Programming with Accelerate, GPU Programming with Accelerate, Overview, Running on the GPU–Running on the GPU

Accelerate without, Overview

CPUs vs., GPU Programming with Accelerate

programming with Accelerate, GPU Programming with Accelerate–GPU Programming with Accelerate

running programs on, Running on the GPU–Running on the GPU

granularity, Granularity–Granularity, Example: Shortest Paths in a Graph, Adding Parallelism, Example: A Parallel Type Inferencer, The Par Monad Compared to Strategies, The Par Monad Compared to Strategies, Limiting the Number of Threads with a Semaphore

Eval and finer, The Par Monad Compared to Strategies

in parallelizing maps, Example: Shortest Paths in a Graph

larger, Par and, The Par Monad Compared to Strategies

of K-Means problem, Granularity–Granularity

problems from parallelizing, Example: A Parallel Type Inferencer

problems with, Limiting the Number of Threads with a Semaphore

when adding parallelism, Adding Parallelism

GUI callback, Threads and Foreign In-Calls

GUI libraries, calling foreign functions by, Threads and Foreign Out-Calls

H

Hackage, Introduction, Tools and Resources

documentation on, Tools and Resources

libraries on, Introduction

Handle, A Trivial Server, A Trivial Server, Design One: One Giant Lock

closing of, A Trivial Server

for communication of server and client, A Trivial Server

interleaving messages to, Design One: One Giant Lock

handle function, catching exceptions with, Exceptions in Haskell

handleJust, Timeouts

handleMessage function, Running the Client

Haskell, Lazy Evaluation and Weak Head Normal Form, Exceptions in Haskell, Exceptions in Haskell, A Trivial Server

2010 standard, exceptions in, Exceptions in Haskell

98 standard, exceptions in, Exceptions in Haskell

as lazy language, Lazy Evaluation and Weak Head Normal Form

web server implementations in, A Trivial Server

Haskell Platform, Tools and Resources, Tools and Resources

components of, Tools and Resources

library documentation, Tools and Resources

Hoogle, Tools and Resources

HTTP library, Asynchronous Exceptions

hyperthreaded cores, RTS Options to Tweak

I

I/O, Overlapping Input/Output–Merging

I/O manager thread, A Trivial Server

I/O-bound program, Example: Searching for Files

identity property, The Identity Property–The Identity Property

IL monad, Example: Image Rotation

IList data type, Pipeline Parallelism, Rate-Limiting the Producer

defined, Pipeline Parallelism

long chain in, Rate-Limiting the Producer

image processing, parallel array operations for, Introduction

image rotation, Example: Image Rotation–Example: Image Rotation

immutable data structures, MVar wrappers for, MVar as a Container for Shared State

imperative languages, MVar as a Container for Shared State, Cancellation and Timeouts

and code modifying state, Cancellation and Timeouts

locks in, MVar as a Container for Shared State

implicit masks, Catching Asynchronous Exceptions

inconsistent state, Cancellation and Timeouts, Masking Asynchronous Exceptions

data left in, Masking Asynchronous Exceptions

of data, after cancellation, Cancellation and Timeouts

indexArray operation, Arrays and Indices

indexing, Operations on Arrays, Arrays and Indices, Indexing Arrays

arrays, in Accelerate, Arrays and Indices, Indexing Arrays

delayed arrays, Operations on Arrays

inferBind, Example: A Parallel Type Inferencer

inferTop, Example: A Parallel Type Inferencer

infix application ($ operator), MVar as a Container for Shared State

initLogger function, MVar as a Simple Channel: A Logging Service

INLINE pragmas (Repa), Example: Image Rotation–Summary

insert operation, MVar as a Container for Shared State

interleaving messages, Design One: One Giant Lock

interleaving of effects, Basic Concurrency: Threads and MVars

interpreter (Accelerate), GPU Programming with Accelerate

interruptible operations, Masking Asynchronous Exceptions–Masking Asynchronous Exceptions

interruption, mask and forkIO–mask and forkIO, Asynchronous Exceptions: Discussion

IntMap function, Example: Shortest Paths in a Graph

IO action, What Can We Not Do with STM?, The ParIO monad

in ParIO, The ParIO monad

in STM, What Can We Not Do with STM?

IO monad, Exceptions in Haskell, Cancellation and Timeouts, Asynchronous Exceptions: Discussion, Running Example: Managing Windows, Processes and the Process Monad

cancellation in, Cancellation and Timeouts

catching exceptions in, Exceptions in Haskell

Process monad vs., Processes and the Process Monad

safety of code for, Asynchronous Exceptions: Discussion

STM monad performed in, Running Example: Managing Windows

IOException data type, building and inspecting, Exceptions in Haskell

IORef, Limiting the Number of Threads with a Semaphore, Shared Concurrent Data Structures

for concurrent shared data structures, Shared Concurrent Data Structures

to store semaphore values, Limiting the Number of Threads with a Semaphore

isEmptyTChan, More Operations Are Possible

IVar type, Dataflow Parallelism: The Par Monad, Example: Shortest Paths in a Graph, Limitations of Pipeline Parallelism

for Par computations, Dataflow Parallelism: The Par Monad

returned from runPar, Limitations of Pipeline Parallelism

to produce new graph, Example: Shortest Paths in a Graph

J

join function, Running the Client

K

K-Means problem, Example: The K-Means Problem–Granularity, Parallelizing K-Means–Parallelizing K-Means, Performance and Analysis–Performance and Analysis, Visualizing Spark Activity–Visualizing Spark Activity, Granularity–Granularity

granularity of, Granularity–Granularity

parallelizing, Parallelizing K-Means–Parallelizing K-Means

performance/analysis of, Performance and Analysis–Performance and Analysis

spark activitiy, visualizing, Visualizing Spark Activity–Visualizing Spark Activity

kernels (Accelerate), Example: Shortest Paths

kmeans_seq function, Example: The K-Means Problem, Parallelizing K-Means

kmeans_strat function, Parallelizing K-Means

L

labelThread function, Event Logging and ThreadScope, Event Logging and ThreadScope

large-scale arrays, parallelizing, Data Parallel Programming with Repa

layout of an array, Arrays, Shapes, and Indices

lazy data structures, Dataflow Parallelism: The Par Monad, Adding Parallelism

and Strategies, Dataflow Parallelism: The Par Monad

parallel skeletons vs., Adding Parallelism

lazy evaluation, Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form, Lazy Evaluation and Weak Head Normal Form, MVar as a Container for Shared State, Shared Concurrent Data Structures

and MVar, MVar as a Container for Shared State

defined, Lazy Evaluation and Weak Head Normal Form

with shared data structures, Shared Concurrent Data Structures

lazy streams, parallelizing, Parallelizing Lazy Streams with parBuffer–Parallelizing Lazy Streams with parBuffer

length function, list evaluation with, Lazy Evaluation and Weak Head Normal Form

less defined (term), The Identity Property

let it crash philosophy, The Philosophy of Distributed Failure

libraries, Introduction, Using Different Schedulers, Example: Image Rotation–Summary, Asynchronous Exceptions, Threads and Foreign Out-Calls

DevIL, Example: Image Rotation–Summary

GUI, Threads and Foreign Out-Calls

HTTP, Asynchronous Exceptions

monad-par, Using Different Schedulers

on Hackage, Introduction

lift function, Creating Arrays Inside Acc, Example: A Mandelbrot Set Generator

liftIO, The ParIO monad, Processes and the Process Monad

line buffering mode (server), A Trivial Server

lists, Lazy Evaluation and Weak Head Normal Form, A Strategy for Evaluating a List in Parallel–A Strategy for Evaluating a List in Parallel

length function for, Lazy Evaluation and Weak Head Normal Form

parallel evaluation of, A Strategy for Evaluating a List in Parallel–A Strategy for Evaluating a List in Parallel

Lloyds algorithm, Example: The K-Means Problem, Example: The K-Means Problem

locking, of servers, with MVar, Design One: One Giant Lock

locks, Introduction, MVar as a Container for Shared State

difficulty in programming with, Introduction

in imperative languages, MVar as a Container for Shared State

LogCommand data type, MVar as a Simple Channel: A Logging Service

Logger data type, MVar as a Simple Channel: A Logging Service

logging services, MVar as a Simple Channel: A Logging Service–MVar as a Simple Channel: A Logging Service

logMessage operation, MVar as a Simple Channel: A Logging Service

logStop operation, MVar as a Simple Channel: A Logging Service

lookup function, MVar as a Container for Shared State

lost wakeups, Blocking Until Something Changes

M

main function and program termination, A Simple Example: Reminders

main threads, Detecting Deadlock, Threads and Foreign Out-Calls

as bound threads, Threads and Foreign Out-Calls

deadlocking of, Detecting Deadlock

makeNewClusters function, Example: The K-Means Problem

Mandelbrot set generator, Example: A Mandelbrot Set Generator

manifest arrays, Operations on Arrays

map function, Lazy Evaluation and Weak Head Normal Form, Operations on Arrays–Operations on Arrays, Running a Simple Accelerate Computation

and lazy data structure, Lazy Evaluation and Weak Head Normal Form

in Accelerate, Running a Simple Accelerate Computation

in Repa, Operations on Arrays–Operations on Arrays

mapM function, Overlapping Input/Output

mapWithKey function, Example: Shortest Paths in a Graph

mask function, Masking Asynchronous Exceptions, Catching Asynchronous Exceptions, mask and forkIO–mask and forkIO, Asynchronous Exceptions: Discussion

MaskedInterruptible constructor, Masking Asynchronous Exceptions

MaskedUninterruptible constructor, Masking Asynchronous Exceptions

masking asynchronous exceptions, Masking Asynchronous Exceptions–Masking Asynchronous Exceptions

masking state, mask and forkIO

mask_, Asynchronous Exception Safety for Channels

master function (distributed servers), Distribution

master nodes in distributed programming, Running with Multiple Nodes on One Machine

memory, Bounded Channels, Performance and Scaling, Thread Creation and MVar Operations

and unbounded channels, Bounded Channels

overhead for threads, Thread Creation and MVar Operations

required by parallelisms, Performance and Scaling

mergePortsBiased function, Merging Channels

mergePortsRR function, Merging Channels

merging, Merging–Merging, Merging with STM–Merging with STM, Merging Channels–Merging Channels

typed channels, Merging Channels–Merging Channels

with MVar, Merging–Merging

with STM, Merging with STM–Merging with STM

Message constructor, for LogCommand data type, MVar as a Simple Channel: A Logging Service

mkStaticClosure function, The Master Process–The Master Process

modifyMVar, Masking Asynchronous Exceptions, Masking Asynchronous Exceptions, Asynchronous Exception Safety for Channels, Asynchronous Exceptions: Discussion

built-in safety of, Asynchronous Exceptions: Discussion

implementing, Masking Asynchronous Exceptions

variant of, Asynchronous Exception Safety for Channels

modular programs, Terminology: Parallelism and Concurrency, Parallel Programming Using Threads

concurrency of, Terminology: Parallelism and Concurrency

creating, Parallel Programming Using Threads

monad-par library, schedules and, Using Different Schedulers

MonadIO monad, Processes and the Process Monad

monads, computeP and, Parallelizing the Program–Parallelizing the Program

monitor function, Handling Failure

moveWindow, Running Example: Managing Windows, Running Example: Managing Windows

concurrent call to, Running Example: Managing Windows

implemented with STM, Running Example: Managing Windows

moveWindowSTM, Running Example: Managing Windows

multi-node programming, Multi-Node Ping–Running on Multiple Machines, Running with Multiple Nodes on One Machine–Running with Multiple Nodes on One Machine, Running on Multiple Machines

on multiple machines, Running on Multiple Machines

on one machine, Running with Multiple Nodes on One Machine–Running with Multiple Nodes on One Machine

multicast channels, building, MVar as a Building Block: Unbounded Channels

multiclient servers, main function for, A Trivial Server

multiple cores, How to Achieve Parallelism with Concurrency, Limiting the Number of Threads with a Semaphore

and concurrency, How to Achieve Parallelism with Concurrency

NBSem run on, Limiting the Number of Threads with a Semaphore

multiple writers, for one-place channels, Bounded Channels

multiplication (in Accelerate), Example: A Mandelbrot Set Generator–Example: A Mandelbrot Set Generator

mutable containers, for shared data structures, Shared Concurrent Data Structures

mutable state, shared, Communication: MVars, MVar as a Container for Shared State–MVar as a Container for Shared State

mutual deadlock, Detecting Deadlock

MVar, Communication: MVars–MVar as a Building Block: Unbounded Channels, MVar as a Simple Channel: A Logging Service–MVar as a Simple Channel: A Logging Service, MVar as a Container for Shared State–MVar as a Container for Shared State, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels, Overlapping Input/Output–Overlapping Input/Output, Merging–Merging, Merging, Masking Asynchronous Exceptions, Blocking, Merging with STM, Implementing Channels with STM, An Alternative Channel Implementation–An Alternative Channel Implementation, What Can We Not Do with STM?, Limiting the Number of Threads with a Semaphore

and merging, Merging

asynchronous I/O and, Overlapping Input/Output–Overlapping Input/Output

creating unbounded channels with, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels

implemented with STM, Blocking

implementing channels with, MVar as a Simple Channel: A Logging Service–MVar as a Simple Channel: A Logging Service

implementing NBSem with, Limiting the Number of Threads with a Semaphore

merging asynchronous I/O with, Merging–Merging

merging events into single, Merging with STM

performance compared with STM, What Can We Not Do with STM?

protocol for operations with, Masking Asynchronous Exceptions

shared state container, MVar as a Container for Shared State–MVar as a Container for Shared State

STM vs., Implementing Channels with STM, An Alternative Channel Implementation–An Alternative Channel Implementation

N

N command, Extending the Simple Server with State, Design Four: Use STM

NBSem, Limiting the Number of Threads with a Semaphore

nested arrays, Accelerate and, Arrays and Indices

nested timeouts, Timeouts

nesting calls, The Par Monad Compared to Strategies, Masking Asynchronous Exceptions, Parallel Version

of withAsync, Parallel Version

to runPar, The Par Monad Compared to Strategies

network-transport-tcp package, The Distributed-Process Family of Packages

newClient function, Client Data

newEmptyMVar operation, Communication: MVars

newEmptyTMVarIO, Async Revisited

newfactor function, The Implementation

newUnique, Timeouts

NFData, Deepseq

in Deepseq, Deepseq

NodeId, The Master Process

nonblocking semaphores, Limiting the Number of Threads with a Semaphore

normal form, Lazy Evaluation and Weak Head Normal Form, Deepseq

defined, Lazy Evaluation and Weak Head Normal Form

in Deepseq, Deepseq

Notice constructor, Client Data

NVidia, GPU Programming with Accelerate

O

one-place channels, Communication: MVars–Communication: MVars, Bounded Channels

bounded channels vs., Bounded Channels

MVar as, Communication: MVars–Communication: MVars

onException function, Exceptions in Haskell

OpenCL language, GPU Programming with Accelerate

OpenGL, Threads and Foreign Out-Calls

operations, on Arrays, Operations on Arrays–Operations on Arrays

optimization, Tuning Concurrent (and Parallel) Programs

optimization options, Example: Computing Shortest Paths

ordering, Running Example: Managing Windows, Running Example: Managing Windows

detecting violations of, Running Example: Managing Windows

imposed on MVars, Running Example: Managing Windows

orElse function, Symmetric Concurrency Combinators, The Implementation

orElse operation, Merging with STM

overflowed sparks, Example: Parallelizing a Sudoku Solver

overhead, Example: Shortest Paths in a Graph, Limiting the Number of Threads with a Semaphore, Thread Creation and MVar Operations

and runPar function, Example: Shortest Paths in a Graph

for threads, Thread Creation and MVar Operations

of atomicModifyIORef, Limiting the Number of Threads with a Semaphore

P

packages, installing, Sample Code

Par monad, Example: Parallelizing a Sudoku Solver, Dataflow Parallelism: The Par Monad–Adding Parallelism, Example: Shortest Paths in a Graph–Example: Shortest Paths in a Graph, Pipeline Parallelism–Limitations of Pipeline Parallelism, Example: A Conference Timetable–Adding Parallelism, Using Different Schedulers, Using Different Schedulers, The Par Monad Compared to Strategies–The Par Monad Compared to Strategies, Data Parallel Programming with Repa, The ParIO monad

and parallelizing large-scale arrays, Data Parallel Programming with Repa

constraint satisfaction problems, solving with, Example: A Conference Timetable–Adding Parallelism

Floyd-Warshall algorithm, parallelizing, Example: Shortest Paths in a Graph–Example: Shortest Paths in a Graph

force as default in, Example: Parallelizing a Sudoku Solver

implemented as library, Using Different Schedulers

ParIO vs., The ParIO monad

pipleline paralellism and, Pipeline Parallelism–Limitations of Pipeline Parallelism

schedulers available in, Using Different Schedulers

Strategies vs., The Par Monad Compared to Strategies–The Par Monad Compared to Strategies

parallel programs, Terminology: Parallelism and Concurrency, Tuning Concurrent (and Parallel) Programs–RTS Options to Tweak

defined, Terminology: Parallelism and Concurrency

tuning, Tuning Concurrent (and Parallel) Programs–RTS Options to Tweak

parallelism, Terminology: Parallelism and Concurrency–Terminology: Parallelism and Concurrency, Basic Parallelism: The Eval Monad–Deepseq, Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form, Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form, The Eval Monad, rpar, and rseq, The Eval Monad, rpar, and rseq, The Eval Monad, rpar, and rseq, Deepseq–Deepseq, Example: The K-Means Problem–Granularity, GC’d Sparks and Speculative Parallelism–GC’d Sparks and Speculative Parallelism, GC’d Sparks and Speculative Parallelism–GC’d Sparks and Speculative Parallelism, Parallel Programming Using Threads–The ParIO monad, How to Achieve Parallelism with Concurrency–How to Achieve Parallelism with Concurrency, Sequential Version–Sequential Version, Parallel Version–Parallel Version, Performance and Scaling–Performance and Scaling, Performance and Scaling–Performance and Scaling, Limiting the Number of Threads with a Semaphore–Limiting the Number of Threads with a Semaphore, The ParIO monad–The ParIO monad, Distributed Concurrency or Parallelism?

achieving with concurrency, How to Achieve Parallelism with Concurrency–How to Achieve Parallelism with Concurrency

Deepseq, Deepseq–Deepseq

distributed-process framework vs., Distributed Concurrency or Parallelism?

Eval monad, The Eval Monad, rpar, and rseq

garbage collected sparks, GC’d Sparks and Speculative Parallelism–GC’d Sparks and Speculative Parallelism

implementing, Parallel Version–Parallel Version

K-Means example, Example: The K-Means Problem–Granularity

lazy evaluation, Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form

ParIO monad and, The ParIO monad–The ParIO monad

performance, Performance and Scaling–Performance and Scaling

rpar operation, The Eval Monad, rpar, and rseq

rseq operation, The Eval Monad, rpar, and rseq

scaling, Performance and Scaling–Performance and Scaling

sequential vs., Sequential Version–Sequential Version

speculative, GC’d Sparks and Speculative Parallelism–GC’d Sparks and Speculative Parallelism

threads, limiting number of, Limiting the Number of Threads with a Semaphore–Limiting the Number of Threads with a Semaphore

weak head normal form, Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form

parameterized strategies, Parameterized Strategies–Parameterized Strategies

parBuffer, Parallelizing Lazy Streams with parBuffer–Parallelizing Lazy Streams with parBuffer

parent threads, Symmetric Concurrency Combinators

ParIO monad, Limitations of Pipeline Parallelism, The ParIO monad–The ParIO monad

parList function, A Strategy for Evaluating a List in Parallel–A Strategy for Evaluating a List in Parallel, A Strategy for Evaluating a List in Parallel, Chunking Strategies–Chunking Strategies

as parameterized Strategy, A Strategy for Evaluating a List in Parallel

defining, A Strategy for Evaluating a List in Parallel–A Strategy for Evaluating a List in Parallel

with chunking, Chunking Strategies–Chunking Strategies

parList Strategy, A Strategy for Evaluating a List in Parallel, Parallelizing Lazy Streams with parBuffer–Parallelizing Lazy Streams with parBuffer

parallelizing lazy streams with, Parallelizing Lazy Streams with parBuffer–Parallelizing Lazy Streams with parBuffer

parMap function, Example: Parallelizing a Sudoku Solver–Example: Parallelizing a Sudoku Solver, A Strategy for Evaluating a List in Parallel, Adding Parallelism

as parallel skeleton, Adding Parallelism

expression of, with Strategies, A Strategy for Evaluating a List in Parallel

parMapM function, Dataflow Parallelism: The Par Monad

parPair Strategy, Parameterized Strategies, Parameterized Strategies, Parameterized Strategies

evalPair Strategy vs., Parameterized Strategies

evaluating components of a pair with, Parameterized Strategies

parameterized Strategy vs., Parameterized Strategies

parsearch function, Adding Parallelism

parSteps_strat function, Parallelizing K-Means

partitioning, Example: Parallelizing a Sudoku Solver, Example: Parallelizing a Sudoku Solver

dynamic, Example: Parallelizing a Sudoku Solver

static, Example: Parallelizing a Sudoku Solver

peer discovery, The Distributed-Process Family of Packages

performance monitoring, program, Thread Creation and MVar Operations–Thread Creation and MVar Operations

phone book example, MVar as a Container for Shared State–MVar as a Container for Shared State

ping example, A First Example: Pings–Summing Up the Ping Example

pipeline operator, Example: Shortest Paths

pipelining, Terminology: Parallelism and Concurrency

pipleline paralellism, Pipeline Parallelism–Limitations of Pipeline Parallelism, Rate-Limiting the Producer–Rate-Limiting the Producer, Limitations of Pipeline Parallelism

limitations of, Limitations of Pipeline Parallelism

rate-limiting, Rate-Limiting the Producer–Rate-Limiting the Producer

Point (type), Example: The K-Means Problem, Example: The K-Means Problem

PointSum (type), Example: The K-Means Problem, Example: The K-Means Problem, Example: The K-Means Problem

Cluster from, Example: The K-Means Problem

constructing, Example: The K-Means Problem

in Lloyds algorithm, Example: The K-Means Problem

PolyType, Example: A Parallel Type Inferencer

POSIX, Threads and Foreign Out-Calls

Prelude functions (in Repa), Data Parallel Programming with Repa

Process API (Control.Distributed), A First Example: Pings

Process monad, Processes and the Process Monad, Data Types

ProcessID, Processes and the Process Monad

ProcessMonitorNotification message, Handling Failure

program analysis problems, parallelism for, Example: A Parallel Type Inferencer

proxies, for forkIO threads, Data Types

put function, Dataflow Parallelism: The Par Monad, Dataflow Parallelism: The Par Monad

strictness of, Dataflow Parallelism: The Par Monad

putMVar operation, Communication: MVars, Communication: MVars, Asynchronous Exception Safety for Channels, Blocking, What Can We Not Do with STM?

and fairness, What Can We Not Do with STM?

and mutable states, Communication: MVars

implementing, Blocking

interruptibility of, Asynchronous Exception Safety for Channels

putStrLn calls, Event Logging and ThreadScope, Event Logging and ThreadScope

and stdout Handle, Event Logging and ThreadScope

debugging with, Event Logging and ThreadScope

put_ operation, Dataflow Parallelism: The Par Monad

R

r0 Strategy, Parameterized Strategies

race function, Symmetric Concurrency Combinators, Timeouts Using race–Timeouts Using race, Recap

for chat server, Recap

for trees of threads, Symmetric Concurrency Combinators

timeouts with, Timeouts Using race–Timeouts Using race

rank operation, Arrays, Shapes, and Indices

rdeepseq, Parameterized Strategies–Parameterized Strategies

read function, The Ping Server Process

read function (POSIX), Threads and Foreign Out-Calls

read pointer (channel), MVar as a Building Block: Unbounded Channels

readChan operations, MVar as a Building Block: Unbounded Channels, Asynchronous Exception Safety for Channels

concurrent, MVar as a Building Block: Unbounded Channels

definition of, Asynchronous Exception Safety for Channels

readEitherTChan, Composition of Blocking Operations

readImage operation, Example: Image Rotation

readMVar, Asynchronous Exception Safety for Channels

readName function, Setting Up a New Client

receive function, The Implementation

receiveChannel (typed channels), Typed Channels

ReceivePort (typed channels), Typed Channels, Typed Channels

record wildcard pattern, Client Data

RecordWildCards extension, Client Data

releaseNBSem, Limiting the Number of Threads with a Semaphore

reminders, timed, A Simple Example: Reminders

remotable, declaring functions as, The Master Process

removeClient function, Setting Up a New Client

render function, Blocking Until Something Changes

rendering thread, Running Example: Managing Windows, Blocking Until Something Changes

blocked by window, Running Example: Managing Windows

implementing, Blocking Until Something Changes

Repa, Data Parallel Programming with Repa–Summary, Arrays, Shapes, and Indices–Operations on Arrays, Arrays, Shapes, and Indices–Arrays, Shapes, and Indices, Arrays, Shapes, and Indices–Arrays, Shapes, and Indices, Example: Computing Shortest Paths–Parallelizing the Program, Parallelizing the Program–Parallelizing the Program, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism, Example: Image Rotation–Summary, Example: Image Rotation–Summary, Running on the GPU

arrays, Arrays, Shapes, and Indices–Operations on Arrays

DevIL library and, Example: Image Rotation–Summary

Floyd-Warshall algorithm and, Example: Computing Shortest Paths–Parallelizing the Program

folding arrays in, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism

image manipulation in, Example: Image Rotation–Summary

indices, Arrays, Shapes, and Indices–Arrays, Shapes, and Indices

parallelizing programs with, Parallelizing the Program–Parallelizing the Program

running programs on GPU vs., Running on the GPU

shape-polymorphism of arrays, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism

shapes, Arrays, Shapes, and Indices–Arrays, Shapes, and Indices

representation type (of Repa arrays), Arrays, Shapes, and Indices, Arrays and Indices

and Accelerate, Arrays and Indices

defined, Arrays, Shapes, and Indices

restore function, Masking Asynchronous Exceptions

retry operation, Blocking, Blocking, Blocking Until Something Changes, Implementing Channels with STM, Performance

defined, Blocking

in readTChan, Implementing Channels with STM

performance of, Performance

to block on arbitrary conditions, Blocking Until Something Changes

rnf (Deepseq), Deepseq

roll back, Running Example: Managing Windows

roots, Detecting Deadlock

rotate function, Example: Image Rotation–Example: Image Rotation

rotating points, about the origin, Example: Image Rotation

round-robin scheduler, Fairness

rpar operation, The Eval Monad, rpar, and rseq, Evaluation Strategies, Parameterized Strategies–Parameterized Strategies, The Par Monad Compared to Strategies

and speculative parallelism, The Par Monad Compared to Strategies

and Strategy, Evaluation Strategies

as a Strategy, Parameterized Strategies–Parameterized Strategies

rparWith Strategy, Parameterized Strategies, GC’d Sparks and Speculative Parallelism

rseq operation (Eval monad), The Eval Monad, rpar, and rseq, Evaluation Strategies

and Strategy, Evaluation Strategies

runClient function, Running the Client

runEval operation, The Eval Monad, rpar, and rseq, The Par Monad Compared to Strategies

runIL function, Example: Image Rotation

runPar function, Dataflow Parallelism: The Par Monad, Example: Shortest Paths in a Graph, Limitations of Pipeline Parallelism, The Par Monad Compared to Strategies, The ParIO monad

and lazy streams, Limitations of Pipeline Parallelism

and ParIO, The ParIO monad

avoiding multiple calls of, The Par Monad Compared to Strategies

overhead of, Example: Shortest Paths in a Graph

returning IVar from, Dataflow Parallelism: The Par Monad

runtime system, options for tuning, RTS Options to Tweak–RTS Options to Tweak

S

scalar arrays, Folding and Shape-Polymorphism, Scalar Arrays

schedulers (Par monad), Using Different Schedulers

search functions, Adding Parallelism

search pattern, Example: A Conference Timetable, Adding Parallelism

as higher-order function, Adding Parallelism

tree-shaped, Example: A Conference Timetable

search skeleton, Adding Parallelism

selects function, Example: A Conference Timetable

semaphores, Limiting the Number of Threads with a Semaphore–Limiting the Number of Threads with a Semaphore, Limiting the Number of Threads with a Semaphore, Limiting the Number of Threads with a Semaphore

limiting number of threads with, Limiting the Number of Threads with a Semaphore–Limiting the Number of Threads with a Semaphore

nonblocking, Limiting the Number of Threads with a Semaphore

storing semaphore values, Limiting the Number of Threads with a Semaphore

sendChannel (typed channels), Typed Channels

SendPort (typed channels), Typed Channels

seq function, Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form, Lazy Evaluation and Weak Head Normal Form

forcing evaluation with, Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form

weak head normal form evaluation in, Lazy Evaluation and Weak Head Normal Form

sequential algorithms, Limiting the Number of Threads with a Semaphore

sequential evaluation, The Eval Monad, rpar, and rseq

Serializable, Typed Channels

serializing data, Defining a Message Type–Defining a Message Type

server applications, Cancellation and Timeouts, Concurrent Network Servers–Recap, A Trivial Server–A Trivial Server, Extending the Simple Server with State–The Implementation, A Chat Server–Recap, Architecture–Architecture, Client Data–Running the Client

adding state to, Extending the Simple Server with State–The Implementation

and thread interruption, Cancellation and Timeouts

architecture of, Architecture–Architecture

chat server, implementing, A Chat Server–Recap

client side, Client Data–Running the Client

implementing, A Trivial Server–A Trivial Server

server state, implementing, Extending the Simple Server with State–The Implementation, Design One: One Giant Lock–Design One: One Giant Lock, Design Two: One Chan Per Server Thread–Design Two: One Chan Per Server Thread, Design Three: Use a Broadcast Chan, Design Four: Use STM–The Implementation, The Server

broadcast channels, Design Three: Use a Broadcast Chan

creating new instance, The Server

one chan per thread, Design Two: One Chan Per Server Thread–Design Two: One Chan Per Server Thread

with MVar, Design One: One Giant Lock–Design One: One Giant Lock

with STM, Design Four: Use STM–The Implementation

server thread, Running the Client

setNumCapabilities, Limiting the Number of Threads with a Semaphore

Shape class, Arrays, Shapes, and Indices, Running a Simple Accelerate Computation

shape-polymorphism of arrays, Folding and Shape-Polymorphism–Folding and Shape-Polymorphism

shared mutable data structures, Communication: MVars, MVar as a Container for Shared State–MVar as a Container for Shared State, Shared Concurrent Data Structures–Shared Concurrent Data Structures

concurrent, Shared Concurrent Data Structures–Shared Concurrent Data Structures

containers for, Communication: MVars, MVar as a Container for Shared State–MVar as a Container for Shared State

shared state, MVar as container for, MVar as a Container for Shared State–MVar as a Container for Shared State

Shortest Paths in a Graph (example), Example: Computing Shortest Paths, Example: Computing Shortest Paths, Example: Shortest Paths

in Accelerate, Example: Shortest Paths

in Repa, Example: Computing Shortest Paths

shortestPath, Example: Shortest Paths in a Graph

Show, as exception, Exceptions in Haskell

SIMD divergence, Example: A Mandelbrot Set Generator

simplelocalnet backend, initializing, Failure and Adding/Removing Nodes

single wake up property, Fairness

single wake-up property (threads), Fairness

size operation, for shapes, Arrays, Shapes, and Indices

skeleton, Adding Parallelism, The Par Monad Compared to Strategies

to parallelize code, Adding Parallelism

with strategies and parallelism, The Par Monad Compared to Strategies

slave nodes in distributed programming, Running with Multiple Nodes on One Machine

SomeException data type, catching, Exceptions in Haskell

spark activitiy, visualizing, Visualizing Spark Activity–Visualizing Spark Activity

spark pool, GC’d Sparks and Speculative Parallelism

sparks, Example: Parallelizing a Sudoku Solver, GC’d Sparks and Speculative Parallelism–GC’d Sparks and Speculative Parallelism, The Par Monad Compared to Strategies

defined, Example: Parallelizing a Sudoku Solver

garbage-collected, GC’d Sparks and Speculative Parallelism–GC’d Sparks and Speculative Parallelism

in ThreadScope, The Par Monad Compared to Strategies

sparse graph, algorithms run over, Example: Shortest Paths in a Graph

spawn function, Dataflow Parallelism: The Par Monad, The Distributed-Process Family of Packages, The Master Process

in distributed programming, The Distributed-Process Family of Packages, The Master Process

in Par monad, Dataflow Parallelism: The Par Monad

speculative parallelism, GC’d Sparks and Speculative Parallelism, The Par Monad Compared to Strategies

speedups, Example: Parallelizing a Sudoku Solver, Performance and Analysis–Performance and Analysis, Granularity–Granularity, Pipeline Parallelism, Example: A Parallel Type Inferencer, Performance and Scaling, Limiting the Number of Threads with a Semaphore

and number of work items, Granularity–Granularity

calculating, Example: Parallelizing a Sudoku Solver

for parallel type inferencer, Example: A Parallel Type Inferencer

for parallelization of K-Means, Performance and Analysis–Performance and Analysis

in NBSem, Limiting the Number of Threads with a Semaphore

in parallel version, Performance and Scaling

in pipeline, Pipeline Parallelism

:sprint command, Lazy Evaluation and Weak Head Normal Form, Lazy Evaluation and Weak Head Normal Form

sqDistance operation, Example: The K-Means Problem

ST monad, Parallel Programming Using Threads

stack overflow, Asynchronous Exceptions: Discussion

stack size, tuning, Thread Creation and MVar Operations

static partitioning, Example: Parallelizing a Sudoku Solver

stdout Handle, Event Logging and ThreadScope

stencil convolutions, Summary

step function, Example: The K-Means Problem, Parallelizing K-Means, Example: Shortest Paths

in Accelerate, Example: Shortest Paths

in K-Means problem, Example: The K-Means Problem

parallelizing, Parallelizing K-Means

STM (Software Transactional Memory), Software Transactional Memory, Software Transactional Memory, Blocking, Blocking, Merging with STM–Merging with STM, Implementing Channels with STM–Asynchronous Exception Safety, An Alternative Channel Implementation–An Alternative Channel Implementation, Bounded Channels–Bounded Channels, What Can We Not Do with STM?–What Can We Not Do with STM?, Performance–Performance, Design Four: Use STM–The Implementation, Recap, Limiting the Number of Threads with a Semaphore

and high contention, Limiting the Number of Threads with a Semaphore

blocking, Blocking

bounded channels, Bounded Channels–Bounded Channels

channels, implementing with, Implementing Channels with STM–Asynchronous Exception Safety

defined, Software Transactional Memory

for chat server, Recap

limitations of, What Can We Not Do with STM?–What Can We Not Do with STM?

merging, handling with, Merging with STM–Merging with STM

MVar vs., An Alternative Channel Implementation–An Alternative Channel Implementation

performance of, Performance–Performance

retry operation, Blocking

server state, implementing with, Design Four: Use STM–The Implementation

Stop constructor, for LogCommand data type, MVar as a Simple Channel: A Logging Service

Strategy, Evaluation Strategies–The Identity Property, Parameterized Strategies–Parameterized Strategies, A Strategy for Evaluating a List in Parallel–A Strategy for Evaluating a List in Parallel, Parallelizing Lazy Streams with parBuffer–Parallelizing Lazy Streams with parBuffer, The Identity Property–The Identity Property

evaluating lists in parallel, A Strategy for Evaluating a List in Parallel–A Strategy for Evaluating a List in Parallel

identity property, The Identity Property–The Identity Property

parameterized, Parameterized Strategies–Parameterized Strategies

parBuffer, parallelizing lazy streams with, Parallelizing Lazy Streams with parBuffer–Parallelizing Lazy Streams with parBuffer

Strategy(-ies), Dataflow Parallelism: The Par Monad, The Par Monad Compared to Strategies–The Par Monad Compared to Strategies, The Par Monad Compared to Strategies, Data Parallel Programming with Repa

and lazy data structures, Dataflow Parallelism: The Par Monad, The Par Monad Compared to Strategies

and parallelizing large-scale arrays, Data Parallel Programming with Repa

Par monad vs., The Par Monad Compared to Strategies–The Par Monad Compared to Strategies

Stream, Pipeline Parallelism

Stream data type, MVar as a Building Block: Unbounded Channels

stream elements, Pipeline Parallelism

streamFold, Pipeline Parallelism, Pipeline Parallelism

strictness annotations (in Repa), Example: Image Rotation–Summary

String type, Sequential Version

String, backslash character in, Example: A Parallel Type Inferencer

sum function, Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form

sum, of complex numbers, Example: A Mandelbrot Set Generator

sumAllS function, Folding and Shape-Polymorphism

super-linear performance, Performance and Scaling

swap function, Lazy Evaluation and Weak Head Normal Form

symmetric concurrency combinators, Symmetric Concurrency Combinators–Timeouts Using race

synchronous channel, What Can We Not Do with STM?

synchronous exceptions, Asynchronous Exceptions

T

tail-calling of exception handlers, Catching Asynchronous Exceptions

tail-recursive strategies, GC’d Sparks and Speculative Parallelism–GC’d Sparks and Speculative Parallelism

takeEitherTMVar, Composition of Blocking Operations

takeMVar operation, Communication: MVars, Communication: MVars, Masking Asynchronous Exceptions, Detecting Deadlock

and mutable states, Communication: MVars

deadlock with, Detecting Deadlock

masking exceptions during, Masking Asynchronous Exceptions

takeTMVar operation, Blocking

TChan, Implementing Channels with STM, Asynchronous Exception Safety, Architecture

and asynchronous exceptions, Asynchronous Exception Safety

for chat server, Architecture

implementing, Implementing Channels with STM

Tell constructor, Client Data

terminate function, The Master Process

termination of programs, A Simple Example: Reminders

the operation, in Accelerate, Scalar Arrays

thread death, Higher-Level Concurrency Abstractions, Avoiding Thread Leakage

automatic cancelling of Async with, Avoiding Thread Leakage

trees of threads and, Higher-Level Concurrency Abstractions

thread number, Event Logging and ThreadScope

thread-local state, APIs with, Threads and Foreign Out-Calls

threadDelay function, A Simple Example: Reminders

ThreadId, Asynchronous Exceptions

threading, A Simple Example: Reminders–A Simple Example: Reminders, Communication: MVars–MVar as a Building Block: Unbounded Channels, MVar as a Container for Shared State–MVar as a Container for Shared State, Fairness–Fairness, Fairness–Fairness, Merging–Merging, Cancellation and Timeouts–Asynchronous Exceptions: Discussion, Merging with STM–Merging with STM, Avoiding Thread Leakage–Avoiding Thread Leakage, Inspecting the Status of a Thread–Inspecting the Status of a Thread, Detecting Deadlock–Detecting Deadlock, Concurrency and the Foreign Function Interface

asynchronous exceptions and, Cancellation and Timeouts–Asynchronous Exceptions: Discussion

avoiding leakage, Avoiding Thread Leakage–Avoiding Thread Leakage

CPU usage and, Fairness–Fairness

detecting deadlock, Detecting Deadlock–Detecting Deadlock

fairness of, Fairness–Fairness

inspecting thread status, Inspecting the Status of a Thread–Inspecting the Status of a Thread

merging, Merging–Merging, Merging with STM–Merging with STM

models for, in C, Concurrency and the Foreign Function Interface

MVars and, Communication: MVars–MVar as a Building Block: Unbounded Channels

shared state, MVar as a Container for Shared State–MVar as a Container for Shared State

ThreadKilled exception, Asynchronous Exceptions

threads, Introduction, Introduction, A Simple Example: Reminders, Communication: MVars–Communication: MVars, MVar as a Container for Shared State, Fairness, Cancellation and Timeouts–Asynchronous Exceptions: Discussion, Cancellation and Timeouts, Asynchronous Exceptions, Timeouts, Running Example: Managing Windows, Blocking Until Something Changes, What Can We Not Do with STM?, What Can We Not Do with STM?, Higher-Level Concurrency Abstractions, Symmetric Concurrency Combinators, Symmetric Concurrency Combinators, A Trivial Server, Limiting the Number of Threads with a Semaphore–Limiting the Number of Threads with a Semaphore, Limiting the Number of Threads with a Semaphore, Event Logging and ThreadScope, Detecting Deadlock, Detecting Deadlock, Thread Creation and MVar Operations–Thread Creation and MVar Operations, Thread Creation and MVar Operations, Threads and Foreign Out-Calls–Threads and Foreign Out-Calls, Threads and Foreign Out-Calls–Threads and Foreign Out-Calls, Threads and Foreign Out-Calls, Threads and Foreign In-Calls

additional, used by program, Limiting the Number of Threads with a Semaphore

and timeout exceptions, Timeouts

blocked on each other, Running Example: Managing Windows

blocked, in STM, What Can We Not Do with STM?

bound, Threads and Foreign Out-Calls

cancelling, Asynchronous Exceptions

child, Symmetric Concurrency Combinators, Detecting Deadlock

communication of, Communication: MVars–Communication: MVars

creating, A Simple Example: Reminders, Thread Creation and MVar Operations–Thread Creation and MVar Operations

deadlocking of, Detecting Deadlock

difficulty programming with, Introduction

FFI and, Threads and Foreign Out-Calls–Threads and Foreign Out-Calls

for concurrent web servers, Introduction

foreign in-calls and, Threads and Foreign In-Calls

foreign out-calls and, Threads and Foreign Out-Calls–Threads and Foreign Out-Calls

identifying, Event Logging and ThreadScope

implementing signals between, Blocking Until Something Changes

interrupting, Cancellation and Timeouts–Asynchronous Exceptions: Discussion

lightweight, A Trivial Server

limiting number of, Limiting the Number of Threads with a Semaphore–Limiting the Number of Threads with a Semaphore

locks for, MVar as a Container for Shared State

memory overhead for, Thread Creation and MVar Operations

multi-way communciation between, What Can We Not Do with STM?

trees of, Higher-Level Concurrency Abstractions, Symmetric Concurrency Combinators

unresponsive, Cancellation and Timeouts

wake up property of, Fairness

threads of control, Terminology: Parallelism and Concurrency

ThreadScope (tool), Tools and Resources, Example: Parallelizing a Sudoku Solver–Example: Parallelizing a Sudoku Solver, Performance and Analysis, Visualizing Spark Activity–Visualizing Spark Activity, The Par Monad Compared to Strategies, Event Logging and ThreadScope–Event Logging and ThreadScope, Event Logging and ThreadScope

and Eval vs. Par monads, The Par Monad Compared to Strategies

installing, Tools and Resources

profiling programs with, Example: Parallelizing a Sudoku Solver–Example: Parallelizing a Sudoku Solver

showing detailed events in, Performance and Analysis

thread number in, Event Logging and ThreadScope

visualizing sparks with, Visualizing Spark Activity–Visualizing Spark Activity

threadStatus function, Inspecting the Status of a Thread–Inspecting the Status of a Thread

throw function, Exceptions in Haskell

throwIO function, Exceptions in Haskell

throwSTM operation, Asynchronous Exception Safety

throwTo, Asynchronous Exceptions, Timeouts

and asynchronous exceptions, Timeouts

and synchronous exceptions, Asynchronous Exceptions

thunk(s), Lazy Evaluation and Weak Head Normal Form, Lazy Evaluation and Weak Head Normal Form, Lazy Evaluation and Weak Head Normal Form, Lazy Evaluation and Weak Head Normal Form, Lazy Evaluation and Weak Head Normal Form

and defined expressions, Lazy Evaluation and Weak Head Normal Form

creation of, by map function, Lazy Evaluation and Weak Head Normal Form

defined, Lazy Evaluation and Weak Head Normal Form

evaluating thunks that refer to other thunks, Lazy Evaluation and Weak Head Normal Form

unevaluated, Lazy Evaluation and Weak Head Normal Form

time, wall-clock and elapsed, Example: Parallelizing a Sudoku Solver

timed reminders, creation of threads in a program with, A Simple Example: Reminders

timeDownload function, Overlapping Input/Output

timeit function, Overlapping Input/Output

timeouts, Timeouts–Timeouts, Timeouts, Timeouts, Timeouts, Timeouts Using race–Timeouts Using race

behavior of, Timeouts

implementation of, Timeouts

nesting, Timeouts

with race operation, Timeouts Using race–Timeouts Using race

TimeTable, Example: A Conference Timetable

TList type, Implementing Channels with STM

TMVar data type, Blocking–Blocking, What Can We Not Do with STM?, Adding a Functor Instance

fairness of, What Can We Not Do with STM?

STM computation vs., Adding a Functor Instance

toIndex function, Arrays, Shapes, and Indices

TopEnv, Example: A Parallel Type Inferencer

TQueue, An Alternative Channel Implementation, Bounded Channels

Chan vs., An Alternative Channel Implementation

to build bounded channels, Bounded Channels

Trace scheduler (monad-par library), Using Different Schedulers

traceEventIO function, Event Logging and ThreadScope

transaction, rolled back, Running Example: Managing Windows

transactional variable, Running Example: Managing Windows

transport layer packages, The Distributed-Process Family of Packages

Traversable class, Example: Shortest Paths in a Graph

traverseWithKey function, Example: Shortest Paths in a Graph

tree-shaped computations, Limiting the Number of Threads with a Semaphore

trees of threads, Higher-Level Concurrency Abstractions, Symmetric Concurrency Combinators

try function, Exceptions in Haskell, Error Handling with Async

catching exceptions with, Exceptions in Haskell

error handling with, Error Handling with Async

tryAquireNBSem, Limiting the Number of Threads with a Semaphore

tuning, Tuning Concurrent (and Parallel) Programs–RTS Options to Tweak, Thread Creation and MVar Operations–Thread Creation and MVar Operations, Thread Creation and MVar Operations–Thread Creation and MVar Operations, Shared Concurrent Data Structures–Shared Concurrent Data Structures, RTS Options to Tweak–RTS Options to Tweak

data structures, shared, Shared Concurrent Data Structures–Shared Concurrent Data Structures

MVar operations, Thread Creation and MVar Operations–Thread Creation and MVar Operations

RTS options for, RTS Options to Tweak–RTS Options to Tweak

thread creation, Thread Creation and MVar Operations–Thread Creation and MVar Operations

tuples, arrays of, Arrays and Indices

TVar, Running Example: Managing Windows, Performance, Performance, Shared Concurrent Data Structures

defined, Running Example: Managing Windows

for concurrent shared data structures, Shared Concurrent Data Structures

locked during commit, Performance

unbounded number of, Performance

type inference engines, parallelizing, Example: A Parallel Type Inferencer–Example: A Parallel Type Inferencer

Typeable, Exceptions in Haskell, Exceptions in Haskell, Defining a Message Type

as exception, Exceptions in Haskell

enabling automatic derivation for, Exceptions in Haskell

message types as, Defining a Message Type

typed channels, Typed Channels–Merging Channels, Merging Channels–Merging Channels, Handling Failure

merging, Merging Channels–Merging Channels

untyped channels vs., Handling Failure

U

unbounded channels, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels, Bounded Channels

bounded channels vs., Bounded Channels

constructing, MVar as a Building Block: Unbounded Channels–MVar as a Building Block: Unbounded Channels

Unbox type class, Arrays, Shapes, and Indices

unboxed arrays, computeS function and, Operations on Arrays

unevaluated computations, Lazy Evaluation and Weak Head Normal Form

unGetChan operation, MVar as a Building Block: Unbounded Channels, More Operations Are Possible

Unicode conversion, Sequential Version

uninterruptibleMask, Masking Asynchronous Exceptions

unit operation, in Accelerate, Scalar Arrays

Unlift class, Creating Arrays Inside Acc

unlift function, Creating Arrays Inside Acc, Example: A Mandelbrot Set Generator

Unmasked constructor, Masking Asynchronous Exceptions

unresponsive threads, deadlocks and, Cancellation and Timeouts

update function, Example: Shortest Paths in a Graph

use function, in Accelerate, Running a Simple Accelerate Computation

user interface, multiple threads with, Cancellation and Timeouts

user interrupt, asynchronous exceptions and, Asynchronous Exceptions: Discussion

using function, Evaluation Strategies, GC’d Sparks and Speculative Parallelism

and garbage-collected sparks, GC’d Sparks and Speculative Parallelism

W

wait function, Overlapping Input/Output, Error Handling with Async–Error Handling with Async

error handling with, Error Handling with Async–Error Handling with Async

for asynchronous actions, Overlapping Input/Output

waitAny function, Merging, Async Revisited, Adding a Functor Instance

waitBoth operation, Symmetric Concurrency Combinators, Symmetric Concurrency Combinators

and orElse combinator, Symmetric Concurrency Combinators

and withAsync function, Symmetric Concurrency Combinators

waitCatch function, Error Handling with Async, Asynchronous Exceptions

error handling with, Error Handling with Async

implementing, Asynchronous Exceptions

waitCatchSTM function, Async Revisited

waitEither function, Merging, Async Revisited, Async Revisited, Symmetric Concurrency Combinators, Symmetric Concurrency Combinators

and symmetric concurrency combinators, Symmetric Concurrency Combinators

in STM, Async Revisited, Async Revisited

waitSTM function, Async Revisited

wall-clock time, elapsed and, Example: Parallelizing a Sudoku Solver

watch list, in TVars, Performance

weak head normal form (WHNF), Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form

web browsers, interrupting several activiites with, Cancellation and Timeouts

web pages, concurrent downloading of, Overlapping Input/Output

weight function, Floyd-Warshall algorithm and, Example: Shortest Paths in a Graph

WHNF (weak head normal form), Lazy Evaluation and Weak Head Normal Form–Lazy Evaluation and Weak Head Normal Form

window manager example, Running Example: Managing Windows–Running Example: Managing Windows

withAsync function, Avoiding Thread Leakage, Symmetric Concurrency Combinators, Parallel Version, Asynchronous Exceptions and Foreign Calls–Asynchronous Exceptions and Foreign Calls

and waitBoth operation, Symmetric Concurrency Combinators

foreign calls with, Asynchronous Exceptions and Foreign Calls–Asynchronous Exceptions and Foreign Calls

installing exception handlers with, Avoiding Thread Leakage

nesting calls of, Parallel Version

withMonitor function, Handling Failure

withStrategy, parallelizing lazy streams with, Parallelizing Lazy Streams with parBuffer

work items, number of, Granularity–Granularity

work pools, Dataflow Parallelism: The Par Monad

work stealing, Example: Parallelizing a Sudoku Solver, The ParIO monad

write pointer (channel), MVar as a Building Block: Unbounded Channels

writeChan operations, MVar as a Building Block: Unbounded Channels, Asynchronous Exception Safety for Channels

concurrent, MVar as a Building Block: Unbounded Channels

definition of, Asynchronous Exception Safety for Channels

writeImage operation, Example: Image Rotation

writeTBQueue, deadlock caused by, Bounded Channels

Y

yields (term), Event Logging and ThreadScope

Z

Z constructor, Arrays, Shapes, and Indices

zeroPoint operation, Example: The K-Means Problem

zipWith function (Accelerate), Zipping Two Arrays