Tool support for generation of transactional code

I would like to announce the availability of compiler support for generation
of transactional code in LLVM IR. Our tool is called Tanger and it is an LLVM
pass. You can download Tanger at:

Transactional memory (TM) is viewed by a lot of people to be an important tool
for enabling parallelism in a wide area of applications, and especially for
developers that are not skilled in concurrent programming. It is a lot better
than locking (e.g., w.r.t. composability) and far easier than low-level
concurrent programming.

Tanger transforms an application that uses a minimal application-level
declaration API for memory transactions (calls to hook functions begin() and
commit() to declare transaction boundaries) into an application that contains
proper calls to an STM for all accesses to memory in transactional code
(e.g., load instructions are transformed into calls to stm_load() functions).
You can find a more detailed description in our Transact'07 paper [1]. If you
use Tanger in your work, please cite this paper (or the paper we link to at
the website below).

We are looking forward to any comments, questions, and contributions. There is
large interest in compiler support for transactional memory right now
especially in the TM community and related communities. I suppose that only
relatively few people from these communities have a compiler background, so
we would really like to get support from people that have a compiler

We thank all the LLVM developers and contributors for creating a great
compiler framework.


[1] Pascal Felber and Christof Fetzer and Ulrich Müller and Torvald Riegel and
Martin Süsskraut and Heiko Sturzrehm, Transactifying Applications using an
Open Compiler Framework, TRANSACT, 2007


This is nice work. Do you have a set of applications or benchmarks that you have transactionalized at the source level? If so, have you reported performance numbers for them somewhere?



The absence of such a tool is the reason why there are not many benchmarks
around, especially no applications that are used by real users. There are two
microbenchmarks in the release and I have performance numbers in my slides
for the Transact presentation
We currently are not doing any TM-specific optimizations as described in
recent Intel or MSR papers, but LLVM's generic optimizations seem to be quite
good at reducing teh number of loads and stores.
I'm currently preparing a Tanger patch for the STAMP benchmarks
(, but I need to add some features first. A full
list of the missing features (all, not just for STAMP) that I am aware of is
in TODO.txt in the release archive.

So, it would be fairly easy to pick, for example, sequential implementations
of various data structures and run them as transactions, but this is not
necessarily what users need or how they would use TM. This problem was also
talked about a lot at Transact's panel discussion, and the agreement was
roughly that we need real users to be able to evaluate TM correctly.

So we can't give you benchmarks yet, but the idea is that tools such as Tanger
can make this process much easier, both regarding benchmarks coming from
researchers and real users. This approach and Tanger are work in progress,
but we are working on it.
If you have any ideas for benchmarks, or know people that do have and are
interested in using TM, please tell me.