Framework: key HIST() names by a fixed-string template argument

HIST()/CONST_STR() created, at every call site, a lambda, a local struct, an
index_sequence expansion over the characters and a ConstStr<'a','b',...> type.
They now produce ConstStr<"ab">: one type per distinct name, the hash still a
static member computed once per name, and concatenation still at the type
level, so names passed as function parameters keep working. Hashes are
unchanged.

2,000 distinct names (a quarter concatenated with a directory) in a template
instantiated twice, -O2: clang 21 3.76 s -> 1.90 s and 591 -> 238 MB peak;
GCC 16 6.41 s -> 3.04 s and 602 -> 366 MB. Object size +6%.

Needs AliceO2Group/O2Physics#18584, which updates the helpers that spelled out
ConstStr<chars...>.

Author: ktf

Framework/Core/include/Framework/HistogramRegistry.h

@@ -129,8 +129,8 @@ class HistogramRegistry
   // HistogramName class providing the associated hash and a first guess for the index in the registry
   struct HistName {
     // ctor for histogram names that are already hashed at compile time via HIST("myHistName")
-    template <char... chars>
-    constexpr HistName(const ConstStr<chars...>& hashedHistName);
+    template <FixedString S>
+    constexpr HistName(const ConstStr<S>& hashedHistName);
     char const* const str{};
     const uint32_t hash{};
     const uint32_t idx{};
@@ -386,8 +386,8 @@ int HistFiller::getBaseElementSize(T* ptr)
 //--------------------------------------------------------------------------------------------------
 //--------------------------------------------------------------------------------------------------
 
-template <char... chars>
-constexpr HistogramRegistry::HistName::HistName(const ConstStr<chars...>& hashedHistName)
+template <FixedString S>
+constexpr HistogramRegistry::HistName::HistName(const ConstStr<S>& hashedHistName)
   : str(hashedHistName.str),
     hash(hashedHistName.hash),
     idx(hash & REGISTRY_BITMASK)

Framework/Core/include/Framework/StringHelpers.h

@@ -122,18 +122,32 @@ consteval uint32_t compile_time_hash_from_literal(const char (&str)[N])
   return crc32(str, N - 2) ^ 0xFFFFFFFF;
 }
 
-template <char... chars>
+/// A string usable as a template argument, so that a compile-time string is
+/// one type per distinct text rather than one type per character.
+template <std::size_t N>
+struct FixedString {
+  char str[N]{};
+  constexpr FixedString(std::string_view s)
+  {
+    for (std::size_t i = 0; i + 1 < N; ++i) {
+      str[i] = s[i];
+    }
+  }
+  constexpr FixedString(const char (&s)[N]) : FixedString(std::string_view{s, N - 1}) {}
+};
+
+template <FixedString S>
 struct ConstStr {
-  static constexpr char str[] = {chars..., '\0'};
-  static constexpr uint32_t hash = compile_time_hash_from_literal(str);
+  static constexpr char const* str = S.str;
+  static constexpr uint32_t hash = compile_time_hash_from_literal(S.str);
 };
 
 template <typename>
 struct is_const_str : std::false_type {
 };
 
-template <char... chars>
-struct is_const_str<ConstStr<chars...>> : std::true_type {
+template <FixedString S>
+struct is_const_str<ConstStr<S>> : std::true_type {
 };
 
 template <typename T>
@@ -142,27 +156,27 @@ consteval bool is_const_str_v(T)
   return is_const_str<T>::value;
 }
 
-template <char... chars1, char... chars2>
-constexpr auto operator+(const ConstStr<chars1...>&, const ConstStr<chars2...>&)
+template <std::size_t N1, std::size_t N2>
+consteval FixedString<N1 + N2 - 1> concatenate(const FixedString<N1>& lhs, const FixedString<N2>& rhs)
 {
-  return ConstStr<chars1..., chars2...>{};
+  char str[N1 + N2 - 1]{};
+  for (std::size_t i = 0; i + 1 < N1; ++i) {
+    str[i] = lhs.str[i];
+  }
+  for (std::size_t i = 0; i + 1 < N2; ++i) {
+    str[N1 - 1 + i] = rhs.str[i];
+  }
+  return FixedString<N1 + N2 - 1>(std::string_view{str, N1 + N2 - 2});
 }
 
-namespace const_str_details
+template <FixedString S1, FixedString S2>
+constexpr auto operator+(const ConstStr<S1>&, const ConstStr<S2>&)
 {
-
-template <typename T, std::size_t... Is>
-constexpr auto as_chars_impl(std::index_sequence<Is...>)
-{
-  return ConstStr<T::str()[Is]...>{};
+  return ConstStr<concatenate(S1, S2)>{};
 }
 
-template <typename T>
-constexpr auto as_chars()
+namespace const_str_details
 {
-  return as_chars_impl<T>(
-    std::make_index_sequence<T::size() - 1>{});
-}
 
 template <int N>
 constexpr auto get_str(const char (&str)[N])
@@ -187,19 +201,7 @@ constexpr auto get_size(const std::string_view& str)
 }
 } // namespace const_str_details
 
-#define CONST_STR(literal)                                  \
-  [] {                                                      \
-    struct literal_to_chars {                               \
-      static constexpr decltype(auto) str()                 \
-      {                                                     \
-        return const_str_details::get_str(literal);         \
-      }                                                     \
-      static constexpr decltype(auto) size()                \
-      {                                                     \
-        return const_str_details::get_size(literal);        \
-      }                                                     \
-    };                                                      \
-    return const_str_details::as_chars<literal_to_chars>(); \
-  }()
+#define CONST_STR(literal) \
+  ConstStr<FixedString<const_str_details::get_size(literal)>(literal)> {}
 
 #endif // O2_FRAMEWORK_STRINGHELPERS_H

Framework/Core/test/test_StringHelpers.cxx

@@ -42,7 +42,7 @@ TEST_CASE("StringHelpersConstStr")
 
   auto myConstStr = CONST_STR("helloWorld");
   printString(myConstStr);
-  static_assert(std::same_as<decltype(myConstStr), ConstStr<'h', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd'>>);
+  static_assert(std::same_as<decltype(myConstStr), ConstStr<"helloWorld">>);
   static_assert(myConstStr.hash == (uint32_t)942280617);
   REQUIRE(myConstStr.hash == compile_time_hash("helloWorld"));
 
@@ -52,7 +52,8 @@ TEST_CASE("StringHelpersConstStr")
 
   auto myConstStr2 = CONST_STR("hello") + CONST_STR("Universe");
   printString(myConstStr2);
-  static_assert(std::same_as<decltype(myConstStr2), ConstStr<'h', 'e', 'l', 'l', 'o', 'U', 'n', 'i', 'v', 'e', 'r', 's', 'e'>>);
+  static_assert(std::same_as<decltype(myConstStr2), ConstStr<"helloUniverse">>);
+  static_assert((CONST_STR("a/") + CONST_STR("b/") + CONST_STR("c")).hash == compile_time_hash("a/b/c"));
 
   enum ParticleSpecies {
     kPion,