Adaptation of On-line Scheduling Strategies for Sensor Network Platforms

Transcription

1 Adaptaton of On-lne Schedulng Strateges for Sensor Network Platforms Chrstan Decker, Tll Redel, Mchael Begl Telecooperaton Offce (TecO), Unversty of Karlsruhe Karlsruhe, Germany Abstract Current sensor network platforms perform multple processes ncludng sensor samplng, communcaton, and varous computatonal tasks. When deployed n unpredctable envronments, complex schedules of those processes may arse. Typcal sensor network qualtes lke perodc samplng of sensors, avodance of starvaton of sngle processes and automatc energy management are crucal and requred to be mantaned n such stuatons. We propose a schedulng framework for senor nodes consstng of a scheduler, a dspatcher and a controller for an adaptaton of process executon durng the runtme. The key components of our framework are a controller and an enhanced dspatcher whch both mplement varous strateges to mantan crucal qualtes of process executon on sensor nodes deployed n unpredctable envronments. Further, the framework s aware of the energy consumpton of sensors. We show that our controlled schedulng framework performs sgnfcantly better than a noncontrolled sngle scheduler n unpredctable envronments. Our proposed measures are effcent to mplement. Results are underpnned by extensve smulatons and a frst mplementaton on our Partcle Computer platform. possble. Therefore, the system should take measures, f a task s constantly left out. In partcular, such a stuaton may occur, f other tasks are permanently consdered to be more mportant because of an event detecton. Our thrd goal s the automatc energy management of sensors on the platforms. Sensors have start-up tmes, shutdown tmes or sample delays. Ths may lead to complex dependences whch need to be resolved by the runtme system. These goals can be approached by an approprate schedulng strategy. However, n unpredctable envronment, the task propertes are unpredctable, too. For nstance, computaton tmes of tasks are varyng, overload stuatons may occur due to event detecton and processng or computatonal tasks may delay the entre system because ther runtme depends strongly on ther nput data. Ths unpredctablty of the envronment makes t necessary to adapt the scheduler onlne whle the system s runnng. Furthermore, the restrcted resources of the sensor node platforms make t rather hard to mplement a complex strategy. Therefore, we propose an adaptve schedulng framework utlzng compact prorty-based schedulers whch are further supported by an enhanced dspatcher and a controller. Keywords: Schedulng, Sensor Network, Energy Management, Partcle Computer Controller Scheduler Dspatcher I. INTRODUCTION Sensor node platforms are proposed for varous montorng and trackng tasks whch are hard to accomplshed by other technologes. Thereby, sensor nodes are deployed n unknown and therefore n unpredctable envronment. As a consequence, the nodes should mplement mechansm to adapt ther tasks to the envronment. Mcrocontrollers on current sensor nodes platforms have to handle a large dversty of processes. Among them are sensor samplng tasks, communcaton tasks and computatonal task. Addtonally, there are background processes for mantenance. Wthn each of those groups further dmensons are revealed. For nstance, sensor samplng tasks may have dfferent propertes regardng samplng nterval and samplng tme. Recently, lots of operatng systems for sensor nodes have been proposed as an underlyng runtme system handlng varous tasks. A promnent example s TnyOS[6], the operatng system for the Berkeley Motes. In ths paper we want to approach three goals, whch we dentfed as crucal for process executon on sensor nodes n unpredctable envronments. Our frst goal s to acheve a low jtter n perodc sensor samplng processes. Samplng n fxed ntervals s reasonable as many algorthms rely on ths property. But, wth many competng samplng processes n an unpredctable envronment hgh load and overload stuatons may occur. As a consequence, the runtme system has to adapt the task propertes to fulfll such requests. Our second goal s the avodance of task starvaton. The nodes are deployed n areas where no external admnstraton or debuggng s Servce Servce... Fgure 1. The adaptve schedulng framework The key component of our framework s the controller and an enhanced dspatcher mplementng a set of strateges to handle the dynamc effects of the system. Tasks are encapsulated n servces representng stand-alone functonal enttes. The dspatcher montors the performance of the executon of the servces and trggers the controller for adaptaton f necessary. Our contrbuton n ths paper s the quanttatve performance evaluaton of onlne schedulng adaptaton strateges whch are suted for resource constraned sensor network platforms appled n unpredctable envronments. Our approach s based on permanent feedback from the current process executon. Remarkable for ths approach s that t results n a very good performance wth a mnmum of prevously defned and uncertan knowledge. The remander s structured as follows: In secton II we wll revew schedulng strateges on sensor nodes. As a result, we wll derve mportant requrements for our schedulng framework. The framework works on functonal enttes called servces, whch wll be ntroduced n secton III. Secton IV then presents the detals of adaptve schedulng framework and the adaptaton strateges. For the evaluaton of the framework we wll descrbe a representatve set of servces n secton

2 V and the results of comparsons wth non-adaptve strateges are dscussed on secton VI. Secton VII shows an mplementaton of the adaptve framework on our Partcle Computer platform. We conclude the paper n secton VIII. II. SCHEDULING STRATEGIES ON SENSOR NODES In ths secton we wll revew mportant schedulng algorthms, whch are currently mplemented on sensor nodes. All algorthms utlze the same task model. A task s defned as a tuple task = { P,C,T,d,r }, whereas P s the functon whch s executed, C s the computaton tme, T s the perod of the executon, d s the deadlne and r dentfes the resources requred by the task. The recurred executon of a task s sad to be a set of jobs J = { j 0, j 1,...}. A job j 0 s scheduled to start ts executon at the tme a ( j 0 ) = a 0, whch s called the arrval tme. An ordered set of jobs accordng to some polcy s called a schedule. If a job gets nterrupted durng ts executon, the schedule s called preemptve. If all jobs runs to completon before the next one s started, the schedule s called non-preemptve. A. Frst-In-Frst-Out (FIFO) A FIFO scheduler executes tasks n the order of ther arrval. As a consequence, each job has a prorty proportonal to ts arrval tme and the resultng schedule s a totally ordered lst of those prortes. A FIFO strategy runs non-preemptvely. As a result, the mplementaton only requres an array of jobs and does not need any a-pror knowledge about the jobs. These qualtes consttute the FIFO strategy as a preferred approach for resource constraned devces. TnyOS 1.x [6], the operatng system of the Berkeley Motes, mplements a FIFO scheduler. However, the scheduler cannot assert tme guarantees of perodc jobs nor executon guarantees. These are serous drawbacks of ths approach. If the job queue s exceeded, then newly arrved jobs must be canceled. As a result, events may get lost and tasks run nto starvaton snce constantly upcomng events may avod the queung of the starvng task. B. Rate Monotonc Schedulng (RMS) RMS s a fx prorty strategy where once a prorty s assgned to a task dependng on ts perod P. Tasks wth shorter perods are assgned hgher prortes than tasks wth longer perods. In [9] the authors showed that RMS s optmal,.e. that no other fxed-prorty algorthm can schedule a task set that cannot be scheduled by RMS. The authors also derved a least upper utlzaton bound for a set of n perodc tasks n a preemptve schedule. If the utlzaton C 1/ 2 U = n(2 1) T, (1) then the RMS guarantees that all deadlnes wll hold. For a nonpreemptve schedule ths guarantee can only be gven, f the followng condton holds: C mn T As a result, RMS executes the jobs repeatable n the same order and acheves even very low jtter durng the perodc executon of the tasks. Fxed-prorty strateges are attractve to be mplemented on sensor nodes, snce they need to compute the schedule only once before the runtme. They can even guarantee perodc behavor of tasks and the mplementaton just requres a sngle array where the jobs rotate through. The major drawback s the nflexblty of RMS. The strategy does not consder varyng executon tmes and cannot adapt ts runtme behavor. Further, an admsson based on (1) underutlzes the system constantly and can result n starvaton of tasks, whch do not satsfy the crtera. C. Earlest Deadlne Frst (EDF) In [9] Lu and Layland nvestgated EDF. The next job s selected accordng to ts deadlne durng the runtme of the system. Ths behavor can handle system dynamcs where new jobs arrve unpredctably n the system. Ths property of EDF guarantees real-tme behavor even n the case of unpredctable event occurrence on sensor nodes. The EDF strategy s preferred for real-tme systems, because t utlzes the processor at best. Further, EDF s optmal n the sense, that f there s a schedule for whch all deadlnes wll hold, then EDF wll fnd t. A task set of n perodc tasks s guaranteed to be schedulable and therefore durng executon all deadlnes wll hold, ff the utlzaton U s C U = 1 (2) T However, (2) holds only for preemptve schedules. In the case of non-preemptve schedules, a complete search accordng to Bartley s algorthm [2] has to be undertaken to fnd a feasble schedule. A varaton s the Sprng algorthm [11] whch utlzes addtonal heurstcs. AmbentRT, the operatng system for the µnode platform [7], mplements an EDF varaton called Earlest Deadlne Frst wth Deadlne Inhertance (EDFI). Ths s a preemptve strategy usng a prorty celng mechansm appled on resource usage n order to solve conflcts when resources are shared between dfferent tasks. In order to run correctly, EDFI requres exact computaton tmes and resource allocaton of each task beforehand. Instead of the exact computaton tme, a Worst-Case-Executon-Tme (WCET) can be specfed. WCET s an upper bound, whch wll never be exceeded. The propertes specfcatons are left to the developer of an applcaton on µnodes and therefore a potental source of errors when wrongly estmated. The EDF strategy s fragle to a domno effect, whch may results n a contnuously mssed deadlnes, once a sngle deadlne was mssed. In partcular, computatonal tasks underle a large varatons as ther computaton tmes are domnated by the nput data. Nevertheless, f these parameters are correctly chosen, then EDFI guarantees deadlockfree executon and real-tme behavor. But, even f the task set s statc and the admsson has verfed the schedulablty,.e. all deadlnes wll hold, EDF may not guarantee fx ntervals between two jobs of the same task. As a consequence, low jtter durng perodc samplng cannot be guaranteed. D. Cooperatve Schedulng In cooperatve schedulng, a task yelds ts executon and the control s gven to a dspatcher for selectng the next one. As a consequence, the process order s mplctly encoded n the applcaton program. Operatng system lke SOS[5] for Motes and the hghlyportable operatng system Contk [4], whch s also avalable for sensor node devces, mplement cooperatve schedulng. In partcular, latter system supports ths strategy through a very lghtweght mplementaton called protothreads. The overhead s comparable to the FIFO schedulng strategy because schedulng decsons are prmarly specfed by the applcaton or the developer. There s bascally addtonal effort through a specfc scheduler. Cooperatve schedulng burdens the effort on the developer. An mplementaton of perodc executon of tasks must be mplctly encoded n the applcaton logc. For achevng fx perodc ntervals the developer need to constantly montor the executon behavor of the entre applcaton. In case of a modfcaton of the applcaton, the measures to acheve a certan processng behavor also have to be modfed. These mght be dstrbuted across all tasks of an applcaton. If applcatons get more com-

3 plex the burden on the developer ncreases. As a result, t arses the rsk, that decsons where to place yelds wthn a task and whch task to select next, may lead to task starvaton. Snce the task swtches are dstrbuted across an applcaton, the possbltes of dfferent executon orders ncrease dramatcally. A developer has to carefully study the entre applcaton n order to reman an ntended behavor. E. Résumé From the prevous analyss we derve now mportant propertes of our schedulng framework for sensor node platforms. Preemptve realtme schedulers guarantee deadlnes for job executon and utlze the processor at best. However, addtonal effort s requred to resolve conflcts due to resource sharng when a job accesses a resource, whle a prevously started job s preempted. Preempton s dffcult to mplement safely on mcrocontroller systems wth no protecton between the tasks. Usually, a tmer nterrupt s used to preempt a runnng task. But the authors of [10] showed, t mpossble to guarantee that a task mustn t swtch off ths nterrupt. The memory consumpton of the swtchng between jobs when they are preempted s not neglgble. A job has to store the current process control block consstng of actual processor regsters and a stack ponter n order to return to ts own block of local varables on the stack. AmbentRT reports an addtonal overhead of 10 bytes per task whle 72 tasks are allowed at maxmum. Although ths s a low overhead per task, t scales up wth the number of tasks and allocates more memory. Snce the memory layout s often organzed statcally and fxed durng comple tme of an applcaton, the memory s permanently reserved for the scheduler. Schedulers supportng real-tme guarantees requre an accurate specfcaton of task propertes, especally of the computaton tme. These are hard to fnd, especally, when they depend on the nput data of a task. WCET approxmatons on the other sde result n underutlzaton of the system. FIFO strateges and fxed-prorty strateges such as RMS are very nflexble. Although attractve for resource constraned sensor nodes due to ther low effort, perodc processes wth low jtter and avodance of task starvaton are hard to support relably. Automatc managng of the energy consumpton of sensors,.e. swtchng them on and off wth respect to ther specfc start-up tmes s not consdered at all. Due to the restrcted resources and the addtonal overhead requred for preemptve tasks, our framework wll mplement nonpreemptve tasks. As a result, resource conflcts cannot occur and ths avods any measures for synchronzaton. Unpredctable event processng may dsturb real-tme propertes. Our framework omts realtme guarantees, but rather prefers low jtter durng perodc executons of tasks. Perods of tasks are adaptable n order to acheve ths requrement. Cooperatve schedulng s certanly best suted for specfc parts of an applcaton on sensor nodes, but t has no vew on the overall executon performance. Furthermore, t s complex and burdens a developer due to the tght couplng of the applcaton and the schedulng decsons appled on the tasks. Fnally, our framework allows flexble annotatons. For nstance, sensor tasks are annotated by ther start-up tmes, n order to make the system aware of the sensors energy management. III. SERVICES As a consequence of our analyss n secton II, we ntroduce the concept of servces, whch reflects the results from n secton II.E. Servces represent a unform abstracton of all recurrng processes on a sensor node. A schematc vew on a servce s depcted n Fgure 2. Central n ths abstracton s the servce functon, whch mplements the functonalty, e.g. sensor samplng. Servces run non-preemptvely and are ndependent from each other,.e. there s no servce, whch calls another one. The start of a servce executon s always drven by the underlyng runtme system. A servce executon s always perodc, non-preemptve and an executon cycle fnshes wth a result stored n a result buffer. The result set s allowed to be empty. As an abstracton of recurrng processes, a servce provdes rch capabltes to be confgured. Among them are regular task propertes lke perod, deadlne and computaton tme, but also addtonal parameters lke starvaton level, and start-up tme for sensor samplng servces. The runtme system utlzes these parameters for ts onlne decsons. Results State Functon Output Buffer Confguraton T, C, d, starvaton level, start-up tme Fgure 2. A schematc vew on a servce an encapsulated ndependent functonal entty for sensor nodes Durng the perodc executon, a servce transts through several states whch are depcted n detaled n Fgure 3. Durng the boot-up of the system, all servces are ntalzed and to the sleepng state. Snce all servces arrve at the same tme n the runtme system, they are now turned on one after the other,.e. accordng to ther start-up parameter, ther new arrval tme of each servce s computed and the servce s placed n the watng state. If the arrval tme s reached for a watng servce t changes ts state to ready. All ready servces are then executed by the dspatcher and they automatcally transt to the watng state. A separate executon state s not necessary because servces run non-preemptvely. If a perod s greater than the start-up tme of a servce, the servce may want to go to the sleepng state n order to save energy. Ths s a crucal feature for sensor samplng servces whch can power-down energy-consumng sensors untl the next usage. Int Sleepng New Turn on Turn off Schedulng Watng Ready Fgure 3. State transton dagram of a servce Execute The servce abstracton does not prohbt event processng. Events occur sporadcally. In [8] the authors suggest a method to model sporadc processes wth perodc processes. Thereby, the mnmum tme dfference between two sporadc events can be consdered as the perod of a perodc process. As a consequence, the ntroducton of servces can handle sporadc event processng. Formally, servces are smlar to the noton of tasks as presented n secton II. We descrbe the servce S as a tuple S = { P,C,T }, where P s the servce functon whch s executed, C s the computaton tme, and T s the perod of the executon. The resource de-

4 scrpton can be omtted because non-preemptve servces do not nterfere wth each other on resources when accessng them. However, conflcts occurrng as a result of sharng resources between dfferent servce nvocatons, are determned by the applcaton logc and must be handled by utlzng nternal states of resources. In the servce model, the computaton tme C s gven (.e. specfed by the developer), but for a concrete executon nstance t s unknown. In partcular, C of an nstance s hghly dynamcally and may strongly vary accordng to the data whch are processed. Ths behavor s the reason for omttng the deadlne. Servces are brought to executon as jobs at a gven arrval tme. The arrval tme of the n-th job representng the n- th nvocaton of servce IV. S s defned as a, n = ( n 1 ) T. SCHEDULING FRAMEWORK AND RUNTIME SYSTEM The schedulng framework for sensor node platforms s responsble for executng the servces. It serves as an underlyng runtme system for all servces on a sensor node platform. The desgn goal was to plug-n multple schedulers and adaptaton strateges. As a consequence, the framework s dvded n the three components: dspatcher, scheduler and controller. The framework operates on the noton of jobs, whch are the runtme representaton of servces. It utlzes the jobs arrval tme and a reference from a job to ts orgnatng servce. Jobs are organzed n two queues, one for all ready jobs, whch need to be executed now, and one queue for watng jobs, whch have ther arrval tme n the future. When desgnng the framework we followed a strct separaton between the components actons on the jobs n order to form a clear concept and to avod sde-effects between the components. An overvew of the framework s depcted n Fgure 4. Modfes job propertes Jobs Ready schedules Controller Scheduler calls Dspatcher Fgure 4. Adaptve schedulng framework notfes Watng Jobs The core component s the dspatcher. It executes the servce functon assocated wth a job. The dspatcher s the only component whch s allowed to remove jobs from the ready queue and to nsert jobs n the watng queue. If jobs acheve ther arrval tme, the scheduler moves them from the watng queue to the ready queue n order to be executed by the dspatcher. The watng queue s sorted accordng to the next arrval tme of a job, whle the ready queue s sorted accordng to prortes computed by the scheduler. The scheduler s the only component whch nserts jobs n the ready queue and changes ther orderng theren. The plannng of the orderng s based on the servce parameters, especally on the computaton tme and perod. The prorty based nterface va the ready queue allows us to plug-n prorty based schedulers, such as FIFO, RMS and EDF. Snce schedulers descrbe a ordered executon plan, ths nterface s naturally generc to handle other schedulers as well. On top of the scheduler we ntroduce a controller. Ths component s responsble for schedule adaptaton. In order to avod faulty nterference wth the scheduler, the controller s only allowed to modfy job propertes. If t changes the prorty of a job, t must notfy the scheduler. In the next subsectons we wll explan the desgn of the framework components n more detal. A. Dspatcher The dspatcher s executed for each job. It has access to two queues ready and watng whch match the states of a servce. Servces n the sleepng and watng state are both contaned n the watng queue. Jobs n the ready queue are ordered by ther prorty wth the hghest prorty on the frst poston. The dspatcher retreves the frst job from the ready queue, executes t and nserts t n the watng queue. Latter s organzed ascendng accordng to the next arrval tmes of the jobs. The fgure below llustrates the separate actons of the dspatcher. Ready Prorty ascendng frst(ready) Fgure 5. A slm dspatcher nsert_sorted(watng) Dspatcher Executon Watng Arrval tme ascendng The dspatcher has only the knowledge about the just occurred executon of a job. For computaton of the job s next arrval tme the dspatcher calls an approprate functon from the servce because the dspatcher does not know the servce s perod. The result from ths functon s used to nsert the job at the rght poston wthn the watng queue. Snce the ready queue s already sorted t takes a constant effort to retreve the hghest prorty job. The nserton n the watng queue uses a nserton sort algorthm wth a complexty of O(n). Based on just two queues and a very low knowledge about each job we acheved a slm desgn of the dspatcher, but stll mantanng flexblty for adaptaton. B. Dspatcher adaptaton strateges In the followng subsectons we present two adaptaton strateges automatc sensor energy management and jtter correcton whch are drectly mplemented n the dspatcher. 1) Energy management Our slm dspatcher desgn s enhanced for automatc energy management. The goal s to swtch off sensor after the samplng job, but swtch them on before the next samplng. Ths has to take the startup tme of the specfc sensors nto account. Here, the servce plays an actve role. The dspatcher s state neutral,.e. the state s held wthn the servce and modfed by the servce tself when the job s accessed by the dspatcher. As a result the servce tself can schedule ts on/off behavor by returnng the approprate arrval tme dependng on ts state when asked by the dspatcher. In Fgure 6 the sensor samplng s just over when the dspatcher requests a new arrval tme for the job. The assocate servce returns nstead of ts perod T, the start-up dfference T w ; w hereby denotes the confgured start-up tme specfc for the sensor samplng servce. After the job s executed at T w the servce wll then return w as the next arrval tme. It s assumed that the job s computaton tme for swtchng the sensor on at T w s neglgble.

5 Ready Sensor Samplng Sleep Sensor Start-up tme Swtch on Ready Sensor Samplng In the followng example we llustrate the effect of jtter correcton. We smulated jobs wth perod T = 3. The executon of jobs s randomly nterfered wth jtter between 0 and 1. One set of jobs was smulated wthout jtter correcton and the other set has utlzed the jtter correcton as defned above. The fgure Fgure 7 plots the hstogram of the resultng perod devatons. As proofed above, the devaton stays between ± 1 for the set utlzng the correcton. Furthermore, the devaton s prmarly 0. For the set where the jtter s not corrected, the devaton stays between ± 2. Although the devaton stays prmarly around 0, the devaton s broader dstrbuted than n the case where correcton s appled. Addressng our goal of low jtter, the jtter correcton outperforms the non-corrected case by factor n the case for 0-devaton. 0 Dspatcher requests new arrval tme T w Dspatcher requests new arrval tme Fgure 6. Automatc energy management T Arrval Tme 2) Jtter correcton The dspatcher s further enhanced to support the goal of low jtter n successve samplng processes. The jtter J s the delay between the arrval tme and the tme the job starts ts executon. We call ths start tme dspatch tme. Jtter occurs as a result of a job s unknown computaton tme. The scheduler has planned the executon order, but a job exceeds the planned computaton tme. As a consequence, t causes a jtter for the next job. The jtter correcton works as follows: Instead of settng the next arrval tme of a job on the perod nterval, the perod s added to the dspatch tme of the job. The new arrval tme s then recursvely defned as a, n = a, + J + T. The advantage of ths defnton s that jobs wth common arrval tmes are dfferently shfted. As a result of ths adaptaton, the next dspatch tme s set closer to the real behavor of the servce. Jtter affects the perod of jobs. Addressng our goal of low jtter, the jtter correcton guarantees that the perod devaton s wthn ± J. We show ths n the followng theorem. jobs Theorem 1: The jtter correcton appled on the arrval tmes of a, n = a, + J + T guarantees a worst-case perod devaton wthn ± max{ J }. Proof: Frstly, we compute the perod of a job usng the dfference of the dspatch tmes between the ( n 2) th executon nstance and the ( n 1)th nstance. We further assume, that the ( n 1) th nstance was delayed by a jtter J. Clearly, the dfference s a, + J a, n 2 = T + J. In the second step, we compute the dfference between the nth executon nstance and the ( n 1) th nstance. The ( n 1) th nstance started at a, = a, + J, because t was delayed, and the n th nstance starts at a, n = a, + J + T, because of the jtter correcton. However, a, n may experence an addtonal jtter J,2. The dfference s a, n a, = T + J,2. The perod devaton T s now the dfference of two consecutve perods of jobs: T = J J, 2 max{ J }. The sequence of the jtter occurrence can be also the other way around, therefore the devaton s T = ± max{ J }. Occurence of perod devaton x 104 no correcton jtter correcton Perod devaton Fgure 7. Perod devaton for a maxmum jtter = 1 and a perod T=3 Although the jtter wll be reduced, the perod ncreases. The shft always moves the arrval tme forward n tme, whch may result n less executon per tme frame. The dspatcher desgn s also able to handle the domno effect by job omsson. If computaton tmes of jobs vary strongly, they may cause an executon delay of a job whch causes further jobs to delay ther executon. Ths may add-up to a delay chan and volate constantly the perodcty of jobs. Before the executon of a job, the dspatcher may ask the assocate servce whether the job already exceeded ts next arrval tme. If at the tme t wth t > a, n+1 the n-th executon of job has not occurred, then the dspatcher can omt the executon. As a result, the delay chan s broken and the domno effect s stopped. C. Scheduler Our schedulng framework allows a clear way to plug-n dfferent schedulers. For all jobs n the watng queue whch have acheved ther arrval tme, the scheduler computes an order of executon. Ths order s expressed as a prorty used to order those jobs n the ready queue. Due to the cooperaton between the scheduler and the dspatcher, we acheved that no servce s represented by multple jobs. From ths perspectve the framework does not mpose addtonal overhead. As a result, the queues can be safely bounded to the maxmum number of servces the system desgner wants to support. For our system tests we mplemented the prevously dscussed strateges EDF, RMS and FIFO. For the reasons analyzed n secton II.E we ntentonally left out a cooperatve schedulng strategy. None of the schedulers n the framework should perform an admsson control. Our second central goal was to avod process starvaton and rather handle such stuatons onlne. Therefore, the schedulers should always accept all jobs. D. Controller A serous problem occurs, f jobs face starvaton. Ths mght be a result of a fx prorty schedulng strategy or constant job omssons n

6 order to stop a domno effect. Such problems are handled by controllers. Controllers are servces as well, but the dspatcher drectly calls them. Ths s requred to guarantee ther executon. By desgn they are requred to only modfy job propertes. For handlng the starvaton problem we now ntroduce the starvaton controller. Ths servce observes the job queues and the past runtme behavor of the other servces n order to bound the maxmum number of job omsson. Each servce s annotated wth a starvaton level specfyng ths bound. The starvaton level s set by the developer n advance and reflects hs requrements on a mnmum response tme for a servce. If the controller s executed t compares ths value wth the number of omssons, whch occurred n seres for ths job. Such analyses are most complex compared to the effort of the scheduler and the dspatcher because for all jobs j n both queues the controller has to compute the number of omssons gven by omsson t t, last = T where t denotes the current tme, t, last s the last tme, that the job was successfully executed and T s the perod of controller then follows a straght rule:, j. The starvaton ( l( ) s ) omsson 0 then pro( j pro = FIFO : f ), where l ( s ) denotes the confgured starvaton level,.e. the number of allowed omssons, pro( j ) s the prorty of the job and pro s a reserved prorty whch causes the scheduler to place FIFO ths job as the frst one before all others n the ready queue. If there s more than one job, then they wll be placed n FIFO order. Snce FIFO s starvaton free as long as the computaton tmes are fnte, the prevously starved job wll be guaranteed executed by the dspatcher. After executon the propertes prorty and starvaton level are reset. The controller requres support from the dspatcher. Due to the complex computatons t wll run seldom. As a consequence, the dspatcher has to record the last successful executon for each job. Usually, the runtme system wll utlze only one starvaton controller for all jobs. The system performance can be mproved, f the perod of ths controller can be determned n advanced. However, an approprate controller perod depends on the starvaton level and the perod of the servce. For nstance, the controller can run more seldom, f the starvaton level s hgh,.e. the developer allows a hgh number of omssons. The optmal controller perod n order to hold all starvaton bounds s the greatest common dvsor (gcd) of all servce perods multpled by the smallest starvaton level. However, as soon as one perod s prme, the gcd s 1, whch runs the controller as fast as the most frequent servce. Checkng all jobs n both queues as fast as a perodc sensor samplng servce mposes too much load on the system. As a consequence, we focus here on the starvaton controller for servces wth the same perod. Although equal n ther perod, dfferent servces may have dfferent starvaton levels. For reasons of comparson, we defne the omsson rato as the number of job omssons of a job per tme step. We now determne the least upper borderlne of the controller perod, where the omsson rato for at least one of the jobs dffers from all the others. If the controller perod exceeds ths borderlne, the omsson rato wll be the same for all jobs. From the controller rule, we can derve the perod guaranteeng the starvaton bound. From l ( s ) omsson 0, we derve T control = l( s ) T t t, last. For dfferent starvaton levels the upper bound s now found by max{ T l( s )}. Beyond ths perod, the controller always evaluates ts control rule to true and notfes the scheduler to schedule all jobs n FIFO order. The Fgure 8 llustrates ths behavor for two servces wth perod T = 3 and starvaton level l ( s ) = 1 and l ( s ) = The upper bound for the controller perod s max{ T l( s )} = 30. Omsson rato Starvaton level 1 Starvaton level Controller perod Fgure 8. Controller perod bound at T = 30 for two control servces wth perod T=3 and dfferent starvaton levels In terms of system load and guarantees for starvaton bounds, no optmal control perod can be gven. An alternatve s to delegate the need of control to the dspatcher. However, the dspatcher then has to count the number of job omssons n order to call controller mmedately. In contrast to our system desgn, the dspatcher then has to know every detal of a servce and addtonally t has to mplement almost all of the controller logc. Ths stands n contrast to our desgn prncples from secton IV. V. CASE STUDY Our evaluaton settng s the AwareOffce [1], an offce space wth multple moveable and moble objects such as chars, tables, wndows, doors and offce supples lke pens, paper, projectors, whteboards and flpcharts. Offce workers nteract wth those objects regularly. We attached our Partcle Computer [3] sensor nodes to those objects n order to derve actons and complex stuatons, e.g. meetng or coffee break. Thereby, the recognton of stuatons s dstrbuted among the sensor nodes. The goal s to support offce workers n plannng meetngs, and control of envronmental and offce nfrastructure components. In the AwareOffce, the Partcle sensor nodes have to perform a set of sensng, communcaton and computaton tasks. The sensor nodes detect multple events n the envronment through a rch phalanx of sensors and forward them. On the other hand, the nodes allocate some of ther resources on communcaton and computaton for collectng data from multple sensng nodes and recognton of complex stuatons. We mplemented the tasks as the followng servces wth the propertes lsted below. Varyng computaton tmes are ndcated through ther relatve occurrence n parentheses rght after the computaton tmes.

7 Servce Computaton Tme C (ms) Perod T (ms) Voltage samplng Audo samplng Lght samplng Acceleraton samplng Force samplng Temperature samplng Volume computaton Shock detecton (acceleraton) 0.02 (99%) / 200 (1%) 20 Shock detecton (force) 0.02 (99%) / 200 (1%) 50 Communcaton 0.5(50%) / 6 (45%) / 22.5 (5%) Table 1. Servce evaluaton set for Partcle sensor nodes whch focus on sensng The set s not statc, but rather contans a dynamc changes n ts propertes. In partcular, communcaton servces and computaton servces are subject to strong varatons of ther computaton tme. The sensor servces have short perods, whch lead to a hgh system utlzaton. As a consequence, we consder the sets as well-chosen representatves for the evaluaton. Our evaluaton method s to benchmark the schedulng framework frst wthout the extenson of the dspatcher and wthout the use of the starvaton controller. We wll test the FIFO, RM and EDF schedulng strateges on the servce set. In partcular, our metrcs n these benchmarks are the jtter of each job and the number of omssons. Latter ndcates the potental level of starvaton. Furthermore, we are nterested n the adaptaton of the perod throughout the jobs. These result provde the baselne whch our approach utlzng jtter correcton and starvaton controller wll mprove. At the end we wll benchmark the sensor energy savngs whch are acheved by the schedulng. VI. SCHEDULING IN UNPREDICTABLE ENVIRONMENTS For deeper nvestgatons on our approach, the servce set from Table 1 was mplemented n a schedulng smulator. The smulaton covered a tme span of 1.1 seconds. We ensured that all possble computaton tmes occurred several tmes n that perod. The servce set was scheduled wthout the adaptaton algorthms and afterwards wth the adaptaton algorthm. We ensured that the behavor of the varyng computaton tme was the same n the comparson. The jtter correcton was done mmedately by the dspatcher. The starvaton controller was called once after the dspatchng of 30 jobs. Durng one smulaton run t was called 13 tmes. The overall system utlzaton was always between 91% and 93%. For all smulatons we consdered the average jtter fracton and the average perod over all jobs for a servce. The jtter fracton expresses the delay between two successve executons of a job normalzed to ts perod. It s computed as follows; denotes the servce, now and last are denote the current and last dspatch tme JtterFrac = t, now t, last T T For the evaluaton of the servce executon, we average the jtter fracton over all jobs of a sngle servce. Ths metrc s abbrevated as. 13 Jtter. The comparson between two smulaton runs, one run wthout adaptaton and the second one wth adaptaton delvers the dfference n the jtter fracton, whch s abbrevated as Jtter. The advantage of ths metrc s that t ncludes nformaton about job omsson. If Jtter > 1, then the jtter exceeded the perod and therefore the job wll be canceled by the dspatcher. As a result of the dynamc of the servce set, we are nterested n the change of the perod of each servce. After each smulaton run we computed the average perodc nterval of servce whch s defned as I = t smulaton / c, where c denotes the number of jobs executed for the servce. Lke for the jtter fracton these ntervals were compared for each servce n the two cases wth and wthout the adaptaton. The result s represented by I. We evaluated our schedulng framework usng the three schedulng strateges RMS; FIFO and EDF. The results are summarzed n Table 2. Note that negatve values represent an mprovement when usng the adaptaton. Postve values ndcate that the schedulng wthout adaptaton performed better. Servce Voltage samplng Audo samplng Lght samplng Acceleraton samplng Force samplng Temperature samplng Volume computaton Shock detecton (force) Shock detecton (acceleraton) Communcaton I (ms) RMS FIFO EDF Jtter (%) I (ms) Jtter (%) I (ms) Jtter (%) Table 2. Results from our schedulng smulatons; negatve numbers ndcate an mprovement acheved by the adaptaton compared to the non-adaptve schedulng

8 Interestng n the table above are the results ndcatng an mprovement of more than 100%. A closer look on the data revealed that these servces suffered under permanent starvaton n the case where no adaptaton was actve. Reasons were a low prorty n case of RMS, a very long deadlne n the case of EDF and a perod volaton n the case of FIFO. The jtter fracton for the jobs of these servces were constantly hgh above 1. As a result the averaged value over all jobs of those servces exceeded the starvaton border. In the smulaton runs those stuatons could be handled through the starvaton controller. The jtter fracton decreased dramatcally below the 1-lmt and as a result we obtaned a dfference of more than 100% between the smulaton runs. Intutvely, ths dfference s explanable, f one s aware that the stuaton for ths servce changed completely from permanent starvaton to actual executon. A. Utlzaton analyss In order to compare our results from Table 2 wth our selecton from Table 2 we analyzed the correspondence between the utlzaton of each sngle servce and the performance of our schedulng framework. The utlzaton s computed accordng to formula (2) but for each servce separately. The frst result shows the correspondence between the utlzaton and the jtter fracton. Jtter fracton dfference [%] Shock detecton servces RMS FIFO EDF Utlzaton Fgure 9. Correspondence between the utlzaton and the mprovements regardng the jtter fracton The fgure above ndcates that the schedulng framework works better on servces wth hgher utlzaton. These are servces where the computaton tme consumes a large fracton of the perod. Servces wth a very short perod share the same property. As an example consder the audo samplng servce from Table 1. For servces wth a low system utlzaton the mprovement s not clear. The jtter fracton s negatve, ths ndcates an mprovement, as well as postve ths s a weakenng. Remarkable are the shock detecton servces wth the large varaton n ther computaton tmes. The acheved mprovement s very hgh, snce the starvaton controller resolved the permanent starvaton. However, the utlzaton s rather low, due to the low probablty of ther long computaton tme. For EDF the mprovement through adaptaton s exceptonal hgh because of the very long deadlne n 99% of the runtme. As a second result of our nvestgaton we present the correspondence between utlzaton and the perodc nterval dfference n Fgure 10. The jtter correcton wll lead to a longer perods due to the fact that the next arrval tme s computed on bass of the last nvocaton. For servces wth low utlzaton, ths can be seen n Fgure 10. However, the adaptaton has a rather small effect on the perod for servces wth hgher utlzaton. Due to ther shorter perods, they are already scheduled qute accurate. Nevertheless, the jtter correcton can mprove ths behavor. Remarkable agan are the changes for the shock detecton servces. Due to ther long starvaton phase the perodc nterval s huge. The mprovement through the starvaton controller s then very sgnfcant. Perodc nterval dfference [ms] RMS FIFO EDF Utlzaton Fgure 10. Correspondence between the utlzaton and the mprovements regardng the perodc nterval B. Automatc energy management Our enhanced dspatcher s able to support the power up and down of sensors. Thereby, the dspatcher queres the servce for a new arrval tme, but let t addtonally know the current tme. As an result, the servce sets the arrval tme for ts next job before the perod, leavng enough tme for the start-up. The developer confgures ths start-up tme. We evaluated the energy management usng the acceleraton sensor ADXL210 of our Partcle Computer platform. The sensor needs 316 us for start-up and draws 1 ma. Fgure 11 plots the energy consumpton over a tme frame of 1.1 seconds. The results were gathered usng the servce set from Table 1 under RMS and all adaptaton mechansms were enabled. Current [ma] Shock detecton servces ADXL Power Consumpton (RMS) Tme [mcroseconds] x 10 5 Fgure 11. Power consumpton ADXL acceleraton sensor Between 475ms and 708ms wthn the plot, the ADXL sensorsamplng job was skpped due to the long runtme of a shock detecton job. The adaptve schedulng framework acheved for the overall tme span a duty cycle of 9.5%. No extra code had to be placed n the applcaton for swtchng the sensor on and off. Smultaneously, the adaptaton mechansms n the framework mproved the jtter fracton. Automatc energy management becomes crucal for sensor node platforms ncorporatng chemcal sensors lke gas sensors wth long start-up tmes.

9 VII. IMPLEMENTATION The mplementaton of the schedulng framework was done on the Partcle Computer platform (Fgure 12). It bases on a Mcrochp PIC18F6720 mcrocontroller. Ths low power MCU has an nstructon cycle of 0,2 µs and ncludes only 4K RAM and 128K ROM. mplementaton. We are usng forward lnk lsts that are only accessble va the queue head. Ths explans the farly hgh overhead the FIFO scheduler. In ths case a more optmzed mplementaton usng just a sngle queue would have been better n terms of performance by avodng the need to terate the whole ready queue. State transton Instructons-cycles Ready to runnng PIC18F cycles 3µs 138 cycles cycles 25.6µs 6.5µs-150µs cycles cycles cycles 6.5µs-92µs 6.5µs-150µs 6.5µs-150µs Runnng to watng create next nstance sort nto watng Watng to Ready FIFO Scheduler RMS Scheduler EDF Scheduler Table 3. Tmng Measurement of Servce Transtons Fgure 12. The Partcle sensor node Due to the resource constrants the mplementaton especally stresses on low schedulng overhead by the means of memory consumpton and computaton tme. A 16bt tmer at nstructon cycle resoluton can be used to trgger dspatchng events reganng control from an nterruptble background applcaton. Because of the nonpreemptve nature of servces, no thread control mechansms are needed. The servce executon state s kept on top of the runtme stack of the background applcaton. Servces are stored wthn a bounded array as a set of servce control blocks. Each block contans generc parameters such as ts perod and can be extended at comple tme by optonal parameters, e.g. the starvaton level. The servce control block represents an ndefntely long sequence of recurrng jobs. Only the arrval tme for the earlest job n tme that has nether been executed nor skpped s stored wth each servce element. The servce run state s mplctly encoded by the membershp n ether the ready or watng queue. The default mplementaton supports 16 actve servces n the system. Each servce control block consumes 5 Byte of RAM. Addtonally 1 byte s needed to pont to the queue heads. Structure splttng s used to store statc parameters such as the ponters to the servce tself. The ponters to the servce procedure are kept n parallel jump table n code memory consumng no addtonal RAM. Overall ths setup consumes only 81 byte of statcally allocated RAM for the scheduler. Prortes of the jobs are reflected by the sortng order of the ready queue supportng both dynamc and fxed prorty schemes. The watng queue s strctly sorted by arrval tme of the next watng job of each servce. The scheduler nteracts wth the dspatcher by nsertng formerly watng jobs nto the ready queue and s called on each arrval of a new job. Arbtrary prorty schemes can be mplemented. The FIFO scheduler as an example smply retans the order of the watng queue on the transton from watng to ready. RMS uses the perod length as sort crteron. The overhead of a sngle scheduler call s thus lmted to the overhead of an nserton nto a sorted lst. Addtonally another nserton s needed when movng a servng from ready to watng vrtually creatng the next nstance of a job. At a maxmum that means nw+nr per job comparson operaton; nw and n r beng the number of jobs n each queue. By desgn nw+n r equals the total number of servces n currently runnng. Concrete tmng measurements based on the mplementaton on a Partcle 2/29 are depcted n Table 3. We use the algorthm from Fgure 13 to mplement the dspatcher. Inserton nto the watng queue s only done once per dspatch event. Inserton nto the ready queue s on the average also done once per dspatch event. But, t can happen as often as n tmes f all servces become ready at the same tme. The concrete tmngs are strongly nfluenced by the lnked lst On the average the teraton overhead for RMS and EDF s even less than FIFO snce sortng termnates the teraton before the end s reached. RMS, EDF and the watng queue nserton do not dffer n the mplementaton n terms of sortng. Only the sortng key changes from the perod n RMS to the deadlne n EDF. Ths explans the equal measurements regardng those algorthms. vod dspatcher() nterrupt tmer1{ for(;;){ tme start=now(); servce current=pop(ready); //dspatch frst dspatch(current); //run servce unnterruptble nterval C=tme_dff(now(),start); servce_calc_next(current,c,start); //create next nsert_sorted(watng,current); whle(next=top(watng) && get_arrval(next)=<now()) schedule(ready,pop(watng)); //call the scheduler f (!top(ready)) { servce next=pop(watng); nsert(ready,next); //pre-schedule sleep_tme= tme_dff(now(),get_arrval(next)); f(sleep_tme>dispatch_overhead){ set_tmer1(sleep_tme); return; //defer loop to nterrupt }}}}} Fgure 13. Dspatcher mplementaton We mplemented the adaptaton strateges jtter correcton, starvaton controller and the energy management. The overhead of the strateges s gven n the Table 4. The real effort spent for the strategy heavly depends on ts perod. As a consequence, we state the basc overhead n µs and quote the perod as we have mplemented t. Adaptaton strategy Jtter correcton Overhead Strategy perod 32.5 µs Every dspatcher nvocaton Starvaton controller 6.5µs-191µs Every 30 dspatcher nvocatons Energy management 27.8µs (+ schedulng) Every sensor perod Table 4. Adaptaton overhead

10 VIII. CONCLUSION AND FUTURE WORK We presented an adaptve schedulng framework whch s especally talored to effcently organze and processes on sensor network platforms whch are deployed n unpredctable envronments. The framework s mplemented as a runtme envronment for ndependent, non-preemptve servces, whch can be effcently scheduled and executed even under hgh load and the varyng computaton tmes. We proposed two adaptaton mechansm: jtter correcton through the dspatcher and starvaton control through a new servce. Low jtter and a starvaton control were the frst two prmary goals defned at the begnnng of ths paper. Our results show sgnfcant mprovements regardng low jtter, and starvaton control. The thrd goal of automatc energy management was also evaluated. The effcent mplementaton of the adaptve schedulng framework proved feasblty for sensor node platforms. For future work we wll further nvestgate the schedulng framework and adaptaton strateges. Crucal n our research wll be the selecton of approprate servce sets and ther propertes. A straght approach cannot be chosen here, snce many effects we are nvestgatng are drectly nfluenced by the servces n ther specfc combnaton. Our future work wll also contan the nvestgaton of other applcaton areas. In partcular, we see hgh potental of our approach n hghly moble scenaros. ACKNOWLEDGMENT The work presented n ths paper was partally funded by the European Communty through the project CoBIs (Collaboratve Busness Items) under contract no and by the Mnstry of Economc Affars of the Netherlands through the BSIK project Smart Surroundngs under contract no REFERENCES [1] M. Begl, T. Zmmer, A. Krohn, C. Decker P. Robnson. Creatng Adhoc Pervasve Computng Envronments, Vdeo at Pervasve 2004 n "Advances n Pervasve Computng", ISBN , pp , Venna, Austra. [2] P.Bratley, M.Floran, P.Robllard. Schedulng wth earlest start and due date constrants. Naval Research Quarterly, 18(4), 1971 [3] C.Decker, A.Krohn, M.Begl, T.Zmmer. The Partcle Computer System. IPSN SPOTS, Los Angeles, USA, 2005 [4] A.Dunkels, O.Schmdt, T.Vogt. Usng Protothreads for Sensor Node Programmng. In Proceedngs of the REALWSN 2005 Workshop on Real-World Wreless Sensor Networks, Stockholm, Sweden, June [5] C.Han, R.Rengaswamy, R.Shea, E.Kohler, M.Srvastava. SOS: A dynamc operatng system for sensor networks. Thrd Internatonal Conference on Moble Systems, Applcatons, And Servces (Mobsys), 2005 [6] J. Hll, R. Szewczyk, A. Woo, S. Hollar, D. Culler, K. Pster, System archtecture drectons for network sensors, ASPLOS 2000, Cambrdge, November [7] T.J. Hofmejer, S.O. Dulman, P.G. Jansen, P.J.M. Havnga. "AmbentRT - Real Tme System Software Support for Data Centrc Sensor Networks", ISSNIP 2004, Australa, December 2004 [8] K.Jeffay, D.F.Stanat, C.U.Martel. On non-preemptve schedulng of perodc and sporadc tasks. 12th IEEE Symposum on Real-Tme Systems (December 1991), pp [9] C.L.Lu, J.W.Layland, Schedulng algorthms for multprogrammng n a hard-real-tme envronment. Journal of the ACM 20(1), 1973 [10] F.Stajano, R.Anderson, The grenade tmer: Fortfyng the watchdog tmer aganst malcous moble code, MoMuC 2000, Waseda, Tokyo, Japan, Oct [11] J.Stankovc, K. Ramamrtham. The desgn of the sprng kernel. In Proceedngs of the IEEE Real-Tme Systems Symposum, December 1987