Changeset 2368 in /cluster/svnroot


Ignore:
Timestamp:
Apr 22, 2010 6:13:17 PM (11 years ago)
Author:
fitz
Message:

LAST COMMIT BROKE MPI VERSION -- will fix tomorrow. Add define guards. Add function descriptions. Minor formatting changes. (#486)

Location:
bccd-ng/branches/fitz-devel/trees/home/bccd/Life
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/Life.c

    r2367 r2368  
    88
    99#include "Life.h"
     10
     11#ifndef NO_X11
    1012#include "XLife.h"
     13#endif
    1114
    1215// defaults
     
    1720
    1821int main(int argc, char ** argv) {
    19         int rank, size;
     22        int rank = 0;
     23        int size = 1;
    2024        int ngrid, ncols, nrows;
    2125        int generations;
     
    3034        MPI_Comm_rank(MPI_COMM_WORLD,&rank);
    3135        MPI_Comm_size(MPI_COMM_WORLD,&size);
    32         #else
    33         rank = 0;
    34         size = 1;
    3536        #endif
    3637
     
    6263        randomize_grid(ncols, nrows, grid, INIT_PROB);
    6364
     65        #ifndef NO_X11
    6466        if (do_display) {
    6567                setupWindow(ncols, nrows);
    6668                moveWindow(rank,size,ncols,nrows);
    6769        }
     70        #endif
    6871
    6972        for (count = 0; count < generations; count++) {
     73                #ifndef NO_X11
    7074                if (do_display)
    7175                        do_draw(rank,ncols,nrows,grid);
     76                #endif
    7277
    7378                do_step(rank,size,ncols,nrows,grid,next_grid);
    7479
     80                #ifdef OMP
     81                #pragma omp parallel for private(j)
     82                #endif
    7583                // copy next_grid to grid
    7684                for (i = 0; i < ncols+2; i++)
     
    8290        free_grid(ncols, nrows, &next_grid);
    8391
     92        #ifndef NO_X11
    8493        if(do_display)
    8594                free_video();
     95        #endif
    8696
    8797        #ifdef MPI
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/Life.h

    r2367 r2368  
    1010#include <mpi.h>
    1111#endif
     12
    1213#include <time.h>     // For seeding random
    1314#include <stdio.h>    // For sscanf
     
    1516#include <stdbool.h>  // For true/false
    1617
    17 #define LIFE_IMAGE_WIDTH 500
    18 #define LIFE_IMAGE_HEIGHT 500
    19 
    2018#define MPI_TORIGHT 0
    2119#define MPI_TOLEFT  1
    2220
     21/*
     22        do_step()
     23                calculates the next step of Life.
     24                All boundaries are periodic.
     25
     26                In the MPI model, processes are aligned side-by-side.
     27                Left and right sides are sent to neighboring processes.
     28                Top and bottom are copied from the process's own grid.
     29*/
    2330void do_step(int rank, int size, int ncols, int nrows, int ** grid,
    2431                int ** next_grid) {
    2532        int i,j,k,l,neighbors;
    2633        int omp_rank;
    27         #ifdef MPI
    28         MPI_Status status;
    29         #endif
    30 
    31         // side by side grid
    32         // top and bottom we get from current cell.
    33         // left right and corners we get from neighboring grids.
    34         // start off with non blocking sends of each "row"
    35         // left is rank - 1 % size, right is rank + 1 % size.
    3634
    3735        #ifdef MPI
    3836        // copy sides
    39         int left_rank = (rank-1+size)%size;
     37        MPI_Status status;
     38        int left_rank  = (rank-1+size)%size;
    4039        int right_rank = (rank+1)%size;
    4140
    42         // If we're only 1, no need to do the communication
     41        // Some MPIs deadlock if a single process tries to communicate with itself
    4342        if (size != 1) {
    44                 // XXX reorder who we're recieving from
    4543                MPI_Sendrecv(grid[1], nrows+2, MPI_INT, left_rank, MPI_TOLEFT,
    46                         grid[ncol1+1], nrows+2, MPI_INT, right_rank, MPI_TOLEFT,
     44                        grid[ncols+1], nrows+2, MPI_INT, right_rank, MPI_TOLEFT,
    4745                        MPI_COMM_WORLD, &status);
    4846
     
    5351        #endif
    5452
    55         // But we still need to copy sides
     53        // Copy sides to maintain periodic boundaries with only one process
    5654        if (size == 1) {
    5755                for (j = 0; j < nrows+2; j++) {
     
    7371        }
    7472
    75         // update
     73        #ifdef OMP
    7674        #pragma omp parallel for private(neighbors,j,k,l)
     75        #endif
    7776        for (i = 1; i <= ncols; i++) {
    7877                for (j = 1; j <= nrows; j++) {
    79                         neighbors = 0;
     78                        // start at -1 to avoid counting "self"
     79                        neighbors = -1;
    8080
     81                        // count neighbors
    8182                        for (k = i-1; k <= i+1; k++) {
    8283                                for (l = j-1; l <= j+1; l++) {
    83                                         if (!(k==i && l==j) && grid[k][l] > 0)
     84                                        if (grid[k][l] > 0)
    8485                                                neighbors++;
    8586                                }
    8687                        }
    8788
     89                        // update next_grid
    8890                        if (neighbors < 2 || neighbors > 3)
    8991                                next_grid[i][j] = 0;
     
    9496}
    9597
    96 typedef int * intarray;
     98/*
     99        allocate_grid()
     100                Allocates memory for a 2D array of integers.
     101*/
     102void allocate_grid(int ncols, int nrows, int *** grid) {
     103        int i,j;
    97104
    98 void allocate_grid(int ncols, int nrows, int *** grid){
    99         int i,j;
    100         (*grid) = (int **) malloc(sizeof(intarray)*(ncols+2));
    101         for (i=0; i<ncols+2;i++) {
    102                 (*grid)[i] = (int *) malloc(sizeof(int)*(nrows+2));
    103                 for (j=0;j<nrows+2;j++) {
    104                         (*grid)[i][j]=0;
    105                 }
     105        (*grid) = (int **) malloc(sizeof(int *) * (ncols+2));
     106
     107        for (i = 0; i < ncols+2; i++) {
     108                (*grid)[i] = (int *) malloc(sizeof(int) * (nrows+2));
     109
     110                for (j = 0; j < nrows+2; j++)
     111                        (*grid)[i][j] = 0;
    106112        }
    107113}
    108114
    109 void free_grid(int ncols, int nrows, int *** grid){
     115/*
     116        free_grid()
     117                Frees memory used by an array that was allocated
     118                with allocate_grid().
     119*/
     120void free_grid(int ncols, int nrows, int *** grid) {
    110121        int i;
    111122        for (i = 0; i < ncols+2; i++) {
     
    115126}
    116127
     128/*
     129        rand_double()
     130                Generate a random double between 0 and 1.
     131*/
    117132double rand_double() {
    118133        return (double)random()/(double)RAND_MAX;
    119134}
    120135
    121 void randomize_grid(int ncols, int nrows, int ** grid, double prob){
     136/*
     137        randomize_grid()
     138                Initialize a Life grid. Each cell has a [prob] chance of starting alive.
     139*/
     140void randomize_grid(int ncols, int nrows, int ** grid, double prob) {
    122141        int i,j;
    123         for (i=1;i<=ncols;i++) {
    124                 for (j=1;j<=nrows;j++) {
    125                         if (rand_double()<prob) {
    126                                 grid[i][j]=1;
    127                         }
     142        for (i = 1; i <= ncols; i++) {
     143                for (j = 1; j <= nrows; j++) {
     144                        if (rand_double() < prob)
     145                                grid[i][j] = 1;
    128146                }
    129147        }
    130148}
    131149
     150/*
     151        random_initByTime()
     152                Seed the random number generator based on the process's rank.
     153*/
    132154void random_initByTime(int rank) {
    133155        srandom(time(NULL) + 100*rank);
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/Makefile

    r2366 r2368  
     1###############################################################################
     2# Makefile for the Game of Life as included on the BCCD (http://bccd.net)
     3#
     4# By default, build only the serial version and include X display.
     5#
     6# Add OMP=1 or MPI=1 to build OpenMP or MPI versions respectively.
     7# Add NO_X11=1 to omit X libraries.
     8###############################################################################
    19
    2 #CC        = mpicc
     10#
     11# Variables and Flags
     12#
     13
    314CC        = gcc
    415
    5 #
    6 # Modify TOPDIR if you use your own include files and library files
    7 #
     16ifdef MPI
     17CC        = mpicc
     18CFLAGS    = -DMPI
     19endif
    820
    9 LIBS      = -lX11 -lm
     21ifdef OMP
     22CC        = gcc
     23CFLAGS   += -fopenmp -DOMP
     24endif
    1025
     26ifndef NO_X11
     27LIBS     += -lX11
     28LDFLAGS  += -L/usr/X11R6/lib
     29else
     30CFLAGS   += -DNO_X11
     31endif
    1132
    12 CFLAGS    = -fopenmp -ggdb
    13 LDFLAGS   = -L/usr/X11R6/lib $(LIBS)
     33LIBS     += -lm
     34CFLAGS   += -g -p
     35LDFLAGS  += $(LIBS)
    1436
    1537PROGRAM   = Life
    1638SRCS      = Life.c
    1739OBJS      = $(SRCS:.c=.o)               # object file
    18 
    19 #
    20 # Rules
    21 #
    22 
    23 .SUFFIXES: .c .o
    24 
    25 .cpp.o:
    26         $(CC) -c $(CFLAGS) $<
    2740
    2841#
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/XLife.h

    r2308 r2368  
    99#include <X11/Xutil.h>
    1010#include <assert.h>   // Include to test return values the lazy way
     11
     12#define LIFE_IMAGE_WIDTH  500
     13#define LIFE_IMAGE_HEIGHT 500
    1114
    1215Display *dpy;
Note: See TracChangeset for help on using the changeset viewer.