使用OpenMP reduction子句求解二维数组的最小值和输出所在下标

原创 已于 2022-10-15 10:22:23 修改 · 1k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #并行计算 #c

于 2022-10-14 17:33:32 首次发布
本文介绍如何使用OpenMP的reduction指令对二维数组中的元素进行最小值计算，并准确获取该最小值的位置。通过三种不同方法对比，展示了自定义规约函数在效率上的优势。

题目：请利用OpenMP 中指令 reduction 编写程序实现对实数数组 x(i,j) = (i + j) / (i * j) (i,j = 1~100) 取最小值并指出最小值对应的下标。

解答思路：初步使用并行思路和reduction子句求出最小值，记录最小值所在的行和列下标。

#include <stdio.h>
#include <omp.h>
#include <time.h>
/*
请利用指令 reduction 编写程序实现对实数数组 x(i,j) = (i + j) / (i * j) (i,j = 1~10) 取最小值并指出最小值对应的下标。
*/

#define m 100
#define n 100

double x_min = 1000;
int min_i, min_j;
int i, j;

double x[m + 1][n + 1];

int main()
{
    clock_t start, finish;
    double Total_time;

    int tid, nthreads;

    start = clock();
    for (int i = 1; i <= m; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            x[i][j] = (float)(i + j) / (i * j);
        }
    }
    omp_set_nested(1);
    omp_set_dynamic(0);
    omp_set_num_threads(20);
#pragma omp parallel for private(tid, nthreads, i, j) shared(x) reduction(min \
                                                                          : x_min)
    for (i = 1; i <= m; i++)
    {
        for (j = 1; j <= n; j++)
        {
            tid = omp_get_thread_num();
            nthreads = omp_get_num_threads();
            if (x[i][j] < x_min)
            {
                x_min = x[i][j];
                min_i = i;
                min_j = j;
            }

            // printf("*****inner:tid = %d,nthreads = %d,x[%d][%d] = %lf\n", tid, nthreads, i, j, x[i][j]);
        }
        // printf("*****outer:tid = %d,nthreads = %d,x[%d][%d] = %lf\n", tid, nthreads, min_i, min_j, x_min);
    }

    printf("min:--------x[%d][%d] = %lf \n", min_i, min_j, x_min);

    // finish = clock();
    // Total_time = (double)(finish - start) / CLOCKS_PER_SEC; //单位换算成秒
    // printf("%f seconds\n", Total_time);
    return 0;
}
运行截图

在这里插入图片描述
在这里插入图片描述

存在的问题：以上程序求出的最小值是正确的，但是下标是有问题的，因为并行之后，不同的线程执行顺序是不固定的，reduction子句里面在进行规约的时候，只能把一个最值给正确拿到，但是i,j下标输出的确实最后一个执行的线程中的最小值的i,j下标。

所以我们可以初步使用最笨的方法，写一个查找函数，从二维数组找到最值，输出其i,j下标，但是很明显，这种方法的效率是很低的，与我们使用并行算法改进效率初衷相悖，代码如下：

#include <stdio.h>
#include <omp.h>
#include <time.h>
/*
请利用指令 reduction 编写程序实现对实数数组 x(i,j) = (i + j) / (i * j) (i,j = 1~10) 取最小值并指出最小值对应的下标。
*/

#define m 100
#define n 100

double x_min = 1000;
int min_i, min_j;
int i, j;

double x[m + 1][n + 1];

int *returnRes(double arr[m + 1][n + 1], double ele)
{
    int res[2] = {0};
    int *p = res;
    for (int i = 1; i <= m; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            if (arr[i][j] == ele)
            {
                res[0] = i;
                res[1] = j;
            }
        }
    }
    return p;
}

int main()
{
    clock_t start, finish;
    double Total_time;

    int tid, nthreads;

    start = clock();
    for (int i = 1; i <= m; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            x[i][j] = (float)(i + j) / (i * j);
        }
    }
    omp_set_nested(1);
    omp_set_dynamic(0);
    omp_set_num_threads(20);
#pragma omp parallel for private(tid, nthreads, i, j) shared(x) reduction(min \
                                                                          : x_min)
    for (i = 1; i <= m; i++)
    {
        for (j = 1; j <= n; j++)
        {
            tid = omp_get_thread_num();
            nthreads = omp_get_num_threads();
            if (x[i][j] < x_min)
            {
                x_min = x[i][j];
                min_i = i;
                min_j = j;
            }

            // printf("*****inner:tid = %d,nthreads = %d,x[%d][%d] = %lf\n", tid, nthreads, i, j, x[i][j]);
        }
        // printf("*****outer:tid = %d,nthreads = %d,x[%d][%d] = %lf\n", tid, nthreads, min_i, min_j, x_min);
    }

    int *res = returnRes(x, x_min);
    printf("min:--------x[%d][%d] = %lf \n", res[0], res[1], x_min);
    // printf("min:--------x[%d][%d] = %lf \n", min_i, min_j, x_min);

    finish = clock();
    Total_time = (double)(finish - start) / CLOCKS_PER_SEC; //单位换算成秒
    printf("%f seconds\n", Total_time);
    return 0;
}
上面的returnRes函数就起到了返回最小值i,j下标的作用，通过在网上查找，我们得到了利用OpenMP reduction子句可以自定义规约函数，我们可以定义成结构体，里面分别是元素值，i下标，j下标，通过比较元素值来判断结构体的大小，从而整体返回一个结构体，这个时候下标也会一起返回出来。代码见下面：
#include <stdio.h>
#include <omp.h>
#include <time.h>
/*
请利用指令 reduction 编写程序实现对实数数组 x(i,j) = (i + j) / (i * j) (i,j = 1~10) 取最小值并指出最小值对应的下标。
*/

#define m 100
#define n 100
double x[m + 1][n + 1];
struct compare
{
    float val;
    int index;
    int index1;
};
struct compare add_matrix(struct compare X, struct compare Y)
{
    struct compare temp;
    if (X.val < Y.val)
    {
        temp.val = X.val;
        temp.index = X.index;
        temp.index1 = X.index1;
    }
    else
    {
        temp.val = Y.val;
        temp.index = Y.index;
        temp.index1 = Y.index1;
    }
    return temp;
}
int main()
{
    int tid, nthreads;
    for (int i = 1; i <= m; i++)

    {
        for (int j = 1; j <= n; j++)

        {
            x[i][j] = (float)(i + j) / (i * j);
        }
    }

    double x_mymin = 1000;
    int mymin_i, mymin_j;
    // omp_set_nested(1);
    omp_set_dynamic(0);
    omp_set_num_threads(10);
    struct compare mymin;
    mymin.val = x[1][1];
    mymin.index = 1;
    mymin.index1 = 1;
    int i = 1;
    int j = 1;
    clock_t begin, end;
    begin = clock();
#pragma omp declare reduction(p_add_matrix     \
                              : struct compare \
                              : omp_out = add_matrix(omp_out, omp_in)) initializer(omp_priv = {100})
    {
#pragma omp parallel for private(tid, nthreads, i, j) shared(x) reduction(p_add_matrix \
                                                                          : mymin)

        for (i = 1; i <= m; i++)

        {
            for (j = 1; j <= n; j++)

            {
                tid = omp_get_thread_num();
                nthreads = omp_get_num_threads();
                if (x[i][j] < mymin.val)

                {
                    mymin.val = x[i][j];
                    mymin.index = i;
                    mymin.index1 = j;
                }

                // printf("*****inner:tid = %d,nthreads = %d,x[%d][%d] = %lf\n", tid, nthreads, i, j, x[i][j]);
            }
            // printf("*****outer:tid = %d,nthreads = %d,x[%d][%d] = %lf\n", tid, nthreads, mymin.index, mymin.index1, mymin.val);
        }
    }
    printf("mymin:--------x[%d][%d] = %lf ", mymin.index, mymin.index1, mymin.val);
    end = clock();
    double cost;
    cost = (double)(end - begin) / CLOCKS_PER_SEC;
    printf("CLOCKS_PER_SEC is %d\n", CLOCKS_PER_SEC);
    printf("time cost is: %lf secs\n", cost);
    return 0;
}
通过调节m,n的值可以测试程序运行的时间，会发现这种方式比单独写一个查找函数的方式要快非常多！下面有运行时间的截图哦，最后感谢我的舍友健神！
1.带查找函数的：（矩阵规模 10000*10000）：1.3S左右

在这里插入图片描述

2.自定义规约函数的：（矩阵规模 10000*10000）：0.4S左右，加速比提高了三倍多！

在这里插入图片描述

指针和二维数组，求二维数组的最大值，最小值，及其他们的下标。
weixin_44935446的博客
05-31 9223
知识点：学会通过指针引用多维数组 多维数组的地址： *（*（a+i）+j）与*（a[i]+j)是等价的，都是a[i][j]的值 *（a+i）+j与a[i]+j是等价的，都是a[i][j]的地址 二维数组a的有关指针 表格形式 含义 a 二维数组名，指向一位数组a[0]，即0行起始地址 a[0],*(a+0),*a 0行0列元素地址...
6、OpenMP归约操作reduction、shared、simd
sxj731533730
06-27 1936
基本思想：OpenMP进行加减乘除运算的规约处理 reduction 可以支持的运算符号 +、-、*、/、&&、|、^、|| 符号 #pragma omp parallel for reduction(+:sum) for(int i=0;i<num;i++) { .... } 测试代码 #include <iostream> #include <omp.h> #include<chrono> using
求二维数组中最大最小值及行列号
02-20
c语言上机考试专用，简单易操作，求二维数组的最大最小值及行列号
求一个数组最小的两个数的下标
05-18
求一个数组的两个最小数，并返回下标。在数组中查找最小的两个数的下标。
OpenMP实现求矩阵均值最大值以及最小值
Lhw_666的博客
09-20 1655
编写OpenMP程序，求10000*10000矩阵的均值，并找到矩阵的最大值和最小值，比较共享变量和私有变量。 #include <stdio.h> #include <stdlib.h> #include <time.h> #include <omp.h> omp_lock_t mutex; int Arr[10000][10000]; long long sum1 = 0, sum2 = 0, end_time1, start_time1, end_ti
10.求二维数组最小值的下标
Sugar_yjl的博客
09-28 761
记录
精选资源
Heat-Diffusion-using-MPI-:使用 OpenMP 和 MPI 求解网格上的热扩散方程
07-08
使用 OpenMP 和 MPI 求解网格上的热扩散方程 考虑在大小为 0 ≤ x, y ≤ π 的二维域上求解 κ = 常数 = 1 的热扩散方程。 设边界条件为 T(x, 0) = cos^2 x T(x, π) = sin^2 x T(0, y) = T(π, y)（以 x 为周期） ...
论文研究-二维三温能量方程求解MPI-OpenMP并行算法研究.pdf
07-22
提出了二维三温能量方程的MPI-OpenMP并行求解算法，该算法上层使用MPI进程进行通信，下层使用OpenMP多线程进行核心计算，不但能够适应大规模问题的求解，而且还表现出很好的扩展性和加速比。实验表明，算法在网格...
使用devcpp，并以二维数组为例，测试collapse子句有利于负载均衡。给完整代码
最新发布
11-16
如果你想利用Dev-C++并利用二维数组测试负载均衡的collapse子句（通常在OpenMP库中用于数据并行处理），实际上OpenMP并不直接支持`collapse`，因为这通常是CUDA或者某些高级并行库的功能。但在OpenMP中，你可以使用`...
精选资源
源程序二维效率_导热_一维和二维稳态导热程序C语言_
10-03
标题提到的"源程序二维效率_导热_一维和二维稳态导热程序C语言_"涉及到的是使用C语言编写的一组程序，用于模拟和计算传热学中的稳态一维和二维导热问题。这种程序对于工程设计、能源管理、材料科学等领域具有重要...
问题：如何找到一个数值二维数组里最出最小的元素及其对应下标？
2303_76295261的博客
07-23 1001
1.将已知(或者从键盘输入数据)的二维数组(arr_1)复制一份(arr_2)，此时arr_1与arr_2这两个二维数组的元素及其对应下标完全一样。3.找到最小元素值后，接着使用循环遍历arr_2，直到找到arr_2里面的与最小值相等的元素，并输出该元素的下标。2.使用冒泡排序法判断arr_1里的最小元素值并输出。
求二维数组中的最大值 最小值及其下标
YL的专栏
12-19 1万+
/* *程序的版权和版本声明部分： *Copyright（c）2013，烟台大学计算机学院学生 *All rights reserved. *文件名称： *作者：尚振伟 *完成日期：2013年 12月19日 *版本号：v0.1
二维数组最小值
bbc121223的博客
03-31 696
第一行 m，n表示二维数组 m行，n列 <=100 接下来 m行，n列的数，a[I,j]<=10000。如果有多个最小值，输出行标最小的，如果同行有多个最小值，输出列标最小的。输入一个二维数组，找出其中最小的数，输出它的值以及所在行号和列号。三个数，分别是 a[I,j] i, j ，意义如要求。
在一个二维数组中找出最小数及其所在的行和列（C语言）
Zhangguohao666的博客
03-29 1万+
使用一维数组，存储最小值及其所在行与列
求二维数组最大最小值----利用函数调用形式(2种方法)
热门推荐
smallgyy的专栏
12-14 2万+
（1）利用冒泡排序思想求二维数组中的最大值 /* 利用函数调用形式，传递二维数组名进行函数调用 设计求二维数组中最小值、最大值的函数，在主函数中调用 利用冒泡排序思想求二维数组最大值。 算法思想：先对各行进行一次冒泡排序，使每行的最后一个数为当前行中最大值， 即二维数组中的最后一列中的数，都是本行中的最大值。 然后对二维数组中的最后一列进行一次冒泡排序，得到最后一列的最后
计算二维数组的最大值，最大值行列下标，最小值，最小值行列下标
wghq的博客
12-29 1071
【代码】计算二维数组的最大值，最大值行列下标，最小值，最小值行列下标。
OpenMP 教程（一） 深入剖析 OpenMP reduction 子句
qq_45537774的博客
11-09 2894
在本篇文章当中我们主要使用一个例子介绍了如何解决并发程序当中的竞争问题，然后也使用了 reduction 子句去解决这个问题，随后介绍了在 OpenMP 当中 reduction 各种规约符号的使用！
OpenMP中的Reduction操作 #pragma omp xxx reduction()
qq_43219379的博客
04-02 5892
OpenMP中的Reduction操作，for循环操作。类似于#pragma omp xxx reduction()。
openmp 并行计算
luoganttcc_son的博客
07-31 301
代码】openmp并行计算。
openmp reduction子句
04-08
OpenMP reduction 子句是 OpenMP 并行编程中的一个关键特性，可以有效地实现多线程之间的数据共享和结果合并，提高程序的并行性和效率。通过使用 reduction 子句，每个线程可以把自己的结果与共享变量的初始值进行...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值