Factor out CodingLoopBase, rename loops to make more sense.

Author: bwbeach

src/main/java/com/backblaze/erasure/ByteInputOutputExpCodingLoop.java

@@ -0,0 +1,42 @@
+/**
+ * One specific ordering/nesting of the coding loops.
+ *
+ * Copyright 2015, Backblaze, Inc.  All rights reserved.
+ */
+
+package com.backblaze.erasure;
+
+public class ByteInputOutputExpCodingLoop extends CodingLoopBase {
+
+    @Override
+    public void codeSomeShards(
+            byte[][] matrixRows,
+            byte[][] inputs, int inputCount,
+            byte[][] outputs, int outputCount,
+            int offset, int byteCount) {
+
+        for (int iByte = offset; iByte < offset + byteCount; iByte++) {
+            {
+                final int iInput = 0;
+                final byte[] inputShard = inputs[iInput];
+                final byte inputByte = inputShard[iByte];
+                for (int iOutput = 0; iOutput < outputCount; iOutput++) {
+                    final byte[] outputShard = outputs[iOutput];
+                    final byte[] matrixRow = matrixRows[iOutput];
+                    outputShard[iByte] = Galois.multiply(matrixRow[iInput], inputByte);
+                }
+            }
+
+            for (int iInput = 1; iInput < inputCount; iInput++) {
+                final byte[] inputShard = inputs[iInput];
+                final byte inputByte = inputShard[iByte];
+                for (int iOutput = 0; iOutput < outputCount; iOutput++) {
+                    final byte[] outputShard = outputs[iOutput];
+                    final byte[] matrixRow = matrixRows[iOutput];
+                    outputShard[iByte] ^= Galois.multiply(matrixRow[iInput], inputByte);
+                }
+            }
+        }
+    }
+
+}

src/main/java/com/backblaze/erasure/ByteInputOutputTableCodingLoop.java

@@ -0,0 +1,44 @@
+/**
+ * One specific ordering/nesting of the coding loops.
+ *
+ * Copyright 2015, Backblaze, Inc.  All rights reserved.
+ */
+
+package com.backblaze.erasure;
+
+public class ByteInputOutputTableCodingLoop extends CodingLoopBase {
+
+    @Override
+    public void codeSomeShards(
+            byte[][] matrixRows,
+            byte[][] inputs, int inputCount,
+            byte[][] outputs, int outputCount,
+            int offset, int byteCount) {
+
+        final byte[][] table = Galois.MULTIPLICATION_TABLE;
+
+        for (int iByte = offset; iByte < offset + byteCount; iByte++) {
+            {
+                final int iInput = 0;
+                final byte[] inputShard = inputs[iInput];
+                final byte inputByte = inputShard[iByte];
+                for (int iOutput = 0; iOutput < outputCount; iOutput++) {
+                    final byte[] outputShard = outputs[iOutput];
+                    final byte[] matrixRow = matrixRows[iOutput];
+                    final byte[] multTableRow = table[matrixRow[iInput] & 0xFF];
+                    outputShard[iByte] = multTableRow[inputByte & 0xFF];
+                }
+            }
+            for (int iInput = 1; iInput < inputCount; iInput++) {
+                final byte[] inputShard = inputs[iInput];
+                final byte inputByte = inputShard[iByte];
+                for (int iOutput = 0; iOutput < outputCount; iOutput++) {
+                    final byte[] outputShard = outputs[iOutput];
+                    final byte[] matrixRow = matrixRows[iOutput];
+                    final byte[] multTableRow = table[matrixRow[iInput] & 0xFF];
+                    outputShard[iByte] ^= multTableRow[inputByte & 0xFF];
+                }
+            }
+        }
+    }
+}

src/main/java/com/backblaze/erasure/ByteOutputInputExpCodingLoop.java

@@ -0,0 +1,30 @@
+/**
+ * One specific ordering/nesting of the coding loops.
+ *
+ * Copyright 2015, Backblaze, Inc.  All rights reserved.
+ */
+
+package com.backblaze.erasure;
+
+public class ByteOutputInputExpCodingLoop extends CodingLoopBase {
+
+    @Override
+    public void codeSomeShards(
+            byte[][] matrixRows,
+            byte[][] inputs, int inputCount,
+            byte[][] outputs, int outputCount,
+            int offset, int byteCount) {
+
+        for (int iByte = offset; iByte < offset + byteCount; iByte++) {
+            for (int iOutput = 0; iOutput < outputCount; iOutput++) {
+                byte [] matrixRow = matrixRows[iOutput];
+                int value = 0;
+                for (int iInput = 0; iInput < inputCount; iInput++) {
+                    value ^= Galois.multiply(matrixRow[iInput], inputs[iInput][iByte]);
+                }
+                outputs[iOutput][iByte] = (byte) value;
+            }
+        }
+    }
+
+}

src/main/java/com/backblaze/erasure/ByteOutputInputTableCodingLoop.java

@@ -0,0 +1,30 @@
+/**
+ * One specific ordering/nesting of the coding loops.
+ *
+ * Copyright 2015, Backblaze, Inc.  All rights reserved.
+ */
+
+package com.backblaze.erasure;
+
+public class ByteOutputInputTableCodingLoop extends CodingLoopBase {
+
+    @Override
+    public void codeSomeShards(
+            byte[][] matrixRows,
+            byte[][] inputs, int inputCount,
+            byte[][] outputs, int outputCount,
+            int offset, int byteCount) {
+
+        byte [] [] table = Galois.MULTIPLICATION_TABLE;
+        for (int iByte = offset; iByte < offset + byteCount; iByte++) {
+            for (int iOutput = 0; iOutput < outputCount; iOutput++) {
+                byte [] matrixRow = matrixRows[iOutput];
+                int value = 0;
+                for (int iInput = 0; iInput < inputCount; iInput++) {
+                    value ^= table[matrixRow[iInput] & 0xFF][inputs[iInput][iByte] & 0xFF];
+                }
+                outputs[iOutput][iByte] = (byte) value;
+            }
+        }
+    }
+}

src/main/java/com/backblaze/erasure/CodingLoop.java

@@ -17,32 +17,42 @@ public interface CodingLoop {
      *
      * The naming of the three loops is (with number of loops in benchmark):
      *
-     *    "index"  - Index of byte within shard.  (200,000 bytes in each shard)
-     *
-     *    "shard"  - Which output shard is being computed.  (3 parity shards)
+     *    "byte"   - Index of byte within shard.  (200,000 bytes in each shard)
      *
      *    "input"  - Which input shard is being read.  (17 data shards)
      *
+     *    "output"  - Which output shard is being computed.  (3 parity shards)
+     *
      * And the naming for multiplication method is:
      *
      *    "table"  - Use the multiplication table.
      *
      *    "exp"    - Use the logarithm/exponent table.
+     *
+     * The ReedSolomonBenchmark class compares the performance of the different
+     * loops, which will depend on the specific processor you're running on.
+     *
+     * This is the inner loop.  It needs to be fast.  Be careful
+     * if you change it.
+     *
+     * I have tried inlining Galois.multiply(), but it doesn't
+     * make things any faster.  The JIT compiler is known to inline
+     * methods, so it's probably already doing so.
      */
     CodingLoop[] ALL_CODING_LOOPS =
             new CodingLoop[] {
-                    new IndexInputShardExpCodingLoop(),
-                    new IndexInputShardTableCodingLoop(),
-                    new IndexShardInputExpCodingLoop(),
-                    new IndexShardInputTableCodingLoop(),
-                    new InputIndexShardExpCodingLoop(),
-                    new InputIndexShardTableCodingLoop(),
-                    new InputShardIndexExpCodingLoop(),
-                    new InputShardIndexTableCodingLoop(),
-                    new ShardIndexInputExpCodingLoop(),
-                    new ShardIndexInputTableCodingLoop(),
-                    new ShardInputIndexExpCodingLoop(),
-                    new ShardInputIndexTableCodingLoop(),
+                    new ByteInputOutputExpCodingLoop(),
+                    new ByteInputOutputTableCodingLoop(),
+                    new ByteOutputInputExpCodingLoop(),
+                    new ByteOutputInputTableCodingLoop(),
+                    new InputByteOutputExpCodingLoop(),
+                    new InputByteOutputTableCodingLoop(),
+                    new InputOutputByteExpCodingLoop(),
+                    new InputOutputByteTableCodingLoop(),
+                    new OutputByteInputExpCodingLoop(),
+                    new OutputByteInputTableCodingLoop(),
+                    new OutputInputByteExpCodingLoop(),
+                    new OutputInputByteTableCodingLoop(),
             };
 
     /**

src/main/java/com/backblaze/erasure/CodingLoopBase.java

@@ -0,0 +1,41 @@
+/**
+ * Common implementations for coding loops.
+ *
+ * Copyright 2015, Backblaze, Inc.  All rights reserved.
+ */
+
+package com.backblaze.erasure;
+
+/**
+ * Common implementations for coding loops.
+ *
+ * Many of the coding loops do not have custom checkSomeShards() methods.
+ * The benchmark doesn't measure that method.
+ */
+public abstract class CodingLoopBase implements CodingLoop {
+
+    @Override
+    public boolean checkSomeShards(
+            byte[][] matrixRows,
+            byte[][] inputs, int inputCount,
+            byte[][] toCheck, int checkCount,
+            int offset, int byteCount) {
+
+        // This is the loop structure for ByteOutputInput, which does not
+        // require temorary buffers for checking.
+        byte [] [] table = Galois.MULTIPLICATION_TABLE;
+        for (int iByte = offset; iByte < offset + byteCount; iByte++) {
+            for (int iOutput = 0; iOutput < checkCount; iOutput++) {
+                byte [] matrixRow = matrixRows[iOutput];
+                int value = 0;
+                for (int iInput = 0; iInput < inputCount; iInput++) {
+                    value ^= table[matrixRow[iInput] & 0xFF][inputs[iInput][iByte] & 0xFF];
+                }
+                if (toCheck[iOutput][iByte] != (byte) value) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}