Practical session 8
Assignment 3
Game of life
• A zero-player game.
• Simulates Evolution, of an
infinite two-dimensional
matrix’s cells.
• Each cell can be alive or
dead.
• A cell’s state in each
iteration (generation) is set
with accordance to its
former state and its
neighbors’ states.
Our version
• We’ll simulate a simplified, one-dimensional
(finite) array.
• Each cell is given an initial state on program
startup
• At each “generation”, a cell will determine its
next state according to its former state and its
neighbors’ states, using a given transition
function
Implementation
• Using the co-routine mechanism, we’ll write a
small simulator for the game.
• Running co-routines:
– n cell instances
– A printer
– A scheduler
A Cell
• Can be alive(1) or dead(0)
• Executes a simple infinite loop:
1. Calculate next state using current state (of “me”
and my left and right neighbors).
2. Update new state
• After each of these two stages, the cell coroutine must resume the scheduler.
In other words, it loops (for ever) over:
(1) resume  (2) resume
A Cell
• Just to be perfectly clear:
– celli‘s left neighbor is celli-1 .
– celli‘s right neighbor is celli+1 .
– The Array “wraps around” 
calculations are %WorldSize
A Cell
• How do we determine a cell’s next step?
– One of the program’s parameters is a transition
function:
• A sequence of hexadecimal digits (a nibble of bits) such
as “B1E3”.
• Each digit represents a transition.
B  1011
new state
Left neighbor’s
state
“My” state
Right neighbor’s
state
Transition example
• Given this transition function:
B=1011
1=0001
E=1110
3=0011
• Say a cell is dead, its left neighbor is dead and its right
neighbor is alive, then “3” can be applied, and thus
the next state is alive (1).
• When no transition can be applied, no transition is
done:
• Say a cell is alive, its left neighbor is alive and its right
neighbor is dead  no transition fits the case (we’d
need either “C” or “D”), and thus no change is made.
The printer
• Simply prints the entire “world” (the array),
whenever it gets “time”.
The scheduler
• You are to implement a simple round-robin
scheduler.
• void scheduler(int cycles)
– Iterate cycles times over all cells
– After each K resumes of cell co-routines, resume the
printer.
– At the end of all cycles, resume the printer once
more, and then terminate the process.
Program’s flow
• Invoked using:
>ass3 <states> <t> <K> <transition_func>
• where:
– <states> - A series of “0” and “1”. describes the
initial state, as well as the amount of cells
– <t> - Amount of scheduler cycles through each cell
– <K> - Printing frequency
– <transition_func> - A series of hexadecimal digits
Program’s flow
• When invoked, and using the co-routines
mechanism from class, your application will:
– Set up: a state array, WorldSize , K
– Initiate all co-routines:
• Each cell needs to get a parameter i with its index.
• The scheduler needs to get cycles (t) as a parameter.
• Initiate the printer
– Initiate an array CORS of pointers to:
cell1, cell2, …, cellWorldSize, scheduler, printer.
– Transfer control to scheduler
Technicalities
• You are to submit a single .zip file, using the
same directory structure as in previous
assignments.
• src folder will include:
– ass3.s (with most of the code)
– printer.s (printer function code)
– scheduler.s (scheduler function code)
Example
• Let’s run an example using your simple
scheduler:
>ass3 01010010 5 7 029B46DF
• First 8 “time slices”
produce readings
and state
computations:
Cell
left
curr next
0
0
0
1
2
0
1
0
1
0
0
2
1
0
1
4
B
3
0
1
0
4
0
4
1
0
0
9
1
5
0
0
1
2
0
6
0
1
0
4
0
7
1
0
0
9
1
New
1
Example
01010010
00101010
00101001
10011001
10010100
10010100
;after 7 “resumes”. No updates.
;after 14; 6 updates made.
;(21): no second updates yet
;(28): 4 second cycle updates
;(35): 2nd cycle updated
;(40): last print (done cycling)