Pith. sign in

REVIEW 4 major objections 4 minor 58 references

Evaluating Learned Indexes in LSM-tree Systems: Benchmarks,Insights and Design Choices

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

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

Pith's one-line read This paper claims that learned indexes can replace fence pointers in LSM-tree systems, delivering a better memory-latency tradeoff, and distills the tuning choices that make that replacement work.

desk verdict A useful unified benchmark with a real testbed, but the headline claim about learned indexes beating fence pointers rests on one favorable dataset and an external technical report. read the letter →

arxiv 2506.08671 v1 pith:SZYD4JCV submitted 2025-06-10 cs.DB cs.DS

Junfeng Liu , Jiarui Ye , Mengshi Chen , Meng Li , Siqiang Luo This is my paper
classification cs.DBcs.DS
keywords learnedindexesLSM-treesfencepointersmemory-latencytradeoffpositionboundaryindexgranularitycompactionoverheadpointlookups
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 argues that learned indexes are a practical, memory-efficient replacement for the fence pointers that LSM-tree key-value stores use to locate data blocks. To test that, it builds a common interface for integrating six data-clustered learned indexes into a widely used LSM-tree implementation and evaluates them under a three-part configuration space. Its central finding is that every learned index it evaluated achieves lower lookup latency than fence pointers at equal memory, while maintaining comparable range-query and mixed-workload performance. The paper further claims that the position boundary (the segment size a model searches) matters more than the internal index structure, that larger SSTables save memory without hurting latency, and that the extra training cost of learned indexes during compaction is modest. If these results hold, developers can adopt learned indexes in existing LSM-tree systems with small engineering effort and a clear tuning recipe.

What carries the argument

The argument rests on a three-parameter configuration space defined for any LSM-compatible learned index: index type (how segments and their inner structures are organized), position boundary (the segment length a model predicts, equal to twice its error bound, which bounds the I/O cost to $O(2\epsilon / B)$ where $B$ is the block size), and index granularity (the SSTable or level size over which an index is built). These parameters are realized through a LearnedIndexTable interface that replaces the standard table class in the LSM-tree, overriding point lookup, iterator, and table builder paths so that the rest of the system treats learned indexes like ordinary tables. The cost analysis shows that once the segment size reaches the I/O block size, further memory investment cannot reduce the dominant disk-I/O cost, which explains the diminishing returns.

What would settle it

Run the same six learned indexes against fence pointers in a second widely used LSM-tree implementation under identical memory budgets and the same point-lookup workload; if fence pointers match or beat the learned indexes on latency at equal memory, the paper's central claim would be refuted.

Watch

Extended reading notes

Core claim

On its own terms, the paper establishes that replacing fence pointers with data-clustered learned indexes in an LSM-tree yields a strictly better memory-latency tradeoff for point lookups: over all tested position boundaries, every learned index uses less memory than fence pointers for the same lookup latency, and RMI and PGM dominate the rest. It also establishes that the dominant lever is the position boundary, not the index type, because disk I/O dominates point-lookup cost; that coarser index granularity (larger SSTables or level-grained models) reduces memory by over 10x with only microsecond-level latency changes; and that model training and writing account for under 5% of compaction time for most indexes. The advantage of learned indexes shrinks as range length grows, because the seek cost they optimize becomes a smaller fraction of total range-query work.

Load-bearing premise

The central claim depends on the assumption that results measured on the Random dataset with one LSM-tree implementation's fixed settings (size ratio, block size, Bloom filter budget) represent how learned indexes behave across LSM-tree systems and workloads generally.

Editorial extensions

If this is right

  • Position boundary should be the first tuning knob: shrinking it improves lookup latency more than switching index types, up to the point where the segment fits in one I/O block.
  • Larger SSTables lower index memory by more than 10x with negligible latency change, freeing memory that can be spent on smaller position boundaries.
  • Memory budgets for learned indexes face diminishing returns; the leftover budget is better spent on Bloom filters and write buffers.
  • Learned indexes preserve their memory-latency advantage in mixed and read-heavy YCSB workloads, but the advantage fades for long range scans.
  • Because training overhead is small, learned indexes can be rebuilt during normal compaction without a separate training pipeline.

Reading between the lines

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

  • The paper's design guidelines suggest a natural next test: dynamically assigning different position boundaries per LSM level based on observed query skew, rather than one uniform boundary; the authors hint at this but do not implement it.
  • The same interface could be ported to other LSM-tree implementations, and the qualitative ranking (RMI and PGM ahead, FITing-Tree behind) may or may not survive; that is a direct testable extension.
  • If the memory-latency advantage holds across hardware, learned-index compatibility could become a first-class parameter in LSM-tree design-space optimization, alongside size ratio and compaction policy.
  • Because only data-clustered indexes were included, the study leaves open whether update-friendly learned indexes like ALEX and LIPP would change the picture if the LSM layout were altered.
Share X Bluesky LinkedIn Reddit HN

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 benchmarks six data-clustered learned indexes (PLR, FITing-Tree, PGM, RadixSpline, PLEX, and RMI) integrated into LevelDB through a custom LearnedIndexTable interface, and compares them against traditional fence pointers. The authors define a configuration space of three parameters——index type, position boundary, and index granularity——and report experiments on point lookups, range lookups, compaction overhead, and mixed YCSB workloads. The headline empirical claim is that all evaluated learned indexes exhibit a superior memory-latency tradeoff compared to fence pointers, and the paper derives practical tuning guidelines such as prioritizing the position boundary, increasing SSTable granularity, and avoiding over-allocation of memory to indexes.

Significance. If the headline result holds across the dataset and configuration space claimed, this would be a useful benchmark for the LSM-tree system community: it provides a unified testbed, integrates six learned indexes in one codebase, and makes source code publicly available. The paper also offers an unusual focus on the memory-latency tradeoff as the primary evaluation axis, and its decomposition of point-lookup cost into table lookup, prediction, disk I/O, and binary search is informative. However, the central empirical claim is currently supported only by the Random dataset in the main text, with all other datasets deferred to an external technical report, and no repeated trials or variance estimates are reported. These gaps make the breadth of the claimed guidelines difficult to assess from the submitted evidence.

major comments (4)
  1. [Section 5, Datasets and Workload Setup; Figure 6] Section 5 states that 'Due to space constraints, we present results for the Random dataset in this paper' and defers the other six SOSD datasets to the external technical report [1]. Yet Section 1 and Section 6 formulate the headline claim universally: 'all evaluated learned indexes exhibit a superior memory-latency tradeoff compared to traditional fence pointers.' The Random dataset is the most favorable case for the piecewise-linear learned indexes considered here: its CDF in Figure 5 is essentially linear, so few segments are needed for a given position boundary, while fence-pointer memory depends only on the number of blocks and is distribution-independent. On skewed datasets such as Segment, Books, FB, Wiki, Longitude, and Longlat, the same position boundary can require substantially more segments, increasing index memory and potentially overturning the Pareto-dominance claim. This is a load-bearing external-validity gap: the main text should include at least concise versions of the deferred dataset results, or the technical report should be made part of the submission, together with a discussion of how the tradeoff depends on data distribution.
  2. [Section 5 and Figure 6; Table 1] No measure of variance or repeated trials is reported. All claimed latencies appear to come from a single run of 1,000,000 operations, and Table 1 reports per-operation times to 0.01 microseconds. At these small differences, run-to-run variance can easily exceed the measured gaps between configurations, so claims such as 'all indexes exhibit nearly identical lookup latencies' (Section 5.1) and 'less than 5% of the total compaction time' (Section 5.3) are not verifiable without error bars or multiple trials. Adding at least standard deviations over several runs is necessary for a benchmark paper whose quantitative conclusions are about small latency deltas.
  3. [Section 5, Settings of Learned Indexes] The setting of two learned-index hyperparameters is described only as the result of informal tuning: for RadixSpline, 'RadixBits = 1 offers the best tradeoff in LSM-tree systems,' and for PGM, 'EpsilonRecursive = 4' is retained after testing various values. The paper does not disclose the grid searched, the dataset(s) used for tuning, or whether the tuning procedure was applied separately per dataset. This matters because RadixSpline and PGM are compared against fence pointers whose only tuning knob here is the block size, and against other learned indexes whose parameters are set by their default implementations. The comparison would be fairer if the tuning procedure and its sensitivity were reported.
  4. [Section 4.1 and Section 6.1] The paper's first design principle is 'Prioritize Position Boundary,' and Section 4.1 defines the position boundary as the segment range length, stating that it 'directly affects I/O cost.' Because the position boundary is defined as the I/O range, the empirical conclusion that it is 'the most critical factor' is partly a tautology: reducing the search range necessarily reduces the dominant I/O cost. The experiments do show the relative magnitude of the effect and the memory price paid for smaller boundaries, but the paper should explicitly separate the definitional dependency from the empirical finding, and should phrase the guideline as a tradeoff recommendation rather than as a newly discovered dominant factor.
minor comments (4)
  1. [References] References [27] and [28] are identical (both are Kraska et al., 'The case for learned index structures,' SIGMOD 2018); please deduplicate and renumber. Also, the related-work paragraph cites both MADEX and RUSLI as [20], which appear to be different papers and should have separate entries.
  2. [Figure 6] The caption of Figure 6 says 'under different datasets,' but Section 5 says only the Random dataset is presented in this paper. Please clarify which subfigures correspond to which datasets, or correct the caption to match the actual content.
  3. [Throughout] The spelling 'FITING-tree' and 'FITing-Tree' is used inconsistently; choose one consistent form.
  4. [Section 5.3] The text states that 'most learned indexes show less than a 5% increase in compaction time, while PLEX exhibits around a 10% increase' and later that 'model writing... consume less than 5% of compaction time.' Since Figure 9 appears to show both total compaction time and a breakdown, please add explicit panel references and axis labels so the reader can connect the claims to the figure.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the paper's claims rest on direct measurements against external learned-index implementations and fence-pointer baselines on a unified LevelDB testbed, not on fitted parameters or self-citation chains.

full rationale

This is an empirical benchmarking paper, not a derivation. The central claims—that learned indexes can improve the memory-latency tradeoff, that position boundary is the dominant lookup factor, that granularity and memory budgets exhibit diminishing returns—are supported by direct measurements of latency, memory, compaction time, and I/O breakdowns. The learned index implementations (PLR, PGM, RadixSpline, PLEX, RMI, FITing-Tree) are external baselines integrated into a unified interface, and fence pointers are compared as an independent classical alternative. No fitted parameter is renamed as a prediction: 'position boundary' is explicitly defined as the segment range length (roughly 2× the error bound), and the observation that smaller boundaries reduce latency follows from the measured I/O-dominated lookup path, not from fitting a parameter to the target outcome. The paper's self-citations ([35], [39], [43]) appear in related-work and future-direction contexts and are not load-bearing for the headline result. The deferral of six SOSD datasets to the authors' technical report [1] is an external-validity gap rather than circularity: the included Random dataset still provides an independent, falsifiable comparison against fence pointers and across index types. The only mild framing concern is that 'position boundary is the most critical factor' is partly built into its definition as the quantity that directly controls I/O cost, but this is a transparent cost-model relationship, not a circular derivation of an empirical result.

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

The paper introduces no new theoretical entities. It does make two hand-chosen hyperparameter settings for RadixSpline and PGM, and it relies on standard LSM-tree properties and the dominance of I/O cost as domain assumptions.

free parameters (2)
  • RadixBits for RadixSpline = 1
    Chosen by the authors after varying the value, as the best memory-performance tradeoff in the LSM setting (Section 4.2, Settings of Learned Indexes).
  • EpsilonRecursive for PGM = 4 (default)
    Retained after testing since it had little impact on PGM performance in LSM-trees (Section 4.2).
assumptions (3)
  • domain assumption LSM-trees store data in sorted, contiguous runs (SSTables) with immutable files across levels.
    Used to justify the focus on data-clustered learned indexes and to design the LearnedIndexTable interface (Section 3.3).
  • domain assumption The I/O cost of fetching a segment from disk dominates point lookup latency, so the position boundary (segment size) is the primary performance lever.
    The paper asserts this in Section 4.1 and uses it to explain the diminishing-returns observations (Section 5.1).
  • standard math The error bound epsilon guarantees that segment length does not exceed 2*epsilon and I/O cost is O(2*epsilon/B).
    Stated in Section 4.1 as a property of data-clustered learned indexes, based on the cited literature (e.g., PGM, FITing-Tree).

how reviews work

0 comments
Cite this review

Pith. "Pith review of Evaluating Learned Indexes in LSM-tree Systems: Benchmarks,Insights and Design Choices." pith.science (2026). https://pith.science/paper/SZYD4JCV

@misc{pith2026250608671,
  author       = {Pith},
  title        = {Pith review of: Evaluating Learned Indexes in LSM-tree Systems: Benchmarks,Insights and Design Choices},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/SZYD4JCV}},
  note         = {Machine review of arXiv:2506.08671}
}
read the original abstract

LSM-tree-based data stores are widely used in industry due to their exceptional performance. However, as data volumes grow, efficiently querying large-scale databases becomes increasingly challenging. To address this, recent studies attempted to integrate learned indexes into LSM-trees to enhance lookup performance, which has demonstrated promising improvements. Despite this, only a limited range of learned index types has been considered, and the strengths and weaknesses of different learned indexes remain unclear, making them difficult for practical use. To fill this gap, we provide a comprehensive and systematic benchmark to pursue an in-depth understanding of learned indexes in LSM-tree systems. In this work, we summarize the workflow of 8 existing learned indexes and analyze the associated theoretical cost. We also identify several key factors that significantly influence the performance of learned indexes and conclude them with a novel configuration space, including various index types, boundary positions, and granularity. Moreover, we implement different learned index designs on a unified platform to evaluate across various configurations. Surprisingly, our experiments reveal several unexpected insights, such as the marginal lookup enhancement when allocating a large memory budget to learned indexes and modest retraining overhead of learned indexes. Besides, we also offer practical guidelines to help developers intelligently select and tune learned indexes for custom use cases.

Figures

Figures reproduced from arXiv: 2506.08671 by the authors.

Figure 1
Figure 1. (A) presents the general structure of an LSM-tree; (B) and (C) illustrate how original fence pointer and learned indexes [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. (A) to (F) present the data structures of data-clustered learned indexes and the general lookup procedure. Ic represents [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. (A) and (B) present the structure of ALEX and LIPP. [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: The figure demonstrates the architecture of our testbed system. The left-hand side is the detailed conduction of [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: The CDF of different datasets 4.2 Implementation To systematically evaluate the effectiveness of the three aforemen￾tioned configurations, we build a benchmark system based on Lev￾elDB, a well-known and streamlined LSM-tree implementation. To integrate learned indexes …
Figure 6
Figure 6. Figure 6: Latency and memory usage of different indexes under different position boundary under different datasets. [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]
Figure 7
Figure 7. Figure 7: Query time breakdown 5.1 Analysis on Position Boundary Observation 1: Smaller position boundary positively reduces the latency for all indexes at the cost of increasing the memory usage. The efficiency of improving performance by adding mem￾ory budget varies from index…
Figure 8
Figure 8. Figure 8: Impact of index granularity on point lookup. [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 9
Figure 9. Figure 9: Compaction time and breakdown. inner indexes and associated overhead. However, when the posi￾tion boundary is smaller than 32, memory usage becomes relatively stable for most learned indexes—except for RMI. In this regime, although fewer inner indexes are needed, the n…
Figure 10
Figure 10. Figure 10: The figure (left) shows the read overhead, the index size, and entries at different levels; the table (right) presents the [PITH_FULL_IMAGE:figures/full_fig_p011_10.png]
Figure 11
Figure 11. Figure 11: Performance of range lookup under different lookup range and position boundary. [PITH_FULL_IMAGE:figures/full_fig_p011_11.png]
Figure 12
Figure 12. Figure 12: Average operation time of indexes under six YCSB workloads. [PITH_FULL_IMAGE:figures/full_fig_p011_12.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

58 extracted references · 42 canonical work pages

  1. [1]

    Learned-Index-for-LSM-tree technical report

    -. Learned-Index-for-LSM-tree technical report. https://github.com/ qingshanlanshan/LearnedIndexInLSM/TechnicalReport.pdf

    work page

  2. [2]

    Hussam Abu-Libdeh, Deniz Altınbüken, Alex Beutel, Ed H Chi, Lyric Doshi, Tim Kraska, Andy Ly, Christopher Olston, et al . 2020. Learned indexes for a google-scale disk-based database.arXiv preprint arXiv:2012.12501(2020)

    arXiv 2020

  3. [3]

    Subarna Chatterjee, Meena Jagadeesan, Wilson Qin, and Stratos Idreos. 2021. Co- sine: a cloud-cost optimized self-designing key-value storage engine.Proceedings of the VLDB Endowment15, 1 (2021), 112–126

    work page 2021

  4. [4]

    Subarna Chatterjee, Mark F Pekala, Lev Kruglyak, and Stratos Idreos. 2024. Limou- sine: Blending Learned and Classical Indexes to Self-Design Larger-than-Memory Cloud Storage Engines.Proceedings of the ACM on Management of Data2, 1 (2024), 1–28

    work page 2024

  5. [5]

    Source Code. 2024. WiredTiger. https://github.com/wiredtiger/wiredtiger

    work page 2024

  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]

    Yifan Dai, Yien Xu, Aishwarya Ganesan, Ramnatthan Alagappan, Brian Kroth, Andrea Arpaci-Dusseau, and Remzi Arpaci-Dusseau. 2020. From WiscKey to Bourbon: A Learned Index for Log-Structured Merge Trees. In14th USENIX Symposium on Operating Systems Design and Implementation (OSDI 20). 155–171

    work page 2020

  8. [8]

    Niv Dayan, Manos Athanassoulis, and Stratos Idreos. 2017. Monkey: Optimal navigable key-value store. InProceedings of the 2017 ACM International Conference on Management of Data. 79–94

    work page 2017

Show all 58 references
  1. [9]

    Niv Dayan and Stratos Idreos. 2018. Dostoevsky: Better Space-Time Trade- Offs for LSM-Tree Based Key-Value Stores via Adaptive Removal of Superfluous Merging. InProceedings of the 2018 International Conference on Management of Data(Houston, TX, USA)(SIGMOD ’18). Association fo...

    2018

  2. [10]

    Niv Dayan and Stratos Idreos. 2019. The log-structured merge-bush & the wacky continuum. InProceedings of the 2019 International Conference on Management of Data. 449–466

    2019

  3. [11]

    Niv Dayan, Tamar Weiss, Shmuel Dashevsky, Michael Pan, Edward Bortnikov, and Moshe Twitto. 2022. Spooky: granulating LSM-tree compactions correctly. Proceedings of the VLDB Endowment15, 11 (2022), 3071–3084

    2022

  4. [12]

    Jialin Ding, Umar Farooq Minhas, Jia Yu, Chi Wang, Jaeyoung Do, Yinan Li, Hantian Zhang, Badrish Chandramouli, Johannes Gehrke, Donald Kossmann, et al. 2020. ALEX: an updatable adaptive learned index. InProceedings of the 2020 ACM SIGMOD International Conference on Management ...

    2020

  5. [13]

    Jialin Ding, Vikram Nathan, Mohammad Alizadeh, and Tim Kraska. 2020. Tsunami: A learned multi-dimensional index for correlated data and skewed workloads.arXiv preprint arXiv:2006.13282(2020)

    2020 arXiv

  6. [14]

    Facebook. 2024. RocksDB. https://github.com/facebook/rocksdb

    2024

  7. [15]

    Paolo Ferragina and Giorgio Vinciguerra. 2020. The PGM-index: a fully-dynamic compressed learned index with provable worst-case bounds.Proceedings of the VLDB Endowment13, 8 (2020), 1162–1175

    2020

  8. [16]

    Alex Galakatos, Michael Markovitch, Carsten Binnig, Rodrigo Fonseca, and Tim Kraska. 2019. Fiting-tree: A data-aware index structure. InProceedings of the 2019 international conference on management of data. 1189–1206

    2019

  9. [17]

    Jiake Ge, Boyu Shi, Yanfeng Chai, Yuanhui Luo, Yunda Guo, Yinxuan He, and Yunpeng Chai. 2023. Cutting Learned Index into Pieces: An In-depth Inquiry into Updatable Learned Indexes. In2023 IEEE 39th International Conference on Data Engineering (ICDE). IEEE, 315–327

    2023

  10. [18]

    Google. 2024. LevelDB. https://github.com/google/leveldb/

    2024

  11. [19]

    Tu Gu, Kaiyu Feng, Gao Cong, Cheng Long, Zheng Wang, and Sheng Wang. 2023. The rlr-tree: A reinforcement learning based r-tree for spatial data.Proceedings of the ACM on Management of Data1, 1 (2023), 1–26

    2023

  12. [20]

    Ali Hadian and Thomas Heinis. 2020. MADEX: Learning-augmented Algorithmic Index Structures.. InAIDB@ VLDB

    2020

  13. [21]

    Andy Huynh, Harshal Chaudhari, Evimaria Terzi, and Manos Athanassoulis. 2021. Endure: A Robust Tuning Paradigm for LSM Trees Under Workload Uncertainty. arXiv preprint arXiv:2110.13801(2021)

    2021 arXiv

  14. [22]

    Andy Huynh, Harshal A Chaudhari, Evimaria Terzi, and Manos Athanassoulis

  15. [23]

    Stratos Idreos, Niv Dayan, Wilson Qin, Mali Akmanalp, Sophie Hilgard, Andrew Ross, James Lennon, Varun Jain, Harshita Gupta, David Li, et al. 2019. Design Continuums and the Path Toward Self-Designing Key-Value Stores that Know Conference acronym ’XX, June 03–05, 2018, Woodsto...

    2019

  16. [24]

    Stratos Idreos, Kostas Zoumpatianos, Brian Hentschel, Michael S Kester, and Demi Guo. 2018. The data calculator: Data structure design and cost synthesis from first principles and learned cost models. InProceedings of the 2018 International Conference on Management of Data. 535–550

    2018

  17. [25]

    Andreas Kipf, Dominik Horn, Pascal Pfeil, Ryan Marcus, and Tim Kraska. 2022. LSI: a learned secondary index structure. InProceedings of the Fifth International Workshop on Exploiting Artificial Intelligence Techniques for Data Management. 1–5

    2022

  18. [26]

    Andreas Kipf, Ryan Marcus, Alexander van Renen, Mihail Stoian, Alfons Kemper, Tim Kraska, and Thomas Neumann. 2020. RadixSpline: a single-pass learned index. InProceedings of the third international workshop on exploiting artificial intelligence techniques for data management. 1–5

    2020

  19. [28]

    Tim Kraska, Alex Beutel, Ed H Chi, Jeffrey Dean, and Neoklis Polyzotis. 2018. The case for learned index structures. InProceedings of the 2018 international conference on management of data. 489–504

    2018

  20. [29]

    Avinash Lakshman and Prashant Malik. 2010. Cassandra: a decentralized struc- tured storage system.ACM SIGOPS Operating Systems Review44, 2 (2010), 35–40

    2010

  21. [30]

    Shane Culpepper, and Renata Borovica-Gajic

    Hai Lan, Zhifeng Bao, J. Shane Culpepper, and Renata Borovica-Gajic. 2023. Updatable Learned Indexes Meet Disk-Resident DBMS - From Evaluations to Design Choices.Proc. ACM Manag. Data1, 2, Article 139 (June 2023), 22 pages. https://doi.org/10.1145/3589284

    2023 doi

  22. [31]

    Hai Lan, Zhifeng Bao, J Shane Culpepper, Renata Borovica-Gajic, and Yu Dong

  23. [32]

    Pengfei Li, Yu Hua, Jingnan Jia, and Pengfei Zuo. 2021. FINEdex: a fine-grained learned index scheme for scalable and concurrent memory systems.Proceedings of the VLDB Endowment15, 2 (2021), 321–334

    2021

  24. [33]

    Pengfei Li, Hua Lu, Qian Zheng, Long Yang, and Gang Pan. 2020. LISA: A learned index structure for spatial data. InProceedings of the 2020 ACM SIGMOD international conference on management of data. 2119–2133

    2020

  25. [34]

    Pengfei Li, Hua Lu, Rong Zhu, Bolin Ding, Long Yang, and Gang Pan. 2023. DILI: A Distribution-Driven Learned Index (Extended version).arXiv preprint arXiv:2304.08817(2023)

    2023 arXiv

  26. [35]

    Junfeng Liu, Fan Wang, Dingheng Mo, and Siqiang Luo. 2024. Structural De- signs Meet Optimality: Exploring Optimized LSM-tree Structures in A Colossal Configuration Space.Proceedings of the ACM on Management of Data2, 3 (2024), 1–26

    2024

  27. [36]

    Yu Liu, Hua Wang, Ke Zhou, ChunHua Li, and Rengeng Wu. 2022. A survey on AI for storage.CCF Transactions on High Performance Computing4, 3 (2022), 233–264

    2022

  28. [37]

    Kai Lu, Nannan Zhao, Jiguang Wan, Changhong Fei, Wei Zhao, and Tongliang Deng. 2021. TridentKV: A read-optimized LSM-tree based KV store via adaptive indexing and space-efficient partitioning.IEEE Transactions on Parallel and Distributed Systems33, 8 (2021), 1953–1966

    2021

  29. [38]

    Lanyue Lu, Thanumalayan Sankaranarayana Pillai, Hariharan Gopalakrishnan, Andrea C Arpaci-Dusseau, and Remzi H Arpaci-Dusseau. 2017. Wisckey: Sepa- rating keys from values in ssd-conscious storage.ACM Transactions on Storage (TOS)13, 1 (2017), 1–28

    2017

  30. [39]

    Siqiang Luo, Subarna Chatterjee, Rafael Ketsetsidis, Niv Dayan, Wilson Qin, and Stratos Idreos. 2020. Rosetta: A robust space-time optimized range filter for key- value stores. InProceedings of the 2020 ACM SIGMOD International Conference on Management of Data. 2071–2086

    2020

  31. [40]

    Marcel Maltry and Jens Dittrich. 2022. A Critical Analysis of Recursive Model Indexes.Proc. VLDB Endow.15, 5 (2022), 1079–1091

    2022

  32. [41]

    Ryan Marcus, Andreas Kipf, Alexander van Renen, Mihail Stoian, Sanchit Misra, Alfons Kemper, Thomas Neumann, and Tim Kraska. 2020. Benchmarking learned indexes.arXiv preprint arXiv:2006.12804(2020)

    2020 arXiv

  33. [42]

    Ryan Marcus, Andreas Kipf, Alexander van Renen, Mihail Stoian, Sanchit Misra, Alfons Kemper, Thomas Neumann, and Tim Kraska. 2020. Benchmarking Learned Indexes.Proc. VLDB Endow.14, 1 (2020), 1–13

    2020

  34. [43]

    Dingheng Mo, Fanchao Chen, Siqiang Luo, and Caihua Shan. 2023. Learning to Optimize LSM-trees: Towards A Reinforcement Learning based Key-Value Store for Dynamic Workloads.Proc. ACM Manag. Data1, 3, Article 213 (Nov. 2023), 25 pages. https://doi.org/10.1145/3617333

    2023 doi

  35. [44]

    Vikram Nathan, Jialin Ding, Mohammad Alizadeh, and Tim Kraska. 2020. Learn- ing multi-dimensional indexes. InProceedings of the 2020 ACM SIGMOD interna- tional conference on management of data. 985–1000

    2020

  36. [45]

    Jianzhong Qi, Guanli Liu, Christian S Jensen, and Lars Kulik. 2020. Effectively learning spatial indices.Proceedings of the VLDB Endowment13, 12 (2020), 2341– 2354

    2020

  37. [46]

    Pandian Raju, Rohan Kadekodi, Vijay Chidambaram, and Ittai Abraham. 2017. Pebblesdb: Building key-value stores using fragmented log-structured merge trees. InProceedings of the 26th Symposium on Operating Systems Principles. 497– 514

    2017

  38. [47]

    Agung Rahmat Ramadhan, Min-guk Choi, Yoojin Chung, and Jongmoo Choi

  39. [48]

    Subhadeep Sarkar and Manos Athanassoulis. 2022. Dissecting, designing, and op- timizing LSM-based data stores. InProceedings of the 2022 International Conference on Management of Data. 2489–2497

    2022

  40. [49]

    Subhadeep Sarkar, Niv Dayan, and Manos Athanassoulis. 2023. The LSM design space and its read optimizations. In2023 IEEE 39th International Conference on Data Engineering (ICDE). IEEE, 3578–3584

    2023

  41. [50]

    Electronics12, 4 (2023), 1018

    An Empirical Study of Segmented Linear Regression Search in LevelDB. Electronics12, 4 (2023), 1018

    2023

  42. [51]

    Mihail Stoian, Andreas Kipf, Ryan Marcus, and Tim Kraska. 2021. PLEX: Towards Practical Learned Indexing.CoRRabs/2108.05117 (2021). arXiv:2108.05117 https: //arxiv.org/abs/2108.05117

    2021 arXiv

  43. [52]

    Chuzhe Tang, Youyun Wang, Zhiyuan Dong, Gansen Hu, Zhaoguo Wang, Minjie Wang, and Haibo Chen. 2020. XIndex: a scalable learned index for multicore data storage. InProceedings of the 25th ACM SIGPLAN symposium on principles and practice of parallel programming. 308–320

    2020

  44. [53]

    Benjamin Spector, Andreas Kipf, Kapil Vaidya, Chi Wang, Umar Farooq Minhas, and Tim Kraska. 2021. Bounding the last mile: Efficient learned string indexing. arXiv preprint arXiv:2111.14905(2021)

    2021 arXiv

  45. [54]

    Chaichon Wongkham, Baotong Lu, Chris Liu, Zhicong Zhong, Eric Lo, and Tianzheng Wang. 2022. Are updatable learned indexes ready?arXiv preprint arXiv:2207.02900(2022)

    2022 arXiv

  46. [55]

    Jiacheng Wu, Yong Zhang, Shimin Chen, Jin Wang, Yu Chen, and Chunxiao Xing. 2021. Updatable learned index with precise positions. 14, 8 (April 2021), 1276–1288. https://doi.org/10.14778/3457390.3457393

    2021

  47. [56]

    Youyun Wang, Chuzhe Tang, Zhaoguo Wang, and Haibo Chen. 2020. SIndex: a scalable learned index for string keys. InProceedings of the 11th ACM SIGOPS Asia-Pacific Workshop on Systems. 17–24

    2020

  48. [59]

    Shangyu Wu, Yufei Cui, Jinghuan Yu, Xuan Sun, Tei-Wei Kuo, and Chun Jason Xue. 2022. NFL: robust learned index via distribution transformation.arXiv preprint arXiv:2205.11807(2022)

    2022 arXiv

  49. [2023]

    A simple yet high-performing on-disk learned index: Can we have our cake and eat it too?arXiv preprint arXiv:2306.02604(2023)

    2023 arXiv

  50. [2024]

    Towards flexibility and robustness of LSM trees.The VLDB Journal(2024), 1–24

    2024

Pith tools

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