Optimized appendDouble0() and refined tests

Author: abissell

chronicle/src/main/java/com/higherfrequencytrading/chronicle/impl/AbstractExcerpt.java

@@ -56,11 +56,10 @@ public abstract class AbstractExcerpt implements Excerpt {
     private static final byte[] Infinity = "Infinity".getBytes();
     private static final byte[] NaN = "NaN".getBytes();
     private static final long MAX_VALUE_DIVIDE_5 = Long.MAX_VALUE / 5;
-    private static final int MAX_NUMBER_LENGTH = 128;
+    private static final int MAX_NUMBER_LENGTH = 512;
     private static final int NUMBER_BUFFER_LAST_IDX = MAX_NUMBER_LENGTH - 1;
 
     private final byte[] numberBuffer = new byte[MAX_NUMBER_LENGTH];
-    private int numberBufferIdx = 0;
     private ExcerptInputStream inputStream = null;
     private ExcerptOutputStream outputStream = null;
 
@@ -1422,21 +1421,19 @@ else if (b == '-')
 
     private void appendLong0(long num) {
         // Extract digits into the end of the numberBuffer
+        int numberBufferIdx = 0;
         do {
             numberBuffer[NUMBER_BUFFER_LAST_IDX - numberBufferIdx++] = (byte) (num % 10L + '0');
             num /= 10L;
         } while (num > 0L);
 
-        // numberBufferIdx was advanced one too many in last run through loop
-        final int numberLength = numberBufferIdx--;
-
         // Bulk copy the digits into the front of the buffer
         // TODO: Can this be avoided with use of correctly offset bulk appends on Excerpt?
-        System.arraycopy(numberBuffer, NUMBER_BUFFER_LAST_IDX - numberBufferIdx,
-                numberBuffer, 0, numberLength);
+        // Uses (numberBufferIdx - 1) because index was advanced one too many times
+        System.arraycopy(numberBuffer, NUMBER_BUFFER_LAST_IDX - (numberBufferIdx - 1),
+                numberBuffer, 0, numberBufferIdx);
 
-        write(numberBuffer, 0, numberLength);
-        numberBufferIdx = 0;
+        write(numberBuffer, 0, numberBufferIdx);
     }
 
     @Override
@@ -1464,18 +1461,23 @@ public ByteStringAppender append(double d, int precision) {
     }
 
     private void appendDouble0(long num, int precision) {
-        // find the number of digits
-        long power10 = Math.max(TENS[precision], power10(num));
-        // starting from the end, write each digit
-        long decimalPoint = TENS[precision - 1];
-        while (power10 > 0) {
-            if (decimalPoint == power10)
-                writeByte('.');
-            // write the lowest digit.
-            writeByte((byte) (num / power10 % 10 + '0'));
-            // remove that digit.
-            power10 /= 10;
-        }
+        // Extract digits into the end of the numberBuffer
+        // Once desired precision is reached, write the '.'
+        int numberBufferIdx = 0;
+        do {
+            numberBuffer[NUMBER_BUFFER_LAST_IDX - numberBufferIdx++] = (byte) (num % 10L + '0');
+            num /= 10L;
+            if (numberBufferIdx == precision)
+                numberBuffer[NUMBER_BUFFER_LAST_IDX - numberBufferIdx++] = (byte) '.';
+        } while (num > 0L);
+
+        // Bulk copy the digits into the front of the buffer
+        // TODO: Can this be avoided with use of correctly offset bulk appends on Excerpt?
+        // Uses (numberBufferIdx - 1) because index was advanced one too many times
+        System.arraycopy(numberBuffer, NUMBER_BUFFER_LAST_IDX - (numberBufferIdx - 1),
+                numberBuffer, 0, numberBufferIdx);
+
+        write(numberBuffer, 0, numberBufferIdx);
     }
 
     private static final long[] TENS = new long[19];

chronicle/src/test/java/com/higherfrequencytrading/chronicle/impl/NewVsOldNumberAppendTest.java

@@ -32,11 +32,12 @@ public class NewVsOldNumberAppendTest {
     static final String TMP = System.getProperty("java.io.tmpdir");
 
     private static final int NUM_ENTRIES_PER_RECORD = 20;
-    private static final int NUM_RECORDS = 400 * 1000;
+    private static final int NUM_RECORDS = 200 * 1000;
     private static final int NUM_WARMUP_RECORDS = 40 * 1000;
     private static final int TOTAL_RECORDS = NUM_RECORDS + NUM_WARMUP_RECORDS;
     private static final long[][] RANDOM_LONGS = new long[TOTAL_RECORDS][NUM_ENTRIES_PER_RECORD];
     private static final double[][] RANDOM_DOUBLES = new double[TOTAL_RECORDS][NUM_ENTRIES_PER_RECORD];
+    private static final int MAX_PRECISION = 8;
 
     private static final Random random = new Random();
 
@@ -49,21 +50,15 @@ public void fillRandoms() {
         for (int i = 0; i < TOTAL_RECORDS; i++) {
             for (int j = 0; j < NUM_ENTRIES_PER_RECORD; j++) {
                 RANDOM_LONGS[i][j] = random.nextLong();
-                RANDOM_DOUBLES[i][j] = random.nextDouble();
+                RANDOM_DOUBLES[i][j] = Math.max(123456.789,
+                                                random.nextDouble() % (10 * 1000 * 1000));
             }
         }
     }
 
-    @Test
-    public void testNumberAppends() throws IOException {
-        System.gc();
-        timeAppends(Generation.NEW, ExcerptType.BYTE_BUFFER);
-        System.gc();
-        timeAppends(Generation.NEW, ExcerptType.UNSAFE);
-        System.gc();
-        timeAppends(Generation.OLD, ExcerptType.BYTE_BUFFER);
-        System.gc();
-        timeAppends(Generation.OLD, ExcerptType.UNSAFE);
+    private enum NumberType {
+        LONG,
+        DOUBLE
     }
 
     private enum Generation {
@@ -94,7 +89,23 @@ private String getStringRep() {
         }
     }
 
-    private void timeAppends(Generation gen, ExcerptType excerptType) throws IOException {
+    @Test
+    public void testNumberAppends() throws IOException {
+        for (NumberType type : NumberType.values()) {
+            System.gc();
+            timeAppends(Generation.NEW, ExcerptType.BYTE_BUFFER, type);
+            System.gc();
+            timeAppends(Generation.NEW, ExcerptType.UNSAFE, type);
+            System.gc();
+            timeAppends(Generation.OLD, ExcerptType.BYTE_BUFFER, type);
+            System.gc();
+            timeAppends(Generation.OLD, ExcerptType.UNSAFE, type);
+        }
+    }
+
+    private void timeAppends(Generation gen,
+                             ExcerptType excerptType,
+                             NumberType numType) throws IOException {
         String basePath = TMP + File.separator;
 
         String newPath = basePath + gen.getStringRep() + excerptType.getStringRep() + "Ic";
@@ -121,38 +132,20 @@ private void timeAppends(Generation gen, ExcerptType excerptType) throws IOExcep
 
             excerpt.startExcerpt(2 * 10 * NUM_ENTRIES_PER_RECORD);
             for (int j = 0; j < NUM_ENTRIES_PER_RECORD; j++) {
-                excerpt.append(RANDOM_LONGS[i][j]);
-                // excerpt.append(RANDOM_DOUBLES[i][j]);
+                if (numType == NumberType.LONG)
+                    excerpt.append(RANDOM_LONGS[i][j]);
+                else if (numType == NumberType.DOUBLE)
+                    excerpt.append(RANDOM_DOUBLES[i][j], (j % MAX_PRECISION + 2));
+                else
+                    throw new AssertionError();
             }
             excerpt.finish();
         }
         newIc.close();
 
         long time = System.nanoTime() - start;
-        System.out.println(gen + " " + excerptType + " time taken " +
+        System.out.println(numType + " " + gen + " " + excerptType + " time taken " +
                            (time / 1000000) + " ms");
-
-        /*
-        // Read out values to ensure they were correct and prevent possible DCE
-        IndexedChronicle ic = new IndexedChronicle(newPath);
-        ic.useUnsafe(excerptType == ExcerptType.UNSAFE);
-        Excerpt readExcerpt = ic.createExcerpt();
-        for (int i = 0; i < TOTAL_RECORDS; i++) {
-            boolean found = readExcerpt.nextIndex();
-            if (!found)
-                assertTrue(found);
-            for (int j = 0; j < NUM_ENTRIES_PER_RECORD; j++) {
-                long l = readExcerpt.readLong();
-                double d = readExcerpt.readDouble();
-                if (l != RANDOM_LONGS[i][j])
-                    assertEquals(l, RANDOM_LONGS[i][j]);
-                if (d != RANDOM_DOUBLES[i][j])
-                    assertEquals(d, RANDOM_DOUBLES[i][j]);
-            }
-            readExcerpt.finish();
-        }
-        ic.close();
-        */
     }
 
     private static void deleteOnExit(String basePath) {