Taming Subgraph Isomorphism for RDF Query Processing

Transcription

1 Tming Sugrph Isomorphism for RDF Query Proessing Jinh Kim # jinh.kim@orle.om Hyungyu Shin hgshin@dl.posteh..kr Wook-Shin Hn wshn@posteh..kr Sungpk Hong # Hssn Chfi # {sungpk.hong, hssn.hfi}@orle.om POSTECH, South Kore # Orle Ls, USA rxiv: v2 [s.db] 10 Jun 2015 ABSTRACT RDF dt re used to model knowledge in vrious res suh s life sienes, Semnti We, ioinformtis, nd soil grphs. The size of rel RDF dt rehes illions of triples. This lls for frmework for effiiently proessing RDF dt. The ore funtion of proessing RDF dt is sugrph pttern mthing. There hve een two ompletely different diretions for supporting effiient sugrph pttern mthing. One diretion is to develop speilized RDF query proessing engines exploiting the properties of RDF dt for the lst dede, while the other diretion is to develop effiient sugrph isomorphism lgorithms for generl, leled grphs for over 30 yers. Although oth diretions hve similr gol (i.e., finding sugrphs in dt grphs for given query grph), they hve een independently reserhed without ler reson. We rgue tht sugrph isomorphism lgorithm n e esily modified to hndle the grph homomorphism, whih is the RDF pttern mthing semntis, y just removing the injetivity onstrint. In this pper, sed on the stte-of-the-rt sugrph isomorphism lgorithm, we propose n in-memory solution, Turo HOM ++, whih is tmed for the RDF proessing, nd we ompre it with the representtive RDF proessing engines for severl RDF enhmrks in server mhine where illions of triples n e loded in memory. In order to speed up Turo HOM ++, we lso provide simple yet effetive trnsformtion nd series of optimiztion tehniques. Extensive experiments using severl RDF enhmrks show tht Turo HOM ++ onsistently nd signifintly outperforms the representtive RDF engines. Speifilly, Turo HOM ++ outperforms its ompetitors y up to five orders of mgnitude. 1. INTRODUCTION The Resoure Desription Frmework (RDF) is stndrd for representing knowledge on the we. It is primrily designed for uilding the Semnti we nd hs een widely dopted in dtse nd dt mining ommunities. RDF models ft s triple whih onsists of sujet (S), predite (P), nd n ojet (O). Due to its simple struture, mny prtitioners mterilize their dt in orresponding uthor n RDF formt. For exmple, RDF dtsets re now pervsive in vrious res inluding life sienes, ioinformtis, nd soil networks. The size of rel RDF dt rehes illions of triples. Suh illion-sle RDF dt re fully loded in min memory of tody s server mhine (The ost of 1TB mhine is less thn $40,000). The SPARQL query lnguge is stndrd lnguge for querying RDF dt in delrtive fshion. Its ore funtion is sugrph pttern mthing, whih orresponds to finding ll grph homomorphisms in the dt grph for query grph [18]. In reent yers, there hve een signifint efforts to speed up the proessing of SPARQL queries y developing novel RDF query proessing engines. Mny engines [1, 17, 18, 24, 25, 28] model RDF dt s tulr strutures nd proess SPARQL queries using speilized join methods. For exmple, RDF-3X [18] trets RDF dt s n edge tle, EDGE(S,P,O), nd mterilizes six different orderings for this tle, so tht it n support mny SPARQL queries just y using merge sed join. Note tht this pproh is effiient for oth disk-sed nd in-memory environments sine merge join exploits only sequentil sns. Some engines [2, 29, 34] tret RDF dt s grphs (or mtries) nd develop speilized grph proessing methods for proessing SPARQL queries. For exmple, gstore [34] uses speilized index strutures to proess SPARQL queries. Note tht these index strutures re sed on gcode [33], whih ws originlly proposed for grph indexing. Sugrph isomorphism, on the other hnd, hs een studied sine the 1970s. The representtive lgorithms re VF2 [19], QuikSI [20], GrphQL [11], GADDI [31], SPATH [32], nd Turo ISO [9]. In order to speed up performne, these lgorithms exploit good mthing orders nd effetive pruning rules. A reent study [13] shows tht good sugrph isomorphism lgorithms signifintly outperform grph indexing sed ones. However, ll of these lgorithms use only smll grphs in their experiments, nd thus, it still remins unler whether these lgorithms n show good performne for illion-sle grphs suh s RDF dt. Although sugrph isomorphism proessing nd RDF query proessing hve similr gols (i.e., finding sugrphs in dt grphs for given query grph), they hve two inexplily different diretions. A sugrph isomorphism lgorithm n e esily modified to hndle the grph homomorphism, whih is the RDF pttern mthing semntis, just y removing the injetivity onstrint. In this pper, sed on the stte-of-the-rt sugrph isomorphism lgorithm [9], we propose n in-memory solution, Turo HOM ++, whih is tmed for the RDF proessing, nd we ompre it with the representtive RDF proessing engines for severl RDF enhmrks in server mhine where illions of triples n e loded in memory. We elieve tht this pproh opens new diretion for RDF proessing so tht oth trditionl diretions n merge or enefit from eh other.

2 By trnsforming RDF grphs into leled grphs, we n pply sugrph homomorphism methods to RDF query proessing. Extensive experiments using severl enhmrks show tht diret modifition of Turo ISO outperforms the RDF proessing engines for queries whih require smll mount of grph explortion. However, for some queries whih require lrge mount of grph explortion, the diret modifition is slower thn some of its ompetitors. This poses n importnt reserh question: Is this phenomenon due to inherent limittions of the grph homomorphism (sugrph isomorphism) lgorithm? Our profile results show tht two mjor sutsks of Turo ISO 1) exploring ndidte sugrphs in ExploreCndidteRegion nd 2) enumerting solutions sed on ndidte regions in SugrphSerh require performne improvement. Turo HOM ++ resolves suh performne hurdles y proposing the type-wre trnsformtion nd tilored optimiztion tehniques. First, in order to speed up ExploreCndidteRegion, we propose novel trnsformtion (Setion 4.1), lled type-wre trnsformtion, whih is simple yet effetive in proessing SPARQL queries. In type-wre trnsformtion, y emedding the types of n entity (i.e., sujet or ojet) into vertex lel set, we n eliminte orresponding query verties/edges from query grph. With type-wre trnsformtion, the query grph size dereses, its topology eomes simpler thn the originl query, nd thus, this trnsformtion improves performne ordingly y reduing the mount of grph explortion. In order to optimize performne in depth, in oth Explore- CndidteRegion nd SugrphSerh, we propose series of optimiztion tehniques (Setion 4.3), eh of whih ontriutes to performne improvement signifintly for suh slow queries. In ddition, we explin how Turo HOM ++ is extended to support 1) generl SPARQL fetures suh s OPTIONAL, nd FILTER, nd 2) prllel exeution for Turo HOM ++ in non-uniform memory ess (NUMA) rhiteture [14, 15]. These generl fetures re neessry to exeute omprehensive enhmrks suh s Berlin SPARQL enhmrk (BSBM) [3]. Note lso tht, when the RDF dt size grows lrge, we hve to rely on the NUMA rhiteture. Extensive experiments using severl representtive enhmrks show tht Turo HOM ++ onsistently nd signifintly outperforms ll its ompetitors for ll queries tested. Speifilly, our method outperforms the ompetitors y up to five orders of mgnitude with only single thred. This indites tht sugrph isomorphism lgorithm tmed for RDF proessing n serve s n in-memory RDF elertor on top of ommeril RDF engine for rel-time RDF query proessing. Our ontriutions re s follows. 1) We provide the first diret omprison etween RDF engines nd the stte-of-the-rt sugrph isomorphism method tmed for RDF proessing, Turo HOM ++, through extensive experiments nd nlyze experimentl results in depth. 2) In order to simplify query grph, we propose novel trnsformtion method lled type-wre trnsformtion, whih ontriutes to oosting query performne. 3) In order to speed up query performne further, we propose series of performne optimiztions s well s NUMA-wre prllelism for fst RDF query proessing. 4) Extensive experiments using severl enhmrks show tht the optimized sugrph isomorphism method onsistently nd signifintly outperforms representtive RDF query proessing engines. The rest of the pper is orgnized s follows. Setion 2 desries the sugrph isomorphism, its stte-of-the-rt lgorithms, Turo ISO, nd their modifition for the grph homomorphism. Setion 3 presents how diret modifition of Turo ISO, Turo HOM, hndles the SPARQL pttern mthing. Setion 4 desries how we otin Turo HOM ++ from Turo HOM using the type-wre trnsformtion nd optimiztions for the effiient SPARQL pttern mthing. Setion 5 desries how Turo HOM ++ n hndle generl SPARQL fetures nd disusses the prlleliztion of Turo HOM ++. Setion 6 reviews the relted work. Setion 7 presents the experimentl result. Finlly, Setion 8 presents our onlusion. 2. PRELIMINARY 2.1 Sugrph Isomorphism nd RDF Pttern Mthing Semnti Suppose tht leled grph is defined s g(v,e,l), where V is set of verties,e( V V) is set of edges, ndlis leling funtion whih mps from vertex or n edge to the orresponding lel set or lel, respetively. Then, the sugrph isomorphism is defined s follows. Definition 1. [13] Given query grph q(v,e,l) nd dt grph g(v,e,l ), sugrph isomorphism is n injetive funtion M : V V suh tht 1) v V,L(v) L (M(v)) nd 2) (u,v) E,(M(u),M(v)) E ndl(u,v) = L (M(u),M(v)). If query vertex, u, hs lnk lel set (or does not speify vertex lel equivlently), it n mth ny dt vertex. Here, L(u) =, nd thus, the suset ondition, L(u) L (M(u)), is lwys stisfied. Similrly, if query edge (u,v) hs lnk lel, it n mth ny dt edge y generlizing the equlity ondition L(u,v) = L (M(u),M(v)) tol(u,v) L (M(u),M(v)). The grph homomorphism [6] is esily otined from the sugrph isomorphism y just removing the injetive onstrint onm in Definition 1. Even though the RDF pttern mthing semntis is sed on the grph homomorphism, to nswer SPARQL queries whih hve vriles on predites, mpping from query edge to n edge lel is lso required. We ll suh grph homomorphism the e(xtended)-grph homomorphism nd present forml definition for it s follows. Definition 2. Given query grph q(v,e,l) nd dt grph g(v,e,l ), n e(xtended)-grph homomorphism is pir of two mpping funtions, query vertex to dt vertex funtion M v : V V suh tht 1) v V,L(v) L (M v(v)) nd 2) (u,v) E,(M v(u),m v(v)) E, nd L(u,v) = L (M v(u),m v(v)), nd query edge to edge lel funtion M e : V V L suh tht (u,v) E,M e(u,v) = L (M v(u),m v(v)). The sugrph isomorphism prolem (resp. the e-grph homomorphism prolem) is to find ll distint sugrph isomorphisms (resp. e-grph homomorphisms) of query grph in dt grph. Figure 1 shows query q 1 nd dt grphg 1. Inq 1, _ mens lnk vertex lel set or lnk edge lel. In the sugrph isomorphism, there is only one solution M 1 = {(u 0,v 0),(u 1,v 1),(u 2, v 2),(u 3,v 3),(u 4,v 4)}. In the e-grph homomorphism, there re three solutions M 1 v = M 1, M 1 e = {((u 0,u 1),),((u 0,u 4),), ((u 2,u 1),),((u 2,u 3),),((u 3,u 4),)}, M 2 v = {(u 0,v 2), (u 1, v 3),(u 2,v 2),(u 3,v 3),(u 4,v 5)},M 2 e = M 1 e, ndm 3 v = {(u 0,v 2), (u 1,v 1),(u 2,v 2),(u 3,v 3),(u 4,v 5)},M 3 e = M 1 e. 2.2 Turo ISO In this susetion, we introdue the stte-of-the rt sugrph isomorphism solution, Turo ISO [9], nd its modifition for the e- grph homomorphism. Although we only desrie the modifition of Turo ISO for the e-grph homomorphism, suh modifition is pplile to other sugrph isomorphism lgorithms inluding

3 u 0 {A} u 1 _ {C} {A} {B} _ u 2 u 3 v 0 {A,D} v 1 {B} {C} v 2 {A} {B} v 3 {C,E} v 5 (lines 9). If the ndidte region is not empty, its mthing order is determined (line 11). The dt vertex, v s, is mpped to the first query vertex u s y ssigning M(u s) = v s nd F(v s) = true where F : V oolen is funtion whih heks whether dt vertex is mpped or not (line 12). Then, the remining sugrph mthing is onduted (line 13). Lstly, the mpping (u s,v s) is restored y removing the mpping for u s nd ssigningf(v s) = flse (line 14). u 4 () query grph q 1. v 4 () dt grph g 1. Figure 1: Exmple of sugrph isomorphism nd e-grph homomorphism. VF2 [19], QuikSI [20], GrphQL [11], GADDI [31], nd SPATH [32], sine ll of the sugrph lgorithms mentioned re instnes of generi sugrph isomorphism frmework [13]. Turo ISO presents n effetive method for the notorious mthing order prolem from whih ll the previous sugrph isomorphism lgorithms hve suffered [13]. Figure 2 illustrtes n exmple of the mthing order prolem, where q 2 is the query grph, nd g 2 is the dt grph 1. Note tht this exmple query results in no nswers. However, the time to finish this query n differ drstilly y how one hooses the mthing order, s it leds to different numer of omprisons. For instne, mthing order < u 0,u 2,u 1,u 3 > requires omprisons while different mthing order < u 0,u 3,u 1,u 2 > requires only * 10 omprisons. X u 1 u 0 A Y u 2 Z u 3 () query grphq 2. v 1 v11 X... X v 0 Y A v12 v10011 v10012 v CR(v0) Y Z... Z... Z X... X 10Xs 10000Ys 5Zs () dt grph g 2. Figure 2: Exmple of showing the mthing order prolem. Turo ISO solves the mthing order prolem with ndidte region explortion, tehnique tht urtely estimtes the numer of ndidte verties for given query pth [9]. In prtiulr, Turo ISO first identifies ndidte dt sugrphs (i.e., ndidte regions) from the strting verties (e.g. the shded re in Figure 2), then explores eh region y performing depth-first serh, whih llows lmost ext seletivity for eh query pth. Algorithm 1 outlines the overll proedure of Turo ISO in detil. First, if query grph hs only one vertex u nd no edge, it is suffiient to retrieve ll dt verties whih hve u s lels (= V(g) L(u) ) nd to find sugrph isomorphism for eh of them (lines 2 4). Otherwise, it selets the strting query vertex from the query grph (line 6). Then, it trnsforms the query grph into its orresponding query tree (line 7). After getting the query tree, for eh dt vertex tht ontins the vertex lel of the strting query vertex, the ndidte region is otined y exploring the dt grph 1 For simpliity, we omit the edge lels nd llow only one vertex lel in the dt grph. Z Algorithm 1 Turo ISO (g(v,e,l),q(v,e,l )) Require: q: query grph, g: dt grph Ensure: ll sugrph isomorphisms from q to g. 1: ifv(q) = {u} nd E = φ then 2: for eh v V(g) L(u) do 3: report M = {(u,v)} 4: end for 5: else 6: u s ChooseStrtQueryVertex(q,g) 7: q WriteQueryTree(q,u s) 8: for eh v s {v v V,L(u s) L(v)} do 9: CR ExploreCndidteRegion(u s,v s) 10: ifcr is not empty then 11: order DetermineMthingOrder(q,CR) 12: UpdteStte(M,F,u s,v s) 13: SugrphSerh(q,q,g,CR,order,1) 14: RestoreStte(M,F,u s,v s) 15: end if 16: end for 17: end if ChooseStrtQueryVertex. ChooseStrtQueryV ertex tries to pik the strting query vertex whih hs the lest numer of ndidte regions. First, s rough estimtion, the query verties re rnked y their sores. The sore of query vertex u isrnk(u) = freq(g,l(u)), where freq(g, L(u)) is the numer of deg(u) dt verties tht hveu s vertex lels. The sore funtion prefers lower frequenies nd higher degrees. After otining the topk lest-sored query verties, the numer of ndidte regions is more urtely estimted for eh of them y using the degree filter nd the neighorhood lel frequeny (NLF) filter. The degree filter qulifies the dt verties whih hve equl or higher degree thn their orresponding query verties. The NLF filter qulifies the dt verties whih hve equl or lrger numer of neighors for ll distint lels of the query vertex. In Figure 2, for exmple, u 0 eomes the strting query vertex sine it hs the lest numer of ndidte regions (= 1). WriteQueryTree. Next, W ritequeryt ree trnsforms the query grph to the query tree. From the strting query vertex otined y ChooseStrtQueryV ertex, reth-first tree trversl is onduted. Every non-tree edge(u,v) of the query grph lso is reorded in the orresponding query tree. For exmple, when u 0 is the strting query vertex, the non-tree edges of q 2 s query tree re (u 1,u 2),(u 1,u 3), nd (u 2,u 3). ExploreCndidteRegion. Using the query tree nd the strting query vertex, ExploreCndidteRegion ollets the ndidte regions. A ndidte region is otined y exploring the dt grph from the strting query vertex in depth-first mnner following the topology of the query tree. During the explortion, the injetivity onstrint should e enfored. The shded re of Figure 2 is the ndidte region CR(v 0) sed on q 2 s query tree. Note tht the ndidte region expnsion is onduted only fter the urrent dt vertex stisfies the onstrints of the degree filter nd the NLF filter.

4 DetermineMthingOrder. After otining the ndidte regions for strting dt vertex, the mthing order is determined for eh ndidte region. Using the ndidte region, Determine- MthingOrder n urtely estimte the numer of ndidte verties for eh query pth. Then, it orders ll query pths in the query tree y the numer of ndidte verties. For exmple, from CR(v 0), the ordered list of query pths is [u 0.u 3, u 0.u 1, u 0.u 2]. Thus, we n esily see tht < u 0,u 3,u 1,u 2 > is the est mthing order sed on this ordered list. SugrphSerh. Exploiting the dt strutures otined from the previous steps, SugrphSerh (Algorithm 2) enumertes ll distint sugrph isomorphisms. It first determines the urrent query vertex u from given mthing order order (line 1). Then, it otins set of dt verties, C R from ndidte region CR (line 2). CR(u,v) represents the ndidte verties of query vertexuwhih re the hildren of v incr, nd P(q,u) is the prent of u in query tree q. For eh ndidte dt vertex v, if v hs lredy een mpped, the urrent solution is rejeted sine it violtes the injetivity onstrint of the sugrph isomorphism (lines 4 6). Next, y lling IsJoinle, if the query vertex u of the urrent dt vertexv hs non-tree edges, the existene of the orresponding edges re heked in the dt grph (line 7). For exmple, given CR(v 0) nd the mthing order < u 0,u 3,u 1,u 2 >, when mking the emedding for u 1, we must hek whether there is n edge from M(u 1) to M(u 3). If the IsJoinle test is pssed, the mpping informtion is updted y ssigning M(u) = v nd F(v) = true (line 8). After updting the mpping, if ll query verties re mpped, sugrph isomorphism M is reported (lines 9 10). Otherwise, further sugrph serh is onduted (line 12). Finlly, ll hnges done y UpdteStte re restored (line 14). Algorithm 2SugrphSerh(q,q,g,CR,order,d ) 1: u order[d ] 2: C R CR(u,M(P(q,u))) 3: for eh v C R suh tht v is not yet mthed do 4: iff(v) = true then 5: ontinue 6: end if 7: ifisjoinle(q,g,m,u,v,...) then 8: UpdteStte(M, F, u, v) 9: if M = V(q) then 10: reportm 11: else 12: SugrphSerh(q,q,g,CR,order,d +1) 13: end if 14: RestoreStte(M, F, u, v) 15: end if 16: end for Modifying Turo ISO for e-grph Homomorphism. We first explin how the generi sugrph isomorphism lgorithm [13] n esily hndle grph homomorphism. The generi sugrph isomorphism lgorithm is implemented s ktrk lgorithm, where we find solutions y inrementing prtil solutions or ndoning them when it is determined tht they nnot e ompleted. Here, given query grph q nd its mthing order (u σ(1), u σ(2),..., u σ( V (q) ) ), solution is modeled s vetor v = (M(u σ(1) ), M(u σ(2) ),..., M(u σ( V (q) ) )) where eh element in v is dt vertex for the orresponding query vertex in the mthing order. At eh step in the ktrk lgorithm, if prtil solution is given, we extend it y dding every possile ndidte dt vertex t the end. Here, ny ndidte dt vertex tht does not stisfy the following three onditions must e pruned. 1) u i V(q),L(u i) L(M(u i)) 2) (u i,u j) E(q),(M(u i),m(u j)) E(g) ndl(u i,u j) = L(M(u i),m(u j)) 3) M(u i) M(u j) if u i u j Note tht the third ondition ensures the injetive ondition, gurnteeing tht no duplite dt vertex exists in eh solution vetor. Thus, y just disling the third ondition, the generi sugrph isomorphism lgorithm finds ll possile homomorphisms. Now, we desrie how to disle the third ondition in Turo ISO, whih is n instne of the generi sugrph isomorphism lgorithm. Turo ISO uses pruning rules y pplying filters inexplore- CndidteRegion nd SugrphSerh. First, the degree filter nd the NLF filter should e modified sine dt vertex n e mpped to multiple query verties. The degree filter qulifies dt verties whih hve n equl numer or more neighors thn distint lels of their orresponding query verties. The NLF filter qulifies dt verties whih hve t lest one neighor for ll distint lels of their orresponding query verties. Seond, lines 4 6 of SugrphSerh ensuring the third ondition should e removed in order to disle the injetivity test. As we see here, with miniml modifition to Turo ISO, it n esily support grph homomorphism. In order to mke Turo ISO hndle the e-grph homomorphism, the query edge to edge lel mpping, M e, should e dditionlly dded in SugrphSerh. For this, UpdteStte ssigns M e(p(q,u),u) =L(M v(p(q,u)),m v(u)), ndrestorestte removes suh mpping. From here on, let us denote Turo ISO modified for the e-grph homomorphism s Turo HOM. 3. RDF QUERY PROCESSING BY E-GRAPH HOMOMORPHISM In this setion, we disuss how RDF dtsets n e nturlly viewed s grphs (Setion 3.1), nd thus how n RDF dtset n e diretly trnsformed into orresponding leled grph (Setion 3.2). After suh trnsformtion, heneforth, the sugrph isomorphism lgorithms modified for the e-grph homomorphism suh s Turo HOM n e pplied for proessing SPARQL queries. 3.1 RDF s Grph An RDF dtset is olletion of triples eh of whih onsists of sujet, predite, nd n ojet. By onsidering triples s direted edges, n RDF dtset nturlly eomes direted grph: the sujets nd the ojets re verties while the predites re edges. Figure 3 is grph representtion of triples tht ptures type reltionships etween university orgniztions. Note tht we use retngles to represent verties in RDF grphs to distinguish them from the leled grphs. Student University rdf:suclssof rdf:type GrduteStudent rdf:type undergrdutedegreefrom student1 univ1 telephone emiladdress suorgniztionof memerof Figure 3: RDF grph. john@dept1.univ1.edu dept1.univ1 rdf:type Deprtment

5 3.2 Diret Trnsformtion To pply sugrph isomorphism lgorithms modified for e-grph homomorphism (e.g. Turo HOM ) for RDF query proessing, RDF grphs hve to e trnsformed into leled grphs first. The most si wy to trnsform RDF grphs is (1) to mp sujets nd ojets to vertex IDs nd (2) to mp predites to edge lels. We ll suh trnsformtion the diret trnsformtion euse the topology of the RDF grph is kept in the leled grph fter the trnsformtion. The vertex lel funtion L(v)(v V(g)) is the identity funtion (i.e. L(v) = {v}). Figure 4 shows the result of the diret trnsformtion of Figure 3 Figures 4, 4, nd 4 re the vertex mpping tle, the edge lel mpping tle, nd the trnsformed grph, respetively. Sujet/Ojet Vertex Predite Edge Lel GrduteStudent v 0 rdf:type Student v 1 rdf:suclssof University v 2 undergrddegreefrom Deprtment v 3 memerof d student1 v 4 suorgniztionof e univ1 v 5 telephone f dept1.univ1 v 6 emiladdress g v 7 john@dept1.univ1.edu v 8 () edge lel mpping tle. () vertex mpping tle. v1 {v1} {v2} v2 v4 v0 {v0} {v4} {v5} v5 f g d e () grph. v7 {v7} v8 {v8} {v6} v6 {v3} Figure 4: Diret trnsformtion of RDF grph (Vertex lel funtionl(v) = {v}). A query grph is otined from SPARQL query. A query vertex my hold the vertex lel whih orresponds to the sujet or ojet speified in the SPARQL query. If the query vertex orresponds to vrile, the vertex lel is left lnk. For exmple, the SPARQL query of Figure 5 is trnsformed into the query grph of Figure 5. Here the query vertex u 0, whih orresponds to Student, holds the vertex lel {v 1}; To the ontrry, the query vertex u 3, whih orresponds to the vrile X, hs lnk (_) s the vertex lel. Similrly, query edge my hold the edge lel whih orresponds to the predite. For exmple, the edge lel of (u 3,u 4) iss the edge orresponds to the undergrddegreefrom predite. SELECT?X,?Y,?Z WHERE {?X rdf:type Student.?Y rdf:type University.?Z rdf:type Deprtment.?X undergrddegreefrom?y.?x memerof?z.?z suorgniztionof?y.} () SPARQL query. u1 u4(=?y) _ {v2} v3 u3(=?x) _ u0 {v1} () query grph. Figure 5: Diret trnsformtion of SPARQL query. e d _ u5(=?z) Note tht, when vrile is delred on predite in SPARQL query, query edge hs lnk edge lel. An e-grph homomorphism lgorithm n nswer suh SPARQL queries sine n {v3} u2 e-grph homomorphism hs edge lel mpping from query edges to their orresponding edge lels. Consequently, the diret trnsformtion mkes it possile to pply onventionl e-grph homomorphism lgorithms for proessing SPARQL queries. In order to evlute the performne of suh n pproh, we pplied Turo HOM on LUBM8000, illion-triple RDF dtset of Leihigh University Benhmrk (LUBM) [8], fter pplying diret trnsformtion. We ompred the performne of Turo HOM ginst two existing RDF engines: RDF-3X [18], nd System-X 2. Figure 6 depits the mesured exeution time of these three systems in log sle. (See Setion 7.1 for the detils of the experiment setup) Figure 6: Comprison etween originl Turo HOM with the diret trnsformtion grph nd other RDF engines. Although there is no ler winner mong them, the figure revels tht Turo HOM performs s good s the existing RDF engines. For short-running queries (i.e Q1, Q3-Q5, Q7, Q8, Q10- Q13), Turo HOM shows fster elpsed time. As those queries speify dt vertex ID, Turo HOM only needs smll mount of grph explortion from one ndidte region with n optiml mthing order, while RDF-3X nd System-X require expensive join opertions. For long-running queries (i.e., Q2, Q6, Q9, nd Q14), Turo HOM is slower thn some of its ompetitors. The performne of Turo HOM lrgely relies on 1) grph explortion yexplorecndidteregion nd 2) sugrph enumertion y SugrphSerh. Moreover, when query grph hs non-tree edges, IsJoinle onstitutes lrge portion of SugrphSerh. The profiling results of long running queries onfirmed tht 1) ExploreCndidte- Region nd SugrphSerh re the dominting ftors nd 2) for queries whih hve non-tree edges (Q2 nd Q9),IsJoinle is the dominting ftor ofsugrphserh. Speifilly, Turo HOM spent the most time on ExploreCndidteRegion (e.g. 46% for Q2, 70% for Q6, 72% for Q9, nd 69% for Q14) nd Sugrph- Serh (e.g. 54% for Q2, 30% for Q6, 28% for Q9, nd 31% for Q14). Moreover, for queries whih hve non-tree edges, the most of SugrphSerh time ws spent on IsJoinle (e.g. 81.4% for Q2 nd 77.6% for Q9). In order to speed up ExploreCndidte- Region, we propose novel trnsformtion (Setion 4.1). Tilored optimiztion tehniques re proposed for improving performne for oth funtions (Setion 4.3). 4. TURBOHOM++ In this setion, we propose n improved e-grph homomorphism lgorithm, Turo HOM ++. Introdued first is the type-wre trnsformtion, whih n result in fster pttern mthing thn diret trnsformtion (Setion 4.1). Turo HOM ++ proesses the leled grph trnsformed y the type-wre trnsformtion (Setion 4.2). Furthermore, for effiient RDF query proessing, four optimiztions re pplied to Turo HOM ++ (Setion 4.3). 2 We nonymize the produt nme to void ny onflit of interest.

6 4.1 Type-wre Trnsformtion To enle the type-wre trnsformtion, we devise the twottriute vertex model whih mkes use of the type informtion speified y the rdf:type predite. Speifilly, this model ssumes tht eh vertex is ssoited with set of lels (the lel ttriute) in ddition to its ID (the ID ttriute). The lel ttriute is otined y following the rdf:type predite if sujet hs one or more rdf:type predites, its types n e otined y following the rdf:type (s well s rdf:suclssof predites trnsitively). For exmple, student1 in Figure 3 hs the lel ttriute,{grdstudent, Student}. The ove two-ttriute vertex model nturlly leds to our new RDF grph trnsformtion, the type-wre trnsformtion. Here, sujets nd ojets re trnsformed to two-ttriute verties y utilizing rdf:type predites s desried ove. Then, the ID ttriute orresponds to the vertex ID, nd the lel ttriute orresponds to the vertex lel. Figure 7 shows n exmple of the mpping tles nd the dt grph, whih is the result of type-wre trnsformtion pplied to Figure 3. Now, we formlly define the type-wre trnsformtion s follows. Definition 3. The type-wre trnsformtion(f V,F ID,F E,F V L, F EL) onverts set of triples T(S,P,O) to type-wre trnsformed grph G(V,E,ID,L). Let us divide T into three disjoint susets whose union is T T (S,P,O ), T t(s t,p t,o t) = {(s, rdf:type,o) T}, ndt s(s s,p s,o s) = {(s, rdf:suclssof, o) T}. 1. A vertex mpping F V : S O S t V, whih is ijetive, mps sujet ins S t or n ojet ino to vertex. 2. A vertex ID mppingf ID : S O S t N { }, whih is ijetive, mps sujet ins S t or n ojet ino to vertex ID or lnk. Here, F ID(x) = if x is vrile. 3. An edge mpping F E : T E, whih is ijetive, mps triple of T into n edge, F E(s,p,o) = (F V(s),F V(o)). 4. A vertex lel mpping F V L : O t O s VL { }, whih is ijetive, mps n ojet of O t O s into vertex lel. Here, F V L(x) = if x is vrile. 5. An edge lel mpping F EL : P EL { }, whih is ijetive, mps predite of P into n edge lel. Here, F EL(x) = if x is vrile. 6. A vertex ID mpping funtion ID : V N mps vertex to vertex ID where ID(v) = F ID F 1 V (v). 7. A leling funtion L 1) mps vertex to set of vertex lels suh thtv V,L(v) = {F V L(o) there is pth from F 1 V (v) to o using triples int t T s} nd 2) mps n edge e to n edge lel suh tht e E, L(e) = F LE (Pred(F 1 E (e))) where Pred(s,p,o) = p. After finding type-wre trnsformtion (F V,F ID,F E,F V L, kf EL) for dt grph g(v,e,l,id ), we n lso onvert SPARQL query into type-wre trnsformed query grph q(v, E, L,ID) y using nother type-wre trnsformtion(f V,F ID,F E, F V L,F EL) suh tht F ID = F ID, F V L = F V L, nd F EL = F EL. For exmple, Figure 8 is the query grph type-wre trnsformed from the SPARQL query in Figure 5. Note tht query vertex my hve multiple vertex lels like dt vertex. Now, we explin how the generi e-grph homomorphism lgorithm works for type-wre trnsformed query/dt grphs. When ppending ndidte dt vertex to the urrent prtil solution, we dditionlly hek the following ondition for the ID ttriute of the two-ttriute vertex model. Sujet/Ojet Vertex ID student1 0 univ1 1 dept1.univ john@dept1.univ1.edu 4 () vertex ID mpping tle. Predite Edge Lel undergrddegreefrom memerof suorgniztionof telephone d emiladdress e () edge lel mpping tle. Type Vertex Lel GrduteStudent A Student B University C Deprtment D () vertex lel mpping tle. v0 v1 0,{A,B} 1,{C} d e (d) dt grph. 3,{} 4,{} 2,{D} Figure 7: Type-wre trnsformtion of n RDF grph. u1 _,{C} u0 _,{B} u2 _,{D} Figure 8: Type-wre trnsformtion of SPARQL query of Figure 5. u {u ID(u) foru V},ID(u) = ID (M v(u)). The virtue of the type-wre trnsformtion is tht it n improve the effiieny of RDF query proessing. Sine the type-wre trnsformtion elimintes ertin verties nd edges y emedding type informtion into the vertex lel, the resulting dt/query grphs hve smller size nd simpler topology thn those trnsformed y the diret trnsformtion. As n exmple, let us onsider the SPARQL query in Figure 5. After diret trnsformtion, it eomes the query grph in Figure 5 tht hs reltively omplex topology onsisting of six verties nd six edges. On the other hnd, the type-wre trnsformtion produes the query grph in Figure 8 tht hs simple tringle topology. This redued numer of verties nd edges hs positive effet on effiieny euse it results in less grph explortion. In generl, the effet of the type-wre trnsformtion n e desried in terms of the numer of dt verties in ll ndidte regions. Consider SPARQL query whih onsists of set of triples T, its diret trnsformed query grph q(v,e,l), nd its typewre trnsformed query grph q (V,E,ID,L ). Let O type = {o (s,rdf : type,o) T or (s,rdf : suclssof,o) T}. In the diret trnsformtion, o O type is trnsformed to query vertex. Let V type set of diret trnsformed query verties from O type. However, in the type-wre trnsformtion, o O type is not trnsformed to query vertex, whih stisfies V = V V type. Therefore, the type-wre trnsformtion leds to less grph explortion in ExploreCndidteRegion nd SugrphSerh. Formlly, using the type-wre trnsformtion, the numer of dt verties in ll ndidte regions is redued y CR vs (u) u V type v s where v s represents the strting dt vertex for eh ndidte region, nd CR vs (u) represents set of dt verties in ndidte region CR(v s) tht orrespond tou. v3 v4 v2

7 4.2 Implementtion Turo HOM ++ mintins two in-memory dt strutures the inverse vertex lel list nd the djeny list. Figure 9 shows the inverse vertex lel list of Figure 7d. The end offsets reords the exlusive end offset of the vertex IDs for eh vertex lel. Figure 9 shows the djeny list of Figure 7d for the outgoing edges. The djeny list stores the djent verties for eh dt vertex in the sme wy s the inverse vertex lel list. One differene is tht the djeny list hs n dditionl rry ( end offsets ) to group the djent verties of dt vertex for eh neighor type. Here, the neighor type refers to the pir of the edge lel nd the vertex lel. For exmple, v 0 in Figure 7d, hs four different neighor types (, C),(, D),(d, ) nd(e, ). Those four neighor types re stored in end offsets, nd eh entry points to the exlusive end offset of the djent vertex ID. Turo HOM ++ mintins nother djeny list for the inoming edges. We ssume tht grphs in our system re periodilly updted from n underlying RDF soure. For effiient grph updte, trnstionl grph store is definitely required. We leve this explortion to future work sine it is eyond the sope of the pper. Note lso tht Turo HOM ++ n lso hndle SPARQL queries under the simple entilment regime orretly. In order to del with the simple entilment regime in the type-wre trnsformed grph, Turo HOM ++ distinguishesl simple (v) = {F LV (o) there is n edge from F 1 V (v) toousing triples int } froml(v). Turo HOM ++ n proess SPARQL query under the simple entilment regime using L simple (v) insted of L(v). end offsets of lel groups djent vertex IDs end offsets vertex IDs A B C D v0 v0 v1 v2 A B C D () inverse lel vertex list. v0 v1 v2 v3 v end offsets ((,C),1) ((,D),2) ((d,_),3) ((e,_),4) ((,C),5) v1 v2 v3 v4 v1 dj(v0,(,d)) dj(v0) () djeny list. dj(v2) Figure 9: In-memory dt strutures for type-wre trnsformed dt grph of Figure 7d (dj(v) : djent verties of v, dj(v,(el,vl)) : djent verties v, whih hve vertex lel vl nd re onneted with edge lel el). As the overll ehvior of Turo HOM ++ is similr to Turo HOM, here, we desrie how Turo HOM ++ uses the dt strutures in ChooseStrtQueryV ertex (line 6 of Algorithm 1), Explore- CndidteRegion (line 9 of Algorithm 1), ndisjoinle (line 7 of Algorithm 2). ChooseStrtQueryVertex. When omputing rnk(u) for query vertex u, the inverse vertex list is used to get freq(g, L(u)) (= l L(u) V(g) l ) where V(g) l is the set of verties hving vertex lel l. When L(u) = 1, Getting the strt nd end offset of speifi vertex lel is enough. When L(u) > 1, for eh l L(u), ll dt verties hvingl, V(g) l, re retrieved from the inverse vertex list, nd freq(g, L(u)) is otined y interseting ll V(g) l. Additionlly, when dt vertex ID v is speified in u, freq(g,l(u)) = 1 if v V(g) l for eh l L(u). Otherwise, freq(g,l(u)) = 0. One lst se is when SPARQL query hs query vertex whih hs no lel or ID t ll. In order to hndle suh queries, we mintin n index lled the predite index where key is predite, nd vlue is pir of list of sujet IDs nd list of ojet IDs. This index is used to ompute freq(g,l(u)). ExploreCndidteRegion. After query tree is generted, ndidte regions re olleted y exploring the dt grph in n indutive wy. In the se se, ll dt verties tht orrespond to the strt query vertex re gthered in the sme wy of omputing freq(g, L(u)). In the indutive se, one the strting dt verties re identified, the ndidte region explortion ontinues y exploiting the djeny informtion stored in the djeny list. If one vertex lel nd one edge lel re speified in the query grph, we n get the djent dt verties diretly from the djeny list. If multiple vertex lels nd one edge lel re speified, we ollet the djent dt verties for eh vertex lel using the djeny list, nd interset them. In se where the vertex lel or edge lel is lnk, Turo HOM ++ finds the orret djent dt verties y 1) olleting ll djent verties whih mth ville informtion (either vertex lel or edge lel) nd 2) unioning them. Additionlly, if the urrent query vertex hs the dt vertex ID ttriute, we hek whether the speified dt vertex is inluded in the dt verties olleted from the djeny list. IsJoinle. The IsJoinle test is equivlent to the indutive se ofexplorecndidteregion when dt vertex ID (previously mthed dt vertex) is speified. 4.3 Optimiztion In this susetion, we introdue optimiztions tht we pply to improve the effiieny of Turo HOM ++. Even though these optimiztions do not hnge Turo HOM ++ severely, they ould improve the query proessing effiieny quite signifintly. Use intersetion on IsJoinle test (+INT). We optimize the IsJoinle test in SugrphSerh. SugrphSerh lls the IsJoinle test y multiple memership opertions. However, the optimiztion llows ulk of IsJoinle tests with one k-wy intersetion opertion where k is the numer of edges etween the urrent query vertex,uin line 1 of Algorithm 2, nd the previously mthed query verties onneted y non-tree edges. SugrphSerh heks the existene of the edges etween the urrent ndidte dt vertex nd the lredy ounded dt verties y lling IsJoinle (line 7 of Algorithm 2) when the orresponding query grph hs non-tree edges. Let us onsider the query grph (Figure 8), the query tree (Figure 10) nd dt grph (Figure 11). Suppose tht, for given mthing order u 1 u 2 u 0, the vertex v 1 is ound to u 1, nd the vertex v 2 is ound to u 2. Then, the next step is to ind dt vertex to u 0. Beuse there is non-tree edge etween u 0 nd u 2, to ind dt vertex of ID v i(i = 0,3,4,,1001) to u 0, we need to hek whether there exists n edge v i v 2. u2 _,{D} u1 _,{C} u0 _,{B} Figure 10: A query tree of the query grph of Figure 8.

8 2,{D} v1 1, {C} v2 v0 v3 v1001 0,{A,B} 3,{A,B} 1000 verties 1001,{A,B} Figure 11: An exmple dt grph for illustrting +INT. IsJoinle heks for the existene of the edge etween the urrent dt vertex nd lredy mthed dt verties y repetitively llingisjoinle. Let us onsider the ove exmple. For ehv i(i = 0,3,4,,1001),IsJoinle tests whether the edge v i v 2 exists. If v 2 is memer of v i s outgoing djeny list, the test sueeds, nd the grph mthing ontinues. Insted, our modified IsJoinle tests ll the edge ourrenes etween the urrent ndidte verties (C R in line 3 of Algorithm 2) nd the djeny lists of the lredy mthed dt verties y one k-wy intersetion opertion. Let us onsider the ove exmple gin. The modified IsJoinle finds the edge etween v 2 nd the ndidte dt verties v 0,v 3,,v 1001 t one. For this, it is enough to perform one intersetion opertion etween thev 2 s inoming djeny verties nd the ndidte dt verties. Sine the modified IsJoinle tkes C R s prmeter, the lines 3 nd 7 of Algorithm 2 re merged into one sttement. Note tht this optimiztion n improve the performne signifintly. In the ove exmple, sine only v 0 nd v 1001 pss the test, we n void lling the originl IsJoinle 998 times. Formlly speking, let us denote 1) the ndidte dt vertex set for the urrent query vertex u s C R, 2) the previously mthed query vertex set, whih is onneted to the urrent query vertex y non-tree query edges, s {u i} k i=1 nd 3) the djent vertex set of v i(= M v(u i)) whereu i is onneted touwith the vertex lelvl i nd the edge lel el i, s dj(v i,vl i,el i). Suppose tht C R nd dj(v i,vl i,el i) re stored in ordered rrys. Then, the omplexity of the originl IsJoinle test is C originl = O( C R k log dj(v i,vl i,el i) ) i=1, sine IsJoinle is lled for eh v C R, nd O(log dj (v i,vl i,el i) ) time is required to ondut inry serh for dj(v i,vl i,el i) elements. On the ontrry, the omplexity of the modified IsJoinle test is min(o( C R + k dj(v i,vl i,el i) ),C originl ) i=1 sine the modifiedisjoinle n hoose thek-wy intersetions strtegy etween snning (k + 1) sorted lists nd performing inry serhes. Disle NLF Filter (-NLF). The seond optimiztion is to disle the NLF filter in ExploreCndidteRegion. The NLF filter my e effetive when the neighor type re very irregulr. However, in prtie, most RDF dtsets re strutured [7, 16]. For exmple, in our smple RDF dtset (Figure 3), in most se, vertex orresponding to grdute student hs telephone, emiladdress, memerof, nd undergrdutedegreefrom predites. Aordingly, the NLF filter is not helpful for suh strutured RDF dtsets. Disle Degree Filter (-DEG). The third optimiztion is to disle the degree filter in ExploreCndidteRegion. Similr to the NLF filter, the degree filter is effetive when the degree is very irregulr while RDF dtsets typilly re not. Reuse Mthing Order (+REUSE). The lst optimiztion is to reuse the mthing order of the first ndidte region for ll the other ndidte regions. Tht is, DetermineMthingOrder (line 6 of Algorithm 1) is lled only one throughout the Turo ISO exeution, nd the sme mthing order is used throughout the query proessing. Turo HOM ++ uses different mthing order for eh ndidte region, euse eh ndidte region ould hve very different numer of ndidte verties for given query pth in the e-grph homomorphism prolems. However, typil RDF dtsets re regulr t the shem level, i.e. well strutured in prtie, nd generting the mthing order for eh ndidte region is ineffetive, espeilly when the size of eh ndidte region is smll. We lso performed experiments with more heterogeneous dtsets, inluding Yet Another Gret Ontology (YAGO) [22], nd Billion Triples Chllenge 2012 (BTC2012) [10]. This optimiztion tehnique still shows good mthing performne s we will see in our extensive experiments in Setion 7, sine these heterogeneous dtsets do not show extreme irregulrity t the shem level. Let us tke the exmple of the expnded RDF dt from Figure 3 nd the query grph of Figure 8. Suppose tht the query tree is Figure 10. In tht se, the strting dt verties of the ndidte regions re the dt verties with the University vertex lel. To mke ndidte region for strting dt vertex, univ1, we must find (1) ll deprtments in univ1 nd (2) ll the grdute students who got their undergrdute degrees from univ1. Beuse the seletivity of (2) is higher thn tht of (1), the mthing order, u 1 u 2 u 0 is hosen. For the other universities (strting verties), it is rre tht the seletivity of (2) is higher thn tht of (1). For suh se, it is more effiient to reuse the first mthing order. 5. FURTHER IMPROVEMENT OF TURBO HOM++ In this setion, we riefly desrie how Turo HOM ++ n hndle the generl SPARQL keywords (Setion 5.1), nd how it n e prllelized under NUMA rhiteture (Setion 5.2). 5.1 Supporting Generl SPARQL Keywords Along with the si grph pttern mthing, we riefly desrie how n e-grph homomorphism lgorithm n hndle the generl SPARQL keywords OPTIONAL, FILTER, nd UNION. Thus, Turo HOM ++ n support the explore use se queries of the Berlin SPARQL enhmrk [3] using OPTIONAL, FILTER, nd UNION. OPTIONAL. To support queries tht sk informtion whih is not neessrily required, the OPTIONAL keyword is used. Figure 12 is n exmple of suh query whih finds the prie of <produt1> nd its rting nd its homepges if possile. To hndle OPTIONAL in Turo HOM ++, we propose simple yet effetive tehnique s follows. First, Turo HOM ++ selets strt query vertex whih is not speified in n OPTIONAL luse. Then, Turo HOM ++ mkes ndidte solution using the nullifynd-keep-serhing strtegy. In ExploreCndidteRegion, if the urrent query vertex is in n OPTIONAL luse, nd no dt vertex is mthed, Turo HOM ++ nullifies the urrent query vertex mpping in ndidte region. In SugrphSerh, even though the mpped dt vertex is nullified, if the orresponding query vertex is in n OPTIONAL luse, it invokes reursive ll. After ndidte solution is onstruted using nullify-nd-keep-serhing, Turo HOM ++ qulifies it using the qulify-nd-exlude-duplite strtegy. The OPTIONAL semntis enfores tht ll verties in n OPTIONAL luse must e

9 mpped to dt verties, otherwise, the mppings of ll query verties in n OPTIONAL luse re nullified. Also, when ll verties in n OPTIONAL luse re nullified, the nullified finl mpping should e generted only one. Turo HOM ++ exludes the duplites y ompring the urrent finl mpping with the previous vlid mpping. For exmple, suppose two suessive solutions of the exmple query re {(prie,$100), (rting, 5), (homepge,null)}, nd {(prie,$100), (rting, 1), (homepge,null)}. The preeding finl solution is qulified s {(prie,$100), (rting, null), (homepge, null)}, ut the ltter solution is dropped euse it is the sme s the preeding finl solution. The qulifynd-exlude-duplite strtegy is reursively pplied to hndle the nested OPTIONAL luses. SELECT?prie?rting?homepge WHERE { <produt1> rdf:type <Produt>. <produt1> prie?prie. OPTIONAL {<produt1> rting?rting. <produt1> homepge?homepge.} } Figure 12: A SPARQL query whih hs n OPTIONAL keyword. FILTER. To restrit solutions tht do not qulify onditions, the FILTER keyword is used. Figure 13 is n exmple of suh query whih finds ll produts whih hve higher rting thn <produt1>. To hndle FILTER expressions, inexpensive filters suh s seletion onditions re pplied whenever we ess the orresponding verties, while expensive filters suh s join onditions nd regulr expressions re pplied fter we find solution without these expensive filters. SELECT?produt WHERE { <produt1> rdf:type <Produt>. <produt1> rting?r1.?produt rdf:type <Produt>.?produt rting?r2. FILTER(?r2 >?r1) } Figure 13: A SPARQL query whih hs FILTER keyword. UNION. In SPARQL, to support the lterntive pttern mthing, the UNION keyword is used. Figure 14 is n exmple of suh query whih finds produts hving either <feture1> or <feture2>. To hndle the UNION keyword, the SPARQL query is split into su-queries, nd n e-grph homomorphism lgorithm solves eh su-query. Then, the finl solutions re the union of the su-queries solutions, s the semnti of the UNION keyword does not remove duplited items. SELECT?produt WHERE { {?produt rdf:type <Produt>.?P hsfeture <feture1>.} UNION {?produt rdf:type <Produt>.?P hsfeture <feture2>.} } Figure 14: A SPARQL query whih hs UNION keyword. 5.2 Prllel Proessing After generting the query tree (line of Algorithm 1), eh strting dt vertex n e proessed independently inluding ndidte region explortion, mthing order determintion nd sugrph serh (lines 9 15). Therefore distriuting suset of the strting dt verties to eh thred is enough to prllelize Turo HOM ++. Distriuting Strting Dt Verties. However, distriuting the strting dt verties in pre-determined wy my led to worklod imlne on threds. Although RDF dtsets re regulr t the shem-level, the rdinlities of one (mny)-to-mny reltionships t the instne-level n signifintly vry in ndidte regions. This property even holds for joins in reltionl dtses. For exmple, in Figure 8, the query involves three types, University, Grdute students, nd Deprtments t the shem level while universities n hve signifintly different numers of grduted students nd deprtments, whih leds to different worklod for eh university vertex. To hve s even worklod for eh thred s muh s possile, we ssign smll hunk of the strting dt verties to threds dynmilly. NUMA-wre Prlleliztion. The modern high-end worksttions dopt the NUMA rhiteture to mximize the prllelism y using the multi-soket systems [14, 15]. However, to fully utilize prllelism NUMA provides, prllel method should void remote memory ess whih retrieves dt stored in remote soket. To void tht, first, eh pge of dt grph is lloted in sokets lol memory in round-roin wy. With this, eh thred n expet uniform ess lteny for dt grph. Seond, thred is enfored to stik to speifi soket, nd thred speifi dt strutures re lloted in the sme soket where the thred runs. By doing so, thred esses its own dt strutures without remote memory ess. 6. RELATED WORK With the inresing populrity of RDF, the demnd for SPARQL support in reltionl dtses is lso growing. To meet suh demnd, most open-soure nd ommeril reltionl dtses support the RDF store nd the RDF query proessing. RDF dtsets re stored into reltionl tles with set of indexes. After tht, SPARQL queries re proessed y trnslting them into the equivlent join queries or y using speil APIs. To support RDF query proessing, mny speilized stores for RDF dt were proposed [2, 4, 17, 18, 25, 28]. Similr to RDBMS, RDF-3X [17, 18] trets RDF triples s ig three-ttriute tle, ut oosts the RDF query proessing y uilding exhustive indexes nd mintining sttistis. RDF-3X proesses mny SPARQL queries y using merge sed join, whih is effiient for disk-sed nd in-memory environments. Different from RDF-3X, Jen [25] exploits multiple-property tles, while BitMt [2] exploits 3-dimensionl it ue, so tht it n lso support 2D mtries of SO, PO, nd PS. H-RDF-3X [12] is distriuted RDF proessing engine where RDF-3X is instlled in eh luster node. Severl grph stores support RDF dt in their ntive grph storges [29, 34]. gstore [34] performs grph pttern mthing using the filter-nd-refinement strtegy. It first finds promising sugrphs using the VS -tree index. After tht, the ext sugrphs re enumerted in the refinement step. Trinity.RDF [29] is susystem of distriuted grph proessing engine, Trinity [21]. The RDF triples re stored in Trinity s key-vlue store. When proessing RDF queries, Trinity.RDF implements speil query proessing methods for RDF dt. In 1976, Ullmnn [23] pulished his seminl pper on the sugrph isomorphism solution sed on ktrking. After his work, mny sugrph isomorphism methods were proposed to improve the effiieny y devising their own mthing order seletion lgorithms nd filtering onstrints [9, 11, 19, 20, 31, 32]. Among those improved methods, Turo ISO [9] solves the notorious mthing order prolem y generting the mthing order for eh ndidte region nd y grouping the query verties whih hve the sme neighor informtion. The method shows the most effiient performne mong ll representtive methods. Along with the ktrking sed methods, the index-sed sugrph isomorphism methods were lso proposed [5, 26, 27, 30,

10 33]. All of those methods first prune out unpromising dt grphs using low-ost filters sed on the grph indexes. After filtering, ny sugrph isomorphism methods n e pplied to those unfiltered dt grphs. This tehnique is only useful when there re mny smll dt grphs. Thus, these index-sed sugrph isomorphism methods do not enhne RDF grph proessing sine there is only one ig grph in n RDF dtse. 7. EXPERIMENTS We perform extensive experiments on lrge-sle rel nd syntheti dtsets in order to show the superiority of tmed sugrph isomorphism lgorithm for RDF query proessing. In the experiment, we use Turo HOM ++. We ssume tht Turo HOM uses diret trnsformtion, while Turo HOM ++ uses type-wre trnsformtion long with ll optimiztions. The speifi gols of the experiments re 1) We show the superior performne of Turo HOM ++ over the stte-of-the-rt RDF engines (Setion 7.2), 2) We nlyze the effet of the type-wre trnsformtion nd the series of optimiztions (Setion 7.3), nd 3) We show the liner speed-up of the prllel Turo HOM ++ with n inresing numer of threds (Setion 7.4). 7.1 Experiment Setup Competitors. We hoose three representtive RDF engines s ompetitors of Turo HOM ++ RDF-3X, TripleBit, nd System-X. Note tht these three systems re pulily ville. RDF-3X [18] is well-known RDF store, showing good performne for vrious types of SPARQL queries. TripleBit [28] is very reent RDF engine effiiently hndling lrge-sle RDF dt. System-X is populr RDF engine exploiting itmp indexing. We exlude Bit- Mt [2] from performne evlution sine it is lerly inferior to TripleBit [28]. gstore is exluded sine it is not pulily ville. Dtsets. We use four RDF dtsets in the experiment LUBM [8], YAGO [22], BTC2012 [10], nd BSBM [3]. LUBM is de-fto stndrd RDF enhmrk whih provides syntheti dt genertor. Using the genertor, we rete three dtsets LUBM80, LUBM800, nd LUBM8000 where the numer represents the sling ftor. YAGO is rel dtset whih onsists of fts from Wikipedi nd the WordNet. BTC2012 is rel dtset rwled from multiple RDF we resoures. Lstly, BSBM is n RDF enhmrk whih provides syntheti dt genertor nd enhmrk queries. BSBM uses more generl SPARQL query fetures suh s FILTER, OPTIONAL, nd UNION. In order to support the originl enhmrk queries in LUBM, we lod the originl triples s well s inferred triples into dtses. In order to otin inferred triples, we use the stte-of-the-rt RDF inferene engine. For exmple, LUBM8000 ontins originl triples nd inferred triples. Note tht this is the stndrd wy to perform the LUBM enhmrk. However, regrding BTC2012, we use the originl triples only for dtse loding. This is euse the BTC2012 dtset ontins mny triples tht violte the RDF stndrd, nd thus the RDF inferene engine refuses to lod nd exeute inferene for the BTC2012 dtset. BSBM ontins originl triples nd inferred triples. Tle 1 shows the numer of verties nd edges of the grphs trnsformed y the diret trnsformtion nd the type-wre trnsformtion. The redued numer of edges in the type-wre trnsformed grph diretly ffets the mount of grph explortion in e-grph homomorphism mthing. Queries. Regrding LUBM, we use the 14 originl enhmrk queries provided in the wesite 3. Previous work suh s [28] nd 3 Tle 1: Grph size sttistis (diret: diret trnsformtion, type-wre: type-wre trnsformtion). V diret E diret V type-wre E type-wre LUBM LUBM LUBM BTC BSBM [29] modified some of the originl queries euse exeuting those originl queries without the inferred triples returns n empty result set. Regrding YAGO nd BTC2012, we use the sme query sets proposed in [18] nd [28], euse they do not hve offiil enhmrk queries. Some queries in the YAGO query set ontin predites whih do not exist in the YAGO dtset. We reple suh predites in queries with the predites in the dtset tht hve the losest mening. For exmple, the predite orninlotion in Q1, Q5, nd Q6 is repled with ornin. Regrding BSBM, we used 12 queries in the explore use se 4 whih ontin OP- TIONAL, FILTER, nd UNION keywords whih test the pility of more generl SPARQL query support. In order to mesure the pure sugrph mthing performne, (1) we omit modifiers whih reorgnize the sugrph pttern mthing results (e.g. DISTINCT nd ORDER BY) in ll queries nd (2) we mesure the elpsed time exluding the ditionry look-up time. Running Environment. We ondut the experiments in server running Linux four Intel Xeon E CPUs nd 1.5TB RAM. The server hs the NUMA [14, 15] rhiteture with 4 sokets in whih eh soket hs its own CPU nd lol memory. We mesure the elpsed times with wrm he. To do tht, we set up the ompetitors running environment s follows. For RDF-3X nd TripleBit, s done in [29], we put the dtse files in the tmpfs in-memory filesystem, whih is kind of RAM disk. For System-X, we set the memory uffer size to400gb, whih is suffiient for loding the entire dtse in memory. We exeute every query five times, exlude the est nd worst times, nd ompute the verge of the remining three. 7.2 Comprison etween Turo HOM++ nd RDF engines We report the elpsed times of the enhmrk queries using single thred. Sine the server hs NUMA rhiteture, memory llotion is lwys done within one CPU s lol memory. LUBM. Tle 2 shows the numer of solutions for ll enhmrk queries in ll LUBM dtsets. Tle 3 shows experimentl results for LUBM80, LUBM800, nd LUBM8000. Note tht Tripleit ws not le to return orret nswers for two queries over LUBM80/LUBM800 nd for ten queries over LUBM8000. In Tle 3, we use X or the supersript * over the elpsed times when TripleBit returns inorret numers of solutions. In order to nlyze results in depth, we lssify the LUBM queries into two types. The first type of queries hs onstnt numer of solutions regrdless of the dtset size. Q1, Q3 Q5, Q7, Q8, nd Q10 Q12 elong to this type. These queries re lled onstnt solution queries. The other queries (Q2, Q6, Q9, Q13, nd Q14) hve inresing numers of solutions proportionl to the dtset size. These queries re lled inresing solution queries. Regrding the onstnt solution queries, only Turo HOM ++ hieves the idel performne in LUBM, whih mens onstnt 4

11 Tle 2: Numer of solutions in LUBM queries. Dtset Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13 Q14 LUBM LUBM LUBM Tle 3: Elpsed time in LUBM [unit: ms] (X: wrong numer of solutions (# of solutions differene > 3), * : wrong numer of solutions (# of solutions differene 3)). Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13 Q14 Turo HOM RDF-3X TripleBit X System-X () LUBM80. Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13 Q14 Turo HOM RDF-3X TripleBit X System-X () LUBM800. Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13 Q14 Turo HOM RDF-3X TripleBit X X X X X X X X X X System-X () LUBM8000. performne regrdless of dtset size. This phenomenon is nlyzed s follows. Eh onstnt solution query ontins query vertex whose ID ttriute is set to n entity in the RDF grph. Thus, Turo HOM ++ hooses tht query vertex s strting query vertex nd genertes ndidte region. Furthermore, in the LUBM dtsets, lthough we inrese the sling ftor in order to inrese the dtse size, the size of the ndidte region explored y every onstnt solution query remins lmost the sme. In ontrst, the elpsed times of RDF-3X inrese s the dtset size inreses. This is euse the dt size to sn for merge join inreses s the dtset size inreses. Thus, the performne gp etween Turo HOM ++ nd RDF-3X inreses s the dtset size inreses. In LUBM80, Turo HOM ++ is (Q11) (Q7) times fster thn RDF-3X. In LUBM800, Turo HOM ++ outperforms RDF-3X y (Q10) (Q7) times. In LUBM8000, Turo HOM ++ outperforms RDF-3X y 43.10(Q1) (Q7) times. TripleBit shows similr trend s RDF-3X. Aordingly,Turo HOM ++ is 4.40 (Q11 in LUBM80) (Q5 in LUBM8000) times fster thn TripleBit. System-X shows onstnt elpsed times for these queries, lthough it is onsistently slower thn Turo HOM ++ y up to86.60 times. For the inresing solution queries (Q2, Q6, Q9, Q13, nd Q14), Turo HOM ++ lso shows the est performne in ll LUBM dtsets. Overll, the elpsed times of Turo HOM ++ re proportionl to the numer of solutions for these queries. Speifilly, fter type-wre trnsformtion, Q13 hs one query vertex whose ID ttriute is set to n entity in the dt grph. Thus, the numer of ndidte regions is one, whih is similr to the onstnt solution query. However, s the dtset size inreses, the ndidte region size lso inreses. The other queries (Q2, Q6, Q9, Q14) do not hve ny query vertex whose ID ttriute is set to n entity in the dt grph. As the dtset inreses, the numer of ndidte regions for these queries inreses, while eh ndidte region size does not hnge. All systems show the inresing elpsed time s the dtset size inreses. RDF-3X shows 7.60 (Q9 in LUBM80) (Q13 in LUBM8000) times longer elpsed times thn Turo HOM ++. TripleBit shows (Q2 in LUBM80) (Q13 in LUBM800) times longer elpsed time thn Turo HOM ++ when onsidering the queries whih hve the right numer of solutions. System-X shows 7.72 (Q14 in LUBM8000) (Q9 in LUBM8000) times longer elpsed time thn Turo HOM ++. For the onstnt solution query, System-X seems to e the est ompetitor of Turo HOM ++. However, regrding the most time-onsuming queries (Q2, Q9), System-X shows poor performne. YAGO. Sine the YAGO dtset ontins only out 50 million triples, ll engines proess the queries very effiiently. Unlike the LUBM queries, the YAGO queries hve only few vriles whih re set to types. Nevertheless, Turo HOM ++ exhiits the est performne for ll YAGO queries. Tle 4 shows the ext numer of solutions nd elpsed times in YAGO. Speifilly, Turo HOM ++ outperforms RDF-3X nd System-X y up to nd times. This performne improvement is due to good mthing order seletion nd the series of optimiztions in the optimized Turo HOM ++. Agin, TripleBit returns inorret numers of solutions for ll queries exept Q2. BTC2012. Tle 5 shows the ext numer of solutions nd elpsed times in BTC2012. Even though BTC2012 ontins over 1-illion triples, ll the engines proess ll BTC2012 queries quite effiiently. This is euse the shpes of query grphs re simple (tree-shped). Furthermore, like LUBM, Q2, Q4, nd Q5 in the BTC2012 query set ontin one query vertex whose ID ttriute is set to n entity in the RDF grph. Still, Turo HOM ++ outperforms RDF-3X, TripleBit, nd System-X y up to , 28.57, nd times, respetively.

12 Tle 4: Numer of solutions nd elpsed time [unit: ms] in YAGO. Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 # of sol Turo HOM RDF3X TripleBit X 1.03 X X X X X X System-X Tle 5: Numer of solutions nd elpsed time [unit: ms] in BTC2012. Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 # of sol Turo HOM RDF3X TripleBit X System-X BSBM.Tle 6 shows the ext numer of solutions nd elpsed times in BSBM. The open soure RDF engines, RDF-3X nd TripleBit, re exluded s they do not support OPTIONAL nd FILTER. Like BTC2012, even though BSBM ontins out 1- illion triples, Turo HOM ++ proesses most BSBM queries less thn 5ms exept Q5 nd Q6. Tht is euse they hve smll numer of solutions nd ontin one query vertex whose ID ttriute is set to n entity in the RDF grph. For those ten queries, Turo HOM ++ outperforms System-X y times. Q5 nd Q6 tke longer thn the other queries euse they use expensive filters suh s join onditions (Q5) nd regulr expression (Q6) nd filter out lrge numer of solutions fter si grph pttern mthing is finished. Before evluting FILTER, Q5 (Q6) hs ( ) solutions from the query grph pttern nd only qulifies 6803 (43508) finl solutions. Tle 6: Numer of solutions nd elpsed time [unit: ms] in BSBM. Q1 Q2 Q3 Q4 Q5 Q6 # of sol Turo HOM System-X Q7 Q8 Q9 Q10 Q11 Q12 # of sol Turo HOM System-X Effet of Improvement Tehniques We mesure the effet of the improvement tehniques inluding the type-wre trnsformtion (Setion 4.1) nd the four optimiztions (Setion 4.3). For this purpose, we use the lrgest LUBM dtset, LUBM8000. We first show the effet of the type-wre trnsformtion euse it is enefiil to ll LUBM queries. We next show the effet of the four optimiztions (Setion 7.3.2) Effet of Type-wre Trnsformtion Tle 7 shows the elpsed times for the LUBM queries in LUBM8000 using the diret trnsformtion (Turo HOM ) nd the type-wre trnsformtion (Turo HOM ++ without optimiztions). Compred with the diret trnsformtion, the type-wre trnsformtion improves the query performne y 1.01(Q1) to 27.22(Q6). The ovious reson for performne improvement is the smller query sizes fter the type-wre trnsformtion. The redued sized query grph leds to smller size ndidte regions nd shorter elpsed times. First of ll, Q6 nd Q14 enefit the most from the type-wre trnsformtion. After the type-wre trnsformtion, these queries eome point-shped. Tht is, solutions of these two queries re diretly otined y iterting the dt verties whih hve the vertex lel of the query vertex, whih orresponds to lines 2 4 in Algorithm 1. Q13 lso enefits muh from the typewre trnsformtion, sine the type-wre trnsformtion hooses etter strting query vertex thn the diret trnsformtion whih hooses query vertex hving type informtion. Q1, Q3, Q4, Q5, Q7, Q8, Q10, Q11, nd Q12 do not enefit from the type-wre trnsformtion euse they lredy hve smll numer of ndidte verties under the diret trnsformtion. Q2 enefits less thn the other long running queries from the type-wre trnsformtion. The following is the profiling result of Q2 with the diret/type-wre trnsformtion. Q2 with diret trnsformtion tkes milliseonds in ExploreCndidteRegion nd milliseonds in SugrphSerh. Note tht, with diret trnsformtion, the strting vertex is ritrrily hosen from u 0, u 1, u 2 in Figure 5 sine they ll hve sme vertex lel frequeny (freq(g,l(u i)) = 1,i = 0,1,2) nd the sme degree of 1. In our implementtion, the first query vertex u 0 is hosen nd thus the lel of the non-tree edge is suorgniztionof. However, with type-wre trnsformtion, the strting vertex is u 1 in Figure 8, nd the lel of the non-tree edge is memerof. Although the numer of ndidte regions with u 1 is the minimum mong u 0, u 1, nd u 2, the ost of IsJoinle lls for memerof inreses 1.30 times. Thus, Q2 with type-wre trnsformtion tkes milliseonds in ExploreCnditeRegion nd milliseonds in SugrphSerh. We hieve only 1.16 times performne improvement. However, the ost of the IsJoinle ll is signifintly redued y using +INT. Thus, fter pplying type-wre trnsformtion nd the tilored optimiztions, the finl elpsed time for Q2 eomes ms, i.e., times performne improvement ompred with diret trnsformtion only Effet of Four Optimiztions In this experiment, we mesure the effet of four optimiztions of Turo HOM ++. We use Q2 nd Q9 in LUBM8000 sine these two queries in LUBM8000 re the most time-onsuming nd exploit ll optimiztions. All the other queries re omitted sine their elpsed times re too short, so tht it is hrd to reognize the effet of optimiztion. Note tht the elpsed times of Q1, Q3 Q5, Q7, Q8, Q10 Q13 re too short (< 2ms), nd Q6 nd Q14 do not enefit from these optimiztions sine they re point-shped. Figure 15 shows the redued times of Q2 nd Q9 in LUBM8000 fter pplying these optimiztions seprtely. The optimiztion tehniques in X-xis re ordered y the redued in deresing mnner +INT, -NLF, -DEG, nd +REUSE. Interestingly, even though Q2 nd Q9 hve the sme shpe (i.e., tringlulr), the most effetive optimiztions were different. +INT ws the most effetive in Q2. -NLF ws the most effetive in Q9 sine the size of eh ndidte region ws very smll. -DEG ws more effetive in Q9 thn in Q2 sine Q9 hs more dt verties pplied to the degree filter. +REUSE ws effetive in Q9 whih hs lrge numer of ndidte regions while Q2 did not enefit from +REUSE.

13 Tle 7: Effet of type-wre trnsformtion in LUBM8000 (Performne gin=diret trnsformtion Type-wre trnsformtion). Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13 Q14 Diret trnsformtion (ms) Type-wre trnsformtion (ms) Performne gin Figure 15: Redued elpsed time of eh optimiztion (Elpsed time of no-optimiztion: ms (Q2) nd ms (Q9)). 7.4 Effet of Prlleliztion In the lst experiment, we report the prlleliztion effet of Turo HOM ++. Among prllelizle queries (Q2, Q6, Q9, nd Q14), whih hve multiple strting dt verties, we hoose Q2 nd Q9. The resons re 1) these queries re the most time-onsuming queries, nd 2) Q6 nd Q14 re point-shped queries whih do not involves grph explortion. In order to show the prllelism, we llote the dt grph in n interleved wy where eh memory pge llotion is ssigned to sokets in round-roin wy. We vry the numer of threds y 1, 4, 8, 12 nd 16. As shown in Figure 16, Turo HOM ++ shows super-liner speed-up proportionl to the numer of threds. In Q2, Turo HOM ++ hieves5.37, 10.49, nd speed-up using 4, 8, 12, nd 16 threds, respetively. In Q9, Turo HOM ++ hieves 4.87, 8.23, nd speed-up. In the experiment, though the dt grph is evenly spred out in 4 sokets, dt verties of ndidte region ould not e uniformly distriuted. Tht mens exeuting pttern mthing of the ndidte region in soket whih hs more dt verties in its lol memory for the ndidte region is enefiil sine less remote memory ess is required. In this sense, mesuring speed-up sed on multiple of 4 threds is more resonle. When omputing the speedup sed on the 4-thred elpsed time, the speed-up of Q2 eomes 1.95, 2.80, nd 3.65 for 8, 12, nd 16 threds. Figure 16: Speed-up of Turo HOM ++ in Q2 nd Q9 in the LUBM8000 dtset). 8. CONCLUSION The ore funtion of proessing RDF dt is sugrph pttern mthing. There hve een two ompletely different diretions for supporting effiient sugrph pttern mthing. One diretion is to develop speilized RDF query proessing engines exploiting the properties of RDF dt, while the other diretion is to develop effiient sugrph isomorphism lgorithms for generl, leled grphs. In this pper, we posed n importnt reserh question, Cn sugrph isomorphism e tmed for effiient RDF proessing? In order to ddress this question, we provided the first diret nd omprehensive omprison of the stte-of-the-rt sugrph isomorphism method with representtive RDF proessing engines. We first showed tht sugrph isomorphism lgorithm requires miniml modifition to hndle grph homomorphism with edge lel mpping whih is the RDF grph pttern mthing semntis. We then provided novel trnsformtion method, lled type-wre trnsformtion long with series of optimiztion tehniques. We next performed extensive experiments using RDF enhmrks in order to show the superiority of the optimized sugrph isomorphism over representtive RDF proessing engines. Experimentl results showed tht the optimized sugrph isomorphism method hieved onsistent nd signifint speedup over those RDF proessing engines. This study drew promising onlusion tht sugrph isomorphism lgorithm tmed for RDF proessing n serve s n inmemory elertor on top of ommeril RDF engine for reltime RDF query proessing s well. We elieve tht this pproh opens new diretion for RDF proessing, so tht oth trditionl diretions n merge or enefit from eh other. Aknowledgment This work ws supported in prt y gift from Orle Ls Externl Reserh Offie. This work ws lso supported y the Ntionl Reserh Foundtion of Kore(NRF) grnt funded y the Kore government(msip) (No. NRF-2014R1A2A2A ) nd the MSIP(Ministry of Siene, ICT nd Future Plnning), Kore, under the ICT Consiliene Cretive Progrm (IITP-2015-R ) supervised y the IITP(Institute for Informtion & ommunitions Tehnology Promotion). Referenes [1] D. J. Adi et l. Sw-store: A vertilly prtitioned dms for semnti we dt mngement. The VLDB Journl, , [2] M. Atre et l. Mtrix it loded: A slle lightweight join query proessor for rdf dt. In WWW 10, [3] C. Bizer nd A. Shultz. The erlin sprql enhmrk. Interntionl Journl on Semnti We nd Informtion Systems (IJSWIS), 1 24, [4] J. Broekstr et l. Sesme: A generi rhiteture for storing nd querying rdf nd rdf shem. In ISWC 02, [5] J. Cheng et l. Fg-index: Towrds verifition-free query proessing on grph dtses. In SIGMOD 07,