Solving the Class Diagram Restructuring Transformation Case with FunnyQT

Transcription

1 olving the lss Digrm Restruturing Trnsformtion se with FunnyQT Tssilo Horn Institute for oftwre Tehnology, University Kolenz-Lnu, Germny FunnyQT is moel querying n moel trnsformtion lirry for the funtionl Lisp-ilet lojure proviing rih n effiient querying n trnsformtion PI. This pper esries the FunnyQT solution to the TT 2013 lss Digrm Restruturing Trnsformtion se. This solution n the GROOVE solution shre the est overll solution wr for this se. 1 Introution FunnyQT is new moel querying n trnsformtion pproh whih is implemente s n PI for the funtionl, JVM-se Lisp-ilet lojure. It provies severl su-pis for implementing ifferent kins of queries n trnsformtions. For exmple, there is moel-to-moel trnsformtion PI, n there is n in-ple trnsformtion PI for writing progrmme grph trnsformtions. FunnyQT urrently supports EMF n JGrL moels, n it n e extene to other moeling frmeworks, too. For solving the tsks of this trnsformtion se 1, only FunnyQT s plin querying n moel mnipultion PIs hve een use, n the tsk is tkle lgorithmilly. 2 The ore Tsk The ore tsk s solution onsists of some helper funtions, funtion for fining sets of pullle properties n sorting them heuristilly in orer to hieve effetive results, the rules epite in the se esription [1], n funtion pplying the rules in orer to relize the trnsformtion. This setion strts with the helpers, then explins the funtion fining pullle properties, n then isusses the restruturing rules. The omplete soure oe is printe in ppenix. Helper Funtions. The helper funtions isusse in this setion re quite simple n ftor out funtionlity tht is use t severl ples in the rules. There re severl very simple helpers tht re not expline in etil. -prop! s new Property with some given nme n Type to some given Entity. elete-prop! eletes the property ientifie y given nme from given entity. The pull-up funtion gets list of [prop-nme type] tuples, set of soure entities, n trget entity. It then s new properties to the trget entity n eletes them from the soure entities. Lstly, there s mke-generliztion! whih retes new Generliztion etween su- n its super-entity, n there s mke-entity! tht retes new Entity. 1 This FunnyQT solution is ville t n on HRE (imge TT13::Uuntu12LT_TT13::FunnyQT.vi) Pieter Vn Gorp, Louis M. Rose, hristin Kruse (Es.): ixth Trnsformtion Tool ontest (TT 2013) EPT 135, 2013, pp , oi: /ept.135.9

2 76 olving the lss Digrm Restruturing Trnsformtion se with FunnyQT The funtion prop-type-set gets n Entity e n returns its set of [prop-nme type] tuples, i.e., there s one suh tuple for ny owne ttriute of e. 1 (efn prop-type-set [e] 2 (set (mp (fn [p] [(eget p :nme) (eget p :type)]) 3 (eget e :ownettriute)))) The filter-y-properties funtion gets olletion of [prop-nme type] tuples vi its pnts prmeter, n olletion of entities vi its entities prmeter. It returns the suset of entities for whih every entity efines ll of the given properties with ientil types. 1 (efn filter-y-properties [pnts entities] 2 (set (filter (fn [e] (forll? #(memer? % (prop-type-set e)) pnts)) 3 entities))) Restruturing Heuristis. This solution oesn t pull up one ttriute t time, ut inste it pulls up the mximl set of properties tht re shre y mximum of entities. I.e., the heuristis n e speifie s follows. Let P 1 n P 2 e sets of properties shre y the sets of entities E 1 n E 2, respetively. 1. If E 1 > E 2, then the solution pulls up the properties of P 1 inste of the properties of P 2. (Mximlity wrt. the numer of entities elring these properties) { 1 if P1 P 2. If E 1 = E 2, then the solution pulls up the properties of P i where i = 2. 2 otherwise (Mximlity wrt. the numer of pullle properties.) D N1 N2 D Mximl numer of elring entities N1 D N1 Mximl numer of pullle properties N1 Figure 1: Exmples for the heuristis Figure 1 illustrtes these heuristis with two exmples. In the left exmple, the property is shre y three lsses, wheres n re shre y only 2 lsses eh. If the trnsformtion pulls up first into new lss, n e pulle up only from n D into nother new lss. The numer of property elrtion ereses from 8 to 6, n remin uplite one, n 2 new lsses hve een rete. If the trnsformtion uses the first heuristi, it pulls up first euse tht s ommon to more lsses thn n. This lso results in 6 remining property elrtions, n remin uplite one, ut only one new lss hs een rete. In the right exmple, the set of properties {, } n {} re shre y two lsses oth. If the trnsformtion eies to pull up, the numer of property elrtions ereses from 7 to 6, n remin uplite one, n one new lss hs een rete. If the trnsformtion uses the seon heuristi, it pulls up n, n the numer of property elrtions ereses from 7 to 5, only remins uplite one, n gin one new lss hs een rete. The ommon-props funtion fins sets of pullle properties n sorts them oring to the heuristis. It is y fr the most omplex funtion of the trnsformtion. The funtion reeives set of entities vi its lsses prmeter n returns the properties ommon to mximl suset of these entities.

3 Tssilo Horn 77 1 (efn ommon-props [lsses] 2 (let [pes (set (mp (fn [pnt] [pnt (filter-y-properties [pnt] lsses)]) 3 (set (mpt prop-type-set lsses)))) 4 freq-mp (pply hsh-mp 5 (mpt (fn [[_ ents]] [ents (ount (filter #(= ents (seon %)) 6 pes))]) 7 pes)) 8 ollpse (fn ollpse [es] 9 (when-let [[pnt entities] (first es)] 10 (let [[s r] (split-with (fn [[_ ents]] (= entities ents)) es)] 11 (ons [(mp first s) entities] 12 (lzy-seq (ollpse r))))))] 13 (ollpse (into (sorte-set-y 14 (fn [[_ es :s ] [_ es :s ]] 15 (let [x (- (ount es) (ount es))] 16 (if (zero? x) 17 (let [x (- (freq-mp es) (freq-mp es))] 18 (if (zero? x) (ompre ) x)) 19 x)))) 20 pes)))) In line 2, pes is oun to set of tuples [pnt entity-set], where pnt is [prop-nme type] tuple n entity-set is the set of ll entities elring suh property. Tht is, pes hs the following form 2. #{[[pn1 t1] #{e1 e2 e3}] [[pn2 t2] #{e2 e3 e4 e5}] [[pn4 t2] #{e2 e3 e4}] [[pn3 t2] #{e1 e2 e3}]} In line 4, freq-mp is oun to hsh-mp tht mps to eh set of entities ouring in the items of pes the numer of ourenes in there. This mp is use to implement the seon heuristi. In line 8, lol funtion ollpse is efine. efore explining tht, first lines 13 to 22 re to e expline. Wht s one there is tht the entries of the set pes re put into sorte set. The sorting orer is etermine y the omprtor funtion efine in lines 14 to 21. It reeives two items of the pes set, ins their entity-sets to es n es, respetively, n then performs these heks: 1. If es ontins more entities thn es, shoul e sorte efore. This implements heuristi Else, if the entity set es ours more often in the items of pes, shoul e sorte efore. This implements heuristi Else, the sorting orer is not importnt n etermine y lojure s stnr ompre funtion tht proues stle orering upon ll ojets implementing omprle. s result, the sorte set hs the following struture, i.e., items with lrger entity sets re sorte efore items with smller entity sets. The item with pn2 is sorte efore the others euse it is shre y 4 entities. #{[[pn2 t2] #{e2 e3 e4 e5}] [[pn3 t2] #{e1 e2 e3}] [[pn1 t1] #{e1 e2 e3}] [[pn4 t2] #{e2 e3 e4}]} In se of eqully lrge entity sets, the numer of ourenes of the entity sets etermines the sorting orer, e.g., the items with pn1 n pn2 re sorte efore the item with pn4, euse their entity sets our twie wheres the entity set of pn4 ours only one. Finlly, this set is mngle y the lol ollpse funtion efine in lines 8 to 12. It simply ollpses (merges) jent items with equl entity sets, thus the result of the funtion hs the following form. ([([pn2 t2]) #{e2 e3 e4 e5}], [([pn1 t1] [pn3 t2]) #{e1 e2 e3}], [([pn4 t2]) #{e2 e3 e4}]} euse the items of pn1 n pn3 hve the sme entity set, they re merge into one item. 2 #{...} is lojure set literl.

4 78 olving the lss Digrm Restruturing Trnsformtion se with FunnyQT Restruturing Rules. The solution efines the funtion pull-up-helper shown in the next listing whih n implement ll three restruturing rules y prmeterizing it ppropritely. The funtion reeives the root moel ojet mo, superlss super, n set of entities lsses in whih to fin ommon properties,. In se of rule 1 n rule 2, super is the superlss of ll lsses, n in se of rule 3, the super prmeter is nil n lsses is the set of top-level lsses. 1 (efn pull-up-helper [mo super lsses] 2 (when (seq lsses) 3 (when-let [[pnts entities] (first (ommon-props lsses))] 4 (if (n super (= lsses entities)) 5 (pull-up mo pnts entities super) ;; rule 1 6 (when (> (ount entities) 1) 7 (let [n (mke-entity! mo)] ;; rule 2 if super is given, else rule 3 8 (pull-up mo pnts entities n) 9 (oseq [s entities] 10 (oseq [olgen (eget s :generliztion) 11 :when (= super (j olgen :generl))] 12 (eelete! olgen)) 13 (mke-generliztion! mo s n)) 14 (when super (mke-generliztion! mo n super)) 15 true)))))) When the set of lsses is not empty (line 2), n if there re ommon properties (line 3), the lrgest list of ommon properties mong the lists of properties elre y mximl numer of entities is oun to pnts, n the entities elring these properties re oun to entities. In se entities equls the set of ll lsses (line 4), the sitution is tht of rule 1, n ll properties in pnts re pulle up to super (line 5). In the other se, the mximl set of ommon properties is shre y mximl ut strit suset of lsses. Here, it hs to e ensure tht there re more thn one entity elring these properties (line 6), euse else the inheritne epth woul inrese without removing elrtions. Then, the sitution is tht of rule 2 if super is non-nil, n the sitution is tht of rule 3 if super is nil. In ny se, ll shre properties re pulle into new entity n (line 8), n the generliztions re pte y eleting the ol generliztions to super (lines 10-12), reting new generliztion to the new superlss n (line 13), n mking super superlss of n (line 14). The overll trnsformtion funtion simply lls the pull-up-helper funtion shown ove with pproprite prmetriztion s long s it n fin mth. Multiple Inheritne Extension. The solution isusse so fr works well lso if the initil moel lrey ontins multiple inheritne. However, they won t rete new entities tht speilize more thn one other entity. To exploit multiple inheritne in orer to restruture the moel resulting from the ore rules so tht there re no uplite properties, one itionl rule is use. It omputes the set of uplite properties of ll lsses, n then ts oring these heuristis. 1. If one of the entities elring the uplite property is top-level lss rete y the ore tsk, then the other entities eome its sulsses. Only top-level entities rete y the ore tsk re reuse, euse reusing one tht lrey existe in the originl lss moel mkes the result s type hierrhy inomptile with originl one, i.e., efore ws no sulss of, ut fterwrs it is. 2. Else, new entity is rete s superlss of the entities, n the property is pulle up. 3 Evlution The evlution results requeste y the se esription [1] re summrize in Tle 1.

5 Tssilo Horn 79 With 110 LO (ore + extension tsk), the solution s size is quite goo given tht its heuristis re more vne thn wht ws emne. Due to these heuristis, its effetiveness is 100% for ll provie n severl itionl moels (e.g., the ones in Figure 1). The se esription efines the omplexity s the sum of opertor ourenes, type referenes, n feture referenes. The FunnyQT solution onsists of 161 funtion lls (or lls to speil forms or mros), 4 type referenes, n 25 feture referenes. The evelopment effort hs een out 8 hours for the solution plus 2 hours for writing unit tests for it. The most hllenging n time-onsuming tsk hs een eveloping heuristis tht hieve 100% effetiveness in ll moels use for testing. ize (LO) 90 (ore only), 105 (ore + extension) omplexity 190 = 161 funlls + 4 type refs + 25 feture refs Effetiveness 100% Development effort pprox. 8 hours (solution) + 2 hours (tests) Exeution time 6 ses for the lrgest moel (testse2_10000.xmi) History of use pprox. 1 yer No. of se stuies pulishe: the 3 TT13 ses, unpulishe: pprox. 20 Mximum pility pprox. 2 million elements on HRE Tle 1: Evlution mesures The etile exeution times on HRE for the lrger moels re epite in Tle2. The lrgest provie moel testse2_10000 onsisting of elements 3 n e proesse in out six seons whih is more thn thousn times fster thn the referene UML-RD solution. Moel ore ore n Extension testse2_ ms 434 ms testse2_ ms 2585 ms testse2_ ms 6041 ms testse3 248 ms 268 ms testse2_ ms ms Tle 2: Detile exeution times on HRE To etermine the mximum pility of the solution, moels up to two millions of elements hve een rete. Given the limite mount of 800 M RM ville to the JVM proess on HRE, the moel with 2 million elements (testse2_200000) is out the mximum pility for the solution. The solution of this se uses only tiny prt of FunnyQT s fetures euse it ws est tkle lgorithmilly. ut next to the moel querying n moel mnipultion PIs use here, FunnyQT provies moel-to-moel trnsformtion PI, PIs for pttern mthing n progrmme grph trnsformtions, n there re more fetures to ome, mking FunnyQT equte for very ivergent set of trnsformtion tsks. Referenes [1] Kevin Lno & hekoufeh Kolhouz Rhimi (2013): se stuy: lss igrm restruturing. In Pieter Vn Gorp, Louis Rose & hristin Kruse, eitors: ixth Trnsformtion Tool ontest (TT 2013), EPT, this volume. 3 The moels testse2_n tully onsist of 10 n elements.

6 80 olving the lss Digrm Restruturing Trnsformtion se with FunnyQT The omplete oure oe of the olution 1 (efn -prop! [mo e pn t] 2 (let [p (erete! Property)] 3 (e! mo :propertys p) 4 (eset! p :nme pn) 5 (eset! p :type t) 6 (e! e :ownettriute p))) 7 8 (efn elete-prop! [e pn] 9 (let [p (first (filter #(= pn (eget % :nme)) 10 (eget e :ownettriute)))] 11 (eelete! p) 12 (eremove! e :ownettriute p))) (efn pull-up [mo pnts froms to] 15 (oseq [[pn t] pnts] 16 (-prop! mo to pn t) 17 (oseq [s froms] 18 (elete-prop! s pn))) 19 true) (efn mke-generliztion! [mo su super] 22 (let [gen (erete! Generliztion)] 23 (e! mo :generliztions gen) 24 (eset! gen :generl super) 25 (eset! gen :speifi su))) (efn mke-entity! [mo] 28 (let [e (erete! Entity)] 29 (e! mo :entitys e) 30 (eset! e :nme (str (gensym "Newlss"))))) (efn prop-type-set [e] 33 (set (mp (fn [p] [(eget p :nme) (eget p :type)]) 34 (eget e :ownettriute)))) (efn filter-y-properties [pnts entities] 37 (set (filter (fn [e] 38 (forll? #(memer? % (prop-type-set e)) pnts)) 39 entities))) (efn ommon-props [lsses] 42 (let [pes (set (mp (fn [pnt] 43 [pnt (filter-y-properties [pnt] lsses)]) 44 (set (mpt prop-type-set lsses)))) 45 freq-mp (pply hsh-mp 46 (mpt (fn [[_ ents]] 47 [ents (ount (filter #(= ents (seon %)) 48 pes))]) 49 pes)) 50 ollpse (fn ollpse [es] 51 (when-let [[pnt entities] (first es)] 52 (let [[s r] (split-with (fn [[_ ents]] 53 (= entities ents)) es)] 54 (ons [(mp first s) entities]

7 Tssilo Horn (lzy-seq (ollpse r))))))] 56 (ollpse (into (sorte-set-y 57 (fn [[_ es :s ] [_ es :s ]] 58 (let [x (- (ount es) (ount es))] 59 (if (zero? x) 60 (let [x (- (freq-mp es) (freq-mp es))] 61 (if (zero? x) 62 (ompre ) 63 x)) 64 x)))) 65 pes)))) (efn pull-up-helper [mo super lsses] 68 (when (seq lsses) 69 (when-let [[pnts entities] (first (ommon-props lsses))] 70 (if (n super (= lsses entities)) 71 (pull-up mo pnts entities super) ;; rule 1 72 (when (> (ount entities) 1) 73 (let [n (mke-entity! mo)] ;; if super rule 2, else rule 3 74 (pull-up mo pnts entities n) 75 (oseq [s entities] 76 (oseq [olgen (eget s :generliztion) 77 :when (= super (j olgen :generl))] 78 (eelete! olgen)) 79 (mke-generliztion! mo s n)) 80 (when super (mke-generliztion! mo n super)) 81 true)))))) (efn exploit-multiple-inheritne [mo] 84 (oseq [[pnts entities] (ommon-props (eget mo :entitys)) 85 :while (> (ount entities) 1)] 86 (let [[n reuse] 87 (if-let [top (first (filter 88 #(n (empty? (eget % :generliztion)) 89 (re-mthes #"Newlss.*" (eget % :nme))) 90 entities))] 91 [top true] 92 [(mke-entity! mo) flse])] 93 (oseq [[pn t] pnts] 94 (when-not reuse 95 (-prop! mo n pn t)) 96 (oseq [e (remove #(= n %) entities)] 97 (elete-prop! e pn) 98 (mke-generliztion! mo e n)))))) (efn pull-up-1-2 [mo] 101 (loop [lsses (eget mo :entitys), pplie flse] 102 (if (seq lsses) 103 (let [super (first lsses) 104 result (pull-up-helper 105 mo super (set (js super :speiliztion :speifi)))] 106 (reur (rest lsses) (or result pplie))) 107 pplie))) (efn pull-up-3 [mo] 110 (pull-up-helper mo nil (set (remove #(seq (eget % :generliztion))

8 82 olving the lss Digrm Restruturing Trnsformtion se with FunnyQT 111 (eget mo :entitys))))) (efn pull-up-ttriutes [moel multi-inheritne] 114 (let [mo (the (ellojets moel moel))] 115 (itertively #(let [r (pull-up-1-2 mo)] 116 (or (pull-up-3 mo) r))) 117 (when multi-inheritne (exploit-multiple-inheritne mo)) 118 moel))