一、实验目的与实验要求
1、实验目的
（1）学会将串行程序改为并行程序。
(2)学会mpich2的使用。
(3)学会openmp的配置。
（4）mpi与openmp之间的比较。
2、实验要求
（1）将串行冒泡程序局部并行化，以降低时间消耗。
(2) 理论上求出时间复杂度之比，根据结果得出时间消耗之比，进行比对分析。
二、实验设备（环境）及要求
Vs2013，mpich2
三、实验内容与步骤
1、实验一 mpi并行
（1）实验内容
1、写出一个冒泡排序程序，求出其时间复杂度，并运行得到相应的时间消耗。
2、将冒泡程序改为mpi并行程序：将全部需要排序的数分成4等份，分给四个进程一起冒泡，最后将所得的结果归到一个进程，进行归并排序，得到结果，得到时间消耗。算出时间复杂度。
3、对得出的结果进行讨论与分析。
（2）主要步骤
1、串行冒泡程序
时间复杂度：取所要排序的数的个数为n个，时间复杂度为n*n/2。
代码实现：
// maopao.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "stdlib.h"
#include"time.h"
const int ARRAY_SIZE = 120000;
int main(int argc, char* argv[])
{
int zongshu[ARRAY_SIZE];
srand(10086);
time_t now_time, end_time;
for (int i = 0; i < ARRAY_SIZE; i++){
zongshu[i]=rand();
}
now_time = time(NULL);
for (int i = 0; i < ARRAY_SIZE; i++)
{
for (int j = ARRAY_SIZE - 1; j > i; j--)
{
if (zongshu[j] <= zongshu[j - 1])
{
int z = zongshu[j - 1];
zongshu[j - 1] = zongshu[j];
zongshu[j] = z;
}
}
}
end_time = time(NULL);
long shijian = end_time - now_time;
for (int i = 0; i <ARRAY_SIZE; i++){
printf("%d ", zongshu[i]);
}
printf("所用时间：%ld",shijian);
while (true);
}
2、并行程序
时间复杂度：取所要排序的数的个数为n个，进程数为m个。时间复杂度：(（n/m）*(n/m)/2)+n+4*n。
代码实现：
// MPITest.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "mpi.h"
#include <stdio.h>
#include <math.h>
#include "stdlib.h"
#define SIZE 4//进程数
const int ARRAY_SIZE = 30000;//每个进程分配的个数
int shuzu[SIZE][ARRAY_SIZE];
int zonghanshu[SIZE][ARRAY_SIZE];
double endwtime;
void Scatter_1(int);
int main(int argc, char *argv[]){
int myid;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
Scatter_1(myid);
MPI_Finalize();
}
void Scatter_1(int myid){
int numtasks;
srand(10086);
for (int i = 0; i < SIZE; i++){
for (int j = 0; j < ARRAY_SIZE; j++){
shuzu[i][j] = rand();
}
}
//随机生成数组
int xiaopaixu[ARRAY_SIZE];
double startwtime = MPI_Wtime();
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
if (numtasks == SIZE){
MPI_Scatter(shuzu, ARRAY_SIZE, MPI_INT, xiaopaixu, ARRAY_SIZE, MPI_INT, 0, MPI_COMM_WORLD);
for (int i = 0; i <ARRAY_SIZE; i++){
for (int j = ARRAY_SIZE - 1; j > i; j--){
if (xiaopaixu[j] <= xiaopaixu[j - 1]){
int z = xiaopaixu[j - 1];
xiaopaixu[j - 1] = xiaopaixu[j];
xiaopaixu[j] = z;
}
}
}//每个进程里的冒泡排序
MPI_Gather(xiaopaixu, ARRAY_SIZE, MPI_INT, zonghanshu, ARRAY_SIZE, MPI_INT, 0, MPI_COMM_WORLD);
int time[SIZE];
for (int i = 0; i < SIZE; i++){
time[i] = 0;
}
int a[SIZE];
int zongpaixu2[ARRAY_SIZE*SIZE];
for (int j = ARRAY_SIZE*SIZE - 1; j >= 0; j--){
for (int k = 0; k < SIZE; k++){
if (time[k] >= ARRAY_SIZE){
a[k] = 0;
}
else
{
a[k] = zonghanshu[k][ARRAY_SIZE - time[k] - 1];
}
}
int x = a[0];
for (int i = 1; i<SIZE; i++){
if (a[i]>x){
x = a[i];
}
}
for (int n = 0; n < SIZE; n++){
if (x == a[n]){
time[n] = time[n] + 1;
break;
}
}
zongpaixu2[j] = x;
}
endwtime = MPI_Wtime();
if (myid);
else
for (int i = 0; i < SIZE*ARRAY_SIZE; i++){
printf("%d ", zongpaixu2[i]);
}
}
if (myid);
else
printf("wall clock time=% f\n", endwtime - startwtime);
}
2、实验2
在实验一的基础上将程序改为openmp。
代码实现：（水平不高，写的程序通用性不好，只写了四线程的）
// Openmp.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#include "stdlib.h"
#include"time.h"
#include <omp.h>
#define SIZE 4
const int ARRAY_SIZE = 12000;
int shuzu[SIZE][ARRAY_SIZE];
int xiaopaixu1[ARRAY_SIZE];
int xiaopaixu2[ARRAY_SIZE];
int xiaopaixu3[ARRAY_SIZE];
int xiaopaixu4[ARRAY_SIZE];
int zonghanshu[SIZE][ARRAY_SIZE];
int zongpaixu[ARRAY_SIZE*SIZE];
void xiaohansu(int *A, int l, int u){
for (int i = l; i <u; i++){
for (int j = u - 1; j > i; j--){
if (A[j] <= A[j - 1]){
int z = A[j - 1];
A[j - 1] = A[j];
A[j] = z;
}
}
}
}
//每个线程排序
int main(int argc, char* argv[])
{
int t1, t2;
int i;
int id;
clock_t now_time, end_time;
srand(10086);
for (int i = 0; i < SIZE; i++){
for (int j = 0; j < ARRAY_SIZE; j++){
shuzu[i][j] = rand();
}
}
//随机生成数组
now_time = clock();
#pragma omp parallel default(none) shared(shuzu,xiaopaixu1,xiaopaixu2,xiaopaixu3,xiaopaixu4,ARRAY_SIZE) private(i)
{
#pragma omp for
for (i = 0; i < ARRAY_SIZE; i++)//这个for循环是并行的,将数组分为四份
{
xiaopaixu1[i] = shuzu[0][i];
xiaopaixu2[i] = shuzu[1][i];
xiaopaixu3[i] = shuzu[2][i];
xiaopaixu4[i] = shuzu[3][i];
}
}
#pragma omp parallel default(none) shared(xiaopaixu1,xiaopaixu2,xiaopaixu3,xiaopaixu4,ARRAY_SIZE)
{
#pragma omp parallel sections
{
#pragma omp section
xiaohansu(xiaopaixu1, 0, ARRAY_SIZE-1);//排序
#pragma omp section
xiaohansu(xiaopaixu2, 0, ARRAY_SIZE);
#pragma omp section
xiaohansu(xiaopaixu3, 0, ARRAY_SIZE);
#pragma omp section
xiaohansu(xiaopaixu4, 0, ARRAY_SIZE);
}
}
for (i = 0; i < ARRAY_SIZE; i++)//合到一份
{
zonghanshu[0][i]=xiaopaixu1[i];
zonghanshu[1][i]=xiaopaixu2[i];
zonghanshu[2][i]=xiaopaixu3[i];
zonghanshu[3][i]=xiaopaixu4[i];
}
int time[SIZE];
for (int i = 0; i < SIZE; i++){
time[i] = 0;
}
int a[SIZE];
for (int j = ARRAY_SIZE*SIZE - 1; j >= 0; j--){
for (int k = 0; k < SIZE; k++){
if (time[k] >= ARRAY_SIZE){
a[k] = 0;
}
else
{
a[k] = zonghanshu[k][ARRAY_SIZE - time[k] - 1];
}
}
int x = a[0];
for (int i = 1; i<SIZE; i++){
if (a[i]>x){
x = a[i];
}
}
for (int n = 0; n < SIZE; n++){
if (x == a[n]){
time[n] = time[n] + 1;
break;
}
}
zongpaixu[j] = x;
}
//归并
end_time = clock();
double shijian = end_time - now_time;
for (int i = 0; i <SIZE*ARRAY_SIZE; i++){
printf("%d ", zongpaixu[i]);
}
printf("所用时间：%lf", shijian / CLK_TCK);
while (true);
}
四：实验结果与分析
Mpi:
串行
Mpi
|
|
1.2万 |
2.4万 |
3.6万 |
4.8万 |
6.0万 |
7.2万 |
|
串行（秒） |
0.441 |
1.766 |
3.951 |
6.877 |
10.469 |
14.687 |
|
6线（秒） |
0.029 |
0.108 |
0.242 |
0.435 |
0.656 |
0.940 |
|
4线（秒） |
0.035 |
0.151 |
0.339 |
0.615 |
0.969 |
1.409 |
|
2线（秒） |
0.119 |
0.502 |
1.108 |
2.040 |
3.121 |
4.516 |
从表中可以看出4线程的时候，并行程序的速度是串行程序速度的十倍之多，而理论上大概8倍。这就跟改的程序有关。在并行程序中，最后采用的是归并，由此，发生了这些奇妙的情况：实则本身的算法就比冒泡优一些，但又不能只采用冒泡算法，那样在最后又来个冒泡，其程序就没有意义了。
Openmp：
这是4.8万个数排序的结果，可以看出用了2.876秒，比MPI慢了四倍之多，这可能是程序的不合理，带来了多余的时间消耗（通信）。但比串行还是要快很多。
五：结论（讨论）
1、实验结论
1、就这冒泡排序改为并行的，虽然时间缩短了很多倍，但与快排等排序算法并行相比，其速度又不堪入目。
2、就冒泡排序而言，其mpi并行远远优于openmp（就我写的程序而言。。。），虽然最后都用了并归。
2、讨论
1、这些程序都实现在一台电脑上完成的，还未试过与其他电脑通信，所以其所表现出来的结果并不完全按正确，毕竟并行计算涉及到不同主机之间的通信。
2、由于个人编程能力不高，在这里只讨论了一些时间上的差异，并未对空间上进行比对（不会。。。）。
3、就openmp程序而言，应该还可以改写，增加其通用性和减少通信。