Sign In Start Free Trial

Haskell High Performance Programming

By : Thomasson

3 (2)

Haskell High Performance Programming

3 (2)

By: Thomasson

Overview of this book

Haskell, with its power to optimize the code and its high performance, is a natural candidate for high performance programming. It is especially well suited to stacking abstractions high with a relatively low performance cost. This book addresses the challenges of writing efficient code with lazy evaluation and techniques often used to optimize the performance of Haskell programs. We open with an in-depth look at the evaluation of Haskell expressions and discuss optimization and benchmarking. You will learn to use parallelism and we'll explore the concept of streaming. We’ll demonstrate the benefits of running multithreaded and concurrent applications. Next we’ll guide you through various profiling tools that will help you identify performance issues in your program. We’ll end our journey by looking at GPGPU, Cloud and Functional Reactive Programming in Haskell. At the very end there is a catalogue of robust library recommendations with code samples. By the end of the book, you will be able to boost the performance of any app and prepare it to stand up to real-world punishment.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Identifying Bottlenecks

1. Identifying Bottlenecks

Meeting lazy evaluation

Memoization and CAFs

Recursion and accumulators

Inspecting time and space usage

Compiler code optimizations

Summary

2. Choosing the Correct Data Structures

2. Choosing the Correct Data Structures

Annotating strictness and unpacking datatype fields

Handling numerical data

Handling binary and textual data

Handling sequential data

Handling tabular data

Handling sparse data

Ephemeral data structures

Working with monads and monad stacks

Summary

3. Profile and Benchmark to Your Heart's Content

3. Profile and Benchmark to Your Heart's Content

Profiling time and allocations

Heap profiling

Benchmarking using the criterion library

Profile and monitor in real time

Summary

4. The Devil's in the Detail

4. The Devil's in the Detail

The anatomy of a Haskell project

Erroring and handling exceptions

Writing tests for Haskell

Trivia at term-level

Trivia at type-level

Useful GHC extensions

Summary

5. Parallelize for Performance

5. Parallelize for Performance

Primitive parallelism and the Runtime System

The Eval monad and strategies

The Par monad and schedules

Diagnosing parallelism – ThreadScope

Data parallel programming – Repa

Summary

6. I/O and Streaming

6. I/O and Streaming

Reading, writing, and handling resources

Streaming with side-effects

Logging in Haskell

Summary

7. Concurrency and Performance

7. Concurrency and Performance

Threads and concurrency primitives

Software Transactional Memory

Runtime System and threads

Asynchronous processing

Lifting up from I/O

Summary

8. Tweaking the Compiler and Runtime System (GHC)

8. Tweaking the Compiler and Runtime System (GHC)

Using GHC like a pro

Tuning GHC's Runtime System

Summary of useful GHC options

Summary of useful RTS options

Summary

9. GHC Internals and Code Generation

9. GHC Internals and Code Generation

Interpreting GHC's internal representations

Primitive GHC-specific features

Datatype generic programming

Generating Haskell with Haskell

Summary

10. Foreign Function Interface

10. Foreign Function Interface

From Haskell to C and C to Haskell

Data marshal and stable pointers

Summary

11. Programming for the GPU with Accelerate

11. Programming for the GPU with Accelerate

Writing Accelerate programs

Running with the CUDA backend

More Accelerate concepts

Summary

12. Scaling to the Cloud with Cloud Haskell

12. Scaling to the Cloud with Cloud Haskell

Processes and message-passing

Handling failure

Nodes and networking

Summary

13. Functional Reactive Programming

13. Functional Reactive Programming

The tiny discrete-time Elerea

Events and signal functions with Yampa

Reactive-banana – Safe and simple semantics

Combining events and behaviors

Summary

14. Library Recommendations

14. Library Recommendations

Representing data

Functional graphs

Numeric data for special use

Encoding and serialization

Persistent storage, SQL, and NoSQL

Networking and HTTP

Cryptography

Web technologies

Parsing and pretty-printing

Pretty-printing and text formatting

Control and utility libraries

Working with monads and transformers

Handling exceptions

Random number generators

Parallel and concurrent programming

Functional Reactive Programming

Mathematics, statistics, and science

Tools for research and sketching

The HaskellR project

Creating charts and diagrams

Scripting and CLI applications

Testing and benchmarking

Summary

Index

Index

Customer Reviews

3 (2)

5 star

0

4 star

50%

3 star

0

2 star

50%

1 star

0

What this book covers

Chapter 1, Identifying Bottlenecks, introduces you to basic techniques for optimal evaluation and avoiding space leaks.

Chapter 2, Choose the Correct Data Structures, works with and optimizes both immutable and mutable data structures.

Chapter 3, Profile and Benchmark to Your Heart's Content, profiles Haskell programs using GHC and benchmarking using Criterion.

Chapter 4, The Devil's in the Detail, explains the small details that affect performance in Haskell programs, including code sharing, specializing, and simplifier rules.

Chapter 5, Parallelize for Performance, exploits parallelism in Haskell programs using the RePa library for data parallelism.

Chapter 6, I/O and Streaming, talks about the pros and cons of lazy and strict I/O in Haskell and explores the concept of streaming.

Chapter 7, Concurrency Performance, explores the different aspects of concurrent programming, such as shared variables, exception handling, and software-transactional memory.

Chapter 8, Tweaking the Compiler and Runtime System, chooses the optimal compiler and runtime parameters for Haskell programs compiled with GHC.

Chapter 9, GHC Internals and Code Optimizations, delves deeper into the compilation pipeline, and understands the intermediate representations of GHC.

Chapter 10, Foreign Function Interface, calls safely to and from C in Haskell using GHC and its FFI support.

Chapter 11, Programming for the GPU with Accelerate, uses the Accelerate library to program backend-agnostic GPU programs and executes on CUDA-enabled systems.

Chapter 12, Scaling to the Cloud with Cloud Haskell, uses the Cloud Haskell ecosystem to build distributed systems with Haskell.

Chapter 13, Functional Reactive Programming, introduces three Haskell FRP libraries, including Elerea, Yampa, and Reactive-banana.

Chapter 14, Library Recommendations, talks about a catalogue of robust Haskell libraries, accompanied with overviews and examples.

Search

Your notes and bookmarks