Subj : Re: transactional memory question
To   : comp.arch,comp.programming.threads
From : Anne & Lynn Wheeler
Date : Tue Oct 04 2005 10:25 am

"Chris Thomasson" <_no_spam_cristom@no_spam_comcast._net> writes:
> IMHO, I believe its too early in the game for actual hardware
> support, even though they really do need it in order for TM to
> become really useful. All of the software emulations I have seen are
> loaded with expensive atomic operations; mutexs seem more
> efficient...

original 801 had a form ... it was used by journal filesystem
for aix in rs/6000.

filesystem metadata was organized ... and the memory system caught all
changes ... so basically you avoided having to do all the explicit
logging/locking statements in the filesystem code ... you did have to
add commit calls.

there was some disagreement whether the overhead of explicit
logs/locks were more expensive than the implicit overhead involved in
transaction memory. turns out there was the overhead of scanning the
whole memory area for changes at commits.

a portable version of the journal filesystem code with explicit
lock/logging changes in the code turned up the explicit lock/logging
calls had lower overhead than transactional memory (at least in the
journal filesystem case).

and unrelated old reference from about same period as aixv3 ... the
Proceedings of the 20th International Symposium on Fault-Tolerant
Computing Systems, pp 89--96, Newcastle, June 1990.

A Fault Tolerant Tightly Coupled Multiprocessor Architecture based on
Stable Transactional Memory

Authors: Michel Banatre and Philippe Joubert
Abstract:

Traditionally, tightly coupled multiprocessors allow data sharing
between multiple caches by keeping cached copies of memory blocks
coherent with respect to shared memory. This is difficult to achieve
in a fault tolerant environment due to the need to save global
checkpoints in shared memory from where consistent cache states can be
recovered after a failure.

The architecture presented in this report solves this problem by
encapsulating the memory modifications done by a process into an
atomic transaction. Caches record dependencies between the
transactions associated with processes modifying the same memory
blocks. Dependent transactions may then be atomically committed. Such
an operation requires a cache coherence protocol responsible for
recording process dependencies as well as keeping coherent cached
copies of blocks and a shared Stable Transactional Memory owing to
which all memory updates are atomic to allow recovery after a
processor failure.

-- 
Anne & Lynn Wheeler | http://www.garlic.com/~lynn/

.