Скачать или смотреть Understanding Why Pthreads Can Be Slower Than Serial Calculations on Linux

Discover why your Pthreads program runs slower than a serial implementation and how to optimize multithreading performance on Linux systems.
---
This video is based on the question https://stackoverflow.com/q/64992925/ asked by the user 'Hamza' ( https://stackoverflow.com/u/14701397/ ) and on the answer https://stackoverflow.com/a/64993427/ provided by the user 'David Schwartz' ( https://stackoverflow.com/u/721269/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Pthreads program is slower than the serial program - Linux

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Why Is Your Pthreads Program Slower Than the Serial Implementation?

If you’ve been diving into the world of multithreading with Pthreads on Linux, you might have run into a perplexing issue: your Pthreads version of a program is running slower than its serial counterpart. In this guide, we'll explore the intricacies of this problem and guide you on how to achieve optimal performance when using multithreading.

The Problem Explained

Let's get to the heart of the matter. You’ve created a simple program to calculate the sum of squared numbers using two different approaches: a serial approach and a Pthreads-based multithreaded approach. To your surprise, the Pthreads version not only runs slower but also becomes increasingly inefficient as you add more threads.

Example Programs

Here’s a brief overview of how both implementations are structured:

Serial Program

The serial version of your program operates by iterating through a specified range, calculating the sum of squares in a simple loop:

[[See Video to Reveal this Text or Code Snippet]]

Pthreads Program

In contrast, the Pthreads version divides the work among multiple threads, each tasked with calculating a portion of the sum:

[[See Video to Reveal this Text or Code Snippet]]

Results Comparison

The execution of both programs yields very different results in terms of time taken:

Serial Execution: Approximately 7 microseconds for n=10

Pthreads Execution: Ranges from 670 to 775 microseconds for the same input

This inconsistency raises the question: why is the Pthreads program slower?

Understanding the Performance Overhead

The core reason for the slower performance in your Pthreads program lies in overhead associated with multithreading:

Thread Creation and Management: Each thread you create consumes system resources. Beyond that, managing multiple threads requires additional synchronization, leading to further delays.

Output Generation: The Pthreads program generates significantly more output than the serial program, which adds to the time consumed.

Short Execution Time: The tests are performed on a very short time scale (in microseconds), meaning that the overhead becomes a substantial part of the total execution time. This can be likened to having a few people perform a task that a single person could do faster because the time taken to gather everyone adds unnecessary delay.

The Analogy: Tightening Screws

To visualize this, consider the analogy of tightening screws. A single person can tighten three screws more quickly than three people can, simply because of the overhead involved in ensuring that everyone has what they need and is coordinated. However, if there is a larger batch of screws, multiple people will finish the task quicker than one.

Recommendations for Improvement

If you’re looking to optimize your Pthreads implementation, here are some tips to help improve performance:

Longer Run Tests: Perform tests with larger datasets so that the time spent on thread management becomes less significant in comparison to the actual computation.

Reduce Output: Minimize or eliminate console output during operations to decrease time spent on I/O processes.

Benchmarking Tools: Utilize more advanced benchmarking tools and techniques to evaluate performance accurately and avoid erroneous conclusions.

Load Balancing: Ensure work is evenly distributed across threads to prevent some threads finishing significantly earlier than others, causing them to sit idle.

Conclusion

Understanding why your Pthreads program is slower than the serial implementation is key to leveraging the advantages of multithreading. By recognizing the overhead factors and optimizing your code accordingly, you can greatly improve execution t