I have designed and implemented a new concurrency control algorithm based on explicit versioning [Middleware '03]. This algorithm, in conjunction with the conflict-aware scheduling strategy which orders and avoids conflicts, improves scaling for problem frequent-conflict applications at the cost of extra annotations of the application code.
Using this combined algorithm called distributed versioning, I have investigated the overhead of using a uniform consistency model (serializability) for a variety of applications (e-commerce, auction sites, bulletin boards). To this end, I have compared the scaling of distributed versioning on these applications with the scaling of both a traditional eager protocol providing a strong consistency model and several lazy protocols providing different levels of specialized loose consistency. I showed that my solution is lightweight enough such that it incurs no penalty for enforcing strong consistency in applications that only require loose consistency. Moreover, distributed versioning can substantially improve performance for applications that do require strong consistency where the only correct protocol has previously been the eager protocol. This allows for a simple programming model that users are already familiar with, and familiar abstractions such as transactional isolation and atomicity. The programmer specifies the transactions in the application code whenever atomicity is required. In addition, the technique requires that the tables accessed in a particular transaction are declared at the beginning of the transaction, which can be automated with a simple parser. Further improvements can be achieved if within a particular transaction, the programmer specifies the last use of each table (which could also be automated by a compiler).