Skip to content
Permalink
master
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
 
 
Cannot retrieve contributors at this time
// GPars - Groovy Parallel Systems
//
// Copyright © 2008-2013 The original author or authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package groovyx.gpars.samples.dataflow
import groovyx.gpars.dataflow.DataflowBroadcast
import groovyx.gpars.dataflow.DataflowReadChannel
import groovyx.gpars.dataflow.operator.DataflowOperator
import groovyx.gpars.group.NonDaemonPGroup
/**
* A concurrent implementation of the Game of Life using dataflow operators
* Inspired by https://github.com/mcmenaminadrian/Groovy-Life/blob/master/Life.groovy
*
* Each cell of the world is represented by a DataflowBroadcast instance, which emits the current value to all subscribed listeners.
* The printGrid() method is one of these listeners, so it can show the current state of the world to the user.
* To transform an old world into a new one, a dataflow operator exists for each cell, monitoring the cell as well as the surroundings of the cell
* and calculating the new value for the cell, whenever all the monitored cells emit new values. The calculated value is written
* back into the cell and so it can be observed by all interested operators in the next iteration of the system.
*
* The system iterates spontaneously without any external clock or synchronization. The inherent quality of operators to wait for all input values
* before proceeding guarantees that the system evolves in phases/generations.
*
* @author Vaclav Pech
*/
class LifeGameWithDataflowOperators {
/* Controls the game */
final def initialGrid = [] //initial values entered by the user
final List<List<DataflowBroadcast>> channelGrid = [] //the sequence of life values (0 or 1) for each cell
final List<List<DataflowReadChannel>> printingGrid = []
//the sequence of life values (0 or 1) for each cell to read by the print method
final List<List<DataflowOperator>> operatorGrid = []
//the grid of operators calculating values for their respective cells
final DataflowBroadcast heartbeats = new DataflowBroadcast() //gives pace to the calculation
def gridWidth
def gridHeight
final def group = new NonDaemonPGroup() //the thread pool to use by all the operators
void run() {
welcome()
printInitialGrid()
setupIndividuals()
evolve(0)
}
void welcome() {
println "Welcome to the Game of Life"
println "Based on John Conway's famous article for the Scientific American."
println "To begin you must specify a grid size. Height and width are limited"
println "to 40 x 40 max."
println()
println "Please specify the width and height of your grid in the format"
println "width,height"
getGridDimensions()
setupCells()
setupOperators()
}
private def setupOperators() {
(0..<gridHeight).each { rowIndex ->
def operatorRow = []
(0..<gridWidth).each { columnIndex ->
def inputChannels = [channelGrid[rowIndex][columnIndex].createReadChannel()]
[rowIndex - 1, rowIndex, rowIndex + 1].each { currentRowIndex ->
if (currentRowIndex in 0..<gridHeight) {
if (columnIndex > 0) inputChannels.add(channelGrid[currentRowIndex][columnIndex - 1].createReadChannel())
if (currentRowIndex != rowIndex) inputChannels.add(channelGrid[currentRowIndex][columnIndex].createReadChannel())
if (columnIndex < gridHeight - 1) inputChannels.add(channelGrid[currentRowIndex][columnIndex + 1].createReadChannel())
}
}
inputChannels.add(heartbeats.createReadChannel())
final Closure code = new LifeClosure(this, inputChannels.size)
operatorRow[columnIndex] = group.operator(inputs: inputChannels, outputs: [channelGrid[rowIndex][columnIndex]], code)
}
operatorGrid.add(operatorRow)
}
}
private def setupCells() {
(0..<gridHeight).each {
def initialRow = []
def valueRow = []
List<DataflowBroadcast> channelRow = []
(0..<gridWidth).each {
initialRow[it] = 0
channelRow[it] = new DataflowBroadcast()
valueRow[it] = channelRow[it].createReadChannel()
}
initialGrid.add(initialRow)
printingGrid.add(valueRow)
channelGrid.add(channelRow)
}
}
void setupIndividuals() {
println()
println "You now need to specify the cells in which the bacteria live."
println "Please enter in the format (x, y). Enter -1, -1 to end this phase."
getCellPlaces()
println "Game will now begin..."
}
void evolve(def generation) {
//initialize the dataflow network by copying the values to the cells (channels)
(0..<gridHeight).each { rowIndex ->
(0..<gridWidth).each { columnIndex ->
channelGrid[rowIndex][columnIndex] << initialGrid[rowIndex][columnIndex]
}
}
while (true) {
heartbeats << 'go!'
//This message is sent to all operators to trigger the calculation of the next generation
println "Generation $generation"
printGrid()
++generation
sleep 500
}
}
void getCellPlaces() {
String gridPoint = new Scanner(System.in).nextLine()
def comma = ","
def gridBits = gridPoint.tokenize(comma)
if (gridBits.isEmpty()) {
errorXY(gridPoint + " does not evaluate")
getCellPlaces()
return
}
if (gridBits[1] == null) {
errorXY(gridPoint + " badly formed")
getCellPlaces()
return
}
if (!gridBits[0].isInteger() || !gridBits[1].isInteger()) {
errorXY(gridPoint + " not numerical")
getCellPlaces()
return
}
def gridW = gridBits[0].toInteger()
def gridH = gridBits[1].toInteger()
if ((gridW == -1) && (gridH == -1))
return
if (!(gridW in 1..gridWidth) || !(gridH in 1..gridHeight)) {
errorXY(gridPoint + " out of range")
getCellPlaces()
return
}
initialGrid[gridH - 1][gridW - 1] = 1;
printInitialGrid()
println "Next place x,y... or -1,-1 to finish"
getCellPlaces()
return
}
void getGridDimensions() {
String gridSize = new Scanner(System.in).nextLine()
def comma = ","
def gridBits = gridSize.tokenize(comma)
if (gridBits.isEmpty()) {
errorXY(gridSize + " does not evaluate")
getGridDimensions()
return
}
if (gridBits[1] == null) {
errorXY(gridSize + " badly formed")
getGridDimensions()
return
}
if (!gridBits[0].isInteger() || !gridBits[1].isInteger()) {
errorXY(gridSize + " not numerical")
getGridDimensions()
return
}
gridWidth = gridBits[0].toInteger()
gridHeight = gridBits[1].toInteger()
if (!(gridWidth in 1..40) || !(gridHeight in 1..40)) {
errorXY(gridSize + "out of range")
getGridDimensions()
}
}
void errorXY(String strMsg) {
println strMsg
}
void printInitialGrid() {
(0..gridWidth + 1).each {
print "*"
}
println()
(0..<gridHeight).each {
def line = it
print "|"
(0..<gridWidth).each {
if (initialGrid[line][it] == 0)
print " "
else
print "X"
}
print "|"
println()
}
(0..gridWidth + 1).each {
print "*"
}
println()
}
void printGrid() {
(0..gridWidth + 1).each {
print "*"
}
println()
(0..<gridHeight).each {
def line = it
print "|"
(0..<gridWidth).each {
if (printingGrid[line][it].val == 0)
print " "
else
print "X"
}
print "|"
println()
}
(0..gridWidth + 1).each {
print "*"
}
println()
}
}
def lifer = new LifeGameWithDataflowOperators()
lifer.run()
class LifeClosure extends Closure {
final int numberOfArguments
LifeClosure(final Object owner, final int numberOfArguments) {
super(owner)
this.numberOfArguments = numberOfArguments
}
@Override
int getMaximumNumberOfParameters() {
return numberOfArguments
}
@Override
Object call(Object[] args) {
def result = args[0]
def mates = args[1..-2].findAll { it > 0 }.size()
if (mates > 3) result = 0
else if (mates == 3) result = 1
else if (result == 1 && mates == 2)
result = 1
else
result = 0
bindOutput result
}
}