The TrieJax Architecture: Accelerating Graph Operations Through Relational Joins

TL;DR

The paper introduces TrieJax, a hardware accelerator that leverages relational join algorithms' properties to significantly speed up graph pattern matching tasks while reducing energy consumption, suitable for integration with manycore processors.

Contribution

It presents TrieJax, a novel hardware accelerator designed specifically for relational join-based graph pattern matching algorithms, demonstrating substantial performance and energy efficiency improvements.

Findings

TrieJax outperforms existing accelerators by 7-63x in speed.

TrieJax reduces energy consumption by up to 1750x.

It effectively integrates with manycore processors for enhanced performance.

Abstract

Graph pattern matching (e.g., finding all cycles and cliques) has become an important component in many critical domains such as social networks, biology, and cyber-security. This development motivated research to develop faster algorithms that target graph pattern matching. In recent years, the database community has shown that mapping graph pattern matching problems to a new class of relational join algorithms provides an efficient framework for computing these problems. In this paper, we argue that this new class of relational join algorithms is highly amenable to specialized hardware acceleration thanks to two fundamental properties: improved locality and inherent concurrency. The improved locality is a result of the provably bound number of intermediate results these algorithms generate, which results in smaller working sets. In addition, their inherent concurrency can be leveraged for effective hardware acceleration and hiding memory latency. We demonstrate the hardware amenability of this new class of algorithms by introducing TrieJax, a hardware accelerator for graph pattern matching. The TrieJax design leverages the improved locality and high concurrency properties to dramatically accelerate graph pattern matching, and can be tightly integrated into existing manycore processors. We evaluate TrieJax on a set standard graph pattern matching queries and datasets. Our evaluation shows that TrieJax outperforms recently proposed hardware accelerators for graph and database processing that do not employ the new class of algorithms by 7-63x on average (up to 539x), while consuming 15-179x less energy (up to 1750x). systems that do incorporate modern relational join algorithms by 9-20x on average (up to 45x), while consuming 59-110x less energy (up to 372x).

Tables

Table 1. Table 1: Graph pattern matching operations used to evaluate TrieJax and their mapping to join queries (shown in datalog format, for brevity).

Name	Query
Path-3	$path3(x,y,z)=R(x,y),S(y,z).$
Path-4	$path4(x,y,z,w)=R(x,y),S(y,z),T(z,w).$
Cycle-3	$cycle3(x,y,z)=R(x,y),S(y,z),T(z,x).$
Cycle-4	$cycle4(x,y,z,w)=R(x,y),S(y,z),T(z,w),$
	$U(w,x).$
Clique-4	$clique4(x,y,z,w)=R(x,y),S(y,z),T(z,w),$
	$U(w,x),V(z,x),W(w,y).$

Table 2. Table 2: Dataset statistics

Dataset	#Nodes	#Edges	Category
ca-GrQc (grqc)	5,242	14,496	Collabor.
soc-sign-bitcoin-alpha (bitcoin)	3,783	24,186	Bitcoin
p2p-Gnutella04 (gnu04)	10,876	39,994	P2P
ego-Facebook (facebook)	4,039	88,234	Social
wiki-Vote (wiki)	7,115	103,689	Social
p2p-Gnutella31 (gnu31)	62,586	147,892	P2P

Table 3. Table 3: Experimental configuration for TrieJax and the software baselines

	TrieJax	Software frameworks
Processing Unit	TrieJax core @ 2.38GHz PRJ 4MB SRAM	16 $\times$ Xeon E5-2630 v3 cores @ 2.4GHz
On-chip memory	L1D ReadOnly 32KB 8-way L2 ReadOnly 32KB 8-way L3 20MB	L1I/L1D 32KB/core 8-way L2 512KB/core 8-way L3 40MB
Off-chip memory	4 $\times$ DDR3-1600 2 $\times$ 12.8GB/s channels	4 $\times$ DDR3-2133 2 $\times$ 17GB/s channels

Full text

In this paper, we argue that this new class of relational join algorithms is highly amenable to specialized hardware acceleration thanks to two fundamental properties: improved locality and inherent concurrency. The improved locality is a result of the provably bound number of intermediate results these algorithms generate, which results in smaller working sets. In addition, their inherent concurrency can be leveraged for effective hardware acceleration and hiding memory latency.

We demonstrate the hardware amenability of this new class of algorithms by introducing TrieJax, a hardware accelerator for graph pattern matching. The TrieJax design leverages the improved locality and high concurrency properties to dramatically accelerate graph pattern matching, and can be tightly integrated into existing manycore processors. We evaluate TrieJax on a set standard graph pattern matching queries and datasets. Our evaluation shows that TrieJax outperforms recently proposed hardware accelerators for graph and database processing that do not employ the new class of algorithms by $7-63\times$ on average (up to $539\times$), while consuming $15-179\times$ less energy (up to $1750\times$). systems that do incorporate modern relational join algorithms by $9-20\times$ on average (up to $45\times$), while consuming $59-110\times$ less energy (up to $372\times$).

1 Introduction

Analyzing the relationships in a graph has become a key building block in many domains, including social networks [33], biology [13], and artificial intelligence [29]. A recent study [28] analyzed the common challenges in graph processing and found that pattern matching problems, namely finding all instances of a given pattern in a graph, to be a dominantly popular problem in graph application domains. Graph pattern matching problems, however, are known to be computationally intensive and thus challenge algorithm designers.

In recent years, the database community has proposed new relational join algorithms that efficiently map graph problems to query evaluation over relational databases. In particular, a new breed of Worst-Case Optimal Join (WCOJ) algorithms has been introduced and studied [21, 32, 2, 20, 15]. These algorithms were shown to be theoretically superior to the traditional join algorithms [4], and WCOJ-based solutions for graph matching problems have been shown to deliver superior performance compared to known graph algorithms [24].

From an architectural perspective, pattern matching via WCOJ algorithms offers two features that make it hardware friendly. First, WCOJ algorithms bound the number of intermediate results they generate, which greatly reduces the algorithms’ working-set size, reduces data transfers to and from memory, and makes them more amenable to caching. In contrast, traditional join algorithms partition multi-way joins (a join operation on multiple relations, or tables) into a tree of binary join operations. Each binary join operation then performs a memory scan on its input relations and generates a (potentially huge) intermediate relation. Importantly, many of the intermediate results are typically filtered out by subsequent join operations. Second, WCOJ algorithms are highly concurrent. Although the algorithms’ control flow is non-trivial, which makes them unsuitable for GPGPUs, their inherent concurrency makes them amenable to hardware acceleration. In addition, this inherent concurrency allows specialized accelerators to apply multithreading techniques to hide memory latency.

In this paper, we argue that WCOJ-based algorithms for solving graph pattern matching problems are highly amenable to specialized acceleration. We describe how graph problems can be mapped to relational join operations and detail how the new breed of relational join algorithms maps to hardware. We further present TrieJax, an on-die, domain-specific accelerator that leverages the hardware-friendly properties of WCOJ algorithms to accelerate graph pattern matching problems and dramatically reduce energy consumption.

TrieJax employs a highly-concurrent WCOJ variant [15] that scans table indexes stored in a tree-based data-structures. In addition, TrieJax caches partial join results to speed up computation and minimize memory traffic. Furthermore, TrieJax is designed to be small enough to serve as a dedicated core in a standard many-core processor. This design allows TrieJax to use the same memory system as other cores in the system, a property that is crucial for operating on large data sets. This is in contrast to discrete accelerators (e.g., GPGPUs), which have limited directly-attached memory capacity and require frequent data transfers between the system memory and their local memory. We validated the performance, area, and energy consumption of TrieJax using a synthesized and placed&routed RTL implementation, whose results drove a cycle-accurate simulator.

We demonstrate the improved performance and reduced energy obtained by leveraging WCOJ-based graph pattern matching algorithms via a comparison of TrieJax to recently proposed database and graph processing accelerators [34, 10]. Unlike TrieJax, these accelerators employ traditional join algorithms and are therefore susceptible to the potential explosion of intermediate results that these algorithms generate. We also demonstrate the benefits of hardware acceleration of WCOJ algorithms by comparing TrieJax to two software database management systems [1, 15] that are based on the new breed of WCOJ algorithms. Ultimately, TrieJax outperforms the state-of-the-art hardware accelerators by $7-63\times$ on average, while consuming $15-179\times$ less energy. Compared to the software systems, TrieJax runs $9-20\times$ faster and consumes $59-110\times$ less energy.

In summary, we make the following contributions:

• •

We present the hardware-friendly properties of WCOJ algorithms and how they can be used for solving graph matching problems.

• •

We present a domain-specific hardware accelerator that leverages the hardware-friendly properties of WCOJ algorithms for graph pattern matching.

• •

We demonstrate the performance and energy benefits of a WCOJ-based pattern matching accelerator through a detailed experimental evaluation.

The rest of the paper is organized as follows. Section 2 explains how graph pattern matching algorithms are mapped to relational join operations and describe the new breed of WCOJ algorithms in more detail. Section 3 describes the TrieJax accelerator architecture and how it maps a WCOJ algorithm to hardware. Finally, Section 4 presents an experimental evaluation comparing the performance and energy consumption of TrieJax to database and graph analytics accelerators on standard graph pattern matching queries.

2 New relational join algorithms and graph pattern matching

Graph pattern matching problems have become paramount in different computational domains, including social networks [33], biology [13], and artificial intelligence [29]. Yet despite the focus in recent years on developing general graph analytics frameworks (including hardware accelerators and optimizations [10, 19, 25]), these frameworks mostly benefit more well-known graph problems (e.g., Breadth-First Search and PageRank) but often ignore graph pattern matching problems.

Recent advances in relational database theory have introduced methods for efficient computation of graph algorithms based on relational join operations. These methods have been found particularly effective for computing graph pattern matching problems. In this section, we describe how relational join operations can be used for graph analytics and review the algorithmic advances in relational join algorithms. We then discuss how these algorithms, unlike traditional ones, avoid generating a large number of intermediate results, which makes them amenable to hardware acceleration.

2.1 Relational Join

Relational database management systems (RDBMS) are a common solution for data management. This type of database follows the relational model of data. In this model, the data is stored in relations, also known as tables (e.g., the tables Posts and Likes mentioned in Figure 1), the table columns are the attributes (e.g., user and postID), and the rows (tuples) are the values. Each row in the table can have an attribute that is a unique primary key. For instance, the Posts table has the primary key postID. Other tables can reference a specific table through its primary key using an attribute known as a foreign key. In our example, the Likes table can reference a post using the post attribute as a foreign key to Posts.

A relational join query is a query that analyzes the relationship between tables via shared attribute values. Figure 1 shows a simple relational join query—the natural join of the three relations Posts, Likes and Follows. The query computes information about posts liked by users with followers. More precisely, the query is asking for tuples where each consists of a post, a user who likes the post, and a follower of the user. While there are different types of join operations, in this work we focus on natural equi-joins where tables are joined by equality of mentioned attributes.

Relational join for graph analytics.   Many graph algorithms can be translated to (SQL-like) join queries, which allows solving graph problems using RDMS solutions. A finite graph is commonly represented in an RDBMS by an adjacency list relation. Each row in the relation represents an edge between two vertices in the graph. Graph patterns queries are translated to join queries. For example, given a graph relation $G$, the query $Q(x,y,z)=G(x,y)\Join G(y,z)\Join G(z,x)$ returns all the triangles in the graph.

Mapping graph pattern matching algorithms to WCOJ-based systems have been shown to be highly effective, and WCOJ-based systems can provide speedups of up to two orders of magnitude compared to low-level graph analytic solutions [4]. Nevertheless, these performance benefits are not universal across all graph algorithms. For example, Aberger et al. [1] have shown that problems such as SSSP [14] and PageRank [26]) do not enjoy similar benefits. In this paper we focus on the important family of graph pattern matching problems.

Database and graph analytic acceleration.   Acceleration of database and graph analytics using SIMD, GPGPU, or specialized hardware accelerator has been a common interest in both the database and micro-architecture communities. Q100 by Wu et al. [34] was the first hardware accelerator that fully supported relational operations. It incorporates relational operators (such as Sort, Select, and Merge-Join) as hardware components in a hardware accelerator for relational column stores. Q100 offers a solution that searches the best custom chip for a specific query from time and energy perspectives. Q100 achieves a speedup of $10\times$ on TPC-H compared to MonetDB, a commonly used column store. Graphicionado by Ham et al. [10] focuses on graph analytics. It implements the vertex-programming model in hardware with embedded programmable units that allow flexible support for graph algorithms such as PageRank or SSSP. The Graphicionado hardware accelerator achieves a speedup of $1.76-6.5\times$ compared to GraphMat [31], a vertex-programming framework that scales using sparse matrix representation and MPI.

New relational join algorithms for graph analytics.   Recently, the database community established new theoretical and algorithmic advances in the area of relational join algorithms. Given a join query with more than two relations, standard join algorithms use the pairwise join approach. The traditional algorithms, such as hash-join [9] or sort-merge join [18], join two relations at a time to create a new intermediate relation. This intermediate relation will later be joined with another (input or intermediate) relation until the final result is computed. Recent work by Atserias et al. [4] shows that pairwise join algorithms can generate many unnecessary intermediate results that are not part of the final result. It helps define a tight bound, called the AGM bound, on the maximum number of results that can be returned from a query in the worst case.

We illustrate the AGM bound with an example. Given the relations $A$, $B$ and $C$, consider the triangle join query: $Q(x,y,z)=A(x,y)\Join B(y,z)\Join C(z,x)$. For simplicity, we assume that each relation has $N$ values. The AGM bound proves that the query result $Q(x,y,z)$ contains no more than $N^{\frac{3}{2}}$ results. However, pairwise join algorithms can generate an intermediate result with up to $N^{2}$ values, while many of them will be filtered by the third relation. Any join algorithm that provides the same complexity as the AGM bound is called Worst-Case Optimal Join (WCOJ) algorithm. In contrast, the traditional pairwise join algorithms are not worst-case optimal. More formal definitions and extensions to general queries can be found in a full survey by Ngo et al. [22].

Systems and acceleration of WCOJ algorithms.   Wu et al. [5] used GPGPU to accelerate a WCOJ algorithm and achieved $2-6\times$ speedups compared to CPU. EmptyHeaded by Aberger et al. [1] offered a relational query engine that maps Generic Join, a WCOJ algorithm, to parallel SIMD operations on a standard CPU. For graph algorithms, EmptyHeaded achieves comparable results to Galois [23], a low-level hand-tuned query engine comparable to GraphMat. On graph pattern matching queries, it achieves a $2-60\times$ speedup compared to other CPU based solutions. Section 4 compares our TrieJax to the systems above or their baselines.

2.2 Cached TrieJoin

Following the publication of the AGM bound, a plethora of Worse Case Optimal Join (WCOJ) algorithms was published [21, 32, 2, 20, 15]. Experimental analysis by Nguyen et al. [24] has shown that the WCOJ algorithms provide significant speedups on complex join queries compared to the traditional approaches such as state of the art RDBMS, graph engines and column stores.

LeapFrog TrieJoin [32], also known as LFTJ, is a commonly used WCOJ algorithm. Its main idea is to iterate over trie-based indexes of the relations in a backtracking manner to generate the join query results. LFTJ does not generate any intermediate results and thus yields a low memory footprint, but it does so at the expense of recomputing recurring intermediate partial joins. Furthermore, the recurring computations have little memory locality as they repeatedly scan irregular, tree-based tries. Cached TrieJoin (CTJ) by Kalinsky et al. [15] eliminates much of the recurring partial join computations by selectively caching partial join results using the available system memory (without violating the WCOJ property). This behavior can benefit low-memory environments and is therefore used as one of the main building blocks in our system.

CTJ operates as follows: Given a query, CTJ decomposes the query structure to detect which attributes can be valid keys and their respective cached values. Then, it uses the caching system to drive the TrieJoin, while saving partial join results in the cache and extracting them later to avoid recurrent computations. CTJ shows a $10\times$ speedup on average compared to LFTJ, and even better speedups compared to traditional query engines.

2.2.1 Indexes

CTJ saves its relations in tries, a multi-level data structure commonly used in WCOJ systems [1], column stores and graph engines [30, 11]. Section 3 elaborates on the physical layout of our indexes. Given a relation, for example the $R(x,y)$ relation with two attributes in Figure 2, the trie representation is as follows:

• •

Each attribute, such as $x$, is a level in the trie.

• •

Each unique path from the root to a leaf is an entry in the relation. For example, the path $(1,1)$ corresponds to the entry of $x=1$ and $y=1$ in $R(x,y)$.

• •

The siblings are sorted.

2.2.2 The Cached TrieJoin algorithm

Next, we elaborate on CTJ, one of our main building blocks. Figure 3 will be used to illustrate the CTJ execution flow. The algorithm is presented in Figure 4. CTJ first orders the variables (e.g, $x\rightarrow y\rightarrow z\rightarrow w$). Then, it looks for matches for each variable in turn from first ($x$) to last ($w$). Initially, the cache is empty (line 14 in Fig. 4). Starting from $x$, CTJ will search all the tries that contain $x$ (e.g., $R(x,y)$) for a match ( 1 in Fig. 3). Each match is found using a variation of merge-join, called leapfrog-join [32], that uses lowest upper bound searches to leap over the variable levels until a match is found. If a match is found, it sets the $x$ value in the result buffer (line 15 in Fig. 4).

Before continuing to the next variable (e.g., $y$), CTJ adjusts the tries (Line 16) such that they align on the children of the current partial join path (the nodes below the paths marked in red in Fig. 3). For example, after step
1 , the $R$ trie is set on the $y$ child nodes of $R(x)=1$. Finally (Line 17), the algorithm calls CTJ to look for a match for the next variable $y$ ( 2 ). In practice, CTJ uses queues instead of recursion. Once all the variables are set ( 4 ), CTJ saves the result (line 2). If no other matches are found for the current variable, CTJ resets the adjusted tries (line 20) to focus on the previous attribute.

CTJ uses cache for partial join results to avoid the computation of recurrent partial joins. Given a join variable (e.g., $z$), CTJ extracts the variables that can be used as keys for caching (e.g., $y$) and the variables that are cached by these keys (lines 4–5). During the standard execution, CTJ checks the cache if the value of the current variable is stored in the cache. If so, it uses the results from the cache and adjusts the tries accordingly (lines 9–11). For example,
5 finds $y=2$ in the cache and reads the value of $z$ from the cache instead of recomputing the join for $z$. Writing to the cache is done during the standard execution ( 3 ), after finding a valid match for a cached entry (line 19).

3 TrieJax Architecture

3.1 System-level overview

TrieJax is designed as a small, on-die co-processor that integrates to the main processor like an additional core, as depicted in Figure 5. This design allows TrieJax to use the main processor’s memory system and avoids the coherence and data transfer overheads that plague discrete accelerators.

TrieJax uses a local read-only L1 and L2 caches that, in turn, are used for caching the index data. Since TrieJax stores its intermediate results in a private scratchpad as we describe later on, only the final results of the join operations are written to memory. The memory system, therefore, streams these write operations directly to memory and bypasses the private caches to avoid cache thrashing and congestion in the cache queues. For example, on some of the benchmarks we evaluate (e.g., path4 query), where the size of the resulting join table is extremely large, bypassing the private caches improves performance by up to $2.5\times$.

The regular processor cores communicate with TrieJax using a co-processor interface similar to that of ARM [3] or RISC-V [27]. For instance, we use a parallel of the ARM LDC command to load the query to the TrieJax internal memory.

3.2 Query language and index memory layout

We use the CTJ compiler [15] to compile SQL join queries for TrieJax. Table 1 lists the graph pattern matching queries used in our evaluation (Section 4) and their mapping to join queries (for brevity, the table uses the compact datalog format rather than SQL).

Figure 6 illustrates a trie layout in TrieJax. TrieJax uses in-memory trie indexes (described in Section 2.2) in a physical layout similar to that of EmptyHeaded [1]. Specifically, this layout stores the unique values of the first join attribute in the relation as a sequential array. The next join attribute is then stored by concatenating the values that match the previous attribute to a continuous array. To identify which values of the second join attribute belong to which elements in the previous attribute, the child ranges array lists the corresponding ranges of the second attribute. For example, Figure 6 shows that the values $\{(1,1),(1,2)\}$ in $R$ can be extracted by focusing on $R(x=1)$, extracting the ranges of its children from the respective indexes $[0,2)$ in the Rx child ranges array, and accessing the extracted index range in the $Ry$ array.

3.3 The TrieJax operational flow

Figure 7 presents the high-level design of TrieJax and the communication between the different components it utilizes to answer graph pattern matching queries. The five major building blocks are lowest upper bound (LUB), MatchMaker, Midwife, Cupid and the partial join results cache (PJR cache). We illustrate the operational flow of TrieJax on the Path3 example query in Figure 6. We begin by describing the operational flow as single threaded. Section 3.4 then describes how TrieJax incorporates multi-threading internally to hide memory latency. The micro-architecture and the internal flow of each component are described in Section 3.6.

The query execution begins by loading the compiled query to a local read-only store in Cupid, the component that controls the execution of the full join query (marked
1 in Figure 7). Cupid starts with the first join variable $x$, by extracting the pointers to the trie arrays of $x$ embedded in the compiled query structure (e.g., $Rx$), and sending them to MatchMaker (marked
2 in Figure 7). Until a response is returned, Cupid saves the current state (e.g., result buffer, parameter id) in its local State Store.

MatchMaker is in charge of finding the first matched value of $x$ in all the tries (based on the Leapfrog Join algorithm described in Section 2.2). Our running example (Figure 6) only has one array ($Rx$), so MatchMaker will request the LUB unit to find the first value for $x$ in $Rx$ ( 3 ). LUB performs a binary search to look up the lowest upper bound of a value in a given array. The unit will search for the index in the trie array in which the value is stored ( 4 ), e.g., $Rx_{index}=0$, and send the result back to MatchMaker. MatchMaker will send the read value and index (e.g., $x=0$, $Rx_{index}=0$) back to Cupid, which will save the index in the current state of variable $x$. Similarly to Cupid, MatchMaker and LUB save their local state in their State Store when sending a request and reads the data when receiving the response.

Next, Cupid will continue to the next variable $y$ and look for a match for $y$. It will read the $Ry$ and $Sy$ array pointers from the compiled query. As described above, the $Ry$ array stores all the values of the child nodes of $Rx$. To extract the $Ry$ range that belongs to the current $x$ value, Cupid will send the $x$ index, the $Ry$ pointer, and the $Rx$ child ranges pointer to Midwife ( 6 ). The Midwife component is in charge of extracting the children of a node in the trie. For example, to extract the $Ry$ values for $Rx_{index}=0$, Midwife will read from the child ranges array the start and end ranges from indexes 0 and 1, respectively. The final $Ry$ range (e.g., $Ry[0:2]$) will be sent to MatchMaker.

Once MatchMaker receives both $Sy$ and $Ry$ array ranges sent from Cupid and Midwife, it will look for the first match of the two array ranges. It will send the pointer of the first value in $Ry$ and the $Sy$ array pointer to LUB ( 3 ). LUB loads the value of $Ry$ from memory and uses binary search to look for its lowest upper bound in $Sy$ (e.g., $Sy=1$). The result is returned to MatchMaker, which extracts its state from the State Store and checks if a match $LdVal$ was found. If so, it will return the data to Cupid that, in turn, will set the state for variable $y$ and continue to the next variable $z$. If not, it will use LUB to look for $LdVal$ in the $Ry$ range, using iterative LUB searches on $Sy$ and $Ry$ until a match is found or it reaches the end of an array. If no match is found, MatchMaker will return a failed response to Cupid, which will restore the previous variable and look for its next match. Once a match is found for $x$, $y$ and $z$, Cupid will write the result to memory. TrieJax uses a small write buffer and sends results to main memory when the buffered results exceed the size of a cache line.

3.4 Multi-threading in TrieJax

TrieJax’s use of multi-threading (MT) achieves two performance benefits. First, MT parallelizes the trie join and thereby extracts memory-level parallelism (MLP), which allows TrieJax to hide memory latency. Second, MT pipelines the operations on the partial join results cache, and enables Cupid to lookup pre-computed partial results while the rest of the accelerator is looking for new results.

Figure 8 presents two different MT schemes, static and dynamic. The static MT scheme divides the arrays of the first attribute between the different threads. This scheme is similar to software MT solution in DBMS systems such as EmptyHeaded [1] and GPU query engines [5]. The disadvantage of this scheme is an unbalanced workload distribution between the different TrieJax threads. For example, in Figure 8, tid1 will generate many results while tid2 will finish quickly without any results.

Dynamic MT, on the other hand, balances the load by dynamically allocating new threads on each match. On a match, the Cupid unit splits the search space to two sub-spaces. The original thread is then bound to the search space containing the current partial result, and the new thread will be bound to the search space after the current match. For example, in Figure 8, a match is found for $x=1$ while using dynamic MT. After the match, tid1 will compute the results for $x=1$ and tid2 will compute the results for $x>1$.

On its own, however, dynamic MT might incur a slow initialization time for queries with infrequent matches due to fewer matching opportunities. TrieJax thus combines both static and dynamic MT.

Each component supports multi-threading by replicating its internal execution state. As shown in Figure 7, each component in the system maintains a small local memory to store the execution state when waiting for a response from another component (e.g. when Cupid requests MatchMaker to find the next match for a variable). Replicating this state allows each component to maintain multiple operations in-flight. For duplicated components, such as Midwife, we use banked stores to support parallel accesses. Section 4.2 examines the performance impact of MT and identifies the number of threads required to achieve performance/storage balance.

3.5 Caching with threads

Locality across partial join results enables TrieJax to break query execution into two parallel flows using the TrieJax partial join results cache (PJR cache). In the main flow, Cupid, Midwife, MatchMaker and LUB construct new partial results. In the other flow, Cupid maintains partial results in the PJR cache and checks if the stored partial results can be used instead of executing the main flow and recompute them. Decoupling the flows and using MT in both allows the units to execute concurrently.

The PJR cache stores intermediate partial join results based on the cache structure provided by the TrieJax compiler, namely which attributes are keys and their corresponding cached attributes. In our caching example from Section 2.2 (Figure 3), the cache entry of PJR cache stores the partial join values and indexes of $z$ (e.g., the values $2$ and $4$ and their indexes) and it is keyed by a hash of the corresponding $y$ value (e.g., $1$). The indexes in the trie array are stored to allow the expansion of the children nodes by Midwife.

When Cupid finds a match on a key attribute (e.g., $y$), it searches PJR cache for its partial join results. For instance, the values of $z$ for the given $y$ (similarly to step
5 in Figure 3). In the case of a cache hit, it uses the cached results instead of recomputing them. Otherwise, PJR cache will allocate a new entry for the array of intermediate results, and Cupid will use the main flow to compute the values and set them (and their indexes) in the entry.

Since partial join results can have variable lengths, each entry contains the number of values currently stored in the entry. If an entry overflows, when it attempts to store more intermediate results than the entry size, it is deallocated to avoid storing incomplete results.

A major challenge when using MT to fill the PJR cache is managing read/write race conditions. We solve this issue by adding an insertion buffer that stores entries that were not fully analyzed, meaning that TrieJax did not finish analyzing all the paths under the entry key. Once an entry is fully analyzed it is copied atomically to the PJR cache. Another MT challenge is write/write races. A keen reader will notice that the same partial join result can be accessed from different paths. If a partial join result is available in the cache, it will be used by the querying thread. However, if the entry is still in the insertion buffer, two threads from different paths might try to append values to the same entry. To avoid this race, the insertion cache uses all the values leading to the key to validate that the values are stored from just one path. For example, when looking on the dynamic MT in Figure 8, we can see that tid1 computes the results for $(x=1,y=2)$, while tid2 looks for the results of $(x=2,y=2)$. If the results for $y=2$ are not in the PJR cache, tid2 will compute the results and store them in the insertion buffer. While $y=2$ is in the insertion buffer, the value of $x$ for tid2 is different and the tid2 results will not be stored.

The last caching challenge is how to determine that an entry is fully analyzed. With dynamic MT, multiple threads can work on the same cache entry in parallel. New threads can even be created on the fly to help analyze the cache entry. To avoid race conditions we add a thread counter to each entry that maintains the number of threads currently working on the entry. Each thread that is involved with a cached entry notifies the cache of its allocation or deallocation to update the count. Once the count reaches zero, the cached entry analysis is done and the entry is copied to the PJR cache.

3.6 The TrieJax components

We now turn to describe the microarchitecture and internal flow in each TrieJax component.

LUB**.**   This component searches for a value in a sorted array using binary search. If the value does not exist, it returns the lowest upper bound. This component has a load (LD) unit to communicate with the memory. Figure 9 presents the logical flow of LUB. Since most of the read operations issued by TrieJax are part of binary search operations, encapsulating the binary search logic in the specialized LUB component allows us to duplicate the component and generate multiple memory accesses that look for matches on different sub-arrays concurrently.

MatchMaker**.**   This component implements the leapfrog join algorithm described in Section 2.2 for one join variable. Figure 10 presents the logical flow of MatchMaker and the queues used to communicate with LUB and Cupid. Given two array ranges, this unit communicates with LUB to find the first value that is contained in both arrays. If no such value is found, the component returns false.

Midwife**.**   This component is used to extract the child nodes of a value node in the trie data structure, following the logic presented in Figure 11. The component computes the memory range in which the child nodes of a given parent node are stored. The inputs to the unit are a pointer to a child node array and a parent index. For example, given the Rx child ranges array in Figure 6 and index [math] of Rx, Midwife extracts the range $[0,2)$ and returns the $Ry[0:2]$ range (start and end pointers) to MatchMaker. The LD unit is used to access the children array. This component is duplicated to handle up to two child node ranges in parallel.

Cupid**.**   This unit manages the execution of the full join query. Figure 12 shows the single threaded logical flow of Cupid. For each join attribute $k$, it uses the MatchMaker to look for the next match in all the indexes that contain $k$. If a match is found, it updates the result buffer and moves to the next join attribute. Otherwise, it backtracks and looks for the next match for the previous join attribute. Finally, the unit uses its store (ST) unit to save the final results to memory. This component is also in charge of the threads management and partial join results caching. More information can be found later in this section.

3.7 TrieJax local memory system

There are three local memory stores in TrieJax. The first is the PJR cache, which is accessed by Cupid. The second is a constant read-only memory that stores the query structure and cache structure described in Section 3. Finally, each component holds a small local memory for maintaining the thread state. For example, LUB units store the searched value and array range before sending the request to memory. Once the request is returned, the thread information is read from the LUB thread store and continues according to the result.

We use SRAM for the local memory stores. The PJR cache is the biggest store, amounting to 4 MB (for brevity, we do not present the full design space exploration for the cache size). This store uses 4 banks to allow fast concurrent accesses. The Cupid thread store is the second biggest amounting to 16 KB, while the remaining stores containing less than 512 B. It supports 32 threads, a configuration which offers the best performance/storage as examined in Section 4.2.

4 TrieJax Evaluation

In this section, we present our evaluation of TrieJax when executing graph pattern queries and compare its performance and power benefits to four state-of-the-art baselines: Cached Trie Join (CTJ) [15] and EmptyHeaded [1] are software systems, and Graphicionado [10] and Q100 [34] are hardware accelerators. Our evaluation focuses on the following core questions:

• •

How does the performance of TrieJax compare to the baselines?

• •

What is the power consumption of TrieJax compared to the baselines?

• •

What is the effect of the TrieJax multi-threading on performance?

• •

How the partial join results cache affect the performance?

4.1 Methodology

TrieJax.   We implemented all the TrieJax building blocks using PyRTL [7]. We then used Cadence Innovus and Design Vision in tandem with the OpenCell 45nm design library to synthesize and place&route the Verilog code generated by PyRTL. The design achieves a fixed frequency of 2.38GHz (critical path of 0.42ns), and the results are for dynamic multi-threading with 32 threads (unless otherwise noted).

The timing and power figures obtained by the physical design were used to drive a cycle-accurate simulator of TrieJax. The simulator models all micro-architectural components described in Section 3. We integrated the simulator with Ramulator [16] to obtain accurate performance of the memory system. The DRAM energy is simulated with DRAMPower [6] using the memory traces from Ramulator. The performance and power of the on-chip SRAM memory were simulated using Cacti 6.5 [12]. The TrieJax uses a default PJR cache size of 4 MB, which includes the insertion buffer. The off-chip memory is simulated as 64GB of DDR3_1600 DRAM with two channels. The total TrieJax core area is $5.31mm^{2}$.

Baselines.   We compare TrieJax to the Q100 and Graphicionado hardware accelerators and to CTJ and Emptyheaded software systems (these baselines are discussed in detail in Section 2.1). Since we do not have the original code for the hardware accelerators, we estimate the performance of Q100 and Graphicionado based on their original software baselines, MonetDB and GraphMat, respectively. We configured the original software baselines as described in the original Q100 and Graphicionado papers and scale the baselines’ results given the best speedup and energy improvement reported in the papers. We believe this methodology provides a comparison that is favorable to both Q100 and Graphicionado.

In addition, we use CTJ and EmptyHeaded as highly tuned WCOJ software baselines. To achieve a comparison that is favorable to the baselines, each system is run 3 times and the minimum value is reported.

To evaluate the power consumption of all software systems we measured the power of the Package and DRAM using the Intel Running Average Power Limit (RAPL) meters [8]. We sample the energy consumption during the benchmark and deduct idle energy consumption measured on the same machine for the same amount of time. For Q100 and Graphicionado, whose original papers did not report DRAM energy consumption, we estimate the memory energy consumption by dividing the DRAM energy consumption of the respective baseline by the accelerator speedup. Because the accelerators use similar algorithms to their baselines, our scaling reduces the idle memory consumption of the DRAM avoided by the speedup.

Finally, our experimental platform is a Supermicro 2028R-E1CR24N server. The server is configured with two Intel Xeon E5-2630 v3 processors running at 2.4 GHz, 64GB of DDR3 DRAM with two channels, and is running a stock Ubuntu 16.04 Linux.

Datasets and queries.   We test five query patterns (listed in Table 1) on 6 different datasets. We focus on common graph pattern matching queries. Testing on linear algorithms returned comparable results to the baselines, which follows the worst-case complexity of the underlying algorithm. We leave the integration of other operators, such as SORT, to future work which can be done similarly to Q100. Our datasets are real-world graphs taken from Stanford SNAP [17]. Table 2 presents the different datasets. Due to the polynomial complexity of our queries, the runtime of the join query drastically increases on bigger datasets. Therefore, we only use datasets with simulation time smaller than five days.

4.2 Impact of multithreading on performance

Figure 14 how using different number of internal threads affect its performance. By using only 8 internal threads, TrieJax’s performance is improved by $5.8\times$, on average, compared to single-threaded implementation. Similarly, running 32 internal threads improves the average performance speedup by $10.8\times$ over single thread version. Using 64 threads, however, has a minor effect on the performance. We therefore choose to use 32 internal threads in our benchmarks.

4.3 Performance comparison

Figure 13 shows the speedup of TrieJax compared to the four baselines (note the logarithmic scale) for the queries listed in Table 1 and datasets listed in Table 2.

TrieJax consistently outperforms the software baselines. Compared to CTJ, TrieJax achieves a speedup of $5.5-45\times$ and $20\times$ on average. In comparison to EmptyHeaded, which uses a highly parallel WCOJ algorithm with SIMD operations, TrieJax reaches a $2.5-44\times$ speedup and $9\times$ on average.

Notably, TrieJax also delivers substantial speedups compared to the hardware accelerators. TrieJax is $7\times$ faster than Graphicionado, on average, ranging between $0.8-32\times$. The speedup is because TrieJax avoids a large number of unnecessary intermediate results, that take the form of messages being passed between the different graph nodes in Graphicionado.

While TrieJax offers a considerable speedup on average, Graphicionado was able to perform faster on the Path4 wiki and Path4 Facebook queries. In these queries, Graphicionado outperforms TrieJax by up to $1.25\times$. The reason for this minor slowdown is that these queries generate a large number of results, and the TrieJax memory system becomes a bottleneck. Nevertheless, these slowdowns may be artifacts of our optimistic estimation of Graphicionado, which does not limit its memory bandwidth.

Finally, TrieJax outperforms Q100 by $63\times$, on average, ranging from $0.9-539\times$. This is mostly due to the inherent inefficiency of the join algorithm of Q100 that generates a large number of intermediate results. While the Q100 performance on the Path3 query is comparable to TrieJax for most datasets, TrieJax outperforms Q100 by up to $539\times$ on complex queries such as Clique4. Q100 is also outperformed by Graphicionado, which is aimed for graph operations and offer better parallelism and sharing of data than Q100 for large queries such as Cycle4 and Clique4.

To summarize, TrieJax delivers dramatic speedups over both software and hardware baselines. Thanks to its internal design that reduces the number of intermediate results and , TrieJax is able to serve most of its data from its fast SRAM caches and minimizes its DRAM accesses. Finally, TrieJax’s aggressive use of multithreading allows it to hide the latency incurred by accessing both internal and external memories.

4.4 Energy efficiency

In order to understand the potential energy efficiency of TrieJax, we first explore how the accelerator’s energy consumption is distributed among its components.

Figure 15 presents the energy distribution in TrieJax for the examined queries, averaged over the different datasets. The figure clearly shows that the lion’s share of the energy consumed by TrieJax goes to the memory system and only a fraction of the energy is consumed by the TrieJax core logic. The dominant memory component is DRAM, which consumes $74-90\%$ of the overall energy. DRAM energy consumption is attributed to explicit read/write operations (mostly writing the final results to memory) and to implicit DRAM idle power (predominantly DRAM refresh operations). The second dominant energy consumer is the L1 cache. Although the cache is read-only and is not involved in writing the final results to memory, it serves the trie traversals triggered by misses in the partial join results cache. Finally, the PJR cache is responsible for up to 7.8% of the total energy consumption for the cycle4 query. Note, however, that for Cycle3 and Clique4 queries there are no valid intermediate result caches and it does no use any energy.

We now turn to compare the energy consumption of TrieJax versus that of the baseline systems. Figure 16 presents the comparison. Importantly, understanding that DRAM is by far the main energy consumer in TrieJax enables us to explain its reduced energy consumption compared to the software and hardware baselines.

When comparing TrieJax to the software baselines, it is not surprising to find that TrieJax much more energy efficient. TrieJax is $110\times$ more energy efficient on average than CTJ and $59\times$ more efficient than EmptyHeaded. This is attributed to three factors. The first factor contributing the TrieJax’s energy efficiency is the reduced energy consumption of its core logic, which is specifically designed to execute join operations and is thus much more energy efficient than a general-purpose core. This factor is slightly less dominant in the case of EmptyHeaded (which is almost $2\times$ more efficient than CTJ), since EmptyHeaded uses efficient CPU SIMD operations. The second contributing factor is the efficient TrieJax’s on-die caching of intermediate results and reduced thrashing of the memory system caches, which dramatically reduces the energy consumption of its memory system. The final contributing factor is the speedups obtained by TrieJax, which dramatically reduce the DRAM’s idle energy consumption.

TrieJax is also much more energy efficient than other hardware accelerators. Specifically, TrieJax consumes, on average, $179\times$ and $15\times$ less energy than Q100 and Graphicionado, respectively. This improved energy efficiency is attributed to two factors. First, the use of a WCOJ algorithm that reduces the number of intermediate results and eliminates most of the expensive DRAM accesses executed by Q100 and Graphicionado. Second, the faster run time of TrieJax dramatically reduces the idle energy consumption of the DRAM, which is mostly the result of periodic DRAM refresh operations.

To summarize, we see that the energy efficiency of graph and database hardware accelerators is bounded by their memory system. Primarily, the number of explicit read/write operations affects both energy consumption and performance. But the performance impact of the memory system also increases DRAM’s idle energy consumption. TrieJax’s caching of internal results thus minimizes its reliance on the memory system, thereby reducing both its active memory energy (read/write) and idle DRAM energy (implicit refresh).

5 Conclusions

We presented TrieJax, an on-chip domain-specific accelerator for graph operations specializing in graph pattern matching. It is driven by new advances in the database community and a plethora of new join algorithms that outperform traditional approaches. TrieJax leverages the inherent concurrency of the algorithm for parallel execution and latency hiding of irregular memory accesses. Furthermore, it integrates a specialized store for intermediate results that can drastically reduce recurrent computations.

We showed that TrieJax outperforms state-of-the-art graph analytics and database accelerators by $7-63\times$ on average, while consuming $15-179\times$ less energy. TrieJax further outperforms relational database management systems that use the modern join algorithms by $9-20\times$ and consumes $59-110\times$ less energy.

We plan to extend our accelerator to other important graph operations such as aggregations (e.g., triangle counting), and use novel algorithmic approaches to offer approximate estimations in a fraction of the time.

Appendix A Number of intermediate results

The design of our system is based on a WCOJ algorithm. A key benefit is the reduction of intermediate results being generated during the computation of graph pattern matching queries. We illustrate the benefit in Figure 18, which compares the number of intermediate results (log scale) on a representative set of benchmarks using CTJ (WCOJ algorithm) and a pairwise join algorithm. The pairwise join algorithm is used in both Q100 and Graphicionado.

On Path4 and Cycle4 queries, CTJ generates on average $18\times$ and $36\times$ fewer intermediate results than the pairwise join algorithm. While the pairwise join must generate all the intermediate results, CTJ only generates intermediate results that are part of the final result in compact caching structure.

Furthermore, CTJ only generates intermediate results that can later be reused to speedup the join. For example, CTJ does not generate any intermediate results for the Clique4 queries, because they cannot be reused.

Appendix B Main memory accesses

Figure 17 shows the number of main memory accesses for each baseline on a logarithmic scale. The figure clearly shows that the WCOJ algorithms, namely EmptyHeaded and CTJ, generate fewer accesses to main memory than the traditional approaches, namely Q100 and Graphicionado. On average, CTJ generates $2.8\times$ fewer memory accesses than EmptyHeaded, $47\times$ fewer than Graphicionado, and $105\times$ fewer than Q100. This matches our motivation for using a WCOJ-based solution for our system.