Boosting Linux Performance: Comparing Kernel Versions on Alder Lake

Table of Contents

1. Introduction
2. Comparison of Kernel Versions
   1. Rendering the PovRay Benchmark
   2. Running the Blender Benchmark
   3. Running Other Benchmarks
3. Analyzing the Results
   1. Benchmark Results on Different Kernel Versions
   2. Impact of Number of Threads on Performance
   3. Effects of Efficiency Cores on Render Time
4. Understanding the Kernel Changes
   1. The Role of Cluster Configurations
   2. Disabling Cluster Configuration for Improved Performance
   3. Future Potential Improvements
5. Conclusion
6. Frequently Asked Questions (FAQ)

Comparing the Performance of Linux Kernel Versions

In this video, we will be exploring the performance differences between different versions of the Linux kernel, specifically on the older lake architecture. We will conduct a comparison by rendering the PovRay benchmark scene using two or three different kernel versions. Additionally, we will run a more involved Blender benchmark to assess the overall improvements that have been made. Although we have conducted other benchmarks in our own time, we will focus on these particular tests in this video. However, we will make sure to share the comprehensive results of all the benchmarks in a future video.

Comparison of Kernel Versions

Rendering the PovRay Benchmark

To begin our analysis, we will boot the original kernel that was built specifically for this machine. We will run the PovRay benchmark, but this time we will only specify that the scene be rendered on 16 cores instead of 24. By doing so, we aim to evaluate the performance cores' ability to handle rendering tasks efficiently. If the kernel can identify the best core to utilize for rendering, it should predominantly select the performance cores. Consequently, any discrepancies in the benchmark's runtime will indicate whether the kernel is effectively directing the threads to the optimal cores.

Running the Blender Benchmark

In addition to the PovRay benchmark, we will also run a benchmark within Blender. It is important to note that since Blender does not have a graphical interface, we initially set it up for the built-in Intel graphics. However, we have now added a basic Nvidia card to the system, which prevents us from booting into the X Windows interface using this kernel. To address this, we will reboot and switch to another kernel that supports the Nvidia card. This will allow us to run the Blender benchmark effectively and observe it in action.

Running Other Benchmarks

While we have conducted various benchmarks in our testing, we will not be covering them in this video due to their time-consuming nature. However, we have been diligently collecting the results and will Present them in a spreadsheet format in a future video. This will provide a comprehensive overview of the system's performance across different kernel versions and benchmarks.

Analyzing the Results

Benchmark Results on Different Kernel Versions

By comparing the runtime of the PovRay benchmark on different kernel versions, we can determine the improvements made in each iteration. To establish a baseline, we initially achieved a benchmark runtime of 17.x seconds with 24 threads. Now, with only 16 threads targeting the performance cores, we expect to observe a slightly longer runtime. By running the benchmark multiple times, we can account for any variations in the results and ensure accurate comparisons.

Impact of Number of Threads on Performance

During the benchmark runs, we noticed that reducing the number of threads from 24 to 16 resulted in a longer runtime. This is primarily due to the efficiency cores and their impact on rendering, as they tend to take slightly longer to complete the workload. However, the difference in runtime was not significant, emphasizing the dominance of the performance cores in this particular task.

Effects of Efficiency Cores on Render Time

Despite the minor slowdown caused by the efficiency cores, the PovRay benchmark demonstrated that their presence still accounts for a noteworthy portion of the render time. We estimate that the efficiency cores contribute to approximately a 15-20% increase in the total runtime compared to using solely performance cores.

Understanding the Kernel Changes

The Role of Cluster Configurations

Under the processor types and features section in the 5.16 kernel, we made a crucial change by disabling the cluster configuration option. By default, this option assumes all cores on the chip are part of the same cluster, allocating work to each core without considering any variations in speed. However, this prevents the kernel from effectively identifying and using the fastest cores available.

Disabling Cluster Configuration for Improved Performance

Disabling the cluster configuration option allows the kernel to recognize individual cores' maximum speed and allocate work accordingly. Although it is not a perfect solution, it has demonstrated improvements in performance, as evidenced by the shorter runtimes observed during the benchmarks. It is worth mentioning that the 5.17 kernel may contain additional patches from Intel to grant the kernel access to the thread director on the chip, enhancing performance further. These changes are expected to be available in the upcoming spring update.

Future Potential Improvements

As we move forward, it is essential to note that the kernel changes discussed in this video may not be present in the 5.17 kernel. However, the potential for further performance improvements remains high since Intel plans to release patches enabling the kernel to utilize the thread director effectively. Therefore, future updates are expected to deliver significant enhancements in terms of core utilization and overall system performance.

Conclusion

In conclusion, our analysis of different kernel versions and their impact on performance has shown promising results. By disabling the cluster configuration and allowing the kernel to identify and utilize the best cores for rendering tasks, we observed notable improvements in runtime. The presence of efficiency cores does contribute to slightly longer render times, but the overall performance gains outweigh this drawback. As we continue to explore kernel updates, we anticipate even more significant improvements in system performance.

Frequently Asked Questions (FAQ)

1. Is it necessary to run the benchmarks multiple times to validate the results? Running the benchmarks multiple times helps ensure accurate and consistent results by accounting for any variations. This approach provides a more reliable assessment of the performance improvements achieved in different kernel versions.

2. How can I download the Blender benchmark? The Blender benchmark can be found online by searching for "Blender benchmark" or a similar query. It is a cross-platform benchmark, and the file to load is typically called "benchmark.blend." However, depending on your distribution, the file name may vary, so it is advisable to search for the specific benchmark file for your system.

3. Will the improvements discussed in this video be available in all Linux distributions? The improvements made by disabling the cluster configuration and the potential future patches from Intel are likely to benefit most Linux distributions. However, availability may vary depending on the specific kernel versions included in each distribution. It is recommended to stay informed about the kernel updates for your particular distribution to take advantage of these improvements.

4. How can I build my own kernel if my distribution does not provide the desired version? If your distribution does not offer the kernel version you require, it is possible to download the desired version from the kernel archive website. You can then follow the instructions provided on the website to build and install the kernel on your system.

5. When can we expect the thread director patches from Intel to be available? Intel is expected to release the thread director patches for the kernel in their 5.18 update, which is scheduled to be released in the spring. It is important to keep an eye on the kernel updates for your distribution to benefit from these performance-enhancing patches.

Resources:

• PovRay
• Blender