Add a different coding loop that runs through memory

in order (good), but loads each shard multiple times (bad).

Author: bwbeach

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

@@ -11,7 +11,8 @@ public interface CodingLoop {
     CodingLoop[] ALL_CODING_LOOPS =
             new CodingLoop[] {
                     new IndexShardInputExpCodingLoop(),
-                    new IndexShardInputTableCodingLoop()
+                    new IndexShardInputTableCodingLoop(),
+                    new ShardInputIndexTableCodingLoop()
             };
 
     /**

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

@@ -0,0 +1,74 @@
+/**
+ * One specific ordering/nesting of the coding loops.
+ *
+ * Copyright 2015, Backblaze, Inc.  All rights reserved.
+ */
+
+package com.backblaze.erasure;
+
+public class ShardInputIndexTableCodingLoop implements CodingLoop {
+
+    @Override
+    public String getName() {
+        return "shard/input/index (mult table)";
+    }
+
+    @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 iShard = 0; iShard < outputCount; iShard++) {
+            byte [] outputShard = outputs[iShard];
+            {
+                final int iInput = 0;
+                final byte [] inputShard = inputs[iInput];
+                final byte [] multTableRow = table[matrixRows[iShard][iInput] & 0xFF];
+                for (int iByte = offset; iByte < offset + byteCount; iByte++) {
+                    outputShard[iByte] = multTableRow[inputShard[iByte] & 0xFF];
+                }
+            }
+            for (int iInput = 1; iInput < inputCount; iInput++) {
+                final byte [] inputShard = inputs[iInput];
+                final byte [] multTableRow = table[matrixRows[iShard][iInput] & 0xFF];
+                for (int iByte = offset; iByte < offset + byteCount; iByte++) {
+                    outputShard[iByte] ^= multTableRow[inputShard[iByte] & 0xFF];
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean checkSomeShards(
+            byte[][] matrixRows,
+            byte[][] inputs, int inputCount,
+            byte[][] toCheck, int checkCount,
+            int offset, int byteCount) {
+
+        // TODO: structure like the coding loop (use a temporary buffer?)
+        //
+        // Checking loop doesn't match the coding loop.  Need to figure
+        // out how to do it.  The problem is that the coding loop uses
+        // the output shards as temporary working space, so the original
+        // value isn't there to check after computing the new value.
+
+        byte [] [] table = Galois.MULTIPLICATION_TABLE;
+        for (int iByte = offset; iByte < offset + byteCount; iByte++) {
+            for (int iRow = 0; iRow < checkCount; iRow++) {
+                byte [] matrixRow = matrixRows[iRow];
+                int value = 0;
+                for (int c = 0; c < inputCount; c++) {
+                    value ^= table[matrixRow[c] & 0xFF][inputs[c][iByte] & 0xFF];
+                }
+                if (toCheck[iRow][iByte] != (byte) value) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+}

src/test/java/com/backblaze/erasure/ReedSolomonTest.java

@@ -206,6 +206,11 @@ public void testCodingLoopsProduceSameAnswers() {
         }
 
         codec.encodeParity(allShards, 0, shardSize);
+        allShards[parityShardCount - 1][0] += 1;
+        assertFalse(codec.isParityCorrect(allShards, 0, shardSize));
+        allShards[parityShardCount - 1][0] -= 1;
+        assertTrue(codec.isParityCorrect(allShards, 0, shardSize));
+
 
         return parityShards;
     }