That cheap SATA SSD you installed years ago may not actually be as slow as it feels.If you have been filling it almost to capacity, the problem may have less to do with its age than with how much space you’re leaving available.SSDs have their own way of managing data behind the scenes, and running one close to its limit can make that job considerably harder.
Understanding what happens after you delete, replace, and write data can reveal why a little unused storage can matter more than you might expect.Why SSDs need free space NAND flash cannot simply overwrite existing data An SSD stores data in non-volatile memory that retains its contents when the drive loses power.This memory is called NAND flash, and it stores data in small units called pages, which are grouped into larger units called blocks.
When you replace a file, the SSD cannot simply overwrite the existing data in place.The controller writes the new data to another page and marks the old page as invalid.Before that block can be reused, the controller must move any valid data elsewhere and erase the entire block.
This process is called garbage collection.The controller tracks which pages contain current data and which can be discarded, then reorganizes the remaining data, so entire blocks can be erased and reused.It also distributes writes across the NAND to manage wear.
A drive with plenty of available space has more room to perform these operations.A nearly full drive has fewer empty blocks available, which can make sustained writes more demanding.This becomes particularly noticeable on inexpensive SSDs, where another part of the flash architecture is often used to make write speeds appear much higher than the underlying NAND can sustain.
Why cheap SSDs can slow down during large writes What is an SLC cache? Some consumer SSDs use a portion of their NAND as an SLC cache, a temporary high-speed area that stores incoming data before the controller moves it into the drive’s normal storage.SLC stands for single-level cell, meaning each flash cell stores one bit of data.Most inexpensive SSDs use TLC or QLC NAND, which stores more bits in each cell.
TLC stores three bits per cell, while QLC stores four.Storing more bits increases capacity, but writing and managing those cells is generally slower than using them as SLC.The controller can temporarily operate some TLC or QLC cells in SLC mode, giving the SSD a fast area for incoming writes.
This works particularly well for short file copies because the data can initially be accepted at high speed before being reorganized into its normal storage format.The problem appears when that cache fills during a large transfer.The SSD then has to write more data directly to its native TLC or QLC storage, where sustained write speeds can be considerably lower.
Related Stop underestimating how much SSD storage your PC actually needs Here's why your next SSD needs to be bigger than you think Posts 20 By Nick Lewis A nearly full drive has less room for the controller to manage data and maintain this cache effectively, which can make the transition to slower sustained writes happen sooner.The tradeoff is that storing more bits in each cell requires the controller to distinguish between more voltage states.This makes writes and other management operations more demanding than they are with SLC NAND.
This is why a budget SSD can deliver high burst speeds while providing much lower sustained performance once its SLC cache is exhausted.The difference can become more obvious as the drive fills, because the controller has less free NAND available for moving data and preparing blocks for reuse.That leaves the SSD with two competing demands during heavy writes.
It needs to keep accepting new data while also reorganizing existing data and reclaiming blocks.Leave some capacity unused Free space acts as practical over-provisioning Close I started paying more attention to this after seeing how differently inexpensive SATA SSDs behave once their free space starts disappearing.A good example is the Crucial BX500, a DRAM-less SATA SSD that uses TLC NAND and relies heavily on its flash cache for burst writes.
In testing, a 1 TB BX500 maintained high write speeds until its cache was exhausted, after which sustained writes could fall to around 40 MB/s.The Samsung 870 EVO takes a different approach.Samsung gives the 1TB model a 42GB SLC cache and reserves roughly 9% of the drive’s capacity for internal use.
That built-in spare area is one reason it can maintain more consistent behavior than cheaper SATA drives, although it still has to manage its NAND as the drive fills.That made the idea of leaving some capacity unused much more interesting to me.Over-provisioning means reserving capacity for the SSD controller rather than using it for files.
The controller can use that space while moving valid pages, reclaiming blocks, managing writes, and performing wear leveling.Enterprise SSDs often dedicate substantial capacity to this purpose, while consumer drives generally expose more of their NAND to the user to maximize usable capacity.You can create additional working room yourself without changing the SSD’s firmware.
On a 1TB drive, leaving 100GB unused means the filesystem only consumes roughly 90% of the available capacity.Leave 200GB unused and you have roughly 20% of the drive’s capacity outside your normal storage workload.Related Your unpowered SSD is a ticking time bomb Long-term cold storage on an SSD could be a risky business.
There are better options.Posts By Monica J.White For an older consumer SSD, I would therefore start by keeping roughly 10% to 20% of its capacity free rather than treating that number as a hard requirement.
A drive with generous factory over-provisioning may gain little from additional free space, while a budget model that spends most of its life close to full can benefit considerably.TRIM helps the SSD reclaim space Linux can tell the controller which data is no longer needed Close Free space is only useful if the SSD knows which NAND pages contain data that the filesystem no longer needs.That is where TRIM helps.
When you delete a large directory, Linux knows that those filesystem blocks are available again.The SSD may still contain the old data in its NAND pages, though.TRIM allows Linux to tell the SSD which ranges are no longer required.
The controller can then account for those pages during garbage collection and future writes.On Linux, you can manually issue TRIM with: sudo fstrim -av This asks supported mounted filesystems to discard unused blocks.Most modern Linux distros can also run TRIM periodically through systemd.
You can check the timer with: systemctl status fstrim.timer If periodic TRIM is already enabled, there is usually no reason to run it manually every day.TRIM and unused capacity serve different purposes.TRIM identifies data that can be discarded, while unused capacity gives the controller additional room to manage the NAND.
Keeping both working together is useful for maintaining consistent SSD performance.Related I threw away all my USB flash drives and replaced them with this tiny DIY SSD One tiny external SSD to rule them all.Posts 4 By Goran Damnjanovic Give your SSD some breathing room An SSD’s advertised capacity can make it tempting to think of the drive as having a fixed amount of space that is available for files.
In practice, how much of that capacity you use can affect how the drive behaves over time.That is worth considering when choosing an SSD as well.A 1TB drive that you expect to keep at 90% capacity gives you much less practical headroom than a 2TB drive used for the same workload.
Buying more capacity than you immediately need can therefore have benefits beyond simply fitting more files.It also changes how you might approach an older drive that still has plenty of life left in it.Instead of waiting until storage becomes a problem and the drive is permanently crowded, you can treat some capacity as working room and plan your storage around that from the beginning.
For a drive that has already served you for years, that may be enough to extend its usefulness without changing anything about the hardware itself.
Read More
