Free tools Windows power users keep installed
One-click scans. No signup required.
iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
A fast SSD can be completely healthy while an AI job barely reads from it. Storage is only one stage in the path from a dataset to a running kernel: files must be found, decoded, transformed, moved through host memory, copied to accelerator memory, and scheduled with enough parallel work. If any earlier or later stage is slower, the drive waits. Diagnose the complete pipeline and measure end-to-end throughput before buying a faster SSD.
What the SSD is—and is not—responsible for
In a conventional training or inference path, data moves from storage into host memory and then from host memory into GPU memory. The SSD can deliver bytes only as fast as the filesystem, application, CPU, memory subsystem, transfer link and consumer of those bytes allow. NVIDIA describes this storage-to-host-to-device route in its data-loading and transfer guidance. A GPUDirect Storage path can reduce CPU and host-memory involvement in some supported environments, but its availability and benefit depend on the platform, software stack and workload; it is not an automatic replacement for ordinary loading.
After a read completes, the application may still spend more time decoding images, decompressing archives, tokenizing text, applying augmentation, waiting for a worker process, or synchronizing a batch than it spent reading the file. On the other side of the transfer, GPU kernel launches, insufficient batch parallelism or model computation can dominate. A utilization percentage from one component cannot identify which stage is limiting the job.
Why a fast SSD can look idle
Peak bandwidth is not workload throughput
Drive specifications usually describe a favorable sequential pattern and a particular queue depth. AI datasets often involve many small files, random or strided reads, metadata lookups, compressed records, concurrent workers and repeated transforms. Those operations may never approach the headline sequential number. A filesystem, network mount or container layer can impose a lower ceiling even when the underlying device is capable of more.
#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
The consumer may be slower than the producer
If CPU transforms or Python-side scheduling cannot prepare the next batch, the SSD has no reason to remain busy. Likewise, if the accelerator is already occupied with a long kernel, the loader may pause. In both cases the storage trace shows idle periods even though the job is progressing normally.
Low GPU activity is not proof of slow storage
NVIDIA’s GPU performance guidance notes that insufficient parallelism can leave compute resources underused. A small batch, serial request handling, synchronization in the application, or a model with little independent work can produce low accelerator activity while storage is waiting. PyTorch also identifies data loading as only one possible bottleneck. Treat low GPU utilization as a symptom requiring a timeline, not as a storage diagnosis.
Caching changes what you are measuring
Once the operating-system page cache or an application cache contains the dataset, later epochs may read mostly from memory. A cached run can therefore be faster without exercising the SSD, while a cold-start run may expose filesystem and metadata costs. Record whether each test is cold, warm or deliberately cache-neutral and compare like with like.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Map every stage of the input-to-compute path
Use this map to turn an apparent SSD problem into a stage-specific question. The symptoms are clues, not proof; confirm them with timestamps and counters.
| Stage | What happens | Typical symptom | Useful check |
|---|---|---|---|
| Storage device | Blocks are read from the SSD or another block device. | High device latency or sustained utilization while consumers wait. | Observe read latency, throughput and queue depth during the representative run. |
| Filesystem or network layer | Paths, metadata, mounts, permissions and remote protocol requests are resolved. | Many small-file stalls or large variation between directories and hosts. | Compare the same data on the intended local path and inspect metadata-heavy intervals. |
| Worker processes | DataLoader workers fetch samples and build batches. | Workers are busy while the accelerator waits, or workers frequently go idle. | Trace worker activity and vary worker count under controlled conditions. |
| Decode and transforms | Compression, image or audio decoding, tokenization and augmentation run on the CPU or in libraries. | CPU saturation, long batch preparation and little storage activity. | Time decoding and transforms separately from file reads. |
| Host memory | Samples are staged, copied and possibly pinned for transfer. | Copy or allocation time dominates; memory pressure causes paging. | Watch host-memory bandwidth, allocation behavior and pinned-memory use. |
| Host-to-device transfer | Prepared batches move across the platform link into accelerator memory. | Gaps before kernels with visible copy operations in a trace. | Inspect transfer duration and overlap with computation. |
| GPU scheduling | Kernels are launched and independent work is kept in flight. | Short kernels separated by idle gaps or low occupancy. | Use a device timeline and check batch and request parallelism. |
| Model compute | The accelerator performs forward, backward or generation work. | Long kernels with little input waiting. | Compare iteration time with input removed or prefetched, without changing model behavior. |
Establish a baseline before changing hardware
A useful baseline describes the real job, not an isolated disk benchmark. Keep the dataset, preprocessing, batch size, precision, number of requests or training steps and software environment fixed. Run long enough to include normal variation rather than diagnosing a startup transient.
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
- Choose a representative interval. Exclude one-time initialization, then record several dozen iterations or a suitable request window. Note whether data is cold, warm or cached.
- Record an end-to-end rate. For training, capture examples or tokens per second and iteration time. For inference, capture request latency and throughput, including the input path you care about.
- Record concurrent activity. Capture accelerator utilization, memory use, host CPU utilization, memory pressure, device-copy activity, storage throughput, read latency and queue depth over the same timestamps.
- Mark batch boundaries. A timeline showing when a batch becomes available is more informative than a single average utilization number. Keep the measurements for a baseline run so later changes can be compared.
- Change one factor at a time. If you increase workers, move the dataset and change batch size simultaneously, you cannot attribute the result to storage.
The decision metric is end-to-end progress. A higher SSD counter without a higher examples-per-second rate means the drive is doing more work but has not removed the limiting stage.
Profile the execution and input pipeline
PyTorch Profiler
PyTorch Profiler records operator costs, input shapes, device activity and execution traces. Use a short warm-up followed by a measured window so initialization does not dominate. In the trace, look for gaps before a batch reaches the device, long CPU-side operators, copy operations that do not overlap with kernels, and kernels separated by host scheduling delays. Correlate those intervals with storage and worker telemetry rather than interpreting a trace lane in isolation.
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 minuteNVIDIA DLProf
NVIDIA’s DLProf user guide describes reports that correlate timing and kernel information and include GPU utilization and I/O duration. An interval with long I/O duration and a waiting accelerator supports an input-path hypothesis. An interval with short I/O but long kernels points toward compute. A report showing low utilization without a corresponding I/O delay is consistent with insufficient parallelism or another host-side constraint, not automatically a slow SSD.
What a convincing trace looks like
| Trace pattern | Most likely interpretation | Next test |
|---|---|---|
| Device waits while workers and reads are active | Input preparation or storage path may be limiting. | Separate read, decode and transfer times; test a tuned loader. |
| Reads finish early, CPU transforms occupy the interval | Decode or augmentation is the constraint. | Measure transform cost and test an equivalent cached or predecoded representation. |
| Copies are long and do not overlap kernels | Host-to-device transfer, pinned-memory handling or synchronization may dominate. | Inspect transfer settings and overlap, then retest without changing the model. |
| Long GPU kernels fill the timeline | Model computation, not storage, controls iteration time. | Optimize or parallelize compute; an SSD upgrade is unlikely to change the rate. |
| Short kernels with large gaps and little I/O | Insufficient parallelism or launch and scheduling overhead is plausible. | Check batch size, request concurrency and synchronization points. |
Isolate storage without fooling yourself
Run controlled comparisons that preserve the behavior you are trying to measure. A cached or synthetic-input run can answer whether the job improves when physical reads are removed, but it is not a production result if it changes decoding, record sizes, randomness or augmentation. Use it as an isolation experiment, then return to the real dataset.
- Real data, normal path: establishes the baseline that matters to users.
- Warm-cache real data: indicates how much cold storage and metadata work affects later iterations.
- Equivalent predecoded or staged data: helps separate decoding from file access, provided the representation and batch behavior remain comparable.
- Synthetic tensors: removes storage and most preprocessing, exposing transfer, scheduling and model-compute time. Do not present its throughput as a measured production outcome.
If replacing physical reads with an equivalent staged source does not improve end-to-end throughput, storage was probably not the limiting stage. If it does, measure which part changed: device reads, filesystem calls, worker wait time, decoding or transfer.
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]
Tune the loader before buying a drive
PyTorch supports asynchronous loading with multiple DataLoader workers. The correct values depend on the workload, CPU, accelerator, memory capacity and data location; copying another machine’s settings is not evidence. Change one setting, repeat the baseline interval and watch both throughput and resource pressure.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated 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 matchWorker processes
Set num_workers above zero to allow background workers to prepare batches. Increase it gradually until preparation no longer leaves the device waiting or until CPU contention, memory use or context-switch overhead worsens. A high count can reduce performance when transforms are light, files are remote, or the host has few cores.
Pinned host memory
PyTorch can use pinned memory to make accelerator transfers more suitable for asynchronous operation. It consumes non-pageable host memory, so watch for exhaustion and do not assume it helps when copies are already hidden by computation.
Persistent workers and prefetching
Persistent workers avoid recreating worker processes between epochs. Prefetching lets workers prepare future batches, but too much prefetched data increases memory use and can amplify stale or wasted work when batches are discarded. These controls matter only when worker startup or preparation is visible in the trace.
A configuration example
DataLoader(
dataset,
batch_size=batch_size,
num_workers=workers,
pin_memory=True,
persistent_workers=(workers > 0),
prefetch_factor=prefetch_batches,
)This is a template for an experiment, not a universally optimal recipe. Record the chosen values with the baseline and verify that the loader still produces the same samples, ordering guarantees and augmentation behavior required by the job.
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 →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
When the measurements justify an SSD upgrade
Consider storage hardware only when representative traces show the storage stage constrains batch availability and changing software or staging materially changes end-to-end throughput. Look for sustained device or filesystem wait, storage latency that aligns with worker starvation, and a measurable improvement when the same workload is supplied from a demonstrably faster path. A high peak number by itself is not sufficient.
Validate the result with an A/B test: keep the host, dataset, loader settings, model and run interval constant; change only the storage path; repeat enough times to account for cache state and normal variance. Report the end-to-end rate and latency, not only the SSD benchmark. If the device was already idle during waits caused by decoding, transfers or compute, a faster drive will have little effect.
How to compare SSDs for an AI workload
Once storage is proven to be the constraint, compare drives against the access pattern and platform rather than the largest sequential figure. The following criteria are the ones that determine whether a replacement can address the measured stage.
| Criterion | Questions to answer | Why it matters |
|---|---|---|
| Interface and protocol | Does the system slot, firmware and operating system support the drive’s physical format and protocol? | An incompatible interface cannot deliver any performance, regardless of its specification. |
| Capacity | Can the dataset, indexes, temporary files and cache fit without constant eviction? | Capacity pressure can recreate the same stalls through extra copying or remote access. |
| Access pattern | Are reads small, random, sequential, concurrent or mixed with writes? | Peak sequential bandwidth may say little about dataset-specific reads. |
| Latency and queue depth | What latency occurs at the concurrency generated by the loader? | Worker starvation is often sensitive to tail latency, not just maximum throughput. |
| Sustained behavior | Does performance remain stable through the full dataset and expected thermal conditions? | Short bursts can hide throttling or cache exhaustion. |
| Endurance | What write volume comes from checkpoints, caches, logs and preprocessing? | A read-focused workload can still have substantial writes over its service life. |
No particular SSD model is established as faster for a specific AI workload here. Choose a category and model only after checking the measured pattern, system compatibility and expected write duty.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Common misdiagnoses and fixes
Misdiagnosis: the GPU is at 40%, so the SSD is slow
Why it fails: insufficient parallelism, small batches or synchronization can underuse the accelerator without any storage wait. Fix: inspect a device timeline and compare accelerator gaps with worker, transfer and storage timestamps.
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).
Misdiagnosis: a synthetic benchmark proves the drive is adequate
Why it fails: a sequential benchmark does not reproduce metadata, small-file, decode or concurrent-read behavior. Fix: benchmark the representative access pattern only after profiling the real job.
Misdiagnosis: adding workers always increases throughput
Why it fails: workers compete for CPU, memory and filesystem resources, and remote storage can become the shared bottleneck. Fix: sweep worker counts while recording end-to-end rate, CPU pressure and storage latency.
Misdiagnosis: cached data proves the production path is fixed
Why it fails: a warm cache removes physical reads and may hide startup, eviction or multi-process behavior. Fix: label cache state and test the cold, warm and steady-state cases that users actually experience.
Misdiagnosis: more prefetch is free
Why it fails: queued batches consume memory and can perform work that is later discarded. Fix: increase prefetch only when the trace shows loader starvation, then check memory and ordering behavior.
A repeatable decision procedure
- Define the outcome: examples or tokens per second, iteration time, request latency or another end-to-end measure.
- Capture a stable baseline: document software, data location, cache state, batch size, workers and accelerator activity.
- Trace one measured window: use PyTorch Profiler, NVIDIA DLProf or equivalent timeline evidence to locate waits.
- Classify the wait: storage or filesystem, decode and transforms, worker scheduling, host memory, transfer, GPU scheduling or model compute.
- Run one isolation experiment: for example, equivalent staged input or synthetic tensors, while preserving the part of the workload under test.
- Tune software first: test worker count, pinned memory, persistence and prefetching only when the trace implicates the loader.
- Test storage A/B: use the same workload and compare end-to-end results, not just device counters.
- Purchase only for a measured constraint: verify compatibility, workload-specific latency and throughput, capacity and endurance.
Practical checklist
- Have you measured a representative interval rather than a startup transient?
- Are cache state and data location documented?
- Do storage, worker, CPU, host-memory, transfer and GPU timelines share timestamps?
- Can you identify the interval in which the accelerator waits for a batch?
- Have you separated file reads from decoding and augmentation?
- Did you test DataLoader settings on this host instead of copying another configuration?
- Does removing physical input improve end-to-end throughput?
- Does changing only the storage path improve that same metric?
- Does the candidate drive match the system interface, access pattern, capacity and endurance needs?
The reliable answer to an underused fast SSD is therefore a measurement, not a specification sheet. Follow the bytes and the waits from storage through host processing and transfer to the accelerator; upgrade the stage that the trace shows is limiting progress.
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.
