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..09b2556 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
@@ -27,6 +27,7 @@
 
 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,6 +57,8 @@
      */
     public abstract long size();
 
+    public abstract long estimateCurrentWeight();
+
     /**
      * @return  access statistics for this cache
      */
@@ -76,7 +79,7 @@
         if (size <= 0) {
             return new Empty<>();
         } else {
-            return new Default<>(size);
+            return new Default<>(size, null);
         }
     }
 
@@ -86,11 +89,11 @@
      * @see #newRecordCache(int)
      */
     @Nonnull
-    public static <T> Supplier<RecordCache<T>> factory(int size) {
+    public static <T> Supplier<RecordCache<T>> factory(int size, Weigher<T, RecordId> weigher) {
         if (size <= 0) {
             return Empty.emptyFactory();
         } else {
-            return Default.defaultFactory(size);
+            return Default.defaultFactory(size, weigher);
         }
     }
 
@@ -117,27 +120,40 @@
         public long size() {
             return 0;
         }
+
+        @Override
+        public long estimateCurrentWeight() {
+            return -1;
+        }
     }
 
     private static class Default<T> extends RecordCache<T> {
         private final Map<T, RecordId> records;
 
-        static final <T> Supplier<RecordCache<T>> defaultFactory(final int size) {
+        private final Weigher<T, RecordId> weigher;
+        private long weight = -1;
+
+        static final <T> Supplier<RecordCache<T>> defaultFactory(final int size, final Weigher<T, RecordId> weigher) {
             return new Supplier<RecordCache<T>>() {
                 @Override
                 public RecordCache<T> get() {
-                    return new Default<>(size);
+                    return new Default<>(size, weigher);
                 }
             };
         }
 
-        Default(final int size) {
+        Default(final int size, final Weigher<T, RecordId> weigher) {
+            this.weigher = 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++;
+                        if (weigher != null) {
+                            weight -= weigher.weigh(eldest.getKey(),
+                                    eldest.getValue());
+                        }
                     }
                     return remove;
                 }
@@ -148,6 +164,9 @@
         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 +184,10 @@
         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 @@
     @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 @@
 
     @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..882be9f 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,17 +18,16 @@
  */
 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 java.util.UUID;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import javax.annotation.Nonnull;
+
+import org.apache.jackrabbit.oak.commons.StringUtils;
 
 /**
  * The record id. This includes the segment id and the offset within the
@@ -150,4 +149,10 @@
         }
     }
 
+    public int estimateMemoryUsage() {
+        int size = 112;
+        size += StringUtils.estimateMemoryUsage(getSegmentId().getGcInfo());
+        return size;
+    }
+
 }
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..45b3411 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,6 +21,7 @@
 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;
 
@@ -36,6 +37,7 @@
 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 +349,39 @@
         }
     }
 
+    public int estimateMemoryUsage() {
+        int size = 4;
+        size += estimateMemoryUsage(getPrimaryType());
+        size += estimateMemoryUsage(getMixinTypes());
+        size += estimateMemoryUsage(getChildName());
+        for (PropertyTemplate property : 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);
+    }
+
 }
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..aa724fe 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,7 @@
 
 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;
 
 public class TemplateCache extends ReaderCache<Template> {
 
@@ -39,40 +36,10 @@
     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);
-        }
+        size += template.estimateMemoryUsage();
         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);
-    }
 
     @Override
     protected boolean isSmall(Template template) {
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 56dd97e..a979d11 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
@@ -222,9 +222,9 @@
          * and {@link #DEFAULT_NODE_CACHE_SIZE}.
          */
         public Default() {
-            this(RecordCache.<String>factory(DEFAULT_STRING_CACHE_SIZE),
-                 RecordCache.<Template>factory(DEFAULT_TEMPLATE_CACHE_SIZE),
-                 PriorityCache.<String, RecordId>factory(DEFAULT_NODE_CACHE_SIZE));
+            this(RecordCache.<String>factory(DEFAULT_STRING_CACHE_SIZE, null),
+                 RecordCache.<Template>factory(DEFAULT_TEMPLATE_CACHE_SIZE, null),
+                 PriorityCache.<String, RecordId>factory(DEFAULT_NODE_CACHE_SIZE, null));
         }
 
         private static class Generations<T> implements Iterable<T> {
@@ -296,14 +296,18 @@
         @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 @@
             };
         }
 
+        @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 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..d10642b 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
@@ -21,6 +21,7 @@
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
+import static org.apache.jackrabbit.oak.commons.StringUtils.estimateMemoryUsage;
 import static org.apache.jackrabbit.oak.segment.CachingSegmentReader.DEFAULT_STRING_CACHE_MB;
 import static org.apache.jackrabbit.oak.segment.CachingSegmentReader.DEFAULT_TEMPLATE_CACHE_MB;
 import static org.apache.jackrabbit.oak.segment.SegmentCache.DEFAULT_SEGMENT_CACHE_MB;
@@ -37,6 +38,8 @@
 import javax.annotation.Nonnull;
 
 import com.google.common.base.Predicate;
+import com.google.common.cache.Weigher;
+
 import org.apache.jackrabbit.oak.segment.RecordCache;
 import org.apache.jackrabbit.oak.segment.RecordId;
 import org.apache.jackrabbit.oak.segment.SegmentNotFoundExceptionListener;
@@ -409,9 +412,9 @@
 
     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 StringCacheW()),
+                RecordCache.<Template>factory(templateCacheSize, new TemplateCacheW()),
+                PriorityCache.<String, RecordId>factory(nodeCacheSize, new NodeCacheW()));
         }
 
         void evictOldGeneration(final int newGeneration) {
@@ -432,4 +435,37 @@
             });
         }
     }
+
+    private static class StringCacheW implements Weigher<String, RecordId> {
+
+        @Override
+        public int weigh(String key, RecordId value) {
+            int size = 32;
+            size += estimateMemoryUsage(key);
+            size += value.estimateMemoryUsage();
+            return size;
+        }
+    }
+
+    private static class NodeCacheW implements Weigher<String, RecordId> {
+
+        @Override
+        public int weigh(String key, RecordId value) {
+            int size = 96;
+            size += estimateMemoryUsage(key);
+            size += value.estimateMemoryUsage();
+            return size;
+        }
+    }
+
+    private static class TemplateCacheW implements Weigher<Template, RecordId> {
+
+        @Override
+        public int weigh(Template key, RecordId value) {
+            int size = 32;
+            size += key.estimateMemoryUsage();
+            size += value.estimateMemoryUsage();
+            return size;
+        }
+    }
 }
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..0626596 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
@@ -32,6 +32,7 @@
 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,17 +66,20 @@
     private long evictionCount;
     private long size;
 
+    private final Weigher<K, V> weigher;
+    private long weight = -1;
+
     /**
      * 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) {
+    public static <K, V> Supplier<PriorityCache<K, V>> factory(final int size, final Weigher<K, V> weigher) {
         checkArgument(bitCount(size) == 1);
         return new Supplier<PriorityCache<K, V>>() {
             @Override
             public PriorityCache<K, V> get() {
-                return new PriorityCache<>(size);
+                return new PriorityCache<>(size, weigher);
             }
         };
     }
@@ -119,13 +123,26 @@
      * @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, null);
+    }
+
+    /**
+     * 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, 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 = weigher;
     }
 
     /**
@@ -133,8 +150,12 @@
      * 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, Weigher<K, V> weigher) {
+        this(size, 31 - numberOfTrailingZeros(size), weigher);
+    }
+
     public PriorityCache(int size) {
-        this(size, 31 - numberOfTrailingZeros(size));
+        this(size, 31 - numberOfTrailingZeros(size), null);
     }
 
     private int project(int hashCode, int iteration) {
@@ -197,10 +218,16 @@
                 costs[old.cost - Byte.MIN_VALUE]--;
                 if (eviction) {
                     evictions[old.cost - Byte.MIN_VALUE]++;
-                    evictionCount++;
+                }
+                evictionCount++;
+                if (weigher != null) {
+                    weight -= weigher.weigh((K) old.key, (V) old.value);
                 }
             } else {
                 size++;
+            }
+            if (weigher != null) {
+                weight += weigher.weigh(key, value);
             }
             return true;
         } else {
@@ -247,6 +274,10 @@
             if (entry != Entry.NULL && purge.apply(entry.generation)) {
                 entries[i] = Entry.NULL;
                 size--;
+                evictionCount++;
+                if (weigher != null) {
+                    weight -= weigher.weigh((K) entry.key, (V) entry.value);
+                }
             }
         }
     }
@@ -278,4 +309,12 @@
         return new CacheStats(hitCount, missCount, loadCount, 0, 0, evictionCount);
     }
 
+    public long maxSize() {
+        return entries.length;
+    }
+
+    public long estimateCurrentWeight() {
+        return weight;
+    }
+
 }