Browse Books

Reviewer: Margaret H. Dunham

This book describes an analytic model for examining the performance of database concurrency control algorithms. While the book is accurate, thorough, and informative, I would not recommend it for the casual database user. The content is quite technical and at times requires a high degree of mathematical maturity to comprehend. Based on the author's Ph.D. dissertation, the contents are aimed at database researchers knowledgeable about database concurrency control issues and performance techniques as well as basic calculus, probability, and queueing theory concepts. Given this level of background, the material is quite easy to read. Theorem proofs and mathematical derivations are accurate and straightforward. Overall, I found this book to contain the best comprehensive treatment of any database concurrency control analytic performance model yet presented. The analytic model is defined within the context of locking techniques (both waiting and nonwaiting cases), but appears to be extendable to other techniques as well. The author states in the introduction, “This model must be powerful enough to help us understand, compare, and control the performance of these [centralized concurrency control] algorithms.” The model presented has successfully achieved the majority of these goals. The validity of the approach is demonstrated by simulation output results. Even though the book deals only with the application of the model to centralized locking, the author points out in the conclusion that future directions for research include expanding it to timestamping and distributed systems as well. A major advantage of this model is that the set of parameters needed to describe it has been reduced to the length of a transaction ( k) and the ratio between the number of transactions and the database size ( N/ D). It was found that as N and D change proportionately, the rate of conflict remains constant. This ratio, &lgr; = N/ D, is called the load of the system. One interesting concurrency control performance phenomenon previously demonstrated in other performance studies is carefully examined: as N increases, the system throughput has been observed to increase and then decrease. Tay calls this DC-thrashing and attributes it to the effect of data contention. As N increases, throughput and also conflict among transactions tend to increase, but increased conflict causes a decline in throughput. “The DC-thrashing point is where the two forces balance each other.” Although this phenomenon has been observed before, the author's concise treatment and discussion of its cause are novel, and the term DC-thrashing is new. Two problems that seem to exist with the model are actually shown not to be restrictive. Database access requests are assumed to be uniformly distributed, but it is usually felt that a more accurate view is that a small amount of the database is accessed most of the time (the 80-20 rule). Tay shows that locking behavior under this access pattern is similar to that with a uniform access to fewer database granules. The other problem is that only exclusive locks are examined. A brief evaluation indicates that the use of shared locks could indeed make a “significant difference to the performance.” The author shows, however, that the effect of read locks is to increase the number of database granules accessed. Both of these assumptions have been used in other concurrency control performance studies, but as far as I know this is the first attempt to show that they do not invalidate the model. There are some additional problems, however, which are not examined by the author. A restriction upon the author's investigation of the no-waiting case is that only fixed-length transactions of one type are examined. Another minor fault is the assumption that aborts are instantaneous. Transaction aborts may actually take considerable time, as they cause a transaction undo. An interesting addition to the book is the complete review of previous concurrency control performance studies (experimental and analytic). The author examines each paper, describes the results, and identifies discrepancies between different papers and his own studies, giving possible causes. Because many varying and somewhat contradictory performance results have been published concerning database concurrency control techniques, this review is an added benefit. To summarize, I found the book to present a useful and accurate database concurrency control performance tool. While it is not recommended for casual database users, the content should prove invaluable for database researchers.