
Driven by the exploding demands for real-time data analytics, hybrid transactional and analytical processing (HTAP) has become a topic of great interest in academia and the database industry. To address the well-known conflict between optimal storage formats for online transactional processing (OLTP) and online analytical processing (OLAP), the conventional practice employs a mixture of distinct indexes and dynamically migrates data across different index domains. Unfortunately, such a multi-index design is notably subject to non-trivial tradeoffs among OLTP/OLAP performance and data freshness. This work advocates a single-index design to serve HTAP workloads. This is made possible by computational storage drives (CSDs) with built-in transparent compression that are emerging on the commercial market. The key is to exploit the fact that compression-capable CSDs enable sparse data management without sacrificing physical storage capacity. Leveraging this, we have developed an HTAP-oriented B + -tree design that can effectively serve HTAP workloads and meanwhile achieve almost instant data freshness. We also comprehensively analyze the inherent effects of storage fill factor and propose a dynamic adapter design to achieve optimal storage/performance efficiency for varying workloads. We have developed and open-sourced a fully functional prototype. Evaluation results show that our design can ensure data freshness and deliver high performance.
Processor vendors constantly introduce new hardware features. Operating systems (OSes) generally enable these features by default, leaving their management to individual applications. This approach, however, can introduce performance overhead or new attack surfaces, a problem termed feature burden . Applications currently lack a fine-grained mechanism to select which hardware features to use. To address this limitation, we introduce the Bespoke Process (bes-proc), a novel operating system abstraction complemented by new hardware extensions for applications with strict performance and security demands. With bes-proc, an application specifies its desired hardware feature set via a processor mask , requiring no modification to the application’s binary. We demonstrate the efficacy of bes-proc by evaluating it on a RISC-V FPGA platform across representative use cases, such as serverless computing, large-memory workloads, and security-sensitive tasks. Our evaluation shows that bes-proc improves performance by a factor of 2.1x to 4.7x.
Safe kernel extensions have gained significant traction, evolving from simple packet filters to large, complex programs that customize storage, networking, and scheduling. Existing kernel extension mechanisms like eBPF rely on in-kernel verifiers to ensure the safety of kernel extensions by static verification using symbolic execution. We identify significant usability issues—safe extensions being rejected by the verifier—due to the language-verifier gap , a mismatch between developers’ expectation of program safety provided by a contract with the programming language, and the verifier’s expectation. We present Rex, a new kernel extension framework that closes the language-verifier gap and improves the usability of kernel extensions in terms of programming experience and maintainability. Rex builds upon language-based safety to provide safety properties desired by kernel extensions, along with a lightweight extralingual runtime for properties that are unsuitable for static analysis, including safe exception handling, stack safety, and termination. With Rex, kernel extensions are written in safe Rust and interact with the kernel via a safe interface provided by Rex’s kernel crate. No separate static verification is needed. Rex addresses usability issues of eBPF kernel extensions without compromising performance.
ASPLOS 2024 received a record of 922 submissions (spread across three review cycles), from which 194 papers were accepted. This record represents an increase of about 50% over 2023, which itself saw a similar increase over 2022. As a result, selecting the best papers proved especially challenging. In this document, we describe the methodology we employed—a process we believe is fair, upholds high standards of quality, and emphasizes consensus and expert judgment. We hope it will be useful for others.
Caches reduce latency and network traffic, and cache performance largely depends on the eviction policy. Eviction effectiveness is typically measured by byte and object miss ratios. Although learning-based eviction policies can reduce misses, their high computational overhead limits practical deployment. This work presents 3L-Cache+, an extended and refined version of 3L-Cache. 3L-Cache+ is an object-level learning-based eviction policy that achieves low computational overhead while delivering strong overall miss-ratio performance. To reduce overhead, we introduce two key techniques. First, we design an efficient training-data collection scheme that filters redundant requests and dynamically adjusts the training frequency. Second, we propose a lightweight eviction method that combines bidirectional sampling, which prioritizes unpopular objects, with an efficient eviction-candidate selection strategy. In addition, an auto-tuning mechanism improves adaptability across traces. We evaluate 3L-Cache+ in a testbed using 4,855 traces. The results show that 3L-Cache+ reduces average CPU overhead by 74.7% and 95.5% compared with HALP and LRB, respectively, and by 22.7% compared with the prior 3L-Cache baseline. 3L-Cache+ incurs only 4.8× LRU overhead under small cache sizes and 3.1× under large cache sizes, while achieving the best byte- or object-miss-ratio performance among 11 state-of-the-art policies.