[llvm-profdata] Use std::unordered_map in SampleProfileMap

[huangjd]

Summary

Patch D147740 Change back to std::unordered_map for SampleProfileMap because it has reference validity, the change to use llvm::DenseMap is moved to a different patch.

[wenlei]

lgtm with nits. thanks.

llvm/include/llvm/ADT/Hashing.h

687–688

Given this is only used by HashKeyMap and not really meant to enable general conversion from llvm hash to std hash, consider move it to SampleProf.h right above SampleProfileMap.

689

nit: Obj -> Val

[huangjd]

llvm/include/llvm/ADT/Hashing.h

687–688

This can be problematic, if llvm::hash_code is being used in std::unordered_map somewhere else and the user defines std::hash<llvm::hash_code> locally, it will cause multiple definition of a class if the header somehow get included.

[ayermolo]

Tried locally to confirm and build of a module succeeds.
Thank you for fixing it.

[huangjd]

Coding style update

llvm/include/llvm/ADT/Hashing.h

template <> struct DenseMapInfo<hash_code, void> {
   static inline hash_code getEmptyKey() { return hash_code(-1); }
   static inline hash_code getTombstoneKey() { return hash_code(-2); }
   static unsigned getHashValue(hash_code val) { return val; }
   static bool isEqual(hash_code LHS, hash_code RHS) { return LHS == RHS; }
 };
 
 } // namespace llvm
 
+/// Implement std::hash so that hash_code can be used in STL containers.
+namespace std {
+
+template<>
+struct hash<llvm::hash_code> {
+  size_t operator()(llvm::hash_code const& Val) const {
+    return Val;
+  }
+};
+
+} // namespace std;
+
 #endif

llvm/include/llvm/ProfileData/SampleProf.h

 };
 
 /// This class provides operator overloads to the map container using MD5 as the
 /// key type, so that existing code can still work in most cases using
 /// SampleContext as key.
 /// Note: when populating container, make sure to assign the SampleContext to
 /// the mapped value immediately because the key no longer holds it.
 class SampleProfileMap
-    : public HashKeyMap<DenseMap, SampleContext, FunctionSamples> {
+    : public HashKeyMap<std::unordered_map, SampleContext, FunctionSamples> {
 public:
   // Convenience method because this is being used in many places. Set the
   // FunctionSamples' context if its newly inserted.
   mapped_type &Create(const SampleContext &Ctx) {
     auto Ret = try_emplace(Ctx, FunctionSamples());
     if (Ret.second)
       Ret.first->second.setContext(Ctx);
     return Ret.first->second;
   }
 
   iterator find(const SampleContext &Ctx) {
-    return HashKeyMap<llvm::DenseMap, SampleContext, FunctionSamples>::find(
+    return HashKeyMap<std::unordered_map, SampleContext, FunctionSamples>::find(
         Ctx);
   }
 
   const_iterator find(const SampleContext &Ctx) const {
-    return HashKeyMap<llvm::DenseMap, SampleContext, FunctionSamples>::find(
+    return HashKeyMap<std::unordered_map, SampleContext, FunctionSamples>::find(
         Ctx);
   }
 
   // Overloaded find() to lookup a function by name. This is called by IPO
   // passes with an actual function name, and it is possible that the profile
   // reader converted function names in the profile to MD5 strings, so we need
   // to check if either representation matches.
   iterator find(StringRef Fname) {
     uint64_t Hash = hashFuncName(Fname);
     auto It = base_type::find(hash_code(Hash));
     if (It != end()) {
       StringRef CtxName = It->second.getContext().getName();
       if (LLVM_LIKELY(CtxName == Fname || CtxName == std::to_string(Hash)))
         return It;
     }
     return end();
   }
 
   size_t erase(const SampleContext &Ctx) {
-    return HashKeyMap<llvm::DenseMap, SampleContext, FunctionSamples>::erase(
-        Ctx);
+    return HashKeyMap<std::unordered_map, SampleContext, FunctionSamples>::
+        erase(Ctx);
   }
 
   size_t erase(const key_type &Key) { return base_type::erase(Key); }
 };
 
 using NameFunctionSamples = std::pair<hash_code, const FunctionSamples *>;
 
 void sortFuncProfiles(const SampleProfileMap &ProfileMap,