Access Official Technical PDF

Share Summary:LinkedInEmail

Near-data processing (NDP) offers a different way to address a familiar systems challenge: moving large volumes of information between storage and a host processor can limit performance, particularly when applications repeatedly read data for analysis. Rather than bringing all data to the code, NDP brings selected computation closer to where the data resides. The nKV research system demonstrates this approach for key-value workloads, including lookups, scans, and graph processing on computational storage.

For industrial automation teams evaluating data-intensive infrastructure, the central idea is relevant wherever storage traffic and processing demands compete for system resources. NDP does not eliminate every transfer or suit every operation. Its potential depends on the workload, the storage architecture, and how effectively computation can be placed and parallelized on the device.

Why move computation closer to data?

In a conventional data-to-code architecture, an application requests information through layers such as a file system and block device. The host then reads and processes that information. When data locality is poor or the workload requires many records, repeated movement across the storage-to-host path can consume bandwidth and add overhead.

NDP reverses this pattern for suitable tasks. A storage device with compute resources can execute an operation near the data, returning a result instead of transferring all the underlying records for host-side processing. This code-to-data model aims to make better use of device-internal bandwidth and parallelism, while reducing traffic across the external connection.

Computational storage combines storage and compute elements within a device. In nKV, the system operates directly on non-volatile memory and flash rather than relying on the conventional file-system and block-device path. It also controls physical data placement, allowing related storage structures to be distributed across device resources to use available parallelism.

How nKV applies near-data processing to a key-value store

nKV is based on RocksDB and extends its storage interface with NDP operations. It can run computation on ARM processor cores or use FPGA hardware support, with software and hardware working together where appropriate. Its demonstration uses the COSMOS+ computational storage platform.

A key design requirement is that the device must understand both where data is located and how it is structured. For an operation to run in-situ, the device needs enough information to interpret keys, values, indexes, and records without asking the host to decode each item. nKV supplies data-format definitions to its NDP commands and uses on-device parsers and accessors to navigate storage structures.

For example, a GET request involves locating the relevant sorted-string-table data, interpreting its index, and retrieving the matching key-value entry. A SCAN can examine values against a condition. With conventional processing, a scan may require transferring a much larger volume of data to the host before the condition can be applied. In nKV, the device can evaluate that condition near the stored records.

Different operations benefit in different ways

The reported results show why NDP should be assessed by operation type rather than treated as a uniform speedup. In the demonstrated setup, nKV improved GET latency by 1.4 times, SCAN bandwidth by two times, and Betweenness Centrality execution by 2.7 times compared with the RocksDB baseline. These figures apply to the paper’s test platform and workloads; they are not general performance guarantees for other storage systems.

  • GET: A latency-sensitive lookup can benefit from a lean I/O path and software execution on the device. Because a single request does not expose much parallel work, adding hardware parallelism is not necessarily advantageous.
  • SCAN: Filtering records by a value can avoid sending irrelevant data to the host. The system can process records in-situ and transfer a materialized result set in bulk.
  • Graph analysis: Betweenness Centrality (BC) requires more complex processing. nKV runs a scan to identify relevant papers and references, then performs graph analysis on the intermediate results. The work can use device software and FPGA support.

The demonstration’s dataset contained 48 million key-value pairs in 2.4 GB of data. The BC workload operated on graphs with varying numbers of relevant edges. These details help frame the reported comparisons: the results arose from a particular database, operation pipeline, and hardware configuration.

Data placement, parallelism, and result handling

Near-data execution requires more than adding a processor to a storage device. nKV’s architecture combines native storage access, knowledge of data formats, operation placement, and result handling. Its integrated user-space NVMe layer avoids some overhead associated with a conventional kernel-driver path. Direct access to physical storage also gives the system control over where sorted-string-table data and indexes are placed.

That control can help expose device-level parallelism. For example, data and index blocks can be placed across different logical units and channels. For operations that produce many matches, nKV materializes some or all of the result set on the device and transfers it using the platform’s DMA engine. Bulk transfer avoids the overhead of returning records one at a time.

Parallelism must still be matched to the task. The FPGA can run multiple instances of hardware accessors and parsers, while software execution is constrained by the available ARM cores. The demonstration found that maximum available parallelism did not always produce the best result. This is an important design consideration: more processing resources are useful only when the operation can use them effectively.

Practical considerations for system designers

For engineers and technical decision-makers, nKV illustrates both the opportunity and the implementation requirements of computational storage. Workloads with substantial data movement or repeated scans may be promising candidates, especially when filtering or analysis can be expressed for execution near the data. Short, latency-critical requests may benefit from a simpler software path instead.

Integration also requires attention to storage formats and physical layout. If the device cannot interpret the application’s records or locate them efficiently, it cannot independently execute the intended operation. Teams assessing NDP should therefore consider workload characteristics, data representation, device interfaces, result sizes, and the costs of adapting application logic.

Conclusion

nKV demonstrates how near-data processing can bring key-value operations and graph analysis onto native computational storage, reducing reliance on host-side data movement. Its results show that the benefits vary by workload: scans and complex analysis can exploit device parallelism, while individual lookups may favor software execution. For automation and infrastructure teams managing data-intensive systems, the practical lesson is to evaluate NDP around specific operations and data paths, not as a blanket replacement for conventional storage processing.

Access Official Technical PDF

About The Author