From: bdemsky Date: Wed, 8 Apr 2009 01:24:42 +0000 (+0000) Subject: program to test debug our system on X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=9b12435bc54aa6f54215de44494d06128e76b78c;p=IRC.git program to test debug our system on --- diff --git a/Robust/src/Benchmarks/SingleTM/RainForest/AStarPathFinder.java b/Robust/src/Benchmarks/SingleTM/RainForest/AStarPathFinder.java new file mode 100644 index 00000000..0fffda1a --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/RainForest/AStarPathFinder.java @@ -0,0 +1,332 @@ +/** + ** A path finder implementation that uses the AStar heuristic based algorithm + ** to determine a path. + ** New changes for our purposes + **/ +public class AStarPathFinder { + + /** The set of nodes that have been searched through */ + private Vector closed; + + /** The set of nodes that we do not yet consider fully searched */ + private SortedList open; + + /** The map being searched */ + GameMap[][] land; + + /** The maximum depth of search we're willing to accept before giving up */ + private int maxSearchDistance; + + /** The complete set of nodes across the map */ + private Node[][] nodes; + + /** True if we allow diagonal movement */ + private boolean allowDiagMovement; + + /** Map size where we are searching */ + private int rows, columns; + + /** + ** Create a path finder with the default heuristic - closest to target. + ** + ** @param land The map to be searched + ** @param maxSearchDistance The maximum depth we'll search before giving up + ** @param allowDiagMovement True if the search should try diagonal movement + **/ + public AStarPathFinder(GameMap[][] land, int maxSearchDistance, boolean allowDiagMovement, int rows, int columns) { + this.land = land; + this.maxSearchDistance = maxSearchDistance; + this.allowDiagMovement = allowDiagMovement; + closed = new Vector(); + open = new SortedList(); + + nodes = new Node[rows][columns]; + for (int x=0;x PLANTER + if(land[tx][ty].hasTree() || land[tx][ty].hasRock()) { + return null; + } + } else { //LUMBERJACK + if((!land[tx][ty].hasTree()) || land[tx][ty].hasRock()) { + return null; + } + } + + // initial state for A*. The closed group is empty. Only the starting + // tile is in the open list + nodes[sx][sy].cost = 0; + nodes[sx][sy].depth = 0; + closed.clear(); + open.clear(); + open.add(nodes[sx][sy]); + + nodes[tx][ty].parent = null; + + // while we haven't exceeded our max search depth + int maxDepth = 0; + while ((maxDepth < maxSearchDistance) && (open.size() != 0)) { + // pull out the first node in our open list, this is determined to + // be the most likely to be the next step based on our heuristic + + Node current = getFirstInOpen(); + + if (current == nodes[tx][ty]) { + break; + } + + removeFromOpen(current); + addToClosed(current); + + // search through all the neighbours of the current node evaluating + // them as next steps + + for (int x=-1;x<2;x++) { + for (int y=-1;y<2;y++) { + // not a neighbour, its the current tile + + if ((x == 0) && (y == 0)) { + continue; + } + + // if we're not allowing diagonal movement then only + // one of x or y can be set + + if (!allowDiagMovement) { + if ((x != 0) && (y != 0)) { + continue; + } + } + + // determine the location of the neighbour and evaluate it + + int xp = x + current.x; + int yp = y + current.y; + + if (isValidLocation(gamer,sx,sy,xp,yp)) { + // the cost to get to this node is cost the current plus the movement + // cost to reach this node. Note that the heursitic value is only used + // in the sorted open list + + int nextStepCost = current.cost + getMovementCost(current.x, current.y, xp, yp); + Node neighbour = nodes[xp][yp]; + + // if the new cost we've determined for this node is lower than + // it has been previously makes sure the node has + // determined that there might have been a better path to get to + // this node so it needs to be re-evaluated + + if (nextStepCost < neighbour.cost) { + if (inOpenList(neighbour)) { + removeFromOpen(neighbour); + } + if (inClosedList(neighbour)) { + removeFromClosed(neighbour); + } + } + + // if the node hasn't already been processed and discarded then + // reset it's cost to our current cost and add it as a next possible + // step (i.e. to the open list) + if (!inOpenList(neighbour) && !(inClosedList(neighbour))) { + neighbour.cost = nextStepCost; + neighbour.heuristic = getHeuristicCost(xp, yp, tx, ty); + maxDepth = Math.max(maxDepth, neighbour.setParent(current)); + addToOpen(neighbour); + } + } + } + } + } + + // since we'e've run out of search + // there was no path. Just return null + if (nodes[tx][ty].parent == null) { + return null; + } + + // At this point we've definitely found a path so we can uses the parent + // references of the nodes to find out way from the target location back + // to the start recording the nodes on the way. + + Path path = new Path(); + Node target = nodes[tx][ty]; + while (target != nodes[sx][sy]) { + path.prependStep(target.x, target.y); + target = target.parent; + } + + // thats it, we have our path + return path; + } + + /** + ** Check if a given location is valid for the supplied gamer + ** + ** @param gamer The Player moving in the map + ** @param sx The starting x coordinate + ** @param sy The starting y coordinate + ** @param xp The x coordinate of the location to check + ** @param yp The y coordinate of the location to check + ** @return True if the location is valid for the given gamer + **/ + + + public boolean isValidLocation(Player gamer, int sx, int sy, int xp, int yp) { + boolean invalid = (xp <= 0) || (yp <= 0) || (xp >= rows-1) || (yp >= columns-1); + + if ((!invalid) && ((sx != xp) || (sy != yp))) { + if(gamer.kind() == 1) { //1=> PLANTER + if (land[xp][yp].hasTree() || land[xp][yp].hasRock()) { + invalid = true; + } + } else { //LUMBERJACK + if (land[xp][yp].hasRock()) { + invalid = true; + } + } + } + return !invalid; + } + + /** + ** Get the first element from the open list. This is the next + ** one to be searched. + ** + ** @return The first element in the open list + **/ + protected Node getFirstInOpen() { + Node n = (Node) open.first(); + return n; + } + + /** + ** Remove a node from the open list + ** + ** @param node The node to remove from the open list + **/ + protected void removeFromOpen(Node node) { + open.remove(node); + } + + /** + ** Add a node to the closed list + ** + ** @param node The node to add to the closed list + **/ + protected void addToClosed(Node node) { + closed.addElement(node); + } + + /** + ** Remove a node from the closed list + ** + ** @param node The node to remove from the closed list + **/ + protected void removeFromClosed(Node node) { + closed.remove(node); + } + + /** + ** Check if the node supplied is in the closed list + ** + ** @param node The node to search for + ** @return True if the node specified is in the closed list + **/ + protected boolean inClosedList(Node node) { + return closed.contains(node); + } + + /** + ** Check if a node is in the open list + ** + ** @param node The node to check for + ** @return True if the node given is in the open list + **/ + protected boolean inOpenList(Node node) { + return open.contains(node); + } + + /** + ** Add a node to the open list + ** + ** @param node The node to be added to the open list + **/ + protected void addToOpen(Node node) { + open.add(node); + } + + /** + ** Get the cost to move through a given location + ** + ** @param x The x coordinate of the tile whose cost is being determined + ** @param y The y coordiante of the tile whose cost is being determined + ** @param xp The x coordinate of the neighbor target location + ** @param yp The y coordinate of the neighbor target location + ** @return The cost of movement through the given tile + **/ + public int getMovementCost(int x, int y, int xp, int yp) { + if (Math.abs(xp - x) == 1 && Math.abs(yp - y) == 1) { + return 14; + } + return 10; + } + + /** + * + * Get the cost of moving through the given tile. This can be used to + ** make certain areas more desirable. + ** + ** @param xp The x coordinate of the tile we're moving from + ** @param yp The y coordinate of the tile we're moving from + ** @param tx The x coordinate of the tile we're moving to + ** @param ty The y coordinate of the tile we're moving to + ** @return The relative cost of moving across the given tile + **/ + public int getHeuristicCost(int xp, int yp, int tx, int ty) { + int heur = (Math.abs(tx - xp) + Math.abs(ty - yp)) * 10; + return heur; + } + + /** + * Used only for debugging by printing the list element's + * x and y coordinates + **/ + + public void debugClosedList() { + for(int i=0; i maxage) { + land[i][j].tree = null; + } else { + land[i][j].tree.incrementage(); + } + countTrees++; + } + } + } + /* Debugging-> System.println("Tree count= "+countTrees); */ + } + + public void run() { + int n; + ServerSocket ss=new ServerSocket(2000); + atomic { + n=numthreads; + done=true; + } + Socket ar[]=new Socket[n]; + for(int i=0; i of) { + return 1; + } else { + return 0; + } + } + + /** + ** @return The cost of the heuristic + **/ + public int getHeuristic() { + return heuristic; + } + + + /** + ** @return The actual cost of traversal + **/ + public int getCost() { + return cost; + } + + /** + ** Only for Debugging by printing contents of Node + **/ + public void debugNode() { + System.println("x= "+ x + " y= "+ y + " cost= " + cost + " heuristic= "+ heuristic + " depth= " + depth); + } + + public int getX() { + return x; + } + + public int getY() { + return y; + } +} + +/** + ** A simple sorted list + ** + **/ +class SortedList { + /** The list of elements */ + private Vector list; + + public SortedList() { + list = new Vector(); + } + /** + ** Retrieve the first element from the list + ** + ** @return The first element from the list + **/ + public Object first() { + Object o = list.elementAt(0); + return o; + } + + /** + ** Empty the list + **/ + public void clear() { + list.clear(); + } + + /** + **Add an element to the list - causes sorting + ** + ** @param o The element to add + **/ + public void add(Object o) { + list.addElement(o); + Node tmp = (Node) o; + int min = tmp.heuristic + tmp.cost; + int i; + int index = 0; + /* Move the Node with minimum cost to the first position */ + for(i = 0; i < list.size(); i++) { + if(min > totalCost(list.elementAt(i))) { + min = totalCost(list.elementAt(i)); + index = i; + } + } + + if(index < 0 || index >=list.size()) { + System.printString("Illegal SortedList.add\n"); + System.exit(-1); + return; + } + + Object temp = list.elementAt(0); + list.setElementAt(list.elementAt(index),0); + list.setElementAt(temp, index); + } + + /** + **@return fixed cost + heuristic cost + **/ + public int totalCost(Object o) { + Node tmp = (Node) o; + int cost = tmp.getHeuristic() + tmp.getCost(); + return cost; + } + + + /** + ** Remove an element from the list + ** + ** @param o The element to remove + **/ + public void remove(Object o) { + list.remove(o); + } + + /** + ** Get the number of elements in the list + ** + ** @return The number of element in the list + **/ + public int size() { + return list.size(); + } + + /** + ** Check if an element is in the list + ** + ** @param o The element to search for + ** @return True if the element is in the list + **/ + public boolean contains(Object o) { + return list.contains(o); + } + + /** + ** Only for Debugging by printing contents of openlist + **/ + public void debugOpenList() { + for(int i=0; i= 0 and < getLength(); + ** @return The step information, the position on the map. + **/ + public Step getStep(int index) { + return (Step) steps.elementAt(index); + } + + /** + ** Get the x coordinate for the step at the given index + ** + ** @param index The index of the step whose x coordinate should be retrieved + ** @return The x coordinate at the step + **/ + public int getX(int index) { + return getStep(index).x; + } + + /** + ** Get the y coordinate for the step at the given index + ** + ** @param index The index of the step whose y coordinate should be retrieved + ** @return The y coordinate at the step + **/ + public int getY(int index) { + return getStep(index).y; + } + + /** + ** Append a step to the path. + ** + ** @param x The x coordinate of the new step + ** @param y The y coordinate of the new step + **/ + public void appendStep(int x, int y) { + steps.addElement(new Step(x,y)); + } + + /** + ** Prepend a step to the path. + ** + ** @param x The x coordinate of the new step + ** @param y The y coordinate of the new step + **/ + public void prependStep(int x, int y) { + steps.insertElementAt(new Step(x, y), 0); + } + + /** + ** Check if this path contains the given step + ** + ** @param x The x coordinate of the step to check for + ** @param y The y coordinate of the step to check for + ** @return True if the path contains the given step + **/ + public boolean contains(int x, int y) { + return steps.contains(new Step(x,y)); + } + +} + +/** + ** A single step within the path + **/ +class Step { + /** The x coordinate at the given step */ + private int x; + /** The y coordinate at the given step */ + private int y; + + /** + ** Create a new step + ** + ** @param x The x coordinate of the new step + ** @param y The y coordinate of the new step + **/ + public Step(int x, int y) { + this.x = x; + this.y = y; + } + + /** + ** Get the x coordinate of the new step + ** + ** @return The x coodindate of the new step + **/ + public int getX() { + return x; + } + + /** + ** Get the y coordinate of the new step + ** + ** @return The y coodindate of the new step + **/ + public int getY() { + return y; + } + + /** + ** Same as Object#hashCode() + **/ + public int hashCode() { + return x*y; + } + + /** + ** Same as Object#equals(Object) + ** + **/ + public boolean equals(Object other) { + if (other instanceof Step) { + Step o = (Step) other; + if((o.x == x) && (o.y == y)) { + return true; + } + } + return false; + } +} diff --git a/Robust/src/Benchmarks/SingleTM/RainForest/Player.java b/Robust/src/Benchmarks/SingleTM/RainForest/Player.java new file mode 100644 index 00000000..68246e7d --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/RainForest/Player.java @@ -0,0 +1,247 @@ +/** + ** An object representing the entity in the game that + ** is going to move along the path. This allows us to pass around entity/state + ** information to determine whether a particular tile is blocked, or how much + ** cost to apply on a particular tile. + ** + ** a) Saves the current X and Y coordinates for a Player + ** b) Saves the destination goalX and goalY + ** c) Determines the boundary using high/low X and Y coordinates for + ** the current position + ** d) Keeps track of the STATE of the player + **/ +public class Player { + private int type; + private int x; + private int y; + private int lowx, highx; + private int lowy, highy; + private int state; + private int goalx, goaly; + private int rows, cols; + private Random rand; + + public Player(int type, int x, int y) { + this.type = type; + this.x = x; + this.y = y; + } + + public Player(int type, int x, int y, int rows, int cols, int bounds) { + this.type = type; + this.x = x; + this.y = y; + this.rows = rows; + this.cols = cols; + lowx = x - bounds; + highx = x + bounds; + lowy = y - bounds; + highy = y + bounds; + // define new boundaries + if (lowx <= 0) + lowx = 1; + if (lowy <= 0) + lowy = 1; + if (highx >= rows) + highx = rows-2; + if (highy >= cols) + highy = cols-2; + rand = new Random(30); //seed to generate random numbers + } + + public void reset(GameMap[][] land, int row, int col, int bounds) { + //Teleport to new location + if(type == 1) { //PLANTER + int tempx = (rand.nextInt(Math.abs(row - 2) + 1)) + 1; + int tempy = (rand.nextInt(Math.abs(col - 2) + 1)) + 1; + if(((tempx - x) > bounds) || ((tempy - y) > bounds)) { + // Quickly determine the boundaries for given row and column + int templowx = tempx - bounds; + int temphighx = tempx + bounds; + int templowy = tempy - bounds; + int temphighy = tempy + bounds; + // define new boundaries + if (templowx <= 0) + templowx = 1; + if (templowy <= 0) + templowy = 1; + if (temphighx >= row-1) + temphighx = row-2; + if (temphighy >= col -1) + temphighy = col-2; + + // + // Add Manual Prefetch + // + + } + x = tempx; + y = tempy; + goalx = -1; + goaly = -1; + setBoundary(bounds, row, col); + } + + if(type == 0) { //LUMBERJACK + int trycount = 5; //try a few more times before teleporting + int i = 0; + while(i MOVING state + return; + } + i++; + } + int tempx = (rand.nextInt(Math.abs(row - 2) + 1)) + 1; + int tempy = (rand.nextInt(Math.abs(col - 2) + 1)) + 1; + /* + if(((tempx - x) > bounds) || ((tempy - y) > bounds)) { + // Quickly determine the boundaries for given row and column + int templowx = tempx - bounds; + int temphighx = tempx + bounds; + int templowy = tempy - bounds; + int temphighy = tempy + bounds; + // define new boundaries + if (templowx <= 0) + templowx = 1; + if (templowy <= 0) + templowy = 1; + if (temphighx >= row-1) + temphighx = row-2; + if (temphighy >= col -1) + temphighy = col-2; + + // + // Add Manual Prefetch + // + + } + */ + x = tempx; + y = tempy; + goalx = -1; + goaly = -1; + setBoundary(bounds, row, col); + } + } + + public void setBoundary(int bounds, int rows, int cols) { + lowx = x - bounds; + highx = x + bounds; + lowy = y - bounds; + highy = y + bounds; + // define new boundaries + if (lowx <= 0) + lowx = 1; + if (lowy <= 0) + lowy = 1; + if (highx >= rows-1) + highx = rows-2; + if (highy >= cols-1) + highy = cols-2; + return; + } + + /** + ** @return if Player is lumberjack or a planter + **/ + public int kind() { + return type; + } + + /** + ** Sets the X and Y coordinate of the Player + **/ + public void setPosition(int x, int y) { + this.x = x; + this.y = y; + } + + public void setNewPosition(int x, int y, int row, int col, int bounds) { + setPosition(x, y); + setBoundary(bounds, row, col); + goalx = -1; + goaly = -1; + } + + public int getX() { + return x; + } + + public int getY() { + return y; + } + + /** Sets state of the Player **/ + + public void setState(int state) { + this.state = state; + return; + } + + public int getState() { + return this.state; + } + + /** Randomly finds a goal in a given boundary for player + ** @return 0 on success and -1 when you cannot find any new goal + **/ + public int findGoal(GameMap[][] land) { + /* Try setting the goal for try count times + * if not possible, then select a completely new goal + */ + int trycount = (highx - lowx) + (highy - lowy); + int i; + + Random rand = new Random(0); + for (i = 0; i < trycount; i++) { + int row = (rand.nextInt(Math.abs(highx - lowx)) + 1) + lowx; + int col = (rand.nextInt(Math.abs(highy - lowy)) + 1) + lowy; + if (type == 1 && (land[row][col].hasTree() == false) && (land[row][col].hasRock() == false)) { + goalx = row; + goaly = col; + return 0; + } + if (type == 0 && (land[row][col].hasTree() == true) && (land[row][col].hasRock() == false)) { + goalx = row; + goaly = col; + return 0; + } + } + return -1; + } + + public void setGoal(int x, int y) { + goalx = x; + goaly = y; + } + + public int getGoalX() { + return goalx; + } + + public int getGoalY() { + return goaly; + } + + /** + ** Only for debugging + **/ + public debugPlayer() { + System.println("State= "+ state+ " Curr X= "+ x + " Curr Y= " + y + " Goal X= "+ goalx + " Goal Y= "+ goaly + " Type = " + type); + } + + /** + ** @return true if reached the goal else return false + **/ + public boolean atDest() { + if (x == goalx && y == goaly) { + return true; + } + return false; + } +} diff --git a/Robust/src/Benchmarks/SingleTM/RainForest/README.txt b/Robust/src/Benchmarks/SingleTM/RainForest/README.txt new file mode 100644 index 00000000..370b3219 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/RainForest/README.txt @@ -0,0 +1,38 @@ +Choosing where to place call to manual prefetching +=================================================== +Since do One move a s per the boundaries of the player + +Choice 0 +======== +1. Prefetch the entire land object + +Choice A: +========= +1. prefetch the entire block around player's current position in the beginning +2. In every round keep prefetching the block around the player's current position + and prefetching the block around the players's goal position when goal is set +3. Do not prefetch if goal is reset to (x,y) (-1,-1) + +Choice B: +========= +1. prefetch the entire block around player's current position in the beginning +2. In every round prefetching the block around the players's goal position + whenever a goal is set and if goal's (tx, ty) distance from source is more + than the boundary BLOCK i.e if(tx - currx > BLOCK || ty - curry > BLOCK) + then prefetch + +Choice C: +========= +1. prefetch the entire block around player's current position in the beginning +2. In every round check if goal is reset => no prefetching + In every round if player's curr position is reset and its distance is + greater than old(x,y) position => prefetch area around new position + In every round if player's goal distance is greater than source then prefetch + the area around new goal position + + + +TODO +==== +1. Find the trans commit and trans aborts per machine (write a script) +2. Remember that the execution is not deterministic diff --git a/Robust/src/Benchmarks/SingleTM/RainForest/RainForest.java b/Robust/src/Benchmarks/SingleTM/RainForest/RainForest.java new file mode 100644 index 00000000..3c2ce264 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/RainForest/RainForest.java @@ -0,0 +1,356 @@ +#define ROW 100 /* columns in the map */ +#define COLUMN 100 /* rows of in the map */ +#define ROUNDS 256 /* Number of moves by each player */ +#define PLAYERS 20 /* Number of Players when num Players != num of client machines */ +#define RATI0 0.5 /* Number of lumberjacks to number of planters */ +#define BLOCK 3 /* Area around the gamer to consider */ +#define TREE_ZONE 0.4 /* Max percentage of trees in a zone */ +#define AGEUPDATETHRESHOLD 16 /* How frequently/how many rounds to increment age of tree */ +#define MAXAGE 100 /* Max age of a tree */ + + +#define LUMBERJACK 0 /* If lumberjack */ +#define PLANTER 1 /* If a tree planter */ + +#define INIT 0 /* Initial state */ +#define MOVING 1 /* When moving along the map */ + +public class RainForest extends Thread { + /** + * The grid where player is playing + **/ + GameMap[][] land; + + /** + ** The shared BarrierServer object updated when trees increment age + ** only updated by one thread running server + **/ + BarrierServer barrserver; + + /** + * The thread id involved + **/ + int threadid; + + /** + * The total number of threads + **/ + int numThreads; + + + public RainForest() { + + } + + public RainForest(GameMap[][] land, BarrierServer barrserver, int threadid, int numThreads) { + this.land = land; + this.threadid = threadid; + this.barrserver = barrserver; + this.numThreads = numThreads; + } + + public void run() { + //Barrier for synchronizing moves + Barrier barr; + int id; + atomic { + id = threadid; + } + barr = new Barrier("127.0.0.1"); + + Random rand = new Random(id); + // Generate random numbers between 1 and row index/column index + int maxValue = ROW - 1; + int minValue = 1; + int row = (rand.nextInt(Math.abs(maxValue - minValue) + 1)) + minValue; + maxValue = COLUMN -1; + int col = (rand.nextInt(Math.abs(maxValue - minValue) + 1)) + minValue; + // + //Add Manual Prefetches for this.land[lowx][lowy] to this.land[highx][highy] + // + // Quickly determine the boundaries for given row and column + int lowx = row - BLOCK; + int highx = row + BLOCK; + int lowy = col - BLOCK; + int highy = col + BLOCK; + // define new boundaries + if (lowx <= 0) + lowx = 1; + if (lowy <= 0) + lowy = 1; + if (highx >= ROW-1) + highx = ROW-2; + if (highy >= COLUMN-1) + highy = COLUMN-2; + + + int person; + if((id&1) != 0) { //same as id%2 + person = LUMBERJACK; + } else { + person = PLANTER; + } + Player gamer = new Player(person, row, col, ROW, COLUMN, BLOCK); + + // + // Debug + // System.println("Player= "+ person+ " PosX= "+row+" PosY= "+col); + // + + //Do N rounds + //do one move per round and synchronise + short[] offsets1 = new short[6]; + for(int i = 0; i BLOCK) || ((gamer.getGoalY() - gamer.getY()) > BLOCK)) { + // Quickly determine the boundaries for given row and column + int lowx = gamer.goalx - BLOCK; + int highx = gamer.goalx + BLOCK; + int lowy = gamer.goaly - BLOCK; + int highy = gamer.goaly + BLOCK; + // define new boundaries + if (lowx <= 0) + lowx = 1; + if (lowy <= 0) + lowy = 1; + if (highx >= ROW-1) + highx = ROW-2; + if (highy >= COLUMN-1) + highy = COLUMN-2; + // + // Add Manual Prefetch for land[lowx][lowy] to land[highx][highy] + // + } + } + gamer.setState(MOVING); + } + + if (gamer.getState() == MOVING) { + Goal nextmove = new Goal(); + int maxSearchDistance = 10; + boolean allowDiagMovement = true; + /* Find shortest path using AStar algo from start to goal */ + AStarPathFinder apath = new AStarPathFinder(land, maxSearchDistance, allowDiagMovement, ROW, COLUMN); + Path newpath = apath.findPath(gamer); + + /* Reset state if there in no path from start to goal */ + if(newpath == null) { + // + // Debug + // System.println("Path from ("+currx+","+curry+") to ("+gamer.getGoalX()+","+gamer.getGoalY()+") is null"); + // + + gamer.reset(land, ROW, COLUMN, BLOCK); + gamer.setState(INIT); + return; + } + + nextmove.setXY(newpath.getX(0), newpath.getY(0)); + gamer.setPosition(nextmove.getX(), nextmove.getY()); + currx = gamer.getX(); + curry = gamer.getY(); + if (gamer.atDest()) { + if (gamer.kind() == LUMBERJACK) { + //If tree present, cut + if (land[currx][curry].hasTree()) { + land[currx][curry].cutTree(); + // + // Debug + // System.println("Cut tree"); + // + } + } else { // PLANTER + // If empty, plant tree + if (land[currx][curry].hasTree() == false) { + if(hasMoreTrees(land, currx, curry) == false) { + TreeType t = new TreeType(); + land[currx][curry].putTree(t); + // + // Debug + // System.println("Put tree"); + // + } + } + } + gamer.setNewPosition(currx, curry, ROW, COLUMN, BLOCK); + gamer.setState(INIT); + } else if(land[currx][curry].hasTree() && gamer.kind() == LUMBERJACK) { //Cut trees along the way + land[currx][curry].cutTree(); + // + // Debug + // System.println("Cut tree while moving"); + // + } + // Not at destination - do nothing + return; + } + } + + /** + ** Only for Debugging + **/ + public void printLand(GameMap[][] land, int row, int col) { + for (int i = 0; i < row; i++) { + for (int j = 0; j < col; j++) { + land[i][j].print(); + } + System.println(""); + } + } + + /** + * Parse the command line options. + **/ + public static void parseCmdLine(String args[], RainForest rf) { + int i = 0; + String arg; + while(i < args.length && args[i].startsWith("-")) { + arg = args[i++]; + //check options + if(arg.equals("-N")) { + if(i < args.length) { + rf.numThreads = new Integer(args[i++]).intValue(); + } + } else if(arg.equals("-h")) { + rf.usage(); + } + } + + if(rf.numThreads == 0) + rf.usage(); + } + + /** + * The usage routine which describes the program options. + **/ + public void usage() { + System.println("usage: ./RainForestN.bin master -N \n"); + System.printString(" -N the number of threads\n"); + System.printString(" -h help with usage\n"); + } + + /** + ** Check the number of trees in a given area + ** @return true if area covered more than the zone for trees + **/ + public boolean hasMoreTrees(GameMap[][] land, int x, int y) { + int lowx = x - BLOCK; + int highx = x + BLOCK; + int lowy = y - BLOCK; + int highy = y + BLOCK; + // define new boundaries + if (lowx <= 0) + lowx = 1; + if (lowy <= 0) + lowy = 1; + if (highx >= ROW-1) + highx = ROW-2; + if (highy >= COLUMN-1) + highy = COLUMN-2; + int treeCount = 0; + int areaCount = 0; + for(int i = lowx; i < highx; i++) { + for(int j = lowy; j < highy; j++) { + if(land[i][j].tree != null) + treeCount++; + areaCount++; + } + } + if(treeCount >= (TREE_ZONE * areaCount)) { + return true; + } + return false; + } +} diff --git a/Robust/src/Benchmarks/SingleTM/RainForest/RockType.java b/Robust/src/Benchmarks/SingleTM/RainForest/RockType.java new file mode 100644 index 00000000..75989c13 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/RainForest/RockType.java @@ -0,0 +1,8 @@ +/** + ** Rock and its properties + **/ +public class RockType { + + public RockType() { + } +} diff --git a/Robust/src/Benchmarks/SingleTM/RainForest/TreeType.java b/Robust/src/Benchmarks/SingleTM/RainForest/TreeType.java new file mode 100644 index 00000000..c13b981f --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/RainForest/TreeType.java @@ -0,0 +1,26 @@ +/** + ** Tree and its properties + **/ +public class TreeType { + private int age; + + public TreeType() { + age = 0; + } + + public int getage() { + return age; + } + + public void incrementage() { + age++; + } + + public void incrementTenYrs() { + age = age + 10; + } + + public void incrementFiveYrs() { + age = age + 5; + } +} diff --git a/Robust/src/Benchmarks/SingleTM/RainForest/extractLines b/Robust/src/Benchmarks/SingleTM/RainForest/extractLines new file mode 100755 index 00000000..aff1b586 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/RainForest/extractLines @@ -0,0 +1,3 @@ +#!/bin/sh +lines=$(grep -n "#" tmp1RainForest.java | cut -d: -f1 | sed '1q') +sed '/^#/d' tmp1RainForest.java > tmpRainForest.java diff --git a/Robust/src/Benchmarks/SingleTM/RainForest/makefile b/Robust/src/Benchmarks/SingleTM/RainForest/makefile new file mode 100644 index 00000000..c9ba9650 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/RainForest/makefile @@ -0,0 +1,24 @@ +MAINCLASS=RainForest +SRC=tmp${MAINCLASS}.java \ + Player.java \ + TreeType.java \ + GameMap.java \ + RockType.java \ + Barrier.java \ + Goal.java \ + Path.java \ + Node.java \ + AStarPathFinder.java + +FLAGS=-singleTM -nooptimize -mainclass ${MAINCLASS} -debug + +default: + cpp ${MAINCLASS}.java > tmp1${MAINCLASS}.java + ./extractLines + ../../../buildscript ${FLAGS} -o ${MAINCLASS} ${SRC} + +clean: + rm tmp1RainForest.java + rm tmpRainForest.java + rm -rf tmpbuilddirectory + rm *.bin