Investigating the Performance of the Implementations of Embedded Languages in Haskell

Abstract

Accelerate is a language for high-performance computing embedded in Haskell. Embedding languages in other languages is a popular approach for language prototyping, as it reduces the language front-end work from the language designer. To execute the programs written in these languages, the designers need to implement at least an interpreter or a compiler. Tree-walking interpreters are known to be slow, and so different approaches might be implemented if performance is important. This thesis implements a tree-walking interpreter, a bytecode interpreter and a JIT compiler using LLVM in Haskell for a standalone language and compares the performance of each to an optimized bytecode interpreter written in C. However, the results indicate that tree-walking interpreters are often less than an order of magnitude slower and occasionally even faster than bytecode interpreters when both are written in Haskell.

Based on this result, it seemed unlikely that Accelerate's performance issues, especially in a multi-threaded environment, were caused by its tree-walking interpreter. In light of this, I investigated this performance deterioration using a nanosecond-precision profiler and varying heap sizes for the Haskell garbage collector. The results from this show that garbage collection has a large impact on the behaviour of Accelerate programs, and that the performance of these programs likely depends on overhead relating to this. However, the amount of garbage collection occurences is identified to not be the direct cause of the performance degradation. I suggest future work to see what can be done to investigate this problem further and how to fix these performance issues.