OpenMP初探

最新推荐文章于 2024-10-09 13:08:33 发布
最新推荐文章于 2024-10-09 13:08:33 发布
阅读量162 收藏 1
点赞数 1
文章标签： c/c++

OpenMP支持c、cpp、fortran，本文对比使用openmp和未使用openmp的效率差距和外在表现，然后讲解基础知识。

一、举例

1、使用OpenMP与未使用OpenMP的比较。

OpenMP是使用多线程的接口。

以c语言程序举例，即ba.c文件如下：

#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void Test(int n)
{
    int j;
    for (int i = 0; i < 100000000; ++i)
    {
        //do nothing, just waste time
        j++;
    }
    printf("%d, ", n);
}
int main(int argc, char *argv[])
{
    int i;

    #pragma omp parallel for
    for (i = 0; i < 100; ++i)
        Test(i);
    
    system("pause");    
    return 1;
}

在编译时，参数如下：

编译结果如下：

耗时：9s

注意：我的电脑为双核，所以开启了4个线程分别运行。

接下来，我通过window + R，输入msconfig，并进入boot中的高级设置，将我电脑的设置为单核，然后再运行同样的程序，可以发现结果如下：

于是可以发现，再设置为单核之后，程序会创建两个线程，这样的结果就是从0 50开始划分，这样显然是没有充分利用cpu的，所以将电脑设置为原来的双核。

 

 

 

未优化的如下：

// #include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void Test(int n)
{
    int j;
    for (int i = 0; i < 100000000; ++i)
    {
        //do nothing, just waste time
        j++;
    }
    printf("%d, ", n);
}
int main(int argc, char *argv[])
{
    int i;

    // #pragma omp parallel for
    for (i = 0; i < 100; ++i)
        Test(i);
    
    system("pause");    
    return 1;
}

在编译时，参数如下：

编译结果如下：

耗时： 24s

不难得知，此程序使用的为单核单线程 ，所以运行速度远远低于使用多核多线程的速度。

 

上面输出了100个数字，时间上来说优化后是未优化的3倍。

然后后续我又输出了1000个数字，未优化的时间为240s，而优化后的时间为84s，可见优化后同样也是优化前的3倍左右。

之所以四个线程的速度仅仅是单线程速度的3倍而不是4倍，这是因为多线程在线程的切换、合作等方面也需要花费一定的时间，所以只是到了3倍的差距，而没有达到4倍的差距。

 

 

2、获取当前线程id、获取总的线程数

#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main(int argc, char *argv[])
{

    int nthreads,tid;

    // fork a team of thread
    #pragma omp parallel private(nthreads,tid)
    {
        //obtian and print thread id
        tid=omp_get_thread_num();
        printf("Hello Word from OMP thread %d\n",tid);

        // only master thread does this;
        if(tid==0)
        {
            nthreads = omp_get_num_threads();
            printf("Number of thread: %d\n",nthreads);
        }
    }
    
    system("pause");    
    return 1;
}

编译条件如下：

 

运行结果如下：

每次运行，可以发现顺序是不同的。但是Number of thread: 4永远是在线程0之后出现，并且tid==0时的这个线程为主线程。

 

 

3、之前使用的为c语言，下面改写为c++。

#include <omp.h>
#include <iostream>
#include <windows.h>
using namespace std;
void Test(int n)
{
    int j;
    for (int i = 0; i < 100000000; ++i)
    {
        //do nothing, just waste time
        j++;
    }
    cout << n << " ";
}
int main(int argc, char *argv[])
{
    int i;

    #pragma omp parallel for
    for (i = 0; i < 100; ++i)
        Test(i);

    system("pause");
    return 1;
}

编译条件为 g++ t.cpp -o t -fopenmp，结果如下：

同样地，这里使用四核来生成的。

 

 

4、如下所示，也是使用c++语言。 

#include <iostream>
#include <windows.h>
#include <omp.h>
using namespace std;
void test(int m) {
    int i = 0;
    double a = 0.0;
    double b = 0.0;
    double c = 0.0;
    for (i = 0; i < 100000000; i++) {
        a += 0.1;
        b += 0.2;
        c = a + b;
    }
    cout << m << " ";
}
int main()
{
    #pragma omp parallel for
    for (int i = 0; i < 200; i++) {
        test(i);
    }
    system("pause");
    return 0;
}

在这里也没有什么很大的区别，总之，我们就是需要将void test这个函数写的复杂一些，然后就会耗时，这样才能看出来变化。

另外，在这里，我们可以看到结果中，是对for循环进行等量的划分，比如对于i从0到200的for循环里，会根据我电脑的2核划分为0 - 50、 51-100、 101-150、 151-200这几个区间，然后使用多核cpu进行运算，这个优化的效果我想是非常惊人的。

 

 

 

 

5、三层循环

#include <iostream>
#include <windows.h>
#include <omp.h>
using namespace std;
void test(int m, int n, int l) {
    int i = 0;
    double a = 0.0;
    double b = 0.0;
    double c = 0.0;
    for (i = 0; i < 100000000; i++) {
        a += 0.1;
        b += 0.2;
        c = a + b;
    }
    cout << m << " " << n << " " << l  << endl;
}
int main()
{
    cout << "first" << endl;
    #pragma omp parallel for
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            for (int k = 0; k < 5; k++) {
                test(i, j, k);
            }
        }
    }

    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;
    cout << "over hah" << endl;

    cout << "second" << endl;
    #pragma omp parallel for
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            for (int k = 0; k < 5; k++) {
                test(i, j, k);
            }
        }
    }
    system("pause");
    return 0;
}

结果，

可以看到，还是最外层的循环进行转化。

耗时： 45s。

 

如果我们将上面的两个#pragma openmp parallel for去掉，再进行试验。注意#pragma是预编译指令，比如这里告诉编译器要进行并行运算。

则需要100s左右。虽然没有特别明显的提高，但是还是快了很多，优势是非常明显的。

上面的举例都是一些简单的例子，而对于具体的项目还会遇到问题，需要灵活应变。

 

 

二、基础

　　需要使用openmp就需要引入omp.h库文件。然后在编译时添加参数 -fopenmp即可。 在具体需要进行并行运算的部分，使用 #pragma omp 指令[子句] 来告诉编译器如何并行执行对应的语句。 常用的指令如下：

  • parallel - 即#pragma omp parallel 后面需要有一个代码片段，使用{}括起来，表示会被并行执行。
  • parallel for - 这里后面跟for语句即可，不需要有额外的代码块。
  • sections
  • parallel sections
  • single - 表示只能单线程执行
  • critical - 临界区，表示每次只能有一个openmp线程进入
  • barrier - 用于并行域内代码的线程同步，线程执行到barrier时停下来 ，直到所有线程都执行到barrier时才继续。

　　常用的子句如下：

  • num_threads - 指定并行域内线程的数目
  • shared - 指定一个或者多个变量为多个线程的共享变量
  • private - 指定一个变量或者多个变量在每个线程中都有它的副本　　

　　另外，openmp还提供了一些列的api函数来获取并行线程的状态或控制并行线程的行为，常用api如下：

  • omp_in_parallel - 判断当前是否在并行域中。
  • omp_get_thread_num - 获取线程号
  • omp_set_num_threads - 设置并行域中线程格式
  • omp_get_num_threads - 返回并行域中线程数
  • omp_get_dynamic - 判断是否支持动态改变线程数目
  • omp_get_max_threads - 获取并行域中可用的最大的并行线程数目
  • omp_get_num_procs - 返回系统中处理器的个数　　

　　

　　

1、如下使用parallel，会根据电脑配置并行执行多次。

#include <iostream>
#include <windows.h>
#include <omp.h>
using namespace std;
int main()
{
    #pragma omp parallel
    {
        cout << "this is in parallel" << endl;
    }
    system("pause");
    return 0;
}

 

2、使用parallel num_threads(3)，限制并行的线程数为3。

#include <iostream>
#include <windows.h>
#include <omp.h>
using namespace std;
int main()
{
    #pragma omp parallel num_threads(3)
    {
        cout << "this is in parallel" << endl;
    }
    system("pause");
    return 0;
}

这样，最终会输出3个语句，因为语句被并行运行了3次。结果如下：

但是上面的结果不是固定的，这里可以很明显的表示出程序是并行运行的，因为第一个输出还没来得及换行，第二个又继续输出了，所以它们是独立地并行地运算的。

 

 

3、下面我们使用 #pragma parallel for num_threads(4)，并且在并行域中，我们还通过 omp_get_thread_num()来获取线程号，如下:

#include <iostream>
#include <windows.h>
#include <omp.h>
using namespace std;
int main()
{
    #pragma omp parallel for num_threads(4)
    for (int i = 0; i < 20; i++) {
        cout << omp_get_thread_num() << endl;
    }
    system("pause");
    return 0;
}

这里就是对这个for循环使用4个线程来并行。 注意 #pragma omp parallel for num_threads(4) 与 #pragma omp parallel  num_threads(4) 不同，可自行体会。

结果如下，出现空行是因为多线程并行运算，导致换行符没来得及输出另外一个线程号就被输出了。

 

 

4、对比单线程、2线程、4线程、...... 、12线程效率。

#include <iostream>
#include <windows.h>
#include <omp.h>
using namespace std;
void test() {
    int j = 0;
    for (int i = 0; i < 100000; i++) {
        // do something to kill time...
        j++;
    }
};

int main()
{

    double startTime;
    double endTime;

    // 不使用openMp
    startTime = omp_get_wtime();
    for (int i = 0; i < 100000; i++) {
        test();
    }
    endTime = omp_get_wtime();
    cout << "single thread cost time: " << endTime - startTime << endl;

    // 2个线程
    startTime = omp_get_wtime();
    #pragma omp parallel for num_threads(2)
    for (int i = 0; i < 100000; i++) {
        test();
    }
    endTime = omp_get_wtime();
    cout << "2 threads cost time: " << endTime - startTime << endl;

    // 4个线程
    startTime = omp_get_wtime();
    #pragma omp parallel for num_threads(4)
    for (int i = 0; i < 100000; i++) {
        test();
    }
    endTime = omp_get_wtime();
    cout << "4 threads cost time: " << endTime - startTime << endl;

    // 6个线程
    startTime = omp_get_wtime();
    #pragma omp parallel for num_threads(6)
    for (int i = 0; i < 100000; i++) {
        test();
    }
    endTime = omp_get_wtime();
    cout << "6 threads cost time: " << endTime - startTime << endl;

    // 8个线程
    startTime = omp_get_wtime();
    #pragma omp parallel for num_threads(8)
    for (int i = 0; i < 100000; i++) {
        test();
    }
    endTime = omp_get_wtime();
    cout << "8 threads cost time: " << endTime - startTime << endl;

    // 10个线程
    startTime = omp_get_wtime();
    #pragma omp parallel for num_threads(10)
    for (int i = 0; i < 100000; i++) {
        test();
    }
    endTime = omp_get_wtime();
    cout << "10 threads cost time: " << endTime - startTime << endl;

    // 12个线程
    startTime = omp_get_wtime();
    #pragma omp parallel for num_threads(12)
    for (int i = 0; i < 100000; i++) {
        test();
    }
    endTime = omp_get_wtime();
    cout << "12 threads cost time: " << endTime - startTime << endl;

    system("pause");
    return 0;
}

结果如下：

 

 于是，我们可以看到，单线程（不使用openMP）时消耗时间最长，2线程约为单线程的一半，4个线程（本电脑为4个逻辑内核）约为1/3时间，6个线程的时候时间甚至更长，12个线程在时间上也没有明显额减少，所以，线程数的制定可以根据电脑的核心数来做出选择。

 

 

 

更多例子：

#include <iostream>
#include <windows.h>
#include <omp.h>
using namespace std;
void test(int i) {
    int j = 0;
    for (int i = 0; i < 100000000; i++) {
        // do something to kill time...
        j++;
    }
    cout << i << endl;
};

int main()
{

    // 此程序中使用到的openmp不可简单地理解为一个封装起来的库，实际上应该理解为一个框架。这个框架是由硬件开发商和软件开发商共同开发的，即通过协商api，来使得多核并行运算更容易上手、使用
    // 主要参考文章：https://wdxtub.com/2016/03/20/openmp-guide/
    
    // #pragma omp parallel for
    // for (int i = 0; i != 10; i++) {
    //     test(i);
    // }



    // #pragma omp parallel 
    // {
    //     #pragma omp for
    //     for (int i = 0; i < 10; i++) {
    //         test(i);
    //     }
    // }



    // XXX 错误，对于并行运算，不支持 != 的形式
    // #pragma omp parallel for
    // for (int i = 0; i != 10; i++) {
    //     test(i);
    // }



    // 在并行区域内声明了一个变量private_a，那么在多线程执行时，每个线程都会创建这么一个private_a变量。
    // 最终输出结果为668/668/669/669，说明2个线程加了两次，2个线程加了3次。
    // #pragma omp parallel
    // {
    //     int private_a = 666;
    //     #pragma omp for
    //     for (int i = 0; i < 10; i++) {
    //         test(i);
    //         private_a++;
    //     }
    //     cout << private_a << endl;
    // }



    // 在并行区域之外定义的变量是共享的，即使下面有多个线程并行执行for循环，但是不会为每个线程创建share_a变量，所以最终每个线程访问的都是同一个内存，输出的结果为4个676
    // int share_a = 666;
    // #pragma omp parallel
    // {
    //     #pragma omp for
    //     for (int i = 0; i < 10; i++) {
    //         test(i);
    //         share_a++;
    //     }
    //     cout << share_a << endl;
    // }


    // 注意：这种循环是普通的循环，其中的sum是共享的，然后sum是累加的，所以从结果中也可以看出sum一定是非递减的，最终结果为45。
    // int sum = 0;
    // cout << "Before: " << sum << endl;
    // #pragma omp parallel for
    // for (int i = 0; i < 10; i++) {
    //     sum = sum + i;
    //     cout << sum << endl;
    // }
    // cout << "After: " << sum << endl;


    // 注意：这里采用了reduction(+:sum)，所以每个线程根据reduction(+:sum)的声明计算出自己的sum（注意：在每个线程计算之初，sum均为在并行域之外规定的0，即对于4个线程而言，4个线程都会有一个初始值为0的sum，然后再叠加），然后再将各个线程的sum添加起来，所以从结果来看，sum是不存在某种特定规律的。
    // int sum = 0;
    // cout << "Before: " << sum << endl;
    // #pragma omp parallel for reduction(+:sum)
    // for (int i = 0; i < 10; i++) {
    //     sum = sum + i;
    //     cout << sum << endl;
    // }
    // cout << "After: " << sum << endl;


    // 下面的减法是类似的，对比上面的两个例子即可。
    // int sum = 100;
    // cout << "Before: " << sum << endl;
    // #pragma omp parallel for
    // for (int i = 0; i < 10; i++) {
    //     sum = sum - i;
    //     cout << sum << endl;
    // }
    // cout << "After: " << sum << endl;

    // int sum = 100;
    // cout << "Before: " << sum << endl;
    // #pragma omp parallel for reduction(-:sum)
    // for (int i = 0; i < 10; i++) {
    //     sum = sum - i;
    //     cout << sum << endl;
    // }
    // cout << "After: " << sum << endl;



    // 下面的两个例子中一个使用了原子操作，一个没有使用原子操作。
    // 使用原子操作的最后结果正确且稳定，而没有使用原子操作最终的结果是不稳定的。
    // int sum = 0;
    // cout << "Before: " << sum << endl;
    // #pragma omp parallel for
    // for (int i = 0; i < 20000; i++) {
    //     #pragma omp atomic
    //     sum++;
    // }
    // cout << "Atomic-After: " << sum << endl;

    // int sum = 0;
    // #pragma omp parallel for
    // for (int i = 0; i < 20000; i++) {
    //     sum++;
    // }
    // cout << "None-atomic-After: " << sum << endl;



    // 线程同步之critical
    // 使用critical得到的结果是稳定的，而不使用critical得到的结果是不稳定的。
    // 值得注意的是：critical与atomic的区别在于 - atomic仅仅使用自增(++、--等)或者简化(+=、-=等)两种方式，
    // 并且只能表示下一句，而critical却没有限制，且可以通过{}代码块来表示多句同时只能有一个线程来访问。
    // int sum = 0;
    // cout << "Before: " << sum << endl;
    // #pragma omp parallel for
    // for (int i = 0; i < 100; i++) {
    //     #pragma omp critical(a)
    //     {
    //         sum = sum + i;
    //         sum = sum + i * 2;
    //     }
    // }
    // cout << "After: " << sum << endl;


    // 同时运行下面的两个程序，可以发现有些许不同。
    // 这个程序中的第一个for循环会多线程执行，并且如果一个线程执行完，如果有的线程没有执行完，
    // 那么就会等到所有线程执行完了再继续向下执行。所以结果中 - 和 + 区分清晰。
    // #pragma omp parallel 
    // {
    //     #pragma omp for 
    //     for (int j = 666; j < 1000; j++) {
    //         cout << "-" << endl;
    //     }

    //     #pragma omp for nowait
    //     for (int i = 0; i < 100; i++) {
    //         cout << "+" << endl;
    //     }
    // }

    // 这个程序中的第一个for循环同样会有多个线程同时执行，只是其中某个线程最先执行完了之后，
    // 不会等其他的线程，而是直接进入了下一个for循环，所以结果中的 - 和 + 在中间部分是混杂的。
    // #pragma omp parallel 
    // {
    //     #pragma omp for nowait
    //     for (int i = 0; i < 100; i++) {
    //         cout << "+" << endl;
    //     }

    //     #pragma omp for 
    //     for (int j = 666; j < 1000; j++) {
    //         cout << "-" << endl;
    //     }
    // }
    // 
    // 可知，barrier为隐式栅障，即并行区域中所有线程执行完毕之后，主线程才继续执行。
    // 而nowait的声明即可取消栅障，这样，即使并行区域内即使所有的线程还没有执行完，
    // 但是执行完了的线程也不必等待所有线程执行结束，而可自动向下执行。


    // 如下所示正常来说应该是第一个for循环中的一个线程执行完之后nowait进入下一个for循环，
    // 但是我们通过 #pragma omp barrier 来作为显示同步栅障，即让这个先执行完的线程等待所有线程执行完毕再进行下面的运算
    // #pragma omp parallel 
    // {
    //     #pragma omp for nowait
    //     for (int i = 0; i < 100; i++) {
    //         cout << "+" << endl;
    //     }

    //     #pragma omp barrier

    //     #pragma omp for 
    //     for (int j = 666; j < 1000; j++) {
    //         cout << "-" << endl;
    //     }
    // }



    // 这里我们通过#pragma omp master来让主线程执行for循环，然后其他的线程执行后面的cout语句，
    // 所以，cout的内容会出现在for循环多次（这取决于你电脑的性能），最后，主线程执行完for语句后，也会执行一次cout
    // #pragma omp parallel
    // {
    //     #pragma omp master
    //     {
    //         for (int i = 0; i < 10; i++) {
    //             cout << i << endl;
    //         }
    //     }
    //     cout << "This will be shown two or more times" << endl;
    // }



    // 使用section可以指定不同的线程来执行不同的部分
    // 如下所示，通过#pragma omp parallel sections来指定不同的section由不同的线程执行
    // 最后得到的结果是多个for循环是混杂在一起的
    // #pragma omp parallel sections
    // {
    //     #pragma omp section
    //     for (int i = 0; i < 10; i++) {
    //         cout << "+";
    //     }

    //     #pragma omp section 
    //     for (int j = 0; j < 10; j++) {
    //         cout << "-";
    //     }

    //     #pragma omp section
    //     for (int k = 0; k < 10; k++) {
    //         cout << "*";
    //     }        
    // }

    system("pause");
    return 0;
}

通过上面的例子，我们就可以对OpenMP有一个基本的入门过程了。

 

weixin_34270865
关注
【程序语言】并行编程——openMP初探
精灵的博客
01-16 7464
（1）openMP的配置（windows平台+vs2010）。在Visul Studio中配置openMP十分简单，只需打开“项目 - > 属性 - > C/C++ - > 语言”中将“OpenMPI支持”选为"是" 如下图所示：              这样你就可以开始OpenMP之旅了。 （2）下面开始我们最简单的OpenMPI语句，hello world! #include
并行初探
ph の BLOG
09-13 1201
一些笔记整理 1. 基础认知 1.1 如何编写并行程序 基本思想：将要完成的任务分配给多个核。 两种广泛的方法：任务并行和数据并行 任务并行 将待解决问题所需要执行的各个任务分配到各个核上执行。（执行不同的指令） 数据并行 将待解决问题所需要处理的数据分配给各个核，每个核在分配到的数据集上执行大致相似的操作。 1.2 两种并行内存系统 共享内存系统 各个核能够共享到计算机的内存。 （比如Pthreads和OpenMP就是为此设计） 分布式内存系统 每个核拥有自己的私有内存，核之间的通信是显式
openmp openmp
06-13
openmpopenmpopenmpopenmpopenmpopenmpopenmpopenmpopenmpopenmpopenmpopenmp
OpenMP编程指南
beyondjhf_2008的博客
05-27 166
[size=medium]OpenMP编程指南 本文转载于http://blog.csdn.net/drzhouweiming/archive/2009/04/20/4093624.aspx 进入多核时代后，必须使用多线程编写程序才能让各个CPU核得到利用。在单核时代，通常使用操作系统提供的API来创建线程，然而，在多核系统中，情况发生了很大的变化， 如果仍然使用操作系统API来创建线...
什么是OpenMP
最新发布
qq_41505080的博客
10-09 204
OpenMP (Open Multi-Processing) 是一个用于共享内存多处理器编程的 API（应用程序编程接口）。它提供了一组编译器指令、库函数和环境变量，用于开发多线程并行程序。OpenMP 主要用于 C、C++ 和 Fortran 语言，适用于在多核处理器上执行的共享内存并行计算任务。OpenMP 常用于科学计算、图像处理、数据分析等需要并行化计算的大型应用中。命令会创建一个并行区域，多个线程将在此区域内同时运行。
初探OpenMP
何似莫相逢
05-22 950
vs下OpenMP简单demo，配置方式
初探MNN
2Know的博客
12-08 1902
初探MNN 伴随着大量人工智能项目的落地，业界对端上推理的需求也越来越旺盛。在之前的文章中介绍过OpenCV的DNN模块，目前开源的端上推理引擎除了OpenCV的DNN之外，还有tensorFlow-lite、paddle-lite、NCNN、MNN等多个推理框架。目前端上推理引擎主要支持CPU及端上GPU，主流的的设备是CPU(arm)+GPU(mali qualcomm powerVR),主要...
OpenMPI源码剖析1：MPI_Init初探
alcc34716的博客
04-08 3535
OpenMPI的底层实现: 我们知道，OpenMPI应用起来还是比较简单的，但是如果让我自己来实现一个MPI的并行计算，你会怎么设计呢？————这就涉及到比较底层的东西了。 回想起我们最简单的代码，通过comm_rank来决定做不同的事情，那么这个comm_rank是怎么得到的呢？ 源代码从哪里看起？在百度，谷歌都没有找到关于源码剖析的一些资料，只能先找找头文件 mpi.h搜索找...
MIT算法导论公开课高级课题与并行算法初探
MPI主要适用于分布式内存系统，而OpenMP则主要用于共享内存系统，它们都提供了丰富的接口用于简化并行编程。 在MIT算法导论公开课的这部分课程笔记中，将涉及以上提到的高级课题和并行算法的理论基础与实际应用案例...
OpenMP--HowToGuide
01-26
并行编程有两大工具：OpenMP和MPI，OpenMP更易于上手，且易于安装。这是一本入门书。
OpenMP_Fortran
03-23
MPI编程，OpenMP编程，Fortran语言甚而，并行计算
OpenM
szv123_rier的专栏
04-09 1196
转载自：http://blog.csdn.net/netnote/article/details/3137563    1        简介 www.openmp.org GNU的gomp项目； Include ；编译参数-fopenmp打开openmp，如果使用-lgomp则编译成单线程版本； 条件编译 #ifdef _OPENMP 声明并行区，由编译器和运行时库确定线程的创建、终
OpenMP概述
yuanlanxiaup
11-26 493
根据计算平台和规模的不同，并行计算可以分为两种：第一种是基于单一计算机系统的多核处理器或多处理器进行多线程并行计算，采用共享存储的方式，主要的标准有OpenMP，如下左图所示；第二种就是基于多台计算机组件的集群（Cluster）计算系统进行并行计算，采用消息传递方式，主要的标准有MPI，如下右图所示。本文将主要介绍多线程方式的并行计算。 首先来了解一下单核处理器上程序运行方式，系统中包括...
openMP一小时初探
weixin_30569153的博客
07-08 102
参考： 通过 GCC 学习 OpenMP 框架（详细，我只看到临界区之前） OpenMP基本概念（全看，内含并行化控制的三种编程要素：编译制导、API函数集和环境变量） OpenMP入门教程（一）（也讲了fork-join执行模型、线程概念、数据作用域...） 我主要跟着第一篇教程看了部分内容，后面两篇当作补充，这里po一下我打的两个简单例子： test1.cpp ...
openMP
ichangjian的专栏
01-25 533
1.借助 OpenMP* 实现更多工作共享 https://software.intel.com/zh-cn/articles/more-work-sharing-with-openmp 2.32 OpenMP traps for C++ developers https://software.intel.com/zh-cn/articles/32-openmp-traps-fo
OpenMP
学习、思考、总结
07-14 773
OpenMp是由OpenMP Architecture Review Board牵头提出的，并已被广泛接受的，用于共享内存并行系统的多线程程序设计的一套指导性的编译处理方案(Compiler Directive)。OpenMP支持的编程语言包括C语言、C++和Fortran；而支持OpenMp的编译器包括Sun Compiler，GNU Compiler和Intel Compiler等。O
OpenMP多核编程指南
"OpenMP简易教程是一篇针对多核并行计算的教程，旨在帮助开发者理解和使用OpenMP优化处理大数据量计算的程序。OpenMP是一种并行编程模型，特别适用于多核处理器环境，用于解决CPU核数扩展性、方便性和可移植性的问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值