Hadrons: grids stored with hash of SIMD type (for mixed-precision setups)

Hadrons/Environment.cc

@@ -43,137 +43,24 @@ HADRONS_ERROR_REF(ObjectDefinition, "no object with address " + std::to_string(a
 // constructor /////////////////////////////////////////////////////////////////
 Environment::Environment(void)
 {
-    dim_ = GridDefaultLatt();
+    dim_         = GridDefaultLatt();
-    nd_  = dim_.size();
+    nd_          = dim_.size();
-    grid4d_.reset(SpaceTimeGrid::makeFourDimGrid(
+    defaultGrid_ = {typeHash<vComplex>(), 1};
-        dim_, GridDefaultSimd(nd_, vComplex::Nsimd()),
+    grid4d_[defaultGrid_].reset(
-        GridDefaultMpi()));
+        SpaceTimeGrid::makeFourDimGrid(dim_, 
-    gridRb4d_.reset(SpaceTimeGrid::makeFourDimRedBlackGrid(grid4d_.get()));
+                                       GridDefaultSimd(nd_, vComplex::Nsimd()),
+                                       GridDefaultMpi()));
+    gridRb4d_[defaultGrid_].reset(
+        SpaceTimeGrid::makeFourDimRedBlackGrid(grid4d_[defaultGrid_].get()));
     vol_ = 1.;
     for (auto d: dim_)
     {
         vol_ *= d;
     }
-    rng4d_.reset(new GridParallelRNG(grid4d_.get()));
+    rng4d_.reset(new GridParallelRNG(grid4d_[defaultGrid_].get()));
 }
 
 // grids ///////////////////////////////////////////////////////////////////////
-void Environment::createGrid(const unsigned int Ls)
-{
-    if ((Ls > 1) and (grid5d_.find(Ls) == grid5d_.end()))
-    {
-        auto g = getGrid();
-        
-        grid5d_[Ls].reset(SpaceTimeGrid::makeFiveDimGrid(Ls, g));
-        gridRb5d_[Ls].reset(SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls, g));
-    }
-}
-
-void Environment::createCoarseGrid(const std::vector<int> &blockSize, 
-                                   const unsigned int Ls)
-{
-    int              nd      = getNd();
-    std::vector<int> fineDim = getDim(), coarseDim;
-    unsigned int     cLs;
-    auto             key4d = blockSize, key5d = blockSize;
-
-    createGrid(Ls);
-    coarseDim.resize(nd);
-    for (int d = 0; d < coarseDim.size(); d++)
-    {
-        coarseDim[d] = fineDim[d]/blockSize[d];
-        if (coarseDim[d]*blockSize[d] != fineDim[d])
-        {
-            HADRONS_ERROR(Size, "Fine dimension " + std::to_string(d) 
-                         + " (" + std::to_string(fineDim[d]) 
-                         + ") not divisible by coarse dimension ("
-                         + std::to_string(coarseDim[d]) + ")"); 
-        }
-    }
-    if (blockSize.size() > nd)
-    {
-        cLs = Ls/blockSize[nd];
-        if (cLs*blockSize[nd] != Ls)
-        {
-            HADRONS_ERROR(Size, "Fine Ls (" + std::to_string(Ls) 
-                         + ") not divisible by coarse Ls ("
-                         + std::to_string(cLs) + ")");
-        }
-        key4d.resize(nd);
-        key5d.push_back(Ls);
-    }
-    gridCoarse4d_[key4d].reset(
-        SpaceTimeGrid::makeFourDimGrid(coarseDim, 
-            GridDefaultSimd(nd, vComplex::Nsimd()), GridDefaultMpi()));
-    if (Ls > 1)
-    {
-        gridCoarse5d_[key5d].reset(
-            SpaceTimeGrid::makeFiveDimGrid(cLs, gridCoarse4d_[key4d].get()));
-    }
-}
-
-GridCartesian * Environment::getGrid(const unsigned int Ls) const
-{
-    try
-    {
-        if (Ls == 1)
-        {
-            return grid4d_.get();
-        }
-        else
-        {
-            return grid5d_.at(Ls).get();
-        }
-    }
-    catch(std::out_of_range &)
-    {
-        HADRONS_ERROR(Definition, "no grid with Ls= " + std::to_string(Ls));
-    }
-}
-
-GridRedBlackCartesian * Environment::getRbGrid(const unsigned int Ls) const
-{
-    try
-    {
-        if (Ls == 1)
-        {
-            return gridRb4d_.get();
-        }
-        else
-        {
-            return gridRb5d_.at(Ls).get();
-        }
-    }
-    catch(std::out_of_range &)
-    {
-        HADRONS_ERROR(Definition, "no red-black grid with Ls= " + std::to_string(Ls));
-    }
-}
-
-GridCartesian * Environment::getCoarseGrid(
-    const std::vector<int> &blockSize, const unsigned int Ls) const
-{
-    auto key = blockSize;
-
-    try
-    {
-        if (Ls == 1)
-        {
-            key.resize(getNd());
-            return gridCoarse4d_.at(key).get();
-        }
-        else
-        {
-            key.push_back(Ls);
-            return gridCoarse5d_.at(key).get();
-        }
-    }
-    catch(std::out_of_range &)
-    {
-        HADRONS_ERROR(Definition, "no coarse grid with Ls= " + std::to_string(Ls));
-    }
-}
-
 unsigned int Environment::getNd(void) const
 {
     return nd_;

Hadrons/Environment.hpp

@@ -83,15 +83,28 @@ private:
         int                     module{-1};
         std::unique_ptr<Object> data{nullptr};
     };
+    typedef std::pair<size_t, unsigned int>     FineGridKey;
+    typedef std::pair<size_t, std::vector<int>> CoarseGridKey;
 public:
     // grids
+    template <typename VType = vComplex>
     void                    createGrid(const unsigned int Ls);
+    template <typename VType = vComplex>
     void                    createCoarseGrid(const std::vector<int> &blockSize,
                                              const unsigned int Ls = 1);
-    GridCartesian *         getGrid(const unsigned int Ls = 1) const;
+    template <typename VType = vComplex>
-    GridRedBlackCartesian * getRbGrid(const unsigned int Ls = 1) const;
+    GridCartesian *         getGrid(void) const;
+    template <typename VType = vComplex>
+    GridRedBlackCartesian * getRbGrid(void) const;
+    template <typename VType = vComplex>
+    GridCartesian *         getCoarseGrid(const std::vector<int> &blockSize) const;
+    template <typename VType = vComplex>
+    GridCartesian *         getGrid(const unsigned int Ls) const;
+    template <typename VType = vComplex>
+    GridRedBlackCartesian * getRbGrid(const unsigned int Ls) const;
+    template <typename VType = vComplex>
     GridCartesian *         getCoarseGrid(const std::vector<int> &blockSize,
-                                          const unsigned int Ls = 1) const;
+                                          const unsigned int Ls) const;
     std::vector<int>        getDim(void) const;
     int                     getDim(const unsigned int mu) const;
     unsigned int            getNd(void) const;
@@ -154,22 +167,23 @@ public:
     void                    printContent(void) const;
 private:
     // general
-    double                                 vol_;
+    double                              vol_;
-    bool                                   protect_{true};
+    bool                                protect_{true};
     // grids
-    std::vector<int>                       dim_;
+    std::vector<int>                    dim_;
-    GridPt                                 grid4d_;
+    FineGridKey                         defaultGrid_;
-    std::map<unsigned int, GridPt>         grid5d_;
+    std::map<FineGridKey, GridPt>       grid4d_;
-    GridRbPt                               gridRb4d_;
+    std::map<FineGridKey, GridPt>       grid5d_;
-    std::map<unsigned int, GridRbPt>       gridRb5d_;
+    std::map<FineGridKey, GridRbPt>     gridRb4d_;
-    std::map<std::vector<int>, GridPt>     gridCoarse4d_;
+    std::map<FineGridKey, GridRbPt>     gridRb5d_;
-    std::map<std::vector<int>, GridPt>     gridCoarse5d_;
+    std::map<CoarseGridKey, GridPt>     gridCoarse4d_;
-    unsigned int                           nd_;
+    std::map<CoarseGridKey, GridPt>     gridCoarse5d_;
+    unsigned int                        nd_;
     // random number generator
-    RngPt                                  rng4d_;
+    RngPt                               rng4d_;
     // object store
-    std::vector<ObjInfo>                   object_;
+    std::vector<ObjInfo>                object_;
-    std::map<std::string, unsigned int>    objectAddress_;
+    std::map<std::string, unsigned int> objectAddress_;
 };
 
 /******************************************************************************
@@ -203,6 +217,191 @@ void Holder<T>::reset(T *pt)
 /******************************************************************************
  *                     Environment template implementation                    *
  ******************************************************************************/
+// grids ///////////////////////////////////////////////////////////////////////
+template <typename VType>
+void Environment::createGrid(const unsigned int Ls)
+{
+    size_t hash = typeHash<VType>();
+
+    if (grid4d_.find({hash, 1}) == grid4d_.end())
+    {
+        grid4d_[{hash, 1}].reset(
+            SpaceTimeGrid::makeFourDimGrid(getDim(), 
+                                        GridDefaultSimd(getNd(), VType::Nsimd()),
+                                        GridDefaultMpi()));
+        gridRb4d_[{hash, 1}].reset(
+            SpaceTimeGrid::makeFourDimRedBlackGrid(grid4d_[{hash, 1}].get()));
+    }
+    if (grid5d_.find({hash, Ls}) == grid5d_.end())
+    {
+        auto g = grid4d_[{hash, 1}].get();
+        
+        grid5d_[{hash, Ls}].reset(SpaceTimeGrid::makeFiveDimGrid(Ls, g));
+        gridRb5d_[{hash, Ls}].reset(SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls, g));
+    }
+}
+
+template <typename VType>
+void Environment::createCoarseGrid(const std::vector<int> &blockSize,
+                                   const unsigned int Ls)
+{
+    int              nd      = getNd();
+    std::vector<int> fineDim = getDim(), coarseDim(nd);
+    unsigned int     cLs;
+    auto             key4d = blockSize, key5d = blockSize;
+    size_t           hash  = typeHash<VType>();
+
+    createGrid(Ls);
+    for (int d = 0; d < coarseDim.size(); d++)
+    {
+        coarseDim[d] = fineDim[d]/blockSize[d];
+        if (coarseDim[d]*blockSize[d] != fineDim[d])
+        {
+            HADRONS_ERROR(Size, "Fine dimension " + std::to_string(d) 
+                         + " (" + std::to_string(fineDim[d]) 
+                         + ") not divisible by coarse dimension ("
+                         + std::to_string(coarseDim[d]) + ")"); 
+        }
+    }
+    if (blockSize.size() > nd)
+    {
+        cLs = Ls/blockSize[nd];
+        if (cLs*blockSize[nd] != Ls)
+        {
+            HADRONS_ERROR(Size, "Fine Ls (" + std::to_string(Ls) 
+                         + ") not divisible by coarse Ls ("
+                         + std::to_string(cLs) + ")");
+        }
+    }
+    else
+    {
+        cLs = Ls;
+    }
+    key4d.resize(nd);
+    key5d.push_back(Ls);
+
+    CoarseGridKey hkey4d = {hash, key4d}, hkey5d = {hash, key5d};
+
+    if (gridCoarse4d_.find(hkey4d) == gridCoarse4d_.end())
+    {
+        gridCoarse4d_[hkey4d].reset(
+            SpaceTimeGrid::makeFourDimGrid(coarseDim, 
+                GridDefaultSimd(nd, VType::Nsimd()), GridDefaultMpi()));
+    }
+    if (gridCoarse5d_.find(hkey5d) == gridCoarse5d_.end())
+    {
+        gridCoarse5d_[hkey5d].reset(
+            SpaceTimeGrid::makeFiveDimGrid(cLs, gridCoarse4d_[hkey4d].get()));
+    }
+}
+
+template <typename VType>
+GridCartesian * Environment::getGrid(void) const
+{
+    auto it = grid4d_.find({typeHash<VType>(), 1});
+
+    if (it != grid4d_.end())
+    {
+        return it->second.get();
+    }
+    else
+    {
+        HADRONS_ERROR(Definition, "no 4D grid for SIMD type '" 
+                                  + typeName<VType>() + "'");
+    }
+}
+
+template <typename VType>
+GridRedBlackCartesian * Environment::getRbGrid(void) const
+{
+    auto it = gridRb4d_.find({typeHash<VType>(), 1});
+
+    if (it != gridRb4d_.end())
+    {
+        return it->second.get();
+    }
+    else
+    {
+        HADRONS_ERROR(Definition, "no 4D red-black grid for SIMD type '" 
+                                  + typeName<VType>() + "'");
+    }
+}
+
+template <typename VType>
+GridCartesian * Environment::getCoarseGrid(const std::vector<int> &blockSize) const
+{
+    std::vector<int> s = blockSize;
+
+    s.resize(getNd());
+    auto it = gridCoarse4d_.find({typeHash<VType>(), s});
+    if (it != gridCoarse4d_.end())
+    {
+        return it->second.get();
+    }
+    else
+    {
+        HADRONS_ERROR(Definition, "no 4D coarse grid for SIMD type '" 
+                                  + typeName<VType>() + "' and block size "
+                                  + vecToStr(blockSize));
+    }
+}
+
+template <typename VType>
+GridCartesian * Environment::getGrid(const unsigned int Ls) const
+{
+    auto it = grid5d_.find({typeHash<VType>(), Ls});
+
+    if (it != grid5d_.end())
+    {
+        return it->second.get();
+    }
+    else
+    {
+        HADRONS_ERROR(Definition, "no 5D grid for SIMD type '" 
+                                  + typeName<VType>() + "' and Ls = "
+                                  + std::to_string(Ls));
+    }
+}
+
+template <typename VType>
+GridRedBlackCartesian * Environment::getRbGrid(const unsigned int Ls) const
+{
+    auto it = gridRb5d_.find({typeHash<VType>(), Ls});
+
+    if (it != gridRb5d_.end())
+    {
+        return it->second.get();
+    }
+    else
+    {
+        HADRONS_ERROR(Definition, "no 5D red-black grid for SIMD type '" 
+                                  + typeName<VType>() + "' and Ls = "
+                                  + std::to_string(Ls));
+    }
+}
+
+template <typename VType>
+GridCartesian * Environment::getCoarseGrid(const std::vector<int> &blockSize,
+                                           const unsigned int Ls) const
+{
+    std::vector<int> s = blockSize;
+
+    s.push_back(Ls);
+    auto it = gridCoarse5d_.find({typeHash<VType>(), s});
+    if (it != gridCoarse5d_.end())
+    {
+        return it->second.get();
+    }
+    else
+    {
+        HADRONS_ERROR(Definition, "no 5D coarse grid for SIMD type '" 
+                                  + typeName<VType>() + "', block size "
+                                  + vecToStr(blockSize)
+                                  + " and Ls = " + std::to_string(Ls));
+    }
+}
+
+
 // general memory management ///////////////////////////////////////////////////
 template <typename B, typename T, typename ... Ts>
 void Environment::createDerivedObject(const std::string name,
@@ -230,19 +429,19 @@ void Environment::createDerivedObject(const std::string name,
         object_[address].Ls          = Ls;
         object_[address].data.reset(new Holder<B>(new T(std::forward<Ts>(args)...)));
         object_[address].size        = MemoryProfiler::stats->maxAllocated - initMem;
-        object_[address].type        = &typeid(B);
+        object_[address].type        = typeIdPt<B>();
-        object_[address].derivedType = &typeid(T);
+        object_[address].derivedType = typeIdPt<T>();
         if (MemoryProfiler::stats == &memStats)
         {
             MemoryProfiler::stats = nullptr;
         }
     }
     // object already exists, no error if it is a cache, error otherwise
-    else if ((object_[address].storage     != Storage::cache) or 
+    else if ((object_[address].storage               != Storage::cache) or 
-             (object_[address].storage     != storage)        or
+             (object_[address].storage               != storage)        or
-             (object_[address].name        != name)           or
+             (object_[address].name                  != name)           or
-             (object_[address].type        != &typeid(B))     or
+             (typeHash(object_[address].type)        != typeHash<B>())  or
-             (object_[address].derivedType != &typeid(T)))
+             (typeHash(object_[address].derivedType) != typeHash<T>()))
     {
         HADRONS_ERROR_REF(ObjectDefinition, "object '" + name + "' already allocated", address);
     }

Hadrons/Global.cc

@@ -72,6 +72,11 @@ void Hadrons::initLogger(void)
 }
 
 // type utilities //////////////////////////////////////////////////////////////
+size_t Hadrons::typeHash(const std::type_info *info)
+{
+    return info->hash_code();
+}
+
 constexpr unsigned int maxNameSize = 1024u;
 
 std::string Hadrons::typeName(const std::type_info *info)

Hadrons/Global.hpp

@@ -155,14 +155,28 @@ const std::type_info * typeIdPt(const T &x)
     return &typeid(x);
 }
 
-std::string typeName(const std::type_info *info);
-
 template <typename T>
 const std::type_info * typeIdPt(void)
 {
     return &typeid(T);
 }
 
+size_t typeHash(const std::type_info *info);
+
+template <typename T>
+size_t typeHash(const T &x)
+{
+    return typeHash(typeIdPt(x));
+}
+
+template <typename T>
+size_t typeHash(void)
+{
+    return typeHash(typeIdPt<T>());
+}
+
+std::string typeName(const std::type_info *info);
+
 template <typename T>
 std::string typeName(const T &x)
 {