Index: oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/segment/CompactionMap.java
===================================================================
--- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/segment/CompactionMap.java	(revision 1701579)
+++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/segment/CompactionMap.java	(working copy)
@@ -18,6 +18,7 @@
 
 import static com.google.common.collect.Maps.newHashMap;
 import static com.google.common.collect.Maps.newTreeMap;
+import static com.google.common.collect.Sets.newHashSet;
 import static com.google.common.collect.Sets.newTreeSet;
 import static org.apache.jackrabbit.oak.commons.IOUtils.humanReadableByteCount;
 import static org.apache.jackrabbit.oak.plugins.segment.Segment.RECORD_ALIGN_BITS;
@@ -27,6 +28,8 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
 import java.util.UUID;
 
 /**
@@ -87,6 +90,10 @@
 
     private CompactionMap prev;
 
+    CompactionMap(SegmentTracker tracker) {
+        this(Integer.getInteger("compress-interval", 100000), tracker);
+    }
+
     CompactionMap(int compressInterval, SegmentTracker tracker) {
         this.compressInterval = compressInterval;
         this.tracker = tracker;
@@ -244,14 +251,30 @@
         compressInternal(Collections.<UUID>emptySet());
     }
 
+    protected static boolean TREE_MAPS = false;
+
     private void compressInternal(Set<UUID> removed) {
         if (recent.isEmpty() && removed.isEmpty()) {
             // noop
             return;
         }
-        Set<UUID> uuids = newTreeSet();
 
-        Map<UUID, Map<Integer, RecordId>> mapping = newTreeMap();
+        //TODO
+        Set<UUID> uuids = null;
+        if (TREE_MAPS) {
+            uuids = newTreeSet();
+        } else {
+            uuids = newHashSet();
+        }
+
+        // TODO newTreeMap
+        Map<UUID, Map<Integer, RecordId>> mapping = null;
+        if (TREE_MAPS) {
+            mapping = newTreeMap();
+        } else {
+            mapping = newHashMap();
+        }
+
         for (Entry<RecordId, RecordId> entry : recent.entrySet()) {
             RecordId before = entry.getKey();
 
@@ -263,7 +286,12 @@
 
             Map<Integer, RecordId> map = mapping.get(uuid);
             if (map == null) {
-                map = newTreeMap();
+                // TODO newTreeMap
+                if (TREE_MAPS) {
+                    map = newTreeMap();
+                } else {
+                    map = newHashMap();
+                }
                 mapping.put(uuid, map);
             }
             map.put(before.getOffset(), entry.getValue());
@@ -290,6 +318,12 @@
         int newIndex = 0;
         int newEntry = 0;
         int oldEntry = 0;
+
+        if (!TREE_MAPS) {
+            // TODO this will take care of the missing sort
+            uuids = new TreeSet<UUID>(uuids);
+        }
+
         for (UUID uuid : uuids) {
             newmsbs[newEntry] = uuid.getMostSignificantBits();
             newlsbs[newEntry] = uuid.getLeastSignificantBits();
@@ -297,7 +331,12 @@
             // offset -> record
             Map<Integer, RecordId> newsegment = mapping.get(uuid);
             if (newsegment == null) {
-                newsegment = newTreeMap();
+                // TODO newTreeMap
+                if (TREE_MAPS) {
+                    newsegment = newTreeMap();
+                } else {
+                    newsegment = newHashMap();
+                }
             }
 
             if (oldEntry < msbs.length
@@ -311,6 +350,10 @@
                 }
                 oldEntry++;
             }
+            if (!TREE_MAPS) {
+                // TODO this will take care of the missing sort
+                newsegment = new TreeMap<Integer, RecordId>(newsegment);
+            }
 
             newEntryIndex[newEntry++] = newIndex;
             for (Entry<Integer, RecordId> entry : newsegment.entrySet()) {
@@ -515,5 +558,4 @@
 
         return total;
     }
-
 }