Pith. sign in

REVIEW 4 major objections 4 minor 41 references

EnGN: A High-Throughput and Energy-Efficient Accelerator for Large Graph Neural Networks

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

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

Pith's one-line read This paper claims a ring-connected PE array makes large GNNs run 1802.9x faster than CPU and 19.75x faster than GPU.

desk verdict Genuine architectural ideas in this GNN accelerator, but the headline HyGCN comparison is under-scrutinized and the paper contradicts itself on energy efficiency (1.85X vs. 6.2X), so treat the numbers as conditional. read the letter →

arxiv 1909.00155 v3 pith:OZLNC7CH submitted 2019-08-31 cs.DC

Shengwen Liang , Ying Wang , Cheng Liu , Lei He , Huawei Li , Xiaowei Li This is my paper · ORCID
classification cs.DC
keywords graphneuralnetworkhardwareacceleratorring-edge-reducedataflowtilingdegree-awarecacheenergyefficiencyGNNinferenceedge-centricprocessing
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

This paper tries to establish that a single, edge-centric accelerator can serve the common three-stage computation shared by diverse graph neural networks and beat both general-purpose processors and a specialized GCN accelerator on speed and energy. The core proposal is the ring-edge-reduce (RER) dataflow, which passes vertex properties around a ring of processing elements so aggregation happens inside the array instead of through random memory lookups. Supporting mechanisms are graph-property-aware mapping, edge reordering, graph tiling with adaptive row/column scheduling, and a degree-aware vertex cache. The evidence comes from a cycle-accurate simulator co-verified against a synthesized 14nm RTL design, reporting average speedups of 1802.9x over CPU, 19.75x over GPU, and 2.97x over a prior GCN accelerator, with energy-efficiency gains of 1326.35x, 304.43x, and 6.2x respectively. If these numbers hold, they make a strong case that domain-specific GNN accelerators can be built around one unified dataflow rather than a mosaic of specialized units.

What carries the argument

The load-bearing mechanism is the ring-edge-reduce (RER) dataflow: vertex properties circulate through a ring-connected PE array while each PE aggregates the properties destined for its row, turning random neighbor access into nearest-neighbor communication. It is paired with edge reordering, graph tiling, dimension-aware stage reordering, and a degree-aware vertex cache.

What would settle it

Build a cycle-exact model of the prior GCN accelerator with the same 14nm SRAM memory system and the same HBM model, run the same GNN/dataset workloads, and compare end-to-end cycles; if the EnGN-vs-prior speedup drops below 2.97x, or if an independent RTL checkout of the simulator changes cycle counts, the central comparison fails.

Watch

Extended reading notes

Core claim

EnGN's central claim is that GNN propagation can be factored into feature extraction, aggregate, and update, and that all three can be executed on one homogeneous array of processing elements connected in a ring. The RER dataflow streams vertex properties around the ring; each PE picks out the values it needs according to the edge list, so sparse, randomly connected neighbor gathering becomes a sequence of nearest-neighbor transfers. Edge reorganization arranges the edge list in the order properties rotate through the ring, closing most of the gap to a fully connected PE column. The design also exploits the algebraic identity that, when aggregation is a sum, feature extraction and aggregation commute ($\sigma(A(XW)) = \sigma((AX)W)$), letting the compiler choose the cheaper order based on input versus output feature dimensions. Large graphs are handled by tiling into shards that fit on chip, with tile scheduling chosen from explicit read/write cost formulas, and a degree-aware vertex cache reserves its entries for high-degree vertices to improve hit rates on power-law graphs.

Load-bearing premise

The headline speedup and energy ratios depend on the cycle-accurate simulator faithfully representing the designed hardware, and on the prior GCN accelerator's published results being directly comparable despite different process nodes and memory technologies.

Editorial extensions

If this is right

  • A single 128x16 PE array with the RER dataflow can execute five common GNN families (GCN, GraphSage-Pool, Gated-GCN, GRN, R-GCN) without separate neural-network and graph-processing units.
  • Edge reorganization alone lifts RER aggregate utilization to near-ideal, yielding up to 5.4x speedup on large graphs.
  • Adaptive tile scheduling can cut off-chip I/O by tens of times relative to fixed row- or column-major order on graphs with many output classes.
  • Dimension-aware stage reordering reduces aggregate work when feature dimensions change across layers, with up to 8.96x improvement over a fixed aggregate-first order on one dataset.
  • Even with a much smaller on-chip buffer (1.6MB versus 22MB), the architecture retains about 3x speedup over a prior GCN accelerator, indicating that its memory hierarchy substitutes for raw capacity.

Reading between the lines

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

  • Editorial extension: if the simulator-to-RTL co-verification holds, the same three-stage abstraction could carry to GNN training, where gradient aggregation follows the same edge-centric reduce pattern but doubles the data movement.
  • Editorial extension: the commutative identity for sum aggregation suggests compiler- or runtime-level automatic selection of stage order for any GNN with sum aggregation, going beyond the paper's manual dimension-aware heuristic.
  • Editorial extension: degree-aware caching could be ported to CPU and GPU graph workloads by pinning high-degree vertices in reserved cache ways, a directly testable software adaptation.
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

4 major / 4 minor

Summary. The paper presents EnGN, a specialized accelerator for graph neural network inference. EnGN abstracts GNN propagation into feature-extraction, aggregate, and update stages; proposes a ring-edge-reduce (RER) dataflow and PE array; introduces a degree-aware vertex cache (DAVC); and adds graph tiling with adaptive scheduling and dimension-aware stage reordering (DASR). The evaluation, based on a cycle-accurate simulator co-verified with an RTL design, reports average speedups of 1802.9x, 19.75x, and 2.97x over CPU, GPU, and HyGCN, and energy-efficiency gains of 1326.35x, 304.43x, and 6.2x, respectively.

Significance. The architectural ideas are internally coherent, and the paper contains useful analysis, including the tiling I/O-cost comparison in Eq. (8) and the RER edge-reorganization example in Fig. 6. If the performance claims survive scrutiny, EnGN would be a meaningful contribution to GNN acceleration. However, the headline numbers rest on an unpublished simulator, an uncorrected cross-technology baseline comparison, and cache parameters tuned on the same benchmarks; these issues must be resolved before the quantitative claims can be accepted as stated. The paper does not provide machine-checked proofs or reproducible code, so the evaluation is not independently verifiable from the manuscript alone.

major comments (4)
  1. [Section 6.2 (Power&Area vs Energy Efficiency), Abstract, Conclusion] The paper reports two different energy-efficiency ratios versus HyGCN: 1.85X in the 'Power&Area' paragraph and 6.2X in the 'Energy Efficiency' paragraph, the Abstract, and the Conclusion. Table 4 gives HyGCN energy efficiency as 1.30 GOPS/W and EnGN as 2.40 GOPS/W, a ratio of 1.85X; the 6.2X figure is unexplained. Because this ratio is a headline claim, the authors must specify the exact metric (peak vs achieved throughput, inclusion/exclusion of memory power) and reconcile the numbers.
  2. [Section 6.1 (Baselines), Table 4] The HyGCN baseline is not re-simulated or re-synthesized; its runtime, power (6.7W), and energy efficiency (1.30 GOPS/W) are taken from the HyGCN publication. HyGCN is on 12nm with 22MB eDRAM, while EnGN is synthesized in 14nm with SRAM. The paper states that it replaces eDRAM with SRAM for EnGN but applies no technology or memory-technology scaling to HyGCN's power and energy figures. Given that the accelerator-vs-accelerator speedup is only 2.97X, a 1.5-2X change in HyGCN baseline assumptions could flip the conclusion; the comparison protocol needs to be made explicit and robust.
  3. [Section 6.3 (Degree Aware Vertex Cache)] The DAVC design parameters are selected on the same benchmarks used for evaluation. Figure 16(a) is used to set the reserved proportion to all cache entries and Fig. 16(b) to set the 64KB size. This is parameter fitting rather than a validation of the degree-aware policy; the paper should either fix the parameters a priori from graph statistics or report cross-validation and sensitivity to held-out graphs. Otherwise the general claim of a 'degree-aware' benefit is not supported.
  4. [Section 6.1 (Accelerator simulator)] The performance evaluation relies entirely on a cycle-accurate simulator that is stated to be co-verified with a synthesized RTL design, but neither the simulator nor the RTL is described in sufficient detail for independent verification. Since all headline numbers (1802.9X, 19.75X, 2.97X) are simulator outputs, the paper should include at least a validation subsection with RTL-vs-simulator cycle counts for representative kernels, or make the simulator available.
minor comments (4)
  1. [Section 6.2 (Throughput)] The text says the average throughput is 3265.87 GOP/s, achieving 79.7% of peak throughput i.e. 4096 GOP/s, but Table 4 lists peak performance as 6144 GOP/s for EnGN. With 6144, the achieved fraction is 53.1%; the authors should correct either the table or the text.
  2. [Fig. 9] The figure panels report speedups for CPU-DGL/EnGN, CPU-PyG/EnGN, GPU-DGL/EnGN, GPU-PyG/EnGN, and HyGCN/EnGN, but the axis is labeled only 'Speedup' without specifying the direction; consider adding explicit 'baseline/EnGN' annotations to avoid ambiguity.
  3. [Algorithm 1] In Algorithm 1, the update loop over edges (lines 6-8) appears to update a destination vertex once per incident edge, which may be a per-edge or per-vertex operation; the pseudocode would be clearer if the update loop were over vertices rather than edges.
  4. [Section 7.1 and reference [36]] The citation for reference [36] is 'Gram: Scaling graph computation to the trillions,' but the text refers to a geometric learning library based on PyTorch; please check the citation numbering and attach the correct reference.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found; the speedup claims rest on an external simulator-based evaluation rather than on equations fitted to the claimed results.

full rationale

The paper's headline speedups and energy-efficiency ratios are obtained from a cycle-accurate simulator whose timing is co-verified against a synthesized RTL design (Section 6.1), not from an analytic model whose parameters are fitted to the target metrics. The CPU/GPU results are measured from DGL/PyG executions, while the HyGCN comparison uses HyGCN's published power and throughput numbers as external baselines rather than as fitted inputs. The DAVC proportion and capacity are selected by sweeping cache-hit rate on the benchmark graphs (Section 6.3), which is a design-configuration choice and a possible overfitting concern, but the reported speedups are measurements of the resulting design, not predictions forced by the fitted parameter. The associativity-based stage reordering (Eqs. 6-7) and the I/O-cost scheduling comparison (Table 3) are algebraic derivations that do not assume the conclusions. No load-bearing self-citation appears; references to HyGCN and prior graph accelerators are to external groups. The internal discrepancy between the 1.85X and 6.2X energy-efficiency claims is a consistency or accuracy issue, not circularity. Therefore no step of the claimed derivation chain reduces to its own inputs by construction.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The central performance claims depend on several hand-chosen design parameters (DAVC proportion and size, PE array dimensions) and on domain assumptions about GNN structure and graph degree distributions. The cache parameters are tuned on the same benchmark graphs used to report speedups, which can make the reported results optimistic relative to an unbiased evaluation.

free parameters (3)
  • DAVC reserved cache proportion = 1.0 (all entries reserved for high-degree vertices)
    Set by sweeping the proportion from 0 to 1 on the evaluation graphs (Fig 16a); used for all reported results.
  • DAVC cache size = 64KB
    Chosen from a cache-size sweep on the benchmark graphs (Fig 16b); affects the aggregate-stage performance via hit rate.
  • PE array size = 128x16
    Hand-selected design point; sensitivity analysis in Fig 17 shows that throughput varies with array size, so this choice partially determines the reported GOP/s.
assumptions (4)
  • domain assumption The three-stage abstraction (feature extraction, aggregate, update) covers the computing patterns of typical GNNs including GCN, GS-Pool, R-GCN, Gated-GCN, and GRN.
    The design and evaluation assume that all target GNNs can be mapped to these three stages; GS-Pool is later excluded from DASR because its average operator prevents stage reordering, indicating the abstraction is not universal. See Section 2.2, Algorithm 1.
  • domain assumption Real-world graphs exhibit a power-law degree distribution, making a degree-aware cache beneficial.
    Motivates DAVC; the paper cites Broder et al. but does not verify this property on all benchmark datasets. See Section 4.2.
  • standard math Matrix multiplication is associative, so feature extraction and summation-based aggregation can be reordered without changing results.
    This is the basis for dimension-aware stage reordering (Observation 1 in Section 5.1).
  • domain assumption The HBM 2.0 energy of 3.9 pJ/bit from prior literature is a valid input for estimating on-chip and off-chip energy.
    Used for energy-efficiency calculations; the value is taken from reference [30] rather than measured in this design. See Section 6.1.

how reviews work

0 comments
Cite this review

Pith. "Pith review of EnGN: A High-Throughput and Energy-Efficient Accelerator for Large Graph Neural Networks." pith.science (2026). https://pith.science/paper/OZLNC7CH

@misc{pith2026190900155,
  author       = {Pith},
  title        = {Pith review of: EnGN: A High-Throughput and Energy-Efficient Accelerator for Large Graph Neural Networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/OZLNC7CH}},
  note         = {Machine review of arXiv:1909.00155}
}
read the original abstract

Graph neural networks (GNNs) emerge as a powerful approach to process non-euclidean data structures and have been proved powerful in various application domains such as social networks and e-commerce. While such graph data maintained in real-world systems can be extremely large and sparse, thus employing GNNs to deal with them requires substantial computational and memory overhead, which induces considerable energy and resource cost on CPUs and GPUs. In this work, we present a specialized accelerator architecture, EnGN, to enable high-throughput and energy-efficient processing of large-scale GNNs. The proposed EnGN is designed to accelerate the three key stages of GNN propagation, which is abstracted as common computing patterns shared by typical GNNs. To support the key stages simultaneously, we propose the ring-edge-reduce(RER) dataflow that tames the poor locality of sparsely-and-randomly connected vertices, and the RER PE-array to practice RER dataflow. In addition, we utilize a graph tiling strategy to fit large graphs into EnGN and make good use of the hierarchical on-chip buffers through adaptive computation reordering and tile scheduling. Overall, EnGN achieves performance speedup by 1802.9X, 19.75X, and 2.97X and energy efficiency by 1326.35X, 304.43X, and 6.2X on average compared to CPU, GPU, and a state-of-the-art GCN accelerator HyGCN, respectively.

Figures

Figures reproduced from arXiv: 1909.00155 by the authors.

Figure 2
Figure 2. Execution time breakdown of GNN models. of each vertex’s incoming neighbors. As shown in [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Execution time of GCN model on graph with 0.25M [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 5
Figure 5. Architecture details. computing structure. In this manner, each PE in the same column of PE-array is responsible for a single dimension of vertex property and each PE in the same row handles a single vertex. The properties of a vertex are arranged in columns and aligned in the property bank. The dimen￾sions of input vertex property become independent to the hardware architecture and can be continuously injected into… view at source ↗
Figures from the paper (6 more)
Figure 7
Figure 7. Figure 7: Memory hierarchy. will be directly read to DST RF in the PE unit. Otherwise, EnGN will access the last-level result banks. In this manner, the DAVC can alleviate the overhead incurred by the result bank accesses. 5 ENGN OPTIMIZATION 5.1 Observations of GNN computing To…
Figure 8
Figure 8. Figure 8: Graph tiling and tile scheduling. accumulation in aggregate. When Eq. 6 is used, the number of operations is E × F. When Eq. 7 is chosen, the amount of operations becomes E × H. While the property dimension varies as observed in last subsection, F is not equal to H. To…
Figure 9
Figure 9. Figure 9: Performance comparison of EnGN over CPU, GPU, and HyGCN. (a) Performance speedup of EnGN over CPU-DGL [PITH_FULL_IMAGE:figures/full_fig_p010_9.png]
Figure 10
Figure 10. Figure 10: Throughput of EnGN, CPU, GPU, and HyGCN. Some datasets are ignored due to literature space constraints. [PITH_FULL_IMAGE:figures/full_fig_p010_10.png]
Figure 12
Figure 12. Figure 12: Performance comparison of GNNs with original edge layout and reorganized edge layout. Note that both the [PITH_FULL_IMAGE:figures/full_fig_p011_12.png]
Figure 16
Figure 16. Figure 16: Cache hit ratio over different proportions (a) and cache size (KB)(b). [PITH_FULL_IMAGE:figures/full_fig_p012_16.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

41 extracted references · 25 canonical work pages

  1. [1]

    Imagenet classifi- cation with deep convolutional neural networks,

    A. Krizhevsky, I. Sutskever, and G. E. Hinton, “Imagenet classifi- cation with deep convolutional neural networks,” Commun. ACM, vol. 60, no. 6, pp. 84–90, May 2017

    work page 2017

  2. [2]

    Semi-supervised classification with graph convolutional networks,

    T. N. Kipf and M. Welling, “Semi-supervised classification with graph convolutional networks,” CoRR, vol. abs/1609.02907, 2016

    arXiv 2016

  3. [3]

    Fastgcn: Fast learning with graph convolutional networks via importance sampling,

    J. Chen, T. Ma, and C. Xiao, “Fastgcn: Fast learning with graph convolutional networks via importance sampling,” CoRR, vol. abs/1801.10247, 2018

    arXiv 2018

  4. [4]

    Knowl- edge transfer for out-of-knowledge-base entities: A graph neural network approach,

    T. Hamaguchi, H. Oiwa, M. Shimbo, and Y. Matsumoto, “Knowl- edge transfer for out-of-knowledge-base entities: A graph neural network approach,” CoRR, vol. abs/1706.05674, 2017

    arXiv 2017

  5. [5]

    Aligraph: A comprehensive graph neural network platform,

    R. Zhu, K. Zhao, H. Yang, W. Lin, C. Zhou, B. Ai, Y. Li, and J. Zhou, “Aligraph: A comprehensive graph neural network platform,” CoRR, vol. abs/1902.08730, 2019

    arXiv 1902

  6. [6]

    Euler: A distributed graph deep learning framework

    Alibaba, “Euler: A distributed graph deep learning framework.” [Online]. Available: https://github.com/alibaba/euler

    work page

  7. [7]

    Deep graph library: Towards efficient and scalable deep learning on graphs,

    M. Wang, L. Yu, D. Zheng, Q. Gan, Y. Gai, Z. Ye, M. Li, J. Zhou, Q. Huang, C. Ma, Z. Huang, Q. Guo, H. Zhang, H. Lin, J. Zhao, J. Li, A. J. Smola, and Z. Zhang, “Deep graph library: Towards efficient and scalable deep learning on graphs,” ArXiv, vol. abs/1909.01315, 2019

    arXiv 1909

  8. [8]

    Fast graph representation learning with pytorch geometric,

    M. Fey and J. E. Lenssen, “Fast graph representation learning with pytorch geometric,” ArXiv, vol. abs/1903.02428, 2019

    arXiv 1903

Show all 41 references
  1. [9]

    Neugraph: Parallel deep neural network computation on large graphs,

    L. Ma, Z. Yang, Y. Miao, J. Xue, M. Wu, L. Zhou, and Y. Dai, “Neugraph: Parallel deep neural network computation on large graphs,” in 2019 USENIX Annual Technical Conference (USENIX ATC 19). Renton, WA: USENIX Association, Jul. 2019, pp. 443– 458

    2019

  2. [10]

    Graph structure in the web,

    A. Broder, R. Kumar, F. Maghoul, P . Raghavan, S. Rajagopalan, R. Stata, A. Tomkins, and J. Wiener, “Graph structure in the web,” Comput. Netw., vol. 33, no. 1-6, pp. 309–320, Jun. 2000

    2000

  3. [11]

    Collective classification in network data,

    P . Sen, G. Namata, M. Bilgic, L. Getoor, B. Gallagher, and T. Eliassi- Rad, “Collective classification in network data,” Tech. Rep., 2008

    2008

  4. [12]

    Graph neural networks: A review of methods and applications,

    J. Zhou, G. Cui, Z. Zhang, C. Yang, Z. Liu, and M. Sun, “Graph neural networks: A review of methods and applications,” ArXiv, vol. abs/1812.08434, 2018

    2018 arXiv

  5. [13]

    A comprehensive survey on graph neural networks,

    Z. Wu, S. Pan, F. Chen, G. Long, C. Zhang, and P . S. Yu, “A comprehensive survey on graph neural networks,” CoRR, vol. abs/1901.00596, 2019

    1901 arXiv

  6. [14]

    Neural message passing for quantum chemistry,

    J. Gilmer, S. S. Schoenholz, P . F. Riley, O. Vinyals, and G. E. Dahl, “Neural message passing for quantum chemistry,” CoRR, vol. abs/1704.01212, 2017

    2017 arXiv

  7. [15]

    Inductive representa- tion learning on large graphs,

    W. L. Hamilton, R. Ying, and J. Leskovec, “Inductive representa- tion learning on large graphs,” CoRR, vol. abs/1706.02216, 2017

    2017 arXiv

  8. [16]

    Modeling relational data with graph convolutional networks,

    M. Schlichtkrull, T. N. Kipf, P . Bloem, R. vanden Berg, I. Titov, and M. Welling, “Modeling relational data with graph convolutional networks,” in The Semantic Web , A. Gangemi, R. Navigli, M.-E. Vidal, P . Hitzler, R. Troncy, L. Hollink, A. Tordai, and M. Alam, Eds. Cham: Sp...

    2018

  9. [17]

    Lan- guage modeling with gated convolutional networks,

    Y. N. Dauphin, A. Fan, M. Auli, and D. Grangier, “Lan- guage modeling with gated convolutional networks,” CoRR, vol. abs/1612.08083, 2016

    2016 arXiv

  10. [18]

    Recent advances in recurrent neural networks,

    H. Salehinejad, J. Baarbe, S. Sankar, J. Barfett, E. Colak, and S. Valaee, “Recent advances in recurrent neural networks,” CoRR, vol. abs/1801.01078, 2018

    2018 arXiv

  11. [19]

    Gated graph sequence neural networks,

    Y. Li, D. Tarlow, M. Brockschmidt, and R. S. Zemel, “Gated graph sequence neural networks,” CoRR, vol. abs/1511.05493, 2016

    2016 arXiv

  12. [20]

    Accelerating graph analytics on cpu-fpga heterogeneous platform,

    S. Zhou and V . K. Prasanna, “Accelerating graph analytics on cpu-fpga heterogeneous platform,” in 2017 29th International Sym- posium on Computer Architecture and High Performance Computing (SBAC-P AD), Oct 2017, pp. 137–144

    2017

  13. [21]

    Poster: Domain-specialized cache management for graph analytics,

    P . Faldu, J. Diamond, and B. Grot, “Poster: Domain-specialized cache management for graph analytics,” in 2019 28th Interna- tional Conference on Parallel Architectures and Compilation Techniques (P ACT), Sep. 2019, pp. 473–474

    2019

  14. [22]

    Hygcn: A gcn accelerator with hybrid architecture,

    M. Yan, L. Deng, X. Hu, L. Liang, Y. Feng, X. Ye, Z. Zhang, D. Fan, and Y. Xie, “Hygcn: A gcn accelerator with hybrid architecture,” ArXiv, vol. abs/2001.02514, 2020

    2001 arXiv

  15. [23]

    Characterizing and understanding gcns on gpu,

    M. Yan, Z. Chen, L. Deng, X. Ye, Z. Zhang, D. Fan, and Y. Xie, “Characterizing and understanding gcns on gpu,” IEEE Computer Architecture Letters, pp. 1–1, 2020

    2020

  16. [24]

    Bandwidth reduction using importance weighted pruning on ring allreduce,

    Z. Cheng and Z. Xu, “Bandwidth reduction using importance weighted pruning on ring allreduce,” CoRR, vol. abs/1901.01544, 2019

    1901 arXiv

  17. [25]

    Gridgraph: Large-scale graph processing on a single machine using 2-level hierarchical parti- tioning,

    X. Zhu, W. Han, and W. Chen, “Gridgraph: Large-scale graph processing on a single machine using 2-level hierarchical parti- tioning,” in 2015 USENIX Annual Technical Conference (USENIX ATC 15). Santa Clara, CA: USENIX Association, Jul. 2015, pp. 375–386

    2015

  18. [26]

    Toward an architecture for never-ending language learning,

    A. Carlson, J. Betteridge, B. Kisiel, B. Settles, E. R. Hruschka, Jr., and T. M. Mitchell, “Toward an architecture for never-ending language learning,” in Proceedings of the Twenty-Fourth AAAI Con- ference on Artificial Intelligence , ser. AAAI’10. AAAI Press, 2010, pp. 1306–13...

  19. [27]

    Deep Gaussian Embedding of Graphs: Unsupervised Inductive Learning via Ranking,

    A. Bojchevski and S. G ¨unnemann, “Deep Gaussian Embedding of Graphs: Unsupervised Inductive Learning via Ranking,” arXiv e-prints, p. arXiv:1707.03815, Jul 2017

    2017 arXiv

  20. [28]

    R-mat: A recursive model for graph mining,

    D. Chakrabarti, Y. Zhan, and C. Faloutsos, “R-mat: A recursive model for graph mining,” in SIAM International Conference on Data Mining, 2004

    2004

  21. [29]

    Ramulator: A fast and extensible dram simulator,

    Y. Kim, W. Yang, and O. Mutlu, “Ramulator: A fast and extensible dram simulator,” IEEE Comput. Archit. Lett., vol. 15, no. 1, p. 4549, Jan. 2016

    2016

  22. [30]

    Fine-grained dram: Energy-efficient dram for extreme bandwidth systems,

    M. OConnor, N. Chatterjee, D. Lee, J. Wilson, A. Agrawal, S. W. Keckler, and W. J. Dally, “Fine-grained dram: Energy-efficient dram for extreme bandwidth systems,” in Proceedings of the 50th Annual IEEE/ACM International Symposium on Microarchitecture, ser. MICRO-50 17. New Yor...

    2017

  23. [31]

    Graphrnn: A deep generative model for graphs,

    J. You, R. Ying, X. Ren, W. L. Hamilton, and J. Leskovec, “Graphrnn: A deep generative model for graphs,” CoRR, vol. abs/1802.08773, 2018

    2018 arXiv

  24. [32]

    Pregel: A system for large-scale graph processing,

    G. Malewicz, M. H. Austern, A. J. Bik, J. C. Dehnert, I. Horn, N. Leiser, and G. Czajkowski, “Pregel: A system for large-scale graph processing,” in Proceedings of the 2010 ACM SIGMOD Inter- national Conference on Management of Data, ser. SIGMOD ’10. New York, NY, USA: ACM, 20...

    2010

  25. [33]

    Numa-aware graph-structured analytics,

    K. Zhang, R. Chen, and H. Chen, “Numa-aware graph-structured analytics,” SIGPLAN Not., vol. 50, no. 8, pp. 183–193, Jan. 2015

    2015

  26. [34]

    Powergraph: Distributed graph-parallel computation on natural graphs,

    J. E. Gonzalez, Y. Low, H. Gu, D. Bickson, and C. Guestrin, “Powergraph: Distributed graph-parallel computation on natural graphs,” in Proceedings of the 10th USENIX Conference on Operating Systems Design and Implementation , ser. OSDI’12. Berkeley, CA, USA: USENIX Association...

    2012

  27. [35]

    Gemini: A computation- centric distributed graph processing system,

    X. Zhu, W. Chen, W. Zheng, and X. Ma, “Gemini: A computation- centric distributed graph processing system,” in Proceedings of the 12th USENIX Conference on Operating Systems Design and Implemen- tation, ser. OSDI’16. Berkeley, CA, USA: USENIX Association, 2016, pp. 301–316

    2016

  28. [36]

    Gram: Scaling graph computation to the trillions,

    M. Wu, F. Yang, J. Xue, W. Xiao, Y. Miao, L. Wei, H. Lin, Y. Dai, and L. Zhou, “Gram: Scaling graph computation to the trillions,” in Proceedings of the Sixth ACM Symposium on Cloud Computing, ser. SoCC ’15. New York, NY, USA: ACM, 2015, pp. 408–421

    2015

  29. [37]

    Efficient processing of deep neural networks: A tutorial and survey,

    V . Sze, Y.-H. Chen, T.-J. Yang, and J. Emer, “Efficient processing of deep neural networks: A tutorial and survey,” Proceedings of the IEEE, 2017

    2017

  30. [38]

    Diannao: A small-footprint high-throughput accelerator for ubiq- uitous machine-learning,

    T. Chen, Z. Du, N. Sun, J. Wang, C. Wu, Y. Chen, and O. Temam, “Diannao: A small-footprint high-throughput accelerator for ubiq- uitous machine-learning,” in Proceedings of the 19th International Conference on Architectural Support for Programming Languages and Operating Syste...

    2014

  31. [39]

    EIE: efficient inference engine on compressed deep neural network,

    S. Han, X. Liu, H. Mao, J. Pu, A. Pedram, M. A. Horowitz, and W. J. Dally, “EIE: efficient inference engine on compressed deep neural network,” CoRR, vol. abs/1602.01528, 2016

    2016 arXiv

  32. [40]

    Graphicionado: A high-performance and energy-efficient accel- erator for graph analytics,

    T. J. Ham, L. Wu, N. Sundaram, N. Satish, and M. Martonosi, “Graphicionado: A high-performance and energy-efficient accel- erator for graph analytics,” in The 49th Annual IEEE/ACM Interna- tional Symposium on Microarchitecture, ser. MICRO-49. Piscataway, NJ, USA: IEEE Press, 20...

    2016

  33. [41]

    Alleviating irregularity in graph analytics acceleration: A hardware/software co-design approach,

    M. Yan, X. Hu, S. Li, A. Basak, H. Li, X. Ma, I. Akgun, Y. Feng, P . Gu, L. Deng, X. Ye, Z. Zhang, D. Fan, and Y. Xie, “Alleviating irregularity in graph analytics acceleration: A hardware/software co-design approach,” in Proceedings of the 52Nd Annual IEEE/ACM International S...

    2019

Pith tools

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