OpenMP并行实验报告
OpenMP并行实验报告
并行实验报告一、积分计算圆周率1.1 积分计算圆周率的向量优化1.1.1 串行版本的设计任务：理解积分求圆周率的方法，将其用C代码实现。
注意：理论上，dx越小，求得的圆周率越准确；在计算机中由于表示的数据是有精度围的，如果dx太小，积分次数过多，误差积累导致结果不准确。
以下为串行代码：#include<stdio.h>#include<time.h>#define N 10000000double get_pi(int dt){double pi=0.0;double delta =1.0/dt;int i;for(i=0; i<dt; i++){double x=(double)i/dt;pi+=delta/(1.0+x*x);}return pi*4;}int main(){int dx;double pai;double start,finish;dx=N;start=clock();pai=get_pi(dx);finish=clock();printf("%.8lf\n",pai);printf("%.8lfS\n",(double)(finish-start)/CLOCKS_PER_SEC); return 0;}时间运行如下：第一次：time=0.02674000S第二次：time=0.02446500S第三次：time=0.02402800S三次平均为：0.02508S1.1.2 SSE向量优化版本设计任务：此部分需要给出单精度和双精度两个优化版本。
注意：（1）测试均在划分度为10的7次方下完成。
以下是SSE双精度的代码：#include<stdio.h>#include<x86intrin.h>#include<time.h>#define N 10000000double get_pi(int dt){double pi=0.0;double delta =1.0/dt;int i;for(i=0; i<dt; i++){double x=(double)i/dt;pi+=delta/(1.0+x*x);}return pi*4;}double get_pi_sse(size_t dt){double pi=0.0;double delta =1.0/dt;__m128d xmm0,xmm1,xmm2,xmm3,xmm4;xmm0=_mm_set1_pd(1.0);xmm1=_mm_set1_pd(delta);xmm2=_mm_set_pd(delta,0.0);xmm4=_mm_setzero_pd();for(long int i=0; i<=dt-2; i+=2){xmm3= _mm_set1_pd((double)i*delta);xmm3= _mm_add_pd(xmm3,xmm2);xmm3= _mm_mul_pd(xmm3,xmm3);xmm3= _mm_add_pd(xmm0,xmm3);xmm3= _mm_div_pd(xmm1,xmm3);xmm4= _mm_add_pd(xmm4,xmm3);}double tmp[2] __attribute__((aligned(16))); _mm_store_pd(tmp,xmm4);pi+=tmp[0]+tmp[1]/*+tmp[2]+tmp[3]*/;return pi*4.0;}int main(){int dx;double pai;double start,finish;dx=N;start=clock();pai=get_pi_sse(dx);finish=clock();printf("%.8lf\n",pai);printf("%.8lfS\n",(double)((finish-start)/CLOCKS_PER_SEC)); return 0;}时间运行如下：第一次：time=0.00837500S第二次：time=0.00741100S第三次：time=0.00772000S三次平均为：0.00783S以下是SSE单精度的代码：#include<stdio.h>#include<x86intrin.h>#include<time.h>#define N 10000000float get_pi_sse(size_t dt){float pi=0.0;float delta =1.0/dt;__m128 xmm0,xmm1,xmm2,xmm3,xmm4;xmm0=_mm_set1_ps(1.0);xmm1=_mm_set1_ps(delta);xmm2=_mm_set_ps(delta*3,delta*2,delta,0.0);xmm4=_mm_setzero_ps();for(long int i=0; i<=dt-4; i+=4){xmm3= _mm_set1_ps((float)i*delta);xmm3= _mm_add_ps(xmm3,xmm2);xmm3= _mm_mul_ps(xmm3,xmm3);xmm3= _mm_add_ps(xmm0,xmm3);xmm3= _mm_div_ps(xmm1,xmm3);xmm4= _mm_add_ps(xmm4,xmm3);}float tmp[4] __attribute__((aligned(16)));_mm_store_ps(tmp,xmm4);pi+=tmp[0]+tmp[1]+tmp[2]+tmp[3];return pi*4.0;}int main(){int dx;float pai;double start,finish;dx=N;start=clock();pai=get_pi_sse(dx);finish=clock();printf("%.8f\n",pai);printf("%.8lfS\n",(double)((finish-start)/CLOCKS_PER_SEC)); return 0;}时间运行如下：第一次：time=0.00406100S第二次：time=0.00426400S第三次：time=0.00437600S三次平均为：0.00423S1.1.3 AVX向量优化版本设计任务：此部分需要给出单精度和双精度两个优化版本注意：（1）测试均在划分度为10的7次方下完成。
多核多线程技术OpenMP_实验报告2
实验二：OpenMP多线程编程模块一：基础练习3 编译执行，执行结果：简答与思考：1 写出关键的并行代码（1）四个线程各自执行6次迭代。
#include"stdafx.h"#include<omp.h>int _tmain(int argc, _TCHAR* argv[]){printf("Hello World \n");#pragma omp parallel{for(int i=0; i<6; i++){printf("Iter:%d Thread%d\n ",i,omp_get_thread_num());}}printf("GoodBye World\n");return 0;}（2）四个线程协同完成6次迭代。
#include"stdafx.h"#include<omp.h>int _tmain(int argc, _TCHAR* argv[]){printf("Hello World \n");#pragma omp parallel{#pragma omp forfor(int i=0; i<6; i++){printf("Iter:%d Thread%d\n ",i,omp_get_thread_num());}}printf("GoodBye World\n");return 0;}2 附加练习：（1）编译执行下面的代码，写出两种可能的执行结果。
int i=0,j = 0;#pragma omp parallel forfor ( i= 2; i < 7; i++ )for ( j= 3; j< 5; j++ )printf(“i = %d, j = %d\n”, i, j);可能的结果:1种2种i=2，j=3 i=2，j=3i=2，j=4 i=2，j=4i=3，j=3 i=3，j=3i=3，j=4 i=3，j=4i=6，j=3 i=5，j=3i=6，j=4 i=5，j=4i=4，j=3 i=5，j=3i=4，j=4 i=5，j=4i=5，j=3 i=6，j=3i=5，j=4 i=6，j=4（2）编译执行下面的代码，写出两种可能的执行结果。
并行程序实验报告
并行程序设计实验报告姓名：学号：一、实验目的通过本次试验，了解使用OpenMP编程的基本方法和MPI的编程方法，通过实践实现的基本程序，掌握基本的线程及进程级并行应用开发技术，能够分析并行性能瓶颈及相应优化方法。
二、实验环境Linux操作系统，mpi库，多核处理器三、实验设计与实现（一）MPI并行程序设计用MPI编写一个greeting程序，编号为0的进程接受其它各进程的“问候”，并在计算机屏幕上显示问候情况。
用MPI编写一个多进程求积分的程序，并通过积分的方法求π的值，结果与π的25位精确值比较。
（二）多线程程序设计用Pthreads或OpenMP编写通过积分的方法求π的程序。
把该程序与相应的MPI程序比较。
用Pthreads或OpenMP编写编写矩阵相乘的程序，观察矩阵增大以及线程个数增减时的情形。
四、实验环境安装（一）MPI环境安装1.安装kylin操作系统的虚拟机（用VirtualBox）2.安装增强功能，使之与windows主机能够文件共享。
3.拷贝mpich-3.0.4.tar.gz到/root/myworkspace/目录下，并解压（tar xzf mpich-3.0.4.tar.gz）4.下面开始安装mkdir /root/myworkspace/mpi./configure --prefix=/root/myworkspace/mpi --disable-f77 --disable-fcmakemake install5.配置环境变量打开/root/.bashrc文件，在文件的末尾加上两行：PATH=$PATH:/root/myworkspace/mpi/binexport PATH保存退出，然后执行命令source /root/.bashrc（二）openMP实验环境安装Visual Studio中修改：项目->属性->c/c++->语言，将“OpenMP支持”改成“是”：五、实验结果及分析（一）MPI并行程序设计实验一：问候发送与接收非零号进程将问候的信息发送给0号进程，0号进程依次接收其它进程发送过来的消息并将其输出。
华科并行实验报告
一、实验模块计算机科学与技术二、实验标题并行计算实验三、实验目的1. 了解并行计算的基本概念和原理；2. 掌握并行编程的基本方法；3. 通过实验加深对并行计算的理解。
四、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 并行计算平台：OpenMP五、实验步骤1. 准备实验环境首先，在计算机上安装OpenMP库，并配置环境变量。
2. 编写并行计算程序编写一个简单的并行计算程序，实现以下功能：（1）计算斐波那契数列的第n项；（2）计算素数的个数；（3）计算矩阵乘法。
以下为斐波那契数列的并行计算程序示例：```cpp#include <omp.h>#include <iostream>using namespace std;int main() {int n = 30;int fib[31] = {0};fib[0] = 0;fib[1] = 1;#pragma omp parallel forfor (int i = 2; i <= n; i++) {fib[i] = fib[i - 1] + fib[i - 2];}cout << "斐波那契数列的第" << n << "项为：" << fib[n] << endl; return 0;}```3. 编译程序使用g++编译器编译程序，并添加OpenMP库支持。
```bashg++ -fopenmp -o fib fib.cpp```4. 运行程序在命令行中运行编译后的程序，观察结果。
5. 分析结果通过对比串行计算和并行计算的结果，分析并行计算的优势。
六、实验过程1. 准备实验环境，安装OpenMP库并配置环境变量；2. 编写并行计算程序，实现斐波那契数列的并行计算；3. 编译程序，并添加OpenMP库支持；4. 运行程序，观察结果；5. 分析结果，对比串行计算和并行计算的性能。
并行程序设计实验报告-OpenMP 进阶实验
实验2：OpenMP 进阶实验1、实验目的掌握生产者-消费者模型，具备运用OpenMP相关知识进行综合分析，可实现实际工程背景下生产者-消费者模型的线程级负责均衡规划和调优。
2、实验要求1）single与master语句制导语句single 和master 都是指定相关的并行区域只由一个线程执行，区别在于使用master 则由主线程（0 号线程）执行，使用single 则由运行时的具体情况决定。
两者还有一个区别是single 在结束处隐含栅栏同步，而master 没有。
在没有特殊需求时，建议使用single 语句。
程序代码见程序2-12）barrier语句在多线程编程中必须考虑到不同的线程对同一个变量进行读写访问引起的数据竞争问题。
如果线程间没有互斥机制，则不同线程对同一变量的访问顺序是不确定的，有可能导致错误的执行结果。
OpenMP中有两种不同类型的线程同步机制，一种是互斥机制，一种是事件同步机制。
其中事件同步机制的设计思路是控制线程的执行顺序，可以通过设置barrier同步路障实现。
3）atomic、critical与锁通过critical 临界区实现的线程同步机制也可以通过原子（atomic）和锁实现。
后两者功能更具特点，并且使用更为灵活。
程序代码见程序2-2、2-3、2-44）schedule语句在使用parallel 语句进行累加计算时是通过编写代码来划分任务，再将划分后的任务分配给不同的线程去执行。
后来使用paralle for 语句实现是基于OpenMP 的自动划分，如果有n 次循环迭代k 个线程，大致会为每一个线程分配[n/k]各迭代。
由于n/k 不一定是整数，所以存在轻微的负载均衡问题。
我们可以通过子句schedule 来对影响负载的调度划分方式进行设置。
5）循环依赖性检查以对π 的数值估计的方法为例子来探讨OpenMP 中的循环依赖问题。
圆周率π（Pi）是数学中最重要和最奇妙的数字之一，对它的计算方法也是多种多样，其中适合采用计算机编程来计算并且精确度较高的方法是通过使用无穷级数来计算π 值。
OpenMP+MPI混合并行编程
H a r b i n I n s t i t u t e o f T e c h n o l o g y并行处理与体系结构实验报告实验题目： OpenMP+MPI混合并行编程院系：计算机科学与技术姓名：学号：实验日期： 2011-12-25哈尔滨工业大学实验四：OpenMP+MPI混合并行编程一、实验目的1、复习前几次实验的并行机制，即OpenMP与MPI编程模式。
2、掌握OpenMP与MPI混合并行编程模式。
二、实验内容1、使用OpenMP+MPI混合编程并与OpenMP、MPI单独编程的比较。
在OpenMp并行编程中，主要针对细粒度的循环级并行，主要是在循环中将每次循环分配给各个线程执行，主要应用在一台独立的计算机上；在MPI并行编程中，采用粗粒度级别的并行，主要针对分布式计算机进行的，他将任务分配给集群中的所有电脑，来达到并行计算；OpenMp+MPI混合编程，多台机器间采用MPI分布式内存并行且每台机器上只分配一个MPI进程，而各台机器又利用OpenMP进行多线程共享内存并行。
2、分析影响程序性能的主要因素。
在采用OpenMP实现的并行程序中，由于程序受到计算机性能的影响，不能大幅度的提高程序运行速度，采用了集群的MPI并行技术，程序被放到多台电脑上运行，多台计算机协同运行并行程序，但是，在集群中的每台计算机执行程序的过程又是一个执行串行程序的过程，因此提出的OpenMP+MPI技术，在集群内采用MPI技术，减少消息传递的次数以提高速度，在集群的每个成员上又采用OpenMP技术，节省内存的开销，这样综合了两种并行的优势，来提升并行程序的执行效率。
三、实验原理OpenMP编程：使用Fork-Join的并行执行模式。
开始时由一个主线程执行程序，该线程一直串行的执行，直到遇到第一个并行化制导语句后才开始并行执行。
含义如下:①Fork：主线程创建一队线程并行执行并行域中的代码；②Join：当各线程执行完毕后被同步或中断，最后又只有主线程在执行。
哈工大软件学院并行程序设计课程实验报告之二
《并行程序设计》课程实验报告实验2：基于Windows Thread和OpenMP的多线程编程姓名*** 院系软件学院学号**********任课教师张伟哲指导教师苏统华实验地点软件学院五楼机房实验时间2015年4月8日实验课表现出勤、表现得分实验报告得分实验总分操作结果得分一、实验目的要求：需分析本次实验的基本目的，并综述你是如何实现这些目的的？一、1．熟练掌握C++语言；。
2、掌握Visual Studio* .NET*集成开发环境的使用；3、掌握Windows32 Thread API开发多线程程序；4、掌握Windows32 Thread API中互斥机制的使用方式二、1．掌握OpenMP的基本功能、构成方式、句法；2、掌握OpenMP体系结构、特点与组成；3、掌握采用OpenMP进行多核架构下多线程编程的基本使用方法和调试方法。
二、实验内容该部分填写在实验过程中，你都完成了哪些工作。
一、1. 定位到文件夹Win32 Threads\ HelloThreads\，用Microsoft Visual studio打开文件HelloThread.sln，编译并运行程序；2. 对main.cpp中函数进行修改，要求输出线程创建顺序（例如：Hello Thread 0, Hello Thread 1, Hello Thread 2 等等）；注意：利用CreateThread()循环变量作为每个线程的执行顺序唯一标识3. 编译并多次运行程序，记录线程执行顺序，分析线程程序执行顺序是否不可预见及其产生原因4. 定位到文件夹Win32 Threads\ Pi\，用Microsoft Visual studio打开文件Pi.sln，编译并运行程序；5. 对此串行代码使用Windows32 Thread API进行线程化，要求4线程实现，且每次迭代计算仅由一个线程完成6. 使用CRITICAL_SECTION机制和Semaphors机制对多线程共享变量进行互斥操作，避免数据竞争。
并行计算实验报告
分析 :这样的加速比 , 是符合预测 , 很好的 . 附 ：（实验 源码 ） 1 pi.cpp #include <cstdio> #include <cstdlib> #include <cstring> #include <cctype> #include <cmath> #include <ctime> #include <cassert>
#include <climits> #include <iostream> #include <iomanip> #include <string> #include <vector> #include <set> #include <map> #include <queue> #include <deque> #include <bitset> #include <algorithm> #include <omp.h> #define MST(a, b) memset(a, b, sizeof(a)) #define REP(i, a) for (int i = 0; i < int(a); i++) #define REPP(i, a, b) for (int i = int(a); i <= int(b); i++) #define NUM_THREADS 4 using namespace std; const int N = 1e6; double sum[N]; int main() { ios :: sync_with_stdio(0); clock_t st, ed; double pi = 0, x; //串行 st = clock(); double step = 1.0 / N; REP(i, N) { x = (i + 0.5) * step; pi += 4.0 / (1.0 + x * x); } pi /= N; ed = clock(); cout << fixed << setprecision(10) << "Pi: " << pi << endl; cout << fixed << setprecision(10) << "串行用时: " << 1.0 * (ed - st) / CLOCKS_PER_SEC << endl; //并行域并行化 pi = 0; omp_set_num_threads(NUM_THREADS); st = clock(); int i; #pragma omp parallel private(i) { double x; int id; id = omp_get_thread_num();
在Linux或Windows环境下配置OpenMP开发运行环境,并利用蒙特卡罗算法计算半径为 1 单元的球体体积。
计算机科学与技术系实验报告课程名称：并行计算及编程实验项目：专业班级：姓名：学号：实验时间：批阅时间：指导教师：成绩：兰州交通大学《并行计算及编程》课程实验报告实验名称：课内综合实验1一、实验目的在Linux或Windows环境下配置OpenMP开发运行环境，并利用蒙特卡罗算法计算半径为1 单元的球体体积。
二、实验内容1. 验证所配置OpenMP并行环境的正确性；2. 分别用串行程序和并行程序实现以上问题的求解；3. 比较并行和串行程序的执行时间，并行计算加速比；4. 提交电子版详细实验报告。
三、实验环境Windows10,下载Visual Studio2019四、实验过程（包括程序设计说明，实验步骤，经调试后正确的源程序，程序运行结果）①实验步骤：下载Visual Studio2019图1用hello world 程序验证在Solution Explorer （解决方案资源管理器）中对项目名右键，选择属性，更改图2进行配置图3配置成功后输出答案②环境配置好后，利用蒙特卡罗算法计算半径为1 单元的球体体积。
/用串行程序实现：经过调试后的正确程序：#include<iostream>#include<stdlib.h>#include<time.h>using namespace std;int main() {long int max = 10000000;long int i, count = 0;double x, y, z, bulk, start_time, end_time;start_time = clock();time_t t;srand((unsigned)time(&t));//函数产生一个以当前时间开始的随机种子for (i = 0; i < max; i++) {x = rand(); //生成0~RAND_MAX之间的一个随机数，其中RAND_MAX 是stdlib.h 中定义的一个整数，它与系统有关。
并行实验报告
实验名称：并行处理技术在图像识别中的应用实验目的：1. 了解并行处理技术的基本原理和应用场景。
2. 掌握并行计算环境搭建和编程技巧。
3. 分析并行处理技术在图像识别任务中的性能提升。
实验时间：2023年10月15日-2023年10月25日实验设备：1. 主机：****************************，16GB RAM2. 显卡：NVIDIA GeForce RTX 2080 Ti3. 操作系统：Windows 10 Professional4. 并行计算软件：OpenMP，MPI实验内容：本实验主要分为三个部分：1. 并行计算环境搭建2. 图像识别任务并行化3. 性能分析和比较一、并行计算环境搭建1. 安装OpenMP和MPI库：首先在主机上安装OpenMP和MPI库，以便在编程过程中调用并行计算功能。
2. 编写并行程序框架：使用C++编写一个并行程序框架，包括并行计算函数和主函数。
3. 编译程序：使用g++编译器编译程序，并添加OpenMP和MPI库的相关编译选项。
二、图像识别任务并行化1. 数据预处理：将原始图像数据转换为适合并行处理的格式，例如将图像分割成多个子图像。
2. 图像识别算法：选择一个图像识别算法，如SVM（支持向量机）或CNN（卷积神经网络），并将其并行化。
3. 并行计算实现：使用OpenMP或MPI库将图像识别算法的各个步骤并行化，例如将图像分割、特征提取、分类等步骤分配给不同的线程或进程。
三、性能分析和比较1. 实验数据：使用一组标准图像数据集进行实验，例如MNIST手写数字识别数据集。
2. 性能指标：比较串行和并行处理在图像识别任务中的运行时间、准确率等性能指标。
3. 结果分析：分析并行处理在图像识别任务中的性能提升，并探讨影响性能的因素。
实验结果：1. 并行处理在图像识别任务中显著提升了运行时间，尤其是在大规模数据集上。
2. 并行处理对准确率的影响较小，甚至略有提升。
并行程序设计实验报告-OpenMP 基础实验
实验1：OpenMP 基础实验1、实验目的1）了解OpenMP的运行环境2）掌握OpenMP编程的基本要素、编译方法，可运用相关知识独立完成一个基本的OpenMP程序的编写与调试过程。
2、实验要求1）掌握OpenMP运行环境在ubuntu环境中打开一个终端界面。
尝试在图形操作界面左侧寻找终端的图标进行点击，或直接使用快捷键Ctrl+Alt+T打开终端界面进行Shell环境。
2）运行一个简单OpenMP程序程序代码见程序1-1、1-23）OpenMP兼容性检查通过检查预处理宏_OPENMP 是否定义来进行条件编译。
如果定义了_OPENMP，则包含omp.h 并调用OpenMP 库函数。
程序代码见程序1-34）常用线程操作库函数语句在OpenMP编程过程中，一旦涉及线程操作，有较大的概率使用三个常用的库函数，分别为：(1) int omp_get_num_threads(void) 获取当前线程组（team）的线程数量，如果不在并行区调用，则返回1。
(2) int omp_get_thread_num(void) 返回当前线程号。
(3) int omp_get_num_procs(void) 返回可用的处理核个数。
注意区别这三个库函数的外形及意义，特别是前两个库函数，初始使用时很容易混淆。
程序代码见程序1-45）parallel语句的练习parallel 用来构造一个并行区域，在这个区域中的代码会被多个线程（线程组）执行，在区域结束处有默认的同步（隐式路障）。
我们可以在parallel 构造区域内使用分支语句，通过omp_get_thread_num 获得的当前线程编号来指定不同线程执行区域内的不同代码。
程序代码见程序1-5、1-66）critical和reducation语句的练习为了保证在多线程执行的程序中，出现资源竞争的时候能得到正确结果，OpenMP 提供了3种不同类型的多线程同步机制：排它锁、原子操作和临界区。
用OpenMP并行化气象预报模式试验
( 并行试验的基本方案
我们在 ) （一种典型的分布共享型并行计算机， 以下简称 $ ） 上进 * #$ + , , ’. / / / . / / / 行了全部的试验测试。分别对浅水波模式 （以下简称 ) 和复杂地形下的嵌套细网 0 模式） 格模式 （以下简称 1 进行了并行化处理， 对模式的详细介绍请参见文献 ［ ］ 与 ［ ］ 。 2 模式） . 3 试验方案如表( ：
表! 并行试验方案
4 " # $ & ’ ! " % ! " # ) 0 模式 5 6 7 8 ( 9 9 试验( 试验. ( 5 3 7 8 3 : 9 7 ; 8 3 : 试验3 试验9 1 2 模式 . 6 3 8 ( 9 7
分别测试了两个模式的两种计算格点量， 即对 ) （ ） 为5 0 模式水平格点数 # 8 < 6 78 ， 。 ( 9 9和( 5 3 7 8 3 : 9 1 2 模式则为7 ; 8 3 :和. 6 3 8 ( 9 7 $ & ’ ! "的并行版本是在充分优化串行模式后的基础上开发的。依据对模式各部分 % 耗时的统计， 我们依次将其并行。在判断不存在数据相关的部分后， 我们可以在粒度 （ ） 较大的循环外加入并行指导语句， 即# ， ， + = ’ > ? = + , @ < B 方向均可分给多个 C " D 运行。 A 下面可通过两个例子来说明： （) CE$! " " 4 F 4 G G H GI $I H J 4 D G K 2 4 F H I） （ ， ， CE$! " L" F # M 4 K H < # N " N） （P： CE$! " LF H I D C K # $ O H ) K） ， I $( . (< Q ( O G 4 R ， I $( . (# Q ( O G $ R （S ） O $ KS B G N " NQN I " # J （B ） （ ， ） # J G N " NQ" # R # < （ ， ） （J （ ） （ ， ） ） ／ M $ F K # < Q * H $ < PM $ F K # < N " N （!$ （!O， ） ） # J I . S O HS / S $ FS !BS O HS / （B （ ， ） （ ， ） ／ LH ) KQH ) KP / S 5 !I ) # * G 4 G 4） !M $ F K # < !M $ F K # < !N " N （ ， ） ） L（" # R # < PI " DPI " T ( . ( C $ O K # O D H 这段程序用来求总的位涡度拟能值 H ) K。$ & ’ ! " 指导语句添加在循环语句的最外 % 层， 程序首先作为一个单进程执行， 碰到 " 包含一个或多个进程的 4 F 4 G G H GI $ 结构时， 过程组就形成了， 同时产生每个组员的数据环境。由于大部分变量是被所有的进程共享
openMP实验总结报告
openMP实验报告目录openMP实验报告 (1)OpenMP简介 (1)实验一 (2)实验二 (4)实验三 (5)实验四 (6)实验五 (9)实验六 (10)实验七 (11)实验八 (13)实验总结 (15)在学习了MPI之后，我们又继续学习了有关openMP的并行运算，通过老师的细致讲解，我们对openMP有了一个初步的了解：OpenMP简介OpenMP是一种用于共享内存并行系统的多线程程序设计的库(Compiler Directive),特别适合于多核CPU上的并行程序开发设计。
它支持的语言包括：C语言、C++、Fortran；不过，用以上这些语言进行程序开发时，并非需要特别关注的地方，因为现如今的大多数编译器已经支持了OpenMP，例如：Sun Compiler,GNU Compiler、Intel Compiler、Visual Studio等等。
程序员在编程时，只需要在特定的源代码片段的前面加入OpenMP专用的#pargma omp预编译指令，就可以“通知”编译器将该段程序自动进行并行化处理，并且在必要的时候加入线程同步及通信机制。
当编译器选择忽略#pargma omp预处理指令时，或者编译器不支持OpenMP时，程序又退化为一般的通用串行程序，此时，代码依然可以正常运作，只是不能利用多线程和多核CPU来加速程序的执行而已。
OpenMP使得程序员可以把更多的精力投入到并行算法本身，而非其具体实现细节。
对基于数据分集的多线程程序设计，它是一个很好的选择。
同时，使用OpenMP也提供了更强的灵活性，可以较容易的适应不同的并行系统配置。
线程粒度和负载平衡等是传统多线程程序设计中的难题，然而，在OpenMP中，OpenMP库从程序员手中接管了部分这两方面的工作，从而使得程序员可以更加专注于具体的算法本身，而非如何编程使得代码在CPU负载平衡和线程粒度方面做出平衡。
但是，作为高层抽象，OpenMP并不适合需要复杂的线程间同步和互斥的场合。
并行程序设计导论实验报告11123508盛骁文
并行程序设计导论实验报告11123508盛骁文用OpenMP进行共享内存编程实验报告 11123508 盛骁文实验一:程序5-1 一个使用OpenMP的”hello world”程序源代码:#include <stdio.h>#include <stdlib.h>#include <omp.h>void Hello(void);int main(int argc,char* argv[]){int thread_count = strtol(argv[1],NULL,10);# pragma omp parallel num_threads(thread_count)Hello();return 0;}void Hello(void){int my_rank = omp_get_thread_num();int thread_count = omp_get_num_threads();printf("Hello from thread %d of %d\n",my_rank,thread_count); }实验运行结果:实验心得:有多个线程运行程序，线程会竞争访问标准输出，因此不保证输出会按线程编号的顺序出现，输出可能是任何其他的线程编号的排列。
实验二:程序5-2 第一个OpenMP梯形积分法程序源代码:#include <stdio.h>#include <stdlib.h>#include <omp.h>void Trap(double a,double b,int n,double* global_result_p);int main(int argc,char* argv[]){double global_result =0.0;double a,b;int n;int thread_count;thread_count = strtol(argv[1],NULL,10);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 = %.14\n,a,b,global_result");return 0;}double f(double x){return 0;}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-1;i++){x = local_a + i*h;my_result += f(x);}my_result = my_result*h;# pragma omp critical*global_result_p += my_result;}实验运行结果:。
基于openMP的并行计算实验
并行计算实验报告课程：并行计算姓名：郑波学号44班级：计算机科学与技术13-2班日期：2015年12月7日实验一：OpenMP基本使用一、实验目的1、熟悉OpenMP编程。
2、比较串行算法与并行算法在执行时间上的差别；3、考察线程数目使用不同对并行算法执行时间的影响；4、考察运算规模N对串、并行算法执行时间上的影响。
二、实验内容1、使用OpenMP进行两个矩阵A和B的加法，并分析串行、并行时间的差别以及问题规模对程序运行时间的影响三、实验步骤1、整个程序的设计流程①全局变量设置三个宏定义过的size×size的二维数组啊a,b,c。
②初始化a数组为全1，b数组为全2③通过omp_set_num_threads()库函数设置线程数④调用openMP库函数omp_get_wtime()获取当前时间start#pragma omp parallel for开始做并行区部分…结束后再次调用omp_get_wtime()获取时间end，end-start即为并行消耗时间⑤再次调用时间函数更新strat串行做一边矩阵相加更新end,end-start即为串行耗时代码如下：#include<iostream>#include<omp.h>#define size 10000using namespace std;int a[size][size],b[size][size],c[size][size];int main(){for(int i=0;i!=size;++i) //initial the matrixfor(int j=0;j!=size;++j){a[i][j]=1;b[i][j]=2;}double start=omp_get_wtime();omp_set_num_threads(4);#pragma omp parallel forfor(int i=0;i<size;++i)for(int j=0;j<size;++j)c[i][j]=a[i][j]+b[i][j];double end=omp_get_wtime();cout<<"并行运行时间："<<end-start<<endl;start=omp_get_wtime();for(int i=0;i<size;++i)for(int j=0;j<size;++j)c[i][j]=a[i][j]+b[i][j];end=omp_get_wtime();cout<<"串行运行时间："<<end-start<<endl;system("pause");}2、问题规模对串、并行程序时间的影响(A、B矩阵的大小为N*M)(1)通过不断增加问题规模，观察串行和并行程序的执行时间，得到如下表格的时间消耗数据：(2)一定程度的时候，并行运行的速度较串行有了提升。
实验1 寻找完数的OpenMP并行程序
深圳大学实验报告课程名称：并行计算实验名称：寻找完数的OpenMP并行程序姓名：学号：班级：软件工程实验日期：2014.11.19一. 实验目的1) 用OpenMP编写基本的并行程序2) 掌握for编译制导语句3) 对并行程序进行简单的性能分析二. 实验环境1) 硬件环境：32核CPU、32G内存计算机；2) 软件环境：Microsoft Visual Studio 2008；3) 登录方式：通过远程桌面(mstsc)连接:804，用户名和初始密码都是自己的学号。
三. 实验内容1) 实验要求：用OpenMP语言编写程序，求小于等于n的所有完数。
程序必须采用原始方法依次判断每个小于等于n的数是否完数，不可利用其他高阶原理。
2) 评分标准：首先要保证程序的运行结果正确，否则不得分，然后主要根据执行时间、加速比和分析来评分。
3)参考函数set<int> FinishedNumber(int n)，完成以下程序中的函数set<int> FinishedNumber(int n, int p)，其中n代表一个整数，p代表线程数，该函数返回小于等于n的所有完数的集合。
#include<iostream>#include<math.h>#include<vector>#include<set>#include<utility>#include<algorithm>#include<time.h>using namespace std;set<int> FinishedNumber(int n){set<int> s;for (int i = 2; i <= n; i++){int maxv = (int)(sqrt(double(i)) + 1);int sum = 1;for (int j = 2; j<maxv; j++)if (i%j == 0)sum += j + i / j;if (sum == i)s.insert(i);}return s;}set<int> FinishedNumber(int n, int p){set<int> s;return s;}int main(){vector<pair<int, int> > vTest;for (int i = 1000000; i <= 5000000; i += 1000000)for (int j = 1; j <= 32; j*=2)vTest.push_back(pair<int, int>(i, j));for (vector<pair<int, int> >::iterator iter = vTest.begin(); iter != vTest.end(); ++iter) {clock_t pt = 0;pt -= clock();set<int> ps = FinishedNumber(iter->first, iter->second);pt += clock();clock_t st = 0;st -= clock();set<int> ss = FinishedNumber(iter->first);st += clock();cout << iter->first << "," << iter->second << ":";/*for (set<int>::iterator iter = ps.begin(); iter != ps.end(); ++iter){cout << " " << *iter;}*/cout << ", execution time: " << pt / 1000.0;cout << ", speedup: " << st*1.0/pt << endl;if (ps != ss){cout << "error!" << endl;}}return 0;}4) 测试并行程序并分析其执行时间和加速比表1 执行时间(秒)表2 加速比。
实验一串匹配OpenMPI并行编程
实验概述【实验目的及要求】本实验的目的是通过练习掌握共享存储并行编程的知识和技巧。
●掌握OpenMP并行程序编写的基本步骤●熟悉OpenMP编程环境和工具的使用●了解OpenMP程序调试和调优的技巧【实验原理】通过对KMP串匹配的串行算法的修改，以及开拓你其并行结构，就可以达到用openMP 并行化串匹配算法来改进匹配的效率，达到高效的目的。
设计的思路为：将长为n的文本串T均匀划分成互不重叠的p段，分布于处理器0到p-1中，且使得相邻的文本段分布在相邻的处理器中，显然每个处理器中局部文本段的长度为n/（最后一个处理器可在其段尾补上其它特殊字符使其长度与其它相同）。
再将长为m的⎡⎤p模式串P和模式串的newnext函数播送到各处理器中。
各处理器使用改进的KMP算法并行地对局部文本段进行匹配，找到所有段内匹配位置。
但是每个局部段（第p-1段除外）段尾m-1字符中的匹配位置必须跨段才能找到。
一个简单易行的办法就是每个处理器（处理器p-1除外）将本局部段的段尾m-1个字符传送给下一处理器，下一处理器接收到前一处理器传来的字符串后，再接合本段的段首m-1个字符构成一长为2(m-1)的段间字符串，对此字符串做匹配，就能找到所有段间匹配位置。
但是算法的通信量很大，采用下述两种改进通信的方法可以大大地降低通信复杂度：①降低播送模式串和newnext函数的通信复杂度。
利用串的周期性质，先对模式串P作预处理，获得其最小周期长度|U|、最小周期个数s及后缀长度|V|（P=U s V），只需播送U，s，|V|和部分newnext函数就可以了，从而大大减少了播送模式串和newnext函数的通信量。
而且串的最小周期和next函数之间的关系存在着下面定理1所示的简单规律，使得能够设计出常数时间复杂度的串周期分析算法。
②降低每个处理器（处理器p-1除外）将本局部文本段的段尾m-1个字符传送给下一处理器的通信复杂度。
每个处理器在其段尾m-1个字符中找到模式串P的最长前缀串，因为每个处理器上都有模式串信息，所以只需传送该最长前缀串的长度就行了。
OpenMP程序的编译与运行-实验报告二
曲阜师范大学实验报告课程名称：并行计算实验名称：OpenMP并行程序的编译和运行姓名：***学号：**********班级：2014级全日制研究生实验日期：2014年10月31一. 实验目的1) 在Linux平台上编译和运行OpenMP程序；2) 在Windows平台上编译和运行OpenMP程序。
二. 实验环境1) 硬件环境：32核CPU、32G内存计算机；2) 软件环境：Linux、Win2003、GCC、MPICH、VS2008；3) Linux登录方式：通过ssh方式（用SecureCRT工具或putty工具，可网上下载）连接曙光集群服务器，用户名：root，密码：********；4) Windows登录方式：在自己机器上运行。
三. 实验内容1. Linux下OpenMP程序的编译和运行。
OpenMP是一个共享存储并行系统上的应用编程接口，支持C/C++和FORTRAN等语言，编译和运行简单的"Hello World"程序。
在Linux下编辑hellomp.c源程序，或在Windows下编辑并通过附件中的FTP工具（端口号：1021）上传，用"gcc -fopenmp -O2 -o hellomp.out hellomp.c"命令编译，用"./hellomp.out"命令运行程序，代码如下：#include <omp.h>#include <stdio.h>int main(){int nthreads,tid;omp_set_num_threads(8);#pragma omp parallel private(nthreads,tid){tid=omp_get_thread_num();printf("Hello World from OMP thread %d\n",tid);if(tid==0){nthreads=omp_get_num_threads();printf("Number of threads is %d\n",nthreads);}}}答：（提供关键的截图和简单的文字描述）（1）先通过putty连接到曙光集群，登录进去，就到了LINUX系统（2）查询hellomp.c文件（3）显示hellomp.c文件内容（4）输入"gcc -fopenmp -O2 -o hellomp.out hellomp.c"命令编译（5）输入"./hellomp.out"命令运行程序得到的结果截图如下：2. Windows下OpenMP程序的编译和运行。
openMP实验总结报告
openMP实验总结报告openMP 实验报告openMP 实验报告目录openMP 实验报告 (1)OpenMP 简介 (1)实验一 (2)实验二 (3)实验三 (5)实验四 (6)实验五 (9)实验六 (10)实验七 (11)实验八 (13)实验总结 (15)在学习了MPI 之后，我们又继续学习了有关openMP 的并行运算，通过老师的细致讲解，我们对openMP 有了一个初步的了解：OpenMP 简介OpenMP 是一种用于共享内存并行系统的多线程程序设计的库(Compiler Directive),特别适合于多核CPU 上的并行程序开发设计。
它支持的语言包括：C 语言、C++、Fortran；不过，用以上这些语言进行程序开发时，并非需要特别关注的地方，因为现如今的大多数编译器已经支持了OpenMP，例如：Sun Compiler,GNU Compiler、Intel Compiler、Visual Studio等等。
程序员在编程时，只需要在特定的源代码片段的前面加入OpenMP 专用的#pargmaomp预编译指令，就可以“通知”编译器将该段程序自动进行并行化处理，并且在必要的时候加入线程同步及通信机制。
当编译器选择忽略#pargmaomp预处理指令时，或者编译器不支持OpenMP 时，程序又退化为一般的通用串行程序，此时，代码依然可以正常运作，只是不能利用多线程和多核openMP 实验报告CPU来加速程序的执行而已。
OpenMP使得程序员可以把更多的精力投入到并行算法本身，而非其具体实现细节。
对基于数据分集的多线程程序设计，它是一个很好的选择。
同时，使用 OpenMP 也提供了更强的灵活性，可以较容易的适应不同的并行系统配置。
线程粒度和负载平衡等是传统多线程程序设计中的难题，然而，在OpenMP 中，OpenMP 库从程序员手中接管了部分这两方面的工作，从而使得程序员可以更加专注于具体的算法本身，而非如何编程使得代码在CPU 负载平衡和线程粒度方面做出平衡。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
并行实验报告一、积分计算圆周率1.1 积分计算圆周率的向量优化1.1.1 串行版本的设计任务：理解积分求圆周率的方法，将其用C代码实现。
注意：理论上，dx越小，求得的圆周率越准确；在计算机中由于表示的数据是有精度范围的，如果dx太小，积分次数过多，误差积累导致结果不准确。
以下为串行代码：#include<stdio.h>#include<time.h>#define N 10000000double get_pi(int dt){double pi=0.0;double delta =1.0/dt;int i;for(i=0; i<dt; i++){double x=(double)i/dt;pi+=delta/(1.0+x*x);}return pi*4;}int main(){int dx;double pai;double start,finish;dx=N;start=clock();pai=get_pi(dx);finish=clock();printf("%.8lf\n",pai);printf("%.8lfS\n",(double)(finish-start)/CLOCKS_PER_SEC); return 0;}时间运行如下：第一次：time=0.02674000S第二次：time=0.02446500S第三次：time=0.02402800S三次平均为：0.02508S1.1.2 SSE向量优化版本设计任务：此部分需要给出单精度和双精度两个优化版本。
注意：（1）测试均在划分度为10的7次方下完成。
以下是SSE双精度的代码：#include<stdio.h>#include<x86intrin.h>#include<time.h>#define N 10000000double get_pi(int dt){double pi=0.0;double delta =1.0/dt;int i;for(i=0; i<dt; i++){double x=(double)i/dt;pi+=delta/(1.0+x*x);}return pi*4;}double get_pi_sse(size_t dt){double pi=0.0;double delta =1.0/dt;__m128d xmm0,xmm1,xmm2,xmm3,xmm4;xmm0=_mm_set1_pd(1.0);xmm1=_mm_set1_pd(delta);xmm2=_mm_set_pd(delta,0.0);xmm4=_mm_setzero_pd();for(long int i=0; i<=dt-2; i+=2){xmm3= _mm_set1_pd((double)i*delta);xmm3= _mm_add_pd(xmm3,xmm2);xmm3= _mm_mul_pd(xmm3,xmm3);xmm3= _mm_add_pd(xmm0,xmm3);xmm3= _mm_div_pd(xmm1,xmm3);xmm4= _mm_add_pd(xmm4,xmm3);}double tmp[2] __attribute__((aligned(16))); _mm_store_pd(tmp,xmm4);pi+=tmp[0]+tmp[1]/*+tmp[2]+tmp[3]*/;return pi*4.0;}int main(){int dx;double pai;double start,finish;dx=N;start=clock();pai=get_pi_sse(dx);finish=clock();printf("%.8lf\n",pai);printf("%.8lfS\n",(double)((finish-start)/CLOCKS_PER_SEC)); return 0;}时间运行如下：第一次：time=0.00837500S第二次：time=0.00741100S第三次：time=0.00772000S三次平均为：0.00783S以下是SSE单精度的代码：#include<stdio.h>#include<x86intrin.h>#include<time.h>#define N 10000000float get_pi_sse(size_t dt){float pi=0.0;float delta =1.0/dt;__m128 xmm0,xmm1,xmm2,xmm3,xmm4;xmm0=_mm_set1_ps(1.0);xmm1=_mm_set1_ps(delta);xmm2=_mm_set_ps(delta*3,delta*2,delta,0.0);xmm4=_mm_setzero_ps();for(long int i=0; i<=dt-4; i+=4){xmm3= _mm_set1_ps((float)i*delta);xmm3= _mm_add_ps(xmm3,xmm2);xmm3= _mm_mul_ps(xmm3,xmm3);xmm3= _mm_add_ps(xmm0,xmm3);xmm3= _mm_div_ps(xmm1,xmm3);xmm4= _mm_add_ps(xmm4,xmm3);}float tmp[4] __attribute__((aligned(16)));_mm_store_ps(tmp,xmm4);pi+=tmp[0]+tmp[1]+tmp[2]+tmp[3];return pi*4.0;}int main(){int dx;float pai;double start,finish;dx=N;start=clock();pai=get_pi_sse(dx);finish=clock();printf("%.8f\n",pai);printf("%.8lfS\n",(double)((finish-start)/CLOCKS_PER_SEC)); return 0;}时间运行如下：第一次：time=0.00406100S第二次：time=0.00426400S第三次：time=0.00437600S三次平均为：0.00423S1.1.3 A VX向量优化版本设计任务：此部分需要给出单精度和双精度两个优化版本注意：（1）测试均在划分度为10的7次方下完成。
（2）在编译时需要加-mavx 编译选项，才能启用AVX指令集，否则默认SSE指令集（3）理论上，向量版本对比SSE版本和串行版本有明显加速，单精度版本速度明显优于双精度，速度接近双精度的两倍。
以下是AVX双精度的代码：#include<stdio.h>#include<x86intrin.h>#include<time.h>#define N 10000000/*double get_pi(int dt){double pi=0.0;double delta =1.0/dt;int i;for(i=0; i<dt; i++){double x=(double)i/dt;pi+=delta/(1.0+x*x);}return pi*4;}*/double get_pi_avx(size_t dt){double pi=0.0;double delta =1.0/dt;__m256d ymm0,ymm1,ymm2,ymm3,ymm4;ymm0=_mm256_set1_pd(1.0);ymm1=_mm256_set1_pd(delta);ymm2=_mm256_set_pd(delta*3,delta*2,delta,0.0);ymm4=_mm256_setzero_pd();for(long int i=0; i<=dt-4; i+=4){ymm3= _mm256_set1_pd((double)i*delta);ymm3= _mm256_add_pd(ymm3,ymm2);ymm3= _mm256_mul_pd(ymm3,ymm3);ymm3= _mm256_add_pd(ymm0,ymm3);ymm3= _mm256_div_pd(ymm1,ymm3);ymm4= _mm256_add_pd(ymm4,ymm3);}double tmp[4] __attribute__((aligned(32)));_mm256_store_pd(tmp,ymm4);pi+=tmp[0]+tmp[1]+tmp[2]+tmp[3];return pi*4.0;}int main(){int dx;double pai;double start,finish;dx=N;start=clock();pai=get_pi_avx(dx);finish=clock();printf("%.8lf\n",pai);printf("%.8lfS\n",(double)((finish-start)/CLOCKS_PER_SEC)); return 0;}时间运行如下：第一次：time=0.00720200S第二次：time=0.00659800S第三次：time=0.00670600S三次平均为：0.00683S以下是AVX单精度的代码：时间运行如下：第一次：time=0.00234200S第二次：time=0.00234200S第三次：time=0.00230000S三次平均为：0.002328S由以上实验统计得出结论：AVX-float=0.002328 SAVX-double=0.00683 SSSE-float=0.00423 SSSE-double= 0.00783 S基本符合规律：（以下为速度比较）AVX-float > AVX-double ≈SSE-float > SSE-double > serial1.2 积分计算圆周率的OpenMP优化1.2.1 OpenMP并行化任务：在串行代码的基础上进行OpenMP并行优化注意：测试在划分度为10的9次方下完成。
参考代码：#include<stdio.h>#include<omp.h>#define N 1000000000double get_pi(int dt){double pi=0.0;double delta =1.0/dt;int i;#pragma omp parallel for reduction(+:pi) for(i=0; i<dt; i++){double x=(double)i/dt;pi+=delta/(1.0+x*x);}return pi*4;}int main(){int dx;double pai;//double start,finish;dx=N;double start=omp_get_wtime();pai=get_pi(dx);double finish=omp_get_wtime();printf("%.8lf\n",pai);printf("%lf\n",finish-start);return 0;}运行结果如下图：串行结果如下：提速十分明显。