I think you are wrong if you really think nothing else will match the PS5's storage solution, anyways we don't even know what will be in there, maybe let's wait and see how things will turn out.
OK, let's consider some practical solutions.
SSD benchmarks show us how large block IO and deep command queue results in maximum possible throughput. Using
block size of
256 to 1MB and
queue depth of 8 to 16 commands would often lead to an
order of magnitude better read-write performance than the default values of 4KB and QD 1.
So just reformat the disk to use 2 MB clusters and that should boost real-world throughput in random access loads, right?
(There will be a LOT of wasted spase on small files, but let's just ingnore it for this excercise of thought, since we only care about better random access speeds).
Unfortunately Windows has to maintain compatibility with legacy storage devices and drivers, and that might prevent them from effectively implementing these changes.
Enabling 2MB clusters today will only result in write amplification, when small 4KB buffers in the the IO subsystem will prevent efficient block IO resulting in unnecessary read-modify-write operations, when the entire large cluster will have to be read then written back to update only a small block of data.
First we need to change typical application usage patterns to accomodate zero latency and enormous read bandwidth of NVMe SSDs, and so far this did not happen, as the file handling APIs and block disk IO interfaces did not really change since 1993, even though current storage can work faster than DRAM of these days.
Consider some of the most obvious
changes I mentioned above, like modifying the file system by introducing
8 KB and
16 KB physical sector sizes that match the
write page size of NV flash memory, and
1 MB and
2 MB cluster size that matches the
erase block size.
Only
exFAT and
NTFS currently support large clusters, but not FAT32 or ReFS.
exFAT supports up to
32 MByte clusters, and by default Windows 10 assigns 128 KByte clusters for volumes below 512 GB, then comes in a progression of 256/512/1024/2048 KB etc. cluster sizes for 512GB and 1/2/4 TB etc. volume sizes. (exFAT formatted media also contains the
Flash Parameters block, which can be used to optimize access patterns by the OS).
NTFS supports cluster sizes from 512 bytes to 64 KB (since Windows 2000), while 128/256/512 KB, and 1/
2 MB clusters were added in Windows 10 version 1709 - though Microsoft does not recommend anything but
4 KB.
Unfortunately Microsoft only supports
512B and 4K physical sectors in the IO subsystem; other sizes are not supported, even though both NVMe and exFAT support arbitrary number of bytes per sector, and NTFS has some reserved fields that may be accomodated for this.
Most SSDs advertise
512e (emulation of 512B sectors) and some advertise
4Kn (4K Native, an Advanced disk format first
introduced in Windows8/Server2012), but neither of these match the native write page size.
The problem is virtual memory paging (
pagefile.sys) - Windows has always been using page size of
4 KB on both 32-bit (
x86) and 64-bit (
x64, x86-64) platforms, and so it does on the recent
ARM64 platform.
Windows 10 kernel is closely related to
Windows 2000 (NT 5.0) kernel, which ran on
16 MB of RAM (three orders of magnitude lower than my current 16 GB) and
5 GB hard disk drives (two orders of magnitude lower than current 500 GByte SSDs) with
transfer rates of 5 MB/s (1.5 order of magnitude slower than current 200 MB/s hard disks, and three orders of magnitude slower than the fastest PCIe 4.0 NVMe SSDs that can achieve 5 GB/s).
Yet the page size did not really change through all these years (and neither has the NTFS file system, which remains at version 3.1 as was introduced in Windows 2000).
Nowadays all x64 (Intel64/x86-64) processors support
page size of
2 MB (Page Size Extension flag), and most recent ones ones support page size of 1 GB (
pdpe1gb flag), but Windows kernel
has not been changed to fully support large pages on the same level as 4 KB pages.
Why? Mostly because of driver and application compatibility issues that such a giant leap, from 4KB to 2MB, would have created. Even on
64-bit Itanium, where the virtual memory subsystem supports
eight different page sizes from 4 KB to
256 MB, they've chosen
8 KB page size as the least disruptive - and that was a dedicated server/HPC platform with practically no requirements for backward compatibility.
Future Intel processors might support
arbitrary page allocation units, such as 64 KB page size, but it would take years before such support is widespread.
And without support for large physical sectors - and related support for large memory page sizes - you cannot enable large clusters that match the properties of flash memory devices and eliminate overhead from small sector emulation and internal garbage collection in the SSD.
So there is a lot of work ahead to make the improvements happen, but it's only taking baby steps, with no announced commitment to solve the problem systematically. Not that I can really see how they could practically solve it without some clear break from existing hardware compatibility requirements - something that Apple does with OS X on an yearly basis.