Haskell High Performance Programming
Table of Contents
Haskell High Performance Programming
Credits
About the Author
About the Reviewer
www.PacktPub.com
eBooks, discount offers, and more
Why subscribe?
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example code
Downloading the color images of this book
Errata
Piracy
Questions
1. Identifying Bottlenecks
Meeting lazy evaluation
Writing sum correctly
Weak head normal form
Folding correctly
Memoization and CAFs
Constant applicative form
Recursion and accumulators
The worker/wrapper idiom
Guarded recursion
Accumulator parameters
Inspecting time and space usage
Increasing sharing and minimizing allocation
Compiler code optimizations
Inlining and stream fusion
Polymorphism performance
Partial functions
Summary
2. Choosing the Correct Data Structures
Annotating strictness and unpacking datatype fields
Unbox with UNPACK
Using anonymous tuples
Performance of GADTs and branching
Handling numerical data
Handling binary and textual data
Representing bit arrays
Handling bytes and blobs of bytes
Working with characters and strings
Using the text library
Builders for iterative construction
Builders for strings
Handling sequential data
Using difference lists
Difference list performance
Difference list with the Writer monad
Using zippers
Accessing both ends fast with Seq
Handling tabular data
Using the vector package
Handling sparse data
Using the containers package
Using the unordered-containers package
Ephemeral data structures
Mutable references are slow
Using mutable arrays
Using mutable vectors
Bubble sort with vectors
Working with monads and monad stacks
The list monad and its transformer
Free monads
Working with monad transformers
Speedup via continuation-passing style
Summary
3. Profile and Benchmark to Your Heart's Content
Profiling time and allocations
Setting cost centres manually
Setting cost centres automatically
Installing libraries with profiling
Debugging unexpected crashes with profiler
Heap profiling
Cost centre-based heap profiling
Objects outside the heap
Retainer profiling
Biographical profiling
Benchmarking using the criterion library
Profile and monitor in real time
Monitoring over HTTP with ekg
Summary
4. The Devil's in the Detail
The anatomy of a Haskell project
Useful fields and flags in cabal files
Test suites and benchmarks
Using the stack tool
Multi-package projects
Erroring and handling exceptions
Handling synchronous errors
The exception hierarchy
Handling asynchronous errors
Throw and catch in other monads besides IO
Writing tests for Haskell
Property checks
Unit testing with HUnit
Test frameworks
Trivia at term-level
Coding in GHC PrimOps
Control inlining
Using rewrite rules
Specializing definitions
Phase control
Trivia at type-level
Phantom types
Functional dependencies
Type families and associated types
Useful GHC extensions
Monomorphism Restriction
Extensions for patterns and guards
Strict-by-default Haskell
Summary
5. Parallelize for Performance
Primitive parallelism and the Runtime System
Spark away
Subtle evaluation – pseq
When in doubt, use the force
The Eval monad and strategies
Composing strategies
Fine-tune granularity with chunking and buffering
The Par monad and schedules
spawn for futures and promises
Non-deterministic parallelism with ParIO
Diagnosing parallelism – ThreadScope
Data parallel programming – Repa
Playing with Repa in GHCi
Mapping and delayed arrays
Reduction via folding
Manifest representations
Delayed representation and fusion
Indices, slicing, and extending arrays
Convolution with stencils
Cursored and partitioned arrays
Writing fast Repa code
Additional libraries
Example from image processing
Loading the image from file
Identifying letters with convolution
Extracting strings from an image
Testing and evaluating performance
Summary
6. I/O and Streaming
Reading, writing, and handling resources
Traps of lazy I/O
File handles, buffering, and encoding
Binary I/O
Textual I/O
I/O performance with filesystem objects
Sockets and networking
Acting as a TCP/IP client
Acting as a TCP server (Unix domain sockets)
Raw UDP traffic
Networking above the transport layer
Managing resources with ResourceT
Streaming with side-effects
Choosing a streaming library
Simple streaming using io-streams
Creating input streams
Using combinators and output streams
Handling exceptions and resources in streams
An example of parsing using io-streams and attoparsec
Streaming using pipes
Composing and executing pipes
For loops and category theory in pipes
Handling exceptions in pipes
Strengths and weaknesses of pipes
Streaming using conduits
Handling resources and exceptions in conduits
Resuming conduits
Logging in Haskell
Logging with FastLogger
More abstract loggers
Timed log messages
Monadic logging
Customizing monadic loggers
Summary
7. Concurrency and Performance
Threads and concurrency primitives
Threads and mutable references
Avoid accumulating thunks
Atomic operations with IORefs
MVar
MVars are fair
MVar as a building block
Broadcasting with Chan
Software Transactional Memory
STM example – Bank accounts
Alternative transactions
Exceptions in STM
Runtime System and threads
Masking asynchronous exceptions
Asynchronous processing
Using the Async API
Async example – Timeouts
Composing with Concurrently
Lifting up from I/O
Top-level mutable references
Lifting from a base monad
Lifting base with exception handling
Summary
8. Tweaking the Compiler and Runtime System (GHC)
Using GHC like a pro
Operating GHC
Circular dependencies
Adjusting optimizations and transformations
The state hack
Floating lets in and out
Eliminating common subexpressions
Liberate-case duplicates code
Compiling via the LLVM route
Linking and building shared libraries
Preprocessing Haskell source code
Enforcing type-safety using Safe Haskell
Tuning GHC's Runtime System
Scheduler and green threads
Sparks and spark pool
Bounded threads and affinity
Indefinite blocking...