Polling Efficiently on Stock Hardware

Transcription

1 Polling Efficienly on Sock Hardware Marc Feeley D6paremen d nformaique e Recherche Opi%aionnelle Universi4 de Monr&l C.P. 628, SUCC. A, Monr&l, Canada H3C 3J7 f eeley@iro.umonreal. ca Absrac Two sraegies for supporing rwynchronous inerrups are: he use of he processor s hardware inerrup sysem and he use of polling. The advanages of polling include: porabdiy, simpliciy, and low cos for handling inerrups. Unforunaely, polling has an overhead for he explici inerrup checks insered in he code. This paper describes balanced polling, a mehod for placing he inerrup checks which has a low overhead and also guaranees an upper bound on inerrup laency. This mehod has been used by Gambi (an opimizing naive code compiler for Scheme) o suppor a number of feaures including muliprocessing and sack overflow deecion. The overhead of balanced polling is less han for ca/j-reurn polling which places inerrup checksa every procedure enry and exi. The overhead of call-reurn polling is ypically 70% larger (bu someimes over larger) han heoverhead of balanced polling. nroducion n his paper, he erm inerrup is defined se an excepional even for which some special processing is needed (e.g. a heap overflow). The handling of an inerrup is done in hree phases. The inerrup is raised when he even occurs. A some poin afer his he processor deecs he inerrup and hen handles i by invoking he appropriae inerrup handler. There are wo ypes of inerrups. Synchronous inerrups can only be raised a well defined locaions in he code (e.g. an arihmeic overflow or invalid poiner dereference). Asynchronous inerrups can be raised a any locaion (e.g. aimeror user inerrup).. Deecing inerrups There are essenially wo ways in which inerrups can be deeced. They can be deeced auomaically by he processor s hardware or by explici checks insered in he code. These will be called implici and ezplici deecion respecively. On sock hardware, he following inerrups are ofen deeced implicily: arihmeic overflows, address alignmen errors, address ranslaion errors, and user and imer inerrups. The following inerrups are usually deeced Permission o copy wihou fee all or par of his maerial is graned provided ha he copies are no made or disribued for direc commercial advanage, he ACM copyrigh noice and he ile of he publicaion and is dae appear, and noice is given ha copying is by permission of he Associaion for Compuing Machinery. To copy oherwise, or o republish, requires a fee and/or specific permission. ACM-FPCA 93-6/93 /Copenhagen, DK e 993 ACM O XJ S.50 explicily: sack and heap overflows, read and wrie barriere (for incremenal [3] and generaional [0] garbage collecion), and ype errore and range errors. This classificaion depends on he capabiliies of he hardware and oher implemenaion consrains. n principle all inerrups could be deeced explicily and i is mainly for performance reasons (bu someimes for simpliciy) ha hey are deeced implicily. Sack overflows can for example be deeced implicily by placing an invalid guard page a he sack s limi. This however may be expensive or overly burdensome o do for a muliasking syeem which mus mainain several small sacks. There are oher reaaons why explici deecion may be preferable o implici deecion. mplici deecion is less porable because he rapping mechanism varies from processor o processor. Porabiliy can be increased somewha by relying on sandard libraries such as he UNX signal.h rouines bu his increases he cos of each inerrup and i only gives access o he mos common ypes of inerrups. Anoher problem wih implici deecion on sock hardware is he high coe of handling an inerrup. Curren rap archiecures ener kernel mode o process he inerrup. This requires ha he processor s sae (all of he regisers or some significan eubse) be saved and laer resored. f he rap handler is in user space, wo addiional ransiions beween user and kernel space are needed. Explici deecion has a much lower cos. The main reasons are ha conrol remains in user space, he call o he inerrup handler can be open coded and/or specialized, and a minimum number of regisers have o be saved (since he compiler knows which regisers are live and possibly which are clobbered by he handler). Unforunaely, he cos of deecing he inerrup (Tdeec ) applies o all poenial inerrup poins. Explici deecion will only be more efficien han implici deecion if inerrups are sufficienly frequen o make he following inequaliy rue Tde.. < p(tampica - TexP[ici ) where p ie he probabdiy ha an inerrup is deeced, and Tamp{aca and Te$pl,.~ are respecively he imes o handle he inerrup in each approach. As a concree example for synchronous inerrups, aasume ha an arihmeic operaion has o be checked for overflow and ha a single branch on overflow insrucion cam deec his (i.e. Td=ec = l), Assuming TmPlic$ Te=p~,c~ is 00 insrucional, explici Johnson [8] repors a cos of 06 insrucions on he SPARC o ake an overfiow rap on he TAD DccTV insrucion, This cos 79

2 deecion will be preferable if p >.0, ha is if here is an overflow a leas once ou of every 00 imes he arihmeic operaion is execued..2 Asynchronous nerrups The handling of asynchronous inerrups is an issue in many languages and sysems bu his paper looks a he issuesin he conex of a Lisp sysem because Lisp sresses many problems (e.g. garbage collecion and small funcions). The mehods described here are however applicable o oher languages. Because hey can be raised a any poin in he program, asynchronous inerrups pose special problems..2. Criical Secions To suppor garbage collecion, Lisp sysems mus mainain a memory sae ha can be parsed by he garbage collecor. However, he sysem s sae can emporarily become inconsisen in he middle of some code sequences. Soring a 64 bi poiner ino z migh for example ranslae ino a sequence of wo 32 bl sore insrucions. Since immediaely afer he firs sore z does no conain a valid poiner, he sysem mus insure ha z is no accessed, eiher explicily or by he garbage collecor, before he second sore is performed. Oher cases where he sysem poenially eners an inconsisen sae include: updaing sysem srucures, saving Lisp objecs in locaions no scanned by he garbage collecor, and saving non Lisp objecs in locaions scanned by he garbage collecor (e.g. when clearing or exracing a poiner s ype ag, and unboxing numbers). nerrups are a problem because hey can no be processed in an inconsisen sae if he inerrup handler migh call he garbage collecor or oherwise access he par of he sae which is inconsisen. This is a definie possibiliy y if he inerrup handlers are wrien in unresriced Lisp or if he sysem suppors user inerrups (for enering a break loop) or preempion inerrups (for muliasking). Eiher he sysem is carefully designed o never ener inconsisen saes (which precludes a number of compiler opimizaions), or he code sequences are proeced wihin uninerrupible criical secionsz. When inerrups are deeced implicily, a simple implemenion of criical secions is o inhibi inerrups for he duraion of he criical secion. This can be done by surrounding i wih a pair of insrucions o disable and enable he inerrups. nerrups raised during a criical secion will ge handled when he inerrups are reenabled a he end of he criical secion. This approach suffers from a high overhead for he added disabe/enable pairs bu he overhead can be reduced somewha by using a single pair around a grouping of criical secions. Techniques ha compleely avoid he overhead of disable/enable pairs do exis. Maclisp and Lucid Common Lisp keep he locaion of all criical secions in a able. When an inerrup is raised, he address of he inerruped insrucion is looked up in he able. f he inerrup was raised inside a criical secion, he res of he criical secion is firs execued and hen he inerrup handler is called. does no accoun for he processing of he overflow, so T*mP,* ~Z will be roughly 00 insrucions. e? %= Some sysems suppor user specified cr}ical secions. However, only criical secions ha span a few insrucions are considered here since his funcionaliy is sufficien o suppor user specified criical 6eci0ns. Maclisp achieves his by single sepping he code o he end of he criical secion (by he use of he PDP-0 s XCT insrucion)3. Lucid Common Lisp uses his sraegy for he inernal subrouines called by compiled code [4]. T [9] has a slighly differen zero cos sraegy ha does- no use ables. When an inerrup is raised, he coninuaion is modified so ha soon afer he criical secion is finished he inerrup handler is called. Anoher sraegy [], designed specifically for he problem of allocaion in a muliasking sysem, also single seps he inerruped code bu no on every inerrup. nsead, i is he garbage collecor which single seps each ask if is program couner indicaes ha i is in he middle of an allocaion. When inerrups are deeced explicily, criical secions are easy o implemen. The compiler simply has o insure ha inerrup checks are only generaed in safe places (i.e. ouside criical secions). 2 Polling The bigges issue wih explici deecion of asynchronous inerrups is he placemen of he inerrup checks. Placing hem afer every insrucion (ouside criical secions) would clearly be oo expensive. A more efficien approach consiss of puing inerrup checks a specific places in he code so ha inerrups are checked, or polled, periodically. A few sysems use polling for asynchronous inerrups (e.g. Gambi [5], MT-Scheme [2], MuliScheme [], Allegro Common Lisp, and SML/NJ [2]). Gambi is a Scheme sysem wih muliprocessing exensions aken from Mulilisp [7]. Asynchronous inerrups are used o disribue work among he processors by dynamic pariioning. dle processors send work reques inerrups o oher processors which mus respond wih a ask o run or no ask. Polling was chosen because of he high frequency of work reques inerrups when programs use fine grain parallelism and because i is imporan o answer work requess quickly o minimize he idleness of he processors. n heory, he compiler could arbirarily reduce he polling overhead (Opo ~) by decreasing he proporion of inerrup checks execued wih respec o he normal insrucions execued by he program. f all insrucions ake uni ime hen OP.ll a ~PO~Z/Nwasr, where NpO// is he number of inerrup checks execued and N~n~r is he number of normal insrucions execued. This sraegy lowers he frequency of inerrup checking and consequenly incre~es he average laency of inerrups (i.e. he ime beween he raising of he inerrup and he handling of he inerrup). Average laency (L) and overhead are inversely relaed by ~ = Npoll + Nn3r Npoll =+ Opel{ Here laency is expressed in number of insrucions. To accoun for non-uni ime insrucions, laency can be expressed in unis of ime (or number of machine cycles). Thk leads o he definiions 3 The acual mechanism used in MacLisp is even more general [3]. allows annoaions on he criical secions ha specify wheher inerrups should: be ignored, be deferred o he end of he criical secion, resar he criical secion, or invoke a special handler, 80

3 ~ _ TPOl + T,mw., Jvpoll where Tpoll is he oal ime spen on inerrup checks and Tin,, he ime spen on normal insrucions. f an inerrup check akes k ime unis on average hen L == k(l + &). To simplify he d~cussion, all insrucions will be ass~-rned o ake uni ime. 3 The Problem of Procedure Calls Alhough polling seems simple enough o implemen, here is a complicaion. Normally, programs are no composed of a single sream of insrucions. f his were he case he compiler could simply coun he insrucions i emis and inser an inerrup check afer every so many insrucions. Branches and procedure calls can aler he flow of conrol in unpredicable ways and so, i isn clear how he compiler can achieve a consan number of insrucions beween inerrup checks. A reasonable compromise is o ask of he compiler o emi inerrup checks such ha a given laency (L~ac ) is never exceeded. 3. Code Srucure Before exploring he problem furher, i is convenien o inroduce a formalism o describe he srucure of a procedure s code. The code of a procedure will be represened by a graph of basic blocks of insrucions. There are wo special ypes of basic blocks: enry poins and reurn poins. A procedure hss a single enry poin and one reurn poin for each procedure call in subproblem posiion. Branches are only allowed aa he las insrucion of a bs sic block. Four ypes of branches exis: local branches (possibly condiional) o oher basic blocks of he same procedure, ail calls o procedures (i.e. reducions), non-ail calls o procedures (i.e. subproblems), and reurns from procedures. Local branches and non-ail calls are no allowed o form cycles and hus hey impose a DAG srucure o he code. Following Scheme s convenion, i ia assumed ha loops are always expressed wih ail calls. Noe ha subproblem and reducion calls always jump o enry poins and ha procedure reurns always jump o reurn poins. These resricions are imporan o remember because hey simplify he analysis of he conrol flow. Figure gives he graph for he procedure for-each which conains all four ypes of branches. Reurns and ail calls have been represened wih doed lines because hey do no correspond o DAG edges. Solid lines are used for subproblem calls o highligh he fac ha, jus like local branches, i is known where conrol coninues afer he procedure reurns (if i reurns a all). The generaliy of he DAG is only needed o express he sharing of code. For he momen, i is sufficien o make he simplifying assumpion ha he DAG haa been convered ino a ree by duplicaing each shared branch. The handling of shared code is described in Secion 6. A necessary condiion for any polling sraegy is ha an inline sequence of more han L~az insrucions is never generaed wihou an inervening inerrup check. The compiler can exploi he code srucure for his purpose. A locally conneced secion is any subse of he basic blocks ha is conneced by local branches only (for example, he hree basic blocks a he op of Figure or he boom one). For any insrucion in a locally conneced secion, i is easy (define (for-each f ) (if (null? ) *f (begin (f (car )) (for-each f (cdr l))))) for-each i!=? (null? ) ~ e].. L J i fi :. L ~..! (Cdr ) : [....., E Figurel: The for-each procedure andie corresponding code graph. o deermine wha insrucions are on he pah o from hesecion s roo. These insrucions areexacly hose ha are execued a runime before. Thus, for any insrucion in a locally conneced secion, he compiler can ell how far back helas inerrup check occured (assuming here is one on he same pah from ha secion s roo). The number of insrucions ha seperae an insrucion from he previous inerrup check is called he insrucion s dela. For insrucions ha are no preceded by an inerrup check in he same secion, he definiion of dela will vary according o he polling sraegy. When he dela reaches Lmm, an inerrup check is insered by he compiler before he insrucion. f hk is in he middle of a criical secion, he compiler mus move he inerrup check o he end (or beginning) of hecriicrd secion. 3.2 Call-Reurn Polling Polling sraegies differ in how he ransiion beween locally conneced secions is handled. CaJLreurn polling is a simple sraegy ha consiss of puing an inerrup check as he very firs insrucion of each secion s roo. Since he roo of a secion is eiher he enry poin of he procedure or he reurn poin of a subproblem call, his corresponds o polling on procedure call and reurn. A firs glance, polling on reurn does no seem necessary since a procedure ia bound o ge called a some poin. However, his would mean ha here is no upper bound on he inerrup laency because i is possible o build a coninuaion ha does no call any procedure for an arbirarily long ime. For example, he following procedure does no call any procedure during he unwinding of he recursion. (define (lengh-even? ls) (i:f (and (pair? s) (lengh-even? (cdr s))) #)) 8

4 (define (make-person name age gender) (vecor name age gender)) (define (person-nine X) (vecor-ref x O)) (define (person-age x) (vecor-ref x )) (define (person-genderx) (vecor-ref x 2)) (define (sum vec h) ; sum vecor from o h (if (= h) (vicor-ref vec ) (lee ((mid (quoien (+ h) 2)) (lo (sum vec mid)) (hi (sum vec (+ mid ) h))) (+o hi)))) Figure 2: Twoinsances of shor lived procedures. nerrup u Rnl ; 4 P+ :.. \ lfl[m-km --- \ /p checks Figure 3: The maximal dela mehod. There area fewvariaions ofcs.ll-reurn polling. The inerrup check a he reurn poin can be removed if checks are pu onall reurn branches. Similarly, he inerrup check a he enry poin can be replaced by checks on branches o procedures (boh ail calls andnon-a.il ca.lls). The four possible variaions give equivalen dynamic behavior (i.e. same number of inerrup checks execued) bu one maybe preferable o he ohers if i yields more compac code. This depends on he paricular code generaion echniques used by he compiler and he programs being compiled. Compacness ofcodeis no ablg issue here so i won reconsidered furher. 4 Shor Lived Procedures Unforunaely, call-reurn polling has poor performance in cerain circumsances. The wors case occurs when procedures are shor lived, ha ia hey reurn shorly afer being called. A leas wo inerrup checks are performed per procedure call in subproblem posiion (once on enry and once on exi) and one if i is a reducion. This is a significan overhead if he procedure conains few insrucions. n languages ha promoe heuseof large procedureshk would no be a serious problem, bu in Lisp i is common osrucure programs ino several shor procedures. Two insances of his syle, ypified by he procedures in Figure 2, are he implemenaion of daa absracions and divide and conquer algorihms. n blnarydivide andconquer algorihms, a leas halfofhe recursive calls correspond o he base case. f he algorihm is fine grained, such as he procedure sure, he overhead of polling will be noiceable because allheleafca.lls are shor lived. The problem wih call-reurn polling is ha i doesn ake he srucure of he program ino accoun. f i is known ha a procedure P is always called when dela is equal o n, hen he compiler could infer ha upon enry o P, dela is n. This would inroduce a grace period of Lm.x n insrucions a l S enry poin during which inerrup checks are no needed. A similar saemen holds for reurn poins. Noe ha his yields a perfec placemen of inerrup checks if i is carried ou a all procedure enry and reurn poins. nerrup checks would occur exacly every Lmaz insrucions. A more realisic soluion is needed o handle he case where procedures and reurn poins are called in differen conexs. A simple exension o he previous mehod is o use m insead of n, where m is he maximum dela of all call sies o P (and similarly for reurn poins). This maximal dela mehod is illusraed in Figure 3 where dark recangles are used o represen inerrup check insrucions. This is no an ideal soluion for wo reasons. Firs, i forces all conrol pahs hrough P o have an early inerrup check (in P) if jus one call sie o P has a high dela. would be much beer if each procedure call paid i s own way, meaning ha inerrup checks should be pu on he call sies wih high delas. No only would his improve P s grace period, i would pu he inerrup check where i causes he led overhead (because a high dela is a sign of a high number of normal insrucions)4. A second shorcoming of his soluion is ha he source and desinaion of procedure calls has o be known a compile ime. This informaion is no generally available. One could reasonably argue ha wih he use of programmer annoaions and/or conrol flow analysis he desinaion of mos procedure calls could be inferred by he compiler for ypicrd programs. However, he desinaion of reurns is harder o deermine because i would require a full daaflow analysis of he program and in general a procedure has a number of possible poins o reurn o. The exisence of higher order funcions is anoher source of difficuly. 5 Balanced Polling ThE secion presens a general soluion ha does no rely on any knowledge of he conrol flow of he program. The mehod could be exended wih appropriae rules, such as maximal dela, o beer handle he cases where conrol flow informaion is available, bu his is no considered here. The idea is o define polling sae invarians for procedure enry and exi. The polling sraegy expecs hese invarians o be rue a he enry and reurn poins of all procedures and consequenly mus arrange for hem o be rue a procedure calls and reurns. Specifically, he invarian a procedure enry is ha inerrups have been checked a mos Lmax E insrucions ago. Here E is he grace period a enry poins and is consan for all procedures. n oher words, dela is defined o be Lmaz - E a enry poins. Dela now represens an upper bound o he disance from he las inerrup check, The invarian a procedure reurn is more complex. Elhcr dela is less han E or, he pah from he enry poin o he reurn insrucion is a mos E insrucions. These invarian are shown in Figure 4. Procedure P has wo branches ha illusrae he wo cases for procedure reurn. Noe ha a procedure can be exied by a procedure reurn as well as 4 This assumes ha all pahs o P are equiprobable 82

5 ~m insrucions P* ::,---;: , i ~ i ~enrypin ~ a mos E insrucion p-+.rl.~ procedure! reurn ; i + ~~ -- i a mos E. msrucio -. procedur~ reurn > c ; ; Figure 4: Procedure reurn invarians in balanced polling. a reducion call. For now, reducion calls will be ignored o simplify he discussion. 5. Subproblem Calls These invarians have imporan implicaions. To begin wih, shor lived procedures are handled well because here is no need o check inerrups on any pah ha reurns shorly wihou a call o anoher procedure (i.e. wih less han Enon-call insrucions). Th~corresponds ohe righmos pah in Figure 4. Moreover i allows he dela a reurn poins o be defined as~plus hedela forhecorresponding ballpoin. This can be confirmed by considering he wo possible cases. Assume procedure P does a subproblem call o procedure Pz which evenually reurns back o P via a procedure reurn in P2: s. bp,. blexn Pr=.d--= C*U P ~ P2 - P Eiher he las inerrup check waa in PZ, so by definiion dela a he reurn poin (in P) is less han E. Alernaively, Pz was shor lived and didn check inerrups, so here are a mos E insrucions ha seperae he call sie (in P) from he reurn poin (in P). As far sa polling is concerned, a procedure called in subproblem posiion can be viewed w an inerrup check free sequence of E insrucions. The compilaion rule here is ha if dela a a call poin exceeds L max - E hen an inerrup check ia insered a he call. This rule means ha up o llm~ /Ej subproblem procedure calls can be done in sequence wihou any inerrup j checking. To see why, consider he scenario where he firs call is immediaely preceded by an inerrup check. A he reurn poin, dela is equal o E. f he insrucions for argumen seup and branch are ignored, dela a he nh reurn poin is n x E. Only when his reaches Lma is an inerrup check needed. 5.2 Reducion Calls As described, he polling sraegy does no handle reducion procedure calls (ail calls) very gracefully. The case o consider here is when a subproblem call is o a procedure which exis via a series of ail calls, finally ending in a procedure reurn:.-bproblem r.dncim reducion P.o..dU.. An inerrup check mus always be pu a a reducion call poin o guard agains he case where he called procedure reurns shorly wihou checking inerrups (sa in Pn_ calling Pn). Noe ha he reurn poin in P can have a dela as low as E. Noe also ha P. can execue aa many aa E inerrup check free insrucions before reurning o he reurn poin in P. Thus, i is no valid for P.- o jump o Pn wih a dela greaer han O because his migh violae he polling invarian a he reurn poin in P. The reamen of reducions can be improved by inroducing a new parameer (R) and consequenly adjusing he polling invarians o suppor i. R is defined as he larges admissible dela a a reducion call. Thus, an inerrup check ia pu on any reducion cdl whose dela would oherwise be greaer han R. The same polling behavior aa before is obained by seing R o 0. The polling consrains for reducion calls can be relaxed by increming he value of R. R is a mos Lma= - E because a reducion call migh be o a procedure ha doesn check inerrups for as many as E insrucions. A new invarian for reurn poins has o be formulaed o accommodae R. The dela a reurn poins mus now be a less E + R o accoun for he case explained previously. Tha is, on reurn o P here could be up o E insrucions in P. plus as much as R insrucions a he ail of Pn_l since he las inerrup check. When he compiler encouners a subproblem procedure call i ses he dela a he reurn poins o E plus he larges value beween R and he dela for he corresponding call poin. Of course, if his value is greaer han L~az an inerrup check is firs pu a he call sie and he dela a he reurn poin is se o E + R. The inroducion of R also makes i possible o relax he invarian for procedure reurns. Since he dela for reurn poins is a leas E + R, a procedure reurn s dela as high aa E + R can be oleraed wihou requiring an inerrup check. Wih hese new invarians, here can be up o [(LmaS - R)/E] subproblem procedure calls in sequence wihou inerrup checks. This polling sraegy will be called balanced polling. A summary of he compilaion rules for balanced polling is given in Figure 5. The wo consans E and R mus be chosen carefully o achieve good performance. Small values for E and R increase he number of inerrup checks for shor lived procedures and ail recursive procedures respecively. On he oher hand, high values increase he number of inerrup checks in code wih many subproblem procedure calls (e.g. recursive procedures). Choosing E = R = \.Lmaz /k] is a 83

6 Locaion Acion Enry poin A + Lma$ E Non-branch if (A z ham - ) hen insrucion add inerrup check A-O AA+l (for nex insrucion) Subproblem if (A z Lmax - E) hen call add inerrup check A+O A +- E + max(r, A) (for reurn poin) Reducion if (A z R) hen call add inerrup check Procedure if (A ~ E +?) and here are inerrups reurn on pah from enry poin hen add inerrup check Figure 5: Compilaion rules for balanced polling. reasonable compromise and a value of k = 6 gives good performance in pracice. This suggess ha here are ypically less han 6 subproblem procedure calls per procedure in he benchmark programs (see Secion 8). sum ~ , (= h),/ \ \. Y l(vecor-refl (quolen U=w-lw,~ SW- L J SW ~ E& l $ , = J 5.3 Minimal Polling T T The choice of L~4~ is also an issue. A high Lrnac W~ give a low polling overhead. However, i is imporan o realize ha here is a limi o how low he polling overhead can be made by increasing he value of Lmm. Th~ is due o he conservaive naure of he sraegy. Whaever he values of L mar, E and R are, a le~ one inerrup check is generaed beween he enry poin and he firs procedure call. Dela is Lmar E on enry o a procedure, so clearly he firs call (reducion or subproblem) mus be preceded by an inerrup check. Similarly, here is a leas one inerrup check beween any reurn poin and he exi of he procedure (reurn or reducion call) because dela a any reurn poin is a leas E + R. These wo ypes of pahs are he only ones ha are necessarily par of any unbounded lengh pah. Thus, i is sufficien o have one inerrup check on each of hese pahs o guaranee ha all possible conrol pahs have a bounded number of insrucions beween inerrup checks. This minimal polling sraegy is useful because is overhead is a lower bound ha can be used o evaluae oher echniques. An example of minimal polling for he procedure sum and he ail recursive varian r-sum is presened in Fig- vec ure 6. For he call (sum v h) here are exacly 2 x (h /) inerrup checks execued or nearly one inerrup check per procedure call (assuming h + is a power of wo). By comparison, checking inerrups a procedure enry and exi would require wo inerrup checks per procedure call. However, for he ail recursive procedure r-sum boh mehods are essenially equivalen wih one inerrup check per ieraion. is ineresing o noe ha balanced polling is more r-sum L J (define (r-sum vec s i) (if (< i O) s (r-sum (+ s (vecor-ref vec i)) (- i l)))) Figure 6: Minimal polling for he recursive procedure sure and a ail recursive varian.! 84

7 general han minimal polling and call-reurn polhng. These can be emulaed by judiciously choosing E, R and L mar. Minimal polling is obained when O < E = R < Lmaz (i.e. E and R are arbirarily large and L~~ is arbirarily larger). An inerrup check is pu a he firs cdl and anoher one is pu a he reurn or reducion call ha follows he las reurn poin. Call-reurn polling occurs when O= E< R= Lmox. This places inerrup checks a all enry poins and reurn poins. 6 Handling Join Poins has been assumed ha he code of procedures is in he form of a ree. However, he compilaion of condiionals (i.e. and, or, if and cond) in subproblem posiion inroduces join poins ha give a DAG srucure o he code. Cerain opimizaion echniques, s,uch as common code eliminaion, can also produce join poins o express he sharing of idenical code branches. Join poins can be handled wih he maximal dela mehod. Tha is, he dela a he join poin is he maximum dela of all branches o he join poin. 7 Polling in Gambi Polling is a general mechanism ha can serve many purposes. Gambi is a Lisp sysem for shared memory muliprocessors. Gambi uses polling for Sack overflow deecion Preempion inerrupion (for muliasking) ner-processor communicaion (for work disribuion) ner-ask communicaion (for killing asks) Barrier synchronizaion (e.g. for synchronizing all processors for a garbage collecion and o copy objecs and load code o he privae memory of every processor) A special echnique is used o check all hese csaes wih a single es. The inerrup flag is really a poiner ha is normally se o poin o he end of he area available for he sack. Noe ha because sack overflows are deeced asynchronously, he sack exends a lile furher han his limi. An inerrup check consiss of comparing he flag o he curren sack poiner, and o jumping o an ou of line handler when he sack poiner exceeds he limi. A processor can be inerruped by seing he flag o a value ha forces his siuaion (e.g. O). The inerrup handler hen uses some oher flags o discriminae beween he possible sources of inerrup. SML/NJ [2] uses a similar approach based on he heap allocaion poiner. Alhough i can be done wih a single es, he inerrup check may sill be relaively expensive. Because all processors mus have access o a processor s inerrup flag, i is locaed in shared memory (which can be cached easily). ncreasing LmG= is no a viable soluion because he polling frequency can be lowered beyond a cerain poin. To provide a finer level of conrol, inerrups can be checked inermienly. Polling insrucions generaed by he compiler represen virual inerrup check poins and an acual check of he inerrup flag occurs once every n virual checks. This is easily implemened by a privae couner ha is decremened a every virual check. When i reaches zero i is rese o n and he inerrup check is performed. The average cos of an inerrup check will hus be he cos of updaing and checking he privae couner plus l/nh he cos of checking he inerrup flag. An ineresing opimizaion occurs here. Balanced polling hss a endency o pu he inerrup checks a branch poins. An inerrup check iself involves a branch insrucion so in many cases i is possible o combine he wo branches ino a single one. Moreover, several machines have a combined decremen and branch insrucion ha helps reduce he cos even furher. All hese ideas are implemened in Gambi. Below is an example showing he M68020 assembly code generaed by Gambi for he ail-recursive procedure las. The boxed par is he inerrup check sequence (noe ha n = 0 and ha regiser a5 always conains a poiner o he sack limi poiner). 8 Resuls (define (las ls) (le ((res (cdr ls))) (if (pair? res) (las res) (car ls)))) L : ; enry: dl=ls & ao=re adr MOV dl, al ; res <- (cdr ls) movl ai@-,d2 bs d2,d7 ; (pair? res) bne L2 movl d2,di ; la <- res dbra d6,li ; decremen and es couner moveq *9, d5 ; rese couner cmpl a5~, sp ; is sp beyond he limi? bcc L ; no inerrup if sp>=limi jsr handler ; call inerrup handler bra Li ; reducion call o las L2 : movl di, al ; resul <- (car ls) movl alq, dl jmp ao@ ; reurn To have a beer idea of he polling overhead ha can be expeced from hese polling mehods, i is imporan o measure he overhead on acual programs. Two siuaions are especially ineresing o evaluae: he overhead on ypicaj programs and on pahological programs ha are mean o exhibi he bes and wors performance. Several programs and polling mehods were esed. The programs were compiled by Gambi in four differen ways: wih no inerrup checks, wih minimal polling, wih callreurn polling and balanced polling. For balanced polling, Lmaz was se o values from 0 o 90 and E and R were se a ll ma= /6]. A value of n = 0 was used for polling inermienly. The average runime on en runs was aken for each siuaion. The overhead of minimal polling over he program compiled wih no inerrup checks is repored in he firs column of Table. The overhead for he oher polling mehods is expressed relaive o he overhead of minimal polling. Thus a relaive overhead of 2 means ha he overhead is wice ha of minimal polling. The program igh, shown below, was designed o exhibi wors-case behavior. (define (igh n) (if (> n O) (igh (- n l)))) 85

8 M:~.~ callreurn Balanced polling Opoll polling Rel. OV. when E = R = [.Lmaz /6j and Lm.= k Program (%) Rel. OV igh unfolded boyer browse Cpsak dderiv , deriv desruc div puzzle ak akl raverse riangle compiler 4.4, conform earley peval abisor allpairs fib mm ms qsor queens ranree scan ,0 sum ridiag Table : Overhead of polling mehods on benchmark programs. 86

9 is a igh loop ha doesn do anyhing excep updae a loop couner. There are only wo insrucions execued on every ieraion: an incremen and a condiional branch. nerrup checks will clearly add a high overhead o his. For mos polling mehods he overhead is abou 80%. n he case of bsjanced polling wih Lmm = 0 he overhead is roughly wice ha because wo inerrup checks ge added o every loop. The program unfolded is he same loop as igh bu unfolded 80 imes. Thus, i is a long inline sequence of 80 decremens followed by one condiional branch insrucion. The polling mehods do well on his program (abou 6% for minimal and call-reurn polling) because procedure calls are relaively infrequen and i is easy o handle he irdine sequence of insrucions. As expeced for balanced polling, increasing Lmaz decreased he overhead, down o abou 470. Lm~c would have o be greaer han 90 o reduce he overhead o ha of minimal polling (a L~~ = 90 here are wo inerrup checks per loop). The oher programs are spli in hree groups. The firs group conains programs from he Gabriel benchmark suie [6]. The second group conains more realisic applicaions ha have no been designed wih benchmarking in mind. They are fairly sizeable wih a leas 500 lines of code (5,000 for compiler). The las group conains parallel programs aken from [4]. These programs are wrien in Mulilisp bu were compiled as sequenial programs (i.e. wih FUTURE and TOUCi operaions removed) o facor ou he overhead of supporing parallelism. The resuls show ha minimal polling ouperforms csureurn polling in nearly all cases. Someimes by as much as a facor of four, bu by a facor closer o.7 on average. The larges differences occur for fine grain recursive programs (e.g. ak and fib) and programs wih a profusion of daa absracion procedures (e.g. conform). The performance of balanced polling is raher poor for small values of Lmm, wo o hree imes he overhead of minimal polling when Lmaz = 0. However, balanced polling gives performance close o minimal polling when Lmm is high. Wih Lm~ = 90 he overhead ranges from 5% o 25%. The highes overheads are for fine grain recursive programs. Overall, he average overhead for balanced polling is abou 5% for values of Lmu higher han 50. [4] M, Feeley. An EfFcien and General mplemenaion of Fuures on Large Scale Shared Memory Muliprocessors. PhD hesis, Brandeis Universiy Deparmen of Compuer Science, 993, [5] M. Feeley and J. S. Miller. A parsllel virual machine for efficien Scheme compilaion. n Proceedings o,f he 2990 ACM Conference on Lisp and Funcional Programming, Nice, France, June 990. [6] R. P. Gabriel. Performance and Evaluaion o,j Lisp Sysems. Research Repors and Noes, Compuer Sysems Series. MT Press, Cambridge, MA, 985. [7] [8] [9] [0] [] [2] [3] [4] R. Halseacl. Mulilisp: A language for concurren symbolic compuaion. n ACM Trans. on Prog. Languages and Sysems, pages , Ocober 985. D. Johnson. Trap archiecures for Lisp sysems. n Proceedings of he 990A CM Conference on Lisp and Funcional Programming, Nice, France, June 990. D. Kranz, R. Kelsey, J. Rees, P. Hudak, J. Philbin, and N. Adams. Orbi: An opimizing compiler for Scheme. n ACM SGPLAN 86 Symposium on Compiler Consrucion, pages , June 986. H. Lieberman and C. Hewi. A real-ime garbage collecor based on he lifeimes of objecs. Communicaions of he ACM, 26(6):49429, June 983, J. S. Miller. mplemening a Schemc+baaed parallel processing sysem. nernaional Journal of Parallel Processing, 7(5)} Ocober 988. G. J. Rozss. Liar, an Algol-like compiler for Scheme. S. b. hesis, Deparmen of Elecrical Engineering and Compuer Science, Massachuses nsiue of Technology, January 984. G. L. Seele Jr. Privae Communicaion, December 992. J. L. Whie. Privae Communicaion, December 992. Acknowledgemens wish o hank he following people for heir help in undersanding he inerrup handling mechanism of paricular sysems: Guy L. Seele Jr. and Jonahan Rees for Maclisp; Jon L. Whie for Maclisp and Lucid Common Lisp; David Kranz for T; and Guillermo J. Rozaa for MT-Scheme. also wish o hank he reviewers for heir help. References [] [2] [3] A. W. Appel. Allocaion wihou locking. Sofware Pracice and lkperience, 9(7): , July 989. A. W. Appel. Compiling wih coninuaions. Cambridge Universiy Press, 992. H. Baker. Lis processing in reaj ime on a serial compuer. Communicaions of he ACM, 2(4): , April