New ModelArrayRef

core/src/ModelComponent.cpp

@@ -10,8 +10,7 @@
 namespace Nextsim {
 
 std::unordered_map<std::string, ModelComponent*> ModelComponent::registeredModules;
-MARBackingStore ModelComponent::sharedArrays(static_cast<size_t>(SharedArray::COUNT));
-MARConstBackingStore ModelComponent::protectedArrays(static_cast<size_t>(ProtectedArray::COUNT));
+MARStore ModelComponent::store;
 ModelArray* ModelComponent::p_oceanMaskH = nullptr;
 size_t ModelComponent::nOcean;
 std::vector<size_t> ModelComponent::oceanIndex;
@@ -47,18 +46,6 @@ void ModelComponent::getAllFieldNames(std::unordered_set<std::string>& uF,
     }
 }
 
-void ModelComponent::registerSharedArray(SharedArray type, ModelArray* addr)
-{
-    // Assignment of pointer in array
-    sharedArrays[static_cast<size_t>(type)] = addr;
-}
-
-void ModelComponent::registerProtectedArray(ProtectedArray type, const ModelArray* addr)
-{
-    // Assignment of pointer in array
-    protectedArrays[static_cast<size_t>(type)] = addr;
-}
-
 /*
  * This assumes that the HField array size has already been set in the restart
  * reading routine. The mask, like all ModelArrays, is double precision,

core/src/PrognosticData.cpp

@@ -22,10 +22,10 @@ PrognosticData::PrognosticData()
     , pOcnBdy(0)
 
 {
-    registerProtectedArray(ProtectedArray::H_ICE, &m_thick);
-    registerProtectedArray(ProtectedArray::C_ICE, &m_conc);
-    registerProtectedArray(ProtectedArray::H_SNOW, &m_snow);
-    registerProtectedArray(ProtectedArray::T_ICE, &m_tice);
+    getStore().registerArray(Protected::H_ICE, &m_thick);
+    getStore().registerArray(Protected::C_ICE, &m_conc);
+    getStore().registerArray(Protected::H_SNOW, &m_snow);
+    getStore().registerArray(Protected::T_ICE, &m_tice);
 }
 
 void PrognosticData::configure()
@@ -71,10 +71,10 @@ void PrognosticData::update(const TimestepTime& tst)
     iceGrowth.update(tst);
     pOcnBdy->updateAfter(tst);
 
-    ModelArrayRef<SharedArray::H_ICE, MARBackingStore, RO> hiceTrueUpd(getSharedArray());
-    ModelArrayRef<SharedArray::C_ICE, MARBackingStore, RO> ciceUpd(getSharedArray());
-    ModelArrayRef<SharedArray::H_SNOW, MARBackingStore, RO> hsnowTrueUpd(getSharedArray());
-    ModelArrayRef<SharedArray::T_ICE, MARBackingStore, RO> ticeUpd(getSharedArray());
+    ModelArrayRef<Shared::H_ICE, RO> hiceTrueUpd(getStore());
+    ModelArrayRef<Shared::C_ICE, RO> ciceUpd(getStore());
+    ModelArrayRef<Shared::H_SNOW, RO> hsnowTrueUpd(getStore());
+    ModelArrayRef<Shared::T_ICE, RO> ticeUpd(getStore());
 
     // Calculate the cell average thicknesses
     HField hiceUpd = hiceTrueUpd * ciceUpd;

core/src/include/MARStore.hpp

@@ -0,0 +1,126 @@
+/*!
+ * @file MARBackingStore.hpp
+ *
+ * @date 22 Feb 2023
+ * @author Tim Spain <timothy.spain@nersc.no>
+ */
+
+#ifndef MARSTORE_HPP
+#define MARSTORE_HPP
+
+#include <list>
+#include <string>
+#include <unordered_map>
+
+struct TextTag;
+
+namespace Nextsim {
+
+class ModelArray;
+
+typedef ModelArray* ModelArrayReference;
+typedef const ModelArray* ModelArrayConstReference;
+
+class MARStore {
+public:
+    void registerArray(const std::string& field, ModelArray* ptr, bool isReadWrite = false)
+    {
+        // Clean the old array, if set
+        if (storeRW.count(field)) {
+            // If the pointer was in the RW array, null it
+            storeRW[field] = nullptr;
+            // Set any RW references with this field to nullptr
+            auto range = referencesRW.equal_range(field);
+            for (auto it = range.first; it != range.second; ++it) {
+                *(it->second) = nullptr;
+            }
+        } else if (storeRO.count(field)) {
+            storeRO[field] = nullptr;
+        }
+        // Set any RO references with this field to nullptr
+        auto range = referencesRO.equal_range(field);
+        for (auto it = range.first; it != range.second; ++it) {
+            *(it->second) = nullptr;
+        }
+
+        // Set the new reference based on the passed access boolean
+        if (!isReadWrite) {
+            storeRO[field] = ptr;
+        } else {
+            storeRW[field] = ptr;
+            auto range = referencesRW.equal_range(field);
+            for (auto it = range.first; it != range.second; ++it) {
+                *(it->second) = ptr;
+            }
+        }
+        range = referencesRO.equal_range(field);
+        for (auto it = range.first; it != range.second; ++it) {
+            *(it->second) = ptr;
+        }
+    }
+
+    std::unordered_map<std::string, const ModelArray*> getAllData() const
+    {
+        std::unordered_map<std::string, const ModelArray*> dataMap;
+
+        for (auto entry : storeRW) {
+            dataMap.insert(entry);
+        }
+        for (auto entry : storeRO) {
+            dataMap.insert(entry);
+        }
+        return dataMap;
+    }
+
+private:
+    ModelArray* getFieldAddr(const std::string& field, ModelArrayReference& ptr)
+    {
+        // Add this address to the waiting list for RW fields.
+        referencesRW.insert({ field, &ptr });
+        return storeRW.count(field) ? ptr = storeRW.at(field) : nullptr;
+    }
+
+    const ModelArray* getFieldAddr(const std::string& field, ModelArrayConstReference& ptr)
+    {
+        referencesRO.insert({ field, &ptr });
+        if (storeRO.count(field)) {
+            ptr = storeRO.at(field);
+            return ptr;
+        } else if (storeRW.count(field)) {
+            ptr = storeRW.at(field);
+            return ptr;
+        } else {
+            return nullptr;
+        }
+    }
+
+    void removeReference(const std::string& field, ModelArrayConstReference& ptr)
+    {
+        auto range = referencesRO.equal_range(field);
+        for (auto it = range.first; it != range.second;)
+            if (it->second == &ptr)
+                it = referencesRO.erase(it);
+            else
+                ++it;
+    }
+
+    void removeReference(const std::string& field, ModelArrayReference& ptr)
+    {
+        auto range = referencesRW.equal_range(field);
+        for (auto it = range.first; it != range.second;)
+            if (it->second == &ptr)
+                it = referencesRW.erase(it);
+            else
+                ++it;
+    }
+
+    std::unordered_map<std::string, ModelArray*> storeRO;
+    std::unordered_map<std::string, ModelArray*> storeRW;
+    std::unordered_multimap<std::string, ModelArrayReference*> referencesRW;
+    std::unordered_multimap<std::string, ModelArrayConstReference*> referencesRO;
+    template <const TextTag& fieldName, bool isReadWrite> friend class ModelArrayRef;
+};
+
+}
+
+#endif /* MARSTORE_HPP */