软硬件协同仿真加速——OpenMP

原创 已于 2022-05-19 00:30:46 修改 · 1.7k 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

于 2022-05-19 00:28:36 首次发布
本文介绍了OpenMP，一种用于共享内存并行系统的多线程编程方案，适用于C、C++和Fortran。文章详细讲解了如何使用OpenMP的pragma指令，包括获取线程数、并行处理for循环、解决线程竞争问题以及数据环境类导语，旨在简化多核CPU上的并行编程，提高程序执行效率。

一、什么是OpenMP

OpenMP是⼀种⽤于共享内存并⾏系统的多线程程序设计⽅案，⽀持的编程语⾔包括C、C++和Fortran。OpenMP提供了对并⾏算法的⾼层抽象描述，特别适合在多核CPU机器上的并⾏程序设计。编译器根据程序中添加的pragma指令，⾃动将程序并⾏处理，使⽤OpenMP降低了并⾏编程的难度和复杂度。当编译器不⽀持OpenMP时，程序会退化成普通（串⾏）程序。程序中已有的OpenMP指令不会影响程序的正常编译运⾏。

二、OpenMP的使用

1、获取本机的线程数

代码

#include<omp.h>
 
#include<iostream>
 
int main()
 
{
 
    std::cout << "parallel begin:\n";
 
    #pragma omp parallel
 
    {
 
        std::cout << omp_get_thread_num() << std::endl;
 
    }
 
    std::cout << "\n parallel end.\n";
 
    std::cin.get();
 
    return 0;
 
}

结果：
在这里插入图片描述
说明本机是16线程

2、基本的编译导语

#pragma omp parallel

omp中使用parallel制导指令标识代码中的并行段
如上个例子中的指令#pragma omp parallel，因此打印输出并行执行。
#pragma omp parallel

       {

         //线程并行执行的代码

        }

parallel表示其后语句将被多个线程并行执行，“#pragma omp parallel”后面的语句（或者，语句块）被称为parallel region。多个线程的执行顺序是不能保证的。

#pragma omp parallel for

对for循环进行并行处理，每个核之间是并行执行，各线程顺序不能保证

  • 不加openmp指令运行，耗时1.97s
#include <iostream>
#include <time.h>
void test()
{
    int a = 0;
    for (int i=0;i<100000000;i++)
        a++;
}
int main()
{
    clock_t t1 = clock();
    for (int i=0;i<8;i++)
        test();
    clock_t t2 = clock();
    std::cout<<"time: "<<t2-t1<<std::endl;
}
  • 加openmp指令
#include <iostream>
#include <time.h>
void test()
{
    int a = 0;
    for (int i=0;i<100000000;i++)
        a++;
}
int main()
{
    clock_t t1 = clock();
    #pragma omp parallel for
    for (int i=0;i<8;i++)
        test();
    clock_t t2 = clock();
    std::cout<<"time: "<<t2-t1<<std::endl;
}

#pragma omp parallel for num_threads(4)

指定使用线程数为4

3、解决线程竞争引入的编译导语

当多个线程并行执行时，有可能多个线程同时对某变量进行了读写操作，从而导致不可预知的结果。比如下面的例子，对于包含10个整形元素的数组a，我们用for循环求它各个元素之和，并将结果保存在变量sum里。

#include <iostream>
int main()
{
    int sum = 0;
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
#pragma omp parallel for
    for (int i=0;i<10;i++)
        sum = sum + a[i];
    std::cout<<"sum: "<<sum<<std::endl;
    return 0;
}

如果我们注释掉#pragma omp parallel for，让程序先按照传统串行的方式执行，很明显，sum=55。但按照并行方式执行后，sum则会变成其他值，比如在某次运行过程中，sum=49。其原因是，当某线程A执行sum = sum + a[i]的同时，另一线程B正好在更新sum，而此时A还在用旧的sum做累加，于是出现了错误。
基本解决方案
生成一个数组sumArray，其长度为并行执行的线程的个数（默认情况下，该个数等于CPU的核数），在for循环里，让各个线程更新自己线程对应的sumArray里的元素累加到sum里
代码

#include <iostream>
#include <omp.h>
int main(){
    int sum = 0;
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    int coreNum = omp_get_num_procs();//获得处理器个数
    int* sumArray = new int[coreNum];//对应处理器个数，先生成一个数组
    for (int i=0;i<coreNum;i++)//将数组各元素初始化为0
        sumArray[i] = 0;
#pragma omp parallel for
    for (int i=0;i<10;i++)
    {
        int k = omp_get_thread_num();//获得每个线程的ID
        sumArray[k] = sumArray[k]+a[i];
    }
    for (int i = 0;i<coreNum;i++)
        sum = sum + sumArray[i];
    std::cout<<"sum: "<<sum<<std::endl;
    return 0;
}

用omp_get_num_procs()函数来获取处理器个数，用omp_get_thread_num()函数来获得每个线程的ID，为了使用这两个函数，我们需要include<omp.h>
存在的问题：
上面的代码虽然达到了目的，但是它产生了较多的额外操作。OpenMP提供了以下的方法解决线程竞争冒险。

#pragma omp parallel for reduction(+:sum)

在#pragma omp parallel for后面加上了reduction(+:sum)，它的意思是告诉编译器：下面的for循环你要分成多个线程跑，但每个线程都要保存变量sum的拷贝，循环结束后，所有线程把自己的sum累加起来作为最后的输出。

#include <iostream>
int main(){
    int sum = 0;
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
#pragma omp parallel for reduction(+:sum)
    for (int i=0;i<10;i++)
        sum = sum + a[i];
    std::cout<<"sum: "<<sum<<std::endl;
    return 0;
}

存在的问题：
reduction虽然很方便，但它只支持一些基本操作，比如+，-，*,&,|,&&,||等。

#pragma omp critical

实例：求数组a的最大值，将结果保存在max里。
for循环还是被自动分成N份来并行执行，用#pragma omp critical将if(temp > max) max = temp 括了起来，它的意思是：各个线程还是并行执行for里面的语句，但当你们执行到critical里面时，要注意有没有其他线程正在里面执行，如果有的话，要等其他线程执行完再进去执行。这样就避免了race condition问题，但显而易见，它的执行速度会变低，因为可能存在线程等待情况。

#include <iostream>
int main(){
    int max = 0;
    int a[10] = {11,2,33,49,113,20,321,250,689,16};
#pragma omp parallel for
    for (int i=0;i<10;i++)
    {
        int temp = a[i];
#pragma omp critical
        {
            if (temp > max)
                max = temp;
        }
    }
    std::cout<<"max: "<<max<<std::endl;
    return 0;
}

#pragma omp atomic

与critical类似，但比critical效率高
只支持x++ ， x–, --x, ++x
x （ + - * / & | << >> ） = expr

#include <iostream>  
#include <omp.h> // OpenMP编程需要包含的头文件  
  
int main()  
{  
    int sum = 0;   
  
    std::cout << "Before: " << sum << std::endl;  
  
#pragma omp parallel for  
    for (int i = 0; i < 20000; ++i)   
    {  
#pragma omp atomic  
        sum++;  
    }  
  
    std::cout << "After: " << sum << std::endl;  
    return 0;  
}

pragma omp single

用在一段只被单个线程执行的代码段之前，表示后面的代码段将被单线程执行。
代码
在这里插入图片描述结果
在这里插入图片描述

#pragma omp barrier

事件同步，各线程执行顺序是不同的，在并行结束的位置加barrier，可以在此位置让各线程同步
在这里插入图片描述

#pragma omp section

采用section定义的每段程序都将只执行一次，sections中的每段section将并行执行。一个程序中可以定义多个sections，每个sections中又可以定义多个section。同一个sections中section之间处于并行状态。sections与其他sections之间处于串行状态。

#include<omp.h>  
#include<iostream>  
using namespace std;  
void SectionsTest()  
{  
    int i;  
    #pragma omp parallel num_threads(4)  
    {  
        #pragma omp sections //第1个sections  
        {  
            #pragma omp section  
            {  
                cout<<"section 1 线程ID："<<omp_get_thread_num()<<"\n";  
            }  
            #pragma omp section  
            {  
                cout<<"section 2 线程ID："<<omp_get_thread_num()<<"\n";  
            }  
        }  
        #pragma omp sections //第2个sections  
        {  
            #pragma omp section  
            {  
                cout<<"section 3 线程ID："<<omp_get_thread_num()<<"\n";  
            }  
            #pragma omp section  
            {  
                cout<<"section 4 线程ID："<<omp_get_thread_num()<<"\n";  
            }  
        }  
    }  
}

运行程序，其结果有：

section 1 线程ID：0
section 2 线程ID：1
section 3 线程ID：3
section 4 线程ID：1

section1 与section2并行， section3与section4并行
这两个section又串行
在这里插入图片描述

task

参考：https://blog.youkuaiyun.com/gengshenghong/article/details/7004594
task主要适用于不规则的循环迭代和递归的函数调用。都是无法使用for来完成的情况。

#include <omp.h>
 
void task(int p)
{
	printf("task, Thread ID: %d, task: %d\n", omp_get_thread_num(), p);
}
 
#define N		50
void init(int*a)
{
	for(int i = 0;i < N;i++)
		a[i] = i + 1;
}
 
int main(int argc, _TCHAR* argv[])  
{
	int a[N];
	init(a);
 
#pragma omp parallel num_threads(2)
	{
#pragma omp single
		{
			for(int i = 0;i < N; i=i+a[i]) //i递增没有规律
			{
#pragma omp task
				task(a[i]);
			}
		}
	}
 
	return 0;  
}

用single表示只有一个线程会执行下面的代码，表示一开始程序单线程执行，遇到task之后动态的派发线程。OpenMP遇到了task之后，就会使用当前的线程或者延迟一会后接下来的线程来执行task定义的任务。task的作用，就是定义了一个显式的任务。
task和前面的for和sections的区别在于：
for/section 静态 task 动态
task是“动态”定义任务的，在运行过程中，只需要使用task就会定义一个任务，任务就会在一个线程上去执行，那么其它的任务就可以并行的执行。可能某一个任务执行了一半的时候，或者甚至要执行完的时候，程序可以去创建第二个任务，任务在一个线程上去执行，一个动态的过程，不像sections和for那样，在运行之前，已经可以判断出可以如何去分配任务。而且，task是可以进行嵌套定义的，可以用于递归的情况等等。

4、数据环境类导语

OpenMP的数据处理子句包括private、firstprivate、lastprivate、shared、default、reduction copyin和copyprivate。它与编译制导指令parallel，for和sections相结合，用来控制变量的作用范围。

share

没有采取保护会有数据竞争
shared子句声明的变量将在所有线程之间共享，所有线程都可以对同一个内存位置进行读写操作,程序员需确保多个线程正确地访问共享变量（通过critical等指令）
在这里插入图片描述
没有保护，因此两次运行结果不一样
在这里插入图片描述

private

private（list）每个线程都有它自己的私有变量副本，从申明的并行区域开始，为每个线程声明一个相同类型的新对象，对原始对象的所有引用都将替换为对新对象的引用，对于每个线程，声明为私有的变量未初始化

	int i = 0;
	float a = 512.3;
#pragma omp parallel private(i,a)
	{
		i = i + 1;
		printf("thread %d i = %d a= %f\n", omp_get_thread_num(), i, a);
	}
	printf("out of parallel i = %d", i);
	}

运行结果如下，每个线程都有一个独立的i变量，互不影响，同时也不影响原始的i。
在这里插入图片描述

firstprivate

firstprivate子句指定的变量不仅是private作用范围，同时在进入并行区域构造前根据其原始对象的值初始化
示例代码如下

	int i = 1;
	float a = 512.3;
#pragma omp parallel firstprivate(i) private(a)
	{
		i = i + 1;
		printf("thread %d i = %d a= %f\n", omp_get_thread_num(), i, a);
	}
	printf("out of parallel i = %d", i);

运行结果如下，每个线程都有一个独立的i变量，且进入并行区域时每个线程的i都被初始化原始值1。
在这里插入图片描述

lastprivate

lastprivate子句指定的变量不仅是private作用范围，同时会将最后一次迭代或最后一个section执行的值复制回原来的变量

	int i = 0;
	float a = 512.3;
#pragma omp parallel 
	{
	#pragma omp sections lastprivate(i) private(a)
		{
		#pragma omp section
			{
				i = i + omp_get_thread_num();
				printf("thread %d i = %d a= %f\n", omp_get_thread_num(), i, a);
			}
		#pragma omp section
			{
				i = i + omp_get_thread_num();
				printf("thread %d i = %d a= %f\n", omp_get_thread_num(), i, a);
			}
		}
	}

	printf("out of parallel i = %d", i);

运行结果如下，每个线程都有一个独立的i变量，且退出并行区域时原始的i变量被设置成其中一个section线程的相应变量值。
在这里插入图片描述

参考：
https://blog.youkuaiyun.com/laobai1015/article/details/79020128?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162843230216780265414989%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=162843230216780265414989&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduend~default-1-79020128.first_rank_v2_pc_rank_v29&utm_term=openMP%E9%85%8D%E7%BD%AE&spm=1018.2226.3001.4187
https://zhuanlan.zhihu.com/p/61857547
https://blog.youkuaiyun.com/augusdi/article/details/8808158#
https://blog.youkuaiyun.com/u014357799/article/details/79387357
https://blog.youkuaiyun.com/rlyhaha/article/details/79420233

MambaLZ
关注
软硬件协同仿真——硬件加速
u010170039的博客
04-23 6042
#软硬件协同仿真——硬件加速 软硬件协同仿真——硬件加速1. 仿真验证方法1.1 软件仿真(Software Simulation)1.2 协同模拟 (Co-Simulation)1.3 协同仿真 (Co-Emulation)1.4 三种仿真技术对比2. 硬件加速实现方法2.1 专用硬件Emulator2.2 硬件加速方式2.3 硬件加速实现方法 参考： 王宏伟,孙宇明,李铀,唐柳. 一种软件联合FPGA硬件仿真加速系统设计[C]//.2020中国航空工业技术装备工程协会年会论文集.[出版者不详],202
随机森林算法的加速：OpenMP方法
Working hard and Focus
11-03 731
OpenMP用于编写多线程应用程序的 API。它是一组编译器指令和库例程，使并行编程比使用显式线程更容易它实际上大大简化了用 Fortran 、C/ C++ 编写多线程编程程序。主流编译器（gcc/g++，Visual C++）都支持OpenMP，在Windows和Linux操作系统上都比较容易上手，对原始代码的侵入较少。随机森林由N棵随机树（Randomized Trees）组成，在训练与其他衍生算法中，很多情形下每棵树内的运算是独立的，且与树的顺序无关。
OpenMP #pragma omp parallel for 深度解析：99%的人都忽略了这4个关键点
最新发布
CodeTrick的博客
12-03 919
掌握OpenMP的循环并行化技巧，显著提升多核程序性能。详解#pragma omp parallel for 的适用场景、调度策略、数据竞争规避与线程私有化处理四大关键点，深入解析常见误区与优化方法，让并行效率最大化，值得收藏。
【C++】OpenMP简介
chi's blog
05-06 2909
OpenMP 是一套 C++ 并行编程框架, 也支持 Forthan .它是一个跨平台的多线程实现， 能够使串行代码经过最小的改动自动转化成并行的。具有广泛的适应性。这个最小的改动，有时候只是一行编译原语！(在高阶示例中，我们将演示并评估加速性能)具体实现是通过分析编译原语#pragma，将用原语定义的代码块，自动转化成并行的线程去执行。每个线程都将分配一个独立的id. 最后再合并线程结果。OpenMP 入门与实例分析。
openMP的一点使用经验
weixin_30449453的博客
03-23 2148
最近在看多核编程。简单来说，由于现在电脑CPU一般都有两个核，4核与8核的CPU也逐渐走入了寻常百姓家，传统的单线程编程方式难以发挥多核CPU的强大功能，于是多核编程应运而生。按照我的理解，多核编程可以认为是对多线程编程做了一定程度的抽象，提供一些简单的API，使得用户不必花费太多精力来了解多线程的底层知识，从而提高编程效率。这两天关注的多核编程的工具包括openMP和TBB。按照目前网上的讨论，...
运用OpenMP提速图像处理速度
weixin_33709609的博客
12-15 757
一、算法测试// openmptest的测试程序#include "stdafx.h"void Test(int n){    for (int i=0;i&lt;10000;i++)    {        int j=0;        j = j+1;    }    printf("%d",n);}int _tmain(int argc, _TCHAR* argv[]){    for (...
【ALINX黑金Zynq7000综合教程】：软硬件协同设计技巧揭秘
本文全面介绍了ALINX黑金Zynq7000平台，从硬件架构解析到软件环境搭建，再到软硬件协同设计实践与综合性能测试评估。首先，本文详细分析了Zynq7000的处理器架构、内存管理和IO接口特性，特别是在双核心ARM Cortex-A9...
6、并行计算：OpenMP、MPI和CUDA全解析
iii12的专栏
08-21 94
本文深入解析了并行计算的核心概念与技术，包括OpenMP、MPI和CUDA等主流并行编程模型。文章详细介绍了并行计算的基本原理、处理器分类、内存类型、互连方式及其优缺点，并探讨了不同场景下的并行编程方法与优化策略。通过实际应用案例，展示了并行计算在科学计算、机器学习和金融计算等领域的强大能力。
Ansys Fluent并行计算加速术：提升仿真速度的秘诀
![Ansys Fluent并行计算加速术：提升仿真速度的秘诀]... # 摘要 本文系统性地介绍了Ansys Fluent并行计算的原理、设置、调试以及在不同行业中的应用实例。首先概述了并行计算在计算流体力学（CFD）中的必要性及其优势...
【Archard模型并行计算速成】：加速仿真过程的实用方法
并行计算是一种计算方法，它利用多个处理单元同时执行计算任务，以加速整个处理过程。并行计算在科学、工程、人工智能等多个领域中扮演着至关重要的角色。相比传统串行计算，它可以显著缩短数据处理时间，满足日益...
使用OpenMP给程序加速（三）负载平衡与并行性能--转载
11-03 2381
摘要实现出色并行性能的关键是选择适合应用的粒度。粒度是指并行任务的实际工作量。如果粒度太细，则并行性能会因通信开销增加而受到影响。如果粒度太粗，则并行性能会因负载不均衡而受到影响。为确保实现最佳并行性能，开发人员应确定适合并行任务的粒度（通常粒度越大越好），同时还应避免负载不均衡和通信开销增加的情况发生。背景多线程应用的并行任务工作量大小（粒度）会对其并行性能产生很大影响。在分解一项应用使之适用于多线程处理时，开发人员通常采用的方法是从逻辑上将问题分割成尽量多的并行任务，或者在并行任务内根据共享数据与执行顺
嵌入式系统芯片的软硬件协同仿真环境设计
07-25
针对嵌入式系统芯片SoC开发验证阶段的需求，介绍了一种通用的SoC软硬件协同仿真平台。软件仿真由C/C++和汇编语言编写，硬件仿真基于VMM验证方法学所搭建，SoC设计代码由RTL代码编写而成。
OpenMP并行加速
u010385790的博客
12-15 7646
OpenMP并行加速 1.   简介 OpenMP是一个编译器指令和库函数集合，主要是为共享式存储计算机并行程序设计使用的。 OpenMP的一个Parallelfor指令，就是标准的并行模式fork/join式并行模式，基本思想是，程序开始时只有一个主线程，程序中的串行部分都由主线程执行，并行的部分是通过派生其他线程来执行，但是如果并行部分没有结束时是不会执行串行部分的。也即OpenMP并行
使用OpenMP给程序加速（一）
11-03 1457
<br />OpenMP语法简介：<br /> <br />你想让你的程序运行的更快吗？<br />你想让你的程序在改动很少代码的基础上免费的飞奔起来吗？<br /> <br />如果答案是肯定的，向您推荐Inter免费的OpenMP。<br />OpenMP是基于多核处理器的，如果你的机器不是多核的，请不要往下读了！<br /> <br />1，OpenMP 的概述<br />OpenMP 的应用程序接口（API）是在共享存储体系结构上的一个编程模型，它包含编<br />译指导（Compiler Dire
openMP和Cuda对加密程序进行并行化加速
Takina的博客
03-01 1758
CUDA（Compute Unified Device Architecture）是由NVIDIA公司开发的一个并行计算平台和应用程序接口（API）模型。它允许软件开发者和软件工程师使用NVIDIA GPU（图形处理单元）进行通用处理（即非图形处理），这种技术被称为GPGPU（General-Purpose computing on Graphics Processing Units）。执行线程是可由调度程序独立管理的最小程序指令序列。
基于 RISC-V SoC 的可配置 FFT 系统设计（12）RISC-V SoC 软硬件协同仿真验证
新芯设计的博客
01-16 1522
本项目基于软硬件协同仿真验证的理念思维，针对稀疏多音信号，以 MATLAB 采样的数据与处理的结果，作为本次实验的基准数据。对于 C 软件程序设计功能的正确性，可以通过 Visual Studio 2019 软件编程工具来验证。对于 RISC-V FFT 硬件系统设计功能的正确性与可行性，是通过 Vivado 2019.1 集成开发工具来的仿真结果来验证的。...
软硬件协同调优案例解读：活用CPU SIMD加速技术为软件提速
ly945143215的博客
09-19 998
来自OptimizeLab：我们是一群活跃于国内外开源社区，使用各种优化技术追求极致性能的开源工作者。本文是我们在优快云发布的第一篇文章，通过Go语言开源社区在ARM64平台对通用字符串比较的优化方案，向读者介绍如何通过SIMD并行化技术提升软件的执行速度。OptimizeLab项目:https://github.com/OptimizeLab/docs 作者：陈硕 首发于https://opensource.huawei.com/classroom.html?zid=0 SIMD即单指令多数..
笔记：soc最小系统（软硬件协同仿真）--插桩&hello
qq_43029779的博客
05-04 3064
笔记：soc最小系统（软硬件协同仿真）–插桩&hello 0.环境配置：quartus2 15.0+Modelsim10.4+keil5 1.插桩 功能：在完成最小系统的设计后，简单测试数据是否能够写入寄存器，以及uart能否打印hello 实现：先在keil和quartus2分别设计好软硬件工程，再将keil产生的bin/hex文件读到最小系统的sram中，最后通过Modelsim仿真查看波形与打印字符。 1.1 soc最小系统架构连接解析 下图是一个soc系统的结构图，我们即将按照这个架构连接s
openMP的加速原理
qq_31638535的博客
10-16 1094
自动并行化循环，每个线程处理循环中的一部分迭代。OpenMP 将线程的工作划分为独立的任务，每个任务分配给一个线程，最终实现并行加速。使用 OpenMP 很简单，只需在代码中加入相关的 Pragma 指令，编译器会自动处理线程创建、任务分配和同步。这样，通过简单地添加指令，你就可以利用多线程的计算能力，加速循环等耗时操作。
CUDAMPI加速超声速化学反应流模拟软件OSTC的优化研究
该研究不仅涉及底层算法设计、数据结构重构，还包括软硬件协同优化策略的探索，旨在显著提升大规模科学计算的效率与可扩展性。超声速化学反应流广泛存在于高超声速飞行器气动热力学分析、燃烧室内部流场模拟、推进...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值