Lab 8a – The Game of Life "Write a C program to display successive generations of the Game of Life using a 80 x 80 grid of square cells. Each new generation consists of births (an empty cell with exactly 3 neighbors), survivals (a filled cell with either 2 or 3 neighbors), and deaths by starvation (a filled cell with 0 or 1 neighbors) or over population (4 or more neighbors). Setup the initial generation or seed with Run Length Encoded (RLE) patterns of live and dead cells. Use the switches to restart/select new seed patterns. Generate and display at least five successive generations in one second." BYU CS 224 The Game of Life

The Game of Life By completing the Life Lab, a student will have: Experienced dealing with limited system resources (time and memory). Parsed a RLE string for numbers and tokens. Written time critical algorithms. Examined compiler generated code and optimized the code for speed. Used C bit-arrays and pointers. Implemented C pre-processor macros. Learned techniques of computer simulations. BYU CS 224 The Game of Life

Questions… What is the RAM size of the MSP430F2274? How many Life cells in an 80 x 80 array? What is the smallest data type required to store a Life cell? Why are two arrays needed to create successive generations of Life? 1024 bytes 80  80 = 6400 cells Alive or dead = 2 (Boolean, bit) The next generation is a function of only the current generation. BYU CS 224 The Game of Life

Game of Life Rules  A live cell stays alive (survives) if it has 2 or 3 live neighbors, otherwise it dies.  A dead cell comes to life (birth) if it has exactly 3 live neighbors, otherwise it stays dead. BYU CS 224 The Game of Life

The Game of Life Rules The Game of Life is theoretically played on an infinite Cartesian grid of square cells; each cell is either "alive" or "dead". The state of each cell for successive generations of Life is determined by how the cell interacts with its eight neighboring cells using the following rules (referred to as B3/S23):  A live cell stays alive (survives) if it has 2 or 3 live neighbors, otherwise it dies.  A dead cell comes to life (birth) if it has exactly 3 live neighbors, otherwise it stays dead. Computer RAM memory and LCD display area are limited on our development boards. Therefore, restrict your Life simulation to an 80 x 80 grid of binary square cells with the outer cells always being dead. BYU CS 224 The Game of Life

C Bit Manipulation C language is very efficient in manipulating bits or other pieces of data shorter than a byte.. Operator Description & Binary AND Operator copies a bit to the result if it exists in both operands. | Binary OR Operator copies a bit if it exists in either operand. ^ Binary XOR Operator copies the bit if it is set in one operand but not both. ~ Binary Ones Complement Operator is unary and has the effect of 'flipping' bits. << Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. >> Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. life[row][col/8] |= (0x80 >> (col%8)); life[row][col/8] &= ~(0x80 >> (col%8)); BYU CS 224 The Game of Life

life[row][col/8] & (0x80 >> (col%8)) lcd_point(col*2, row*2, 7); RBX430-1 LCD 160 x 160 x 5 pixels display row (0-79) col (0-79) life[row][col/8] & (0x80 >> (col%8)) lcd_point(col*2, row*2, 7); uint8 life[80][10]; BYU CS 224 The Game of Life

C Pre-processor C Pre-processor macros Simplify coding Make program more readable Helps avoid errors from repetition. #define MASK(col) (0x80 >> ((col)%8)) #define SET_CELL(a2d,row,col) a2d[row][(col)/8] |= MASK(col) #define CLEAR_CELL(a2d,row,col) a2d[row][(col)/8] &= ~ MASK(col) #define TOGGLE_CELL(a2d,row,col) a2d[row][(col)/8] ^= MASK(col) #define CELL_VALUE(a1d,col) ((a1d[(col)/8] & MASK(col)) ? 1 : 0) SET_CELL(life,row,col); CLEAR_CELL(life,row,col); TOGGLE_CELL(life,row,col); if (CELL_VALUE(temp,col) == 0) { ... }; BYU CS 224 The Game of Life

“Sliding” Window into life 1. Init pr, cr, nr from life array. life[79][0-9] … life[78][0-9] life[77][0-9] life[76][0-9] life[75][0-9] pr[0-9] … cr[0-9] nr[0-9] 1 neighbor Cell dies 2. Use pr, cr, nr to update current row in life array. life[79][0-9] … life[78][0-9] D life[77][0-9] life[76][0-9] life[75][0-9] pr[0-9] … cr[0-9] nr[0-9] 3. Copy cr to pr, nr to cr, and current row+1 to nr from life array. life[79][0-9] … life[78][0-9] life[77][0-9] life[76][0-9] life[75][0-9] pr[0-9] … cr[0-9] nr[0-9] BYU CS 224 The Game of Life

“Sliding” Window into life 3 neighbors Cell birth 4. Use pr, cr, nr to update current row in life array. life[79][0-9] … life[78][0-9] life[77][0-9] B S life[76][0-9] life[75][0-9] 2 neighbors Cell survives 3 neighbors Cell birth pr[0-9] … cr[0-9] nr[0-9] 5. Copy cr to pr, nr to cr, and current row+1 to nr from life array. life[79][0-9] … life[78][0-9] life[77][0-9] life[76][0-9] life[75][0-9] pr[0-9] … cr[0-9] nr[0-9] 1 neighbor Cell death 6. Use pr, cr, nr to update current row in life array. life[79][0-9] … life[78][0-9] life[77][0-9] life[76][0-9] D life[75][0-9] pr[0-9] … cr[0-9] nr[0-9] BYU CS 224 The Game of Life

Initial Game Seed The initial Life generation or game seed is created from a set of Run Length Encoded patterns that are loaded by your program into the Life grid at the beginning of a new game. Thereafter, each successive generation is a new grid created by applying the above rules simultaneously to every cell in the previous generation (ie., births and deaths occur simultaneously). Write a C function to parse an ASCII RLE pattern using the following function prototype: void draw_rle_pattern(int row, int col, const uint8* pattern); where: row = lower Life grid row (0-79) of the pattern col = left Life grid column (0-79) of the pattern pattern = byte pointer (const uint8*) to the RLE pattern BYU CS 224 The Game of Life

Walk the array until token or NULL terminator. Return result in number Parsing String Parsing What is the value of X? char str[] = "Point X = 100"; Walk the array until token or NULL terminator. (Token must be unique) Find token: char* ptr = str; int number = 0; while (*ptr && (*ptr++ != 'X')); isdigit returns 0 or 1 Find beginning of number: while (*ptr && !isdigit(*ptr)) ++ptr; Convert to decimal: while (isdigit(*ptr)) number = number * 10 + (*ptr++ - '0'); Return result in number Proceed with parsing of line. BYU CS 224 The Game of Life

Game Seed Selection Use the four switches on the RBX430-1 development board to load/restart a new pre-set Life game seed. Write a C function to load a set of RLE patterns using a switch value to select either a LIFE, BIRD, OBJECTS, or set of patterns of your choice. enum SEED { LIFE=0x01, BIRD=0x02, OBJECTS=0x04, YOURS=0x08 }; void init_life(enum SEED seed); if (seed = (P1IN & 0x0f) ^ 0x0f) init_life(seed); (Use the BIRD seed for the 60-second club.) BYU CS 224 The Game of Life

Life Patterns Gosper Glider Gun BYU CS 224 The Game of Life

Optimization Each successive generation of Life should be created and displayed in one-fifth of a second or less. To reach this goal, you will need to choose an optional data structure for the Life grids as well as use appropriate algorithms and data derivations to efficiently generate successive generations. Call the function display_results after every generation. The simulation will stop and display the average generations per second immediately after seconds equals 60. Your goal should be to make the top 10 list of the 60 Second Club. BYU CS 224 The Game of Life

Life Requirements 1 point Your source contains header comments with your name and a declaration that the completed assignment is your own work. The red LED blinks for every new generation of Life. An unaltered display_results function is called for each generation to display the current generation, time in seconds, and the current number of generations per second on the LCD. 5 points Each generation of Life is correctly displayed (B3/S23) using an 80 x 80 grid (2x2 LCD pixels) with the outer cells always being dead. A 1 pixel border outlines the Life grid on the LCD. 2 points Encrypted Life patterns are correctly loaded from program memory into an 80 x 80 Life grid using the Life Run Length Encoded (RLE) Life format. 1 point Pressing a switch at any time loads a new generation seed from a set of pre-defined RLE patterns and restarts a new Life game. (Switch #4 loads a set of RLE patterns of your choice.) 1 point 1 point Each successive generation takes no longer than 1/5 of a second to create and display. BYU CS 224 The Game of Life

Life Requirements +1 point Passed off with a TA at least one day early. (No timestamps please!) +1 point Your Life simulation runs faster than six generations per second. (+2 points if faster than 9 generations and +3 points if faster than 12 generations per second.) +2 points Your Life grid is a toroid array where the left and right edges of the Life grid are "stitched" together as well as the top and bottom edges. The result is that active areas of Life generations move across a grid edge reappear at the opposite edge. +1 point Use switch #4 to toggle your simulation between regular rules (B3/S23) and a HighLife rules variation (B36/S23) where a cell is born if it has 3 or 6 neighbors and survives if it has 2 or 3 neighbors. Add a RLE replicator pattern to your LIFE seed and observe what happens. x = 4, y = 4, rule = B36/S23\nb3o$o3b$o3b$o! -1 point For each school day late. (Timestamps may be used to verify completion time.) BYU CS 224 The Game of Life

60 Second Club Rules Rules will be used in determining the top 10 submissions: Your Life program is written in C (no assembly please!) Set both your CCS project Optimization level and Control speed vs. size trade-offs to 1. (Project->Properties->Build->MSP430 Compiler->Optimization) Use the "BIRD" set of patterns as the Life seed to determine placement in the top 10 rankings. Clear the generation and seconds counter at the beginning of the game. The function display_results is called for every generation. The simulation will stop and display the average generations per second immediately after seconds equals 60. Use any C library function (without modification) in your implementation. Submit your source to a TA for verification. If your speed is faster than any in the following list, you will be added! BYU CS 224 The Game of Life

60 Second Club BYU CS 224 The Game of Life

Speed!!!! Increase processor speed to maximum (16MHz). Choose an efficient/fast method of storing the Life grids. Choices could include: Use FRAM to store two life arrays. (Slowest approach) Use LCD RAM for current, FRAM for next. (A little faster.) Use RAM for current, FRAM for next. (Faster.) Using system RAM as a bit array and a smaller RAM window to update next generation in system RAM. (Fastest solution!) Avoid copying data as much as possible. Remove redundant operations from loops. Use table lookups where possible instead of repeated calculations such as when creating bit masks. Use local variables to remove repeated calculations. BYU CS 224 The Game of Life

How to Proceed Do a thorough design – use systematic decomposition. Verify demo Life works correctly. Add a simple pattern (ie. Blinker) to your life grid. Add B3/S23 logic and test. Program RLE loader and test. Optimize and use regression tests. Test, test, test. BYU CS 224 The Game of Life

“Life is governed by 4 simple rules!” Links… “Life is governed by 4 simple rules!” Game of Life http://www.youtube.com/watch?v=pWNq9iMxYZo Life in Life http://www.youtube.com/watch?v=xP5-iIeKXE8 Epic Conway’s Game of Life http://www.youtube.com/watch?v=C2vgICfQawE 60 Second Club http://students.cs.byu.edu/~cs124ta/labs/L09a-life/life_60_sec_club.html BYU CS 224 The Game of Life

BYU CS 224 The Game of Life

#includes needed for Life lab Previous, current, and next row life.c #includes needed for Life lab // includes ----------------------------------------------------------- #include "msp430.h" #include <stdlib.h> #include "RBX430-1.h" #include "RBX430_lcd.h" #include "life.h" // global variables --------------------------------------------------- extern volatile uint16 WDT_Sec_Cnt; // WDT second counter extern volatile uint16 seconds; // # of seconds extern volatile uint16 switches; // debounced switch values uint8 life[NUM_ROWS][NUM_COLS/8]; // 80 x 80 life grid uint8 life_pr[NUM_COLS/8]; // previous row uint8 life_cr[NUM_COLS/8]; // current row uint8 life_nr[NUM_COLS/8]; // next row enum { BIRTH = 1, DEATH = 3 }; Bit Life grid array Previous, current, and next row BYU CS 224 The Game of Life

life.c Initialize RBX430 and LCD Setup switches and Watchdog as timer // main ---------------------------------------------------------------- void main(void) { RBX430_init(_16MHZ); // init board ERROR2(lcd_init()); // init LCD //lcd_volume(360); // increase LCD brightness watchdog_init(); // init watchdog port1_init(); // init P1.0-3 switches __bis_SR_register(GIE); // enable interrupts while (1) // new pattern seed uint16 generation; // generation counter uint16 row, col; uint16 neighbors = BIRTH; // cell neighbors // setup beginning life generation init_life(BIRD); // load a new life seed into LCD WDT_Sec_Cnt = WDT_1SEC_CNT; // reset WD 1 second counter seconds = 0; // clear second counter switches = 0; // clear switch variable generation = 0; // start generation counter Setup switches and Watchdog as timer Splash screen Wait for switch BYU CS 224 The Game of Life

life.c For each row For each column Real-time Stats while (1) // next generation { // for each life row (78 down to 1) for (row = NUM_ROWS-2; row; --row) // for each life column (78 down to 1) for (col = NUM_COLS-2; col; --col) if (neighbors == BIRTH) cell_birth(row, col); } else cell_death(row, col); lcd_wordImage(life_image, (HD_X_MAX - 126) / 2, 50, neighbors = (neighbors == BIRTH) ? DEATH : BIRTH); // display life generation and generations/second on LCD if (display_results(++generation)) break; } // end main() For each row For each column Real-time Stats BYU CS 224 The Game of Life

Life value, birth and death macros life.h Life value, birth and death macros #define NUM_ROWS 80 #define NUM_COLS 80 #define cell_value(life_row,col) (life_row[(col) >> 3] & (0x01 << ((col) & 0x07)) ? 1 : 0) #define cell_birth(row,col) { life[(row)][(col) >> 3] |= (0x01 << ((col) & 0x07)); \ lcd_point((col) << 1, (row) << 1, 7); } #define cell_death(row,col) { life[(row)][(col) >> 3] &= ~(0x01 << ((col) & 0x07)); \ lcd_point((col) << 1, (row) << 1, 6); } enum SEED { LIFE=0x01, BIRD=0x02, OBJECTS=0x04, YOURS=0x08, RANDOM }; enum { DEATH = 6, BIRTH }; void draw_rle_pattern(int row, int col, const uint8* object); void init_life(enum SEED seed); //******************************************************************************* // life rle patterns // still lifes extern const uint8 block[]; extern const uint8 beehive[]; extern const uint8 loaf[]; extern const uint8 boat[]; // oscillators extern const uint8 blinker[]; extern const uint8 toad[]; extern const uint8 beacon[]; extern const uint8 by_flop[]; extern const uint8 hexapole[]; extern const uint8 pulsar[]; ... Seed enums Life Patterns BYU CS 224 The Game of Life

3 dead cells, 1 live cell, and next row lifelib.c //************************************************************************* // includes #include "msp430x22x4.h" #include "RBX430-1.h" // still lifes const uint8 block[] = { "x = 2, y = 2, rule = B3/S23\n2o$2o!" }; const uint8 beehive[] = { "x = 3, y = 4, rule = B3/S23\nbo$obo$obo$bo!" }; const uint8 loaf[] = { "x = 4, y = 4, rule = B3/S23\nb2o$o2bo$obo$bo!" }; const uint8 boat[] = { "x = 3, y = 3, rule = B3/S23\n2o$obo$bo!" }; // oscillators const uint8 blinker[] = { "x = 3, y = 1, rule = B3/S23\n3o!" }; const uint8 toad[] = { "x = 4, y = 2, rule = B3/S23\nb3o$3o!" }; const uint8 beacon[] = { "x = 4, y = 4, rule = B3/S23\n2b2o$3bo$o$2o!" }; const uint8 by_flop[] = { "x = 6, y = 7, rule = B3/S23\n" "3bo$bobo$5bo$5o$5bo$bobo$3bo!" }; const uint8 hexapole[] = { "x = 9, y = 9, rule = B3/S23\n" "2o$obo2$2bobo2$4bobo2$6bobo$7b2o!" }; Size of pattern Upper left corner 3 dead cells, 1 live cell, and next row BYU CS 224 The Game of Life

lcd_point(col*2, row*2, 7); RBX430-1 LCD 160 x 160 x 5 pixels display row (0-79) col (0-79) uint8 life[80][10]; life[row][col/8] & 0x01 << (col%8) lcd_point(col*2, row*2, 7); BYU CS 224 The Game of Life

lcd_point(col*2, row*2, 7); RBX430-1 LCD 160 x 160 x 5 pixels display row (0-79) col (0-79) life[row][col/8] & 0x80 >> (col%8) lcd_point(col*2, row*2, 7); uint8 life[80][10]; BYU CS 224 The Game of Life

C Pre-processor C Pre-processor macros Simplify coding Make program more readable Helps avoid errors from repetition. #define MASK(bit) (0x80 >> (bit%8)) #define SET_CELL(byte,bit) byte |= MASK(bit); #define CLEAR_CELL(byte,bit) byte &= ~MASK(bit); #define TOGGLE_CELL(byte,bit) byte ^= MASK(bit); #define TEST_CELL(byte,bit) (byte & MASK(bit)); SET_CELL(life[row][col/8],col); CLEAR_CELL(life[row][col/8],col); TOGGLE_CELL(life[row][col/8],col); if (TEST_CELL(temp[col/8],col)) { ... }; BYU CS 224 The Game of Life

CELL BIRTH: Set cell bit in life array: life[(row)][(col) >> 3] |= (0x80 >> ((col) & 0x07)); CELL DEATH: Clear cell bit in life array: life[(row)][(col) >> 3] &= ~(0x80 >> ((col) & 0x07)); TEST CELL: Test cell bit in a specified single dimensioned row (alive or dead?): (life_row[(col) >> 3] & (0x80 >> ((col) & 0x07)) ? 1 : 0) 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 0000 0000 0000 0000 0000 0000 Life_row[0] Life_row[1] Life_row[2] 0100 0000 To test logical column 17, we need to find the physical bit corresponding to this value First, we find the byte in the row by dividing by 8 (col >> 3), this gives us 17/8=2 or Life_row[2] Next we create a bit mask to select the correct bit in the physical byte. col&0x7 is the same as col%8 or 17&0x7 = 0x0001 0001 & 0x0000 0111 = 1 0x80 >> 1 = 1000 0000 >> 1 = 0100 0000, which is the mask we need to select bit 17. For cell birth we use |= to turn this bit on. For cell death we use &= with the ones complement of this value to turn the bit off. ~(0100 0000) = 1011 1111 BYU CS 224 The Game of Life

In order to encode draw_rle_pattern(40,60,beacon) Given Life Array 80 40,63 11 1 0001 0011 40,60 40 40 80 In order to encode draw_rle_pattern(40,60,beacon) Given beacon[] = { "x = 4, y = 4, rule = B3/S23\n2o$o$3bo$2b2o!" }; First go to location 40,60 and add (y-1)=3 to the y value for 40,63 Then add the 4 rows of entries specified in the beacon description. The last row should start at 40,60 BYU CS 224 The Game of Life