Header Ad Placement

Delilah's Chunked Query Offload Takes 8.1 Seconds Against a 5.55-Second Host Baseline

COMPUTATIONAL STORAGE AND QUERY EXECUTION

A one-query prototype study finds that keeping data near storage can save transfers while host-driven chunking, repeated passes and device-memory costs erase the gain. Its baseline also routes through the board.

By Ossam Hashim

KEY FINDINGS

  • Delilah reports about 4.58 seconds for its best offloaded, hand-coded SSB Q3.3 configuration, versus about 5.55 seconds when operators run on the host. In a separate chunking comparison, offload grows from about 5.0 to 8.1 seconds. These are related experiments, not one interchangeable set of configurations.
  • The host baseline reads columns through Delilah before processing them. The result is not a comparison against a tuned database reading a directly attached SSD. Joins, grouping and projection also remain on the host in the offload experiment.
  • eBPF packages calls to registered device functions; it is not necessarily the code doing the expensive filtering. In the reported best-case breakdown, staging and date conversion consume about 63% of query time, while explicit program-offload stages are each below 0.01 seconds.
  • The paper exposes a useful architectural failure mode, not proof that all computational storage loses. Its cited NVMe revisions are older than the versions now listed officially, code safety is out of scope, and the stated column sizes do not reconcile with the claimed shared-buffer fit.

The Question Is Who Owns the Loop

Query Processing with eBPF-Offload on Computational Storage, by Alexander Krause and colleagues, asks whether a host-invoked computational-storage interface is a useful target for query processing. The November 13 paper extends an earlier Delilah project with a detailed execution-model analysis and a hand-coded query evaluation. It is a study of a particular prototype and offload structure, not a new general-purpose database release.

The attraction is familiar: apply filters close to stored data and return a smaller result. But there are two different distances to reduce. Bytes might travel less far between storage and the host while still making repeated trips through memory on the accelerator. A fast predicate does not compensate automatically for staging its input, writing an intermediate result, maintaining cache coherence and asking the host what to do next.

Delilah puts that distinction under pressure. A host loads a program, supplies arguments, requests execution and reads results. For a column larger than the working buffer, the host repeats this sequence over chunks. For a multi-operator plan, it repeats passes. The important question is therefore not simply whether a filter runs in hardware or whether bytecode is portable. It is whether the device can keep processing the data stream without returning control for each unit of work.

What the Standards Actually Promise

The SNIA architecture standard defines a broader programming model than this simple host loop. Its direct model lets a host request a function. Its indirect model associates computation with storage requests, data locality or data characteristics. It also describes aggregator functions that call other functions, including sequences determined from intermediate results.

That distinction matters because the SNIA API standard states that version 1.1 is tailored to a host-orchestrated interface and that a fully device-managed interface requires additional functions. A batch can reduce separate submissions, but an interface for batching known work is not automatically an interface for an ongoing, data-dependent scan. The paper's analysis says its fixed request graphs cannot express the variable iteration it wants.

The current NVMe Computational Programs page independently describes a host-driven approach. It now lists Computational Programs and Subsystem Local Memory revision 1.3, dated within the August 2026 specification set. The paper's bibliography instead cites revision 1.2 from 2025. This article does not treat the paper as a clause-by-clause audit of revision 1.3. Its measured results concern Delilah, while its standards argument must be read against the versions and interfaces it actually discusses.

A Board in the Data Path, Not Compute Inside Flash

Delilah runs on OpenSSD Daisy, using four ARM Cortex-A53 cores and an FPGA in a Zynq system. The evaluated board connects to the host over PCIe Gen3 x8 and to one Samsung 970 EVO SSD over Gen3 x4. An Intel Core i7-4790 host runs the comparison. These are concrete experimental resources, not a survey of current storage hardware.

The processor sits in the path between host and SSD. It accesses that SSD through its external interface, rather than operating inside the flash controller with privileged access to internal flash bandwidth. Conclusions about this board should not be silently transferred to a co-designed SSD, a data-processing unit with a different memory path, or a proprietary streaming engine.

The host driver submits commands through io_uring. A controller in device user space runs uBPF virtual machines, with worker threads pinned to cores. Program slots hold downloaded code; data slots exchange arguments and results; a separate shared buffer stages column data. Registered native functions can use Neon SIMD or drive an FPGA filter.

This is also not a bit-for-bit implementation of every standard command. Delilah deliberately lets registered functions read the underlying SSD. That deviation already gives the device more control over input loading than the strict host-issued storage flow discussed in the paper. It is useful to the experiment, but it needs to stay visible when interpreting standards-wide conclusions.

eBPF Glue Does Not Remove Memory Work

In this design, downloadable eBPF code can call functions registered on the device by name. The same calling format can reach a software implementation or an accelerator facade. Most heavy filtering work can therefore run as native or hardware code rather than as an interpreted bytecode loop.

The paper includes both cases. Its filter calls a vectorized Neon function. Its date conversion instead loops in eBPF, with source-level tuning because the uBPF JIT translates instructions without optimizing the loop. Replacing one bytecode format is consequently not an obvious fix for the whole system. Different operators put different work on the memory path.

Coherence makes the distinction more concrete. Host and SSD DMA do not snoop the device processor caches for the relevant buffers. Whole-slot invalidation and flushing make a tiny invocation pay for a large reserved region. In one 128-MiB-slot microbenchmark, maintenance accounts for 97% of a 16.94-ms execution latency.

Range-based maintenance changes that result dramatically: with 1-GiB slots, the reported 1-KB-file invocation falls from roughly 240 ms to 0.27 ms. But the host must describe the exchanged ranges correctly at cache-line granularity. Hardware coherence is discussed as another trade-off, not implemented as a universal solution. It would constrain the memory placement and consume limited coherent paths.

The Query Is Smaller Than a Database Benchmark

The query is SSB Q3.3 at scale factor 10. It selects two cities and a year range, then groups revenue by customer city, supplier city and year. Customer and supplier attributes are denormalized into the fact-table layout. Filters return bitmasks; the host combines them position by position, groups positions and invokes device aggregation for groups.

Calling this full offload would be misleading without the paper's definition. It means all operators implemented as eBPF programs are offloaded. Joins, grouping and projection still run on the host. It is neither a complete database-engine integration nor the full Star Schema Benchmark suite. Query experiments are reported as averages over ten repetitions.

The host-only baseline also deserves special care. It reads every needed column through Delilah into host memory, then runs the operators on the host CPU. It therefore pays the board's transfer and coherence path even when computation stays on the host. There is no measured comparison here against a tuned engine using a directly attached SSD. That missing control prevents a claim about the best placement on an unconstrained server.

Where the Seconds Go

The best reported Neon-filter breakdown totals about 4.58 seconds. Staging columns costs 1.36 seconds and converting dates to years costs 1.50 seconds, roughly 30% and 33% respectively. Filters consume 0.84 seconds together, and aggregation 0.40 seconds. Intermediate-result transfers are about 0.23 seconds. Values read from the published breakdown are approximate, with 0.01-second resolution.

Against the roughly 5.55-second host baseline, the paper calls the best result about 17% faster. More precisely, those times imply about 17% less elapsed time; they should not be casually relabeled a 17% throughput increase. The host executes its operators in about 1.5 seconds, versus about 2.7 seconds of device filtering, conversion and aggregation. The overall gain comes from avoiding some transfers to the host, not faster device-side operators.

The separate FPGA comparison uses software filters without Neon, so it cannot be compared directly with the best 4.58-second run. With concurrent city filters, hardware filtering changes total runtime from 5.85 to 5.72 seconds. With sequential filters, it changes 7.29 to 6.46 seconds. A faster filter helps, but the shared memory path limits how much query time disappears.

The decisive chunking comparison is another pair: about 5.0 seconds when operators run to completion, versus about 8.1 seconds with 128-MB chunks. That is roughly 60% longer than its own unchunked run and slower than the 5.55-second host baseline. Repeated commands, coherence work, compilation, staging and aggregation passes accumulate. It would be wrong to describe 8.1 seconds as the measured consequence of chunking the separate 4.58-second configuration.

An Unresolved Buffer-Size Discrepancy

The paper describes 60 million values per column: 240 MB each for customer city, supplier city and revenue, plus 480 MB for the date. Those stated sizes add to 1.2 GB. Yet the text says all four columns fit in a 1-GB shared buffer, and Appendix A draws that buffer as 1 GiB. Switching between decimal and binary units does not close the gap.

The publication does not reconcile those statements in the text inspected for this analysis. The appropriate response is to retain the reported timing comparisons while marking the residency assumption unresolved. It is not safe to use the claimed fit as an independently verified capacity calculation, to infer an undocumented compression scheme, or to silently substitute a larger buffer. A reproduction should establish the actual file sizes, staging lifetimes and configured buffer before trusting the best-case explanation.

A Better Evaluation Plan

Start with three baselines: a direct host storage path, the same host query routed through the board, and the device-offload path. This separates accelerator benefit from a cost introduced by the experimental topology. Keep the data layout, predicate selectivity and result correctness fixed across them.

Then record bytes and passes as well as seconds. Separate SSD-to-buffer traffic, device-memory reads and writes, intermediate bytes returned to the host, cache-maintenance ranges and commands per chunk. Sweep working-set size across the actual available buffer and include outputs large enough to fill a data slot. Overlap of two chunks can hide some transfer latency, but it does not eliminate bytes or repeated passes.

A device-driven scan is an architectural alternative worth testing, not a speedup established by Delilah. It needs a way to request the next input, preserve state and emit results without a host restart every time a buffer fills. The paper's proposed co-designed SSD direction goes further by placing computation at multiple points in the data path. No benchmark in this study proves that proposed successor faster.

Assumptions and limitations

This article analyzes one paper and its stated prototype measurements. Standards documents and current official pages provide interface context; project repositories establish that code resources exist, not that the experiments were reproduced or that the checkout matches every reported configuration. No hardware test, code-security audit or performance replication was performed for this article.

The authors argue their roadblocks are structural and stopped before storage-manager integration. That argument is stronger than the empirical coverage: one hand-coded query, one board and SSD, an older host, selected operator implementations and a host baseline routed through the board. Platform-specific coherence delays and random-memory costs are not universal eBPF costs. The unresolved column-size/buffer-fit discrepancy and the newer NVMe revisions further limit broad conclusions.

Downloaded-code safety remains outside Delilah's scope. The paper says its loader checks program-slot fit, not a complete policy for preventing corrupting or nonterminating programs and unsafe registered functions. Portable bytecode and a working JIT do not establish production isolation. The appendix also labels itself generated from the code base; it is documentation, not independent verification of the implementation.

Worked Example: Count Memory Traffic Before Promising a Speedup

This invented bandwidth budget assumes 12.8 GB/s of memory bandwidth. Four full-sized passes per input byte imply an ideal input ceiling of 3.2 GB/s, below a 4-GB/s input stream. If only half the input survives and the last two passes scale with that output, traffic becomes three bytes per input byte and the ceiling becomes about 4.27 GB/s. This is arithmetic, not a Delilah measurement: it ignores protocol overhead, contention and additional intermediates. The paper's four-access illustration is a full-output case, not a universal lower bound for selective filters.

from fractions import Fraction as F
bandwidth = F(64, 5)
for keep in (F(1), F(1, 2)):
    traffic = 2 + 2 * keep
    ceiling = bandwidth / traffic
    print(float(ceiling))
assert bandwidth / 4 == F(16, 5)
assert bandwidth / 3 == F(64, 15)

Sources & Provenance

  • Primary study: Query Processing with eBPF-Offload on Computational Storage, Alexander Krause and colleagues, arXiv:2611.18119, November 2026. Main Sections 1-7, references and Appendix A checked; measured times remain author-reported.
  • SNIA architecture standard v1.2, April 21, 2026. Direct and indirect usage and the broader programming model distinguish architectural possibilities from a particular host interface.
  • SNIA API standard v1.1, May 31, 2025. Its API overview explicitly identifies host orchestration and the need for additional functions for a fully device-managed interface.
  • NVMe Computational Programs page. Current official description of host-driven execution and the August 2026 specification list, including revision 1.3; not a complete audit of its normative clauses.
  • Delilah controller repository. Identifies the Petalinux application for the Daisy OpenSSD platform; not evidence that every benchmark is reproducible from a single current checkout.
  • Delilah evaluation repository. Identifies the experimental-evaluation code resource. Repository inspection here does not validate the measured figures or resolve the shared-buffer discrepancy.

The bandwidth arithmetic and evaluation checklist are explanatory analysis. A negative result on this offload path is a reason to measure orchestration and memory carefully, not to reject every form of near-data computation.

Comments

Kubernetes Liveness Is Not Readiness: Why a Health Check Can Amplify an Outage

KUBERNETES FAILURE RECOVERY A failed health check is an observation. Restarting a container and withholding traffic are different responses, and choosing the wrong one can amplify an outage. By Hossam The important question is what failure should trigger A web application loses access to its shared database. Its processes are still running, but requests that require database access fail. A health endpoint reports the dependency problem. Should Kubernetes restart every application container, or stop directing those requests to it? The endpoint alone cannot choose the right recovery action. Kubernetes separates startup, liveness and readiness probes because they answer different operational questions. Startup protects initialization, liveness can trigger container termination and restart handling, and readiness controls eligibility for traffic from matching Services. A green check is meaningful only within the check and response that were designed. This is a documentation-based de...

Editorial Governance & Pages