Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteUse GPUs for the numerical work that makes an AI model run; use computational storage to reduce the data that has to reach those GPUs. Matrix multiplication, convolutions, attention, embeddings, training, fine-tuning and inference kernels are GPU workloads. Filtering, decompression, parsing, feature extraction, indexing and deduplication are good candidates for processing beside an SSD. In most production systems the best design is complementary: storage-side processing and caching reduce bytes and CPU overhead, while a direct path such as GPUDirect Storage feeds the remaining data into GPU memory.
What each technology is designed to do
Computational-storage SSDs
A computational-storage drive is an SSD that includes processing resources able to execute selected operations close to the stored data. Instead of transferring every byte to a host CPU, the drive can apply a filter, decompress an object, parse records, calculate features or build an index, then return only the result. The value is not that the SSD becomes a general-purpose accelerator. The value is that fewer bytes cross the storage bus and fewer CPU cycles are spent on data preparation.
As an Amazon Associate I earn from qualifying purchases.
The operations must be expressible in the device’s supported programming model and must justify the overhead of sending work to the drive. A transformation that is too complex, branch-heavy or poorly supported by the device may be faster on a CPU or GPU. Computational storage therefore works best as a selective data-reduction layer, not as a replacement for a full accelerator.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →GPUs
A GPU contains many arithmetic units and high-bandwidth memory optimized for applying the same mathematical operations to large arrays. Deep-learning frameworks map matrix multiplication, convolutions, attention, embedding lookups and related tensor kernels to those units. During training, the GPU also holds activations, gradients and optimizer state; during inference it executes the model’s forward pass and often batches requests to increase throughput.
#1 Best Overall
- MEET THE NEXT GEN: Consider this a cheat code; Our Samsung 990 PRO Gen4 SSD helps you reach near max performance with lightning-fast speeds; Whether you’re a hardcore gamer or a tech guru, you’ll get power efficiency built for the final boss
- REACH THE NEXT LEVEL: Gen4 steps up with faster transfer speeds and high-performance bandwidth; With a more than 55% improvement in random performance compared to 980 PRO, it’s here for heavy computing and faster loading
- THE FASTEST SSD FROM THE WORLD'S FLASH MEMORY BRAND: The speed you need for any occasion; With read and write speeds up to 7450/6900 MB/s you’ll reach near max performance of PCIe 4.0 powering through for any use
- PLAY WITHOUT LIMITS: Give yourself some space with storage capacities from 1TB to 4TB; Sync all your saves and reign supreme in gaming, video editing, data analysis and more
- IT’S A POWER MOVE: Save the power for your performance; Get power efficiency all while experiencing up to 50% improved performance per watt over the 980 PRO; It makes every move more effective with less consumption
GPU memory is much faster than storage but has fixed capacity. Storage capacity and distributed data fabrics scale more easily, so a practical system keeps hot tensors and batches in GPU memory, stages data in local memory or NVMe, and retains the full corpus on a larger storage tier.
Why the choice is usually not either-or
AI input passes through a pipeline: storage, filesystem or object client, CPU or DPU preprocessing, host memory, interconnect and finally GPU memory. A fast GPU can sit idle if the earlier stages cannot deliver complete batches. Conversely, accelerating input delivery does little when the model’s arithmetic occupies the GPU continuously.
NVIDIA’s storage guidance describes the goal as avoiding “starving” accelerated resources by verifying that storage can feed them efficiently. Its DGX guidance also emphasizes balancing the system rather than optimizing one component in isolation. A computational-storage device can remove filtering or decompression work from the host and shrink transfers; a GPU then performs the dense tensor computation on the reduced stream. GPUDirect Storage (GDS) can provide a direct DMA path from storage to GPU memory, avoiding a CPU bounce buffer when the application and stack support it.
Free tools Windows power users keep installed
One-click scans. No signup required.
Match the operation to the engine
| Pipeline operation | Usually the better first target | Reason |
|---|---|---|
| Matrix multiplication and convolutions | GPU | High arithmetic intensity and mature tensor kernels. |
| Attention and transformer layers | GPU | Large parallel tensor operations and model-state reuse. |
| Embedding generation or lookup | GPU, with careful memory planning | Vector math is parallel, but random access can make memory layout decisive. |
| Model training and fine-tuning steps | GPU | Backpropagation and optimizer updates dominate compute. |
| Inference kernels | GPU for the model; storage path for input delivery | Latency depends on both model execution and request-data movement. |
| Filtering rows or objects | Computational storage or DPU | Discarding unwanted records near the data reduces downstream bytes. |
| Decompression and format conversion | Computational storage, DPU or CPU | Choose the location that avoids a transfer bottleneck without delaying batches. |
| Parsing, feature extraction and indexing | Computational storage or DPU when supported | These transformations can reduce or organize data before GPU processing. |
| Deduplication | Computational storage or storage service | Eliminating duplicate payloads saves capacity and traffic. |
This division follows the difference between GPU computation and near-data processing. A storage processor should not be expected to run an entire neural network unless a specific product and software stack explicitly support that model, and even then its performance must be measured against a GPU.
First diagnose the bottleneck: compute-bound or I/O-bound?
The same model can be compute-bound on one dataset and I/O-bound on another. Measure the complete pipeline while the model runs, rather than inferring the answer from the SSD’s sequential-read specification.
Signs that arithmetic is the limit
- GPU utilization remains high while input queues stay populated.
- Changing to faster storage leaves step time nearly unchanged.
- Profiler traces show most elapsed time in matrix, convolution, attention or optimizer kernels.
- Increasing batch size or using a more efficient kernel changes throughput more than changing the data path.
For this case, prioritize GPU count and memory capacity, interconnect bandwidth, kernel efficiency, mixed-precision support and model parallelism. A computational-storage layer may still lower CPU usage, but it is unlikely to deliver the largest speedup.
Rank #2
- Ideal for high speed, low power storage
- Gen 4x4 NVMe PCle performance
- Up to 6,000MB/s read, 4,000MB/s write
- Includes Acronis cloning software
- 5-year limited warranty
Signs that data movement is the limit
- GPU utilization repeatedly drops while the input queue is empty.
- CPU threads spend substantial time reading, decoding, parsing or copying data.
- Storage, network or filesystem bandwidth is saturated before GPUs are busy.
- Increasing workers improves throughput until the host or storage path saturates.
- Large files or many small objects create long tail latency between batches.
Here, improve data layout, caching, direct I/O and preprocessing placement before buying more GPUs. Computational storage can help when it removes a measurable transformation or shrinks the byte stream. A DPU, a better filesystem or a local NVMe staging tier may be a simpler solution.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →What the published throughput figures actually mean
Storage requirements vary dramatically with image resolution, compression, augmentation, worker count and model phase. NVIDIA’s DGX Best Practices document gives a planning figure of 150–200 MB/s per GPU for 1080p files (2022). For some high-resolution computer-vision training workloads, current DGX SuperPOD H200 storage documentation cites 4 GB/s per GPU. The same documentation reports more than 27 GB/s of direct reads into GPUs in a GDS-enabled DGX SuperPOD configuration.
These are workload- and system-specific engineering figures, not a universal comparison between a computational-storage SSD and a GPU. They describe particular DGX configurations, file workloads and software paths. A smaller workstation, a networked dataset, a different compression format or an inference service with tiny requests can produce very different results.
A separate 2021 RecSSD paper reported a 2× end-to-end latency reduction versus commodity SSDs across eight recommendation-inference models. That result is tied to the paper’s device, models and evaluation setup; it should not be generalized to every computational-storage product or AI workload.
How a complementary architecture is assembled
1. Keep the authoritative dataset on scalable storage
Retain the full corpus on the storage tier that meets capacity, durability and sharing requirements. Do not force the entire dataset into GPU memory. GPU memory is the fastest tier but is fixed and expensive per gigabyte; storage and data fabrics provide the capacity needed for large training sets.
2. Stage hot data on local NVMe
Use local NVMe SSDs as a cache or staging tier when repeated epochs would otherwise reread data over a network. Select a drive with enough capacity for the working set, an endurance rating appropriate to repeated writes, a PCIe generation supported by the host and thermal characteristics that fit the chassis. “NVMe SSD” is only an interface category; model, controller, NAND type, capacity and sustained-write behavior still matter.
Rank #3
- SPEED UP PROJECTS. Launch creator applications fast with uncompromising PCIe 4.0 read speeds up to 7,100MB/s,[2] (1TB and 2TB[1] models) and write speeds up to 6,700MB/s[2] (1TB[1]-4TB[1] models).
- CREATE AND STORE MORE. Make more room for your 4K videos and high-resolution images with capacities from 500GB[1] up to 4TB[1] on M.2 2280 built with our trusted 8th generation SANDISK BiCS QLC 3D CBA NAND.
- IT GOES WHERE YOU GO. With an all-new power efficient design, your drive delivers high performance with low power, giving you more time to be productive while on the go.
- UNCOMPROMISED RELIABILITY. With up to 1,200 TBW[3] (4TB[1] model) endurance rating, your drive is designed for creators.
- KEEP YOUR DRIVE UPDATED. Monitor your SSD’s performance and check for updates with the downloadable SANDISK Dashboard application.[5]
3. Reduce data before the GPU when the operation is suitable
Apply predicate filtering, decompression, parsing, feature extraction, indexing or deduplication near the data only when the storage device exposes the required operation and its latency is lower than host processing. Keep transformations deterministic and observable so that a device-side failure can fall back to a host path without corrupting the dataset.
4. Use a direct storage-to-GPU path where supported
GDS can move data directly between storage and GPU memory through DMA, avoiding a CPU bounce buffer. This is valuable when storage I/O is on the critical path. NVIDIA notes that GDS does not help if the CPU must parse or process the data before or after GPU computation, or when computation already dominates and I/O is completely overlapped. The application, filesystem, drivers, storage device and topology must all support the path.
5. Keep batching and overlap explicit
Use asynchronous reads, pinned buffers where required by the framework, and double- or triple-buffered batches so that one batch is transferred while another is processed. Measure whether the overlap is real: a nominally asynchronous pipeline can still serialize on a filesystem lock, decompressor, CPU copy or insufficient queue depth.
Five axes for choosing an investment
| Decision axis | Questions to answer | Implication |
|---|---|---|
| Arithmetic intensity versus bytes moved | How many operations are performed per byte read, and where is elapsed time spent? | High arithmetic intensity favors GPUs; high byte volume with light transforms favors near-data processing and better I/O. |
| Expressibility inside storage | Can the needed filter, decoder or feature transform run on the device without unsupported branches or excessive data copies? | If not, use a CPU, DPU or GPU preprocessing path. |
| Latency and throughput target | Is the service sensitive to tail latency, or is it streaming a large training set? | Inference may favor low-latency asynchronous I/O; training may favor sustained bandwidth and prefetching. |
| GPU-memory and cache fit | Does the hot working set fit in GPU memory or local cache? | Keep reusable data close to the GPU; avoid swapping active training data to disk, which substantially reduces performance. |
| Software and deployment complexity | Are drivers, firmware, orchestration, observability and failure recovery available for the chosen path? | A theoretical bandwidth gain is not useful if integration and operations erase it. |
If the model dominates runtime, spend first on GPU capacity, interconnect and kernel efficiency. If bytes moved dominate, first fix layout, caching, direct I/O and storage-side reduction. Only then decide whether another GPU or a computational-storage device addresses the measured limit.
Choose the data path by model phase
Pre-training
Pre-training commonly streams a very large corpus for many steps. Sustained throughput, shuffling, decompression and host-to-device transfer can become the limit. GDS is a strong candidate when the storage path can deliver directly to GPU memory and the application does not require CPU parsing in the middle. Local NVMe caching can reduce repeated network reads, while computational storage can filter or decode data that would otherwise consume CPU cycles.
Fine-tuning
Fine-tuning datasets are often smaller, but repeated epochs and augmentation can still expose I/O stalls. First check whether the working set fits in local cache. If it does, caching may outperform adding a specialized storage processor. If the dataset remains too large or preprocessing is expensive, near-data filtering and direct reads can be evaluated independently.
Rank #4
- HUGE SPEED BOOST: Get random read/write speeds that are 40%/55% faster than 980 PRO; Experience up to 1400K/1550K IOPS, while sequential read/write speeds up to 7,450/6,900 MB/s reach near the max performance of PCIe 4.0*
- BREAKTHROUGH POWER EFFICIENCY: Use less power and get more performance; Enjoy up to 50% improved performance per watt over 980 PRO, plus optimal power efficiency with max PCIe 4.0 performance**
- SMART THERMAL CONTROL: Samsung's own nickel-coated controller delivers effective thermal control; With its slim size, 990 PRO is a perfect fit for desktops and laptops that meet the PCI-SIG D8 standard***
- THE CHAMPION MAKER: Up to 65% improvement in random performance enables faster loads for an ultimate gaming experience on PS5 and DirectStorage PC games****
- SAMSUNG MAGICIAN SOFTWARE: Get the most out of your SSD with Samsung Magician's advanced yet intuitive optimization tools; Monitor drive health, protect valuable data, and receive important updates for your 990 PRO
Inference
Inference has two distinct paths: model execution and request-data handling. A GPU usually executes the model kernels, while the storage path serves documents, embeddings, prompts or feature records. Small requests may be dominated by metadata and tail latency rather than sequential bandwidth. The 2026 ACM study of libaio, io_uring, SPDK and GDS across large-language-model pre-training, fine-tuning and inference reports io_uring as useful for inference and GDS for pre-training and fine-tuning. That result supports selecting an I/O path by phase instead of naming one API the universal winner.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallWhere DPUs and Magnum IO fit
A DPU can handle networking, storage services, security or data movement outside the host CPU. NVIDIA’s Magnum IO approach combines storage I/O, network I/O, in-network compute and DPU acceleration for multi-GPU systems. This is broader than a computational-storage SSD: the DPU may sit in the server or network path while the SSD remains a conventional device. For a multi-GPU cluster, evaluate the complete topology—PCIe switches, NUMA placement, network fabric, storage targets and GPU affinity—rather than comparing device labels in isolation.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.A benchmark that answers the real question
Run an end-to-end benchmark with the production model phase and representative data. A synthetic sequential-read test cannot reveal whether decompression, metadata, cache misses or CPU copies starve the GPU.
- Define the unit of work. Record samples per second, tokens per second, training-step time or inference latency, including p50, p95 and p99 where service latency matters.
- Use representative data. Match file sizes, compression, sharding, augmentation, object count and access pattern. Test both a cold cache and a warm cache.
- Measure each stage. Capture storage throughput and latency, filesystem or object-client time, CPU utilization, decompression and parsing time, host-memory bandwidth, PCIe or network traffic, GPU utilization and GPU-memory occupancy.
- Compare paths, not just devices. Test the baseline CPU path, local NVMe cache, computational-storage reduction if available, asynchronous I/O and GDS where supported. Keep batch size, worker count and model settings constant for each comparison.
- Check overlap. Inspect traces for gaps between batches. If I/O is fully hidden behind computation, a faster storage path may show no end-to-end gain even when its raw bandwidth is higher.
- Repeat across phases. Pre-training, fine-tuning and inference have different access patterns. A path that wins for streaming training may lose for small, latency-sensitive inference requests.
- Test failure behavior. Disconnect a cache tier, fill it, restart a device-side service and introduce a malformed record. Verify that the pipeline reports errors and falls back safely.
Common mistakes and how to correct them
Buying GPUs for an empty input queue
More GPU capacity cannot fix a loader that delivers batches late. Profile queue depth and CPU preprocessing first; add caching, asynchronous reads, better sharding or near-data filtering when those are the measured limits.
Assuming a fast NVMe label guarantees training speed
Drive bandwidth may be limited by PCIe lanes, thermals, filesystem overhead, network storage, decompression or small random reads. Validate sustained performance in the target chassis and workload, and check endurance for write-heavy caches.
Sending data through the CPU despite selecting GDS
A CPU parser, unsupported filesystem, incompatible driver or hidden memory copy can force a bounce-buffer path. Confirm the actual DMA route with the platform’s telemetry and ensure that the application does not require CPU processing between the read and GPU kernel.
Best Value
- This product has been replaced by our latest generation. Please search for the SANDISK Optimus GX 7100 NVMe SSD
- HIGH-OCTANE GAMING. Experience speeds up to 7,250MB/s read and 6,900MB/s write (1-2TB models), with up to 35% faster performance than previous generation.
- PURPOSE-BUILT. Designed for serious on-the-go gamers, with a PCIe Gen4 interface and SANDISK’s next generation TLC 3D NAND.
- MORE TIME TO CLEAR THAT CHECKPOINT. Built with laptops and handheld gaming devices in mind, with up to 100% more power efficiency over the previous generation.
- DO MORE WITH DASHBOARD. Ensure your drive is optimized for prime performance with the downloadable WD_BLACK Dashboard (Windows only).
Offloading every transformation to storage
Device-side execution has finite compute, memory and firmware support. Offload only transformations that reduce meaningful traffic or CPU work. Keep complex, model-dependent augmentation on the engine that can execute it efficiently.
Ignoring cache state
A warm-cache benchmark can make a slow backend appear irrelevant, while a cold-cache run can exaggerate startup costs. Report both states and the cache-fill policy used in production.
Comparing isolated components
A computational-storage SSD, GPU, DPU or I/O library cannot be ranked fairly without the same dataset, model, topology and software stack. End-to-end step time or request latency is the decision metric.
Recommended Free Tools
Costs, power and operational trade-offs
No neutral, apples-to-apples cost-per-performance comparison between commercial computational-storage SSDs and current GPUs is established by the available figures. Prices, power draw, endurance and return on investment depend on the specific drive, accelerator, server, workload and utilization. Treat any universal speedup, watt or dollar claim with caution unless it comes from a benchmark matching your configuration.
Computational storage adds firmware, device management, security and observability requirements. GPUs add accelerator scheduling, memory management, cooling and often licensing or cluster-orchestration considerations. A conventional NVMe cache may deliver most of the benefit with less operational complexity; a specialized device becomes more attractive when repeated preprocessing is demonstrably the bottleneck and the reduction is large enough to keep expensive GPUs busy.
Practical decision checklist
- Measure GPU idle time and input-queue starvation during the real workload.
- Separate model-kernel time from read, decode, parse and copy time.
- Classify each preprocessing operation as GPU-suitable math, host work or near-data reduction.
- Confirm GPU-memory capacity, local-cache capacity and the size of the hot working set.
- Validate PCIe lanes, NUMA placement, network topology, thermals and sustained NVMe behavior.
- Check whether the filesystem, drivers and application support GDS or another direct path.
- Benchmark cold and warm cache, production compression and all relevant model phases.
- Document fallback behavior when a computational-storage or cache tier is unavailable.
Bottom line
Computational storage should handle data reduction; GPUs should handle dense AI mathematics. It cannot generally replace a GPU for training, fine-tuning or inference kernels, and a GPU cannot automatically solve a storage or preprocessing bottleneck. Start with measurements, improve layout and caching, use direct storage-to-GPU transfers when the stack supports them, and add computational-storage processing only where it removes a proven source of byte movement or CPU work.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
