In Storage Computing for Data Intensive Workloads

23 concepts17 papers1 proposal

In traditional computer architectures, computation and storage live in separate worlds. Data resides on a Solid State Drive (SSD) or hard disk, while processing happens exclusively within the central processing unit (CPU) or graphics processing unit (GPU). To perform even a simple operation—such as searching for a specific keyword in a terabyte of text—the data must be fetched from storage, transferred across a system bus (like PCIe), and loaded into main memory (DRAM) before the CPU can inspect it.

As datasets have grown exponentially, this separation has created what computer architects call the "data movement wall" or the von Neumann bottleneck. As noted by David Z. Pan, this bottleneck severely constrains modern data-intensive workloads. The physical interconnect between storage and compute acts as a narrow straw, throttling performance and wasting massive amounts of energy simply shuffling bits back and forth, as described by Kwanghyun Park et al.

In-storage computing (or near-data processing) flips this paradigm. Instead of moving massive amounts of data to the compute units, it embeds processing power directly inside or adjacent to the storage device. By executing data-intensive operations in situ, the storage device filters, aggregates, or transforms the data locally, sending only a tiny fraction of the original volume—the final results—back across the system bus.

Traditional Architecture:
[ Storage ] ====( Massive Data Transfer )====> [ PCIe Bus ] ====> [ Host CPU/RAM ]

In-Storage Computing Architecture:
[ Storage -> Internal Compute (Filter/Reduce) ] ====( Small Result Transfer )====> [ Host CPU/RAM ]

The Intuition: Bandwidth Asymmetry and Data Reduction

To understand why in-storage computing works so well, we must look at the internal architecture of modern solid-state storage. Inside an SSD, data is distributed across dozens of flash memory chips connected via highly parallel internal channels. The aggregate internal bandwidth available within the flash array is often many times higher than the external bandwidth of the PCIe interface connecting the SSD to the host.

When a standard system reads data, this internal parallelism is bottlenecked by the external interface. In-storage computing taps directly into this internal firehose.

Furthermore, many data-heavy workloads exhibit high data reduction ratios. Consider a database scan that filters a billion rows to find a few thousand matching entries. If this filter operation is pushed down into the storage device, the internal processors can scan the flash memory at native speeds. Wenqi Jiang et al. highlight how offloading specific computational operators, such as SQL filters or aggregations, directly into memory controllers or storage interfaces discards irrelevant data before it ever reaches the main system bus. The host CPU is freed from the mundane task of parsing raw data, and the system bus remains unburdened.

This concept traces its roots back to early paradigms like Active Disks proposed by Erik Reidel et al., which demonstrated that offloading application-level logic to the microcontrollers embedded within commodity disk drives could yield linear performance scaling for data mining and multimedia processing.

Hardware Mechanisms: FPGAs, ASICs, and Firmware

Modern implementations of near-data processing rely on a few distinct hardware strategies depending on the flexibility and performance characteristics required by the workload:

1. FPGA-Based SmartSSDs

Integrating Field-Programmable Gate Arrays (FPGAs) directly onto the storage platform allows for reconfigurable, high-throughput hardware acceleration close to the data. For instance, Ji-Hoon Kim et al. demonstrate that embedding FPGA-based accelerators onto a "SmartSSD" platform allows large-scale graph-based nearest neighbor searches to be processed locally. This mitigates both the latency and energy costs of moving billion-vector datasets across the PCIe bus.

2. Specialized ASICs

For fixed, highly intensive workloads, Application-Specific Integrated Circuits (ASICs) offer maximum efficiency. A clear example is found in video analytics: Mahadev Satyanarayanan et al. propose "decode-enabled storage," which integrates specialized video-decoding ASICs directly into the storage controller. This offloads the computationally heavy task of decoding compressed surveillance video formats right where the data resides, eliminating a massive CPU bottleneck during unindexed data searches.

3. Firmware and FTL Customization

Instead of adding new hardware, some approaches repurpose the existing microprocessors already present inside SSD controllers (which typically manage tasks like wear leveling and bad-block management via the Flash Translation Layer, or FTL). Mark Wilkening et al. leverage this by integrating application-specific logic directly into the FTL firmware to accelerate recommendation systems, allowing the storage device to execute data-intensive tasks while simultaneously managing physical data mapping.

Bypassing the Software Stack

The benefits of near-data processing are not solely hardware-based; they also stem from bypassing software overhead. In a conventional system, reading data involves navigating multiple layers of the operating system (OS) kernel, virtual file systems, block layers, and device drivers. This introduces significant latency, context switching, and memory copying overhead.

To achieve true efficiency, near-storage architectures often employ hardware-software co-designs that allow the storage device to operate autonomously. As emphasized by Fatma Ozcan et al., this co-design is essential for moving computation closer to the physical medium cleanly.

For example, Jie Zhang et al. introduce a self-governing flash-based accelerator that bypasses the host OS and file system entirely, fusing non-volatile storage directly with a lightweight processing unit to eliminate traditional data transfer bottlenecks. In large-scale scientific applications, Sumukh Pinge demonstrates that utilizing storage devices with integrated FPGAs enables peer-to-peer data transfers that completely circumvent the host CPU and RAM, maximizing throughput for complex spectral library searches.

Application Paradigms

Near-data processing has proven highly effective across several domains where data volume outpaces compute bandwidth:

  • Databases and Analytics: Pushing down relational operations allows databases to scale efficiently. Kwanghyun Park et al. show that pushing database logic like scans and joins into SmartSSDs can nearly double performance while cutting energy consumption in half. Similarly, Sang Woo Jun et al. utilize in-store processing within the BlueDBM architecture to accelerate big data analytics. This paradigm extends to spatial data as well; Fei Xiao et al. show that pushing analytical operations down to the database management layer minimizes data transfer volumes for massive raster datasets.
  • Graph Processing: Graph algorithms are notorious for random, non-sequential data access patterns that result in poor cache locality on traditional CPUs. Jinho Lee et al. address this with ExtraV, a framework that brings computation closer to storage using a coherent hardware accelerator to efficiently execute out-of-memory graph analytics.
  • Machine Learning and Edge AI: Modern deep learning models often feature data footprints that dwarf host memory capacities. Mark Wilkening et al. accelerate recommendation model inference by offloading large embedding tables from DRAM to SSDs and executing the associated "gather-reduce" operations directly on the SSD controller. For Large Language Models (LLMs), Hongsun Jang et al. demonstrate that offloading parameter updates to computational storage devices (CSDs) bypasses slow system interconnects during training. At the edge, Jack Sampson et al. employ CSDs to co-locate computation with storage on edge servers, drastically reducing data volume and communication latency for continuous learning applications.

By transforming storage units from passive repositories into active processing partners, in-storage computing dismantles the data movement wall, offering a scalable path forward for the world's most data-intensive applications.

Key Foundational Work

Query Processing on Smart SSDs (2014) — contributed 2 concept elements to this direction.
Active Storage for Large-Scale Data Mining and Multimedia (1998) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_near_data_processing_e473b46f,
  title = {near-data processing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/near-data-processing/rdr_e473b46fd3e442d9a1379433c79f758b},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_near_data_processing_e473b46f_v1,
  title = {near-data processing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/near-data-processing/rdr_e473b46fd3e442d9a1379433c79f758b/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake