diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/CacheWeights.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/CacheWeights.java
new file mode 100644
index 0000000..60552f2
--- /dev/null
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/CacheWeights.java
@@ -0,0 +1,125 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.jackrabbit.oak.segment;
+
+import static org.apache.jackrabbit.oak.commons.StringUtils.estimateMemoryUsage;
+
+import javax.annotation.Nonnull;
+
+import org.apache.jackrabbit.oak.segment.ReaderCache.CacheKey;
+
+import com.google.common.cache.Weigher;
+
+public class CacheWeights {
+
+    public static final int OBJECT_HEADER_SIZE = 12;
+
+    private static final int LIRS_CACHE_OVERHEAD = 168;
+
+    private static final int RECORD_CACHE_OVERHEAD = 32;
+
+    private static final int PRIORITY_CACHE_OVERHEAD = 96;
+
+    private static final int SEGMENT_CACHE_OVERHEAD = 168;
+
+    public static class OneWeigher<K, V> implements Weigher<K, V> {
+
+        @Override
+        public int weigh(Object key, Object value) {
+            return 1;
+        }
+    }
+
+    private static final Weigher<Object, Object> NOOP_WEIGHER = new OneWeigher<>();
+
+    @SuppressWarnings("unchecked")
+    public static <K, V> Weigher<K, V> noopWeigher() {
+        return (Weigher<K, V>) NOOP_WEIGHER;
+    }
+
+    public static class SegmentCacheWeigher implements
+            Weigher<SegmentId, Segment> {
+        @Override
+        public int weigh(@Nonnull SegmentId id, @Nonnull Segment segment) {
+            int size = SEGMENT_CACHE_OVERHEAD;
+            // segmentid weight estimation is included in segment
+            size += segment.estimateMemoryUsage();
+            return size;
+        }
+    }
+
+    public static class NodeCacheWeigher implements Weigher<String, RecordId> {
+
+        @Override
+        public int weigh(String key, RecordId value) {
+            int size = PRIORITY_CACHE_OVERHEAD;
+            size += estimateMemoryUsage(key);
+            size += value.estimateMemoryUsage();
+            return size;
+        }
+    }
+
+    public static class StringCacheWeigher implements Weigher<String, RecordId> {
+
+        @Override
+        public int weigh(String key, RecordId value) {
+            int size = RECORD_CACHE_OVERHEAD;
+            size += estimateMemoryUsage(key);
+            size += value.estimateMemoryUsage();
+            return size;
+        }
+    }
+
+    public static class TemplateCacheWeigher implements
+            Weigher<Template, RecordId> {
+
+        @Override
+        public int weigh(Template key, RecordId value) {
+            int size = RECORD_CACHE_OVERHEAD;
+            size += key.estimateMemoryUsage();
+            size += value.estimateMemoryUsage();
+            return size;
+        }
+    }
+
+    public static class ReaderTemplateCacheWeigher implements
+            Weigher<CacheKey, Template> {
+
+        @Override
+        public int weigh(CacheKey key, Template value) {
+            int size = LIRS_CACHE_OVERHEAD;
+            size += key.estimateMemoryUsage();
+            size += value.estimateMemoryUsage();
+            return size;
+        }
+    }
+
+    public static class ReaderStringCacheWeigher implements
+            Weigher<CacheKey, String> {
+
+        @Override
+        public int weigh(CacheKey key, String value) {
+            int size = LIRS_CACHE_OVERHEAD;
+            size += key.estimateMemoryUsage();
+            size += estimateMemoryUsage(value);
+            return size;
+        }
+    }
+
+}
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/PropertyTemplate.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/PropertyTemplate.java
index 998c59c..da1a10e 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/PropertyTemplate.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/PropertyTemplate.java
@@ -18,12 +18,14 @@
  */
 package org.apache.jackrabbit.oak.segment;
 
-import javax.annotation.Nonnull;
-
 import static com.google.common.base.Preconditions.checkNotNull;
+import static org.apache.jackrabbit.oak.segment.CacheWeights.OBJECT_HEADER_SIZE;
+
+import javax.annotation.Nonnull;
 
 import org.apache.jackrabbit.oak.api.PropertyState;
 import org.apache.jackrabbit.oak.api.Type;
+import org.apache.jackrabbit.oak.commons.StringUtils;
 
 import com.google.common.collect.ComparisonChain;
 
@@ -104,4 +106,8 @@ public class PropertyTemplate implements Comparable<PropertyTemplate> {
         return name + "(" + type + ")";
     }
 
+    public int estimateMemoryUsage() {
+        return OBJECT_HEADER_SIZE + 16 + StringUtils.estimateMemoryUsage(name);
+    }
+
 }
\ No newline at end of file
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/ReaderCache.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/ReaderCache.java
index 3dbe4d3..f33e765 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/ReaderCache.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/ReaderCache.java
@@ -20,17 +20,18 @@
 package org.apache.jackrabbit.oak.segment;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static org.apache.jackrabbit.oak.segment.CacheWeights.OBJECT_HEADER_SIZE;
 
 import java.util.Arrays;
 
 import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
-import com.google.common.base.Function;
-import com.google.common.cache.Weigher;
 import org.apache.jackrabbit.oak.cache.CacheLIRS;
 import org.apache.jackrabbit.oak.cache.CacheStats;
-import org.apache.jackrabbit.oak.cache.EmpiricalWeigher;
+
+import com.google.common.base.Function;
+import com.google.common.cache.Weigher;
 
 /**
  * A cache consisting of a fast and slow component. The fast cache for small items is based
@@ -39,12 +40,7 @@ import org.apache.jackrabbit.oak.cache.EmpiricalWeigher;
 public abstract class ReaderCache<T> {
 
     @Nonnull
-    private final Weigher<CacheKey<T>, T> weigher = new Weigher<CacheKey<T>, T>() {
-        @Override
-        public int weigh(CacheKey<T> key, T value) {
-            return getEntryWeight(value);
-        }
-    };
+    private final Weigher<CacheKey, T> weigher;
 
     @Nonnull
     private final String name;
@@ -59,7 +55,7 @@ public abstract class ReaderCache<T> {
      * The slower (LIRS) cache.
      */
     @Nonnull
-    private final CacheLIRS<CacheKey<T>, T> cache;
+    private final CacheLIRS<CacheKey, T> cache;
 
     /**
      * Create a new string cache.
@@ -67,11 +63,14 @@ public abstract class ReaderCache<T> {
      * @param maxWeight the maximum memory in bytes.
      * @param averageWeight  an estimate for the average weight of the elements in the
      *                       cache. See {@link CacheLIRS#setAverageMemory(int)}.
+     * @param weigher   Needed to provide an estimation of the cache weight in memory
      */
-    protected ReaderCache(long maxWeight, int averageWeight, @Nonnull String name) {
+    protected ReaderCache(long maxWeight, int averageWeight,
+            @Nonnull String name, @Nonnull Weigher<CacheKey, T> weigher) {
         this.name = checkNotNull(name);
+        this.weigher = checkNotNull(weigher);
         fastCache = new FastCache<>();
-        cache = CacheLIRS.<CacheKey<T>, T>newBuilder()
+        cache = CacheLIRS.<CacheKey, T>newBuilder()
                 .module(name)
                 .maximumWeight(maxWeight)
                 .averageWeight(averageWeight)
@@ -113,7 +112,7 @@ public abstract class ReaderCache<T> {
         if (value != null) {
             return value;
         }
-        CacheKey<T> key = new CacheKey<>(hash, msb, lsb, offset);
+        CacheKey key = new CacheKey(hash, msb, lsb, offset);
         value = cache.getIfPresent(key);
         if (value == null) {
             value = loader.apply(offset);
@@ -137,12 +136,6 @@ public abstract class ReaderCache<T> {
     }
 
     /**
-     * Estimation includes the key's overhead, see {@link EmpiricalWeigher} for
-     * an example
-     */
-    protected abstract int getEntryWeight(T value);
-
-    /**
      * Determine whether the entry is small, in which case it can be kept in the fast cache.
      */
     protected abstract boolean isSmall(T value);
@@ -192,7 +185,7 @@ public abstract class ReaderCache<T> {
 
     }
 
-    private static class CacheKey<T> {
+    static class CacheKey {
         private final int hash;
         private final long msb, lsb;
         private final int offset;
@@ -217,7 +210,7 @@ public abstract class ReaderCache<T> {
             if (!(other instanceof ReaderCache.CacheKey)) {
                 return false;
             }
-            CacheKey<?> o = (CacheKey<?>) other;
+            CacheKey o = (CacheKey) other;
             return o.hash == hash && o.msb == msb && o.lsb == lsb &&
                     o.offset == offset;
         }
@@ -229,6 +222,9 @@ public abstract class ReaderCache<T> {
                 '+' + Integer.toHexString(offset);
         }
 
+        public int estimateMemoryUsage() {
+            return OBJECT_HEADER_SIZE + 32;
+        }
     }
 
     private static class FastCacheEntry<T> {
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordCache.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordCache.java
index 60d5fd5..30c62a0 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordCache.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordCache.java
@@ -19,6 +19,8 @@
 
 package org.apache.jackrabbit.oak.segment;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import java.util.LinkedHashMap;
 import java.util.Map;
 
@@ -27,6 +29,7 @@ import javax.annotation.Nonnull;
 
 import com.google.common.base.Supplier;
 import com.google.common.cache.CacheStats;
+import com.google.common.cache.Weigher;
 
 /**
  * Partial mapping of keys of type {@code T} to values of type {@link RecordId}. This is
@@ -56,9 +59,12 @@ public abstract class RecordCache<T> {
      */
     public abstract long size();
 
+    public abstract long estimateCurrentWeight();
+
     /**
      * @return  access statistics for this cache
      */
+    @Nonnull
     public CacheStats getStats() {
         return new CacheStats(hitCount, missCount, loadCount, 0, 0, evictionCount);
     }
@@ -76,11 +82,28 @@ public abstract class RecordCache<T> {
         if (size <= 0) {
             return new Empty<>();
         } else {
-            return new Default<>(size);
+            return new Default<>(size, CacheWeights.<T, RecordId> noopWeigher());
         }
     }
 
     /**
+     * @param size size of the cache
+     * @param weigher   Needed to provide an estimation of the cache weight in memory
+     * @return  A factory returning {@code RecordCache} instances of the given {@code size}
+     *          when invoked.
+     * @see #newRecordCache(int)
+     */
+    @Nonnull
+    public static <T> Supplier<RecordCache<T>> factory(int size, @Nonnull Weigher<T, RecordId> weigher) {
+        if (size <= 0) {
+            return Empty.emptyFactory();
+        } else {
+            return Default.defaultFactory(size, checkNotNull(weigher));
+        }
+    }
+
+    /**
+     * @param size size of the cache
      * @return  A factory returning {@code RecordCache} instances of the given {@code size}
      *          when invoked.
      * @see #newRecordCache(int)
@@ -90,7 +113,7 @@ public abstract class RecordCache<T> {
         if (size <= 0) {
             return Empty.emptyFactory();
         } else {
-            return Default.defaultFactory(size);
+            return Default.defaultFactory(size, CacheWeights.<T, RecordId> noopWeigher());
         }
     }
 
@@ -117,27 +140,42 @@ public abstract class RecordCache<T> {
         public long size() {
             return 0;
         }
+
+        @Override
+        public long estimateCurrentWeight() {
+            return -1;
+        }
     }
 
     private static class Default<T> extends RecordCache<T> {
+
+        @Nonnull
         private final Map<T, RecordId> records;
 
-        static final <T> Supplier<RecordCache<T>> defaultFactory(final int size) {
+        @Nonnull
+        private final Weigher<T, RecordId> weigher;
+
+        private long weight = -1;
+
+        static final <T> Supplier<RecordCache<T>> defaultFactory(final int size, @Nonnull final Weigher<T, RecordId> weigher) {
             return new Supplier<RecordCache<T>>() {
                 @Override
                 public RecordCache<T> get() {
-                    return new Default<>(size);
+                    return new Default<>(size, checkNotNull(weigher));
                 }
             };
         }
 
-        Default(final int size) {
+        Default(final int size, @Nonnull final Weigher<T, RecordId> weigher) {
+            this.weigher = checkNotNull(weigher);
             records = new LinkedHashMap<T, RecordId>(size * 4 / 3, 0.75f, true) {
                 @Override
                 protected boolean removeEldestEntry(Map.Entry<T, RecordId> eldest) {
                     boolean remove = super.size() > size;
                     if (remove) {
                         Default.super.evictionCount++;
+                        weight -= weigher.weigh(eldest.getKey(),
+                                eldest.getValue());
                     }
                     return remove;
                 }
@@ -148,6 +186,9 @@ public abstract class RecordCache<T> {
         public synchronized void put(@Nonnull T key, @Nonnull RecordId value) {
             super.loadCount++;
             records.put(key, value);
+            if (weigher != null) {
+                weight += weigher.weigh(key, value);
+            }
         }
 
         @Override
@@ -165,5 +206,10 @@ public abstract class RecordCache<T> {
         public synchronized long size() {
             return records.size();
         }
+
+        @Override
+        public long estimateCurrentWeight() {
+            return weight;
+        }
     }
 }
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordCacheStats.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordCacheStats.java
index aa4914f..d42a4a5 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordCacheStats.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordCacheStats.java
@@ -47,14 +47,19 @@ public class RecordCacheStats extends AnnotatedStandardMBean implements CacheSta
     @Nonnull
     private final Supplier<Long> elementCount;
 
+    @Nonnull
+    private final Supplier<Long> weight;
+
     private CacheStats lastSnapshot;
 
-    public RecordCacheStats(
-            @Nonnull String name, @Nonnull Supplier<CacheStats> stats, @Nonnull Supplier<Long> elementCount) {
+    public RecordCacheStats(@Nonnull String name,
+            @Nonnull Supplier<CacheStats> stats,
+            @Nonnull Supplier<Long> elementCount, @Nonnull Supplier<Long> weight) {
         super(CacheStatsMBean.class);
         this.name = checkNotNull(name);
         this.stats = checkNotNull(stats);
         this.elementCount = checkNotNull(elementCount);
+        this.weight = checkNotNull(weight);
         this.lastSnapshot = stats.get();
     }
 
@@ -145,7 +150,7 @@ public class RecordCacheStats extends AnnotatedStandardMBean implements CacheSta
 
     @Override
     public long estimateCurrentWeight() {
-        return -1;
+        return weight.get();
     }
 
     @Override
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordId.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordId.java
index f4b476a..ad42898 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordId.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/RecordId.java
@@ -18,11 +18,9 @@
  */
 package org.apache.jackrabbit.oak.segment;
 
-import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static java.lang.Integer.parseInt;
-import static org.apache.jackrabbit.oak.segment.Segment.RECORD_ALIGN_BITS;
-import static org.apache.jackrabbit.oak.segment.Segment.RECORD_ID_BYTES;
+import static org.apache.jackrabbit.oak.segment.CacheWeights.OBJECT_HEADER_SIZE;
 
 import java.util.UUID;
 import java.util.regex.Matcher;
@@ -150,4 +148,8 @@ public final class RecordId implements Comparable<RecordId> {
         }
     }
 
+    public int estimateMemoryUsage() {
+        return OBJECT_HEADER_SIZE + 16 + segmentId.estimateMemoryUsage();
+    }
+
 }
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/Segment.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/Segment.java
index c09d38b..5e75349 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/Segment.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/Segment.java
@@ -24,6 +24,7 @@ import static com.google.common.base.Preconditions.checkPositionIndexes;
 import static com.google.common.base.Preconditions.checkState;
 import static java.util.Arrays.fill;
 import static org.apache.jackrabbit.oak.commons.IOUtils.closeQuietly;
+import static org.apache.jackrabbit.oak.segment.CacheWeights.OBJECT_HEADER_SIZE;
 import static org.apache.jackrabbit.oak.segment.RecordNumbers.EMPTY_RECORD_NUMBERS;
 import static org.apache.jackrabbit.oak.segment.SegmentId.isDataSegmentId;
 import static org.apache.jackrabbit.oak.segment.SegmentVersion.LATEST_VERSION;
@@ -44,15 +45,17 @@ import java.util.UUID;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
-import com.google.common.base.Charsets;
-import com.google.common.collect.AbstractIterator;
 import org.apache.commons.io.HexDump;
 import org.apache.commons.io.output.ByteArrayOutputStream;
 import org.apache.jackrabbit.oak.api.PropertyState;
 import org.apache.jackrabbit.oak.api.Type;
+import org.apache.jackrabbit.oak.commons.StringUtils;
 import org.apache.jackrabbit.oak.plugins.memory.PropertyStates;
 import org.apache.jackrabbit.oak.segment.RecordNumbers.Entry;
 
+import com.google.common.base.Charsets;
+import com.google.common.collect.AbstractIterator;
+
 /**
  * A list of records.
  * <p>
@@ -714,4 +717,28 @@ public class Segment {
         }
     }
 
+    /**
+     * Estimate of how much memory this instance would occupy in the segment
+     * cache.
+     */
+    public int estimateMemoryUsage() {
+        int size = OBJECT_HEADER_SIZE + 76;
+        size += 56; // 7 refs x 8 bytes
+
+        if (id.isDataSegmentId()) {
+            int recordNumberCount = getRecordNumberCount();
+            size += 5 * recordNumberCount;
+
+            int referencedSegmentIdCount = getReferencedSegmentIdCount();
+            size += 8 * referencedSegmentIdCount;
+
+            size += StringUtils.estimateMemoryUsage(info);
+        }
+        if (!data.isDirect()) {
+            // seems to overreport by 100+ bytes
+            size += size();
+        }
+        size += id.estimateMemoryUsage();
+        return size;
+    }
 }
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/SegmentCache.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/SegmentCache.java
index ea78b2c..f954f35 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/SegmentCache.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/SegmentCache.java
@@ -24,12 +24,14 @@ import java.util.concurrent.ExecutionException;
 
 import javax.annotation.Nonnull;
 
+import org.apache.jackrabbit.oak.cache.CacheStats;
+import org.apache.jackrabbit.oak.segment.CacheWeights.SegmentCacheWeigher;
+
 import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.RemovalListener;
 import com.google.common.cache.RemovalNotification;
 import com.google.common.cache.Weigher;
-import org.apache.jackrabbit.oak.cache.CacheStats;
 
 /**
  * A cache for {@link Segment} instances by their {@link SegmentId}.
@@ -47,12 +49,7 @@ import org.apache.jackrabbit.oak.cache.CacheStats;
 public class SegmentCache {
     public static final int DEFAULT_SEGMENT_CACHE_MB = 256;
 
-    private final Weigher<SegmentId, Segment> weigher = new Weigher<SegmentId, Segment>() {
-        @Override
-        public int weigh(@Nonnull SegmentId id, @Nonnull Segment segment) {
-            return 224 + segment.size();
-        }
-    };
+    private final Weigher<SegmentId, Segment> weigher = new SegmentCacheWeigher();
 
     private final long maximumWeight;
 
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/SegmentId.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/SegmentId.java
index 899ee2a..b9affeb 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/SegmentId.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/SegmentId.java
@@ -18,11 +18,14 @@
  */
 package org.apache.jackrabbit.oak.segment;
 
+import static org.apache.jackrabbit.oak.segment.CacheWeights.OBJECT_HEADER_SIZE;
+
 import java.util.UUID;
 
 import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
+import org.apache.jackrabbit.oak.commons.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -252,4 +255,11 @@ public class SegmentId implements Comparable<SegmentId> {
         return (int) lsb;
     }
 
+    public int estimateMemoryUsage() {
+        int size = OBJECT_HEADER_SIZE;
+        size += 48; // 6 fields x 8, ignoring 'gcInfo'
+        size += StringUtils.estimateMemoryUsage(gcInfo);
+        return size;
+    }
+
 }
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/StringCache.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/StringCache.java
index f3868c4..05a89ff 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/StringCache.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/StringCache.java
@@ -19,7 +19,7 @@
 
 package org.apache.jackrabbit.oak.segment;
 
-import static org.apache.jackrabbit.oak.commons.StringUtils.estimateMemoryUsage;
+import org.apache.jackrabbit.oak.segment.CacheWeights.ReaderStringCacheWeigher;
 
 public class StringCache extends ReaderCache<String> {
     /**
@@ -33,15 +33,7 @@ public class StringCache extends ReaderCache<String> {
      * @param maxSize the maximum memory in bytes.
      */
     StringCache(long maxSize) {
-        super(maxSize, 250, "String Cache");
-    }
-
-    @Override
-    protected int getEntryWeight(String string) {
-        int size = 168; // overhead for each cache entry
-        size += 40; // key
-        size += estimateMemoryUsage(string); // value
-        return size;
+        super(maxSize, 250, "String Cache", new ReaderStringCacheWeigher());
     }
 
     @Override
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/Template.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/Template.java
index 2055f28..881841b 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/Template.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/Template.java
@@ -21,8 +21,10 @@ package org.apache.jackrabbit.oak.segment;
 import static com.google.common.base.Preconditions.checkElementIndex;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
+import static org.apache.jackrabbit.oak.api.Type.STRING;
 import static org.apache.jackrabbit.oak.plugins.memory.EmptyNodeState.MISSING_NODE;
 import static org.apache.jackrabbit.oak.segment.Segment.RECORD_ID_BYTES;
+import static org.apache.jackrabbit.oak.segment.CacheWeights.OBJECT_HEADER_SIZE;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -36,6 +38,7 @@ import com.google.common.base.Objects;
 import com.google.common.collect.Lists;
 import org.apache.jackrabbit.oak.api.PropertyState;
 import org.apache.jackrabbit.oak.api.Type;
+import org.apache.jackrabbit.oak.commons.StringUtils;
 import org.apache.jackrabbit.oak.plugins.memory.MemoryChildNodeEntry;
 import org.apache.jackrabbit.oak.spi.state.ChildNodeEntry;
 import org.apache.jackrabbit.oak.spi.state.NodeState;
@@ -347,4 +350,29 @@ public class Template {
         }
     }
 
+    public int estimateMemoryUsage() {
+        int size = OBJECT_HEADER_SIZE;
+        size += 48;
+        size += StringUtils.estimateMemoryUsage(childName);
+        size += estimateMemoryUsage(mixinTypes);
+        size += estimateMemoryUsage(primaryType);
+        for (PropertyTemplate property : properties) {
+            size += property.estimateMemoryUsage();
+        }
+        return size;
+    }
+
+    private static int estimateMemoryUsage(PropertyState propertyState) {
+        if (propertyState == null) {
+            return 0;
+        }
+        int size = OBJECT_HEADER_SIZE;
+        size += StringUtils.estimateMemoryUsage(propertyState.getName());
+        for (int k = 0; k < propertyState.count(); k++) {
+            String s = propertyState.getValue(STRING, k);
+            size += StringUtils.estimateMemoryUsage(s);
+        }
+        return size;
+    }
+
 }
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/TemplateCache.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/TemplateCache.java
index 8b45545..e3133fe 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/TemplateCache.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/TemplateCache.java
@@ -19,10 +19,8 @@
 
 package org.apache.jackrabbit.oak.segment;
 
-import static org.apache.jackrabbit.oak.api.Type.STRING;
-
 import org.apache.jackrabbit.oak.api.PropertyState;
-import org.apache.jackrabbit.oak.commons.StringUtils;
+import org.apache.jackrabbit.oak.segment.CacheWeights.ReaderTemplateCacheWeigher;
 
 public class TemplateCache extends ReaderCache<Template> {
 
@@ -32,46 +30,7 @@ public class TemplateCache extends ReaderCache<Template> {
      * @param maxSize the maximum memory in bytes.
      */
     TemplateCache(long maxSize) {
-        super(maxSize, 250, "Template Cache");
-    }
-
-    @Override
-    protected int getEntryWeight(Template template) {
-        int size = 168; // overhead for each cache entry
-        size += 40;     // key
-
-        size += estimateMemoryUsage(template.getPrimaryType());
-        size += estimateMemoryUsage(template.getMixinTypes());
-        size += estimateMemoryUsage(template.getChildName());
-        for (PropertyTemplate property : template.getPropertyTemplates()) {
-            size += estimateMemoryUsage(property);
-        }
-        return size;
-    }
-
-    private static int estimateMemoryUsage(PropertyTemplate propertyTemplate) {
-        return 4 + // index
-            estimateMemoryUsage(propertyTemplate.getName());
-    }
-
-    private static int estimateMemoryUsage(PropertyState propertyState) {
-        if (propertyState == null) {
-            return 0;
-        }
-
-        int size = estimateMemoryUsage(propertyState.getName());
-        for (int k = 0; k < propertyState.count(); k++) {
-            size += estimateMemoryUsage(propertyState.getValue(STRING, k));
-        }
-        return size;
-    }
-
-    private static int estimateMemoryUsage(String string) {
-        if (string == null) {
-            return 0;
-        }
-
-        return StringUtils.estimateMemoryUsage(string);
+        super(maxSize, 250, "Template Cache", new ReaderTemplateCacheWeigher());
     }
 
     @Override
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/WriterCacheManager.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/WriterCacheManager.java
index 6441e8c..10571c2 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/WriterCacheManager.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/WriterCacheManager.java
@@ -296,14 +296,18 @@ public abstract class WriterCacheManager {
         @Override
         public CacheStatsMBean getStringCacheStats() {
             return new RecordCacheStats("String deduplication cache stats",
-                    accumulateRecordCacheStats(stringCaches), accumulateRecordCacheSizes(stringCaches));
+                    accumulateRecordCacheStats(stringCaches),
+                    accumulateRecordCacheSizes(stringCaches),
+                    accumulateRecordCacheWeights(stringCaches));
         }
 
         @CheckForNull
         @Override
         public CacheStatsMBean getTemplateCacheStats() {
             return new RecordCacheStats("Template deduplication cache stats",
-                    accumulateRecordCacheStats(templateCaches), accumulateRecordCacheSizes(templateCaches));
+                    accumulateRecordCacheStats(templateCaches),
+                    accumulateRecordCacheSizes(templateCaches),
+                    accumulateRecordCacheWeights(templateCaches));
         }
 
         @Nonnull
@@ -336,6 +340,21 @@ public abstract class WriterCacheManager {
             };
         }
 
+        @Nonnull
+        public static <T> Supplier<Long> accumulateRecordCacheWeights(
+                final Iterable<RecordCache<T>> caches) {
+            return new Supplier<Long>() {
+                @Override
+                public Long get() {
+                    long size = 0;
+                    for (RecordCache<?> cache : caches) {
+                        size += cache.estimateCurrentWeight();
+                    }
+                    return size;
+                }
+            };
+        }
+
         @CheckForNull
         @Override
         public CacheStatsMBean getNodeCacheStats() {
@@ -351,6 +370,12 @@ public abstract class WriterCacheManager {
                         public Long get() {
                             return nodeCache.get().size();
                         }
+                    },
+                    new Supplier<Long>() {
+                        @Override
+                        public Long get() {
+                            return nodeCache.get().estimateCurrentWeight();
+                        }
                     });
         }
 
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/file/FileStoreBuilder.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/file/FileStoreBuilder.java
index dc0a5bf..7d7ad58 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/file/FileStoreBuilder.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/file/FileStoreBuilder.java
@@ -36,7 +36,9 @@ import java.io.IOException;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
-import com.google.common.base.Predicate;
+import org.apache.jackrabbit.oak.segment.CacheWeights.NodeCacheWeigher;
+import org.apache.jackrabbit.oak.segment.CacheWeights.StringCacheWeigher;
+import org.apache.jackrabbit.oak.segment.CacheWeights.TemplateCacheWeigher;
 import org.apache.jackrabbit.oak.segment.RecordCache;
 import org.apache.jackrabbit.oak.segment.RecordId;
 import org.apache.jackrabbit.oak.segment.SegmentNotFoundExceptionListener;
@@ -50,6 +52,8 @@ import org.apache.jackrabbit.oak.stats.StatisticsProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.base.Predicate;
+
 /**
  * Builder for creating {@link FileStore} instances.
  */
@@ -409,9 +413,9 @@ public class FileStoreBuilder {
 
     private static class EvictingWriteCacheManager extends WriterCacheManager.Default {
         public EvictingWriteCacheManager(int stringCacheSize, int templateCacheSize, int nodeCacheSize) {
-            super(RecordCache.<String>factory(stringCacheSize),
-                RecordCache.<Template>factory(templateCacheSize),
-                PriorityCache.<String, RecordId>factory(nodeCacheSize));
+            super(RecordCache.<String>factory(stringCacheSize, new StringCacheWeigher()),
+                RecordCache.<Template>factory(templateCacheSize, new TemplateCacheWeigher()),
+                PriorityCache.<String, RecordId>factory(nodeCacheSize, new NodeCacheWeigher()));
         }
 
         void evictOldGeneration(final int newGeneration) {
diff --git a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/file/PriorityCache.java b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/file/PriorityCache.java
index 24b3992..dc2051f 100644
--- a/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/file/PriorityCache.java
+++ b/oak-segment-tar/src/main/java/org/apache/jackrabbit/oak/segment/file/PriorityCache.java
@@ -20,6 +20,7 @@
 package org.apache.jackrabbit.oak.segment.file;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
 import static java.lang.Integer.bitCount;
 import static java.lang.Integer.numberOfTrailingZeros;
 import static java.lang.Long.numberOfLeadingZeros;
@@ -29,9 +30,12 @@ import static java.util.Arrays.fill;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
+import org.apache.jackrabbit.oak.segment.CacheWeights;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Supplier;
 import com.google.common.cache.CacheStats;
+import com.google.common.cache.Weigher;
 
 /**
  * {@code PriorityCache} implements a partial mapping from keys of type {@code K} to values
@@ -65,6 +69,26 @@ public class PriorityCache<K, V> {
     private long evictionCount;
     private long size;
 
+    @Nonnull
+    private final Weigher<K, V> weigher;
+    private long weight = 0;
+
+    /**
+     * Static factory for creating new {@code PriorityCache} instances.
+     * @param size  size of the cache. Must be a power of 2.
+     * @return  a new {@code PriorityCache} instance of the given {@code size}.
+     */
+    public static <K, V> Supplier<PriorityCache<K, V>> factory(final int size, @Nonnull final Weigher<K, V> weigher) {
+        checkArgument(bitCount(size) == 1);
+        checkNotNull(weigher);
+        return new Supplier<PriorityCache<K, V>>() {
+            @Override
+            public PriorityCache<K, V> get() {
+                return new PriorityCache<>(size, weigher);
+            }
+        };
+    }
+
     /**
      * Static factory for creating new {@code PriorityCache} instances.
      * @param size  size of the cache. Must be a power of 2.
@@ -119,13 +143,26 @@ public class PriorityCache<K, V> {
      * @param rehash    Number of rehashes. Must be greater or equal to {@code 0} and
      *                  smaller than {@code 32 - numberOfTrailingZeros(size)}.
      */
-    public PriorityCache(int size, int rehash) {
+    PriorityCache(int size, int rehash) {
+        this(size, rehash, CacheWeights.<K, V> noopWeigher());
+    }
+
+    /**
+     * Create a new instance of the given {@code size}. {@code rehash} specifies the number
+     * of rehashes to resolve a clash.
+     * @param size      Size of the cache. Must be a power of {@code 2}.
+     * @param rehash    Number of rehashes. Must be greater or equal to {@code 0} and
+     *                  smaller than {@code 32 - numberOfTrailingZeros(size)}.
+     * @param weigher   Needed to provide an estimation of the cache weight in memory
+     */
+    public PriorityCache(int size, int rehash, @Nonnull Weigher<K, V> weigher) {
         checkArgument(bitCount(size) == 1);
         checkArgument(rehash >= 0);
         checkArgument(rehash < 32 - numberOfTrailingZeros(size));
         this.rehash = rehash;
         entries = new Entry<?,?>[size];
         fill(entries, Entry.NULL);
+        this.weigher = checkNotNull(weigher);
     }
 
     /**
@@ -133,6 +170,10 @@ public class PriorityCache<K, V> {
      * the maximum number allowed by the given {@code size}. ({@code 31 - numberOfTrailingZeros(size)}.
      * @param size      Size of the cache. Must be a power of {@code 2}.
      */
+    public PriorityCache(int size, @Nonnull Weigher<K, V> weigher) {
+        this(size, 31 - numberOfTrailingZeros(size), weigher);
+    }
+
     public PriorityCache(int size) {
         this(size, 31 - numberOfTrailingZeros(size));
     }
@@ -190,7 +231,8 @@ public class PriorityCache<K, V> {
 
         if (index >= 0) {
             Entry<?, ?> old = entries[index];
-            entries[index] = new Entry<>(key, value, generation, initialCost);
+            Entry<?, ?> newE = new Entry<>(key, value, generation, initialCost);
+            entries[index] = newE;
             loadCount++;
             costs[initialCost - Byte.MIN_VALUE]++;
             if (old != Entry.NULL) {
@@ -199,9 +241,11 @@ public class PriorityCache<K, V> {
                     evictions[old.cost - Byte.MIN_VALUE]++;
                     evictionCount++;
                 }
+                weight -= weighEntry(old);
             } else {
                 size++;
             }
+            weight += weighEntry(newE);
             return true;
         } else {
             return false;
@@ -247,10 +291,16 @@ public class PriorityCache<K, V> {
             if (entry != Entry.NULL && purge.apply(entry.generation)) {
                 entries[i] = Entry.NULL;
                 size--;
+                weight -= weighEntry(entry);
             }
         }
     }
 
+    @SuppressWarnings("unchecked")
+    private int weighEntry(Entry<?, ?> entry) {
+        return weigher.weigh((K) entry.key, (V) entry.value);
+    }
+
     @Override
     public synchronized String toString() {
         return "PriorityCache" +
@@ -278,4 +328,8 @@ public class PriorityCache<K, V> {
         return new CacheStats(hitCount, missCount, loadCount, 0, 0, evictionCount);
     }
 
+    public long estimateCurrentWeight() {
+        return weight;
+    }
+
 }
diff --git a/oak-segment-tar/src/test/java/org/apache/jackrabbit/oak/segment/CacheWeightsTest.java b/oak-segment-tar/src/test/java/org/apache/jackrabbit/oak/segment/CacheWeightsTest.java
new file mode 100644
index 0000000..51f14f3
--- /dev/null
+++ b/oak-segment-tar/src/test/java/org/apache/jackrabbit/oak/segment/CacheWeightsTest.java
@@ -0,0 +1,457 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.jackrabbit.oak.segment;
+
+import static org.apache.jackrabbit.oak.segment.Segment.GC_GENERATION_OFFSET;
+import static org.apache.jackrabbit.oak.segment.SegmentVersion.LATEST_VERSION;
+import static org.junit.Assume.assumeTrue;
+
+import java.nio.ByteBuffer;
+import java.util.AbstractMap.SimpleImmutableEntry;
+import java.util.Map.Entry;
+import java.util.UUID;
+
+import org.apache.commons.lang.RandomStringUtils;
+import org.apache.jackrabbit.oak.cache.CacheStats;
+import org.apache.jackrabbit.oak.commons.StringUtils;
+import org.apache.jackrabbit.oak.segment.CacheWeights.StringCacheWeigher;
+import org.apache.jackrabbit.oak.segment.file.PriorityCache;
+import org.apache.jackrabbit.oak.segment.memory.MemoryStore;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Supplier;
+
+/**
+ * Test/Utility class to measure size in memory for common segment-tar objects.
+ * <p>
+ * The test is <b>disabled</b> by default, to run it you need to set the
+ * {@code CacheWeightsTest} system property:<br>
+ * {@code mv clean test -Dtest=CacheWeightsTest -DCacheWeightsTest=true -Dtest.opts.memory=-Xmx2G}
+ * </p>
+ * <p>
+ * To collect the results check the
+ * {@code org.apache.jackrabbit.oak.segment.CacheWeightsTest-output.txt} file:<br>
+ * {@code cat target/surefire-reports/org.apache.jackrabbit.oak.segment.CacheWeightsTest-output.txt}
+ * </p>
+ */
+public class CacheWeightsTest {
+
+    private static final Logger LOG = LoggerFactory
+            .getLogger(CacheWeightsTest.class);
+
+    private static final boolean ENABLED = Boolean
+            .getBoolean(CacheWeightsTest.class.getSimpleName());
+
+    // http://www.javaworld.com/article/2077496/testing-debugging/java-tip-130--do-you-know-your-data-size-.html
+    // http://www.javaspecialists.eu/archive/Issue029.html
+    // http://www.slideshare.net/cnbailey/memory-efficient-java
+
+    /*-
+     * Open JDK's JOL report on various segment classes:
+
+    org.apache.jackrabbit.oak.segment.RecordId object internals:
+    OFFSET  SIZE      TYPE DESCRIPTION                    VALUE
+      0    12           (object header)                N/A
+     12     4       int RecordId.offset                N/A
+     16     4 SegmentId RecordId.segmentId             N/A
+     20     4           (loss due to the next object alignment)
+    Instance size: 24 bytes
+    Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
+
+    org.apache.jackrabbit.oak.segment.SegmentId object internals:
+    OFFSET  SIZE         TYPE DESCRIPTION                    VALUE
+      0    12              (object header)                N/A
+     12     4          int SegmentId.gcGeneration         N/A
+     16     8         long SegmentId.msb                  N/A
+     24     8         long SegmentId.lsb                  N/A
+     32     8         long SegmentId.creationTime         N/A
+     40     4 SegmentStore SegmentId.store                N/A
+     44     4       String SegmentId.gcInfo               N/A
+     48     4      Segment SegmentId.segment              N/A
+     52     4              (loss due to the next object alignment)
+    Instance size: 56 bytes
+    Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
+
+    org.apache.jackrabbit.oak.segment.Segment object internals:
+    OFFSET  SIZE              TYPE DESCRIPTION                    VALUE
+      0    12                   (object header)                N/A
+     12     4      SegmentStore Segment.store                  N/A
+     16     4     SegmentReader Segment.reader                 N/A
+     20     4         SegmentId Segment.id                     N/A
+     24     4        ByteBuffer Segment.data                   N/A
+     28     4    SegmentVersion Segment.version                N/A
+     32     4     RecordNumbers Segment.recordNumbers          N/A
+     36     4 SegmentReferences Segment.segmentReferences      N/A
+     40     4            String Segment.info                   N/A
+     44     4                   (loss due to the next object alignment)
+    Instance size: 48 bytes
+    Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
+
+    org.apache.jackrabbit.oak.segment.Template object internals:
+    OFFSET  SIZE               TYPE DESCRIPTION                    VALUE
+      0    12                    (object header)                N/A
+     12     4      SegmentReader Template.reader                N/A
+     16     4      PropertyState Template.primaryType           N/A
+     20     4      PropertyState Template.mixinTypes            N/A
+     24     4 PropertyTemplate[] Template.properties            N/A
+     28     4             String Template.childName             N/A
+    Instance size: 32 bytes
+    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
+
+     */
+
+    private MemoryStore store;
+
+    @BeforeClass
+    public static void assumptions() {
+        assumeTrue(ENABLED);
+    }
+
+    @Before
+    public void setup() throws Exception {
+        store = new MemoryStore();
+    }
+
+    @Test
+    public void testObjects() {
+        final int count = 1000000;
+
+        Supplier<Entry<Object, Long[]>> factory = new Supplier<Entry<Object, Long[]>>() {
+
+            @Override
+            public Entry<Object, Long[]> get() {
+
+                Object[] objects = new Object[count];
+                for (int i = 0; i < count; ++i) {
+                    Object o = new Object();
+                    objects[i] = o;
+                }
+                long weight = CacheWeights.OBJECT_HEADER_SIZE * count;
+                return new SimpleImmutableEntry<Object, Long[]>(objects,
+                        new Long[] { (long) count, weight });
+            }
+        };
+        runTest(factory, "Object[x" + count + "]");
+    }
+
+    @Test
+    public void testSegmentIds() {
+        runSegmentIds(1000000, false);
+    }
+
+    @Test
+    public void testSegmentIdsWGc() {
+        runSegmentIds(1000000, true);
+    }
+
+    private void runSegmentIds(final int count, final boolean gcInfo) {
+        Supplier<Entry<Object, Long[]>> factory = new Supplier<Entry<Object, Long[]>>() {
+
+            @Override
+            public Entry<Object, Long[]> get() {
+                long weight = 0;
+                Object[] objects = new Object[count];
+                for (int i = 0; i < count; ++i) {
+                    SegmentId o = randomSegmentId(gcInfo);
+                    weight += o.estimateMemoryUsage();
+                    objects[i] = o;
+                }
+                return new SimpleImmutableEntry<Object, Long[]>(objects,
+                        new Long[] { (long) count, weight });
+            }
+        };
+        String name = "SegmentId";
+        if (gcInfo) {
+            name += "[x" + count + "|GCInfo]";
+        } else {
+            name += "[x" + count + "]";
+        }
+        runTest(factory, name);
+    }
+
+    @Test
+    public void testRecordIds() {
+        runRecordIds(1000000, false);
+    }
+
+    @Test
+    public void testRecordIdsWGc() {
+        runRecordIds(1000000, true);
+    }
+
+    private void runRecordIds(final int count, final boolean gcInfo) {
+        Supplier<Entry<Object, Long[]>> factory = new Supplier<Entry<Object, Long[]>>() {
+
+            @Override
+            public Entry<Object, Long[]> get() {
+                long weight = 0;
+                Object[] objects = new Object[count];
+                for (int i = 0; i < count; ++i) {
+                    RecordId o = randomRecordId(gcInfo);
+                    weight += o.estimateMemoryUsage();
+                    objects[i] = o;
+                }
+                return new SimpleImmutableEntry<Object, Long[]>(objects,
+                        new Long[] { (long) count, weight });
+            }
+        };
+        String name = "RecordId";
+        if (gcInfo) {
+            name += "[x" + count + "|GCInfo]";
+        } else {
+            name += "[x" + count + "]";
+        }
+        runTest(factory, name);
+    }
+
+    @Test
+    public void testStringCache() {
+        final int count = 1000000;
+        final int keySize = 96;
+        final boolean gcInfo = true;
+
+        Supplier<Entry<Object, Long[]>> factory = new Supplier<Entry<Object, Long[]>>() {
+
+            @Override
+            public Entry<Object, Long[]> get() {
+                RecordCache<String> cache = RecordCache.factory(count,
+                        new StringCacheWeigher()).get();
+                for (int i = 0; i < count; ++i) {
+                    String k = randomString(keySize);
+                    RecordId v = randomRecordId(gcInfo);
+                    cache.put(k, v);
+                }
+                long weight = cache.estimateCurrentWeight();
+                return new SimpleImmutableEntry<Object, Long[]>(cache,
+                        new Long[] { (long) count, weight });
+            }
+        };
+        runTest(factory, "StringCache[x" + count
+                + "|RecordCache<String, RecordId>]");
+    }
+
+    @Test
+    public void testNodeCache() {
+        final int count = 1000000;
+        // key usually is a stableid, see SegmentNodeState#getStableId
+        // 2fdd370e-423c-43d6-aad7-6e336c551a38:xxxxxx
+        final int keySize = 43;
+        final boolean gcInfo = true;
+
+        Supplier<Entry<Object, Long[]>> factory = new Supplier<Entry<Object, Long[]>>() {
+
+            @Override
+            public Entry<Object, Long[]> get() {
+                int size = (int) PriorityCache.nextPowerOfTwo(count);
+                PriorityCache<String, RecordId> cache = PriorityCache
+                        .<String, RecordId> factory(size,
+                                new CacheWeights.NodeCacheWeigher()).get();
+
+                for (int i = 0; i < count; ++i) {
+                    String k = randomString(keySize);
+                    RecordId v = randomRecordId(gcInfo);
+                    cache.put(k, v, 0, (byte) 0);
+                }
+                long weight = cache.estimateCurrentWeight();
+                return new SimpleImmutableEntry<Object, Long[]>(cache,
+                        new Long[] { (long) count, weight });
+            }
+        };
+        runTest(factory, "NodeCache[x" + count
+                + "|PriorityCache<String, RecordId>]");
+    }
+
+    @Test
+    public void testSegments() {
+        final int count = 10000;
+        final int bufferSize = 5 * 1024;
+
+        Supplier<Entry<Object, Long[]>> factory = new Supplier<Entry<Object, Long[]>>() {
+
+            @Override
+            public Entry<Object, Long[]> get() {
+
+                long weight = 0;
+                Object[] objects = new Object[count];
+                for (int i = 0; i < count; ++i) {
+                    Segment o = randomSegment(bufferSize);
+                    weight += o.estimateMemoryUsage();
+                    objects[i] = o;
+                }
+                return new SimpleImmutableEntry<Object, Long[]>(objects,
+                        new Long[] { (long) count, weight });
+            }
+        };
+        runTest(factory, "Segment[x" + count + "|" + bufferSize + "]");
+    }
+
+    @Test
+    public void testSegmentCache() {
+        final int count = 10000;
+        final int cacheSizeMB = 100;
+        final int bufferSize = 5 * 1024;
+
+        Supplier<Entry<Object, Long[]>> factory = new Supplier<Entry<Object, Long[]>>() {
+
+            @Override
+            public Entry<Object, Long[]> get() {
+                SegmentCache cache = new SegmentCache(cacheSizeMB);
+                for (int i = 0; i < count; ++i) {
+                    Segment segment = randomSegment(bufferSize);
+                    cache.putSegment(segment);
+                }
+                CacheStats stats = cache.getCacheStats();
+                long elements = stats.getElementCount();
+                long weight = stats.estimateCurrentWeight();
+                return new SimpleImmutableEntry<Object, Long[]>(cache,
+                        new Long[] { elements, weight });
+            }
+        };
+        runTest(factory, "SegmentCache[x" + cacheSizeMB + "MB|" + bufferSize
+                + "|Cache<SegmentId, Segment>]");
+    }
+
+    @Test
+    public void testStrings() {
+        final int count = 10000;
+        final int length = 256;
+
+        Supplier<Entry<Object, Long[]>> factory = new Supplier<Entry<Object, Long[]>>() {
+
+            @Override
+            public Entry<Object, Long[]> get() {
+
+                long weight = 0;
+                Object[] objects = new Object[count];
+                for (int i = 0; i < count; ++i) {
+                    String s = randomString(length);
+                    weight += StringUtils.estimateMemoryUsage(s);
+                    objects[i] = s;
+                }
+                return new SimpleImmutableEntry<Object, Long[]>(objects,
+                        new Long[] { (long) count, weight });
+            }
+        };
+        runTest(factory, "String[x" + count + "|" + length + "]");
+    }
+
+    private SegmentId randomSegmentId(boolean withGc) {
+        UUID u = UUID.randomUUID();
+        SegmentId id = new SegmentId(store, u.getMostSignificantBits(),
+                u.getLeastSignificantBits());
+        if (withGc) {
+            id.reclaimed(randomString(80));
+        }
+        return id;
+    }
+
+    private RecordId randomRecordId(boolean withGc) {
+        return new RecordId(randomSegmentId(withGc), 128);
+    }
+
+    private Segment randomSegment(int bufferSize) {
+        byte[] buffer = new byte[bufferSize];
+        buffer[0] = '0';
+        buffer[1] = 'a';
+        buffer[2] = 'K';
+        buffer[3] = SegmentVersion.asByte(LATEST_VERSION);
+        buffer[4] = 0; // reserved
+        buffer[5] = 0; // refcount
+
+        int generation = 0;
+        buffer[GC_GENERATION_OFFSET] = (byte) (generation >> 24);
+        buffer[GC_GENERATION_OFFSET + 1] = (byte) (generation >> 16);
+        buffer[GC_GENERATION_OFFSET + 2] = (byte) (generation >> 8);
+        buffer[GC_GENERATION_OFFSET + 3] = (byte) generation;
+
+        ByteBuffer data = ByteBuffer.wrap(buffer);
+        SegmentId id = randomSegmentId(false);
+        Segment segment = new Segment(store, store.getReader(), id, data);
+
+        //
+        // TODO check impact of MutableRecordNumbers overhead of 65k bytes
+        //
+        // MutableRecordNumbers recordNumbers = new MutableRecordNumbers();
+        // MutableSegmentReferences segmentReferences = new
+        // MutableSegmentReferences();
+        // String metaInfo = "{\"wid\":\"" + wid + '"' + ",\"sno\":" + 0
+        // + ",\"t\":" + currentTimeMillis() + "}";
+        // segment = new Segment(store, store.getReader(), buffer,
+        // recordNumbers, segmentReferences, metaInfo);
+
+        return segment;
+    }
+
+    private static String randomString(int lenght) {
+        return RandomStringUtils.randomAlphanumeric(lenght);
+    }
+
+    @SuppressWarnings("unused")
+    private static void runTest(Supplier<Entry<Object, Long[]>> factory,
+            String name) {
+
+        long start = memory();
+        Entry<Object, Long[]> e = factory.get();
+        Object object = e.getKey(); // prevent gc
+        long count = e.getValue()[0];
+        long weight = e.getValue()[1];
+        long end = memory();
+
+        long delta = end - start;
+        long itemH = delta / count;
+        long itemW = weight / count;
+
+        LOG.info(":: {} Test", name);
+        LOG.info("heap delta is       {}, {} bytes per item ({} -> {})", delta,
+                itemH, start, end);
+        LOG.info("estimated weight is {}, {} bytes per item", weight, itemW);
+        if (itemW > itemH * 1.1) {
+            LOG.info("*warn* estimated weight is over 10% bigger than heap based weight");
+        }
+        if (itemW * 1.1 < itemH) {
+            LOG.info("*warn* estimated weight is over 10% smaller than heap based weight");
+        }
+    }
+
+    private static long memory() {
+        gc();
+        return Runtime.getRuntime().totalMemory()
+                - Runtime.getRuntime().freeMemory();
+    }
+
+    private static void gc() {
+        for (int i = 0; i < 10; i++) {
+            System.gc();
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+}
diff --git a/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/CopyVersionHistoryTest.java b/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/CopyVersionHistoryTest.java
index 68c2143..5038c9c 100644
--- a/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/CopyVersionHistoryTest.java
+++ b/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/CopyVersionHistoryTest.java
@@ -252,6 +252,11 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest {
 
         assertMissingHistories(session,
                 VERSIONABLES_OLD, VERSIONABLES_OLD_ORPHANED, VERSIONABLES_YOUNG, VERSIONABLES_YOUNG_ORPHANED);
+
+ //       System.err.println(session.getNode("/jcr:system"));
+ //       System.err.println(session.getNode("/jcr:system/jcr:versionStorage"));
+        // assertNotNull(session.getNode("/jcr:system/jcr:versionStorage").getPrimaryNodeType());
+
     }
 
     protected Session performCopy(VersionCopySetup setup) throws RepositoryException, IOException {
@@ -394,4 +399,40 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest {
         // after restoring, the paths should be still versionable
         assertVersionablePaths(session, names);
     }
+
+    @Test
+    public void dontCopyVersionHistoryMixed() throws RepositoryException, IOException {
+        // first don't copy version history, then copy for some items only
+
+        Session session = performCopy(new VersionCopySetup() {
+            @Override
+            public void setup(VersionCopyConfiguration config) {
+                config.setCopyVersions(null);
+                config.setCopyOrphanedVersions(null);
+            }
+        });
+
+        assertMissingHistories(session,
+                VERSIONABLES_OLD, VERSIONABLES_OLD_ORPHANED, VERSIONABLES_YOUNG, VERSIONABLES_YOUNG_ORPHANED);
+
+        System.err.println(session.getNode("/jcr:system"));
+        System.err.println(session.getNode("/jcr:system/jcr:versionStorage"));
+
+        session = performCopy(new VersionCopySetup() {
+            @Override
+            public void setup(VersionCopyConfiguration config) {
+                config.setCopyVersions(betweenHistories);
+                config.setCopyOrphanedVersions(null);
+            }
+        });
+        assertVersionableProperties(session, VERSIONABLES_YOUNG);
+        assertExistingHistories(session, VERSIONABLES_YOUNG);
+        assertVersionablePaths(session, VERSIONABLES_YOUNG);
+        assertMissingHistories(session, VERSIONABLES_OLD, VERSIONABLES_OLD_ORPHANED, VERSIONABLES_YOUNG_ORPHANED);
+        assertVersionsCanBeRestored(session, VERSIONABLES_YOUNG);
+        
+        System.err.println(session.getNode("/jcr:system"));
+        System.err.println(session.getNode("/jcr:system/jcr:versionStorage"));
+    }
+
 }