zeus
4 years ago
26 changed files with 1635 additions and 1 deletions
@ -1,2 +1,103 @@ |
|||
# hybrid-mpi |
|||
# hybri-mpi ! |
|||
|
|||
Instances of Ubuntu Linux with [MPICH](https://www.mpich.org) -- portable implementation of Message Passing Interface (MPI) standard. Designed for MPI program development and deployment. |
|||
|
|||
## LabInstance mpi2 |
|||
|
|||
|
|||
 |
|||
|
|||
|
|||
|
|||
## Quickstart |
|||
|
|||
This is a quickstart guide of howto use this *LabInstance to deploy MPI programs* |
|||
|
|||
### HowTo use it |
|||
|
|||
|
|||
### Default Configuration |
|||
|
|||
- Working Directory |
|||
|
|||
> /project |
|||
|
|||
- Default user |
|||
|
|||
> docker |
|||
|
|||
- Default password |
|||
|
|||
> docker |
|||
|
|||
- Default password4root |
|||
|
|||
> pass |
|||
|
|||
|
|||
#### Find lab workers |
|||
|
|||
|
|||
> ifconfig |
|||
> |
|||
> nmap -sP 172.130.0.0/24 |
|||
> |
|||
|
|||
|
|||
#### connect to workers |
|||
|
|||
```bash |
|||
ssh docker@[IP] |
|||
``` |
|||
|
|||
|
|||
|
|||
#### Compile |
|||
|
|||
> mpicc -o /home/ubuntu/mpi_hello_world examples/mpi_hello_world.c |
|||
|
|||
#### run the MPI hello world program |
|||
|
|||
> mpirun -n 10 -f /home/ubuntu/hosts /home/ubuntu/mpi_hello_world |
|||
|
|||
|
|||
--- |
|||
**NOTE:** copy hello world to all clients |
|||
|
|||
```bash |
|||
# scp hello wrold to all clients. sudo -u mpi for auto scp connect. see /home/mpi/.ssh |
|||
while read -r line; |
|||
do |
|||
scp /home/ubuntu/mpi_hello_world ubuntu@$line:/home/ubuntu/mpi_hello_world |
|||
done < /home/ubuntu/hosts |
|||
``` |
|||
--- |
|||
|
|||
|
|||
#### Publish Your Work |
|||
|
|||
|
|||
```bash |
|||
|
|||
mkdir /home/ubuntu/directory |
|||
put your files and other directories into /home/ubuntu/directory |
|||
swarmlab-publish /home/ubuntu/directory |
|||
open URL in Browser |
|||
|
|||
``` |
|||
|
|||
|
|||
--- |
|||
**MORE INFO** |
|||
|
|||
See examples directory |
|||
```bash |
|||
|
|||
cd examples |
|||
make mpi_hello_world |
|||
make example ex=squares |
|||
... |
|||
|
|||
``` |
|||
--- |
|||
|
|||
|
|||
|
After Width: | Height: | Size: 80 KiB |
@ -0,0 +1,37 @@ |
|||
DIRhosts=/home/ubuntu/hosts |
|||
DIR=/home/ubuntu |
|||
options=-env I_MPI_DEBUG=3 |
|||
number=10 |
|||
|
|||
ex= |
|||
|
|||
all: mpi_hello_world example |
|||
.PHONY: all |
|||
|
|||
mpi_hello_world: |
|||
@swarmlab-getworkers > $(DIRhosts) ;\
|
|||
mpicc ./mpi_hello_world.c -o $(DIR)/mpi_hello_world ;\
|
|||
while read line; do\
|
|||
echo "scp $(DIR)/mpi_hello_world ubuntu@$$line:$(DIR)/mpi_hello_world " ;\
|
|||
scp $(DIR)/mpi_hello_world ubuntu@$$line:$(DIR)/mpi_hello_world ;\
|
|||
echo "$$line" ;\
|
|||
done < $(DIRhosts);\
|
|||
echo "mpirun $(options) -wdir=$(DIR) -n $(number) -f $(DIRhosts) $(DIR)/mpi_hello_world" ; \
|
|||
mpirun $(options) -wdir=$(DIR) -n $(number) -f $(DIRhosts) $(DIR)/mpi_hello_world |
|||
|
|||
example: |
|||
@if [ ! -z $(ex) ]; then\
|
|||
swarmlab-getworkers > $(DIRhosts) ;\
|
|||
mpicc ./$(ex).c -o $(DIR)/$(ex) ;\
|
|||
while read line; do\
|
|||
echo "scp $(DIR)/$(ex) ubuntu@$$line:$(DIR)/$(ex) " ;\
|
|||
scp $(DIR)/$(ex) ubuntu@$$line:$(DIR)/$(ex) ;\
|
|||
echo "$$line" ;\
|
|||
done < $(DIRhosts);\
|
|||
echo "mpirun $(options) -wdir=$(DIR) -n $(number) -f $(DIRhosts) $(DIR)/$(ex)" ; \
|
|||
mpirun $(options) -wdir=$(DIR) -n $(number) -f $(DIRhosts) $(DIR)/$(ex) ; \
|
|||
else\
|
|||
echo "usage: make example ex=source file" ; \
|
|||
echo "e.g.: make example ex=mv" ; \
|
|||
fi\
|
|||
|
|||
@ -0,0 +1,51 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
|
|||
main(int argc, char** argv) |
|||
{ |
|||
int my_rank; |
|||
int p, k; |
|||
int root; |
|||
int a1_local; |
|||
int a2_local; |
|||
int local_num; |
|||
int endnum; |
|||
int local_res; |
|||
int final_res; |
|||
int namelen; |
|||
char proc_name[MPI_MAX_PROCESSOR_NAME]; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &p); |
|||
MPI_Get_processor_name(proc_name, &namelen); |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("Dose plithos arithmvn:\n"); |
|||
scanf("%d", &endnum); |
|||
} |
|||
|
|||
root = 0; |
|||
MPI_Bcast(&endnum, 1, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
local_res = 0; |
|||
local_num = endnum/p; |
|||
a1_local = (my_rank * local_num) + 1; |
|||
a2_local = a1_local + local_num - 1; |
|||
for (k=a1_local; k<=a2_local; k++) |
|||
local_res = local_res + (k*k); |
|||
printf("\n Process %d on %s : local result = %d \n", my_rank, proc_name, local_res); |
|||
|
|||
root = 0; |
|||
MPI_Reduce(&local_res, &final_res, 1, MPI_INT, MPI_SUM, root, MPI_COMM_WORLD); |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("\n Total result for N = %d is equal to : %d \n", endnum, final_res); |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,56 @@ |
|||
#include "mpi.h" |
|||
#include <stdio.h> |
|||
#define SIZE 16 |
|||
#define UP 0 |
|||
#define DOWN 1 |
|||
#define LEFT 2 |
|||
#define RIGHT 3 |
|||
|
|||
int main(argc,argv) |
|||
int argc; |
|||
char *argv[]; { |
|||
int numtasks, rank, source, dest, outbuf, i, tag=1, |
|||
inbuf[4]={MPI_PROC_NULL,MPI_PROC_NULL,MPI_PROC_NULL,MPI_PROC_NULL,}, |
|||
nbrs[4], dims[2]={4,4}, |
|||
periods[2]={0,0}, reorder=0, coords[2]; |
|||
|
|||
MPI_Request reqs[8]; |
|||
MPI_Status stats[8]; |
|||
MPI_Comm cartcomm; |
|||
|
|||
MPI_Init(&argc,&argv); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &numtasks); |
|||
|
|||
if (numtasks == SIZE) { |
|||
MPI_Cart_create(MPI_COMM_WORLD, 2, dims, periods, reorder, &cartcomm); |
|||
MPI_Comm_rank(cartcomm, &rank); |
|||
MPI_Cart_coords(cartcomm, rank, 2, coords); |
|||
MPI_Cart_shift(cartcomm, 0, 1, &nbrs[UP], &nbrs[DOWN]); |
|||
MPI_Cart_shift(cartcomm, 1, 1, &nbrs[LEFT], &nbrs[RIGHT]); |
|||
|
|||
outbuf = rank; |
|||
|
|||
for (i=0; i<4; i++) { |
|||
dest = nbrs[i]; |
|||
source = nbrs[i]; |
|||
MPI_Isend(&outbuf, 1, MPI_INT, dest, tag, |
|||
MPI_COMM_WORLD, &reqs[i]); |
|||
MPI_Irecv(&inbuf[i], 1, MPI_INT, source, tag, |
|||
MPI_COMM_WORLD, &reqs[i+4]); |
|||
} |
|||
|
|||
MPI_Waitall(8, reqs, stats); |
|||
|
|||
printf("rank= %d coords= %d %d neighbors(u,d,l,r)= %d %d %d %d\n", |
|||
rank,coords[0],coords[1],nbrs[UP],nbrs[DOWN],nbrs[LEFT], |
|||
nbrs[RIGHT]); |
|||
printf("rank= %d inbuf(u,d,l,r)= %d %d %d %d\n", |
|||
rank,inbuf[UP],inbuf[DOWN],inbuf[LEFT],inbuf[RIGHT]); |
|||
} |
|||
else |
|||
printf("Must specify %d processors. Terminating.\n",SIZE); |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,69 @@ |
|||
#include "mpi.h" |
|||
#include <stdio.h> |
|||
#include <math.h> |
|||
|
|||
double f( double ); |
|||
|
|||
double f( double a) |
|||
{ |
|||
return (4.0 / (1.0 + a*a)); |
|||
} |
|||
|
|||
int main( int argc, char *argv[] ) |
|||
{ |
|||
int done = 0, n, myid, numprocs, i; |
|||
double PI25DT = 3.141592653589793238462643; |
|||
double mypi, pi, h, sum, x; |
|||
double startwtime=0.0, endwtime; |
|||
int namelen; |
|||
char processor_name[MPI_MAX_PROCESSOR_NAME]; |
|||
|
|||
MPI_Init(&argc,&argv); |
|||
MPI_Comm_size(MPI_COMM_WORLD,&numprocs); |
|||
MPI_Comm_rank(MPI_COMM_WORLD,&myid); |
|||
MPI_Get_processor_name(processor_name,&namelen); |
|||
|
|||
fprintf(stderr,"Process %d on %s\n", |
|||
myid, processor_name); |
|||
|
|||
while (!done) |
|||
{ |
|||
if (myid == 0) |
|||
{ |
|||
printf("Enter the number of intervals (0 quits):\n"); |
|||
scanf("%d",&n); |
|||
|
|||
startwtime = MPI_Wtime(); |
|||
} |
|||
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD); |
|||
if (n == 0) |
|||
done = 1; |
|||
else |
|||
{ |
|||
h = 1.0 / (double) n; |
|||
sum = 0.0; |
|||
for (i = myid + 1; i <= n; i += numprocs) |
|||
{ |
|||
x = h * ((double)i - 0.5); |
|||
sum += f(x); |
|||
} |
|||
mypi = h * sum; |
|||
|
|||
MPI_Reduce(&mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); |
|||
|
|||
if (myid == 0) |
|||
{ |
|||
printf("pi is approximately %.16f, Error is %.16f\n", |
|||
pi, fabs(pi - PI25DT)); |
|||
endwtime = MPI_Wtime(); |
|||
printf("wall clock time = %f\n", |
|||
endwtime-startwtime); |
|||
} |
|||
} |
|||
} |
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
@ -0,0 +1,59 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
|
|||
main(int argc, char** argv) |
|||
{ |
|||
int my_rank; |
|||
int p, k, count; |
|||
int root; |
|||
int a1_local; |
|||
int a2_local; |
|||
int local_num; |
|||
int endnum; |
|||
int local_res[50]; |
|||
int final_res[50]; |
|||
int namelen; |
|||
char proc_name[MPI_MAX_PROCESSOR_NAME]; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &p); |
|||
MPI_Get_processor_name(proc_name, &namelen); |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("Dose plithos arithmvn:\n"); |
|||
scanf("%d", &endnum); |
|||
} |
|||
|
|||
root = 0; |
|||
MPI_Bcast(&endnum, 1, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
local_num = endnum/p; |
|||
a1_local = (my_rank * local_num) + 1; |
|||
a2_local = a1_local + local_num - 1; |
|||
count=0; |
|||
for (k=a1_local; k<=a2_local; k++) |
|||
{ |
|||
local_res[count] = (k*k); |
|||
count++; |
|||
} |
|||
printf("\n Process %d on %s : local squares are : ", my_rank, proc_name); |
|||
for (k=0; k<local_num; k++) printf("%d ", local_res[k]); |
|||
printf("\n\n"); |
|||
|
|||
root = 0; |
|||
MPI_Gather(local_res, local_num, MPI_INT, final_res, local_num, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("\n The %d squares are the following: ", endnum); |
|||
for (k=0; k<endnum; k++) printf("%d ",final_res[k]); |
|||
printf("\n\n"); |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,121 @@ |
|||
/*******************************************************************
|
|||
* |
|||
* A similar example that uses MPI_Scatterv and MPI_Gatherv |
|||
* |
|||
* The program should be run with exactly 8 processes. |
|||
* Process 0 initializes a matrix (x) of 8 by 8 integers and distributes |
|||
* the lower triangular part of the matrix to the processes using |
|||
* MPI_Scatterv. The processes receive different number of elements: |
|||
* process 0 gets one element, process 1 gets 2 elements and process i |
|||
* gets i+1 elements. The elements of all processes are then gathered |
|||
* (using MPI_Gatherv) again in another 8 by 8 matrix (res) of process 0 |
|||
* (which is initialized with zeros) in triangular shape. |
|||
* |
|||
* ********************************************************************/ |
|||
|
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include "mpi.h" |
|||
#define MAXPROC 8 /* Max number of procsses */ |
|||
#define LENGTH 8 /* Size of matrix is LENGTH * LENGTH */ |
|||
|
|||
main(int argc, char* argv[]) { |
|||
int i, j, np, me; |
|||
const int root = 0; /* Root process in scatter */ |
|||
|
|||
int x[LENGTH][LENGTH]; /* Send buffer */ |
|||
int y[LENGTH]; /* Receive buffer */ |
|||
int res[LENGTH][LENGTH]; /* Final receive buffer */ |
|||
|
|||
int *sendcount, *recvcount; /* Arrays for sendcounts and recvcounts */ |
|||
int *displs1, *displs2; /* Arrays for displacements */ |
|||
|
|||
MPI_Init(&argc, &argv); /* Initialize MPI */ |
|||
MPI_Comm_size(MPI_COMM_WORLD, &np); /* Get nr of processes */ |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &me); /* Get own identifier */ |
|||
|
|||
/* Check that we have one process for each row in the matrix */ |
|||
if (np != LENGTH) { |
|||
if (me == 0) { |
|||
printf("You have to use %d processes\n", LENGTH); |
|||
} |
|||
MPI_Finalize(); |
|||
exit(0); |
|||
} |
|||
|
|||
/* Allocate memory for the sendcount and displacements arrays */ |
|||
sendcount = (int *)malloc(LENGTH*sizeof(int)); |
|||
displs1 = (int *)malloc(LENGTH*sizeof(int)); |
|||
|
|||
/* Initialize sendcount and displacements arrays */ |
|||
for (i=0; i<LENGTH; i++) { |
|||
sendcount[i] = i+1; |
|||
displs1[i] = i*LENGTH; |
|||
} |
|||
|
|||
if (me == 0) { /* Process 0 does this */ |
|||
/* Initialize the matrix x with values 0 .. LENGTH*LENGTH-1 */ |
|||
for (i=0; i<LENGTH; i++) { |
|||
for (j=0; j<LENGTH; j++) { |
|||
x[i][j] = i*LENGTH+j; |
|||
} |
|||
} |
|||
/* Print out the matrix before it is distributed */ |
|||
printf("The initial matrix is\n"); |
|||
for (i=0; i<LENGTH; i++) { |
|||
for (j=0; j<LENGTH; j++) { |
|||
printf("%4d ", x[i][j]); |
|||
} |
|||
printf("\n"); |
|||
} |
|||
} |
|||
|
|||
/* Scatter the lower triangular part of array x to all proceses, place it in y */ |
|||
MPI_Scatterv(&x, sendcount, displs1, MPI_INT, &y, sendcount[me], MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
if (me==0) { |
|||
/* Initialize the result matrix res with values 0 */ |
|||
for (i=0; i<LENGTH; i++) { |
|||
for (j=0; j<LENGTH; j++) { |
|||
res[i][j] = 0; |
|||
} |
|||
} |
|||
/* Print out the result matrix res before gathering */ |
|||
printf("The result matrix before gathering is\n"); |
|||
for (i=0; i<LENGTH; i++) { |
|||
for (j=0; j<LENGTH; j++) { |
|||
printf("%4d ", res[i][j]); |
|||
} |
|||
printf("\n"); |
|||
} |
|||
} |
|||
|
|||
/* Allocate memory for the recvcount and displacements arrays */ |
|||
recvcount = (int *)malloc(LENGTH*sizeof(int)); |
|||
displs2 = (int *)malloc(LENGTH*sizeof(int)); |
|||
|
|||
for (i=0; i<LENGTH; i++) { |
|||
recvcount[i] = i+1; |
|||
displs2[i] = i*LENGTH; |
|||
} |
|||
|
|||
/* Gather the local elements of each process to form a triangular matrix in the root */ |
|||
MPI_Gatherv(&y, recvcount[me], MPI_INT, &res, recvcount, displs2, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
if (me == 0) { /* Process 0 does this */ |
|||
/* Print out the result matrix after gathering */ |
|||
printf("The result matrix after gathering is\n"); |
|||
for (i=0; i<LENGTH; i++) { |
|||
for (j=0; j<LENGTH; j++) { |
|||
printf("%4d ", res[i][j]); |
|||
} |
|||
printf("\n"); |
|||
} |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
@ -0,0 +1,45 @@ |
|||
#include "mpi.h" |
|||
#include <stdio.h> |
|||
#define NPROCS 8 |
|||
|
|||
int main(argc,argv) |
|||
int argc; |
|||
char *argv[]; { |
|||
int rank, new_rank, sendbuf, recvbuf, numtasks, |
|||
ranks1[4]={0,1,2,3}, ranks2[4]={4,5,6,7}; |
|||
MPI_Group orig_group, new_group; |
|||
MPI_Comm new_comm; |
|||
|
|||
MPI_Init(&argc,&argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &numtasks); |
|||
|
|||
if (numtasks != NPROCS) { |
|||
printf("Must specify MP_PROCS= %d. Terminating.\n",NPROCS); |
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
sendbuf = rank; |
|||
|
|||
/* Extract the original group handle */ |
|||
MPI_Comm_group(MPI_COMM_WORLD, &orig_group); |
|||
|
|||
/* Divide tasks into two distinct groups based upon rank */ |
|||
if (rank < NPROCS/2) { |
|||
MPI_Group_incl(orig_group, NPROCS/2, ranks1, &new_group); |
|||
} |
|||
else { |
|||
MPI_Group_incl(orig_group, NPROCS/2, ranks2, &new_group); |
|||
} |
|||
|
|||
/* Create new new communicator and then perform collective communications */ |
|||
MPI_Comm_create(MPI_COMM_WORLD, new_group, &new_comm); |
|||
MPI_Allreduce(&sendbuf, &recvbuf, 1, MPI_INT, MPI_SUM, new_comm); |
|||
|
|||
MPI_Group_rank (new_group, &new_rank); |
|||
printf("rank= %d newrank= %d recvbuf= %d\n",rank,new_rank,recvbuf); |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,24 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
|
|||
main(int argc, char** argv) |
|||
{ |
|||
|
|||
int my_rank; |
|||
int size; |
|||
int namelen; |
|||
char proc_name[MPI_MAX_PROCESSOR_NAME]; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &size); |
|||
MPI_Get_processor_name(proc_name, &namelen); |
|||
|
|||
if (my_rank == 2) |
|||
printf("Hello – I am process 2\n"); |
|||
else |
|||
printf("Hello from process %d of %d on %s\n", my_rank, size, proc_name); |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
@ -0,0 +1,53 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
|
|||
main(int argc, char** argv) |
|||
{ |
|||
int my_rank; |
|||
int k, p; |
|||
int threshold; |
|||
int root; |
|||
int local_max; |
|||
int total_max; |
|||
int data[10]; |
|||
int namelen; |
|||
char proc_name[MPI_MAX_PROCESSOR_NAME]; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &p); |
|||
MPI_Get_processor_name(proc_name, &namelen); |
|||
|
|||
for (k=0; k<10; k++) |
|||
data[k]=my_rank+k; |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("Dose ena orio anazitisis:\n"); |
|||
scanf("%d", &threshold); |
|||
} |
|||
|
|||
root = 0; |
|||
MPI_Bcast(&threshold, 1, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
local_max = 0; |
|||
for (k=0; k<10; k++) |
|||
{ |
|||
if ((data[k] > threshold) && (data[k] > local_max)) local_max=data[k]; |
|||
} |
|||
printf("\n Process %d on %s : local maximum = %d \n", my_rank, proc_name, local_max); |
|||
|
|||
root = 0; |
|||
MPI_Reduce(&local_max, &total_max, 1, MPI_INT, MPI_MAX, root, MPI_COMM_WORLD); |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
if (total_max > threshold) |
|||
printf("\n Maximum number found for threshold %d is equal to : %d \n", threshold, total_max); |
|||
else |
|||
printf("\n No number found greater than threshold %d \n", threshold); |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
@ -0,0 +1,124 @@ |
|||
/******************************************************************************
|
|||
* * MPI Matrix Multiply - C Version |
|||
* * FILE: mpi_mm.c |
|||
* * OTHER FILES: make.mpi_mm.c |
|||
* * DESCRIPTION: |
|||
* * In this code, the master task distributes a matrix multiply |
|||
* * operation to numtasks-1 worker tasks. |
|||
* * NOTE1: C and Fortran versions of this code differ because of the way |
|||
* * arrays are stored/passed. C arrays are row-major order but Fortran |
|||
* * arrays are column-major order. |
|||
* * AUTHOR: Ros Leibensperger / Blaise Barney |
|||
* * CONVERTED TO MPI: George L. Gusciora (1/25/95) |
|||
* ******************************************************************************/ |
|||
#include "mpi.h" |
|||
#include <stdio.h> |
|||
#define NRA 62 /* number of rows in matrix A */ |
|||
#define NCA 15 /* number of columns in matrix A */ |
|||
#define NCB 7 /* number of columns in matrix B */ |
|||
#define MASTER 0 /* taskid of first task */ |
|||
#define FROM_MASTER 1 /* setting a message type */ |
|||
#define FROM_WORKER 2 /* setting a message type */ |
|||
|
|||
int main(argc,argv) |
|||
int argc; |
|||
char *argv[]; |
|||
{ |
|||
int numtasks, /* number of tasks in partition */ |
|||
taskid, /* a task identifier */ |
|||
numworkers, /* number of worker tasks */ |
|||
source, /* task id of message source */ |
|||
dest, /* task id of message destination */ |
|||
nbytes, /* number of bytes in message */ |
|||
mtype, /* message type */ |
|||
rows, /* rows of matrix A sent to each worker */ |
|||
averow, extra, offset, |
|||
/* used to determine rows sent to each worker */ |
|||
i, j, k, rc; /* misc */ |
|||
double a[NRA][NCA], /* matrix A to be multiplied */ |
|||
b[NCA][NCB], /* matrix B to be multiplied */ |
|||
c[NRA][NCB]; /* result matrix C */ |
|||
MPI_Status status; |
|||
|
|||
rc = MPI_Init(&argc,&argv); |
|||
rc|= MPI_Comm_size(MPI_COMM_WORLD,&numtasks); |
|||
rc|= MPI_Comm_rank(MPI_COMM_WORLD,&taskid); |
|||
if (rc != 0) |
|||
printf ("error initializing MPI and obtaining task ID information\n"); |
|||
else |
|||
printf ("mpi_pi_mm MPI task ID = %d\n", taskid); |
|||
numworkers = numtasks-1; |
|||
/**************************** master task ************************************/ |
|||
if (taskid == MASTER) |
|||
{ |
|||
printf("Number of worker tasks = %d\n",numworkers); |
|||
for (i=0; i<NRA; i++) |
|||
for (j=0; j<NCA; j++) |
|||
a[i][j]= i+j; |
|||
for (i=0; i<NCA; i++) |
|||
for (j=0; j<NCB; j++) |
|||
b[i][j]= i*j; |
|||
|
|||
/* send matrix data to the worker tasks */ |
|||
averow = NRA/numworkers; |
|||
extra = NRA%numworkers; |
|||
offset = 0; |
|||
mtype = FROM_MASTER; |
|||
for (dest=1; dest<=numworkers; dest++) |
|||
{ |
|||
rows = (dest <= extra) ? averow+1 : averow; |
|||
printf(" sending %d rows to task %d\n",rows,dest); |
|||
MPI_Send(&offset, 1, MPI_INT, dest, mtype, MPI_COMM_WORLD); |
|||
MPI_Send(&rows, 1, MPI_INT, dest, mtype, MPI_COMM_WORLD); |
|||
MPI_Send(&a[offset][0], rows*NCA, MPI_DOUBLE, dest, mtype, |
|||
MPI_COMM_WORLD); |
|||
MPI_Send(&b, NCA*NCB, MPI_DOUBLE, dest, mtype, MPI_COMM_WORLD); |
|||
offset = offset + rows; |
|||
} |
|||
|
|||
/* wait for results from all worker tasks */ |
|||
mtype = FROM_WORKER; |
|||
for (i=1; i<=numworkers; i++) |
|||
{ |
|||
source = i; |
|||
MPI_Recv(&offset, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status); |
|||
MPI_Recv(&rows, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status); |
|||
MPI_Recv(&c[offset][0], rows*NCB, MPI_DOUBLE, source, mtype, MPI_COMM_WORLD, &status); |
|||
} |
|||
|
|||
/* print results */ |
|||
printf("Here is the result matrix\n"); |
|||
for (i=0; i<NRA; i++) |
|||
{ |
|||
printf("\n"); |
|||
for (j=0; j<NCB; j++) |
|||
printf("%6.2f ", c[i][j]); |
|||
} |
|||
printf ("\n"); |
|||
} |
|||
|
|||
/**************************** worker task ************************************/ |
|||
if (taskid > MASTER) |
|||
{ |
|||
mtype = FROM_MASTER; |
|||
MPI_Recv(&offset, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD, &status); |
|||
MPI_Recv(&rows, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD, &status); |
|||
MPI_Recv(&a, rows*NCA, MPI_DOUBLE, MASTER, mtype, MPI_COMM_WORLD, &status); |
|||
MPI_Recv(&b, NCA*NCB, MPI_DOUBLE, MASTER, mtype, MPI_COMM_WORLD, &status); |
|||
|
|||
for (k=0; k<NCB; k++) |
|||
for (i=0; i<rows; i++) |
|||
{ |
|||
c[i][k] = 0.0; |
|||
for (j=0; j<NCA; j++) |
|||
c[i][k] = c[i][k] + a[i][j] * b[j][k]; |
|||
} |
|||
mtype = FROM_WORKER; |
|||
MPI_Send(&offset, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD); |
|||
MPI_Send(&rows, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD); |
|||
MPI_Send(&c, rows*NCB, MPI_DOUBLE, MASTER, mtype, MPI_COMM_WORLD); |
|||
} |
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,30 @@ |
|||
#include <mpi.h> |
|||
#include <stdio.h> |
|||
|
|||
int main(int argc, char** argv) { |
|||
// Initialize the MPI environment. The two arguments to MPI Init are not
|
|||
// currently used by MPI implementations, but are there in case future
|
|||
// implementations might need the arguments.
|
|||
MPI_Init(NULL, NULL); |
|||
|
|||
// Get the number of processes
|
|||
int world_size; |
|||
MPI_Comm_size(MPI_COMM_WORLD, &world_size); |
|||
|
|||
// Get the rank of the process
|
|||
int world_rank; |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); |
|||
|
|||
// Get the name of the processor
|
|||
char processor_name[MPI_MAX_PROCESSOR_NAME]; |
|||
int name_len; |
|||
MPI_Get_processor_name(processor_name, &name_len); |
|||
|
|||
// Print off a hello world message
|
|||
printf("Hello world from processor %s, rank %d out of %d processors\n", |
|||
processor_name, world_rank, world_size); |
|||
|
|||
// Finalize the MPI environment. No more MPI calls can be made after this
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
@ -0,0 +1,58 @@ |
|||
#include <stdio.h> |
|||
#include <mpi.h> |
|||
#define N 10 |
|||
|
|||
main(int argc, char **argv) { |
|||
int j,k,A_loc; |
|||
int rank,size,root; |
|||
int A[N]; |
|||
int B_loc[N]; |
|||
int C[N]; |
|||
int B[N][N]; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &size); |
|||
|
|||
root = 0; |
|||
|
|||
/* Αρχικοποίησε τους πίνακες Β και C */ |
|||
|
|||
if (rank == root) |
|||
{ |
|||
|
|||
for (k=0; k<N; k++) |
|||
for (j=0; j<N; j++) |
|||
B[k][j] = k+j; |
|||
|
|||
for (k=0; k<N; k++) |
|||
C[k] = k; |
|||
} |
|||
|
|||
/* Διαμοίρασε τον πίνακα B κατά γραμμές με χρήση της MPI_Scatter */ |
|||
|
|||
MPI_Scatter(B, N, MPI_INT, B_loc, N, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
/* Στείλε σε όλες το διάνυσμα C με χρήση της MPI_Bcast */ |
|||
|
|||
MPI_Bcast(C, N, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
/* Κάνε τους απαραίτητους τοπικούς πολλαπλασιασμούς και προσθέσεις προκειμένου να υπολογίσεις το τοπικό σου στοιχείο του πίνακα Α */ |
|||
|
|||
A_loc = 0; |
|||
for(j=0; j<N; j++) |
|||
A_loc += C[j]*B_loc[j]; |
|||
|
|||
/* και συγκέντρωσε τα τελικά αποτελέσματα απλά με μία MPI_Gather */ |
|||
|
|||
MPI_Gather(&A_loc, 1, MPI_INT, A, 1, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
/* τύπωσε το τελικό αποτέλεσμα */ |
|||
if (rank == 0) |
|||
{ |
|||
for (k=0; k<N; k++) |
|||
printf("A[%d]=%d\n", k, A[k]); |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
@ -0,0 +1,33 @@ |
|||
#include "mpi.h" |
|||
#include <stdio.h> |
|||
|
|||
int main(argc,argv) |
|||
int argc; |
|||
char *argv[]; { |
|||
int numtasks, rank, next, prev, buf[2], tag1=1, tag2=2; |
|||
MPI_Request reqs[4]; |
|||
MPI_Status stats[4]; |
|||
|
|||
MPI_Init(&argc,&argv); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &numtasks); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &rank); |
|||
|
|||
prev = rank-1; |
|||
next = rank+1; |
|||
if (rank == 0) prev = numtasks - 1; |
|||
if (rank == (numtasks - 1)) next = 0; |
|||
|
|||
MPI_Irecv(&buf[0], 1, MPI_INT, prev, tag1, MPI_COMM_WORLD, &reqs[0]); |
|||
MPI_Irecv(&buf[1], 1, MPI_INT, next, tag2, MPI_COMM_WORLD, &reqs[1]); |
|||
|
|||
MPI_Isend(&rank, 1, MPI_INT, prev, tag2, MPI_COMM_WORLD, &reqs[2]); |
|||
MPI_Isend(&rank, 1, MPI_INT, next, tag1, MPI_COMM_WORLD, &reqs[3]); |
|||
|
|||
MPI_Waitall(4, reqs, stats); |
|||
|
|||
printf("Process %d: Parelava ta stoixeia %d and %d\n", rank, buf[0], buf[1]); |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,55 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
|
|||
main(int argc, char** argv) { |
|||
int my_rank; |
|||
int p,k,res,finres,a1,b1,num; |
|||
int source; |
|||
int target; |
|||
int tag1 = 50; |
|||
int tag2 = 60; |
|||
int endnum; |
|||
MPI_Status status; |
|||
|
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &p); |
|||
|
|||
|
|||
if (my_rank == 0) { |
|||
printf("Dose plithos aritmon:\n"); |
|||
scanf("%d", &endnum); |
|||
for (target = 1; target < p; target++) |
|||
MPI_Send(&endnum, 1, MPI_INT, target, tag1, MPI_COMM_WORLD); |
|||
} |
|||
else |
|||
MPI_Recv(&endnum, 1, MPI_INT, 0, tag1, MPI_COMM_WORLD, &status); |
|||
|
|||
|
|||
res = 0; |
|||
num = endnum/p; |
|||
a1 = (my_rank * num) + 1; |
|||
b1 = a1 + num - 1; |
|||
for (k=a1; k<=b1; k++) |
|||
res = res + (k*k); |
|||
|
|||
|
|||
if (my_rank != 0) { |
|||
MPI_Send(&res, 1, MPI_INT, 0, tag2, MPI_COMM_WORLD); |
|||
} |
|||
else { |
|||
finres = res; |
|||
printf("\n Apotelesma of process %d: %d\n", my_rank, res); |
|||
for (source = 1; source < p; source++) { |
|||
MPI_Recv(&res, 1, MPI_INT, source, tag2, MPI_COMM_WORLD, &status); |
|||
finres = finres + res; |
|||
printf("\n Apotelesma of process %d: %d\n", source, res); |
|||
} |
|||
printf("\n\n\n Teliko Apotelesma: %d\n", finres); |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,66 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
main(int argc, char** argv) |
|||
{ |
|||
int my_rank, p, k, size; |
|||
float b; |
|||
int root, position; |
|||
char buffer[50]; |
|||
int matrixA[100]; |
|||
int loc_num; |
|||
int loc_matrix[100]; |
|||
float loc_res[100]; |
|||
float final_res[100]; |
|||
int namelen; |
|||
char proc_name[MPI_MAX_PROCESSOR_NAME]; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &p); |
|||
MPI_Get_processor_name(proc_name, &namelen); |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("YPOLOGISMOS THS PARASTASHS b * A \n\n"); |
|||
printf("DOSE THN TIMH TOY B:\n"); |
|||
scanf("%f", &b); |
|||
printf("DOSE TO MHKOS TOY PINAKA A:\n"); |
|||
scanf("%d", &size); |
|||
printf("DOSE TA STOIXEIA TOY PINAKA A MHKOYS %d:\n", size); |
|||
for (k=0; k<size; k++) |
|||
scanf("%d", &matrixA[k]); |
|||
position = 0; |
|||
MPI_Pack(&size, 1, MPI_INT, buffer, 50, &position, MPI_COMM_WORLD); |
|||
MPI_Pack(&b, 1, MPI_FLOAT, buffer, 50, &position, MPI_COMM_WORLD); |
|||
} |
|||
|
|||
root = 0; |
|||
MPI_Bcast(buffer, 50, MPI_PACKED, root, MPI_COMM_WORLD); |
|||
position = 0; |
|||
MPI_Unpack(buffer, 50, &position, &size, 1, MPI_INT, MPI_COMM_WORLD); |
|||
MPI_Unpack(buffer, 50, &position, &b, 1, MPI_FLOAT, MPI_COMM_WORLD); |
|||
|
|||
loc_num = size/p; |
|||
root = 0; |
|||
MPI_Scatter(matrixA, loc_num, MPI_INT, loc_matrix, loc_num, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
for (k=0; k<loc_num; k++) |
|||
loc_res[k] = b*loc_matrix[k]; |
|||
|
|||
printf("\n Process %d on %s : local results are : ", my_rank, proc_name); |
|||
for (k=0; k<loc_num; k++) printf("%f ", loc_res[k]); |
|||
printf("\n\n"); |
|||
|
|||
root = 0; |
|||
MPI_Gather(loc_res, loc_num, MPI_INT, final_res, loc_num, MPI_FLOAT, root, MPI_COMM_WORLD); |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("\n TELIKO APOTELESMA %f * A =\n", b); |
|||
for (k=0; k<size; k++) printf("%f ", final_res[k]); |
|||
printf("\n\n"); |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
@ -0,0 +1,50 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
|
|||
int main(argc,argv) |
|||
int argc; |
|||
char *argv[]; |
|||
{ |
|||
int numtasks, rank, dest, source, tag = 1; |
|||
char msg1[15], msg2[15]; |
|||
MPI_Status stat; |
|||
|
|||
MPI_Init(&argc,&argv); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &numtasks); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &rank); |
|||
|
|||
sprintf(msg1, "Sample message"); |
|||
|
|||
if (rank == 0) { |
|||
dest = 1; |
|||
source = 1; |
|||
|
|||
while (1) { |
|||
MPI_Send(msg1, 15, MPI_CHAR, dest, tag, |
|||
MPI_COMM_WORLD); |
|||
sprintf(msg1, "\0"); |
|||
MPI_Recv(msg1, 15, MPI_CHAR, source, tag, |
|||
MPI_COMM_WORLD, &stat); |
|||
printf("Process %d Message = %s \n", rank, msg1); |
|||
sleep(2); |
|||
} |
|||
} |
|||
|
|||
else if (rank == 1) { |
|||
dest = 0; |
|||
source = 0; |
|||
|
|||
while (1) { |
|||
sprintf(msg2, "\0"); |
|||
MPI_Recv(msg2, 15, MPI_CHAR, source, tag, |
|||
MPI_COMM_WORLD, &stat); |
|||
printf("Process %d Message = %s \n", rank, msg2); |
|||
sleep(2); |
|||
MPI_Send(msg2, 15, MPI_CHAR, dest, tag, |
|||
MPI_COMM_WORLD); |
|||
} |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
@ -0,0 +1,63 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
|
|||
main(int argc, char** argv) |
|||
{ |
|||
int my_rank; |
|||
int p, k; |
|||
int b, size; |
|||
int root; |
|||
int matrixA[100]; |
|||
int loc_num; |
|||
int loc_matrix[100]; |
|||
int loc_res[100]; |
|||
int final_res[100]; |
|||
int namelen; |
|||
char proc_name[MPI_MAX_PROCESSOR_NAME]; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &p); |
|||
MPI_Get_processor_name(proc_name, &namelen); |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("YPOLOGISMOS THS PARASTASHS b * A \n\n"); |
|||
printf("DOSE THN TIMH TOY B:\n"); |
|||
scanf("%d", &b); |
|||
printf("DOSE TO MHKOS TOY PINAKA A:\n"); |
|||
scanf("%d", &size); |
|||
printf("DOSE TA STOIXEIA TOY PINAKA A MHKOYS %d:\n", size); |
|||
for (k=0; k<size; k++) |
|||
scanf("%d", &matrixA[k]); |
|||
} |
|||
|
|||
root = 0; |
|||
MPI_Bcast(&size, 1, MPI_INT, root, MPI_COMM_WORLD); |
|||
MPI_Bcast(&b, 1, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
loc_num = size/p; |
|||
|
|||
root = 0; |
|||
MPI_Scatter(matrixA, loc_num, MPI_INT, loc_matrix, loc_num, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
for (k=0; k<loc_num; k++) |
|||
loc_res[k] = b*loc_matrix[k]; |
|||
|
|||
printf("\n Process %d on %s : local results are : ", my_rank, proc_name); |
|||
for (k=0; k<loc_num; k++) printf("%d ", loc_res[k]); |
|||
printf("\n\n"); |
|||
|
|||
root = 0; |
|||
MPI_Gather(loc_res, loc_num, MPI_INT, final_res, loc_num, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("\n TELIKO APOTELESMA %d * A =\n", b); |
|||
for (k=0; k<size; k++) printf("%d ", final_res[k]); |
|||
printf("\n\n"); |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
@ -0,0 +1,112 @@ |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include "mpi.h" |
|||
#define MAXPROC 8 /* Max number of procsses */ |
|||
#define NAMELEN 80 /* Max length of machine name */ |
|||
#define LENGTH 8 /* Size of matrix is LENGTH * LENGTH */ |
|||
|
|||
main(int argc, char* argv[]) { |
|||
int i, j, np, me, count; |
|||
const int nametag = 42; /* Tag value for sending name */ |
|||
const int datatag = 43; /* Tag value for sending data */ |
|||
const int root = 0; /* Root process in scatter */ |
|||
MPI_Status status; /* Status object for receive */ |
|||
|
|||
char myname[NAMELEN]; /* Local host name string */ |
|||
char hostname[MAXPROC][NAMELEN]; /* Received host names */ |
|||
|
|||
int x[LENGTH][LENGTH]; /* Send buffer */ |
|||
int y[LENGTH]; /* Receive buffer */ |
|||
|
|||
int *sendcount, *displs; /* Arrays for sendcounts and displacements */ |
|||
|
|||
MPI_Init(&argc, &argv); /* Initialize MPI */ |
|||
MPI_Comm_size(MPI_COMM_WORLD, &np); /* Get nr of processes */ |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &me); /* Get own identifier */ |
|||
|
|||
gethostname(&myname, NAMELEN); /* Get host name */ |
|||
|
|||
/* Check that we have one process for each row in the matrix */ |
|||
if (np != LENGTH) { |
|||
if (me == 0) { |
|||
printf("You have to use %d processes\n", LENGTH); |
|||
} |
|||
MPI_Finalize(); |
|||
exit(0); |
|||
} |
|||
|
|||
/* Allocate memory for the sendcount and displacements arrays */ |
|||
sendcount = (int *)malloc(LENGTH*sizeof(int)); |
|||
displs = (int *)malloc(LENGTH*sizeof(int)); |
|||
|
|||
/* Initialize sendcount and displacements arrays */ |
|||
for (i=0; i<LENGTH; i++) { |
|||
sendcount[i] = i+1; |
|||
displs[i] = i*LENGTH; |
|||
} |
|||
|
|||
if (me == 0) { /* Process 0 does this */ |
|||
|
|||
/* Initialize the matrix x with values 0 .. LENGTH*LENGTH-1 */ |
|||
for (i=0; i<LENGTH; i++) { |
|||
for (j=0; j<LENGTH; j++) { |
|||
x[i][j] = i*LENGTH+j; |
|||
} |
|||
} |
|||
|
|||
/* Print out the matrix before it is distributed */ |
|||
printf("The matrix is\n"); |
|||
for (i=0; i<LENGTH; i++) { |
|||
for (j=0; j<LENGTH; j++) { |
|||
printf("%4d ", x[i][j]); |
|||
} |
|||
printf("\n"); |
|||
} |
|||
|
|||
printf("\nProcess %d on host %s is scatteringing the lower triangular part of the matrix x to all %d processes\n\n", me, myname, np); |
|||
|
|||
/* Scatter the lower triangular part of array x to all proceses, place it in y */ |
|||
MPI_Scatterv(&x, sendcount, displs, MPI_INT, &y, LENGTH, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
/* Process zero prints out own portion of the scattered array */ |
|||
for (i=0; i<sendcount[me]; i++) { |
|||
printf("%4d", y[i]); |
|||
} |
|||
printf(" "); |
|||
printf(" from process %d on host %s\n", me, myname); |
|||
|
|||
/* Receive messages with hostname and the scattered data */ |
|||
/* from all other processes */ |
|||
for (i=1; i<np; i++) { |
|||
MPI_Recv (&hostname[i], NAMELEN, MPI_CHAR, i, nametag, MPI_COMM_WORLD, \ |
|||
&status); |
|||
MPI_Recv (&y, LENGTH, MPI_INT, i, datatag, MPI_COMM_WORLD, &status); |
|||
MPI_Get_count(&status, MPI_INT, &count); /* Get nr of elements in message */ |
|||
|
|||
/* Print out the elements we received from this process */ |
|||
for (j=0; j<count; j++) { |
|||
printf("%4d", y[j]); |
|||
} |
|||
for (j=0; j<LENGTH-count; j++) { /* Format output to look like a matrix */ |
|||
printf(" "); |
|||
} |
|||
printf(" from process %d on host %s\n", i, hostname[i]); |
|||
} |
|||
|
|||
printf("Ready\n"); |
|||
|
|||
} else { /* all other processes do this */ |
|||
|
|||
/* Receive the scattered matrix from process 0, place it in array y */ |
|||
MPI_Scatterv(&x, sendcount, displs, MPI_INT, &y, LENGTH, MPI_INT, root, MPI_COMM_WORLD); |
|||
|
|||
/* Send own name back to process 0 */ |
|||
MPI_Send (&myname, NAMELEN, MPI_CHAR, 0, nametag, MPI_COMM_WORLD); |
|||
/* Send the received array back to process 0 */ |
|||
MPI_Send (&y, sendcount[me], MPI_INT, 0, datatag, MPI_COMM_WORLD); |
|||
|
|||
} |
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,61 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
|
|||
main(int argc, char** argv) |
|||
{ |
|||
int my_rank, size; |
|||
int source, dest; |
|||
int tag1= 50; |
|||
int tag2 = 60; |
|||
int tag3 =70; |
|||
int found = 0; |
|||
int other_found; |
|||
int k, code; |
|||
int data[10]; |
|||
int namelen; |
|||
MPI_Status status; |
|||
char proc_name[MPI_MAX_PROCESSOR_NAME]; |
|||
char other_proc_name[MPI_MAX_PROCESSOR_NAME]; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &size); |
|||
MPI_Get_processor_name(proc_name, &namelen); |
|||
|
|||
for (k=0; k<10; k++) |
|||
data[k]=my_rank+k; |
|||
|
|||
if (my_rank == 0) |
|||
{ |
|||
printf("Dose ena kodiko anazitisis:\n"); |
|||
scanf("%d", &code); |
|||
for (dest =1; dest<size; dest++) |
|||
MPI_Send(&code, 1, MPI_INT, dest, tag1, MPI_COMM_WORLD); |
|||
} |
|||
else |
|||
{ |
|||
MPI_Recv(&code, 1, MPI_INT, 0, tag1, MPI_COMM_WORLD, &status); |
|||
} |
|||
|
|||
for (k=0; k<10; k++) |
|||
{ if (data[k] == code) found=1; } |
|||
|
|||
if (my_rank != 0) |
|||
{ MPI_Send(&found, 1, MPI_INT, 0, tag2, MPI_COMM_WORLD); |
|||
MPI_Send(proc_name, namelen+1, MPI_CHAR, 0, tag3, MPI_COMM_WORLD); } |
|||
|
|||
|
|||
if (my_rank == 0) { |
|||
for (source=1; source<size; source++) { |
|||
MPI_Recv(&other_found, 1, MPI_INT, source, tag2, MPI_COMM_WORLD, &status); |
|||
MPI_Recv(other_proc_name, 50, MPI_CHAR, source, tag3, MPI_COMM_WORLD, &status); |
|||
if (other_found) |
|||
printf("\n Code %d found in database of process %d on %s \n", code, source, other_proc_name); |
|||
} |
|||
if (found) |
|||
printf("\n Code %d found in database of process %d on %s \n", code, my_rank, proc_name); |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
@ -0,0 +1,60 @@ |
|||
#include <stdio.h> |
|||
#include "mpi.h" |
|||
|
|||
main(int argc, char** argv) |
|||
{ |
|||
int my_rank; |
|||
int p,k,res,finres,num; |
|||
int source,target; |
|||
int tag1=50, tag2=60, tag3=70; |
|||
int plithos; |
|||
int data[100]; |
|||
int data_loc[100]; |
|||
MPI_Status status; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &p); |
|||
|
|||
if (my_rank == 0) { |
|||
printf("Dose plithos aritmon:\n"); |
|||
scanf("%d", &plithos); |
|||
printf("Dose tous %d arithmous:\n", plithos); |
|||
for (k=0; k<plithos; k++) |
|||
scanf("%d", &data[k]); |
|||
for (target = 1; target < p; target++) |
|||
MPI_Send(&plithos, 1, MPI_INT, target, tag1, MPI_COMM_WORLD); |
|||
num = plithos/p; k=num; |
|||
for (target = 1; target < p; target++) { |
|||
MPI_Send(&data[k], num, MPI_INT, target, tag2, MPI_COMM_WORLD); |
|||
k+=num; } |
|||
for (k=0; k<num; k++) |
|||
data_loc[k]=data[k]; |
|||
} |
|||
else { |
|||
MPI_Recv(&plithos, 1, MPI_INT, 0, tag1, MPI_COMM_WORLD, &status); |
|||
num = plithos/p; |
|||
MPI_Recv(&data_loc[0], num, MPI_INT, 0, tag2, MPI_COMM_WORLD, &status); |
|||
} |
|||
|
|||
res = 0; |
|||
for (k=0; k<num; k++) |
|||
res = res + (data_loc[k]*data_loc[k]); |
|||
|
|||
if (my_rank != 0) { |
|||
MPI_Send(&res, 1, MPI_INT, 0, tag3, MPI_COMM_WORLD); |
|||
} |
|||
else { |
|||
finres = res; |
|||
printf("\n Apotelesma of process %d: %d\n", my_rank, res); |
|||
for (source = 1; source < p; source++) { |
|||
MPI_Recv(&res, 1, MPI_INT, source, tag3, MPI_COMM_WORLD, &status); |
|||
finres = finres + res; |
|||
printf("\n Apotelesma of process %d: %d\n", source, res); |
|||
} |
|||
printf("\n\n\n Teliko Apotelesma: %d\n", finres); |
|||
} |
|||
|
|||
MPI_Finalize(); |
|||
} |
|||
|
|||
@ -0,0 +1,53 @@ |
|||
#include "mpi.h" |
|||
#include <stdio.h> |
|||
#include <string.h> |
|||
|
|||
#define BUFLEN 512 |
|||
|
|||
int main(int argc, char *argv[]) |
|||
{ |
|||
int myid, numprocs, next, namelen; |
|||
char buffer[BUFLEN], processor_name[MPI_MAX_PROCESSOR_NAME]; |
|||
MPI_Status status; |
|||
|
|||
MPI_Init(&argc,&argv); |
|||
MPI_Comm_size(MPI_COMM_WORLD,&numprocs); |
|||
MPI_Comm_rank(MPI_COMM_WORLD,&myid); |
|||
MPI_Get_processor_name(processor_name,&namelen); |
|||
|
|||
fprintf(stderr,"Process %d on %s\n", myid, processor_name); |
|||
strcpy(buffer,"hello there"); |
|||
if (myid == numprocs-1) |
|||
next = 0; |
|||
else |
|||
next = myid+1; |
|||
|
|||
if (myid == 0) |
|||
{ |
|||
printf("%d sending '%s' \n",myid,buffer); |
|||
MPI_Send(buffer, strlen(buffer)+1, MPI_CHAR, next, 99, MPI_COMM_WORLD); |
|||
MPI_Send(buffer, strlen(buffer)+1, MPI_CHAR, MPI_PROC_NULL, 299, MPI_COMM_WORLD); |
|||
printf("%d receiving \n",myid); |
|||
MPI_Recv(buffer, BUFLEN, MPI_CHAR, MPI_ANY_SOURCE, 99, MPI_COMM_WORLD, |
|||
&status); |
|||
printf("%d received '%s' \n",myid,buffer); |
|||
/* mpdprintf(001,"%d receiving \n",myid); */ |
|||
} |
|||
else |
|||
{ |
|||
printf("%d receiving \n",myid); |
|||
MPI_Recv(buffer, BUFLEN, MPI_CHAR, MPI_ANY_SOURCE, 99, MPI_COMM_WORLD, |
|||
&status); |
|||
MPI_Recv(buffer, BUFLEN, MPI_CHAR, MPI_PROC_NULL, 299, MPI_COMM_WORLD, |
|||
&status); |
|||
printf("%d received '%s' \n",myid,buffer); |
|||
/* mpdprintf(001,"%d receiving \n",myid); */ |
|||
MPI_Send(buffer, strlen(buffer)+1, MPI_CHAR, next, 99, MPI_COMM_WORLD); |
|||
printf("%d sent '%s' \n",myid,buffer); |
|||
} |
|||
MPI_Barrier(MPI_COMM_WORLD); |
|||
MPI_Finalize(); |
|||
return (0); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,66 @@ |
|||
#include "mpi.h" |
|||
#include <stdio.h> |
|||
#define NELEM 25 |
|||
|
|||
int main(argc,argv) |
|||
int argc; |
|||
char *argv[]; |
|||
{ |
|||
int numtasks, rank, source=0, dest, tag=1, i; |
|||
typedef struct { |
|||
float x, y, z; |
|||
float velocity; |
|||
int n, type; |
|||
} Particle; |
|||
Particle p[NELEM], particles[NELEM]; |
|||
MPI_Datatype particletype, oldtypes[2]; |
|||
int blockcounts[2]; |
|||
|
|||
/* MPI_Aint type used to be consistent with syntax of */ |
|||
/* MPI_Type_extent routine */ |
|||
MPI_Aint offsets[2], extent; |
|||
|
|||
MPI_Status stat; |
|||
|
|||
MPI_Init(&argc,&argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD, &rank); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &numtasks); |
|||
|
|||
/* Setup description of the 4 MPI_FLOAT fields x, y, z, velocity */ |
|||
offsets[0] = 0; |
|||
oldtypes[0] = MPI_FLOAT; |
|||
blockcounts[0] = 4; |
|||
|
|||
/* Setup description of the 2 MPI_INT fields n, type */ |
|||
/* Need to first figure offset by getting size of MPI_FLOAT */ |
|||
MPI_Type_extent(MPI_FLOAT, &extent); |
|||
offsets[1] = 4 * extent; |
|||
oldtypes[1] = MPI_INT; |
|||
blockcounts[1] = 2; |
|||
|
|||
/* Now define structured type and commit it */ |
|||
MPI_Type_struct(2, blockcounts, offsets, oldtypes, &particletype); |
|||
MPI_Type_commit(&particletype); |
|||
|
|||
/* Initialize the particle array and then send it to each task */ |
|||
if (rank == 0) { |
|||
for (i=0; i<NELEM; i++) { |
|||
particles[i].x = i * 1.0; |
|||
particles[i].y = i * -1.0; |
|||
particles[i].z = i * 1.0; |
|||
particles[i].velocity = 0.25; |
|||
particles[i].n = i; |
|||
particles[i].type = i % 2; |
|||
} |
|||
for (i=0; i<numtasks; i++) |
|||
MPI_Send(particles, NELEM, particletype, i, tag, MPI_COMM_WORLD); |
|||
} |
|||
|
|||
MPI_Recv(p, NELEM, particletype, source, tag, MPI_COMM_WORLD, &stat); |
|||
|
|||
/* Print a sample of what was received */ |
|||
printf("rank= %d %3.2f %3.2f %3.2f %3.2f %d %d\n", rank,p[3].x, |
|||
p[3].y,p[3].z,p[3].velocity,p[3].n,p[3].type); |
|||
|
|||
MPI_Finalize(); } |
|||
|
|||
@ -0,0 +1,186 @@ |
|||
#include "mpi.h" |
|||
#include <stdio.h> |
|||
/* stdlib is needed for declaring malloc */ |
|||
#include <stdlib.h> |
|||
|
|||
#define MAX2(a,b) (((a)>(b)) ? (a) : (b)) |
|||
|
|||
int GlobalReadInteger( void ); |
|||
void Hello( void ); |
|||
void Ring( void ); |
|||
/*
|
|||
* void Stress( void ); |
|||
* void Globals( void ); |
|||
* */ |
|||
|
|||
int main(int argc, char *argv[]) |
|||
{ |
|||
|
|||
int me, option, namelen, size; |
|||
char processor_name[MPI_MAX_PROCESSOR_NAME]; |
|||
|
|||
MPI_Init(&argc, &argv); |
|||
MPI_Comm_rank(MPI_COMM_WORLD,&me); |
|||
MPI_Comm_size(MPI_COMM_WORLD,&size); |
|||
|
|||
if (size < 2) { |
|||
fprintf(stderr, "systest requires at least 2 processes" ); |
|||
MPI_Abort(MPI_COMM_WORLD,1); |
|||
} |
|||
|
|||
MPI_Get_processor_name(processor_name,&namelen); |
|||
|
|||
fprintf(stderr,"Process %d is alive on %s\n", |
|||
me, processor_name); |
|||
|
|||
while (1) { |
|||
|
|||
MPI_Barrier(MPI_COMM_WORLD); |
|||
|
|||
again: |
|||
if (me == 0) { |
|||
/* Read user input for action */ |
|||
/* (void) printf("\nOptions: 0=quit, 1=Hello, 2=Ring, 3=Stress, ");
|
|||
* (void) printf("4=Globals : "); */ |
|||
(void) printf("\nOptions: 0=quit, 1=Hello, 2=Ring : "); |
|||
(void) fflush(stdout); |
|||
} |
|||
option = GlobalReadInteger(); |
|||
if ( (option < 0) || (option > 4) ) |
|||
goto again; |
|||
|
|||
switch (option) { |
|||
case 0: |
|||
MPI_Finalize(); |
|||
return(0); |
|||
case 1: |
|||
Hello(); break; |
|||
case 2: |
|||
Ring(); break; |
|||
/*
|
|||
* case 3: |
|||
* Stress(); break; |
|||
* case 4: |
|||
* Globals(); break; |
|||
* */ |
|||
default: |
|||
fprintf(stderr,"systest: invalid option %d\n", option); break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
int GlobalReadInteger( void ) |
|||
/*
|
|||
* Process zero reads an integer from stdin and broadcasts |
|||
* to everyone else |
|||
* */ |
|||
{ |
|||
int me, value; |
|||
|
|||
MPI_Comm_rank(MPI_COMM_WORLD, &me); |
|||
if (me == 0) { |
|||
if (scanf("%d", &value) != 1) |
|||
fprintf(stderr,"failed reading integer value from stdin\n"); |
|||
} |
|||
MPI_Bcast(&value, 1, MPI_INT, 0, MPI_COMM_WORLD); |
|||
return value; |
|||
} |
|||
|
|||
void Hello( void ) |
|||
/*
|
|||
* Everyone exchanges a hello message with everyone else. |
|||
* The hello message just comprises the sending and target nodes. |
|||
* */ |
|||
{ |
|||
int nproc, me; |
|||
int type = 1; |
|||
int buffer[2], node; |
|||
MPI_Status status; |
|||
|
|||
MPI_Comm_rank(MPI_COMM_WORLD, &me); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &nproc); |
|||
|
|||
if (me == 0) { |
|||
printf("\nHello test ... show network integrity\n----------\n\n"); |
|||
fflush(stdout); |
|||
} |
|||
|
|||
for (node = 0; node<nproc; node++) { |
|||
if (node != me) { |
|||
buffer[0] = me; |
|||
buffer[1] = node; |
|||
MPI_Send(buffer, 2, MPI_INT, node, type, MPI_COMM_WORLD); |
|||
MPI_Recv(buffer, 2, MPI_INT, node, type, MPI_COMM_WORLD, &status); |
|||
|
|||
if ( (buffer[0] != node) || (buffer[1] != me) ) { |
|||
(void) fprintf(stderr, "Hello: %d!=%d or %d!=%d\n", |
|||
buffer[0], node, buffer[1], me); |
|||
printf("Mismatch on hello process ids; node = %d\n", node); |
|||
} |
|||
|
|||
printf("Hello from %d to %d\n", me, node); |
|||
fflush(stdout); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void Ring( void ) /* Time passing a message round a ring */ |
|||
{ |
|||
int nproc, me; |
|||
MPI_Status status; |
|||
int type = 4; |
|||
int left, right; |
|||
char *buffer; |
|||
int lenbuf, max_len; |
|||
double us_rate; |
|||
double start_ustime, used_ustime; |
|||
|
|||
MPI_Comm_rank(MPI_COMM_WORLD, &me); |
|||
MPI_Comm_size(MPI_COMM_WORLD, &nproc); |
|||
left = (me + nproc - 1) % nproc; |
|||
right = (me + 1) % nproc; |
|||
|
|||
/* Find out how big a message to use */ |
|||
|
|||
if (me == 0) { |
|||
(void) printf("\nRing test...time network performance\n---------\n\n"); |
|||
(void) printf("Input maximum message size: "); |
|||
(void) fflush(stdout); |
|||
} |
|||
max_len = GlobalReadInteger(); |
|||
if ( (max_len <= 0) || (max_len >= 4*1024*1024) ) |
|||
max_len = 512*1024; |
|||
if ( (buffer = (char *) malloc((unsigned) max_len)) == (char *) NULL) { |
|||
printf("process %d could not allocate buffer of size %d\n",me,max_len); |
|||
MPI_Abort(MPI_COMM_WORLD,7777); |
|||
} |
|||
|
|||
lenbuf = 1; |
|||
while (lenbuf <= max_len) { |
|||
start_ustime = MPI_Wtime(); |
|||
if (me == 0) { |
|||
MPI_Send(buffer,lenbuf,MPI_CHAR,left, type,MPI_COMM_WORLD); |
|||
MPI_Recv(buffer,lenbuf,MPI_CHAR,right,type,MPI_COMM_WORLD,&status); |
|||
} |
|||
else { |
|||
MPI_Recv(buffer,lenbuf,MPI_CHAR,right,type,MPI_COMM_WORLD,&status); |
|||
MPI_Send(buffer,lenbuf,MPI_CHAR,left, type,MPI_COMM_WORLD); |
|||
} |
|||
used_ustime = MPI_Wtime() - start_ustime; |
|||
|
|||
if (used_ustime > 0) /* rate is megabytes per second */ |
|||
us_rate = (double)(nproc*lenbuf / (used_ustime*(double)1000000)); |
|||
else |
|||
us_rate = 0.0; |
|||
if (me == 0) { |
|||
printf("len=%d bytes, used= %f sec., rate=%f Mbytes/sec\n", |
|||
lenbuf, used_ustime, us_rate); |
|||
} |
|||
lenbuf *= 2; |
|||
} |
|||
if (me == 0) |
|||
printf("clock resolution in seconds: %10.8f\n", MPI_Wtick()); |
|||
free(buffer); |
|||
} |
|||
|
|||
|
|||
Loading…
Reference in new issue