MODELS FOR STUDYING CONCURRENCY CONTROL PERFORMANCE ALTERNATIk ES AND IMPLICATIONS

AT&T Bell LaboratorIes Murray Hill NJ 07974

Michael J Care\ Mvon L.n n\

Computer Sciences Department Unnerslh of Wlsconsm Madison WI 53706

.4BSTRACT

A number of recent studies hale exammed the performance of concurrent\ control algorithms for database manage- ment s\stems The results reported to date rather than bemg defimove ha\e tended to be contradIctor> In 011s paper rather than presenting “yet another algorithm per- formance stud)” we crlbcally mvesngate the assumwons made m the models used m past studies and their Imphca- tlons We employ a “complete” model of a database emlronment to study the relatn~e performance of three dlf- ferent approaches to the concurrency control problem under a \arleb of modehng assumptions We shon how differences m the underlymg assumpnons explam the seem- mgl\ contradlctorq performance results We also examine how reahsnc the various assumptions would be for “real” database sqqtems

1 IWRODUCTION Research m the area of concurrency control for data-

base systems has led to the development of many con- currenck control algorithms Most of these algorithms are based on one of three basrc mechamsms lodmg [Mena Rose78 Graj79 Lmd79 Ston79] rrmestamps [Reed78 Thorn79 BernSOb] and oprnrsru concurrency control (also called commit-hme \ahdabon or certdicanon) IBada79 Casa79 Kung81 Cer182] Bernstem and Good- man [Bern81 Bern821 sur\ey manv of the algorithms that hate been developed and describe how nea algorithms ma) be created b\ combmmg the three basic mechanisms

This research waz parnaIl\ supported bv the Wsconsm Alumm Research Foundanon Evanonal Science Foundanon Grant Number DCR-84028 18 and an IBM Facultv Development Award

Pertmwon to copy wthout fee all or part of this matenal IS granted prowded that the copies are not made or dlstrlbuted for direct commercial advantage, the ACM copyrIght notxe and the title of the pubhcatlon and its date appear, and notIce IS gwen that copymg IS by pern-uwon of the Assoclatlon for Computmg Machmery To copy otherwse, or to repubhsh, reqmres a fee and/or specific permwon

0 1985 ACM o-89791-160-l/85/005/0108 $00 75

Gl\en the e\er-growmg number of atallable con- current) control algorithms conslderable research has recently been deleted to elaluatmg the performance of the barlous concurrency control algorithms The beha\lor of lockmg has been mbesngated usmg both slmulatlon [Spit76 Rles77 Rles79a Rles79b Balt82 Lm82bl and analyacal models [ Iran79 Pot180 Gracll Good83 Reut83 Thorn83 Tal84a Ta\84b] A quahtatne stud) that chstussed performance ISsues for a number of dlstrl- buted locking and omestamp algorithms was presented m (BernSOa] and an emplrrcal comparison of ceveral con- currency control schemes uas gl\en m I Pem83] Recentlq the performance of different concurrency control mechamsms habe been compared m a number of slmula- non studies The performance of lockmg was compared with the performance of basrc nmestamp ordermg m IGall and with basic and mulhverslon nmestamp order- mg m [ Lm83] The performance of several alternanves for handlmg deadloch m lockl?g algorithms was studled m IBaIt Results of experiments comparmg lockmg to the optlmlsnc method appeared m IRob182a Rob182b] and the performance of several carlants of lockmg basic timestamp ordermg and the opnmlstuz method were compared m ICare83a Care841 Fmallq the performance of several Integrated concurrent) control and recover) algorithms were evaluated m IAgra83a Agra83b]

These performance studies are mformanbe but the results that hale emerged Instead of bemg definmve have been very contradIctor\ For example studies b\ Care\ and Stonebraher ICare and Agrawal and DeWm IAgra83al suggest that an algorithm that uses blockmg Instead of restarts IS preferable trom a performance vlewpomt but studies bl Ta) ITak84a Ta\84b] and Baiter et al IBait suggest that restarts lead to better perfor- mance than blochmg Optimlsuc methods outperformed lockmg m IFran whereac the opposite results were reported in IAgra83b Care83aJ Results reported m IGall82j regardmg lockmg versus basic umestamp ordermg contradict those of ILm83] ’

’ Tins last example ulll not be addressed further m ttw paper

Each of the previous studies employed a different per- formance model and several of the studies were based on assumptions that have no clear phvslcal meanmg In this

paper instead of presentmg “bet another performance study * we address the assumphons made m the models used m past studies and their Implications We begm by estabhshmg a framework based on a complete and (we believe) “reahsnc” model of a database management sys- tem Our model captures all the main elements of a data- base environment mcludmg both users (I e termmals the source of transacbons) and phwcal resources for stormg and processing the data (I e disks and CPUs) m addition to the usual model components (workload and database characteristics) Based on this framework we show how differences m assumpnons explam the apparently contradlc- tory performance results from the previous stu&es We also examine what assumptions are reasonable for real sys- tems and how more reahsbc assumpuons would have altered the conclusions of several of the earlier studies

In parncular we cribcally examine the common assumpuon of rnjntte resources A number of anal?tlcal studies (for example IFran Tal84a Ta784b]) and simulabon studies (for example (Lm82b Lm83j) compare concurrency control algorithms under the assumption that transactions progress at a rate independent of the number of concurrent transactions In other words theq proceed m parallel rather than m an interleaved manner ThlS IS

only reallq possible m a system with enough resources so that transachons neter have to wsut for CPU or l/O Service - hence our choice of the phrase “mfinrte resources” We will m\esugate thus assumption by performing studies with trul\ infinite resources with multiple CPU-I/O de\- ices and wrth transactlons that thmk while holdmg locks The infinite resource case represents an “Ideal” system the mulhple CPU-I/O device case models a class of mulhpro- cessor database machines and having transactions thmk while executmg models an mteracuve workload

We examine three concurrency control algorithms in this study two lockmg algorithms and an opbmlsbc algo- nthm, which differ as to when and how they detect and resolve confhcts Section 2 describes our choice of con- currency control algorithms We use a simulator based on a closed queuing model of a smgle-site database system for our performance studies The structure and characteristics of thus simulator are described in Section 3 Section 4 presents the performance experiments and our results In Section 5 we summarize the mam conclusions of our study

2 CONCURRENCY CONTROL STRATEGIES

A transaction T IS a sequence of acuons (al a2 an} where a, IS either read or write Given a concurrent execution of transactions action a, of transacnon T, and acnon a of T confrrcr If they access the same obJect and either (I 4 a, Is’read and a IS write or (II) a IS write and a IS read or write The Jarrous concurren& control algo! rlthms basIcall> differ m the time when the\ drrect CO~I~IC?S and the wa\ that they resolve conjrcts IBern 1 For thus studc we have chosen to examme three concurrency control

algorithms that represent extremes m conflict detection and resolution

BlocXq Transacbons set read locks on objects that the\ read and these locks are later upgraded to write locks for objects which they also write If a loch request IS

demed the requestmg transaction IS blocked A waits-for graph of transacnons IS maintained ]Gra!79] and deadlock detecnon IS performed each time a transaction blocks If a deadlock IS discovered the youngest transacuon m the deadlock cycle IS chosen as the vlcbm and restarted Dynamic two-phase lockmg ]Gray79] IS an example of this

strategy Immedrate-Restart As m the case of blockmg transac-

tions read-lock the ObJects that they read and they later upgrade these locks to write locks for ob’ects which they also write However If a lock request IS denied the requesbng transachon IS aborted and restarted after a restart delay The delay period which should be on the order of the expected response bme of a transactjon prevents the same conflict from re-occurring repeatedly A concurrency control strategy slmllar to this was considered m ]Tay84a Tay84b J

Opttmcstx Transactions are allowed to execute unhm- dered and are validated only after they have reached their commit points A transachon is restarted at its commit point If It finds that any obJect that It read has been written by another bansaction which committed during its hfetlme The opbmisbc method proposed bq hung and Robinson ]Kung8l] IS based on this strateg\

These algornhms represent two extremes with respect to when confhcts are detected The blocking and Immediate-restart algorithms are based on dynamic lockmg so confhcts are detected as the) occur The opnmlsnc algo- rithm on the other hand does not detect conflicts untd transacuon commit time The three algorithms also represent two different extremes with respect to conflict resolution The blochmg algorithm blocks transacbons to resolve conflrcts restarting them onlc when necessar? because of a deadlock The Immediate-restart and opumis- tic algorrthms always use restarts to resohe conflicts

One final note m regard to the three algorithms In the Immediate-restart algorithm a restarted transacnon must be delayed for some time to allow the conflicting tran- sacDon to complete otherwise the same lock conflict will occur repeatedl) For the ophmlstic algorithm It IS unnecessary to delal the restarted transacbon as anv detected conflict IS with an already commmed transaction A restart delah IS also unnecessary for the blocking algo- rithm as the same deadlock cannot arise repeatedly

3 SlMULATiON MODEL Central to our simulator for studying concurrency

control algorithm performance IS the closed queumg model of a single-site database system shown m Figure I This model IS an extended version of the model used m [Care83a Care841 \shlch m turn had its origins in the model of ]Rles77 Rles79a Rles79b] There are a fixed number of tetmmals from which transactions originate

109

TERMINALS

l

J

1:

Figure I Log& Queumg Model

There IS a hmlt to the number of transactions allowed to be achve at an) ome m the system the mulhprogrammmg level mpl A transacnon IS consldered active If It IS either recelvmg service or watmg for service mslde the database system When a new transaction orrgmates If the system already has a full set of active transachons It enters the readv queue where It waits for a currently active transaction to complete or abort (transacbons m the ready queue are not considered acttve) The transaction then enters the cc queue (concurrency control queue) and makes the first of its concurrency con@01 requests If the concurrency con- trol request IS granted the transacbon proceeds to the objecf queue and accesses its first ObJect ff more than one object IS to be accessed prior to the next concurrency con- trol request the transacbon ~111 cycle through this queue several hmes When the next concurrency control request IS required the transaction re-enters the concurrency con- trol queue and makes the request It IS assumed for model- mg convemence that a transacbon performs all of Its reads before performmg any writes In one of the performance studies later In the paper we examme the performance of concurrency control algorithms under Interactive work- loads The thmb path m the model provides an optlonal random delay that follows object accesses for this purpose

2 The simulator mamtams backup copies of transactIon read and write sets

More ~111 be sad about modeling Interactive transacuons short11

If the result of a concurrency control request IS that the transacnon must bloch It enters the blocAed queue until It 1s once agam able to proceed If a request leads to a declslon to restart the transaction II goes to the back of the ready queue posslblj after a randomly determined restart delay period of mean reszartde/o\ (as In the Immediate- restart algorithm) It then begins mahmg all of the same concurrency control requests and obJect accesses over agam ’ Eventuallv the transaction ma) complete and the concurrency control algorithm may choose to commit the transactlon If the transactton IS read-onl) It IS finished If It has wrltten one or more objects during its execution however It first enters the update queue and writes its deferred updates mto the database Deferred updates are assumed here because our slmulatlon framework IS

Intended to support an\ concurrency control algorithm - all algorithms operate correctly with deferred updates but not all algorithms work with recovery schemes that do m- place updates

To further Illustrate how transachons flow through the model we brlefly describe how the locking algorithms and the opfimlsbc algorithm are modeled For lockmg each concurrency control request corresponds to a lock request for an ObJect and these requests alternate with ObJect accesses Locks are released together at end-of-transaction (after the deferred updates have been performed) Walt queues for locks and a watts-for graph are mamtamed by an algorithm--specific pornon of the simulator For optlmls- tic concurrency control the first concurrency control request IS granted lmmedlately (I e it IS a “no-op”) all ObJect accesses are then performed with no intervening concurrency control requests Only after the last object access IS fimshed does a transachon return to the concurrency control queue m the optimlsbc case at which nme Its vahdatlon test IS performed (followed If successful by its deferred updates)

Underlymg the loglcal model of Figure 1 are two phy- slcal resources the CPU and the I/O (I e disk) resources Associated with the concurrency control object access and deferred update serllces m Figure I are some use of one or both of these two resources The amounts of CPU and I/O bme per loglcal service are specified as slmulauon parame- ters The phjslcal queumg model IS depjcted m Figure 2 and Table I summarizes Its associated slmulabon parameters As shown the physical model IS a collechon of termmals multiple CPU servers and mulnple I/O servers The delay paths for the think and restart delays are also reflected m the physlcal queumg model Slmula- tlon parameters specify the number of CPU servers the number of l/O servers and the number of terminals for the model When a transaction needs CPU service It IS asslgned a free CPU server, otherwise the transaction wants unnl one becomes free Thus the CPU servers ma) be thought of as bemg a pool of servers all Idenbcal and serv- mg one global CPU queue Requests m the CPU queue are ser\lced FCFS (first-come first-served) except that

.lO

TERWYALS

Figure 2 Physical Queuing Model

concurrent\ control requests hate prIorIt\ ocer all other serbice requests Our Ii0 model IS that of a partltroned database where the data m the database IS spread out across all of the disks There IS a queue associated ulth each of the I/O servers When a transacnon needs serklce It chooses a disk (at random with all disks bemg equall) Ilkelk) and waits m an 1/O queue associated with the selected dish The service dlsclphne for the 110 queues IS also FCFS

The parameters obj-to and obJ-cpu are the amounts of I/O and CPU time associated W&I readmg or wrlhng an obJect Readmg an object takes resources equal to obJ-to followed by obj-CpU Wrlhng an object takes resources equal to obj-cpu at the Dme of the write request and obJ-co at deferred update hme as It IS assumed that bansachons mamtam deferred update hsts m buffers In mam memory These parameters represent constant service time require- ments rather than stochasnc ones for slmphc@ The e\tlh&.-nrne parameter IS the mean of an exponenDal hme dlstrlbubon which determmes the time delay between the complebon of a transacuon and the mltlatjon of a new tran- saction from a termmal Fmall) the rrrtr/nrlhrrme param- eter IS the mean of an exponential time dlstrlbutlon which determmes the mtra-transaction thmh time for the model (If any) To model mteracuve workloads transactions can be made to undergo d thmkmg period between fimshmg their reads and startmg their writes

A transactjon IS modeled according to the number of obJectc that it reads and writes The parameter rratLstze IS

Parameter Meanmg db-size number of obJects In database tran-srzr ttUZLSlZC mm-we wrrte-prob restart-delaj num-ret ms mpl e~Lthttth-ttttw tnttlmh.rtttte objm.ro objmcpu nut?lcpus ttutt~drsls

mean size of transacbon size of largest transacnon size of smallest transacnon Pr(wrlte X 1 read X) mean transactlon restart delay number of termmals multiprogramming level mean time between transactions mean mtra-transacnon think time I/O hme for accessmg an ObJect CPU hme for accessmg an ObJeCt number of cpus number of disks

Table I Simulation Parameters

the average number of objects read by a transachon the mean of a umform dlstrlbubon between MlLslze and I)zcL*sIze (mcluslve) These objects are randomly chosen (without replacement) from among all of the ObJectsi In the database The probability that an object read by a transac- hon ~111 also be written IS determined by the parameter trrtreprob The size of the database IS assumed to be db- stze

The reader may have noted the absence of exphclt concurrency control cost parameters We assume for the purpose ot this study that the cost of performmg con- currency control operahons IS neghglble compared to the cost of accessing objects It has been shown elsewhere that the concurrenct control request processing costs for algo- rithms based on lockmg and ophmlshc methods are roughly comparable ICare83bj the mam difference being the hmes at which these costs are Incurred so this assumption should not bias our results

4 PERFORMANCE EXPERIMENTS We performed a number of slmulatlon experiments to

study the lmphcahons of different assumpbons on the per- formance of the three concurrency control algorithms described m Secbon 3 We first examined the performance of the three strategies in the case of very low conflicts We then mvesbgated the performance under the mfmlte resources assumpcron with hmlted resources and with multiple CPUs and disks Last ue examined the case Of an Interactike workload

Table 2 gives the stmulatlon parameter values used for the experiments reported here (except where otherwise noted) The parameters that car) from experiment to experiment are not hsted In the table but wdl Instead be given m the descrlptlon of the experiments The database and transaction sizes were selected so as to lomtlq yield E region of okration which allous the mteresbng perfor- mance effects to be observed ulthout necesqnatmg impossi- bly long slmulatlon times These sizes are expressed in pages as we equate objects and pages In 0-11s stud\ The multlproglammmg level IS \arred between a hmn of 5 tran- sactlons and a lrmlt of the total number of termmals set to 200 m this stud\ to allon a range of confhct probabihues

111

---”

T 120

h

r

cl 80

”

8

h 40

P

”

t

0 - blocking 0 - immediate-restart A - ophmlsnc

I I

50 loo 1.50 200

Muloprogrammmg Level

Figure 3 Throughput (Infinite Resources)

to be mvestlgated The object processmg costs were chosen based on our notion of roughly what realistic values might be We employed a modified form of the batch means method [Sarg76] for our stahsbcal data analyses and each emulation was run for 20 batches with a large batch hme to produce sufficiently bght 90% confidence mtervals 3 The actual batch bme varied from experiment to experiment, but the throughput confidence Intervals were typically m the range of plus or minus a few percent of the mean value more than sufficient for our purposes We discuss only the stansucally slgmficant performance chfferences when summarlzmg our results All throughput results are expressed in units of transactions per second and response bmes are given m seconds

Throughout the paper we use a fixed set of symbols for represenbng the data pomts obtamed from the three dlf- ferent concurrency control algorithms These symbols are summarized at the top of each of the pages with graphs

4 1 Evperlment 1 Low Conflict Sltuatlon For the first experiment we used a larger database

size of 10 000 objects Due to the large database size and the relanvelj small transachon size there were few con- fl~cts In this experiment The throughput results for a sys- tem W&I miinrte resources and a system wtth finite resources (I CPU and 2 disks) are shown m Figures 3 and 4 respecnvelb The performance of the three concurrent) control strategies was close m both cases confirming the results reported In [Care83a, Care84, Agra83a Agra83b] and elsewhere - If confhcts are rare It makes little chffer- ence which concurrency control algorithm IS used In both cases. blochng outperformed the other two algorithms by a small amount Note also that the throughput curves reach a plateau at a mulbprogrammmg level of 75 In Figure 3 (the mfimte resource case) This IS due to the fact that

3 More InformatIon on the details of the mod&d batch means method rrav be found In [Care83a]

6

T

h

”

B

h2

P

”

t 1

50 loo 150 200

Mulnpropmmmg Level

Figure 4 Throughput (1 CPU 2 Disks)

with 200 terminals a I second think time and an execu- bon bme of 500 mllhseconds (on the average) mcreasmg the allowed number of acnve transactions beyond 75 has no effect - all avadable transacuons are ahead) acnve and the rest are in the think state A plateau IS reached earher m Figure 4 (the finite resource case) because the resources are saturated with 25 concurrently acbve transacuons

Smce we were Interested in mveshgatmg differences m concurrency control strateges we decreased the database size to 1000 objects (as shown in Table 2) to create a sltua- bon where conflicts are more frequent The rest of the experiments were performed using this database size

4 2 Experiment 2 Infinite Resources The next experiment examined the performance

characterlsncs of the three strategies assuming infinite resources for a variety of mulbprogrammmg levels With mfinite resources as the mulhprogramtnmg level IS

Increased the throughput should also increase In the absence of data contenbon However for a given Size data- base the probablhty of confhcts increases as the mulbpro- grammmg level increases For blcckmg the increased confhct probablhq ~111 manifest Itself In the form of more

Parameter Value db- stze 1000 pages traxstze 8 page readset ma32lze 12 page readset (maximum) tmasrze 4 page readset (mmimum) wrtreprob 0 25 nuttL terms 200 termmals mpl 5 10, 25, 50, 75 100 and 200 extthrnLttme I second obj- 10 35 mdhseconds obkcpu 15 milliseconds

Table 2 Simulahon Parameter Settmgs

112

0 - blockmg CJ- Immediate-restart A - opbmlsbc

90

T

h

”

B

h30

d

50 100 I50

Multlprogrammmg Level

Figure 5 Throughput (lnfimte Resources)

1

200

blocking due to demal of lock requests and an Increased number of restarts due to deadlocks For the restart- orlented strategies the htgher probablht? of confhcts will result m a larger number of restarts

Figure 5 shows the throughput results for Experiment 2 Blockmg starts thrashmg as the multlprogrammmg level 1s increased beyond a certam level whereas the throughput keeps mcreasmg for the opnmlshc algorithm These results agree with predlchons m [Fran831 that were based on slml- lar assumpbons Figure 6 shows the average number of bmes that a transactjon was blocked and restarted per com- mlt called the block ratlo (dotted Ime) and the restart rabo (solid lmes) for the three concurrency control algorithms Note that the thrashmg m blockmg IS due to the large Increase m the number of times that a transacnon IS blocked, which reduces the effect!\e mulnprogrammmg level rather than to an mcrease m the number of restarts This result IS m agreement with the asseruon m [salt82 Tay84a, Tay84b] that under low resource contentlon and a high level of mulhprogrammmg blockmg ma? start thrash- mg before restarts do Although the restart ratlo for the op0mlstic algorithm Increases qulcklq with an Increase m the mulbprogrammmg level new transacbons start execut- mg m place of the restarted ones, keepmg the effechve mulhprogrammmg level high and thus entsulmg an Increase rn throughput

Unhke the other two algorithms the throughput of the Immediate-restart algorithm reaches a plateau This hap- pens for the followmg reason When a transacbon IS res- tarted m the lmmedlate-restart strategy, a restart delay IS Invoked to allow the confhctmg transactlon to complete before the restarted hY+fWIchon IS placed back m the ready queue The duration of the restart delay 1s exponenual with a mean equal to the runnmg average of the transaction response time - that IS the durabon of the delay IS adap- tlve depending on the observed average response time We chose to employ an adaphve delay after performmg a sense-

5

4

C r

0 3 a

n t

f 2 I

1 0

1 I s

e

t

20

I5

D

e 10

I

a

Y5

50 100 150 200

Muluprogrammmg Level

Figure 6 Confhct Ranos (Infimte Resources)

--(p--e- /-------+-J

I 1 1 I t

50 100 I50 200

Muluprogrammmg Level

Figure 7 Response Time (Infimte Resources)

tiv~ty analysis that showed us that the performance of Immexhate-restarts IS senslhve to the restart delay nme par- hcularly In the mfimte resource case Our experiments mdlcated that a delay of about one transactlon time IS best and that throughput begms to drop off rapIdly when the delay exceeds more than a few transacnon times Because of this adapbve dela). then the lmmedlate-restart algorithm reaches a state where mcreasmg the multlprogrammmg level does not result m an actual Increase m the number of acuve transactlons - there are no transacnons waltmg m the ready queue so mcreasmg the allowed populanon has no effect All of the non-active transactions are either m a terminal thmkmg state or a restart delay state

Figure 7 shows the mean response time (sohd Imes) and the standard devlanon of response hme (dotted hnes) for each of the three algorithms The response hmes are baslcally what one would expect given the throughput

113

I - .

0 - blochmg c - Immediate-restart A - optlmlstlc

6-

T

h

u

g

h 2-

P

” 0 I

so 100 Muluprogrammmg Level

150 200

” 1 I I I 8

SO 100 I.50 200

Muluprogrammmg Level

Figure 8 Throughput (I CPU 2 Disks) Figure 9 D~sb Uhhzanon (I CPU 2 Disks)

results plus the fact that we have employed a closed queu- mg model TINS figure does Illustrate one Interesting phenomenon that occurred m nearly all of the experiments reported m 011s paper The standard denanon of the response brne IS smaller for blockmg than for the Immediate-restart algorithm o\er most of the multlprogram- mmg levels explored - the response nme variance for the Immediate-restart algorithm IS quite slgnlficant A high variance m response time IS undesirable from a user s standpomt

4 3 Experiment 3 Resource-Lunlted Sltuatlon In Experiment 3 we analyzed the Impact of fimte

resources on the performance characterlsfics of the three concurrency control algorithms A database system with I CPU and 2 disks was assumed for this experiment The throughput results are presented m Figure 8

Observe that for all three algorithms as the mulnpro- grammmg level IS Increased the throughput first Increases then reaches a peak and then finally either decreases or remams roughly constant In a system with fimte CPU and l/O resources the achievable throughput may be con- stramed bq one or more of the followmg factors It ma) be that not enough transacoons are avallable to keep the sys- tem resources bus) Alternabvely It may be that enough transactlons are avallable but because of data contenhon the “useful” number of transacuons IS less than what 1s requtred to keep the resources “useful])” bus) That IS transactlons that are blocked due to loch confhcts are not useful ylrnllarlq the use of resources to process transac- tlons that are later restarted IS not useful Fmall) It ma\ be that enough useful non-confllctmg transactions are a\allable but that the a\allable resources are alread) saturated

the resources ubhzed at low levels of muluprogrammmg Figure 9 shows the total (sohd hnes) and useful (dotted hnes) disk utdlzauons for thus experiment The useful utlh- zatlons mdlcate the fraction of the resources used to do work that actually completed (1 e they exclude the frachon used for worh that was later undone by restarts) The ut111- zanon of the disks IS selected here because the disks are the bottleneck resource with our parameter settmgs Note the direct COrrdahOn between the useful unhzaclon curves of Figure 9 and the throughput curves of Figure 8 a trend that IS evident m all of the experiments reported here For blocbng the throughput peaks at mpl = 25 where the disks are bemg 97 2% uuhzed with a useful utlhzatlon of 92 1% lncreasmg the muluprogrammmg level further onlj Increases data contention and the throughput decreases as the amount of blockmg and the number of res- tarts Increase at a much faster rate For the optrmlsnc algorithm the useful uhhzaQon of the disks peaks at mpl = IO and the throughput decreases with an increase m the mulhprogrammmg level because of the increase In the res- tart ran0 This restart ratlo increase means that a larger fraction of the disk hme IS spent on processmg ObJects that WIII be redone later For the lmmedlate-restart algorithm the throughput also peaks at mpl = IO and then decreases remammg rough]) constant beyond 50 The throughput remams constant for this algorithm for the same reason as described m the last experiment - mcreasmg the allowable number of transactlons has no effect beyond 50 as all of the non-acme transachons are either thmkmg or m a res- tart delay state

As the multlprngrammmg level was Increased the throughput first Increased for all three concurrent\ control algorithms as there were not enough transactions to keep

With regards to the throughput for the three strategies several observauons are m order First the maxlmum throughput (I e the best global throughput) was obtamed with the blochmg algorithm Second lmmedlate-restarts performed as well as or better than the opumlshc algo- rlthm There were more restarts ~lth the cptnnlqnc algo- rlthm and each restart was more cxpenslve this IS

u

114

80

D

e60

I

a40

0 - blockmg 0 - immediate-restart A - OphmlShc

6 T

h

”

t2

h 2

P

”

t

I 1 so loo 150 200

Mulaprogrammmg Level

Flgure IO Response Time (I CPU 2 Disks)

reflected m the relahve useful disk uhhzatlons for the two strategies Fmallq the throughput achieved with the Immediate-restart strategy for mpl = 200 was somewhat better than the throughput achieved with either blockmg or W&I the optlmlstlc algortthm

Figure IO gives the average and the standard devlahon of response nme for the three algorithms m the fimte resource case The differences are eben more nohceable than m the mfimte case Blochmg has the lowest delay (fastest response time) over most of the muluprogrammmg levels The Immediate-restart algorithm IS next and the OphmlstX algorithm has the worst response time As for the standard de\lahons blochmg 1s the best Immediate- restarts IS the worst and the optlmlstlc algorithm IS m between the two As m Experiment 1 the Immediate- restart algorithm exhlblts a verv high response hme \arl- ante

One of the pomts rzused earher merits further dlscus- slon Should the performance of the Immediate-restart algorithm at mpl = 200 lead us to conclude that Immediate-restart IS a better strategy at high lecels of mul- hprogrammmg’ We beheve that the answer IS no for several reasons First the mulhprogrammmg level IS Internal to the database system, controllmg the number of transachons that may concurrently compete for data and resources and has nothmg to do with the number of users that the database system may support, the latter IS deter- mmed by the number of termmals Thus one should con- figure the system to control the mulhprogrammmg at a level which gives the best performance In our experiment the highest throughput and smallest standard devlatlon of response hme were achieved usmg the blockmg algorithm at mpl = 50 Second the restart delav m the Immediate-restart strategh IS there so that the confllctmg transactjon can complete before the restarted transactlon IS placed back mto the read\ queue However an unmtended side effect of this restart delac m a svstem alth a fimte

El

Y 9

I so 100 150 200

Muluprogrammmg Level

Figure I I Throughput (Adaphke Delacs)

number of users IS that It hm1t.s the actual mulhprogram- mmg level and hence also hmlts the number of confhcts and resulhng restarts due to reduced data contenhon Although the multlprogrammmg level was increased to the total number of users (200) the actual acerage mulhpro- grammmg level never exceeded about 60 Thus the restart delay provides a crude mechamsm for hmmng the mul- hprogrammmg level when restarts become over]\ frequent and addmg a restart delay to the other two algorithms should Improve their performance at high levels of mul- uprogrammmg as well

To cerlf\ this latter argument we performed another experiment where the adapbve restart delay was used for restarted transacnons m both the blochmg and optimlsbc algorithms as well The throughput results that we obtamed are shown m Figure I I It can be seen that mtro- ducmg an adaptlbe restart delay helped to hmlt the mul- hprogrammmg level for the blochrng and optlmlstlc algo- rnhms under high conflrcts as It does for Immediate- restarts reducmg data contentlon at the upper end of the curves Blockmg emerges as the clear wmner and the performance of the opttmlstlc algorrthm becomes compar- able to the Immediate-restart strategy The one negative effect that we observed from addmg this dela) was an Increase m the standard devlahon of the response hmes for the blockmg and ophmlshc algorithms Smce a restart delay only helps performance for high mulfiprogrammmg levels It seems that a better strategy IS to enforce a lower mulhprogrammmg level hmlt to aved thrashmg due to high Contenhon and to mamtam a small standard deviation of response hme

4 4 Experuuent 4 Multiple Resources In thus experiment we moved the system from fimte

resources towards Infinite resources We increased the number of resources avallable to IO CPUs and 20 disks and then to 25 CPUs and 50 disks to determme where finrte

115

0 - blocking 0 - Immediate-restart A - ophmlsbc

~32

h

r 24

0

”

lt’6

h

8 20

h

P IO

”

t

-3

( I so 100 150 200

Multlprogrammmg Level

Figure I2 Throughput (IO CPUs 20 Disks)

I I I 1

so 100 150 200

Muluprogrammmg Level

Figure I4 Throughput (25 CPUs 50 Disks) Figure I5 Disk Udlzation (25 CPUs 50 Disks)

resources start behavmg hhe mfimte resources m a mul- hprocessor database machme environment

For IO CPUs and 20 disks the behavior of the three concurrency control Grategles was farrly slmllar to the behavior m the case of I CPU and 2 disks The throughput results for 011s case are shown m Figure I2 and the disk uhhZi3hOn figures for thus case are given In Figure I3 Blocking agam provided the highest overall throughput For large mulbprogrammmg levels however the Immediate-restart strategy probIded better throughput than blockmg but not enough to beat the hrghest throughput probIded by the blockmg algorithm In this resource configuratlon the maxlmum useful uhhzations of the dlshs with the blockmg lmmechate-restarts and the opnmlstlc algorithm were 55 5% 44 6% and 466% respective]) ahereas the maximum total disk utihzahons

u

t

I

I

I

2.

a

t

1

0

”

U

t

I

t

I

z

a

t

I

0

”

IO

08

06

04

02

I I 1 0

so 100 150 200

Muloprogrammmg Level

Figure I3 Disk Unhzatlon (10 CPUs, 20 Disks)

10

08

06

04

1 1 1

so loo 150 200

Muluprogrammmg Level

were 61 8% 72 6% and 94 I% Note that due to res- tarts the total utlhzabons for the restart-oriented algorithms are higher than those for blockmg the difference IS par- hall) due to wasted resources By “wasted resources” here we mean resources used to process ObJects that were later undone due to restarts - these resources are wasted m the sense that they were consumed mahmg them una- vallable for other purposes such as background tasks

For 25 CPUs and 50 dlshs the maximum throughput obtamed with the ophmlstlc algorithm beats the maxImum throughput obtamed W&I blockmg (although not by very much) The throughput results for this case are shown m Figure I4 and the unhzatlons are given m Figure I5 The total and the useful disk uhhzabons for the maxlmum throughput pmt for blockmg were 33 5% and 30 I % (respechvely) whereas the correspondmg numbers for the

116

OptImlstK algorithm were 62 6% and 32 6% Thus the optimlshc algorltbm has become attracnve because a large amount of otherwlse unused resources are akalable and thus the resources wasted due to restarts does not adversely affect performance In other words W&I useful uhhzations m the 30% range the system begms to behave somewhat like It has mfimte resources

Another mtereshng observation from these results 1s that with blockmg resource unhzauon decreases as the level of mulaprogrammmg increases and hence throughput decreases This IS a further mdlcatlon that blockmg may thrash due to wamng for locks before It thrashes due to the number of restarts IBaIt Tay84a Tay84b] as we saw m the mfimte resource case On the other hand with the optimlstlc algorithm as the mulhprogrammmg level Increases the total ubhzatlon of resources and resource waste Increases and the throughput decreases somewhat Thus thus strategy ecentuallq thrashes due to the number of restarts (I e because of resources) With Immediate- restarts as explamed earher a plateau IS reached for throughput and resource utlhzanon because the actual mul- bprogrammrng level IS hmlted b\ the restart dela) under high data contention

4 5 Experiment 5 Interactive Worhloads In our last experiment we modeled mteractl\e tran-

sacbons that perform a number of reads thmk for some period of nme and then perform tbelr writes This model of mteractlve transactIons was momated by a large hod\ of form-screen apphcatlons where data 1s put up on the screen the user ma\ change some of the fields after starmg at the screen for a while and then the user types “enter” causmg the updates to be performed The intent of this experiment was to find out whether large mtra-transacnon - Internal - thmk times can cause a system with finrte resources to behake hke it has mfimte resources The mteractlve workload experiment was performed for Internal thmh times of 1 5 and IO seconds At the same hme the external thrnh times were Increased to 3 11 and 21 seconds (respectIveI\) m order to keep roughly the same rauo of thmkrng transactions to active transactIons We hate assumed a fimte resource environment W&I 1 CPU and 2 disks for the system m thus experiment

Figure paus (16 17) (18 19) dnd (20 21) show the throughput and drsk utlhzatlons obtamed for the I 5 and 10 second Inter-transactjon thmk time experiments (respec- bvely) On the average a tranqactlon requires 150 mll- hseconds of CPU hme and 350 mdhseconds of disk time so Internal thmk times of 1 5 and 10 seconds thus consld- erablq Increase the duration for which a locks are held Thus causes the resource ubhzabon for blockmg to decrease as the Internal thmk hme Increases With the opbmlsbc algorithm the demand for resources IS also reduced due to large thmk ames and the resources start behavmg as though they were mfimte resources Consequendy for large thmk times the opnmlsbc algorithm performs better than the blockmg strategy (see Figures 18 and 20) For an Internal thmk time of 21 seconds the useful utihzabon of resource5 IS much higher with the opfimrstlc algorrthm than

the blockmg strategy and the highest throughput value IS also conslderablq higher For 5 seconds of internal thmk hme the throughput and the useful utlhzatlon n1tl-1 the optlmlshc algorithm IS also better than for blockmg For a I second Internal thmk bme however blockmg performs better (see Figure 16) The resource unhzauons here are such that wasted resources due to restarts makes the optlmlsnc algorithm the loser

The highest throughput obtamed W&I the opumlstlc algorithm was consIstentI> beael than that for Immediate- restarts although for higher levels of multlprogrammmg the throughput obtamed w1tl-1 Immediate-restarts uas better than the throughput obtamed wltb the optlmlsbc algorithm due to the mulbprogrammmg-hmmng effect of Immediate- restart s restart delay As noted before 011s high multipro- grammmg level difference could be reversed bq addmg a restart delay to the optlmlsnc algorithm

5 CONCLUSIONS AND IMPLICATIONS One major conclusion of 011s stud) IS that for medium

to high levels of resource utihzatron a blockmg algorltbm hke dynamic two-phase lockmg IS a better choice than a restart-orlented concurrency control hke the Immediate- restart or optlmlstlc algorithms However If resource Utah- zatlons are sufficlentlq low that a large amount of wasted resources can be tolerated and m addmon there are a large number of transactions acallable to execute then a restart- orlented algorithm IS a better choice We found the optlmlsbc algorithm to be the best choice under these con- dmons Such 10~ resource utlhzatlons could arlse m a database machme with a large number of CPUs and disks and a number of termmals slmllar to what one finds m typ lcal tlmesharmg systems today Thev could also arise m prlmarlly Interactive apphcahons where very large thmk times occur and the number of termmals IS such that the utllizahon of the system is low as a result It 1s an open quesnon whether or not such low uhhzabons could really occur m real systems If not blocking algorithms will remam the preferred method for database concurrency con- b-01

Another result of this study IS that we have re- confirmed results from a number of other studies mclud- mg those reported m IBaIt Agra83a Agra83b Care83a Care84 Fran83 Taj84a Tay84bJ We have shown that seemmgl) contradictor\ results some of which favor bloch- mg algorithms and others of which favor restarts are not contradIctor\ at all The studies are all correct w&m the hmlts of their assumptions partlcularlq their assumpbons about system resources While It IS possible to study the effects of data contention and resource contenuon feparatelk m some models [Tay84a Tay84b] It appears not to be worth domg so If the goal IS to select a concurrency control algorithm for a real system - the proper algorithm choice IS resource-dependent

An mterestmg side result of th~s stud) IS that the level of multlprogrammmg m database systems should be care- fully controlled We refer here to the multtprogrammmg level Internal to the database system controllmg the number of transacbons that ma) concurrent\> compete for

117

0 - blockmg C - Immediate-restart A - ophmisac

6

T

h

r 4

0

”

B

h2

P

”

t I I f

50 loo I50 200

Mulbprogrammmg Level

Figure 16 Throughput (1 Second Internal Thmkmg) Fqure 17

T

“3

r

0

II2

t3

h

P ’

”

t

I ,

50 loo 150 200

Muluprogrammmg Level

Figure 18 Throughput (5 Seconds Internal Thmkmg)

T 3

h

r

g

h I

P

”

t 1

50 loo 150 200

Multlprogrammmg Level

u

IO t

I

08 I

I 06

z

a 04

t

I 02

0

”

U IO

t

I 08

I

I 06

z

P 04

t

I 02

0

”

Figure 19 Disk Ubhzanon (5 Seconds Internal Thmkmg)

10 U

08 1

1

I 06

z

P 04

t

I 02

0

”

I

I

I I 1 ,

50 loo 150 200

Muluprogrammmg Level

Disk Uahzahon ( I Second Internal Thmkmg)

r

‘m---- --__ -- -0

1 1

50 loo I50 200

Muluprogrammmg Level

50 100 150 200

Mulnprogrammmg Level

Figure 2 1 Disk Ubhzabon ( IO Seconds Internal Thmkmg) Figure 20 Throughput (10 Seconds Internal Thmkmg)

118

data, CPU and l/O serkxes As in the case of paging operating systems if the mul~programmmg level is

increased beyond a certain level the blocking and optimis- tic concurrency control strategies start thrashing We have confirmed the results of [Balt82, Fran83 Tay84a. Tay84b] for lockmg in the low resource contention case but more important]> we have also seen that the effect can be signifi- cant for both locking and optimisbc concurrency control under higher levels of resource contention We found that when we delayed restarted transacbons by an amount equal to the running average response time it had the beneficial side effect of limiting the actual mulbprogrammmg level and the degradation in throughput was arrested (albeit a ht- tle bit late) Since the use of a restart delac to limit the mulbprogrammmg level is at best a crude strategv adaptive algorithms that dynamically adJust the multiprogramming level in order to maximize system throughput need to be designed Some performance indicators that might be used in the design of such an algorithm are useful resource utile- zation, running averages of throughput or response time etc The design of such adaptive algorithms IS an open problem

In closing we wish to leave the reader with the fol- lowing thoughts about the future, due to Bill Wulf [ Wulf81)

“Although the hardware costs will contcnue to fall dramatccalll and machme speeds will increase equal- ly dramancalk we must assume that our asplratcons wdl rrse even more Because of thu, we are not about to face either a cvcle or memon) surplus For the near-term fiture the dommant effect wrll not be machme cost or speed alone but rather a contrnumg anempt to mcrease the return from a finite resource - that IS a particular computer at our disposal ”

ACKNOWLEDGEMENTS The authors wish to acknowledge helpful discussions

that one or more of us have had with Mary Vernon Nat Goodman and (especially) Y C Taq Comments from Rudd Canaday on an earlier version of this paper helped us to improve the presentation The NSF-sponsored Crystal multicomputer proJect at the University of Wisconsin pro- vided the many VAX II/750 CPU-hours that were required for this study

REFERENCES

; Agra83a J Agrawal R and Dewitt D Integrated Concurrence Control and Recover Mechan- isms Design and Performance Evaluation Technical Report No 497 Computer SCI-

ences Department University of Wisconsm- Madison February 1983

(Agra83b]

I Bada79]

IBaIt

[Bern80a]

(Bern80bj

[Bern811

[Bern821

ICare83a]

[ Care83b]

] Care841

[ Casa79]

Agrawal, R Concurrent) Control and Recover 111 Multcprocessor Database Machines Design and Performance Evalua- non Ph D Thesis Computer Sciences Department University of Wisconsin- Madison I983 Badal D ‘Correctness of Concurrency Control and lmplicabons in Distributed Data- bases Proceedrngs of the COMPSAC ‘79 Conference Chicago Illinois, November 1979

R Balter P Berard and P Decitre “Why Control of the Concurrency Level in DISWI-

buted Systems is More Fundamental than Deadlock Management Proceedmgs of the First ACM SIGACT-SIGOPS Symposrum on Prmclples of Dlstrlbuted Computmg August 1982

Bernstein P and Goodman N Fundamen- tal Algorcthms for Concurrent\ Control m Du- tnbuted Database Svstems Technical Report Computer Corporanon of America 1980 Bernstein P , and Goodman N

Timestamp-Based Algorithms for Con- currency Control in Distributed Database Systems Proceedmgs of the Stxth Interna- tional Conference on Verv Large Data Bases October 1980 Bernstein P and Goodman N Con- currency Control in Distributed Database Systems ACM Computmg Survevs 13(2) June 1981 Bernstein P and Goodman N “A Sophisbcate s lntroduchon to Distributed Database Concurrency Control Proceedcngs of the Eighth International Conference on Ven Large Data Bases September 1982 Carey M Modelmg and Evaluation of Data- base Concurrent\ Control 4Igorrthms Ph D Thesis Computer Science Division (EECS) University of California Berkeley Sep- tember 1983 Carey M “An Abstract Model of Database Concurrency Control Algorithms Proceed- ings of the ACM SIGMOD Internatronal Conference on Management of Data San Jose California May 1983 Carey, M , and Stonebraker M ‘The Per- formance of Concurrency Control Algorithms for Database Management Systems Proceedmgs of the Tenth lnternatlonal Confer- ence on Very Large Data Bases Singapore August 1984 Casanova M The Concurrency Control Problem for Database Systems Ph D Thesis, Computer Science Department, Harvard University 1979

119

[ Cer1821

[ Fran831

IGall82]

1 Good83]

[Gray791

[Gray811

I Iran791

[Kungll]

[ Lm 82aj

[ Lm82b)

[Lm83]

[Lmd79]

Cerl S and Owlclu S “On the Use of Optimisuc Methods for Concurrency Control m Dlstrlbuted Databases Procecdrngs of the Sixth Berkelex Worhshop on Dlstrrbuted Data Management and Computer Nent or Is Febru- ary 1982 Franaszek P and Robinson J Lunrtatlons of Concurrent\ rn T~ansactlon Processmg Report No RClOl51 IBM Thomas J Wat- son Research Center August 1983 Galler B Concurrem\ Control Performance Issues Ph D Thesis Computer Science Department University of Toronto Sep- tember 1982 Goodman N Surl R and Taq Y A Simple Analytic Model for Performance of Exclusive Lockmg m Database Systems Proceedmgs of the Second ACM SIGACT- SIGMOD Svmpostum on Prrnctples of Database &stems Atlanta Georgia March 1983 Gra) J ‘Notes On Database Operatmg Systems in Operating &sterns An Ad\ awed Course Sprmger-Verlag 1979 Graj J Homan P Korth H and Ober- marck R 4 Strabr Man 4nal\sls of the Pro- babtlln of M’amng and Deadlock In a Database Svstem Techmcal Report No RJ3066 IBM San Jose Research Laborator) February 1981 lram h and Lm H Queuing Network Models for Concurrent Transacnon Process- ing m a Database System Proceedrngs of the ACM-SIGMOD International Conference on Management of Data 1979 Kung, H and Robmson J “On Ophmlshc Methods for Concurrency Control ACM Transactions on Database Svstems 6(2) June 1981 Lm W and Nolte J Dlstrtbuted Database Control and Allocanon Semi-Annual Report Techmcal Report Computer Corporauon of America CambrIdge Massachusetts Janu- ary 1982 Lm W and Nolte J ’ Performance of Two Phase Lockmg Proceedmgs of the St\ th Berkelel Workshop on Distributed Data Management and Computer Nenuorhs Febfu- an 1982

Lm W and Nolte J “Basic Timestamp Mulnple Version TImestamp and Two-Phase Locking Proceedmgs of the Nmth Interna- tional Conference on ken Large Data Bases Florence Ital) November 1983 Lmdsa) B et al Notes on Dlstrrbuted Data- bases Report No RJ2571 IBM San Jose Research Laboratory 1979

Mena 1

Pem83]

[ PohSO]

[ Reed781

IReut83j

Rles77]

Rles79a]

[ Rles79b]

Menasce D and Muntz R “Lockmg and Deadlock Detechon in Dlstrlbuted Data- bases Proceedings of the Third Berkelej Workshop on Distributed Data Management and Computer Networhs August 1978 Peml P and Reuter A EmpIrical Com- parison of Database Concurrency Control Schemes A oceedmgs of the Ninth Interna- tlonal Conference on I/fn Large Databases 1983 Potler D and LeBlanc P Analysis of Lockmg Pohcles In Database Management Systems Communlcatlons of the ACM 23(10) October 1980 Reed D Nammg and Svnchronrzatlon 111 a Decentralaed Computer Svstem Ph D Thesis Department of ElectrIcal Engmeermg and Computer Science Massachusetts lnstl- tute of Technology I978 Reuter A An Anal\ tic Model of Transachon Interference tn Database Sjstems IB 68183 Umverslty of Kaserslautern West Germany 1983

&es D and Stonebraker M Effects of Lockmg Granularity on Database Manage- ment System Performance ACM Transac- tions on Database Systems 2(3) September 1977

Ries D The Effects of Concurrex\ Control on Database Management S\ stem Performance Ph D Thesis Department of Electrical Engmeermg and Computer Science Umver- slty of Cahforma at Berkeley 1979 Rles D and Stonebraker M Loclung Granularity Revisited ACM Tt ansacttons on Database &stems 4(2) June 1979

(Rob182aj Robinson 3 Design of Concurrerw Controls for Transactron Processrng Systems Ph D Thesis Department of Computer Science Carnegie-Mellon Urmerslrq I982

[ Rob182b] Robinson J Expertmcnts 11 rth Transactron Processrng on a Multi-Mwroprocessor Report No RC9725 IBM Thomas J Watson Research Center December I982

[Rose781

[ Sarg761

1 Splt76]

Rosenhrantz D Stearns R and Lewis P System Level Concurrenq Control for Dlstrlbuted Database Systems 4CM Tran- sact/ons on Database S\stems 3(2) June 1978

Sargent R Stz@shcai Analbsls of Simula- non Output Data Proceedrngs of the Fourth Annual Swposlum on the Smlulatron of Com- puter S\stems August 1976 Spltzer J Performance Prototyping of Data Management Apphcatlons Proceed- ings of the ACM 76 Annual Conference October 1976

120

I Stan 791

[Tay84al

ITay84bl

Stonebraker M “Concurrency Control and Consistency of Muluple Copies of Data m Dlstrlbuted INGRES IEEE Transactrons on Software Engrneermg X3) Ma! 1979 Tay Y A Mean Value Performance Model for Loclung m Databases, Ph D Thesis Computer Science Department Harvard Umverslty February 1984 Tay Y , and Sun, R ‘ Choice and Perfor- mance in Lockmg for Databases’ Proceed- mgs of the Tenth International Conference on Ven, Large Data Bases Singapore August 1984

[ Thorn791 Thomas R “A MaJority Consensus Approach to Concurrence Control for Multi- ple Copy Databases ACM Ti ansactlons on Database Slstems 4(2) June I979

[ Thorn831 Thomasian A and Ryu 1 ‘A Decomposl- hon Solutron to the Queuing Network Model of the Centralized DBMS with Static Lock- ‘ng Proceedcngs of the ACM-SIGMETRICS Confirence on Measurement and Modelmg of Computer Svstems Minneapolis MN, August 1983

[Wulf81] Wulf w ‘CornplIers and Computer Archl- tecture IEEE Computer Jul) I98 1

121