Changeset 2372 in /cluster/svnroot


Ignore:
Timestamp:
Apr 30, 2010 6:03:03 PM (11 years ago)
Author:
fitz
Message:

(#486)
Move operations in main to functions
Add Life struct

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

Legend:

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

    r2370 r2372  
    1 #ifndef LIFE_DEFAULTS_H
    2 #define LIFE_DEFAULTS_H
     1#ifndef BCCD_LIFE_DEFAULTS_H
     2#define BCCD_LIFE_DEFAULTS_H
     3
     4#include <stdbool.h>
    35
    46// Default parameters for the simulation
    5 const int  DEFAULT_GRID = 105;
     7const int  DEFAULT_SIZE = 105;
    68const int  DEFAULT_GENS = 1000;
    79const bool DEFAULT_DISP = true;
     
    1113#define  LIFE_IMAGE_WIDTH 500
    1214#define LIFE_IMAGE_HEIGHT 500
     15
     16// All the data Life needs
     17struct life_t {
     18        int  rank;
     19        int  size;
     20        int  ncols;
     21        int  nrows;
     22        int  ** grid;
     23        int  ** next_grid;
     24        bool do_display;
     25        int  generations;
     26};
    1327
    1428enum CELL_STATES {
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/Life.c

    r2369 r2372  
    88
    99#include "Life.h"
    10 
    11 #ifndef NO_X11
    12 #include "XLife.h"
    13 #endif
    14 
    1510#include "Defaults.h" // For Life's constants
    1611
    1712int main(int argc, char ** argv) {
    18         int rank = 0;
    19         int size = 1;
    20         int omp_size;
    21         int ngrid, ncols, nrows;
    22         int generations;
    23         bool do_display;
    2413        int count, i, j;
    25         int ** grid;
    26         int ** next_grid;
     14        struct life_t life;
    2715
    28         // Set up MPI
    29         #ifdef MPI
    30         MPI_Init(&argc,&argv);
    31         MPI_Comm_rank(MPI_COMM_WORLD,&rank);
    32         MPI_Comm_size(MPI_COMM_WORLD,&size);
    33         #endif
     16        init(&life, &argc, &argv);
    3417
    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);
    40         #endif
    41 
    42         random_initByTime(rank);
    43 
    44         ngrid       = DEFAULT_GRID;
    45         ncols       = ngrid;
    46         nrows       = ngrid;
    47         generations = DEFAULT_GENS;
    48         do_display  = DEFAULT_DISP;
    49 
    50         // command line arguments
    51         if (argc > 1) {
    52                 sscanf(argv[1],"%d",&nrows);
    53         }
    54         if (argc > 2) {
    55                 sscanf(argv[2],"%d",&ncols);
    56         }
    57         if (argc > 3) {
    58                 sscanf(argv[3],"%d",&generations);
    59         }
    60         if (argc > 4) {
    61                 if (atoi(argv[4]) != 1)
    62                         do_display = false;
    63         }
    64 
    65         allocate_grid(ncols, nrows, &grid);
    66         allocate_grid(ncols, nrows, &next_grid);
    67         randomize_grid(ncols, nrows, grid, INIT_PROB);
    68 
    69         #ifndef NO_X11
    70         if (do_display) {
    71                 setupWindow(ncols, nrows);
    72                 moveWindow(rank,size,ncols,nrows);
    73         }
    74         #endif
    75 
    76         for (count = 0; count < generations; count++) {
     18        for (count = 0; count < life.generations; count++) {
    7719                #ifndef NO_X11
    78                 if (do_display)
    79                         do_draw(rank,ncols,nrows,grid);
     20                if (life.do_display)
     21                        do_draw(&life);
    8022                #endif
    8123
    82                 do_step(rank,size,ncols,nrows,grid,next_grid);
     24                do_step(&life);
    8325
    8426                #ifdef OMP
     
    8628                #endif
    8729                // copy next_grid to grid
    88                 for (i = 0; i < ncols+2; i++)
    89                         for (j = 0; j < nrows+2; j++)
    90                                 grid[i][j] = next_grid[i][j];
     30                for (i = 0; i < life.ncols+2; i++)
     31                        for (j = 0; j < life.nrows+2; j++)
     32                                life.grid[i][j] = life.next_grid[i][j];
    9133        }
    9234
    93         free_grid(ncols, nrows, &grid);
    94         free_grid(ncols, nrows, &next_grid);
    95 
    96         #ifndef NO_X11
    97         if(do_display)
    98                 free_video();
    99         #endif
    100 
    101         #ifdef MPI
    102         MPI_Finalize();
    103         #endif
     35        cleanup(&life);
    10436}
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/Life.h

    r2369 r2372  
    77////////////////////////////////////////////
    88
     9#ifndef BCCD_LIFE_H
     10#define BCCD_LIFE_H
     11
     12#ifndef NO_X11
     13#include "XLife.h"
     14#endif
     15
    916#ifdef MPI
    1017#include <mpi.h>
    1118#endif
     19
     20#include "Defaults.h" // For Life's constants
    1221
    1322#include <time.h>     // For seeding random
     
    1625#include <stdbool.h>  // For true/false
    1726
    18 #include "Defaults.h" // For Life's constants
     27// Prototypes
     28int               init (struct life_t * life, int * c, char *** v);
     29void           do_step (struct life_t * life);
     30void       copy_bounds (struct life_t * life);
     31void    allocate_grids (struct life_t * life);
     32void        free_grids (struct life_t * life);
     33double     rand_double ();
     34void    randomize_grid (struct life_t * life, double prob);
     35void random_initByTime (int rank);
     36void           cleanup (struct life_t * life);
     37
     38/*
     39        init_env()
     40                Initialize runtime environment.
     41*/
     42int init (struct life_t * life, int * c, char *** v) {
     43        int argc          = *c;
     44        char ** argv      = *v;
     45        life->rank        = 0;
     46        life->size        = 1;
     47        life-> ncols      = DEFAULT_SIZE;
     48        life->nrows       = DEFAULT_SIZE;
     49        life->generations = DEFAULT_GENS;
     50        life->do_display  = DEFAULT_DISP;
     51
     52        // Set up MPI
     53        #ifdef MPI
     54        MPI_Init(&argc, &argv);
     55        MPI_Comm_rank(MPI_COMM_WORLD, &life->rank);
     56        MPI_Comm_size(MPI_COMM_WORLD, &life->size);
     57        #elif OMP
     58        omp_set_num_threads(omp_get_num_procs());
     59        #endif
     60
     61        random_initByTime(life->rank);
     62
     63        // process command line arguments
     64        if (argc > 1) {
     65                sscanf(argv[1],"%d",&life->nrows);
     66        }
     67        if (argc > 2) {
     68                sscanf(argv[2],"%d",&life->ncols);
     69        }
     70        if (argc > 3) {
     71                sscanf(argv[3],"%d",&life->generations);
     72        }
     73        if (argc > 4) {
     74                if (atoi(argv[4]) == 1)
     75                        life->do_display = true;
     76                else
     77                        life->do_display = false;
     78        }
     79
     80        allocate_grids(life);
     81        randomize_grid(life, INIT_PROB);
     82
     83        #ifndef NO_X11
     84        if (life->do_display) {
     85                setupWindow(life->ncols, life->nrows);
     86                moveWindow(life->rank, life->size);
     87        }
     88        #endif
     89}
    1990
    2091/*
     
    2798                Top and bottom are copied from the process's own grid.
    2899*/
    29 void do_step(int rank, int size, int ncols, int nrows, int ** grid,
    30                 int ** next_grid) {
     100void do_step (struct life_t * life) {
    31101        int i,j,k,l,neighbors;
    32         int omp_rank;
     102
     103        int rank  = life->rank;
     104        int size  = life->size;
     105        int ncols = life->ncols;
     106        int nrows = life->nrows;
     107
     108        int ** grid      = life->grid;
     109        int ** next_grid = life->next_grid;
     110
     111        copy_bounds(life);
     112
     113        #ifdef OMP
     114        #pragma omp parallel for private(neighbors,j,k,l)
     115        #endif
     116        for (i = 1; i <= ncols; i++) {
     117                for (j = 1; j <= nrows; j++) {
     118                        neighbors = 0;
     119
     120                        // count neighbors
     121                        for (k = i-1; k <= i+1; k++) {
     122                                for (l = j-1; l <= j+1; l++) {
     123                                        if (!(k == i && l == j) && grid[k][l] == ALIVE)
     124                                                neighbors++;
     125                                }
     126                        }
     127
     128                        // update next_grid
     129                        if (neighbors < LOWER_THRESH || neighbors > UPPER_THRESH)
     130                                next_grid[i][j] = DEAD;
     131                        else if (grid[i][j] == ALIVE || neighbors == SPAWN_THRESH)
     132                                next_grid[i][j] = ALIVE;
     133                }
     134        }
     135}
     136
     137void copy_bounds (struct life_t * life) {
     138        int i,j;
     139
     140        int rank  = life->rank;
     141        int size  = life->size;
     142        int ncols = life->ncols;
     143        int nrows = life->nrows;
     144
     145        int ** grid = life->grid;
    33146
    34147        #ifdef MPI
     
    71184                grid[i][nrows+1] = grid[i][1];
    72185        }
    73 
    74         #ifdef OMP
    75         #pragma omp parallel for private(neighbors,j,k,l)
    76         #endif
    77         for (i = 1; i <= ncols; i++) {
    78                 for (j = 1; j <= nrows; j++) {
    79                         neighbors = 0;
    80 
    81                         // count neighbors
    82                         for (k = i-1; k <= i+1; k++) {
    83                                 for (l = j-1; l <= j+1; l++) {
    84                                         if (!(k == i && l == j) && grid[k][l] == ALIVE)
    85                                                 neighbors++;
    86                                 }
    87                         }
    88 
    89                         // update next_grid
    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;
    94                 }
    95         }
    96 }
    97 
    98 /*
    99         allocate_grid()
     186}
     187
     188/*
     189        allocate_grids()
    100190                Allocates memory for a 2D array of integers and
    101191                initializes all cells to DEAD.
    102192*/
    103 void allocate_grid(int ncols, int nrows, int *** grid) {
     193void allocate_grids (struct life_t * life) {
    104194        int i,j;
    105 
    106         (*grid) = (int **) malloc(sizeof(int *) * (ncols+2));
     195        int ncols = life->ncols;
     196        int nrows = life->nrows;
     197
     198        life->grid = (int **) malloc(sizeof(int *) * (ncols+2));
     199        life->next_grid = (int **) malloc(sizeof(int *) * (ncols+2));
    107200
    108201        for (i = 0; i < ncols+2; i++) {
    109                 (*grid)[i] = (int *) malloc(sizeof(int) * (nrows+2));
    110                 for (j = 0; j < nrows+2; j++)
    111                         (*grid)[i][j] = DEAD;
    112         }
    113 }
    114 
    115 /*
    116         free_grid()
     202                life->grid[i] = (int *) malloc(sizeof(int) * (nrows+2));
     203                life->next_grid[i] = (int *) malloc(sizeof(int) * (nrows+2));
     204                for (j = 0; j < nrows+2; j++) {
     205                        life->grid[i][j] = DEAD;
     206                        life->next_grid[i][j] = DEAD;
     207                }
     208        }
     209}
     210
     211/*
     212        free_grids()
    117213                Frees memory used by an array that was allocated
    118                 with allocate_grid().
    119 */
    120 void free_grid(int ncols, int nrows, int *** grid) {
     214                with allocate_grids().
     215*/
     216void free_grids (struct life_t * life) {
    121217        int i;
     218        int ncols = life->ncols;
     219
    122220        for (i = 0; i < ncols+2; i++) {
    123                 free((*grid)[i]);
    124         }
    125         free(*grid);
     221                free(life->grid[i]);
     222                free(life->next_grid[i]);
     223        }
     224        free(life->grid);
     225        free(life->next_grid);
    126226}
    127227
     
    139239                of starting alive.
    140240*/
    141 void randomize_grid(int ncols, int nrows, int ** grid, double prob) {
     241void randomize_grid (struct life_t * life, double prob) {
    142242        int i,j;
     243        int ncols = life->ncols;
     244        int nrows = life->nrows;
     245
    143246        for (i = 1; i <= ncols; i++) {
    144247                for (j = 1; j <= nrows; j++) {
    145248                        if (rand_double() < prob)
    146                                 grid[i][j] = ALIVE;
     249                                life->grid[i][j] = ALIVE;
    147250                }
    148251        }
     
    157260        srandom(time(NULL) + 100*rank);
    158261}
     262
     263void cleanup (struct life_t * life) {
     264        free_grids(life);
     265
     266        #ifndef NO_X11
     267        if (life->do_display)
     268                free_video();
     269        #endif
     270
     271        #ifdef MPI
     272        MPI_Finalize();
     273        #endif
     274}
     275
     276#endif
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/Makefile

    r2369 r2372  
    3333
    3434LIBS     += -lm
    35 CFLAGS   += -O3
     35CFLAGS   +=
    3636LDFLAGS  += $(LIBS)
    3737
  • bccd-ng/branches/fitz-devel/trees/home/bccd/Life/XLife.h

    r2369 r2372  
    99#include <X11/Xutil.h>
    1010#include <assert.h>   // Include to test return values the lazy way
     11#include <stdio.h>    // for sprintf
    1112
    1213#include "Defaults.h" // For Life's constants
     
    2829}
    2930
    30 void moveWindow(int rank,int size,int ncols, int nrows) {
     31void moveWindow(int rank,int size) {
    3132        int posx, posy;
    3233        posx = 50+(int)((double)rank/(double)size*(double)LIFE_IMAGE_WIDTH);
     
    112113}
    113114
    114 void do_draw(int rank, int ncols, int nrows, int ** grid) {
    115 
     115void do_draw(struct life_t * life) {
    116116        int x1,x2,y1,y2;
    117117        int i,j;
    118118        char string[2];
    119         sprintf(string,"%d",rank);
     119
     120        int rank        = life->rank;
     121        int ncols       = life->ncols;
     122        int nrows       = life->nrows;
     123        int rect_width  = (int)((double)IMAGE_WIDTH/(double)(ncols+1));
     124        int rect_height = (int)((double)IMAGE_HEIGHT/(double)(nrows+1));
     125
     126        int x           = 10; // X coordinate for window
     127        int y           = 10; // Y coordinate for window
     128        int width       = 15; // width of the window
     129        int height      = 15; // height of the window
     130        int rank_x      = 12; // X coordinate for rank display
     131        int rank_y      = 23; // Y coordinate for rank display
     132
     133        sprintf(string,"%d", rank);
    120134
    121135        XSetForeground(dpy, gc, deadColor);
    122136        XFillRectangle(dpy,buffer,gc,0,0,IMAGE_WIDTH,IMAGE_HEIGHT);
    123         int rect_width=(int)((double)IMAGE_WIDTH/(double)(ncols+1));
    124         int rect_height=(int)((double)IMAGE_HEIGHT/(double)(nrows+1));
    125         for (i=1;i<=ncols;i++) {
     137
     138        for (i = 1; i <= ncols; i++) {
    126139                x1 = (int)((double)(i-1)/(double)(ncols+1)*(double)IMAGE_WIDTH);
    127                 for (j=1;j<=nrows;j++) {
     140                for (j = 1; j <= nrows; j++) {
    128141                        y1 = (int)((double)(j-1)/(double)(nrows+1)*
    129142                                        (double)IMAGE_HEIGHT);
    130                         if (grid[i][j]==ALIVE) {
    131                                 int life =grid[i][j];
    132                                 if (life>numXGrayscale-1) life=numXGrayscale-1;
    133                                 XSetForeground(dpy, gc, Xgrayscale[life].pixel);
     143                        if (life->grid[i][j] == ALIVE) {
     144                                int cell = life->grid[i][j];
     145                                if (cell>numXGrayscale-1) cell=numXGrayscale-1;
     146                                XSetForeground(dpy, gc, Xgrayscale[cell].pixel);
    134147                        } else {
    135148                                XSetForeground(dpy, gc, deadColor);
     
    138151                }
    139152        }
     153
    140154        XSetForeground(dpy,gc,deadColor);
    141         XFillRectangle(dpy,buffer,gc,10,10,15,15);
     155        XFillRectangle(dpy,buffer,gc,x,y,width,height);
    142156        XSetForeground(dpy,gc,liveColor);
    143         XDrawRectangle(dpy,buffer,gc,10,10,15,15);
    144         XDrawString(dpy,buffer,gc,12,23,string,2);
     157        XDrawRectangle(dpy,buffer,gc,x,y,width,height);
     158        XDrawString(dpy,buffer,gc,rank_x,rank_y,string,sizeof(string));
    145159
    146160        XCopyArea(dpy, buffer, w, gc, 0, 0,
Note: See TracChangeset for help on using the changeset viewer.