parallel algorithm (WIP)

Author: sebastianhaeni

src/main/java/ch/sebastianhaeni/pancake/Node.java

@@ -1,16 +1,25 @@
 package ch.sebastianhaeni.pancake;
 
+import java.io.Serializable;
 import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.List;
 
-class Node {
+class Node implements Serializable {
  private final int[] pancakes;
  private final int flipCount;
+ private final Node parent;
+ private final int flipPosition;
 
- Node(int[] pancakes, int flipCount) {
+ Node(int[] pancakes) {
+ this(pancakes, 0, null, -1);
+ }
+
+ Node(int[] pancakes, int flipCount, Node parent, int flipPosition) {
  this.pancakes = pancakes;
  this.flipCount = flipCount;
+ this.parent = parent;
+ this.flipPosition = flipPosition;
  }
 
  int getOptimisticDistanceToSolution() {
@@ -54,7 +63,10 @@ List<Node> nextNodes() {
  for (int i = 1; i < pancakes.length; i++) {
  int pancake = pancakes[i];
  if (pancake - current != 1) {
- list.add(flip(i + 1));
+ int flipPosition = i + 1;
+ if (flipPosition != this.flipPosition) {
+ list.add(flip(flipPosition));
+ }
  }
  current = pancake;
  }
@@ -72,10 +84,15 @@ Node flip(int flipPosition) {
 
  System.arraycopy(pancakes, flipPosition, flipped, flipPosition, pancakes.length - flipPosition);
 
- return new Node(flipped, getFlipCount() + 1);
+ return new Node(flipped, getFlipCount() + 1, this, flipPosition);
  }
 
  int[] getPancakes() {
  return pancakes;
  }
+
+ Node getParent() {
+ return parent;
+ }
+
 }

src/main/java/ch/sebastianhaeni/pancake/ParallelSolver.java

@@ -0,0 +1,222 @@
+package ch.sebastianhaeni.pancake;
+
+import mpi.MPI;
+import mpi.Request;
+import mpi.Status;
+
+import java.util.Arrays;
+import java.util.List;
+
+@SuppressWarnings("Duplicates")
+public class ParallelSolver {
+ private static final int MASTER_RANK = 0;
+ static int[] workers = new int[]{1, 2, 3, 4};
+
+ public static void main(String[] args) {
+ MPI.Init(args);
+ int rank = MPI.COMM_WORLD.Rank();
+
+ if (rank == MASTER_RANK) {
+ runMaster();
+ } else {
+ runSlave(rank);
+ }
+
+ MPI.Finalize();
+ }
+
+ private static void runSlave(int rank) {
+ Request finishCommand = MPI.COMM_WORLD.Irecv(new int[0], 0, 0, MPI.INT, MASTER_RANK, Tags.FINISH);
+
+ outer:
+ while (finishCommand.Test() == null) {
+ WorkPacket[] work = new WorkPacket[1];
+ Request workRequest = MPI.COMM_WORLD.Irecv(work, 0, 1, MPI.OBJECT, MASTER_RANK, Tags.WORK);
+
+ while (workRequest.Test() == null) {
+ if (finishCommand.Test() != null) {
+ break outer;
+ }
+ try {
+ Thread.sleep(50);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+// System.out.format("%d just got some work from master\n", rank);
+
+ Node node = work[0].getNode();
+ int bound = work[0].getBound();
+
+ SearchResult result = compute(node, bound);
+ sendResult(result);
+ }
+
+// System.out.format("%d is done for the day\n", rank);
+ }
+
+ private static SearchResult compute(Node node, int bound) {
+ int newBound = node.getFlipCount() + node.getOptimisticDistanceToSolution();
+
+ if (newBound > bound) {
+ return new SearchResult(newBound);
+ }
+
+ if (node.isSolution()) {
+ return new SearchResult(node);
+ }
+
+ int min = Integer.MAX_VALUE;
+ List<Node> successors = node.nextNodes();
+
+ for (Node successor : successors) {
+ SearchResult result = compute(successor, bound);
+
+ if (result.solutionNode != null) {
+ return result;
+ }
+
+ if (result.bound < min) {
+ min = result.bound;
+ }
+ }
+
+ return new SearchResult(min);
+ }
+
+ private static void sendResult(SearchResult searchResult) {
+ MPI.COMM_WORLD.Isend(new SearchResult[]{searchResult}, 0, 1, MPI.OBJECT, MASTER_RANK, Tags.RESULT);
+ }
+
+ private static void runMaster() {
+// Node root = new Node(new int[]{39,47,13,46,11,43,49,14,7,57,59,42,53,37,55,20,28,33,5,27,34,40,19,52,10,35,8,31,48,30,22,45,12,24,32,36,38,17,50,54,41,60,26,4,2,9,58,23,44,1,6,15,16,29,51,18,21,3,56,25});
+ Node root = new Node(new int[]{17, 2, 5, 13, 3, 7, 8, 4, 20, 11, 9, 18, 6, 14, 1, 10, 16, 15, 12, 19});
+// Node root = new Node(new int[]{5, 2, 7, 10, 13, 16, 14, 6, 8, 18, 15, 11, 1, 12, 3, 4, 9, 17});
+// Node root = new Node(new int[]{2, 1, 5, 4, 3});
+
+ System.out.format("Solving a pancake pile in parallel of height %d.\n", root.getPancakes().length);
+
+ long start = System.currentTimeMillis();
+ Node solution = solve(root);
+ long end = System.currentTimeMillis();
+
+ System.out.format("%dms passed\n", (end - start));
+
+ if (solution == null) {
+ System.out.println("No solution found");
+ return;
+ }
+ System.out.format("Found solution after %d flips.\n", solution.getFlipCount());
+
+ StringBuilder sb = new StringBuilder();
+ Node current = solution;
+ while (current.getParent() != null) {
+ sb.insert(0, Arrays.toString(current.getParent().getPancakes()) + "\n");
+ current = current.getParent();
+ }
+
+ System.out.println(sb.toString());
+ }
+
+ private static Node solve(Node root) {
+ if (root.isSolution()) {
+ return root;
+ }
+
+ Node solutionNode = null;
+ int bound = root.getOptimisticDistanceToSolution();
+ int maxBound = bound * 10;
+
+ while (solutionNode == null) {
+ SearchResult result = search(root, bound);
+
+ if (result.solutionNode != null) {
+ solutionNode = result.solutionNode;
+ }
+
+ if (result.bound >= maxBound) {
+ return null;
+ }
+
+ bound = result.bound;
+ }
+
+ for (int worker : workers) {
+ MPI.COMM_WORLD.Isend(new int[0], 0, 0, MPI.INT, worker, Tags.FINISH);
+ }
+
+ return solutionNode;
+ }
+
+ private static SearchResult search(Node node, int bound) {
+ int newBound = node.getFlipCount() + node.getOptimisticDistanceToSolution();
+
+ if (newBound > bound) {
+ return new SearchResult(newBound);
+ }
+
+ if (node.isSolution()) {
+ return new SearchResult(node);
+ }
+
+ int min = Integer.MAX_VALUE;
+ List<Node> successors = node.nextNodes();
+
+ int currentWorker = 0;
+ for (Node successor : successors) {
+ WorkPacket packet = new WorkPacket(successor, bound);
+ int destination = workers[currentWorker % workers.length];
+ MPI.COMM_WORLD.Isend(new WorkPacket[]{packet}, 0, 1, MPI.OBJECT, destination, Tags.WORK);
+ currentWorker++;
+ }
+
+ SearchResult[] result = new SearchResult[1];
+ Request[] requests = new Request[successors.size()];
+ currentWorker = 0;
+
+ for (int i = 0; i < successors.size(); i++) {
+ int destination = workers[currentWorker % workers.length];
+ requests[i] = MPI.COMM_WORLD.Irecv(result, 0, 1, MPI.OBJECT, destination, Tags.RESULT);
+ currentWorker++;
+ }
+
+ int answers = 0;
+ boolean[] handledRequests = new boolean[requests.length];
+ while (answers < requests.length) {
+ for (int i = 0; i < requests.length; i++) {
+ Request request = requests[i];
+ Status status;
+
+ if (handledRequests[i] || (status = request.Test()) == null) {
+ continue;
+ }
+
+ answers++;
+ handledRequests[i] = true;
+// System.out.format("Master got result from %d\n", status.source);
+ if (result[0].solutionNode != null) {
+ return result[0];
+ }
+
+ if (result[0].bound < min) {
+ min = result[0].bound;
+ }
+ }
+
+ try {
+ Thread.sleep(50);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ return new SearchResult(min);
+ }
+
+ private static class Tags {
+ static final int WORK = 1;
+ static final int RESULT = 2;
+ static final int FINISH = 3;
+ }
+}

src/main/java/ch/sebastianhaeni/pancake/Main.java renamed to src/main/java/ch/sebastianhaeni/pancake/RecursiveSolver.java

@@ -1,28 +1,40 @@
 package ch.sebastianhaeni.pancake;
 
+import java.util.Arrays;
 import java.util.List;
 
-public class Main {
+public class RecursiveSolver {
 
  public static void main(String[] args) {
 
-// Node root = new Node(new int[]{46, 53, 18, 4, 56, 11, 57, 59, 55, 25, 6, 34, 41, 13, 39, 52, 7, 33, 43, 21, 32, 51, 5, 1, 58, 49, 54, 9, 24, 17, 19, 27, 50, 42, 22, 30, 20, 3, 14, 28, 40, 10, 12, 29, 37, 8, 36, 2, 26, 38, 16, 60, 15, 48, 35, 45, 31, 44, 23, 47}, 0);
-// Node root = new Node(new int[]{2, 6, 10, 5, 1, 3, 8, 4, 7, 9}, 0);
-// Node root = new Node(new int[]{1, 2, 3}, 0);
-// Node root = new Node(new int[]{11, 7, 15, 6, 17, 3, 19, 16, 4, 10, 8, 12, 20, 14, 2, 5, 1, 9, 13, 18}, 0);
- Node root = new Node(new int[]{5, 2, 7, 10, 13, 16, 14, 6, 8, 15, 11, 1, 12, 3, 4, 9}, 0);
+// Node root = new Node(new int[]{46, 53, 18, 4, 56, 11, 57, 59, 55, 25, 6, 34, 41, 13, 39, 52, 7, 33, 43, 21, 32, 51, 5, 1, 58, 49, 54, 9, 24, 17, 19, 27, 50, 42, 22, 30, 20, 3, 14, 28, 40, 10, 12, 29, 37, 8, 36, 2, 26, 38, 16, 60, 15, 48, 35, 45, 31, 44, 23, 47});
+// Node root = new Node(new int[]{2, 6, 10, 5, 1, 3, 8, 4, 7, 9});
+// Node root = new Node(new int[]{3, 1, 2});
+// Node root = new Node(new int[]{11, 7, 15, 6, 17, 3, 19, 16, 4, 10, 8, 12, 20, 14, 2, 5, 1, 9, 13, 18});
+ Node root = new Node(new int[]{5, 2, 7, 10, 13, 16, 14, 6, 8, 18, 15, 11, 1, 12, 3, 4, 9, 17});
+
+ System.out.format("Solving a pancake pile of height %d.\n", root.getPancakes().length);
 
  long start = System.currentTimeMillis();
  Node solution = solve(root);
  long end = System.currentTimeMillis();
 
- System.out.println((end - start) + "ms passed");
+ System.out.format("%dms passed\n", (end - start));
 
  if (solution == null) {
  System.out.println("No solution found");
  return;
  }
- System.out.println("Found solution after " + solution.getFlipCount() + " flips.");
+ System.out.format("Found solution after %d flips.\n", solution.getFlipCount());
+
+ StringBuilder sb = new StringBuilder();
+ Node current = solution;
+ while (current.getParent() != null) {
+ sb.insert(0, Arrays.toString(current.getParent().getPancakes()) + "\n");
+ current = current.getParent();
+ }
+
+ System.out.println(sb.toString());
  }
 
  private static Node solve(Node root) {

src/main/java/ch/sebastianhaeni/pancake/SearchResult.java

@@ -1,6 +1,8 @@
 package ch.sebastianhaeni.pancake;
 
-class SearchResult {
+import java.io.Serializable;
+
+class SearchResult implements Serializable {
  Node solutionNode;
  int bound;
 

src/main/java/ch/sebastianhaeni/pancake/WorkPacket.java

@@ -0,0 +1,21 @@
+package ch.sebastianhaeni.pancake;
+
+import java.io.Serializable;
+
+public class WorkPacket implements Serializable {
+ private final Node node;
+ private final int bound;
+
+ public WorkPacket(Node node, int bound) {
+ this.node = node;
+ this.bound = bound;
+ }
+
+ public Node getNode() {
+ return node;
+ }
+
+ public int getBound() {
+ return bound;
+ }
+}

src/main/java/ch/sebastianhaeni/pancake/parallel/Master.java

@@ -0,0 +1,4 @@
+package ch.sebastianhaeni.pancake.parallel;
+
+public class Master {
+}

src/main/java/ch/sebastianhaeni/pancake/parallel/Slave.java

@@ -0,0 +1,4 @@
+package ch.sebastianhaeni.pancake.parallel;
+
+public class Slave {
+}