Re: Transactions and error recovery
On 3/28/07 9:45 AM, in article
firstname.lastname@example.org, "Lourens Veen"
My idea continues on this handling issue. Currently, the C++ execution
model provides for a single thread of execution. A "run" of a
programme is a monolithic series of operations (transaction)
performed by C++'s abstract machine. Thread support is being added,
so that a run of a programme will become a set of transactions
performed by multiple abstract machines in parallel.
What I would like to do is split up the entire "old style" monolithic
run into lots of small transactions, and make them atomic. If
something goes wrong, the transaction is cancelled/rolled back, and
the system continues as if the transaction never occurred.
I think your idea is brilliant - and should be taken further. Toward that
end, I would suggest naming this technique, "Software Transactional Memory".
I would also propose writing up a Wikipedia article on this invention (using
this page as a model:
(Note: I would be sure to leave in the credit to my brother for
"popularizing" STM - even though - judging from your familiarity with the
technology - he apparently still has his work cut out for him :-).
That requires cooperation from shared data structures, and some kind
of error handling paradigm. Or a language that does it automatically
of course, where it is inherent in the abstract machine. I don't see
that happening with C++ any time soon, but it would be interesting to
see what a C++-like language based on transactions would look like.
A C++ program that supported such "transactions" would use an "atomic"
keyword to indicate the scope of the transaction. For example:
typedef std::set<int> IntSet;
void f( IntSet& setOne, IntSet& setTwo)
setOne.insert( 5 );
setTwo.insert( 5 );
The f() routine attempts to insert the value "5" into two sets in one atomic
operation. The fact that the operation is atomic means that an observer that
finds 5 in one set is certain to find 5 in the other set as well. Now, f()'s
atomic operation may fail (because another thread conducts a concurrent
operation with one of the sets that prevents these two insertions from
completing atomically). If f()'s atomic operation fails, f() inserts nothing
into either set (the transaction is "rolled back") and f() tries the same
atomic operation again.
Note that unlike conventional locking with mutexes, STM atomic operations
are composable (they may nest) and generic (setOne and setTwo may be
selected at runtime). It would not be safe to implement f() with
conventional locks unless the program also adopts (and enforces) a protocol
that regulates access to the two sets (which rules out arbitrary sets as
I would recommend trying out STM for yourself - with a C++ compiler that
supports the "atomic" keyword. An STM C++ compiler (based on gcc) can be
found (along with other STM material and references) at this web site:
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]