Pthreads矩阵乘法实现

这两天接触了Markdown文档编辑器之后,我便对这种编辑方式欲罢不能了,下面继续推出pthreads矩阵乘法的使用方法。其实与MPI矩阵乘法的实现比起来,Pthreads要简单很多,主要是由于MPI是基于进程的通信,而Pthreads和之后要提到的OpenMP则是基于线程的通信,从代码量和实现方式相比较来看,线程的通信似乎是要更简单一些,将矩阵划分成块之后直接分配给对应线程即可。

并行化思路

假设矩阵乘法为A * B = C。让每个线程计算乘积向量 x 的不同部分,特别地,p 个线程中的每一个线程计算x中的 1000/P 个连续的元素。这个算法首先通过pthread_create函数生成thread_count个进程,再将矩阵 A 按行分配给每个线程,并将矩阵B定义为全局变量,使每个线程能计算相应部分的矩阵相乘结果,然后再将子线程的计算结果返回给主线程,通过pthread_join函数使主线程等待所有线程结束,最后在主线程里将矩阵返回结果存储到文件中。
好了,废话不多说,直接上代码!

Pthreads矩阵乘法实现


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

int thread_count;
int size, local_size;
int *a, *b, *c;
FILE *fp;

int* transpose_matrix(int *m, int size);

void* Init();

void* pthread_mult(void* rank);

int main(int argc, char* argv[]){
    int i, j;
    long thread;

    float time_use = 0;
    struct timeval start;
    struct timeval end;

    size = 1000;

    gettimeofday(&start, NULL);

    pthread_t* thread_handles;

    thread_count = strtol(argv[1], NULL, 10);

    local_size = size/thread_count;

    thread_handles = malloc(thread_count * sizeof(pthread_t));

    Init();

    for(thread = 0; thread<thread_count; thread++)
        pthread_create(&thread_handles[thread], NULL, pthread_mult, (void*) thread);

    for (thread=0; thread<thread_count; thread++)
        pthread_join(thread_handles[thread], NULL);

    fp=fopen("c.txt","w");//打开文件
    for(i=0;i<1000;i++) {//写数据
        for(j=0;j<1000;j++)
            fprintf(fp,"%d ",c[i*size+j]); 
        fputc('\n',fp); 
    }
    fclose(fp);//关闭文件

    gettimeofday(&end, NULL);
    time_use = (end.tv_sec-start.tv_sec)*1000000+(end.tv_usec-start.tv_usec);

    printf("time_use is %f\n", time_use/1000000);

    free(thread_handles);
    free(a);
    free(b);
    free(c);
    return 0;
}

int* transpose_matrix(int *m, int size){
    int i, j;
    for(i=0; i<size; i++){
        for(j=i+1; j<size; j++){
            int temp = m[i*size+j];
            m[i*size+j] = m[j*size+i];
            m[j*size+i] = temp;
        }
    }
    return m;
}

void* Init(){

    int i, j;

    a = (int*)malloc(sizeof(int)*size*size);
    b = (int*)malloc(sizeof(int)*size*size);
    c = (int*)malloc(sizeof(int)*size*size);

    //从文件中读入矩阵
    fp=fopen("a.txt","r");//打开文件
    for(i=0;i<1000;i++) //读数据
        for(j=0;j<1000;j++)
            fscanf(fp,"%d",&a[i*size+j]);
    fclose(fp);//关闭文件

    fp=fopen("b.txt","r");

    for(i=0;i<1000;i++)
        for(j=0;j<1000;j++)
            fscanf(fp,"%d",&b[i*size+j]);
    fclose(fp);

    b = transpose_matrix(b, size);
}

void* pthread_mult(void* rank){
    long my_rank = (long) rank;
    int i, j, k, temp;
    int my_first_row = my_rank*local_size;
    int my_last_row = (my_rank+1)*local_size - 1;

    for(i = my_first_row; i <= my_last_row; i++){
        for(j = 0; j<size; j++){
            temp = 0;
            for(k = 0; k<size; k++)
                temp += a[i*size+k] * b[j*size+k];
            c[i*size+j] = temp;
        }

    }
}

结果加速比展示

串行矩阵乘法运行时间:3.490950秒

① 不同进程执行时间及其加速比展示:

进程数目 运行时间(秒) 加速比
1 3.500414 1.00271101
2 2.116865 1.649113193
4 2.079719 1.678568114
8 2.088567 1.671457033
20 2.036915 1.713841766
25 2.047089 1.705323999

② 不同进程执行效率展示:

进程数目 效率
1 1.00271101
2 0.8245565965
4 0.4196420285
8 0.208932129125
20 0.0856920883
25 0.06821295996

结果分析

① 执行时间分析:
开始时由1个线程增长为2个线程的过程中,执行时间接近于减半,较符合并行计算的情况,但之后随着线程数目的增多,并行计算的时间再也没有减半,基本稳定在2秒左右。
在1个线程增加到2个线程的过程中,加速比几乎增加了两倍,符合并行计算的情况,但之后随着线程数的增加,加速比基本稳定在1.6~1.7左右,再也没有加倍的情况出现。
③ 效率分析:
程序执行效率随线程数增加在不断下降,只是下降的趋势在不断减小。
④ 原因分析:
Pthreads并行程序的测试平台为Intel Core i5 CPU,为双核CPU,即在一个处理器上集成两个运算核心支持两个线程并行执行。一个线程与串行乘法的执行时间相比要差不多,两线程时时间大致减半,但两线程以上则并行时间不会再有明显变化。因此会出现上述结果。

  • 3
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
好的,下面给您介绍一下使用Pthreads实现矩阵向量乘法的方法: 首先,我们需要定义一个结构体,用于传递参数: ``` typedef struct { double *matrix; // 矩阵 double *vector; // 向量 double *result; // 结果 int rows; // 矩阵的行数 int cols; // 矩阵的列数 int start; // 起始行 int end; // 结束行 } thread_param_t; ``` 然后,我们需要编写一个线程函数,用于计算矩阵向量乘法: ``` void *multiply(void *arg) { thread_param_t *param = (thread_param_t *)arg; for (int i = param->start; i < param->end; i++) { double sum = 0.0; for (int j = 0; j < param->cols; j++) { sum += param->matrix[i * param->cols + j] * param->vector[j]; } param->result[i] = sum; } pthread_exit(NULL); } ``` 接下来,我们需要创建线程,并将参数传递给它们: ``` void multiply_matrix_vector(double *matrix, double *vector, double *result, int rows, int cols, int num_threads) { pthread_t threads[num_threads]; thread_param_t params[num_threads]; int rows_per_thread = rows / num_threads; for (int i = 0; i < num_threads; i++) { params[i].matrix = matrix; params[i].vector = vector; params[i].result = result; params[i].rows = rows; params[i].cols = cols; params[i].start = i * rows_per_thread; params[i].end = (i == num_threads - 1) ? rows : (i + 1) * rows_per_thread; pthread_create(&threads[i], NULL, multiply, (void *)&params[i]); } for (int i = 0; i < num_threads; i++) { pthread_join(threads[i], NULL); } } ``` 最后,我们可以调用 multiply_matrix_vector() 函数来进行矩阵向量乘法计算: ``` int main() { double matrix[4][3] = {{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0}, {10.0, 11.0, 12.0}}; double vector[3] = {1.0, 2.0, 3.0}; double result[4] = {0.0}; multiply_matrix_vector((double *)matrix, vector, result, 4, 3, 2); for (int i = 0; i < 4; i++) { printf("%lf ", result[i]); } printf("\n"); return 0; } ``` 以上就是使用 Pthreads 实现矩阵向量乘法的方法,希望对您有所帮助!
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值