diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/CacheSerializers.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/CacheSerializers.java
new file mode 100644
index 0000000..8546981
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/CacheSerializers.java
@@ -0,0 +1,58 @@
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed 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 com.googlesource.gerrit.modules.cache.chroniclemap;
+
+import com.google.gerrit.server.cache.PersistentCacheDef;
+import com.google.gerrit.server.cache.serialize.CacheSerializer;
+import com.google.inject.Singleton;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Singleton
+public class CacheSerializers {
+  private static final Map<String, CacheSerializer<?>> keySerializers = new ConcurrentHashMap<>();
+  private static final Map<String, CacheSerializer<?>> valueSerializers = new ConcurrentHashMap<>();
+
+  static <K, V> void registerCacheDef(PersistentCacheDef<K, V> def) {
+    String cacheName = def.name();
+    registerCacheKeySerializer(cacheName, def.keySerializer());
+    registerCacheValueSerializer(cacheName, def.valueSerializer());
+  }
+
+  static <K, V> void registerCacheKeySerializer(
+      String cacheName, CacheSerializer<K> keySerializer) {
+    keySerializers.computeIfAbsent(cacheName, (name) -> keySerializer);
+  }
+
+  static <K, V> void registerCacheValueSerializer(
+      String cacheName, CacheSerializer<V> valueSerializer) {
+    valueSerializers.computeIfAbsent(cacheName, (name) -> valueSerializer);
+  }
+
+  @SuppressWarnings("unchecked")
+  public static <K> CacheSerializer<K> getKeySerializer(String name) {
+    if (keySerializers.containsKey(name)) {
+      return (CacheSerializer<K>) keySerializers.get(name);
+    }
+    throw new IllegalStateException("Could not find key serializer for " + name);
+  }
+
+  @SuppressWarnings("unchecked")
+  public static <V> CacheSerializer<V> getValueSerializer(String name) {
+    if (valueSerializers.containsKey(name)) {
+      return (CacheSerializer<V>) valueSerializers.get(name);
+    }
+    throw new IllegalStateException("Could not find value serializer for " + name);
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java
index 311445b..bde4fd1 100644
--- a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java
@@ -39,7 +39,7 @@
 
   private final ChronicleMapCacheConfig config;
   private final CacheLoader<K, V> loader;
-  private final ChronicleMap<K, TimedValue<V>> store;
+  private final ChronicleMap<KeyWrapper<K>, TimedValue<V>> store;
   private final LongAdder hitCount = new LongAdder();
   private final LongAdder missCount = new LongAdder();
   private final LongAdder loadSuccessCount = new LongAdder();
@@ -55,6 +55,8 @@
       CacheLoader<K, V> loader,
       MetricMaker metricMaker)
       throws IOException {
+    CacheSerializers.registerCacheDef(def);
+
     this.config = config;
     this.loader = loader;
     this.hotEntries =
@@ -63,11 +65,11 @@
 
     ChronicleMapStorageMetrics metrics = new ChronicleMapStorageMetrics(metricMaker);
 
-    final Class<K> keyClass = (Class<K>) def.keyType().getRawType();
+    final Class<KeyWrapper<K>> keyWrapperClass = (Class<KeyWrapper<K>>) (Class) KeyWrapper.class;
     final Class<TimedValue<V>> valueWrapperClass = (Class<TimedValue<V>>) (Class) TimedValue.class;
 
-    final ChronicleMapBuilder<K, TimedValue<V>> mapBuilder =
-        ChronicleMap.of(keyClass, valueWrapperClass).name(def.name());
+    final ChronicleMapBuilder<KeyWrapper<K>, TimedValue<V>> mapBuilder =
+        ChronicleMap.of(keyWrapperClass, valueWrapperClass).name(def.name());
 
     // Chronicle-map does not allow to custom-serialize boxed primitives
     // such as Boolean, Integer, for which size is statically determined.
@@ -75,11 +77,11 @@
     // it cannot be used.
     if (!mapBuilder.constantlySizedKeys()) {
       mapBuilder.averageKeySize(config.getAverageKeySize());
-      mapBuilder.keyMarshaller(new ChronicleMapMarshallerAdapter<>(def.keySerializer()));
+      mapBuilder.keyMarshaller(new KeyWrapperMarshaller<>(def.name()));
     }
 
     mapBuilder.averageValueSize(config.getAverageValueSize());
-    mapBuilder.valueMarshaller(new TimedValueMarshaller<>(def.valueSerializer()));
+    mapBuilder.valueMarshaller(new TimedValueMarshaller<>(def.name()));
 
     mapBuilder.entries(config.getMaxEntries());
 
@@ -117,7 +119,7 @@
     }
 
     <K, V> void registerCallBackMetrics(
-        String name, ChronicleMap<K, TimedValue<V>> store, InMemoryLRU<K> hotEntries) {
+        String name, ChronicleMap<KeyWrapper<K>, TimedValue<V>> store, InMemoryLRU<K> hotEntries) {
       String sanitizedName = metricMaker.sanitizeMetricName(name);
       String PERCENTAGE_FREE_SPACE_METRIC =
           "cache/chroniclemap/percentage_free_space_" + sanitizedName;
@@ -162,10 +164,12 @@
     return config;
   }
 
+  @SuppressWarnings("unchecked")
   @Override
   public V getIfPresent(Object objKey) {
-    if (store.containsKey(objKey)) {
-      TimedValue<V> vTimedValue = store.get(objKey);
+    KeyWrapper<K> keyWrapper = (KeyWrapper<K>) new KeyWrapper<>(objKey);
+    if (store.containsKey(keyWrapper)) {
+      TimedValue<V> vTimedValue = store.get(keyWrapper);
       if (!expired(vTimedValue.getCreated())) {
         hitCount.increment();
         hotEntries.add((K) objKey);
@@ -180,8 +184,9 @@
 
   @Override
   public V get(K key) throws ExecutionException {
-    if (store.containsKey(key)) {
-      TimedValue<V> vTimedValue = store.get(key);
+    KeyWrapper<K> keyWrapper = new KeyWrapper<>(key);
+    if (store.containsKey(keyWrapper)) {
+      TimedValue<V> vTimedValue = store.get(keyWrapper);
       if (!needsRefresh(vTimedValue.getCreated())) {
         hitCount.increment();
         hotEntries.add(key);
@@ -211,8 +216,9 @@
 
   @Override
   public V get(K key, Callable<? extends V> valueLoader) throws ExecutionException {
-    if (store.containsKey(key)) {
-      TimedValue<V> vTimedValue = store.get(key);
+    KeyWrapper<K> keyWrapper = new KeyWrapper<>(key);
+    if (store.containsKey(keyWrapper)) {
+      TimedValue<V> vTimedValue = store.get(keyWrapper);
       if (!needsRefresh(vTimedValue.getCreated())) {
         hitCount.increment();
         return vTimedValue.getValue();
@@ -235,14 +241,16 @@
 
   @SuppressWarnings("unchecked")
   public void putUnchecked(Object key, Object value, Timestamp created) {
-    TimedValue<?> wrapped = new TimedValue<>(value, created.toInstant().toEpochMilli());
-    store.put((K) key, (TimedValue<V>) wrapped);
+    TimedValue<?> wrappedValue = new TimedValue<>(value, created.toInstant().toEpochMilli());
+    KeyWrapper<?> wrappedKey = new KeyWrapper<>(key);
+    store.put((KeyWrapper<K>) wrappedKey, (TimedValue<V>) wrappedValue);
   }
 
   @Override
   public void put(K key, V val) {
-    TimedValue<V> wrapped = new TimedValue<>(val);
-    store.put(key, wrapped);
+    KeyWrapper<K> wrappedKey = new KeyWrapper<>(key);
+    TimedValue<V> wrappedValue = new TimedValue<>(val);
+    store.put(wrappedKey, wrappedValue);
     hotEntries.add(key);
   }
 
@@ -251,7 +259,7 @@
       store.forEachEntry(
           c -> {
             if (expired(c.value().get().getCreated())) {
-              hotEntries.remove(c.key().get());
+              hotEntries.remove(c.key().get().getValue());
               c.context().remove(c);
             }
           });
@@ -282,17 +290,19 @@
   private void evictColdEntries() {
     store.forEachEntryWhile(
         e -> {
-          if (!hotEntries.contains(e.key().get())) {
+          if (!hotEntries.contains(e.key().get().getValue())) {
             e.doRemove();
           }
           return runningOutOfFreeSpace();
         });
   }
 
+  @SuppressWarnings("unchecked")
   @Override
   public void invalidate(Object key) {
-    store.remove(key);
-    hotEntries.remove((K) key);
+    KeyWrapper<K> wrappedKey = (KeyWrapper<K>) new KeyWrapper<>(key);
+    store.remove(wrappedKey);
+    hotEntries.remove(wrappedKey.getValue());
   }
 
   @Override
diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapMarshallerAdapter.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapMarshallerAdapter.java
deleted file mode 100644
index 0c60dca..0000000
--- a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapMarshallerAdapter.java
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright (C) 2020 The Android Open Source Project
-//
-// Licensed 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 com.googlesource.gerrit.modules.cache.chroniclemap;
-
-import com.google.gerrit.server.cache.serialize.CacheSerializer;
-import net.openhft.chronicle.bytes.Bytes;
-import net.openhft.chronicle.core.util.ReadResolvable;
-import net.openhft.chronicle.hash.serialization.BytesReader;
-import net.openhft.chronicle.hash.serialization.BytesWriter;
-
-public class ChronicleMapMarshallerAdapter<T>
-    implements BytesWriter<T>, BytesReader<T>, ReadResolvable<ChronicleMapMarshallerAdapter<T>> {
-
-  private final CacheSerializer<T> cacheSerializer;
-
-  ChronicleMapMarshallerAdapter(CacheSerializer<T> cacheSerializer) {
-    this.cacheSerializer = cacheSerializer;
-  }
-
-  @Override
-  public ChronicleMapMarshallerAdapter<T> readResolve() {
-    return new ChronicleMapMarshallerAdapter<>(cacheSerializer);
-  }
-
-  @Override
-  public T read(Bytes in, T using) {
-    int serializedLength = (int) in.readUnsignedInt();
-    byte[] serialized = new byte[serializedLength];
-    in.read(serialized, 0, serializedLength);
-    using = cacheSerializer.deserialize(serialized);
-    return using;
-  }
-
-  @Override
-  public void write(Bytes out, T toWrite) {
-    final byte[] serialized = cacheSerializer.serialize(toWrite);
-    out.writeUnsignedInt(serialized.length);
-    out.write(serialized);
-  }
-}
diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/KeyWrapper.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/KeyWrapper.java
new file mode 100644
index 0000000..cfab341
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/KeyWrapper.java
@@ -0,0 +1,42 @@
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed 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 com.googlesource.gerrit.modules.cache.chroniclemap;
+
+import com.google.common.base.Objects;
+
+public class KeyWrapper<V> {
+
+  private final V value;
+
+  KeyWrapper(V value) {
+    this.value = value;
+  }
+
+  public V getValue() {
+    return value;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (!(o instanceof KeyWrapper)) return false;
+    KeyWrapper<?> that = (KeyWrapper<?>) o;
+    return Objects.equal(value, that.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(value);
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/KeyWrapperMarshaller.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/KeyWrapperMarshaller.java
new file mode 100644
index 0000000..7c7801c
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/KeyWrapperMarshaller.java
@@ -0,0 +1,55 @@
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed 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 com.googlesource.gerrit.modules.cache.chroniclemap;
+
+import net.openhft.chronicle.bytes.Bytes;
+import net.openhft.chronicle.core.util.ReadResolvable;
+import net.openhft.chronicle.hash.serialization.BytesReader;
+import net.openhft.chronicle.hash.serialization.BytesWriter;
+
+public class KeyWrapperMarshaller<V>
+    implements BytesWriter<KeyWrapper<V>>,
+        BytesReader<KeyWrapper<V>>,
+        ReadResolvable<KeyWrapperMarshaller<V>> {
+
+  private final String name;
+
+  KeyWrapperMarshaller(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public KeyWrapperMarshaller<V> readResolve() {
+    return new KeyWrapperMarshaller<>(name);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public KeyWrapper<V> read(Bytes in, KeyWrapper<V> using) {
+    int serializedLength = (int) in.readUnsignedInt();
+    byte[] serialized = new byte[serializedLength];
+    in.read(serialized, 0, serializedLength);
+    V v = (V) CacheSerializers.getKeySerializer(name).deserialize(serialized);
+    using = new KeyWrapper<>(v);
+
+    return using;
+  }
+
+  @Override
+  public void write(Bytes out, KeyWrapper<V> toWrite) {
+    final byte[] serialized = CacheSerializers.getKeySerializer(name).serialize(toWrite.getValue());
+    out.writeUnsignedInt(serialized.length);
+    out.write(serialized);
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/TimedValueMarshaller.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/TimedValueMarshaller.java
index 60897bf..ec30043 100644
--- a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/TimedValueMarshaller.java
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/TimedValueMarshaller.java
@@ -13,7 +13,6 @@
 // limitations under the License.
 package com.googlesource.gerrit.modules.cache.chroniclemap;
 
-import com.google.gerrit.server.cache.serialize.CacheSerializer;
 import java.nio.ByteBuffer;
 import net.openhft.chronicle.bytes.Bytes;
 import net.openhft.chronicle.core.util.ReadResolvable;
@@ -25,17 +24,18 @@
         BytesReader<TimedValue<V>>,
         ReadResolvable<TimedValueMarshaller<V>> {
 
-  private final CacheSerializer<V> serializer;
+  private final String name;
 
-  TimedValueMarshaller(CacheSerializer<V> serializer) {
-    this.serializer = serializer;
+  TimedValueMarshaller(String name) {
+    this.name = name;
   }
 
   @Override
   public TimedValueMarshaller<V> readResolve() {
-    return new TimedValueMarshaller<>(serializer);
+    return new TimedValueMarshaller<>(name);
   }
 
+  @SuppressWarnings("unchecked")
   @Override
   public TimedValue<V> read(Bytes in, TimedValue<V> using) {
     long initialPosition = in.readPosition();
@@ -57,7 +57,7 @@
     // Deserialize object V (remaining bytes)
     byte[] serializedV = new byte[vLength];
     in.read(serializedV, 0, vLength);
-    V v = serializer.deserialize(serializedV);
+    V v = (V) CacheSerializers.getValueSerializer(name).deserialize(serializedV);
 
     using = new TimedValue<>(v, created);
 
@@ -66,7 +66,7 @@
 
   @Override
   public void write(Bytes out, TimedValue<V> toWrite) {
-    byte[] serialized = serializer.serialize(toWrite.getValue());
+    byte[] serialized = CacheSerializers.getValueSerializer(name).serialize(toWrite.getValue());
 
     // Serialize as follows:
     // created | length of serialized V | serialized value V
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheIT.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheIT.java
index df6fc38..36ce53c 100644
--- a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheIT.java
+++ b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheIT.java
@@ -48,7 +48,7 @@
     final int negativeDiskLimit = -1;
     final Cache<String, String> cache =
         persistentCacheFactory.build(
-            new TestPersistentCacheDef("foo", negativeDiskLimit), CacheBackend.CAFFEINE);
+            new TestPersistentCacheDef("foo", null, negativeDiskLimit), CacheBackend.CAFFEINE);
 
     assertThat(cache.getClass().getSimpleName()).isEqualTo("CaffeinatedGuavaCache");
   }
@@ -58,7 +58,7 @@
     final int positiveDiskLimit = 1024;
     assertThat(
             persistentCacheFactory.build(
-                new TestPersistentCacheDef("foo", positiveDiskLimit), CacheBackend.CAFFEINE))
+                new TestPersistentCacheDef("foo", null, positiveDiskLimit), CacheBackend.CAFFEINE))
         .isInstanceOf(ChronicleMapCacheImpl.class);
   }
 
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheTest.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheTest.java
index e8c1f4a..5d380ff 100644
--- a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheTest.java
+++ b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheTest.java
@@ -25,6 +25,7 @@
 import com.google.gerrit.metrics.DisabledMetricMaker;
 import com.google.gerrit.metrics.MetricMaker;
 import com.google.gerrit.metrics.dropwizard.DropWizardMetricMaker;
+import com.google.gerrit.server.cache.serialize.CacheSerializer;
 import com.google.gerrit.server.cache.serialize.StringCacheSerializer;
 import com.google.gerrit.server.config.SitePaths;
 import com.google.inject.Guice;
@@ -47,6 +48,7 @@
 import org.junit.rules.TemporaryFolder;
 
 public class ChronicleMapCacheTest {
+  private static final String TEST_CACHE_NAME = "test-cache-name";
   @Inject MetricMaker metricMaker;
   @Inject MetricRegistry metricRegistry;
 
@@ -58,6 +60,8 @@
 
   @Before
   public void setUp() throws Exception {
+    CacheSerializers.registerCacheKeySerializer(TEST_CACHE_NAME, StringCacheSerializer.INSTANCE);
+    CacheSerializers.registerCacheValueSerializer(TEST_CACHE_NAME, StringCacheSerializer.INSTANCE);
     sitePaths = new SitePaths(temporaryFolder.newFolder().toPath());
     Files.createDirectories(sitePaths.etc_dir);
 
@@ -82,7 +86,7 @@
   }
 
   @Test
-  public void getIfPresentShouldReturnNullWhenThereisNoCachedValue() throws Exception {
+  public void getIfPresentShouldReturnNullWhenThereIsNoCachedValue() throws Exception {
     assertThat(newCacheWithLoader(null).getIfPresent("foo")).isNull();
   }
 
@@ -237,7 +241,7 @@
   @Test
   public void getIfPresentShouldReturnNullWhenValueIsExpired() throws Exception {
     ChronicleMapCacheImpl<String, String> cache =
-        newCache(true, null, Duration.ofSeconds(1), null, 1);
+        newCache(true, TEST_CACHE_NAME, null, Duration.ofSeconds(1), null, 1);
     cache.put("foo", "some-stale-value");
     Thread.sleep(1010); // Allow cache entry to expire
     assertThat(cache.getIfPresent("foo")).isNull();
@@ -247,7 +251,7 @@
   public void getShouldRefreshValueWhenExpired() throws Exception {
     String newCachedValue = UUID.randomUUID().toString();
     ChronicleMapCacheImpl<String, String> cache =
-        newCache(true, newCachedValue, null, Duration.ofSeconds(1), 1);
+        newCache(true, TEST_CACHE_NAME, newCachedValue, null, Duration.ofSeconds(1), 1);
     cache.put("foo", "some-stale-value");
     Thread.sleep(1010); // Allow cache to be flagged as needing refresh
     assertThat(cache.get("foo")).isEqualTo(newCachedValue);
@@ -256,7 +260,7 @@
   @Test
   public void shouldPruneExpiredValues() throws Exception {
     ChronicleMapCacheImpl<String, String> cache =
-        newCache(true, null, Duration.ofSeconds(1), null, 1);
+        newCache(true, TEST_CACHE_NAME, null, Duration.ofSeconds(1), null, 1);
     cache.put("foo1", "some-stale-value1");
     cache.put("foo2", "some-stale-value1");
     Thread.sleep(1010); // Allow cache entries to expire
@@ -293,10 +297,10 @@
   public void shouldEvictOldestElementInCacheWhenIsNeverAccessed() throws Exception {
     final String fooValue = "foo";
 
-    gerritConfig.setInt("cache", "foo", "maxEntries", 2);
-    gerritConfig.setInt("cache", "foo", "percentageHotKeys", 10);
-    gerritConfig.setInt("cache", "foo", "avgKeySize", "foo1".getBytes().length);
-    gerritConfig.setInt("cache", "foo", "avgValueSize", valueSize(fooValue));
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "maxEntries", 2);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "percentageHotKeys", 10);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "avgKeySize", "foo1".getBytes().length);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "avgValueSize", valueSize(fooValue));
     gerritConfig.save();
 
     ChronicleMapCacheImpl<String, String> cache = newCacheWithLoader(fooValue);
@@ -313,10 +317,10 @@
   public void shouldEvictRecentlyInsertedElementInCacheWhenOldestElementIsAccessed()
       throws Exception {
     final String fooValue = "foo";
-    gerritConfig.setInt("cache", "foo", "maxEntries", 2);
-    gerritConfig.setInt("cache", "foo", "percentageHotKeys", 10);
-    gerritConfig.setInt("cache", "foo", "avgKeySize", "foo1".getBytes().length);
-    gerritConfig.setInt("cache", "foo", "avgValueSize", valueSize(fooValue));
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "maxEntries", 2);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "percentageHotKeys", 10);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "avgKeySize", "foo1".getBytes().length);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "avgValueSize", valueSize(fooValue));
     gerritConfig.save();
 
     ChronicleMapCacheImpl<String, String> cache = newCacheWithLoader(fooValue);
@@ -354,13 +358,13 @@
   @Test
   public void shouldTriggerPercentageFreeMetric() throws Exception {
     String cachedValue = UUID.randomUUID().toString();
-    String freeSpaceMetricName = "cache/chroniclemap/percentage_free_space_" + cachedValue;
-    gerritConfig.setInt("cache", cachedValue, "maxEntries", 2);
-    gerritConfig.setInt("cache", cachedValue, "avgKeySize", cachedValue.getBytes().length);
-    gerritConfig.setInt("cache", cachedValue, "avgValueSize", valueSize(cachedValue));
+    String freeSpaceMetricName = "cache/chroniclemap/percentage_free_space_" + TEST_CACHE_NAME;
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "maxEntries", 2);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "avgKeySize", cachedValue.getBytes().length);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "avgValueSize", valueSize(cachedValue));
     gerritConfig.save();
 
-    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(cachedValue);
+    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(TEST_CACHE_NAME, cachedValue);
 
     assertThat(getMetric(freeSpaceMetricName).getValue()).isEqualTo(100);
 
@@ -373,13 +377,13 @@
   @Test
   public void shouldTriggerRemainingAutoResizeMetric() throws Exception {
     String cachedValue = UUID.randomUUID().toString();
-    String autoResizeMetricName = "cache/chroniclemap/remaining_autoresizes_" + cachedValue;
-    gerritConfig.setInt("cache", cachedValue, "maxEntries", 2);
-    gerritConfig.setInt("cache", cachedValue, "avgKeySize", cachedValue.getBytes().length);
-    gerritConfig.setInt("cache", cachedValue, "avgValueSize", valueSize(cachedValue));
+    String autoResizeMetricName = "cache/chroniclemap/remaining_autoresizes_" + TEST_CACHE_NAME;
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "maxEntries", 2);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "avgKeySize", cachedValue.getBytes().length);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "avgValueSize", valueSize(cachedValue));
     gerritConfig.save();
 
-    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(cachedValue);
+    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(TEST_CACHE_NAME, cachedValue);
 
     assertThat(getMetric(autoResizeMetricName).getValue()).isEqualTo(1);
 
@@ -397,12 +401,12 @@
     int percentageHotKeys = 60;
     int maxEntries = 10;
     int expectedCapacity = 6;
-    String hotKeysCapacityMetricName = "cache/chroniclemap/hot_keys_capacity_" + cachedValue;
-    gerritConfig.setInt("cache", cachedValue, "maxEntries", maxEntries);
-    gerritConfig.setInt("cache", cachedValue, "percentageHotKeys", percentageHotKeys);
+    String hotKeysCapacityMetricName = "cache/chroniclemap/hot_keys_capacity_" + TEST_CACHE_NAME;
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "maxEntries", maxEntries);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "percentageHotKeys", percentageHotKeys);
     gerritConfig.save();
 
-    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(cachedValue);
+    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(TEST_CACHE_NAME, cachedValue);
 
     assertThat(getMetric(hotKeysCapacityMetricName).getValue()).isEqualTo(expectedCapacity);
   }
@@ -414,12 +418,12 @@
     int maxEntries = 10;
     int maxHotKeyCapacity = 3;
     final Duration METRIC_TRIGGER_TIMEOUT = Duration.ofSeconds(2);
-    String hotKeysSizeMetricName = "cache/chroniclemap/hot_keys_size_" + cachedValue;
-    gerritConfig.setInt("cache", cachedValue, "maxEntries", maxEntries);
-    gerritConfig.setInt("cache", cachedValue, "percentageHotKeys", percentageHotKeys);
+    String hotKeysSizeMetricName = "cache/chroniclemap/hot_keys_size_" + TEST_CACHE_NAME;
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "maxEntries", maxEntries);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "percentageHotKeys", percentageHotKeys);
     gerritConfig.save();
 
-    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(cachedValue);
+    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(TEST_CACHE_NAME, cachedValue);
 
     assertThat(getMetric(hotKeysSizeMetricName).getValue()).isEqualTo(0);
 
@@ -448,12 +452,12 @@
     int maxEntries = 10;
     int maxHotKeyCapacity = 3;
     final Duration METRIC_TRIGGER_TIMEOUT = Duration.ofSeconds(2);
-    String hotKeysSizeMetricName = "cache/chroniclemap/hot_keys_size_" + cachedValue;
-    gerritConfig.setInt("cache", cachedValue, "maxEntries", maxEntries);
-    gerritConfig.setInt("cache", cachedValue, "percentageHotKeys", percentageHotKeys);
+    String hotKeysSizeMetricName = "cache/chroniclemap/hot_keys_size_" + TEST_CACHE_NAME;
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "maxEntries", maxEntries);
+    gerritConfig.setInt("cache", TEST_CACHE_NAME, "percentageHotKeys", percentageHotKeys);
     gerritConfig.save();
 
-    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(cachedValue);
+    ChronicleMapCacheImpl<String, String> cache = newCacheWithMetrics(TEST_CACHE_NAME, cachedValue);
 
     for (int i = 0; i < maxHotKeyCapacity; i++) {
       cache.put(cachedValue + i, cachedValue);
@@ -478,7 +482,7 @@
     String autoResizeMetricName = "cache/chroniclemap/remaining_autoresizes_" + sanitized;
     String hotKeyCapacityMetricName = "cache/chroniclemap/hot_keys_capacity_" + sanitized;
 
-    newCacheWithMetrics(cacheName);
+    newCacheWithMetrics(cacheName, null);
 
     getMetric(hotKeySizeMetricName);
     getMetric(percentageFreeMetricName);
@@ -487,44 +491,61 @@
   }
 
   private int valueSize(String value) {
-    final TimedValueMarshaller<String> marshaller =
-        new TimedValueMarshaller<>(StringCacheSerializer.INSTANCE);
+    final TimedValueMarshaller<String> marshaller = new TimedValueMarshaller<>(TEST_CACHE_NAME);
 
     Bytes<ByteBuffer> out = Bytes.elasticByteBuffer();
     marshaller.write(out, new TimedValue<>(value));
     return out.toByteArray().length;
   }
 
-  private ChronicleMapCacheImpl<String, String> newCacheWithMetrics(String cachedValue)
+  private ChronicleMapCacheImpl<String, String> newCacheWithMetrics(
+      String cacheName, @Nullable String cachedValue) throws IOException {
+    return newCache(true, cacheName, cachedValue, null, null, null, null, 1, metricMaker);
+  }
+
+  private ChronicleMapCacheImpl<String, String> newCacheWithMetrics(
+      String cacheName,
+      String cachedValue,
+      CacheSerializer<String> keySerializer,
+      CacheSerializer<String> valueSerializer)
       throws IOException {
-    return newCache(true, cachedValue, null, null, 1, metricMaker);
+    return newCache(
+        true, cacheName, cachedValue, null, null, null, null, 1, new DisabledMetricMaker());
   }
 
   private ChronicleMapCacheImpl<String, String> newCache(
       Boolean withLoader,
-      @Nullable String cachedValue,
+      String cacheName,
+      @Nullable String loadedValue,
       @Nullable Duration expireAfterWrite,
       @Nullable Duration refreshAfterWrite,
       Integer version)
       throws IOException {
     return newCache(
         withLoader,
-        cachedValue,
+        cacheName,
+        loadedValue,
         expireAfterWrite,
         refreshAfterWrite,
+        null,
+        null,
         version,
         new DisabledMetricMaker());
   }
 
   private ChronicleMapCacheImpl<String, String> newCache(
       Boolean withLoader,
+      String cacheName,
       @Nullable String cachedValue,
       @Nullable Duration expireAfterWrite,
       @Nullable Duration refreshAfterWrite,
+      @Nullable CacheSerializer<String> keySerializer,
+      @Nullable CacheSerializer<String> valueSerializer,
       Integer version,
       MetricMaker metricMaker)
       throws IOException {
-    TestPersistentCacheDef cacheDef = new TestPersistentCacheDef(cachedValue);
+    TestPersistentCacheDef cacheDef =
+        new TestPersistentCacheDef(cacheName, cachedValue, keySerializer, valueSerializer);
 
     File persistentFile =
         ChronicleMapCacheFactory.fileName(
@@ -542,21 +563,21 @@
         cacheDef, config, withLoader ? cacheDef.loader() : null, metricMaker);
   }
 
-  private ChronicleMapCacheImpl<String, String> newCacheWithLoader(@Nullable String cachedValue)
+  private ChronicleMapCacheImpl<String, String> newCacheWithLoader(@Nullable String loadedValue)
       throws IOException {
-    return newCache(true, cachedValue, null, null, 1);
+    return newCache(true, TEST_CACHE_NAME, loadedValue, null, null, 1);
   }
 
   private ChronicleMapCacheImpl<String, String> newCacheWithLoader() throws IOException {
-    return newCache(true, null, null, null, 1);
+    return newCache(true, TEST_CACHE_NAME, null, null, null, 1);
   }
 
   private ChronicleMapCacheImpl<String, String> newCacheVersion(int version) throws IOException {
-    return newCache(true, null, null, null, version);
+    return newCache(true, TEST_CACHE_NAME, null, null, null, version);
   }
 
   private ChronicleMapCacheImpl<String, String> newCacheWithoutLoader() throws IOException {
-    return newCache(false, null, null, null, 1);
+    return newCache(false, TEST_CACHE_NAME, null, null, null, 1);
   }
 
   private <V> Gauge<V> getMetric(String name) {
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapMarshallerAdapterTest.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapMarshallerAdapterTest.java
deleted file mode 100644
index 09f7f17..0000000
--- a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapMarshallerAdapterTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (C) 2020 The Android Open Source Project
-//
-// Licensed 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.
-// limitations under the License.
-// See the License for the specific language governing permissions and
-package com.googlesource.gerrit.modules.cache.chroniclemap;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import com.google.gerrit.server.cache.serialize.ObjectIdCacheSerializer;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import net.openhft.chronicle.bytes.Bytes;
-import org.eclipse.jgit.lib.ObjectId;
-import org.junit.Test;
-
-public class ChronicleMapMarshallerAdapterTest {
-
-  @Test
-  public void shouldDeserializeToTheSameObject() {
-    ObjectId id = ObjectId.fromString("aabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
-    byte[] serializedId = ObjectIdCacheSerializer.INSTANCE.serialize(id);
-    ByteBuffer serializedIdWithLen = ByteBuffer.allocate(serializedId.length + 4);
-    serializedIdWithLen.order(ByteOrder.LITTLE_ENDIAN);
-    serializedIdWithLen.putInt(serializedId.length);
-    serializedIdWithLen.put(serializedId);
-
-    ChronicleMapMarshallerAdapter<ObjectId> marshaller =
-        new ChronicleMapMarshallerAdapter<>(ObjectIdCacheSerializer.INSTANCE);
-    ObjectId out = marshaller.read(Bytes.allocateDirect(serializedIdWithLen.array()), null);
-
-    assertThat(id).isEqualTo(out);
-  }
-
-  @Test
-  public void shouldSerializeToTheSameObject() {
-    ObjectId id = ObjectId.fromString("aabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
-    ChronicleMapMarshallerAdapter<ObjectId> marshaller =
-        new ChronicleMapMarshallerAdapter<>(ObjectIdCacheSerializer.INSTANCE);
-
-    Bytes<ByteBuffer> out = Bytes.elasticByteBuffer();
-    marshaller.write(out, id);
-    assertThat(marshaller.read(out, null)).isEqualTo(id);
-  }
-}
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/KeyWrapperMarshallerTest.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/KeyWrapperMarshallerTest.java
new file mode 100644
index 0000000..44a5dd6
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/KeyWrapperMarshallerTest.java
@@ -0,0 +1,45 @@
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed 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 com.googlesource.gerrit.modules.cache.chroniclemap;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.gerrit.server.cache.serialize.ObjectIdCacheSerializer;
+import java.nio.ByteBuffer;
+import net.openhft.chronicle.bytes.Bytes;
+import org.eclipse.jgit.lib.ObjectId;
+import org.junit.Before;
+import org.junit.Test;
+
+public class KeyWrapperMarshallerTest {
+  private static final String TEST_CACHE_NAME = "key-wrapper-test";
+
+  @Before
+  public void setup() {
+    CacheSerializers.registerCacheKeySerializer(TEST_CACHE_NAME, ObjectIdCacheSerializer.INSTANCE);
+  }
+
+  @Test
+  public void shouldSerializeAndDeserializeBack() {
+    ObjectId id = ObjectId.fromString("1234567890123456789012345678901234567890");
+    KeyWrapperMarshaller<ObjectId> marshaller = new KeyWrapperMarshaller<>(TEST_CACHE_NAME);
+
+    final KeyWrapper<ObjectId> wrapped = new KeyWrapper<>(id);
+
+    Bytes<ByteBuffer> out = Bytes.elasticByteBuffer();
+    marshaller.write(out, wrapped);
+    final KeyWrapper<ObjectId> actual = marshaller.read(out, null);
+    assertThat(actual).isEqualTo(wrapped);
+  }
+}
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TestPersistentCacheDef.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TestPersistentCacheDef.java
index b81baec..0e52f1d 100644
--- a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TestPersistentCacheDef.java
+++ b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TestPersistentCacheDef.java
@@ -21,42 +21,61 @@
 import com.google.gerrit.server.cache.serialize.StringCacheSerializer;
 import com.google.inject.TypeLiteral;
 import java.time.Duration;
+import java.util.Optional;
 import java.util.UUID;
 
 public class TestPersistentCacheDef implements PersistentCacheDef<String, String> {
 
   private static final Integer DEFAULT_DISK_LIMIT = 1024;
 
+  private final String name;
   private final String loadedValue;
   private final Duration expireAfterWrite;
   private final Duration refreshAfterWrite;
   private final Integer diskLimit;
+  private final CacheSerializer<String> keySerializer;
+  private final CacheSerializer<String> valueSerializer;
 
   public TestPersistentCacheDef(
-      String loadedValue,
+      String name,
+      @Nullable String loadedValue,
       @Nullable Duration expireAfterWrite,
       @Nullable Duration refreshAfterWrite) {
 
+    this.name = name;
     this.loadedValue = loadedValue;
     this.expireAfterWrite = expireAfterWrite;
     this.refreshAfterWrite = refreshAfterWrite;
     this.diskLimit = DEFAULT_DISK_LIMIT;
+    this.keySerializer = StringCacheSerializer.INSTANCE;
+    this.valueSerializer = StringCacheSerializer.INSTANCE;
   }
 
-  public TestPersistentCacheDef(String loadedValue, Integer diskLimit) {
+  public TestPersistentCacheDef(String name, @Nullable String loadedValue, Integer diskLimit) {
 
+    this.name = name;
     this.loadedValue = loadedValue;
     this.expireAfterWrite = null;
     this.refreshAfterWrite = null;
     this.diskLimit = diskLimit;
+    this.keySerializer = StringCacheSerializer.INSTANCE;
+    this.valueSerializer = StringCacheSerializer.INSTANCE;
   }
 
-  public TestPersistentCacheDef(String loadedValue) {
+  public TestPersistentCacheDef(
+      String name,
+      @Nullable String loadedValue,
+      @Nullable CacheSerializer<String> keySerializer,
+      @Nullable CacheSerializer<String> valueSerializer) {
 
+    this.name = name;
     this.loadedValue = loadedValue;
     this.expireAfterWrite = Duration.ZERO;
     this.refreshAfterWrite = Duration.ZERO;
     this.diskLimit = DEFAULT_DISK_LIMIT;
+    this.keySerializer = Optional.ofNullable(keySerializer).orElse(StringCacheSerializer.INSTANCE);
+    this.valueSerializer =
+        Optional.ofNullable(valueSerializer).orElse(StringCacheSerializer.INSTANCE);
   }
 
   @Override
@@ -71,17 +90,17 @@
 
   @Override
   public CacheSerializer<String> keySerializer() {
-    return StringCacheSerializer.INSTANCE;
+    return keySerializer;
   }
 
   @Override
   public CacheSerializer<String> valueSerializer() {
-    return StringCacheSerializer.INSTANCE;
+    return valueSerializer;
   }
 
   @Override
   public String name() {
-    return loadedValue;
+    return name;
   }
 
   @Override
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TimedValueMarshallerTest.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TimedValueMarshallerTest.java
index 62c1d44..b630e36 100644
--- a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TimedValueMarshallerTest.java
+++ b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TimedValueMarshallerTest.java
@@ -19,16 +19,23 @@
 import java.nio.ByteBuffer;
 import net.openhft.chronicle.bytes.Bytes;
 import org.eclipse.jgit.lib.ObjectId;
+import org.junit.Before;
 import org.junit.Test;
 
 public class TimedValueMarshallerTest {
+  private static final String TEST_CACHE_NAME = "timed-value-cache";
+
+  @Before
+  public void setup() {
+    CacheSerializers.registerCacheValueSerializer(
+        TEST_CACHE_NAME, ObjectIdCacheSerializer.INSTANCE);
+  }
 
   @Test
   public void shouldSerializeAndDeserializeBack() {
     ObjectId id = ObjectId.fromString("1234567890123456789012345678901234567890");
     long timestamp = 1600329018L;
-    TimedValueMarshaller<ObjectId> marshaller =
-        new TimedValueMarshaller<>(ObjectIdCacheSerializer.INSTANCE);
+    TimedValueMarshaller<ObjectId> marshaller = new TimedValueMarshaller<>(TEST_CACHE_NAME);
 
     final TimedValue<ObjectId> wrapped = new TimedValue<>(id, timestamp);