并行程序设计——OMP编程

最新推荐文章于 2024-06-11 21:57:22 发布
最新推荐文章于 2024-06-11 21:57:22 发布
阅读量2.1k 收藏 16
点赞数
分类专栏： 大作业 算法 文章标签： c语言 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/troublenbfriend/article/details/121500335
版权

并行程序设计——OMP编程

实验一

实验内容

分别实现课件中的梯形积分法的Pthread、OpenMP版本，熟悉并掌握OpenMP编程方法，探讨两种编程方式的异同。

实验代码

OpenMP编程
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>

void Trap(double a, double b, int n, double *global_result_p);

double f(double x) {
    return x * x;
}

int main(int argc, char *argv[]) {
    double global_result = 0.0;
    double a, b;
    int n;
    int thread_count;
    thread_count = 5;
    printf("Enter a, b, and n\n");
    scanf("%lf %lf %d", &a, &b, &n);
# pragma omp parallel num_threads(thread_count)
    Trap(a, b, n, &global_result);
    printf("With n = %d trapezoids, our estimate\n", n);
    printf("of the integral from %f to %f = %.14e\n", a, b, global_result);
    return 0;
} /* main*/

void Trap(double a, double b, int n, double *global_result_p) {
    double h, x, my_result;
    double local_a, local_b;
    int i, local_n;
    int my_rank = omp_get_thread_num();
    int thread_count = omp_get_num_threads();
    h = (b - a) / n;
    local_n = n / thread_count;
    local_a = a + my_rank * local_n * h;
    local_b = local_a + local_n * h;
    my_result = (f(local_a) + f(local_b)) / 2.0;
    for (i = 1; i <= local_n; i++) {
        x = local_a + i * h;
        my_result += f(x);
    }
    my_result = my_result * h;
# pragma omp critical
    *global_result_p += my_result;
} /* Trap*/
实验效果

请添加图片描述

pthread编程
#include <pthread.h>
#include <algorithm>
#include <stdio.h>
# include <stdlib.h>


double f(double x) {
    return x * x;
}

typedef struct {
    int threadId;
} threadParm_t;
const int THREAD_NUM = 5; //表示线程的个数
int next_task = 1;//从1开始
int seg = 50;//每次分50份
double totalSize = 0.000; //表示总面积
double h = 0.00;//表示间距
double a = 1.000, b = 8.000;
int n = 1000;
pthread_mutex_t barrier_mutex = PTHREAD_MUTEX_INITIALIZER;


void cal(int i) {
    //计算第i分
    double x = a + i * h;
    double myResult = f(x) * h;
    pthread_mutex_lock(&barrier_mutex);
    totalSize += myResult;
    pthread_mutex_unlock(&barrier_mutex);
}

void *SSE_pthread(void *parm) {
    int task = 0;
    while (true) {
        pthread_mutex_lock(&barrier_mutex);
        next_task += seg;
        task = next_task;
        pthread_mutex_unlock(&barrier_mutex);
        if (task - seg >= n) break;
        for (int i = task - seg; i < std::min(task, n); i++) {
            cal(i);
        }
    }
    pthread_exit(nullptr);
}

int main(int arg, char *argv[]) {
    pthread_t thread[THREAD_NUM];
    threadParm_t threadParm[THREAD_NUM];
    for (int i = 0; i < THREAD_NUM; i++) {
        threadParm[i].threadId = i;
    }
    printf("Enter a, b, and n\n");
    scanf("%lf %lf %d", &a, &b, &n);
    //先计算两边的面积之和
    h = (b - a) / n;
    totalSize = h * (f(a) + f(b)) / 2;
    for (int i = 0; i < THREAD_NUM; i++) {
        pthread_create(&thread[i], nullptr, SSE_pthread, (void *) &threadParm[i]);
    }
    for (int k = 0; k < THREAD_NUM; k++) {
        pthread_join(thread[k], nullptr);
    }
    pthread_mutex_destroy(&barrier_mutex);
    printf("With n = %d trapezoids, our estimate\n", n);
    printf("of the integral from %f to %f = %.14e\n", a, b, totalSize);
    return 0;
}
实验结果

请添加图片描述
注：由于我的pthread求梯形的基准和OpenMP的基准不同，所以求的实验结果略有差异

两种编程方式的异同

OpenMP是根植于编译器的，更偏向于将原来串行化的程序，通过加入一些适当的编译器指令（compiler directive）变成并行执行，从而提高代码运行的速率。这样做是在没有OpenMP支持编译时，代码仍然可以编译。 创建线程等后续工作需要编译器来完成。

而Pthread是一个库，所有的并行线程创建都需要我们自己完成。Pthread仅在有多个处理器可用时才对并行化有效，并且仅在代码针对可用处理器数进行了优化时才有效。 因此，OpenMP的代码更易于扩展。

实验二

实验描述

对于课件中“多个数组排序”的任务不均衡案例进行OpenMP编程实现（规模可自己调整），并探索不同循环调度方案的优劣。提示：可从任务分块的大小、线程数的多少、静态动态多线程结合等方面进行尝试，探索规律。

实验代码

#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <ctime>
#include <sys/time.h>
#include <algorithm>


const int ARR_NUM = 1000; //固定数组大小
const int ARR_LEN = 4000; //固定数组长度
int THREAD_NUM = 4; //固定线程个数，改变粗颗粒分配大小
int seg = 10; //改变粗颗粒的分配大小
struct timeval startTime, stopTime;// timers
int arr[ARR_NUM][ARR_LEN];
int tempArr[ARR_NUM][ARR_LEN]; //用于暂时存储数组，控制变量唯一
int next_arr = 0;

void OMP_sort();

void init(int num) {
    srand(unsigned(time(nullptr)));
    for (int i = 0; i < num; i++) {
        for (int j = 0; j < ARR_LEN; j++)
            arr[i][j] = rand();
    }
}

//使用冒泡排序，使变量唯一
void sort(int *a) {
    for (int i = 0; i < ARR_LEN - 1; ++i) {
        for (int j = i + 1; j < ARR_LEN; ++j) {
            if (a[j] < a[i]) {
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
    }
}

void store(int a[][ARR_LEN], int b[][ARR_LEN], int num) {
    for (int i = 0; i < num; i++) {
        for (int j = 0; j < ARR_LEN; j++)
            b[i][j] = a[i][j];
    }
}


int main(int argc, char *argv[]) {
    init(ARR_NUM);
    store(arr, tempArr, ARR_NUM);
    for (; seg <= 100; seg += 10) {
        printf("seg: %d\n",seg);
        store(tempArr, arr, ARR_NUM);
        next_arr = 0;
        gettimeofday(&startTime, NULL);
# pragma omp parallel num_threads(THREAD_NUM)
        OMP_sort();
        gettimeofday(&stopTime, NULL);
        double trans_mul_time =
                (stopTime.tv_sec - startTime.tv_sec) * 1000 + (stopTime.tv_usec - startTime.tv_usec) * 0.001;
        printf("time :%lf ms\n", trans_mul_time);

    }
    return 0;
} /* main*/

void OMP_sort() {
    int task = 0;
    while (true) {
#pragma omp critical //每次只能一个线程执行
        task = next_arr += seg;//每次动态分配seg个
        if (task - seg >= ARR_NUM) break;
        int min = task < ARR_NUM ? task : ARR_NUM;
        for (int i = task - seg; i < min; ++i) {
            sort(arr[i]);
        }
    }
} /* Trap*/

实验运行结果

请添加图片描述
如此进行多次重复实验，将得到的数据绘成echarts图表

实验图表和结论

请添加图片描述

实验结论

  1. 由以上图表可知，根据动态粗颗粒的分配的大小可知，各个分配结果的运行效率基本相似。
  2. 由上图可知，当每次分配数目为30的时候，运行时间最短，运行效率最快。但是当每次分配个数超过80时，运行效率也不低。由于此次实验总的数组的行数比较少，所以运行效率并不会相差很大，如若需要更加准确的数值的话，则需要加大数组的行数。

实验三（附加题）

实验内容

实现高斯消去法解线性方程组的OpenMP编程，与SSE/AVX编程结合，并探索优化任务分配方法。

实验代码

#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <ctime>
#include <sys/time.h>
#include <algorithm>
#include <pmmintrin.h>


const int n = 2048;//固定矩阵规模，控制变量
const int maxN = n + 1; // 矩阵的最大值
float a[maxN][maxN];
float temp[maxN][maxN];//用于暂时存储a数组中的变量，控制变量唯一
const int THREAD_NUM = 4; //表示线程的个数
int seg = 30;//表示每次线程运行的行数，将来它会改变来探究最优任务分配方法
int next_task = 0;
int line = 0;//记录当前所依赖的行数
struct timeval startTime, stopTime;// timers


/**
 * 根据第i行的元素，消除j行的元素
 * @param i 根据的行数
 * @param j 要消元的行数
 */
void OMP_elimination(int i, int j) {
    float tep;
    __m128 div, t1, t2, sub;
    // 用temp暂存相差的倍数
    tep = a[j][i] / a[i][i];
    // div全部用于存储temp，方便后面计算
    div = _mm_set1_ps(tep);

    //每四个一组进行计算，思想和串行类似
    int k = n - 3;
    for (; k >= i + 1; k -= 4) {
        t1 = _mm_loadu_ps(a[i] + k);
        t2 = _mm_loadu_ps(a[j] + k);
        sub = _mm_sub_ps(t2, _mm_mul_ps(t1, div));
        _mm_store_ss(a[j] + k, sub);
    }
    //处理剩余部分
    for (k += 3; k >= i + 1; --k) {
        a[j][k] -= a[i][k] * tep;
    }
    a[j][i] = 0.00;
}

/**
 * 多线程消元函数,动态粗颗粒分配，每次分配seg个
 * @param parm
 */
void OMP_func() {
    int task = 0;
    while (true) {
#pragma omp critical //每次只能一个线程执行
        {
            task = next_task;
            next_task += seg;//每次分配seg个
        }
        if (task >= n) break;
        int min = task + seg < n ? task + seg : n;
        for (int i = task; i < min; ++i) {
            OMP_elimination(line, i);
        }
    }
}

//用于矩阵改变数值,为防止数据溢出,随机数的区间为100以内的浮点数
void change() {
    srand((unsigned) time(NULL));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= n; j++) {
            a[i][j] = (float) (rand() % 10000) / 100.00;
        }
    }
}


/**
 * 将a数组的数据存储到b数组中
 * @param a
 * @param b
 */
void store(float a[][maxN], float b[][maxN]) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= n; j++) {
            b[i][j] = a[i][j];
        }
    }
}

int main(int arg, char *argv[]) {
    change();
    store(a, temp);
    // SSE算法消元设计
    for (; seg <= 300; seg += 30) {
        store(temp, a);//从temp中取数
        printf("seg: %d\n", seg);
        gettimeofday(&startTime, NULL);
        for (line = 0; line < n - 1; ++line) {
            next_task = line + 1;
# pragma omp parallel num_threads(THREAD_NUM)
            OMP_func();
        }
        gettimeofday(&stopTime, NULL);
        double trans_mul_time =
                (stopTime.tv_sec - startTime.tv_sec) * 1000 + (stopTime.tv_usec - startTime.tv_usec) * 0.001;
        printf("time: %lf ms\n", trans_mul_time);
    }
}

代码运行结果

请添加图片描述

如此重复多次实验，将所得到的的数据绘成echarts图表

实验图表和结论

请添加图片描述
实验结论

  1. 与上个实验不同的是，这次实验我增加了整体矩阵的大小和每次分配行数的间距，这样得出的实验结果更加准确。
  2. 由上图表可知，当矩阵规模达到2048 × \times × 2048时，整体运行的运行时间都相对较短，运行效率相比于串行化执行要快很多。每次分配90行的时候运行效果最佳，180~240的时候与90相差不大，整体区别不太。所以矩阵规模越大，尽量分配越多的行数使运行效率加快。
NK.MainJay
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenMP并行程序设计（二）
周伟明的多核、测试专栏
09-04 8万+
 OpenMP并行程序设计（二）... 11、fork/join并行执行模式的概念... 12、OpenMP指令和库函数介绍... 13、parallel 指令的用法... 34、for指令的使用方法... 45 sections和section指令的用法... 5OpenMP并行程序设计（二）1、fork/join并行执行模式的概念OpenMP是一个编译器指令
并行计算omp
ddddddddrose的博客
10-08 1308
omp
使用omp和mpi并行技术实现蒙特卡罗算法实验 （MonteCarlo）
weixin_56273009的博客
06-19 1059
parallel for：parallel和for指令的结合，也是用在for循环语句之前，表示for循环体的代码将被多个线程并行执行，它同时具有并行域的产生和任务分担两个功能；lastprivate：是用来指定将线程中的一个或多个私有变量的值在并行处理结束后复制到主线程中的同名变量中，负责拷贝的线程是for或sections任务分担中的最后一个线程；firstprivate：指定一个或多个变量在每个线程都有它自己的私有副本，并且私有变量要在进入并行域或任务分担域时，继承主线程中的同名变量的值作为初值；
【图像重建】基于OMP+SP+SL0算法SAR图像重建,含PSNR附Matlab代码
最新发布
matlab_dingdang的博客
06-11 1207
合成孔径雷达（SAR）是一种主动式微波遥感技术，能够获取高分辨率的图像，在军事侦察、灾害监测、资源勘探等领域发挥着重要作用。SAR图像重建是SAR数据处理的核心环节，其目标是通过对接收到的原始数据进行处理，还原出目标场景的真实图像。传统的SAR图像重建算法，如距离多普勒算法（Range-Doppler Algorithm），在复杂环境下容易受到噪声和散射的影响，导致图像质量下降。近年来，随着压缩感知理论的发展，基于稀疏表示的SAR图像重建算法得到广泛关注。
OMP 编程
Nathan_wz的专栏
01-05 722
设置线程数： export OMP_NUM_THREADS=2 头文件 #include 编译命令： g++ test.c -o test -fopenmp 查看线程数目： omp_get_thread_num()
C语言实现OMP算法
12-28
C语言实现的OMP（正交匹配追踪算法），1024长度数据恢复在1秒以内，重构效果很好
OpenMP编程模型(OMP)
hxxjxw的博客
04-30 488
在train Pytorch模型的时候遇到的，但它是C++的 Open Multi-Processing是一个应用程序接口（API），可用于显式指导多线程、共享内存的并行性。 OpenMP是基于线程的并行 https://www.cnblogs.com/lfri/p/10111315.html ...
使用omp并行技术实现快排加速
weixin_56273009的博客
06-19 1047
快速排序可以说是最为常见的排序算法，冒泡排序时间复杂度达到了O（N2），而桶排序容易造成浪费空间。#pragma omp section //该区域对前部分数据进行排序。编译：g++ ./filename.cpp -o ./filename -fopenmp。1、原理：快排需要找一个数作为基准数，用来参照。基准数在中间某位置，两端有指针，找到相应数后，交换。注意：若令第一个数为基准数，先从右往左找，再从左往右找。运行：./filename n n为所设置的线程数。
中科大并行程序设计历年期末考试试卷
03-09
在中国科学技术大学（中科大，USTC）的课程设置中，有一门专门探讨这一主题的课程——并行程序设计。这些历年期末考试试卷为学生提供了宝贵的复习资源，帮助他们理解和掌握并行计算的关键概念和技术。 试卷内容通常...
MPI与OpenMP并行程序设计
09-27
《MPI与OpenMP并行程序设计》是一本深入探讨并行计算领域中两种主流技术——Message Passing Interface（MPI）和OpenMP的书籍。并行计算是解决大规模计算问题的关键技术，尤其是在高性能计算、数据分析和机器学习等...
多核程序设计
12-16
### 多核程序设计——利用OpenMP实现高效并行计算 #### 一、OpenMP的背景与发展 随着计算机硬件技术的飞速发展，多核处理器已成为现代计算机的标准配置。为了充分利用多核处理器的强大计算能力，开发高效的并行...
并行_omp_omp并行计算_
10-04
OMP并行计算实现矩阵乘法，等等等等等等等等
omp（OMP的MATLAB代码）
04-23
omp（OMP的MATLAB代码）
OpenMP并行计算程序例子
11-25
OpenMP并行计算例子,主要包括简单例子、并行循环、常用函数、分段并行、嵌套并行、求π以及同步这些例子。所有例子都已经过测试。
omp算法代码
09-21
稀疏分解； omp算法； matlab代码
omp matlab程序
04-28
omp重构程序
Java共享内存并行编程
09-04
JOMP是一个专为Java设计的共享内存并行编程接口，其目标是为了简化并行编程的复杂性，提高并行程序的开发效率。它借鉴了OpenMP的思想，提供了一系列伪指令和运行库函数，使得程序员可以更轻松地编写并行代码。JOMP由...
MPI与OpenMP并行程序设
12-18
《MPI与OpenMP并行程序设计：C语言版》是一本深入浅出的并行计算入门书籍，专注于介绍两种主流的并行编程模型——Message Passing Interface（MPI）和Open Multi-Processing（OpenMP）。这两者在现代高性能计算领域...
omp 并行计算for循环语句_OpenMP并行计算常用语句（循环并行）
weixin_39948442的博客
11-22 2194
之前主要看了雷洪、胡许冰编著的“多核并行高性能计算OpenMP”这本书，也写了些代码。很久没用了，现在重新整理记录下。或许之后还会用上，添几行代码就可以省去手动并行的麻烦。本篇的内容主要是参考这本书，也有自己写的一些东西。首先了解下背景OpenMP (Open Multi-Processing) 是共享内存模式的，因此它可以在一个节点上使用多个核并行。使用方法比较简单，通过一套并行描述的注释来指导...
OpenMP并行计算基础：程序设计与实践指南
通过以上内容，开发者可以了解并掌握OpenMP的基础知识，从而编写高效的并行程序，利用多核处理器提升计算性能。学习OpenMP不仅可以提高程序运行速度，还能帮助理解并行计算的原理，为解决大规模计算问题打下基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值