Index

Symbols

! operator
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
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
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
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
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
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
in K-Means problem, Example: The K-Means Problem
parallelizing, Parallelizing K-Means
associativity (foldP), Folding and Shape-Polymorphism
Async API, How to Achieve Parallelism with Concurrency
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
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
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
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
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, The bracket Operation
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
concurrency vs., Terminology: Parallelism and Concurrency
GUI, Threads and Foreign In-Calls
calls
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, Catching Asynchronous Exceptions
infix use of, Exceptions in Haskell
catchSTM, Asynchronous Exception Safety
centroids
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 events into single, Merging with STM
TChan vs., Implementing Channels with STM
channel abstraction, An Alternative Channel Implementation
channels
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
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
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
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)
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
between distributed processes, Distributed Programming
between server and client, A Trivial Server
of threads, Communication: MVars, Communication: MVars
compilers
deadlock detection by, Detecting Deadlock
for functional language, Example: A Parallel Type Inferencer
complex numbers
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
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, Higher-Level Concurrency Abstractions, Summary: The Async API
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
parallel skeletons and, Adding Parallelism, Adding Parallelism
constructors
:., 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
debugging, Debugging the CUDA Backend
support in Accelerate for, Running on the GPU

D

data dependencies, Dataflow Parallelism: The Par Monad
data parallelism
defined, Pipeline Parallelism
pipeline parallelism vs., Limitations of Pipeline Parallelism
data structure(s)
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
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
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, Detecting Deadlock, Detecting Deadlock
and MVar, Communication: MVars
of mutual deadlock, Detecting Deadlock
death, thread, Higher-Level Concurrency Abstractions, Avoiding Thread Leakage
debugging
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
computeS function and, Operations on Arrays
defined, Operations on Arrays
from fromFunction operation, Operations on Arrays
indexing, Operations on Arrays
depth threshold
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
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
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
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
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
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
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
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
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)
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
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
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
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
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, Fairness, Fairness
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
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
and exceptions, Asynchronous Exceptions
as bracket function, Exceptions in Haskell
find function
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
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
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
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
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), Rate-Limiting the Producer
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, mask and forkIO, mask and forkIO, Asynchronous Exceptions: Discussion
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, Example: Computing Shortest Paths
delayed arrays from, Operations on Arrays
fromListUnboxed function, Arrays, Shapes, 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
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
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)
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
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
documentation on, Tools and Resources
libraries on, Introduction
Handle
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
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
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
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
and code modifying state, Cancellation and Timeouts
locks in, MVar as a Container for Shared State
implicit masks, Catching Asynchronous Exceptions
inconsistent state
data left in, Masking Asynchronous Exceptions
of data, after cancellation, Cancellation and Timeouts
indexArray operation, Arrays and Indices
indexing
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
in ParIO, The ParIO monad
in STM, What Can We Not Do with STM?
IO 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
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
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

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
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
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
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
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
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
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
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
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
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
built-in safety of, Asynchronous Exceptions: Discussion
implementing, Masking Asynchronous Exceptions
variant of, Asynchronous Exception Safety for Channels
modular programs
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
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
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
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
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, Masking Asynchronous Exceptions
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
in Deepseq, Deepseq
NodeId, The Master Process
nonblocking semaphores, Limiting the Number of Threads with a Semaphore
normal form
defined, Lazy Evaluation and Weak Head Normal Form
in Deepseq, Deepseq
Notice constructor, Client Data
NVidia, GPU Programming with Accelerate

P

packages, installing, Sample Code
Par monad, Dataflow Parallelism: The Par Monad, Adding Parallelism
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
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, Parallel Programming Using Threads, The ParIO monad
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
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, Parallelizing Lazy Streams with parBuffer, Parallelizing Lazy Streams with parBuffer
parMap function, Example: Parallelizing a Sudoku Solver, Example: Parallelizing a Sudoku Solver
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
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
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
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)
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
strictness of, Dataflow Parallelism: The Par Monad
putMVar operation, Communication: MVars
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
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
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
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
blocked by window, Running Example: Managing Windows
implementing, Blocking Until Something Changes
Repa, Data Parallel Programming with Repa, Summary
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)
and Accelerate, Arrays and Indices
defined, Arrays, Shapes, and Indices
restore function, Masking Asynchronous Exceptions
retry operation, Blocking
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
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
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
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
as higher-order function, Adding Parallelism
tree-shaped, Example: A Conference Timetable
search skeleton, Adding Parallelism
selects function, Example: A Conference Timetable
semaphores
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
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, Concurrent Network Servers, Recap
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
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
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
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
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
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
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
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
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
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
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)
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
and mutable states, Communication: MVars
deadlock with, Detecting Deadlock
masking exceptions during, Masking Asynchronous Exceptions
takeTMVar operation, Blocking
TChan
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
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
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
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), 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
and asynchronous exceptions, Timeouts
and synchronous exceptions, Asynchronous Exceptions
thunk(s)
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
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
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
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
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
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
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
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, Merging Channels, Merging Channels
untyped channels vs., Handling Failure

U

unbounded 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
and garbage-collected sparks, GC’d Sparks and Speculative Parallelism

W

wait function
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
and orElse combinator, Symmetric Concurrency Combinators
and withAsync function, Symmetric Concurrency Combinators
waitCatch function
error handling with, Error Handling with Async
implementing, Asynchronous Exceptions
waitCatchSTM function, Async Revisited
waitEither function, Merging, 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
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
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

Z

Z constructor, Arrays, Shapes, and Indices
zeroPoint operation, Example: The K-Means Problem
zipWith function (Accelerate), Zipping Two Arrays