Sha used to seed from a unique string

benchmarks/Benchmark_dwf.cc

@@ -76,9 +76,9 @@ int main (int argc, char ** argv)
   std::vector<int> seeds5({5,6,7,8});
   
   std::cout << GridLogMessage << "Initialising 4d RNG" << std::endl;
-  GridParallelRNG          RNG4(UGrid);  RNG4.SeedFixedIntegers(seeds4);
+  GridParallelRNG          RNG4(UGrid);  RNG4.SeedUniqueString(std::string("The 4D RNG"));
   std::cout << GridLogMessage << "Initialising 5d RNG" << std::endl;
-  GridParallelRNG          RNG5(FGrid);  RNG5.SeedFixedIntegers(seeds5);
+  GridParallelRNG          RNG5(FGrid);  RNG5.SeedUniqueString(std::string("The 5D RNG"));
   std::cout << GridLogMessage << "Initialised RNGs" << std::endl;
 
   LatticeFermion src   (FGrid); random(RNG5,src);

lib/GridCore.h

@@ -48,6 +48,7 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 #include <Grid/serialisation/Serialisation.h>
 #include <Grid/threads/Threads.h>
 #include <Grid/util/Util.h>
+#include <Grid/util/Sha.h>
 #include <Grid/communicator/Communicator.h> 
 #include <Grid/cartesian/Cartesian.h>    
 #include <Grid/tensors/Tensors.h>      

lib/lattice/Lattice_rng.h

@@ -251,7 +251,7 @@ namespace Grid {
 
       dist[0].reset();
       for(int idx=0;idx<words;idx++){
-  fillScalar(buf[idx],dist[0],_generators[0]);
+	fillScalar(buf[idx],dist[0],_generators[0]);
       }
 
       CartesianCommunicator::BroadcastWorld(0,(void *)&l,sizeof(l));
@@ -283,7 +283,7 @@ namespace Grid {
       RealF *pointer=(RealF *)&l;
       dist[0].reset();
       for(int i=0;i<2*vComplexF::Nsimd();i++){
-  fillScalar(pointer[i],dist[0],_generators[0]);
+	fillScalar(pointer[i],dist[0],_generators[0]);
       }
       CartesianCommunicator::BroadcastWorld(0,(void *)&l,sizeof(l));
     }
@@ -291,7 +291,7 @@ namespace Grid {
       RealD *pointer=(RealD *)&l;
       dist[0].reset();
       for(int i=0;i<2*vComplexD::Nsimd();i++){
-  fillScalar(pointer[i],dist[0],_generators[0]);
+	fillScalar(pointer[i],dist[0],_generators[0]);
       }
       CartesianCommunicator::BroadcastWorld(0,(void *)&l,sizeof(l));
     }
@@ -299,7 +299,7 @@ namespace Grid {
       RealF *pointer=(RealF *)&l;
       dist[0].reset();
       for(int i=0;i<vRealF::Nsimd();i++){
-  fillScalar(pointer[i],dist[0],_generators[0]);
+	fillScalar(pointer[i],dist[0],_generators[0]);
       }
       CartesianCommunicator::BroadcastWorld(0,(void *)&l,sizeof(l));
     }
@@ -317,6 +317,17 @@ namespace Grid {
       std::seed_seq src(seeds.begin(),seeds.end());
       Seed(src,0);
     }
+
+    void SeedUniqueString(const std::string &s){
+      std::vector<int> seeds;
+      seeds = GridChecksum::sha256_seeds(s);
+      std::cout << GridLogMessage << "Intialising Serial RNG with unique string " <<s<< std::endl;
+      std::cout << GridLogMessage << "SHA seeds are: " <<s<< std::endl;
+      for(int i=0;i<seeds.size();i++){
+	std::cout << GridLogMessage << "\t " <<seeds[i]<< std::endl;
+      }
+      SeedFixedIntegers(seeds);
+    }
   };
 
   class GridParallelRNG : public GridRNGbase {
@@ -377,6 +388,16 @@ namespace Grid {
       _time_counter += usecond()- inner_time_counter;
     };
 
+    void SeedUniqueString(const std::string &s){
+      std::vector<int> seeds;
+      seeds = GridChecksum::sha256_seeds(s);
+      std::cout << GridLogMessage << "Intialising Parallel RNG with unique string " <<s<< std::endl;
+      std::cout << GridLogMessage << "SHA seeds are: " <<s<< std::endl;
+      for(int i=0;i<seeds.size();i++){
+	std::cout << GridLogMessage << "\t " <<seeds[i]<< std::endl;
+      }
+      SeedFixedIntegers(seeds);
+    }
     void SeedFixedIntegers(const std::vector<int> &seeds){
 
       // Everyone generates the same seed_seq based on input seeds

lib/util/Sha.h

@@ -0,0 +1,70 @@
+   /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./lib/util/Sha.h
+
+    Copyright (C) 2018
+
+    Author: Peter Boyle
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+    *************************************************************************************/
+    /*  END LEGAL */
+extern "C" {
+#include <openssl/sha.h>
+}
+
+#pragma once
+
+class GridChecksum
+{
+public:
+  static inline uint32_t crc32(void *data,size_t bytes)
+  {
+    return ::crc32(0L,(unsigned char *)data,bytes);
+  }
+  static inline std::vector<unsigned char> sha256(void *data,size_t bytes)
+  {
+    std::vector<unsigned char> hash(SHA256_DIGEST_LENGTH);
+    SHA256_CTX sha256;
+    SHA256_Init  (&sha256);
+    SHA256_Update(&sha256, data,bytes);
+    SHA256_Final (&hash[0], &sha256);
+    return hash;
+  }
+  static inline std::vector<int> sha256_seeds(const std::string &s)
+  {
+    std::vector<int> seeds;
+    std::vector<unsigned char> uchars = sha256((void *)s.c_str(),s.size());
+    for(int i=0;i<uchars.size();i++) seeds.push_back(uchars[i]);
+    return seeds;
+  }
+};
+
+/*
+int main(int argc,char **argv)
+{
+  std::string s("The quick brown fox jumps over the lazy dog");
+  auto csum = GridChecksum::sha256_seeds(s);
+  std::cout << "SHA256 sum is 0x";
+  for(int i=0;i<csum.size;i++) { 
+    std::cout << std::hex << csum[i];
+  }
+  std::cout << std::endl;
+}
+*/