Dr. Dobb's Journal - December 2007 - (Page 49)

d12gran_p5ma 10/12/07 10:26 AM Page 49 This shows that only certain operations can be undone on the standard containers. Atomic behavior is only possible to guarantee when a function has no side effects prior to an exception being thrown, or the availability of a guaranteed undo function that can be called in a scope-guard or an exception handler. Dealing with exceptions is complicated and sometimes messy, and requires different approaches in different circumstances. Some good examples of the subtleties of exception handling are given by Herb Sutter both in Exceptional C++: 47 Engineering Puzzles, Programming Problems and Solutions (Addison-Wesley, 2000); and More Exceptional C++ (AddisonWesley, 2002). atomic::vector list1, list2; void f(const std::string &s) { atomic::transaction tr; list1.push_back(s); list2.push_back(s); tr.commit(); } The transaction tr defines the scope of the transaction, namely the entire function f(). list1 and list2 are of type atomic::vector, which is a special container that interacts with atomic::transaction. If f() exits without calling tr.commit(), then all of the changes in f() are undone. The Atomic C++ Library for transactional programming provides a range of containers that can be rolled back to any point in their past by transactions. Transactional containers are designed in such a way that deletions can be safely undone without the possibility of failure when the container is rolled back, even if it involves inserting data back into the data structure. Nesting Transactions The ability to roll back a single function is Transactions Databases approach errors in a completely different way. Instead of making error recovery explicit, databases make error recovery implicit through the use of transactions; see An Introduction to Database Systems by C.J. Date (Addison-Wesley, 1991). In this Transact-SQL example, the transaction begins with BEGIN TRAN T1 and ends with COMMIT TRAN T1: BEGIN TRAN T1 UPDATE table1 UPDATE table2 SELECT * from table1 UPDATE table3 COMMIT TRAN T1 Transactions are units of work that either completely succeed, or can be rolled back completely. If an error such as a disk full, a key violation, or user error occurs during the transaction, it simply rolls back (undoes) all of the operations to the beginning of the transaction. This is safe and robust because the data is guaranteed to be left in its initial consistent state. While recovering from exceptions is difficult in C++, it is extremely easy in databases with transactions. The Atomic Library (calumgrant.net/ atomic) I present here implements transactions in C++, based on database transactions. Here is the same example using a transaction: December 2007 l www.ddj.com l Dr. Dobb’s Journal 49 http://www.dynamicpdf.com http://www.dynamicpdf.com http://www.cete.com http://www.cete.com http://www.ddj.com

Table of Contents Feed for the Digital Edition of Dr. Dobb's Journal - December 2007

Dr. Dobb's Journal - December 2007 Contents Hmmmm Alia Vox Developer Diaries Developer’s Notebook Computer Books: Reading Between the Lines Conversations Query Anything with SQLite XQuery Web Maps with the Google Map API OpenALM and Its Manifesto Transactional Programming Effective Concurrency The Agile Edge Swaine’s Flames

Dr. Dobb's Journal - December 2007

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.