Question

我可以在必要时发布我的代码，但我的问题主要是概念性的。我正在使用线程实现高斯消除。我有p pthreads以列主要顺序在nxn矩阵上运行。在任何p线程开始对列进行操作之前，必须进行行操作以将该列中具有最大值的行移动到对角线。所以我需要每个线程等待然后齐声运行。目前，在每个列中，每个线程检查其id，id = 0的那个将执行行操作。我的问题是如何获取所有线程但id = 0等待然后在Unison中运行。

我尝试过使用互斥锁和条件。这些似乎不起作用，因为它们为单个线程提供所有访问权限。根据我的理解，人们只能通过让一个已经存在的请求锁来以这种方式阻塞一个线程，所以它必须等待。这在我的情况下会出现问题，因为我不希望任何非0线程都有锁定，一旦它们被解锁，我希望它们能够自由运行，直到它们完成对列的工作。

我试图通过简单地将全局“colReady”变量设置为0来避免Mutex锁定。非零线程while循环直到colReady = True。从逻辑上讲，这是完全合理的，但它没有以编程方式工作。

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <pthread.h>

#define n 20
#define numThr 3

double **matrix;
int pivotReady[n] = { 0 };

pthread_cond_t cond_pivot_ready;
pthread_mutex_t cond_mutex;

int swapRows (int row1, int row2)
{
    double *tempRow = matrix[row1];
    matrix[row1] = matrix[row2];
    matrix[row2] = tempRow;
    return 0;
}

void randinit ()
{
    int i, j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n + 1; j++) {
            matrix[i][j] = drand48 ();
        }
    }
}

void rowReduce (void *arg);

void printMatrix ()
{
    int i, j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n + 1; j++) {
            printf (" %4.2f ", matrix[i][j]);
        }
        printf ("\n");
    }
}

int main ()
{
    pthread_cond_init (&cond_pivot_ready, NULL);
    pthread_mutex_init (&cond_mutex, NULL);

    int i, j;
    double temp;
    pthread_t p_threads[numThr];
    pthread_attr_t attr;
    pthread_attr_init (&attr);

    //create matrix
    matrix = malloc (sizeof (double *) * n);
    for (i = 0; i < n; i++) {
        *(matrix + i) = malloc (sizeof (double) * (n + 1));
    }

    randinit ();

    for (i = 0; i < numThr; i++) {
        pthread_create (&p_threads[i], &attr, rowReduce, (void *) ((long) i));
    }

    for (i = 0; i < numThr; i++) {
        pthread_join (p_threads[i], NULL);
    }
    printf ("Final Matrix:\n");
    printMatrix ();

    return 0;
}

void rowReduce (void *arg)
{
    int id = (int) arg;
    int i, pivot, row;
    double ratio, temp, max;
    int maxRow;

    for (pivot = 0; pivot < n - 1; pivot++) {

        //PIVOT THREAD
        if (id == 0) {
            pthread_mutex_lock (&cond_mutex);
            max = matrix[pivot][pivot]
                maxRow = pivot;
            for (i = pivot + 1; i < n; i++) {
                temp = matrix[i][pivot];
                if (temp > max) {
                    max = temp;
                    maxRow = i;
                }
            }
            swapRows (pivot, maxRow);

            pivotReady[pivot] = 1;
            pthread_cond_signal (&cond_pivot_ready);

            for (row = pivot + 1 + id; row < n; row += numThr) {

                ratio = matrix[row][pivot] / matrix[pivot][pivot];
                printf ("t1: row = %d, piv = %d, ratio = %f\n", row, pivot,
                        ratio);
                for (int i = pivot; i < n + 1; i++) {
                    matrix[row][i] -= ratio * matrix[pivot][i];
                }
            }
            pthread_mutex_unlock (&cond_mutex);
        }
        //NON-PIVOT THREAD
        else {
            pthread_mutex_lock (&cond_mutex);
            while (!(pivotReady[pivot])) {
                pthread_cond_wait (&cond_pivot_ready, &cond_mutex);
            }

            for (row = pivot + 1 + id; row < n; row += numThr) {
                ratio = matrix[row][pivot] / matrix[pivot][pivot];
                for (int i = pivot; i < n + 1; i++) {
                    matrix[row][i] -= ratio * matrix[pivot][i];
                }
            }
            pthread_mutex_unlock (&cond_mutex);

        }

    }

    //printf("rowReduce called with id = %d\n", id);
    pthread_exit (0);
}

这个程序应该打印一个以三角形形式放置的随机矩阵。

Answer 1

您只需在访问cond_mutex时按住pivotReady[pivot]，因为这是它保护的唯一共享状态。

您还需要使用pthread_cond_broadcast()而不是pthread_cond_signal()，因为一旦数据透视准备就绪，您需要所有等待线程继续。

经过轻微的重构，以便不重复行处理代码，它看起来像：

for (pivot = 0; pivot < n - 1; pivot++) {

    //PIVOT THREAD
    if (id == 0) {
        max = matrix[pivot][pivot];
        maxRow = pivot;
        for (i = pivot + 1; i < n; i++) {
            temp = matrix[i][pivot];
            if (temp > max) {
                max = temp;
                maxRow = i;
            }
        }
        swapRows (pivot, maxRow);

        pthread_mutex_lock (&cond_mutex);
        pivotReady[pivot] = 1;
        pthread_cond_broadcast (&cond_pivot_ready);
        pthread_mutex_unlock (&cond_mutex);
    }
    //NON-PIVOT THREAD
    else {
        pthread_mutex_lock (&cond_mutex);
        while (!(pivotReady[pivot])) {
            pthread_cond_wait (&cond_pivot_ready, &cond_mutex);
        }
        pthread_mutex_unlock (&cond_mutex);
    }

    for (row = pivot + 1 + id; row < n; row += numThr) {
        ratio = matrix[row][pivot] / matrix[pivot][pivot];
        for (int i = pivot; i < n + 1; i++) {
            matrix[row][i] -= ratio * matrix[pivot][i];
        }
    }
}

Pthread条件

1 个答案: