Pith. sign in

REVIEW 3 major objections 4 minor 53 references

RapidStore: An Efficient Dynamic Graph Storage System for Concurrent Queries

T0 review · 3 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Graph storage cuts concurrent query latency up to 71 percent by versioning whole subgraphs instead of edges.

desk verdict Polished systems paper with an uneven concurrency protocol: the GC race against reader registration is a real correctness bug that breaks snapshot isolation. read the letter →

arxiv 2507.00839 v1 pith:5JFCMIGW submitted 2025-07-01 cs.DB

Chiyu Hao , Jixian Su , Shixuan Sun , Hao Zhang , Sen Gao , Jianwen Zhao , Chenyi Zhang , Jieru Zhao
show 2 more authors
Chen Chen Minyi Guo
This is my paper · ORCID
classification cs.DB
keywords dynamicgraphstorageconcurrentqueriessubgraph-centricconcurrencycontrolcopy-on-writecompressedadaptiveradixtreemulti-versionanalyticsread-intensiveworkloads
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

RapidStore is an in-memory storage system for graphs that change over time, aimed at workloads where reads vastly outnumber writes. The paper argues that the usual per-edge versioning and vertex locking used for concurrency make reads slow: every edge access carries a version check, every vertex visit can contend with a writer's lock, and memory fills with version chains. Its answer is to version whole subgraphs instead of edges, so readers can build a consistent snapshot by picking one immutable version per subgraph and then traverse lock-free. The authors report that this approach brings analytic workloads to within 0.92x to 2.11x of a static CSR baseline, cuts query latency by 31.86 percent to 71.08 percent against the best alternative system, and saves up to 56.34 percent of memory, while keeping writes within a modest factor of the fastest competitor.

What carries the argument

The load-bearing piece is subgraph-centric multi-version concurrency control with copy-on-write: the graph is partitioned into subgraphs of 64 vertices; each update creates a new immutable snapshot of only the affected subgraph and links it into that subgraph's version chain; readers take the current read timestamp and assemble a snapshot by selecting, for each subgraph, the latest version with timestamp no greater than that start time. Because new versions are made by copying a root-to-leaf path in C-ART, a compressed adaptive radix tree whose leaves hold up to 256 consecutive vertex IDs, version creation is cheap and existing snapshots are never modified, so readers need no locks and never do version checks during scans or searches.

What would settle it

Run a stress test in which one writer transaction inserts edges spanning two subgraphs while a reader repeatedly checks a cross-subgraph invariant, such as a global edge counter or the presence of a two-edge path stored across the partition boundary. If the reader ever observes one updated subgraph together with an unupdated partner from the same commit, the atomic snapshot guarantee is broken; the protocol's correctness depends on the read timestamp making the whole multi-subgraph commit visible at once.

Watch

Extended reading notes

Core claim

On its own terms, the paper's central discovery is that the granularity of versioning, not the graph data structure alone, determines whether concurrent reads can be fast. By maintaining versions at the subgraph level, with each version an immutable copy-on-write snapshot stored separately from the data, RapidStore eliminates the per-edge version checks that dominate scan-heavy analytics, and by giving readers a start timestamp with lock-free snapshot construction it removes read-write lock contention. The C-ART structure then supplies constant-depth search, linear scans, and cheap path copying so that snapshot creation does not tax writes. The measured consequences are that PageRank, BFS, SSSP, WCC, and triangle counting all run close to static CSR speed while concurrent writers continue to make progress with little reader slowdown.

Load-bearing premise

The whole design rests on the assumption that a reader's start timestamp always defines a consistent graph state, even when one writer has updated several subgraphs at once; if a reader could see some of those updated subgraphs but not others, the snapshot guarantee would break.

Editorial extensions

If this is right

  • Read queries should stay fast even with many concurrent writers, because they never touch locks; the measured read completion time grows at most 13.36 percent with 4 writers and 28 readers, versus up to 41.04 percent for baseline systems.
  • Scan-heavy analytics and search-heavy work both benefit, with latency reduced by 31.86 percent to 71.08 percent over the best baseline across five standard graph algorithms and six datasets.
  • Memory footprint drops by up to 56.34 percent, because per-edge version chains are replaced by one copy-on-write path per subgraph version and vertex IDs are compressed inside C-ART leaves.
  • Write throughput remains within a 1.9x to 2.2x factor of the fastest insert-only baseline, and the system handles batch updates well because a large update amortizes the cost of copying shared paths.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The decoupling suggests that read latency under mixed workloads will be limited by memory bandwidth rather than by contention; the paper's bandwidth measurements point to a ceiling that faster memory or higher-radix tree nodes could raise.
  • An adaptive partition-size strategy, hinted at in the paper but not implemented, could reduce write conflicts on skewed graphs by shrinking partitions around hot vertices while keeping large partitions for low-degree regions; this is a testable extension not claimed by the authors.
  • Because C-ART compresses leaves by longest common prefix, the design should carry over naturally to graphs with 64-bit vertex IDs and to workloads that mix point lookups with range scans; this implication goes beyond the reported 32-bit experiments.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. RapidStore proposes an in-memory dynamic graph storage system targeting read-intensive concurrent workloads. The graph is partitioned into subgraphs, and each subgraph maintains a version chain, replacing per-edge versioning; write transactions use MV2PL with a global write timestamp, while readers register in a reader tracer and access immutable copy-on-write snapshots selected by a global read timestamp. The storage layer introduces C-ART, a leaf-compressed adaptive radix tree for high-degree neighbor sets, and a clustered index for low-degree vertices. The evaluation compares RapidStore with Sortledton, Teseo, Aspen, and LiveGraph on six datasets and five GAP workloads, reporting faster analytics, competitive insertion throughput, lower memory consumption, and better read-write concurrency than the baselines.

Significance. If the correctness issues are resolved, the paper makes a useful contribution: subgraph-level versioning is a clean way to eliminate per-edge version checks, C-ART's horizontal leaf compression and the clustered index are concrete and implementable ideas, and the evaluation is more thorough than the average systems paper (six datasets, five workloads, medians over five runs, four baselines, an ablation study, and a partition-size sensitivity analysis). The performance claims are falsifiable and mostly consistent with the reported experiments. However, the serializability guarantee currently rests on an informal proof, and the garbage-collection race described below means the central correctness claim is not yet established.

major comments (3)
  1. [§5.2.2, §5.3, Appendix A.1] The garbage-collection protocol has a snapshot-isolation race. A reader R samples the global read timestamp tr and then publishes its start time in the reader tracer via CAS. Between these two steps, a writer W can commit a new version at timestamp t, advance tr to t, and run GC on the modified subgraphs. Because R has not yet set its status bit, W's scan of the reader tracer does not see R, so W reclaims every non-latest version, including the version with timestamp tr that R is about to request. R then publishes tr and traverses the version chain, finding that the required snapshot has been freed, which can cause a use-after-free or a missing-version error. Appendix A.1 only argues that GC preserves versions of active readers; it does not cover a reader in the window between sampling tr and publishing its start time. The protocol needs a mechanism such as registering the slot before sampling tr, treating slots in the process of registration as active, or delaying GC until no reader can hold the pre-advance value of tr.
  2. [§5.2.1] The read-timestamp advancement rule is underspecified. The paper states that after assigning commit timestamp t, the writer polls tr and 'if tr = t-1, atomically increments tr by 1,' but it does not say what happens when the condition is false. Consider writers W1 and W2 receiving commit timestamps 1 and 2; if W2 finishes first, it observes tr=0 and, under a literal reading, proceeds without advancing tr. W1 later advances tr from 0 to 1, and no writer is left to advance it to 2, so readers permanently see a stale snapshot. The protocol must specify that a writer waits or retries until tr = t-1, or otherwise enforces ordered tr advancement, before completing its commit or performing GC; Proposition 5.1 depends on this.
  3. [§5.2.2 and §5.4] The reader snapshot construction is described as iterating over the version chains of all p subgraphs and copying p snapshot pointers into the reader workspace. For Friendster (|V|≈65M, |P|=64), p≈1M, so every read query pays O(p·k) ≈ 32M version-chain operations before performing any graph operation. This is inconsistent with the high search throughput reported in Appendix B.1 and with the claim that C-ART provides effectively constant-time search; the snapshot-construction cost alone would dominate short queries. Please clarify whether snapshot construction is eager, and if so report this cost in the experiments, or whether it is lazy/on-demand per accessed subgraph, and adjust the complexity analysis in §5.4 accordingly.
minor comments (4)
  1. [§5.1 vs §5.4] The partitioning rule is stated as contiguous blocks of |P| vertices in §5.1 and as 'randomly dividing the graph into equal-sized partitions' in §5.4; please reconcile these descriptions, since the definition of subgraphs and the vertex-index lookup depend on it.
  2. [§6.2 vs §6.5 and hyperparameters paragraph] The leaf segment size B is given as 256 in §6.2 and as 512 in §6.5 and the hyperparameters paragraph; please standardize the value and the notation.
  3. [§7.3] The sentence 'showing negligible performance drop even with 31 or 28 writers' appears to refer to the number of readers (31 or 28) given the fixed total of 32 threads; as written, 31 writers leaves only 1 reader, which conflicts with the subsequent memory-bandwidth saturation discussion.
  4. [§7.2] Aspen is described as designed for single-writer execution but is benchmarked with 32 writer threads; if this is intended as a stress test, please state so explicitly, otherwise use its supported configuration for the insertion comparison.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation found: RapidStore's performance claims rest on external baselines and ablations; only a minor non-load-bearing self-citation and a concurrency-proof gap appear.

full rationale

The central performance claims are backed by an implemented system measured against external baselines (Sortledton, Teseo, Aspen, LiveGraph, CSR) on six datasets, with component contributions isolated in the ablation study of Table 6. No fitted parameter is renamed as a prediction, and no uniqueness theorem from the authors' prior work is invoked to force a design choice. The only self-citation is reference [2], an anonymous technical report cited for full proof details; because the same proof is included in Appendix A, this citation is not load-bearing. A correctness concern does exist but is not circularity: in Section 5.2.1 the global read timestamp t_r is described as 'the latest consistent snapshot available to read queries,' and Appendix A.1 asserts that readers see a consistent state because 'write queries only advance t_r after committing all their updates.' This leaves unproven the interleaving in which a reader samples t_r before a writer advances it and then needs versions the writer's GC reclaims before the reader registers. That is a missing proof step in the concurrency-control argument, not a reduction of the paper's output to its input; the experimental results are not derived from that assertion. Accordingly, no specific circular step can be quoted, and the appropriate finding is no significant circularity, with score 2 reflecting the minor non-load-bearing self-citation rather than any circular reduction.

Assumptions & free parameters 2 free parameters · 3 assumptions · 2 invented entities

The free parameters are limited: partition size and leaf size, both empirically chosen. No constants are fitted to the target metrics. The main assumptions are standard concurrency control axioms and the correctness of the snapshot protocol, which is plausible but not machine-checked. The paper invents C-ART as a data structure and the subgraph-centric versioning mechanism, both with falsifiable performance handles.

free parameters (2)
  • partition size |P| = 64
    Globally set to 64 based on empirical read/write trade-off across two datasets (Section 5.4 and Figure 12). The performance results depend on this value.
  • leaf segment size B = 512
    Set to 512 in experiments, the text says this 'cooperates with AVX2 instructions'. No systematic sweep of B is shown, so it is a hand-chosen constant used in all results.
assumptions (3)
  • standard math MV2PL ensures write serializability when locks are acquired in sorted subgraph-ID order.
    This is a standard concurrency control result, but it is assumed and stated rather than proved in the paper (Section 5.2.1).
  • domain assumption The graph can be partitioned into equal-sized contiguous vertex-ID ranges without significant performance loss.
    The paper acknowledges static partitioning 'randomly dividing the graph into equal-sized partitions' is a limitation, and real workloads with skewed update patterns could invalidate the performance claims (Section 5.4).
  • domain assumption Reader start time is sampled as the current value of t_r, and t_r advances only after all subgraph versions of a commit are linked.
    This is the load-bearing atomicity assumption for snapshot consistency. The proof in Appendix A.1 assumes it but does not prove that the memory ordering in the implementation enforces it.
invented entities (2)
  • C-ART (Compressed Adaptive Radix Tree) independent evidence
    purpose: Stores neighbor sets of high-degree vertices with compact leaves, fast search, and copy-on-write support.
    The structure is new and its performance is evaluated in isolation through the ablation study and filling-ratio tables. It is a concrete data structure with a defined mechanism, though no external implementation exists yet.
  • Subgraph version chain with reader tracer independent evidence
    purpose: Coordinates snapshot visibility and garbage collection for coarse-grained versions.
    This is a system mechanism rather than a physical entity, and its correctness is testable through the reported concurrency experiments. The reader tracer is described in sufficient detail to be implemented independently.

how reviews work

0 comments
Cite this review

Pith. "Pith review of RapidStore: An Efficient Dynamic Graph Storage System for Concurrent Queries." pith.science (2026). https://pith.science/paper/5JFCMIGW

@misc{pith2026250700839,
  author       = {Pith},
  title        = {Pith review of: RapidStore: An Efficient Dynamic Graph Storage System for Concurrent Queries},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/5JFCMIGW}},
  note         = {Machine review of arXiv:2507.00839}
}
read the original abstract

Dynamic graph storage systems are essential for real-time applications such as social networks and recommendation, where graph data continuously evolves. However, they face significant challenges in efficiently handling concurrent read and write operations. We find that existing methods suffer from write queries interfering with read efficiency, substantial time and space overhead due to per-edge versioning, and an inability to balance performance, such as slow searches under concurrent workloads. To address these issues, we propose RapidStore, a holistic approach for efficient in-memory dynamic graph storage designed for read-intensive workloads. Our key idea is to exploit the characteristics of graph queries through a decoupled system design that separates the management of read and write queries and decouples version data from graph data. Particularly, we design an efficient dynamic graph store to cooperate with the graph concurrency control mechanism. Experimental results demonstrate that RapidStore enables fast and scalable concurrent graph queries, effectively balancing the performance of inserts, searches, and scans, and significantly improving efficiency in dynamic graph storage systems.

Figures

Figures reproduced from arXiv: 2507.00839 by the authors.

Figure 1
Figure 1. An example of ART. prefix from the root to that node. The byte sequence 𝑀 of a vertex is indexed from 0. To search vertex 𝑀 = 0𝑥010200𝐹 𝐹 , we first examine 𝑀 [0] = 01 in Node1 since Node1’s depth is 0, and follow the pointer to Node2. Due to path compression, Node2’s depth is 2, so we skip to 𝑀 [2] = 00 and proceed to Node3, which has a depth of 3. We match 𝑀 [3] = 𝐹 𝐹 in Node3 and retrieve the target vertex. Inser… view at source ↗
Figure 2
Figure 2. Performance under varying numbers of readers [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Insertion throughput as the number of readers [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (13 more)
Figure 4
Figure 4. Figure 4: An overview of RapidStore. queries in execution to free up resources. ○6 Release the locks held by the write query, allowing other queries to access the subgraphs. In contrast, RapidStore executes a read query as follows: ○1 Reg￾ister the query with the start time obta…
Figure 5
Figure 5. Figure 5: Overview of the multi-version graph store design with the copy-on-write strategy. without lock contention. Let ΔS be the set of subgraphs modified by 𝑊 , and let 𝑠 = |ΔS|. The workspace cost of 𝑊 is 𝑂(𝑠). Since RapidStore sorts ΔS to obtain locks, the time cost of acqu…
Figure 6
Figure 6. Figure 6: An example of C-ART storing the same elements [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: Insertion of vertex 𝑣 into 𝑁 (𝑢) stored in a C-ART. Red highlights the updated pointers. • Case 1: 𝑏 < 𝐵. Insert 𝑣 directly into the leaf and update the affected pointers in the parent node to reflect the change. • Case 2: 𝑏 = 𝐵 and the leaf is shared by multiple keys.…
Figure 8
Figure 8. Figure 8: Performance of write operations. Sortledton ranks second on most datasets, with other systems show￾ing similar performance trends. These results highlight RapidStore’s capability to efficiently handle random access patterns, a critical requirement in dynamic graph appl…
Figure 12
Figure 12. Figure 12: Write and read performance of RapidStore with varying partition sizes (|𝑃 |). execute PageRank. Figures 10 and 11 report insertion throughput and memory bandwidth utilization, respectively. As the number of readers increases from 0 to 4, RapidStore’s insertion through…
Figure 10
Figure 10. Figure 10: Insertion performance under varying numbers of [PITH_FULL_IMAGE:figures/full_fig_p011_10.png]
Figure 11
Figure 11. Figure 11: Corresponding avg. memory bandwidth usage rate [PITH_FULL_IMAGE:figures/full_fig_p011_11.png]
Figure 13
Figure 13. Figure 13: summarizes the memory consumption of the systems after inserting all edges, measured using the resident set size (RSS) reported by the operating system. RapidStore is the most memory￾efficient, saving up to 56.34% of memory compared to other systems. This efficiency i…
Figure 14
Figure 14. Figure 14: Performance of basic read operations. The reader tracer has a fixed size 𝑘, which is the maximum number of concurrent read queries the system supports. Therefore, there can be at most 𝑘 active read queries holding references to versions of 𝑆. Garbage Collection Proces…
Figure 15
Figure 15. Figure 15: Scalability with the number of writers varying. [PITH_FULL_IMAGE:figures/full_fig_p016_15.png]
Figure 17
Figure 17. Figure 17: Write throughput of the evaluated systems on the ldbc dataset. The left plot reports results using a randomly generated trace, while the right plot uses the real ldbc trace. Sortledton Teseo Aspen LiveGraph RapidStore 2 0 2 2 2 4 2 6 2 8 2 10 2 12 2 14 2 16 2 18 2 20 …
Figure 16
Figure 16. Figure 16: Evaluation of large writes with small lookups under varying batch sizes. The solid line represents write throughput (Batch Update), and the dashed line represents read throughput (Search), both measured in thousand edges per second (TEPS) [PITH_FULL_IMAGE:figures/ful…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

53 extracted references · 46 canonical work pages

  1. [1]

    Christopher R Aberger, Andrew Lamb, Susan Tu, Andres Nötzli, Kunle Olukotun, and Christopher Ré. 2017. Emptyheaded: A relational engine for graph processing. ACM Transactions on Database Systems (TODS) 42, 4 (2017), 1–44

    work page 2017

  2. [2]

    Anonymous. 2024. RapidStore: An Efficient Dynamic Graph Stor- age System for Concurrent Queries. https://drive.google.com/file/d/ 1JloreneahMUu1OO7o6qkCLIoPQeHo_GJ/view. Accessed: 2025-7-1

    work page 2024

  3. [3]

    Scott Beamer, Krste Asanović, and David Patterson. 2015. The GAP benchmark suite. arXiv preprint arXiv:1508.03619 (2015)

    arXiv 2015

  4. [4]

    Nathan Bronson, Zach Amsden, George Cabrera, Prasad Chakka, Peter Dimov, Hui Ding, Jack Ferris, Anthony Giardullo, Sachin Kulkarni, Harry Li, et al. 2013. {TAO}:{Facebook’s} distributed data store for the social graph. In 2013 USENIX Annual Technical Conference (USENIX ATC 13). 49–60

    work page 2013

  5. [5]

    Yuze Chi, Guohao Dai, Yu Wang, Guangyu Sun, Guoliang Li, and Huazhong Yang. 2016. Nxgraph: An efficient graph processing system on a single machine. In 2016 IEEE 32nd International Conference on Data Engineering (ICDE) . IEEE, 409–420

    work page 2016

  6. [6]

    James C Corbett, Jeffrey Dean, Michael Epstein, Andrew Fikes, Christopher Frost, Jeffrey John Furman, Sanjay Ghemawat, Andrey Gubarev, Christopher Heiser, Peter Hochschild, et al. 2013. Spanner: Google’s globally distributed database. ACM Transactions on Computer Systems (TOCS) 31, 3 (2013), 1–22

    2013

  7. [7]

    Dean De Leo and Peter Boncz. 2019. Packed memory arrays-rewired. In 2019 IEEE 35th International Conference on Data Engineering (ICDE) . IEEE, 830–841

    work page 2019

  8. [8]

    Dean De Leo and Peter Boncz. 2021. Teseo and the analysis of structural dynamic graphs. Proceedings of the VLDB Endowment 14, 6 (2021), 1053–1066

    work page 2021

Show all 53 references
  1. [9]

    Laxman Dhulipala, Guy E Blelloch, Yan Gu, and Yihan Sun. 2022. Pac-trees: Supporting parallel and compressed purely-functional collections. In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. 108–121

    2022

  2. [10]

    Laxman Dhulipala, Guy E Blelloch, and Julian Shun. 2019. Low-latency graph streaming using compressed purely-functional trees. In Proceedings of the 40th ACM SIGPLAN conference on programming language design and implementation . 918–934

    2019

  3. [11]

    Cristian Diaconu, Craig Freedman, Erik Ismert, Per-Ake Larson, Pravin Mittal, Ryan Stonecipher, Nitin Verma, and Mike Zwilling. 2013. Hekaton: SQL server’s memory-optimized OLTP engine. In Proceedings of the 2013 ACM SIGMOD Inter- national Conference on Management of Data . 1243–1254

    2013

  4. [12]

    David Ediger, Rob McColl, Jason Riedy, and David A Bader. 2012. Stinger: High performance data structure for streaming graphs. In 2012 IEEE Conference on High Performance Extreme Computing . IEEE, 1–5

    2012

  5. [13]

    Guanyu Feng, Zixuan Ma, Daixuan Li, Shengqi Chen, Xiaowei Zhu, Wentao Han, and Wenguang Chen. 2021. Risgraph: A real-time streaming system for evolving graphs to support sub-millisecond per-update analysis at millions ops/s. In Proceedings of the 2021 International Conference ...

    2021

  6. [14]

    Xiyang Feng, Guodong Jin, Ziyi Chen, Chang Liu, and Semih Salihoğlu. 2023. Kùzu Graph Database Management System. In CIDR

    2023

  7. [15]

    Per Fuchs, Domagoj Margan, and Jana Giceva. 2022. Sortledton: a universal, transactional graph data structure. Proceedings of the VLDB Endowment 15, 6 (2022), 1173–1186

    2022

  8. [16]

    Joseph E Gonzalez, Yucheng Low, Haijie Gu, Danny Bickson, and Carlos Guestrin

  9. [17]

    Pankaj Gupta, Venu Satuluri, Ajeet Grewal, Siva Gurumurthy, Volodymyr Zhabiuk, Quannan Li, and Jimmy Lin. 2014. Real-time twitter recommenda- tion: Online motif detection in large dynamic graphs. Proceedings of the VLDB Endowment 7, 13 (2014), 1379–1380

    2014

  10. [18]

    Shuo Han, Lei Zou, and Jeffrey Xu Yu. 2018. Speeding up set intersections in graph algorithms using simd instructions. In Proceedings of the 2018 International Conference on Management of Data . 1587–1602

    2018

  11. [19]

    Chathura Kankanamge, Siddhartha Sahu, Amine Mhedbhi, Jeremy Chen, and Semih Salihoglu. 2017. Graphflow: An active graph database. In Proceedings of the 2017 ACM International Conference on Management of Data . 1695–1698

    2017

  12. [20]

    Pradeep Kumar and H Howie Huang. 2020. Graphone: A data store for real-time analytics on evolving graphs. ACM Transactions on Storage (TOS) 15, 4 (2020), 1–40

    2020

  13. [21]

    Per-Åke Larson, Spyros Blanas, Cristian Diaconu, Craig Freedman, Jignesh M Patel, and Mike Zwilling. 2011. High-Performance Concurrency Control Mech- anisms for Main-Memory Databases. Proceedings of the VLDB Endowment 5, 4 (2011)

    2011

  14. [22]

    Viktor Leis, Alfons Kemper, and Thomas Neumann. 2013. The adaptive radix tree: ARTful indexing for main-memory databases. In 2013 IEEE 29th International Conference on Data Engineering (ICDE) . IEEE, 38–49

    2013

  15. [23]

    Youhuan Li, Lei Zou, M Tamer Özsu, and Dongyan Zhao. 2020. Space-Efficient Subgraph Search Over Streaming Graph With Timing Order Constraint. IEEE Transactions on Knowledge and Data Engineering 34, 9 (2020), 4453–4467

    2020

  16. [24]

    Hyeontaek Lim, Michael Kaminsky, and David G Andersen. 2017. Cicada: De- pendably fast multi-core in-memory transactions. InProceedings of the 2017 ACM International Conference on Management of Data . 21–35

    2017

  17. [25]

    Peter Macko, Virendra J Marathe, Daniel W Margo, and Margo I Seltzer. 2015. Llama: Efficient graph analytics using large multiversioned arrays. In 2015 IEEE 31st International Conference on Data Engineering . IEEE, 363–374

    2015

  18. [26]

    Mugilan Mariappan and Keval Vora. 2019. Graphbolt: Dependency-driven syn- chronous processing of streaming graphs. InProceedings of the Fourteenth EuroSys Conference 2019. 1–16

    2019

  19. [27]

    Robert Campbell McColl, David Ediger, Jason Poovey, Dan Campbell, and David A Bader. 2014. A performance evaluation of open source graph databases. In Proceedings of the first workshop on Parallel programming for analytics applications. 11–18

    2014

  20. [28]

    Thomas Neumann, Tobias Mühlbauer, and Alfons Kemper. 2015. Fast serializ- able multi-version concurrency control for main-memory database systems. In Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data. 677–689

    2015

  21. [29]

    Prashant Pandey, Brian Wheatman, Helen Xu, and Aydin Buluc. 2021. Terrace: A hierarchical graph container for skewed dynamic graphs. In Proceedings of the 2021 International Conference on Management of Data . 1372–1385

    2021

  22. [30]

    Xiafei Qiu, Wubin Cen, Zhengping Qian, You Peng, Ying Zhang, Xuemin Lin, and Jingren Zhou. 2018. Real-time constrained cycle detection in large dynamic graphs. Proceedings of the VLDB Endowment 11, 12 (2018), 1876–1888

    2018

  23. [31]

    M Mazhar Rathore, Awais Ahmad, Anand Paul, and Gwanggil Jeon. 2015. Efficient graph-oriented smart transportation using internet of things generated big data. In 2015 11th International Conference on Signal-Image Technology & Internet-Based Systems (SITIS). IEEE, 512–519

    2015

  24. [32]

    Pedro Ribeiro and Fernando Silva. 2014. G-tries: a data structure for storing and finding subgraphs. Data Mining and Knowledge Discovery 28 (2014), 337–377

    2014

  25. [33]

    Siddhartha Sahu, Amine Mhedhbi, Semih Salihoglu, Jimmy Lin, and M Tamer Özsu. 2017. The ubiquity of large graphs and surprising challenges of graph processing. Proceedings of the VLDB Endowment 11, 4 (2017), 420–431

    2017

  26. [34]

    Aneesh Sharma, Jerry Jiang, Praveen Bommannavar, Brian Larson, and Jimmy Lin. 2016. GraphJet: Real-time content recommendations at Twitter. Proceedings of the VLDB Endowment 9, 13 (2016), 1281–1292

    2016

  27. [35]

    Sijie Shen, Zihang Yao, Lin Shi, Lei Wang, Longbin Lai, Qian Tao, Li Su, Rong Chen, Wenyuan Yu, Haibo Chen, et al. 2023. Bridging the Gap between Relational {OLTP} and Graph-based{OLAP}. In 2023 USENIX Annual Technical Conference (USENIX ATC 23). 181–196

    2023

  28. [36]

    Jifan Shi, Biao Wang, and Yun Xu. 2024. Spruce: a Fast yet Space-saving Structure for Dynamic Graph Storage. Proceedings of the ACM on Management of Data 2, 1 (2024), 1–26

    2024

  29. [37]

    Julian Shun and Guy E Blelloch. 2013. Ligra: a lightweight graph processing framework for shared memory. In Proceedings of the 18th ACM SIGPLAN sympo- sium on Principles and practice of parallel programming . 135–146

    2013

  30. [38]

    Julian Shun, Laxman Dhulipala, and Guy E Blelloch. 2015. Smaller and faster: Parallel processing of compressed graphs with Ligra+. In 2015 Data Compression Conference. IEEE, 403–412

    2015

  31. [39]

    Weiping Song, Zhiping Xiao, Yifan Wang, Laurent Charlin, Ming Zhang, and Jian Tang. 2019. Session-based social recommendation via dynamic graph attention networks. In Proceedings of the Twelfth ACM international conference on web search and data mining . 555–563

    2019

  32. [40]

    Yihan Sun, Daniel Ferizovic, and Guy E Belloch. 2018. PAM: parallel augmented maps. In Proceedings of the 23rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming . 290–304

    2018

  33. [41]

    Stephen Tu, Wenting Zheng, Eddie Kohler, Barbara Liskov, and Samuel Madden

  34. [42]

    Keval Vora, Rajiv Gupta, and Guoqing Xu. 2017. Kickstarter: Fast and accurate computations on streaming graphs via trimmed approximations. In Proceed- ings of the twenty-second international conference on architectural support for programming languages and operating systems . 237–251

    2017

  35. [43]

    Jianguo Wang, Chunbin Lin, Yannis Papakonstantinou, and Steven Swanson

  36. [44]

    Brian Wheatman and Helen Xu. 2018. Packed compressed sparse row: A dy- namic graph representation. In 2018 IEEE High Performance extreme Computing Conference (HPEC). IEEE, 1–7

    2018

  37. [45]

    Boyu Yang, Weiguo Zheng, Xiang Lian, Yuzheng Cai, and X Sean Wang. 2024. HERO: A Hierarchical Set Partitioning and Join Framework for Speeding up the Set Intersection Over Graphs. Proceedings of the ACM on Management of Data 2, 1 (2024), 1–25

    2024

  38. [46]

    Tangwei Ying, Hanhua Chen, and Hai Jin. 2020. Pensieve: Skewness-aware version switching for efficient graph processing. In Proceedings of the 2020 ACM SIGMOD International Conference on Management of Data . 699–713

    2020

  39. [47]

    Song Yu, Shufeng Gong, Qian Tao, Sijie Shen, Yanfeng Zhang, Wenyuan Yu, Pengxi Liu, Zhixin Zhang, Hongfu Li, Xiaojian Luo, et al . 2024. LSMGraph: Chiyu Hao1, Jixian Su1, Shixuan Sun1, Hao Zhang2, Sen Gao1, Jianwen Zhao2, Chenyi Zhang2, Jieru Zhao1, Chen Chen1, Minyi Guo1 A Hi...

    2024

  40. [48]

    Siyi Zhang, Xiaoxi Cui, Yurong Cheng, Ye Yuan, and Guoren Wang. 2022. Online Global Query Planning for Dynamic Road Networks. In 2022 IEEE 8th Inter- national Conference on Cloud Computing and Intelligent Systems (CCIS) . IEEE, 666–670

    2022

  41. [49]

    Xiaowei Zhu, Guanyu Feng, Marco Serafini, Xiaosong Ma, Jiping Yu, Lei Xie, Ashraf Aboulnaga, and Wenguang Chen. 2019. Livegraph: A transactional graph storage system with purely sequential adjacency list scans. arXiv preprint arXiv:1910.05773 (2019). RapidStore: An Efficient D...

    2019 arXiv

  42. [53]

    The condi- tion𝑡𝑟 =𝑡− 1 enforces that writes with earlier timestamps have already advanced𝑡𝑟 , thereby preventing out-of-order commits

    This step ensures that write queries commit in the serial order determined by their commit timestamps. The condi- tion𝑡𝑟 =𝑡− 1 enforces that writes with earlier timestamps have already advanced𝑡𝑟 , thereby preventing out-of-order commits. (4) Serial Equivalence: Since write qu...

  43. [2012]

    In 10th USENIX symposium on operating systems design and implementation (OSDI 12)

    PowerGraph: Distributed Graph-Parallel Computation on Natural Graphs. In 10th USENIX symposium on operating systems design and implementation (OSDI 12). 17–30

  44. [2013]

    In Proceedings of the Twenty-Fourth ACM Symposium on Operating Systems Principles

    Speedy transactions in multicore in-memory databases. In Proceedings of the Twenty-Fourth ACM Symposium on Operating Systems Principles . 18–32

  45. [2017]

    inverted list compression

    An experimental study of bitmap compression vs. inverted list compression. In Proceedings of the 2017 ACM International Conference on Management of Data . 993–1008

    2017

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.