here - Stefan-Marr.de

Appendix B. Appendix: Performance Evaluation
B.1.1. Microbenchmarks
We implemented the microbenchmarks specifically for assessing the performance
of the presented implementations. The changes to the LRSTM and
AmbientTalkST variants of the benchmarks are restricted to the necessary
setup operations to execute the benchmarks in the context of the actor or
STM implementation.
Int Loop This benchmark is a tight while loop that subtracts 1 from an integer
and executes until the integer is zero. This loop only executes
basic stack operations and uses a special bytecode to do the subtraction.
Thus, it does neither create context objects for message sends nor allocate
other objects, because the integers are represented as immediate
values.
LRSTM: Loop executed in context of the STM, but since no object field
mutation is done, an ideal implementation will not exhibit any slowdown.
An OMOP-based implementation might need to reify the send
of the subtraction operation, which will lead to a significant reduction
of performance.
AmbientTalkST: The loop is executed inside a single actor and thus, an
ideal implementation would not exhibit any slowdown. OMOP-based
implementations might have the same message reification penalty as
for the LRSTM implementation.
Float Loop This benchmark is a tight while loop that subsequently does
two additions of floating point numbers until the floating point value
reaches a predefined limit. The loop results in corresponding stack operations
for instance to store and load the float. Similarly to the Int
Loop, the addition is done by a special bytecode that does not require a
message send with context object creation. However, the floating point
numbers are represented as heap objects and lead to high allocation
rates. Note that we do not measure GC time but use a large enough
heap instead, which avoids garbage collection completely.
LRSTM and AmbientTalkST: We expect the same results as for the Int Loop,
because the implementation is nearly identical.
InstVar Access This benchmark is a tight while loop identical to the Int Loop,
with additionally reads and writes an object field. All operations are encoded
with bytecodes without resulting in message sends. Thus, neither
allocation nor creation of context objects is done.
262