Home Page Icon
Home Page
Table of Contents for
Table of Contents
Close
Table of Contents
by Michael Diamant, Vincent Theron
Scala High Performance Programming
Scala High Performance Programming
Scala High Performance Programming
Credits
About the Authors
About the Reviewer
www.PacktPub.com
eBooks, discount offers, and more
Why subscribe?
Free access for Packt account holders
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. The Road to Performance
Defining performance
Performant software
Hardware resources
Latency and throughput
Bottlenecks
Summarizing performance
The problem with averages
Percentiles to the rescue
Collecting measurements
Using benchmarks to measure performance
Profiling to locate bottlenecks
Pairing benchmarks and profiling
A case study
Tooling
Summary
2. Measuring Performance on the JVM
A peek into the financial domain
Unexpected volatility crushes profits
Reproducing the problem
Throughput benchmark
Latency benchmark
The first latency benchmark
The coordinated omission problem
The second latency benchmark
The final latency benchmark
Locating bottlenecks
Did I test with the expected set of resources?
Was the system environment clean during the profiling?
Are the JVM's internal resources performing to expectations?
Where are the CPU bottlenecks?
What are the memory allocation patterns?
Trying to save the day
A word of caution
A profiling checklist
Taking big steps with microbenchmarks
Microbenchmarking the order book
Summary
3. Unleashing Scala Performance
Value classes
Bytecode representation
Performance considerations
Tagged types - an alternative to value classes
Specialization
Bytecode representation
Performance considerations
Tuples
Bytecode representation
Performance considerations
Pattern matching
Bytecode representation
Performance considerations
Tail recursion
Bytecode representation
Performance considerations
The Option data type
Bytecode representation
Performance considerations
Case study – a more performant option
Summary
4. Exploring the Collection API
High-throughput systems – improving the order book
Understanding historical trade-offs – list implementation
List
TreeMap
Adding limit orders
Canceling orders
The current order book – queue implementation
Queue
Improved cancellation performance through lazy evaluation
Set
Benchmarking LazyCancelOrderBook
Lessons learned
Historical data analysis
Lagged time series returns
Vector
Data clean up
Handling multiple return series
Array
Looping with the Spire cfor macro
Summary
5. Lazy Collections and Event Sourcing
Improving the client report generation speed
Diving into the reporting code
Using views to speed up report generation time
Constructing a custom view
Applying views to improve report generation performance
View caveats
SeqView extends Seq
Views are not memoizers
Zipping up report generation
Rethinking reporting architecture
An overview of Stream
Transforming events
Building the event sourcing pipeline
Streaming Markov chains
Stream caveats
Streams are memoizers
Stream can be infinite
Summary
6. Concurrency in Scala
Parallelizing backtesting strategies
Exploring Future
Future and crazy ideas
Future usage considerations
Performing side-effects
Blocking execution
Handling failures
Hampering performance through executor submissions
Handling blocking calls and callbacks
ExecutionContext and blocking calls
Asynchronous versus nonblocking
Using a dedicated ExecutionContext to block calls
Using the blocking construct
Translating callbacks with Promise
From callbacks to a Future-based API
Combining Future with Promise
Tasked with more backtest performance improvements
Introducing Scalaz Task
Creating and executing Task
Asynchronous behavior
The execution model
Modeling trading day simulations with Task
Wrapping up the backtester
Summary
7. Architecting for Performance
Distributed automated traders
A glimpse into distributed architectures
The first attempt at a distributed automated trader
Introducing CRDTs
The state-based increase-only counter
The operation-based increase-only counter
CRDTs and automated traders
When the balance is not enough
A new CRDT - the grow-only set
Free trading strategy performance improvements
Benchmarking the trading strategy
The danger of unbounded queues
Applying back pressure
Applying load-control policies
Rejecting work
Interrupting expensive processing
Free monads
Describing a program
Building an interpreter
Benchmarking the new trading strategy pipeline
A Task interpreter
Exploring free monads further
Summary
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
Cover
Next
Next Chapter
Scala High Performance Programming
Table of Contents
Scala High Performance Programming
Credits
About the Authors
About the Reviewer
www.PacktPub.com
eBooks, discount offers, and more
Why subscribe?
Free access for Packt account holders
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. The Road to Performance
Defining performance
Performant software
Hardware resources
Latency and throughput
Bottlenecks
Summarizing performance
The problem with averages
Percentiles to the rescue
Collecting measurements
Using benchmarks to measure performance
Profiling to locate bottlenecks
Pairing benchmarks and profiling
A case study
Tooling
Summary
2. Measuring Performance on the JVM
A peek into the financial domain
Unexpected volatility crushes profits
Reproducing the problem
Throughput benchmark
Latency benchmark
The first latency benchmark
The coordinated omission problem
The second latency benchmark
The final latency benchmark
Locating bottlenecks
Did I test with the expected set of resources?
Was the system environment clean during the profiling?
Are the JVM's internal resources performing to expectations?
Where are the CPU bottlenecks?
What are the memory allocation patterns?
Trying to save the day
A word of caution
A profiling checklist
Taking big steps with microbenchmarks
Microbenchmarking the order book
Summary
3. Unleashing Scala Performance
Value classes
Bytecode representation
Performance considerations
Tagged types - an alternative to value classes
Specialization
Bytecode representation
Performance considerations
Tuples
Bytecode representation
Performance considerations
Pattern matching
Bytecode representation
Performance considerations
Tail recursion
Bytecode representation
Performance considerations
The Option data type
Bytecode representation
Performance considerations
Case study – a more performant option
Summary
4. Exploring the Collection API
High-throughput systems – improving the order book
Understanding historical trade-offs – list implementation
List
TreeMap
Adding limit orders
Canceling orders
The current order book – queue implementation
Queue
Improved cancellation performance through lazy evaluation
Set
Benchmarking LazyCancelOrderBook
Lessons learned
Historical data analysis
Lagged time series returns
Vector
Data clean up
Handling multiple return series
Array
Looping with the Spire cfor macro
Summary
5. Lazy Collections and Event Sourcing
Improving the client report generation speed
Diving into the reporting code
Using views to speed up report generation time
Constructing a custom view
Applying views to improve report generation performance
View caveats
SeqView extends Seq
Views are not memoizers
Zipping up report generation
Rethinking reporting architecture
An overview of Stream
Transforming events
Building the event sourcing pipeline
Streaming Markov chains
Stream caveats
Streams are memoizers
Stream can be infinite
Summary
6. Concurrency in Scala
Parallelizing backtesting strategies
Exploring Future
Future and crazy ideas
Future usage considerations
Performing side-effects
Blocking execution
Handling failures
Hampering performance through executor submissions
Handling blocking calls and callbacks
ExecutionContext and blocking calls
Asynchronous versus nonblocking
Using a dedicated ExecutionContext to block calls
Using the blocking construct
Translating callbacks with Promise
From callbacks to a Future-based API
Combining Future with Promise
Tasked with more backtest performance improvements
Introducing Scalaz Task
Creating and executing Task
Asynchronous behavior
The execution model
Modeling trading day simulations with Task
Wrapping up the backtester
Summary
7. Architecting for Performance
Distributed automated traders
A glimpse into distributed architectures
The first attempt at a distributed automated trader
Introducing CRDTs
The state-based increase-only counter
The operation-based increase-only counter
CRDTs and automated traders
When the balance is not enough
A new CRDT - the grow-only set
Free trading strategy performance improvements
Benchmarking the trading strategy
The danger of unbounded queues
Applying back pressure
Applying load-control policies
Rejecting work
Interrupting expensive processing
Free monads
Describing a program
Building an interpreter
Benchmarking the new trading strategy pipeline
A Task interpreter
Exploring free monads further
Summary
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset