Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Book Overview & Buying Haskell High Performance Programming
  • Table Of Contents Toc
  • Feedback & Rating feedback
Haskell High Performance Programming

Haskell High Performance Programming

By : Thomasson
3 (2)
Buy this Book
close
close
Haskell High Performance Programming

Haskell High Performance Programming

3 (2)
By: Thomasson
Buy this Book

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.
Table of Contents (16 chapters)
close
close
close
Preface
Icon
Preface
Icon
What this book covers
Icon
What you need for this book
Icon
Who this book is for
Icon
Conventions
Icon
Reader feedback
Icon
Customer support
Free Chapter
1
1. Identifying Bottlenecks
Icon
1. Identifying Bottlenecks
Icon
Meeting lazy evaluation
Icon
Memoization and CAFs
Icon
Recursion and accumulators
Icon
Inspecting time and space usage
Icon
Compiler code optimizations
Icon
Summary
2
2. Choosing the Correct Data Structures
Icon
2. Choosing the Correct Data Structures
Icon
Annotating strictness and unpacking datatype fields
Icon
Handling numerical data
Icon
Handling binary and textual data
Icon
Handling sequential data
Icon
Handling tabular data
Icon
Handling sparse data
Icon
Ephemeral data structures
Icon
Working with monads and monad stacks
Icon
Summary
3
3. Profile and Benchmark to Your Heart's Content
Icon
3. Profile and Benchmark to Your Heart's Content
Icon
Profiling time and allocations
Icon
Heap profiling
Icon
Benchmarking using the criterion library
Icon
Profile and monitor in real time
Icon
Summary
4
4. The Devil's in the Detail
Icon
4. The Devil's in the Detail
Icon
The anatomy of a Haskell project
Icon
Erroring and handling exceptions
Icon
Writing tests for Haskell
Icon
Trivia at term-level
Icon
Trivia at type-level
Icon
Useful GHC extensions
Icon
Summary
5
5. Parallelize for Performance
Icon
5. Parallelize for Performance
Icon
Primitive parallelism and the Runtime System
Icon
The Eval monad and strategies
Icon
The Par monad and schedules
Icon
Diagnosing parallelism – ThreadScope
Icon
Data parallel programming – Repa
Icon
Summary
6
6. I/O and Streaming
Icon
6. I/O and Streaming
Icon
Reading, writing, and handling resources
Icon
Streaming with side-effects
Icon
Logging in Haskell
Icon
Summary
7
7. Concurrency and Performance
Icon
7. Concurrency and Performance
Icon
Threads and concurrency primitives
Icon
Software Transactional Memory
Icon
Runtime System and threads
Icon
Asynchronous processing
Icon
Lifting up from I/O
Icon
Summary
8
8. Tweaking the Compiler and Runtime System (GHC)
Icon
8. Tweaking the Compiler and Runtime System (GHC)
Icon
Using GHC like a pro
Icon
Tuning GHC's Runtime System
Icon
Summary of useful GHC options
Icon
Summary of useful RTS options
Icon
Summary
9
9. GHC Internals and Code Generation
Icon
9. GHC Internals and Code Generation
Icon
Interpreting GHC's internal representations
Icon
Primitive GHC-specific features
Icon
Datatype generic programming
Icon
Generating Haskell with Haskell
Icon
Summary
10
10. Foreign Function Interface
chevron up
Icon
10. Foreign Function Interface
Icon
From Haskell to C and C to Haskell
Icon
Data marshal and stable pointers
Icon
Summary
11
11. Programming for the GPU with Accelerate
Icon
11. Programming for the GPU with Accelerate
Icon
Writing Accelerate programs
Icon
Running with the CUDA backend
Icon
More Accelerate concepts
Icon
Summary
12
12. Scaling to the Cloud with Cloud Haskell
Icon
12. Scaling to the Cloud with Cloud Haskell
Icon
Processes and message-passing
Icon
Handling failure
Icon
Nodes and networking
Icon
Summary
13
13. Functional Reactive Programming
Icon
13. Functional Reactive Programming
Icon
The tiny discrete-time Elerea
Icon
Events and signal functions with Yampa
Icon
Reactive-banana – Safe and simple semantics
Icon
Combining events and behaviors
Icon
Summary
14
14. Library Recommendations
Icon
14. Library Recommendations
Icon
Representing data
Icon
Functional graphs
Icon
Numeric data for special use
Icon
Encoding and serialization
Icon
Persistent storage, SQL, and NoSQL
Icon
Networking and HTTP
Icon
Cryptography
Icon
Web technologies
Icon
Parsing and pretty-printing
Icon
Pretty-printing and text formatting
Icon
Control and utility libraries
Icon
Working with monads and transformers
Icon
Handling exceptions
Icon
Random number generators
Icon
Parallel and concurrent programming
Icon
Functional Reactive Programming
Icon
Mathematics, statistics, and science
Icon
Tools for research and sketching
Icon
The HaskellR project
Icon
Creating charts and diagrams
Icon
Scripting and CLI applications
Icon
Testing and benchmarking
Icon
Summary
15
Index
Icon
Index

From Haskell to C and C to Haskell

A classic usage of the FFI is calling C functions from Haskell. So let's start with that. Consider that you wrote a function in C, for instance the recursive nth Fibonacci number like the fib.c file here:

/* file: fib.c */

int fib_c(int num)
{
  if (num <= 2)
  {
    return 1;
  }
  else
  {
    return(fib_c(num - 1) + fib_c(num - 2));
  }
}

Although naive, this implementation is still faster than the Haskell equivalent.

Now, to call this fast naive fib_c function from Haskell, at its simplest we could just add the following line to a Haskell source file and then we would have a fib_c :: Int → Int Haskell function:

-- file: ffi-fib.hs

foreign import ccall
  fib_c :: Int -> Int

main = print $ fib_c 20

The only FFI-specific thing here is foreign import. Note that, with some earlier versions of GHC, it was necessary to explicitly enable the FFI with -XForeignFunctionInterface.

To compile this program, we should give both the Haskell and C...

Unlock full access

Continue reading for free

A Packt free trial gives you instant online access to our library of over 7000 practical eBooks and videos, constantly updated with the latest in tech
Start a 7-day FREE trial
End of Section 2
Next Section

Create a Note

Modal Close icon
You need to login to use this feature.
notes
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete

Delete Note

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete

Edit Note

Modal Close icon
Write a note (max 255 characters)
Cancel
Update Note

Confirmation

Modal Close icon
claim successful
Order Page Read Now

Buy this book with your credits?

Modal Close icon
Are you sure you want to buy this book with one of your credits?
Close
YES, BUY