DPL: use per-path cache entry in ObjectCache

Author: ehellbar

Framework/Core/include/Framework/InputRecord.h

@@ -422,37 +422,35 @@ class InputRecord
         auto id = ObjectCache::Id::fromRef(ref);
         ConcreteDataMatcher matcher{header->dataOrigin, header->dataDescription, header->subSpecification};
         // If the matcher does not have an entry in the cache, deserialise it
-        // and cache the deserialised object at the given id.
+        // and cache the deserialised object alongside its id, keyed by path.
         auto path = fmt::format("{}", DataSpecUtils::describe(matcher));
         LOGP(debug, "{}", path);
         auto& cache = mRegistry.get<ObjectCache>();
         auto& callbacks = mRegistry.get<CallbackService>();
-        auto cacheEntry = cache.matcherToId.find(path);
-        if (cacheEntry == cache.matcherToId.end()) {
-          cache.matcherToId.insert(std::make_pair(path, id));
+        auto cacheEntry = cache.matcherToEntry.find(path);
+        if (cacheEntry == cache.matcherToEntry.end()) {
           std::unique_ptr<ValueT const, Deleter<ValueT const>> result(DataRefUtils::as<CCDBSerialized<ValueT>>(ref).release(), false);
           void* obj = (void*)result.get();
           callbacks.call<CallbackService::Id::CCDBDeserialised>((ConcreteDataMatcher&)matcher, (void*)obj);
-          cache.idToObject[id] = obj;
+          cache.matcherToEntry.emplace(path, ObjectCache::Entry{id, obj});
           LOGP(info, "Caching in {} ptr to {} ({})", id.value, path, obj);
           return result;
         }
-        auto& oldId = cacheEntry->second;
+        auto& entry = cacheEntry->second;
         // The id in the cache is the same, let's simply return it.
-        if (oldId.value == id.value) {
-          std::unique_ptr<ValueT const, Deleter<ValueT const>> result((ValueT const*)cache.idToObject[id], false);
+        if (entry.id.value == id.value) {
+          std::unique_ptr<ValueT const, Deleter<ValueT const>> result((ValueT const*)entry.obj, false);
           LOGP(debug, "Returning cached entry {} for {} ({})", id.value, path, (void*)result.get());
           return result;
         }
-        // The id in the cache is different. Let's destroy the old cached entry
-        // and create a new one.
-        delete reinterpret_cast<ValueT*>(cache.idToObject[oldId]);
+        // The id in the cache is different. Destroy this path's previously cached object and replace it.
+        delete reinterpret_cast<ValueT*>(entry.obj);
         std::unique_ptr<ValueT const, Deleter<ValueT const>> result(DataRefUtils::as<CCDBSerialized<ValueT>>(ref).release(), false);
         void* obj = (void*)result.get();
         callbacks.call<CallbackService::Id::CCDBDeserialised>((ConcreteDataMatcher&)matcher, (void*)obj);
-        cache.idToObject[id] = obj;
-        LOGP(info, "Replacing cached entry {} with {} for {} ({})", oldId.value, id.value, path, obj);
-        oldId.value = id.value;
+        LOGP(info, "Replacing cached entry {} with {} for {} ({})", entry.id.value, id.value, path, obj);
+        entry.id = id;
+        entry.obj = obj;
         return result;
       } else {
         throw runtime_error("Attempt to extract object from message with unsupported serialization type");
@@ -503,30 +501,28 @@ class InputRecord
     // it's updated.
     auto id = ObjectCache::Id::fromRef(ref);
     ConcreteDataMatcher matcher{header->dataOrigin, header->dataDescription, header->subSpecification};
-    // If the matcher does not have an entry in the cache, deserialise it
-    // and cache the deserialised object at the given id.
+    // If the matcher does not have an entry in the cache, deserialise it and cache it per path.
     auto path = fmt::format("{}", DataSpecUtils::describe(matcher));
     LOGP(debug, "{}", path);
     auto& cache = mRegistry.get<ObjectCache>();
-    auto cacheEntry = cache.matcherToMetadataId.find(path);
-    if (cacheEntry == cache.matcherToMetadataId.end()) {
-      cache.matcherToMetadataId.insert(std::make_pair(path, id));
-      cache.idToMetadata[id] = DataRefUtils::extractCCDBHeaders(ref);
+    auto cacheEntry = cache.matcherToMetadata.find(path);
+    if (cacheEntry == cache.matcherToMetadata.end()) {
+      auto [it, inserted] = cache.matcherToMetadata.emplace(
+        path, ObjectCache::MetadataEntry{id, DataRefUtils::extractCCDBHeaders(ref)});
       LOGP(info, "Caching CCDB metadata {}: {}", id.value, path);
-      return cache.idToMetadata[id];
+      return it->second.metadata;
     }
-    auto& oldId = cacheEntry->second;
+    auto& entry = cacheEntry->second;
     // The id in the cache is the same, let's simply return it.
-    if (oldId.value == id.value) {
+    if (entry.id.value == id.value) {
       LOGP(debug, "Returning cached CCDB metatada {}: {}", id.value, path);
-      return cache.idToMetadata[id];
+      return entry.metadata;
     }
-    // The id in the cache is different. Let's destroy the old cached entry
-    // and create a new one.
-    LOGP(info, "Replacing cached entry {} with {} for {}", oldId.value, id.value, path);
-    cache.idToMetadata[id] = DataRefUtils::extractCCDBHeaders(ref);
-    oldId.value = id.value;
-    return cache.idToMetadata[id];
+    // The id in the cache is different. Replace this path's metadata.
+    LOGP(info, "Replacing cached entry {} with {} for {}", entry.id.value, id.value, path);
+    entry.id = id;
+    entry.metadata = DataRefUtils::extractCCDBHeaders(ref);
+    return entry.metadata;
   }
 
   template <typename T = DataRef, typename R>

Framework/Core/include/Framework/ObjectCache.h

@@ -14,12 +14,14 @@
 #include "Framework/DataRef.h"
 #include <unordered_map>
 #include <map>
+#include <string>
 
 namespace o2::framework
 {
 
 /// A cache for CCDB objects or objects in general
 /// which have more than one timeframe of lifetime.
+/// The cache is keyed *per path* rather than by a global id-derived hash.
 struct ObjectCache {
   struct Id {
     int64_t value;
@@ -39,20 +41,28 @@ struct ObjectCache {
       }
     };
   };
-  /// A cache for deserialised objects.
+
+  /// Per-path cache entry for a deserialised CCDB object.
+  struct Entry {
+    Id id{0};
+    void* obj{nullptr};
+  };
+
+  /// Per-path cache entry for the CCDB metadata map.
+  struct MetadataEntry {
+    Id id{0};
+    std::map<std::string, std::string> metadata;
+  };
+
+  /// A per-path cache for deserialised objects.
   /// This keeps a mapping so that we can tell if a given
-  /// path was already received and it's blob stored in
-  /// .second.
-  std::unordered_map<std::string, Id> matcherToId;
-  /// A map from a CacheId (which is the void* ptr of the previous map).
-  /// to an actual (type erased) pointer to the deserialised object.
-  std::unordered_map<Id, void*, Id::hash_fn> idToObject;
-
-  /// A cache to the deserialised metadata
+  /// path was already received and it's blob stored in .second.obj
+  std::unordered_map<std::string, Entry> matcherToEntry;
+
+  /// A per-path cache to the deserialised metadata
   /// We keep it separate because we want to avoid that looking up
   /// the metadata also pollutes the object cache.
-  std::unordered_map<std::string, Id> matcherToMetadataId;
-  std::unordered_map<Id, std::map<std::string, std::string>, Id::hash_fn> idToMetadata;
+  std::unordered_map<std::string, MetadataEntry> matcherToMetadata;
 };
 
 } // namespace o2::framework