[ntuple] automatic evolution in and out std::atomic

Allow for std::atomic<T> --> T (or compatible) automatic conversion and
vice versa.

Author: jblomer

tree/ntuple/inc/ROOT/RNTupleDescriptor.hxx

@@ -153,6 +153,7 @@ public:
    /// The dictionary does not need to be available for this method.
    /// Needs the full descriptor to look up sub fields.
    bool IsCustomEnum(const RNTupleDescriptor &desc) const;
+   bool IsStdAtomic() const;
 };
 
 // clang-format off

tree/ntuple/src/RField.cxx

@@ -1099,8 +1099,11 @@ void ROOT::RAtomicField::ReconcileOnDiskField(const RNTupleDescriptor &desc)
    static const std::vector<std::string> prefixes = {"std::atomic<"};
 
    const auto &fieldDesc = desc.GetFieldDescriptor(GetOnDiskId());
-   EnsureMatchingOnDiskField(fieldDesc, kDiffTypeName);
-   EnsureMatchingTypePrefix(fieldDesc, prefixes);
+   if (fieldDesc.GetTypeName().rfind("std::atomic<", 0) == 0) {
+      EnsureMatchingOnDiskField(fieldDesc, kDiffTypeName);
+   } else {
+      fSubfields[0]->SetOnDiskId(GetOnDiskId());
+   }
 }
 
 std::vector<ROOT::RFieldBase::RValue> ROOT::RAtomicField::SplitValue(const RValue &value) const

tree/ntuple/src/RFieldBase.cxx

@@ -975,7 +975,13 @@ void ROOT::RFieldBase::ConnectPageSource(ROOT::Internal::RPageSource &pageSource
 
    if (!fIsArtificial) {
       R__ASSERT(fOnDiskId != kInvalidDescriptorId);
-      ReconcileOnDiskField(pageSource.GetSharedDescriptorGuard().GetRef());
+      // Handle moving from on-disk std::atomic<T> to (compatible of) T in memory centrally because otherwise
+      // we would need to handle it in each and every ReconcileOnDiskField()
+      const auto &desc = pageSource.GetSharedDescriptorGuard().GetRef();
+      if (!dynamic_cast<RAtomicField *>(this) && desc.GetFieldDescriptor(GetOnDiskId()).IsStdAtomic()) {
+         SetOnDiskId(desc.GetFieldDescriptor(GetOnDiskId()).GetLinkIds()[0]);
+      }
+      ReconcileOnDiskField(desc);
    }
 
    for (auto &f : fSubfields) {

tree/ntuple/src/RNTupleDescriptor.cxx

@@ -187,6 +187,13 @@ bool ROOT::RFieldDescriptor::IsCustomEnum(const RNTupleDescriptor &desc) const
                     desc.GetFieldDescriptor(subFieldId).GetTypeName()) != std::end(gIntTypeNames);
 }
 
+bool ROOT::RFieldDescriptor::IsStdAtomic() const
+{
+   if (fStructure != ROOT::ENTupleStructure::kPlain)
+      return false;
+   return (fTypeName.rfind("std::atomic<", 0) == 0);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 bool ROOT::RColumnDescriptor::operator==(const RColumnDescriptor &other) const

tree/ntuple/test/ntuple_evolution_type.cxx

@@ -251,3 +251,35 @@ TEST(RNTupleEvolution, ArrayAsRVec)
    EXPECT_EQ(1, a(0)[0]);
    EXPECT_EQ(2, a(0)[1]);
 }
+
+TEST(RNTupleEvolution, CheckAtomic)
+{
+   FileRaii fileGuard("test_ntuple_evolution_check_atomic.root");
+   {
+      auto model = ROOT::RNTupleModel::Create();
+      auto a = model->MakeField<std::atomic<std::int32_t>>("a");
+      auto i = model->MakeField<std::int32_t>("i");
+      auto writer = ROOT::RNTupleWriter::Recreate(std::move(model), "ntpl", fileGuard.GetPath());
+
+      *a = 7;
+      *i = 13;
+      writer->Fill();
+   }
+
+   auto reader = RNTupleReader::Open("ntpl", fileGuard.GetPath());
+
+   auto v1 = reader->GetView<std::atomic<std::int64_t>>("a");
+   auto v2 = reader->GetView<std::atomic<std::int64_t>>("i");
+   auto v3 = reader->GetView<std::int64_t>("a");
+
+   try {
+      reader->GetView<std::atomic<std::byte>>("a");
+      FAIL() << "automatic evolution into an invalid atomic inner type should fail";
+   } catch (const ROOT::RException &err) {
+      EXPECT_THAT(err.what(), testing::HasSubstr("cannot be matched to its in-memory type"));
+   }
+
+   EXPECT_EQ(7, v1(0));
+   EXPECT_EQ(13, v2(0));
+   EXPECT_EQ(7, v3(0));
+}