Changeset 2597 in /cluster/svnroot


Ignore:
Timestamp:
Aug 29, 2010 7:26:01 PM (10 years ago)
Author:
skylar
Message:

merging in mpd fixes again (#520)

Location:
bccd-ng/branches/skylar-devel/trees
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • bccd-ng/branches/skylar-devel/trees/bin/bccd-snarfhosts

    r2559 r2597  
    5050        fi
    5151done
     52
     53rm -f $FILE.lock
  • bccd-ng/branches/skylar-devel/trees/etc/init.d/mpd

    r2150 r2597  
    1 #!/bin/sh
     1#!/bin/bash
    22
    33### BEGIN INIT INFO
    44# Provides:             mpd
    55# Required-Start:
    6 # Required-Stop:       
     6# Required-Stop:
    77# Default-Start:        2 4 5
    88# Default-Stop:         0 1 6
    9 # Short-Description: Start MPICH Process Manager Daemon
     9# Short-Description: Start MPICH Process Daemon
     10# Description:       MPD (MPICH Process Daemon) is the daemon that manages
     11#                    distribution of MPI processes compiled and run with
     12#                    MPICH2. This init script has been written to help
     13#                    manage MPD on the BCCD (http://bccd.net).
    1014### END INIT INFO
    1115
     
    1519
    1620NAME=mpd
    17 DAEMON=/bccd/software/mpich2-1.2.1/bin/mpd
     21MPICH_BIN=/bccd/software/mpich2/bin
     22DAEMON=$MPICH_BIN/$NAME
     23MPDEXIT="$MPICH_BIN/mpdexit localmpd"
    1824PIDFILE=/var/run/mpd.pid
    1925CFGFILE=/etc/mpd.conf
    20 HEADNODE=node000.bccd.net
     26PORTFILE=/etc/snmp/mpd.port
     27NCPUS=`grep ^processor /proc/cpuinfo | wc -l`
     28
     29if [ "`cat /etc/bccd-stage`" == "LIBERATED" ]; then
     30        HEADNODE=pxenode000.bccd.net
     31else
     32        HEADNODE=node000.bccd.net
     33fi
    2134
    2235test -x $DAEMON || exit 5
    2336
    24 function start_mpd {
    25         if test "`hostname`" == "$HEADNODE"; then
     37function head_start {
     38        unset PORT
     39
     40        # if we've already found a port, don't try again
     41        # but check it anyways just for good measure
     42        if test -f $PORTFILE; then
     43                PORT=`cat $PORTFILE`
     44                /bin/nc -z localhost $PORT
     45                # unset PORT if it's now used
     46                test $? == 0 && unset PORT
     47        fi
     48
     49        if ! test $PORT; then
     50                # $RANDOM gives an integer between 0 and 32767
     51                # ... add 32767 to get a high port number.
    2652                PORT=$(($RANDOM+32767))
    27                 /bin/nc -z `hostname` $PORT
    2853
     54                # Test availability of that port and keep trying
     55                # until we get an open one
     56                /bin/nc -z localhost $PORT
    2957                while [ $? -eq 0 ]; do
    3058                        PORT=$(($RANDOM+32767))
    31                         /bin/nc -z `hostname` $PORT
     59                        /bin/nc -z localhost $PORT
    3260                done
    33                 echo $PORT > /etc/snmp/mpd.port
    3461
    35                 start-stop-daemon --start --quiet --oknodo --pidfile $PIDFILE --startas $DAEMON -- --pid=$PIDFILE --daemon --ncpus=$NCPUS --listenport=$PORT
     62                echo $PORT > $PORTFILE
     63        fi
     64
     65        chmod 600 $CFGFILE
     66        start-stop-daemon --start --quiet --oknodo \
     67                --pidfile $PIDFILE --startas $DAEMON -- \
     68                --pid=$PIDFILE --daemon --ncpus=$NCPUS --listenport=$PORT
     69        status=$?
     70        chmod 644 $CFGFILE
     71
     72        return $status
     73}
     74
     75function compute_start {
     76        PORT=`snmpget -OQv -c public -v 1 $HEADNODE \
     77                .1.3.6.1.4.1.2021.84.4.1.2.8.109.112.100.95.112.111.114.116.1 \
     78                | sed -e 's!"!!g'`
     79
     80        chmod 600 $CFGFILE
     81        start-stop-daemon --start --quiet --oknodo \
     82                --pidfile $PIDFILE --startas $DAEMON -- \
     83                --pid=$PIDFILE --daemon --ncpus=$NCPUS --host=$HEADNODE --port=$PORT
     84        status=$?
     85        chmod 644 $CFGFILE
     86
     87        return $status
     88}
     89
     90function start_mpd {
     91        # matches node000.bccd.net AND pxenode000.bccd.net
     92        if [[ "`hostname`" =~ node000 ]]; then
     93                head_start
     94                return $?
    3695        else
    37                 PORT=`snmpget -OQv -c public -v 1 $HEADNODE .1.3.6.1.4.1.2021.84.4.1.2.8.109.112.100.95.112.111.114.116.1|sed -e 's!"!!g'`
    38                 start-stop-daemon --start --quiet --oknodo --pidfile $PIDFILE --startas $DAEMON -- --pid=$PIDFILE --daemon --ncpus=$NCPUS --host=$HEADNODE --port=$PORT
     96                compute_start
     97                return $?
    3998        fi
    4099}
     
    42101case $1 in
    43102        start)
    44                 log_daemon_msg "Starting MPD server" "mpd"
    45                 NCPUS=`grep ^processor /proc/cpuinfo | wc -l`
    46                 chmod 600 $CFGFILE
     103                test $UID == 0 || { log_failure_msg "Must be root!" && exit 4; }
     104
     105                $0 status &> /dev/null
     106                test $? == 0 && { log_success_msg "MPD server already running" && exit 0; }
     107
     108                log_daemon_msg "Starting MPD server"
    47109                start_mpd
    48                 chmod 644 $CFGFILE
    49110                status=$?
     111
     112                log_progress_msg "mpd"
    50113                log_end_msg $status
    51114                ;;
    52115        stop)
    53                 log_daemon_msg "Stopping MPD server" "mpd"
    54                 start-stop-daemon --stop --quiet --oknodo --pidfile $PIDFILE
    55                 log_end_msg $?
    56                 rm -f $PIDFILE
     116                test $UID == 0 || { log_failure_msg "Must be root!" && exit 4; }
     117
     118                $0 status &> /dev/null
     119                test $? != 0 && { log_success_msg "No MPD server running" && exit 0; }
     120
     121                log_daemon_msg "Stopping MPD server"
     122                chmod 600 $CFGFILE
     123                $MPDEXIT
     124                status=$?
     125                chmod 644 $CFGFILE
     126
     127                log_progress_msg "mpd"
     128               
     129                rm -f $PIDFILE &> /dev/null
     130                log_end_msg $status
    57131                ;;
    58         restart)
    59                 $0 stop && sleep 2 && $0 start
     132        restart | force-reload)
     133                $0 stop; sleep 1; $0 start
    60134                ;;
    61135        status)
    62                 pidofproc -p $PIDFILE $DAEMON > /dev/null
     136                pidofproc -p $PIDFILE $DAEMON &> /dev/null
    63137                status=$?
    64138                if [ $status -eq 0 ]; then
     
    70144                ;;
    71145        *)
    72                 echo "Usage: $0 {start|stop|restart|status}"
     146                echo "Usage: $0 {start|stop|restart|force-reload|status}"
    73147                exit 2
    74148                ;;
  • bccd-ng/branches/skylar-devel/trees/home/bccd/Life/Life.c

    r2543 r2597  
    1 /*******************************************
    2 MPI Life 1.0
    3 Copyright 2002, David Joiner and
    4   The Shodor Education Foundation, Inc.
    5 Updated 2010, Andrew Fitz Gibbon and
    6   The Shodor Education Foundation, Inc.
    7 
    8 A C implementation of Conway's Game of Life.
    9 
    10 To run:
    11 ./Life [Rows] [Columns] [Generations] [Display]
    12 
    13 See the README included in this directory for
    14 more detailed information.
    15 *******************************************/
    16 
     1////////////////////////////////////////////
     2// MPI Life 0.9
     3// Copyright 2002, David Joiner and
     4//   The Shodor Education Foundation, Inc.
     5////////////////////////////////////////////
     6
     7#include <stdlib.h>
     8#include <stdio.h>
    179#include "Life.h"
    18 #include "Defaults.h" // For Life's constants
     10#include "mpi.h"
     11#include <time.h>
     12
     13#include <X11/Xlib.h> // Every Xlib program must include this
     14#include <X11/Xutil.h>
     15#include <assert.h>   // I include this to test return values the lazy way
     16#include <unistd.h>   // So we got the profile for 10 seconds
     17#define NIL (0)       // A name for the void pointer
     18
     19typedef unsigned int bool;
     20#define false 0;
     21#define true 1;
     22
     23#define MPI_TORIGHT 0
     24#define MPI_TOLEFT 1
     25
     26MPI_Status mpi_status;
    1927
    2028int main(int argc, char ** argv) {
     29    int size;
     30    int rank;
     31    int ngrid;
     32    int ncols;
     33    int nrows;
     34    int max_count;
     35    int do_display;
     36    int count;
     37    int i,j;
     38    int ** grid;
     39    int ** next_grid;
     40
     41    // Set up MPI
     42    MPI_Init(&argc,&argv);
     43    MPI_Comm_rank(MPI_COMM_WORLD,&rank);
     44    MPI_Comm_size(MPI_COMM_WORLD,&size);
     45
     46    random_initByTime(rank);
     47
     48    // defaults
     49    ngrid=105;
     50    ncols=ngrid;
     51    nrows=ngrid;
     52    max_count=1000;
     53    do_display=1;
     54   
     55    // command line arguments
     56    if (argc > 1) {
     57        sscanf(argv[1],"%d",&nrows);
     58    }
     59    if (argc > 2) {
     60        sscanf(argv[2],"%d",&ncols);
     61    }
     62    if (argc > 3) {
     63        sscanf(argv[3],"%d",&max_count);
     64    }
     65    if (argc > 4) {
     66        sscanf(argv[4],"%d",&do_display);
     67    }
     68    if (do_display!=0) do_display=1;
     69
     70
     71    allocate_grid(ncols, nrows, &grid);
     72    allocate_grid(ncols, nrows, &next_grid);
     73    randomize_grid(ncols, nrows, grid, 0.25);
     74    if (do_display==1)
     75        setupWindow(ncols, nrows);
     76    if (do_display==1)
     77        moveWindow(rank,size,ncols,nrows);
     78
     79
     80    bool done=false;
     81    count=0;
     82    while(!done) {
     83        if (count++>max_count) done=true;
     84        // output
     85        if (count%1==0&&do_display==1) {
     86                doDraw(rank,ncols,nrows,grid);
     87        }
     88        do_step(rank,size,ncols,nrows,grid,next_grid);
     89        //doDraw(rank,ncols,nrows,next_grid);
     90        //do_step(ncols,nrows,next_grid,grid);
     91        for (i=0;i<ncols+2;i++) {
     92            for (j=0;j<nrows+2;j++) {
     93                grid[i][j]=next_grid[i][j];
     94            }
     95        }
     96    }
     97   
     98   
     99    cleanup_grid(ncols, nrows, &grid);
     100    cleanup_grid(ncols, nrows, &next_grid);
     101    if(do_display==1) free_video();
     102    MPI_Finalize();
     103
     104
     105}
     106
     107void do_step(int rank, int size, int ncols, int nrows, int ** grid,
     108        int ** next_grid) {
     109    int i,j,k,l,neighbors;
     110   
     111    // side by side grid
     112    // top and bottom we get from current cell.
     113    //left right and corners we get from neighboring grids.
     114    // start off with non blocking sends of each "row"
     115    // left is rank - 1 % size, right is rank + 1 % size.
     116
     117    // copy sides
     118    int left_rank = (rank-1+size)%size;
     119    int right_rank = (rank+1)%size;
     120   
     121    // If we're only 1, no need to do the communication
     122    if (size != 1) {
     123            if (left_rank>=rank) {
     124                MPI_Send(grid[1],nrows+2,MPI_INT,left_rank,MPI_TOLEFT,
     125                    MPI_COMM_WORLD);
     126                MPI_Recv(grid[ncols+1],nrows+2,MPI_INT,right_rank,
     127                    MPI_TOLEFT,
     128                    MPI_COMM_WORLD, &mpi_status);
     129            } else {
     130                MPI_Recv(grid[ncols+1],nrows+2,MPI_INT,right_rank,
     131                    MPI_TOLEFT,MPI_COMM_WORLD, &mpi_status);
     132                MPI_Send(grid[1],nrows+2,MPI_INT,left_rank,MPI_TOLEFT,
     133                    MPI_COMM_WORLD);
     134            }
     135           
     136            if (right_rank>=rank) {
     137                MPI_Send(grid[ncols],nrows+2,MPI_INT,right_rank,MPI_TORIGHT,
     138                    MPI_COMM_WORLD);
     139                MPI_Recv(grid[0],nrows+2,MPI_INT,left_rank,
     140                    MPI_TORIGHT,
     141                    MPI_COMM_WORLD, &mpi_status);
     142            } else {
     143                MPI_Recv(grid[0],nrows+2,MPI_INT,left_rank,
     144                    MPI_TORIGHT,
     145                    MPI_COMM_WORLD, &mpi_status);
     146                MPI_Send(grid[ncols],nrows+2,MPI_INT,right_rank,MPI_TORIGHT,
     147                    MPI_COMM_WORLD);
     148            }
     149        }
     150   
     151    // copy corners
     152        grid[0][0]=grid[0][nrows];
     153        grid[0][nrows+1]=grid[0][1];
     154        grid[ncols+1][0]=grid[ncols+1][nrows];
     155        grid[ncols+1][nrows+1]=grid[ncols+1][1];
    21156       
    22 #ifdef PETAKIT
    23         startTimer();
    24 #endif
    25         int count;
    26         struct life_t life;
    27 
    28         init(&life, &argc, &argv);
    29 
    30         for (count = 0; count < life.generations; count++) {
    31                 if (life.do_display)
    32                         do_draw(&life);
    33 
    34                 copy_bounds(&life);
    35 
    36                 eval_rules(&life);
    37 
    38                 update_grid(&life);
    39 
    40                 throttle(&life);
     157        //copy top and bottom
     158        for (i=1;i<=ncols;i++) {
     159                grid[i][0]=grid[i][nrows];
     160                grid[i][nrows+1]=grid[i][1];
    41161        }
    42162
    43         cleanup(&life);
    44 
    45 #ifdef PETAKIT
    46         printStats("Life",life.size,"mpi",life.ncols * life.nrows, "1.3",0, 3, "iCOLUMNS", (long long int) life.ncols, "iROWS", (long long int)life.nrows, "iGENERATIONS", (long long int)life.generations);
    47 #endif
    48 
    49         exit(EXIT_SUCCESS);
    50 }
     163
     164        //update
     165        for (i=1;i<=ncols;i++) {
     166                for (j=1;j<=nrows;j++) {
     167                        neighbors=0;
     168                        for (k=i-1;k<=i+1; k++) {
     169                                for (l=j-1;l<=j+1; l++) {
     170                                        if (!(k==i&&l==j)&&grid[k][l]>0) {
     171                                                neighbors++;
     172                                        }
     173                                }
     174                                if (neighbors>3) continue;
     175                        }
     176                        if (neighbors<2||neighbors>3) {
     177                                next_grid[i][j]=0;
     178                        } else if (grid[i][j]>0||neighbors==3) {
     179                                next_grid[i][j]=grid[i][j]+1;
     180                        }
     181                }
     182        }
     183}
     184
     185typedef int * intarray;
     186
     187void allocate_grid(int ncols, int nrows, int *** grid){
     188    int i,j;
     189    (*grid) = (int **) malloc(sizeof(intarray)*(ncols+2));
     190    for (i=0; i<ncols+2;i++) {
     191        (*grid)[i] = (int *) malloc(sizeof(int)*(nrows+2));
     192        for (j=0;j<nrows+2;j++) {
     193            (*grid)[i][j]=0;
     194        }
     195    }
     196}
     197void cleanup_grid(int ncols, int nrows, int *** grid){
     198    int i;
     199    for (i=0;i<ncols+2;i++) {
     200        free((*grid)[i]);
     201    }
     202    free(*grid);
     203}
     204void randomize_grid(int ncols, int nrows, int ** grid, double prob){
     205    int i,j;
     206    for (i=1;i<=ncols;i++) {
     207        for (j=1;j<=nrows;j++) {
     208            if (rand_double()<prob) {
     209                grid[i][j]=1;
     210            }
     211        }
     212    }
     213}
     214
     215double rand_double() {
     216    return (double)rand()/(double)RAND_MAX;
     217}
     218
     219
     220
     221// X information, at some point this should be cleaned up so
     222// that it does not use global variables
     223
     224// setupWindow modified from the tutorial on
     225// http://tronche.com/gui/x/xlib-tutorial/
     226// by Christophe Tronche
     227
     228
     229Display *dpy;
     230int blackColor;
     231int whiteColor;
     232Window w;
     233GC gc;
     234Pixmap buffer;
     235Colormap theColormap;
     236int numXGrayscale=10;
     237XColor Xgrayscale[10];
     238int IMAGE_WIDTH=LIFE_IMAGE_WIDTH;
     239int IMAGE_HEIGHT=LIFE_IMAGE_HEIGHT;
     240
     241void free_video() {
     242     XCloseDisplay(dpy);
     243}
     244
     245void moveWindow(int rank,int size,int ncols, int nrows) {
     246      int posx, posy;
     247      posx = 50+(int)((double)rank/(double)size*(double)LIFE_IMAGE_WIDTH);
     248      posy = 50;
     249      XMoveWindow(dpy, w, posx, posy);
     250}
     251
     252
     253void setupWindow(int ncols, int nrows) {
     254      int i;
     255      XTextProperty xtp;
     256        Status xst;
     257
     258        // Generate name object
     259        char *name="Life";
     260        xst = XStringListToTextProperty(&name,1,&xtp);
     261        assert(xst != 0);
     262
     263      // Open the display
     264
     265      dpy = XOpenDisplay(NIL);
     266      assert(dpy);
     267
     268      // Get some colors
     269
     270      blackColor = BlackPixel(dpy, DefaultScreen(dpy));
     271      whiteColor = WhitePixel(dpy, DefaultScreen(dpy));
     272
     273      // Create the window
     274      if (nrows>ncols) {
     275         IMAGE_WIDTH = (int)((double)LIFE_IMAGE_WIDTH*(double)ncols/(double)nrows);
     276         IMAGE_HEIGHT = LIFE_IMAGE_HEIGHT;
     277      } else {
     278         IMAGE_HEIGHT = (int)((double)LIFE_IMAGE_HEIGHT*(double)nrows/(double)ncols);
     279         IMAGE_WIDTH = LIFE_IMAGE_WIDTH;
     280      }
     281     
     282
     283      w = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0,
     284                                     IMAGE_WIDTH, IMAGE_HEIGHT, 0, blackColor,
     285                                     blackColor);
     286        XSetWMProperties(dpy,w,&xtp,NULL,NULL,0,NULL,NULL,NULL);
     287      buffer = XCreatePixmap(dpy,DefaultRootWindow(dpy),
     288          IMAGE_WIDTH,IMAGE_HEIGHT,DefaultDepth(dpy,
     289          DefaultScreen(dpy)));
     290         
     291      theColormap = XCreateColormap(dpy, DefaultRootWindow(dpy),
     292          DefaultVisual(dpy,DefaultScreen(dpy)), AllocNone);
     293         
     294      for (i=0;i<numXGrayscale;i++) {
     295          int color = (int)((double)i*35535.0/(double)numXGrayscale)+30000;
     296          Xgrayscale[i].red=color;
     297          Xgrayscale[i].green=color;
     298          Xgrayscale[i].blue=color;
     299          XAllocColor(dpy,theColormap,&(Xgrayscale[i]));
     300      }
     301
     302      // We want to get MapNotify events
     303
     304      XSelectInput(dpy, w, StructureNotifyMask);
     305
     306      // "Map" the window (that is, make it appear on the screen)
     307
     308      XMapWindow(dpy, w);
     309
     310      // Create a "Graphics Context"
     311
     312      gc = XCreateGC(dpy, w, 0, NIL);
     313
     314      // Tell the GC we draw using the white color
     315
     316      XSetForeground(dpy, gc, whiteColor);
     317
     318      // Wait for the MapNotify event
     319
     320      for(;;) {
     321            XEvent e;
     322            XNextEvent(dpy, &e);
     323            if (e.type == MapNotify)
     324                  break;
     325      }
     326
     327}
     328
     329void doDraw(int rank, int ncols, int nrows, int ** grid) {
     330
     331    int x1,x2,y1,y2;
     332    int i,j;
     333    char string[2];
     334    sprintf(string,"%d",rank);
     335   
     336    XSetForeground(dpy, gc, blackColor);
     337    XFillRectangle(dpy,buffer,gc,0,0,IMAGE_WIDTH,IMAGE_HEIGHT);
     338    int rect_width=(int)((double)IMAGE_WIDTH/(double)(ncols+1));
     339    int rect_height=(int)((double)IMAGE_HEIGHT/(double)(nrows+1));
     340    for (i=1;i<=ncols;i++) {
     341        x1 = (int)((double)(i-1)/(double)(ncols+1)*(double)IMAGE_WIDTH);
     342        for (j=1;j<=nrows;j++) {
     343            y1 = (int)((double)(j-1)/(double)(nrows+1)*
     344                (double)IMAGE_HEIGHT);
     345            if (grid[i][j]>0) {
     346                int life =grid[i][j];
     347                if (life>numXGrayscale-1) life=numXGrayscale-1;
     348                XSetForeground(dpy, gc, Xgrayscale[life].pixel);
     349            } else {
     350                XSetForeground(dpy, gc, blackColor);
     351            }
     352            XFillRectangle(dpy,buffer,gc,x1,y1,rect_width,rect_height);
     353         }
     354     }
     355     XSetForeground(dpy,gc,blackColor);
     356     XFillRectangle(dpy,buffer,gc,10,10,15,15);
     357     XSetForeground(dpy,gc,whiteColor);
     358     XDrawRectangle(dpy,buffer,gc,10,10,15,15);
     359     XDrawString(dpy,buffer,gc,12,23,string,2);
     360     
     361     XCopyArea(dpy, buffer, w, gc, 0, 0,
     362         IMAGE_WIDTH, IMAGE_HEIGHT,  0, 0);
     363     XFlush(dpy);
     364         
     365}
     366
     367void random_initByTime(int rank) {
     368    time_t ltime;
     369
     370    time(&ltime);
     371    srand((unsigned) ltime + 100*rank);
     372}
Note: See TracChangeset for help on using the changeset viewer.