Pith. sign in

REVIEW 3 major objections 4 minor 42 references

Binsparse: A Specification for Cross-Platform Storage of Sparse Matrices and Tensors

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 Binsparse proposes the first cross-platform binary standard for sparse matrices and tensors, with large measured size and read-time gains over ASCII formats.

desk verdict Binsparse is a real and useful specification with strong uncompressed results, but the compressed-storage headline numbers are measured against raw .mtx rather than the .mtx.gz baseline practitioners actually use. read the letter →

arxiv 2506.19175 v1 pith:QOPE3FPS submitted 2025-06-23 cs.MS cs.DCcs.DS

Benjamin Brock , Willow Ahrens , Hameer Abbasi , Timothy A. Davis , Juni Kim , James Kitchen , Spencer Patty , Isaac Virshup
show 1 more author
Erik Welch
This is my paper · ORCID
classification cs.MScs.DCcs.DS
keywords BinsparsesparsematrixstoragetensorbinaryfileformatHDF5MarketFROSTTCSR
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

The paper aims to establish Binsparse as the first cross-platform standard for storing sparse matrices and tensors directly in binary form. Its central claim is that a small JSON descriptor plus standard binary arrays, embedded in existing containers such as HDF5, can replace ASCII-based Matrix Market and FROSTT files with roughly 2.4x smaller files for CSR (7.5x with compression) and read times about 26.5x faster in warm-cache tests. If this holds, the standard would give ordinary users the speed of hand-rolled binary formats without the portability cost, and would let libraries read and write their native in-memory formats to disk without format conversion.

What carries the argument

The central object is the JSON descriptor plus a set of named binary arrays: indices_0, indices_1, pointers_to_1, and values, whose meanings are fixed per format. The descriptor alone determines which arrays exist and what they mean, so the same binary arrays work in HDF5, Zarr, NPZ, or DLPack without changing the data. For tensors, a hierarchical level description based on the fibertree abstraction lets any array-of-arrays layout be described. This machinery is what makes native binary storage possible without inventing a new container format.

What would settle it

Take any matrix in the >1M-entry SuiteSparse set, store it as gzipped Matrix Market (.mtx.gz) and as Binsparse HDF5 CSR with gzip, and time full reads including decompression on the same hardware; if .mtx.gz reads as fast as or faster than .csr.bsp.gz while staying comparable in size, the paper's compressed-format claims fail.

Watch

Extended reading notes

Core claim

Binsparse proposes that any common sparse matrix or tensor format—COO, CSR, CSC, doubly compressed variants, and hierarchical fiber formats—can be described by a short JSON header that names the format, shape, number of stored values, structure, and data types, with the actual data stored as plain binary arrays inside a general-purpose binary container. By separating metadata from arrays and letting the container handle endianness, compression, and chunking, the format avoids inventing a new container format. Measured on every SuiteSparse Matrix Collection matrix with at least a million entries, the HDF5 CSR form averages 2.4x smaller than Matrix Market text without compression and 7.5x smaller with gzip; the reference parser averages 26.5x faster warm-cache reads and 31x faster unflushed writes than fast_matrix_market for uncompressed CSR, with similar advantages for tensors against FROSTT parsers. The specification also defines a level-based custom tensor language so formats native to tensor compilers can be stored directly.

Load-bearing premise

The evaluation assumes the relevant alternative is uncompressed Matrix Market text; if users would actually store gzipped Matrix Market files, the reported size and read/write speed advantages shrink because ASCII text compresses well.

Editorial extensions

If this is right

  • Reading a sparse matrix becomes a near memcpy-style load into the CSR or COO structure instead of token-by-token text parsing, so bandwidth-bound routines spend less time in file I/O.
  • Because the same named arrays slot into multiple established containers, files written once can be read by C, C++, Python, Julia, and other frameworks through existing container libraries.
  • The level-based tensor language means in-memory formats used by tensor compilers can be serialized directly, eliminating conversion to coordinate form before saving.
  • Parallel reading that splits each dataset across processes gives large compressed files roughly 2x additional speedup over sequential reads in the paper's measurements.

Reading between the lines

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

  • If gzipped Matrix Market text, rather than plain text, is the realistic alternative for practitioners, the compressed-file size and speed advantages likely shrink; a direct .mtx.gz versus .bsp.gz comparison would settle how large the real-world win is.
  • If Binsparse becomes a shared interchange contract, it could also serve as the in-memory exchange layer between sparse libraries, making custom shim code unnecessary.
  • Since the JSON header is human-readable and external metadata can be attached, the format could double as a self-describing archival standard, allowing large matrix collections to be distributed as a single HDF5 file per matrix set.
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. The paper introduces Binsparse, a specification for storing sparse matrices and tensors as a JSON descriptor plus binary arrays, embeddable in containers such as HDF5, Zarr, and NPZ, and supporting native in-memory formats including COO, CSR, CSC, DCSR, and DCSC, as well as custom hierarchical tensor formats. The authors report reference implementations across several languages and frameworks, convert the SuiteSparse Matrix Collection and a subset of FROSTT tensors to Binsparse, and benchmark file sizes and read/write times against fast_matrix_market and splatt. The headline results are large average file size reductions (e.g., 2.4x for uncompressed CSR, 7.5x for compressed CSR) and warm-cache read speedups (e.g., 26.5x for uncompressed CSR), with smaller speedups for compressed formats.

Significance. If the compressed-format claims are placed on a proper baseline, this paper makes a valuable contribution: it provides a concrete, embeddable, cross-platform binary specification for sparse data, with multiple reference implementations and a large-scale conversion and validation effort. The uncompressed-format benefits (2.4x size reduction, 26.5x read speedup, 31x write speedup for CSR) appear robust and are not undermined by the baseline concern raised below. The release of parsers in multiple languages and containers, plus bitwise-identical validation on the SuiteSparse collection, are notable strengths. The main reservation is that the compressed-format comparisons use an uncompressed text baseline, which overstates the practical advantage of compressed Binsparse for users whose current alternative is gzipped Matrix Market.

major comments (3)
  1. [Section 5.1 / Table 3 / Abstract] The compressed-size claims are computed against uncompressed .mtx files rather than gzipped Matrix Market (.mtx.gz). Table 3 reports average reductions of 7.2x and 7.5x for .coo.bsp.gz and .csr.bsp.gz over raw .mtx, and the abstract inherits the 7.5x number. Since ASCII text compresses well and .mtx.gz is the common compressed-text alternative for SuiteSparse data, the true size advantage of compressed Binsparse over compressed text is likely much smaller. The same baseline issue affects the compressed read/write speedups in Tables 5 and 8 (2.6x/1.4x average). The authors should either add .mtx.gz file-size and read/write measurements as a baseline or explicitly scope all compressed-format claims to comparisons against uncompressed text.
  2. [Abstract / Section 5.1] The abstract says the format is evaluated 'on every matrix in the SuiteSparse Matrix Collection' and then reports average reductions of 2.4x and 7.5x, but those averages (Table 3) are taken only over matrices with at least one million entries, as stated in the table caption and Section 5.1. A reader cannot tell from the abstract that the headline numbers exclude the majority of the collection. Please state the subset explicitly in the abstract and conclusions, or report full-collection statistics separately.
  3. [Section 5.5] The contribution bullet claims 'parallel reads on average about 2x faster than sequential reads,' but the body reports roughly 1.4x improvement for uncompressed cold reads, no improvement for warm uncompressed reads, and about 2.4x for compressed COO. This is inconsistent unless 'average' is defined more precisely. Please either reconcile the claim with the per-format numbers or remove the aggregate statement.
minor comments (4)
  1. [Section 4 / Table 1 / Abstract] The abstract claims 4 binary containers, but the text lists HDF5, Zarr, and NPZ as the container libraries and describes in-memory interchange separately. Please clarify whether 'In-Memory' is counted as a container in Table 1, and align the abstract, contributions, and table.
  2. [Figure 1] The y-axis label and the title both read 'File Size (Bytes)'; consider removing the duplicate label or making one of them the axis unit only.
  3. [Section 5.6] The sentence 'the average speedups are 1.4x and 1.4x' should identify the format as .csr.bsp.gz explicitly, since multiple compressed formats appear in Table 8.
  4. [Section 2] A brief statement in the related work section that gzip-compressed Matrix Market is a common distribution format, and roughly what compression ratios it achieves on SuiteSparse matrices, would help readers contextualize the compressed-format comparisons.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the paper's format claims are validated by external benchmarks, not by self-referential derivation.

full rationale

The paper makes no analytic derivation whose output equals its input; all central claims are empirical measurements against external baselines. File size reductions (Tables 3, 4) and read/write speedups (Tables 5–8) are obtained by converting the SuiteSparse Matrix Collection and FROSTT tensors and timing the reference parser against fast_matrix_market and splatt, which are independent third-party tools. The only self-referential element is citation [16], the authors' own Binsparse specification; it is used to reference the format definition rather than to justify a numerical result, and the paper independently implements parsers in multiple languages, validates bitwise equality against Matrix Market, and reports performance on public corpora. The skeptic's concern about comparing compressed Binsparse to uncompressed .mtx rather than .mtx.gz is a baseline-selection issue that may affect the strength of the practical win claims, but it is not circularity: the measured quantities do not reduce by construction to any fitted parameter or to a self-citation. Accordingly, the circularity score is 0.

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

No fitted parameters or invented physical entities are present; the central claims are empirical. The listed axioms are domain assumptions about the portability of the underlying containers, the representativeness of the benchmark corpora, and the strength of the chosen baseline.

assumptions (3)
  • domain assumption HDF5, Zarr, and NPZ provide portable binary storage, including endianness handling, so that the JSON descriptor plus binary arrays reconstruct the same sparse structure across systems.
    Section 3: Binsparse is embeddable in these containers to leverage existing cross-platform support instead of defining a new binary format; the spec's portability claim depends on this.
  • domain assumption fast_matrix_market is the fastest available Matrix Market parser, hence the right baseline.
    Section 5 says 'to the best of our knowledge'. All read and write speedup claims are relative to this parser.
  • domain assumption The SuiteSparse Matrix Collection and FROSTT repository are representative of real sparse matrix and tensor workloads.
    Used as the only evaluation corpora; generalizing beyond them assumes they cover relevant size, sparsity, and value distributions.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Binsparse: A Specification for Cross-Platform Storage of Sparse Matrices and Tensors." pith.science (2026). https://pith.science/paper/QOPE3FPS

@misc{pith2026250619175,
  author       = {Pith},
  title        = {Pith review of: Binsparse: A Specification for Cross-Platform Storage of Sparse Matrices and Tensors},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QOPE3FPS}},
  note         = {Machine review of arXiv:2506.19175}
}
read the original abstract

Sparse matrices and tensors are ubiquitous throughout multiple subfields of computing. The widespread usage of sparse data has inspired many in-memory and on-disk storage formats, but the only widely adopted storage specifications are the Matrix Market and FROSTT file formats, which both use ASCII text. Due to the inefficiency of text storage, these files typically have larger file sizes and longer parsing times than binary storage formats, which directly store an in-memory representation to disk. This can be a major bottleneck; since sparse computation is often bandwidth-bound, the cost of loading or storing a matrix to disk often exceeds the cost of performing a sparse computation. While it is common practice for practitioners to develop their own, custom, non-portable binary formats for high-performance sparse matrix storage, there is currently no cross-platform binary sparse matrix storage format. We present Binsparse, a cross-platform binary sparse matrix and tensor format specification. Binsparse is a modular, embeddable format, consisting of a JSON descriptor, which describes the matrix or tensor dimensions, type, and format, and a series of binary arrays, which can be stored in all modern binary containers, such as HDF5, Zarr, or NPZ. We provide several reference implementations of Binsparse spanning 5 languages, 5 frameworks, and 4 binary containers. We evaluate our Binsparse format on every matrix in the SuiteSparse Matrix Collection and a selection of tensors from the FROSTT collection. The Binsparse HDF5 CSR format shows file size reductions of 2.4x on average without compression and 7.5x with compression. We evaluate our parser's read/write performance against a state-of-the-art Matrix Market parser, demonstrating warm cache mean read speedups of 26.5x without compression and 2.6x with compression, and write speedups of 31x without compression and 1.4x with compression.

Figures

Figures reproduced from arXiv: 2506.19175 by the authors.

Figure 1
Figure 1. File sizes for all matrices in the SuiteSparse Matrix [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. CSR matrix represented hierarchically A level is a collection of zero or more fibers which all have the same format. The elements of fibers in a level may be subfibers in a sublevel. The global tensor we wish to store is represented by a level that holds a single root fiber. Binsparse tensors are described under the custom tag, which stores a set of levels of type dense, sparse, or, for the innermost layer of scalar… view at source ↗
Figure 1
Figure 1. To simplify the analysis, here we examine only the pri [PITH_FULL_IMAGE:figures/full_fig_p007_1.png] view at source ↗
Figures from the paper (3 more)
Figure 3
Figure 3. Figure 3: Single-threaded cold and warm cache read times for all matrices in the SuiteSparse Matrix Collection with more [PITH_FULL_IMAGE:figures/full_fig_p009_3.png]
Figure 4
Figure 4. Figure 4: Cold and warm cache parallel read times for all matrices in the SuiteSparse Matrix Collection with more than one million entries. “mtx” indicates Matrix Market, while “bsp” indicates a Binsparse file format, “csr” indicates the CSR format is used, “coo” indicates the C…
Figure 5
Figure 5. Figure 5: Single-threaded flushed and unflushed write times for all matrices in the SuiteSparse Matrix Collection with more [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

42 extracted references · 30 canonical work pages

  1. [1]

    [n. d.]. NPY format. NumPy API reference. https://numpy.org/doc/2.1/ reference/generated/numpy.lib.format.html#npy\protect\discretionary{\char\ hyphenchar\font}{}{}format Accessed August 21, 2024

    work page 2024

  2. [2]

    [n. d.]. SSD 970 EVO PLUS NVMe ® M.2 2 TB Memory & storage - MZ- V7S2T0B/AM: Samsung US. https://www.samsung.com/us/computing/memory- storage/solid-state-drives/ssd-970-evo-plus-nvme-m-2-2-tb-mz-v7s2t0b-am/. Accessed August 20, 2024

    work page 2024

  3. [3]

    Eigen - store sparse matrix as binary

    2015. Eigen - store sparse matrix as binary. https://scicomp.stackexchange.com/ questions/21417/eigen-store-sparse-matrix-as-binary

    work page 2015

  4. [4]

    cuSPARSE

    2024. cuSPARSE. https://docs.nvidia.com/cuda/cusparse/index.html

    work page 2024

  5. [5]

    DLPack: Open In Memory Tensor Structure

    2025. DLPack: Open In Memory Tensor Structure. https://github.com/dmlc/ dlpack

    work page 2025

  6. [6]

    Hameer Abbasi. 2018. Sparse: A more modern sparse array library. scipy (June 2018). https://doi.org/10.25080/Majora-4af1f417-00a

    work page doi:10.25080/majora-4af1f417-00a 2018

  7. [7]

    Finch: Sparse and Structured Tensor Programming with Control Flow

    Willow Ahrens, Teodoro Fields Collin, Radha Patel, Kyle Deeds, Changwan Hong, and Saman Amarasinghe. 2024. Finch: Sparse and Structured Array Programming with Control Flow. arXiv:2404.16730 [cs.MS] https://arxiv.org/abs/2404.16730 Binsparse: A Specification for Cross-Platform Storage of Sparse Matrices and Tensors 16 MiB 64 MiB 256 MiB 1 GiB 4 GiB 16 GiB ...

    work page Pith review arXiv 2024

  8. [8]

    Gilbert, and Aydın Buluç

    Ariful Azad, Oguz Selvitopi, Md Taufique Hussain, John R. Gilbert, and Aydın Buluç. 2022. Combinatorial BLAS 2.0: Scaling Combinatorial Algorithms on Distributed-Memory Systems. IEEE Transactions on Parallel and Distributed Systems 33, 4 (2022), 989–1001. https://doi.org/10.1109/TPDS.2021.3094091

    work page arXiv 2022

Show all 42 references
  1. [9]

    Bader and Tamara G

    Brett W. Bader and Tamara G. Kolda. 2008. Efficient MATLAB Computations with Sparse and Factored Tensors. SIAM Journal on Scientific Computing 30, 1 (Jan. 2008), 205–231. https://doi.org/10.1137/060676489 Publisher: Society for Industrial and Applied Mathematics

    2008 doi

  2. [10]

    Vivek Bharadwaj, Osman Asif Malik, Riley Murray, Laura Grigori, Aydin Buluc, and James Demmel. 2023. Fast Exact Leverage Score Sampling from Khatri-Rao Products with Applications to Tensor Decomposition. In Advances in Neural Information Processing Systems , A. Oh, T. Naumann,...

    2023

  3. [11]

    Aart Bik, Penporn Koanantakool, Tatiana Shpeisman, Nicolas Vasilache, Bixia Zheng, and Fredrik Kjolstad. 2022. Compiler Support for Sparse Tensor Compu- tations in MLIR. ACM Transactions on Architecture and Code Optimization 19, 4 (Sept. 2022), 50:1–50:25. https://doi.org/10.1...

    2022 doi

  4. [12]

    Ronald Boisvert, Roldan Pozo, and K Remington. 1996. The Matrix Market Exchange Formats: Initial Design . NIST Interagency/Internal Report (NISTIR), National Institute of Standards and Technology, Gaithersburg, MD

    1996

  5. [13]

    Dongarra

    R F Boisvert, R Pozo, K Remington, R F Barrett, and J.J. Dongarra. 1996. Matrix Market: A Web Resource for Test Matrix Collections . Technical Report. https: //www.osti.gov/biblio/465805

    1996

  6. [14]

    Benjamin Brock, Aydın Buluç, and Katherine Yelick. 2024. RDMA-Based Al- gorithms for Sparse Matrix Multiplication on GPUs. In Proceedings of the 38th ACM International Conference on Supercomputing (Kyoto, Japan) (ICS ’24). As- sociation for Computing Machinery, New York, NY, U...

    2024

  7. [15]

    Mattson, Scott McMillan, and José E

    Benjamin Brock, Aydın Buluç, Timothy G. Mattson, Scott McMillan, and José E. Moreira. 2021. Introduction to GraphBLAS 2.0. In 2021 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW) . 253–262. https: //doi.org/10.1109/IPDPSW52791.2021.00047

    2021

  8. [16]

    Davis, Jim Kitchen, Erik Welch, Isaac Virishup, and Willow Ahrens

    Benjamin Brock, Timothy A. Davis, Jim Kitchen, Erik Welch, Isaac Virishup, and Willow Ahrens. 2024. Binary Sparse Format Specification Version 0.1. https: //graphblas.org/binsparse-specification/

    2024

  9. [17]

    Davis and Yifan Hu

    Timothy A. Davis and Yifan Hu. 2011. The University of Florida Sparse Matrix Collection. ACM Trans. Math. Softw. 38, 1, Article 1 (Dec 2011), 25 pages. https: //doi.org/10.1145/2049662.2049663

    2011

  10. [18]

    Duff Duff, Roger G

    I.S. Duff Duff, Roger G. Grimes, and John G. Lewis. 1997. The Rutherford-Boeing Sparse Matrix Collection. Technical Report RAL-TR-97-031. Rutherford Appleton Laboratory. https://cds.cern.ch/record/337273

    1997

  11. [19]

    I. S. Duff, Roger G. Grimes, and John G. Lewis. 1989. Sparse Matrix Test Problems. ACM Trans. Math. Softw. 15, 1 (Mar 1989), 1–14. https://doi.org/10.1145/62038. 62043

    1989 doi

  12. [20]

    1992.Users’ Guide for the Harwell- Boeing Sparse Matrix Collection (Release I)

    Iain S Duff, Roger G Grimes, and John G Lewis. 1992.Users’ Guide for the Harwell- Boeing Sparse Matrix Collection (Release I) . Technical Report TR/PA/92/86. 76–78 pages

    1992

  13. [21]

    Pourmal Elena. 2024. Upcoming New HDF5 Features: Progress on Multi- thread, Sparse Data Storage, and Encryption in HDF5. https://doi.org/10.5281/zenodo. 13308713

    2024 doi

  14. [22]

    Jonathan Frankle and Michael Carbin. 2019. The Lottery Ticket Hypothesis: Finding Sparse, Trainable Neural Networks. arXiv:1803.03635 [cs] (March 2019). http://arxiv.org/abs/1803.03635 arXiv: 1803.03635

    2019 arXiv

  15. [23]

    Charles R Harris, K Jarrod Millman, Stéfan J Van Der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J Smith, et al. 2020. Array programming with NumPy. Nature 585, 7825 (2020), 357–362

    2020

  16. [24]

    Fredrik Kjolstad, Stephen Chou, David Lugato, Shoaib Kamil, and Saman Ama- rasinghe. 2017. taco: A tool to generate tensor algebra kernels. In 2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE) . 943–948. https://doi.org/10.1109/ASE.2017.8115709

    2017

  17. [25]

    Kolodziej, Mohsen Aznaveh, Matthew Bullock, Jarrett David, Timothy A

    Scott P. Kolodziej, Mohsen Aznaveh, Matthew Bullock, Jarrett David, Timothy A. Davis, Matthew Henderson, Yifan Hu, and Read Sandstrom. 2019. The SuiteSparse Matrix Collection Website Interface. Journal of Open Source Software 4, 35 (2019),

    2019

  18. [26]

    Sandeep Koranne. 2011. Hierarchical Data Format 5 : HDF5 . Springer US, Boston, MA, 191–200. https://doi.org/10.1007/978-1-4419-7719-9_10

    2011 doi

  19. [27]

    Adam Lugowski. 2023. fast_matrix_market: Fast and Full-Featured Matrix Market I/O Library. https://doi.org/10.5281/zenodo.10223767

    2023 doi

  20. [28]

    John Mainzer, Neil Fortner, Gerd Heber, Elena Pourmal, Quincey Koziol, Suren Byna, and Marc Paterno. 2019. Sparse Data Management in HDF5. In 2019 IEEE/ACM 1st Annual Workshop on Large-scale Experiment-in-the-Loop Computing (XLOOP). IEEE, 20–25

    2019

  21. [29]

    Alistair Miles, Jonathan Striebel, and Jeremy Maitin-Shepard. 2023. Zar Specifi- cation Version 3. https://zarr.dev/zeps/accepted/ZEP0001.html

    2023

  22. [30]

    Stavros Papadopoulos, Kushal Datta, Samuel Madden, and Timothy Mattson

  23. [31]

    Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gre- gory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Rai- son, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner,...

    2019

  24. [32]

    Xinli Shang, Kai Jiang, Zheng Shao, and Mohammad Islam. 2022. Cost Efficiency @ Scale in Big Data File Format. https://www.uber.com/blog/cost-efficiency- big-data/

    2022

  25. [33]

    Choi, Jiajia Li, Richard Vuduc, Jongsoo Park, Xing Liu, and George Karypis

    Shaden Smith, Jee W. Choi, Jiajia Li, Richard Vuduc, Jongsoo Park, Xing Liu, and George Karypis. 2017. FROSTT: The Formidable Repository of Open Sparse Tensors and Tools. http://frostt.io/ Benjamin Brock, Willow Ahrens, Hameer Abbasi, Timothy A. Davis, Juni Kim, James Kitchen,...

    2017

  26. [34]

    Sidiropoulos, and George Karypis

    Shaden Smith, Niranjay Ravindran, Nicholas D. Sidiropoulos, and George Karypis

  27. [35]

    Vivienne Sze, Yu-Hsin Chen, Tien-Ju Yang, and Joel S. Emer. 2020. Efficient Processing of Deep Neural Networks.Synthesis Lectures on Computer Architecture 15, 2 (June 2020), 1–341. https://doi.org/10.2200/S01004ED1V01Y202004CAC050 Publisher: Morgan & Claypool Publishers

    2020 doi

  28. [36]

    The HDF Group. [n. d.]. Hierarchical Data Format, version 5. https://www. hdfgroup.org/HDF5/

  29. [37]

    Oliphant, Matt Haberland, Tyler Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren Weckesser, Jonathan Bright, Stéfan J

    Pauli Virtanen, Ralf Gommers, Travis E. Oliphant, Matt Haberland, Tyler Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren Weckesser, Jonathan Bright, Stéfan J. van der Walt, Matthew Brett, Joshua Wilson, K. Jarrod Millman, Nikolay Mayorov, Andrew R. J. Nelson, E...

    2020

  30. [38]

    Martin Winter, Daniel Mlakar, Rhaleb Zayer, Hans-Peter Seidel, and Markus Steinberger. 2019. Adaptive Sparse Matrix-Matrix Multiplication on the GPU. In Proceedings of the 24th Symposium on Principles and Practice of Parallel Program- ming (Washington, District of Columbia)(PP...

    2019

  31. [39]

    Jordi Wolfson-Pou and Edmond Chow. 2019. Modeling the Asynchronous Jacobi Method Without Communication Delays. J. Parallel and Distrib. Comput. 128 (2019), 84–98. https://doi.org/10.1016/j.jpdc.2019.02.002 Optimization Notice: Software and workloads used in performance tests m...

    2019 doi

  32. [1244]

    https://doi.org/10.21105/joss.01244

    doi

  33. [2015]

    In Proceedings of the 2015 IEEE International Parallel and Distributed Processing Symposium (IPDPS ’15)

    SPLATT: Efficient and Parallel Sparse Tensor-Matrix Multiplication. In Proceedings of the 2015 IEEE International Parallel and Distributed Processing Symposium (IPDPS ’15). IEEE Computer Society, Washington, DC, USA, 61–70. https://doi.org/10.1109/IPDPS.2015.27

    2015 doi

  34. [2016]

    The TileDB array data storage manager.Proceedings of the VLDB Endowment 10, 4 (2016), 349–360

    2016

Pith tools

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