MPP-pi.tar

MPP-pi/0000775000175000017500000000000013207241221010232 5ustar  dshdshMPP-pi/C/0000775000175000017500000000000013262644607010434 5ustar  dshdshMPP-pi/C/Makefile0000775000175000017500000000063613262644607012104 0ustar  dshdshMF=	Makefile

# For the DAC
#CC=	mpicc
#CFLAGS=	-O3

# For Cirrus
#CC=	mpicc
#CFLAGS=	-O3 -cc=icc

# For ARCHER
CC=	cc
CFLAGS=

LFLAGS=	-lm

EXE=	piparallel

SRC= \
	piparallel.c

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .c .o

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

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

all:	$(EXE)

$(EXE):	$(OBJ)
	$(CC) $(CFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-pi/C/piparallel.c0000664000175000017500000000457713207241221012722 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;

  printf("Computing approximation to pi using N = %d\n", N);

  /* 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);

  printf("Hello from rank %d\n", rank);

  /* 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;

  printf("On rank %d istart = %d, istop = %d\n", rank, istart, istop);

  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 *any* source and place value in recvpi */
	  /* all messages are tagged as zero */

	  tag = 0;

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

	  printf("rank 0 receiving from rank %d\n", status.MPI_SOURCE);

	  /* add to running total */

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

      tag = 0;

      printf("rank %d sending to rank 0\n", rank);

      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;
}
MPP-pi/C/piserial.c0000664000175000017500000000071413207241221012372 0ustar  dshdsh#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define N 840

int main(void)
{
  double pi, exactpi;

  int i;

  printf("Computing approximation to pi using N = %d\n", N);

  pi = 0.0;

  for (i=1; i<=N; i++)
    {
      pi = pi + 1.0/( 1.0 + pow( (((double) i)-0.5)/((double) N), 2.0) );
    }

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

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

  return 0;
}
MPP-pi/F/0000775000175000017500000000000013262644655010442 5ustar  dshdshMPP-pi/F/piserial.f900000664000175000017500000000077413207241221012557 0ustar  dshdshprogram piserial

  implicit none

  integer, parameter :: N = 840

  double precision :: pi, exactpi

  integer :: i

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

  pi = 0.0d0

!  Compute an approximation to pi using a simple series expansion for pi/4

  do i = 1, N

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

  end do

  pi = pi * 4.0d0/dble(N)

  exactpi = 4.0d0*atan(1.0d0)

  write(*,*) 'pi = ', pi, ', % error = ', abs(100.0d0*(pi-exactpi)/exactpi)

end program piserial
MPP-pi/F/piparallel.f900000664000175000017500000000460713207241221013073 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)

  write(*,*) 'Hello from rank ', rank

! 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

  write(*,*) 'On rank ', rank, ' istart = ', istart, ', istop = ', istop

  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 *any* source and place value in recvpi
! all messages are tagged as zero

       tag = 0

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

       write(*,*) 'rank 0 receiving from rank ', status(MPI_SOURCE)

! add to running total

       pi = pi + recvpi

    end do

  else

! all other processes send their partial value to rank 0

     write(*,*) 'rank ', rank, ' sending 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-pi/F/Makefile0000775000175000017500000000063613262644655012112 0ustar  dshdshMF=	Makefile

# For the DAC

#FC=	mpif90
#FFLAGS=	-O3

# For Cirrus
#FC=	mpif90
#FFLAGS=	-O3

# For ARCHER
FC=	ftn
FFLAGS=

LFLAGS=

EXE=	piparallel

SRC= \
	piparallel.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-pi/C++/0000775000175000017500000000000013262644615010561 5ustar  dshdshMPP-pi/C++/piparallel.cc0000664000175000017500000000470113207241221013200 0ustar  dshdsh#include <cstdlib>
#include <cmath>

#include "mpi.h"

#include <iostream>

using namespace std;

#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;

  cout << "Computing approximation to pi using N = " << N << endl;

  // 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);

  cout << "Hello from rank " << rank << endl;

  // Now make sure output only comes from one process

  if (rank == 0) cout << "Running on " << size << " process(es)" << endl;

  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;

  cout << "On rank " << rank << " istart = " << istart
       << ", istop = " << istop << endl;

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

  cout << "On rank " << rank << " partialpi = " << partialpi << endl;

  //
  // 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, MPI_ANY_SOURCE, tag, comm, &status);

	  cout << "rank 0 receiving from rank " << status.MPI_SOURCE << endl;

	  // add to running total

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

      tag = 0;

      cout << "rank " << rank << " sending to rank 0" << endl;

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

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

  exactpi = 4.0*atan(1.0);
  
  if (rank == 0)
    {
      cout << "pi = " << pi
	   << ", % error = " << fabs(100.0*(pi-exactpi)/exactpi) << endl;
    }

  MPI_Finalize();

  return 0;
}
MPP-pi/C++/Makefile0000775000175000017500000000064613262644615012232 0ustar  dshdshMF=	Makefile

# For the DAC
#CC=	mpicxx
#CFLAGS=	-O3

# For Cirrus
#CC=	mpicxx
#CFLAGS=	-O3 -cxx=icpc

# For ARCHER
CC=	CC
CFLAGS=

LFLAGS=	-lm

EXE=	piparallel

SRC= \
	piparallel.cc

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .cc .o

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

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

all:	$(EXE)

$(EXE):	$(OBJ)
	$(CC) $(CFLAGS) -o $@ $(OBJ) $(LFLAGS)

$(OBJ):	$(MF)

clean:
	rm -f $(OBJ) $(EXE) core
MPP-pi/F08/0000775000175000017500000000000013262644645010611 5ustar  dshdshMPP-pi/F08/piserial.f900000664000175000017500000000077413207241221012727 0ustar  dshdshprogram piserial

  implicit none

  integer, parameter :: N = 840

  double precision :: pi, exactpi

  integer :: i

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

  pi = 0.0d0

!  Compute an approximation to pi using a simple series expansion for pi/4

  do i = 1, N

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

  end do

  pi = pi * 4.0d0/dble(N)

  exactpi = 4.0d0*atan(1.0d0)

  write(*,*) 'pi = ', pi, ', % error = ', abs(100.0d0*(pi-exactpi)/exactpi)

end program piserial
MPP-pi/F08/piparallel.f900000664000175000017500000000522113207241221013234 0ustar  dshdshprogram piparallel

  use mpi_f08

  implicit none

  integer, parameter :: N = 840
  integer :: i

! MPI variables

  integer :: rank, size, source, tag, ierr
  integer :: realsize

  type(MPI_Comm)     :: comm
  type(MPI_Status)   :: status
  type(MPI_Datatype) :: mpirealtype

! Other local variables

  integer :: istart, istop
  real(kind=8) :: pi, exactpi, 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()

  call MPI_Comm_size(comm, size)
  call MPI_Comm_rank(comm, rank)

  write(*,*) 'Hello from rank ', rank

! Now make sure output only comes from one process

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

  partialpi = 0.0d0

! We could just set mpirealtype = MPI_DOUBLE_PRECISION but the
! following code is more general and will still work even if we
! change the Fortran definitions of pi etc. to single precision.

  call MPI_Sizeof(pi, realsize)
  call MPI_Type_match_size(MPI_TYPECLASS_REAL, realsize, mpirealtype)

!  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

  write(*,*) 'On rank ', rank, ' istart = ', istart, ', istop = ', istop

  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 *any* source and place value in recvpi
! all messages are tagged as zero

       tag = 0

       call MPI_Recv(recvpi, 1, mpirealtype, MPI_ANY_SOURCE, &
                     tag, comm, status)

       write(*,*) 'rank 0 receiving from rank ', status%MPI_SOURCE

! add to running total

       pi = pi + recvpi

    end do

  else

! all other processes send their partial value to rank 0

     write(*,*) 'rank ', rank, ' sending to rank 0'

     tag = 0

     call MPI_Ssend(partialpi, 1, mpirealtype, 0, tag, comm)

  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()

end program piparallel
MPP-pi/F08/Makefile0000775000175000017500000000104613262644645012255 0ustar  dshdshMF=	Makefile

# Note the Fortran2008 interface does not currently work on Cirrus
# These settings should work for most MPI versions, e.g. your laptop

# For the DAC
#FC=	mpif90
#FFLAGS=	-O3

# For Cirrus
#FC=	mpif90
#FFLAGS=	-O3

# For ARCHER
FC=	ftn
FFLAGS=

LFLAGS=

EXE=	piparallel

SRC= \
	piparallel.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