...
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 - or Macros
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.
In some cases Macros can be used to create something about as compact as a scala map/fold idiom but without expressing a function object at all. See LoggerMacros.scala for examples of this.
Avoid Passing Functions - By Name Arguments - Use Macros
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.
A macro can often be used instead to avoid the need for the by-name argument. (See AssertMacros.scala for examples of this)
Avoid Return Objects and Tuples
...
TBD: See the definitions of these. These make it convenient to reuse objects in recursive code, as is common in Daffodil. A small pool of reusable objects is maintained per thread. Accessing one causes it to either be created, or an existing one initialized. They get put back on exit of scope, and Scala 2.11's macros are used to avoid allocating closure objects as well.
Use Reusable Pools of Stored Objects
When reusable objects do not follow a stack discipline, then you can still reuse them by pooling them.
TBD: See Pool.scala for a common pooling idiom