added a data-parallel version of Mandelbrot calculation using collections from javaslang, performs horribly though

Author: mguenther

src/main/java/com/mgu/parallel/data/mandelbrot/Mandelbrot.java

@@ -0,0 +1,69 @@
+package com.mgu.parallel.data.mandelbrot;
+
+import javaslang.collection.Array;
+import javaslang.collection.Seq;
+import javaslang.concurrent.Future;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class Mandelbrot {
+
+    private static final int DEFAULT_MAX_ITERATIONS = 1_000;
+
+    private static final double XR = -2.0;
+
+    private static final double XI = 1.25;
+
+    private static final double YR = 1.2;
+
+    private static final double YI = -1.25;
+
+    private final ExecutorService executorService;
+
+    private final int width;
+
+    private final int height;
+
+    public Mandelbrot(final int width, final int height) {
+        this(width, height, Executors.newFixedThreadPool(8));
+    }
+
+    public Mandelbrot(final int width, final int height, final ExecutorService executorService) {
+        this.width = width;
+        this.height = height;
+        this.executorService = executorService;
+    }
+
+    public Future<Seq<Integer>> computeParallel(final Array<Integer> withIndicesInCells) {
+        return Future.traverse(executorService, withIndicesInCells, this::singleComputation);
+    }
+
+    private Future<Integer> singleComputation(final Integer index) {
+        final int x = index % width;
+        final int y = index / width;
+
+        final double xc = XR + (XI - XR) * x / width;
+        final double yc = YR + (YI - YR) * y / height;
+
+        return Future.of(() -> mandelbrot(xc, yc));
+    }
+
+    private Integer mandelbrot(final double xc, final double yc) {
+        return mandelbrot(xc, yc, DEFAULT_MAX_ITERATIONS);
+    }
+
+    private Integer mandelbrot(final double xc, final double yc, final int maxIterations) {
+        Integer i = 0;
+        double x = 0.0;
+        double y = 0.0;
+        while (x * x + y * y < 4 && i < maxIterations) {
+            double xt = x * x - y * y + xc;
+            double yt = 2 * x * y + yc;
+            x = xt;
+            y = yt;
+            i++;
+        }
+        return i;
+    }
+}

src/main/java/com/mgu/parallel/data/mandelbrot/MandelbrotBenchmark.java

@@ -0,0 +1,32 @@
+package com.mgu.parallel.data.mandelbrot;
+
+import javaslang.collection.Array;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.State;
+
+import java.util.concurrent.TimeUnit;
+
+@State
+public class MandelbrotBenchmark {
+
+    private static final int LENGTH_SIDE_A = 1_000;
+
+    private static final int LENGTH_SIDE_B = 1_000;
+
+    private final Mandelbrot mandelbrot;
+
+    public MandelbrotBenchmark() {
+        this.mandelbrot = new Mandelbrot(LENGTH_SIDE_A, LENGTH_SIDE_B);
+    }
+
+    @GenerateMicroBenchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public void runMandelbrotDataParallel() {
+        final Array<Integer> iterationsPerCoordinate = Array.range(0, LENGTH_SIDE_A * LENGTH_SIDE_B);
+        mandelbrot.computeParallel(iterationsPerCoordinate);
+    }
+}

src/main/java/com/mgu/parallel/data/mandelbrot/MandelbrotStarter.java

@@ -0,0 +1,10 @@
+package com.mgu.parallel.data.mandelbrot;
+
+import org.openjdk.jmh.Main;
+
+public class MandelbrotStarter {
+
+    public static void main(String[] args) {
+        Main.main(args);
+    }
+}

src/main/java/com/mgu/parallel/task/mandelbrot/MandelbrotBenchmark.java

@@ -11,25 +11,29 @@
 @State
 public class MandelbrotBenchmark {
 
+    private static final int LENGTH_SIDE_A = 1_000;
+
+    private static final int LENGTH_SIDE_B = 1_000;
+
     private final Mandelbrot mandelbrot;
 
     public MandelbrotBenchmark() {
-        this.mandelbrot = new Mandelbrot(4000, 4000);
+        this.mandelbrot = new Mandelbrot(LENGTH_SIDE_A, LENGTH_SIDE_B);
     }
 
     @GenerateMicroBenchmark
     @BenchmarkMode(Mode.AverageTime)
     @OutputTimeUnit(TimeUnit.MILLISECONDS)
     public void runMandelbrotSequential() {
-        final int[] iterationsPerCoordinate = new int[4000*4000];
+        final int[] iterationsPerCoordinate = new int[LENGTH_SIDE_A * LENGTH_SIDE_B];
         mandelbrot.computeSequential(iterationsPerCoordinate, 0, iterationsPerCoordinate.length);
     }
 
     @GenerateMicroBenchmark
     @BenchmarkMode(Mode.AverageTime)
     @OutputTimeUnit(TimeUnit.MILLISECONDS)
     public void runMandelbrotParallel() {
-        final int[] iterationsPerCoordinate = new int[4000*4000];
+        final int[] iterationsPerCoordinate = new int[LENGTH_SIDE_A * LENGTH_SIDE_B];
         mandelbrot.computeParallel(iterationsPerCoordinate, 0, iterationsPerCoordinate.length);
     }
 }