Linux 7.3 is beginning to take shape as one of the more performance-focused kernel updates in recent years.
The first release candidate arrived on August 30, closing the merge window and beginning the testing phase. The major features expected to appear in the final release have now landed.
Many of the improvements focus on keeping Linux responsive when the system is busy.
That includes filesystems processing large amounts of I/O, applications competing for CPU time, servers operating under memory pressure and latency-sensitive workloads waiting for other processor cores.
Each improvement targets a particular bottleneck, so the results will depend heavily on the hardware and workload. Together, they show how Linux is becoming better at handling demanding conditions.
Btrfs receives substantial performance improvements
Btrfs is one of the biggest beneficiaries of Linux 7.3.
One of the most important changes affects Direct I/O. This allows applications to read and write data while bypassing the normal filesystem page cache. Databases and other storage-intensive applications often use it because they already manage their own caching.
Direct I/O has strict alignment requirements. Some Btrfs operations that failed to meet them previously moved to the buffered I/O path, limiting how much of the storage device’s available throughput the workload could use.
Linux 7.3 introduces an IOmap bounce-buffer mechanism that keeps more operations on the Direct I/O path. According to the Btrfs pull request, testing increased the achievable throughput from around half of the theoretical maximum to approximately 95%.
Btrfs also receives improvements to its logging and fsync() paths.
One change removes an unnecessary delay when several tasks attempt to perform logging operations concurrently. Another avoids searching for holes during a full fsync() when the kernel already knows that the file contains many extents and contains no holes.
The affected tests recorded improvements of around three to five times. These gains apply to specific filesystem operations, so the effect will vary between Btrfs workloads.
The default free-space cache is also moving from version 1 to the newer free-space tree. This implementation stores free-space information inside the Btrfs metadata tree and provides better reliability and scalability on large filesystems.
Administrators running Btrfs will receive most of these improvements automatically when Linux 7.3 reaches their distributions.
EXT4 and IOmap get faster on modern NVMe storage
EXT4 also receives several storage improvements.
The filesystem can now allow more parallel Direct I/O writes in situations where those operations were previously serialized. Its multi-block allocator also avoids some unnecessary work when applications use fallocate() to reserve space.
Below the filesystem itself, Linux 7.3 contains a significant reworking of IOmap, the kernel infrastructure used by filesystems to map file operations onto storage.
The new implementation uses a single callback that the compiler can inline, reducing overhead on a particularly busy I/O path.
The difference becomes more visible on very fast storage, where software processing can limit how quickly the operating system feeds requests to the device. In the submitted IOmap testing, EXT4 performance increased from approximately 1.92 million to 2.19 million IOPS on fast NVMe storage.
That represents an improvement of around 14% in the tested workload.
The result shows how refinements inside the kernel can help filesystems take better advantage of increasingly fast storage hardware.
CPU scheduling gets smarter
Linux 7.3 also includes important scheduler work.
Linux distributes runnable tasks across a hierarchy of scheduling groups. This supports features such as control groups, but repeatedly walking that hierarchy can introduce overhead and produce less consistent scheduling decisions.
The new “flatten the pick” work simplifies parts of that process by allowing the scheduler to select tasks from a flatter run queue.
Testing on an older Intel Sandy Bridge system paired with a Radeon RX 580 showed improvements in both frame rates and frame-time consistency while gaming.
Frame-time consistency determines how smoothly individual frames appear. An inconsistent delivery rate can make a game feel choppy even when its average frame rate appears reasonable. Reducing scheduling delays can create a smoother experience, particularly on older and CPU-constrained systems.
Linux 7.3 also improves scheduling on Intel hybrid processors containing both Performance and Efficiency cores.
These processors require the scheduler to decide when a task should run and which kind of core should handle it.
Previous cluster-aware scheduling behaviour did not always represent Intel’s hybrid topology correctly. The new scheduler work improves that handling across processors including Alder Lake, Lunar Lake and Panther Lake.
This should improve task placement when demanding applications and background processes compete for different kinds of CPU cores.
Fewer stalls under memory pressure
Some of the most dramatic Linux 7.3 numbers come from memory-management fixes.
Kernel Samepage Merging, or KSM, allows identical memory pages to be combined. It is particularly useful in virtualization environments where several virtual machines may contain the same operating-system data.
Before merging or modifying these pages, the kernel sometimes needs to determine which virtual memory areas reference them. Under heavy memory pressure, a problem in this reverse-mapping process could hold an internal lock for hundreds of milliseconds.
Anything else waiting for that lock had to stop.
In the affected test, the worst delay reached approximately 700 milliseconds. The Linux 7.3 fix reduced it to below two milliseconds.
For virtualized systems and workloads using KSM under pressure, this could translate into fewer unexplained pauses.
Another improvement reduces locking contention inside zsmalloc, the memory allocator used by zRAM and Zswap to store compressed pages.
When many processes released compressed memory simultaneously, they could contend for the same locks. The new implementation distributes some of that work more effectively.
A Raspberry Pi 4B showed improvements of up to 1.83 times in the submitted test, while a 20-core Intel system reached up to 1.4 times.
The larger improvement on the Raspberry Pi is particularly interesting. Compressed memory is commonly used on devices with limited RAM, which is also where unnecessary allocator overhead becomes especially noticeable.
Executed programs stay in memory longer
Linux 7.3 also changes how Multi-Gen LRU treats executable pages.
Multi-Gen LRU helps the kernel decide which memory pages are actively being used and which can be reclaimed when memory becomes scarce.
Mapped executable pages could previously be reclaimed too aggressively, even after the code had recently been executed. If the application needed that code again, the system had to read it back from storage.
Linux 7.3 promotes these pages after their first use, making frequently executed code less likely to be selected immediately for reclaim.
In testing on a deliberately memory-constrained 32-core Arm build system, system CPU time fell from 9,248 seconds to approximately 7,862 seconds. A similar improvement was observed on x86.
The benefit should be most visible on oversubscribed virtual machines, dense container hosts and build systems where executable code regularly competes with application data for memory.
Lower latency for real-time and networking workloads
Another Linux 7.3 change targets communication between processor cores.
When one CPU asks other CPUs to perform work using an inter-processor interrupt, it may need to wait for those processors to complete the request. The kernel previously kept preemption disabled for the entire operation, including while waiting for remote CPUs to respond.
That could create substantial latency spikes. A high-priority task ready to run on the waiting CPU had to wait until the operation finished.
Linux 7.3 allows preemption to be re-enabled during the waiting period. The CPU can therefore run another eligible task while the request completes.
In testing with the Data Plane Development Kit, or DPDK, P99 latency dropped from approximately 17 milliseconds to 1.5 milliseconds. That represents a reduction of around 90%.
The change is especially relevant to packet processing, telecommunications and real-time workloads where predictable response time is essential.
A server may process a large number of requests per second while a small percentage experience long delays. This improvement helps reduce those latency spikes.
What Linux 7.3 improves
The performance story of Linux 7.3 comes from several targeted changes across the kernel:
Btrfs avoids slow paths during important Direct I/O and
fsync()operations.EXT4 and IOmap reduce overhead on fast storage.
The scheduler makes better decisions on constrained and hybrid CPUs.
Memory-management fixes remove long stalls under pressure.
zRAM and Zswap handle concurrent memory operations more effectively.
SMP changes reduce latency for high-priority workloads.
These improvements will appear in different places and under different conditions. A desktop user may notice smoother frame delivery. A database server may benefit from faster filesystem operations. A container host may experience fewer memory-related stalls. A packet-processing system may see much lower tail latency.
Linux 7.3-rc1 is currently in the testing stage. Features can still be adjusted, and regressions may be discovered before the stable release arrives.
Once Linux 7.3 is stable, most users will receive it through their distributions. Administrators can then test it against their own hardware and workloads to determine which improvements apply to their environments.
Linux 7.3 focuses on the bottlenecks that appear when systems are busy: storage contention, memory pressure, CPU scheduling and latency. These improvements target the conditions where performance matters most.
If you found this useful, please leave a like, subscribe if you haven’t already, and share it with someone who might enjoy it too.
Until next time, keep exploring.