From 1774a4d3311085f93cae44122368d0b2c4808f50 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@higherfrequencytrading.com>
Date: Mon, 10 Nov 2014 15:07:08 +0000
Subject: [PATCH] Tweek segment sizes again.

---
 .../map/AbstractChronicleMapBuilder.java      | 36 +++++++++----------
 .../chronicle/map/ChronicleMapTest.java       |  3 +-
 .../chronicle/map/EntryCountMapTest.java      | 36 +++++++++----------
 3 files changed, 36 insertions(+), 39 deletions(-)

diff --git a/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
index a89942f33..e0a689148 100644
--- a/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
+++ b/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
@@ -372,10 +372,8 @@ public abstract class AbstractChronicleMapBuilder<K, V,
         if (segments == 1)
             return entries;
         double poorDistEntriesScale = Math.log(segments) * entries;
-        if (segments <= 8)
-            return Math.min(entries * segments,
-                    (long) (entries + poorDistEntriesScale * 0.11 + segments * 8)); // 11% was min for tests
-        return (long) (entries + poorDistEntriesScale * 0.11 + 80); // 11% was min for tests
+        return Math.min(entries * segments,
+                (long) (entries + poorDistEntriesScale * 0.14 + 32)); // 12% was min for tests
     }
 
     @Override
@@ -390,24 +388,22 @@ public abstract class AbstractChronicleMapBuilder<K, V,
     }
 
     private int estimateSegments() {
-        for (int power = 1; power < 64; power *= 2) {
-            if (entries <= power * power * power)
-                return power;
-        }
-        long size = (entrySize + 32) * entries;
-        if (size < 10L * 1000 * 1000) // 10 MB
-            return 64;
-        if (size < 100L * 1000 * 1000) // 100 MB
-            return 128;
-        if (size < 400L * 1000 * 1000) // 400 MB
-            return 256;
-        if (size < 1L * 1000 * 1000 * 1000) // 1 GB
+        return (int) Math.min(Maths.nextPower2(entries / 32, 1), estimateSegementBasedOnSize());
+
+    }
+
+    private int estimateSegementBasedOnSize() {
+        // based on entries with multimap of 100 bytes.
+        long size = (long) (Math.log10(entrySize + 32) / 2 * entries);
+        if (size < 10 * 1000)
             return 512;
-        if (size < 10L * 1000 * 1000 * 1000) // 10 GB
+        if (size < 100 * 1000)
             return 1024;
-        if (size < 100L * 1000 * 1000 * 1000) // 100 GB
+        if (size < 1000 * 1000)
             return 2048;
-        return 4096;
+        if (size < 10 * 1000 * 1000)
+            return 4096;
+        return 8192;
     }
 
     @Override
@@ -937,7 +933,7 @@ public abstract class AbstractChronicleMapBuilder<K, V,
     int segmentHeaderSize() {
         int segments = actualSegments();
         // reduce false sharing unless we have a lot of segments.
-        return segments <= 8192 ? 64 : 16;
+        return segments <= 8192 ? 128 : 64;
     }
 
     public MultiMapFactory multiMapFactory() {
diff --git a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
index 098f16f25..d69a281ad 100644
--- a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
@@ -576,7 +576,7 @@ public class ChronicleMapTest {
             InstantiationException, InterruptedException, ExecutionException {
 //        int runs = Integer.getInteger("runs", 10);
         int procs = Runtime.getRuntime().availableProcessors();
-        int threads = procs * 2; // runs > 100 ? procs / 2 : procs;
+        int threads = procs * 3;
         ExecutorService es = Executors.newFixedThreadPool(procs);
         for (int runs : new int[]{10, 50, 250, 500, 1000, 2500}) {
             // JAVA 8 produces more garbage than previous versions for internal work.
@@ -585,6 +585,7 @@ public class ChronicleMapTest {
             OffHeapUpdatableChronicleMapBuilder<CharSequence, LongValue> builder = OffHeapUpdatableChronicleMapBuilder
                     .of(CharSequence.class, LongValue.class)
                     .entries(entries)
+                    .actualSegments(8 * 1024)
                     .entryAndValueAlignment(OF_8_BYTES)
                     .entrySize(24);
 
diff --git a/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java b/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java
index d3cad018a..742366961 100644
--- a/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java
@@ -53,7 +53,7 @@ public class EntryCountMapTest {
             throws IOException {
         OffHeapUpdatableChronicleMapBuilder<CharSequence, LongValue> mapBuilder = OffHeapUpdatableChronicleMapBuilder.of(CharSequence.class, LongValue.class)
                 .entries(entries)
-                .minSegments(segments)
+                .actualSegments(segments)
                 .entrySize(entrySize)
                 .entryAndValueAlignment(alignment);
         return mapBuilder.createPersistedTo(getPersistenceFile());
@@ -103,33 +103,33 @@ public class EntryCountMapTest {
             testEntriesMaxSize(s, 2000, 3100, i);
             testEntriesMaxSize(s, 4000, 5100, i);
             testEntriesMaxSize(s, 5000, 7100, i);
-            testEntriesMaxSize(s, 8000, 10200, i);
-            testEntriesMaxSize(s, 12000, 16000, i);
-            testEntriesMaxSize(s, 16000, 21300, i);
+            testEntriesMaxSize(s, 8000, 11000, i);
+            testEntriesMaxSize(s, 12000, 17000, i);
+            testEntriesMaxSize(s, 16000, 22000, i);
             s = 32;
             testEntriesMaxSize(s, 2000, 3900, i);
             testEntriesMaxSize(s, 4000, 5900, i);
             testEntriesMaxSize(s, 5000, 7900, i);
             testEntriesMaxSize(s, 8000, 12000, i);
-            testEntriesMaxSize(s, 12000, 15900, i);
-            testEntriesMaxSize(s, 16000, 21300, i);
-            testEntriesMaxSize(s, 32000, 42200, i);
+            testEntriesMaxSize(s, 12000, 17000, i);
+            testEntriesMaxSize(s, 16000, 23000, i);
+            testEntriesMaxSize(s, 32000, 46000, i);
             s = 64;
             testEntriesMaxSize(s, 5000, 7550, i);
             testEntriesMaxSize(s, 8000, 11400, i);
-            testEntriesMaxSize(s, 12000, 16000, i);
-            testEntriesMaxSize(s, 16000, 22000, i);
-            testEntriesMaxSize(s, 32000, 43000, i);
-            testEntriesMaxSize(s, 40000, 54000, i);
+            testEntriesMaxSize(s, 12000, 18000, i);
+            testEntriesMaxSize(s, 16000, 24000, i);
+            testEntriesMaxSize(s, 32000, 47000, i);
+            testEntriesMaxSize(s, 40000, 60000, i);
             s = 128;
-            testEntriesMaxSize(s, 16000, 23000, i);
-            testEntriesMaxSize(s, 32000, 44200, i);
-            testEntriesMaxSize(s, 40000, 56000, i);
-            testEntriesMaxSize(s, 64000, 92000, i);
-            testEntriesMaxSize(s, 129000, 190000, i);
+            testEntriesMaxSize(s, 16000, 24000, i);
+            testEntriesMaxSize(s, 32000, 50000, i);
+            testEntriesMaxSize(s, 40000, 62000, i);
+            testEntriesMaxSize(s, 64000, 98000, i);
+            testEntriesMaxSize(s, 129000, 204000, i);
             s = 256;
-            testEntriesMaxSize(s, 64000, 92000, i);
-            testEntriesMaxSize(s, 129000, 192000, i);
+            testEntriesMaxSize(s, 64000, 100000, i);
+            testEntriesMaxSize(s, 129000, 213000, i);
         }
         // hyperbolic average gives more weight to small numbers.
         System.out.printf("Score: %.2f%n", scoreCount / score);