Changeset 2369 in /cluster/svnroot


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

Continue refactoring of Life

(#486)
Revert logic bug
Move magic numbers and other constants to a common header
Minor formatting updating
(#502)
Set number of threads based on available processors/cores

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

    r2368 r2369  
    1313#endif
    1414
    15 // defaults
    16 const int  DEFAULT_GRID = 105;
    17 const int  DEFAULT_GENS = 1000;
    18 const bool DEFAULT_DISP = true;
    19 const double  INIT_PROB = 0.25;
     15#include "Defaults.h" // For Life's constants
    2016
    2117int main(int argc, char ** argv) {
    2218        int rank = 0;
    2319        int size = 1;
     20        int omp_size;
    2421        int ngrid, ncols, nrows;
    2522        int generations;
     
    3431        MPI_Comm_rank(MPI_COMM_WORLD,&rank);
    3532        MPI_Comm_size(MPI_COMM_WORLD,&size);
     33        #endif
     34
     35        // Set up OpenMP
     36        #ifdef OMP
     37        omp_size = omp_get_num_procs();
     38        omp_set_num_threads(omp_size);
     39        printf("set num threads to %d\n", omp_size);
    3640        #endif
    3741
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/Life.h

    r2368 r2369  
    1616#include <stdbool.h>  // For true/false
    1717
    18 #define MPI_TORIGHT 0
    19 #define MPI_TOLEFT  1
     18#include "Defaults.h" // For Life's constants
    2019
    2120/*
     
    3433
    3534        #ifdef MPI
    36         // copy sides
    3735        MPI_Status status;
    3836        int left_rank  = (rank-1+size)%size;
    3937        int right_rank = (rank+1)%size;
    4038
    41         // Some MPIs deadlock if a single process tries to communicate with itself
     39        // Some MPIs deadlock if a single process tries to communicate
     40        // with itself
    4241        if (size != 1) {
     42                // copy sides to neighboring processes
    4343                MPI_Sendrecv(grid[1], nrows+2, MPI_INT, left_rank, MPI_TOLEFT,
    4444                        grid[ncols+1], nrows+2, MPI_INT, right_rank, MPI_TOLEFT,
    4545                        MPI_COMM_WORLD, &status);
    4646
    47                 MPI_Sendrecv(grid[ncols], nrows+2, MPI_INT, right_rank, MPI_TORIGHT,
    48                         grid[0], nrows+2, MPI_INT, left_rank, MPI_TORIGHT,
    49                         MPI_COMM_WORLD, &status);
     47                MPI_Sendrecv(grid[ncols], nrows+2, MPI_INT, right_rank,
     48                        MPI_TORIGHT, grid[0], nrows+2, MPI_INT, left_rank,
     49                        MPI_TORIGHT, MPI_COMM_WORLD, &status);
    5050        }
    5151        #endif
    5252
    53         // Copy sides to maintain periodic boundaries with only one process
     53        // Copy sides locally to maintain periodic boundaries
     54        // when there's only one process
    5455        if (size == 1) {
    5556                for (j = 0; j < nrows+2; j++) {
     
    7677        for (i = 1; i <= ncols; i++) {
    7778                for (j = 1; j <= nrows; j++) {
    78                         // start at -1 to avoid counting "self"
    79                         neighbors = -1;
     79                        neighbors = 0;
    8080
    8181                        // count neighbors
    8282                        for (k = i-1; k <= i+1; k++) {
    8383                                for (l = j-1; l <= j+1; l++) {
    84                                         if (grid[k][l] > 0)
     84                                        if (!(k == i && l == j) && grid[k][l] == ALIVE)
    8585                                                neighbors++;
    8686                                }
     
    8888
    8989                        // update next_grid
    90                         if (neighbors < 2 || neighbors > 3)
    91                                 next_grid[i][j] = 0;
    92                         else if (grid[i][j] > 0 || neighbors == 3)
    93                                 next_grid[i][j] = grid[i][j] + 1;
     90                        if (neighbors < LOWER_THRESH || neighbors > UPPER_THRESH)
     91                                next_grid[i][j] = DEAD;
     92                        else if (grid[i][j] == ALIVE || neighbors == SPAWN_THRESH)
     93                                next_grid[i][j] = ALIVE;
    9494                }
    9595        }
     
    9898/*
    9999        allocate_grid()
    100                 Allocates memory for a 2D array of integers.
     100                Allocates memory for a 2D array of integers and
     101                initializes all cells to DEAD.
    101102*/
    102103void allocate_grid(int ncols, int nrows, int *** grid) {
     
    107108        for (i = 0; i < ncols+2; i++) {
    108109                (*grid)[i] = (int *) malloc(sizeof(int) * (nrows+2));
    109 
    110110                for (j = 0; j < nrows+2; j++)
    111                         (*grid)[i][j] = 0;
     111                        (*grid)[i][j] = DEAD;
    112112        }
    113113}
     
    136136/*
    137137        randomize_grid()
    138                 Initialize a Life grid. Each cell has a [prob] chance of starting alive.
     138                Initialize a Life grid. Each cell has a [prob] chance
     139                of starting alive.
    139140*/
    140141void randomize_grid(int ncols, int nrows, int ** grid, double prob) {
     
    143144                for (j = 1; j <= nrows; j++) {
    144145                        if (rand_double() < prob)
    145                                 grid[i][j] = 1;
     146                                grid[i][j] = ALIVE;
    146147                }
    147148        }
     
    150151/*
    151152        random_initByTime()
    152                 Seed the random number generator based on the process's rank.
     153                Seed the random number generator based on the
     154                process's rank.
    153155*/
    154156void random_initByTime(int rank) {
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/Makefile

    r2368 r2369  
    2020
    2121ifdef OMP
     22# If gcc, must have version >= 4.2
    2223CC        = gcc
    2324CFLAGS   += -fopenmp -DOMP
     
    3233
    3334LIBS     += -lm
    34 CFLAGS   += -g -p
     35CFLAGS   += -O3
    3536LDFLAGS  += $(LIBS)
    3637
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/XLife.h

    r2368 r2369  
    1010#include <assert.h>   // Include to test return values the lazy way
    1111
    12 #define LIFE_IMAGE_WIDTH  500
    13 #define LIFE_IMAGE_HEIGHT 500
     12#include "Defaults.h" // For Life's constants
    1413
    1514Display *dpy;
    16 int blackColor;
    17 int whiteColor;
     15int deadColor;
     16int liveColor;
    1817Window w;
    1918GC gc;
     
    5453        // Get some colors
    5554
    56         blackColor = BlackPixel(dpy, DefaultScreen(dpy));
    57         whiteColor = WhitePixel(dpy, DefaultScreen(dpy));
     55        deadColor = BlackPixel(dpy, DefaultScreen(dpy));
     56        liveColor = WhitePixel(dpy, DefaultScreen(dpy));
    5857
    5958        // Create the window
     
    6867
    6968        w = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0,
    70                         IMAGE_WIDTH, IMAGE_HEIGHT, 0, blackColor,
    71                         blackColor);
     69                        IMAGE_WIDTH, IMAGE_HEIGHT, 0, deadColor,
     70                        deadColor);
    7271        XSetWMProperties(dpy,w,&xtp,NULL,NULL,0,NULL,NULL,NULL);
    7372        buffer = XCreatePixmap(dpy,DefaultRootWindow(dpy),
     
    10099        // Tell the GC we draw using the white color
    101100
    102         XSetForeground(dpy, gc, whiteColor);
     101        XSetForeground(dpy, gc, liveColor);
    103102
    104103        // Wait for the MapNotify event
     
    120119        sprintf(string,"%d",rank);
    121120
    122         XSetForeground(dpy, gc, blackColor);
     121        XSetForeground(dpy, gc, deadColor);
    123122        XFillRectangle(dpy,buffer,gc,0,0,IMAGE_WIDTH,IMAGE_HEIGHT);
    124123        int rect_width=(int)((double)IMAGE_WIDTH/(double)(ncols+1));
     
    129128                        y1 = (int)((double)(j-1)/(double)(nrows+1)*
    130129                                        (double)IMAGE_HEIGHT);
    131                         if (grid[i][j]>0) {
     130                        if (grid[i][j]==ALIVE) {
    132131                                int life =grid[i][j];
    133132                                if (life>numXGrayscale-1) life=numXGrayscale-1;
    134133                                XSetForeground(dpy, gc, Xgrayscale[life].pixel);
    135134                        } else {
    136                                 XSetForeground(dpy, gc, blackColor);
     135                                XSetForeground(dpy, gc, deadColor);
    137136                        }
    138137                        XFillRectangle(dpy,buffer,gc,x1,y1,rect_width,rect_height);
    139138                }
    140139        }
    141         XSetForeground(dpy,gc,blackColor);
     140        XSetForeground(dpy,gc,deadColor);
    142141        XFillRectangle(dpy,buffer,gc,10,10,15,15);
    143         XSetForeground(dpy,gc,whiteColor);
     142        XSetForeground(dpy,gc,liveColor);
    144143        XDrawRectangle(dpy,buffer,gc,10,10,15,15);
    145144        XDrawString(dpy,buffer,gc,12,23,string,2);
Note: See TracChangeset for help on using the changeset viewer.