如何实现线程的负载均衡？

Question

我对如何在线程之间进行负载平衡有疑问。 每个线程都应该处理 N*N 矩阵中的特定行，例如，如果 N = 4 和 Num_Threads = 2。请注意，这种情况仅适用于 (N%Num_Threads) == 0。

for (int i = 0 ; i < num_threads; i++){
    if ( i == 0) { RANGE -> R1 = 0; RANGE -> R2 = n/num_threads; }
    else {
        RANGE -> R1 = RANGE -> R2  ; // I have defined a struct previously contains R1,R2 which means Row1,Row2
        RANGE -> R2 = RANGE -> R1 + n/num_threads ; }
        cout << "ThreadID= " << i << ", startRow= " << RANGE -> R1 << ", endRow= " << RANGE -> R2 << endl ;   
        pthread_create(&threads[i],NULL,Median,RANGE);
    }
}

输出：

ThreadID= 0 start_row = 0  , end_row = 
ThreadID= 1 ..... = 2 , .....=4

**但是，如果 (N%Num_Threads).= 0 & Num_Threads < N，我该如何进行负载平衡。例如，如果 N = 5 且 Num_Threads = 3。**

我试图给每个线程 (N/Num_threads) 行，但我应该如何将剩余的 (N%Numthreads) 行划分为线程？

例如，如果 N = 5 和 Num_threads = 3 那么将剩下 2 行，我如何将它们分配到 3 个线程？ 如果它是像 N = 101 和 Num_Threads=7 这样的大数字，那将更难做到我不知道如何实现这一点。

注意：并非所有线程都应采用相同的行数，但代码应尝试在线程之间实现尽可能多的负载平衡。

Answer 1

您已经拥有并且正在使用一个对象来向每个线程传达它要操作的行的范围，所以我认为您所要求的只是如何计算这些范围，以使它们的大小彼此相差不超过一项。

假设您有N个项目要分布在T个线程中。 所有线程将至少获得N / T个项目， N % T个线程将各自再获得一个。 有很多方法可以为此编写代码，但这个非常简单明了：

size_t next_range_start = 0;

for (int i = 0 ; i < num_threads; i++) {
    size_t next_range_end_exclusive = next_range_start + n / num_threads;

    if (i < (n % num_threads)) {
        next_range_end_exclusive++;
    }

    cout << "ThreadID = " << i
         << ", startRow = " << next_range_start
         << ", endRow (exclusive) = " << next_range_end_exclusive
         << endl ;
    pthread_create(&threads[i], NULL, Median,
            new range_type(next_range_start, next_range_end_exclusive));
    next_range_start = next_range_end_exclusive;
}

请注意，要为不同的线程使用相同的范围对象，您需要足够的同步和信号以确保每个工作线程在主线程使用下一个工作线程的值更新对象之前读取它需要的数据。 如图所示，为每个线程使用单独的范围对象要容易得多。 然而，如前所述，它确实让每个工作线程负责释放它接收到的范围对象。

另请注意，上面假设范围对象的结束索引是独占的，而不是包含在内的。 您的原始代码暗示了这一点，但有点模棱两可。 也可以使用包容性最终指数，并进行一些调整。