This page is for Scala performance coding hints that should be used for performance critical code, such as the repetitive places in the Daffodil runtime module.
These ideas basically amount to writing "java-like" Scala code.
Do not use this style except in performance critical areas, as it makes the code less readable, less compact, much harder to get correct, etc.
Hopefully in the future improvements in JVMs and the Scala compiler will make some of these techniques less necessary.
Avoid Unnecessary Allocation
...
Measurements have often shown allocation to be a large cost, so there is a bunch of techniques for avoiding excess allocation.
Avoid Passing Functions - While Loops for Iteration
Scala's map, flatmap, fold, reduce, foreach, etc. All these things take a function argument. Due to JVM issues, even though these functions are only used downward, they still end up allocated on the heap.
In general this means writing plain-old while-loops instead of Scala's much more compact idioms.
Avoid Passing Functions - By Name Arguments
Code like this
| Code Block |
|---|
def foo (a: Int, b : => Int) = { .... } |
Every time method foo is called, a little function closure is allocated for the 'b' argument passing.
Avoid Return Objects and Tuples
...
For the very common case of wanting to return an optional result, e.g., where you would want to return Option\[T], instead return a Maybe\[T] for objects, and use MaybeInt, MaybeLong, etc. for numbers. See below about avoiding Option type.
Similar common return types are small tuples of values, and the Either\[L, R] and Try\[T] types.
Avoid Option Type - Use Maybe Family of Types
...