From 8ec28607f5eaadd4529b058dda9c26453aecb07c Mon Sep 17 00:00:00 2001 From: Aldor Date: Wed, 5 Oct 2016 01:23:02 +0300 Subject: [PATCH 1/2] Spliterator exercise: initial commit --- .../exercise/RectangleSpliterator.java | 69 ++++++++++++++----- .../RectangleSpliteratorExercise.java | 6 +- 2 files changed, 53 insertions(+), 22 deletions(-) diff --git a/src/main/java/spliterators/lesson7/exercise/RectangleSpliterator.java b/src/main/java/spliterators/lesson7/exercise/RectangleSpliterator.java index 9e2dc01..678d132 100755 --- a/src/main/java/spliterators/lesson7/exercise/RectangleSpliterator.java +++ b/src/main/java/spliterators/lesson7/exercise/RectangleSpliterator.java @@ -6,41 +6,72 @@ import java.util.function.IntConsumer; public class RectangleSpliterator extends Spliterators.AbstractIntSpliterator { + private static int getColumnCount(int[][] array) { + return (array.length == 0) ? 0 : array[0].length; + } + + private static int getArraySize(int[][] array) { + return array.length * getColumnCount(array); + } - private final int innerLength; private final int[][] array; - private final int startOuterInclusive; - private final int endOuterExclusive; - private final int startInnerInclusive; + private final int columnCount; + private final int finalIndexExc; + private int currentRow; + private int currentCol; + private int currentIndex; + private boolean noMoreElements; + + private void setCurrentIndex(int absoluteIndex) { + currentRow = absoluteIndex / columnCount; + currentCol = absoluteIndex % columnCount; + currentIndex = absoluteIndex; + noMoreElements = absoluteIndex >= finalIndexExc; + } public RectangleSpliterator(int[][] array) { - this(array, 0, array.length, 0); + this(array, 0, getArraySize(array)); } - private RectangleSpliterator(int[][] array, int startOuterInclusive, int endOuterExclusive, int startInnerInclusive) { - super(Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.NONNULL); + private RectangleSpliterator(int[][] array, int fromAbsoluteIndexInc, int toAbsoluteIndexExc) { + super(toAbsoluteIndexExc - fromAbsoluteIndexInc, + Spliterator.IMMUTABLE | Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.NONNULL); - innerLength = array.length == 0 ? 0 : array[0].length; this.array = array; - this.startOuterInclusive = startOuterInclusive; - this.endOuterExclusive = endOuterExclusive; - this.startInnerInclusive = startInnerInclusive; + columnCount = getColumnCount(array); + finalIndexExc = toAbsoluteIndexExc; + setCurrentIndex(fromAbsoluteIndexInc); } @Override - public OfInt trySplit() { - // TODO - throw new UnsupportedOperationException(); + public boolean tryAdvance(IntConsumer action) { + if (noMoreElements) return false; + + try { + action.accept(array[currentRow][currentCol]); + } finally { + if (++currentCol == columnCount) { + currentCol = 0; + currentRow++; + } + noMoreElements = (++currentIndex == finalIndexExc); + } + return true; } @Override - public long estimateSize() { - return ((long) endOuterExclusive - startOuterInclusive)*innerLength - startInnerInclusive; + public OfInt trySplit() { + if (finalIndexExc - currentIndex < 2) return null; + + int splitPosition = currentIndex + (finalIndexExc - currentIndex) / 2; + RectangleSpliterator newSpliterator = new RectangleSpliterator(array, currentIndex, splitPosition); + setCurrentIndex(splitPosition); + return newSpliterator; } @Override - public boolean tryAdvance(IntConsumer action) { - // TODO - throw new UnsupportedOperationException(); + public long estimateSize() { + return finalIndexExc - currentIndex; } + } diff --git a/src/main/java/spliterators/lesson7/exercise/RectangleSpliteratorExercise.java b/src/main/java/spliterators/lesson7/exercise/RectangleSpliteratorExercise.java index 4aa9586..6b96944 100755 --- a/src/main/java/spliterators/lesson7/exercise/RectangleSpliteratorExercise.java +++ b/src/main/java/spliterators/lesson7/exercise/RectangleSpliteratorExercise.java @@ -10,15 +10,15 @@ @Fork(1) @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) -@Warmup(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS) +@Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS) @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS) @State(Scope.Thread) public class RectangleSpliteratorExercise { - @Param({"100"}) + @Param({"100", "1000", "10000"}) public int outerLength; - @Param({"100"}) + @Param({"100", "1000", "10000"}) public int innerLength; public int[][] array; From ae0ce946829352c5b060d10458ee3c744427cb8b Mon Sep 17 00:00:00 2001 From: Aldor Date: Wed, 5 Oct 2016 09:04:59 +0300 Subject: [PATCH 2/2] Spliterator exercise: initial commit --- RectangleSpliteratorResults.txt | 37 +++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 RectangleSpliteratorResults.txt diff --git a/RectangleSpliteratorResults.txt b/RectangleSpliteratorResults.txt new file mode 100644 index 0000000..6ff3901 --- /dev/null +++ b/RectangleSpliteratorResults.txt @@ -0,0 +1,37 @@ +Benchmark (innerLength) (outerLength) Mode Cnt Score Error Units +RectangleSpliteratorExercise.baiseline_par 100 100 avgt 10 0,009 ± 0,001 ms/op +RectangleSpliteratorExercise.baiseline_par 100 1000 avgt 10 0,022 ± 0,001 ms/op +RectangleSpliteratorExercise.baiseline_par 100 10000 avgt 10 0,239 ± 0,004 ms/op +RectangleSpliteratorExercise.baiseline_par 1000 100 avgt 10 0,015 ± 0,001 ms/op +RectangleSpliteratorExercise.baiseline_par 1000 1000 avgt 10 0,110 ± 0,004 ms/op +RectangleSpliteratorExercise.baiseline_par 1000 10000 avgt 10 3,162 ± 0,038 ms/op +RectangleSpliteratorExercise.baiseline_par 10000 100 avgt 10 0,095 ± 0,001 ms/op +RectangleSpliteratorExercise.baiseline_par 10000 1000 avgt 10 2,915 ± 0,032 ms/op +RectangleSpliteratorExercise.baiseline_par 10000 10000 avgt 10 28,678 ± 0,514 ms/op +RectangleSpliteratorExercise.baiseline_seq 100 100 avgt 10 0,005 ± 0,001 ms/op +RectangleSpliteratorExercise.baiseline_seq 100 1000 avgt 10 0,048 ± 0,001 ms/op +RectangleSpliteratorExercise.baiseline_seq 100 10000 avgt 10 0,659 ± 0,046 ms/op +RectangleSpliteratorExercise.baiseline_seq 1000 100 avgt 10 0,031 ± 0,001 ms/op +RectangleSpliteratorExercise.baiseline_seq 1000 1000 avgt 10 0,361 ± 0,023 ms/op +RectangleSpliteratorExercise.baiseline_seq 1000 10000 avgt 10 4,914 ± 0,056 ms/op +RectangleSpliteratorExercise.baiseline_seq 10000 100 avgt 10 0,304 ± 0,002 ms/op +RectangleSpliteratorExercise.baiseline_seq 10000 1000 avgt 10 3,853 ± 0,111 ms/op +RectangleSpliteratorExercise.baiseline_seq 10000 10000 avgt 10 37,277 ± 0,271 ms/op +RectangleSpliteratorExercise.rectangle_par 100 100 avgt 10 0,023 ± 0,001 ms/op +RectangleSpliteratorExercise.rectangle_par 100 1000 avgt 10 0,161 ± 0,002 ms/op +RectangleSpliteratorExercise.rectangle_par 100 10000 avgt 10 1,561 ± 0,020 ms/op +RectangleSpliteratorExercise.rectangle_par 1000 100 avgt 10 0,160 ± 0,004 ms/op +RectangleSpliteratorExercise.rectangle_par 1000 1000 avgt 10 1,516 ± 0,074 ms/op +RectangleSpliteratorExercise.rectangle_par 1000 10000 avgt 10 15,453 ± 0,510 ms/op +RectangleSpliteratorExercise.rectangle_par 10000 100 avgt 10 1,550 ± 0,013 ms/op +RectangleSpliteratorExercise.rectangle_par 10000 1000 avgt 10 15,762 ± 0,356 ms/op +RectangleSpliteratorExercise.rectangle_par 10000 10000 avgt 10 86,951 ± 1,201 ms/op +RectangleSpliteratorExercise.rectangle_seq 100 100 avgt 10 0,028 ± 0,001 ms/op +RectangleSpliteratorExercise.rectangle_seq 100 1000 avgt 10 0,545 ± 0,003 ms/op +RectangleSpliteratorExercise.rectangle_seq 100 10000 avgt 10 3,211 ± 0,011 ms/op +RectangleSpliteratorExercise.rectangle_seq 1000 100 avgt 10 0,532 ± 0,001 ms/op +RectangleSpliteratorExercise.rectangle_seq 1000 1000 avgt 10 2,591 ± 0,010 ms/op +RectangleSpliteratorExercise.rectangle_seq 1000 10000 avgt 10 26,322 ± 0,045 ms/op +RectangleSpliteratorExercise.rectangle_seq 10000 100 avgt 10 2,581 ± 0,020 ms/op +RectangleSpliteratorExercise.rectangle_seq 10000 1000 avgt 10 25,866 ± 0,074 ms/op +RectangleSpliteratorExercise.rectangle_seq 10000 10000 avgt 10 258,187 ± 0,691 ms/op \ No newline at end of file