Fast and Robust Distributed Subgraph Enumeration

TL;DR

RADS is a novel asynchronous distributed system for subgraph enumeration that reduces memory and communication costs, improves robustness, and outperforms existing methods on large graphs.

Contribution

Introduces RADS, a robust asynchronous distributed framework with a region-grouped multi-round approach that minimizes data shuffling and enhances performance and scalability.

Findings

RADS outperforms state-of-the-art approaches in experiments.

Reduces network communication and memory usage.

Improves robustness and load balancing in distributed subgraph enumeration.

Abstract

We study the classic subgraph enumeration problem under distributed settings. Existing solutions either suffer from severe memory crisis or rely on large indexes, which makes them impractical for very large graphs. Most of them follow a synchronous model where the performance is often bottlenecked by the machine with the worst performance. Motivated by this, in this paper, we propose RADS, a Robust Asynchronous Distributed Subgraph enumeration system. RADS first identifies results that can be found using single-machine algorithms. This strategy not only improves the overall performance but also reduces network communication and memory cost. Moreover, RADS employs a novel region-grouped multi-round expand verify & filter framework which does not need to shuffle and exchange the intermediate results, nor does it need to replicate a large part of the data graph in each machine. This feature not only reduces network communication cost and memory usage, but also allows us to adopt simple strategies for memory control and load balancing, making it more robust. Several heuristics are also used in RADS to further improve the performance. Our experiments verified the superiority of RADS to state-of-the-art subgraph enumeration approaches.

Figures

Tables

Table 1. Table 1 : Profiles of datasets

Dataset($G$)	$\left|V\right|$	$\left|E\right|$	Avg. degree	Diameter
RoadNet	56M	717M	1.05	48K
DBLP	0.3M	1.0M	6.62	21
LiveJournal	4.8M	42.9M	18	17
UK2002	18.5M	298.1M	32	22

Table 2. Table 2 : Illustration of the Size of Index Files of Crystal

Dataset($G$)	Data Graph File Size	Index File Size
DBLP	13M	210M
RoadNet	2.3G	16.9G
LiveJournal	501M	6.5G
UK	4.1G	60G

Table 3. Table 3 : Compression on Roadnet(Mb)

Query	$q_1$	$q_2$	$q_3$	$q_4$	$q_5$	$q_6$	$q_7$	$q_8$
EL	264	13	65	81	136	183	-	-
ET	163	5	33	40	63	73	-	-

Table 4. Table 4 : Compression on DBLP (Gb)

Query	$q_1$	$q_2$	$q_3$	$q_4$	$q_5$	$q_6$	$q_7$	$q_8$
EL	0.3	0.2	4.5	3.2	17.6	7.6	5.3	4
ET	0.08M	0.06	1.1	0.7	3.8	1.3	0.9	0.8

Equations

$${BD}_{G_t}(v)=\underset{v^{\prime }\in V_{G_t}^b}{\min }dist(v,v^{\prime })$$

$${Span}_P(u)=\underset{u^{\prime }\in V_P}{\max }dist(u,u^{\prime })$$

$$E_{d{p}_i}^{cro}=\{(u_i,u_j)\in E_P|u_i\in P_{i-1},u_j\in d{p}_i.LF\}(\text{mbox}fori>0)$$

$$\mathcal{SC}(PL)=\sum _{d{p}_i\in PL}\frac{1}{(i+1{)}^{\rho }}\times (|E_{d{p}_i}^{sib}|+|E_{d{p}_i}^{cro}|)$$

$$\mathcal{SC}(PL)=\sum _{d{p}_i\in PL}[\frac{|E_{d{p}_i}^{sib}|+|E_{d{p}_i}^{cro}|}{(i+1{)}^{\rho }}+\frac{deg(d{p}_i.piv)}{(i+1)}]$$

$$proximity(v,rg)=\frac{|adj(v)\cap {\bigcup }_{v^{\prime }\in rg}adj(v^{\prime })|}{|adj(v)|}$$

Full text

1 Introduction

Subgraph enumeration is the problem of finding all occurrences of a query graph in a data graph. Its solution is a basis for many other algorithms and it finds numerous applications. This problem has been well studied under single machine settings [10][19]. However in the real world, the data graphs are often fragmented and distributed across different sites. This phenomenon highlights the importance of distributed systems of subgraph enumeration. Also, the increasing size of modern graph makes it hard to load the whole graph into memory, which further strengthens the requirement of distributed subgraph enumeration.

In recent years, several approaches and systems have been proposed [1, 21, 13, 15, 6, 5]. However, existing systems either need to exchange large intermediate results (e.g., [13],[15] and [21]), or copy and replicate large parts of the data graph on each machine (e.g., [1] and [6, 5]), or rely on heavy indexes (e.g., [18]). Both exchanging and caching large intermediate results and exchanging and caching large parts of the data graph will cause heavy burden on the network and on memory, in fact, when the graphs are large these systems tend to crash due to memory depletion. In addition, most of the current systems are synchronous, hence they suffer from synchronization delay, that is, the machines must wait for each other for the completion of certain processing tasks, making the overall performance equivalent to that of the slowest machine. More details about existing work can be found in Section 8.

It is observed in previous work [15, 18] that when the data graph is large, the number of intermediate results can be huge, making the network communication cost a bottleneck and causing memory crash. On the other hand, systems that rely on replication of large parts of the data graph or heavy indexes are impractical for large data graphs and low-end computer clusters. In this paper, we present RADS, a Robust Asynchronous Distributed Subgraph enumeration system. Different from previous work, our system does not need to exchange intermediate results or replicate large parts of the data graph. It does not rely on heavy indexes or suffer from synchronization delay. Our system is also more robust due to our memory control strategies and easy for load balancing.

To be specific, we make the following contributions:

1. (1)

We propose a novel distributed subgraph enumeration framework, where the machines do not need to exchange intermediate results, nor do they need to replicate large parts of the data graph. 2. (2)

We propose a method to identify embeddings that can be found on each local machine independent of other machines, and use single-machine algorithm to find them. This strategy not only improves the overall performance, but also reduces network communication and memory cost. 3. (3)

We propose effective memory control strategies to minimize the chance of memory crash, making our system more robust. Our strategy also facilitates workload balancing. 4. (4)

We propose optimization strategies to further improve the performance. These include (i) a set of rules to compute an efficient execution plan, (ii) a dynamic data structure to compactly store intermediate results. 5. (5)

We conduct extensive experiments which demonstrate that our system is not only significantly faster than existing solutions 111Except for some queries using [18], which relies on heavy indexes., but also more robust.

Paper Organization In Section 2, we present the preliminaries. In Section 3, we present the architecture and framework of our system RADS. In Section 4, we present algorithms for computing the execution plan. In Section 5, we present the embedding trie data structure to compress our intermediate results. Our memory control strategy is given in Section 6. We present our experiments in Section 7, discuss related work in Section 8 and conclude the paper in Section 9. Some proofs, detailed algorithms and auxiliary experimental results are given in the appendix.

2 Preliminaries

Data Graph & Query Graph Both the data graph and query graph (a.k.a query pattern) are assumed to be unlabeled, undirected, and connected graphs. We use $G$ = ($V_{G}$, $E_{G}$) and $P$ = ($V_{P}$, $E_{P}$) to denote the data graph and query graph respectively, where $V_{G}$ and $V_{P}$ are the vertex sets, and $E_{G}$ and $E_{P}$ are the edge sets. We will use data (resp. query) vertex to refer to vertices in the data (resp. query) graph. Generally, for any graph $g$, we use $V_{g}$ and $E_{g}$ to denote its vertex set and edge set respectively, and for any vertex $v$ in $g$, we use $adj(v)$ to denote $v$’s neighbour set in $g$ and use $deg(v)$ to denote the degree of $v$.

Subgraph Isomorphism Given a data graph $G$ and a query pattern $P$, $P$ is subgraph isomorphic to $G$ if there exists an injective function $f$: $V_{P}$ $\rightarrow$ $V_{G}$ such that for any edge ($u_{1}$, $u_{2}$) $\in$ $E_{P}$, there exists an edge ($f$($u_{1}$), $f$($u_{2}$)) $\in$ $E_{G}$. The injective function is also known as an embedding of $P$ in $G$ (or, from $P$ to $G$), and it can be represented as a set of vertex pairs ($u$, $v$) where $u$ $\in$ $V_{P}$ is mapped to $v$ $\in$ $V_{G}$. We will use $\mathbb{R}_{G}(P)$ to denote the set of all embeddings of $P$ in $G$.

The problem of subgraph enumeration is to find the set $\mathbb{R}_{G}(P)$. In the literature, subgraph enumeration is also referred to as subgraph isomorphism search [16][10][19] and subgraph listing [12][21].

Partial Embedding A partial embedding of graph $P$ in graph $G$ is an embedding in $G$ of a vertex-induced subgraph of $P$. A partial embedding is a full embedding if the vertex-induced subgraph is $P$ itself.

Symmetry Breaking A symmetry breaking technique based on automorphism is conventionally used to reduce duplicate embeddings [8]. As a result the data vertices in the final embeddings should follow a preserved order of the query vertices. We apply this technique in this paper by default and we will specify the preserved order when necessary.

Graph Partition & Storage Given a data graph $G$ and $m$ machines $\{M_{1},\dots,M_{m}\}$ in a distributed environment, a partition of $G$ is denoted $\{G_{1},G_{2},\dots,G_{m}\}$ where $G_{t}$ is the partition located in the $t^{th}$ machine $M_{t}$. In this paper, we assume each partition is stored as an adjacency-list. For any data vertex $v$, we assume its adjacency-list is stored in a single machine $M_{t}$ and we say $v$ is owned by $M_{t}$ (or resides in $M_{t}$). We call $v$ a foreign vertex of $M_{t}$ if $v$ is not owned by $M_{t}$. We say a data edge $e$ is owned by (or resides in) $M_{t}$ (denoted as $e\in E_{G_{t}}$) if either end vertex of $e$ resides in $M_{t}$. Note that an edge can reside in two different machines.

For any $v$ owned by $M_{t}$, we call $v$ a border vertex if any of its neighbors is owned by other machines than $M_{t}$. Otherwise we call it a non-border vertex. We use $V^{b}_{G_{t}}$ to denote the set of all border vertices in $M_{t}$.

3 RADS Architecture

In this section, we first present an overview of the architecture of ${{\tt RADS}}$, followed by the R-Meef framework of ${{\tt RADS}}$. We give a detailed implementation of R-Meef in Appendix B.

3.1 Architecture Overview

The architecture of ${{\tt RADS}}$ is shown in Figure 1. Given a query pattern $P$, within each machine, ${{\tt RADS}}$ first launches a process of single-machine enumeration (SM-E) and a daemon thread, simultaneously. After SM-E finishes, ${{\tt RADS}}$ launches a R-Meef thread subsequently. Note that the R-Meef threads of different machines may start at different time.

• •

Single-Machine Enumeration The idea of SM-E is to try to find a set of local embeddings using a single-machine algorithm, such as TurboIso[10], which does not involve any distributed processing. The subsequent distributed process only has to find the remaining embeddings. This strategy can not only boost the overall enumeration efficiency but also significantly reduce the memory cost and communication cost of the subsequent distributed process. Moreover the local embeddings can be used to estimate the space cost of a region group, which will help to effectively control the memory usage (to be discussed in Section 6).

We first define the concepts of border distance and span, which will be used to identify embeddings that can be found by SM-E.

Definition 1** (Border Distance)**

Given a graph partition $G_{t}$ and data vertex $v$ in $G_{t}$, the border distance of $v$ w.r.t $G_{t}$, denoted as ${{BD}}_{G_{t}}(v)$, is the minimum shortest distance between $v$ and any border vertex of $G_{t}$, that is

[TABLE]

where $dist(v,v^{\prime})$ is the shortest distance between $v$ and $v^{\prime}$.

Definition 2** (Span)**

Given a query pattern $P$, the span of query vertex $u$, denoted as ${Span}_{P}(u)$, is the maximum shortest distance between $u$ and any other vertex of $P$, that is

[TABLE]

Proposition 1

Given a data vertex $v$ of $G_{t}$ and a query vertex $u$ of $P$, if ${Span}_{P}(u)\leq{{BD}}_{G_{t}}(v)$, then there will be no embedding $f$ of $P$ in $G$ such that $f(u)=v$, and $f(u^{\prime})$ is not owned by $M_{t}$, where $u^{\prime}\in P$, $u^{\prime}\neq u$.

Proposition 1 states that if the border distance of $v$ is not smaller than the span of query vertex $u$, there will be no cross-machine embeddings (i.e., embeddings where the query vertices are mapped to data vertices residing in different machines) which map $u$ to $v$. The proof of Proposition 1 is in the Appendix A.1.

Let $u_{start}$ be the starting query vertex (namely, the first query vertex to be mapped) and $C(u_{start})$ be the candidate vertex set of $u_{start}$ in $G_{t}$. Let $C_{1}(u_{start})\subseteq C(u_{start})$ be the subset of candidates whose border distance is no less than the span of $u_{start}$. According to Proposition 1, any embedding that maps $u_{start}$ to a vertex in $C_{1}(u_{start})$ can be found using a single-machine subgraph enumeration algorithm over $G_{t}$, independent of other machines. In RADS, the candidates in $C_{1}(u_{start})$ will be processed by SM-E, and the other candidates will be processed by the subsequent distributed process. The SM-E process is simple, and we will next focus on the distributed process. For presentation simplicity, from now on when we say a candidate vertex of $u_{start}$, we mean a candidate vertex in $C(u_{start})-C_{1}(u_{start})$, unless explicitly stated otherwise.

The distributed process consists of some daemon threads and the subgraph enumeration thread:

• •

Daemon Threads listen to requests from other machines and support four functionalities:

(1) verifyE is to return the edge verification results for a given request consisting of vertex pairs. For example, given a request $\{(v_{0},v_{1})$, $(v_{2},v_{3})\}$ posted to $M_{1}$, $M_{1}$ will return $\{true,false\}$ if $(v_{0},v_{1})$ is an edge in $G_{1}$ while $(v_{2},v_{3})$ is not.

(2) fetchV is to return the adjacency-lists of the requested vertices of the data graph. The requested vertices sent to machine $M_{i}$ must reside in $M_{i}$.

(3) checkR is to return the number of unprocessed region groups (which is a group of candidate data vertices of the starting query vertex, see Section 3.2) of the local machine (i.e., the machine on which the thread is running).

(4) shareR is to return an unprocessed region group of the local machine to the requester machine. shareR will also mark the region group sent out as processed.

• •

R-Meef Thread is the core subgraph enumeration thread. When necessary, the local R-Meef thread sends verifyE requests and fetchV requests to the Daemon threads located in other machines, and the other machines respond to these requests accordingly.

Once a local machine finishes processing its own region groups, it will broadcast a checkR request to the other machines. Upon receiving the numbers of unfinished region groups from other machines, it will send a shareR request to the machine with the maximum number of unprocessed region groups. Once it receives a region group, it will process it on the local machine. checkR and shareR are for load balancing purposes only, and they will not be discussed further in this paper.

3.2 The R-Meef Framework

Before presenting the details of the R-Meef framework, we need the following definitions.

Definition 3** (embedding candidate)**

Given a partition $G_{t}$ of data graph $G$ located in machine $M_{t}$ and a query pattern $P$, an injective function $f_{G_{t}}$: $V_{P}$ $\rightarrow$ $V_{G}$ is called an embedding candidate (EC) of $P$ $w.r.t$ $G_{t}$ if for any edge $(u$, $u^{\prime})$ $\in$ $E_{P}$, there exists an edge $(f_{G_{t}}(u)$, $f_{G_{t}}(u^{\prime}))$ $\in$ $E_{G_{t}}$ provided either $f_{G_{t}}(u)$ $\in$ $V_{G_{t}}$ or $f_{G_{t}}(u^{\prime})$ $\in$ $V_{G_{t}}$.

We use $\widetilde{\mathbb{R}}_{G_{t}}(P)$ to denote the set of ECs of $P$ $w.r.t$ $G_{t}$. Note that for an EC $f_{G_{t}}$ and a query vertex $u$, $f_{G_{t}}(u)$ is not necessarily owned by $G_{t}$. That is, the adjacency-list of $f_{G_{t}}(u)$ may be stored in other machines. For any query edge $(u,u^{\prime})$, an EC only requires that the corresponding data edge $(f_{G_{t}}(u)$, $f_{G_{t}}(u^{\prime}))$ exists if at least one of $f_{G_{t}}(u)$ and $f_{G_{t}}(u^{\prime})$ resides in $G_{t}$. Therefore, an EC may not be an embedding. Intuitively, the existence of the edge $(f_{G_{t}}(u),f_{G_{t}}(u^{\prime}))$ can only be verified in $G_{t}$ if one of its end vertices resides in $G_{t}$. Otherwise the existence of the edge cannot be verified in $M_{t}$, and we call such edges undetermined edges.

Definition 4

Given an EC $f_{G_{t}}$ of query pattern $P$, for any edge $(u,u^{\prime})\in E_{P}$, we say $(f_{G_{t}}(u),f_{G_{t}}(u^{\prime}))$ is an undetermined edge of $f_{G_{t}}$ if neither $f_{G_{t}}(u)$ nor $f_{G_{t}}(u^{\prime})$ is in $G_{t}$.

Example 1

Consider a partition $G_{t}$ of a data graph $G$ and a triangle query pattern $P$ where $V_{P}=\{u_{0},u_{1},u_{2}\}$. The mapping $f_{G_{t}}=$ $\{(u_{0},v_{0})$, $(u_{0},v_{1})$, $(u_{0},v_{2})\}$ is an EC of $P$ in $G$ $w.r.t$ $G_{t}$ if $v_{0}\in V_{G_{t}}$, $v_{1}\in adj(v_{0})$ and $v_{2}\in adj(v_{0})$ and neither $v_{1}$ nor $v_{2}$ resides in $G_{t}$. $(v_{1},v_{2})$ is an undetermined edge of $f_{G_{t}}$.

Obviously if we want to determine whether $f_{G_{t}}$ is actually an embedding of the query pattern, we have to verify its undetermined edges in other machines. For any undetermined edge $e$, if its two end vertices reside in two different machines, we can use either of them to verify whether $e\in E_{G}$ or not. To do that, we need to send a verifyE request to one of the machines.

Note that it is possible that an undetermined edge is shared by multiple ECs. To reduce network traffic, we do not send verifyE requests once for each individual EC, instead, we build an edge verification index (EVI) and use it to identify ECs that share undetermined edges. We assume each EC is assigned an ID (We will discuss how to assign such IDs and how to build EVI in Section 5).

Definition 5** (edge verification index)**

Given a set $\widetilde{\mathbb{R}}_{G_{t}}(P)$ of ECs, the edge verification index (EVI) of $\widetilde{\mathbb{R}}_{G_{t}}(P)$ is a key-value map ${I}$ where

1. (1)

for any tuple $(e,IDs)\in{I}$,

• •

the key $e$ is a vertex pair $(v,v^{\prime})$.

• •

the value $IDs$ is the set of IDs of the ECs in $\widetilde{\mathbb{R}}_{G_{t}}(P)$ of which $e$ is an undetermined edge. 2. (2)

for any undetermined edge $e$ of $f_{G_{t}}\in$ $\widetilde{\mathbb{R}}_{G_{t}}(P)$, there exists a unique tuple in ${I}$ with $e$ as the key and the ID of $f_{G_{t}}$ in the value.

Intuitively, the EVI groups the ECs that share each undetermined edge together. It is straightforward to see:

Proposition 2

Given data graph $G$, query pattern $P$ and an edge verification index ${I}$, for any $(e,IDs)\in{I}$, if $e\notin E_{G}$, then none of the ECs corresponding to $IDs$ can be an embedding of $P$ in $G$.

Example 2

Consider two embedding candidates $f_{G_{t}}=$ $\{(u_{0},v_{0})$, $(u_{0},v_{1})$, $(u_{0},v_{2})\}$ and $f_{G_{t}}^{\prime}=$ $\{(u_{0},v_{3})$, $(u_{0},v_{1})$, $(u_{0},v_{2})\}$ of a triangle pattern $P$ of a data graph $G$ where $V_{P}=\{u_{0},u_{1},u_{2}\}$. Assuming $(v_{1},v_{2})$ is an undetermined edge, we can have an edge verification index: ${I}=\{(v_{1},v_{2})<f_{G_{t}},f_{G_{t}}^{\prime}>\}$ where $f_{G_{t}},f_{G_{t}}$ are represented by their IDs in ${I}$. If $(v_{1},v_{2})$ is verified non-existing, both $f_{G_{t}}$ and $f_{G_{t}}$ can be filtered out.

Like SEED and Twintwig, we decompose the pattern graph into small decomposition units.

Definition 6** (decomposition)**

A decomposition of query pattern $P$ is a sequence of decomposition units ${\mathcal{DE}}$ $=$ $(dp_{0}$, $\dots$, $dp_{l})$ where every $dp_{i}\in$ ${\mathcal{DE}}$ is a subgraph of $P$ such that

1. (1)

The vertex set of $dp_{i}$ consists of a pivot vertex ${piv}$ and a non-empty set ${LF}$ of leaf222In an abuse of the word “leaf”. vertices, all of which are vertices in $V_{P}$; and for every $u^{\prime}\in{LF}$, $({piv},u^{\prime})\in E_{P}$. 2. (2)

The edge set of $dp_{i}$ consists of two parts, $E_{dp_{i}}^{star}$ and $E_{dp_{i}}^{sib}$, where $E_{dp_{i}}^{star}$ $=$ $\bigcup_{u^{\prime}\in{LF}}$ $\{(dp_{i}.{piv},$ $u^{\prime})\}$ is the set of edges between the pivot vertex and the leaf vertices, and $E_{dp_{i}}^{sib}$ $=$ $\bigcup_{u,u^{\prime}\in dp_{i}.{LF}}$ $\{(u,u^{\prime})$ $\in$ $E_{P}\}$ is the set of edges between the leaf vertices. 3. (3)

$\bigcup_{dp_{i}\in{\mathcal{DE}}}(V_{dp_{i}})=V_{P}$, and for $i<j$, $V_{dp_{i}}\cap dp_{j}.{LF}=\emptyset$.

Note condition (3) in the above definition says the leaf vertices of each decomposition unit do not appear in the previous units. Unlike the decompositions in SEED [15] and TwinTwig [13], our decomposition unit is not restricted to stars and cliques, and $\bigcup_{dp_{i}\in{\mathcal{DE}}}(E_{dp_{i}})$ may be a proper subset of $E_{P}$.

Example 3

Consider the query pattern in Figure 2 (a), we may have a decomposition $(dp_{0}$, $dp_{1}$, $dp_{2}$, $dp_{3}$) where $dp_{0}.{piv}$ $=$ $u_{0}$, $dp_{0}.{LF}$ $=$ $\{u_{1}$, $u_{2}$, $u_{7}$ $\}$, $dp_{1}.{piv}$ $=$ $u_{1}$, $dp_{1}.{LF}$ $=$ $\{u_{3},u_{4}\}$, $dp_{2}.{piv}$ $=$ $u_{2}$, $dp_{2}.{LF}$ $=$ $\{u_{5}$, $u_{6}\}$, and $dp_{3}.piv=u_{0}$, $dp_{3}.{LF}=\{u_{8},u_{9}\}$. Note that the edge $(u_{4}$, $u_{5})$ is not in any decomposition unit.

Given a decomposition ${\mathcal{DE}}=(dp_{0}$, $\dots$, $dp_{l})$ of pattern $P$, we define a sequence of sub-query patterns $P_{0},\ldots,P_{l}$, where $P_{0}$ = $dp_{0}$, and for $i>0$, $P_{i}$ consists of the union of $P_{i-1}$ and $dp_{i}$ together with the edges across the vertices of $P_{i-1}$ and $dp_{i}$, that is, $V_{P_{i}}$ = $\bigcup_{j\leq i}V_{dp_{j}}$, $E_{P_{i}}$ = $\bigcup_{j\leq i}$ $E_{P_{j}}$ $\cup$ $\{(u_{i},u_{j})\in E_{P}|u_{i}\in P_{i-1},u_{j}\in dp_{i}.{LF}\}$. Note that (a) none of the leaf vertices of $dp_{i}$ can be in $P_{i-1}$; and (b) $P_{i}$ is the subgraph of $P$ induced by the vertex set $V_{P_{i}}$, and $P_{l}=P$. We say ${\mathcal{DE}}$ forms an execution plan if for every $i\in[1,l]$, the pivot vertex of $dp_{i}$ is in $P_{i-1}$. Formally, we have

Definition 7** (execution plan)**

A decomposition ${\mathcal{DE}}=(dp_{0}$, $\dots$, $dp_{l})$ of $P$ is an execution plan (${{PL}}$) if $dp_{i}.{piv}$ $\in$ $V_{P_{i-1}}$ for all $i\in[1,l]$.

For example, the decomposition in Example 3 is an execution plan.

Let ${{PL}}=(dp_{0}$, $\dots$, $dp_{l})$ be an execution plan. For each $dp_{i}$, we define

[TABLE]

We call the edges in $E_{dp_{i}}^{star}$, $E_{dp_{i}}^{sib}$ and $E_{dp_{i}}^{cro}$ the expansion edges, *sibling * edges, and cross-unit edges respectively. The sibling edges and cross-unit edges are both called verification edges.

Consider $dp_{0}$ in Example 3, we have $E_{dp_{0}}^{sib}$=$\{(u_{1},u_{2})\}$, $E_{dp_{0}}^{cro}$=$\emptyset$. For $dp_{2}$, we have $E_{dp_{2}}^{sib}$=$\{(u_{5},u_{6})\}$, $E_{dp_{2}}^{cro}$=$\{(u_{4},u_{5})\}$.

Note that the expansion edges of all the units form a spanning tree of $P$, and the verification edges are the edges not in the spanning tree.

With the above concepts, we are ready to present the R-Meef framework. Given query pattern $P$, data graph $G$ and its partition $G_{t}$ on machine $M_{t}$, R-Meef finds a set of embeddings of $P$ in $G_{t}$ according to an execution plan ${{PL}}$, which provides a processing order for the query pattern $P$. In our approach, each machine $M_{t}$ will evaluate $P_{0}$ in the first round, and based on the results in round i, it will evaluate the next pattern $P_{i+1}$ in the next round. The final results will be obtained when $P_{l}$ is evaluated in all machines (each machine computes a subset of the final embeddings, the union of which is the final set of embeddings of $P$ in $G$).

Moreover, in our approach, each machine $M_{t}$ starts by mapping $dp_{0}.{piv}$ (which is the $u_{start}$ in Section 3.1) to a candidate vertex of $dp_{0}.{piv}$ that resides in $M_{t}$. When the number of such candidate vertices is large, there is a possibility of generating too many intermediate results (i.e., ECs and embeddings of $P_{0}$, $\dots$ $P_{l}$). To prevent memory crash, we divide the candidate vertex set of $dp_{0}.{piv}$ into disjoint region groups ${{RG}}$ = $\{rg_{0}$, $\dots$, $rg_{h}\}$, and process each group separately.

The workflow of R-Meef is as follows:

1. (1)

From the vertices residing in $M_{t}$ , R-Meef divides the candidate vertices of $dp_{0}.{piv}$ into different region groups. Then it processes each group sequentially and separately. 2. (2)

For each region group, R-Meef processes one unit at a round based on the execution plan ${{PL}}$. In the $i^{th}$ round, the workflow can be illustrated in Figure 3.

In Figure 3, $\mathbb{R}_{G_{t}}(P_{i-1})$ represents the set of embedding of $P_{i-1}$ generated and cached from the last round. For the first round (i.e., round 0), $\mathbb{R}_{G_{t}}(P_{i-1})$ will be initialized as $\bigcup\{(dp_{0}.{piv},v)\}$ where $v$ is a candidate vertex of $dp_{0}.{piv}$. By expanding $\mathbb{R}_{G_{t}}(P_{i-1})$, we get all the ECs of $P_{i}$ $w.r.t$ $M_{t}$, i.e., $\widetilde{\mathbb{R}}_{G_{t}}(P_{i})$. After verification and filtering, we get all the embeddings of $P_{i}$ for this region group of $M_{t}$.

In each round, the expand and verify & filter processes work as follows:

• •

Expand Given an embedding $f$ of $P_{i-1}$ obtained from the previous round, $dp_{i}.{piv}$ has already been matched to a data vertex $v$ by $f$ since $dp_{i}.{piv}\in P_{i-1}$. By searching the neighborhood of $v$, we expand $f$ to find the ECs of $P_{i}$ containing $(dp_{i}.{piv}$, $v)$ $w.r.t$ $M_{t}$. It is worth noting that if $v$ does not reside in $M_{t}$, we have to fetch its adjacency-list from other machines. Different embeddings from previous round may share some common foreign vertices to fetch in order to expand. To reduce network traffic, for all the embeddings from last round, we gather all the vertices that need to be fetched and then fetch their adjacency-lists together by sending a single $fetchV$ request.

One important assumption here is that each machine has a record of the ownership information (i.e., which machine a data vertex resides in) of all the vertices. This record can be constructed offline as a map whose size is $|V|$, which can be saved together with the adjacency-list and takes one extra byte space for each vertex.

• •

Verify $\&$ Filter Upon having a set of ECs (i.e. $\widetilde{\mathbb{R}}_{G_{t}}(P_{i})$), we store them compactly in a embedding trie and build an EVI from them (the embedding trie and EVI will be further discussed in Section 5). Then we send a $verifyE$ request consisting of the keys of EVI, i.e., undetermined data edges, to other machines to verify their existence. After we get the verification results, each failed key indicates that the corresponding ECs can be filtered out. The output of the final round is the set of embeddings of query pattern $P$ found by $M_{t}$ for this region group.

Note that a detailed implementation and example of R-Meef is given in Appendix B. Although the idea of our framework is straightforward. However, in order to achieve the best performance, each critical component of it should be carefully designed. In the following sections, we tackle the challenges one by one.

4 Computing Execution Plan

It is obvious that we may have multiple valid execution plans for a query pattern and different execution plans may have different performance. The challenge is how to find the most efficient one among them ? In this section, we present some heuristics to find a good execution plan.

4.1 Minimizing Number of Rounds

Given query pattern $P$ and an execution plan ${{PL}}$, we have $|{{PL}}|+1$ rounds for each region group, and once all the rounds are processed we will get the set of final embeddings. Also, within each round, the workload can be shared. To be specific, a single undetermined edge $e$ may be shared by multiple ECs. If these embedding candidates are generated in the same round, the verification of $e$ can be shared by all of them. The same applies to the foreign vertices where the cost of fetching and memory space can be shared among multiple embedding candidates if they happen to be in the same round. Therefore, our first heuristic is to minimize the number of rounds (namely, the number of decomposition units) so as to maximize the workload sharing.

Here we present a technique to compute a query execution plan, which guarantees a minimum number of rounds. Our technique is based on the concept of maximum leaf spanning tree [7].

Definition 8

A maximum leaf spanning tree (MLST) of pattern $P$ is a spanning tree of $P$ with the maximum number of leafs (a leaf is a vertex with degree 1). The number of leafs in a MLST of $P$ is called the maximum leaf number of $P$, denoted $l_{P}$.

A closely related concept is minimum connected dominating set.

Definition 9

A connected dominating set (CDS) of $P$ is a subset $D$ of $V_{P}$ such that (1) $D$ is a dominating set of $P$, that is, any vertex of $P$ is either in $D$ or adjacent to a vertex in $D$, and (2) the subgraph of $P$ induced by $D$ is connected.

A minimum connected dominating set (MCDS) is a CDS with the smallest cardinality among all CDSs. The number of vertices in a MCDS is called the connected domination number, denoted $c_{P}$.

It is shown in [4] that $|V_{P}|=c_{P}+l_{P}$.

Theorem 1

Given a pattern $P$, any execution plan of $P$ has at least $c_{P}$ decomposition units, and there exists an execution plan with exactly $c_{P}$ decomposition units.

The proof of Theorem 1 is in the Appendix A.1.

Theorem 1 indicates that $c_{P}$ is the minimum number of rounds of any execution plan. The above proof provides a method to construct an execution plan with $c_{P}$ rounds from a MLST. It is worth noting that the decomposition units in the query plan constructed as in the proof have distinct pivot vertices.

Example 4

Consider the pattern $P$, it can be easily verified that the tree obtained by erasing the edges $(u_{1},u_{2})$, $(u_{3},u_{4})$, $(u_{4},u_{5})$, $(u_{5},u_{6})$ and $(u_{8},u_{9})$ is a MLST of $P$. Choosing $u_{0}$ as the root, we will get a minimum round execution plan ${{PL}}_{1}$=$\{dp_{0}$, $dp_{1}$, $dp_{2}\}$ where $dp_{0}.{piv}$ $=$ $u_{0}$, $dp_{0}.{LF}$ $=$ $\{u_{1}$, $u_{2}$, $u_{7}$, $u_{8}$, $u_{9}\}$, $dp_{1}.{piv}$ $=$ $u_{1}$, $dp_{1}.{LF}$ $=$ $\{u_{3},u_{4}\}$ and $dp_{2}.{piv}$ $=$ $u_{2}$, $dp_{2}.{LF}$ $=$ $\{u_{5},u_{6}\}$. If we choose $u_{1}$ as the root, we will get a different minimum-round execution plan ${{PL}}_{2}$=$\{dp_{0},dp_{1},dp_{2}\}$, where $dp_{0}.{piv}=u_{1}$, $dp_{0}.{LF}=\{u_{0},u_{3},u_{4}\}$, $dp_{1}.{piv}=u_{0}$, $dp_{1}.{LF}=\{u_{2}$, $u_{7}$ $u_{8},u_{9}\}$, $dp_{2}.{piv}=u_{2}$, $dp_{2}.{LF}=\{u_{5},u_{6}\}$

4.2 Minimizing the span of $dp_{0}.piv$

Given a pattern $P$, multiple execution plans may exist with the minimum number of rounds, while their $dp_{0}.piv$ can be different. When facing this case, here we present our second heuristic which is to choose the plan(s) whose $dp_{0}.piv$ have the smallest span. This strategy will maximize the number of embeddings that can be found using SM-E. Recall the RADS architecture where $dp_{0}.piv$ is the starting query vertex $u_{start}$, based on Proposition 1, we know that the more candidate vertices of $dp_{0}.piv$ can be processed in SM-E, the more workload can be separated from the distributed processing, and therefore the more communication cost and memory usage can be reduced.

Consider the pattern in Figure 4, the bold edges demonstrate a MLST based on which both $u_{3}$ and $u_{4}$ can be chosen as $dp_{0}.{piv}$. And the execution plans from them have the same number of rounds. However, ${Span}_{P}(u_{3})=2$ while ${Span}_{P}(u_{4})=3$. Therefore we choose the plan with $u_{3}$ as the $dp_{0}.{piv}$.

4.3 Maximizing Filtering Power

Given a pattern $P$, multiple execution plans may exist with the minimum number of rounds and their $dp_{0}.piv$ have the same smallest span. Here we use the third heuristic which is to choose plans with more verification edges in the earlier rounds. The intuition is to maximize the filtering power of the verification edges as early as possible. To this end, we propose the following score function $\mathcal{SC}({{PL}})$ for an execution plan ${{PL}}=\{dp_{0}$, $\dots$, $dp_{l}\}$:

[TABLE]

$|E_{dp_{i}}^{sib}|+|E_{dp_{i}}^{cro}|$ is the number of verification edges in round $i$, and $\rho$ is a positive parameter used to tune the score function. In our experiments we use $\rho=1$. The function $\mathcal{SC}({{PL}})$ calculates a score by assigning larger weights to the verification edges in earlier rounds (since $\frac{1}{(i+1)^{\rho}}>\frac{1}{(j+1)^{\rho}}$ if $i<j$).

Example 5

Consider the query plans ${{PL}}_{1}$ and ${{PL}}_{2}$ in Example 4. The total number of verification edges in these plans are the same. In ${{PL}}_{1}$, the number of verifications edges for the first, second and third round is 2, 1, 2 respectively. In ${{PL}}_{2}$, the number of verification edges for the three rounds is 1, 2, and 2 respectively. Therefore, we prefer ${{PL}}_{1}$. Using $\rho=1$, we can calculate the scores of the two plans as follows:

$\mathcal{SC}({{PL}}_{1})=$* $2/1+1/2+2/3$ $\approx 3.2$*

$\mathcal{SC}({{PL}}_{2})=$* $1/1+2/2+2/3$ $\approx 2.7$*

When several minimum-round execution plans have the same score, we use another heuristic rule to choose the best one from them: the larger the degree of the pivot vertex, the earlier we process the unit. The pivot vertex with a larger degree has a stronger power to filter unpromising candidates.

To accommodate this rule, we can modify the score function in (1) by adding another component as follows:

[TABLE]

To this end, we have a set of rules to follow when to compute the execution plan. Since the query vertex is normally very small. We can simply enumerate all the possible execution plans and choose the best according to those rules.

5 Embedding Trie

As stated before, to save memory, the intermediate results (which include embeddings and embedding candidates generated in each round) are stored a compact data structure called an embedding trie. Besides the compression, the challenges here are how to ensure each intermediate result has a unique ID in the embedding trie and the embedding trie can be easily maintained ?

Before we give our solution, we first define a matching order, which is the order following which the query vertices are matched in R-Meef. It is also the order the nodes in the embedding trie are organized.

Definition 10** (Matching Order)**

Given a query execution plan ${{PL}}$ $=$ $\{dp_{0}$, $\ldots$, $dp_{l}\}$ of pattern $P$, the matching order w. r. t ${{PL}}$ is a relation $\prec$ defined over the vertices of $P$ that satisfies the following conditions:

1. (1)

$dp_{i}.piv\prec$* $dp_{j}.piv$ if $i<j$;* 2. (2)

For any two vertices $u_{1}\in dp_{i}.{LF}$ and $u_{2}\in dp_{j}.{LF}$, $u_{1}\prec u_{2}$ if $i<j$. 3. (3)

For $i\in[0,l]$:

1. (i)

$dp_{i}.{piv}\prec u$* for all $u\in dp_{i}.{LF}$;* 2. (ii)

for any vertices $u_{1}$, $u_{2}\in dp_{i}.{LF}$ that are not the pivot vertices of other units, $u_{1}\prec u_{2}$ if $deg(u_{1})$ ¿ $deg(u_{2})$, or $deg(u_{1})=deg(u_{2})$ and the vertex ID of $u_{1}$ is less than that of $u_{2}$; 3. (iii)

if $u_{1}\in dp_{i}.{LF}$ is a pivot vertex of another unit, and $u_{2}\in dp_{i}.{LF}$ is not a pivot vertex of another unit, then $u_{1}\prec u_{2}$.

Intuitively the above relation orders the vertices of $P$ as follows: (a) Generally a vertex $u_{1}$ in $dp_{i}$ is before a vertex $u_{2}$ in $dp_{j}$ if $i<j$, except for the special case where $u_{1}\in dp_{i}.{LF}$ and $u_{2}=dp_{j}.piv$. In this special case, $u_{2}$ may appear in the leaf of some previous unit $dp_{k}$ ($k\leq i$), and it may be arranged before $u_{1}$ according to Condition (2) or Condition (3) (ii).

(b) Starting from $dp_{0}$, the vertex $dp_{0}.{piv}$ is arranged before all other vertices. For the leaf vertices of $dp_{0}$, it arranges those that are pivot vertices of other units before those that are not (Condition (3)(iii)), and for the former, it arranges them according to the ID of the units for which they are the pivot vertex333Note that no two units share the same pivot vertex. (Condition (1)); for the latter, it arranges them in descending order of their degree in the original pattern $P$, and if they have the same degree it arranges them in the order of vertex ID (Condition (3) (ii)). For each subsequent $dp_{i}$, the pivot vertex must appear in the leaf of some previous unit, hence its position has been fixed; and the leaf vertices of $dp_{i}$ are arranged in the same way as the leaf vertices of $dp_{0}$.

It is easy to verify $\prec$ is a strict total order over $V_{P}$. Following the matching order, the vertices of $P$ can be arranged into an ordered list. Consider the execution plan ${{PL}}_{1}$ in Example 4. The vertices in the query can be arranged as ($u_{0},u_{1},u_{2},u_{7},u_{8},u_{9},u_{3},u_{4},u_{5},u_{6}$) according to the matching order.

Let ${{PL}}=\{dp_{0}$, $\ldots$, $dp_{l}\}$ be an execution plan, $P_{i}$ be the subgraph of $P$ induced from the vertices in $dp_{0}\cup\cdots\cup dp_{i}$ (as defined in Section 3.2), and $\mathbb{R}$ be a set of results (i.e., embeddings or embedding candidates) of $P_{i}$. For easy presentation, we assume the vertices in $P_{i}$ have been arranged into the list $u^{0},u^{1},\ldots,u^{n}$ by the matching order, that is, the query vertex at position $j$ is $u^{j}$. Then each result of $P_{i}$ can be represented as a list of corresponding data vertices. These lists can be merged into a collection of trees as follows:

1. (1)

Initially, each result $f$ is treated as a tree $T_{f}$, where the node at level $j$ stores the data vertex $f(u^{j})$ for $j\in[0,n]$, and the root is the node at level 0. 2. (2)

If multiple results map $u^{0}$ to the same data vertex, merge the root nodes of their trees. This partitions the results in $\mathbb{R}$ into different groups, each group will be stored in a distinct tree. 3. (3)

For each newly merged node ${\mathcal{N}}$, if multiple children of ${\mathcal{N}}$ correspond to the same vertex, merge these children into a single child of ${\mathcal{N}}$. 4. (4)

Repeat step (3) untill no nodes can be merged.

The collection of trees obtained above is a compact representation of the results in $\mathbb{R}$. Each leaf node in the tree uniquely identifies a result.

The embedding trie is a collection of similar trees. However, since the purpose of the embedding trie is to save space, we cannot get it by merging the result lists. Instead, we will have to construct it by inserting nodes one by one when results are generated, and removing nodes when results are eliminated. Next we formally define embedding trie and present the algorithms for the maintenance of the embedding trie.

5.1 Structure of the Embedding Trie

Definition 11** (Embedding Trie)**

Given a set $\mathbb{R}$ of results of $P_{i}$, the embedding trie of $\mathbb{R}$ is a collection of trees used to store the results in $\mathbb{R}$ such that:

1. (1)

Each tree represents a set of results that map $u^{0}$ to the same data vertex. 2. (2)

Each tree node ${\mathcal{N}}$ has

• •

v*: a data vertex*

• •

parentN*: a pointer pointing to its parent node (the pointer of the root node is null).*

• •

childCount*: the number of child nodes of ${\mathcal{N}}$.* 3. (3)

If two nodes have the same parent, then they store different data vertices. 4. (4)

Every leaf-to-root path represents a result in $\mathbb{R}$, and every result in $\mathbb{R}$ is represented as a unique leaf-to-root path. 5. (5)

If we divide the tree nodes into different levels such that the root nodes are at level 0, the children of the root nodes are at level 1 and so on, then the tree nodes at level $j$ ($j\in[0,1]$) store the set of values $\{f(u^{j})|f\in$ $\mathbb{R}$ $\}$.

Example 6

Consider $P_{0}$ in Example 1, where the vertices are ordered as $u_{0},u_{1},u_{2}$ according to the matching order. There are three ECs of $P_{0}$: $(v_{0},v_{1},v_{2})$, $(v_{0},v_{1},v_{9})$ and $(v_{0},v_{9},v_{11})$. These results can be stored in a tree shown in Figure 5(a). When the second EC is filtered out, we have $\mathbb{R}_{G_{t}}(P_{0})$ compressed in a tree as shown in Figure 5(b). The first EC can be expanded to an EC of $P_{1}$ (where the list of vertices of $P_{1}$ are $u_{0},u_{1},u_{2},u_{3},u_{4}$), which is as shown in Figure 5(c).

Although the structure of embedding trie is simple, it has some nice properties:

• •

Compression Storing the results in the embedding trie saves space than storing them as a collection of lists.

• •

Unique ID For each result in the embedding trie, the address of its leaf node in memory can be used as the unique ID.

• •

Retrieval Given a particular ID represented by a leaf node, we can easily follow its pointer $parentN$ step-by-step to retrieve the corresponding result.

• •

Removal To remove a result with a particular ID, we can remove its corresponding leaf node and decrease the $childCount$ of its parent node by 1. If $ChildCount$ of this parent node reaches 0, we remove this parent node. This process recursively affects the ancestors of the leaf node.

5.2 Maintaining the embedding trie

Recall that in Algorithm 4, given an embedding $f$ of $P_{i-1}$, the function $expandEmbedTrie$ is used to search for the ECs of $dp_{i}$ within the neighbourhood of the mapped data vertex of $v_{piv}$, where $v_{piv}=f(dp_{i}.{piv})$. Moreover, the $expandEmbedTrie$ function handles the task of expanding the embedding trie ${\mathcal{ET}}$ by concatenating $f$ with each newly found EC of $dp_{i}$. If an EC is filtered out or if an embedding cannot be expanded to a final result, the function must remove it from ${\mathcal{ET}}$. Now we present the details of the $expandEmbedTrie$ function in Algorithm 1.

When $dp_{i}.{piv}$ is mapped to the data vertex $v=f(dp_{i}.{piv})$ by an embedding $f$ of $P_{i-1}$, Algorithm 1 uses a backtracking approach to find the ECs of $P_{i}$ within the neighbourhood of $v$. The recursive procedure is given in the subroutine $adjEnum$. In each round of the recursive call, $adjEnum$ tries to match $u^{\prime}$ to a candidate vertex $v$ and add $(u^{\prime}$,$v)$ to $f$, where $u^{\prime}$ is a query vertex in $dp_{i}.{LF}$. When $f$ is expanded to an EC of $P_{i}$, which means an EC of $dp_{i}$ is concatenated to the original $f$, we add it into ${\mathcal{ET}}$ by chaining up the corresponding embedding trie nodes. If $f$ cannot be expanded into an EC of $P_{i}$, we will remove it from ${\mathcal{ET}}$.

Lines 1 to 9 of Algorithm 1 compute the candidate set for each $u\in dp_{i}.{LF}$ as the intersection of the neighbor set of $v=f(dp_{i}.{piv})$ and the neighbor set of each $f(u^{\prime})$, where $(u^{\prime},u)$ is a cross-unit edge and $f(u^{\prime})$ is in $M_{t}$. If any of the candidate sets is empty, it removes $f$ from ${\mathcal{ET}}$. Otherwise it passes on the next query vertex $u$ and the ID of $f$ (which is a node in ${\mathcal{ET}}$) to the recursive subroutine $adjEnum$.

The subroutine $adjEnum$ is given in Algorithm 2. It plays the same roles as the SubgraphSearch procedure in the backtracking framework [16]. In Line 1, $adjEnum$ creates an local variable $\mathcal{F}_{current}$ with default value $false$. The value indicates whether $f$ can be extended to an EC of $P_{i}$. For the leaf vertex $u$, $adjEnum$ first creates a copy $C_{r}(u)$ of $C(u)$, and then refines the candidate vertex set $C_{r}(u)$ by considering every sibling edge $(u,u^{\prime})$ where $u^{\prime}$ has already been mapped by $f$ to $f(u^{\prime})$. If $f(u^{\prime})$ resides in $M_{t}$, $C_{r}(u)$ is shrank by an intersection with $adj(f(u^{\prime}))$ (Line 2 to 5). Then, for each vertex $v$ in the refined set $C_{r}(u)$, it first initializes a flag $\mathcal{E}$ with the value $true$ (Line 7), this value indicates whether $u$ can be potentially mapped to $v$. Then if $v$ resides in $M_{t}$ it will check every verification edge $(u,u^{\prime})$ where $u^{\prime}$ has been mapped to see if $(v,f(u^{\prime}))$ exists, if one of such edge does not exist, it will set $\mathcal{E}$ to false (Lines 8 to 11), meaning $u$ cannot be mapped to $v$. This part (Lines 7 to 11) is like the IsJoinable function in the backtracking framework [16].

If $\mathcal{E}$ is still true after the local verification, we add $(u$, $v)$ to $f$ (Line 13). Then we create a new trie node ${\mathcal{N}}^{\prime}$ for $v$ with ${\mathcal{N}}$ as its parentN (Line 14, 15). After that, if $f$ grows to an EC of $P_{i}$ , then for each undetermined edge $e$ of $f$ (both end vertices are not in the local machine), we add ${\mathcal{N}}^{\prime}$ to ${I}[e]$ (Line 17, 18). We also set the $\mathcal{F}_{current}$ as true (Line 19). If $f$ is not an EC of $P_{i}$, which means there are still leaf vertices of $dp_{i}$ not matched, we get the next leaf vertex $u^{\prime}$ (Line 21), and launch a recursive call of $adjEnum$ by passing it ${\mathcal{N}}^{\prime}$ and $u^{\prime}$ (Line 22). We record the return value from its deeper $adjEnum$ as $\mathcal{F}_{deeper}$. If $\mathcal{F}_{deeper}$ is true after all the recursive calls, which means there are ECs with $v$ mapped to $u$ in $f$, we increase $childCount$ of the parentNode ${\mathcal{N}}$ and add the newly created ${\mathcal{N}}^{\prime}$ to as a child of ${\mathcal{N}}$ in ${\mathcal{ET}}$ (Line 23 to 25). Then we backtrack by removing $(u,v)$ from $f$, so that we can try to map $u$ to another candidate vertex in $C_{r}(v)$.

After we tried all the candidate vertices of $C_{r}(u)$, we return the value of $\mathcal{F}_{current}$ (Line 27).

Note that the edge verification index ${I}$ is maintained during the expansion process.

6 Memory Control Strategies

This section focuses on the challenge of robustness of R-Meef. Since R-Meef still caches fetched foreign vertices and intermediate results in memory, memory consumption is still a critical issue when the data graph is large. We propose a grouping strategy to keep the peak memory usage under the memory capacity of the local machine.

Our idea is to divide the candidate vertices of the first query vertex $dp_{0}.{piv}$ into disjoint groups and process each group independently. In this way, the overall cached data on each machine will be divided into several parts, where each part is no larger than the available memory $\Phi$.

A naive way of grouping the candidate vertices is to divide them randomly. However, random grouping of the vertices may put vertices that are “dissimilar” to each other into the same group, potentially resulting in more network communication cost. Consider the data graph in Figure 6. Suppose the candidate vertex set is $\{v_{0}$,$v_{1}$,$v_{2}$, $v_{3}\}$. If we divide it into two groups $\{v_{0},v_{1}\}$ and $\{v_{2},v_{3}\}$, then because $v_{0}$ and $v_{1}$ share most neighbours, there is a good chance for the ECs of $dp_{0}$ generated from $v_{0}$ and $v_{1}$ to share common verification edges, and share common foreign vertices that need to be fetched (e.g., if $dp_{1}.{piv}$ is mapped to $v_{5}$ by ECs originated from $v_{0}$ and $v_{1}$, and $v_{5}$ is not on the local machine). However, if we partition the candidate set into $\{v_{0},v_{2}\}$ and $\{v_{1},v_{3}\}$, then there is little chance for such sharing.

Our goal is to find a way to partition the candidate vertices into groups so that the chance of edge verification sharing and foreign vertices sharing by the results in each group is maximized.

Let $C\equiv C(dp_{0}.{piv})$ be the candidate set of $dp_{0}.{piv}$, and $\Phi$ be the available memory. Our method is to generate the groups one by one as follows. First we pick a random vertex $v\in C$ and let $rg=\{v\}$ be the initial group. If the estimated memory requirement of the results originated from $rg$, denoted $\phi(rg)$ (we will discuss memory estimation shortly), is less than $\Phi$, we choose another candidate vertex in $C-rg$ that has the greatest proximity to $rg$ and add it to $rg$; if $\phi(rg)$ ¿ $\Phi$ we remove the last added vertex from $rg$. This generates the first group. For the remaining candidate vertices we repeat the process, until all candidate vertices are divided into groups. The detailed algorithm is given in the Algorithm 3. Here an important concept is the the proximity of a vertex $v$ to a group of vertices, and we define it as the percentage of $v^{\prime}$s neighbors that are also neighbors of some vertex in $rg$, that is,

[TABLE]

Intuitively the vertices put into the same group are within a region - each time we will choose a new vertex that has a distance of at most 2 from one of the vertices already in the group (unless there are no such vertices). Therefore we call the group a region group.

Estimating memory usage In our system, the main memory consumption comes from the intermediate results and the fetched foreign vertices. The space cost of other data structures is trivial.

Consider the set of intermediate results $\mathcal{R}$ originated from the group $rg\subseteq C$. Recall that all results originated from the same candidate vertex of $dp_{0}.{piv}$ are stored in the same tree, while any results originated from different candidate vertices are stored in different trees. Therefore, if we know the space cost of the results originated from every candidate vertex, we can add them together to obtain the space cost of all results originated from $rg$.

To estimate the space cost of the results originated from a single vertex, we use the average space cost of local embeddings of a candidate vertex $v\in C_{1}(u_{start})$ in embedding trie format, which can be obtained when we conduct SM-E. Recall that for each $v$ of $C_{1}(u_{start})$ in SM-E, we find the local embeddings originated from $v$ following a backtracking approach. In each recursive step of the backtracking approach, we may record the number of candidate vertices that are matched to the corresponding query vertex. The sum of all steps will be the number of trie nodes if we group the those local embeddings into embedding trie. Based on the sum, we know the space cost of local embeddings originating from $v$ in the format of embedding trie. .

Next, we consider the space cost of the fetched foreign vertices in each round. Recall that when expanding the embeddings of $P_{i-1}$ to ECs of $P_{i}$, we only need to fetch vertex $v$ if there exists $f\in{{{R}_{G_{t}}({P_{i-1}})}}$ such that $f(dp_{i}.{piv})=v$. In the worst case, for every candidate vertex $v$ of $dp_{i}.{piv}$, there exists some $f\in{{{R}_{G_{t}}({P_{i-1}})}}$ which maps $dp_{i}.{piv}$ to $v$, and none of these candidate vertices of $dp_{i}.{piv}$ resides locally. Therefore the number of data vertices that need to be fetched equals to $|C(dp_{i}.{piv})|$ in the worst case.

In practice, the space cost of $C(dp_{i}.{piv})$ is usually small compared with that of the intermediate results, and we can allocate a certain amount of memory for caching the fetched data vertices. Note that when more data vertices need to be fetched, we may release some previously cached data vertices if necessary. Therefore we can ignore the space cost of the fetched data vertices when we estimate the memory cost of each region group.

7 Experiment

In this section, we present our experimental results.

Environment We conducted our experiments in a cluster platform where each machine is equipped with Intel CPU with 16 Cores and 16G memory. The operating system of the cluster is Red Hat Enterprise Linux 6.5.

Algorithms We compared our system with four state-of-the-art distributed subgraph enumeration approaches:

• •

PSgL [21], the algorithm using graph exploration originally based on Pregel.

• •

TwinTwig [13], the algorithm using joining approach originally based on MapReduce.

• •

SEED [15], an upgraded version of TwinTwig while supporting clique decomposition unit.

• •

Crystal [18], the algorithm relying on clique-index and compression and originally using MapReduce.

We implemented our approach in C++ with the help of Mpich2 [9] and Boost library [20]. We used Boost.Asio to achieve the asynchronous message listening and passing. We used TurboIso[10] as our SM-E processing algorithm.

The performance of distributed graph algorithms varies a lot depending on different programming languages and different underline distributed engine and file systems [3]. It is not fair enough to simply compare our approach with the Pregel-based PSgL or other Hadoop-based approaches. Therefore to achieve a fair comparison, we implemented PSgL, TwinTwig and SEED using C++ with MPI library. For Crystal, we chose to use the original program provided by its authors because our experiments with TwinTwig and SEED indicate that our implementation and the original implementation over Hadoop showed no significant difference in terms of performance. In memory, we loaded the data graph in each node in the format of adjacency-list for RADS, PSgL and TwinTwig. In order to support the clique decomposition unit of SEED, we also loaded the edges in-memory between the neighbours of a vertex along with the adjacency-list of the vertex.

Dataset & Queries We used four real datasets in our experiments: DBLP, RoadNet, LiveJournal and UK2002. The profiles of these data sets are given in Table 1. The diameter in Table 1 is the longest shortest path between any two data vertices. We partitioned each data graph using the multilevel k-way partition algorithm provided by Metis [11]. DBLP is a relatively small data graph which can be loaded into memory without partitioning, however, we still partition it here. One may argue when the data graph is small, we can use single-machine enumeration algorithms. However, our purpose of using DBLP here is not to test which algorithm is better when the graph can be loaded as a whole, but is to test whether the distributed approaches can fully utilize the memory when there is enough space available.

RoadNet is a larger but much sparser data graph than the others, consequently the number of embeddings of each query is smaller. Therefore it can be used to illustrate whether a subgraph enumeration solution has good filtering power to filter out false embeddings early. In contrast, the two denser data graphs, liveJournal and UK2002, are used to test the algorithms’ ability to handle denser graphs with huge numbers of embeddings.

On disk, our data graphs are stored in plain text format where each line represents an adjacency-list of a vertex. The approach of Crystal relies on the clique-index of the data graph which should be pre-constructed and stored on disk. In Table 2, we present the disk space cost of the index files generated by the program of Crystal (M for Mega Bytes, G for Giga Bytes).

The queries we used are given in Figure 7.

We evaluate the performance, measured by time elapsed and communication cost, of the five approaches in Section 7.1. The cluster we used for this experiment consists of 10 nodes. Due to space limit, more experimental results, including execution plan evaluation and scalability test etc., are presented in Appendix C.

7.1 Performance Comparison

We compare the performance of five subgraph enumeration approaches by measuring the time elapsed (in seconds) and the volume of exchanged data of processing each query pattern. The results of DBLP, RoadNet, LiveJournal and UK2002 are given in 8, Figure 9, Figure 10 and Figure 11 , respectively. We mark the result as empty when the test fails due to out-of-memory errors. When any bar reaches the upper bound, it means the corresponding values is beyond the upper bound value shown in the chart.

Exp-1:RoadNet The results over the RoadNet dataset are given in Figure 8. As can be seen from the figure, RADS and PSgL are significantly faster than the other three methods (by more than 1 order of magnitude). RADS and PSgL are using graph exploration while the others are using join-based methods. Therefore, both RADS and PSgL demonstrated efficient filtering power. Since join-based methods need to group the intermediate results based on keys so as to join them together, the performance was significantly dragged down when dealing with sparse graphs compared with RADS and PSgL.

It is worth noting that PSgL was verified slower than TwinTwig and SEED in [13][15]. This may be because the datasets used in TwinTwig and SEED are much denser than RoadNet, hence a huge number of embeddings will be generated. The grouped intermediate results of TwinTwig and SEED significantly reduced the cost of network traffic. Another interesting observation is that although Crystal has heavy indexes, its performance is much worse than PSgL and RADS. The reason is that the number of cliques in RoadNet is relatively small considering the graph size.

Moreover, there are no cliques with more than two vertices in queries $q_{1}$, $q_{3}$, $q_{6}$, $q_{7}$ and $q_{8}$. In such cases,

the clique index cannot help to improve the performance.

As shown in Figure 8(b), the communication cost is not large for any of the approaches (less than 5M for most queries). In particular, for RADS, the communication cost is almost 0 which is mainly because most data vertices can be processed by SM-E, as such no network communication is required.

Exp-2:DBLP The result over DBLP is shown in Figure 9. As aforementioned, DBLP is smaller but much denser than RoadNet. The number of intermediate results generated in DBLP are much larger than that in RoadNet, as implied by the data communication cost shown in Figure 9 (b). Since PSgL does not consider any compression or grouping over intermediate results, the communication cost of PSgL is much higher than the other approaches (more than 200M for queries after $q_{4}$). Consequently, the time delay due to shuffling the intermediate results caused bad performance for PSgL. However, PSgL is still faster than SEED and TwinTwig. This may be because the time cost of grouping intermediate results of TwinTwig and SEED is heavy as well. It is worth noting that the communication cost of our RADS is quite small (less than 5M). This is because of the caching strategy of RADS where most foreign vertices are only fetched once and cached in the local machine. If most vertices are cached, there will be no further communication cost. The time efficiency of RADS is better than Crystal even for queries $q_{2}$,$q_{4}$ and $q_{5}$ where the triangle crystal can be directly loaded from index without any computation.

Exp-3:LiveJournal As shown in Figure 10, for LiveJournal, SEED, TwinTwig and PSgL start becoming impractical for queries from $q_{3}$ to $q_{8}$. It took them more than 10 thousand seconds in order to process each of those queries. Due to the huge number of intermediate results generated, the communication cost increased significantly as well, especially for PSgL whose communication cost was beyond control when the query vertices reach 6. The method of Crystal achieved good performance for queries $q_{2}$, $q_{4}$ and $q_{5}$. This is mainly because Crystal simply retrieved the cached embeddings of the triangle to match the vertices $(u_{0},u_{1},u_{2})$ of those 3 queries. However, when dealing with the queries with no good crystals ($q_{6}$, $q_{7}$ and $q_{8}$), our method significantly outperformed Crystal. One important thing to note is that the other three methods (SEED, TwinTwig and PSgL) are sensitive to the end vertices, such as $u_{5}$ in $q_{5}$. Both time cost and communication cost increased significantly from $q_{4}$ to $q_{5}$. RADS processes those end vertices last by simply enumerating the combinations without caching any results related to them. The end vertices within Crystal will be bud vertices which only requires simple combinations. As indicated by query $q_{5}$ where their processing time increased slightly from that of $q_{4}$, RADS and Crystal are nicely tuned to handle end vertices.

Exp-4:UK2002 As shown in Figure 11, TwinTwig, SEED and PSgL failed the tests of queries after $q_{3}$ due to memory failure caused by huge number of intermediate results. The communication cost of all other methods are significantly larger than RADS (more than 2 orders of magnitude), we omit the chart for communication cost here. Similar to that of LiveJournal, the processing time of Crystal is better than that of RADS for the queries with cliques. This is because Crystal directly retrieves the embeddings of the cliques from the index. However, for queries without good crystals, our approach demonstrates better performance. As shown in Table 2, the index files of Crystal is more than 10 times larger than the original data graph.

Another advantage of RADS over Crystal is our memory control strategies ensures it is more robust: we tried to set a memory upper bound of 8G and test query $q_{6}$, Crystal starts crashing due to memory leaks, while RADS successfully finished the query for this test.

8 Related Work

The works most closely related to ours are TwinTwig [13], SEED [15] and PSgL [21]. Both [13] and [15] use multi-round two-way joins. [13] uses the same data partitioning as in our work, and it decomposes the query graph $P$ into a set of small trees ${dp_{0},\ldots,dp_{k}}$ such that the union of these trees is equal to $P$. Since the decomposition units are trees, a set of embeddings of $dp_{i}$ can be obtained on each machine without consulting other machines, and the union of the embeddings on all machines is the set of all embeddings of $dp_{i}$ over $G$. In the first round, the embeddings of $dp_{0}$ and $dp_{1}$ are joined to obtain that of $P_{1}$; in each subsequent round, the embeddings of $P_{i-1}$ and $dp_{i}$ are joined to obtain that of $P_{i}$. Since the embeddings of $P_{i-1}$ on one machine must be joined with the embeddings of $dp_{i}$ on every machine, all the intermediate results (i.e., embeddings of $P_{i-1}$ and $dp_{i}$) must be cached and then shuffled based on the join key and re-distributed to the machines. Synchronization is necessary since shuffling and re-distribution can only start when all machines have the intermediate results ready. [15] is similar to [13], except that it allows decomposition units to be cliques as well as trees, and it uses bushy join rather than left-deep joins444There are independent optimization strategies in each paper, of course.. To compute the intermediate results for these units, it adopts a slightly different data partition strategy: it uses star-clique-preserved partitions. Both TwinTwig and SEED may generate huge intermediate results, and shuffling, re-distribution and synchronization cost a lost of time. Our approach is different in that we do not use joins, instead we use expand-verify-filter on each machine, as such we generate less intermediate results, and we do not need to re-distribute them to different machines.

PSgL [21] is based on Pregel [17]. It maps the query vertices one at a time following breath-first traversal, so that partial matches are expanded repeatedly until the final results are obtained. In this way it avoids explicit joins similar to our approach. However, there are important differences between PSgL and our system (RADS). (1) In each step of expansion, PSgL needs to shuffle and send the partial matches (intermediate results) to other machines, while RADS does not need to do so. (2) PSgL stores each (partial) match as a node of a static result tree, while RADS stores the results in a dynamic and compact data structure. (3) There is no memory control in PSgL.

Also closely related to our work are [6] and [5], which introduce systems for parallelizing serial graph algorithms, including (but not limited to) subgraph isomorphism search algorithms. These systems partition the data graph into different machines, but do not partition the query graph. Each machine evaluates the query pattern on its own machine using a serial algorithm (e.g., VF2) independently of others, but before that it must copy parts of the data graph from other machines. These parts of the graph are determined as follows. For each boundary vertex $v$ on the current machine, it copies the nodes and edges within a distance $d$ from $v$, where $d$ is the diameter of the query graph. The final results are obtained by collecting the final results from all machines. Obviously, if the query graph diameter is large, and the data graph diameter is small (e.g., those of social network graphs), or there are many boundary vertices involved, then the entire partition of the neighboring machine may have to be fetched. This will generate heavy network traffic as well as burden on the memory of the local machine.

The work [1] treats the query pattern as a conjunctive query, where each predicate represents an edge, and computes the results as a multi-way join in a single round of map and reduce. As observed in [14], the problem with this approach is that most edges have to duplicated over several machines in the map phase, hence there is a scalability problem when the query pattern is complex.

Qiao et al [18] represent the set $I_{P}$ of all embeddings of pattern $P$ in a compressed form, $code(I_{P})$, based on a minimum vertex cover of $P$. It decomposes the query graph $P$ into a core $core(P)$ and a set of so-called crystals $\{p_{1},\ldots,p_{k}\}$, such that $code(I_{P})$ can be obtained by joining the compressed results of $core(P)$ and $\{p_{1},\ldots,p_{k}\}$. This join process can be parallelized in map-reduce. The compressed results of $core(P)$ and the crystals can be obtained from the compressed results of components of $P$. To expedite query processing, it builds an index of all cliques of the data graph, as shown in Table 2. Although no shuffling of intermediate results is required, the indexes of [18] can be many times larger than the data graph, and computing/maintaining such big indexes can be very expensive, making it less practical.

BigJoin, one of the algorithms proposed in [2], treats a subgraph query as a join of $|E_{P}|$ binary relations where each relation represents an edge in $P$. Similar to RADS and PSgL, it generates results by expanding partial results a vertex at a time, assuming a fixed order of the query vertices. BigJoin targets achieving worst-case optimality. Different from our work, it still needs to shuffle and exchange intermediate results, and therefore synchronization before that.

9 Conclusion

We presented a practical asynchronous subgraph enumeration system ${{\tt RADS}}$ whose core is based on a new framework R-Meef(region-grouped multi-round expand verify $\&$ filter). By processing the data vertices far away from the border using the single-machine algorithms, we isolated a large part of vertices which does not have to involve in the distributed process. By passing verification results of foreign edges and adjacency-list of foreign vertices, RADS significantly reduced the network communication cost. We also proposed a compact format to store the generated intermediate results. Our query execution plan and several memory control strategies including foreign vertex caching and region groups are designed to improve the efficiency and robustness of RADS. Our experiment results have verified the superiority of RADS compared with state-of-the-art subgraph enumeration approaches.

Appendix A Proofs

A.1 Proof of Proposition 1

Proof A.2**.**

Suppose there is an embedding $f$ such that $f(u)=v$, $f(u^{\prime})=v^{\prime}$. We show $dist(v,v^{\prime})\leq{{BD}}_{G_{t}}(v)$, therefore $v^{\prime}$ must be on $M_{t}$. Any shortest path from $u$ to $u^{\prime}$ will be mapped by $f$ to a path in $G$, therefore $dist(v,v^{\prime})\leq dist(u,u^{\prime})$ $\leq{Span}_{P}(u)$. By assumption, ${Span}_{P}(u)\leq{{BD}}_{G_{t}}(v)$, therefore $dist(v,v^{\prime})\leq{{BD}}_{G_{t}}(v)$.

A.2 Proof of Theorem 1

Proof A.3**.**

Suppose $\{dp_{0},\ldots,dp_{k}\}$ is an execution plan. The plan has $k+1$ decomposition units. Clearly the pivot vertices of the decomposition units form a connected dominating set of $P$. Therefore, $k+1\geq c_{P}$. This proves any execution plan has at least $c_{P}$ decomposition units.

*Now suppose $T$ is a MLST of $P$. From $|V_{P}|=c_{P}+l_{P}$ we know the number of non-leaf vertices in $T$ is $c_{P}$. We can construct an execution plan by choosing one of the non-leaf vertices $v_{0}$ as $dp_{0}.{piv}$, and all neighbors of $v_{0}$ in $T$ as the vertices in $dp_{0}.{LF}$. Regarding $v_{0}$ as the root of the spanning tree $T$, we then choose each of the non-leaf children $v_{i}$ of $v_{0}$ in $T$ as the pivot vertex of the next decomposition unit $dp_{i}.{piv}$, and all children of $v_{i}$ as the vertices in $dp_{i}.{LF}$. Repeat this process until every non-leaf vertex of $T$ becomes the pivot vertex of a decomposition unit. This decomposition has exactly $c_{P}$ units, and it forms an execution plan. This shows that there exists an execution plan with $c_{P}$ decomposition units. *

Appendix B Implementation of R-Meef

We present the implementation of R-Meef as shown in Algorithm 4.

Within each machine, we group the candidate data vertices of $dp_{0}.{piv}$ within $M_{t}$ into region groups (Line 1). For each region group $rg$, a multi-round mapping process is conducted (Line 2 to 18). Within each round, we use a data structure ${\mathcal{ET}}$ (embedding trie) to save the generated intermediate results, i.e., embeddings and embedding candidates (Line 3). The edge verification index ${I}$ is initialized in Line 4, which will be reset for each round of processing (line 11).

1. (1)

First Round (round 0) Starting from each candidate $v$ of $rg$, we match $v$ to $dp_{0}.{piv}$ in the execution plan. After the pivot vertex is matched, we find all the ECs of $dp_{0}$ with respect to $M_{t}$ and compress them into ${\mathcal{ET}}$. We use a function $expandEmbedTrie$ to represent this process (Line 7). For each EC compressed in ${\mathcal{ET}}$, its undetermined edges need to be verified in order to determine whether this EC is an embedding of $dp_{0}$. We record this information in the edge verification index ${I}$, which is constructed in the $expandEmbedTrie$ function. After we have the EVI ${I}$ in $M_{t}$, we send a $verifyE$ request to verify those undetermined edges within ${I}$ in the machine which has the ability to verify it (function $verifyForeignE$ in Line 8). After the edges in ${I}$ are all verified, we remove the failed ECs from ${\mathcal{ET}}$ (Line 9). 2. (2)

Other Rounds For each of the remaining rounds of the execution plan, we first clear the EVI ${I}$ from previous round (Line 11). In the $i^{th}$ round, we want to find all the ECs of $P_{i}$ based on the embeddings in $R_{G_{t}}(P_{i-1})$ (where $dp_{i}.{piv}$ has been matched). The process is to expand every embedding $f$ of $R_{G_{t}}(P_{i-1})$ with each embedding candidate of $dp_{i}$ within the neighbourhood of $f(dp_{i}.{piv})$. If not all the data vertices matched to $dp_{i}.{piv}$ by the ECs in $R_{G_{t}}(P_{i-1})$ reside in $M_{t}$, we will have to fetch the adjacency-lists of those foreign vertices from other machines in order to expand from them. A sub-procedure $fetchForeignV$ is used to represent this process (Line 12). After fetching, for each embedding $f$ of $R_{G_{t}}(P_{i-1})$, we find all the ECs of $P_{i}$ by expanding from $f(dp_{i}.{piv})$ (Line 14). The found ECs are compressed into ${\mathcal{ET}}$. Then $veriForeignE$ and $filterFailedEmbed$ are called to make sure that the failed ECs are filtered out from the embedding trie, which will only contain the actual embeddings of $P_{i}$, i.e., $R_{G_{t}}(P_{i})$ (Line 15, 16).

After all the rounds of this region group have finished, we have a set of embeddings of $P$ compressed into ${\mathcal{ET}}$. The results obtained from all the region groups are put together to obtain the embeddings found by $M_{t}$.

One important thing to note is that if a foreign vertex is already cached in the local machine, for the undetermined edges attached to this vertex, we can verify them locally without sending requests to other machines. Also we do not re-fetch any foreign vertex if it is already cached previously.

Example 1**.**

Consider the data graph $G$ in Figure 2, where the vertices marked with dashed border lines reside in $M_{1}$ and the other vertices reside in $M_{2}$. Consider the pattern $P$ and execution plan ${{PL}}$ given in Example 3. We assume the preserved orders due to symmetry breaking are: $u_{1}<u_{2}$, $u_{3}$ $<$ $u_{6}$, $u_{4}$ $<$ $u_{5}$ and $u_{8}<u_{9}$.

There are two vertices $\{v_{0}$, $v_{2}\}$ in $M_{0}$ and two vertices $\{v_{1}$, $v_{10}\}$ in $M_{2}$ with a degree not smaller than that of $dp_{0}.{piv}$. Therefore in $M_{1}$, we have $C(dp_{0}.{piv})$ $=$ $\{v_{0}$, $v_{2}\}$ and in $M_{2}$ we have $C(dp_{0}$.${piv})$ $=$ $\{v_{1}$, $v_{10}\}$. After grouping, assume we have ${{RG}}=\{rg_{0}$, $rg_{1}\}$ where $rg_{0}$ $=$ $\{v_{0}\}$ and $rg_{1}$ $=$ $\{v_{2}\}$ in $M_{1}$, and ${{RG}}=\{rg_{0}\}$ where $rg_{0}=\{v_{1}$, $v_{10}\}$ in $M_{2}$.

Consider the region group $rg_{0}$ in $M_{1}$. In round [math], we first match $v_{0}$ to $dp_{0}.{piv}$. Expanding from $v_{0}$, we may have ECs including by not limit to (we lock $u_{7}$ to $v_{7}$ for easy demonstration):

$f_{G_{1}}$* $=$ $\{(u_{0}$, $v_{0})$, $(u_{1}$, $v_{1})$, $(u_{2}$, $v_{2})$, $(u_{7}$, $v_{7})\}$*

$f_{G_{1}}^{\prime}$* $=$ $\{(u_{0},v_{0})$, $(u_{1}$, $v_{1})$, $(u_{2}$, $v_{9})$, $(u_{7}$, $v_{7})\}$*

$f_{G_{1}}^{\prime\prime}$* $=$ $\{(u_{0},v_{0})$, $(u_{1}$, $v_{9})$, $(u_{2}$, $v_{11})$, $(u_{7}$, $v_{7})\}$*

We compress these ECs into ${\mathcal{ET}}$. Note that a mapping such as $\{(u_{0},v_{0})$, $(u_{1}$, $v_{1})$, $(u_{2}$, $v_{11})$, $(u_{7}$, $v_{7})\}$ is not an EC of $dp_{0}$ $w.r.t$ $M_{1}$ since $(v_{1}$, $v_{11})$ can be locally verified to be non-existent. Since the undermined edge $(v_{1}$, $v_{9})$ of $f_{G_{1}}^{\prime}$ cannot be determined in $M_{1}$, we put $\{(v_{1},v_{9}),<f_{G_{1}}^{\prime}>\}$ into the EVI I. We then ask $M_{2}$ to verify the existence of the edge. $M_{2}$ returns false, therefore $f_{G_{1}}^{\prime}$ will be removed from ${\mathcal{ET}}$.

In round $1$, we have two embeddings $R_{G_{t}}(P_{0})$= $\{f_{G_{1}}$, $f_{G_{1}}^{\prime\prime}\}$ to start with. To extend $f_{G_{1}}$ and $f_{G_{1}}^{\prime\prime}$, we need to fetch the adjacency-lists of $v_{1}$ and $v_{9}$ respectively. We send a single $fetchV$ request to fetch the adjacency-lists of $v_{1}$ and $v_{9}$ from $M_{2}$. After expansion from $v_{1}$, we get a single embedding $\{(u_{0}$, $v_{0})$, $(u_{1}$, $v_{1})$, $(u_{2}$, $v_{2})$, $(u_{3}$, $v_{3})$, $(u_{4}$, $v_{4})$, $(u_{7}$, $v_{7})$ $\}$ in $R_{G_{t}}(P_{1})$. There is no embedding of $P_{1}$ expanded from $v_{9}$. Hence $f_{G_{1}}^{\prime\prime}$ will be removed from the embedding trie.

In round 2, we expand from $v_{2}$ to get the ECs of $P_{2}$. $dp_{2}.piv$ was already mapped to $v_{2}$ as seen above, and $v_{2}$ has neighbors $v_{5},v_{6}$ and $v_{10}$ that are not matched to any query vertices. Since there are sibling edge $(u_{5},u_{6})$ and cross-unit edge $(u_{4},u_{5})$ in $P_{2}$, we need to verify the existence of $(v_{4},v_{5})$ and $(v_{5},v_{6})$ if we want to map $u_{5}$ to $v_{5}$ and map $u_{6}$ to $v_{6}$. The existence of both $(v_{4}$, $v_{5})$ and $(v_{5},v_{6})$ can be verified locally. Similarly if we want to map $u_{5}$ to $v_{5}$, $u_{6}$ to $v_{10}$, we will have to verify the existence of $(v_{5},v_{10})$, and so on. It can be locally verified that $(v_{5},v_{10})$ does not exist, and remotely verified that $(v_{6},v_{10})$ does not exist. Therefore, at the end of this round, we will get a single embedding for $P_{2}$ which extends the embedding for $P_{1}$ by mapping $u_{5},u_{6}$ to $v_{5},v_{6}$ respectively. We expand the embedding trie accordingly.

Following the above process, after we process the last round, we have an embedding of $P$ starting from region group $rg_{0}$ in machine $M_{1}$ will be saved in ${\mathcal{ET}}$:

$f_{G_{1}}$* $=$ $\{(u_{0},v_{0})$, $(u_{1}$, $v_{1})$, $(u_{2}$, $v_{2})$, $(u_{3}$, $v_{3})$, $(u_{4}$, $v_{4})$, $(u_{5}$, $v_{5})$, $(u_{6}$, $v_{6})$, $(u_{7}$, $v_{7})$, $(u_{8}$, $v_{9})$, $(u_{9}$, $v_{11})\}$*

Appendix C More Experimental Results

C.1 Scalability Test

We compare the scalability of the five approaches by varying the number of nodes in the cluster (5, 10, 15), 3 cases in total. The queries we processed are shown in Figure 7. Instead of reporting the processing time, here we report the ratio between the total processing time of all queries using 5 nodes and that of the other two cases, which we call scalability ratio. The results are as shown in Figure 12.

The most important thing to observe is that our approach demonstrates linear speed-up when the number of nodes is increased for Roadnet and DBLP. The reason for Roadnet is because most vertices of each partition are far away from the border, therefore the majority of embeddings can be found by SM-E. Each machine of our approach are almost independent except for some workload sharing. As for DBLP, which is a small graph, almost all vertices can be cached in memory, RADS takes full advantage of it. Because TwinTwig, SEED and PSgL failed some queries for LiveJournal and UK2002, we omit their scalability results in those two datasets. The difference between Crystal and RADS is not much while RADS is better for both.

C.2 Effectiveness of Query Execution Plan

To validate the effectiveness of our strategy for choosing query execution plan, we compare the processing time of RADS with two other baseline plans which are generated by replacing the execution plan of RADS with the execution plans $RanS$ and $RanM$, respectively. $RanS$ represents a plan consisting of random star decomposition units (no limit on the size of the star) and $RanM$ represents plan with minimum number of rounds without considering the strategies in Section 4.3. The cluster we used for this test consists of 10 nodes. In order to cover more random query plans, we run each test 5 times and report the average. The queries are as shown in Figure 7. For queries $q_{1}$ to $q_{3}$, the query plans generated in the above three implementations are almost the same. Therefore, we omit the data for those three queries.

The results of Roadnet, DBLP, LiveJournal and UK2002 are as shown in Figure 13. For RoadNet, it is not surprising to see that the processing time are almost the same for the 3 execution plans. This is because most vertices of each RoadNet partition can be processed by SM-E, and different distributed query execution plans have little effect over the total processing time. For all other three data sets, it is obvious that our fully optimized execution plan is playing an important role in improving the query processing time, especially when dealing with large graphs such as LiveJournal and UK2002 where large volumes of network communication are generated and can be shared.

C.3 Effectiveness of Compression

To show the effectiveness of our compression strategy, we conducted an experiment to compare the space cost of the simple embedding-list (EL) with that of our embedding trie (ET). We use the RoadNet and DBLP data sets for this test. The queries are as shown in Figure 7. We omit the test over the other two data sets because the uncompressed volume of the results are too big.

The results are as shown in Table 3 and Table 4, respectively. For RoadNet the intermediate results generated by Queries 7 and 8 are negligible, therefore they are not listed. The results for both datasets demonstrate a good compression ratio. It is worth noting that the compression ratios of all queries over RoadNet are smaller than that over DBLP. This is because the embeddings of Roadnet are very diverse and they do not share a lot of common vertices.

C.4 More Query Processing Results

As aforementioned, SEED supports clique as decomposition unit and Crystal indexes the cliques in the graph storage. Both methods shall have advantages when processing queries with more cliques. It is noted that most of the queries in Figure 7 do not contain any clique. For sound fairness, we also tested some queries from [18] for the methods of SEED, Crystal and RADS. The queries are as shown in Figure 14, all of which have cliques. In contrast to the experiment in Section 7.1, for SEED, here we also used the program implemented by its original authors. This will guarantee both SEED and Crystal have their maximum optimized performance when processing those queries.

The results are as shown in Figure 15. We omit the results of SEED for UK2002 since its time cost is much higher compared with the other two methods. Being consistent with the result in Section 7.1, RADS performs constantly faster than SEED and Crystal when running on Roadnet (more than 1 order of magnitude) and on DBLP. For other datasets, RADS is still better than SEED for all queries, while worse than Crystal for the queries $q_{1}$, $q_{2}$ and $q_{4}$. This is reasonable because of the heavy clique index of Crystal. However, RADS has a noticeable improvement over Crystal when processing $q_{3}$, where the verification edges helped RADS filtered a lot of unpromising candidates.