here - Stefan-Marr.de

6.2. Case Studies
Important for this evaluation is that both, the ad hoc as well as the OMOPbased
implementation provide the same guarantees.
General Implementation The general idea behind the implemented STM is
the same in both cases. To be precise, both of our implementations share the
main code parts, only the code that realizes the capturing of field accesses is
different.
For the sake of brevity, the evaluation disregards LRSTM’s support for
nested transactions, error handling, and other advanced features. The implementation
discussed here is a sketch of a minimal STM system that enables
atomic execution of transactions.
The implementation sketch is given in Lst. 6.4. It builds on top of the ability
to change all state access operations to work on a workingCopy of an object,
instead of working on the object directly. To this end, in the context of a transaction
each object can obtain a working copy for itself. A transaction maintains
a set of changes, represented by Change objects. These change objects
maintain the connection between the working copy and the original object,
as well as a copy of the original object. Thus, all operations in the scope of
a transaction result in read and write operations to the working copy of an
object instead of changing the original.
When a transaction is to be committed, all threads are stopped and the
#commit operation checks for conflicting operations. #hasConflict checks
whether the original object has changed compared to when the current transaction
accessed it the first time. If no conflicts are found, the changes made
during the transaction are applied, and the commit succeeds.
Managing State Access The main mechanism both implementations need to
provide is an interception of all state access operations. Thus, all field reads
and writes need to be adapted to operate on a working copy instead of the
original object. Furthermore, all primitives that read from or write to objects
need to be adapted in a similar way.
Ad Hoc Solutions Renggli and Nierstrasz [2007] proposed to use program
transformation to weave in the necessary operations. Instead of using an
AST transformation as done here (cf. Sec. 7.1), such adaptions could be applied
with higher-level approaches such as aspect-oriented programming (cf.
Sec. 7.1.3). The main requirement is that all field accesses are adaptable.
149