MPP-solutions.tar

MPP-solutions/0000775000175000017500000000000013207241214011663 5ustar  dshdshMPP-solutions/F-MPI/0000775000175000017500000000000013207241214012473 5ustar  dshdshMPP-solutions/F-MPI/CartesTopology/0000775000175000017500000000000013207241214015451 5ustar  dshdshMPP-solutions/F-MPI/CartesTopology/scriptfile0000664000175000017500000000012413207241214017535 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./rotate

MPP-solutions/F-MPI/CartesTopology/scriptfile-scan0000664000175000017500000000012313207241214020456 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./scan


MPP-solutions/F-MPI/CartesTopology/rotate.f900000664000175000017500000000316713207241214017276 0ustar  dshdsh!
! perform a global sum of data stored on each process by rotating each piece of data all the
! way round the ring. At each iteration, a process receives some data from the left, adds the 
! value to its running total, then passes the data it has just received on to the right.
!
! Previous version in ../Rotate/rotate.f90
!
! Use virtual topologies, here cartesian 1D
!

program rotate
implicit none
include 'mpif.h'

integer :: comm, ierr, rank, size, request,tag
integer :: send_status(MPI_STATUS_SIZE), recv_status(MPI_STATUS_SIZE)
integer :: left, right, addon, sum, i, passon
! New variables required
integer :: ndims, comm1d, direction,disp
integer :: dims(1)
logical :: periods(1), reorder

comm = MPI_COMM_WORLD
tag = 1

call MPI_INIT(ierr)
call MPI_COMM_SIZE(comm,size,ierr)

! Cartesian topology
ndims = 1
dims(1) = 0
periods(1) = .true.       ! Cyclic
reorder = .false.
direction = 0             ! Shift along the first index
disp = 1                  ! Shift by 1

call MPI_DIMS_CREATE(size,1,dims,ierr)
call MPI_CART_CREATE(comm,ndims,dims,periods,reorder,comm1d,ierr)
call MPI_COMM_RANK(comm1d,rank,ierr)
call MPI_CART_SHIFT(comm1d,direction,disp,left,right,ierr)

sum = 0
! Initialise local values to:
passon = (rank+1)**2
! Alternatively use
! passon = rank

! Use non-blocking point-to-point communication 
do i=1,size

 call MPI_ISSEND(passon,1,MPI_INTEGER,left,tag,comm1d,request,ierr)
 call MPI_RECV(addon,1,MPI_INTEGER,right,tag,comm1d,recv_status,ierr)
 call MPI_WAIT(request,send_status,ierr)

sum = sum + addon
passon = addon
enddo

write(*,*)'The sum is:', sum,' on processor', rank

call MPI_FINALIZE(ierr)

end program rotate
MPP-solutions/F-MPI/CartesTopology/Makefile0000664000175000017500000000047613207241214017120 0ustar  dshdshMF=	Makefile

FC=	mpif90
FFLAGS=	

LFLAGS=

EXE=	rotate

SRC= \
	rotate.f90	

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .f90 .o

OBJ=	$(SRC:.f90=.o)

.f90.o:
	$(FC) $(FFLAGS) -c $<

all:	$(EXE)

$(EXE):	$(OBJ)
	$(FC) $(FFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-solutions/F-MPI/CartesTopology/Makefile-scan0000664000175000017500000000047213207241214020036 0ustar  dshdshMF=	Makefile

FC=	mpif90
FFLAGS=	

LFLAGS=

EXE=	scan

SRC= \
	scan.f90	

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .f90 .o

OBJ=	$(SRC:.f90=.o)

.f90.o:
	$(FC) $(FFLAGS) -c $<

all:	$(EXE)

$(EXE):	$(OBJ)
	$(FC) $(FFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-solutions/F-MPI/CartesTopology/scan.f900000664000175000017500000000151713207241214016721 0ustar  dshdsh!
! perform a global sum of data stored on each process by rotating each piece of data all the
! way round the ring. At each iteration, a process receives some data from the left, adds the 
! value to its running total, then passes the data it has just received on to the right.
!
! Use virtual topologies, here cartesian 1D, like in rotate.f90  and MPI_SCAN
!

program rotate
implicit none
include 'mpif.h'

integer :: comm, ierr, rank, size
integer :: sum, passon

comm = MPI_COMM_WORLD

call MPI_INIT(ierr)
call MPI_COMM_SIZE(comm,size,ierr)
call MPI_COMM_RANK(comm,rank,ierr)

sum = 0
! Initialise local values to:
passon = (rank+1)**2
! Alternatively use
! passon = rank

! Use MPI_Scan
call MPI_SCAN(passon,sum,1,MPI_INTEGER,MPI_SUM,comm,ierr)

write(*,*)'The sum is:', sum,' on processor', rank

call MPI_FINALIZE(ierr)

end program rotate
MPP-solutions/F-MPI/PingPong/0000775000175000017500000000000013207241214014214 5ustar  dshdshMPP-solutions/F-MPI/PingPong/scriptfile0000664000175000017500000000012513207241214016301 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 2
mpiexec -n $NSLOTS ./pingpong
MPP-solutions/F-MPI/PingPong/Makefile0000664000175000017500000000050213207241214015651 0ustar  dshdshMF=	Makefile

FC=	mpif90
FFLAGS=	

LFLAGS=

EXE=	pingpong

SRC= \
	pingpong.f90	

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .f90 .o

OBJ=	$(SRC:.f90=.o)

.f90.o:
	$(FC) $(FFLAGS) -c $<

all:	$(EXE)

$(EXE):	$(OBJ)
	$(FC) $(FFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-solutions/F-MPI/PingPong/pingpong.f900000664000175000017500000000515113207241214016357 0ustar  dshdsh!
! Program in which 2 processes repeatedly pass a message back and forth
!
! The same data is sent from A to B, then returned from B to A.
!

program pingpong
implicit none
include 'mpif.h'

integer :: ierr, size, rank, comm, i, length, numiter
integer :: status(MPI_STATUS_SIZE)
integer :: tag1, tag2, extent
character*10 temp_char10
integer :: iargc
real, allocatable :: sbuffer(:)
double precision :: tstart, tstop, time, totmess

comm = MPI_COMM_WORLD
tag1 = 1
tag2 = 2

call MPI_INIT(ierr)
call MPI_COMM_RANK(comm,rank,ierr)
call MPI_COMM_SIZE(comm,size,ierr)

if (iargc() /= 2) then
 if (rank .eq. 0) then
   write(*,*) 'Usage: pingpong <array length> <number of iterations>'
 end if

 call mpi_finalize(ierr)
 stop
end if


if (rank.gt.1) then
 print*, 'Rank not participating', rank
end if


if (rank .eq. 0) then 
 call getarg(1,temp_char10)
 read(temp_char10,*) length
 call getarg(2,temp_char10)
 read(temp_char10,*) numiter

 print*, 'Array length, number of iterations = '
 print*,  length, numiter
end if

call MPI_BCAST(length,1,MPI_INTEGER,0,comm,ierr)
call MPI_BCAST(numiter,1,MPI_INTEGER,0,comm,ierr)

! Must be run on at least 2 processors
if(size.lt.2)then
 if(rank.eq.0) write(*,*) ' The code must be run on at least 2 processors.'
 call MPI_FINALIZE(ierr)
 stop
endif

! Allocate array
allocate(sbuffer(length))

! Send 'buffer' back and forth between rank 0 and rank 1.
do i=1,length
 sbuffer(i) = rank + 10.d0
enddo

! Start timing the parallel part here.
call MPI_BARRIER(comm,ierr)                                           
tstart = MPI_Wtime()

do i=1,numiter
 if (rank.eq.0)then
  call MPI_SSEND(sbuffer(1),length,MPI_REAL,1,tag1,comm,ierr)
  call MPI_RECV(sbuffer(1),length,MPI_REAL,1,tag2,comm,status,ierr)

 else if (rank.eq.1)then
  call MPI_RECV(sbuffer(1),length,MPI_REAL,0,tag1,comm,status,ierr)
  call MPI_SSEND(sbuffer(1),length,MPI_REAL,0,tag2,comm,ierr)
 endif
enddo


tstop = MPI_Wtime()
time  = tstop - tstart

call MPI_TYPE_SIZE(MPI_REAL,extent,ierr)

if(rank.eq.0)then
 totmess = 2.d0*extent*length/1024.d0*numiter/1024.d0
 write(*,*) ' Ping-Pong of twice ',extent*length,' bytes, for ',numiter,' times.'
 write(*,*) 'Total computing time is ',time,' [s].'
 write(*,*) 'Total message size is ',totmess,' [MB].'
 write(*,*) 'Latency (time per message) is ', time/numiter*0.5d0,'[s].'
 write(*,*) 'Bandwidth (message per time) is ',totmess/time,' [MB/s].'

 if(time.lt.1.d0)then
  write(*,*) 'WARNING: The time is too short to be meaningful, increase the number of iterations and/or the array size so time is at least one second!'
    
    
 endif
endif

deallocate(sbuffer)

call MPI_FINALIZE(ierr)

end program pingpong
MPP-solutions/F-MPI/CollComms/0000775000175000017500000000000013207241214014363 5ustar  dshdshMPP-solutions/F-MPI/CollComms/scriptfile0000664000175000017500000000012713207241214016452 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./collcomms

MPP-solutions/F-MPI/CollComms/collcomms.f900000664000175000017500000000206113207241214016672 0ustar  dshdsh!
! perform a global sum of data stored on each process by rotating each piece of data all the
! way round the ring. At each iteration, a process receives some data from the left, adds the 
! value to its running total, then passes the data it has just received on to the right.
!
! Start from code in ../rotate.rotate.f90
!
! Now using an MPI reduction operation to perform the global sum
!

program rotate
implicit none
include 'mpif.h'

integer :: comm, ierr, rank, size, request
integer :: send_status(MPI_STATUS_SIZE), recv_status(MPI_STATUS_SIZE)
integer :: sum, i, passon

comm = MPI_COMM_WORLD

call MPI_INIT(ierr)
call MPI_COMM_RANK(comm,rank,ierr)
call MPI_COMM_SIZE(comm,size,ierr)

sum = 0
! Initialise local values to:
passon = (rank+1)**2
! Alternatively use
! passon = rank

! Use collective reduction operation to perform global sum

!call MPI_REDUCE(passon,sum,1,MPI_INTEGER,MPI_SUM,0,comm,ierr)
call MPI_ALLREDUCE(passon,sum,1,MPI_INTEGER,MPI_SUM,comm,ierr)

write(*,*)'The sum is:', sum,' on processor ',rank

call MPI_FINALIZE(ierr)

end program rotate
MPP-solutions/F-MPI/CollComms/Makefile0000664000175000017500000000050413207241214016022 0ustar  dshdshMF=	Makefile

FC=	mpif90
FFLAGS=	

LFLAGS=

EXE=	collcomms

SRC= \
	collcomms.f90	

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .f90 .o

OBJ=	$(SRC:.f90=.o)

.f90.o:
	$(FC) $(FFLAGS) -c $<

all:	$(EXE)

$(EXE):	$(OBJ)
	$(FC) $(FFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-solutions/F-MPI/Rotate/0000775000175000017500000000000013207241214013731 5ustar  dshdshMPP-solutions/F-MPI/Rotate/scriptfile0000664000175000017500000000012413207241214016015 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./rotate

MPP-solutions/F-MPI/Rotate/rotate.f900000664000175000017500000000236313207241214015553 0ustar  dshdsh!
! perform a global sum of data stored on each process by rotating each piece of data all the
! way round the ring. At each iteration, a process receives some data from the left, adds the 
! value to its running total, then passes the data it has just received on to the right.
!

program rotate
implicit none
include 'mpif.h'

integer :: comm, ierr, rank, size, request,tag
integer :: send_status(MPI_STATUS_SIZE), recv_status(MPI_STATUS_SIZE)
integer :: left, right, addon, sum, i, passon

comm = MPI_COMM_WORLD
tag = 1

call MPI_INIT(ierr)
call MPI_COMM_RANK(comm,rank,ierr)
call MPI_COMM_SIZE(comm,size,ierr)

! Send current number to the right and receive from the left
left = rank - 1
right = rank + 1

if ((rank+1).eq.size)then
 right = 0
endif
if(rank.eq.0)then
 left = size -1
endif

sum = 0
! Initialise local values to:
passon = (rank+1)**2
! Alternatively use
! passon = rank

! Use non-blocking point-to-point communication 
do i=1,size

 call MPI_ISSEND(passon,1,MPI_INTEGER,right,tag,comm,request,ierr)
 call MPI_RECV(addon,1,MPI_INTEGER,left,tag,comm,recv_status,ierr)
 call MPI_WAIT(request,send_status,ierr)

 sum = sum + addon
 passon = addon

enddo

write(*,*)'The sum is:', sum,' on processor', rank

call MPI_FINALIZE(ierr)

end program rotate
MPP-solutions/F-MPI/Rotate/Makefile0000664000175000017500000000047613207241214015400 0ustar  dshdshMF=	Makefile

FC=	mpif90
FFLAGS=	

LFLAGS=

EXE=	rotate

SRC= \
	rotate.f90	

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .f90 .o

OBJ=	$(SRC:.f90=.o)

.f90.o:
	$(FC) $(FFLAGS) -c $<

all:	$(EXE)

$(EXE):	$(OBJ)
	$(FC) $(FFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-solutions/F-MPI/DerivedDataTypes/0000775000175000017500000000000013207241214015674 5ustar  dshdshMPP-solutions/F-MPI/DerivedDataTypes/scriptfile0000664000175000017500000000012513207241214017761 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 7
mpiexec -n $NSLOTS ./derdaty

MPP-solutions/F-MPI/DerivedDataTypes/scriptfile-pingpong0000664000175000017500000000013513207241214021601 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 2
mpiexec -n $NSLOTS ./pingpong-derdaty
MPP-solutions/F-MPI/DerivedDataTypes/pingpong-derdaty.f900000664000175000017500000000451713207241214021476 0ustar  dshdsh!
! Program in which 2 processes repeatedly pass a M rows of a NxN matrix back and forth
!
!

program pingpong
implicit none
include 'mpif.h'

integer :: ierr, size, rank, comm, i, length, j
integer :: status(MPI_STATUS_SIZE)
real :: buffer(100000)
integer, parameter :: iter =3      ! Number of ping pongs to be executed
integer, parameter :: M=2,N=4,ColStart=2  ! M number of rows to be sent together, N number of coulumns, ColStart start row
integer :: mrowtype                ! new type to be created
double precision, dimension(N,N) :: sendmatrix, recvmatrix

comm = MPI_COMM_WORLD

call MPI_INIT(ierr)
call MPI_COMM_RANK(comm,rank,ierr)
call MPI_COMM_SIZE(comm,size,ierr)

! Code  must only run on 2 processors.
if(size.ne.2)then
 if(rank.eq.0) write(*,*) ' The code can only be run on 2 processors.'
 call MPI_FINALIZE(ierr)
 stop
endif

! Number of rows must not exceed number of coulumns, and start row to be sent must not exceed N.
if(M.gt.N.or.ColStart.gt.N.or.(ColStart+M).gt.(N+1))then
 write(*,*) 'The number of rows MUST NOT be bigger than the number of coulumns: ',M, N, ColStart
 call MPI_FINALIZE(ierr)
 stop
endif

! Create new datatype mrowtype to send M rows and commit it.
call MPI_TYPE_VECTOR(N,M,N,MPI_DOUBLE_PRECISION,mrowtype,ierr)
call MPI_TYPE_COMMIT(mrowtype,ierr)

! Initialize matrix.
do j = 1, N
 do i = 1, N
  sendmatrix(i,j) = i*10**(j-1)+rank
  write(*,*)'Intitialized matrix on rank ',rank,':',i,j, sendmatrix(i,j)
 enddo
enddo

! E.g. sending rows 4, 5 and 6 of a matrix back and forth between rank 0 and rank 1
! corresponds to ColStart = 4, M = 3

do i = 1, iter
 if (rank.eq.0)then

  call MPI_SSEND(sendmatrix(ColStart,1),1,mrowtype,1,50,comm,ierr)
  call MPI_RECV(recvmatrix(ColStart,1),1,mrowtype,1,60,comm,status,ierr)

 else

  call MPI_RECV(recvmatrix(ColStart,1),1,mrowtype,0,50,comm,status,ierr)
  call MPI_SSEND(sendmatrix(ColStart,1),1,mrowtype,0,60,comm,ierr)

 endif

 sendmatrix(ColStart:ColStart+M,1:N) = recvmatrix(ColStart:ColStart+M,1:N)

enddo

! Matrix after iter ping-pongs
do j=1,N
 do i=1,N
  write(*,*) 'Matrix in the end on rank ',rank,':', i,j,sendmatrix(i,j)
 enddo
enddo

if(rank.eq.0)then
 write(*,30) M,N,N,ColStart,iter
endif

30 format (1x, 'Sending ', i3 ,'  column(s) of an ', i3, ' x ', i3, ' matrix, starting with column ', i3 ,' and sending it ',i6,' times.')

call MPI_FINALIZE(ierr)

end program pingpong
MPP-solutions/F-MPI/DerivedDataTypes/Makefile0000664000175000017500000000050013207241214017327 0ustar  dshdshMF=	Makefile

FC=	mpif90
FFLAGS=	

LFLAGS=

EXE=	derdaty

SRC= \
	derdaty.f90	

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .f90 .o

OBJ=	$(SRC:.f90=.o)

.f90.o:
	$(FC) $(FFLAGS) -c $<

all:	$(EXE)

$(EXE):	$(OBJ)
	$(FC) $(FFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-solutions/F-MPI/DerivedDataTypes/derdaty.f900000664000175000017500000000422613207241214017654 0ustar  dshdsh!
! Rotate exercise from ../Rotate/rotate.f90 with derived data types
!
! Using MPI_GET_ADDRESS and MPI_TYPE_CREATE_STRUCT (MPI2)
! instead of MPI_ADDRESS and MPI_TYPE_COMMIT (MPI1)
!

program derdaty
implicit none
include 'mpif.h'

type compound
 integer :: ival
 double precision :: dval
end type compound 

! introduce new variables related to derived datatypes
type(compound) :: passon,addon,sum
integer :: blocklen(2), type(2)
integer (MPI_ADDRESS_KIND), dimension(2) :: disp
integer (MPI_ADDRESS_KIND) :: base
integer :: newtype

! old variables as already used for the rotate.f90 code
integer :: comm, ierr, rank, size, request
integer :: send_status(MPI_STATUS_SIZE), recv_status(MPI_STATUS_SIZE)
integer :: left, right, i, tag

comm = MPI_COMM_WORLD
tag = 1

call MPI_INIT(ierr)
call MPI_COMM_RANK(comm,rank,ierr)
call MPI_COMM_SIZE(comm,size,ierr)

! Must be run on more than 1 processor
if(size.eq.1)then
 write(*,*) 'Must be run on more than 1 processor.'
 call MPI_FINALIZE(ierr)
 stop
endif
 
! Create all necessary info for the derived datatype
call MPI_GET_ADDRESS(passon%ival,disp(1),ierr)
call MPI_GET_ADDRESS(passon%dval,disp(2),ierr)

base = disp(1)
disp(1) = disp(1) - base
disp(2) = disp(2) - base

blocklen(1) = 1
blocklen(2) = 1

type(1) = MPI_INTEGER
type(2) = MPI_DOUBLE_PRECISION

! Create the new datatype, called 'newtype' and commit it
call MPI_TYPE_CREATE_STRUCT(2,blocklen,disp,type,newtype,ierr)
call MPI_TYPE_COMMIT(newtype,ierr)

! Send current number to the right and receive from the left
left = rank - 1
right = rank + 1

if ((rank+1).eq.size)then
 right = 0
elseif(rank.eq.0)then
 left = size -1
endif

sum%ival = 0
sum%dval = 0.0

! Initialise local values to:
passon%ival = rank
passon%dval = (rank+1)**2

! Use non-blocking point-to-point communication 
do i=1,size

 call MPI_ISSEND(passon,1,newtype,right,tag,comm,request,ierr)
 call MPI_RECV(addon,1,newtype,left,tag,comm,recv_status,ierr)
 call MPI_WAIT(request,send_status,ierr)

sum%ival = sum%ival + addon%ival
sum%dval = sum%dval + addon%dval
passon%ival = addon%ival
passon%dval = addon%dval

enddo

write(*,*)'The sum is:', sum,' on processor', rank

call MPI_FINALIZE(ierr)

end program derdaty
MPP-solutions/F-MPI/DerivedDataTypes/Makefile-pingpong0000664000175000017500000000052213207241214021152 0ustar  dshdshMF=	Makefile

FC=	mpif90
FFLAGS=	

LFLAGS=

EXE=	pingpong-derdaty

SRC= \
	pingpong-derdaty.f90	

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .f90 .o

OBJ=	$(SRC:.f90=.o)

.f90.o:
	$(FC) $(FFLAGS) -c $<

all:	$(EXE)

$(EXE):	$(OBJ)
	$(FC) $(FFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-solutions/F-MPI/Helloworld/0000775000175000017500000000000013207241214014606 5ustar  dshdshMPP-solutions/F-MPI/Helloworld/scriptfile0000664000175000017500000000012713207241214016675 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./helloworld
MPP-solutions/F-MPI/Helloworld/Makefile0000664000175000017500000000050613207241214016247 0ustar  dshdshMF=	Makefile

FC=	mpif90
FFLAGS=	

LFLAGS=

EXE=	helloworld

SRC= \
	helloworld.f90	

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .f90 .o

OBJ=	$(SRC:.f90=.o)

.f90.o:
	$(FC) $(FFLAGS) -c $<

all:	$(EXE)

$(EXE):	$(OBJ)
	$(FC) $(FFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-solutions/F-MPI/Helloworld/helloworld.f900000664000175000017500000000115013207241214017276 0ustar  dshdsh!
! Prints 'Hello World' from rank 0 and                                                                       ! prints what processor it is out of the total number of processors from all ranks   
!

program helloworld
implicit none
include  "mpif.h"

integer :: comm, rank, size, ierr

comm = MPI_COMM_WORLD

call MPI_INIT(ierr)

call MPI_COMM_RANK(comm, rank, ierr)
call MPI_COMM_SIZE(comm, size, ierr)

! Each process prints out its rank
write(*,*) 'I am ', rank, 'out of ', size,' processors.'

! Only processor 0 prints 
if(rank.eq.0) write(*,*) 'Hello World!.'

call MPI_FINALIZE(ierr)

end program helloworld
MPP-solutions/F-MPI/Pi/0000775000175000017500000000000013207241214013043 5ustar  dshdshMPP-solutions/F-MPI/Pi/scriptfile0000664000175000017500000000011713207241214015131 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./pi
MPP-solutions/F-MPI/Pi/Makefile0000775000175000017500000000046413207241214014512 0ustar  dshdshMF=	Makefile

FC=	mpif90
FFLAGS=

LFLAGS=

EXE=	pi

SRC= \
	pi.f90

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .f90 .o

OBJ=	$(SRC:.f90=.o)

.f90.o:
	$(FC) $(FFLAGS) -c $<

all:	$(EXE)

$(EXE):	$(OBJ)
	$(FC) $(FFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-solutions/F-MPI/Pi/pi.f900000664000175000017500000000422513207241214013776 0ustar  dshdshprogram piparallel

  use mpi

  implicit none

  integer, parameter :: N = 840

  double precision :: pi, exactpi

  integer :: i

! MPI variables

  integer :: comm, rank, size, source, tag, ierr
  integer, dimension(MPI_STATUS_SIZE) :: status

! Other local variables

  integer :: istart, istop
  double precision :: partialpi, recvpi

  write(*,*) 'Computing approximation to pi using N = ', N

! Initialise MPI and compute number of processes and local rank

  comm = MPI_COMM_WORLD

  call MPI_INIT(ierr)

  call MPI_COMM_SIZE(comm, size, ierr)
  call MPI_COMM_RANK(comm, rank, ierr)


! Now make sure output only comes from one process

  if (rank == 0) write(*,*) 'Running on ', size, ' process(es)'

  partialpi = 0.0d0

!  Compute an approximation to pi using a simple series expansion for pi/4
!  Ensure each process computes a separate section of the summation
!  NOTE: here I assume that N is exactly divisible by the number of processes

  istart = N/size * rank + 1
  istop  = istart + N/size - 1


  do i = istart, istop

     partialpi = partialpi + 1.0d0/(1.0d0+((dble(i)-0.5d0)/dble(N))**2)

  end do

  write(*,*) 'On rank ', rank, ' partialpi = ', partialpi * 4.0d0/dble(N)

! Compute global value of pi by sending partial values to rank 0
! NOTE: this would be more efficiently done using MPI_REDUCE

  if (rank == 0) then

! initialise pi to locally computed partial sum

    pi = partialpi

! add in contributions from other processes

    do source = 1, size-1

! receive partialpi from rank=source and place value in recvpi
! all messages are tagged as zero

       tag = 0

       call MPI_RECV(recvpi, 1, MPI_DOUBLE_PRECISION, source, &
                     tag, comm, status, ierr)

! add to running total

       pi = pi + recvpi

    end do

  else

! all other processes send their partial value to rank 0

     tag = 0

     call MPI_SSEND(partialpi, 1, MPI_DOUBLE_PRECISION, 0, &
                    tag, comm, ierr)
  end if

  pi = pi * 4.0d0/dble(N)

  exactpi = 4.0d0*atan(1.0d0)

  if (rank == 0) then
     write(*,*) 'pi = ', pi, ', % error = ', abs(100.0d0*(pi-exactpi)/exactpi)
  end if

! Finalise MPI

  call MPI_FINALIZE(ierr)

end program piparallel
MPP-solutions/C-MPI/0000775000175000017500000000000013207241214012470 5ustar  dshdshMPP-solutions/C-MPI/CartesTopology/0000775000175000017500000000000013207241214015446 5ustar  dshdshMPP-solutions/C-MPI/CartesTopology/scriptfile0000664000175000017500000000012313207241214017531 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./rotate
MPP-solutions/C-MPI/CartesTopology/scriptfile-scan0000664000175000017500000000012213207241214020452 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./scan

MPP-solutions/C-MPI/CartesTopology/Makefile0000664000175000017500000000045013207241214017105 0ustar  dshdsh# Makefile for Rotate code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	mpicc
LIB=	-lm

#
# Object files
#
OBJ=	rotate.o 

#
# Compile
#
rotate:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o rotate
MPP-solutions/C-MPI/CartesTopology/scan.c0000664000175000017500000000157413207241214016545 0ustar  dshdsh//
// perform a global sum of data stored on each process by rotating each piece of data all the
// way round the ring. At each iteration, a process receives some data from the left, adds the 
// value to its running total, then passes the data it has just received on to the right.
//
// Use virtual topologies, here cartesian 1D, like in rotate.c and MPI_Scan
//

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <mpi.h>


int main(){

  int rank, size;
  int passon, sum;
  MPI_Comm comm;

  comm  = MPI_COMM_WORLD;

  MPI_Init(NULL,NULL);

  MPI_Comm_size(comm, &size); 
  MPI_Comm_rank(comm,&rank);

  sum = 0;

  // Initialise local values to:
  passon = (rank+1)*(rank+1);

  //  Alternatively use
  // passon = rank;

  // Use MPI_scan

  MPI_Scan(&passon,&sum,1,MPI_INT,MPI_SUM,comm);


  printf( "The sum is: %d on processor %d \n",sum, rank);
  MPI_Finalize();

}
MPP-solutions/C-MPI/CartesTopology/rotate.c0000664000175000017500000000333013207241214017107 0ustar  dshdsh//
// perform a global sum of data stored on each process by rotating each piece of data all the
// way round the ring. At each iteration, a process receives some data from the left, adds the 
// value to its running total, then passes the data it has just received on to the right.
//
// previous version in ../rotate/rotate.c
//
// Use virtual topologies, here cartesian 1D
//

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <mpi.h>

#define TRUE  1
#define FALSE 0
#define ndims 1    

int main(){
  // New variables required
  int comm1d,direction,disp;
  int dims[ndims];
  int period[ndims];
  int reorder;
  // Variables as before
  int rank, size,tag;
  int start,stop,i;
  int left, right, addon, passon, sum;
  MPI_Comm comm;
  MPI_Status status;
  MPI_Request request;

  comm  = MPI_COMM_WORLD;
  tag =1;

  MPI_Init(NULL,NULL);

  MPI_Comm_size(comm, &size); 

  // Cartesian topology
  dims[0] = 0;
  period[0] = TRUE;    // TRUE, Cyclic
  reorder = FALSE;      // FALSE
  direction = 0;       // shift along the first index
  disp = 1;            // Shift by 1

  MPI_Dims_create(size,ndims,dims);
  MPI_Cart_create(comm,ndims,dims,period,reorder,&comm1d);
  MPI_Comm_rank(comm1d,&rank);
  MPI_Cart_shift(comm1d,direction,disp,&left,&right);

  sum = 0;

  // Initialise local values to:
  passon = (rank+1)*(rank+1);

  //  Alternatively use
  // passon = rank;

  // Use non-blocking point-to-point communication

  for(i=0;i<size;i++){
    MPI_Issend(&passon,1,MPI_INT,right,tag,comm1d,&request);
    MPI_Recv(&addon,1,MPI_INT,left,tag,comm1d,&status);
    MPI_Wait(&request,&status);

    sum = sum + addon;
    passon = addon;

  }


  printf( "The sum is: %d on processor %d \n",sum, rank);
  MPI_Finalize();

}
MPP-solutions/C-MPI/CartesTopology/Makefile-scan0000664000175000017500000000044213207241214020030 0ustar  dshdsh# Makefile for Rotate code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	mpicc
LIB=	-lm

#
# Object files
#
OBJ=	scan.o 

#
# Compile
#
scan:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o scan
MPP-solutions/C-MPI/PingPong/0000775000175000017500000000000013207241214014211 5ustar  dshdshMPP-solutions/C-MPI/PingPong/scriptfile0000664000175000017500000000012513207241214016276 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./pingpong
MPP-solutions/C-MPI/PingPong/Makefile-default0000664000175000017500000000050113207241214017267 0ustar  dshdsh# Makefile for PingPong code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	mpicc
LIB=	-lm

SRC=	pingpong.c 
#
# Object files
#
OBJ=$(SRC:.c=.o)

#
# Compile
#
pingpong:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o pingpong
MPP-solutions/C-MPI/PingPong/pingpong.c0000664000175000017500000000544613207241214016207 0ustar  dshdsh//
//  Program in which 2 processes repeatedly pass a message back and forth
//
// The same data is sent from A to B, then returned from B to A.
//
// Corrected July 2010 ($HOME/mail/EPCC/NAIS/DSH)
//

#include <stdlib.h>
#include <stdio.h>
#include <mpi.h>

int main(int argc, char* argv[]){
  int rank, size, numiter,length;
  int start,stop,i,iter;
  int tag1, tag2,extent;
  double *sbuffer;
  double t1, t2,totmess;
  MPI_Comm comm;
  MPI_Status status;

  comm  = MPI_COMM_WORLD;
  tag1= 1;
  tag2 = 2;

  MPI_Init(&argc, &argv);
  MPI_Comm_rank(comm, &rank);            
  MPI_Comm_size(comm, &size); 

  // Abort if run on less than 2 processors.
  if(size < 2){
    if(rank == 0){
      printf("The code must be run on at least 2 processors.\n");
    }
    MPI_Finalize();
    exit(1);
  }
  
  if(argc < 2) {
    if(rank == 0){
     printf("Code requires 2 input arguments: The array length and the number of iterations. \n");
    }
    MPI_Finalize();
  exit(1);
  }

  if(rank > 1){
    printf( "Rank %d not participating \n",rank);
  }

  if (rank == 0) {
    length = atoi(argv[1]);
    numiter = atoi(argv[2]);
    printf("Array length = %d , number of iterations = %d\n",length,numiter);
  }

  MPI_Bcast(&length,1,MPI_INT,0,comm);
  MPI_Bcast(&numiter,1,MPI_INT,0,comm);


  // Allocate array
  sbuffer = malloc(length*sizeof(double));
 
  // Send 'buffer' back and forth between rank 0 and rank 1.
  for(i=0;i<length;i++)
    sbuffer[i] = (double)rank + 10.0;

  // Time the parallel execution.
  MPI_Barrier(comm);
  t1 = MPI_Wtime();

  // Swap back and forth for iter times

  for(iter=1;iter<numiter;iter++){

  if(rank == 0){

  // Timings only make sense when no print statements are includes!

   MPI_Ssend(&sbuffer[0],length,MPI_DOUBLE,1,tag1,comm);
   MPI_Recv(&sbuffer[0],length,MPI_DOUBLE,1,tag2,comm,&status);
  }

 else if(rank == 1){

   MPI_Recv(&sbuffer[0],length,MPI_DOUBLE,0,tag1,comm,&status);
   MPI_Ssend(&sbuffer[0],length,MPI_DOUBLE,0,tag2,comm);

   }
  }   //end of for loop



  t2 = MPI_Wtime();

  // Extent of an MPI_DOUBLE on this machine

  MPI_Type_size(MPI_DOUBLE,&extent);

  if(rank == 0){
    // Each iteration comprises two messages
    // A MB os 1024*1024 bytes
   totmess = 2.0*extent*length/1024*numiter/1024;
   printf( "Ping-Pong of twice %d bytes, for %d times \n",extent*length,numiter);
   printf( "Total computing time is %f [s]\n", t2 - t1 );
   printf( "Total message size is %f [MB] \n", totmess );
   printf( "Latency (time per message) is %f [s]\n",  0.5*(t2-t1)/numiter);
   printf( "Bandwidth (message size per time) is %f [MB/s]\n",  totmess/(t2-t1));
   
   if((t2-t1)<1.0)
     
     printf( "WARNING: The time is too short to be meaningful, increase the number of iterations and/or the array size so time is at least one second!\n");
  }

  free(sbuffer);

  MPI_Finalize();

}
MPP-solutions/C-MPI/PingPong/Makefile0000664000175000017500000000055213207241214015653 0ustar  dshdsh# Makefile for PingPong code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	/opt/usr/multi/multi_apps_bin/mpich2/bin/mpicc
LIB=	-lm

SRC=	pingpong.c 
#
# Object files
#
OBJ=$(SRC:.c=.o)

#
# Compile
#
pingpong:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o pingpong
MPP-solutions/C-MPI/CollComms/0000775000175000017500000000000013207241214014360 5ustar  dshdshMPP-solutions/C-MPI/CollComms/scriptfile0000664000175000017500000000012613207241214016446 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./collcomms
MPP-solutions/C-MPI/CollComms/collcomms.c0000664000175000017500000000204113207241214016511 0ustar  dshdsh//
// perform a global sum of data stored on each process by rotating each piece of data all the
// way round the ring. At each iteration, a process receives some data from the left, adds the 
// value to its running total, then passes the data it has just received on to the right.
//
// Start from code in ../Rotate/rotate.c
//
//  Now using an MPI reduction operation to perform the global sum
//

#include <stdlib.h>
#include <stdio.h>
#include <mpi.h>

int main(){
  int rank, size;
  int start,stop,i;
  int passon, sum;
  MPI_Comm comm;
  MPI_Status status;
  MPI_Request request;

  comm  = MPI_COMM_WORLD;

  MPI_Init(NULL,NULL);
  MPI_Comm_rank(comm, &rank);            
  MPI_Comm_size(comm, &size); 

  sum = 0;

  // Initialise local values to:
  passon = (rank+1)*(rank+1);

  //  Alternatively use
  // passon = rank;


  // Use MPI reduction operation

  //MPI_Reduce(&passon,&sum,1,MPI_INT,MPI_SUM,0,comm);
  MPI_Allreduce(&passon,&sum,1,MPI_INT,MPI_SUM,comm);

  printf( "The sum is: %d on processor %d\n",sum,rank);

  MPI_Finalize();

}
MPP-solutions/C-MPI/CollComms/Makefile0000664000175000017500000000050513207241214016020 0ustar  dshdsh# Makefile for Collective Communications code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	mpicc
LIB=	-lm

#
# Object files
#
OBJ=	collcomms.o 

#
# Compile
#
collcomms:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o collcomms

MPP-solutions/C-MPI/Rotate/0000775000175000017500000000000013207241214013726 5ustar  dshdshMPP-solutions/C-MPI/Rotate/scriptfile0000664000175000017500000000012313207241214016011 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./rotate
MPP-solutions/C-MPI/Rotate/Makefile0000664000175000017500000000045613207241214015373 0ustar  dshdsh# Makefile for Rotate code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	mpicc
LIB=	-lm

#
# Object files
#
OBJ=	rotate.o 

#
# Compile
#
rotate:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o rotate core

MPP-solutions/C-MPI/Rotate/rotate.c0000664000175000017500000000241713207241214015374 0ustar  dshdsh//
// perform a global sum of data stored on each process by rotating each piece of data all the
// way round the ring. At each iteration, a process receives some data from the left, adds the 
// value to its running total, then passes the data it has just received on to the right.
//

#include <stdlib.h>
#include <stdio.h>
#include <mpi.h>

int main(){
  int rank, size, tag;
  int start,stop,i;
  int left, right, addon, passon, sum;
  MPI_Comm comm;
  MPI_Status status;
  MPI_Request request;

  comm  = MPI_COMM_WORLD;

  tag = 1;

  MPI_Init(NULL,NULL);
  MPI_Comm_rank(comm, &rank);            
  MPI_Comm_size(comm, &size); 

  //Send current number to the right and receive from the left
  left = rank -1;
  right = rank + 1;
  if ((rank+1) == size){
    right = 0;
  }
  if(rank == 0){
    left = size - 1;
  }

  sum = 0;

  // Initialise local values to:
  passon = (rank+1)*(rank+1);

  //  Alternatively use
  // passon = rank;

  // Use non-blocking point-to-point communication

  for(i=0;i<size;i++){
    MPI_Issend(&passon,1,MPI_INT,right,tag,comm,&request);
    MPI_Recv(&addon,1,MPI_INT,left,tag,comm,&status);
    MPI_Wait(&request,&status);

    sum = sum + addon;
    passon = addon;

  }


  printf( "The sum is: %d on processor %d \n",sum, rank);
  MPI_Finalize();

}
MPP-solutions/C-MPI/DerivedDataTypes/0000775000175000017500000000000013207241214015671 5ustar  dshdshMPP-solutions/C-MPI/DerivedDataTypes/scriptfile0000664000175000017500000000012413207241214017755 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./derdaty
MPP-solutions/C-MPI/DerivedDataTypes/derdaty.c0000664000175000017500000000420313207241214017470 0ustar  dshdsh//
// Rotate exercise from ../Rotate/rotate.c with derived data types                              
//
// Using MPI_GET_ADDRESS and MPI_TYPE_CREATE_STRUCT (MPI2)                                             
// instead of MPI_ADDRESS and MPI_TYPE_COMMIT (MPI1)    
//

#include <stdlib.h>
#include <stdio.h>
#include <mpi.h>

struct compound{
  int ival;
  double dval;
};


int main(){

  struct compound passon,addon,sum;
  int rank, size,tag;
  int start,stop,i;
  int left, right;
  MPI_Comm comm;
  MPI_Status status;
  MPI_Request request;
  // introduce new variables related to derived datatypes
  int length[2] = {1,1};
  MPI_Aint disp[2],base;
  MPI_Datatype type[2], newtype;

  comm  = MPI_COMM_WORLD;
  tag = 1;

  MPI_Init(NULL,NULL);
  MPI_Comm_rank(comm, &rank);            
  MPI_Comm_size(comm, &size); 

  // Must be run on more than 1 procesor.
  if (size == 1)
    {
      printf("Must be run on more than 1 processor.\n");
      MPI_Finalize();
      exit(1);
    }

  // Create all necessary info for the derived datatype
  MPI_Get_address(&passon.ival, &disp[0]);
  MPI_Get_address(&passon.dval, &disp[1]);

  base = disp[0];
  disp[0] = disp[0] - base;
  disp[1] = disp[1] -base;

  type[0] = MPI_INT;
  type[1] = MPI_DOUBLE;

  // Create the new datatype, called 'newtype' and commit it
  MPI_Type_create_struct(2,length,disp,type,&newtype);
  MPI_Type_commit(&newtype);

  //Send current number to the right and receive from the left
  left = rank -1;
  right = rank + 1;
  if ((rank+1) == size){
    right = 0;
  }
  else if(rank == 0){
    left = size - 1;
  }

  sum.ival = 0;
  sum.dval = 0.0;

  // Initialise local values to:
  passon.ival = rank;
  passon.dval = (rank+1)*(rank+1);

  // Use non-blocking point-to-point communication

  for(i=0;i<size;i++){
    MPI_Issend(&passon,1,newtype,right,tag,comm,&request);
    MPI_Recv(&addon,1,newtype,left,tag,comm,&status);
    MPI_Wait(&request,&status);

    sum.ival = sum.ival + addon.ival;
    sum.dval = sum.dval + addon.dval;
    passon.ival = addon.ival;
    passon.dval = addon.dval;

  }


   printf( "The sums are: %d %f on processor %d \n",sum.ival,sum.dval, rank);
  MPI_Finalize();

}
MPP-solutions/C-MPI/DerivedDataTypes/pingpong-derdaty.c0000664000175000017500000000554313207241214021317 0ustar  dshdsh//
//  Program in which 2 processes repeatedly pass M columns of a matrix back and forth
//
// The number/array swapped changes from swap to swap; from back and forth.
//

#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <mpi.h>

#define N  4    // For an NxN matrix
#define M  1    // Number of columns to be sent together
#define ColStart  2    // where ColStart is the start column
#define itmax 4 // Number of iterations = itmax - 1

int main(int argc, char* argv[]){
  int rank, size, ierr,length;
  int start,stop,i,j,iter;    
  double rbuffer,sbuffer;
  MPI_Comm comm;
  MPI_Status status;

  double sendmatrix[N][N], recvmatrix[N][N];
  MPI_Datatype mcoltype;


  comm  = MPI_COMM_WORLD;

  ierr = MPI_Init(&argc, &argv);
  MPI_Comm_rank(comm, &rank);            
  MPI_Comm_size(comm, &size); 

  // Abort if not run on 2 processors.
  if(size != 2){
    if(rank == 0){
      printf("The code can only be run on 2 processors.\n");
    }
    MPI_Finalize();
    exit(1);
  }

  // Number of rows must not exceed number of coulumns, and start row to be sent must not exceed N.
  if(M > N || ColStart > N ||(ColStart+M) > (N+1)){
    printf("The number of rows MUST NOT be bigger than the number of coulumns: M=%d, N=%d, ColStart=%d \n",M,N,ColStart);
    MPI_Finalize();
    exit(1);
  }

  // Create new datatype mrowtype to send M columns and commit it.
  MPI_Type_vector(N,M,N,MPI_DOUBLE,&mcoltype);
  MPI_Type_commit(&mcoltype);

  // Initialize matrix
  for(i=0;i<N;i++){
    for(j=0;j<N;j++){
      sendmatrix[i][j] = (i+1)*pow(10,j)+rank;
      printf("Matrix intialized on rank %d: i=%d, j=%d, element=%f \n",rank,i,j,sendmatrix[i][j]);
    }
  }

  //E.g. sending columns 4, 5 and 6 of a matrix 10x10 back and forth between rank 0 and rank 1
  // corresponds to ColStart = 4, M = 3, N = 10

  for(iter=1;iter<itmax;iter++){
   if(rank == 0){

    for(i=0;i<N;i++){
     for(j=ColStart;j<(ColStart+M);j++){
     }
    }

    MPI_Ssend(&(sendmatrix[0][ColStart-1]),1,mcoltype,1,50,comm);
    MPI_Recv(&(recvmatrix[0][ColStart-1]),1,mcoltype,1,60,comm,&status);
   }
   else{

    for(i=0;i<N;i++){
     for(j=ColStart;j<(ColStart+M);j++){
     }
    }

    MPI_Recv(&(recvmatrix[0][ColStart-1]),1,mcoltype,0,50,comm,&status);
    MPI_Ssend(&(sendmatrix[0][ColStart-1]),1,mcoltype,0,60,comm);

   }

   for(i=0;i<N;i++){
    for(j=ColStart;j<(ColStart+M);j++){
     sendmatrix[i][j-1] = recvmatrix[i][j-1];
    }
   }
  }


  // Matrix after itmax ping-pongs                                                                                   
  for(i=0;i<N;i++){
   for(j=0;j<N;j++){
    printf("Matrix in the end on rank %d: i=%d, j=%d, element=%f \n",rank,i,j,sendmatrix[i][j]);
   }
  }

  if(rank == 0){
    printf("Sending %d column(s) of an %d x %d matrix, starting with column %d and sending it %d times.\n",M,N,N,ColStart,itmax-1);
  }

  MPI_Finalize();

}
MPP-solutions/C-MPI/DerivedDataTypes/Makefile0000664000175000017500000000047713207241214017341 0ustar  dshdsh# Makefile for Collective Communications code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	mpicc
LIB=	-lm

#
# Object files
#
OBJ=	derdaty.o 

#
# Compile
#
derdaty:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o derdaty

MPP-solutions/C-MPI/DerivedDataTypes/Makefile-pingpong0000664000175000017500000000055013207241214021150 0ustar  dshdsh# Makefile for Collective Communications with pingpong code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	mpicc
LIB=	-lm

#
# Object files
#
OBJ=	pingpong-derdaty.o 

#
# Compile
#
pingpong-derdaty:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o pingpong-derdaty

MPP-solutions/C-MPI/Helloworld/0000775000175000017500000000000013207241214014603 5ustar  dshdshMPP-solutions/C-MPI/Helloworld/scriptfile0000664000175000017500000000012713207241214016672 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./helloworld
MPP-solutions/C-MPI/Helloworld/Makefile0000664000175000017500000000047013207241214016244 0ustar  dshdsh# Makefile for helloworld code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	mpicc
LIB=	-lm

#
# Object files
#
OBJ=	helloworld.o 

#
# Compile
#
helloworld:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o helloworld
MPP-solutions/C-MPI/Helloworld/helloworld.c0000664000175000017500000000105213207241214017120 0ustar  dshdsh//
// Prints 'Hello World' from rank 0 and 
// prints what processor it is out of the total number of processors from all ranks
//

#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>

int main(){
  int rank, size, ierr;
  MPI_Comm comm;

  comm  = MPI_COMM_WORLD;

  MPI_Init(NULL,NULL);
  MPI_Comm_rank(comm, &rank);            
  MPI_Comm_size(comm, &size); 

  // Each process prints out its rank
  printf("I am %d out of %d\n", rank,size);

  // Only processor 0 prints 
  if(rank == 0) {
   printf("Hello World!\n"); 
  }

  MPI_Finalize();

}
MPP-solutions/C-MPI/Pi/0000775000175000017500000000000013207241214013040 5ustar  dshdshMPP-solutions/C-MPI/Pi/scriptfile0000664000175000017500000000011713207241214015126 0ustar  dshdsh#!/bin/bash
#$ -V
#$ -l h_rt=:10:
#$ -cwd
#$ -pe mpi 4
mpiexec -n $NSLOTS ./pi
MPP-solutions/C-MPI/Pi/Makefile0000664000175000017500000000043013207241214014475 0ustar  dshdsh# Makefile for Pi code

#
# Fortran compiler and options
#

#
# C compiler and options
#
CC=	mpicc
LIB=	-lm

#
# Object files
#
OBJ=	pi.o 

#
# Compile
#
pi:	$(OBJ)
	$(CC) -o $@ $(OBJ) $(LIB)

.c.o:
	$(CC) -c $<

#
# Clean out object files and the executable.
#
clean:
	rm *.o pi
MPP-solutions/C-MPI/Pi/pi.c0000664000175000017500000000425013207241214013615 0ustar  dshdsh#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include <mpi.h>

#define N 840

int main(void)
{
  double pi, exactpi;

  int i;

  /* MPI variables */

  MPI_Comm comm;
  MPI_Status status;

  int rank, size, source, tag;

  /* Other variables */

  int istart, istop;
  double partialpi, recvpi;

 
  /* Initialise MPI and compute number of processes and local rank */

  comm = MPI_COMM_WORLD;

  MPI_Init(NULL, NULL);

  MPI_Comm_size(comm, &size);
  MPI_Comm_rank(comm, &rank);

  if(rank == 0){
    printf("Computing approximation to pi using N = %d\n", N);
  }

  /* Now make sure output only comes from one process */

  if (rank == 0) printf("Running on %d process(es)\n", size);

  partialpi = 0.0;

  /*
   * Compute an approximation to pi using a simple series expansion for pi/4
   * Ensure each process computes a separate section of the summation
   * NOTE: here I assume that N is exactly divisible by the number of processes
   */

  istart = N/size * rank + 1;
  istop  = istart + N/size - 1;

  for (i=istart; i<=istop; i++)
    {
      partialpi = partialpi +
	          1.0/( 1.0 + pow( (((double) i)-0.5)/((double) N), 2.0) );
    }

  printf("On rank %d partialpi = %f\n", rank, partialpi*4.0/((double) N));

  /*
   * Compute global value of pi by sending partial values to rank 0 
   * NOTE: this would be more efficiently done using MPI_REDUCE 
   */

  if (rank == 0)
    {
      /* Initialise pi to locally computed parial sum */

      pi = partialpi;

      /* Add in contribution from other processes */

      for (source = 1; source < size; source++)
	{
	  /* receive partialpi from rank=source and place value in recvpi */
	  /* all messages are tagged as zero */

	  tag = 0;

	  MPI_Recv(&recvpi, 1, MPI_DOUBLE, source, tag, comm, &status);

	  /* add to running total */

	  pi = pi + recvpi;
	}
    }
  else
    {
      /* all other processes send their partial value to rank 0 */

      tag = 0;

      MPI_Ssend(&partialpi, 1, MPI_DOUBLE, 0, tag, comm);
    }

  pi = pi * 4.0/((double) N);

  exactpi = 4.0*atan(1.0);
  
  if (rank == 0)
    {
      printf("pi = %f, %% error = %f\n", pi, fabs(100.0*(pi-exactpi)/exactpi));
    }

  MPI_Finalize();

  return 0;
}