Atomicity and consistency issues in service composition and transactional memory

点击翻译按钮获取中文摘要

The concept of transactions has been fundamental for providing fault tolerance, reliability and robustness for database applications. Over the years, researchers have been trying to achieve similar transactional guarantees for other, non-database, applications. This proposal is concerned with incorporating transactional properties for services in the area of Services Computing and for memory operations in the area of Transactional Memory. A transaction is an execution of a program. It is committed when the execution is complete and successful. Otherwise, it is aborted and partial execution, if any, is rolled back. Thus, a transaction is an atomic unit. Each transaction, when executed alone, is assumed to be correct. A concurrent execution of several transactions is taken to be correct when the execution is equivalent to some serial execution of the same transactions. In Services Computing, the general vision is that services can be (i) described in an implementation-independent and ``semantic'' fashion, (ii) published in generally accessible repositories, (iii) found in standard ways, by clients, (iv) composed into new services fitting their needs, and (v) executed by referring back to the service providers behind their selection. Composite services may further be composed into higher level services. ``Black box'' services are gradually replaced by services whose executions can be monitored and even controlled (in a limited way) by consumers. My research aims at incorporating transactional properties for such services to enable flexible and dynamic compositions. In Transactional Memory, memory operations are grouped into atomic units. Demarcation into atomic units is intended to free the programmers from explicit synchronization of different units using locks, critical sections, etc. Nesting of the atomic units occurs naturally, with procedure calls. I propose to work on characterizing correct concurrent executions of atomic units and on compositional properties. The ultimate goal is to make concurrent programming easy. This will facilitate increasing the speed of computation, especially in multi-core machines.