Containerized In-Storage Processing and Computing-Enabled SSD Disaggregation

Donghyun Gouk; Eojin Ryu; Eunjee Na; Hanyeoreum Bae; Hyein Woo; Hyunkyu Choi; Jinwoo Baek; Jiseon Kim; Junhee Kim; Mahmut Kandemir

REVIEW 3 major objections 5 minor 54 references

Containerized In-Storage Processing and Computing-Enabled SSD Disaggregation

T0 review · 3 major / 5 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 DockerSSD claims it can run unmodified Docker containers on SSD firmware, speeding distributed LLM inference by 7.9x.

desk verdict Solid engineering extension of the authors' own HPCA DockerSSD work; the genuinely new LLM pool result is interesting but rests on an unvalidated analytical KV-cache model, so the 7.9x headline is not yet earned. read the letter →

arxiv 2506.06769 v1 pith:VVAEULDQ submitted 2025-06-07 cs.AR

Miryeong Kwon , Donghyun Gouk , Eunjee Na , Jiseon Kim , Junhee Kim , Hyein Woo , Eojin Ryu , Hyunkyu Choi

show 4 more authors

Jinwoo Baek Hanyeoreum Bae Mahmut Kandemir Myoungsoo Jung

This is my paper

classification cs.AR

keywords in-storageprocessingDockercontainersSSDfirmwarevirtualizationNVMeEthernetoverdisaggregatedstorageLLMinferenceKVcache

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

Containerized in-storage processing is the claim that a computational SSD can execute ordinary Docker containers directly on its firmware, without rewriting applications for vendor-specific ISP kernels or APIs. The paper builds this with Virtual-FW, a lightweight firmware stack that emulates 133 system calls and runs a minimal Docker runtime, and Ether-oN, an Ethernet-over-NVMe kernel driver that gives the SSD an IP address and lets the host manage containers with the standard `docker` CLI. The payoff is that any containerized data-processing workload can be offloaded to the drive, and that a set of such drives can be disaggregated into a computing-enabled storage pool that keeps large working sets—notably LLM key-value caches—near the flash. Evaluations on an FPGA prototype and a cycle-accurate simulator report up to 2.0x speedup over a host system and a 7.9x improvement in distributed LLM inference relative to host-based serving with swap. This addresses the paper's five identified ISP challenges: manual implementation, file-layout ignorance, kernel context switching, device reliance, and data vulnerability.

What carries the argument

The load-bearing mechanism is Virtual-FW, a firmware-level OS emulation layer that is the reason containers can run on storage without a full operating system. It replaces the Linux kernel's system-call path with 133 lightweight function wrappers organized into thread, I/O, and network handlers, avoiding context-switch overhead, and it includes mini-docker, a compact implementation of the Docker stack that supports image pull, create, start, stop, restart, kill, rm, logs, ps, and rmi operations. Its counterpart is Ether-oN, a kernel driver that adds transmit and receive NVMe vendor commands (0xE0–0xE1) plus pre-submitted receive commands for asynchronous upcalls, effectively creating a virtual Ethernet link between the host and each SSD over PCIe. Together these let a host manage ISP-containers with the unmodified `docker` CLI, and let a set of DockerSSDs form a disaggregated storage pool whose flash-resident KV caches carry the distributed LLM inference workload.

What would settle it

Run an unmodified container that exercises a system call absent from Virtual-FW's emulated set—such as `clone3`, user namespaces, or `io_uring`—with `docker run` against a DockerSSD prototype. If the container fails to start or silently falls back to host execution, the paper's central claim of unmodified container support is false; a simpler check is to trace the system calls of a typical real-world container (e.g., a data-science notebook) and compare them with Table 1a.

Watch

Extended reading notes

Core claim

The central discovery is that an SSD's firmware can be turned into a container runtime: by emulating just 133 system calls as function wrappers and implementing 11 essential Docker commands in a mini-docker module, Virtual-FW executes unmodified application binaries on the drive's bare-metal cores. Ether-oN adds two vendor-specific NVMe commands (transmit and receive frames) that overlay socket-based Ethernet on PCIe, so each DockerSSD has its own IP address and the host can `docker pull` and `docker run` onto the drive as if it were a networked node. The paper then argues that this makes ISP host-independent and secure: a λFS filesystem partitions NVMe namespaces into a private area for container images and a sharable area coordinated with the host by an inode lock, preventing concurrent modification. In the distributed case, a pool of DockerSSDs runs LLM inference with KV caches stored on flash rather than host DRAM, which the authors show eliminates swap traffic and data copies, giving an average 7.9x improvement over host-based inference with Linux swap.

Load-bearing premise

The whole approach assumes that Virtual-FW's subset of 133 emulated system calls and 11 Docker commands is enough to run arbitrary containerized workloads, yet the paper only tests six hand-picked benchmarks that lie inside that subset.

Editorial extensions

If this is right

Any container that fits within the emulated 133 system-call set can be offloaded to the SSD without recompilation or vendor-specific APIs, so the programming barrier for in-storage processing becomes a compatibility question rather than an API question.
A host can treat a pool of DockerSSDs as ordinary network-attached compute and storage nodes, enabling disaggregated deployments in which each SSD is an independent unit of scale.
Memory-heavy serving workloads that currently rely on host DRAM with swap, such as LLM inference with KV caching, can move their working set into the storage pool and avoid swap overhead and data movement.
The prototype and simulator results indicate that containerized ISP can outperform programmable-ISP baselines (P.ISP-R/V), a full-OS-in-SSD approach (D-FullOS), and a split-processor approach (D-Naive) by 1.6x, 1.6x, and 1.8x respectively.
For long sequence lengths, the flash-resident KV cache makes distributed inference on DockerSSD converge to about 9.5x faster than host-based serving, with the crossover point occurring at sequence length 256 for the smallest tested model and 1,024 for the largest.

Reading between the lines

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

If the coverage assumption holds, the same containerized-ISP design should extend beyond LLM inference to other memory-bound serving workloads, such as vector databases, graph analytics, or large-scale recommendation systems, because the benefit comes from keeping large reusable data structures near flash rather than from anything LLM-specific.
The most direct way to test the paper's central promise is to run a container that uses a syscall outside the 133 emulated set (e.g., `clone3` or user namespaces); if it fails, the 'run without modifying' claim is false.
The Ether-oN mechanism of pre-submitted NVMe receive commands and asynchronous upcalls could serve as a general low-latency data plane for other PCIe devices that need to initiate host communication, not just computational SSDs.
One could probe the performance boundary by varying syscall density and I/O intensity; the paper's own sensitivity analysis suggests compute-bound short-sequence inference stays host-favorable, so the crossover would define where containerized ISP wins.

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.

Desk Editor's Note

read the letter

Quick take: this is an extended version of the authors' HPCA DockerSSD paper, and the honest new contribution is the computing-enabled storage pool for distributed LLM inference. The container-on-firmware idea, Ether-oN, Virtual-FW, and the 2.0x I/O speedup are prior work (refs 13,14) re-presented cleanly. That is fine as an arXiv extended version, but reviewers should not credit those pieces as new.

What the paper does well: the FPGA prototype is real evidence, the workload coverage is decent, and the system-call emulation table is useful. The disaggregation story—DockerSSD as an independent IP-addressable node that can form a pool—is a plausible and genuinely useful direction. I also appreciate that they compare against P.ISP and D-FullOS rather than only against a host.

Now the soft spots, in proportion. The 7.9x LLM speedup is the centerpiece of the extended version, and it is built on an analytical KV-cache model injected into an existing simulator (Calculon). That model is not validated against the prototype, against a real LLM, or even against real flash-backed swap. The baseline H-Cache uses Linux swap to put KV cache on a 400GB SSD, while D-Cache treats flash as local memory. The entire gap is therefore a modeling artifact unless the model's memory-time equations are right.

The stress-test note flags a specific red flag: the paper says a KV cache is O(n^2)-sized and reduces compute to O(n). Standard KV caches are O(n) in storage per layer; what is O(n^2) is accumulated attention traffic. If the model confuses cumulative traffic with resident cache size, the memory-bandwidth advantage of flash-as-local-memory gets exaggerated. I read the relevant paragraph in 'Analysis with varying sequence lengths' and the phrasing is loose enough that the model could indeed be built on that error. The crossover points in Fig. 13 (256 and 1,024 tokens) are suspiciously early for flash to beat DRAM-backed host memory. So the 7.9x claim is not supported as presented. This is the load-bearing weakness, and it is a real one.

Secondary but worth noting: the 133-system-call subset and 11 Docker commands are not proven sufficient for general workloads. That matters for the general-adaptability claim, but it is a scope limitation, not a fatal flaw. No code or data is released, which hurts given the analytical model needs checking.

Who is this for: people working on computational SSDs and near-data processing will want to read it. It deserves a serious referee, not a desk reject, provided the reviewer pushes hard on the KV-cache model and asks for validation or a corrected derivation. My recommendation: send it to peer review with a request for the analytical model to be either validated or replaced.

In short: the I/O story is solid but mostly prior work; the LLM pool story is genuinely new but currently a simulation artifact in waiting. Engage with it, but require the model to be shown correct before believing the 7.9x.

Referee Report

3 major / 5 minor

Summary. The manuscript proposes DockerSSD, an in-storage processing (ISP) model that uses OS-level virtualization (containers) inside SSDs, together with two key mechanisms: Ether-oN, a kernel driver that overlays Ethernet networking on NVMe vendor-specific commands, and Virtual-FW, a lightweight firmware stack that emulates a subset of system calls and supplies a minimal Docker environment. The authors also describe a Lambda filesystem (λFS) for secure backend flash management and a disaggregated computing-enabled storage pool. The paper claims that DockerSSD outperforms a host-only system and prior programmable ISP models (P.ISP-R/V, D-Naive, D-FullOS) by up to 1.6–1.8× on I/O-intensive workloads, and that a pool of DockerSSDs speeds up distributed LLM inference by 7.9× over a host-based swapped-memory configuration. The LLM result is obtained from a simulator (Calculon) extended with the authors' analytical KV-cache model, while the other results are from a combination of an FPGA prototype and gem5/SimpleSSD simulations.

Significance. If the results hold, the containerized-ISP concept could substantially lower the barrier to ISP adoption by removing vendor-specific APIs and source-level modifications, and the disaggregated storage-pool approach could have broad applicability to distributed data services. The paper's strengths include a real FPGA prototype with six RISC-V cores, an open-hardware NVMe controller integration, a clear separation of the ISP-compute path from the block-I/O path, and the demonstration that a lightweight firmware stack can reduce binary size by over 80×. The use of established simulators (gem5, SimpleSSD) cross-validated against RTL is also a positive methodological feature. However, the headline LLM result depends on an unvalidated analytical model with a questionable complexity claim, and the general adaptability claim is only tested on a limited set of workloads.

major comments (3)

[Section VIII, Fig. 13] The text states: 'Using an O(n^2)-sized KV cache allows reuse of previously computed KV vectors, reducing computational complexity to O(n).' This is a scaling error. Standard KV cache size is O(n) per layer (2 * n * d_model * num_layers), while O(n^2) is the complexity of pairwise attention when no cache is used; the cache does not reduce total sequence processing to O(n) because attention still performs O(n^2) dot products across the sequence. If the analytical model added to the Calculon simulator uses an O(n^2) cache size, the memory footprint and swap traffic for H-Cache would be overestimated, making the 7.9× D-Cache-versus-H-Cache speedup and the crossover points at 256 and 1,024 tokens artifacts of the model rather than system measurements. The paper provides no validation of this analytical KV-cache model against real flash devices, the FPGA prototype, or a real LLM inference workload. This is load-bearing for the central extended-version contribution and must be corrected and justified.
[Section V, Table 1a] The paper claims users can 'run algorithms without modifying them for vendor-specific runtimes' and that DockerSSD enables 'diverse data processing near the flash.' This claim rests on the sufficiency of the 133 emulated system calls (65 thread, 43 I/O, 25 network) and the 11 supported Docker commands. The evaluation uses only six benchmarks whose system-call footprints (Table 2) are not shown to be representative. Common syscalls such as ioctl, select/poll, socketpair, sendmsg, recvmsg, and mmap variants are not listed in Table 1a; if any containerized workload needs an unemulated call, execution will fail, and no fallback mechanism is described. The paper should either demonstrate that the emulated subset covers the tested workloads' full call paths or add an explicit compatibility statement, because this limits the generality of the 'run without modification' contribution.
[Section VIII, Methodology] The LLM evaluation is entirely inside a simulator, and the newly added KV-cache analytical model is not cross-validated with either the prototype or a real inference system. The simulator cross-validation cited in the Evaluation section covers the flash backend and RTL, not the analytical model. In addition, the H-Cache baseline uses Linux swap to place the KV cache on a 400GB SSD, which is a page-based mechanism; a more realistic host-side flash-backed KV cache (e.g., paged attention with SSD offload) could reduce the gap to D-Cache substantially. The reported 421× (H-Cache vs. H-NoCache) and 4.6K× (D-Cache vs. D-NoCache) gains are not sanity-checked against known attention-flop counts or memory-bandwidth limits. The authors need to provide the analytical model's equations, validate them against either the prototype or published LLM inference profiles, and compare against a stronger host-side baseline before the 7.9× claim can be accepted.

minor comments (5)

[Abstract] The abstract states 'up to 2.0× better performance for I/O-intensive workloads' without identifying the baseline; clarify whether this is versus Host, P.ISP-R/V, or D-FullOS.
[Evaluation, Figure 10] The phrase 'reduced the Linux binary size by 83.4×' is ambiguous; a reduction by 83.4× means the new size is 1/83.4 of the original, which is likely intended, but the phrasing should be made explicit.
[Section IV, Backend Media Management] The inode-lock protocol is described at a high level but does not specify how the host VFS invalidates a stale inode when the ISP-container modifies a file; a concrete sequence of Ether-oN packets and lock calls would improve reproducibility.
[Section VII, Evaluation] The paper mixes results from the FPGA prototype and the gem5/SimpleSSD simulator without consistently labeling each figure; for example, Figure 3 has no caption or environment description, and Figure 11 does not state which configuration was used for the P.ISP-Latency breakdown. Please add explicit source labels to each figure.
[Section VIII, Fig. 12b] The breakdown labels 'Compute' and 'Memory' are not defined in the caption; state whether 'Memory' includes flash access, swap, or DRAM bandwidth and how these times are measured in the simulator.

Circularity Check

0 steps flagged · score 2.0 of 10

No load-bearing circularity; the 7.9x LLM claim rests on an unvalidated analytical model and self-derived baselines, but not on a fitted or renamed input.

full rationale

I walked the derivation chain. The core ISP containerization (Ether-oN, Virtual-FW, lambda-FS) is inherited from the authors' own prior publications [13,14], and the present manuscript is an extended version, so part of the evaluation is self-referential by provenance. However, no circular reduction is exhibited: the system is measured against external baselines (host-only, Willow/Biscuit-style P.ISP-R/V, D-Naive, D-FullOS) and the gem5/SimpleSSD simulator is cross-validated against the FPGA prototype. The new 7.9x distributed-LLM-inference result is generated by an analytical KV-cache model added to Calculon; the paper states the model's assumptions (H-Cache uses Linux swap, D-Cache treats flash as local memory) but does not present equations, and there is no evidence the model is fitted to the reported speedups. The "O(n^2)-sized KV cache" phrasing is a scaling error (a KV cache is O(n) per layer; the attention matrix is O(n^2)), and the syscall-coverage limitation is real, but these are correctness risks, not circularity. The self-citations to the earlier DockerSSD papers are load-bearing for the architecture's provenance, but the present evaluation would be falsifiable if the model or prototype data were wrong; hence no step meets the quote-and-reduction standard.

Assumptions & free parameters 1 free parameters · 4 assumptions · 4 invented entities

The central claims rest on the availability of capable SSD frontend processors, the sufficiency of a 133-syscall emulation subset, the validity of NVMe vendor commands for Ethernet, and the accuracy of the simulation stack. The free-parameter ledger is small, with only a design choice (four pre-allocated NVMe commands) identified as hand-tuned. No explicit parameter fitting to performance results is described.

free parameters (1)

Number of pre-allocated receive NVMe commands per SQ = 4
The paper states 'Based on our preliminary studies, we use four pre-allocated commands per SQ to balance efficiency and resource utilization.' This is a hand-chosen design parameter that affects the upcall throughput of Ether-oN, but it is not central to the main performance claims.

assumptions (4)

domain assumption Modern SSD frontend processors (e.g., 2GHz, 8 cores) can run containerized Linux applications without a full OS.
The paper cites prior SSD hardware capabilities (references 17, 35, 36) and treats this as given. It is load-bearing because Virtual-FW relies on executing user-space containers on bare-metal embedded cores.
ad hoc to paper Virtual-FW's subset of 133 emulated system calls is sufficient for the tested and future containerized workloads.
The paper implements a subset and evaluates it on 13 workloads, but does not prove completeness. This assumption is needed for the central claim of running 'algorithms without modifying them'.
domain assumption Ethernet packets can be carried over NVMe vendor-specific commands (opcodes 0xE0 and 0xE1) without breaking NVMe compliance or host interoperability.
The Ether-oN design relies on these opcodes being reserved for vendor use and on the host NVMe driver accepting them. This is reasonable but not formally verified.
domain assumption The gem5/SimpleSSD simulation environment accurately models the FPGA prototype's behavior.
The paper says the simulator was 'cross-validated with our hardware RTL and synthesized prototype backend', but no quantitative validation data is shown. The LLM and large-scale results depend on this.

invented entities (4)

Ether-oN independent evidence
purpose: A kernel driver that maps Ethernet packets onto NVMe commands, giving the SSD an IP address and enabling network-based ISP management.
The prototype includes a driver and the paper describes its operation with NVMe vendor-specific opcodes. It is an implemented artifact, not a purely theoretical construct.
Virtual-FW independent evidence
purpose: A lightweight firmware stack that emulates system calls and provides a mini-Docker runtime on the SSD.
Implemented in 7.5K LOC of firmware and evaluated on an FPGA prototype. Its behavior is observable through the reported benchmark results.
Lambda filesystem (lambdaFS) independent evidence
purpose: A backend flash filesystem that uses NVMe namespaces and inode locks to isolate and share files between the host and ISP containers.
The paper describes its implementation and synchronization mechanism; it is tied to the prototype's firmware and tested via the workloads.
mini-docker independent evidence
purpose: A minimal container runtime inside Virtual-FW that supports 11 Docker commands for image and container lifecycle management.
The paper lists the supported commands and describes their use in the evaluation, making it observable.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Containerized In-Storage Processing and Computing-Enabled SSD Disaggregation." pith.science (2026). https://pith.science/paper/VVAEULDQ

@misc{pith2026250606769,
  author       = {Pith},
  title        = {Pith review of: Containerized In-Storage Processing and Computing-Enabled SSD Disaggregation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VVAEULDQ}},
  note         = {Machine review of arXiv:2506.06769}
}

read the original abstract

ISP minimizes data transfer for analytics but faces challenges in adaptation and disaggregation. We propose DockerSSD, an ISP model leveraging OS-level virtualization and lightweight firmware to enable containerized data processing directly on SSDs. Key features include Ethernet over NVMe for network-based ISP management and Virtual Firmware for secure, efficient container execution. DockerSSD supports disaggregated storage pools, reducing host overhead and enhancing large-scale services like LLM inference. It achieves up to 2.0x better performance for I/O-intensive workloads, and 7.9x improvement in distributed LLM inference.

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

54 extracted references · 50 canonical work pages

[1]

Enabling cost-effective data processing with smart SSD

Yangwook Kang, Yang-suk Kee, Ethan L Miller, and Chanik Park. Enabling cost-effective data processing with smart SSD. In 2013 IEEE 29th symposium on mass storage systems and technologies (MSST), pages 1–12. IEEE, 2013

work page 2013
[2]

Accelerating external sorting via {On-the-ﬂy} data merge in active {SSDs}

Young-Sik Lee, Luis Cavazos Quero, Youngjae Lee, Jin-Soo Kim, and Seungryoul Maeng. Accelerating external sorting via {On-the-ﬂy} data merge in active {SSDs}. In 6th USENIX Workshop on Hot T opics in Storage and File Systems (HotStorage 14) , 2014

work page 2014
[3]

Willow: A User- Programmable SSD, OSDI’14

Sudharsan Seshadri, Mark Gahagan, Sundaram Bhaskaran, Trevor Bunker, Arup De, Yanqin Jin, Yang Liu, and Steven Swanson. Willow: A User- Programmable SSD, OSDI’14

work page
[4]

Yoon, Duck-Ho Bae, Insoon Jo, Jinyoung Lee, Jonghyun Yoon, Jeong-Uk Kang, Moonsang Kwon, Chanho Yoon, Sangyeun Cho, Jaeheon Jeong, and Duckhyun Chang

Boncheol Gu, Andre S. Yoon, Duck-Ho Bae, Insoon Jo, Jinyoung Lee, Jonghyun Yoon, Jeong-Uk Kang, Moonsang Kwon, Chanho Yoon, Sangyeun Cho, Jaeheon Jeong, and Duckhyun Chang. Biscuit: A framework for Near-data Processing of Big Data Workloads, ISCA’16

work page
[5]

In-storage processing of database scans and joins

Sungchan Kim, Hyunok Oh, Chanik Park, Sangyeun Cho, Sang-Won Lee, and Bongki Moon. In-storage processing of database scans and joins. Information Sciences , 327:183–200, 2016

work page 2016
[6]

Yoursql: a high-performance database sys- tem leveraging in-storage computing

Insoon Jo, Duck-Ho Bae, Andre S Yoon, Jeong-Uk Kang, Sangyeun Cho, Daniel DG Lee, and Jaeheon Jeong. Yoursql: a high-performance database sys- tem leveraging in-storage computing. Proceedings of the VLDB Endowment , pages 924–935, 2016

work page 2016
[7]

Kaml: A ﬂexible, high-performance key-value ssd

Yanqin Jin, Hung-Wei Tseng, Yannis Papakon- stantinou, and Steven Swanson. Kaml: A ﬂexible, high-performance key-value ssd. In 2017 IEEE International Symposium on High Performance Com- puter Architecture (HPCA) , pages 373–384. IEEE, 2017

work page 2017
[8]

Summarizer: trading communication with computing near stor- age

Gunjae Koo, Kiran Kumar Matam, Te I, HV Kr- ishna Giri Narra, Jing Li, Hung-Wei Tseng, Steven Swanson, and Murali Annavaram. Summarizer: trading communication with computing near stor- age. In Proceedings of the 50th Annual IEEE/ACM International Symposium on Microarchitecture , 2017

work page 2017

Show all 54 references

[9]

Prolonging 3d nand ssd lifetime via read latency relaxation

Chun-Yi Liu, Yunju Lee, Wonil Choi, and Myoung- soo Jung. Prolonging 3d nand ssd lifetime via read latency relaxation. In In Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, pages 730–742. IEEE, 2021

2021
[10]

Catalina: In-storage process- ing acceleration for scalable big data analytics

Mahdi Torabzadehkashi, Siavash Rezaei, Ali Hey- darigorji, Hosein Bobarshad, Vladimir Alves, and Nader Bagherzadeh. Catalina: In-storage process- ing acceleration for scalable big data analytics. In 2019 27th Euromicro International Conference on Parallel, Distributed and Netw...

2019
[11]

{INSIDER}: Designing {In-Storage} computing system for emerging {High-Performance} drive

Zhenyuan Ruan, Tong He, and Jason Cong. {INSIDER}: Designing {In-Storage} computing system for emerging {High-Performance} drive. In 2019 USENIX Annual T echnical Conference (USENIX ATC 19) , pages 379–394, 2019

2019
[12]

Genstore: A high-performance in-storage processing system for genome sequence analysis

Nika Mansouri Ghiasi, Jisung Park, Harun Mustafa, Jeremie Kim, Ataberk Olgun, Arvid Goll- witzer, Damla Senol Cali, Can Firtina, Haiyu Mao, Nour Almadhoun Alserr, et al. Genstore: A high-performance in-storage processing system for genome sequence analysis. In Proceedings of t...

2022
[13]

Containerized in- storage processing model and hardware acceler- ation for fully-ﬂexible computational ssds

Donghyun Gouk, Miryeong Kwon, Hanyeoreum Bae, and Myoungsoo Jung. Containerized in- storage processing model and hardware acceler- ation for fully-ﬂexible computational ssds. IEEE Computer Architecture Letters , 2023

2023
[14]

11 Bae, and Myoungsoo Jung

Donghyun Gouk, Miryeong Kwon, Hanyeoreum This manuscript is an extended version of the original paper accepted by IEEE Micro. 11 Bae, and Myoungsoo Jung. Dockerssd: Container- ized in-storage processing and hardware acceler- ation for computational ssds. In 2024 IEEE Inter- na...

2024
[15]

Samsung Key V alue SSD enables High Performance Scaling

Samsung. Samsung Key V alue SSD enables High Performance Scaling. https://www. samsung.com/semiconductor/global.semi. static/Samsung_Key_V alue_SSD_enables_High_ Performance_Scaling-0.pdf , 2017

2017
[16]

{PinK}: High-speed in-storage key- value store with bounded tails

Junsu Im, Jinwook Bae, Chanwoo Chung, Sungjin Lee, et al. {PinK}: High-speed in-storage key- value store with bounded tails. In 2020 USENIX Annual T echnical Conference (USENIX ATC 20) , pages 173–187, 2020

2020
[17]

LS2088A Intelligent-SSD Card

Argonboards. LS2088A Intelligent-SSD Card. https://www.argonboards.com/ls2088a- intelligent-ssd-card , 2022

2022
[18]

{Vigil- KV}:{Hardware-Software}{Co-Design} to inte- grate strong latency determinism into {Log- Structured} merge {Key-V alue} stores

Miryeong Kwon, Seungjun Lee, Hyunkyu Choi, Jooyoung Hwang, and Myoungsoo Jung. {Vigil- KV}:{Hardware-Software}{Co-Design} to inte- grate strong latency determinism into {Log- Structured} merge {Key-V alue} stores. In 2022 USENIX Annual T echnical Conference (USENIX ATC 22), pa...

2022
[19]

Dotori: A key-value ssd based kv store

Carl Duffy , Jaehoon Shim, Sang-Hoon Kim, and Jin-Soo Kim. Dotori: A key-value ssd based kv store. Proceedings of the VLDB Endowment , 16(6):1560–1572, 2023

2023
[20]

Kv-csd: A hardware-accelerated key- value store for data-intensive applications

Inhyuk Park, Qing Zheng, Dominic Manno, Soonyeal Yang, Jason Lee, David Bonnie, Bradley Settlemyer, Youngjae Kim, Woosuk Chung, and Gary Grider. Kv-csd: A hardware-accelerated key- value store for data-intensive applications. In 2023 IEEE International Conference on Cluster Co...

2023
[21]

Lamda: Large model ﬁne-tuning via spectrally decomposed low-dimensional adapta- tion

Seyedarmin Azizi, Souvik Kundu, and Massoud Pedram. Lamda: Large model ﬁne-tuning via spectrally decomposed low-dimensional adapta- tion. arXiv preprint arXiv:2406.12832 , 2024

2024 arXiv
[22]

Gpt-3: Its nature, scope, limits, and consequences

Luciano Floridi and Massimo Chiriatti. Gpt-3: Its nature, scope, limits, and consequences. Minds and Machines, 30:681–694, 2020

2020
[23]

Jurassic-1: Technical details and evalu- ation

Opher Lieber, Or Sharir, Barak Lenz, and Yoav Shoham. Jurassic-1: Technical details and evalu- ation. White Paper. AI21 Labs , 1(9):1–17, 2021

2021
[24]

Pangu- {\Sigma}: Towards trillion parameter language model with sparse heteroge- neous computing

Xiaozhe Ren, Pingyi Zhou, Xinfan Meng, Xinjing Huang, Yadao Wang, Weichao Wang, Pengfei Li, Xiaoda Zhang, Alexander Podolskiy , Grigory Ar- shinov , et al. Pangu- {\Sigma}: Towards trillion parameter language model with sparse heteroge- neous computing. arXiv preprint arXiv:23...

2023 arXiv
[25]

Scaling language models: Methods, analysis & insights from training gopher

Jack W Rae, Sebastian Borgeaud, Trevor Cai, Katie Millican, Jordan Hoffmann, Francis Song, John Aslanides, Sarah Henderson, Roman Ring, Su- sannah Young, et al. Scaling language models: Methods, analysis & insights from training gopher. arXiv preprint arXiv:2112.11446 , 2021

2021 arXiv
[26]

Large language models and the reverse turing test

Terrence J Sejnowski. Large language models and the reverse turing test. Neural computation , 35(3):309–342, 2023

2023
[27]

Palm: Scaling language modeling with pathways

Aakanksha Chowdhery , Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm: Scaling language modeling with pathways. Journal of Machine Learning Research , 24(240):1–113, 2023

2023
[28]

Efﬁcient large-scale language model training on gpu clusters using megatron-lm

Deepak Narayanan, Mohammad Shoeybi, Jared Casper, Patrick LeGresley , Mostofa Patwary , Vijay Korthikanti, Dmitri V ainbrand, Prethvi Kashinkunti, Julie Bernauer, Bryan Catanzaro, et al. Efﬁcient large-scale language model training on gpu clusters using megatron-lm. In Proceed...

2021
[29]

OpenExpress: Fully Hardware Automated Open Research Framework for Future Fast NVMe Devices, USENIX ATC’20

Myoungsoo Jung. OpenExpress: Fully Hardware Automated Open Research Framework for Future Fast NVMe Devices, USENIX ATC’20
[30]

Deployment of in-storage compute

Scott Shadley . Deployment of in-storage compute. In Storage Developer Conference , 2018

2018
[31]

Revis- iting widely held ssd expectations and rethinking system-level implications

Myoungsoo Jung and Mahmut Kandemir. Revis- iting widely held ssd expectations and rethinking system-level implications. ACM SIGMETRICS Per- formance Evaluation Review , 41(1):203–216, 2013

2013
[32]

Graphssd: graph semantics aware ssd

Kiran Kumar Matam, Gunjae Koo, Haipeng Zha, Hung-Wei Tseng, and Murali Annavaram. Graphssd: graph semantics aware ssd. In Proceed- ings of the 46th international symposium on computer architecture, pages 116–128, 2019

2019
[33]

De- coupled ssd: Rethinking ssd architecture through network-based ﬂash controllers

Jiho Kim, Myoungsoo Jung, and John Kim. De- coupled ssd: Rethinking ssd architecture through network-based ﬂash controllers. In Proceedings of the 50th Annual International Symposium on Com- puter Architecture , pages 1–13, 2023

2023
[34]

Leaftl: A learning- based ﬂash translation layer for solid-state drives

Jinghan Sun, Shaobo Li, Yunxin Sun, Chao Sun, Dejan V ucinic, and Jian Huang. Leaftl: A learning- based ﬂash translation layer for solid-state drives. In Proceedings of the 28th ACM International Con- ference on Architectural Support for Programming Languages and Operating Sys...

2023
[35]

Layerscape 2088A and 2048A Multicore Communications Processors

NXP . Layerscape 2088A and 2048A Multicore Communications Processors. https://www.nxp. com/products/LS2088A
[36]

Microsemi PM8609 12 This manuscript is an extended version of the original paper accepted by IEEE Micro

Microchip Technology Inc. Microsemi PM8609 12 This manuscript is an extended version of the original paper accepted by IEEE Micro. NVMe2032 Controller. https://www.microchip. com/en-us/product/pm8609
[37]

NVM Express

NVM Express, Inc. NVM Express. https:// nvmexpress.org/wp-content/uploads/NVM- Express-Base-Speciﬁcation-Revision-2.2-2025.03. 11-Ratiﬁed.pdf

2025
[38]

Linux Control Groups v1

Linux Man. Linux Control Groups v1. https:// www.kernel.org/doc/Documentation/cgroup- v1/cgroups.txt
[39]

Linux Namespaces

Linux Man. Linux Namespaces. https://man7. org/linux/man-pages/man7/namespaces.7.html
[40]

Docker: Lightweight Linux Contain- ers for Consistent Development and Deployment

Dirk Merkel. Docker: Lightweight Linux Contain- ers for Consistent Development and Deployment. Linux journal , 2014(239), 2014

2014
[41]

Docker, Inc. docker. https://www.docker.com/
[42]

Docker Compose

Docker, Inc. Docker Compose. https://docs. docker.com/compose/
[43]

Kuber- netes

Cloud Native Computing Foundation. Kuber- netes. https://kubernetes.io/
[44]

Xilinx Virtex UltraScale+

Xilinx. Xilinx Virtex UltraScale+. https:// www.xilinx.com/products/silicon-devices/fpga/ virtex-ultrascale-plus.html
[45]

Sim- pleSSD: Modeling Solid State Drives for Holistic System Simulation

Myoungsoo Jung, Jie Zhang, Ahmed Abulila, Miryeong Kwon, Narges Shahidi, John Shalf, Nam Sung Kim, and Mahmut Kandemir. Sim- pleSSD: Modeling Solid State Drives for Holistic System Simulation. IEEE Computer Architecture Letters, 17(1), 2017

2017
[46]

Reinhardt, Ali Saidi, Arkaprava Basu, Joel Hestness, Derek R

Nathan Binkert, Bradford Beckmann, Gabriel Black, Steven K. Reinhardt, Ali Saidi, Arkaprava Basu, Joel Hestness, Derek R. Hower, Tushar Krishna, Somayeh Sardashti, Rathijit Sen, Korey Sewell, Muhammad Shoaib, Nilay V aish, Mark D. Hill, and David A. Wood. The gem5 simulator. A...

2011
[47]

Deep learning recommendation model for per- sonalization and recommendation systems

Maxim Naumov , Dheevatsa Mudigere, Hao- Jun Michael Shi, Jianyu Huang, Narayanan Sun- daraman, Jongsoo Park, Xiaodong Wang, Udit Gupta, Carole-Jean Wu, Alisson G Azzolini, et al. Deep learning recommendation model for per- sonalization and recommendation systems. arXiv preprin...

1906 arXiv
[48]

MariaDB Foundation. MariaDB. https://mariadb. org
[49]

Meta Platforms, Inc. RocksDB. https://rocksdb. org
[50]

GNU grep

Free Software Foundation, Inc. GNU grep. https://www.gnu.org/software/grep/
[51]

GNU coreutils

Free Software Foundation, Inc. GNU coreutils. https://www.gnu.org/software/coreutils/
[52]

Nginx, Inc. Nginx. https://www.nginx.com/
[53]

Chris Evans. vsftpd. https://security .appspot. com/vsftpd.html
[54]

Calculon: a methodology and tool for high-level co-design of systems and large language models, SC’23

Mikhail Isaev , Nic McDonald, Larry Dennison, and Richard V uduc. Calculon: a methodology and tool for high-level co-design of systems and large language models, SC’23. This manuscript is an extended version of the original paper accepted by IEEE Micro. 13

Pith tools

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

[1] [1]

Enabling cost-effective data processing with smart SSD

Yangwook Kang, Yang-suk Kee, Ethan L Miller, and Chanik Park. Enabling cost-effective data processing with smart SSD. In 2013 IEEE 29th symposium on mass storage systems and technologies (MSST), pages 1–12. IEEE, 2013

work page 2013

[2] [2]

Accelerating external sorting via {On-the-ﬂy} data merge in active {SSDs}

Young-Sik Lee, Luis Cavazos Quero, Youngjae Lee, Jin-Soo Kim, and Seungryoul Maeng. Accelerating external sorting via {On-the-ﬂy} data merge in active {SSDs}. In 6th USENIX Workshop on Hot T opics in Storage and File Systems (HotStorage 14) , 2014

work page 2014

[3] [3]

Willow: A User- Programmable SSD, OSDI’14

Sudharsan Seshadri, Mark Gahagan, Sundaram Bhaskaran, Trevor Bunker, Arup De, Yanqin Jin, Yang Liu, and Steven Swanson. Willow: A User- Programmable SSD, OSDI’14

work page

[4] [4]

Yoon, Duck-Ho Bae, Insoon Jo, Jinyoung Lee, Jonghyun Yoon, Jeong-Uk Kang, Moonsang Kwon, Chanho Yoon, Sangyeun Cho, Jaeheon Jeong, and Duckhyun Chang

Boncheol Gu, Andre S. Yoon, Duck-Ho Bae, Insoon Jo, Jinyoung Lee, Jonghyun Yoon, Jeong-Uk Kang, Moonsang Kwon, Chanho Yoon, Sangyeun Cho, Jaeheon Jeong, and Duckhyun Chang. Biscuit: A framework for Near-data Processing of Big Data Workloads, ISCA’16

work page

[5] [5]

In-storage processing of database scans and joins

Sungchan Kim, Hyunok Oh, Chanik Park, Sangyeun Cho, Sang-Won Lee, and Bongki Moon. In-storage processing of database scans and joins. Information Sciences , 327:183–200, 2016

work page 2016

[6] [6]

Yoursql: a high-performance database sys- tem leveraging in-storage computing

Insoon Jo, Duck-Ho Bae, Andre S Yoon, Jeong-Uk Kang, Sangyeun Cho, Daniel DG Lee, and Jaeheon Jeong. Yoursql: a high-performance database sys- tem leveraging in-storage computing. Proceedings of the VLDB Endowment , pages 924–935, 2016

work page 2016

[7] [7]

Kaml: A ﬂexible, high-performance key-value ssd

Yanqin Jin, Hung-Wei Tseng, Yannis Papakon- stantinou, and Steven Swanson. Kaml: A ﬂexible, high-performance key-value ssd. In 2017 IEEE International Symposium on High Performance Com- puter Architecture (HPCA) , pages 373–384. IEEE, 2017

work page 2017

[8] [8]

Summarizer: trading communication with computing near stor- age

Gunjae Koo, Kiran Kumar Matam, Te I, HV Kr- ishna Giri Narra, Jing Li, Hung-Wei Tseng, Steven Swanson, and Murali Annavaram. Summarizer: trading communication with computing near stor- age. In Proceedings of the 50th Annual IEEE/ACM International Symposium on Microarchitecture , 2017

work page 2017