Pthreads矩阵-向量程序

以下是一个使用Pthreads库编写的矩阵-向量乘法程序，该程序将矩阵和向量作为输入，并使用多个线程对它们进行计算。

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

#define MAX_THREADS 100

// 线程计算的任务结构体
typedef struct {
    int thread_id;
    int thread_count;
    int rows_per_thread;
    int matrix_size;
    int *matrix;
    int *vector;
    int *result;
} Task;

// 矩阵乘法的线程函数
void *matrix_mult(void *arg) {
    Task *task = (Task *) arg;
    int start_row = task->thread_id * task->rows_per_thread;
    int end_row = (task->thread_id + 1) * task->rows_per_thread;

    // 计算每行的乘积
    for (int i = start_row; i < end_row; i++) {
        int row_sum = 0;
        for (int j = 0; j < task->matrix_size; j++) {
            row_sum += task->matrix[i * task->matrix_size + j] * task->vector[j];
        }
        task->result[i] = row_sum;
    }
    return NULL;
}

int main(int argc, char *argv[]) {
    int thread_count = atoi(argv[1]);
    int matrix_size = atoi(argv[2]);

    // 随机生成矩阵和向量
    int *matrix = malloc(matrix_size * matrix_size * sizeof(int));
    int *vector = malloc(matrix_size * sizeof(int));
    int *result = malloc(matrix_size * sizeof(int));
    for (int i = 0; i < matrix_size * matrix_size; i++) {
        matrix[i] = rand() % 10;
    }
    for (int i = 0; i < matrix_size; i++) {
        vector[i] = rand() % 10;
    }

    // 计算每个线程需要处理的行数
    int rows_per_thread = matrix_size / thread_count;

    // 创建线程任务
    Task tasks[MAX_THREADS];
    pthread_t threads[MAX_THREADS];
    for (int i = 0; i < thread_count; i++) {
        tasks[i].thread_id = i;
        tasks[i].thread_count = thread_count;
        tasks[i].rows_per_thread = rows_per_thread;
        tasks[i].matrix_size = matrix_size;
        tasks[i].matrix = matrix;
        tasks[i].vector = vector;
        tasks[i].result = result;
        pthread_create(&threads[i], NULL, matrix_mult, (void *) &tasks[i]);
    }

    // 等待所有线程完成
    for (int i = 0; i < thread_count; i++) {
        pthread_join(threads[i], NULL);
    }

    // 输出结果
    printf("Matrix:\n");
    for (int i = 0; i < matrix_size * matrix_size; i++) {
        printf("%d ", matrix[i]);
        if ((i + 1) % matrix_size == 0) {
            printf("\n");
        }
    }
    printf("Vector:\n");
    for (int i = 0; i < matrix_size; i++) {
        printf("%d\n", vector[i]);
    }
    printf("Result:\n");
    for (int i = 0; i < matrix_size; i++) {
        printf("%d\n", result[i]);
    }

    free(matrix);
    free(vector);
    free(result);
    return 0;
}

在这个程序中，我们首先读取线程数和矩阵大小两个输入参数，并使用`malloc()`函数动态分配矩阵、向量和结果数组的内存空间。然后我们按照线程数计算每个线程需要处理的行数，并为每个线程创建一个`Task`结构体来存储其计算任务的相关信息。

接着，我们使用`pthread_create()`函数创建每个线程，并将其对应的任务结构体作为参数传递给它们。在线程函数`matrix_mult()`中，我们根据每个线程的编号计算它需要处理的行范围，并使用两个嵌套循环来计算矩阵和向量的乘积。最后，我们将每行的结果存储在结果数组中。

在主线程中，我们使用`pthread_join()`函数等待所有线程完成，并输出矩阵、向量和结果数组的内容。最后，我们释放分配的内存空间并返回0表示程序正常结束。