Reorganised the TODO. Really getting somewhere

lib/Grid_init.cc

@@ -10,18 +10,57 @@
 #include <sys/stat.h> 
 #include <sys/time.h>
 #include <signal.h>
-
+#include <iostream>
 #include <Grid.h>
 
 #undef __X86_64
+#define MAC
+
+#ifdef MAC
+#include <execinfo.h>
+#endif
+
 namespace Grid {
 
+  std::streambuf *Grid_saved_stream_buf;
+#if 0
+  void Grid_quiesce_nodes(void)
+  {
+#ifdef GRID_COMMS_MPI
+    int me;
+    MPI_Comm_rank(MPI_COMM_WORLD,&me);
+    std::streambuf* Grid_saved_stream_buf = std::cout.rdbuf();
+    if ( me ) { 
+      std::ofstream file("log.node");
+      std::cout.rdbuf(file.rdbuf());
+    }
+#endif
+  }
+#endif
+  void Grid_quiesce_nodes(void)
+  {
+#ifdef GRID_COMMS_MPI
+    int me;
+    MPI_Comm_rank(MPI_COMM_WORLD,&me);
+    if ( me ) { 
+      std::cout.setstate(std::ios::badbit);
+    }
+#endif
+  }
+  void Grid_unquiesce_nodes(void)
+  {
+#ifdef GRID_COMMS_MPI
+    std::cout.clear();
+#endif
+  }
+
 void Grid_init(int *argc,char ***argv)
 {
 #ifdef GRID_COMMS_MPI
   MPI_Init(argc,argv);
 #endif
   Grid_debug_handler_init();
+  Grid_quiesce_nodes();
 }
 void Grid_finalize(void)
 {
@@ -35,6 +74,10 @@ double usecond(void) {
   return 1.0*tv.tv_usec + 1.0e6*tv.tv_sec;
 }
 
+
+#define _NBACKTRACE (256)
+void * Grid_backtrace_buffer[_NBACKTRACE];
+
 void Grid_sa_signal_handler(int sig,siginfo_t *si,void * ptr)
 {
   printf("Caught signal %d\n",si->si_signo);
@@ -43,10 +86,8 @@ void Grid_sa_signal_handler(int sig,siginfo_t *si,void * ptr)
 
 #ifdef __X86_64
     ucontext_t * uc= (ucontext_t *)ptr;
-
   struct sigcontext *sc = (struct sigcontext *)&uc->uc_mcontext;
   printf("  instruction %llx\n",(uint64_t)sc->rip);
-
 #define REG(A)  printf("  %s %lx\n",#A, sc-> A);
   REG(rdi);
   REG(rsi);
@@ -68,14 +109,14 @@ void Grid_sa_signal_handler(int sig,siginfo_t *si,void * ptr)
   REG(r14);
   REG(r15);
 #endif
-
-  fflush(stdout);
-
-  if ( si->si_signo == SIGSEGV ) {
-    printf("Grid_sa_signal_handler: Oops... this was a sigsegv you naughty naughty programmer. Goodbye\n");
-    fflush(stdout);
-    exit(-1);
+#ifdef MAC
+  int symbols    = backtrace        (Grid_backtrace_buffer,_NBACKTRACE);
+  char **strings = backtrace_symbols(Grid_backtrace_buffer,symbols);
+  for (int i = 0; i < symbols; i++){
+    printf ("%s\n", strings[i]);
   }
+#endif
+  exit(0);
   return;
 };
 

lib/Grid_summation.h

@@ -16,6 +16,96 @@ inline void subdivides(GridBase *coarse,GridBase *fine)
   }
 }
 
+template<class vobj,int nbasis>
+inline void projectBlockBasis(Lattice<iVector<vComplex,nbasis > > &coarseData,
+			      const             Lattice<vobj>   &fineData,
+			      const std::vector<Lattice<vobj> > &Basis)
+{
+  GridBase * fine  = fineData._grid;
+  GridBase * coarse= coarseData._grid;
+  int  _ndimension = coarse->_ndimension;
+
+  // checks
+  assert( nbasis == Basis.size() );
+  subdivides(coarse,fine); 
+  for(int i=0;i<nbasis;i++){
+    conformable(Basis,fineData);
+  }
+
+  std::vector<int>  block_r      (_ndimension);
+  
+  for(int d=0 ; d<_ndimension;d++){
+    block_r[d] = fine->_rdimensions[d] / coarse->_rdimensions[d];
+  }
+
+  coarseData=zero;
+
+  // Loop with a cache friendly loop ordering
+  for(int sf=0;sf<fine->oSites();sf++){
+
+    int sc;
+    std::vector<int> coor_c(_ndimension);
+    std::vector<int> coor_f(_ndimension);
+    GridBase::CoorFromIndex(coor_f,sf,fine->_rdimensions);
+    for(int d=0;d<_ndimension;d++) coor_c[d]=coor_f[d]/block_r[d];
+    GridBase::IndexFromCoor(coor_c,sc,coarse->_rdimensions);
+
+    for(int i=0;i<nbasis;i++) {
+      
+      coarseData._odata[sc][i]=coarseData._odata[sc][i]
+	+ innerProduct(Basis[i]._odata[sf],fineData._odata[sf]);
+
+    }
+  }
+  return;
+  
+}
+
+
+template<class vobj,int nbasis>
+inline void promoteBlockBasis(const Lattice<iVector<vComplex,nbasis > > &coarseData,
+			                        Lattice<vobj>   &fineData,
+			      const std::vector<Lattice<vobj> > &Basis)
+{
+  GridBase * fine  = fineData._grid;
+  GridBase * coarse= coarseData._grid;
+  int  _ndimension = coarse->_ndimension;
+
+  // checks
+  assert( nbasis == Basis.size() );
+  subdivides(coarse,fine); 
+  for(int i=0;i<nbasis;i++){
+    conformable(Basis,fineData);
+  }
+
+  std::vector<int>  block_r      (_ndimension);
+  
+  for(int d=0 ; d<_ndimension;d++){
+    block_r[d] = fine->_rdimensions[d] / coarse->_rdimensions[d];
+  }
+
+  // Loop with a cache friendly loop ordering
+  for(int sf=0;sf<fine->oSites();sf++){
+
+    int sc;
+    std::vector<int> coor_c(_ndimension);
+    std::vector<int> coor_f(_ndimension);
+
+    GridBase::CoorFromIndex(coor_f,sf,fine->_rdimensions);
+    for(int d=0;d<_ndimension;d++) coor_c[d]=coor_f[d]/block_r[d];
+    GridBase::IndexFromCoor(coor_c,sc,coarse->_rdimensions);
+
+    for(int i=0;i<nbasis;i++) {
+
+      if(i==0) fineData._odata[sf]=                    coarseData._odata[sc][i]*Basis[i]._odata[sf];
+      else     fineData._odata[sf]=fineData._odata[sf]+coarseData._odata[sc][i]*Basis[i]._odata[sf];
+
+    }
+  }
+  return;
+  
+}
+
 // useful in multigrid project;
 // Generic name : Coarsen?
 template<class vobj>
@@ -30,10 +120,6 @@ inline void sumBlocks(Lattice<vobj> &coarseData,const Lattice<vobj> &fineData)
   
   std::vector<int>  block_r      (_ndimension);
   
-  ///////////////////////////////////////////////////////////
-  // Detect whether the result is replicated in dimension d
-  ///////////////////////////////////////////////////////////
-  
   for(int d=0 ; d<_ndimension;d++){
     block_r[d] = fine->_rdimensions[d] / coarse->_rdimensions[d];
   }