Lock Free Linked List using Compare & Swap. Final Project Distributed Algorithms and Systems

Transcription

1 Lok Free Linke List using Compre & Swp Finl Projet Distriute Algorithms n Systems Lwrene Bush Computer Siene Deprtment Rensseler Polytehni Institute Troy, New York April 30, 2002 Astrt For my projet, I implemente Lok-Free Linke List. This entile the retion of new t strutures n lgorithms, the simultion of the ompre&swp synhroniztion primitive n writing multi-three simultion n test progrm. The t strutures re templte so tht they n store ny t type. I strte with the metho tht John Vlois explins in his pper Lok-Free Linke Lists Using Compre&Swp n in his Thesis Lok-Free Dt Strutures n moifie it so tht it oul e implemente in C Prolem Desription This is nlogous to ro onstrution. A system must e use to insert n elete piees of ro while rs re still going own the ro. This is omplishe y using uxiliry noes, the Compre&Swp primitive to swing pointers n reful mnipultion n heking of the t struture opertions. Auxiliry noes re noes tht ontin next pointer ut no t. These noes re inserte etween the rel noes in linke list (shown elow s the lue rrows). Auxiliry noes This projet resses the issue of onurrent ess to shre t. This is importnt to pplitions in prllel lgorithms, istriute omputing, user-level thre implementtion n multiproessor operting systems. When multiple proesses onurrently ess shre t the most importnt issues re t integrity n performne. Dt integrity n e mintine using stnr mutul exlusion methos, however, this omes with performne ost. An Astrt Dt Type (ADT), whih llows onurrent opertions y ifferent proessors without using mutul exlusion while ensuring t integrity, is presente in John Vlois pper Lok-Free Linke Lists Using Compre-n- Swp. 1 The ADT presente in his pper iffers from previous Universl methos euse his ADT iretly mnipultes the t struture to improve performne. The Lok-Free Linke List presente in the pper llows onurrent trversl, insertion n eletion opertions y ifferent proesses without orrupting the t struture. Compre&Swp ( shown elow ) is synhroniztion primitive tht tomilly ompres n uptes vlue. Compre&Swp Synhroniztion Primitive ool Compre&Swp ( Type * x, Type ol, Type new) { // BEGIN ATOMIC if *x!= ol { *x = new; return TRUE; } else { return FALSE } // END ATOMIC } 5 20

2 The use of synhroniztion primitive implies tht the ADT uses mutul exlusion. Tehnilly, it oes. However, the ADT mkes only limite use of hrwre level tomi opertions to swing pointers in the insert n elete opertions. The ojetive of this projet is to implement these ies. 2. Relte Work The ojetive of Lok-Free t strutures is to voi performne elys while ojets re in the ritil setion. Lok-Free t strutures re lle wit-free. They gurntee prtiulr level of performne even if the onurrent ojets hlt. Orinry synhroniztion primitives use mutul exlusion. There re silly 2 types of mutul exlusion: loking n usy witing. They re oth mrre with iffiulties. In loking, onvoying n elok re two potentil prolems. Priority inversion is prolem with usy witing. Convoying mens tht one slow or elye proess in the ritil region ffets ll the other proesses witing for it. The prolem of elok ours when two (or more) proesses re witing for resoure tht the other is using. If usy-witing mutul exlusion is eing use then the following sitution known s priority inversion n result. Suppose tht CPU sheuler is using priority sheuling metho where the high priority proesses lwys tke preeene over the low priority proesses. Then, high priority proess using the CPU n e witing for resoure hel y low priority proess. The result is tht the low priority proess will never get to use the CPU n the high priority proess will never get to use the resoure. Lmport isovere tht these prolems n e voie using Lok-Free methos. He spent twenty-seven yers onsiering the enefits of voiing mutul exlusion. Lmport rete the first Lok-Free lgorithm for the single-writer/ multiple reer shre vrile. Lmport s hievements spurre muh more reserh n, onsequently, improvements in the fiel of Lok-Free methos. Msslin n Pu oine the term Lok-Free. They wrote multi proessor Operting System kernel using Lok-Free t strutures. Lok-Free is n lterntive to mutul exlusion. It oes not require exlusive ess. Lok-Free t strutures implement onurrent ojets without the use of mutul exlusion. This metho mkes tions pper tomi. Confliting opertions o not orrupt the t struture. Vlois metho llows simultneous trversl, insertion n eletion. Herlihy i reserh on universl synhroniztion primitives. Compre&Swp is universl primitive. A universl primitive is one tht solves the onsensus prolem. Herlihy showe tht universl primitive is neessry n suffiient to implement Lok-Free ADTs. An lgorithm tht provies Lok-Free funtionlity for ny generi ADT is lso lle universl. Universl mens for ny. Doing this requires powerful synhroniztion primitive. In other wors, primitive tht is powerful enough to solve this prolem is susequently lle universl. It just so hppens tht this prolem is nlogous to the onsensus prolem n, therefore, if it n solve the onsensus prolem, it n o Lok-Free t strutures. There re urrently universl (for ny ADT) wit free methos ut they hve too muh overhe to e effiient. This pper shows iret implementtion tht is more effiient. Vlois uses single wor version of Compre&Swp whih is ommonly ville on most systems. 3. Solution Desription For this projet, I implemente Lok-Free Linke List, Test lss n relte lgorithms. The Lok-Free Linke List is shre strt t type (ADT) tht llows opertions y ifferent proessors to our t the sme time. 2

3 For this implementtion I rete the following lsses: List Clss Noe Clss Itertor Clss Test Clss Lok Clss CritilSetion Clss Auxiliry noes Together, the List, Noe n Itertor Clsses provie the following funtionlity: 20 Trverse Insert Delete Synhroniztion is provie y simulting the Compre&Swp primitive using the Lok n CritilSetion lsses. Eh noe hs its own istint lok to synhronize the swinging of its next pointer. The Test lss uses multiple thres to simulte istriute onurrent opertions on the list. Consier the following exmple where n insert n elete simultneously our on jent noes. We re going to elete Noe while inserting Noe. Step One: Crete n onnet Noe n n ompnying uxiliry noe. Step One Atthment 4 ontins omplete esription of eh progrm file. The 2 most funmentl spets of this implementtion re pointer swinging n the use of uxiliry noes. Pointer swinging entils reing pointer n then using the ompre n swp primitive to tomilly rehek n hnge the pointer. Pointer swinging resolves ontention when onfliting opertions our. The result is tht one of the opertions fils. An exmple of this is if two proesses ttempt to elete the sme noe. An uxiliry noe is noe with only next pointer ( no t ). We insert n uxiliry noe in etween eh ell in the list (shown elow s the lue rrows). This llows jent opertions to tke ple without interfering with eh other. Step Two: ->next->next = Step Two

4 Step Three: ->next->ompre_n_swp_next(, ->next) Step Three Itertor In the insert/elete exmple ove, it is not ler how the lgorithm knows where the vrious pointers re. This is omplishe through the itertor ojet. The itertor in my implementtion is nlogous to the ursor in Vlois pper. It is like pointer on sterois. It is use to inite where to insert n elete. An itertor ontins the following 3 noe pointers: trget pre_ell pre_ux 23 These re shown in the piture elow. Step Four: uxiliry noe next = noe ->next->ompre_n_swp_next(, ) Itertor ( t noe ) pre_ux Step Four pre_ell trget 20 We n see from ove tht when n insert is performe forwr pth remins for ny trversing proess. If eletion is performe the elete noe mintins forwr pth for ny trversing proess. In grge olletion system, tht elete noe will ontinue to exist until there re no more pointers to it. However, in my implementtion, I use the ssumption regring Memory Mngement stte in Vlois pper on pge 7: We hve thus fr ssume tht new ells oul e llote whenever neessry, n tht elete ells oul e left intt for ursors to ontinue trversing them. 24 It lso ontins its own funtions. Its most funmentl opertion is the forwr trversl ( ++ ). This is implemente through opertor overloing s shown in the following oe: itertor opertor++(int n) { itertor temp; temp = *this; go_next(); return temp; } ool go_next() { if(trget->is_lst_noe()) { return flse; } pre_ell = sfere(trget); pre_ux = sfere(trget->next); upte_itertor(); return true; } Note tht the ove onurreny epition only estlishes the si logil onstrut for the opertions n not the entire implementtion. 4

5 voi upte_itertor() { if ( pre_ux->next == trget ) { return; } list_noe * p = pre_ux; list_noe * n = p->next; while ( ( n->is_not_lstnoe() ) && n->is_ux_ell() ) { pre_ell-> ompre_n_swp_next( p, n ); p = n; n = sfere(p->next); } // en while pre_ux = p; trget = n; } // en itertor upte The first funtion (upte_itertor) is overloe. It is postfix itertor, therefore it prepres to return the previous vlue of the itertor. It then lls go_next. The go_next funtion moves the pre_ell pointer forwr to the trget pointer n moves the pre_ux forwr to the next ell. It then lls upte_itertor whih is where the trget finlly gets set. The finl estintion trget is epenent on the lotion of pre_ux. If pre_ux lrey points to trget, then the itertor oes not nee upting n the funtion returns. However, while iterting forwr, it will nee upting. Therefore the funtion moves two temporry pointers (p n q) progressively forwr until the n pointer is pointing to norml ell (with t) rther thn n ux_ell. This will e the next norml ell fter pre_ell. Then it sets the pre_ux n trget n returns. Note tht if the upte funtion enounters string of ux_noes long the wy, it will remove the extr ones using the ompre n swp funtion. Uner high ontention, extr ux_noes n our. This is y esign. However, s pge 3 of Vlois pper inites, hins of uxiliry noes re permitte in his lgorithm, lthough they re unesirle for performne resons. Therefore, ny pssing itertor removes them. The ove C++ oe oes not show the full etil of every funtion lle uring the itertion proeure; however, it oes show the si logi ehin the opertion. 4. Solution Anlysis To test this ADT I rete seprte lss whih runs progrm test sequene. The test sequene ws written to e exhustive (mny inserts, eletes n trversls) n to rete lot of ontention. The test progrm runs 40 onurrent thres. Eh thre mkes out 1,000 insertions n 400 eletions for totl of out 40,000 insertions n out 16,000 eletions. The funtion TestFuntionG (in the tthe file test.pp) performs this thre speifi testing sequene. The test sequene is s follows: Eh thre mkes 500 insertions. It oes this 10 noes t time, n then moves the itertor k to the eginning of the list. Eh thre then performs the following sequene 100 times. 1. Move the itertor to the egining of the list. 2. Iterte to the 25 th ell (note iterting skips uxiliry ells). 3. Delete 2 noes. 4. Iterte 2 noes forwr. 5. Insert 3 ells. 6. Move the itertor to the eginning of the list. 7. Iterte to the 25 th rel noe. 8. Insert 3 noes. 9. Iterte forwr 2 noes. 10. Delete 2 noes. Eh of the 40 thres operte onurrently. The generl ie is tht the eletions woul use the inserting itertors to fll k to its position. This woul then mke them perform opertions on the sme ell or on iretly jent ells, reting ontention. The test progrm trks vrious sttistis to verify the results. The ontention rete y the numerous insertions n eletions uses some of the insertions n eletions to fil. This is the intene ehvior of the ADT. When n insertion or eletion fils, it returns the vlue of flse. When n insertion or eletion is suessful, it returns the vlue of true. 5

6 Eh thre keeps trk of how mny insertions n eletions it mkes. It lso keeps trk of how mny of these fil. Eh thre then lultes net numer of itions to the list (i.e. suessful insertions suessful eletions). Eh thre then s these figures to the (net) totl numer e to the test t struture (using synhroniztion ojet to prevent re onitions on the vlue). Tht numer is shown elow s the Sum of thres net itions to the list. The numer of suessful n unsuessful insertions n eletions for eh iniviul thre is lso shown in the Smple Output Atthment 3. One interesting point tht the t revels is tht the thre tht finishes first typilly hs fewer file insertions n eletions thn the other thres. This is euse it h more time in the insertion re y itself (or without s mny other onurrently operting thres). In other wors, it experienes less ontention. The sme is true for the thres tht finish lst. Note tht the thres re run in orer (1 40) ut they o not neessrily finish in tht orer. This relly epens on how muh CPU time eh thre is given. The list t struture lso trks these itions n eletions. A synhroniztion ojet lso protets the hnges to this vlue. Tht numer is shown elow s the List internl /elete ounter: ListSize. After ll of the thres hve quit, the progrm runs n integrity test on the list. This is run in non-onurrent moe. It s up ll the norml n uxiliry noes in the list n reports the figures ( List internl /elete ounter: ListSize n totl_ux_ells ). You n see from the t elow tht ll 3 mesurements inite the sme numer of norml ells in the list. This shows tht the list funtions re orretly exeuting the insertion n eletion requests. It lso mens tht the ADT orretly reports to the thres when these opertions fil. In ll the tests I performe, these numers lwys mthe. There re only 4 file eletions in this run. There re usully 0 5 for this prtiulr test. The test ttempts to rete s muh ontention s possile y hving 40 onurrent thres ll inserting n eleting in the sme re of the list (pproximtely from noe 20 40). However, using eletions to fil requires more ontention thn using insertions to fil. The t in the Atthment 3 shows list of the first 1,000 noes in the finl list. The t elow lso shows the totl numer of rel noes n uxiliry noes. There is 1 more uxiliry noe thn norml ell in the finl list. This is perfet euse we nee t lest one more uxiliry noe so tht there is one efore n fter eh ell. The lgorithm oes not gurntee tht there will e just 1 more uxiliry noe thn rel noes. However, this is usully the se. Sometimes there re few more thn neee. The lgorithm ttempts to remove them ll, ut epening on the type n mount of ontention, it n leve some extrs. They will e lene up lter, ut t ny given moment, there my e some extr uxiliry noes in the list. This is onsistent with the intene opertion of the ADT. Atthment 3 inlues report on the ontents n type of the first 1,000 ells so tht you n see tht this is so. The list lso ontins 1 senoe n 1 lstnoe (the lst noe is not shown in the report). DATA Report from the tres: Sum of thres net itions to the list = Integrity test : totl_norml_ells. = totl_ux_ells = List internl /elete ounter: ListSize = You n see from the t in Atthment 3 tht there were numerous insertion filures. This is normlly the se. It is smll perentge of the totl ttempts ut with 40,000 inserts, the smll perentge is signifint numer (out 600 in totl). 6

7 5. Conlusion In onlusion, the ADT performe extly s expete. Note: The test isusse ove ws run on 600 MHz AMD Compq Presrio running Winows 98. When the sme test is run on Winows 2000 XP mhine with fster proessor, the results re ifferent. The ifferene is tht on the XP mhine there re no insert or elete filures. This is most likely ue to the fster proessor. It oul lso e ue to the wy user spe thres re llote CPU time, prtiulrly when nother thre is loking. Running itionl thres in omintion with ifferent n more ggressive insertion, trversl, eletion pttern, woul most likely rete, itionl ontention n susequent insertion/eletion filures. Plese refer to Atthment 5, files test.pp n test.h for the omplete test sequene oe. Referenes Atthments: 1. Instrutions 2. Test Sequene 3. Smple Output 4. Progrm File Desriptions 5. Coe Printouts: min.pp test.h test.pp lokfreelist.h lok.h lok.pp ritilsetion.h ritilsetion.pp 6. Min Referene Pper: J. Vlois. Lok-Free Linke Lists Using Compre n Swp. 7. Projet Proposl 1. J.D. Vlois. Lok-Free Linke Lists Using Compre-n Swp. In Proeeings of the Fouteenth Symposium on Priniples of Distriute Comuting (1995) 2. J.H. Anerson. Lmport on Mutul Exlusion: 27 Yers of Plnting Sees (2001) 3. H. Msslin n C. Pu. A Lok-Free Multiproessor OS Kernel. Tehnil report CUCS M. Herlihy. Impossiility n Universlity Results for Wit-Free synhroniztion. In Proeeings of the Seventh Symposium on Priniples of Distriute Computing. 7