In-place Graph Rewriting with Interaction Nets

Transcription

1 In-place Gaph Rewiting with Inteaction Nets Ian Mackie hina ato n algoithm is in-place, o uns in-situ, when it does not need an additional memo to eecute beond a small constant amount. Thee ae man algoithms that ae efficient because of this featue, theefoe it is an impotant aspect of an algoithm. In most pogamming languages, it is not obvious when an algoithm can un in-place, and moeove it is often not clea that the implementation espects that idea. In this pape we stud inteaction nets as a fomalism whee we can see diectl, visuall, that an algoithm is in-place, and moeove the implementation will espect that it is inplace. Not all algoithms can un in-place howeve. We can nevetheless still use the same language, but now we can annotate pats of the algoithm that can un in-place. We suggest an annotation fo ules, and give an algoithm to find this automaticall though analsis of the inteaction ules. 1 Intoduction n algoithm uns in-place, o in-situ, if it needs a constant amount of eta space to un. Fo an algoithm to be in-place, the input is usuall ovewitten, so mutable data-stuctues need to be suppoted b the pogamming language. Thee ae man well-known in-place algoithms, in paticula fom the domain of soting. One eample is bubble sot, that we can wite in Java fo instance: static void bubble() { int t; fo (int i = n-1; i >= 0; --i) fo (int j = 1; j <= i; ++j) if (a[j-1] > a[j]) { t = a[j-1]; a[j-1] = a[j]; a[j] = t; } } With some knowledge of what the above instuctions do, and tacing a few steps of the eecution, we can soon ealise that it uns in-place: one additional memo location (t) is all that is needed to sot the aa a of integes. In man pogams howeve, it is not obvious that an algoithm can un in-place, and moeove it is often not clea that the undeling implementation espects that idea. This issue becomes moe petinent when we eamine diffeent pogamming paadigms and diffeent pogamming stles, especiall when we have dnamic data-stuctues. In Figue 1 we give fou fagments of pogams fo inseting an element into a soted list (so pat of the insetion sot algoithm). These pogams ae witten in Polog, Haskell and Java, with the latte witten using two diffeent pogamming stles. Insetion can be witten so that it uns in-place, but it is not eas to see which of these eamples ae (o can be) in-place unless we stat to eamine the compile, the un-time sstem, and the definition of functions like cons in the case of Java. Declaative languages (functional and logic based in this eample) ae designed to be efeentiall tanspaent, so the data-stuctues ae updated in a non-destuctive wa. Moeove, it is not the pogamme who decides how memo is allocated and oganised in these languages. On the othe-hand, languages like C and Java (the impeative fagment) the pogamme does the memo allocation (and de-allocation also in some languages) eplicitl, and theefoe has a bette idea of esouce usage. These eamples illustate some of the difficulties in knowing if the pogam will un in-place o not. Pelimina Repot. Final vesion to appea in: TERMGRPH 2016 c I. Mackie &. ato This wok is licensed unde the Ceative Commons ttibution License.

2 2 In-place Gaph Rewiting with Inteaction Nets Pogam 1: Polog inset([y Ys], X, [Y s]):- Y < X,!, inset(ys, X, s). inset(ys, X, [X Ys]). Pogam 2: Haskell inset e [] = [e] inset e (:s) = if e < then e::s else :(inset e s) Pogam 3: Java (functional stle) static List inset(int, List l) { if (isempt(l) < l.head) etun cons(, l); else etun cons(l.head, inset(, l.tail)); } Figue 1: Eample pogams Pogam 4: Java (destuctive stle) static List inset(int, List l) { if (isempt(l) < l.head) etun cons(, l); else { l.tail = inset(, l.tail); etun l; } } In-place algoithms ae impotant because the can lead to moe efficient algoithms, and even change time compleit. If the data-stuctue suppots it, concatenation of two lists can be constant time if done in-place, but linea if not. Memo allocation is also epensive, so minimising it also makes it moe efficient. lthough less impotant in some was, thee ae devices that have limited space (embedded sstems, hand-held devises, etc.), so limiting the space usage if thee is no un-time impact is alwas advantageous. In this pape we use a fomalism whee we can see diectl, in fact visualise, that an algoithm is in-place, and moeove the implementation espects that it is in-place. We use the gaphical ewiting sstem of inteaction nets [5] as ou pogamming paadigm. This visual language has man similaities with tem ewiting sstems in that the ae use-defined sstems. Fo this eason, the can be consideed as specification languages. Howeve, the ae also a model of computation that equies all aspects of the computation to be eplained, including coping and gabage collection. Fo this eason the ae like an implementation model, o low-level language. It is the mitue of these featues that allows us to see diectl how the pogam can be implemented, and thus see how the memo is allocated. Not all algoithms can un in-place howeve. The fomalism will still be of use though, and we identif thee diffeent uses of the infomation we can ascetain fom inteaction ules: 1. If the ewite ules have a paticula popet then the algoithm is in-place (and will be implemented in-place). 2. If the ules can be applied in a given wa, so a stateg is needed, then the algoithm can be implemented in-place. 3. If neithe of the above hold, then we can still make use of the fomalism b e-using as much data as possible in the computation. Fo the final point, we can eithe ask the pogamme to annotate the ules, o develop an algoithm to do this automaticall. In this pape, we give eamples to motivate the fist and last points moe details including the second point will be given in a longe vesion of this pape. The space usage of algoithms, as well as the time compleit, ae fundamental in algoithm design and analsis, and well documented in man tetbooks. Thee have also been a numbe of woks that

3 I. Mackie &. ato 3 give a bound on the space usage though tpe sstems, fo eample [3], and [4]. Ou appoach is moe sntactical, and uses popeties of the undeling un-time sstem. Oveview. The est of this pape is stuctued as follows. In the net section we ecall the backgound, and give some eamples to motivate the ideas. We then give some case studies of eamples that ae in-place in ection 3. In ection 4 we intoduce an annotation fo the ules which allows fo node euse. We then go on in ection 5 to show an algoithm to annotate a ule automaticall in the case of using a fied-size node epesentation fo nodes. fte a bief discussion on how we can use this infomation in a compile in ection 6, we conclude in ection 7. 2 Backgound In the gaphical ewiting sstem of inteaction nets [5], we have a set Σ of smbols, which ae names of the nodes. Each smbol has an ait a that detemines the numbe of auilia pots that the node has. If a(α) = n fo α Σ, then α has n + 1 pots: n auilia pots and a distinguished one called the pincipal pot labelled with an aow. Nodes ae dawn as follows: 1... n net built on Σ is an undiected gaph with nodes as the vetices. The edges of the net connect nodes togethe at the pots such that thee is onl one edge at eve pot. pot which is not connected is called a fee pot. Two nodes (α,β) Σ Σ connected via thei pincipal pots fom an active pai, which is the inteaction net analogue of a ede. ule ((α,β) N) eplaces the pai (α,β) b the net N. ll the fee pots ae peseved duing eduction, and thee is at most one ule fo each pai of nodes. The following diagam illustates the idea, whee N is an net built fom Σ. n... 1 n N 1 1 m 1 m We efe to the ule ((α,β) N) as α β. The most poweful popet of this gaph ewiting sstem is that it is one-step confluent all eduction sequences ae pemutation equivalent. We use an etension of these pue inteaction nets: values can be stoed in the nodes, and ules can test these values. This is done is such a wa as to peseve the one-step confluence popet. We use this etension in the insetion sot eample below. It is possible to eason about the gaphical epesentation of nets, but it is convenient to have a tetual calculus fo compact epesentation. Thee ae seveal calculi in the liteatue, and hee we eview one calculus [2], which is a efined vesion of [1]. gents: Let Σ be a set of smbols, anged ove b α,β,..., each with a given ait a : Σ IN. n occuence of a smbol is called an agent, and the ait is the numbe of auilia pots. Names: Let N be a set of names, anged ove b,,z, etc. N and Σ ae assumed disjoint. Names coespond to wies in the gaph sstem.

4 4 In-place Gaph Rewiting with Inteaction Nets Tems: tem is built on Σ and N b the gamma: t ::= α(t 1,...,t n ) $t, whee N, α Σ, a(α) = n and t 1,...,t n,t ae tems, with the estiction that each name can appea at most twice. If n = 0, then we omit the paentheses. If a name occus twice in a tem, we sa that it is bound, othewise it is fee. We wite s,t,u to ange ove tems, and s, t, u to ange ove sequences of tems. tem of the fom α(t 1,...,t n ) can be seen as a tee with the pincipal pot of α at the oot, and the tems t 1,...,t n ae the subtees connected to the auilia pots of α. The tem $t epesents an indiection node which is ceated b eduction, and is not nomall pat of an initial tem. Intuitivel, $t coesponds to a vaiable bounded with t (o a state such that an envionment captues t). Equations: If t, u ae tems, then the unodeed pai t = u is an equation. Θ will be used to ange ove sequences of equations. Rules: Rules ae pais of tems witten: α( 1,..., n ) = β( 1,..., m ) Θ, whee (α,β) Σ Σ is the active pai, and Θ is the ight-hand side of the ule. We will abbeviate in the following the leftand ight-hand sides of the ule b LH and RH espectivel. ll names occu eactl twice in a ule, and thee is at most one ule fo each pai of agents. 3 In-place algoithms: case studies Hee we give some eample inteaction net sstems that demonstate the ideas we have discussed peviousl. The fist one is una numbes with addition. We epesent the following tem ewiting sstem: add(,)=, add((),)=add(,()) as a sstem of nets with nodes,,, and two ewite ules: The following is an eample of add((),): Net, we intoduce an eample fo the ckemann function defined b: ack 0 n = n+1, ack m 0 = ack (m-1) 1, ack m n = ack (m-1) (ack m (n-1)). We can build the inteaction net sstem on the una natual numbes that coesponds to the tem ewiting sstem as follows: 2 2 Ped 2 Dup Ped

5 I. Mackie &. ato 5 whee the node Dup duplicates and nodes, and the node Ped eases the node: Dup Dup Dup Ped The following is an eample of ewiting: 2 Dup Dup Ped Ped Ped ack 1 2 ack 0 (ack 1 1) Obsevation fo in-place unning. Inteaction nets ae quite unique as a pogamming paadigm because we ae basicall witing pogams using the intenal data-stuctue. We chaacteise thee kinds of ewiting ule: Case 1: thee ae two nodes in the ight-hand side (RH). The two nodes of the active pai can be eused. Thus, no matte which wa we evaluate, the algoithm fo these ules can un in constant space. The ules, and Dup ae classified in this case. Case 2: thee ae less than two nodes in the RH. The active pai nodes can be eused as nodes that occu in the RH, so in tems of the memo space, it can un in constant space as well. Fo instance, the ules, and Ped ae classified in this case. Case 3: thee ae moe than two nodes in the RH. Hee, active pai nodes can be eused as nodes that occu in the RH, but additional memo space is equied fo othe nodes. We divide this into two ve diffeent categoies: 1. n active pai ceates anothe active pai that is Case 2 above. These two eductions togethe make the algoithm in-place. Fo instance, in the last two-step eductions of ack 1 2 to ack 0 (ack 1 1) in the eample, we can save memo space fo two nodes when we take Ped and Dup in this ode, in compaison with the ode Dup and Ped. 2. Fo instance, the ules 2, 2 and Dup ae classified in this case. These ules ae not in-place, but the total cost can be educed b choosing the two eused nodes well. Fo instance, in the ule 2, it is bette to euse the 2 in the LH as the ight side (not the left side) because the infomation of the ight auilia pot (denoted as ) can be eused. Thus we t to euse the memo in the best wa possible. Insetion sot is a well-known in-place algoithm. The fist thee inteaction ules below encode insetion of an item into a soted list, and the final two ules encode the insetion sot algoithm. I() nil nil

6 6 In-place Gaph Rewiting with Inteaction Nets I() I() > I() I nil nil I I() I These five ules encode the whole pogam thee is nothing else. Ou eal point howeve, is that in this case a tace of the eecution (an animation of this algoithm) is showing no moe and no less than what is needed to eplain this algoithm. It is in-place because to begin with we need to put an additional I node, and the final ule fo I eases this. We invite the eade to tace the following eample net: I nil This eample is the full sstem of inteaction nets fo the insetion sot algoithm, and it uns inplace. Thee ae othe eamples, fo instance evesing a list. In this case, we need to stat with adding a ev node, and the final ule deletes it. The following two ules implement evesing an list: ev nil ev h ev h The stating configuation is shown in the following eample, which will evese the list in-place with five inteactions: nil ev nil 4 nnotating Rules In the pevious section we saw that thee ae inteaction sstems that can un in-place. To ensue that this is actuall achieved at the implementation level, we need to make sue that fo these eamples the nodes in the ule ae eused when building the new net. This idea can be also used even when thee ae moe than two nodes in the ight-hand side of the ule, and in this case thee is a choice of how to euse the nodes. We net intoduce an annotation to show which nodes in the RH of the ule ae eused. This helps the compile to analse infomation so that it can impove on the in-place eecution of pats of the pogam. nnotation: L and R. We intoduce L and R to denote whee the left-hand side and the ight-hand side nodes in the LH of a ule ae used fo in-place computation, espectivel. Fo instance, the ule is witten as follows:

7 I. Mackie &. ato 7 *R *L The advantage is that the compile is easil able to know, tavesing the net, not onl whee the active pai nodes ae used, but also which infomation about the connections should be peseved. Fo instance, in the above eample, the infomation denoted as 1 and 1 in the LH of the ule should be peseved, sa as _ 1 and _ 1, because these ae ovewitten in the RH of the ule, and the 1 and 1 in the RH should be eplaced b the _ 1 and _ 1. nnotation fo changing of the node name. To change the node name, we intoduce a name cast, such as the tpe cast of the C pogamming language, with the L and R. Fo instance, the ule 2 is witten as follows: 2 Dup Ped (*R) (*L) In this eample, the compile can also know that the infomation denoted as and in the LH of the ule should be peseved, b checking the connection of L and R. dvantage of using a fied-size node epesentation fo nodes. We epesent nodes as a fied-size node, thus fied-size auilia pots. Fo this we need to use moe space than necessa, but we can manage and euse nodes in a simple wa [6]. Hee, we assume that auilia pots ae assigned b the ode fom the left-hand side to the ight-hand side, the ule is witten as follows: (*L) o we can euse not onl the L node, but also the pointe infomation (denoted as ). 5 Deiving nnotations In the pevious section we showed how ules can be annotated with infomation about the euse of nodes. Hee, in the case of using a fied-size node epesentation, we define a function to calculate how a given tem is simila to othes. We fist intoduce some notation. Fo stings we wite double quotes ( and ). We use the notation {} in a sting as the esult of eplacing the occuence {} with its actual value. Fo instance, if = abc and = 89 then 1{}2{} = 1abc289. We use + as an infi bina opeation to concatenate stings. We also use a smbol to show the empt sequence. In ode to show whee in a tem is in a sequence of equations, we use the following tem path notation: nth (L R) : ag 1 ag 2... Fo instance, the tem t in =,α(β(s,t),z)=w is denoted as 2L:12 because the t occus in α(β(s,t),z), which is the left-hand side tem of the second equation, occus in β(s,t), which is the fist agument of the tem, and in the second agument of the tem β(s,t). Using this, we can now give an impotant definition fo this pape:

8 8 In-place Gaph Rewiting with Inteaction Nets Definition 1 (Node matching) The function Match below takes a tem and a sequence of equations, and etuns a list of a pai (scoe, tem path) whee the scoe contains the numbe of the matched agent and matched aguments. We use tandad ML notation fo lists, thus, in the following the is list concatenation. Match(t, (e 1,...,e n )) = Match e (t, e 1, e (t, e n, n) Match e (t, s = u, pos) = Match t (t, s, {pos}l : )@Match t (t, u, {pos}r : ) Match t (α( ),, tpath) = [((0,0),tpath)] Match t (α( ), β(t 1,...,t n ), tpath) = [((agentpts, namepts), t (α( ), t 1, {tpath}1 t (α( ), t n, {tpath}n ) whee agentpts = if α = β then 1 else 0 namepts = Match ns (, (t 1,...,t n )) Match ns (, t) = 0 Match ns (, ) = 0 Match ns ((, ), (t, t)) = (if = t then 1 else 0) + Match ns (, t) Thus Match will etun a list of the matching metics fo each node, and give the location in the net fo each. We can then easil etact the best one fom this infomation. The following eamples illustate how this infomation is calculated. Eample 2 The ule given peviousl is witten tetuall as ( 1, 2 ) = ( 1 ) (( 1, 2 )) = 1 Fist we take the left hand side tem ( 1, 2 ) of the active pai. etuns the following list: Match(( 1, 2 ), (( 1 ), 2 ) = 1 ) [((1,1),1L:), ((0,1),1L:1), ((0,0),1L:11), ((0,0),1L:2), ((0,0),1R:)] The fist element of this esult ((1,1),1L :) shows that the highest scoe (1,1) is obtained when we annotate the tem 1L :, which is (( 1 ), 2 ), such as ( L)(( 1 ), 2 ). Net we take the ight hand side tem ( 1 ). The following is the esult of the function Match fo ( 1 ): [((0,0),1L:), ((1,0),1L:1), ((0,0),1L:11), ((0,0),1L:2), ((0,0),1R:)] This esult shows that thee is one agent tem 1L : 1 (thus ( 1 )) that has the same id with ( 1 ), and no agent tems that have the same occuence of the agument. Theefoe, ( 1 ) should be annotated as ( R)( 1 ). These annotations coespond to the fist gaph in ection 4. Eample 3 The ule 2 given peviousl is witten tetuall as 2(,) = () = Dup((,w),Ped((w,))) The esult of Match(2(, ), = Dup((, w), Ped((w, )))) is as follows: [((0,0),1L:), ((0,0),1R:), ((0,0),1R:1), ((0,0),1R:11), ((0,0),1R:12), ((0,0),1R:2), ((0,1),1R:21)), ((0,0),1R:211), ((0,0),1R:212)].

9 I. Mackie &. ato 9 This shows that the tem 1R : 21, which is (w,), should be annotated b ( L) because it has the highest scoe (0,1). In the case of (), the esult of the Match is as follows: [((0,0),1L:), ((0,0),1R:), ((0,1),1R:1), ((0,0),1R:11), ((0,0),1R:12), ((0,0),1R:2), ((0,0),1R:21)), ((0,0),1R:211), ((0,0),1R:212)]. Thus, taking account of using a fied-size node epesentation, we find that we should annotate the tem 1R : 1, which is (,w), b ( R), though we annotated Ped in the gaph in ection 4. Of couse, the evaluation of the scoe depends on the implementation method. Howeve, in these cases, (0, 1) must be highest because the othes ae (0,0). 6 Discussion The algoithm given above can be put to use in the compilation of ules. Thee is some choice fo the compile if seveal nodes get the same scoe. We biefl summaise hee some details about the lowlevel language, and a desciption of how data-stuctues ae used. Ou contibution hee is to etend those ideas with euse. In the longe vesion of this pape we will give the algoithm fo compilation in detail and focus on the data-stuctues that ae used. n impotant esult that we get about compilation is that we do the least amount of wok in implementing the inteaction ules. The concete epesentation of an inteaction net can be summaised b the following diagam, whee Γ epesents a net, EQ a stack of equations, and I an inteface of the net: Γ EQ I The following is the epesentation of the net (,) = (w), (,w) = (), whee N ae nodes epesenting vaiables: N N EQ I The inteface of the net is whee we collect all the fee edges of a net. We have a set of instuctions that can manipulate this data-stuctue, and the compilation of a ewite ule needs to geneate code to manipulate this stuctue. What we have achieved in this pape is an annotation of a ule so that we can geneate code to manipulate data-stuctues of the kind shown above with the least amount of wok. pecificall, we limit the allocation of memo on the heap, and also avoid unnecessa gabage collection. We also find the best wa to build the RH of the ule, b e-using the memo cells and the eisting pointes. Retuning to the ideas pesented in the intoduction, we have obtained the following: Case 1: if thee ae two nodes in the RH of the ule, then the algoithm fo eecuting these ules will un in-place, and moeove we will pefom the fewest updates of pointes to build the RH. This is because the algoithm above will find the best wa of eusing both nodes and connections.

10 10 In-place Gaph Rewiting with Inteaction Nets Cases 2 and 3: Even when the algoithm is not in-place because we have moe than two nodes o fewe than two nodes in the RH, the ideas of this pape still gives the optimal implementation of the ule. We note howeve that if we change the data-stuctue, thee ma be othe solutions to this poblem, so the esult we obtain is with espect to the chosen data-stuctue. One aspect of in-place inteaction nets eduction that we have not eamined in the cuent pape is paiing up inteaction ules b using a specific eduction stateg. Fo eample, if an inteaction sstem has a ule with one node in the RH, and anothe ule with thee, then we might be able to schedule these two ules to be pefomed togethe, this maintaining the algoithm in-place. Thee ae a numbe of was we can do this at the implementation level, and we will include details of this aspect in the long vesion of the pape. 7 Conclusion We have intoduced a notion to ewite gaphs, specificall inteaction nets, in-place. We have identified a numbe of in-place algoithms and this lead us to an annotation to facilitate the implementation of in-place ewiting b e-using nodes of active pais. The main featue of this annotation is that is will give the best possible euse, so will allow the least amount of wok to be done when ewiting the gaph. We ae cuentl woking to incopoate the ideas of this pape into an implementation, using the model peviousl developed in [2]. We hope to pesent details of that, and benchmak esults at a futue time. Refeences [1] Maibel Fenández & Ian Mackie (1999): Calculus fo Inteaction Nets. In G. Nadathu, edito: Poceedings of the Intenational Confeence on Pinciples and Pactice of Declaative Pogamming (PPDP 99), Lectue Notes in Compute cience 1702, pinge-velag, pp , doi: / [2] bubaka Hassan, Ian Mackie & hina ato (2015): n Implementation Model fo Inteaction Nets. In: Poceedings 8th Intenational Wokshop on Computing with Tems and Gaphs, TERMGRPH 2014, Vienna, ustia, Jul 13, 2014., pp , doi: /eptc [3] Matin Hofmann (2000): Tpe stem fo Bounded pace and Functional In-Place Update Etended bstact. In Get molka, edito: Pogamming Languages and stems, 9th Euopean mposium on Pogamming, EOP 2000, Euopean Joint Confeences on the Theo and Pactice of oftwae, ETP 2000, Belin, Geman, Poceedings, Lectue Notes in Compute cience 1782, pinge, pp , doi: / [4] John Hughes & Las Paeto (1999): Recusion and Dnamic Data-stuctues in Bounded pace: Towads Embedded ML Pogamming. In Didie Rémi & Pete Lee, editos: Poceedings of the fouth CM IG- PLN Intenational Confeence on Functional Pogamming (ICFP 99), Pais, 1999, CM, pp , doi: / [5] Yves Lafont (1990): Inteaction Nets. In: Poceedings of the 17th CM mposium on Pinciples of Pogamming Languages (POPL 90), CM Pess, pp , doi: / [6] imon L. Peton Jones (1987): The Implementation of Functional Pogamming Languages. Pentice Hall Intenational.