diff --git a/lab2/b.data b/lab2/b.data
deleted file mode 100644
index bb0421a096ea75f821f55d3d154b67b00480abe6..0000000000000000000000000000000000000000
--- a/lab2/b.data
+++ /dev/null
@@ -1,301 +0,0 @@
- 10
- 35
- -19
- -46
- -2
- -50
- 8
- 42
- -47
- 23
- 11
- 40
- 45
- 50
- 8
- -49
- -6
- 0
- -32
- 48
- 39
- 26
- 14
- -25
- -47
- -22
- 48
- -19
- 5
- -40
- 22
- -38
- -9
- -11
- 7
- 16
- -10
- -26
- -29
- -17
- -23
- 15
- 25
- -42
- -23
- -30
- 44
- -28
- -46
- 19
- -29
- -45
- -24
- 29
- 36
- -18
- -25
- 26
- -12
- 42
- -35
- -11
- 10
- -40
- -43
- 5
- 19
- -35
- 6
- -31
- -3
- 2
- -15
- -9
- -17
- 13
- 0
- 45
- 35
- 35
- 29
- 28
- -15
- -27
- 24
- -39
- -27
- -37
- -26
- -23
- 19
- -32
- 27
- -27
- 49
- 2
- 20
- -15
- -9
- -35
- -34
- 23
- -20
- 26
- -10
- 26
- -6
- 31
- -32
- 33
- -34
- 11
- 7
- -29
- -20
- -43
- -15
- 44
- 2
- -19
- 28
- -17
- 0
- 13
- -14
- 9
- -28
- 43
- 26
- -10
- 4
- 41
- -21
- -44
- -11
- 29
- -33
- 2
- -3
- 0
- -1
- -14
- -31
- 38
- -14
- -6
- 43
- -3
- -33
- 46
- 9
- 14
- 26
- 35
- 41
- 13
- 8
- -7
- -46
- -44
- 40
- 17
- 26
- 19
- 48
- -24
- 12
- -36
- -25
- -46
- -2
- -15
- -18
- -17
- -2
- -46
- 31
- -39
- -39
- 5
- -40
- 27
- -25
- 10
- 17
- -6
- -44
- -47
- 26
- -40
- -19
- 41
- -15
- 22
- 14
- 15
- -19
- 24
- -14
- 2
- 45
- -34
- 37
- -26
- 49
- -41
- -31
- 1
- -28
- 3
- 14
- -44
- 18
- -7
- -45
- -38
- 28
- 1
- 49
- -40
- 31
- -24
- -42
- 15
- -6
- -43
- -33
- -38
- -49
- -2
- 11
- 7
- 49
- 28
- 39
- -5
- 25
- -3
- -1
- 37
- -34
- -20
- -1
- 27
- 31
- -19
- -33
- 41
- 8
- 39
- -42
- 29
- -21
- 16
- 19
- -25
- 16
- 19
- -3
- -11
- 15
- -1
- 6
- 36
- 5
- 11
- -12
- -41
- -41
- 2
- 12
- 10
- 0
- 14
- 21
- 39
- 19
- 48
- 20
- 38
- -28
- -4
- 30
- -12
- 36
- 33
- -2
- 16
- 9
- -4
- -48
- 10
- -38
- -7
- 28
- 14
- 10
- -24
- -39
- -42
- -19
diff --git a/lab3/data/sphere.stl b/lab2/data/sphere.stl
similarity index 100%
rename from lab3/data/sphere.stl
rename to lab2/data/sphere.stl
diff --git a/lab2/game_of_life-serial.c b/lab2/game_of_life-serial.c
deleted file mode 100644
index 02c0cf900e35672b170b1bdc56890e7663e391cd..0000000000000000000000000000000000000000
--- a/lab2/game_of_life-serial.c
+++ /dev/null
@@ -1,119 +0,0 @@
-/***********************
-
-Conway Game of Life
-
-serial version
-
-************************/
-
-#include <stdio.h>
-
-#include <stdlib.h>
-
-#define NI 200 /* array sizes */
-
-#define NJ 200
-
-#define NSTEPS 500 /* number of time steps */
-
-int main(int argc, char *argv[])
-{
- int i, j, n, im, ip, jm, jp, ni, nj, nsum, isum;
- int **old, **new;
- float x;
-
- /* allocate arrays */
-
- ni = NI + 2; /* add 2 for left and right ghost cells */
- nj = NJ + 2;
- old = malloc(ni*sizeof(int*));
- new = malloc(ni*sizeof(int*));
-
- for(i=0; i<ni; i++){
- old[i] = malloc(nj*sizeof(int));
- new[i] = malloc(nj*sizeof(int));
- }
-
- /* initialize elements of old to 0 or 1 */
-
- for(i=1; i<=NI; i++){
- for(j=1; j<=NJ; j++){
- x = rand()/((float)RAND_MAX + 1);
- if(x<0.5){
- old[i][j] = 0;
- } else {
- old[i][j] = 1;
- }
- }
- }
-
- /* time steps */
- for(n=0; n<NSTEPS; n++){
-
- /* corner boundary conditions */
- old[0][0] = old[NI][NJ];
- old[0][NJ+1] = old[NI][1];
- old[NI+1][NJ+1] = old[1][1];
- old[NI+1][0] = old[1][NJ];
-
- /* left-right boundary conditions */
-
- for(i=1; i<=NI; i++){
- old[i][0] = old[i][NJ];
- old[i][NJ+1] = old[i][1];
- }
-
- /* top-bottom boundary conditions */
-
- for(j=1; j<=NJ; j++){
- old[0][j] = old[NI][j];
- old[NI+1][j] = old[1][j];
- }
-
- for(i=1; i<=NI; i++){
- for(j=1; j<=NJ; j++){
- im = i-1;
- ip = i+1;
- jm = j-1;
- jp = j+1;
-
- nsum = old[im][jp] + old[i][jp] + old[ip][jp]
- + old[im][j ] + old[ip][j ]
- + old[im][jm] + old[i][jm] + old[ip][jm];
-
- switch(nsum){
-
- case 3:
- new[i][j] = 1;
- break;
-
- case 2:
- new[i][j] = old[i][j];
- break;
-
- default:
- new[i][j] = 0;
- }
- }
- }
-
- /* copy new state into old state */
-
- for(i=1; i<=NI; i++){
- for(j=1; j<=NJ; j++){
- old[i][j] = new[i][j];
- }
- }
- }
-
- /* Iterations are done; sum the number of live cells */
- isum = 0;
- for(i=1; i<=NI; i++){
- for(j=1; j<=NJ; j++){
- isum = isum + new[i][j];
- }
- }
- printf("\nNumber of live cells = %d\n", isum);
-
- return 0;
-}
diff --git a/lab2/game_of_life-serial.f90 b/lab2/game_of_life-serial.f90
deleted file mode 100644
index 06a504d5ae456145801d6d648d4d0e7f961b2986..0000000000000000000000000000000000000000
--- a/lab2/game_of_life-serial.f90
+++ /dev/null
@@ -1,88 +0,0 @@
-!----------------------
-! Conway Game of Life
-! serial version
-!----------------------
-
-program life
-
- implicit none
- integer, parameter :: ni=200, nj=200, nsteps = 500
- integer :: i, j, n, im, ip, jm, jp, nsum, isum
- integer, allocatable, dimension(:,:) :: old, new
- real :: arand
-
- ! allocate arrays, including room for ghost cells
-
- allocate(old(0:ni+1,0:nj+1), new(0:ni+1,0:nj+1))
-
- ! initialize elements of old to 0 or 1
-
- do j = 1, nj
- do i = 1, ni
- call random_number(arand)
- old(i,j) = nint(arand)
- enddo
- enddo
-
- ! iterate
-
- time_iteration: do n = 1, nsteps
-
- ! corner boundary conditions
-
- old(0,0) = old(ni,nj)
- old(0,nj+1) = old(ni,1)
- old(ni+1,nj+1) = old(1,1)
- old(ni+1,0) = old(1,nj)
-
- ! left-right boundary conditions
-
- old(1:ni,0) = old(1:ni,nj)
- old(1:ni,nj+1) = old(1:ni,1)
-
- ! top-bottom boundary conditions
-
- old(0,1:nj) = old(ni,1:nj)
- old(ni+1,1:nj) = old(1,1:nj)
-
- do j = 1, nj
- do i = 1, ni
-
- im = i - 1
- ip = i + 1
- jm = j - 1
- jp = j + 1
- nsum = old(im,jp) + old(i,jp) + old(ip,jp) &
- + old(im,j ) + old(ip,j ) &
- + old(im,jm) + old(i,jm) + old(ip,jm)
-
- select case (nsum)
- case (3)
- new(i,j) = 1
- case (2)
- new(i,j) = old(i,j)
- case default
- new(i,j) = 0
- end select
-
- enddo
- enddo
-
- ! copy new state into old state
-
- old = new
-
- enddo time_iteration
-
- ! Iterations are done; sum the number of live cells
-
- isum = sum(new(1:ni,1:nj))
-
- ! Print final number of live cells.
-
- write(*,*)"Number of live cells = ",isum
-
- deallocate(old, new)
-
-end program life
-
diff --git a/lab3/hello_mpi.c b/lab2/hello_mpi.c
similarity index 100%
rename from lab3/hello_mpi.c
rename to lab2/hello_mpi.c
diff --git a/lab3/hello_mpi.f90 b/lab2/hello_mpi.f90
similarity index 100%
rename from lab3/hello_mpi.f90
rename to lab2/hello_mpi.f90
diff --git a/lab3/mpi_bandwidth-nonblock.c b/lab2/mpi_bandwidth-nonblock.c
similarity index 100%
rename from lab3/mpi_bandwidth-nonblock.c
rename to lab2/mpi_bandwidth-nonblock.c
diff --git a/lab3/mpi_bandwidth-nonblock.f90 b/lab2/mpi_bandwidth-nonblock.f90
similarity index 100%
rename from lab3/mpi_bandwidth-nonblock.f90
rename to lab2/mpi_bandwidth-nonblock.f90
diff --git a/lab3/mpi_bandwidth.c b/lab2/mpi_bandwidth.c
similarity index 100%
rename from lab3/mpi_bandwidth.c
rename to lab2/mpi_bandwidth.c
diff --git a/lab3/mpi_bandwidth.f90 b/lab2/mpi_bandwidth.f90
similarity index 100%
rename from lab3/mpi_bandwidth.f90
rename to lab2/mpi_bandwidth.f90
diff --git a/lab3/mpi_derived_types.c b/lab2/mpi_derived_types.c
similarity index 100%
rename from lab3/mpi_derived_types.c
rename to lab2/mpi_derived_types.c
diff --git a/lab3/mpi_derived_types.f90 b/lab2/mpi_derived_types.f90
similarity index 100%
rename from lab3/mpi_derived_types.f90
rename to lab2/mpi_derived_types.f90
diff --git a/lab3/mpi_latency.c b/lab2/mpi_latency.c
similarity index 100%
rename from lab3/mpi_latency.c
rename to lab2/mpi_latency.c
diff --git a/lab3/mpi_latency.f90 b/lab2/mpi_latency.f90
similarity index 100%
rename from lab3/mpi_latency.f90
rename to lab2/mpi_latency.f90
diff --git a/lab2/parallel_search-serial.c b/lab2/parallel_search-serial.c
deleted file mode 100644
index ce08025f8a630a7c3d0eba2835b17f7c896a0df5..0000000000000000000000000000000000000000
--- a/lab2/parallel_search-serial.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char *argv[])
-{
- const int N=300;
- int i,target;
- int b[N];
- FILE *infile,*outfile;
-
- /* File b.data has the target value on the first line
- The remaining 300 lines of b.data have the values for the b array */
- infile = fopen("b.data","r" ) ;
- outfile = fopen("found.data","w") ;
-
- /* read in target */
- fscanf(infile,"%d", &target);
-
- /* read in b array */
- for(i=0;i<N;i++) {
- fscanf(infile,"%d", &b[i]);
- }
- fclose(infile);
-
- /* Search the b array and output the target locations */
-
- for(i=0;i<N;i++) {
- if( b[i] == target) {
- fprintf(outfile,"%d\n",i+1);
- }
- }
- fclose(outfile);
-
- return 0;
-}
diff --git a/lab2/parallel_search-serial.f90 b/lab2/parallel_search-serial.f90
deleted file mode 100644
index f8d7e64b1bd4f8760f920249297e035d8f32ecdd..0000000000000000000000000000000000000000
--- a/lab2/parallel_search-serial.f90
+++ /dev/null
@@ -1,31 +0,0 @@
-PROGRAM search
- implicit none
- integer, parameter :: N=300
- integer i, target ! local variables
- integer b(N) ! the entire array of integers
-
- ! File b.data has the target value on the first line
- ! The remaining 300 lines of b.data have the values for the b array
- open(unit=10,file="b.data")
-
- ! File found.data will contain the indices of b where the target is
- open(unit=11,file="found.data")
-
- ! Read in the target
- read(10,*) target
-
- ! Read in b array
-
- do i=1,N
- read(10,*) b(i)
- end do
-
- ! Search the b array and output the target locations
-
- do i=1,N
- if (b(i) == target) then
- write(11,*) i
- end if
- end do
-
-END PROGRAM search
diff --git a/lab2/pi_serial.c b/lab2/pi_serial.c
deleted file mode 100644
index bf205725370bf45231b4d66c70826aa0df986a1c..0000000000000000000000000000000000000000
--- a/lab2/pi_serial.c
+++ /dev/null
@@ -1,104 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-void srandom (unsigned seed);
-double dboard (int darts);
-#define DARTS 50000 /* number of throws at dartboard */
-#define ROUNDS 10 /* number of times "darts" is iterated */
-#define MASTER 0 /* task ID of master task */
-
-int main (int argc, char *argv[])
-{
- double homepi, /* value of pi calculated by current task */
- pi, /* average of pi after "darts" is thrown */
- avepi, /* average pi value for all iterations */
- pirecv, /* pi received from worker */
- pisum; /* sum of workers pi values */
- int i, n;
-
- srandom (0);
-
- avepi = 0;
- for (i = 0; i < ROUNDS; i++) {
- pi = dboard(DARTS);
-
- /* Master calculates the average value of pi over all iterations */
- avepi = ((avepi * i) + pi)/(i + 1);
- printf(" After %8d throws, average value of pi = %10.8f\n",
- (DARTS * (i + 1)),avepi);
-
- }
-
- return 0;
-}
-
-
-
-/******************************************************************************
-* FILE: dboard.c
-* DESCRIPTION:
-* Used in pi calculation example codes.
-* See mpi_pi_send.c and mpi_pi_reduce.c
-* Throw darts at board. Done by generating random numbers
-* between 0 and 1 and converting them to values for x and y
-* coordinates and then testing to see if they "land" in
-* the circle." If so, score is incremented. After throwing the
-* specified number of darts, pi is calculated. The computed value
-* of pi is returned as the value of this function, dboard.
-* Note: the seed value for rand() is set in pi_send.f or pi_reduce.f.
-* AUTHOR: unknown
-* LAST REVISED: 04/14/05 Blaise Barney
-****************************************************************************/
-/*
-Explanation of constants and variables used in this function:
- darts = number of throws at dartboard
- score = number of darts that hit circle
- n = index variable
- r = random number between 0 and 1
- x_coord = x coordinate, between -1 and 1
- x_sqr = square of x coordinate
- y_coord = y coordinate, between -1 and 1
- y_sqr = square of y coordinate
- pi = computed value of pi
-*/
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#define sqr(x) ((x)*(x))
-long random(void);
-
-double dboard(int darts)
-{
- double x_coord, y_coord, pi, r;
- int score, n;
- unsigned int cconst; /* must be 4-bytes in size */
- /*************************************************************************
- * The cconst variable must be 4 bytes. We check this and bail if it is
- * not the right size
- ************************************************************************/
- if (sizeof(cconst) != 4) {
- printf("Wrong data size for cconst variable in dboard routine!\n");
- printf("See comments in source file. Quitting.\n");
- exit(1);
- }
- cconst = 2 << (31 - 1);
- score = 0;
-
- /* "throw darts at board" */
- for (n = 1; n <= darts; n++) {
- /* generate random numbers for x and y coordinates */
- r = (double)random()/cconst;
- x_coord = (2.0 * r) - 1.0;
- r = (double)random()/cconst;
- y_coord = (2.0 * r) - 1.0;
-
- /* if dart lands in circle, increment score */
- if ((sqr(x_coord) + sqr(y_coord)) <= 1.0)
- score++;
- }
-
- /* calculate pi */
- pi = 4.0 * (double)score/(double)darts;
- return(pi);
-}
diff --git a/lab2/pi_serial.f90 b/lab2/pi_serial.f90
deleted file mode 100644
index 5f92b6ec6a52dbe92545be4082d3cbf78e3f3685..0000000000000000000000000000000000000000
--- a/lab2/pi_serial.f90
+++ /dev/null
@@ -1,57 +0,0 @@
-program pi
-
-implicit none
-
-integer, parameter :: DARTS = 50000, ROUNDS = 10, MASTER = 0
-
-real(8) :: pi_est
-real(8) :: homepi, avepi, pirecv, pisum
-integer :: rank
-integer :: i, n
-integer, allocatable :: seed(:)
-
-! we set it to zero in the sequential run
-rank = 0
-
-! initialize the random number generator
-! we make sure the seed is different for each task
-call random_seed()
-call random_seed(size = n)
-allocate(seed(n))
-seed = 12 + rank*11
-call random_seed(put=seed(1:n))
-deallocate(seed)
-
-avepi = 0
-do i = 0, ROUNDS-1
- pi_est = dboard(DARTS)
-
- ! calculate the average value of pi over all iterations
- avepi = ((avepi*i) + pi_est)/(i + 1)
-
- print *, "After ", DARTS*(i+1), " throws, average value of pi =", avepi
-end do
-
-contains
-
- real(8) function dboard(darts)
-
- integer, intent(in) :: darts
-
- real(8) :: x_coord, y_coord
- integer :: score, n
-
- score = 0
- do n = 1, darts
- call random_number(x_coord)
- call random_number(y_coord)
-
- if ((x_coord**2 + y_coord**2) <= 1.0d0) then
- score = score + 1
- end if
- end do
- dboard = 4.0d0*score/darts
-
- end function
-
-end program
diff --git a/lab2/reference.found.data b/lab2/reference.found.data
deleted file mode 100644
index 1dc51432b5eff390d364e00d3d92b08caaa34f12..0000000000000000000000000000000000000000
--- a/lab2/reference.found.data
+++ /dev/null
@@ -1,5 +0,0 @@
- 62
- 183
- 271
- 291
- 296
diff --git a/lab3/README.md b/lab3/README.md
deleted file mode 100644
index e9a9120b61c9fe6af01f3902fce32f619ed899ec..0000000000000000000000000000000000000000
--- a/lab3/README.md
+++ /dev/null
@@ -1,84 +0,0 @@
-# Overview
-
-In this lab you will get more familiar with more advanced MPI topics, including one sided communication and MPI I/O.
-
-### Goals
-
-Get experience in MPI one sided communication, MPI I/O and topologies in MPI
-
-### Duration
-
-Three hours
-
-# Source Codes
-
-- MPI I/O. Serial hello world in C and Fortran ([hello_mpi.c](hello_mpi.c) and [hello_mpi.f90](hello_mpi.f90))
-- MPI Derived types and I/O. Serial STL file reader in C and Fortran ([mpi_derived_types.c](mpi_derived_types.c) and [mpi_derived_types.f90](mpi_derived_types.f90)
-- MPI Latency: C and Fortran ([mpi_latency.c](mpi_latency.c) and [mpi_latency.f90](mpi_latency.f90))
-- MPI Bandwidth : C and Fortran ([mpi_bandwidth.c](mpi_bandwidth.c) and [mpi_bandwidth.f90](mpi_bandwidth.f90))
-- MPI Bandwidth Non-Blocking: C and Fortran ([mpi_bandwidth-nonblock.c](mpi_bandwidth-nonblock.c)
- and [mpi_bandwidth-nonblock.f90](mpi_bandwidth-nonblock.f90))
-
-
-# Preparation
-
-In preparation for this lab, read the [general instructions](../README.md) which will help you get going on Beskow.
-
-# Exercise 1 - MPI I/O
-
-MPI I/O is used so that results can be written to the same file in parallel. Take the serial hello world programs and modify them so that instead of writing the output to screen the output is written to a file using MPI I/O.
-
-The simplest solution is likely to be for you to create a character buffer, and then use the MPI_File_write_at function.
-
-# Exercise 2 - MPI I/O and derived types
-
-Take the serial stl reader and modify it such that the stl file is read (and written) in parallel using collective MPI I/O. Use derived types such that the file can be read/written with a maximum of 3 I/O operations per read and write.
-
-The simplest solution is likely to create a derived type for each triangle, and then use the MPI_File_XXXX_at_all function. A correct solution will have the same MD5 hash for both stl models (input and output), unless the order of the triangles has been changed.
-
-```
-md5sum out.stl data/sphere.stl
-822aba6dc20cc0421f92ad50df95464c out.stl
-822aba6dc20cc0421f92ad50df95464c data/sphere.stl
-```
-
-# Exercises 3 - Bandwidth and latency between nodes
-
-Use `mpi_wtime` to compute latency and bandwidth with the bandwidth and latency codes above
-
-**Note**: In modifying the original exercises provided by LLNL, We had to make a small change to the latency code as the Cray latency is a lot better than the tests were designed for. When the latency is of the order 1 millisecond, writing it out as an integer number of milliseconds did not make much sense.
-
-For this exercise, it is nice to compare running on the same node e.g.
-
-```
-salloc -N 1 --ntasks-per-node=2 -A <project> -t 00:05:00
-srun -n 2 ./mpi_latency.x
-```
-
-with running on separate nodes
-
-```
-salloc -N 2 --ntasks-per-node=1 -A <project> -t 00:05:00
-srun -n 2 ./mpi_latency.x
-```
-
-Similarly for the bandwidth.
-
-As you would expect the latency is much better on a single node than across nodes, but possibly unexpectedly if you just have 2 MPI tasks the bandwidth is better between nodes than across a single node. (probably related to lack of contention for resources, e.g. the gemini chips and the l3 cache etc.)
-
-# Solutions
-
-The solutions will be made available at the end of the lab.
-
-# Acknowledgment
-
-The examples in this lab are provided for educational purposes by
-[National Center for Supercomputing Applications](http://www.ncsa.illinois.edu/),
-(in particular their [Cyberinfrastructure Tutor](http://www.citutor.org/)),
-[Lawrence Livermore National Laboratory](https://computing.llnl.gov/) and
-[Argonne National Laboratory](http://www.mcs.anl.gov/). Much of the LLNL MPI materials comes from the
-[Cornell Theory Center](http://www.cac.cornell.edu/).
-We would like to thank them for allowing us to develop the material for machines at PDC.
-You might find other useful educational materials at these sites.
-
-
diff --git a/lab3/game_of_life-one_sided-prototype.c b/lab3/game_of_life-one_sided-prototype.c
deleted file mode 100644
index efaa10af99a3cc49444ad8ff58f81c43993ddf3e..0000000000000000000000000000000000000000
--- a/lab3/game_of_life-one_sided-prototype.c
+++ /dev/null
@@ -1,250 +0,0 @@
-/****************************
- Conway Game of Life
-
- 2 processors
- divide domain top-bottom
- (break with horizontal line)
-*****************************/
-
-#include "mpi.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-#define NI 200
-#define NJ 200
-
-#define NSTEPS 500
-
-int main(int argc, char *argv[])
-{
- int i, j, n, im, ip, jm, jp, nsum, isum, isum1, nprocs ,myid, ierr;
- int ig, jg, i1g, i2g, j1g, j2g, ninom, njnom, ninj, i1, i2, i2m,
- j1, j2, j2m, ni, nj, isumloc,igrid;
- int niproc, njproc;
- int **old, **new, *old1d, *new1d;
-
- int above_rank,below_rank;
-
- float x;
-
- /* initialize MPI */
-
- MPI_Init(&argc,&argv);
- MPI_Comm_size(MPI_COMM_WORLD,&nprocs);
- MPI_Comm_rank(MPI_COMM_WORLD,&myid);
-
- /* nominal number of points per proc. in each direction,
- without ghost cells, assume numbers divide evenly */
-
- niproc = nprocs; /* divide domain in i direction only */
- njproc = 1;
- ninom = NI/niproc;
- njnom = NJ/njproc;
-
- /* NI must be exactly divisble by nprocs */
-
- if(ninom*niproc!=NI) {
- igrid=NI;
- printf("Need to be able to divide the i grid exactly between the processes\n");
- printf("grid points in i=%d nprocs=%d\n",igrid,nprocs);
- MPI_Abort(MPI_COMM_WORLD, 1);
- }
-
- /* global starting and ending indices (without ghost cells) */
-
- i1g = (myid*ninom) + 1;
- i2g = i1g + ninom - 1;
- j1g = 1;
- j2g = njnom;
-
- /* local starting and ending indices, including ghost cells */
-
- i1 = 0;
- i2 = ninom + 1;
- i2m = i2 - 1;
- j1 = 0;
- j2 = njnom + 1;
- j2m = j2 - 1;
-
- /* allocate arrays; want elements to be contiguous, so
- allocate 1-D arrays, then set pointer to each row (old
- and new) to allow use of array notation for convenience */
-
- ni = i2-i1+1;
- nj = j2-j1+1;
- ninj = ni*nj;
-
- old1d = malloc(ninj*sizeof(int));
- new1d = malloc(ninj*sizeof(int));
- old = malloc(ni*sizeof(int*));
- new = malloc(ni*sizeof(int*));
-
- for(i=0; i<ni; i++){
- old[i] = &old1d[i*nj];
- new[i] = &new1d[i*nj];
- }
-
- /* FIXME */
- /* create the memory window */
-
-
-
-
- /* Initialize elements of old to 0 or 1.
- We're doing some sleight of hand here to make sure we
- initialize to the same values as in the serial case.
- The rand() function is called for every i and j, even
- if they are not on the current processor, to get the same
- random distribution as the serial case, but they are
- only used if i and j reside on the current procesor. */
-
-
- for(ig=1; ig<=NI; ig++){
- for(jg=1; jg<=NJ; jg++){
- x = rand()/((float)RAND_MAX + 1);
-
- /* if this i is on the current processor */
- if( ig >= i1g && ig <= i2g ){
-
- /* local i and j indices, accounting for lower ghost cell */
- i = ig - i1g + 1;
- j = jg ;
-
- if(x<0.5){
- old[i][j] = 0;
- }else{
- old[i][j] = 1;
- }
- }
-
- }
- }
-
- /* iterate */
-
- for(n=0; n<NSTEPS; n++){
-
- /* transfer data to ghost cells */
-
- if(nprocs == 1){
-
- /* left and right columns */
-
- for(i=1; i<i2; i++){
- old[i][0] = old[i][j2m];
- old[i][j2] = old[i][1];
- }
-
- /* top and bottom */
-
- for(j=1; j<j2; j++){
- old[0][j] = old[i2m][j];
- old[i2][j] = old[1][j];
- }
-
- /* corners */
-
- old[0][0] = old[i2m][j2m];
- old[0][j2] = old[i2m][1];
- old[i2][j2] = old[1][1];
- old[i2][0] = old[1][j2m];
-
- }else{
-
- if(myid==0) {
- above_rank=nprocs-1;
- } else {
- above_rank=myid-1;
- }
-
- if(myid==nprocs-1) {
- below_rank=0;
- } else {
- below_rank=myid+1;
- }
-
- /* FIXME */
-
- /* use one sided communication to move row from above and */
- /* below into ghost cells */
-
- /* read row from bottom of above process into top row of ghost cells */
- /* remember a fence call is needed before and after the get */
-
-
- /* read row from below into bottom row of ghost cells */
- /* remember a fence call is needed before and after the get */
-
-
- /* left and right including corners*/
- /* needs something more complicated if problem split into 2d */
-
- for(i=i1; i<=i2; i++){
- old[i][0] = old[i][j2m];
- old[i][j2] = old[i][1];
- }
-
- }
-
- /* update states of cells */
-
- for(i=1; i<i2; i++){
- for(j=1; j<j2; j++){
-
- im = i-1;
- ip = i+1;
- jm = j-1;
- jp = j+1;
- nsum = old[im][jp] + old[i][jp] + old[ip][jp]
- + old[im][j ] + old[ip][j ]
- + old[im][jm] + old[i][jm] + old[ip][jm];
-
- switch(nsum){
- case 3:
- new[i][j] = 1;
- break;
- case 2:
- new[i][j] = old[i][j];
- break;
- default:
- new[i][j] = 0;
- }
- }
- }
-
- /* copy new state into old state */
-
- for(i=1; i<i2; i++){
- for(j=1; j<j2; j++){
- old[i][j] = new[i][j];
- }
- }
-
- }
-
- /* Iterations are done; sum the number of live cells */
-
- isum = 0;
- for(i=1; i<i2; i++){
- for(j=1; j<j2; j++){
- isum = isum + new[i][j];
- }
- }
-
- /* Print final number of live cells. For multiple processors,
- must reduce partial sums */
-
- if(nprocs > 1){
- isumloc = isum;
- MPI_Reduce(&isumloc, &isum, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
- }
-
- if(myid == 0) printf("Number of live cells = %d\n", isum);
-
-
- /* FIXME */
- /* free the windows */
-
- MPI_Finalize();
-}
-
diff --git a/lab3/game_of_life-one_sided-prototype.f90 b/lab3/game_of_life-one_sided-prototype.f90
deleted file mode 100644
index 8055eec285b546b206f1f18ade1f1588a8d3abdd..0000000000000000000000000000000000000000
--- a/lab3/game_of_life-one_sided-prototype.f90
+++ /dev/null
@@ -1,215 +0,0 @@
-!------------------------------
-! Conway Game of Life
-!
-! One sided communication
-!
-! Domain is split vertically (left/right) so that data
-! to be transfered is contiguous
-!
-! leftmost rank is rank 0
-!------------------------------
-
-program life
- implicit none
- include 'mpif.h'
-
- integer, parameter :: ni=200, nj=200, nsteps = 500
- integer :: i, j, n, im, ip, jm, jp, nsum, isum, isum1, &
- ierr, myid, nprocs, i1, i2, j1, j2, i1p, i2m, j1p, j2m, &
- i1n, i2n, ninom, njnom, niproc, njproc, nitot, isumloc, &
- j1n,j2n
- integer, allocatable, dimension(:,:) :: old, new
- real :: arand
-
- integer :: left_rank, right_rank
- integer(kind=MPI_ADDRESS_KIND) :: size,target_disp
- integer disp_unit,left_win,right_win
-
- ! initialize MPI
-
- call mpi_init(ierr)
- call mpi_comm_rank(mpi_comm_world, myid, ierr)
- call mpi_comm_size(mpi_comm_world, nprocs, ierr)
-
- ! domain decomposition
-
- ! nominal number of points per proc., without ghost cells,
- ! assume numbers divide evenly; niproc and njproc are the
- ! numbers of procs in the i and j directions.
- niproc = 1
- njproc = nprocs
- ninom = ni/niproc
- njnom = nj/njproc
-
- if(njnom*njproc.ne.nj) then
- if(myid.eq.0) then
- write(*,*) "Need to be able to divide the j grid exactly between the processes"
- write(*,*) "grid points in j",nj," nprocs=",nprocs
- write(*,*) "grid points per cell",njnom
- write(*,*) "cells that would be used",njnom*njproc
- endif
- call mpi_abort(mpi_comm_world,1,ierr)
- endif
-
-
- ! nominal starting and ending indices, without ghost cells
- i1n = 1
- i2n = ninom
- j1n = myid*njnom + 1
- j2n = j1n + njnom - 1
-
- ! local starting and ending index, including 2 ghost cells
- ! in each direction (at beginning and end)
- i1 = i1n - 1
- i1p = i1 + 1
- i2 = i2n + 1
- i2m = i2 - 1
- j1 = j1n-1
- j1p = j1 + 1
- j2 = j2n + 1
- j2m = j2 - 1
- nitot = i2 - i1 + 1
-
- ! allocate arrays
- allocate( old(i1:i2,j1:j2), new(i1:i2,j1:j2) )
-
- ! FIXME
- ! Create the memory window
-
-
-
- ! Initialize elements of old to 0 or 1. We're doing some
- ! sleight of hand here to make sure we initialize to the
- ! same values as in the serial case. The random_number
- ! function is called for every i and j, even if they are
- ! not on the current processor, to get the same random
- ! distribution as the serial case, but they are only used
- ! if this i and j reside on the current procesor.
-
- do j = 1, nj
- do i = 1, ni
- call random_number(arand)
- if(j > j1 .and. j < j2) old(i,j) = nint(arand)
- enddo
- enddo
-
- ! iterate
-
-
-
- time_iteration: do n = 1, nsteps
-
- ! transfer data to ghost cells
-
- if(nprocs == 1) then
-
- ! left and right boundary conditions
-
- old(i1p:i2m,0) = old(i1p:i2m,j2m)
- old(i1p:i2m,j2) = old(i1p:i2m,1)
-
- ! top and bottom boundary conditions
-
- old(i1,:) = old(i2m,:)
- old(i2,:) = old(i1p,:)
-
- ! corners
-
- old(i1,j1) = old(i2m,j2m)
- old(i1,j2) = old(i2m,j1p)
- old(i2,j2) = old(i1p,j1p)
- old(i2,j1) = old(i1p,j2m)
-
- else
-
- if(myid.eq.0) then
- left_rank=nprocs-1
- else
- left_rank=myid-1
- endif
-
- if(myid.eq.nprocs-1) then
- right_rank=0
- else
- right_rank=myid+1
- endif
-
-
- ! use one sided communication to move row from left and
- ! right into ghost cells
-
- ! read row from the left into the left row of ghost cells
- ! remember a fence call is needed before and after the get
- ! make sure you use a variable of type
- ! integer(kind=MPI_ADDRESS_KIND) for the target displacement
- ! FIXME
-
-
- ! read row from the right into the right row of ghost cells
- ! remember a fence call is needed before and after the get
-
-
- ! top and bottom including corners
- ! will not work with 2d distribution of cells
-
- old(i1,:) = old(i2n,:)
- old(i2,:) = old(i1n,:)
-
- endif
-
- do j = j1p, j2m
- do i = i1p, i2m
-
- im = i - 1
- ip = i + 1
- jm = j - 1
- jp = j + 1
- nsum = old(im,jp) + old(i,jp) + old(ip,jp) &
- + old(im,j ) + old(ip,j ) &
- + old(im,jm) + old(i,jm) + old(ip,jm)
-
- select case (nsum)
- case (3)
- new(i,j) = 1
- case (2)
- new(i,j) = old(i,j)
- case default
- new(i,j) = 0
- end select
-
- enddo
- enddo
-
- ! copy new state into old state
- old(i1p:i2m,j1p:j2m) = new(i1p:i2m,j1p:j2m)
-
- enddo time_iteration
-
-
- ! Iterations are done; sum the number of live cells
-
- isum = sum(new(i1p:i2m,j1p:j2m))
-
- ! Print final number of live cells. For multiple
- ! processors, must reduce partial sums.
-
- if(nprocs > 1) then
- isumloc = isum
- call mpi_reduce(isumloc, isum, 1, mpi_integer, &
- mpi_sum, 0, mpi_comm_world, ierr)
- endif
-
- if(myid == 0) then
- write(*,"(/'Number of live cells = ', i6/)") isum
- endif
-
- ! FIXME
- ! free the windows
-
-
- deallocate(old, new)
- call mpi_finalize(ierr)
-
-end program life
-
-
diff --git a/lab3/simple_1d_topology.c b/lab3/simple_1d_topology.c
deleted file mode 100644
index 512a08879017c32ed4995b2f1498c3764680c265..0000000000000000000000000000000000000000
--- a/lab3/simple_1d_topology.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "mpi.h"
-#include <stdio.h>
-#include <stdlib.h>
-int main(int argc, char *argv[])
-{
- int nprocs,myid,period,cart_id;
- int plus_one,minus_one,cart_position;
-
- MPI_Comm cart_comm;
-
- /* initialize MPI */
-
- MPI_Init(&argc,&argv);
- MPI_Comm_size(MPI_COMM_WORLD,&nprocs);
- MPI_Comm_rank(MPI_COMM_WORLD,&myid);
-
- period=1;
-
- MPI_Cart_create(MPI_COMM_WORLD,1,&nprocs,&period,0,&cart_comm);
- MPI_Comm_rank(cart_comm,&cart_id);
- MPI_Cart_coords(cart_comm,myid,1,&cart_position);
-
- MPI_Cart_shift(cart_comm,0,1,&cart_id,&plus_one);
- MPI_Cart_shift(cart_comm,0,-1,&cart_id,&minus_one);
-
- printf("myid = %d cart_id=%d cart_position=%d plus_one=%d minus_one=%d\n",myid,cart_id,cart_position,plus_one,minus_one);
-
- MPI_Finalize();
-
- return 0;
-}
-
diff --git a/lab3/simple_1d_topology.f90 b/lab3/simple_1d_topology.f90
deleted file mode 100644
index b12ccf4248e6658d993a9c7d1c1406daf3997347..0000000000000000000000000000000000000000
--- a/lab3/simple_1d_topology.f90
+++ /dev/null
@@ -1,27 +0,0 @@
-program topology
- implicit none
- include 'mpif.h'
-
- integer nprocs,myid,ierr,period,cart_id
- integer plus_one,minus_one,cart_position
- integer cart_comm
-
- call mpi_init(ierr)
- call mpi_comm_rank(mpi_comm_world, myid, ierr)
- call mpi_comm_size(mpi_comm_world, nprocs, ierr)
-
- period=1
-
- call mpi_cart_create(MPI_COMM_WORLD,1,nprocs,period,0,cart_comm,ierr)
- call mpi_comm_rank(cart_comm,cart_id,ierr)
- call mpi_cart_coords(cart_comm,myid,1,cart_position,ierr)
-
- call mpi_cart_shift(cart_comm,0,1,cart_id,plus_one,ierr)
- call mpi_cart_shift(cart_comm,0,-1,cart_id,minus_one,ierr)
-
- write(*,*) "myid=",myid,"cart_id=",cart_id,"cart_position=",cart_position
- write(*,*) "cart_position=",cart_position,"plus_one=",plus_one,"minus_one=",minus_one
-
- call mpi_finalize(ierr)
-
-end program topology