How Fill State and Fragmentation Degrade SSD Benchmarks

This article explores how a high drive fill state and file system fragmentation severely degrade Solid State Drive (SSD) benchmark scores. While SSDs do not suffer from the mechanical delays of traditional hard drives, their internal architecture relies heavily on available free space and efficient data mapping to maintain peak speeds. When an SSD fills up or becomes heavily fragmented, critical features like dynamic caching shrink, background maintenance stalls, and the drive controller becomes overwhelmed with metadata overhead, ultimately resulting in significantly lower synthetic benchmark results.

Dynamic SLC Caching Limitations

Most modern consumer SSDs use Triple-Level Cell (TLC) or Quad-Level Cell (QLC) NAND flash memory, which is inherently slow to write to. To achieve high speeds, drives use a portion of their empty space to simulate faster Single-Level Cell (SLC) memory, known as a dynamic SLC cache.

  • Empty Drive: A large portion of the free space is used as high-speed cache. Benchmarking tools write data directly to this fast zone, yielding maximum advertised speeds.
  • Full Drive: As the drive fills with user data, the dynamic SLC cache shrinks to minimal levels. When a benchmark runs, it immediately exhausts the tiny remaining cache, forcing the SSD to write directly to the slow TLC or QLC NAND. This causes write benchmark scores to plummet.

Garbage Collection and Write Amplification

Unlike hard drives, SSDs cannot overwrite existing data directly. Data is written to small "pages," but can only be erased in much larger "blocks."

When an SSD has plenty of free space, the controller writes new benchmark data to entirely empty blocks. However, when the drive fill state is high, fully empty blocks are scarce; instead, most blocks are partially filled with valid data and old, deleted data (invalid data).

To write new benchmark data on a nearly full drive, the SSD must perform a "read-modify-write" cycle on the fly:

  1. Read the entire partially filled block into its internal memory.
  2. Erase the entire block on the NAND flash.
  3. Write the old valid data back, alongside the new benchmark data.

This process, known as write amplification, forces the SSD to do several times the amount of actual work for a single write request. If a benchmark runs while the drive is forced into this state, write speeds drop drastically and latency spikes.

File System Fragmentation and Controller Overhead

A common myth is that fragmentation does not affect SSDs because they have no physical read/write heads to move. While physical seek times do not exist on flash media, severe file system fragmentation still degrades SSD benchmark scores due to software and controller bottlenecks.

When a file system is heavily fragmented, free space is scattered in tiny chunks across the logical map of the drive. When benchmarking software generates its temporary test file (often 1GB to 64GB in size), the operating system must split that test file into thousands of fragments to fit the available logical gaps.

This degrades benchmark scores in three ways:

  • I/O Overhead: Instead of sending a few large, continuous write or read commands, the operating system must send thousands of small requests to access the fragmented test file. Processing these extra commands slows down transfer rates.
  • Flash Translation Layer (FTL) Strain: The SSD controller uses an FTL to map the operating system's logical addresses to the physical locations on the NAND flash. Fragmented requests force the controller to constantly look up and update thousands of disjointed entries in its mapping table, taxing the SSD’s processor.
  • Reduced Parallelism: SSDs achieve high sequential speeds by writing large chunks of data across multiple NAND chips simultaneously. Fragmented data disrupts the controller's ability to batch and stripe these requests efficiently, lowering sequential read and write scores.

The Compounding Effect During Benchmarks

Synthetic benchmarks (such as CrystalDiskMark or AS SSD) measure maximum theoretical performance by pushing the drive's queue depths and bandwidth to their limits. When you benchmark a drive that is both nearly full and heavily fragmented, these issues compound.

The operating system bottlenecks the test by sending fragmented, inefficient data requests. Simultaneously, the SSD controller is starved of fast SLC cache and is forced to execute slow garbage collection routines just to find space for the benchmark's temporary test files. The result is a benchmark score that reflects the drive's worst-case recovery speed rather than its true hardware capability.