Almost Conway's

Objectives

1. Learn more MPI go get close to Conway's Game of Life

Notes

• Conway's Game of Life is at least a curiosity if not a theoretical entry in the background of computability.
• It is played on a grid.
  • Each cell in the grid is either alive or dead
  • At each turn, each cell computes the number of neighbors (8 of them) that are alive.
    • If the cell is alive
      • If there are fewer than 2 or more than three neighbors alive, the cell dies.
      • Otheriwse the cell survives.
    • If the cell is dead
      • And there are exactaly three alive neighbors, the cell comes alive.
  • Example
• How could we do this computation?
• This is an ideal candidate for parallelization as
  • The computation at each cell is independent.
  • The data decomposes nicely.
• MPI_Barrier(MPI_Comm)
  • reference.
  • Mostly for prinitng and labels.
  • Computations is the comm group wait until all computations in the group reach this point.
  • You would like to use this very infrequently.
• I made my data contiguous (int ary[r][c])
  • In general a 2d array and 1d array are the the same thing.
    • ondD[x] = 2d[r][c]
    • x = r*colSize + c
    • r = x / colSize
    • c = x / colSize
    • For example if rows = 5 and columns = 4
    • There are 20 (4x5) entries
    • 1d they would jus be 0 , 1, 2, ... , 19
    • In 2d they would be:

      0 : (0,0)	1 : (0,1)	2 : (0,2)	3: (0,3)
      4 : (1,0)	5 : (1,1)	6 : (1,2)	7: (1,3)
      8 : (2,0)	9 : (2,1)	10 : (2,2)	11: (2,3)
      12 : (3,0)	13 : (3,1)	13 : (3,2)	15: (3,3)
      16 : (4,0)	17 : (4,1)	18 : (4,2)	19: (4,3)

• We tend to employ perodic boundary conditions for this type of simulation.
  • It allows an approximation of infinity
  • Assuming the space is semi-uniform
• This means that we need to share boundaries left and right.
  • But the the far left edge maps to the far right edge.
  • And the same the other way.
  • And the top and bottom as well.
• MPI has a nice collective operation for exchanging something like rows

  •  
    int MPI_Sendrecv(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
        int dest, int sendtag, void *recvbuf, int recvcount,
        MPI_Datatype recvtype, int source, int recvtag,
        MPI_Comm comm, MPI_Status *status)

  • This handles a certan amount of synchronization problems.
  • Send to the dest, receive from the source.
  • We could do this with a series of sends and receives.
• The rows are easy, because they are contiguous, but the columns are a problem.
  • We could do a bunch of sends and recieves, but this is a pain.
• Fortunately MPI has a construct

  •  
    int MPI_Type_vector(int count, int blocklength, 
        int stride, MPI_Datatype oldtype, MPI_Datatype * newtype) 

  • reference.
  • count is the number of blocks (ie rows in our case)
  • blocklength: is the number of contiguous elements. (probably 1 in our case)
  • stride: the distance between the starting elements, columns + 2 in our case.
  • old datatype : the type in the vector
  • new data type : MPI_Datatype, the type of a portion of the vector
  • Used with MPI_Type_commit(MPI_Type * datatype)
  • And with MPI_Type_free(MPI_Type * datatype)
• Take a look at life.cpp.