Master worker pattern iluwatar#799 (iluwatar#831)

* master worker pattern

* Update App.java

* Adding new line to README.md

* Adding new line to pom.xml

* Adding new line to ArrayEquality.java

* Adding new line to Input.java

* Adding new line to Result.java

* Adding new line to ArrayTransposeMasterWorker.java

* Adding new line to ArrayTransposeMaster.java

* Adding new line to ArrayTransposeWorker.java

* Adding new line to Worker.java

* Adding new line to ArrayInputTest.java

* Adding new line ArrayTransposeMasterWorkerTest.java

* Adding new line to ArrayResult.java

* Review changes

* Update README.md

Author: AnaghaSasikumar

master-worker-pattern/README.md

@@ -0,0 +1,28 @@
+---
+layout: pattern
+title: Master-Worker
+folder: master-worker-pattern
+permalink: /patterns/master-worker-pattern/
+categories: Centralised Parallel Processing
+tags:
+ - Java
+ - Difficulty-Intermediate
+---
+
+## Also known as
+
+> Master-slave or Map-reduce
+
+## Intent
+
+> Used for centralised parallel processing.
+
+## Applicability
+This pattern can be used when data can be divided into multiple parts, all of which need to go through the same computation to give a result, which need to be aggregated to get the final result.
+
+## Explanation
+In this pattern, parallel processing is performed using a system consisting of a master and some number of workers, where a master divides the work among the workers, gets the result back from them and assimilates all the results to give final result. The only communication is between the master and the worker - none of the workers communicate among one another and the user only communicates with the master to get the required job done. The master has to maintain a record of how the divided data has been distributed, how many workers have finished their work and returned a result, and the results themselves to be able to aggregate the data correctly.
+
+## Credits
+* [https://docs.gigaspaces.com/sbp/master-worker-pattern.html]
+* [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/masterslave.htm]

master-worker-pattern/pom.xml

@@ -0,0 +1,21 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>com.iluwatar</groupId>
+    <artifactId>java-design-patterns</artifactId>
+    <version>1.21.0-SNAPSHOT</version>
+  </parent>
+  <artifactId>master-worker-pattern</artifactId>
+  <dependencies>
+      <dependency>
+          <groupId>org.junit.jupiter</groupId>
+          <artifactId>junit-jupiter-api</artifactId>
+          <scope>test</scope>
+      </dependency>
+      <dependency>
+          <groupId>org.junit.jupiter</groupId>
+          <artifactId>junit-jupiter-engine</artifactId>
+          <scope>test</scope>
+      </dependency>
+    </dependencies>
+</project>

master-worker-pattern/src/main/java/com/iluwatar/masterworker/App.java

@@ -0,0 +1,71 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014-2016 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.iluwatar.masterworker;
+
+import com.iluwatar.masterworker.system.ArrayTransposeMasterWorker;
+
+/**
+ * <p>The <b><em>Master-Worker</em></b> pattern is used when the problem at hand can be solved by dividing into 
+ * multiple parts which need to go through the same computation and may need to be aggregated to get final result.
+ * Parallel processing is performed using a system consisting of a master and some number of workers, where a 
+ * master divides the work among the workers, gets the result back from them and assimilates all the results to
+ * give final result. The only communication is between the master and the worker - none of the workers communicate
+ * among one another and the user only communicates with the master to get required job done.</p>
+ * <p>In our example, we have generic abstract classes {@link MasterWorker}, {@link Master} and {@link Worker} which
+ * have to be extended by the classes which will perform the specific job at hand (in this case finding transpose of
+ * matrix, done by {@link ArrayTransposeMasterWorker}, {@link ArrayTransposeMaster} and {@link ArrayTransposeWorker}).
+ * The Master class divides the work into parts to be given to the workers, collects the results from the workers and
+ * aggregates it when all workers have responded before returning the solution. The Worker class extends the Thread
+ * class to enable parallel processing, and does the work once the data has been received from the Master. The
+ * MasterWorker contains a reference to the Master class, gets the input from the App and passes it on to the Master.
+ * These 3 classes define the system which computes the result. We also have 2 abstract classes {@link Input} and
+ * {@link Result}, which contain the input data and result data respectively. The Input class also has an abstract
+ * method divideData which defines how the data is to be divided into segments. These classes are extended by
+ * {@link ArrayInput} and {@link ArrayResult}.</p>
+ */
+
+public class App {
+  
+  /**
+   * Program entry point.
+   * @param args command line args
+   */
+
+  public static void main(String[] args) {
+    ArrayTransposeMasterWorker mw = new ArrayTransposeMasterWorker();
+    int rows = 10;
+    int columns = 20;
+    int[][] inputMatrix = ArrayUtilityMethods.createRandomIntMatrix(rows,columns);    
+    ArrayInput input = new ArrayInput(inputMatrix);
+    ArrayResult result = (ArrayResult) mw.getResult(input);    
+    if (result != null) {
+      ArrayUtilityMethods.printMatrix(inputMatrix);
+      System.out.println("");
+      ArrayUtilityMethods.printMatrix(result.data);
+    } else {
+      System.out.println("Please enter non-zero input");
+    }
+  }
+
+}

master-worker-pattern/src/main/java/com/iluwatar/masterworker/ArrayInput.java

@@ -0,0 +1,86 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014-2016 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.iluwatar.masterworker;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ *Class ArrayInput extends abstract class {@link Input} and contains data
+ *of type int[][].
+ */
+
+public class ArrayInput extends Input<int[][]> {
+
+  public ArrayInput(int[][] data) {
+    super(data);
+  }
+  
+  static int[] makeDivisions(int[][] data, int num) {
+    int initialDivision = data.length / num; //equally dividing
+    int[] divisions = new int[num];
+    Arrays.fill(divisions, initialDivision);
+    if (initialDivision * num != data.length) {
+      int extra = data.length - initialDivision * num;
+      int l = 0;
+      //equally dividing extra among all parts
+      while (extra > 0) {
+        divisions[l] = divisions[l] + 1;
+        extra--;
+        if (l == num - 1) {
+          l = 0;
+        } else {
+          l++;
+        }
+      }
+    }
+    return divisions;
+  }
+
+  @Override
+  public ArrayList<Input> divideData(int num) {
+    if (this.data == null) {
+      return null;
+    } else {
+      int[] divisions = makeDivisions(this.data, num);
+      ArrayList<Input> result = new ArrayList<Input>(num);
+      int rowsDone = 0; //number of rows divided so far
+      for (int i = 0; i < num; i++) {
+        int rows = divisions[i];
+        if (rows != 0) {
+          int[][] divided = new int[rows][this.data[0].length];
+          for (int j = 0; j < rows; j++) {
+            divided[j] = this.data[rowsDone + j];
+          }
+          rowsDone += rows;
+          ArrayInput dividedInput = new ArrayInput(divided);
+          result.add(dividedInput);
+        } else {
+          break; //rest of divisions will also be 0
+        }
+      }
+      return result;
+    }    
+  } 
+}

master-worker-pattern/src/main/java/com/iluwatar/masterworker/ArrayResult.java

@@ -0,0 +1,36 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014-2016 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.iluwatar.masterworker;
+
+/**
+ *Class ArrayResult extends abstract class {@link Result} and contains data
+ *of type int[][].
+ */
+
+public class ArrayResult extends Result<int[][]> {
+
+  public ArrayResult(int[][] data) {
+    super(data);
+  }
+}

master-worker-pattern/src/main/java/com/iluwatar/masterworker/ArrayUtilityMethods.java

@@ -0,0 +1,110 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014-2016 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.iluwatar.masterworker;
+
+import java.util.Random;
+
+/**
+ *Class ArrayUtilityMethods has some utility methods for matrices and arrays.
+ */
+
+public class ArrayUtilityMethods {
+ 
+  /**
+   * Method arraysSame compares 2 arrays @param a1 and @param a2
+   * and @return whether their values are equal (boolean).
+   */
+
+  public static boolean arraysSame(int[] a1, int[] a2) {
+    //compares if 2 arrays have the same value
+    if (a1.length != a2.length) {
+      return false;
+    } else {
+      boolean answer = false;
+      for (int i = 0; i < a1.length; i++) {
+        if (a1[i] == a2[i]) {
+          answer = true;
+        } else {
+          answer = false;
+          break;
+        }
+      }
+      return answer;
+    }
+  }
+
+  /**
+   * Method matricesSame compares 2 matrices @param m1 and @param m2
+   * and @return whether their values are equal (boolean).
+   */
+  
+  public static boolean matricesSame(int[][] m1, int[][] m2) {
+    if (m1.length != m2.length) {
+      return false;
+    } else {
+      boolean answer = false;
+      for (int i = 0; i < m1.length; i++) {
+        if (arraysSame(m1[i], m2[i])) {
+          answer = true;
+        } else {
+          answer = false;
+          break;
+        }
+      }
+      return answer;
+    }
+  }
+  
+  /**
+   * Method createRandomIntMatrix creates a random matrix of size @param rows
+   * and @param columns @return it (int[][]).
+   */
+  
+  public static int[][] createRandomIntMatrix(int rows, int columns) {
+    int[][] matrix = new int[rows][columns];
+    Random rand = new Random();
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < columns; j++) {
+        //filling cells in matrix
+        matrix[i][j] = rand.nextInt(10);
+      }
+    }
+    return matrix;
+  }
+  
+  /**
+   * Method printMatrix prints input matrix @param matrix.
+   */
+  
+  public static void printMatrix(int[][] matrix) {
+    //prints out int[][]
+    for (int i = 0; i < matrix.length; i++) {
+      for (int j = 0; j < matrix[0].length; j++) {
+        System.out.print(matrix[i][j] + " ");
+      }
+      System.out.println("");
+    }
+  }
+  
+}