Computer Control: Task Synchronisation in Dynamic Priority Scheduling

Transcription

1 Computer Control: Task Synchronsaton n Dynamc Prorty Schedulng Sérgo Adrano Fernandes Lopes Department of Industral Electroncs Engneerng School Unversty of Mnho Campus de Azurém 4800 Gumarães - PORTUGAL emal: sfl@de.umnho.pt Antóno José Pessoa de Magalhães SAIC - DEMEGI Faculty of Engneerng Unversty of Porto Rua dos Bragas 4050 Porto - PORTUGAL emal: apmag@fe.up.pt Abstract Due to common resource protecton, most real-tme tasks have non-preemptve sectons. Such sectons, called crtcal sectons, rse several problems to real-tme schedulng theory. Namely, deadlock avodance and bounded blockng tme. Dfferent and wdely mentoned solutons exst for ths problem n the context of fxed prorty schedulng. However, solutons for the same problem but n the context of totally dynamc schedulng, although much more nterestng, are seldom referred n the current lterature. Ths paper surveys those solutons and llustrates ther phlosophes, provdng thus a consderable help for real-tme systems desgners who develop or ntent to develop ther applcatons upon EDF or other totally dynamc schedulng algorthm. Keywords: Dscrete Dgtal Control Systems, Computer Control, Real-Tme Schedulng and Task Synchronzaton. Introducton Real-tme systems are those that must perform correctly not only the value but also n the tme doman. Computer controllers are probably the most known real-tme systems. Ths s because a controller must obey to some tme constrant n sensng the envronment and perform control actons accordngly. There are many areas of nvestgaton n real-tme systems. One of the most nterestng and challengng s the schedulng theory. Ths s partcularly true when tasks have to synchronse ther executons. The dynamc schedulng algorthms are known for a long tme. Lu and Layland [] showed that Rate Monotonc (RM) and Earlest Deadlne Frst (EDF) are optmal for fxed and dynamc prorty systems, respectvely. Unfortunately, Lu and Layland conclusons only apply for ndependent tasks. Yet, n a mult-taskng control system, tasks are lkely to share data or some physcal or logcal devce that cannot be arbtrarly accessed. Tasks that perform n ths way are sad to be dependent, n the sense that tasks executon depend on each other. In ths scenaro, the system must provde some protecton mechansm around shared resources. Otherwse, resource corrupton wll occur due to tasks' concurrent accesses to shared resources. Synchronsaton mechansms (lke semaphores, montors, etc.) can protect shared resources. However, they defne crtcal sectons n the tasks' code. That s, tasks have portons of code that are non-preemptve, from the pont of vew of a task that ntents to enter an already accessed resource. Synchronsaton poses serous problems n dynamc schedulng. Dependent tasks may easly mss ther deadlnes. Such scenaros are totally unacceptable n a hard real-tme envronment. Yet, fndng the optmal schedulng n a preemptve system wth resource sharng s known to be an NP-hard problem[]. However, dynamc prorty schemes are much advantageous: namely, they provde good processor effcency. Therefore, a consderable research effort has been done s the context of dependent tasks dynamc schedulng, and solutons have been found. Unfortunately, those solutons do not seem to have had much echo on real-tme systems desgners. Ths s probably because such solutons are very dspersed n the current lterature and no survey seems to exst. Ths paper surveys and llustrates three solutons for the dynamc schedulng of dependent tasks. A specal emphass s placed on the EDF algorthm. By dong ths, the paper collects the most common solutons to the stated problem and present them n an organsed way. Secton descrbes the problem and the solutons that can

2 S. F. LOPES AND A. P. MAGALHÃES solve t n fxed prorty systems. Sectons, 4 and 5, survey three synchronsaton algorthms for dynamc prorty schedulng. Namely Dynamc PCP, Stack Resource Protocol (SRP) and Interruptble Crtcal Sectons (ICS), respectvely. Secton 6 summarses the most mportant conclusons. Synchronsaton Problems and Fxed Prorty Solutons The two major problems that arse n dynamc schedulng systems are multple prorty nverson and deadlock. Prorty nverson happens when a hgh prorty task has to wat for a lower prorty task to release a shared resource. Fgure shows an example of multple prorty nverson. In here, a ntermedate prorty task preempts a lower prorty task durng the blockng of the hgher prory task by. The up arrows denote tasks' executon request tmes and the down ones denote tasks' executon completon tmes. Crtcal secton that protects resource Crtcal secton that protects resource t t t t 4 t 5 t 6 t 7 Tme Fgure - Prorty Inverson Example. The deadlock problem happens when at least two tasks block smultaneously watng for any other to release a shared resource. Ths scenaro s llustrated n Fgure by and, whle (not sharng any resource wth any of the other tasks) s normally executed. t t t Deadlock t t t t Tme Crtcal secton that protects resource Crtcal secton that protects resource Crtcal secton that protects resource Fgure - Deadlock Example. Two solutons for these problems are presented by Sha, Rajkumar and Lehoczky [] n the context of fxed prorty schedulng, f crtcal sectons are protected by bnary semaphores. These are the Prorty Inhertance Protocol (PIP) and the Prorty Celng Protocol (PCP). The former states that when a lower prorty task executng a crtcal secton blocks a hgher prorty task, t transtvely abandons ts actual prorty and nherts the prorty of the blocked task. The latter defnes a prorty celng for each semaphore, and states that a task can only enter a crtcal secton f ts actual prorty s hgher than the prorty of all semaphores' celngs currently locked by other tasks. The prorty celng of each semaphore equals the prorty of the hghest prorty task that can use t. By usng PCP, both multple prorty nverson and deadlock are prevented. Furthermore, chaned blockng s also avoded. Whst the PCP s not drectly appled to dynamc prorty schedulng, t s a good pont of departure. Moreover, t can be easly adapted to totally dynamc schedulng as t wll be shown n the next secton. Dynamc PCP The Dynamc PCP, frstly presented by Chen and Ln [4], s an extenson of PCP to dynamc prorty schedulng. It assumes that a task prorty s gven by the deadlne of ts current executon f t s pendng; or by the deadlne of ts next executon, otherwse. Snce tasks prortes change wth tme, so do the prorty celngs of the semaphores controllng the access to shared resources. In prorty dynamc algorthms we need to dstngush between a task's prorty and the prorty of ts executons. The former, called orgnal prorty and denoted p(t), depends only on the deadlnes of ts sequence of executons. The latter, called augmented prorty and denoted p * (t), depends also on the prorty nhertance mechansm. The Dynamc PCP s gven by two rules:

3 TASK SYNCHRONISATION IN DYNAMIC PRIORITY SCHEDULING At nstant t, the prorty celng of a semaphore S, c(t), s the orgnal prorty of the hghest prorty task H that locks, or may lock, S at tme t or later. That s, c(t) = p H (t). When the executon of a task tres to lock S, t gets the lock f p * (t) > c H (t), where S H s the semaphore wth hghest prorty celng among all the semaphores locked by others executons at that tme. Otherwse, the task's executon s suspended, and the executon of task L, whch currently locks S H, nherts p * (t) untl t frees S H. Ths soluton, besdes solvng the problems prevously dscussed, possesses an nterestng property: f a task s blocked, that wll occur n ts frst crtcal secton. Therefore, the lock condton only needs to be verfed for the frst semaphore lock of each task. Fgure shows how ths algorthm apples (d(t ) denotes the prorty assocated wth a deadlne at nstant t, accordng to EDF). t 0 t t t t 4 t 5 t 6 t t t Tme Crtcal secton protected by semaphore S Crtcal secton protected by semaphore S Crtcal secton protected by semaphore S t 0 : p = p * = d(t 7 ), p = p * = d(t 8 ) and p = p * = d(t 9 ). c = d(t 7 ), c = d(t 8 ) and c = d(t 8 ). t : p * > p *. t : p * /> c, * p = p * = d(t 8 ). t : p * = P = d(t 9 ). p * = d(t 8 ) > p * = d(t 9 ). t 4 : p * = d(t 7 ) > p * = d(t 8 ), p * > c. t 5 : p = d(t 7 +T ), c = d(t 7 +T ). t 6 : p = d(t 8 +T ), c = c = d(t 8 +T ). p = d(t 9 +T ). Fgure - Deadlock Preventon wth Dynamc PCP. Chen and Ln show that applyng Dynamc PCP synchronsaton, a set of n perodc tasks are schedulable by the EDF f n = C + B, () T where, C denotes maxmum executon tme, T s the perod and B s the prorty nverson bound, of task t. 4 Stack Resource Polcy Baker [5] presents another soluton that extends the PCP n three very useful ways: mult-unt resources allowng other more general resource protecton then smple bnary semaphores do; support for varous schedulng polces EDF, RM, Deadlne Monotonc and combnatons of those; runtme stack sharng resultng n memory savngs, so mportant n real-tme systems. Besdes ts prorty, each task has also an assocated fxed preempton level π. A task may only preempt another task j f π > π j. The preempton levels must be defned n such a way that the prorty concept s not volated (see Baker [5]). One possble defnton s orderng them nversely wth respect to the relatve deadlnes. Each resource R r has a preempton celng, c r (v r ), that depends on the number of unts currently avalable of that resource. The defnton s: c r (v r ) s the maxmum between zero end the preempton levels of all the tasks' executons that may be blocked when there are v r unts of R r avalable. Denotng by µ r ( ), the maxmum needs n unts of a resource R r by a task, the prevous defnton can be stated more formally: c r (v r ) = max ({0} {π : v r <µ r ( )}). ()

4 4 S. F. LOPES AND A. P. MAGALHÃES For smplcty, t s also convenent to defne a global celng of the system π : π = max (c r : r =,...,m}, () where m s the number of resources. Now s then possble to defne the SRP: the request for executon of a task, s blocked untl π >π. Fgure 4 exemplfes the applcaton of ths synchronsaton algorthm n the context of the EDF. Three tasks, and and three resources R, R and R are consdered. The tasks' preempton levels are π =, π = and π =. The number of unts of each resource are NR =, NR = and NR =. Fnally, the maxmum needs of each resource by each tasks are gven n Table. Accordng to these parameters, preempton celngs of each resource for each number of avalable unts are gven n Table. R r µ r ( ) µ r ( ) µ r ( ) R R 0 R Table - Maxmum resource needs of the tasks represented n Fgure 4. R r c r (0) c r () c r () c r () R 0 R R 0 Table - Preempton celngs for the tasks represented n Fgure 4. π π = π = π = 0 Allocaton of unts of resource R Allocaton of unts of resource R Allocaton of unts of resource R t t t t t 4 5 Tme t 0 : c () = 0, c () = 0, c () = 0 and, therefore, π =0. t : (, R,), π = c (0) =. t : π /> π. t : c () = 0, (, R,), π = c (0) =. t 4 : π /> π. t 5 : π = c () = 0, π >π. Fgure 4 - SRP Example. Baker also proves that a set of n tasks (perodc and aperodc), wth relatve deadlnes equal to the perod (D =T ), s schedulable by the EDF f k C Bk k : +. (4) k=,..., n T T = It s worth notcng that ths result s better than the one provded by the Dynamc PCP (compare wth equaton ), n the senses that there s only one blockng term n the sum. Also worth notng s that the runtme stack sharng can be acheved smply by defnng ts preempton celng as zero. As t never blocks any executon, t may be gnored n the computaton of the prorty nverson bounds B k. k

5 TASK SYNCHRONISATION IN DYNAMIC PRIORITY SCHEDULING 5 5 Interruptble Crtcal Sectons So far we've seen two pessmstc synchronsaton protocols, n the sense that they cause blockng. Yet, optmstc (.e. non-blockng) concurrency control exst. One of these technques s the ICS protocol presented by Johnson [6]. The advantages of the ICSs nclude: no hgh prorty task ever wats for a lower prorty one and the synchronsaton protocol s ndependent of the schedulng algorthm. However, ICSs have ther own lmtatons: ther purpose s to protect shared data (objects) and t takes a lttle more overhead for the operatng system durng context swtches. The ICSs are based on Restartable Atomc Sequences (RASs). A RAS s a sequence of code that s re-executed from the begnnng f t s nterrupted by a context swtch. Each operaton on the shared object (executed n an ICS) computes ts modfcatons n a prvate set of records obtaned from a global stack of records. To commt the operaton the ICS has to: remove from the global stack the records used; add to the global stack the garbage records; lnk the new records to the shared data structure by changng the value of a ponter. The operaton s commtted by the executon of a decsve nstructon. Every shared object has a commt record and a flag that ndcates f ts commt record s vald or nvald. The executon of an ICS s: If a prevous operaton has left a vald commt regster, t executes the respectve wrtes to the shared object (the change s asserted cleanng phase) and sets the flag nvald. Computes ts changes n the prvate set of records and wrtes them n the commt regster. Sets the commt regster flag vald (decsve nstructon). Fgure 5 llustrates ths method appled to the case of a lnked lst. Data GlobalRecordStack GarbageHead current g GarbageTal g struct CommtRecordElement { word *lhs, rhs; } CommtRecord[MAX]; boolean vald; record *GlobalRecordStack; ICS () { record *current, *GarbageHead, *GarbageTal; word nstructon; RAS { f (Vald) { nstructon = 0; whle (nstructon < && CommtRecord[nstructon].lhs!= NULL) { *(CommtRecord[nstructon].lhs) = CommtRecord[nstructon].rhs; nstructon ++; } vald = FALSE; } current = GlobalRecordStack; // ncates lst ponters GarbageHead = GarbageTal = NULL; // computes modfcatons to the data structure CommtRecord[0].lhs = &(GarbageTal->next); // save modfcatoms n CommtRecord CommtRecord[0].rhs = current; CommtRecord[].lhs = &GlobalRecordStack; CommtRecord[].rhs = GarbageHead; CommtRecord[].lhs = CrtcalLnk; CommtRecord[].rhs = CrtcalLnkValue; vald = TRUE; // commts the operaton } } Fgure 5 - ICS Appled to a Lnked Lst Data Structure.

6 6 S. F. LOPES AND A. P. MAGALHÃES By ensurng that no hgh prorty task s blocked by a lower prorty one, ths algorthm prevents prorty nverson. Fgure 6 llustrates ths property; t assumes that, before t, the last operatons upon O e O were accomplshed by and, respectvely. ICS whch accesses object O ICS whch accesses object O Cleanng phase of the operaton of task t t t t 4 t 5 t 6 t 7 Tme Commt regster fllng up phase Fgure 6 - Prorty Inverson Preventon wth ICSs. The schedulablty analyses for ths synchronsaton algorthm s not known by the tme of ths wrtng. The only boundng stated by Johnson n [6] s that, under the worst possble scenaro, a task executes twce each crtcal secton. Therefore, we have: n C E + I, j, (5) j= where, E s the maxmum executon tme of the task excludng the duraton of crtcal sectons, and I,j s tme spent executng the j th crtcal secton of task. 6 Concluson General purpose synchronsaton prmtves that may lead a task to unpredctable blockng tmes or deadlocks are no soluton for real-tme systems. Feasble solutons to ths problem exst. Moreover, they are wdely refereed n the current lterature, but mostly n the context of fxed prorty schedulng. Consequently solutons for real-tme task synchronsaton n the context of dynamc schedulng are mostly unknown to most real-tme systems desgners. Ths paper has ntended to full ths gap by surveyng, llustratng and comparng the most mportant solutons presented n the specalsed lterature. We hope ths can help real-tme communty n desgnng modern and realstc control systems based on dynamc algorthms. References [] C. L. Lu and J. W. Layland, 97, "Schedulng Algorthms for Multprogrammng n a Hard Real-Tme Envronment", Journal of the ACM, vol. 0, no.. [] A. K.-L. Mok, 98, "Fundamental Desgn Problems of Dstrbuted Systems for the Hard-Real-Tme Envronment", Ph.D. Thess, Massachsetts Insttute of Tecnhology. [] L. Sha, R. Rajkumar and J. Lehoczky, 990, "Prorty Inhertance Protocols: An Aproach to Real-Tme Synchronzaton", IEEE Transactons on Computers, vol. 9, nº 9. [4] M.-I. Chen and K.-J. Ln, 990, "Dynamc Prorty Celngs: A Concurrency Control Protocol for Real- Tme Systems", Journal of Real-Tme Systems, vol., nº 4. [5] T. P. Baker, 99, "Stack-Based Schedulng of Realtme Processes", Journal of Real-Tme Systems, vol., nº. [6] T. Johnson, 99, "Interruptble Crtcal Sectons for Real-Tme Systems", Techncal Report, Department of Computer and Informaton Scence, Unversty of Florda.