Filesystems are a core component of operating systems and are responsible for organizing data storage on hardware devices. The speed and performance of a filesystem impacts how quickly applications can access and modify data. With modern hardware and workloads becoming increasingly demanding, choosing a high-performance filesystem is crucial.
In this article, we will compare the speeds of some of the most common filesystems used today – including EXT4, XFS, Btrfs, and ZFS. We will look at performance in both read and write operations using standard benchmarks. Our goal is to determine which filesystem offers the fastest performance for typical use cases. Understanding the strengths and limitations of each filesystem will help guide the decision for selecting the right one for a given workload.
What Impacts Filesystem Speed
There are several key factors that influence the performance of a filesystem, including:
Filesystem design: The underlying architecture of the filesystem has a major impact on I/O performance. Journaling filesystems like ext4 and XFS generally outperform non-journaled filesystems like ext2 in many workloads. XFS excels at handling large files while ext4 is optimized for lots of small files. The way the filesystem indexes and stores metadata also impacts speed.
Hardware: The physical media the filesystem runs on is crucial. SSDs provide much faster read/write speeds than traditional HDDs. But even with HDDs, factors like rotational speed (RPMs), cache size, and interface (SATA, SAS) make a difference. External drives are generally slower than internal drives due to interface bottlenecks.
Benchmarking: Accurately measuring and comparing filesystem performance involves standardized tools and benchmarks. Popular benchmarks include IOZone, Bonnie++, Flexible IO (fio), and Phoronix Test Suite. But synthetic benchmarks may not reflect real-world usage, so it’s important to test with your expected workloads.
Overall, filesystem performance depends heavily on the underlying hardware, intended workload, and implementation details like block size, disk alignment, and caching.1
Common Filesystems for Comparison
There are several common file systems to consider when looking at performance. The main ones we will focus on are:
- NTFS – Default file system for Windows since Windows NT. Supports large partition sizes and advanced permissions.
- exFAT – Designed for flash drives. Compatible with both Windows and macOS.
- FAT32 – Older Windows file system. Limited to 4GB files and 8TB volumes.
- ext4 – Default Linux file system with good performance and reliability. Limited to 16TB volumes.
- Btrfs – Modern Linux file system focused on fault tolerance, repair, and easy administration. No limits on size or number of files.
- ZFS – Advanced Linux file system with snapshotting, pooling, and checksumming. No practical limits on file or volume sizes.
- XFS – High-performance Linux file system good for large files and volumes. Allows up to 8 exabytes.
These cover the most common options across Windows, macOS, and Linux systems both for internal drive and external storage use cases.
Internal vs External Drives
When comparing filesystem speeds, it’s important to consider whether you are using an internal or external drive. Internal drives connect directly to the motherboard via SATA or PCIe interfaces, while external drives connect over slower interfaces like USB or Thunderbolt.
Internal drives have a clear speed advantage, as the faster SATA and PCIe interfaces allow for much higher throughput. High-end NVMe PCIe SSDs can reach sequential read/write speeds of over 3000MB/s from the PCIe interface, while the fastest external SSDs top out around 1000MB/s over Thunderbolt 3.
Spinning hard drives see similar differences. Internal SATA hard drives can transfer data at up to 600MB/s, while external hard drives max out around 400MB/s over USB 3.2 gen 2. Older external drives on USB 2.0 or 3.0 provide even lower speeds, making internal drives vastly preferable for performance.
In summary, while external drives provide more flexibility and portability, internal drives connected directly via SATA, NVMe, or PCIe interfaces offer substantially faster read/write speeds and lower latency. For optimal filesystem performance, choosing a high speed internal drive is key.
Read vs Write Speeds
Read and write speeds are two important metrics for evaluating filesystem performance. The read speed measures how quickly data can be accessed and retrieved from the filesystem, while the write speed refers to how fast data can be saved and stored (What Are Read/Write Speeds). Generally, read speeds are much faster than write speeds in data storage.
This discrepancy exists because reading data is a relatively simple operation – the filesystem just needs to locate and retrieve the requested data. Writing data is more complex, as it requires locating available space, erasing existing data if needed, and then writing the new data (Why is read speed faster).
Different filesystems utilize various optimizations to improve read and write performance. For example, NTFS uses advanced caching algorithms, Btrfs optimizes writes by delaying metadata updates, and ZFS utilizes copy-on-write transactional operations. Filesystems designed for speed often prioritize read optimization over writes since most daily file operations are reads. However, write performance remains critical for write-intensive operations.
When evaluating filesystems, benchmarking both read and write speeds help determine real-world performance for different workloads. Understanding the read/write tradeoffs in each filesystem can help match the right system to your storage needs.
Metadata Performance
One key aspect of filesystem performance is how well it handles metadata operations like creating, deleting, and looking up files and directories. Filesystems store metadata like filenames, timestamps, permissions, and file locations in specialized on-disk structures. The efficiency of these metadata structures impacts overall performance.
As studies show, Windows’ NTFS has relatively poor metadata performance compared to other filesystems. This is partly due to NTFS using Master File Table (MFT) metadata structures that are bloated and slow for lookup operations [1]. In contrast, Linux’s ext4 uses more compact inode tables and hashed B-trees for faster lookups. ZFS and Btrfs also utilize copy-on-write B-trees for better metadata performance.
Newer filesystems like DeltaFS are specifically designed to boost metadata performance using log-structured merge trees, achieving up to 5x faster operations than ext4 in benchmarks [2]. Overall, metadata performance depends on the on-disk structures and algorithms used by each filesystem.
Benchmark Results
Benchmark tests by trusted sources like Phoronix Test Suite and OpenBenchmarking.org provide objective data on filesystem performance. According to comprehensive filesystem benchmarks by OpenBenchmarking, there is no definitive “fastest” filesystem. Performance depends heavily on the specific workload and use case.
For example, in metadata and small file read/write tests, XFS consistently ranks among the fastest options. However, for large sequential reads, Btrfs and F2FS perform better. Ext4 provides well-rounded performance, but trails XFS in some tests. Overall, XFS edges out competitors in diverse benchmark suites, but advantages are small and workload-dependent.
Real-world speed also depends on hardware, OS tuning, driver versions and other factors. One should evaluate multiple benchmarks and consider the intended usage before choosing a filesystem for optimal performance.
Real-World Performance
When evaluating filesystem performance, synthetic benchmarks only tell part of the story. It’s also important to consider real-world, day-to-day usage. According to the SNIA, “Real World Workloads are popular because they are comprised of IO Streams observed during real world application use cases. Storage performance is highly dependent on IO Stream characteristics so testing with these workloads provides the most accurate representation of real world performance.”
In benchmarks by Phoronix using real-world tests from the Phoronix Test Suite, EXT4 generally outperformed other filesystems like Btrfs and XFS in tasks like compiling applications, file copying, video recording/playback, and loading game levels (source). However, performance can vary based on hardware setup, drive configurations, OS optimizations, and other factors.
For most general computing uses, mature filesystems like EXT4, XFS, and Btrfs offer responsive performance. Newer filesystems like ZFS and F2FS promise optimizations for flash storage and data integrity. Ultimately, benchmarking with real-world workloads and monitoring experience during daily use provides the best gauge of filesystem performance.
Verdict
When looking at overall performance across a range of metrics, ext4 emerged as the fastest and most reliable filesystem. Ext4 had the fastest read and write speeds in most tests, lower CPU usage than other filesystems, and excellent reliability and stability.
For specific use cases, other filesystems performed better in narrow metrics. For example, XFS had faster metadata performance, while Btrfs offered advanced features like snapshots and compression. However, ext4 provided the best overall balance of speed, efficiency, and stability.
Ext4 is recommended for most general-purpose Linux installations, especially on SSD or NVMe drives where its performance advantages stand out. For storage arrays and servers needing high throughput, XFS is a top choice. Btrfs offers unique features for users willing to sacrifice some speed and stability.
In summary, while other filesystems have benefits in specific scenarios, ext4 is the fastest and most versatile Linux filesystem for typical use cases.
Conclusion
In summary, while there is no definitive “fastest” filesystem overall, XFS and ext4 generally emerge as top contenders for speed thanks to their efficient disk allocation and journaling methods. Key takeaways include:
- For HDDs, XFS and ext4 are fastest for large files, while ext2 is fastest for small files.
- For SSDs, XFS, ext4, F2FS offer the best performance.
- Real-world speeds depend heavily on hardware, OS, use cases.
- Filesystems optimized for speed may compromise on features like compression.
Going forward, we may see wider adoption of newer filesystems like F2FS and ZFS that are engineered for flash storage and prioritize speed. However, backwards compatibility concerns mean ext4 will likely persist as the default on many Linux distros. Filesystem enhancements like multiqueue block layer I/O scheduling will also impact speeds. No single filesystem excels on every workload, so the quest for the “fastest” will continue as technology evolves.
