SOFTWARE-BUG LOCALIZATION WITH GRAPH MINING

Transcription

1 Chpter 17 SOFTWARE-BUG LOCALIZATION WITH GRAPH MINING Frnk Eihinger Institute for Progrm Strutures nd Dt Orgniztion (IPD) Universit-t Krlsruhe (TH), Germny Klemens B-ohm Institute for Progrm Strutures nd Dt Orgniztion (IPD) Universit-t Krlsruhe (TH), Germny Astrt Keywords: In the reent pst, numer of frequent sugrph mining lgorithms hs een proposed They llow for nlyses in domins where dt is nturlly grphstrutured. However, used y slility prolems when deling with lrge grphs, the pplition of grph mining hs een limited to only few domins. In softwre engineering, deugging is n importnt issue. It is most hllenging to lolize ugs utomtilly, s this is expensive to e done mnully. Severl pprohes hve een investigted, some of whih nlyze tres of repeted progrm exeutions. These tres n e represented s ll grphs. Suh grphs desrie the invotions of methods during n exeution. This hpter is survey of grph mining pprohes for ug loliztion sed on the nlysis of dynmi ll grphs. In prtiulr, this hpter first introdues the suprolem of reduing the size of ll grphs, efore the different pprohes to lolize ugs sed on suh redued grphs re disussed. Finlly, we ompre seleted tehniques experimentlly nd provide n outlook on future issues. Softwre Bug Loliztion, Progrm Cll Grphs C.C. Aggrwl nd H. Wng (eds.), Mnging nd Mining Grph Dt, Advnes in Dtse Systems 40, DOI / _17, Springer Siene+Business Medi, LLC

2 516 MANAGING AND MINING GRAPH DATA 1. Introdution Softwre qulity is huge onern in industry. Almost ny softwre ontins t lest some minor ugs fter eing relesed. In order to void ugs, whih inur signifint osts, it is importnt to find nd fix them efore the relese. In generl, this results in devoting more resoures to qulity ssurne. Softwre developers usully try to find nd fix ugs y mens of in-depth ode reviews, long with testing nd lssil deugging. Loting ugs is onsidered to e the most time onsuming nd hllenging tivity in this ontext [6, 20, 24, 26] where the resoures ville re limited. Therefore, there is need for semi-utomted tehniques guiding the deugging proess [34]. If developer otins some hints where ugs might e lolized, deugging eomes more effiient. Reserh in the field of softwre reliility hs een extensive, nd vrious tehniques hve een developed ddressing the identifition of defet-prone prts of softwre. This interest is not limited to softwre-engineering reserh. In the mhine-lerning ommunity, utomted deugging is onsidered to e one of the ten most hllenging prolems for the next yers [11]. So fr, no ug loliztion tehnique is perfet in the sense tht it is ple of disovering ny kind of ug. In this hpter, we look t reltively new lss of ug loliztion tehniques, the nlysis of ll grphs with grph-mining tehniques. It n e seen s n pproh orthogonl to nd omplementing existing tehniques. Grph mining, or more speifilly frequent sugrph mining, is reltively young disipline in dt mining. As desried in the other hpters of this ook, there re mny different tehniques s well s numerous pplitions for grph mining. Proly the most prominent pplition is the nlysis of hemil moleules. As the NP-omplete prolem of sugrph isomorphism [16] is n inherent prt of frequent sugrph mining lgorithms, the nlysis of moleules enefits from the reltively smll size of most of them. Compred to the nlysis of moleulr dt, softwre-engineering rtifts re typilly mpped to grphs tht re muh lrger. Consequently, ommon grph-mining lgorithms do not sle for these grphs. In order to mke use of ll grphs whih reflet the invotion struture of speifi progrm exeutions, it is key to deploy suitle ll-grph-redution tehnique. Suh tehniques help to llevite the slility prolems to some extent nd llow to mke use of grph-mining lgorithms in numer of ses. As we will demonstrte, suh pprohes work well in ertin ses, ut some hllenges remin. Besides slility issues tht re still unsolved, some ll-grph-redution tehniques led to nother hllenge: They introdue edge weights representing ll frequenies. As grph-mining reserh hs onentrted on struturl nd tegoril domins, rther thn on quntittive weights, we re not wre of

3 Softwre-Bug Loliztion with Grph Mining 517 ny lgorithm speilized in mining weighted grphs. Though this hpter presents tehnique to nlyze grphs with weighted edges, the tehnique is omposition of estlished lgorithms rther thn universl weighted grph mining lgorithm. Thus, esides mining lrge grphs, weighted grph mining is further hllenge for grph-mining reserh driven y the field of softwre engineering. The reminder of this hpter is strutured s follows: Setion 2 introdues some si priniples of ll grphs, ugs, grph mining nd ug loliztion with suh grphs. Setion 3 gives n overview of relted work in softwre engineering employing dt-nlysis tehniques. Setion 4 disusses different ll-grph-redution tehniques. The different ug-loliztion pprohes re presented nd ompred in Setion 5 nd Setion 6 onludes. 2. Bsis of Cll Grph Bsed Bug Loliztion This setion introdues the onept of dynmi ll grphs in Susetion 2.1. It presents some lsses of ugs in Susetion 2.2 nd Susetion 2.3 explins how ug loliztion with ll grphs works in priniple. A rief overview of key spets of grph nd tree mining in the ontext of this hpter is given in Susetion Dynmi Cll Grphs Cll grphs re either stti or dynmi [17]. A stti ll grph [1] n e otined from the soure ode. It represents ll methods 1 of progrm s nodes nd ll possile method invotions s edges. Dynmi ll grphs re of importne in this hpter. They represent n exeution of prtiulr progrm nd reflet the tul invotion struture of the exeution. Without ny further tretment, ll grph is rooted ordered tree. The min-method of progrm usully is the root, nd the methods invoked diretly re its hildren. Figure 17.1 is n strt exmple of suh ll grph where the root Node represents themin-method. Unredued ll grphs typilly eome very lrge. The reson is tht, in modern softwre development, dedited methods typilly enpsulte every single funtionlity. These methods ll eh other frequently. Furthermore, itertive progrmming is very ommon, nd methods lling other methods our within loops, exeuted thousnds of times. Therefore, the exeution of even smll progrm lsting some seonds often results in ll grphs onsisting of millions of edges. The size of ll grphs prohiits strightforwrd mining with stte-ofthe-rt grph-mining lgorithms. Hene, redution of the grphs whih om- 1 In this hpter, we use method interhngely with funtion.

4 518 MANAGING AND MINING GRAPH DATA presses the grphs signifintly ut keeps the essentil properties of n individul exeution is neessry. Setion 4 desries different redution tehniques. 2.2 Bugs in Softwre In the softwre-engineering literture, there is numer of different definitions of ugs, defets, errors, filures, fults nd the like. For the purpose of this hpter, we do not differentite etween them. It is enough to know tht ug in progrm exeution mnifests itself y produing some other results thn speified or y leding to some unexpeted runtime ehvior suh s rshes or non-terminting runs. In the following, we introdue some types of ugs whih re prtiulrly interesting in the ontext of ll grph sed ug loliztion. () ()... Figure An unredued ll grph, ll grph with struture ffeting ug, nd ll grph with frequeny ffeting ug. () Crshing nd non-rshing ugs: Crshing ugs led to n unexpeted termintion of the progrm. Prominent exmples inlude null pointer exeptions nd divisions y zero. In mny ses, e.g., depending on the progrmming lnguge, suh ugs re not hrd to find: A stk tre is usully shown whih gives hints where the ug ourred. Hrder to ope with re non-rshing ugs, i.e., filures whih led to fulty results without ny hint tht something went wrong during the exeution. As non-rshing ugs re hrd to find, ll pprohes to disover ugs with ll-grph mining fous on them nd leve side rshing ugs. Osionl nd non-osionl ugs: Osionl ugs re ugs whih our with some ut not with ny input dt. Finding osionl ugs is prtiulrly diffiult, s they re hrder to reprodue, nd more test ses re neessry for deugging. Furthermore, they our more frequently, s non-osionl ugs re usully deteted erly, nd osionl ugs might only e found y mens of extensive testing. As ll ug-loliztion tehniques presented in this hpter rely on ompring ll grphs of filing nd orret progrm exeutions, they del with o-

5 Softwre-Bug Loliztion with Grph Mining 519 sionl ugs only. In other words, esides exmples of filing progrm exeutions, there needs to e ertin numer of orret exeutions. Struture nd ll frequeny ffeting ugs: This distintion is prtiulrly useful when designing ll grph sed ug-loliztion tehniques. Struture ffeting ugs re ugs resulting in different shpes of the ll grph where some prts re missing or our dditionlly in fulty exeutions. An exmple is presented in Figure 17.1, where Node lled from is missing, ompred to the originl grph in Figure In this exmple, fulty if-ondition in Node ould hve used the ug. In ontrst, ll frequeny ffeting ugs re ugs whih led to hnge in the numer of lls of ertin sutree in fulty exeutions, rther thn to ompletely missing or new sustrutures. In the exmple in Figure 17.1, fulty loop ondition or fulty if-ondition inside loop in Method re typil uses for the inresed numer of lls of Method. As proly ny ug-loliztion tehnique, ll grph sed ug loliztion is ertinly not le to find ll kinds of softwre ugs. For exmple, it is possile tht ugs do not ffet the ll grph t ll. For instne, if some mthemtil expression lultes fulty results, this does not neessrily ffet susequent method lls nd ll grph mining n not detet this. Therefore, ll grph sed ug loliztion should e seen s tehnique whih omplements other tehniques, s the ones we will desrie in Setion 3. In this hpter we onentrte on deterministi ugs of single-threded progrms nd leve side ugs whih re speifi for suh situtions. However, the tehniques desried in the following might lote suh ugs s well. 2.3 Bug Loliztion with Cll Grphs So fr, severl pprohes hve een proposed to lolize ugs y mens of ll-grph mining [9, 13, 14, 25]. We will present them in detil in the following setions. In nutshell, the pprohes onsist of three steps: 1 Dedution of ll grphs from progrm exeutions, ssignment of lels orret or filing. 2 Redution of ll grphs. 3 Mining of ll grphs, nlysis of the resulting frequent sugrphs. Step 1: Deriving ll grphs is reltively simple. They n e otined y tring progrm exeutions while testing, whih is ssumed to e done nywy. Furthermore, lssifition of progrm exeutions s orret or filing is

6 520 MANAGING AND MINING GRAPH DATA needed to find disrimintive ptterns in the lst step. Otining the neessry informtion n e done esily, s qulity ssurne widely uses test suites whih provide the orret results [18]. Step 2: Cll-grph redution is neessry to overome the huge sizes of ll grphs. This is muh more hllenging. It involves the deision how muh informtion lost is tolerle when ompressing the grphs. However, even if redution tehniques n filitte mining in mny ses, they urrently do not llow for mining of ritrry softwre projets. Detils on ll-grph redution re presented in Setion 4. Step 3: This step inludes frequent sugrph mining nd the nlysis of the resulting frequent sugrphs. The intuition is to serh for ptterns typil for fulty exeutions. This often results in rnking of methods suspeted to ontin ug. The rtionle is tht suh rnking is given to softwre developer who n do ode review of the suspiious methods. The speifis of this step vry widely nd highly depend on the grph-redution sheme used. Setion 5 disusses the different pprohes in detil. 2.4 Grph nd Tree Mining Frequent sugrph mining hs een introdued in erlier hpters of this ook. As suh tehniques re of importne in this hpter, we riefly repitulte those whih re used in the ontext of ug loliztion sed on ll grph mining: Frequent sugrph mining: Frequent sugrph mining serhes for the omplete set of sugrphs whih re frequent within dtse of grphs, with respet to user defined minimum support. Respetive lgorithms n mine onneted grphs ontining leled nodes nd edges. Most implementtions lso hndle direted grphs nd pseudo grphs whih might ontin self-loops nd multiple edges. In generl, the grphs nlyzed n ontin yles. A prominent mining lgorithm is gspn [32]. Closed frequent sugrph mining: Closed mining lgorithms differ from regulr frequent sugrph mining in the sense tht only losed sugrphs re ontined in the result set. A sugrph sg is lled losed if no other grph is ontined in the result set whih is supergrph of sg nd hs extly the sme support. Closed mining lgorithms therefore produe more onise result sets nd enefit from pruning opportunities whih my speed up the lgorithms. In the ontext of this hpter, the CloseGrph lgorithm [33] is used, s losed sugrphs proved to e well suited for ug loliztion [13, 14, 25].

7 Softwre-Bug Loliztion with Grph Mining 521 Rooted ordered tree mining: Tree mining lgorithms ( survey with more detils n e found in [5]) work on dtses of trees nd exploit their hrteristis. Rooted ordered tree mining lgorithms work on rooted ordered trees, whih hve the following hrteristis: In ontrst to free trees, rooted trees hve dedited root node, theminmethod in ll trees. Ordered trees preserve the order of outgoing edges of node, whih is not enoded in ritrry grphs. Thus, ll trees n keep the informtion tht ertin node is lled efore nother one from the sme prent. Rooted ordered tree mining lgorithms produe result sets of rooted ordered trees. They n e emedded in the trees from the originl tree dtse, preserving the order. Suh lgorithms hve the dvntge tht they enefit from the order, whih speeds up mining signifintly. Tehniques in the ontext of ug loliztion sometimes use the FREQT rooted ordered tree mining lgorithm [2]. Oviously, this n only e done when ll trees re not redued to grphs ontining yles. 3. Relted Work This hpter of the ook surveys ug loliztion sed on grph mining nd dynmi ll grphs. As mny pprohes orthogonl to ll-grph mining hve een proposed, this setion on relted work provides n overview of suh pprohes. The most importnt distintion for ug loliztion tehniques is if they re stti or dynmi. Dynmi tehniques rely on the nlysis of progrm runs while stti tehniques do not require ny exeution. An exmple for stti tehnique is soure ode nlysis whih n e sed on ode metris or different grphs representing the soure ode, e.g., stti ll grphs, ontrolflow grphs or progrm-dependene grphs. Dynmi tehniques usully tre some informtion during progrm exeution whih is then nlyzed. This n e informtion on the vlues of vriles, rnhes tken during exeution or ode segments exeuted. In the reminder of this setion we riefly disuss the different stti nd dynmi ug loliztion tehniques. At the end of this setion we present reent work in mining of stti progrm-dependene grphs in little more detil, s this pproh mkes use of grph mining. However, it is stti in nture s it does not involve ny progrm exeutions. It is therefore not similr to the mining shemes sed on dynmi ll grphs desried in the reminder of this hpter. Mining of Soure Code. Softwre-omplexity metris re mesures derived from the soure ode desriing the omplexity of progrm or its

8 522 MANAGING AND MINING GRAPH DATA methods. In mny ses, omplexity metris orrelte with defets in softwre [26, 34]. A stndrd tehnique in the field of mining softwre repositories is to mp post-relese filures from ug dtse to defets in stti soure ode. Suh mpping is done in [26]. The uthors derive stndrd omplexity metris from soure ode nd uild regression models sed on them nd the informtion if the softwre entities onsidered ontin ugs. The regression models n then predit post-relese filures for new piees of softwre. A similr study uses deision trees to predit filure proilities [21]. The pproh in [30] uses regression tehniques to predit the likelihood of ugs sed on stti usge reltionships etween softwre omponents. All pprohes mentioned require lrge olletion of ugs nd version history. Dynmi Progrm Sliing. Dynmi progrm sliing [22] n e very useful for deugging lthough it is not extly ug loliztion tehnique. It helps serhing for the ext use of ug if the progrmmer lredy hs some lue or knows where the ug ppers, e.g., if stk tre is ville. Progrm sliing gives hints whih prts of progrm might hve ontriuted to fulty exeution. This is done y exploring dt dependenies nd reveling whih sttements might hve ffeted the dt used t the lotion where the ug ppered. Sttistil Bug Loliztion. Sttistil ug loliztion is fmily of dynmi, mostly dt foused nlysis tehniques. It is sed on instrumenttion of the soure ode, whih llows to pture the vlues of vriles during n exeution, so tht ptterns n e deteted mong the vrile vlues. In [15], this pproh is used to disover progrm invrints. The uthors lim tht ugs n e deteted when unexpeted invrints pper in filing exeutions or when expeted invrints do not pper. In [23], vrile vlues gined y instrumenttion re used s fetures desriing progrm exeution. These re then nlyzed with regression tehniques, whih leds to potentilly fulty piees of ode. A similr pproh, ut with fous on the ontrol flow, is [24]. It instruments vriles in ondition sttements. It then lultes rnking whih yields high vlues when the evlution of these sttements differs signifintly in orret nd filing exeutions. The instrumenttion-sed pprohes mentioned either hve lrge memory footprint [6] or do not pture ll ugs. The ltter is used y the usul prtie not to instrument every prt of progrm nd therefore not to wth every vlue, ut to instrument smpled prts only. [23] overomes this prolem y olleting smll smpled prts of informtion from produtive ode on lrge numers of mhines vi the Internet. However, this does not filitte the disovery of ugs efore the softwre is shipped.

9 Softwre-Bug Loliztion with Grph Mining 523 Anlysis of Exeution Tres. A tehnique using tring nd visuliztion is presented in [20]. It relies on rnking of progrm omponents sed on the informtion whih omponents re exeuted more often in filing progrm exeutions. Though this tehnique is rther simple, it produes good ugloliztion results. In [6], the uthors go step further nd nlyze sequenes of method lls. They demonstrte tht the temporl order of lls is more promising to nlyze thn onsidering frequenies only. Both tehniques n e seen s sis for the more sophistited ll grph sed tehniques this hpter fouses on. The usge of ll sequenes insted of ll frequenies is generliztion whih tkes more struturl informtion into ount. Cll grph sed tehniques then generlize from sequene-sed tehniques. They do so y using more omplex struturl informtion enoded in the grphs. Mining of Stti Progrm-Dependene Grphs. Reent work of Chng et l. [4] fouses on disovering negleted onditions, whih re lso known s missing pths, missing onditions nd missing ses. They re lss of ugs whih re in mny ses non-rshing osionl ugs (f. Susetion 2.2) dynmi ll grph sed tehniques trget suh ugs s well. An exmple of negleted ondition is forgotten se in swith-sttement. This ould led to wrong ehvior, fulty results in some osions nd is in generl nonrshing. Chng et l. work with stti progrm-dependene grphs (PDGs) [28] nd utilize grph-mining tehniques. PDGs re grphs desriing oth ontrol nd dt dependenies (edges) etween elements (nodes) of method or of n entire progrm. Figure 17.2 provides n exmple PDG representing the method dd(, ) whih returns the sum of its two prmeters. Control dependenies re displyed y solid lines, dt dependenies y dshed lines. As PDGs re stti, only the numer of instrutions nd dependenies within method limit their size. Therefore, they re usully smller thn dynmi ll grphs (see Setions 2 nd 4). However, they typilly eome quite lrge s well, s methods often ontin mny dependenies. This is the reson why they nnot e mined diretly with stndrd grph-mining lgorithms. PDGs n e derived from soure ode. Therefore, like other stti tehniques, PDG nlysis does not involve ny exeution of progrm. The ide ehind [4] is to first determine onditionl rules in softwre projet. These re rules (derived from PDGs, s we will see) ourring frequently within projet, representing fult-free ptterns. Then, rule violtions re serhed, whih re onsidered to e negleted onditions. This is sed on the ssumption tht the more ertin pttern is used, the more likely it is to e vlid rule. The onditionl rules re generted from PDGs y deriving (topo-

10 524 MANAGING AND MINING GRAPH DATA dd dd dd =_in =_in ret=result =_in ret=result =_in result=+ result=+ ret=result () () () Figure An exmple PDG, sugrph nd topologil grph minor. logil) grph minors 2. Suh grph minors represent trnsitive intrproedurl dependenies. They n e seen like sugrphs s set of smller grphs desriing the hrteristis of PDG. The PDG minors re otined y employing heuristi mximl frequent sugrph-mining lgorithm developed y the uthors. Then, n expert hs to onfirm nd possily edit the grph minors (lso lled progrmming rules) found y the lgorithm. Finlly, heuristi grph-mthing lgorithm, whih is developed y the uthors s well, serhes the PDGs to find the rule violtions in question. From tehnil point of view, esides the PDG representtion, the pproh relies on the two new heuristi lgorithms for mximl frequent sugrph mining nd grph mthing. Both tehniques re not investigted from grph theoreti point of view nor evluted with stndrd dt sets for grph mining. Most importntly, there re no gurntees for the heuristi lgorithms: It remins unler in whih ses grphs re not found y the lgorithms. Furthermore, the pproh requires n expert to exmine the rules, typilly hundreds, y hnd. However, the lgorithms do work well in the evlution of the uthors. The evlution on four open soure progrms demonstrtes tht the pproh finds most negleted onditions in rel softwre projets. More preisely, 82% of ll rules re found, ompred to mnul investigtion. A drwk of the pproh is the reltively high flse-positive rte whih leds to ug-detetion preision of 27% on verge. Though grph-mining tehniques similr to dynmi ll grph mining (s presented in the following) re used in [4], the pprohes re not relted. The work of Chng et l. relies on stti PDGs. They do not require ny progrm exeution, s dynmi ll grphs do. 2 A grph minor is grph otined y repeted deletions nd edge ontrtions from grph [10]. For topologil grph minors s used in [4], in ddition, pths etween two nodes n e repled with edges etween oth nodes. Figure 17.2 provides () n exmple PDG long with () sugrph nd () topologil grph minor. The ltter is minor of oth, the PDG nd the sugrph. Note tht in generl ny sugrph of grph is minor s well.

11 Softwre-Bug Loliztion with Grph Mining Cll-Grph Redution As motivted erlier, redution tehniques re essentil for ll grph sed ug loliztion: Cll grphs re usully very lrge, nd grph-mining lgorithms do not sle for suh sizes. Cll-grph redution is usully done y lossy ompression of the grphs. Therefore, it involves the trdeoff etween keeping s muh informtion s possile nd strong ompression. As some ug loliztion tehniques rely on the temporl order of method exeutions, the orresponding redution tehniques enode this informtion in the redued grphs. In Susetion 4.1 we desrie the possily esiest redution tehnique, whih we ll totl redution. In Susetion 4.2 we introdue vrious tehniques for the redution of itertively exeuted strutures. As some tehniques mke use of the temporl order of method lls during redution, we desrie these spets in Susetion 4.3. We provide some ides on the redution of reursion in Susetion 4.4 nd onlude the setion with rief omprison in Susetion Totl Redution The totl redution tehnique is proly the esiest tehnique nd yields good ompression. In the following, we introdue two vrints: Totl redution (R totl ). Totl redution mps every node representing the sme method in the ll grph to single node in the redued grph. This my give wy to the existene of loops (i.e., the output is regulr grph, not tree), nd it limits the size of the grph (in terms of nodes) to the numer of methods of the progrm. In ug loliztion, [25] hs introdued this tehnique, long with temporl extension (see Susetion 4.3). Totl redution with edge weights (R totl w ). [14] hs extended the plin totl redution sheme (R totl ) to inlude ll frequenies: Every edge in the grph representing method ll is nnotted with n edge weight. It represents the totl numer of lls of the llee method from the ller method in the originl grph. These weights llow for more detiled nlyses. Figure 17.3 ontins exmples of the totl redution tehniques: () is n unredued ll grph, () its totl redution (R totl ) nd () its totl redution with edge weights (R totl w ). In generl, totl redution (R totl nd R totl w ) redues the grphs quite signifintly. Therefore, it llows grph mining sed ug loliztion with softwre projets lrger thn other redution tehniques. On the other hnd, muh

12 526 MANAGING AND MINING GRAPH DATA 1 1 d d () unredued () R totl Figure Totl redution tehniques. 4 1 d () R totl w informtion on the progrm exeution is lost. This onerns frequenies of the exeutions of methods (R totl only) s well s informtion on different struturl ptterns within the grphs (R totl nd R totl w ). In prtiulr, the informtion is lost in whih ontext (t whih position within grph) ertin sustruture is exeuted. 4.2 Itertions Next to totl redution, redution sed on the ompression of itertively exeuted strutures (i.e., used y loops) is promising. This is due to the frequent usge of itertions in tody s softwre. In the following, we introdue two vrints: Unordered zero-one-mny redution (R 01m unord ). This redution tehnique omits equl sustrutures of exeutions whih re invoked more thn twie from the sme node. This ensures tht mny equl sustrutures lled within loop do not led to ll grphs of n extreme size. In ontrst, the informtion tht some sustruture is exeuted severl times is still enoded in the grph struture, ut without ext numers. This is done y douling sustrutures within the ll grph. Compred to totl redution (R totl ), more informtion on progrm exeution is kept. The downside is tht the ll grph generlly is muh lrger. This redution tehnique is inspired y Di Ftt et l. [9] (f. R 01m ord in Susetion 4.3), ut does not tke the temporl order of the method exeutions into ount. [13, 14] hve used it for omprisons with other tehniques whih do not mke use of temporl informtion. Sutree redution (R sutree ). This redution tehnique, proposed in [13, 14], redues sutrees exeuted itertively y deleting ll ut the first sutree nd inserting the ll frequenies s edge weights. In generl, it therefore leds to smller grphs thn R 01m unord. The edge weights llow for detiled nlysis; they serve s the sis of the nly-

13 Softwre-Bug Loliztion with Grph Mining 527 sis tehnique desried in Susetion 5.2. Detils of the redution tehnique re given in the reminder of this susetion. Note tht with R totl, nd with R 01m unord in most ses s well, the grphs of orret nd filing exeution with ll frequeny ffeting ug (f. Susetion 2.2) re redued to extly the sme grph. With R sutree (nd with R totl w s well), the edge weights would e different when ll frequeny ffeting ugs our. Anlysis tehniques n disover this (f. Susetion 5.2). 1 1 d () unredued d () R 01m unord Figure Redution tehniques sed on itertions. 4 1 () R sutree Figure 17.4 illustrtes the two itertion-sed redution tehniques: () is n unredued ll grph, () its zero-one-mny redution without temporl order (R 01m unord ) nd () its sutree redution (R sutree ). Note tht the four lls of from re redued to two lls with R 01m unord nd to one edge with weight 4 withr sutree. Further, the grph resulting fromr sutree hs one node more thn the one otined from R totl w in Figure 17.3, ut the sme numer of edges. d level 1 level 1 level 1 level 3 level 2 d d level 2 level 3 d d 2 level 2 2 level 3 d 3 () Figure A rw ll tree, its first nd seond trnsformtion step. () () For the sutree redution (R sutree ), [14] orgnizes the ll tree into n horizontl levels. The root node is t level 1. All other nodes re in levels numered with the distne to the root. A n- ve pproh to redue the exmple ll tree in Figure 17.5 would e to strt t level 1 with Node. There, one would find two hild sutrees with different struture one ould not merge nything. Therefore, one proeeds level y level, strting from level n 1, s desried in Algorithm 22. In the exmple in Figure 17.5, one strts inlevel 2.

14 528 MANAGING AND MINING GRAPH DATA The left Nodehs two different hildren. Thus, nothing n e merged there. In the right, the two hildren re merged y dding the edge weights of the merged edges, yielding the tree in Figure In the next level, level 1, one proesses the root Node. Here, the struture of the two suessor sutrees is the sme. Therefore, they re merged, resulting in the tree in Figure Algorithm 22 Sutree redution lgorithm. 1: Input: ll tree orgnized in n levels 2: for level = n 1 to 1 do 3: for eh node in level do 4: merge ll isomorph hild-sutrees of node, sum up orresponding edge weights 5: end for 6: end for 4.3 Temporl Order So fr, the ll grphs desried just represent the ourrene of method lls. Even though, sy, Figures 17.3 nd 17.4 might suggest tht is lled efore in the root Node, this informtion is not enoded in the grphs. As this might e relevnt for disriminting fulty nd orret progrm exeutions, the ug-loliztion tehniques proposed in [9, 25] tke the temporl order of method lls within one ll grph into ount. In Figure 17.6, inresing integers tthed to the nodes represent the order. In the following, we present the orresponding redution tehniques: Totl redution with temporl edges (R totl tmp ). In ddition to the totl redution (R totl ), [25] uses so lled temporl edges. The uthors insert them etween ll methods whih re exeuted onseutively nd re invoked from the sme method. They ll the resulting grphs softwreehvior grphs. This redution tehnique inludes the temporl order from the rw ordered ll trees in the redued grph representtions. Tehnilly, temporl edges re direted edges with nother lel, e.g., temporl, ompred to other edges whih re leled, sy, ll. As the grph-mining lgorithms used for further nlysis n hndle edges leled differently, the nlysis of suh grphs does not give wy to ny speil hllenges, exept for n inresed numer of edges. In onsequene, the totlly redued grphs loose their min dvntge, their smll size. However, tking the temporl order into ount might help disovering ertin ugs.

15 Softwre-Bug Loliztion with Grph Mining 529 Ordered zero-one-mny redution (R 01m ord ). This redution tehnique proposed y Di Ftt et l. [9] mkes use of the temporl order. This is done y representing the grph s rooted ordered tree, whih n e nlyzed with n order wre mining lgorithm. To inlude the temporl order, the redution tehnique is hnged s follows: While R 01m unord omits ny equl sustruture whih is invoked more thn twie from the sme node, here only sustrutures re removed whih re exeuted more thn twie in diret sequene. This filittes tht ll temporl reltionships re retined. E.g., in the redution of the sequene,,,d, (see Figure 17.6) only the third is removed, nd it is still enoded tht is lled fter d one. Depending on the tul exeution, this tehnique might led to extreme sizes of ll trees. For exmple, if within loop Method is lled followed y two lls of, the redution leds to the repeted sequene,,, whih is not redued t ll. The rooted ordered tree miner in [9] prtly ompenstes the dditionl effort for mining lgorithms used y suh sizes, whih re huge ompred to R 01m unord. Rooted ordered tree mining lgorithms sle signifintly etter thn usul grph mining lgorithms [5], s they mke use of the order. () unredued d () R totl tmp () R 01m ord Figure Temporl informtion in ll grph redutions. Figure 17.6 illustrtes the two grph redutions whih re wre of the temporl order. (The integers tthed to the nodes represent the invotion order.) () is n unredued ll grph, () its totl redution with temporl edges (dshed, R totl tmp ) nd () its ordered zero-one-mny redution (R 01m ord ). Note tht, ompred tor 01m unord,r 01m ord keeps third Nodelled from, s the diret sequene of nodes leled is interrupted. 4.4 Reursion Another hllenge with the potentil to redue the size of ll grphs is reursion. The totl redutions (R totl, R totl w nd R totl tmp ) impliitly hndle reursion s they redue oth itertion nd reursion. E.g., when every method

16 530 MANAGING AND MINING GRAPH DATA is ollpsed to single node, (self-)loops impliitly represent reursion. Besides tht, reursion hs not een investigted muh in the ontext of ll-grph redution nd in prtiulr not s strting point for redutions in ddition to itertions. The reson for tht is, s we will see in the following, tht the redution of reursion is less ovious thn reduing itertions nd might finlly result in the sme grphs s with totl redution. Furthermore, in omputeintensive pplitions, progrmmers frequently reple reursions with itertions, s this voids ostly method lls. Nevertheless, we hve investigted reursion-sed redution of ll grphs to ertin extent nd present some pprohes in the following. Two types of reursion n e distinguished: Diret reursion. When method lls itself diretly, suh method ll is lled diret reursion. An exmple is given in Figure 17.7 where Method lls itself. Figure 17.7 presents possile redution represented with self-loop t Node. In Figure 17.7, edge weights s inr sutree represent oth frequenies of itertions nd the depth of diret reursion. Indiret reursion. It my hppen tht some method lls nother method whih in turn lls the first one gin. This leds to hin of method lls s in the exmple in Figure 17.7 where lls whih gin lls et. Suh hins n e of ritrry length. Oviously, suh indiret reursions n e redued s shown in Figures 17.7 (d). This leds to the existene of loops d d () () () (d) (e) (f) Figure Exmples for redution sed on reursion. Both types of reursion re hllenging when it omes to redution. Figures 17.7e (f) illustrte one wy of reduing diret reursions. While the susequent reflexive lls of re merged into single node with weighted self-loop,, nd d eome silings. As with totl redutions, this leds to new strutures whih do not our in the originl grph. In ug loliztion, one might wnt to void suh rtifts. E.g., d lled from extly the sme

17 Softwre-Bug Loliztion with Grph Mining 531 method s ould e struture-ffeting ug whih is not found when suh rtifts our. The prolem with indiret reursion is tht it n e hrd to detet nd eomes expensive to detet ll ourrenes of long-hined reursion. To onlude, when reduing reursions, one hs to e wre tht, s with totl redution, some rtifts my our. 4.5 Comprison To ompre redution tehniques, we must look t the level of ompression they hieve on ll grphs. Tle 17.1 ontins the sizes of the resulting grphs (inresing in the numer of edges) when different redution tehniques re pplied to the sme ll grph. The ll grph used here is otined from n exeution of the Jv diff tool tken from [8] used in the evlution in [13, 14]. Clerly, the effet of the redution tehniques vries extremely depending on the kind of progrm nd the dt proessed. However, the smll progrm used illustrtes the effet of the vrious tehniques. Furthermore it n e expeted tht the differenes in ll-grph ompressions eome more signifint with inresing ll grph sizes. This is euse lrger grphs tend to offer more possiilities for redutions. Redution Nodes Edges R totl, R totl w R sutree R totl tmp R 01m unord R 01m ord unredued Tle Exmples for the effet of ll grph redution tehniques. Oviously, the totl redution (R totl nd R totl w ) hieves the strongest ompression nd yields redution y two orders of mgnitude. As 22 nodes remin, the progrm hs exeuted extly this numer of different methods. The sutree redution (R sutree ) hs signifintly more nodes ut only five more edges. As roughly speking grph-mining lgorithms sle with the numer of edges, this seems to e tolerle. We expet the smll inrese in the numer of edges to e ompensted y the inrese in struturl informtion enoded. The unordered zero-one-mny redution tehnique (R 01m unord ) gin yields somewht lrger grphs. This is euse repetitions re represented s douled sustrutures insted of edge weights. With the totl redution with temporl edges (R totl tmp ), the numer of edges inreses y roughly 50% due to the temporl informtion, while the ordered zero-one-mny redution (R 01m ord ) lmost doules this numer. Susetion 5.4 ssesses the effetive-

18 532 MANAGING AND MINING GRAPH DATA ness of ug loliztion with the different redution tehniques long with the loliztion methods. Clerly, some ll grph redution tehniques lso re expensive in terms of runtime. However, we do not ompre the runtimes, s the susequent grph mining step usully is signifintly more expensive. To summrize, different uthors hve proposed different redution tehniques, eh one together with loliztion tehnique (f. Setion 5): the totl redution (R totl tmp ) in [25], the zero-one-mny redution (R 01m ord ) in [9] nd the sutree redution (R sutree ) in [13, 14]. Some of the redutions n e used or t lest e vried in order to work together with ug loliztion tehnique different from the originl one. In Susetion 5.4, we present originl nd vried omintions. 5. Cll Grph Bsed Bug Loliztion This setion fouses on the third nd lst step of the generi ug-loliztion proess from Susetion 2.3, nmely frequent sugrph mining nd ug loliztion sed on the mining results. In this hpter, we distinguish etween struturl pprohes [9, 25] nd the frequeny-sed pproh used in [13, 14]. In Susetions 5.1 nd 5.2 we desrie the two kinds of pprohes. In Susetion 5.3 we introdue severl tehniques to integrte the results of struturl nd frequeny-sed pprohes. We present some omprisons in Susetion Struturl Approhes Struturl pprohes for ug loliztion n lote struture ffeting ugs (f. Susetion 2.2) in prtiulr. Approhes following this ide do so either in isoltion or s omplement to frequeny-sed pproh. In most ses, likelihood P(m) tht Method m ontins ug is lulted, for every method. This likelihood is then used to rnk the methods. In the following, we refer to it s sore. In the reminder of this susetion, we introdue nd disuss the different struturl soring pprohes. The Approh y Di Ftt et l. In [9], the R 01m ord ll-grph redution is used (f. Setion 4), nd the rooted ordered tree miner FREQT [2] is employed to find frequent sutrees. The ll trees nlyzed re lrge nd led to slility prolems. Hene, the uthors limit the size of the sutrees serhed to mximum of four nodes. Bsed on the results of frequent sutree mining, they define the speifi neighorhood (SN ). It is the set of ll sugrphs ontined in ll ll grphs of filing exeutions whih re not frequent in ll grphs of orret exeutions:

19 Softwre-Bug Loliztion with Grph Mining 533 SN := {sg (supp(sg,d fil ) = 100%) (supp(sg,d orr ) minsup)} where supp(g,d) denotes the support of grph g, i.e., the frtion of grphs in grph dtse D ontining g. D fil nd D orr denote the sets of ll grphs of filing nd orret exeutions. [9] uses minimum support minsup of 85%. Bsed on the speifi neighorhood, struturl sore P SN is defined: P SN (m) := supp(g m,sn) supp(g m,sn)+supp(g m,d orr ) where g m denotes ll grphs ontining Method m. Note tht P SN ssigns the vlue 0 to methods whih do not our within SN nd the vlue 1 to methods whih our in SN ut not in orret progrm exeutions D orr. The Approh y Eihinger et l. The notion of speifi neighorhood (SN ) hs the prolem tht no support n e lulted when the SN is empty. 3 Furthermore, experiments of ours hve reveled tht the P SN -soring only works well if signifint numer of grphs is ontined insn. This depends on the grph redution nd mining tehniques nd hs not lwys een the se in the experiments. Thus, to omplement the frequeny-sed soring (f. Susetion 5.2), nother struturl sore is defined in [14]. It is sed on the set of frequent sugrphs whih our in filing exeutions only, SG fil. The struturl sore P fil is lulted s the support of m in SG fil : P fil (m) := supp(g m,sg fil ) Further Support-sed Approhes. Both the P SN -sore [9] nd the P fil -sore [14] hve their weknesses. Both pprohes onsider struture ffeting ugs whih led to dditionl sustrutures in ll grphs orresponding to filing exeutions. In thesn, only sustrutures ourring in ll filing exeutions (D fil ) re onsidered they re ignored if single filing exeution does not ontin the struture. The P fil -sore onentrtes on sugrphs ourring in filing exeutions only (SG fil ), lthough they do not need to e ontined in ll filing exeutions. Therefore, oth pprohes might not find struture ffeting ugs leding not to dditionl strutures ut to fewer strutures. The weknesses mentioned hve not een prolem so fr, s they hve rrely ffeted the respetive evlution, or the omintion with nother rnking method hs ompensted it. 3 [9] uses simplisti fll-k pproh to del with this effet.

20 534 MANAGING AND MINING GRAPH DATA One possile solution for roder struturl sore is to define sore sed on two support vlues: The support of every sugrph sg in the set of ll grphs of orret exeutions supp(sg,d orr ) nd the respetive support in the set of filing exeutions supp(sg,d fil ). As we re interested in the support of methods nd not of sugrphs, the mximum support vlues of ll sugrphs sg in the set of sugrphs SG ontining ertin Method m n e derived: s fil (m) := s orr (m) := mx {sg sg SG,m sg} supp(sg,d fil) mx {sg sg SG,m sg} supp(sg,d orr) Exmple Think of Method, lled from themin-method nd ontining ug. Let us ssume there is sugrph min (where denotes n edge etween two nodes) whih hs support of 100% in filing exeutions nd 40% in orret ones. At the sme time there is the sugrph min where lls fterwrds. Let us sy tht the ug ours extly in this onstelltion. In this sitution, min hs support of 0% ind orr while it hs support of 100% ind fil. Let us further ssume tht there lso is muh lrger sugrph sg whih ontins nd ours in 10% of ll filing exeutions. The vlue s fil () therefore is 100%, the mximum of 100% (sed on sugrph min ), 100% (sed on min ) nd 10% (sed on sg). With the two reltive support vlues s orr nd s fil s sis, new struturl sores n e defined. One possiility would e the solute differene of s fil nd s orr : P fil-orr (m) = s fil (m) s orr (m) Exmple To ontinue Exmple 17.1, P fil-orr () is 60%, the solute differene of 40% (s orr ()) nd 100% (s fil ()). We do not hieve higher vlue thn 60%, s Method lso ours in ug-free sugrphs. The intuition ehind P fil-orr is tht oth kinds of struture ffeting ugs re overed: (1) those whih led to dditionl strutures (high s fil nd low to moderte s orr vlues like in Exmple 17.2) nd (2) those leding to missing strutures (low s fil nd moderte to high s orr ). In ses where the support in oth sets is equl, e.g., oth re 100% for the min-method, P fil-orr is zero. We hve not yet evluted P fil-orr with rel dt. It might turn out tht different ut similr soring methods re etter. The Approh y Liu et l. Although [25] is the first study whih pplies grph mining tehniques to dynmi ll grphs to lolize non-rshing ugs,

21 Softwre-Bug Loliztion with Grph Mining 535 this work is not diretly omptile to the other pprohes desried so fr. In [25], ug loliztion is hieved y rther omplex lssifition proess, nd it does not generte rnking of methods suspeted to ontin ug, ut set of suh methods. The work is sed on ther totl tmp redution tehnique nd works with totl redued grphs with temporl edges (f. Setion 4). The ll grphs re mined with vrint of the CloseGrph lgorithm [33]. This step results in frequent sugrphs whih re turned into inry fetures hrterizing progrm exeution: A oolen feture vetor represents every exeution. In this vetor, every element indites if ertin sugrph is inluded in the orresponding ll grph. Using those feture vetors, support-vetor mhine (SVM) is lerned whih deides if progrm exeution is orret or filing. More preisely, for every method, two lssifiers re lerned: one sed on ll grphs inluding the respetive method, one sed on grphs without this method. If the preision rises signifintly when dding grphs ontining ertin method, this method is deemed more likely to ontin ug. Suh methods re dded to the so-lled ug-relevnt funtion set. Its funtions usully line up in form similr to stk tre whih is presented to user when progrm rshes. Therefore, the ug-relevnt funtion set serves s the output of the whole pproh. This set is given to softwre developer who n use it to lote ugs more esily. 5.2 Frequeny-sed Approh The frequeny-sed pproh for ug loliztion y Eihinger et l. [13, 14] is in prtiulr suited to lote frequeny ffeting ugs (f. Susetion 2.2), in ontrst to the struturl pprohes. It lultes sore s well, i.e., the likelihood to ontin ug, for every method. After hving performed frequent sugrph mining with the CloseGrph lgorithm [33] on ll grphs redued with ther sutree tehnique, Eihinger et l. nlyze the edge weights. As n exmple, ll-frequeny ffeting ug inreses the frequeny of ertin method invotion nd therefore the weight of the orresponding edge. To find the ug, one hs to serh for edge weights whih re inresed in filing exeutions. To do so, they fous on frequent sugrphs whih our in oth orret nd filing exeutions. The gol is to develop n pproh whih utomtilly disovers whih edge weights of ll grphs from progrm re most signifint to disriminte etween orret nd filing. To do so, one possiility is to onsider different edge types, e.g., edges hving the sme lling Method m s (strt) nd the sme method lled m e (end). However, edges of one type n pper more thn one within one sugrph nd, of ourse, in severl different sugrphs. Therefore, the uthors nlyze every edge in every suh lotion, whih is referred to s ontext. To

22 536 MANAGING AND MINING GRAPH DATA speify the ext lotion of n edge in its ontext within ertin sugrph, they do not use the method nmes, s they my our more thn one. Insted, they use unique id for the lling node (id s ) nd nother one for the method lled (id e ). All ids re vlid within their sugrph. To sum up, edges in its ontext in ertin sugrph sg re referened with the following tuple: (sg,id s,id e ). A ertin ug does not ffet ll method lls (edges) of the sme type, ut method lls of the sme type in the sme ontext. Therefore, the uthors ssemle feture tle with every edge in every ontext s olumns nd ll progrm exeutions in the rows. The tle ells ontin the respetive edge weights. Tle 17.2 serves s n exmple. (sg 1,id 1,id 2) (sg 1,id 1,id 3) (sg 2,id 1,id 2) (sg 2,id 1,id 3) Clss g orret g filing Tle Exmple tle used s input for feture-seletion lgorithms. The first olumn ontins referene to the progrm exeution or, more preisely, to its redued ll grph g i G. The seond olumn orresponds to the first sugrph (sg 1 ) nd the edge from id 1 (Method ) to id 2 (Method ). The third olumn orresponds to the sme sugrph (sg 1 ) ut to the edge from id 1 toid 3. Note tht oth id 2 nd id 3 represent Method. The fourth olumn represents n edge from id 1 to id 2 in the seond sugrph (sg 2 ). The fifth olumn represents nother edge in sg 2. Note tht ids hve different menings in different sugrphs. The lst olumn ontins the lss orret or filing. If ertin sugrph is not ontined in ll grph, the orresponding ells hve vlue 0, likeg 1, whih does not ontin sg 1. Grphs (rows) n ontin ertin sugrph not just one, ut severl times t different lotions. In this se, verges re used in the orresponding ells of the tle. The tle struture desried llows for detiled nlysis of edge weights in different ontexts within sugrph. Algorithm 23 desries ll susequent steps in this susetion. After putting together the tle, Eihinger et l. deploy stndrd feture-seletion lgorithm to sore the olumns of the tle nd thus the different edges. They use n entropy-sed lgorithm from the Wek dt-mining suite [31]. It lultes the informtion gin InfoGin [29] (with respet to the lss of the exeutions, orret or filing) for every olumn (Line 23 in Algorithm 23). The informtion gin is vlue etween 0 nd 1, interpreted s likelihood of eing responsile for ugs. Columns with n informtion gin of 0, i.e., the edges lwys hve the sme weights in oth lsses, re disrded immeditely (Line 23 in Algorithm 23). Cll grphs of filing exeutions frequently ontin ug-like ptterns whih re used y preeding ug. Eihinger et l. ll suh rtifts follow-up

23 Softwre-Bug Loliztion with Grph Mining d d e f e () () Figure Follow-up ugs. f ugs. Figure 17.8 illustrtes follow-up ug: () represents ug free version, () ontins ll frequeny ffeting ug in Methodwhih ffets the invotions of d. Here, this method is lled 20 times insted of twie. Following the R sutree redution, this leds to proportionl inrese in the numer of lls in Method d. [14] ontins more detils how follow-up ugs re deteted nd removed from the set of edges E (Line 23 of Algorithm 23). Algorithm 23 Proedure to lulte P freq (m s,m e ) nd P freq (m). 1: Input: set of edges e E, e = (sg,id s,id e ) 2: ssign every e E its informtion gin InfoGin 3: E = E {e e.infogin = 0} 4: remove follow-up ugs from E 5: E (ms,m e) = {e e E e.id s.lel = m s e.id e.lel = m e } 6: P freq (m s,m e ) = mx e E (ms,me) (e.infogin) 7: E m = {e e E e.id s.lel = m} 8: P freq (m) = mx e E m (e.infogin) At this point, Eihinger et l. lulte likelihoods of method invotions ontining ug, for every invotion (desried y lling Method m s nd method lled m e ). They ll this sore P freq (m s,m e ), s it is sed on the ll frequenies. To do the lultion, they first determine sets E (ms,m e) of edges e E for every method invotion in Line 23 of Algorithm 23. In Line 23, they use themx() funtion to lultep freq (m s,m e ), the mximum InfoGin of ll edges (method invotions) in E. In generl, there re mny edges in E with the sme method invotion, s n invotion n our in different ontexts. With the mx() funtion, the uthors ssign every invotion the sore from the ontext rnked highest. Exmple An edge from to is ontined in two sugrphs. In one sugrph, this edge hs low InfoGin vlue of 0.1. In the other sugrph, nd therefore in nother ontext, the sme edge hs high InfoGin

24 538 MANAGING AND MINING GRAPH DATA vlue of 0.8, i.e., ug is reltively likely. As one is interested in these ses, lower sores for the sme invotion re less importnt, nd only the mximum is onsidered. At the moment, the rnking does not only provide the sore for method invotion, P freq (m s,m e ), ut lso the sugrphs where it ours nd the ext emeddings. This informtion might e importnt for softwre developer. The uthors report this informtion dditionlly. To ese omprison with other pprohes not providing this informtion, they lso lulte P freq (m) for every lling Method m in Lines 23 nd 23 of Algorithm 23. The explntion is nlogous to the one of the lultion of P freq (m s,m e ) in Lines 23 nd Comined Approhes As disussed efore, struturl pprohes re well-suited to lote struture ffeting ugs, while frequeny-sed pprohes fous on ll frequeny ffeting ugs. Therefore, it seems to e promising to omine oth pprohes. [13] nd [14] hve investigted suh strtegies. In [13], Eihinger et l. hve omined the frequeny-sed pproh with the P SN -sore [9]. In order to lulte the resulting sore, the uthors use the pproh y Di Ftt et l. [9] without temporl order: They use ther 01m unord redution with generl grph miner, gspn [32], in order to lulte the struturl P SN -sore. They derived the frequeny-sed P freq -sore s desried efore fter mining the sme ll grphs ut with ther sutree redution nd the CloseGrph lgorithm [33] nd different mining prmeters. In order to omine the two sores derived from the results of two grph mining runs, they lulted the rithmeti men of the normlized sores: P om[13] (m) = P freq (m) 2 mx (P freq(n)) + P SN (m) 2 mx (P SN(n)) n sg D n sg D where n is method in sugrph sg in the dtse of ll ll grphs D. As the omined pproh in [13] leds to good results ut requires two ostly grph-mining exeutions, the uthors hve developed tehnique in [14] whih requires only one grph-mining exeution: They omine the frequeny-sed sore with the simple struturl sore P fil, oth sed on the results from one CloseGrph [33] exeution. They omine the results with the rithmeti men, s efore: P om[14] (m) = P freq (m) 2 mx (P freq(n)) + P fil (m) 2 mx (P fil(n)) n sg D n sg D