Memory-Optimized Software Synthesis from Dataflow Program Graphs withlargesizedatasamples

Transcription

1 EURSIP Journl on pplied Signl Processing 2003:6, c 2003 Hindwi Publishing orportion Memory-Optimized Softwre Synthesis from tflow Progrm Grphs withlrgesizetsmples Hyunok Oh The School of Electricl Engineering nd omputer Science, Seoul Ntionl University, Seoul 5-742, Kore Emil: oho@comp.snu.c.kr Soonhoi H The School of Electricl Engineering nd omputer Science, Seoul Ntionl University, Seoul 5-742, Kore Emil: sh@comp.snu.c.kr Received 28 Februry 2002 nd in revised form 5 October 2002 In multimedi nd grphics pplictions, dt smples of nonprimitive type require significnt mount of memory. This pper ddresses the problem of minimizing the memory requirement for such pplictions in embedded softwre synthesis from grphicl dtflow progrms bsed on the synchronous dtflow (SF) model with the given execution order of nodes. We propose memory minimiztion technique tht seprtes globl memory s from locl pointer s: the globl s store live dt smples nd the locl s store the pointers to the globl entries. The proposed lgorithm reduces 67% memory for JPEG encoder, 40% for n H.263 encoder compred with unshred versions, nd 22% compred with the previous shring lgorithm for the H.263 encoder. Through extensive shring optimiztion, we believe tht utomtic softwre synthesis from dtflow progrm grphs chieves the comprble code qulity with the mnully optimized code in terms of memory requirement. Keywords nd phrses: softwre synthesis, memory optimiztion, multimedi, dtflow.. INTROUTION Reducing the size of memory is n importnt objective in embedded system design since n embedded system hs tight re nd power budgets. Therefore, ppliction designers usully spend significnt mount of code development time to optimize the memory requirement. On the other hnd, s system complexity increses nd fst design turn-round time becomes importnt, it ttrcts more ttention to use high-level softwre design methodology: utomtic code genertion from block digrm specifiction. OSSP [], GRPE [2], nd Ptolemy [3] re wellknown design environments, especilly for digitl signl processing pplictions, with utomtic code synthesis fcility from grphicl dtflow progrms. In hierrchicl dtflow progrm grph, node, or block, represents function tht trnsforms input dt strems into output strems. The functionlity of n tomic node is described in high-level lnguge such s or VHL. n rc represents chnnel tht crries strems of dt smples from the source node to the destintion node. The number of smples produced (or consumed) per node firing is clled the output (or the input) smple rte of the node. In cse the number of smples consumed or produced on ech rc is stticlly determined nd cn be ny integer, the grph is clled synchronous dtflow grph (SF) [4] which is widely dopted in forementioned design environments. We illustrte n exmple of SF grph in Figure. Ech rc is nnotted with the number of smples consumed or produced per node execution. In this pper, we re concerned with memory optimized softwre synthesis from SF grphs though the proposed techniques cn be esily extended to other SF extensions. To generte code from the given SF grph, the order of block executions is determined t compile time, which is clled scheduling. Since dtflow grph specifies only prtil orders between blocks, there re usully more thn one vlid schedule. Figure b shows one of mny possible scheduling results in list form, where 2() mens tht block is executed twice. The schedule will be repeted with the strems of input smples to the ppliction. code templte ccording to the schedule of Figure b is shown in Figure c. When synthesizing softwre from n SF grph, spce is llocted to ech rc to store the dt smples

2 Memory-Optimized Softwre Synthesis from tflow Progrm Grphs with Lrge Size t Smples ()2() min() { for(i = 0; i<2; i++){ { { for(i = 0; i<2; i++){ (c) (d) Figure : SF grph exmple, scheduling result, (c) code templte, nd (d) lloction. T 8 8 Zigzg 8 8 Q 8 8 Q 8 8 Zigzg 8 8 T b c d e Figure 2: Imge processing exmple. between the source nd the destintion blocks. The number of llocted entries should be no less thn the mximum number of smples ccumulted on the rc t runtime. fter block is executed twice, two dt smples re produced on ech output rc s explicitly depicted in Figure d. We define llocted on ech rc s locl tht is used for dt trnsfer between two ssocited blocks. If the dt smples re of primitive types, the locl s store dt vlues nd the generted code defines locl with n rry of primitive type dt. Required memory spces in the synthesized code consist of code segments nd dt segments. The ltter stores constnts nd prmeters s well s dt smples. We regrd memory spce for dt smples s memory, or shortly, in this pper. There re severl clsses of pplictions tht del with nonprimitive dt types. The typicl dt type of n imge processing ppliction is mtrix of fixed block size s illustrted in Figure 2. Grphic pplictions usully need to del with structure-type dt smples tht contin informtion on vertex coordintes, viewpoints, light sources, nd so on. Networked multimedi pplictions exchnge pckets of dt smples between blocks. In those pplictions, the requirements re likely to be more significnt thn others. For exmple, the code size of H.263 encoder [5] is bout 00 K bytes but the size is more thn 300 K bytes. Since the requirement of n SF grph depends on the execution order of nodes, there hve been severl pproches [6, 7, 8] to tke the size minimiztion s one of the scheduling objectives. However, they do not consider either shring possibilities nor nonprimitive dt types. Finding out n optiml schedule for minimum requirements considering both is future reserch topic. In this pper, insted, we propose shring technique for nonprimitive type dt smples to minimize the memory requirement ssuming tht the execution order of nodes is lredy determined t compile time. Thus, this work is complementry to existent scheduling lgorithms to further reduce the requirement. Figure 2 demonstrtes simple exmple where we cn reduce the significnt mount of memory by shring s. Without shring, five locl s of size 64 (= 8 8) re needed. On the other hnd, only two s re needed if shring is used so tht, c,nde s shre,ndb nd d s shre. Such shring decision cn be mde t compile time through lifetime nlysis of dt smples, which is well-known compiltion technique. key difference between the proposed technique nd the previous pproches is tht we seprte the locl pointer s from globl dt s explicitly in the synthesized code. In Figure 2, we use five locl pointer s nd two globl s. This seprtion provides more memory shring chnces when the number of locl entries becomes more thn one. If the locl size becomes one fter optimiztion, no seprtion is needed. We exmine Figure 3 which illustrtes simplified version of n H.263 encoder lgorithm where ME node indictes motion estimtion block, Trns is trnsform coding block which performs T nd Quntiztion, nd InvTrns performs inverse trnsform coding nd imge reconstruction. Ech smplebetweennodesisfrmeof76 44 byte size which is lrge enough to ignore locl size. The dimond symbol on the rc between ME nd InvTrns denotes n initil dt smple, which is the previous frme in this exmple. If we do not seprte locl s from globl s, then we need three frme s s shown in Figure 3b since s nd c overlp their lifetimes t ME, nd b t Trns, nd b nd c t InvTrns. Even though two frmes re sufficient for this grph, we cnnot shre ny without seprtion of locl s nd globl s.infct,wecnuseonly two frme s if we use seprte locl pointer s. Figure 3c shows the lloction of locl s nd globl

3 56 EURSIP Journl on pplied Signl Processing g g 2 ME Trns ME Trns b ME Trns InvTrns c InvTrns InvTrns (c) Figure 3: Simplified H.263 encoder in which dimond between InvTrns nd ME indictes n initil smple dely, nd (c) minimum lloction without nd with seprtion of globl s nd locl s, respectively. 2 b Schedule: Smples s(b, 3) s(, 2) s(b, 2) s(b, ) s(, ) 2 2 n itertion cycle t g(3) s(b, 2) g(2) s(b, ) g() s(, ) s(b, 3) s(, 2) 2 2 t (b, 2) (b, ) (, ) Locl s(b, 2) s(b, ) s(, ) s(b, 3) s(, 2) 2 2 t (c) (d) Figure 4: n exmple of SF grph with n initil dely between nd illustrted by dimond, the smple lifetime chrt, (c) globl lifetime chrt, nd (d) locl lifetime chrt. s, nd the mpping of locl s to globl s. The detiled lgorithm nd code synthesis techniques will be explined in Section 4. It is NP-hrd to determine the optiml locl, globl sizes, nd their mppings in generl cses where there re feedbck structures in the grph topology. The problem becomes hrder if we consider shring mong different size dt smples. Therefore, we devise heuristic tht focuses on globl minimiztion first nd pplies n optiml lgorithm next to find the minimum locl pointer sizes nd to mp the locl pointer s to the minimum globl s. The proposed heuristic results in less thn 5% overhed thn n optiml solution on verge. In Section 2, we define new shring problem for nonprimitive dt types, nd survey the previous works briefly. The overview of the proposed technique is presented in Section 3. Section 4 explins how to minimize the size of locl s nd their mppings to the minimum globl s ssuming tht ll dt smples hve the sme size. In Section 5, we extend the technique to the cse where dt smples hve the different sizes. Grphs with initil smples re discussed in Section 6. Finlly, we present some experimentl results in Section 7, nd mke conclusions in Section PROLEM STTEMENT N PREVIOUS WORKS In the proposed technique, globl s store the live dt smples of nonprimitive type while the locl pointer s store the pointers for the globl entries. Since multiple dt smples cn shre the spce s long s their lifetimes do not overlp, we should exmine the lifetimes of dt smples. We denote s(, k) s the kth stored smple on rc nd TNSE s the totl number of smples exchnged during n itertion cycle. onsider n exmple of Figure 4 with the ssocited schedule. TNSE becomes 2 nd two smples, s(, ) nd s(, 2),reproducedndconsumedonrc. rcb hs n initil smple s(b, ) nd two more smples, s(b, 2) nd s(b, 3), during n itertion cycle. The lifetimes of dt smples re displyed in the smple lifetime chrt s shown in Figure 4b, where the horizontl xis indictes the bstrct notion of time: ech invoction of node is considered to be one unit of time. The verticl xis indictes the memory size nd ech rectngle denotes the lifetime intervl of dt smple. Note tht ech smple lifetime defines single time intervl whose strt time is the invoction time of the source block nd the stop time is the completion time of the destintion block. For exmple, the lifetime intervl of smple s(b, 2) is [,].Wetkespecilcreof initil smples. The lifetime of smple s(b, ) is crried forwrd from the lst itertion cycle while tht of smple s(b, 3) is crried forwrd to the next itertion cycle. We denote the former-type intervl s til lifetime intervl, or shortly til intervl, nd the ltter s hed lifetime intervl, or hed intervl. In fct,smples(b, 3) t the current itertion cycle becomes s(b, ) t the next itertion cycle. To distinguish itertion cycles, we use s k (b, 2) to indicte smple s(b, 2) t the kth itertion. Then, in Figure 4, s (b, 3) is equivlent to s 2 (b, ).

4 Memory-Optimized Softwre Synthesis from tflow Progrm Grphs with Lrge Size t Smples 57 nd the smple lifetime tht spns multiple itertion cycles is defined s multicycle lifetime. Note tht the smple lifetime chrt is determined from the schedule. From the smple lifetime chrt, it is obvious tht the minimum size of globl memory is the mximum of the totl memory requirements of live dt smples over time. We summrize this fct s the following lemm without proof. Lemm. The minimum size of globl memory is equl to the mximum totl size of live dt smples t ny instnce during n itertion cycle. We mp the smple lifetimes to the globl s: n exmple is shown in Figure 4c where g(k) indictes the kth globl. In cse ll dt types hve the sme size, n intervl scheduling lgorithm cn successfully mp the smple lifetimes to the minimum size of globl memory. Smple lifetime is distinguished from locl lifetime since locl my store multiple smples during n itertion cycle. onsider n exmple of Figure 4 where the locl sizes of rcs nd b re set to be nd 2, respectively. We denote (, k) s the kth locl entry on rc.then, the locl lifetime chrt becomessdrwninfigure 4d. uffer (, ) stores two smples, s(, ) nd s(, 2), to hve multiple lifetime intervls during n itertion cycle. Now, we stte the problem this pper ims to solve s follows. Problem. etermine L(g,s(g)) nd G(g,s(g)) in order to minimize the sum of them, where L(g,s(g)) is the sum of locl sizes on ll rcs nd G(g,s(g)) is the globl size with given grph g nd given schedule s(g). Since the simpler problems re NP-hrd, this problem is NP-hrd, too. onsider specil cse when ll smples hve the sme type or the sme size. For given locl size, determining the minimum globl size is difficult if locl my hve multiple lifetime intervls, which is stted in the following theorem. Theorem. If the lifetime of locl myhvemultiple lifetime intervls nd ll dt types hve the sme size, the decision problem whether there exists mpping from given number of locl s to given number of globl s is NP-hrd. Proof. We will prove this theorem by showing tht the grph coloring problem cn be reduced to this mpping problem. onsider grph G(V, E) wherev is vertex set nd E is n edge set. simple exmple grph is shown in Figure 5. We ssocite new grph G (Figure 5b) where pir of nodes re creted for ech vertex of grph G nd connected to the dummy source node S nd the dummy sink node K of the grph G. In other words, vertex in grph G is mpped to locl in grph G. The next step is to mp n rc of grph G to schedule sequence in grph G. For instnce, n rc in grph G is mpped to schedule segment ( ) to enforce tht two locl s on Figure 5: n exmple instnce of grph coloring problem, nd the mpped grph for the proof of Theorem. S rcs nd my not be shred. s we trverse ll rcs of grph G, we generte vlid schedule of grph G. Trversing rcs nd in grph G genertes schedule: S( )( )K. From this schedule, we find out tht the lifetime on rc consists of two intervls. The constrint tht two djcent nodes in G my not hve the sme color is trnslted to the constrint tht two locl s my not be shred in G. Therefore, the grph coloring problem for grph G is reduced to the mpping problem for grph G. The register lloction problem in trditionl compilers is to shre the memory spce for the vribles of nonoverlpped lifetimes [9]. If the vrible sizes re not uniform, the lloction problem, known s the dynmic storge lloction problem [0, ], is NP-complete. In our context, this problem is equivlent to minimize the globl memory ignoring the locl sizes nd mpping problems. e Greef et l. [2] presented systemtic procedure to shre rrys for multimedi pplictions in synthesis tool clled TOMIUM. They nlyze lifetimes of rry vribles during single itertion trce of progrm nd do not consider the cse where lifetimes spn multiple itertion cycles. Iftheprogrmisretimed,somevriblescnbelivelonger thn single itertion cycle. nother extension we mke in the proposed pproch is tht we consider ech rry element seprtely for shring decision when ech rry element is of nonprimitive type. Recently, Murthy nd httchryy [3] proposed scheduling technique for SF grphs to optimize the locl memory size by shring. Since they ssume only primitive type dt, their shring decision considers rry vribles s whole. However, their reserch result is complementry to our work since the schedule reduces the number of live dt smples t runtime, which reduces the globl memory size in our frmework. They compred their reserch work with Ritz et l. s [4] whose schedule pttern does not llow nested loop structure. They showed tht nested loop structure my significntly reduce the locl memory size. Even though memory shring techniques hve been reserched extensively from compiler optimiztion to high level synthesis, no previous work hs been performed, to the uthors knowledge, to solve the problem we re solving in this pper. K

5 58 EURSIP Journl on pplied Signl Processing : U is set of smple lifetimes; P is n empty globl lifetime chrt. 2: While (U is not empty){ 3: Tke out smple lifetime x with the erliest strt time from U. 4: Find out globl whose lifetimeends erlier thn the strt timeof x. 5: Priority is given to the tht stores smples on the sme rc if exists. 6: If no such globl exists in P, crete nother globl. 7: Mp x to the selected globl 8: Figure 6: Intervl scheduling lgorithm. Smples 2 3 2() s(, 6) s(, 5) s(, 4) s(, 3) s(, 2) s(, ) g(4) g(3) g(2) g() s(, 4) s(, 3) s(, 2) s(, 5) s(, ) s(, 6) () (2) (3) (4) g() g(2) g(3) g(4) (c) (d) Figure 7: n SF subgrph with given schedule, the smple lifetime chrt, (c) the globl lifetime chrt, nd (d) locl lloction nd mpping. 3. PROPOSE TEHNIQUE In this section, we sketch the proposed heuristic for the problem stted in the previous section. Since the size of nonprimitive dt type is usully much lrger thn tht of pointer type in multimedi pplictions of interest, reducing the globl size is more importnt thn reducing the locl pointer s. Therefore, our heuristic consists of two phses: the first phse is to mp the smple lifetimes within n itertion cycle into the minimum number of globl s ignoring locl sizes, nd the second phse is to determine the minimum locl sizes nd to mp the locl s to the given globl s. 3.. minimiztion Recll tht smple lifetime hs single intervl within n itertion cycle. When ll smples hve the sme dt size, the intervl scheduling lgorithm is known to be n optiml lgorithm [5] to find the minimum globl size. We summrize the intervl scheduling lgorithm in Figure 6. onsider n exmple of Figure 4 whose globl lifetime chrt is displyed in Figure 4c. fter smples s(, ), s(b, ), nd s(b, 2) re mpped into three globl s, s(, 2) cn be mpped to ll three s. mong the cndidte globl s, we select one tht lredy stores s(, ) ccording to the policy of line 5 of Figure 6. The reson of this priority selection is to minimize the locl sizes, which will be discussed in the next section. When the dt smples hve different sizes, this mpping problem becomes NP-hrd since specil cse cn be reduced to 3-prtition problem [0]. Therefore, we develop heuristic, which will be discussed in Section Locl size determintion Theglobl minimiztion lgorithm in the previous phse runs for one itertion cycle while the grph will be executed repetedly. The next phse is to determine the minimum locl sizes tht re necessry to store the pointers of dt smples mpped to the globl s. Initilly we ssign seprte locl to ech live smple during n itertion cycle. Then, the locl size on ech rc becomes the totl number of live smples within n itertion cycle: ech smple occupies seprte locl. In Figure 4,for instnce, two locl s re llocted on rc while three locl s on rc b. Wht is the optiml locl size? The nswer depends on when we set the pointer vlues, or when we bind the locl s to the globl s. If binding is performed stticlly t compile time, we cll it sttic binding. If binding cn be chngedtruntime,itisclleddynmic binding. In generl, the dynmic binding cn reduce the locl size significntly with smll runtime overhed of globl mngement ynmic binding strtegy Since we cn chnge the pointer vlues t runtime in dynmic binding strtegy, the locl size of n rc cn be s smll s the mximum number of live smples t ny time instnce during n itertion cycle. onsider nother exmple of Figure 7 with given scheduling result nd globl lifetime chrt s shown in Figure 7c. Since the mximum number of live smples is four, we need t lest four locl s on rc. Suppose we hve the minimum number of locl s on rc. Locl (, ) stores two

6 Memory-Optimized Softwre Synthesis from tflow Progrm Grphs with Lrge Size t Smples 59 smples, s(, ) nd s(, 5), which re unfortuntely mpped to different globl s. It mens tht the pointer vlue of locl (, ) should be set to g() t the first invoction of node but to g(2) t the third invoction, dynmiclly. We repet this pointer ssignment t every itertion cycle t runtime. If there re initil smples on n rc, cre should be tken to compute the repetition period of pointer ssignment. rc b of Figure 4 hs n initil smple nd needs only two locl s since there re t most two live smples t the sme time. Unlike the previous exmple of Figure 7, the globl lifetime chrt my not repet itself t the next itertion cycle. The lifetime ptterns of locl s (b, ) nd (b, 2) re interchnged t the next itertion cycle s shown in Figure 8. In other words, the repetition periods of pointer ssignment for rcs with initil smples my spn multiple itertion cycles. Section 4 is devoted to computing the repetition period of pointer ssignment for the rcs with initil smples. Suppose n rc hs M locl s. Since the locl sre ccessedsequentilly, ech locl entry hs t most TNSE/M smples nd the pointer to smple s(, k) is stored in (, k mod M). fter the first phse is completed, we exmine the mpping results of the llocted smple in locl to the globl s t the code genertion stge. If the mpping result of the current smple is chnged from the previous one, code segment is inserted utomticlly to lter the pointer vlue t the current schedule instnce. Note tht it incurs both memory overhed of code insertion nd time overhed of runtime mpping Sttic binding strtegy If we use sttic binding, we my not chnge the pointer vlues of locl struntime.itmensthtlllloctedsmples to locl should be mpped to the sme globl. For exmple of Figure 7, we need six locl s for sttic binding: two more s thn the dynmic binding cse since s(, ) nd s(, 5) re not mpped to the sme globl. On the other hnd, rc of Figure 4 needs only one locl for sttic binding since two llocted smples re mpped to the sme globl. How mny s do we need for rc b of Figure 4 for sttic binding? To nswer this question, we extend the globl lifetime chrt over multiple itertion cycles until the smple lifetime ptterns on the rc become periodic. We need to extend the lifetime chrt over two itertion cycles s displyed in Figure 8. Note tht the hed intervl of s 2 (b, 3) is connected to the til intervl of s 3 (b, ) in the next repetition period. Therefore, four live smples re involved in the repetition period tht consists of two itertion cycles. The problem is to find the minimum locl size M such tht ll llocted smples on ech locl re mpped to the sme globl. The minimum number is four in this exmple since s 3 (b, ) cn be plced t the sme locl s s (b, ). How mny itertion cycles should be extended is n equivlent problem to computing the repetition period of pointer ssignment for dynmic binding cse. We refer to the next section for detiled discussion. g(3) s (b, 2) g(2) s (b, ) g() s (, ) Itertion boundry s (b, 3) = s 2 (b, ) s 2 (b, 2) s 2 (b, 3) s (, 2) s 2 (, ) s 2 (, 2) Figure 8: The globl lifetime chrt spnning two itertion cycles for the exmple of Figure REPETITION PERIO OF SMPLE LIFETIME PTTERNS Initil smples my mke the repetition period of the smple lifetime chrt longer thn single itertion cycle since their lifetimes my spn to multiple cycles. In this section, we show how to compute the repetition period of smple lifetime ptterns to determine the periodic pointer ssignment for dynmic binding or to determine the minimum size of locl s for sttic binding. For simplicity, we ssume tht ll smples hve the sme size in this section. This ssumption will be relesed in Section 5. First, we compute the itertion length of smple lifetime. Suppose d initil smples sty live on n rc nd N smples re newly produced for ech itertion cycle. Then, N smples on the rc re consumed from the destintion node. If d is greter thn N, the newly produced smples ll live longer thn n itertion cycle. Otherwise, N d newly creted smples re consumed during the sme itertion cycle while d smples live longer. We summrize this fct in the following lemm. Lemm 2. If there re d initil smples on n rc, the lifetime intervl of (dmodtnse) newly creted smples on the rc spns d/ TNSE +itertion cycles nd tht of (TNSE (dmodtnse)) smples spns d/ TNSE itertion cycles. Let p be the number of itertion cycles in which smple lifetime intervl lies. Figure 9 illustrtes two ptterns tht smple lifetime intervl cn hve in globl lifetime chrt. smple strts its lifetime t the first itertion cycle with hed intervl nd ends its lifetime t the pth itertion with til intervl. Note tht the til intervl t the pth itertion lso ppers t the first itertion cycle. The first pttern, s shown in Figure 9, occurs when the til intervl is mpped to the sme globl s the hed intervl. The intervl mpping pttern repets every p itertion cycles in this cse. The second pttern ppers when the til intervl is mpped to different globl. To compute the repetition period, we hve to exmine when new hed intervl cn be plced t the sme globl. Figure 9b shows simple cse tht new hed intervl cn be plced t the next itertion cycle. Then, the repetition period of the smple t

7 520 EURSIP Journl on pplied Signl Processing Itertions 2 p 2 p p + p Til Hed intervl Til intervl p Til intervl Figure 9: Illustrtion of smple lifetime intervl: when the til intervl is mpped to the sme globl s the hed intervl, nd when the til intervl is mpped to different globl nd there is no chined multicycle smple lifetime intervl. t n h t h 2 t h 2 t 2 h 3 t n h n t n h t h 2 t n h n t n h n k k + p k+ p + p 2 k + p + + p n k + p + + p n t n t n t n h t h 2 t h 2 t 2 h 3 t n h n t n h t h 2 t n h n t n h n k k + k++p k ++ p + p 2 k++p + + p n k++p k+2+p + + p n + + p n Figure 0: Smple lifetime ptterns when multicycle lifetimes re chined so tht til intervl t i is chined to the lifetime of smple j +. se : t n is chined bck to the lifetime of smple. The repetition period of smple lifetime ptterns becomes n i= p i.se2:t n is chined to none. The repetition period becomes n i= p i +. Here, we ssume tht the lifetime of smple k spns p k + itertion cycles. lifetime pttern becomes p. More generl cse occurs when nother multicycle smple lifetime on different rc is chined fter the til intervl. multicycle lifetime is clled chined to til intervl when its hed intervl is plced t the sme globl. The next theorem concerns this generl cse. Theorem 2. Let t i be the til intervl nd h i thehedintervl of smple i, respectively. ssume the lifetime of smple i spns p i +nd t i is chined to the lifetime of smple i +for i = to n. The intervl mpping pttern repets every n i= p i itertion cycles if intervl t n is chined bck to the lifetime of smple. Otherwise it repets every n i= p i +itertion cycles. Proof. Figure 0 illustrtes two ptterns where chined multicycle lifetime intervls re plced. The horizontl xis indictes the itertion cycles. The lifetime intervl of smple strts t k with hed intervl h nd finishes t k + p with til intervl t. Since the lifetime of smple 2 is chined, its hed intervl h 2 is plced t the sme globl s t.the lifetime of smple 2 ends k+ p + p 2. If we repet this process, we cn find tht the lifetime of smple n ends t k + n i= p i. Now, we consider two cses seprtely. se : when intervl t n is chined bck to the lifetime of smple, the repetition period becomes n i= p i s illustrted in Figure 0. se2: when intervl t n is chined to no more lifetime, we should prove tht smple is mpped to the sme globl t

8 Memory-Optimized Softwre Synthesis from tflow Progrm Grphs with Lrge Size t Smples 52 c b Intervls s(c, 2) s(b, ) s(, ) s(c, ) offset 0 s(, ) s(c, 2) s(c, ) s(b, ) Repetition period s(c, ), s(c, 2) : 2 s(, ) : 2 s(b, ) : 2 (c) (d) struct frme g[2]; min() { struct G, b, c[2] = {g,g +; int in = 0, out = ; for(int i = 0; i < mx itertion; i++) { { = c[(i +)%2]; // s codes. Use c[in ]nd. in = (in +)%2; { b = c[i %2]; // s codes. Use nd b. { // s codes. Use b ndc[out ]. out = (out +)%2; struct frme g[2]; min() { struct G [2] = {g +,g, b[2] = {g,g +, c[2] = {g,g +; int in = 0, out = 0, in = 0, out = 0, in = 0, out = ; for(int i = 0; i < mx itertion; i++) { { // s codes. Use c[in ]nd[out ]. in = (in +)%2;out = (out +)%2; { // s codes. Use [in ]ndb[out ]. in = (in +)%2;out = (out +)%2; { // s codes. Use b[in ]ndc[out ]. in = (in +)%2;out = (out +)%2; (e) (f) Figure :grphwhichisequivlenttofigure 3, lifetime intervls of smples for n itertion cycle, (c) n optiml globl lifetime chrt, (d) repetition periods of smple lifetime ptterns, (e) generted code with dynmic binding, nd (f) generted code with sttic binding. the next itertion cycle s shown in Figure 0b. Then, the period becomes n i= p i +. Since the smple lifetime ptterns over itertion cycles re permuttions of ech other, smple should be mpped to mong n globl s ssigned to smples throughn during previous itertions. s illustrted in Figure 0b, other globl s re occupied by other smples t k + n i= p i + except the globl mpped to t n. Therefore, smple is mpped to the sme globl t the next itertion cycle. We pply the bove theorem to the cse of Figure 4b where hed intervl s(b, 3) nd til intervl s(b, ) re mpped to the different globl s. nd the smple lifetime spns two itertion cycles. Therefore, the repetition period becomes 2 nd Figure 8 confirms it. nother exmple grph is shown in Figure, which is identicl to the simplified H.263 encoder exmple of Figure 3. There is dely symbol on rc with number inside which indictes tht there is n initil smple s(c, ). ssume tht the execution order is. uring n itertion cycle, smple s(c, ) is consumed by nd new smple s(c, 2) is produced by s shown in Figure b. Ifwe expnd the lifetime chrt over two itertion cycles, we cn notice tht hed intervl s (c, 2) is extended to til intervl s 2 (c, ) t the second itertion cycle. y intervl scheduling, n optiml mpping is found like Figure c.ytheorem 2, the mpping ptterns of s(c, ) nd s(c, 2) repet every other itertion cycles since hed intervl s(c, 2) is not mpped to the sme globl s til intervl s(c, ). Initil smples lso ffect the lifetime ptterns of smples on the other rcs if they re mpped to the sme globl s s the initil smples. In Figure c, smple s(b, ) re mpped to the sme globl with s(c, ) while s(, ) with s(c, 2). s result, their lifetime ptterns lso repet themselves every other itertion cycles. The summry of repetition periods is displyed in Figure d. Recll tht the repetition periods determine the period of pointer updte in the generted code with dynmic binding strtegy, nd the size of locl s in the generted code with sttic binding strtegy. Figures e nd f show the code segments tht highlight the difference. The dynmic binding scheme lloctes locl pointer onto rc since the number of smples ccumulted on rc is no greter thn one. Similrly, locl is lloctedonrc. Figure e shows code with dynmic

9 522 EURSIP Journl on pplied Signl Processing 2 6 b c offset s(b, ) s(, 2) (til) s(, 8) (hed) s(, ) (til) s(c, ) s(, 7) (hed) s(, 6) s(, 5) s(, 4) s(, 3) Repetition period s(, ),s(, 3),s(, 5),s(, 7) : 4 s(, 2),s(, 4),s(, 6),s(, 8) : 3 s(b, ) : s(c, ) : 4 (c) struct Gg[8]; min() { struct G 0[4] = {g +4,g,g+2,g+5, [3] = {g +6,g+,g+3, b[] = {g +7, c[] = {0; for(int i = 0; i < mx itertion; i++) { { struct G output = 0[(i +3)%4]; // s codes { struct G input[2]; input[0] = 0[i %4]; input[] = [i %3]; // s codes { c[0] = 0[i %4]; // s codes { struct G output = [(i +2)%3]; // s codes { // s codes (d) Figure 2: n SF grph with lrge initil smples, n optiml globl lifetime chrt, (c) repetition periods of smple lifetime ptterns, nd (d) generted code with dynmic binding fter dividing locl s on rc into two locl rrys. binding. When the size of locl is the sme s the number of newly produced smples within n itertion, no index is needed for the in the generted inlined code. The mpped offset of smple s(, ) repets every other cycles s tht of s(c, 2) does. The mpped offset of s(b, ) follows tht of s(c, ). For rc, the minimum size of locl s is one since there is t most live smple on the rc. ut we notice tht if we hve locl on the rc, we need to updte the pointer vlue of ech locl t every ccess since the repetition period is two. Therefore, we llocte two locl s on rc nd fix the pointers. Insted, we updte the locl indices, in for block nd out for block. The decision of the binding scheme is utomticlly tken cre of by the lgorithm. The sttic binding requires two locl pointer s for rc nd, respectively, since the mpping ptterns of smples on repet every other itertion cycles. The locl size for rc is two nd hs the sme binding s Figure e. Figure f represents generted code with sttic binding, which dditionlly requires indices for locl s on rc nd [6]. Hence, we dd dditionl code of updting indices before nd fter the ssocited block s execution. We should consider this overhed to compre the sttic binding with the dynmic binding strtegies. In this exmple, using the dynmic binding strtegy is more dvntgeous. We illustrte n exmple grph which hs lrge initil delys nd thus hs long repetition period of smple lifetime ptterns in Figure 2. The schedule is ssumed to be given s. Interestingly enough, smples on the sme rc hve different repetition periods. The mpping ptterns repeteveryfouritertioncyclesforsmpless(, ), s(, 3), s(, 5), nd s(, 7) since ech smple spns four itertion cycles nd til intervl s(, ) is not mpped to the sme globl

10 Memory-Optimized Softwre Synthesis from tflow Progrm Grphs with Lrge Size t Smples 523 : Procedure LOES(U is set of smple lifetimes) { 2: P { 3: While(U is not empty) { 4: /* compute fesible offsets of every intervl in U with P */ 5: compute lowest offset(u, P); 6: /* st step: choose intervls with the smllest fesible offset from U */ 7: find intervls with lowest offset(u); 8: /* 2nd step(tie breking) : intervl scheduling */ 9: select intervl x with the erliest rrivl time from ; 0: remove x from U. : P P U{x. 2: 3: Figure 3: Pseudocode of LOES lgorithm. s hed intervl s(, 7). On the other hnd, smples s(, 2),s(, 4),s(, 6), nd s(, 8) repet their lifetime ptterns every three itertion cycles since til intervl s(, 2) nd hed intervl s(, 8) re mpped to the sme globl. The sttic binding method lloctes twelve locl s to rc since the overll repetition period of locl s on rc becomes twelve tht is equl to the lest common multiple of 4nd3(= LM(4, 3)). The dynmic binding method, however,llotstwolocl rrys tht hve four nd three s, respectively, to rc. Hence the dynmic binding method cn reduce five locl pointer s thn the sttic binding. code templte with inlined coding style is displyed in Figure 2d. The locl pointer for rc follows tht of smple s(, ). Up to now, we ssume tht ll smples hve the sme size. The next two sections will discuss the extension of the proposed scheme to more generl cse, where smples of different sizes shre the sme globl spce. 5. UFFER SHRING FOR IFFERENT SIZE SMPLES WITHOUT ELYS We re given smple lifetime intervls which re determined from the scheduled execution order of blocks. The optiml ssignment problem of locl pointers to the globl s is nothing but to pck the smple lifetime intervls into single box of globl spce. Since the horizontl position of ech intervl is fixed, we hve to determine the verticl position, which is clled the verticl offset or simply offset. The bottom of the box, or the bottom of the globl spce hs offset 0. The objective function is to minimize the globl spce. Recll tht if ll smples hve the sme size, intervl scheduling lgorithm gives the optiml result. Unfortuntely, however, the optiml ssignment problem with intervls of different sizes is known to be NP-hrd. The lower bound is evident from the smple lifetime chrt; it is the mximum of the totl smple sizes live t ny time instnce during n itertion. We propose simple but efficient heuristic lgorithm. If the grph hs no delys (initil smples), we cn repet the ssignment every itertion cycle. Grphs with initil smples will be discussed in the next section. The proposed heuristic is clled LOES (lowest offset nd erliest strt time first). s the nme implies, it ssigns intervls in the incresing order of offsets, nd in the incresing order of strt times s tie breker. t the first step, the lgorithm chooses n intervl tht cn be ssigned to the smllest offset, mong unmpped intervls. If more thn one intervl is selected, then n intervl is chosen which strts no lter thn others. The erliest strt time first policy llows the plcement lgorithm to produce n optiml result when ll smples hve the sme size since the lgorithm is equivlent to the intervl scheduling lgorithm. The detiled lgorithm is depicted in Figure 3. In this pseudocode, U indictes set of unplced smple lifetime intervls nd P set of plced intervls. t line 5, we compute the fesible offset of ech intervl in U. Set contins intervls whose fesible offsets re lowest mong unplced intervls t line 7. We select the intervl with the erliest strt time in t line 9 nd plce it t its fesible offset to remove it from U nd dd it to P. This process repets until every intervl in U is plced. Since the LOES lgorithm cn find intervls with lowest offset in O(n) time nd choose the erliest intervl mong them in O(n), where n is the number of lifetime intervls, it hs O(n) time complexity to ssign n intervl. Therefore the time complexity of the lgorithm is O(n 2 )forn intervls. Figure 4 shows n exmple grph where the circled number on ech rc indictes the smple size. Figure 4b presents schedule result nd the resultnt smple lifetime intervls. Figure 5 shows the procedure of the LOES lgorithm t work. t first, we select d with the erliest strt time first mong the intervls tht cn be mpped to lowest offset 0. Next, f is selected nd plced since it is the only intervl tht cn be plced t offset 0. In this exmple, the LOES lgorithm produces n optiml ssignment result. With rndomly generted grphs, it gives ner-optiml results most of the time s shown lter. e Greef et l. proposed similr heuristic tht considers the offset first nd smple size next in [2]. Even though

11 524 EURSIP Journl on pplied Signl Processing Smples d b e E 99 c 00 f F b d e c E f F Figure 4: n input grph with smples of different sizes nd schedule (= EF) nd the resultnt smple lifetime chrt. ottom(, b, c, d, e, f ) = (0, 0, 0, 0, 0, 0) Lowest bottom = {, b, c, d, e, f Erliest = {d ottom(, b, c, d, e, f ) = (99, 99, 99, 99, 0) Lowest bottom = { f Erliest = { f ottom(, b, c, e) = (99, 99, 00, 00) Lowest bottom = {, b Erliest = { d d f d f ottom(e) = (99) Lowest bottom = {e Erliest = {e b d e c f ottom(b, e) = (99, 99) Lowest bottom = {b, e Erliest = {b b d c f ottom(b, c, e) = (99, 00, 00) Lowest bottom = {c, e Erliest = {c d c f Figure 5: The proposed plcement lgorithm t work. their heuristic gives similr performnce with rndomly generted grphs, it does not gurntee to produce optiml results when ll smples hve the sme size. 6. UFFER SHRING FOR IFFERENT SMPLE SIZES WITH INITIL SMPLE ELYS In this section, we discuss the most generl cse where grph hs initil smples nd smples hve different sizes. The LOES lgorithm is not directly pplicble to this cse. Figure 6 illustrtes the difficulty with simple exmple. Figure 6 shows mpping result fter the LOES lgorithm is pplied to the first itertion period. We ssume tht h nd t indicte the hed intervl nd the til intervl of the sme smple lifetime, respectively. t the second itertion, intervl h should be plced s shown in Figure 6b since it is extended from the first cycle. The hed intervl h prohibits intervl x from lying on contiguous memory spce t the second itertion. Such splitting is not llowed in the generted code since the code regrds ech smple s unit of ssignment. To overcome this difficulty, we enforce tht multicycle intervls do not shre the globl spce with other intervls with different smple size. Figure 7 displys the min procedure, SSIGN MIN, for the proposed technique. We first clssify intervls into severl groups (lines 2 3 in Figure 7); new group is formed with ll intervls of the sme size if there is t lest one multicycle intervl, nd is denoted s (x) where x is the smple size. If there is no multicycle intervl, ll remining intervls form the lst group R. onsider n exmple of Figure 8 where smple sizes re indicted s circled numbers on the rcs. The smple lifetimes re displyed in Figure 8b. We mke three groups of intervls for this grph. Group (00) includes ll smple intervls ssocited with rcs b, c, ndd while group (200) includes ll intervls ssocited with rcs nd e. Initilly group R is empty in this exmple. The next step is to pply the LOES lgorithm for ech group (x) since (x) contins smples of the sme size only (lines 4 7). We slightly modify the LOES lgorithm so tht the lgorithm finishes the mpping s soon s ll multicycle intervls re mpped: compre line 24 of Figure 7 nd line 2 of Figure 3. The remining unmpped intervls re moved to group R. In Figure 8c, the modified LOES lgorithm plces intervls in (00) in the order of [s(c, ),s(b, 2),s(d,2),s(d,),s(b, ),s(c, 3)]. fter plcing s(c, 3), it completes nd moves remining intervl s(c, 2)

12 Memory-Optimized Softwre Synthesis from tflow Progrm Grphs with Lrge Size t Smples 525 offset t x y h offset st itertion x h t y 2nd itertion Split y t Figure 6: globl lifetime chrt with different size smples where t is til intervl nd h is hed intervl. Intervl x should be split t the second itertion, which is not llowed in the generted code. : Procedure SSIGN MIN(U is set of smple lifetimes) { 2: R { 3: for ech x in U{/* clssify intervls nd sort them */ 4: if (x is delyed intervl) 5: (size(x)) (size(x)) {x 6: else R R {x 7: 8: for ech x in R{/* dd ordinry intervls into (x)*/ 9: if(there is delyed intervl whose size is equl to tht of x) { 0: (size(x)) (size(x)) {x : R R {x 2: 3: 4: for ech (size){ /* plce intervls in (x)*/ 5: cll M LOES ((size)). 6: R R (size) 7: 8: /* plce ordinry intervls in R */ 9: cll LOES(R). 20: 2: 22: Procedure M LOES(U is set of smple lifetimes) { /* slightly modified LOES */ 23: P { 24: While(U hs delyed intervls) { Figure 7: Pseudocode of the proposed lgorithm for grph with delys. into R. Similrly, ordinry intervl s(e,2) nd s(, ) re moved into R fter s(e, 3) is plced for group (200). t lst we pply the originl LOES lgorithm to group R (line 9 of Figure 7) s shown in Figure 8e. The lgorithm loctes intervls s(c, 2), s(e, 2), nd s(, ) in R s shown in Figure 8e. fter ll intervls re mpped to the globl s, we move to the next stge of determining the locl sizes, which is lredy discussed in Section 4. Repetition periods for s(c, ) nd s(c, 3) become two since til intervl s(c, ) spns two itertion cycles nd is not mpped to the sme globl s s(c, 3) is. Repetition periods of s(e, ), s(e, 2), nd s(e, 3) become ll two. generted code with sttic binding is displyed in Figure 8f. 7. EXPERIMENT In this section, we demonstrte the performnce of the proposed technique with three rel-life exmples nd rndomly generted grphs. First, we experimented three rel-life pplictions: JPEG encoder, n MP3 decoder, nd n H.263 encoder. We hve implemented the proposed technique in design environment clled PeE Ptolemy extension s odesign Environment ( in which dtflow progrm grphs for JPEG encoder nd n H.263 encoder re displyed in Figures 9 nd 20, respectively. From the utomticlly synthesized codes, we compute the memory requirements nd summrize the

13 526 EURSIP Journl on pplied Signl Processing b c d e E offset offset s(b, ) s(c, 3) s(d, ) s(c, ) s(b, 2) s(d, 2) (c) E Smple lifetime intervls s(e, ) s(e, 2) s(e, 3) s(e, ) s(e, 3) s(b, ) s(c, 3) s(d, ) s(c, ) s(b, 2) s(d, 2) (d) E s(c, ) s(, ) s(d, ) s(b, 2) s(b, ) s(c, 2) s(d, 2) s(c, 3) E offset s(e, ) s(e, 3) s(b, ) s(c, 3) s(d, ) s(c, ) s(b, 2) s(d, 2) s(, ) (e) s(e, 2) s(c, 2) E chr g[900]; min() { struct G00 b[4] = {g + 200,g,g,g+ 200, c[4] = {g,g + 700,g+ 200,g+ 700, d[4] = {g + 00,g,g+ 00,g+ 200; struct G200 [] = {g + 700, e[2] = {g + 300,g+ 500; for(int i = 0; i<mx itertion; i ++){ { // s codes { // s codes { // s codes { // s codes { // s codes { // s codes { // E s codes (f) Figure 8: grph with smples of different sizes nd delys, smple lifetime chrt, (c) LOES plcement of smples whose size is 00, (d) LOES plcement of smples whose size is 200, (e) LOES plcement of the remined smples without dely, nd (f) generted code with sttic binding.

14 Memory-Optimized Softwre Synthesis from tflow Progrm Grphs with Lrge Size t Smples 527 Figure 9: JPEG encoder exmple tht represents grph of sme size smples without delys. Figure 20: H.263 encoder exmple tht represents grph of different size smples with delys. performnce comprison results in Tble. Since the function body of ech dtflow node is equivlent in ll experiments, only memory requirements re the min item of comprison nd the execution times re ll similr except for the copy overhed to be discussed below. JPEG encoder exmple represents the first nd the simplest clss of progrm grphs in which ll nonprimitive dt smples hve the sme size nd no initil dely exists. Since the locl size of ech rc is one in this exmple, we do not hve to seprte the locl pointer nd the globl dt, which is tken into ccount in the implementtion of the proposed technique. We cn reduce the memory requirements to one third s the third nd the fourth rows of Tble illustrte. The lst row indictes the lower bound of globl requirements tht given execution sequence of nodes needs. The lower bound is nothing but the mximum totl size of dt smples live t ny instnce of time during n execution period. No better result is possible since it is optiml. n MP3 decoder exmple is composed of three kinds of different size smples. It represents the second clss of grphs tht hve different size smples but no initil dely smple. In this exmple, we lso do not hve to seprte locl nd globl s becuse the locl size of ech rc is one. The proposed lgorithm tht shres the spce between different size smples reduces the memory requirement by 52% compred with ny shring lgorithm tht shres the spce mong only equl size smples. The fourth nd the fifth rows show the performnce difference. The proposed lgorithm lso chieves the lower bound in this exmple. s for n H.263 encoder exmple, we mke two versions: the simplified version s discussed in the first section nd the full version. The simplified version is n exmple of the third clss of grphs in which ll nonprimitive dt smples hve the equl size nd initil dely smples exist. s discussed erlier, seprtion of locl s from globl s llows us to reduce the spce to optimum s the sixth row revels. The full version of n H.263 encoder exmple represents the fourth nd the most generl clss of grphs tht consist of different size smples nd initil smples. The H.263 encoder exmple include four different size smple sizes nd eight initil dely smples on eight different rcs. The proposed technique cn reduce the memory requirement by 40% compred with the unshred version. On the other hnd, shring technique reduces the size only 23% if neither seprtion nor shring between different smples is considered. In this smple, we cnnot chieve the lower bound but 256 bytes lrger spce. Note tht the lower bound is usully not chievble if different size smples nd initil smples re involved in the sme grph. The SF model hs limittion tht it regrds smple of nonprimitive type s unit of dt delivery. In n H.263 encoder exmple, the SF model needs n dditionl block tht explicitly divides frme into 99 mcroblocks, pying nonnegligible dt copy overhed nd extr frme-size spce. In mnully written reference code, such dt copy is replced with pointer opertion. Tble 2 revels this observtion: tht even the lower bound of memory requirements of the synthesized code from the SF model is greter thn tht of the reference code. Therefore, we pply the proposed technique to n extended SF model, clled cyclo-sttic dtflow (SF) [7]. With the SF model, we could remove such dt copy overhed. nd the proposed shring technique further reduce the memory requirement by 7% more thn the reference code. In the experiments, we choose the better binding strtegy, sttic or dynmic, for ech dt smples, considering the memory nd the code overhed of index updtes. In the H.263 encoder exmple, sttic binding is preferred for plces where the repetition periods of smple lifetimes spn more thn one itertion cycle. In this exmple, the pointer referencing through locl s incurs runtime overhed, which is bout 0.6% compred with the totl execution time in the H.263 encoder. The second set of experiments s shown in Tble 3 hve been performed to evlute the proposed LOES heuristic. We compre it with n integer liner progrmming (ILP) solver, PLEX ( We rndomly generte the smple lifetimes within first itertion intervl, vrying the strt/end times, sizes, nd initil delys. When the number of smple intervls exceeds 20, the ILP solver tkes prohibitively long execution times. With smll size problems below 20 smple intervls, the overhed of LOES heuristic is less thn % on the verge for 50 experiments.

15 528 EURSIP Journl on pplied Signl Processing Tble : omprison of memory requirements for three rel-life exmples. Exmple JPEG MP3 Simplified H.263 encoder H.263 encoder lss Sme size ifferent size Sme size ifferent size No dely No dely With dely With dely # of smples Without shring K K 659 K Shring s of sme size only K K 50 K uffer shring without seprtion 52 K K 50 K uffer shring with seprtion 74 K 396 K Lower bound of globl size 52 K 74 K 396 K Tble 2: omprison of synthesize codes with reference code for the H.263 encoder. uffer shring without uffer shring with Exmple Reference code seprtion in SF seprtion in SF H.263 Encoder 350 K 29 K 290 K Tble 3: Performnce comprison of LOES lgorithm with integer liner progrmming (optiml) for rndomly generted grphs (unit: %). # of intervls vg. mx (LOES-ILP)/ILP ONLUSIONS We hve proposed shring technique for dt smples of nonprimitive type to minimize the memory requirements from grphicl dtflow progrms bsed on the SF model or its extension ssuming tht the execution order of nodes is lredy determined t compile time. In order to shre more s, the proposed technique seprtes globl memory s from locl pointer s: the globl s store live smples nd the locl s store the pointers to the globl entries. The technique minimizes the memory by shring globl s for dt smples of different size. No previous work is known to us to solve this shring problem especilly for the grphs with initil smples. It lso involves three subproblems of mpping locl pointer s onto the globl spce, determining the locl sizes, nd finding the repeting mpping ptterns. We first obtin the minimum size of globl spces ssuming tht locl pointer s tke negligible mount of spce compred with the globl spce. LOES lgorithm hs been developed for shring between smples of different sizes. The next step ws to bind the locl pointer s to the given globl s for the grph. We present both dynmic binding nd sttic binding methods nd compre them in terms of memory requirements nd code overheds. The proposed technique, including utomtic code genertion nd memory optimiztion, hs been implemented in block digrm design environment clled PeE. No mnul intervention is necessry for the proposed code genertion technique in PeE. The experimentl results show tht the proposed lgorithm is useful, especilly for the grphs with initil delys. The proposed lgorithm tht seprtes locl s nd globl s reduce more memory by 33% in the simplified H.263 encoder nd 22% in the H.263 encoder thn the shring lgorithm tht does not seprte locl s nd globl s. Through extensive shring optimiztions, utomtic softwre synthesis from dtflow progrm grph chieves the comprble code qulity with the mnully optimized code in terms of memory requirement. In this pper, we ssume tht the execution order of blocks is given from the compile-time scheduling. In the future, we will develop n efficient scheduling lgorithm which minimizes the memory requirement bsed on the proposed lgorithm. KNOWLEGMENTS This reserch is supported by Ntionl Reserch Lbortory Progrm (no. M ) nd rin Kore 2 Progrm. The RIT t Seoul Ntionl University provides reserch fcilities for this study.

16 Memory-Optimized Softwre Synthesis from tflow Progrm Grphs with Lrge Size t Smples 529 REFERENES [] OSSP User s Mnul, Synopsys, Mountin View, lif, US. [2] R. Luwereins, M. Engels, J.. Peperstrete, E. Steegmns, nd J. Vn Ginderdeuren, GRPE: SE tool for digitl signl prllel processing, IEEE SSP Mgzine,vol.7,no.2, pp , 990. [3] J. T. uck, S. H, E.. Lee, nd. G. Messerschmitt, Ptolemy: frmework for simulting nd prototyping heterogeneous systems, Interntionl Journl of omputer Simultions, vol. 4, no. 2, pp , 994. [4] E.. Lee nd. G. Messerschmitt, Sttic scheduling of synchronous dtflow progrms for digitl signl processing, IEEE Trns. on omputers, vol. 36, no., pp , 987. [5] Telenor Reserch, TMN (H.263) Encoder/ecoder Version 2.0, June 997, ftp://bonde.nt.no/. [6] P.K.Murthy,S.S.httchryy,ndE..Lee, Jointminimiztion of code nd dt for synchronous dtflow progrms, Journl of Forml Methods in System esign, vol., no., pp. 4 70, 997. [7] W. Sung, J. Kim, nd S. H, Memory efficient softwre synthesis from dtflow grph, in th Interntionl Symposium on System Synthesis (ISSS 98), pp , Hsinchu, Tiwn, ecember 998. [8] S.S.httchryy,P.K.Murthy,ndE..Lee, PGNnd RPM: omplementry heuristics for trnslting SP block digrms into efficient softwre implementtions, Journl of esign utomtion for Embedded Systems,vol.2,no.,pp.33 60, 997. [9] F. J. Kurdhi nd.. Prker, REL: progrm for register lloction, in Proc. 24th M/IEEE esign utomtion onference ( 87), pp , Mimi ech, Fl, US, June 987. [0] M. R. Grey,. S. Johnson, nd L. J. Stockmeyer, Some simplified NP-complete grph problems, Theoreticl omputer Science, vol., no. 3, pp , 976. [] J. Gergov, lgorithms for compile-time memory optimiztion, in Proc. 0th nnul M-SIM Symposium on iscrete lgorithms (SO 99), pp , ltimore, Md, US, Jnury 999. [2] E. e Greef, F. tthoor, nd H.. Mn, rry plcement for storge size reduction in embedded multimedi systems, in Proc. Interntionl onference on ppliction-specific rry Processors (SP), pp , Zurich, Switzerlnd, July 997. [3] P. K. Murthy nd S. S. httchryy, Shred implementtions of signl processing systems using lifetime nlysis techniques, IEEE Trnsctions on omputer-ided esign of Integrted ircuits nd Systems, vol. 20, no. 2, pp , 200. [4] S. Ritz, M. Willems, nd H. Meyr, Scheduling for optimum dt memory compction in block digrm oriented softwre synthesis, in Proc.IEEEInt.onf.coustics,Speech,Signl Processing, pp , etroit, Mich, US, My 995. [5] F. Gvril, lgorithms for minimum coloring, mximum clique, minimum covering by cliques, nd mximum independent set of chordl grph, SIM Journl on omputing, vol., no. 2, pp , 972. [6] S. S. httchryy nd E.. Lee, Memory mngement for dtflow progrmming of multirte signl processing lgorithms, IEEE Trns. Signl Processing, vol. 42, no. 5, pp , 994. [7] G. ilsen, M. Engels, R. Luwereins, nd J.. Peperstrete, yclo-sttic dt flow, IEEE Trns. Signl Processing, vol. 44, no. 2, pp , 996. Hyunok Oh is Ph.. cndidte in the School of omputer Science nd Engineering t Seoul Ntionl University, Kore. He received his.. degree (996) nd M.. degree (998) in computer engineering from Seoul Ntionl University, nd he is in Ph.. progrm from 998 to He is interested in hrdwre-softwre codesign, model of computtion, hrdwresoftwre cosynthesis, memory optimiztion, nd multimedi pplictions. Soonhoi H is currently n ssocite Professor in the School of Electricl Engineering nd omputer Science t Seoul Ntionl University. From 993 to 994, he worked for Hyundi Electronics Industries orportion. He received his.. degree (985) nd M.. degree (987) in electronics engineering from Seoul Ntionl University, nd Ph.. (992) degree in electricl engineering nd computer science from University of liforni, erkeley. He hs worked on Ptolemy project. His reserch interests include hrdwre-softwre codesign, design methodology for embedded systems, nd P clusters. He is member of the M nd IEEE omputer Society.