Merge branch 'feature/dirichlet' of https://github.com/paboyle/Grid into feature/dirichlet

Patch/adaptive wflow

Grid/GridCore.h

@@ -44,7 +44,8 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 #include <Grid/GridStd.h>
 #include <Grid/threads/Pragmas.h>
 #include <Grid/perfmon/Timer.h>
-#include <Grid/perfmon/PerfCount.h>
+#include <Grid/perfmon/Tracing.h>
+//#include <Grid/perfmon/PerfCount.h>
 #include <Grid/util/Util.h>
 #include <Grid/log/Log.h>
 #include <Grid/allocator/Allocator.h>

Grid/algorithms/CoarsenedMatrix.h

@@ -262,7 +262,7 @@ public:
 	autoView( Tnp_v , (*Tnp), AcceleratorWrite);
 	autoView( Tnm_v , (*Tnm), AcceleratorWrite);
 	const int Nsimd = CComplex::Nsimd();
-	accelerator_forNB(ss, FineGrid->oSites(), Nsimd, {
+	accelerator_for(ss, FineGrid->oSites(), Nsimd, {
 	  coalescedWrite(y_v[ss],xscale*y_v(ss)+mscale*Tn_v(ss));
 	  coalescedWrite(Tnp_v[ss],2.0*y_v(ss)-Tnm_v(ss));
         });

Grid/algorithms/approx/Chebyshev.h

@@ -264,7 +264,7 @@ public:
       auto Tnp_v = Tnp->View();
       auto Tnm_v = Tnm->View();
       constexpr int Nsimd = vector_type::Nsimd();
-      accelerator_forNB(ss, in.Grid()->oSites(), Nsimd, {
+      accelerator_for(ss, in.Grid()->oSites(), Nsimd, {
 	  coalescedWrite(y_v[ss],xscale*y_v(ss)+mscale*Tn_v(ss));
 	  coalescedWrite(Tnp_v[ss],2.0*y_v(ss)-Tnm_v(ss));
       });

Grid/algorithms/iterative/ConjugateGradient.h

@@ -58,6 +58,7 @@ public:
 
   void operator()(LinearOperatorBase<Field> &Linop, const Field &src, Field &psi) {
 
+    GRID_TRACE("ConjugateGradient");
     psi.Checkerboard() = src.Checkerboard();
 
     conformable(psi, src);
@@ -117,6 +118,7 @@ public:
     GridStopWatch MatrixTimer;
     GridStopWatch SolverTimer;
 
+    RealD usecs = -usecond();
     SolverTimer.Start();
     int k;
     for (k = 1; k <= MaxIterations; k++) {
@@ -166,14 +168,16 @@ public:
 
       // Stopping condition
       if (cp <= rsq) {
+	usecs +=usecond();
         SolverTimer.Stop();
         Linop.HermOpAndNorm(psi, mmp, d, qq);
         p = mmp - src;
-
+	GridBase *grid = src.Grid();
+	RealD DwfFlops = (1452. )*grid->gSites()*4*k
+   	               + (8+4+8+4+4)*12*grid->gSites()*k; // CG linear algebra
         RealD srcnorm = std::sqrt(norm2(src));
         RealD resnorm = std::sqrt(norm2(p));
         RealD true_residual = resnorm / srcnorm;
-
         std::cout << GridLogMessage << "ConjugateGradient Converged on iteration " << k 
 		  << "\tComputed residual " << std::sqrt(cp / ssq)
 		  << "\tTrue residual " << true_residual
@@ -187,6 +191,8 @@ public:
 	std::cout << GridLogMessage << "\tAxpyNorm   " << AxpyNormTimer.Elapsed() <<std::endl;
 	std::cout << GridLogMessage << "\tLinearComb " << LinearCombTimer.Elapsed() <<std::endl;
 
+	std::cout << GridLogMessage << "\tMobius flop rate " << DwfFlops/ usecs<< " Gflops " <<std::endl;
+
         if (ErrorOnNoConverge) assert(true_residual / Tolerance < 10000.0);
 
 	IterationsToComplete = k;	

Grid/algorithms/iterative/ConjugateGradientMultiShift.h

@@ -84,6 +84,7 @@ public:
 
   void operator() (LinearOperatorBase<Field> &Linop, const Field &src, std::vector<Field> &psi)
   {
+    GRID_TRACE("ConjugateGradientMultiShift");
   
     GridBase *grid = src.Grid();
   

Grid/algorithms/iterative/ConjugateGradientMultiShiftMixedPrec.h

@@ -127,6 +127,7 @@ public:
 
   void operator() (LinearOperatorBase<FieldD> &Linop_d, const FieldD &src_d, std::vector<FieldD> &psi_d)
   { 
+    GRID_TRACE("ConjugateGradientMultiShiftMixedPrec");
     GridBase *DoublePrecGrid = src_d.Grid();
 
     ////////////////////////////////////////////////////////////////////////
@@ -153,6 +154,7 @@ public:
     // dynamic sized arrays on stack; 2d is a pain with vector
     RealD  bs[nshift];
     RealD  rsq[nshift];
+    RealD  rsqf[nshift];
     RealD  z[nshift][2];
     int     converged[nshift];
   
@@ -163,12 +165,8 @@ public:
     RealD cp,bp,qq; //prev
   
     // Matrix mult fields
-    FieldF r_f(SinglePrecGrid);
     FieldF p_f(SinglePrecGrid);
-    FieldF tmp_f(SinglePrecGrid);
     FieldF mmp_f(SinglePrecGrid);
-    FieldF src_f(SinglePrecGrid);
-    precisionChange(src_f, src_d);
 
     // Check lightest mass
     for(int s=0;s<nshift;s++){
@@ -193,18 +191,26 @@ public:
 
     for(int s=0;s<nshift;s++){
       rsq[s] = cp * mresidual[s] * mresidual[s];
+      rsqf[s] =rsq[s];
       std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrec: shift "<< s <<" target resid "<<rsq[s]<<std::endl;
       ps_d[s] = src_d;
     }
     // r and p for primary
-    r_f=src_f; //residual maintained in single
-    p_f=src_f;
     p_d = src_d; //primary copy --- make this a reference to ps_d to save axpys
-  
+    r_d = p_d;
+    
     //MdagM+m[0]
+    precisionChangeFast(p_f,p_d);
+
     Linop_f.HermOpAndNorm(p_f,mmp_f,d,qq); // mmp = MdagM p        d=real(dot(p, mmp)),  qq=norm2(mmp)
-    axpy(mmp_f,mass[0],p_f,mmp_f);
-    RealD rn = norm2(p_f);
+    precisionChangeFast(tmp_d,mmp_f);
+    Linop_d.HermOpAndNorm(p_d,mmp_d,d,qq); // mmp = MdagM p        d=real(dot(p, mmp)),  qq=norm2(mmp)
+    tmp_d = tmp_d - mmp_d;
+    std::cout << " Testing operators match "<<norm2(mmp_d)<<" f "<<norm2(mmp_f)<<" diff "<< norm2(tmp_d)<<std::endl;
+    //    assert(norm2(tmp_d)< 1.0e-4);
+
+    axpy(mmp_d,mass[0],p_d,mmp_d);
+    RealD rn = norm2(p_d);
     d += rn*mass[0];
 
     b = -cp /d;
@@ -222,7 +228,7 @@ public:
   
     // r += b[0] A.p[0]
     // c= norm(r)
-    c=axpy_norm(r_f,b,mmp_f,r_f);
+    c=axpy_norm(r_d,b,mmp_d,r_d);
   
     for(int s=0;s<nshift;s++) {
       axpby(psi_d[s],0.,-bs[s]*alpha[s],src_d,src_d);
@@ -239,13 +245,8 @@ public:
     int k;
   
     for (k=1;k<=MaxIterations;k++){    
+
       a = c /cp;
-
-      //Update double precision search direction by residual
-      PrecChangeTimer.Start();
-      precisionChange(r_d, r_f);
-      PrecChangeTimer.Stop();
-
       AXPYTimer.Start();
       axpy(p_d,a,p_d,r_d); 
 
@@ -262,24 +263,28 @@ public:
       AXPYTimer.Stop();
 
       PrecChangeTimer.Start();
-      precisionChange(p_f, p_d); //get back single prec search direction for linop
+      precisionChangeFast(p_f, p_d); //get back single prec search direction for linop
       PrecChangeTimer.Stop();
 
       cp=c;
       MatrixTimer.Start();  
-      Linop_f.HermOp(p_f,mmp_f); 
-      d=real(innerProduct(p_f,mmp_f));    
+      Linop_f.HermOp(p_f,mmp_f);
       MatrixTimer.Stop();  
 
+      PrecChangeTimer.Start();
+      precisionChangeFast(mmp_d, mmp_f); // From Float to Double
+      PrecChangeTimer.Stop();
+
       AXPYTimer.Start();
-      axpy(mmp_f,mass[0],p_f,mmp_f);
+      d=real(innerProduct(p_d,mmp_d));    
+      axpy(mmp_d,mass[0],p_d,mmp_d);
       AXPYTimer.Stop();
-      RealD rn = norm2(p_f);
+      RealD rn = norm2(p_d);
       d += rn*mass[0];
     
       bp=b;
       b=-cp/d;
-    
+
       // Toggle the recurrence history
       bs[0] = b;
       iz = 1-iz;
@@ -305,12 +310,12 @@ public:
       }
 
       //Perform reliable update if necessary; otherwise update residual from single-prec mmp
-      RealD c_f = axpy_norm(r_f,b,mmp_f,r_f);
+      c = axpy_norm(r_d,b,mmp_d,r_d);
+
       AXPYTimer.Stop();
 
-      c = c_f;
-
       if(k % ReliableUpdateFreq == 0){
+	RealD c_old = c;
 	//Replace r with true residual
 	MatrixTimer.Start();  
 	Linop_d.HermOp(psi_d[0],mmp_d); 
@@ -319,15 +324,10 @@ public:
 	AXPYTimer.Start();
 	axpy(mmp_d,mass[0],psi_d[0],mmp_d);
 
-	RealD c_d = axpy_norm(r_d, -1.0, mmp_d, src_d);
+	c = axpy_norm(r_d, -1.0, mmp_d, src_d);
 	AXPYTimer.Stop();
 
-	std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrec k="<<k<< ", replaced |r|^2 = "<<c_f <<" with |r|^2 = "<<c_d<<std::endl;
-	
-	PrecChangeTimer.Start();
-	precisionChange(r_f, r_d);
-	PrecChangeTimer.Stop();
-	c = c_d;
+	std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrec k="<<k<< ", replaced |r|^2 = "<<c_old <<" with |r|^2 = "<<c<<std::endl;
       }
     
       // Convergence checks
@@ -339,7 +339,7 @@ public:
 	
 	  RealD css  = c * z[s][iz]* z[s][iz];
 	
-	  if(css<rsq[s]){
+	  if(css<rsqf[s]){
 	    if ( ! converged[s] )
 	      std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrec k="<<k<<" Shift "<<s<<" has converged"<<std::endl;
 	    converged[s]=1;

Grid/algorithms/iterative/ConjugateGradientReliableUpdate.h

@@ -73,6 +73,7 @@ public:
   }
     
   void operator()(const FieldD &src, FieldD &psi) {
+    GRID_TRACE("ConjugateGradientReliableUpdate");
     LinearOperatorBase<FieldF> *Linop_f_use = &Linop_f;
     bool using_fallback = false;
       

Grid/allocator/MemoryManager.cc

@@ -40,7 +40,7 @@ void MemoryManager::PrintBytes(void)
 //////////////////////////////////////////////////////////////////////
 MemoryManager::AllocationCacheEntry MemoryManager::Entries[MemoryManager::NallocType][MemoryManager::NallocCacheMax];
 int MemoryManager::Victim[MemoryManager::NallocType];
-int MemoryManager::Ncache[MemoryManager::NallocType] = { 2, 8, 2, 8, 2, 8 };
+int MemoryManager::Ncache[MemoryManager::NallocType] = { 2, 8, 8, 16, 8, 16 };
 uint64_t MemoryManager::CacheBytes[MemoryManager::NallocType];
 //////////////////////////////////////////////////////////////////////
 // Actual allocation and deallocation utils

Grid/allocator/MemoryManagerCache.cc

@@ -3,8 +3,14 @@
 
 #warning "Using explicit device memory copies"
 NAMESPACE_BEGIN(Grid);
-//#define dprintf(...) printf ( __VA_ARGS__ ); fflush(stdout);
-#define dprintf(...)
+
+#define MAXLINE 512
+static char print_buffer [ MAXLINE ];
+
+#define mprintf(...) snprintf (print_buffer,MAXLINE, __VA_ARGS__ ); std::cout << GridLogMemory << print_buffer;
+//#define dprintf(...) printf (__VA_ARGS__ ); fflush(stdout);
+#define dprintf(...) 
+
 
 
 ////////////////////////////////////////////////////////////
@@ -104,7 +110,7 @@ void MemoryManager::AccDiscard(AcceleratorViewEntry &AccCache)
   ///////////////////////////////////////////////////////////
   assert(AccCache.state!=Empty);
   
-   dprintf("MemoryManager: Discard(%llx) %llx\n",(uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr); 
+  mprintf("MemoryManager: Discard(%lx) %lx\n",(uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr); 
   assert(AccCache.accLock==0);
   assert(AccCache.cpuLock==0);
   assert(AccCache.CpuPtr!=(uint64_t)NULL);
@@ -112,7 +118,7 @@ void MemoryManager::AccDiscard(AcceleratorViewEntry &AccCache)
     AcceleratorFree((void *)AccCache.AccPtr,AccCache.bytes);
     DeviceBytes   -=AccCache.bytes;
     LRUremove(AccCache);
-    dprintf("MemoryManager: Free(%llx) LRU %lld Total %lld\n",(uint64_t)AccCache.AccPtr,DeviceLRUBytes,DeviceBytes);  
+    dprintf("MemoryManager: Free(%lx) LRU %ld Total %ld\n",(uint64_t)AccCache.AccPtr,DeviceLRUBytes,DeviceBytes);  
   }
   uint64_t CpuPtr = AccCache.CpuPtr;
   EntryErase(CpuPtr);
@@ -126,7 +132,7 @@ void MemoryManager::Evict(AcceleratorViewEntry &AccCache)
   ///////////////////////////////////////////////////////////////////////////
   assert(AccCache.state!=Empty);
   
-  dprintf("MemoryManager: Evict(%llx) %llx\n",(uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr); 
+  mprintf("MemoryManager: Evict(%lx) %lx\n",(uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr); 
   assert(AccCache.accLock==0);
   assert(AccCache.cpuLock==0);
   if(AccCache.state==AccDirty) {
@@ -137,7 +143,7 @@ void MemoryManager::Evict(AcceleratorViewEntry &AccCache)
     AcceleratorFree((void *)AccCache.AccPtr,AccCache.bytes);
     DeviceBytes   -=AccCache.bytes;
     LRUremove(AccCache);
-    dprintf("MemoryManager: Free(%llx) footprint now %lld \n",(uint64_t)AccCache.AccPtr,DeviceBytes);  
+    dprintf("MemoryManager: Free(%lx) footprint now %ld \n",(uint64_t)AccCache.AccPtr,DeviceBytes);  
   }
   uint64_t CpuPtr = AccCache.CpuPtr;
   EntryErase(CpuPtr);
@@ -150,7 +156,7 @@ void MemoryManager::Flush(AcceleratorViewEntry &AccCache)
   assert(AccCache.AccPtr!=(uint64_t)NULL);
   assert(AccCache.CpuPtr!=(uint64_t)NULL);
   acceleratorCopyFromDevice((void *)AccCache.AccPtr,(void *)AccCache.CpuPtr,AccCache.bytes);
-  dprintf("MemoryManager: Flush  %llx -> %llx\n",(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
+  mprintf("MemoryManager: Flush  %lx -> %lx\n",(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
   DeviceToHostBytes+=AccCache.bytes;
   DeviceToHostXfer++;
   AccCache.state=Consistent;
@@ -165,7 +171,7 @@ void MemoryManager::Clone(AcceleratorViewEntry &AccCache)
     AccCache.AccPtr=(uint64_t)AcceleratorAllocate(AccCache.bytes);
     DeviceBytes+=AccCache.bytes;
   }
-  dprintf("MemoryManager: Clone %llx <- %llx\n",(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
+  mprintf("MemoryManager: Clone %lx <- %lx\n",(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
   acceleratorCopyToDevice((void *)AccCache.CpuPtr,(void *)AccCache.AccPtr,AccCache.bytes);
   HostToDeviceBytes+=AccCache.bytes;
   HostToDeviceXfer++;
@@ -241,7 +247,7 @@ uint64_t MemoryManager::AcceleratorViewOpen(uint64_t CpuPtr,size_t bytes,ViewMod
   assert(AccCache.cpuLock==0);  // Programming error
 
   if(AccCache.state!=Empty) {
-    dprintf("ViewOpen found entry %llx %llx : %lld %lld\n",
+    dprintf("ViewOpen found entry %lx %lx : %ld %ld\n",
 		    (uint64_t)AccCache.CpuPtr,
 		    (uint64_t)CpuPtr,
 		    (uint64_t)AccCache.bytes,

Grid/communicator/Communicator_base.h

@@ -107,6 +107,7 @@ public:
   ////////////////////////////////////////////////////////////////////////////////
   static int  RankWorld(void) ;
   static void BroadcastWorld(int root,void* data, int bytes);
+  static void BarrierWorld(void);
   
   ////////////////////////////////////////////////////////////
   // Reduction
@@ -130,7 +131,7 @@ public:
   template<class obj> void GlobalSum(obj &o){
     typedef typename obj::scalar_type scalar_type;
     int words = sizeof(obj)/sizeof(scalar_type);
-    scalar_type * ptr = (scalar_type *)& o;
+    scalar_type * ptr = (scalar_type *)& o; // Safe alias 
     GlobalSumVector(ptr,words);
   }
   
@@ -154,7 +155,7 @@ public:
 				    int xmit_to_rank,int do_xmit,
 				    void *recv,
 				    int recv_from_rank,int do_recv,
-				    int bytes,int dir);
+				    int xbytes,int rbytes,int dir);
   
   
   void StencilSendToRecvFromComplete(std::vector<CommsRequest_t> &waitall,int i);

Grid/communicator/Communicator_mpi3.cc

@@ -343,7 +343,7 @@ double CartesianCommunicator::StencilSendToRecvFrom( void *xmit,
 						     int bytes,int dir)
 {
   std::vector<CommsRequest_t> list;
-  double offbytes = StencilSendToRecvFromBegin(list,xmit,dest,dox,recv,from,dor,bytes,dir);
+  double offbytes = StencilSendToRecvFromBegin(list,xmit,dest,dox,recv,from,dor,bytes,bytes,dir);
   StencilSendToRecvFromComplete(list,dir);
   return offbytes;
 }
@@ -353,7 +353,7 @@ double CartesianCommunicator::StencilSendToRecvFromBegin(std::vector<CommsReques
 							 int dest,int dox,
 							 void *recv,
 							 int from,int dor,
-							 int bytes,int dir)
+							 int xbytes,int rbytes,int dir)
 {
   int ncomm  =communicator_halo.size();
   int commdir=dir%ncomm;
@@ -375,38 +375,33 @@ double CartesianCommunicator::StencilSendToRecvFromBegin(std::vector<CommsReques
   if ( dor ) {
     if ( (gfrom ==MPI_UNDEFINED) || Stencil_force_mpi ) {
       tag= dir+from*32;
-      ierr=MPI_Irecv(recv, bytes, MPI_CHAR,from,tag,communicator_halo[commdir],&rrq);
+      ierr=MPI_Irecv(recv, rbytes, MPI_CHAR,from,tag,communicator_halo[commdir],&rrq);
       assert(ierr==0);
       list.push_back(rrq);
-      off_node_bytes+=bytes;
+      off_node_bytes+=rbytes;
     }
   }
   
   if (dox) {
     if ( (gdest == MPI_UNDEFINED) || Stencil_force_mpi ) {
       tag= dir+_processor*32;
-      ierr =MPI_Isend(xmit, bytes, MPI_CHAR,dest,tag,communicator_halo[commdir],&xrq);
+      ierr =MPI_Isend(xmit, xbytes, MPI_CHAR,dest,tag,communicator_halo[commdir],&xrq);
       assert(ierr==0);
       list.push_back(xrq);
-      off_node_bytes+=bytes;
+      off_node_bytes+=xbytes;
     } else {
       void *shm = (void *) this->ShmBufferTranslate(dest,recv);
       assert(shm!=NULL);
-      acceleratorCopyDeviceToDeviceAsynch(xmit,shm,bytes);
+      acceleratorCopyDeviceToDeviceAsynch(xmit,shm,xbytes);
     }
   }
-  
-  if ( CommunicatorPolicy == CommunicatorPolicySequential ) {
-    this->StencilSendToRecvFromComplete(list,dir);
-    list.resize(0);
-  }
 
   return off_node_bytes;
 }
 void CartesianCommunicator::StencilSendToRecvFromComplete(std::vector<CommsRequest_t> &list,int dir)
 {
-  //   std::cout << "Copy Synchronised\n"<<std::endl;
   acceleratorCopySynchronise();
+  StencilBarrier();// Synch shared memory on a single nodes
 
   int nreq=list.size();
 
@@ -443,6 +438,10 @@ int CartesianCommunicator::RankWorld(void){
   MPI_Comm_rank(communicator_world,&r);
   return r;
 }
+void CartesianCommunicator::BarrierWorld(void){
+  int ierr = MPI_Barrier(communicator_world);
+  assert(ierr==0);
+}
 void CartesianCommunicator::BroadcastWorld(int root,void* data, int bytes)
 {
   int ierr= MPI_Bcast(data,

Grid/communicator/Communicator_none.cc

@@ -104,6 +104,7 @@ int  CartesianCommunicator::RankWorld(void){return 0;}
 void CartesianCommunicator::Barrier(void){}
 void CartesianCommunicator::Broadcast(int root,void* data, int bytes) {}
 void CartesianCommunicator::BroadcastWorld(int root,void* data, int bytes) { }
+void CartesianCommunicator::BarrierWorld(void) { }
 int  CartesianCommunicator::RankFromProcessorCoor(Coordinate &coor) {  return 0;}
 void CartesianCommunicator::ProcessorCoorFromRank(int rank, Coordinate &coor){  coor = _processor_coor; }
 void CartesianCommunicator::ShiftedRanks(int dim,int shift,int &source,int &dest)
@@ -125,7 +126,7 @@ double CartesianCommunicator::StencilSendToRecvFromBegin(std::vector<CommsReques
 							 int xmit_to_rank,int dox,
 							 void *recv,
 							 int recv_from_rank,int dor,
-							 int bytes, int dir)
+							 int xbytes,int rbytes, int dir)
 {
   return 2.0*bytes;
 }

Grid/communicator/SharedMemoryMPI.cc

@@ -523,7 +523,7 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
   }
   if ( WorldRank == 0 ){
     std::cout << WorldRank << header " SharedMemoryMPI.cc acceleratorAllocDevice "<< bytes 
-	      << "bytes at "<< std::hex<< ShmCommBuf <<std::dec<<" for comms buffers " <<std::endl;
+	      << "bytes at "<< std::hex<< ShmCommBuf << " - "<<(bytes-1+(uint64_t)ShmCommBuf) <<std::dec<<" for comms buffers " <<std::endl;
   }
   SharedMemoryZero(ShmCommBuf,bytes);
   std::cout<< "Setting up IPC"<<std::endl;

Grid/lattice/Lattice_ET.h

@@ -63,7 +63,7 @@ accelerator_inline vobj predicatedWhere(const iobj &predicate,
   typename std::remove_const<vobj>::type ret;
 
   typedef typename vobj::scalar_object scalar_object;
-  typedef typename vobj::scalar_type scalar_type;
+  //  typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
 
   const int Nsimd = vobj::vector_type::Nsimd();

Grid/lattice/Lattice_arith.h

@@ -36,6 +36,7 @@ NAMESPACE_BEGIN(Grid);
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 template<class obj1,class obj2,class obj3> inline
 void mult(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const Lattice<obj3> &rhs){
+  GRID_TRACE("mult");
   ret.Checkerboard() = lhs.Checkerboard();
   autoView( ret_v , ret, AcceleratorWrite);
   autoView( lhs_v , lhs, AcceleratorRead);
@@ -53,6 +54,7 @@ void mult(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const Lattice<obj3> &rhs){
   
 template<class obj1,class obj2,class obj3> inline
 void mac(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const Lattice<obj3> &rhs){
+  GRID_TRACE("mac");
   ret.Checkerboard() = lhs.Checkerboard();
   conformable(ret,rhs);
   conformable(lhs,rhs);
@@ -70,6 +72,7 @@ void mac(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const Lattice<obj3> &rhs){
   
 template<class obj1,class obj2,class obj3> inline
 void sub(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const Lattice<obj3> &rhs){
+  GRID_TRACE("sub");
   ret.Checkerboard() = lhs.Checkerboard();
   conformable(ret,rhs);
   conformable(lhs,rhs);
@@ -86,6 +89,7 @@ void sub(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const Lattice<obj3> &rhs){
 }
 template<class obj1,class obj2,class obj3> inline
 void add(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const Lattice<obj3> &rhs){
+  GRID_TRACE("add");
   ret.Checkerboard() = lhs.Checkerboard();
   conformable(ret,rhs);
   conformable(lhs,rhs);
@@ -106,6 +110,7 @@ void add(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const Lattice<obj3> &rhs){
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 template<class obj1,class obj2,class obj3> inline
 void mult(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const obj3 &rhs){
+  GRID_TRACE("mult");
   ret.Checkerboard() = lhs.Checkerboard();
   conformable(lhs,ret);
   autoView( ret_v , ret, AcceleratorWrite);
@@ -119,6 +124,7 @@ void mult(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const obj3 &rhs){
   
 template<class obj1,class obj2,class obj3> inline
 void mac(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const obj3 &rhs){
+  GRID_TRACE("mac");
   ret.Checkerboard() = lhs.Checkerboard();
   conformable(ret,lhs);
   autoView( ret_v , ret, AcceleratorWrite);
@@ -133,6 +139,7 @@ void mac(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const obj3 &rhs){
   
 template<class obj1,class obj2,class obj3> inline
 void sub(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const obj3 &rhs){
+  GRID_TRACE("sub");
   ret.Checkerboard() = lhs.Checkerboard();
   conformable(ret,lhs);
   autoView( ret_v , ret, AcceleratorWrite);
@@ -146,6 +153,7 @@ void sub(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const obj3 &rhs){
 }
 template<class obj1,class obj2,class obj3> inline
 void add(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const obj3 &rhs){
+  GRID_TRACE("add");
   ret.Checkerboard() = lhs.Checkerboard();
   conformable(lhs,ret);
   autoView( ret_v , ret, AcceleratorWrite);
@@ -163,6 +171,7 @@ void add(Lattice<obj1> &ret,const Lattice<obj2> &lhs,const obj3 &rhs){
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 template<class obj1,class obj2,class obj3> inline
 void mult(Lattice<obj1> &ret,const obj2 &lhs,const Lattice<obj3> &rhs){
+  GRID_TRACE("mult");
   ret.Checkerboard() = rhs.Checkerboard();
   conformable(ret,rhs);
   autoView( ret_v , ret, AcceleratorWrite);
@@ -177,6 +186,7 @@ void mult(Lattice<obj1> &ret,const obj2 &lhs,const Lattice<obj3> &rhs){
   
 template<class obj1,class obj2,class obj3> inline
 void mac(Lattice<obj1> &ret,const obj2 &lhs,const Lattice<obj3> &rhs){
+  GRID_TRACE("mac");
   ret.Checkerboard() = rhs.Checkerboard();
   conformable(ret,rhs);
   autoView( ret_v , ret, AcceleratorWrite);
@@ -191,6 +201,7 @@ void mac(Lattice<obj1> &ret,const obj2 &lhs,const Lattice<obj3> &rhs){
   
 template<class obj1,class obj2,class obj3> inline
 void sub(Lattice<obj1> &ret,const obj2 &lhs,const Lattice<obj3> &rhs){
+  GRID_TRACE("sub");
   ret.Checkerboard() = rhs.Checkerboard();
   conformable(ret,rhs);
   autoView( ret_v , ret, AcceleratorWrite);
@@ -204,6 +215,7 @@ void sub(Lattice<obj1> &ret,const obj2 &lhs,const Lattice<obj3> &rhs){
 }
 template<class obj1,class obj2,class obj3> inline
 void add(Lattice<obj1> &ret,const obj2 &lhs,const Lattice<obj3> &rhs){
+  GRID_TRACE("add");
   ret.Checkerboard() = rhs.Checkerboard();
   conformable(ret,rhs);
   autoView( ret_v , ret, AcceleratorWrite);
@@ -218,6 +230,7 @@ void add(Lattice<obj1> &ret,const obj2 &lhs,const Lattice<obj3> &rhs){
   
 template<class sobj,class vobj> inline
 void axpy(Lattice<vobj> &ret,sobj a,const Lattice<vobj> &x,const Lattice<vobj> &y){
+  GRID_TRACE("axpy");
   ret.Checkerboard() = x.Checkerboard();
   conformable(ret,x);
   conformable(x,y);
@@ -231,6 +244,7 @@ void axpy(Lattice<vobj> &ret,sobj a,const Lattice<vobj> &x,const Lattice<vobj> &
 }
 template<class sobj,class vobj> inline
 void axpby(Lattice<vobj> &ret,sobj a,sobj b,const Lattice<vobj> &x,const Lattice<vobj> &y){
+  GRID_TRACE("axpby");
   ret.Checkerboard() = x.Checkerboard();
   conformable(ret,x);
   conformable(x,y);
@@ -246,11 +260,13 @@ void axpby(Lattice<vobj> &ret,sobj a,sobj b,const Lattice<vobj> &x,const Lattice
 template<class sobj,class vobj> inline
 RealD axpy_norm(Lattice<vobj> &ret,sobj a,const Lattice<vobj> &x,const Lattice<vobj> &y)
 {
+  GRID_TRACE("axpy_norm");
     return axpy_norm_fast(ret,a,x,y);
 }
 template<class sobj,class vobj> inline
 RealD axpby_norm(Lattice<vobj> &ret,sobj a,sobj b,const Lattice<vobj> &x,const Lattice<vobj> &y)
 {
+  GRID_TRACE("axpby_norm");
     return axpby_norm_fast(ret,a,b,x,y);
 }
 

Grid/lattice/Lattice_base.h

@@ -117,6 +117,7 @@ public:
   ////////////////////////////////////////////////////////////////////////////////
   template <typename Op, typename T1> inline Lattice<vobj> & operator=(const LatticeUnaryExpression<Op,T1> &expr)
   {
+    GRID_TRACE("ExpressionTemplateEval");
     GridBase *egrid(nullptr);
     GridFromExpression(egrid,expr);
     assert(egrid!=nullptr);
@@ -140,6 +141,7 @@ public:
   }
   template <typename Op, typename T1,typename T2> inline Lattice<vobj> & operator=(const LatticeBinaryExpression<Op,T1,T2> &expr)
   {
+    GRID_TRACE("ExpressionTemplateEval");
     GridBase *egrid(nullptr);
     GridFromExpression(egrid,expr);
     assert(egrid!=nullptr);
@@ -163,6 +165,7 @@ public:
   }
   template <typename Op, typename T1,typename T2,typename T3> inline Lattice<vobj> & operator=(const LatticeTrinaryExpression<Op,T1,T2,T3> &expr)
   {
+    GRID_TRACE("ExpressionTemplateEval");
     GridBase *egrid(nullptr);
     GridFromExpression(egrid,expr);
     assert(egrid!=nullptr);

Grid/lattice/Lattice_matrix_reduction.h

@@ -32,7 +32,6 @@ template<class vobj>
 static void sliceMaddMatrix (Lattice<vobj> &R,Eigen::MatrixXcd &aa,const Lattice<vobj> &X,const Lattice<vobj> &Y,int Orthog,RealD scale=1.0) 
 {    
   typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
 
   int Nblock = X.Grid()->GlobalDimensions()[Orthog];
@@ -82,7 +81,6 @@ template<class vobj>
 static void sliceMulMatrix (Lattice<vobj> &R,Eigen::MatrixXcd &aa,const Lattice<vobj> &X,int Orthog,RealD scale=1.0) 
 {    
   typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
 
   int Nblock = X.Grid()->GlobalDimensions()[Orthog];
@@ -130,7 +128,6 @@ template<class vobj>
 static void sliceInnerProductMatrix(  Eigen::MatrixXcd &mat, const Lattice<vobj> &lhs,const Lattice<vobj> &rhs,int Orthog) 
 {
   typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
   
   GridBase *FullGrid  = lhs.Grid();

Grid/lattice/Lattice_peekpoke.h

@@ -96,9 +96,6 @@ void pokeSite(const sobj &s,Lattice<vobj> &l,const Coordinate &site){
 
   GridBase *grid=l.Grid();
 
-  typedef typename vobj::scalar_type scalar_type;
-  typedef typename vobj::vector_type vector_type;
-
   int Nsimd = grid->Nsimd();
 
   assert( l.Checkerboard()== l.Grid()->CheckerBoard(site));
@@ -136,9 +133,6 @@ void peekSite(sobj &s,const Lattice<vobj> &l,const Coordinate &site){
         
   GridBase *grid=l.Grid();
 
-  typedef typename vobj::scalar_type scalar_type;
-  typedef typename vobj::vector_type vector_type;
-
   int Nsimd = grid->Nsimd();
 
   assert( l.Checkerboard() == l.Grid()->CheckerBoard(site));
@@ -179,11 +173,11 @@ inline void peekLocalSite(sobj &s,const LatticeView<vobj> &l,Coordinate &site)
   idx= grid->iIndex(site);
   odx= grid->oIndex(site);
   
-  scalar_type * vp = (scalar_type *)&l[odx];
+  const vector_type *vp = (const vector_type *) &l[odx];
   scalar_type * pt = (scalar_type *)&s;
       
   for(int w=0;w<words;w++){
-    pt[w] = vp[idx+w*Nsimd];
+    pt[w] = getlane(vp[w],idx);
   }
       
   return;
@@ -216,10 +210,10 @@ inline void pokeLocalSite(const sobj &s,LatticeView<vobj> &l,Coordinate &site)
   idx= grid->iIndex(site);
   odx= grid->oIndex(site);
 
-  scalar_type * vp = (scalar_type *)&l[odx];
+  vector_type * vp = (vector_type *)&l[odx];
   scalar_type * pt = (scalar_type *)&s;
   for(int w=0;w<words;w++){
-    vp[idx+w*Nsimd] = pt[w];
+    putlane(vp[w],pt[w],idx);
   }
   return;
 };

Grid/lattice/Lattice_reduction.h

@@ -91,10 +91,7 @@ inline typename vobj::scalar_objectD sumD_cpu(const vobj *arg, Integer osites)
   for(int i=0;i<nthread;i++){
     ssum = ssum+sumarray[i];
   } 
-  
-  typedef typename vobj::scalar_object ssobj;
-  ssobj ret = ssum;
-  return ret;
+  return ssum;
 }
 /*
 Threaded max, don't use for now
@@ -222,7 +219,6 @@ template<class vobj> inline RealD maxLocalNorm2(const Lattice<vobj> &arg)
 template<class vobj>
 inline ComplexD rankInnerProduct(const Lattice<vobj> &left,const Lattice<vobj> &right)
 {
-  typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_typeD vector_type;
   ComplexD  nrm;
   
@@ -299,7 +295,6 @@ axpby_norm_fast(Lattice<vobj> &z,sobj a,sobj b,const Lattice<vobj> &x,const Latt
   conformable(z,x);
   conformable(x,y);
 
-  typedef typename vobj::scalar_type scalar_type;
   //  typedef typename vobj::vector_typeD vector_type;
   RealD  nrm;
   
@@ -344,7 +339,6 @@ innerProductNorm(ComplexD& ip, RealD &nrm, const Lattice<vobj> &left,const Latti
 {
   conformable(left,right);
 
-  typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_typeD vector_type;
   Vector<ComplexD> tmp(2);
 
@@ -488,6 +482,14 @@ template<class vobj> inline void sliceSum(const Lattice<vobj> &Data,std::vector<
   int words = fd*sizeof(sobj)/sizeof(scalar_type);
   grid->GlobalSumVector(ptr, words);
 }
+template<class vobj> inline
+std::vector<typename vobj::scalar_object> 
+sliceSum(const Lattice<vobj> &Data,int orthogdim)
+{
+  std::vector<typename vobj::scalar_object> result;
+  sliceSum(Data,result,orthogdim);
+  return result;
+}
 
 template<class vobj>
 static void sliceInnerProductVector( std::vector<ComplexD> & result, const Lattice<vobj> &lhs,const Lattice<vobj> &rhs,int orthogdim) 
@@ -592,7 +594,8 @@ static void sliceNorm (std::vector<RealD> &sn,const Lattice<vobj> &rhs,int Ortho
 template<class vobj>
 static void sliceMaddVector(Lattice<vobj> &R,std::vector<RealD> &a,const Lattice<vobj> &X,const Lattice<vobj> &Y,
 			    int orthogdim,RealD scale=1.0) 
-{    
+{
+  // perhaps easier to just promote A to a field and use regular madd
   typedef typename vobj::scalar_object sobj;
   typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
@@ -623,8 +626,7 @@ static void sliceMaddVector(Lattice<vobj> &R,std::vector<RealD> &a,const Lattice
     for(int l=0;l<Nsimd;l++){
       grid->iCoorFromIindex(icoor,l);
       int ldx =r+icoor[orthogdim]*rd;
-      scalar_type *as =(scalar_type *)&av;
-      as[l] = scalar_type(a[ldx])*zscale;
+      av.putlane(scalar_type(a[ldx])*zscale,l);
     }
 
     tensor_reduced at; at=av;
@@ -664,7 +666,6 @@ template<class vobj>
 static void sliceMaddMatrix (Lattice<vobj> &R,Eigen::MatrixXcd &aa,const Lattice<vobj> &X,const Lattice<vobj> &Y,int Orthog,RealD scale=1.0) 
 {    
   typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
 
   int Nblock = X.Grid()->GlobalDimensions()[Orthog];
@@ -718,7 +719,6 @@ template<class vobj>
 static void sliceMulMatrix (Lattice<vobj> &R,Eigen::MatrixXcd &aa,const Lattice<vobj> &X,int Orthog,RealD scale=1.0) 
 {    
   typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
 
   int Nblock = X.Grid()->GlobalDimensions()[Orthog];
@@ -772,7 +772,6 @@ template<class vobj>
 static void sliceInnerProductMatrix(  Eigen::MatrixXcd &mat, const Lattice<vobj> &lhs,const Lattice<vobj> &rhs,int Orthog) 
 {
   typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
   
   GridBase *FullGrid  = lhs.Grid();

Grid/lattice/Lattice_reduction_gpu.h

@@ -250,8 +250,6 @@ inline typename vobj::scalar_objectD sumD_gpu_large(const vobj *lat, Integer osi
 template <class vobj>
 inline typename vobj::scalar_objectD sumD_gpu(const vobj *lat, Integer osites)
 {
-  typedef typename vobj::vector_type  vector;
-  typedef typename vobj::scalar_typeD scalarD;
   typedef typename vobj::scalar_objectD sobj;
   sobj ret;
   

Grid/lattice/Lattice_transfer.h

@@ -194,11 +194,11 @@ accelerator_inline void convertType(vComplexD2 & out, const ComplexD & in) {
 #endif
 
 accelerator_inline void convertType(vComplexF & out, const vComplexD2 & in) {
-  out.v = Optimization::PrecisionChange::DtoS(in._internal[0].v,in._internal[1].v);
+  precisionChange(out,in);
 }
 
 accelerator_inline void convertType(vComplexD2 & out, const vComplexF & in) {
-  Optimization::PrecisionChange::StoD(in.v,out._internal[0].v,out._internal[1].v);
+  precisionChange(out,in);
 }
 
 template<typename T1,typename T2>
@@ -677,10 +677,10 @@ void localCopyRegion(const Lattice<vobj> &From,Lattice<vobj> & To,Coordinate Fro
       Integer idx_t = 0; for(int d=0;d<nd;d++) idx_t+=ist[d]*(Tcoor[d]/rdt[d]);
       Integer odx_f = 0; for(int d=0;d<nd;d++) odx_f+=osf[d]*(Fcoor[d]%rdf[d]);
       Integer odx_t = 0; for(int d=0;d<nd;d++) odx_t+=ost[d]*(Tcoor[d]%rdt[d]);
-      scalar_type * fp = (scalar_type *)&f_v[odx_f];
-      scalar_type * tp = (scalar_type *)&t_v[odx_t];
+      vector_type * fp = (vector_type *)&f_v[odx_f];
+      vector_type * tp = (vector_type *)&t_v[odx_t];
       for(int w=0;w<words;w++){
-	tp[idx_t+w*Nsimd] = fp[idx_f+w*Nsimd];  // FIXME IF RRII layout, type pun no worke
+	tp[w].putlane(fp[w].getlane(idx_f),idx_t);
       }
     }
   });
@@ -1080,6 +1080,23 @@ vectorizeFromRevLexOrdArray( std::vector<sobj> &in, Lattice<vobj> &out)
   });
 }
 
+template<class VobjOut, class VobjIn>
+void precisionChangeFast(Lattice<VobjOut> &out, const Lattice<VobjIn> &in)
+{
+  typedef typename VobjOut::vector_type Vout;
+  typedef typename VobjIn::vector_type Vin;
+  const int N = sizeof(VobjOut)/sizeof(Vout);
+  conformable(out.Grid(),in.Grid());
+  out.Checkerboard() = in.Checkerboard();
+  int nsimd = out.Grid()->Nsimd();
+  autoView( out_v  , out, AcceleratorWrite);
+  autoView(  in_v ,   in, AcceleratorRead);
+  accelerator_for(idx,out.Grid()->oSites(),1,{
+      Vout *vout = (Vout *)&out_v[idx];
+      Vin  *vin  = (Vin  *)&in_v[idx];
+      precisionChange(vout,vin,N);
+  });
+}
 //Convert a Lattice from one precision to another
 template<class VobjOut, class VobjIn>
 void precisionChange(Lattice<VobjOut> &out, const Lattice<VobjIn> &in)
@@ -1097,7 +1114,7 @@ void precisionChange(Lattice<VobjOut> &out, const Lattice<VobjIn> &in)
 
   int ndim = out.Grid()->Nd();
   int out_nsimd = out_grid->Nsimd();
-    
+  int in_nsimd = in_grid->Nsimd();
   std::vector<Coordinate > out_icoor(out_nsimd);
       
   for(int lane=0; lane < out_nsimd; lane++){

Grid/log/Log.cc

@@ -68,6 +68,7 @@ GridLogger GridLogMessage(1, "Message", GridLogColours, "NORMAL");
 GridLogger GridLogMemory (1, "Memory", GridLogColours, "NORMAL");
 GridLogger GridLogDebug  (1, "Debug", GridLogColours, "PURPLE");
 GridLogger GridLogPerformance(1, "Performance", GridLogColours, "GREEN");
+GridLogger GridLogDslash     (1, "Dslash", GridLogColours, "BLUE");
 GridLogger GridLogIterative  (1, "Iterative", GridLogColours, "BLUE");
 GridLogger GridLogIntegrator (1, "Integrator", GridLogColours, "BLUE");
 GridLogger GridLogHMC (1, "HMC", GridLogColours, "BLUE");
@@ -80,6 +81,7 @@ void GridLogConfigure(std::vector<std::string> &logstreams) {
   GridLogIterative.Active(0);
   GridLogDebug.Active(0);
   GridLogPerformance.Active(0);
+  GridLogDslash.Active(0);
   GridLogIntegrator.Active(1);
   GridLogColours.Active(0);
   GridLogHMC.Active(1);
@@ -91,6 +93,7 @@ void GridLogConfigure(std::vector<std::string> &logstreams) {
     if (logstreams[i] == std::string("Iterative"))   GridLogIterative.Active(1);
     if (logstreams[i] == std::string("Debug"))       GridLogDebug.Active(1);
     if (logstreams[i] == std::string("Performance")) GridLogPerformance.Active(1);
+    if (logstreams[i] == std::string("Dslash"))      GridLogDslash.Active(1);
     if (logstreams[i] == std::string("NoIntegrator"))  GridLogIntegrator.Active(0);
     if (logstreams[i] == std::string("NoHMC"))         GridLogHMC.Active(0);
     if (logstreams[i] == std::string("Colours"))     GridLogColours.Active(1);

Grid/log/Log.h

@@ -138,7 +138,8 @@ public:
         stream << std::setw(log.topWidth);
       }
       stream << log.topName << log.background()<< " : ";
-      stream << log.colour() <<  std::left;
+      //      stream << log.colour() <<  std::left;
+      stream <<  std::left;
       if (log.chanWidth > 0)
       {
         stream << std::setw(log.chanWidth);
@@ -153,9 +154,9 @@ public:
 	stream << log.evidence()
 	       << now	       << log.background() << " : " ;
       }
-      stream << log.colour();
+      //      stream << log.colour();
+      stream <<  std::right;
       stream.flags(f);
-
       return stream;
     } else { 
       return devnull;
@@ -180,6 +181,7 @@ extern GridLogger GridLogWarning;
 extern GridLogger GridLogMessage;
 extern GridLogger GridLogDebug  ;
 extern GridLogger GridLogPerformance;
+extern GridLogger GridLogDslash;
 extern GridLogger GridLogIterative  ;
 extern GridLogger GridLogIntegrator  ;
 extern GridLogger GridLogHMC;

Grid/perfmon/PerfCount.cc

@@ -27,10 +27,13 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 /*  END LEGAL */
 
 #include <Grid/GridCore.h>
-#include <Grid/perfmon/PerfCount.h>
 
+#include <Grid/perfmon/Timer.h>
+#include <Grid/perfmon/PerfCount.h>
 NAMESPACE_BEGIN(Grid);
 
+GridTimePoint theProgramStart = GridClock::now();
+
 #define CacheControl(L,O,R) ((PERF_COUNT_HW_CACHE_##L)|(PERF_COUNT_HW_CACHE_OP_##O<<8)| (PERF_COUNT_HW_CACHE_RESULT_##R<<16))
 #define RawConfig(A,B) (A<<8|B)
 const PerformanceCounter::PerformanceCounterConfig PerformanceCounter::PerformanceCounterConfigs [] = {

Grid/perfmon/Timer.h

@@ -35,17 +35,8 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 
 NAMESPACE_BEGIN(Grid)
 
-// Dress the output; use std::chrono
-// C++11 time facilities better?
-inline double usecond(void) {
-  struct timeval tv;
-  tv.tv_sec = 0;
-  tv.tv_usec = 0;
-  gettimeofday(&tv,NULL);
-  return 1.0*tv.tv_usec + 1.0e6*tv.tv_sec;
-}
-
-typedef  std::chrono::system_clock          GridClock;
+//typedef  std::chrono::system_clock          GridClock;
+typedef  std::chrono::high_resolution_clock   GridClock;
 typedef  std::chrono::time_point<GridClock> GridTimePoint;
 
 typedef  std::chrono::seconds               GridSecs;
@@ -53,6 +44,15 @@ typedef  std::chrono::milliseconds          GridMillisecs;
 typedef  std::chrono::microseconds          GridUsecs;
 typedef  std::chrono::microseconds          GridTime;
 
+extern GridTimePoint theProgramStart;
+// Dress the output; use std::chrono
+// C++11 time facilities better?
+inline double usecond(void) {
+  auto usecs = std::chrono::duration_cast<GridUsecs>(GridClock::now()-theProgramStart); 
+  return 1.0*usecs.count();
+}
+
+
 inline std::ostream& operator<< (std::ostream & stream, const GridSecs & time)
 {
   stream << time.count()<<" s";

Grid/perfmon/Tracing.h

@@ -0,0 +1,66 @@
+#pragma once
+#ifdef GRID_TRACING_NVTX
+#include <nvToolsExt.h>
+class GridTracer {
+public:
+  GridTracer(const char* name) {
+    nvtxRangePushA(name);
+  }
+  ~GridTracer() {
+    nvtxRangePop();
+  }
+};
+inline void tracePush(const char *name) { nvtxRangePushA(name); }
+inline void tracePop(const char *name) { nvtxRangePop(); }
+inline int  traceStart(const char *name) {  }
+inline void traceStop(int ID) {  }
+#endif
+
+#ifdef GRID_TRACING_ROCTX
+#include <roctracer/roctx.h>
+class GridTracer {
+ public:
+  GridTracer(const char* name) {
+    roctxRangePushA(name);
+    std::cout << "roctxRangePush "<<name<<std::endl;
+  }
+  ~GridTracer() {
+    roctxRangePop();
+    std::cout << "roctxRangePop "<<std::endl;
+  }
+};
+inline void tracePush(const char *name) { roctxRangePushA(name); }
+inline void tracePop(const char *name) { roctxRangePop(); }
+inline int  traceStart(const char *name) { roctxRangeStart(name); }
+inline void traceStop(int ID) { roctxRangeStop(ID); }
+#endif
+
+#ifdef GRID_TRACING_TIMER
+class GridTracer {
+ public:
+  const char *name;
+  double elapsed;
+  GridTracer(const char* _name) {
+    name = _name;
+    elapsed=-usecond();
+  }
+  ~GridTracer() {
+    elapsed+=usecond();
+    std::cout << GridLogTracing << name << " took " <<elapsed<< " us" <<std::endl;
+  }
+};
+inline void tracePush(const char *name) {  }
+inline void tracePop(const char *name) {  }
+inline int  traceStart(const char *name) { return 0; }
+inline void traceStop(int ID) {  }
+#endif
+
+#ifdef GRID_TRACING_NONE
+#define GRID_TRACE(name) 
+inline void tracePush(const char *name) {  }
+inline void tracePop(const char *name) {  }
+inline int  traceStart(const char *name) { return 0;  }
+inline void traceStop(int ID) {  }
+#else
+#define GRID_TRACE(name) GridTracer uniq_name_using_macros##__COUNTER__(name);
+#endif

Grid/qcd/QCD.h

@@ -126,6 +126,7 @@ typedef iSpinMatrix<ComplexD >          SpinMatrixD;
 typedef iSpinMatrix<vComplex >          vSpinMatrix;
 typedef iSpinMatrix<vComplexF>          vSpinMatrixF;
 typedef iSpinMatrix<vComplexD>          vSpinMatrixD;
+typedef iSpinMatrix<vComplexD2>         vSpinMatrixD2;
 
 // Colour Matrix
 typedef iColourMatrix<Complex  >        ColourMatrix;
@@ -135,6 +136,7 @@ typedef iColourMatrix<ComplexD >        ColourMatrixD;
 typedef iColourMatrix<vComplex >        vColourMatrix;
 typedef iColourMatrix<vComplexF>        vColourMatrixF;
 typedef iColourMatrix<vComplexD>        vColourMatrixD;
+typedef iColourMatrix<vComplexD2>       vColourMatrixD2;
 
 // SpinColour matrix
 typedef iSpinColourMatrix<Complex  >    SpinColourMatrix;
@@ -144,6 +146,7 @@ typedef iSpinColourMatrix<ComplexD >    SpinColourMatrixD;
 typedef iSpinColourMatrix<vComplex >    vSpinColourMatrix;
 typedef iSpinColourMatrix<vComplexF>    vSpinColourMatrixF;
 typedef iSpinColourMatrix<vComplexD>    vSpinColourMatrixD;
+typedef iSpinColourMatrix<vComplexD2>   vSpinColourMatrixD2;
 
 // SpinColourSpinColour matrix
 typedef iSpinColourSpinColourMatrix<Complex  >    SpinColourSpinColourMatrix;
@@ -153,6 +156,7 @@ typedef iSpinColourSpinColourMatrix<ComplexD >    SpinColourSpinColourMatrixD;
 typedef iSpinColourSpinColourMatrix<vComplex >    vSpinColourSpinColourMatrix;
 typedef iSpinColourSpinColourMatrix<vComplexF>    vSpinColourSpinColourMatrixF;
 typedef iSpinColourSpinColourMatrix<vComplexD>    vSpinColourSpinColourMatrixD;
+typedef iSpinColourSpinColourMatrix<vComplexD2>   vSpinColourSpinColourMatrixD2;
 
 // SpinColourSpinColour matrix
 typedef iSpinColourSpinColourMatrix<Complex  >    SpinColourSpinColourMatrix;
@@ -162,33 +166,37 @@ typedef iSpinColourSpinColourMatrix<ComplexD >    SpinColourSpinColourMatrixD;
 typedef iSpinColourSpinColourMatrix<vComplex >    vSpinColourSpinColourMatrix;
 typedef iSpinColourSpinColourMatrix<vComplexF>    vSpinColourSpinColourMatrixF;
 typedef iSpinColourSpinColourMatrix<vComplexD>    vSpinColourSpinColourMatrixD;
+typedef iSpinColourSpinColourMatrix<vComplexD2>   vSpinColourSpinColourMatrixD2;
 
 // LorentzColour
 typedef iLorentzColourMatrix<Complex  > LorentzColourMatrix;
 typedef iLorentzColourMatrix<ComplexF > LorentzColourMatrixF;
 typedef iLorentzColourMatrix<ComplexD > LorentzColourMatrixD;
 
-typedef iLorentzColourMatrix<vComplex > vLorentzColourMatrix;
-typedef iLorentzColourMatrix<vComplexF> vLorentzColourMatrixF;
-typedef iLorentzColourMatrix<vComplexD> vLorentzColourMatrixD;
+typedef iLorentzColourMatrix<vComplex >  vLorentzColourMatrix;
+typedef iLorentzColourMatrix<vComplexF>  vLorentzColourMatrixF;
+typedef iLorentzColourMatrix<vComplexD>  vLorentzColourMatrixD;
+typedef iLorentzColourMatrix<vComplexD2> vLorentzColourMatrixD2;
 
 // DoubleStored gauge field
 typedef iDoubleStoredColourMatrix<Complex  > DoubleStoredColourMatrix;
 typedef iDoubleStoredColourMatrix<ComplexF > DoubleStoredColourMatrixF;
 typedef iDoubleStoredColourMatrix<ComplexD > DoubleStoredColourMatrixD;
 
-typedef iDoubleStoredColourMatrix<vComplex > vDoubleStoredColourMatrix;
-typedef iDoubleStoredColourMatrix<vComplexF> vDoubleStoredColourMatrixF;
-typedef iDoubleStoredColourMatrix<vComplexD> vDoubleStoredColourMatrixD;
+typedef iDoubleStoredColourMatrix<vComplex >  vDoubleStoredColourMatrix;
+typedef iDoubleStoredColourMatrix<vComplexF>  vDoubleStoredColourMatrixF;
+typedef iDoubleStoredColourMatrix<vComplexD>  vDoubleStoredColourMatrixD;
+typedef iDoubleStoredColourMatrix<vComplexD2> vDoubleStoredColourMatrixD2;
 
 //G-parity flavour matrix
 typedef iGparityFlavourMatrix<Complex> GparityFlavourMatrix;
 typedef iGparityFlavourMatrix<ComplexF> GparityFlavourMatrixF;
 typedef iGparityFlavourMatrix<ComplexD> GparityFlavourMatrixD;
 
-typedef iGparityFlavourMatrix<vComplex> vGparityFlavourMatrix;
-typedef iGparityFlavourMatrix<vComplexF> vGparityFlavourMatrixF;
-typedef iGparityFlavourMatrix<vComplexD> vGparityFlavourMatrixD;
+typedef iGparityFlavourMatrix<vComplex>   vGparityFlavourMatrix;
+typedef iGparityFlavourMatrix<vComplexF>  vGparityFlavourMatrixF;
+typedef iGparityFlavourMatrix<vComplexD>  vGparityFlavourMatrixD;
+typedef iGparityFlavourMatrix<vComplexD2> vGparityFlavourMatrixD2;
 
 
 // Spin vector
@@ -199,6 +207,7 @@ typedef iSpinVector<ComplexD>           SpinVectorD;
 typedef iSpinVector<vComplex >           vSpinVector;
 typedef iSpinVector<vComplexF>           vSpinVectorF;
 typedef iSpinVector<vComplexD>           vSpinVectorD;
+typedef iSpinVector<vComplexD2>          vSpinVectorD2;
 
 // Colour vector
 typedef iColourVector<Complex >         ColourVector;
@@ -208,6 +217,7 @@ typedef iColourVector<ComplexD>         ColourVectorD;
 typedef iColourVector<vComplex >         vColourVector;
 typedef iColourVector<vComplexF>         vColourVectorF;
 typedef iColourVector<vComplexD>         vColourVectorD;
+typedef iColourVector<vComplexD2>        vColourVectorD2;
 
 // SpinColourVector
 typedef iSpinColourVector<Complex >     SpinColourVector;
@@ -217,6 +227,7 @@ typedef iSpinColourVector<ComplexD>     SpinColourVectorD;
 typedef iSpinColourVector<vComplex >     vSpinColourVector;
 typedef iSpinColourVector<vComplexF>     vSpinColourVectorF;
 typedef iSpinColourVector<vComplexD>     vSpinColourVectorD;
+typedef iSpinColourVector<vComplexD2>    vSpinColourVectorD2;
 
 // HalfSpin vector
 typedef iHalfSpinVector<Complex >       HalfSpinVector;
@@ -226,15 +237,17 @@ typedef iHalfSpinVector<ComplexD>       HalfSpinVectorD;
 typedef iHalfSpinVector<vComplex >       vHalfSpinVector;
 typedef iHalfSpinVector<vComplexF>       vHalfSpinVectorF;
 typedef iHalfSpinVector<vComplexD>       vHalfSpinVectorD;
+typedef iHalfSpinVector<vComplexD2>      vHalfSpinVectorD2;
 
 // HalfSpinColour vector
 typedef iHalfSpinColourVector<Complex > HalfSpinColourVector;
 typedef iHalfSpinColourVector<ComplexF> HalfSpinColourVectorF;
 typedef iHalfSpinColourVector<ComplexD> HalfSpinColourVectorD;
     
-typedef iHalfSpinColourVector<vComplex > vHalfSpinColourVector;
-typedef iHalfSpinColourVector<vComplexF> vHalfSpinColourVectorF;
-typedef iHalfSpinColourVector<vComplexD> vHalfSpinColourVectorD;
+typedef iHalfSpinColourVector<vComplex >  vHalfSpinColourVector;
+typedef iHalfSpinColourVector<vComplexF>  vHalfSpinColourVectorF;
+typedef iHalfSpinColourVector<vComplexD>  vHalfSpinColourVectorD;
+typedef iHalfSpinColourVector<vComplexD2> vHalfSpinColourVectorD2;
 
 //G-parity flavour vector
 typedef iGparityFlavourVector<Complex >         GparityFlavourVector;
@@ -244,7 +257,7 @@ typedef iGparityFlavourVector<ComplexD>         GparityFlavourVectorD;
 typedef iGparityFlavourVector<vComplex >         vGparityFlavourVector;
 typedef iGparityFlavourVector<vComplexF>         vGparityFlavourVectorF;
 typedef iGparityFlavourVector<vComplexD>         vGparityFlavourVectorD;
-
+typedef iGparityFlavourVector<vComplexD2>        vGparityFlavourVectorD2;
     
 // singlets
 typedef iSinglet<Complex >         TComplex;     // FIXME This is painful. Tensor singlet complex type.
@@ -254,6 +267,7 @@ typedef iSinglet<ComplexD>         TComplexD;    // FIXME This is painful. Tenso
 typedef iSinglet<vComplex >        vTComplex ;   // what if we don't know the tensor structure
 typedef iSinglet<vComplexF>        vTComplexF;   // what if we don't know the tensor structure
 typedef iSinglet<vComplexD>        vTComplexD;   // what if we don't know the tensor structure
+typedef iSinglet<vComplexD2>       vTComplexD2;   // what if we don't know the tensor structure
 
 typedef iSinglet<Real >            TReal;        // Shouldn't need these; can I make it work without?
 typedef iSinglet<RealF>            TRealF;       // Shouldn't need these; can I make it work without?
@@ -271,47 +285,58 @@ typedef iSinglet<Integer >         TInteger;
 typedef Lattice<vColourMatrix>          LatticeColourMatrix;
 typedef Lattice<vColourMatrixF>         LatticeColourMatrixF;
 typedef Lattice<vColourMatrixD>         LatticeColourMatrixD;
+typedef Lattice<vColourMatrixD2>        LatticeColourMatrixD2;
 
 typedef Lattice<vSpinMatrix>            LatticeSpinMatrix;
 typedef Lattice<vSpinMatrixF>           LatticeSpinMatrixF;
 typedef Lattice<vSpinMatrixD>           LatticeSpinMatrixD;
+typedef Lattice<vSpinMatrixD2>          LatticeSpinMatrixD2;
 
 typedef Lattice<vSpinColourMatrix>      LatticeSpinColourMatrix;
 typedef Lattice<vSpinColourMatrixF>     LatticeSpinColourMatrixF;
 typedef Lattice<vSpinColourMatrixD>     LatticeSpinColourMatrixD;
+typedef Lattice<vSpinColourMatrixD2>    LatticeSpinColourMatrixD2;
 
 typedef Lattice<vSpinColourSpinColourMatrix>      LatticeSpinColourSpinColourMatrix;
 typedef Lattice<vSpinColourSpinColourMatrixF>     LatticeSpinColourSpinColourMatrixF;
 typedef Lattice<vSpinColourSpinColourMatrixD>     LatticeSpinColourSpinColourMatrixD;
+typedef Lattice<vSpinColourSpinColourMatrixD2>    LatticeSpinColourSpinColourMatrixD2;
 
-typedef Lattice<vLorentzColourMatrix>  LatticeLorentzColourMatrix;
-typedef Lattice<vLorentzColourMatrixF> LatticeLorentzColourMatrixF;
-typedef Lattice<vLorentzColourMatrixD> LatticeLorentzColourMatrixD;
+typedef Lattice<vLorentzColourMatrix>   LatticeLorentzColourMatrix;
+typedef Lattice<vLorentzColourMatrixF>  LatticeLorentzColourMatrixF;
+typedef Lattice<vLorentzColourMatrixD>  LatticeLorentzColourMatrixD;
+typedef Lattice<vLorentzColourMatrixD2> LatticeLorentzColourMatrixD2;
 
 // DoubleStored gauge field
-typedef Lattice<vDoubleStoredColourMatrix>  LatticeDoubleStoredColourMatrix;
-typedef Lattice<vDoubleStoredColourMatrixF> LatticeDoubleStoredColourMatrixF;
-typedef Lattice<vDoubleStoredColourMatrixD> LatticeDoubleStoredColourMatrixD;
+typedef Lattice<vDoubleStoredColourMatrix>   LatticeDoubleStoredColourMatrix;
+typedef Lattice<vDoubleStoredColourMatrixF>  LatticeDoubleStoredColourMatrixF;
+typedef Lattice<vDoubleStoredColourMatrixD>  LatticeDoubleStoredColourMatrixD;
+typedef Lattice<vDoubleStoredColourMatrixD2> LatticeDoubleStoredColourMatrixD2;
 
 typedef Lattice<vSpinVector>            LatticeSpinVector;
 typedef Lattice<vSpinVectorF>           LatticeSpinVectorF;
 typedef Lattice<vSpinVectorD>           LatticeSpinVectorD;
+typedef Lattice<vSpinVectorD2>          LatticeSpinVectorD2;
 
 typedef Lattice<vColourVector>          LatticeColourVector;
 typedef Lattice<vColourVectorF>         LatticeColourVectorF;
 typedef Lattice<vColourVectorD>         LatticeColourVectorD;
+typedef Lattice<vColourVectorD2>        LatticeColourVectorD2;
 
 typedef Lattice<vSpinColourVector>      LatticeSpinColourVector;
 typedef Lattice<vSpinColourVectorF>     LatticeSpinColourVectorF;
 typedef Lattice<vSpinColourVectorD>     LatticeSpinColourVectorD;
+typedef Lattice<vSpinColourVectorD2>    LatticeSpinColourVectorD2;
 
 typedef Lattice<vHalfSpinVector>        LatticeHalfSpinVector;
 typedef Lattice<vHalfSpinVectorF>       LatticeHalfSpinVectorF;
 typedef Lattice<vHalfSpinVectorD>       LatticeHalfSpinVectorD;
+typedef Lattice<vHalfSpinVectorD2>      LatticeHalfSpinVectorD2;
 
-typedef Lattice<vHalfSpinColourVector>  LatticeHalfSpinColourVector;
-typedef Lattice<vHalfSpinColourVectorF> LatticeHalfSpinColourVectorF;
-typedef Lattice<vHalfSpinColourVectorD> LatticeHalfSpinColourVectorD;
+typedef Lattice<vHalfSpinColourVector>   LatticeHalfSpinColourVector;
+typedef Lattice<vHalfSpinColourVectorF>  LatticeHalfSpinColourVectorF;
+typedef Lattice<vHalfSpinColourVectorD>  LatticeHalfSpinColourVectorD;
+typedef Lattice<vHalfSpinColourVectorD2> LatticeHalfSpinColourVectorD2;
 
 typedef Lattice<vTReal>            LatticeReal;
 typedef Lattice<vTRealF>           LatticeRealF;
@@ -320,6 +345,7 @@ typedef Lattice<vTRealD>           LatticeRealD;
 typedef Lattice<vTComplex>         LatticeComplex;
 typedef Lattice<vTComplexF>        LatticeComplexF;
 typedef Lattice<vTComplexD>        LatticeComplexD;
+typedef Lattice<vTComplexD2>       LatticeComplexD2;
 
 typedef Lattice<vTInteger>         LatticeInteger; // Predicates for "where"
 
@@ -327,37 +353,42 @@ typedef Lattice<vTInteger>         LatticeInteger; // Predicates for "where"
 ///////////////////////////////////////////
 // Physical names for things
 ///////////////////////////////////////////
-typedef LatticeHalfSpinColourVector  LatticeHalfFermion;
-typedef LatticeHalfSpinColourVectorF LatticeHalfFermionF;
-typedef LatticeHalfSpinColourVectorF LatticeHalfFermionD;
+typedef LatticeHalfSpinColourVector   LatticeHalfFermion;
+typedef LatticeHalfSpinColourVectorF  LatticeHalfFermionF;
+typedef LatticeHalfSpinColourVectorD  LatticeHalfFermionD;
+typedef LatticeHalfSpinColourVectorD2 LatticeHalfFermionD2;
 
 typedef LatticeSpinColourVector      LatticeFermion;
 typedef LatticeSpinColourVectorF     LatticeFermionF;
 typedef LatticeSpinColourVectorD     LatticeFermionD;
+typedef LatticeSpinColourVectorD2    LatticeFermionD2;
 
 typedef LatticeSpinColourMatrix                LatticePropagator;
 typedef LatticeSpinColourMatrixF               LatticePropagatorF;
 typedef LatticeSpinColourMatrixD               LatticePropagatorD;
+typedef LatticeSpinColourMatrixD2              LatticePropagatorD2;
 
 typedef LatticeLorentzColourMatrix             LatticeGaugeField;
 typedef LatticeLorentzColourMatrixF            LatticeGaugeFieldF;
 typedef LatticeLorentzColourMatrixD            LatticeGaugeFieldD;
+typedef LatticeLorentzColourMatrixD2           LatticeGaugeFieldD2;
 
 typedef LatticeDoubleStoredColourMatrix        LatticeDoubledGaugeField;
 typedef LatticeDoubleStoredColourMatrixF       LatticeDoubledGaugeFieldF;
 typedef LatticeDoubleStoredColourMatrixD       LatticeDoubledGaugeFieldD;
+typedef LatticeDoubleStoredColourMatrixD2      LatticeDoubledGaugeFieldD2;
 
 template<class GF> using LorentzScalar = Lattice<iScalar<typename GF::vector_object::element> >;
 
-// Uhgg... typing this hurt  ;)
-// (my keyboard got burning hot when I typed this, must be the anti-Fermion)
 typedef Lattice<vColourVector>          LatticeStaggeredFermion;    
 typedef Lattice<vColourVectorF>         LatticeStaggeredFermionF;    
 typedef Lattice<vColourVectorD>         LatticeStaggeredFermionD;    
+typedef Lattice<vColourVectorD2>        LatticeStaggeredFermionD2;    
 
 typedef Lattice<vColourMatrix>          LatticeStaggeredPropagator; 
 typedef Lattice<vColourMatrixF>         LatticeStaggeredPropagatorF; 
 typedef Lattice<vColourMatrixD>         LatticeStaggeredPropagatorD; 
+typedef Lattice<vColourMatrixD2>        LatticeStaggeredPropagatorD2; 
 
 //////////////////////////////////////////////////////////////////////////////
 // Peek and Poke named after physics attributes

Grid/qcd/action/ActionBase.h

@@ -42,21 +42,31 @@ public:
   bool is_smeared = false;
   RealD deriv_norm_sum;
   RealD deriv_max_sum;
+  RealD Fdt_norm_sum;
+  RealD Fdt_max_sum;
   int   deriv_num;
   RealD deriv_us;
   RealD S_us;
   RealD refresh_us;
   void  reset_timer(void)        {
     deriv_us = S_us = refresh_us = 0.0;
-    deriv_num=0;
     deriv_norm_sum = deriv_max_sum=0.0;
+    Fdt_max_sum =  Fdt_norm_sum = 0.0;
+    deriv_num=0;
   }
-  void  deriv_log(RealD nrm, RealD max) { deriv_max_sum+=max; deriv_norm_sum+=nrm; deriv_num++;}
-  RealD deriv_max_average(void)         { return deriv_max_sum/deriv_num; };
-  RealD deriv_norm_average(void)        { return deriv_norm_sum/deriv_num; };
+  void  deriv_log(RealD nrm, RealD max,RealD Fdt_nrm,RealD Fdt_max) {
+    deriv_max_sum+=max;
+    deriv_norm_sum+=nrm;
+    Fdt_max_sum+=Fdt_max;
+    Fdt_norm_sum+=Fdt_nrm; deriv_num++;
+  }
+  RealD deriv_max_average(void)       { return deriv_max_sum/deriv_num; };
+  RealD deriv_norm_average(void)      { return deriv_norm_sum/deriv_num; };
+  RealD Fdt_max_average(void)         { return Fdt_max_sum/deriv_num; };
+  RealD Fdt_norm_average(void)        { return Fdt_norm_sum/deriv_num; };
   RealD deriv_timer(void)        { return deriv_us; };
-  RealD S_timer(void)            { return deriv_us; };
-  RealD refresh_timer(void)      { return deriv_us; };
+  RealD S_timer(void)            { return S_us; };
+  RealD refresh_timer(void)      { return refresh_us; };
   void deriv_timer_start(void)   { deriv_us-=usecond(); }
   void deriv_timer_stop(void)    { deriv_us+=usecond(); }
   void refresh_timer_start(void) { refresh_us-=usecond(); }
@@ -66,6 +76,7 @@ public:
   // Heatbath?
   virtual void refresh(const GaugeField& U, GridSerialRNG &sRNG, GridParallelRNG& pRNG) = 0; // refresh pseudofermions
   virtual RealD S(const GaugeField& U) = 0;                             // evaluate the action
+  virtual RealD Sinitial(const GaugeField& U) { return this->S(U); } ;  // if the refresh computes the action, can cache it. Alternately refreshAndAction() ?
   virtual void deriv(const GaugeField& U, GaugeField& dSdU) = 0;        // evaluate the action derivative
   virtual std::string action_name()    = 0;                             // return the action name
   virtual std::string LogParameters()  = 0;                             // prints action parameters

Grid/qcd/action/ActionParams.h

@@ -39,30 +39,39 @@ struct GparityWilsonImplParams {
   Coordinate twists;
                      //mu=Nd-1 is assumed to be the time direction and a twist value of 1 indicates antiperiodic BCs
   Coordinate dirichlet; // Blocksize of dirichlet BCs
-  GparityWilsonImplParams() : twists(Nd, 0), dirichlet(Nd, 0) {};
+  int  partialDirichlet;
+  GparityWilsonImplParams() : twists(Nd, 0) {
+    dirichlet.resize(0);
+    partialDirichlet=0;
+  };
 };
   
 struct WilsonImplParams {
   bool overlapCommsCompute;
   Coordinate dirichlet; // Blocksize of dirichlet BCs
+  int  partialDirichlet;
   AcceleratorVector<Real,Nd> twist_n_2pi_L;
   AcceleratorVector<Complex,Nd> boundary_phases;
   WilsonImplParams()  {
-    dirichlet.resize(Nd,0);
+    dirichlet.resize(0);
+    partialDirichlet=0;
     boundary_phases.resize(Nd, 1.0);
       twist_n_2pi_L.resize(Nd, 0.0);
   };
   WilsonImplParams(const AcceleratorVector<Complex,Nd> phi) : boundary_phases(phi), overlapCommsCompute(false) {
     twist_n_2pi_L.resize(Nd, 0.0);
-    dirichlet.resize(Nd,0);
+    partialDirichlet=0;
+    dirichlet.resize(0);
   }
 };
 
 struct StaggeredImplParams {
   Coordinate dirichlet; // Blocksize of dirichlet BCs
+  int  partialDirichlet;
   StaggeredImplParams()
   {
-    dirichlet.resize(Nd,0);
+    partialDirichlet=0;
+    dirichlet.resize(0);
   };
 };
   

Grid/qcd/action/fermion/CayleyFermion5D.h

@@ -183,16 +183,6 @@ public:
 		  GridRedBlackCartesian &FourDimRedBlackGrid,
 		  RealD _mass,RealD _M5,const ImplParams &p= ImplParams());
 
-  void CayleyReport(void);
-  void CayleyZeroCounters(void);
-
-  double M5Dflops;
-  double M5Dcalls;
-  double M5Dtime;
-
-  double MooeeInvFlops;
-  double MooeeInvCalls;
-  double MooeeInvTime;
 
 protected:
   virtual void SetCoefficientsZolotarev(RealD zolohi,Approx::zolotarev_data *zdata,RealD b,RealD c);

Grid/qcd/action/fermion/CloverHelpers.h

@@ -140,6 +140,7 @@ public:
     return NMAX;
   }
 
+  static int getNMAX(Lattice<iImplClover<vComplexD2>> &t, RealD R) {return getNMAX(1e-12,R);}
   static int getNMAX(Lattice<iImplClover<vComplexD>> &t, RealD R) {return getNMAX(1e-12,R);}
   static int getNMAX(Lattice<iImplClover<vComplexF>> &t, RealD R) {return getNMAX(1e-6,R);}
 

Grid/qcd/action/fermion/DWFSlow.h

@@ -0,0 +1,291 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/action/fermion/DWFSlow.h
+
+Copyright (C) 2022
+
+Author: Peter Boyle <pboyle@bnl.gov>
+
+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 */
+#pragma once
+
+NAMESPACE_BEGIN(Grid);
+
+template <class Impl>
+class DWFSlowFermion : public FermionOperator<Impl>
+{
+public:
+  INHERIT_IMPL_TYPES(Impl);
+
+  ///////////////////////////////////////////////////////////////
+  // Implement the abstract base
+  ///////////////////////////////////////////////////////////////
+  GridBase *GaugeGrid(void) { return _grid4; }
+  GridBase *GaugeRedBlackGrid(void) { return _cbgrid4; }
+  GridBase *FermionGrid(void) { return _grid; }
+  GridBase *FermionRedBlackGrid(void) { return _cbgrid; }
+
+  FermionField _tmp;
+  FermionField &tmp(void) { return _tmp; }
+
+  //////////////////////////////////////////////////////////////////
+  // override multiply; cut number routines if pass dagger argument
+  // and also make interface more uniformly consistent
+  //////////////////////////////////////////////////////////////////
+  virtual void  M(const FermionField &in, FermionField &out)
+  {
+    FermionField tmp(_grid);
+    out = (5.0 - M5) * in;
+    Dhop(in,tmp,DaggerNo);
+    out = out + tmp;
+  }
+  virtual void  Mdag(const FermionField &in, FermionField &out)
+  {
+    FermionField tmp(_grid);
+    out = (5.0 - M5) * in;
+    Dhop(in,tmp,DaggerYes);
+    out = out + tmp;
+  };
+
+  /////////////////////////////////////////////////////////
+  // half checkerboard operations 5D redblack so just site identiy
+  /////////////////////////////////////////////////////////
+  void Meooe(const FermionField &in, FermionField &out)
+  {
+    if ( in.Checkerboard() == Odd ) {
+      this->DhopEO(in,out,DaggerNo);
+    } else {
+      this->DhopOE(in,out,DaggerNo);
+    }
+  }
+  void MeooeDag(const FermionField &in, FermionField &out)
+  {
+    if ( in.Checkerboard() == Odd ) {
+      this->DhopEO(in,out,DaggerYes);
+    } else {
+      this->DhopOE(in,out,DaggerYes);
+    }
+  };
+
+  // allow override for twisted mass and clover
+  virtual void Mooee(const FermionField &in, FermionField &out)
+  {
+    out = (5.0 - M5) * in;
+  }
+  virtual void MooeeDag(const FermionField &in, FermionField &out)
+  {
+    out = (5.0 - M5) * in;
+  }
+  virtual void MooeeInv(const FermionField &in, FermionField &out)
+  {
+    out = (1.0/(5.0 - M5)) * in;
+  };
+  virtual void MooeeInvDag(const FermionField &in, FermionField &out)
+  {
+    out = (1.0/(5.0 - M5)) * in;
+  };
+
+  virtual void  MomentumSpacePropagator(FermionField &out,const FermionField &in,RealD _mass,std::vector<double> twist) {} ;
+
+  ////////////////////////
+  // Derivative interface
+  ////////////////////////
+  // Interface calls an internal routine
+  void DhopDeriv(GaugeField &mat,const FermionField &U,const FermionField &V,int dag)  { assert(0);};
+  void DhopDerivOE(GaugeField &mat,const FermionField &U,const FermionField &V,int dag){ assert(0);};
+  void DhopDerivEO(GaugeField &mat,const FermionField &U,const FermionField &V,int dag){ assert(0);};
+
+  ///////////////////////////////////////////////////////////////
+  // non-hermitian hopping term; half cb or both
+  ///////////////////////////////////////////////////////////////
+  void Dhop(const FermionField &in, FermionField &out, int dag)
+  {
+    FermionField tmp(in.Grid());
+    Dhop5(in,out,MassField,MassField,dag );
+    for(int mu=0;mu<4;mu++){
+      DhopDirU(in,Umu[mu],Umu[mu],tmp,mu,dag );    out = out + tmp;
+    }
+  };
+  void DhopOE(const FermionField &in, FermionField &out, int dag)
+  {
+    FermionField tmp(in.Grid());
+    assert(in.Checkerboard()==Even);
+    Dhop5(in,out,MassFieldOdd,MassFieldEven,dag);
+    for(int mu=0;mu<4;mu++){
+      DhopDirU(in,UmuOdd[mu],UmuEven[mu],tmp,mu,dag );    out = out + tmp;
+    }
+  };
+  void DhopEO(const FermionField &in, FermionField &out, int dag)
+  {
+    FermionField tmp(in.Grid());
+    assert(in.Checkerboard()==Odd);
+    Dhop5(in,out, MassFieldEven,MassFieldOdd ,dag );  
+    for(int mu=0;mu<4;mu++){
+      DhopDirU(in,UmuEven[mu],UmuOdd[mu],tmp,mu,dag );    out = out + tmp;
+    }
+  };
+
+  ///////////////////////////////////////////////////////////////
+  // Multigrid assistance; force term uses too
+  ///////////////////////////////////////////////////////////////
+  void Mdir(const FermionField &in, FermionField &out, int dir, int disp){ assert(0);};
+  void MdirAll(const FermionField &in, std::vector<FermionField> &out)   { assert(0);};
+  void DhopDir(const FermionField &in, FermionField &out, int dir, int disp) { assert(0);};
+  void DhopDirAll(const FermionField &in, std::vector<FermionField> &out)    { assert(0);};
+  void DhopDirCalc(const FermionField &in, FermionField &out, int dirdisp,int gamma, int dag) { assert(0);};
+
+  void DhopDirU(const FermionField &in, const GaugeLinkField &U5e, const GaugeLinkField &U5o, FermionField &out, int mu, int dag)
+  {
+    RealD     sgn= 1.0;
+    if (dag ) sgn=-1.0;
+
+    Gamma::Algebra Gmu [] = {
+			 Gamma::Algebra::GammaX,
+			 Gamma::Algebra::GammaY,
+			 Gamma::Algebra::GammaZ,
+			 Gamma::Algebra::GammaT
+    };
+
+    //    mass is  1,1,1,1,-m has to multiply the round the world term
+    FermionField tmp (in.Grid());
+    tmp = U5e * Cshift(in,mu+1,1);
+    out = tmp - Gamma(Gmu[mu])*tmp*sgn;
+    
+    tmp = Cshift(adj(U5o)*in,mu+1,-1);
+    out = out + tmp + Gamma(Gmu[mu])*tmp*sgn;
+
+    out = -0.5*out;
+  };
+
+  void Dhop5(const FermionField &in, FermionField &out, ComplexField &massE, ComplexField &massO, int dag)
+  {
+    // Mass term.... must multiple the round world with mass = 1,1,1,1, -m
+    RealD     sgn= 1.0;
+    if (dag ) sgn=-1.0;
+
+    Gamma G5(Gamma::Algebra::Gamma5);
+
+    FermionField tmp (in.Grid());
+    tmp = massE*Cshift(in,0,1);
+    out = tmp - G5*tmp*sgn;
+    
+    tmp = Cshift(massO*in,0,-1);
+    out = out + tmp + G5*tmp*sgn;
+    out = -0.5*out;
+  };
+
+  // Constructor
+  DWFSlowFermion(GaugeField &_Umu, GridCartesian &Fgrid,
+		 GridRedBlackCartesian &Hgrid, RealD _mass, RealD _M5)
+    :
+    _grid(&Fgrid),
+    _cbgrid(&Hgrid),
+    _grid4(_Umu.Grid()),
+    Umu(Nd,&Fgrid),
+    UmuEven(Nd,&Hgrid),
+    UmuOdd(Nd,&Hgrid),
+    MassField(&Fgrid),
+    MassFieldEven(&Hgrid),
+    MassFieldOdd(&Hgrid),
+    M5(_M5),
+    mass(_mass),
+    _tmp(&Hgrid)
+    {
+      Ls=Fgrid._fdimensions[0];
+      ImportGauge(_Umu);
+
+      typedef typename FermionField::scalar_type scalar;
+
+      Lattice<iScalar<vInteger> > coor(&Fgrid);
+      LatticeCoordinate(coor, 0); // Scoor
+      ComplexField one(&Fgrid);
+      MassField =scalar(-mass);
+      one       =scalar(1.0);
+      MassField =where(coor==Integer(Ls-1),MassField,one);
+      for(int mu=0;mu<Nd;mu++){
+	pickCheckerboard(Even,UmuEven[mu],Umu[mu]);
+	pickCheckerboard(Odd ,UmuOdd[mu],Umu[mu]);
+      }
+      pickCheckerboard(Even,MassFieldEven,MassField);
+      pickCheckerboard(Odd ,MassFieldOdd,MassField);
+      
+    }
+  
+  // DoubleStore impl dependent
+  void ImportGauge(const GaugeField &_Umu4)
+  {
+    GaugeLinkField U4(_grid4);
+    for(int mu=0;mu<Nd;mu++){
+      U4 = PeekIndex<LorentzIndex>(_Umu4, mu);
+      for(int s=0;s<this->Ls;s++){
+	InsertSlice(U4,Umu[mu],s,0);
+      }
+    }
+  }
+
+  ///////////////////////////////////////////////////////////////
+  // Data members require to support the functionality
+  ///////////////////////////////////////////////////////////////
+
+public:
+  virtual RealD Mass(void) { return mass; }
+  virtual int   isTrivialEE(void) { return 1; };
+  RealD mass;
+  RealD M5;
+  int Ls;
+
+  GridBase *_grid4;
+  GridBase *_grid;
+  GridBase *_cbgrid4;
+  GridBase *_cbgrid;
+
+  // Copy of the gauge field , with even and odd subsets
+  std::vector<GaugeLinkField> Umu;
+  std::vector<GaugeLinkField> UmuEven;
+  std::vector<GaugeLinkField> UmuOdd;
+  ComplexField MassField;
+  ComplexField MassFieldEven;
+  ComplexField MassFieldOdd;
+
+  ///////////////////////////////////////////////////////////////
+  // Conserved current utilities
+  ///////////////////////////////////////////////////////////////
+  void ContractConservedCurrent(PropagatorField &q_in_1,
+                                PropagatorField &q_in_2,
+                                PropagatorField &q_out,
+                                PropagatorField &phys_src,
+                                Current curr_type,
+                                unsigned int mu){}
+  void SeqConservedCurrent(PropagatorField &q_in,
+                           PropagatorField &q_out,
+                           PropagatorField &phys_src,
+                           Current curr_type,
+                           unsigned int mu,
+                           unsigned int tmin,
+			   unsigned int tmax,
+			   ComplexField &lattice_cmplx){}
+};
+
+typedef DWFSlowFermion<WilsonImplF> DWFSlowFermionF;
+typedef DWFSlowFermion<WilsonImplD> DWFSlowFermionD;
+
+NAMESPACE_END(Grid);

Grid/qcd/action/fermion/Fermion.h

@@ -47,6 +47,7 @@ Author: Peter Boyle <pabobyle@ph.ed.ac.uk>
 ////////////////////////////////////////////
 // Fermion operators / actions
 ////////////////////////////////////////////
+#include <Grid/qcd/action/fermion/DWFSlow.h>       // Slow DWF
 
 #include <Grid/qcd/action/fermion/WilsonFermion.h>       // 4d wilson like
 NAMESPACE_CHECK(Wilson);
@@ -112,28 +113,21 @@ NAMESPACE_CHECK(DWFutils);
 // Cayley 5d
 NAMESPACE_BEGIN(Grid);
 
-typedef WilsonFermion<WilsonImplR> WilsonFermionR;
+typedef WilsonFermion<WilsonImplD2> WilsonFermionD2;
 typedef WilsonFermion<WilsonImplF> WilsonFermionF;
 typedef WilsonFermion<WilsonImplD> WilsonFermionD;
 
-//typedef WilsonFermion<WilsonImplRL> WilsonFermionRL;
-//typedef WilsonFermion<WilsonImplFH> WilsonFermionFH;
-//typedef WilsonFermion<WilsonImplDF> WilsonFermionDF;
-
-typedef WilsonFermion<WilsonAdjImplR> WilsonAdjFermionR;
 typedef WilsonFermion<WilsonAdjImplF> WilsonAdjFermionF;
 typedef WilsonFermion<WilsonAdjImplD> WilsonAdjFermionD;
 
-typedef WilsonFermion<WilsonTwoIndexSymmetricImplR> WilsonTwoIndexSymmetricFermionR;
 typedef WilsonFermion<WilsonTwoIndexSymmetricImplF> WilsonTwoIndexSymmetricFermionF;
 typedef WilsonFermion<WilsonTwoIndexSymmetricImplD> WilsonTwoIndexSymmetricFermionD;
 
-typedef WilsonFermion<WilsonTwoIndexAntiSymmetricImplR> WilsonTwoIndexAntiSymmetricFermionR;
 typedef WilsonFermion<WilsonTwoIndexAntiSymmetricImplF> WilsonTwoIndexAntiSymmetricFermionF;
 typedef WilsonFermion<WilsonTwoIndexAntiSymmetricImplD> WilsonTwoIndexAntiSymmetricFermionD;
 
 // Twisted mass fermion
-typedef WilsonTMFermion<WilsonImplR> WilsonTMFermionR;
+typedef WilsonTMFermion<WilsonImplD2> WilsonTMFermionD2;
 typedef WilsonTMFermion<WilsonImplF> WilsonTMFermionF;
 typedef WilsonTMFermion<WilsonImplD> WilsonTMFermionD;
 
@@ -141,23 +135,20 @@ typedef WilsonTMFermion<WilsonImplD> WilsonTMFermionD;
 template <typename WImpl> using WilsonClover = WilsonCloverFermion<WImpl, CloverHelpers<WImpl>>;
 template <typename WImpl> using WilsonExpClover = WilsonCloverFermion<WImpl, ExpCloverHelpers<WImpl>>;
 
-typedef WilsonClover<WilsonImplR> WilsonCloverFermionR;
+typedef WilsonClover<WilsonImplD2> WilsonCloverFermionD2;
 typedef WilsonClover<WilsonImplF> WilsonCloverFermionF;
 typedef WilsonClover<WilsonImplD> WilsonCloverFermionD;
 
-typedef WilsonExpClover<WilsonImplR> WilsonExpCloverFermionR;
+typedef WilsonExpClover<WilsonImplD2> WilsonExpCloverFermionD2;
 typedef WilsonExpClover<WilsonImplF> WilsonExpCloverFermionF;
 typedef WilsonExpClover<WilsonImplD> WilsonExpCloverFermionD;
 
-typedef WilsonClover<WilsonAdjImplR> WilsonCloverAdjFermionR;
 typedef WilsonClover<WilsonAdjImplF> WilsonCloverAdjFermionF;
 typedef WilsonClover<WilsonAdjImplD> WilsonCloverAdjFermionD;
 
-typedef WilsonClover<WilsonTwoIndexSymmetricImplR> WilsonCloverTwoIndexSymmetricFermionR;
 typedef WilsonClover<WilsonTwoIndexSymmetricImplF> WilsonCloverTwoIndexSymmetricFermionF;
 typedef WilsonClover<WilsonTwoIndexSymmetricImplD> WilsonCloverTwoIndexSymmetricFermionD;
 
-typedef WilsonClover<WilsonTwoIndexAntiSymmetricImplR> WilsonCloverTwoIndexAntiSymmetricFermionR;
 typedef WilsonClover<WilsonTwoIndexAntiSymmetricImplF> WilsonCloverTwoIndexAntiSymmetricFermionF;
 typedef WilsonClover<WilsonTwoIndexAntiSymmetricImplD> WilsonCloverTwoIndexAntiSymmetricFermionD;
 
@@ -165,161 +156,108 @@ typedef WilsonClover<WilsonTwoIndexAntiSymmetricImplD> WilsonCloverTwoIndexAntiS
 template <typename WImpl> using CompactWilsonClover = CompactWilsonCloverFermion<WImpl, CompactCloverHelpers<WImpl>>;
 template <typename WImpl> using CompactWilsonExpClover = CompactWilsonCloverFermion<WImpl, CompactExpCloverHelpers<WImpl>>;
 
-typedef CompactWilsonClover<WilsonImplR> CompactWilsonCloverFermionR;
+typedef CompactWilsonClover<WilsonImplD2> CompactWilsonCloverFermionD2;
 typedef CompactWilsonClover<WilsonImplF> CompactWilsonCloverFermionF;
 typedef CompactWilsonClover<WilsonImplD> CompactWilsonCloverFermionD;
 
-typedef CompactWilsonExpClover<WilsonImplR> CompactWilsonExpCloverFermionR;
+typedef CompactWilsonExpClover<WilsonImplD2> CompactWilsonExpCloverFermionD2;
 typedef CompactWilsonExpClover<WilsonImplF> CompactWilsonExpCloverFermionF;
 typedef CompactWilsonExpClover<WilsonImplD> CompactWilsonExpCloverFermionD;
 
-typedef CompactWilsonClover<WilsonAdjImplR> CompactWilsonCloverAdjFermionR;
 typedef CompactWilsonClover<WilsonAdjImplF> CompactWilsonCloverAdjFermionF;
 typedef CompactWilsonClover<WilsonAdjImplD> CompactWilsonCloverAdjFermionD;
 
-typedef CompactWilsonClover<WilsonTwoIndexSymmetricImplR> CompactWilsonCloverTwoIndexSymmetricFermionR;
 typedef CompactWilsonClover<WilsonTwoIndexSymmetricImplF> CompactWilsonCloverTwoIndexSymmetricFermionF;
 typedef CompactWilsonClover<WilsonTwoIndexSymmetricImplD> CompactWilsonCloverTwoIndexSymmetricFermionD;
 
-typedef CompactWilsonClover<WilsonTwoIndexAntiSymmetricImplR> CompactWilsonCloverTwoIndexAntiSymmetricFermionR;
 typedef CompactWilsonClover<WilsonTwoIndexAntiSymmetricImplF> CompactWilsonCloverTwoIndexAntiSymmetricFermionF;
 typedef CompactWilsonClover<WilsonTwoIndexAntiSymmetricImplD> CompactWilsonCloverTwoIndexAntiSymmetricFermionD;
 
 // Domain Wall fermions
-typedef DomainWallFermion<WilsonImplR> DomainWallFermionR;
 typedef DomainWallFermion<WilsonImplF> DomainWallFermionF;
 typedef DomainWallFermion<WilsonImplD> DomainWallFermionD;
+typedef DomainWallFermion<WilsonImplD2> DomainWallFermionD2;
 
-//typedef DomainWallFermion<WilsonImplRL> DomainWallFermionRL;
-//typedef DomainWallFermion<WilsonImplFH> DomainWallFermionFH;
-//typedef DomainWallFermion<WilsonImplDF> DomainWallFermionDF;
-
-typedef DomainWallEOFAFermion<WilsonImplR> DomainWallEOFAFermionR;
+typedef DomainWallEOFAFermion<WilsonImplD2> DomainWallEOFAFermionD2;
 typedef DomainWallEOFAFermion<WilsonImplF> DomainWallEOFAFermionF;
 typedef DomainWallEOFAFermion<WilsonImplD> DomainWallEOFAFermionD;
 
-//typedef DomainWallEOFAFermion<WilsonImplRL> DomainWallEOFAFermionRL;
-//typedef DomainWallEOFAFermion<WilsonImplFH> DomainWallEOFAFermionFH;
-//typedef DomainWallEOFAFermion<WilsonImplDF> DomainWallEOFAFermionDF;
-
-typedef MobiusFermion<WilsonImplR> MobiusFermionR;
+typedef MobiusFermion<WilsonImplD2> MobiusFermionD2;
 typedef MobiusFermion<WilsonImplF> MobiusFermionF;
 typedef MobiusFermion<WilsonImplD> MobiusFermionD;
 
-//typedef MobiusFermion<WilsonImplRL> MobiusFermionRL;
-//typedef MobiusFermion<WilsonImplFH> MobiusFermionFH;
-//typedef MobiusFermion<WilsonImplDF> MobiusFermionDF;
-
-typedef MobiusEOFAFermion<WilsonImplR> MobiusEOFAFermionR;
+typedef MobiusEOFAFermion<WilsonImplD2> MobiusEOFAFermionD2;
 typedef MobiusEOFAFermion<WilsonImplF> MobiusEOFAFermionF;
 typedef MobiusEOFAFermion<WilsonImplD> MobiusEOFAFermionD;
 
-//typedef MobiusEOFAFermion<WilsonImplRL> MobiusEOFAFermionRL;
-//typedef MobiusEOFAFermion<WilsonImplFH> MobiusEOFAFermionFH;
-//typedef MobiusEOFAFermion<WilsonImplDF> MobiusEOFAFermionDF;
-
-typedef ZMobiusFermion<ZWilsonImplR> ZMobiusFermionR;
+typedef ZMobiusFermion<ZWilsonImplD2> ZMobiusFermionD2;
 typedef ZMobiusFermion<ZWilsonImplF> ZMobiusFermionF;
 typedef ZMobiusFermion<ZWilsonImplD> ZMobiusFermionD;
 
-//typedef ZMobiusFermion<ZWilsonImplRL> ZMobiusFermionRL;
-//typedef ZMobiusFermion<ZWilsonImplFH> ZMobiusFermionFH;
-//typedef ZMobiusFermion<ZWilsonImplDF> ZMobiusFermionDF;
-
-// Ls vectorised
-typedef ScaledShamirFermion<WilsonImplR> ScaledShamirFermionR;
+typedef ScaledShamirFermion<WilsonImplD2> ScaledShamirFermionD2;
 typedef ScaledShamirFermion<WilsonImplF> ScaledShamirFermionF;
 typedef ScaledShamirFermion<WilsonImplD> ScaledShamirFermionD;
 
-typedef MobiusZolotarevFermion<WilsonImplR> MobiusZolotarevFermionR;
+typedef MobiusZolotarevFermion<WilsonImplD2> MobiusZolotarevFermionD2;
 typedef MobiusZolotarevFermion<WilsonImplF> MobiusZolotarevFermionF;
 typedef MobiusZolotarevFermion<WilsonImplD> MobiusZolotarevFermionD;
-typedef ShamirZolotarevFermion<WilsonImplR> ShamirZolotarevFermionR;
+typedef ShamirZolotarevFermion<WilsonImplD2> ShamirZolotarevFermionD2;
 typedef ShamirZolotarevFermion<WilsonImplF> ShamirZolotarevFermionF;
 typedef ShamirZolotarevFermion<WilsonImplD> ShamirZolotarevFermionD;
 
-typedef OverlapWilsonCayleyTanhFermion<WilsonImplR> OverlapWilsonCayleyTanhFermionR;
+typedef OverlapWilsonCayleyTanhFermion<WilsonImplD2> OverlapWilsonCayleyTanhFermionD2;
 typedef OverlapWilsonCayleyTanhFermion<WilsonImplF> OverlapWilsonCayleyTanhFermionF;
 typedef OverlapWilsonCayleyTanhFermion<WilsonImplD> OverlapWilsonCayleyTanhFermionD;
-typedef OverlapWilsonCayleyZolotarevFermion<WilsonImplR> OverlapWilsonCayleyZolotarevFermionR;
+typedef OverlapWilsonCayleyZolotarevFermion<WilsonImplD2> OverlapWilsonCayleyZolotarevFermionD2;
 typedef OverlapWilsonCayleyZolotarevFermion<WilsonImplF> OverlapWilsonCayleyZolotarevFermionF;
 typedef OverlapWilsonCayleyZolotarevFermion<WilsonImplD> OverlapWilsonCayleyZolotarevFermionD;
 
 // Continued fraction
-typedef OverlapWilsonContFracTanhFermion<WilsonImplR> OverlapWilsonContFracTanhFermionR;
+typedef OverlapWilsonContFracTanhFermion<WilsonImplD2> OverlapWilsonContFracTanhFermionD2;
 typedef OverlapWilsonContFracTanhFermion<WilsonImplF> OverlapWilsonContFracTanhFermionF;
 typedef OverlapWilsonContFracTanhFermion<WilsonImplD> OverlapWilsonContFracTanhFermionD;
-typedef OverlapWilsonContFracZolotarevFermion<WilsonImplR> OverlapWilsonContFracZolotarevFermionR;
+typedef OverlapWilsonContFracZolotarevFermion<WilsonImplD2> OverlapWilsonContFracZolotarevFermionD2;
 typedef OverlapWilsonContFracZolotarevFermion<WilsonImplF> OverlapWilsonContFracZolotarevFermionF;
 typedef OverlapWilsonContFracZolotarevFermion<WilsonImplD> OverlapWilsonContFracZolotarevFermionD;
 
 // Partial fraction
-typedef OverlapWilsonPartialFractionTanhFermion<WilsonImplR> OverlapWilsonPartialFractionTanhFermionR;
+typedef OverlapWilsonPartialFractionTanhFermion<WilsonImplD2> OverlapWilsonPartialFractionTanhFermionD2;
 typedef OverlapWilsonPartialFractionTanhFermion<WilsonImplF> OverlapWilsonPartialFractionTanhFermionF;
 typedef OverlapWilsonPartialFractionTanhFermion<WilsonImplD> OverlapWilsonPartialFractionTanhFermionD;
 
-typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplR> OverlapWilsonPartialFractionZolotarevFermionR;
+typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplD2> OverlapWilsonPartialFractionZolotarevFermionD2;
 typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplF> OverlapWilsonPartialFractionZolotarevFermionF;
 typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplD> OverlapWilsonPartialFractionZolotarevFermionD;
 
 // Gparity cases; partial list until tested
-typedef WilsonFermion<GparityWilsonImplR>     GparityWilsonFermionR;
 typedef WilsonFermion<GparityWilsonImplF>     GparityWilsonFermionF;
 typedef WilsonFermion<GparityWilsonImplD>     GparityWilsonFermionD;
 
-//typedef WilsonFermion<GparityWilsonImplRL>     GparityWilsonFermionRL;
-//typedef WilsonFermion<GparityWilsonImplFH>     GparityWilsonFermionFH;
-//typedef WilsonFermion<GparityWilsonImplDF>     GparityWilsonFermionDF;
-
-typedef DomainWallFermion<GparityWilsonImplR> GparityDomainWallFermionR;
 typedef DomainWallFermion<GparityWilsonImplF> GparityDomainWallFermionF;
 typedef DomainWallFermion<GparityWilsonImplD> GparityDomainWallFermionD;
 
-//typedef DomainWallFermion<GparityWilsonImplRL> GparityDomainWallFermionRL;
-//typedef DomainWallFermion<GparityWilsonImplFH> GparityDomainWallFermionFH;
-//typedef DomainWallFermion<GparityWilsonImplDF> GparityDomainWallFermionDF;
-
-typedef DomainWallEOFAFermion<GparityWilsonImplR> GparityDomainWallEOFAFermionR;
+typedef DomainWallEOFAFermion<GparityWilsonImplR> GparityDomainWallEOFAFermionD2;
 typedef DomainWallEOFAFermion<GparityWilsonImplF> GparityDomainWallEOFAFermionF;
 typedef DomainWallEOFAFermion<GparityWilsonImplD> GparityDomainWallEOFAFermionD;
 
-//typedef DomainWallEOFAFermion<GparityWilsonImplRL> GparityDomainWallEOFAFermionRL;
-//typedef DomainWallEOFAFermion<GparityWilsonImplFH> GparityDomainWallEOFAFermionFH;
-//typedef DomainWallEOFAFermion<GparityWilsonImplDF> GparityDomainWallEOFAFermionDF;
-
-typedef WilsonTMFermion<GparityWilsonImplR> GparityWilsonTMFermionR;
+typedef WilsonTMFermion<GparityWilsonImplR> GparityWilsonTMFermionD2;
 typedef WilsonTMFermion<GparityWilsonImplF> GparityWilsonTMFermionF;
 typedef WilsonTMFermion<GparityWilsonImplD> GparityWilsonTMFermionD;
 
-//typedef WilsonTMFermion<GparityWilsonImplRL> GparityWilsonTMFermionRL;
-//typedef WilsonTMFermion<GparityWilsonImplFH> GparityWilsonTMFermionFH;
-//typedef WilsonTMFermion<GparityWilsonImplDF> GparityWilsonTMFermionDF;
-
-typedef MobiusFermion<GparityWilsonImplR> GparityMobiusFermionR;
+typedef MobiusFermion<GparityWilsonImplR> GparityMobiusFermionD2;
 typedef MobiusFermion<GparityWilsonImplF> GparityMobiusFermionF;
 typedef MobiusFermion<GparityWilsonImplD> GparityMobiusFermionD;
 
-//typedef MobiusFermion<GparityWilsonImplRL> GparityMobiusFermionRL;
-//typedef MobiusFermion<GparityWilsonImplFH> GparityMobiusFermionFH;
-//typedef MobiusFermion<GparityWilsonImplDF> GparityMobiusFermionDF;
-
-typedef MobiusEOFAFermion<GparityWilsonImplR> GparityMobiusEOFAFermionR;
+typedef MobiusEOFAFermion<GparityWilsonImplR> GparityMobiusEOFAFermionD2;
 typedef MobiusEOFAFermion<GparityWilsonImplF> GparityMobiusEOFAFermionF;
 typedef MobiusEOFAFermion<GparityWilsonImplD> GparityMobiusEOFAFermionD;
 
-//typedef MobiusEOFAFermion<GparityWilsonImplRL> GparityMobiusEOFAFermionRL;
-//typedef MobiusEOFAFermion<GparityWilsonImplFH> GparityMobiusEOFAFermionFH;
-//typedef MobiusEOFAFermion<GparityWilsonImplDF> GparityMobiusEOFAFermionDF;
-
-typedef ImprovedStaggeredFermion<StaggeredImplR> ImprovedStaggeredFermionR;
 typedef ImprovedStaggeredFermion<StaggeredImplF> ImprovedStaggeredFermionF;
 typedef ImprovedStaggeredFermion<StaggeredImplD> ImprovedStaggeredFermionD;
 
-typedef NaiveStaggeredFermion<StaggeredImplR> NaiveStaggeredFermionR;
 typedef NaiveStaggeredFermion<StaggeredImplF> NaiveStaggeredFermionF;
 typedef NaiveStaggeredFermion<StaggeredImplD> NaiveStaggeredFermionD;
 
-typedef ImprovedStaggeredFermion5D<StaggeredImplR> ImprovedStaggeredFermion5DR;
 typedef ImprovedStaggeredFermion5D<StaggeredImplF> ImprovedStaggeredFermion5DF;
 typedef ImprovedStaggeredFermion5D<StaggeredImplD> ImprovedStaggeredFermion5DD;
 

Grid/qcd/action/fermion/ImprovedStaggeredFermion.h

@@ -47,18 +47,6 @@ public:
   FermionField _tmp;
   FermionField &tmp(void) { return _tmp; }
 
-  ////////////////////////////////////////
-  // Performance monitoring
-  ////////////////////////////////////////
-  void Report(void);
-  void ZeroCounters(void);
-  double DhopTotalTime;
-  double DhopCalls;
-  double DhopCommTime;
-  double DhopComputeTime;
-  double DhopComputeTime2;
-  double DhopFaceTime;
-
   ///////////////////////////////////////////////////////////////
   // Implement the abstract base
   ///////////////////////////////////////////////////////////////

Grid/qcd/action/fermion/ImprovedStaggeredFermion5D.h

@@ -52,18 +52,6 @@ public:
   FermionField _tmp;
   FermionField &tmp(void) { return _tmp; }
 
-  ////////////////////////////////////////
-  // Performance monitoring
-  ////////////////////////////////////////
-  void Report(void);
-  void ZeroCounters(void);
-  double DhopTotalTime;
-  double DhopCalls;
-  double DhopCommTime;
-  double DhopComputeTime;
-  double DhopComputeTime2;
-  double DhopFaceTime;
-
   ///////////////////////////////////////////////////////////////
   // Implement the abstract base
   ///////////////////////////////////////////////////////////////

Grid/qcd/action/fermion/NaiveStaggeredFermion.h

@@ -47,18 +47,6 @@ public:
   FermionField _tmp;
   FermionField &tmp(void) { return _tmp; }
 
-  ////////////////////////////////////////
-  // Performance monitoring
-  ////////////////////////////////////////
-  void Report(void);
-  void ZeroCounters(void);
-  double DhopTotalTime;
-  double DhopCalls;
-  double DhopCommTime;
-  double DhopComputeTime;
-  double DhopComputeTime2;
-  double DhopFaceTime;
-
   ///////////////////////////////////////////////////////////////
   // Implement the abstract base
   ///////////////////////////////////////////////////////////////

Grid/qcd/action/fermion/WilsonCompressor.h

@@ -32,17 +32,182 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 
 NAMESPACE_BEGIN(Grid);
 
+///////////////////////////////////////////////////////////////
+// Wilson compressor will need FaceGather policies for:
+// Periodic, Dirichlet, and partial Dirichlet for DWF
+///////////////////////////////////////////////////////////////
+class FaceGatherPartialDWF
+{
+public:
+  static int PartialCompressionFactor(GridBase *grid) {return grid->_fdimensions[0]/2;};
+  //  static int PartialCompressionFactor(GridBase *grid) { return 1;}
+  template<class vobj,class cobj,class compressor>
+  static void Gather_plane_simple (commVector<std::pair<int,int> >& table,
+				   const Lattice<vobj> &rhs,
+				   cobj *buffer,
+				   compressor &compress,
+				   int off,int so,int partial)
+  {
+    //DWF only hack: If a direction that is OFF node we use Partial Dirichlet
+    //  Shrinks local and remote comms buffers
+    GridBase *Grid = rhs.Grid();
+    int Ls = Grid->_rdimensions[0];
+    std::pair<int,int> *table_v = & table[0];
+    auto rhs_v = rhs.View(AcceleratorRead);
+    int vol=table.size()/Ls;
+    accelerator_forNB( idx,table.size(), vobj::Nsimd(), {
+	Integer i=idx/Ls;
+	Integer s=idx%Ls;
+	if(s==0)    compress.Compress(buffer[off+i    ],rhs_v[so+table_v[idx].second]);
+	if(s==Ls-1) compress.Compress(buffer[off+i+vol],rhs_v[so+table_v[idx].second]);
+    });
+  }
+  template<class decompressor,class Decompression>
+  static void DecompressFace(decompressor decompress,Decompression &dd)
+  {
+    auto Ls = dd.dims[0];
+    // Just pass in the Grid
+    auto kp = dd.kernel_p;
+    auto mp = dd.mpi_p;
+    int size= dd.buffer_size;
+    int vol= size/Ls;
+    accelerator_forNB(o,size,1,{
+	int idx=o/Ls;
+	int   s=o%Ls;
+	if ( s == 0 ) {
+	  int oo=idx;
+	  kp[o]=mp[oo];
+	} else if ( s == Ls-1 ) {
+	  int oo=vol+idx; 
+	  kp[o]=mp[oo];
+	} else {
+	  kp[o] = Zero();//fill rest with zero if partial dirichlet
+	}
+    });
+  }
+  ////////////////////////////////////////////////////////////////////////////////////////////
+  // Need to gather *interior portions* for ALL s-slices in simd directions
+  // Do the gather as need to treat SIMD lanes differently, and insert zeroes on receive side
+  // Reorder the fifth dim to be s=Ls-1 , s=0, s=1,...,Ls-2.
+  ////////////////////////////////////////////////////////////////////////////////////////////
+  template<class vobj,class cobj,class compressor>
+  static void Gather_plane_exchange(commVector<std::pair<int,int> >& table,const Lattice<vobj> &rhs,
+				    Vector<cobj *> pointers,int dimension,int plane,int cbmask,
+				    compressor &compress,int type,int partial)
+  {
+    GridBase *Grid = rhs.Grid();
+    int Ls = Grid->_rdimensions[0];
+
+    // insertion of zeroes...
+    assert( (table.size()&0x1)==0);
+    int num=table.size()/2;
+    int so  = plane*rhs.Grid()->_ostride[dimension]; // base offset for start of plane
+    
+    auto rhs_v = rhs.View(AcceleratorRead);
+    auto p0=&pointers[0][0];
+    auto p1=&pointers[1][0];
+    auto tp=&table[0];
+    int nnum=num/Ls;
+    accelerator_forNB(j, num, vobj::Nsimd(), {
+	//  Reorders both local and remote comms buffers
+	//  
+	int s  = j % Ls;
+	int sp1 = (s+1)%Ls;  // peri incremented s slice
+	
+	int hxyz= j/Ls;
+
+	int xyz0= hxyz*2; // xyzt part of coor
+	int xyz1= hxyz*2+1;
+	
+	int jj= hxyz + sp1*nnum ; // 0,1,2,3 -> Ls-1 slice , 0-slice, 1-slice ....
+	
+	int kk0= xyz0*Ls + s ; // s=0 goes to s=1
+	int kk1= xyz1*Ls + s ; // s=Ls-1 -> s=0
+	compress.CompressExchange(p0[jj],p1[jj],
+				  rhs_v[so+tp[kk0 ].second], // Same s, consecutive xyz sites
+				  rhs_v[so+tp[kk1 ].second], 
+				  type);
+    });
+    rhs_v.ViewClose();
+  }
+  // Merge routine is for SIMD faces
+  template<class decompressor,class Merger>
+  static void MergeFace(decompressor decompress,Merger &mm)
+  {
+    auto Ls = mm.dims[0];
+    int  num= mm.buffer_size/2; // relate vol and Ls to buffer size
+    auto mp = &mm.mpointer[0];
+    auto vp0= &mm.vpointers[0][0]; // First arg is exchange first
+    auto vp1= &mm.vpointers[1][0];
+    auto type= mm.type;
+    int nnum = num/Ls;
+    accelerator_forNB(o,num,vobj::Nsimd(),{
+
+	int  s=o%Ls;
+	int hxyz=o/Ls; // xyzt related component
+	int xyz0=hxyz*2;
+	int xyz1=hxyz*2+1;
+
+	int sp = (s+1)%Ls; 
+	int jj= hxyz + sp*nnum ; // 0,1,2,3 -> Ls-1 slice , 0-slice, 1-slice ....
+
+	int oo0= s+xyz0*Ls;
+	int oo1= s+xyz1*Ls;
+
+	// same ss0, ss1 pair goes to new layout
+	decompress.Exchange(mp[oo0],mp[oo1],vp0[jj],vp1[jj],type);
+      });
+  }
+};
+class FaceGatherDWFMixedBCs
+{
+public:
+  static int PartialCompressionFactor(GridBase *grid) {return grid->_fdimensions[0]/2;};
+  
+  template<class vobj,class cobj,class compressor>
+  static void Gather_plane_simple (commVector<std::pair<int,int> >& table,
+					 const Lattice<vobj> &rhs,
+					 cobj *buffer,
+					 compressor &compress,
+					 int off,int so,int partial)
+  {
+    if(partial) FaceGatherPartialDWF::Gather_plane_simple(table,rhs,buffer,compress,off,so,partial);
+    else        FaceGatherSimple::Gather_plane_simple(table,rhs,buffer,compress,off,so,partial);
+  }
+  template<class vobj,class cobj,class compressor>
+  static void Gather_plane_exchange(commVector<std::pair<int,int> >& table,const Lattice<vobj> &rhs,
+				    Vector<cobj *> pointers,int dimension,int plane,int cbmask,
+				    compressor &compress,int type,int partial)
+  {
+    if(partial) FaceGatherPartialDWF::Gather_plane_exchange(table,rhs,pointers,dimension, plane,cbmask,compress,type,partial);
+    else        FaceGatherSimple::Gather_plane_exchange    (table,rhs,pointers,dimension, plane,cbmask,compress,type,partial);
+  }
+  template<class decompressor,class Merger>
+  static void MergeFace(decompressor decompress,Merger &mm)
+  {
+    int partial = mm.partial;
+    if ( partial ) FaceGatherPartialDWF::MergeFace(decompress,mm);
+    else           FaceGatherSimple::MergeFace(decompress,mm);
+  }
+
+  template<class decompressor,class Decompression>
+  static void DecompressFace(decompressor decompress,Decompression &dd)
+  {
+    int partial = dd.partial;
+    if ( partial ) FaceGatherPartialDWF::DecompressFace(decompress,dd);
+    else           FaceGatherSimple::DecompressFace(decompress,dd);
+  }
+};
+
 /////////////////////////////////////////////////////////////////////////////////////////////
-// optimised versions supporting half precision too
+// optimised versions supporting half precision too??? Deprecate
 /////////////////////////////////////////////////////////////////////////////////////////////
 
-template<class _HCspinor,class _Hspinor,class _Spinor, class projector,typename SFINAE = void >
-class WilsonCompressorTemplate;
-
 
+//Could make FaceGather a template param, but then behaviour is runtime not compile time
 template<class _HCspinor,class _Hspinor,class _Spinor, class projector>
-class WilsonCompressorTemplate< _HCspinor, _Hspinor, _Spinor, projector,
-				typename std::enable_if<std::is_same<_HCspinor,_Hspinor>::value>::type >
+class WilsonCompressorTemplate  : public FaceGatherDWFMixedBCs
+//  : public FaceGatherSimple
 {
 public:
   
@@ -79,172 +244,81 @@ public:
   /*****************************************************/
   /* Exchange includes precision change if mpi data is not same */
   /*****************************************************/
-  accelerator_inline void Exchange(SiteHalfSpinor *mp,
-				   const SiteHalfSpinor * __restrict__ vp0,
-				   const SiteHalfSpinor * __restrict__ vp1,
-				   Integer type,Integer o) const {
+  accelerator_inline void Exchange(SiteHalfSpinor &mp0,
+				   SiteHalfSpinor &mp1,
+				   const SiteHalfSpinor & vp0,
+				   const SiteHalfSpinor & vp1,
+				   Integer type) const {
 #ifdef GRID_SIMT
-    exchangeSIMT(mp[2*o],mp[2*o+1],vp0[o],vp1[o],type);
+    exchangeSIMT(mp0,mp1,vp0,vp1,type);
 #else
     SiteHalfSpinor tmp1;
     SiteHalfSpinor tmp2;
-    exchange(tmp1,tmp2,vp0[o],vp1[o],type);
-    vstream(mp[2*o  ],tmp1);
-    vstream(mp[2*o+1],tmp2);
+    exchange(tmp1,tmp2,vp0,vp1,type);
+    vstream(mp0,tmp1);
+    vstream(mp1,tmp2);
 #endif
   }
-
+  
 
   /*****************************************************/
   /* Have a decompression step if mpi data is not same */
   /*****************************************************/
-  accelerator_inline void Decompress(SiteHalfSpinor * __restrict__ out,
-				     SiteHalfSpinor * __restrict__ in, Integer o) const {    
-    assert(0);
+  accelerator_inline void Decompress(SiteHalfSpinor &out,
+				     SiteHalfSpinor &in) const {    
+    out = in;
   }
 
   /*****************************************************/
   /* Compress Exchange                                 */
   /*****************************************************/
-  accelerator_inline void CompressExchange(SiteHalfSpinor * __restrict__ out0,
-					   SiteHalfSpinor * __restrict__ out1,
-					   const SiteSpinor * __restrict__ in,
-					   Integer j,Integer k, Integer m,Integer type) const
+  accelerator_inline void CompressExchange(SiteHalfSpinor &out0,
+					   SiteHalfSpinor &out1,
+					   const SiteSpinor &in0,
+					   const SiteSpinor &in1,
+					   Integer type) const
   {
 #ifdef GRID_SIMT
     typedef SiteSpinor vobj;
     typedef SiteHalfSpinor hvobj;
-    typedef decltype(coalescedRead(*in))    sobj;
-    typedef decltype(coalescedRead(*out0)) hsobj;
+    typedef decltype(coalescedRead(in0))    sobj;
+    typedef decltype(coalescedRead(out0)) hsobj;
 
     unsigned int Nsimd = vobj::Nsimd();
     unsigned int mask = Nsimd >> (type + 1);
     int lane = acceleratorSIMTlane(Nsimd);
     int j0 = lane &(~mask); // inner coor zero
     int j1 = lane |(mask) ; // inner coor one
-    const vobj *vp0 = &in[k];
-    const vobj *vp1 = &in[m];
+    const vobj *vp0 = &in0;
+    const vobj *vp1 = &in1;
     const vobj *vp = (lane&mask) ? vp1:vp0;
     auto sa = coalescedRead(*vp,j0);
     auto sb = coalescedRead(*vp,j1);
     hsobj psa, psb;
     projector::Proj(psa,sa,mu,dag);
     projector::Proj(psb,sb,mu,dag);
-    coalescedWrite(out0[j],psa);
-    coalescedWrite(out1[j],psb);
+    coalescedWrite(out0,psa);
+    coalescedWrite(out1,psb);
 #else
     SiteHalfSpinor temp1, temp2;
     SiteHalfSpinor temp3, temp4;
-    projector::Proj(temp1,in[k],mu,dag);
-    projector::Proj(temp2,in[m],mu,dag);
+    projector::Proj(temp1,in0,mu,dag);
+    projector::Proj(temp2,in1,mu,dag);
     exchange(temp3,temp4,temp1,temp2,type);
-    vstream(out0[j],temp3);
-    vstream(out1[j],temp4);
+    vstream(out0,temp3);
+    vstream(out1,temp4);
 #endif
   }
 
   /*****************************************************/
   /* Pass the info to the stencil */
   /*****************************************************/
-  accelerator_inline bool DecompressionStep(void) const { return false; }
+  accelerator_inline bool DecompressionStep(void) const {
+    return false;
+  }
 
 };
 
-#if 0
-template<class _HCspinor,class _Hspinor,class _Spinor, class projector>
-class WilsonCompressorTemplate< _HCspinor, _Hspinor, _Spinor, projector,
-				typename std::enable_if<!std::is_same<_HCspinor,_Hspinor>::value>::type >
-{
-public:
-  
-  int mu,dag;  
-
-  void Point(int p) { mu=p; };
-
-  WilsonCompressorTemplate(int _dag=0){
-    dag = _dag;
-  }
-
-  typedef _Spinor         SiteSpinor;
-  typedef _Hspinor     SiteHalfSpinor;
-  typedef _HCspinor SiteHalfCommSpinor;
-  typedef typename SiteHalfCommSpinor::vector_type vComplexLow;
-  typedef typename SiteHalfSpinor::vector_type     vComplexHigh;
-  constexpr static int Nw=sizeof(SiteHalfSpinor)/sizeof(vComplexHigh);
-
-  accelerator_inline int CommDatumSize(void) const {
-    return sizeof(SiteHalfCommSpinor);
-  }
-
-  /*****************************************************/
-  /* Compress includes precision change if mpi data is not same */
-  /*****************************************************/
-  accelerator_inline void Compress(SiteHalfSpinor &buf,const SiteSpinor &in) const {
-    SiteHalfSpinor hsp;
-    SiteHalfCommSpinor *hbuf = (SiteHalfCommSpinor *)buf;
-    projector::Proj(hsp,in,mu,dag);
-    precisionChange((vComplexLow *)&hbuf[o],(vComplexHigh *)&hsp,Nw);
-  }
-  accelerator_inline void Compress(SiteHalfSpinor &buf,const SiteSpinor &in) const {
-#ifdef GRID_SIMT
-    typedef decltype(coalescedRead(buf)) sobj;
-    sobj sp;
-    auto sin = coalescedRead(in);
-    projector::Proj(sp,sin,mu,dag);
-    coalescedWrite(buf,sp);
-#else
-    projector::Proj(buf,in,mu,dag);
-#endif
-  }
-
-  /*****************************************************/
-  /* Exchange includes precision change if mpi data is not same */
-  /*****************************************************/
-  accelerator_inline void Exchange(SiteHalfSpinor *mp,
-                       SiteHalfSpinor *vp0,
-                       SiteHalfSpinor *vp1,
-		       Integer type,Integer o) const {
-    SiteHalfSpinor vt0,vt1;
-    SiteHalfCommSpinor *vpp0 = (SiteHalfCommSpinor *)vp0;
-    SiteHalfCommSpinor *vpp1 = (SiteHalfCommSpinor *)vp1;
-    precisionChange((vComplexHigh *)&vt0,(vComplexLow *)&vpp0[o],Nw);
-    precisionChange((vComplexHigh *)&vt1,(vComplexLow *)&vpp1[o],Nw);
-    exchange(mp[2*o],mp[2*o+1],vt0,vt1,type);
-  }
-
-  /*****************************************************/
-  /* Have a decompression step if mpi data is not same */
-  /*****************************************************/
-  accelerator_inline void Decompress(SiteHalfSpinor *out, SiteHalfSpinor *in, Integer o) const {
-    SiteHalfCommSpinor *hin=(SiteHalfCommSpinor *)in;
-    precisionChange((vComplexHigh *)&out[o],(vComplexLow *)&hin[o],Nw);
-  }
-
-  /*****************************************************/
-  /* Compress Exchange                                 */
-  /*****************************************************/
-  accelerator_inline void CompressExchange(SiteHalfSpinor *out0,
-			       SiteHalfSpinor *out1,
-			       const SiteSpinor *in,
-			       Integer j,Integer k, Integer m,Integer type) const {
-    SiteHalfSpinor temp1, temp2,temp3,temp4;
-    SiteHalfCommSpinor *hout0 = (SiteHalfCommSpinor *)out0;
-    SiteHalfCommSpinor *hout1 = (SiteHalfCommSpinor *)out1;
-    projector::Proj(temp1,in[k],mu,dag);
-    projector::Proj(temp2,in[m],mu,dag);
-    exchange(temp3,temp4,temp1,temp2,type);
-    precisionChange((vComplexLow *)&hout0[j],(vComplexHigh *)&temp3,Nw);
-    precisionChange((vComplexLow *)&hout1[j],(vComplexHigh *)&temp4,Nw);
-  }
-
-  /*****************************************************/
-  /* Pass the info to the stencil */
-  /*****************************************************/
-  accelerator_inline bool DecompressionStep(void) const { return true; }
-
-};
-#endif
-
 #define DECLARE_PROJ(Projector,Compressor,spProj)			\
   class Projector {							\
   public:								\
@@ -294,11 +368,7 @@ public:
   typedef typename Base::View_type View_type;
   typedef typename Base::StencilVector StencilVector;
 
-  void ZeroCountersi(void)  {  }
-  void Reporti(int calls)  {  }
-
   //  Vector<int> surface_list;
-
   WilsonStencil(GridBase *grid,
 		int npoints,
 		int checkerboard,
@@ -306,7 +376,6 @@ public:
 		const std::vector<int> &distances,Parameters p)  
     : CartesianStencil<vobj,cobj,Parameters> (grid,npoints,checkerboard,directions,distances,p) 
   { 
-    ZeroCountersi();
     //    surface_list.resize(0);
     this->same_node.resize(npoints);
   };
@@ -400,7 +469,6 @@ public:
     }
     this->face_table_computed=1;
     assert(this->u_comm_offset==this->_unified_buffer_size);
-    accelerator_barrier();
   }
 
 };

Grid/qcd/action/fermion/WilsonFermion.h

@@ -74,20 +74,6 @@ public:
   FermionField _tmp;
   FermionField &tmp(void) { return _tmp; }
 
-  void Report(void);
-  void ZeroCounters(void);
-  double DhopCalls;
-  double DhopCommTime;
-  double DhopComputeTime;
-  double DhopComputeTime2;
-  double DhopFaceTime;
-  double DhopTotalTime;
-
-  double DerivCalls;
-  double DerivCommTime;
-  double DerivComputeTime;
-  double DerivDhopComputeTime;
-
   //////////////////////////////////////////////////////////////////
   // override multiply; cut number routines if pass dagger argument
   // and also make interface more uniformly consistent

Grid/qcd/action/fermion/WilsonFermion5D.h

@@ -78,21 +78,6 @@ public:
   int Dirichlet;
   Coordinate Block; 
 
-  /********** Deprecate timers **********/
-  void Report(void);
-  void ZeroCounters(void);
-  double DhopCalls;
-  double DhopCommTime;
-  double DhopComputeTime;
-  double DhopComputeTime2;
-  double DhopFaceTime;
-  double DhopTotalTime;
-
-  double DerivCalls;
-  double DerivCommTime;
-  double DerivComputeTime;
-  double DerivDhopComputeTime;
-
   ///////////////////////////////////////////////////////////////
   // Implement the abstract base
   ///////////////////////////////////////////////////////////////

Grid/qcd/action/fermion/WilsonImpl.h

@@ -37,7 +37,7 @@ NAMESPACE_BEGIN(Grid);
 template <class S, class Representation = FundamentalRepresentation,class Options = CoeffReal >
 class WilsonImpl : public PeriodicGaugeImpl<GaugeImplTypes<S, Representation::Dimension > > {
 public:
-
+  
   static const int Dimension = Representation::Dimension;
   static const bool isFundamental = Representation::isFundamental;
   static const bool LsVectorised=false;
@@ -242,19 +242,13 @@ public:
 typedef WilsonImpl<vComplex,  FundamentalRepresentation, CoeffReal > WilsonImplR;  // Real.. whichever prec
 typedef WilsonImpl<vComplexF, FundamentalRepresentation, CoeffReal > WilsonImplF;  // Float
 typedef WilsonImpl<vComplexD, FundamentalRepresentation, CoeffReal > WilsonImplD;  // Double
-
-//typedef WilsonImpl<vComplex,  FundamentalRepresentation, CoeffRealHalfComms > WilsonImplRL;  // Real.. whichever prec
-//typedef WilsonImpl<vComplexF, FundamentalRepresentation, CoeffRealHalfComms > WilsonImplFH;  // Float
-//typedef WilsonImpl<vComplexD, FundamentalRepresentation, CoeffRealHalfComms > WilsonImplDF;  // Double
+typedef WilsonImpl<vComplexD2, FundamentalRepresentation, CoeffReal > WilsonImplD2;  // Double
 
 typedef WilsonImpl<vComplex,  FundamentalRepresentation, CoeffComplex > ZWilsonImplR; // Real.. whichever prec
 typedef WilsonImpl<vComplexF, FundamentalRepresentation, CoeffComplex > ZWilsonImplF; // Float
 typedef WilsonImpl<vComplexD, FundamentalRepresentation, CoeffComplex > ZWilsonImplD; // Double
+typedef WilsonImpl<vComplexD2, FundamentalRepresentation, CoeffComplex > ZWilsonImplD2; // Double
 
-//typedef WilsonImpl<vComplex,  FundamentalRepresentation, CoeffComplexHalfComms > ZWilsonImplRL; // Real.. whichever prec
-//typedef WilsonImpl<vComplexF, FundamentalRepresentation, CoeffComplexHalfComms > ZWilsonImplFH; // Float
-//typedef WilsonImpl<vComplexD, FundamentalRepresentation, CoeffComplexHalfComms > ZWilsonImplDF; // Double
- 
 typedef WilsonImpl<vComplex,  AdjointRepresentation, CoeffReal > WilsonAdjImplR;   // Real.. whichever prec
 typedef WilsonImpl<vComplexF, AdjointRepresentation, CoeffReal > WilsonAdjImplF;  // Float
 typedef WilsonImpl<vComplexD, AdjointRepresentation, CoeffReal > WilsonAdjImplD;  // Double

Grid/qcd/action/fermion/implementation/CayleyFermion5DImplementation.h

@@ -152,58 +152,6 @@ void CayleyFermion5D<Impl>::DminusDag(const FermionField &psi, FermionField &chi
   }
 }
 
-template<class Impl> void CayleyFermion5D<Impl>::CayleyReport(void)
-{
-  this->Report();
-  Coordinate latt = GridDefaultLatt();          
-  RealD volume = this->Ls;  for(int mu=0;mu<Nd;mu++) volume=volume*latt[mu];
-  RealD NP     = this->_FourDimGrid->_Nprocessors;
-  if ( M5Dcalls > 0 ) {
-    std::cout << GridLogMessage << "#### M5D calls report " << std::endl;
-    std::cout << GridLogMessage << "CayleyFermion5D Number of M5D Calls     : " << M5Dcalls   << std::endl;
-    std::cout << GridLogMessage << "CayleyFermion5D ComputeTime/Calls       : " << M5Dtime / M5Dcalls << " us" << std::endl;
-
-    // Flops = 10.0*(Nc*Ns) *Ls*vol
-    RealD mflops = 10.0*(Nc*Ns)*volume*M5Dcalls/M5Dtime/2; // 2 for red black counting
-    std::cout << GridLogMessage << "Average mflops/s per call                : " << mflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per rank       : " << mflops/NP << std::endl;
-
-    // Bytes = sizeof(Real) * (Nc*Ns*Nreim) * Ls * vol * (read+write) (/2 for red black counting)
-    // read = 2 ( psi[ss+s+1] and psi[ss+s-1] count as 1 )
-    // write = 1
-    RealD Gbytes = sizeof(Real) * (Nc*Ns*2) * volume * 3 /2. * 1.e-9;
-    std::cout << GridLogMessage << "Average bandwidth (GB/s)                 : " << Gbytes/M5Dtime*M5Dcalls*1.e6 << std::endl;
-  }
-
-  if ( MooeeInvCalls > 0 ) {
-
-    std::cout << GridLogMessage << "#### MooeeInv calls report " << std::endl;
-    std::cout << GridLogMessage << "CayleyFermion5D Number of MooeeInv Calls     : " << MooeeInvCalls   << std::endl;
-    std::cout << GridLogMessage << "CayleyFermion5D ComputeTime/Calls            : " << MooeeInvTime / MooeeInvCalls << " us" << std::endl;
-#ifdef GRID_CUDA
-    RealD mflops = ( -16.*Nc*Ns+this->Ls*(1.+18.*Nc*Ns) )*volume*MooeeInvCalls/MooeeInvTime/2; // 2 for red black counting
-    std::cout << GridLogMessage << "Average mflops/s per call                : " << mflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per rank       : " << mflops/NP << std::endl;
-#else
-    // Flops = MADD * Ls *Ls *4dvol * spin/colour/complex
-    RealD mflops = 2.0*24*this->Ls*volume*MooeeInvCalls/MooeeInvTime/2; // 2 for red black counting
-    std::cout << GridLogMessage << "Average mflops/s per call                : " << mflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per rank       : " << mflops/NP << std::endl;
-#endif
-  }
-
-}
-template<class Impl> void CayleyFermion5D<Impl>::CayleyZeroCounters(void)
-{
-  this->ZeroCounters();
-  M5Dflops=0;
-  M5Dcalls=0;
-  M5Dtime=0;
-  MooeeInvFlops=0;
-  MooeeInvCalls=0;
-  MooeeInvTime=0;
-}
-
 template<class Impl>  
 void CayleyFermion5D<Impl>::M5D   (const FermionField &psi, FermionField &chi)
 {
@@ -646,7 +594,6 @@ void CayleyFermion5D<Impl>::ContractConservedCurrent( PropagatorField &q_in_1,
   assert(mass_plus == mass_minus);
   RealD mass = mass_plus;
   
-#if (!defined(GRID_HIP))
   Gamma::Algebra Gmu [] = {
     Gamma::Algebra::GammaX,
     Gamma::Algebra::GammaY,
@@ -765,7 +712,7 @@ void CayleyFermion5D<Impl>::ContractConservedCurrent( PropagatorField &q_in_1,
     else          q_out +=     C;
     
   }
-#endif
+
 }
 
 template <class Impl>
@@ -832,7 +779,6 @@ void CayleyFermion5D<Impl>::SeqConservedCurrent(PropagatorField &q_in,
   }
 #endif
 
-#if (!defined(GRID_HIP))
   int tshift = (mu == Nd-1) ? 1 : 0;
   unsigned int LLt    = GridDefaultLatt()[Tp];
   ////////////////////////////////////////////////
@@ -952,7 +898,6 @@ void CayleyFermion5D<Impl>::SeqConservedCurrent(PropagatorField &q_in,
 
     InsertSlice(L_Q, q_out, s , 0);
   }
-#endif
 }
 #undef Pp
 #undef Pm
@@ -960,88 +905,6 @@ void CayleyFermion5D<Impl>::SeqConservedCurrent(PropagatorField &q_in,
 #undef TopRowWithSource
 
 
-
-#if 0
-template<class Impl>
-void CayleyFermion5D<Impl>::MooeeInternalCompute(int dag, int inv,
-						 Vector<iSinglet<Simd> > & Matp,
-						 Vector<iSinglet<Simd> > & Matm)
-{
-  int Ls=this->Ls;
-
-  GridBase *grid = this->FermionRedBlackGrid();
-  int LLs = grid->_rdimensions[0];
-
-  if ( LLs == Ls ) {
-    return; // Not vectorised in 5th direction
-  }
-
-  Eigen::MatrixXcd Pplus  = Eigen::MatrixXcd::Zero(Ls,Ls);
-  Eigen::MatrixXcd Pminus = Eigen::MatrixXcd::Zero(Ls,Ls);
-  
-  for(int s=0;s<Ls;s++){
-    Pplus(s,s) = bee[s];
-    Pminus(s,s)= bee[s];
-  }
-  
-  for(int s=0;s<Ls-1;s++){
-    Pminus(s,s+1) = -cee[s];
-  }
-  
-  for(int s=0;s<Ls-1;s++){
-    Pplus(s+1,s) = -cee[s+1];
-  }
-  Pplus (0,Ls-1) = mass*cee[0];
-  Pminus(Ls-1,0) = mass*cee[Ls-1];
-  
-  Eigen::MatrixXcd PplusMat ;
-  Eigen::MatrixXcd PminusMat;
-  
-  if ( inv ) {
-    PplusMat =Pplus.inverse();
-    PminusMat=Pminus.inverse();
-  } else { 
-    PplusMat =Pplus;
-    PminusMat=Pminus;
-  }
-  
-  if(dag){
-    PplusMat.adjointInPlace();
-    PminusMat.adjointInPlace();
-  }
-  
-  typedef typename SiteHalfSpinor::scalar_type scalar_type;
-  const int Nsimd=Simd::Nsimd();
-  Matp.resize(Ls*LLs);
-  Matm.resize(Ls*LLs);
-
-  for(int s2=0;s2<Ls;s2++){
-    for(int s1=0;s1<LLs;s1++){
-      int istride = LLs;
-      int ostride = 1;
-      Simd Vp;
-      Simd Vm;
-      scalar_type *sp = (scalar_type *)&Vp;
-      scalar_type *sm = (scalar_type *)&Vm;
-      for(int l=0;l<Nsimd;l++){
-	if ( switcheroo<Coeff_t>::iscomplex() ) {
-	  sp[l] = PplusMat (l*istride+s1*ostride,s2);
-	  sm[l] = PminusMat(l*istride+s1*ostride,s2);
-	} else { 
-	  // if real
-	  scalar_type tmp;
-	  tmp = PplusMat (l*istride+s1*ostride,s2);
-	  sp[l] = scalar_type(tmp.real(),tmp.real());
-	  tmp = PminusMat(l*istride+s1*ostride,s2);
-	  sm[l] = scalar_type(tmp.real(),tmp.real());
-	}
-      }
-      Matp[LLs*s2+s1] = Vp;
-      Matm[LLs*s2+s1] = Vm;
-    }}
-}
-#endif
-
 NAMESPACE_END(Grid);
 
 

Grid/qcd/action/fermion/implementation/CayleyFermion5Dcache.h

@@ -63,9 +63,6 @@ CayleyFermion5D<Impl>::M5D(const FermionField &psi_i,
 
   // 10 = 3 complex mult + 2 complex add
   // Flops = 10.0*(Nc*Ns) *Ls*vol (/2 for red black counting)
-  M5Dcalls++;
-  M5Dtime-=usecond();
-
   uint64_t nloop = grid->oSites();
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t s = sss%Ls;
@@ -78,7 +75,6 @@ CayleyFermion5D<Impl>::M5D(const FermionField &psi_i,
     spProj5p(tmp2,psi(idx_l));
     coalescedWrite(chi[ss+s],pdiag[s]*phi(ss+s)+pupper[s]*tmp1+plower[s]*tmp2);
   });
-  M5Dtime+=usecond();
 }
 
 template<class Impl>  
@@ -104,9 +100,6 @@ CayleyFermion5D<Impl>::M5Ddag(const FermionField &psi_i,
   int Ls=this->Ls;
 
   // Flops = 6.0*(Nc*Ns) *Ls*vol
-  M5Dcalls++;
-  M5Dtime-=usecond();
-
   uint64_t nloop = grid->oSites();
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t s = sss%Ls;
@@ -119,7 +112,6 @@ CayleyFermion5D<Impl>::M5Ddag(const FermionField &psi_i,
     spProj5m(tmp2,psi(idx_l));
     coalescedWrite(chi[ss+s],pdiag[s]*phi(ss+s)+pupper[s]*tmp1+plower[s]*tmp2);
   });
-  M5Dtime+=usecond();
 }
 
 template<class Impl>
@@ -140,8 +132,6 @@ CayleyFermion5D<Impl>::MooeeInv    (const FermionField &psi_i, FermionField &chi
   auto pleem = & leem[0];
   auto pueem = & ueem[0];
 
-  MooeeInvCalls++;
-  MooeeInvTime-=usecond();
   uint64_t nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t ss=sss*Ls;
@@ -178,8 +168,6 @@ CayleyFermion5D<Impl>::MooeeInv    (const FermionField &psi_i, FermionField &chi
       coalescedWrite(chi[ss+s],res);
     }
   });
-
-  MooeeInvTime+=usecond();
   
 }
 
@@ -202,10 +190,6 @@ CayleyFermion5D<Impl>::MooeeInvDag (const FermionField &psi_i, FermionField &chi
 
   assert(psi.Checkerboard() == psi.Checkerboard());
 
-  MooeeInvCalls++;
-  MooeeInvTime-=usecond();
-
-
   uint64_t nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t ss=sss*Ls;
@@ -242,7 +226,6 @@ CayleyFermion5D<Impl>::MooeeInvDag (const FermionField &psi_i, FermionField &chi
       coalescedWrite(chi[ss+s],res);
     }
   });
-  MooeeInvTime+=usecond();
 
 }
 

Grid/qcd/action/fermion/implementation/CayleyFermion5Dvec.h

@@ -94,10 +94,6 @@ CayleyFermion5D<Impl>::M5D(const FermionField &psi_i,
       d_p[ss] = diag[s];
     }}
 
-
-  M5Dcalls++;
-  M5Dtime-=usecond();
-
   assert(Nc==3);
 
   thread_loop( (int ss=0;ss<grid->oSites();ss+=LLs),{ // adds LLs
@@ -198,7 +194,6 @@ CayleyFermion5D<Impl>::M5D(const FermionField &psi_i,
     }
 #endif
   });
-  M5Dtime+=usecond();
 }
 
 template<class Impl>  
@@ -242,8 +237,6 @@ CayleyFermion5D<Impl>::M5Ddag(const FermionField &psi_i,
       d_p[ss] = diag[s];
     }}
 
-  M5Dcalls++;
-  M5Dtime-=usecond();
   thread_loop( (int ss=0;ss<grid->oSites();ss+=LLs),{ // adds LLs
 #if 0
     alignas(64) SiteHalfSpinor hp;
@@ -339,7 +332,6 @@ CayleyFermion5D<Impl>::M5Ddag(const FermionField &psi_i,
     }
 #endif
   });
-  M5Dtime+=usecond();
 }
 
 
@@ -813,9 +805,6 @@ CayleyFermion5D<Impl>::MooeeInternal(const FermionField &psi, FermionField &chi,
   }
   assert(_Matp->size()==Ls*LLs);
 
-  MooeeInvCalls++;
-  MooeeInvTime-=usecond();
-
   if ( switcheroo<Coeff_t>::iscomplex() ) {
     thread_loop( (auto site=0;site<vol;site++),{
       MooeeInternalZAsm(psi,chi,LLs,site,*_Matp,*_Matm);
@@ -825,7 +814,7 @@ CayleyFermion5D<Impl>::MooeeInternal(const FermionField &psi, FermionField &chi,
       MooeeInternalAsm(psi,chi,LLs,site,*_Matp,*_Matm);
     });
   }
-  MooeeInvTime+=usecond();
+
 }
 
 NAMESPACE_END(Grid);

Grid/qcd/action/fermion/implementation/DomainWallEOFAFermionCache.h

@@ -54,8 +54,6 @@ void DomainWallEOFAFermion<Impl>::M5D(const FermionField& psi_i, const FermionFi
   auto pupper = &upper[0];
   auto plower = &lower[0];
   // Flops = 6.0*(Nc*Ns) *Ls*vol
-  this->M5Dcalls++;
-  this->M5Dtime -= usecond();
   
   auto nloop=grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
@@ -71,7 +69,6 @@ void DomainWallEOFAFermion<Impl>::M5D(const FermionField& psi_i, const FermionFi
     }
   });
 
-  this->M5Dtime += usecond();
 }
 
 template<class Impl>
@@ -91,8 +88,6 @@ void DomainWallEOFAFermion<Impl>::M5Ddag(const FermionField& psi_i, const Fermio
   auto plower = &lower[0];
 
   // Flops = 6.0*(Nc*Ns) *Ls*vol
-  this->M5Dcalls++;
-  this->M5Dtime -= usecond();
 
   auto nloop=grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
@@ -108,7 +103,6 @@ void DomainWallEOFAFermion<Impl>::M5Ddag(const FermionField& psi_i, const Fermio
     }
   });
 
-  this->M5Dtime += usecond();
 }
 
 template<class Impl>
@@ -127,8 +121,6 @@ void DomainWallEOFAFermion<Impl>::MooeeInv(const FermionField& psi_i, FermionFie
   auto pleem = & this->leem[0];
   auto pueem = & this->ueem[0];
 
-  this->MooeeInvCalls++;
-  this->MooeeInvTime -= usecond();
   uint64_t nloop=grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t ss=sss*Ls;
@@ -164,7 +156,6 @@ void DomainWallEOFAFermion<Impl>::MooeeInv(const FermionField& psi_i, FermionFie
       coalescedWrite(chi[ss+s],res);
     }
   });
-  this->MooeeInvTime += usecond();
 }
 
 template<class Impl>
@@ -185,8 +176,6 @@ void DomainWallEOFAFermion<Impl>::MooeeInvDag(const FermionField& psi_i, Fermion
 
   assert(psi.Checkerboard() == psi.Checkerboard());
 
-  this->MooeeInvCalls++;
-  this->MooeeInvTime -= usecond();
   auto nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t ss=sss*Ls;
@@ -223,7 +212,6 @@ void DomainWallEOFAFermion<Impl>::MooeeInvDag(const FermionField& psi_i, Fermion
     }
   });
 
-  this->MooeeInvTime += usecond();
 }
 
 NAMESPACE_END(Grid);

Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermion5DImplementation.h

@@ -298,45 +298,33 @@ void ImprovedStaggeredFermion5D<Impl>::DhopInternalOverlappedComms(StencilImpl &
   int LLs = in.Grid()->_rdimensions[0];
   int len =  U.Grid()->oSites();
 
-  DhopFaceTime-=usecond();
   st.Prepare();
   st.HaloGather(in,compressor);
-  DhopFaceTime+=usecond();
 
-  DhopCommTime -=usecond();
   std::vector<std::vector<CommsRequest_t> > requests;
   st.CommunicateBegin(requests);
 
   //  st.HaloExchangeOptGather(in,compressor); // Wilson compressor
-  DhopFaceTime-=usecond();
   st.CommsMergeSHM(compressor);// Could do this inside parallel region overlapped with comms
-  DhopFaceTime+=usecond();
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////
   // Remove explicit thread mapping introduced for OPA reasons.
   //////////////////////////////////////////////////////////////////////////////////////////////////////
-  DhopComputeTime-=usecond();
   {
     int interior=1;
     int exterior=0;
     Kernels::DhopImproved(st,lo,U,UUU,in,out,dag,interior,exterior);
   }
-  DhopComputeTime+=usecond();
 
-  DhopFaceTime-=usecond();
   st.CommsMerge(compressor);
-  DhopFaceTime+=usecond();
 
   st.CommunicateComplete(requests);
-  DhopCommTime +=usecond();
 
-  DhopComputeTime2-=usecond();
   {
     int interior=0;
     int exterior=1;
     Kernels::DhopImproved(st,lo,U,UUU,in,out,dag,interior,exterior);
   }
-  DhopComputeTime2+=usecond();
 }
 
 template<class Impl>
@@ -347,22 +335,14 @@ void ImprovedStaggeredFermion5D<Impl>::DhopInternalSerialComms(StencilImpl & st,
   Compressor compressor;
   int LLs = in.Grid()->_rdimensions[0];
 
- //double t1=usecond();
-  DhopTotalTime -= usecond();
-  DhopCommTime -= usecond();
   st.HaloExchange(in,compressor);
-  DhopCommTime += usecond();
   
-  DhopComputeTime -= usecond();
   // Dhop takes the 4d grid from U, and makes a 5d index for fermion
   {
     int interior=1;
     int exterior=1;
     Kernels::DhopImproved(st,lo,U,UUU,in,out,dag,interior,exterior);
   }
-  DhopComputeTime += usecond();
-  DhopTotalTime   += usecond();
-
 }
 /*CHANGE END*/
 
@@ -371,7 +351,6 @@ void ImprovedStaggeredFermion5D<Impl>::DhopInternalSerialComms(StencilImpl & st,
 template<class Impl>
 void ImprovedStaggeredFermion5D<Impl>::DhopOE(const FermionField &in, FermionField &out,int dag)
 {
-  DhopCalls+=1;
   conformable(in.Grid(),FermionRedBlackGrid());    // verifies half grid
   conformable(in.Grid(),out.Grid()); // drops the cb check
 
@@ -383,7 +362,6 @@ void ImprovedStaggeredFermion5D<Impl>::DhopOE(const FermionField &in, FermionFie
 template<class Impl>
 void ImprovedStaggeredFermion5D<Impl>::DhopEO(const FermionField &in, FermionField &out,int dag)
 {
-  DhopCalls+=1;
   conformable(in.Grid(),FermionRedBlackGrid());    // verifies half grid
   conformable(in.Grid(),out.Grid()); // drops the cb check
 
@@ -395,7 +373,6 @@ void ImprovedStaggeredFermion5D<Impl>::DhopEO(const FermionField &in, FermionFie
 template<class Impl>
 void ImprovedStaggeredFermion5D<Impl>::Dhop(const FermionField &in, FermionField &out,int dag)
 {
-  DhopCalls+=2;
   conformable(in.Grid(),FermionGrid()); // verifies full grid
   conformable(in.Grid(),out.Grid());
 
@@ -404,58 +381,6 @@ void ImprovedStaggeredFermion5D<Impl>::Dhop(const FermionField &in, FermionField
   DhopInternal(Stencil,Lebesgue,Umu,UUUmu,in,out,dag);
 }
 
-template<class Impl>
-void ImprovedStaggeredFermion5D<Impl>::Report(void) 
-{
-  Coordinate latt = GridDefaultLatt();          
-  RealD volume = Ls;  for(int mu=0;mu<Nd;mu++) volume=volume*latt[mu];
-  RealD NP = _FourDimGrid->_Nprocessors;
-  RealD NN = _FourDimGrid->NodeCount();
-
-  std::cout << GridLogMessage << "#### Dhop calls report " << std::endl;
-
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion5D Number of DhopEO Calls   : " 
-	    << DhopCalls   << std::endl;
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion5D TotalTime   /Calls       : " 
-	    << DhopTotalTime   / DhopCalls << " us" << std::endl;
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion5D CommTime    /Calls       : " 
-	    << DhopCommTime    / DhopCalls << " us" << std::endl;
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion5D ComputeTime/Calls        : " 
-	    << DhopComputeTime / DhopCalls << " us" << std::endl;
-
-  // Average the compute time
-  _FourDimGrid->GlobalSum(DhopComputeTime);
-  DhopComputeTime/=NP;
-
-  RealD mflops = 1154*volume*DhopCalls/DhopComputeTime/2; // 2 for red black counting
-  std::cout << GridLogMessage << "Average mflops/s per call                : " << mflops << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per rank       : " << mflops/NP << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per node       : " << mflops/NN << std::endl;
-  
-  RealD Fullmflops = 1154*volume*DhopCalls/(DhopTotalTime)/2; // 2 for red black counting
-  std::cout << GridLogMessage << "Average mflops/s per call (full)         : " << Fullmflops << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per rank (full): " << Fullmflops/NP << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per node (full): " << Fullmflops/NN << std::endl;
-
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion5D Stencil"    <<std::endl;  Stencil.Report();
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion5D StencilEven"<<std::endl;  StencilEven.Report();
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion5D StencilOdd" <<std::endl;  StencilOdd.Report();
-}
-template<class Impl>
-void ImprovedStaggeredFermion5D<Impl>::ZeroCounters(void) 
-{
-  DhopCalls       = 0;
-  DhopTotalTime    = 0;
-  DhopCommTime    = 0;
-  DhopComputeTime = 0;
-  DhopFaceTime    = 0;
-
-
-  Stencil.ZeroCounters();
-  StencilEven.ZeroCounters();
-  StencilOdd.ZeroCounters();
-}
-
 /////////////////////////////////////////////////////////////////////////
 // Implement the general interface. Here we use SAME mass on all slices
 /////////////////////////////////////////////////////////////////////////

Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermionImplementation.h

@@ -334,7 +334,6 @@ void ImprovedStaggeredFermion<Impl>::DhopDerivEO(GaugeField &mat, const FermionF
 template <class Impl>
 void ImprovedStaggeredFermion<Impl>::Dhop(const FermionField &in, FermionField &out, int dag) 
 {
-  DhopCalls+=2;
   conformable(in.Grid(), _grid);  // verifies full grid
   conformable(in.Grid(), out.Grid());
 
@@ -346,7 +345,6 @@ void ImprovedStaggeredFermion<Impl>::Dhop(const FermionField &in, FermionField &
 template <class Impl>
 void ImprovedStaggeredFermion<Impl>::DhopOE(const FermionField &in, FermionField &out, int dag) 
 {
-  DhopCalls+=1;
   conformable(in.Grid(), _cbgrid);    // verifies half grid
   conformable(in.Grid(), out.Grid());  // drops the cb check
 
@@ -359,7 +357,6 @@ void ImprovedStaggeredFermion<Impl>::DhopOE(const FermionField &in, FermionField
 template <class Impl>
 void ImprovedStaggeredFermion<Impl>::DhopEO(const FermionField &in, FermionField &out, int dag) 
 {
-  DhopCalls+=1;
   conformable(in.Grid(), _cbgrid);    // verifies half grid
   conformable(in.Grid(), out.Grid());  // drops the cb check
 
@@ -418,47 +415,33 @@ void ImprovedStaggeredFermion<Impl>::DhopInternalOverlappedComms(StencilImpl &st
   Compressor compressor; 
   int len =  U.Grid()->oSites();
 
-  DhopTotalTime   -= usecond();
-
-  DhopFaceTime    -= usecond();
   st.Prepare();
   st.HaloGather(in,compressor);
-  DhopFaceTime    += usecond();
 
-  DhopCommTime -=usecond();
   std::vector<std::vector<CommsRequest_t> > requests;
   st.CommunicateBegin(requests);
 
-  DhopFaceTime-=usecond();
   st.CommsMergeSHM(compressor);
-  DhopFaceTime+= usecond();
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////
   // Removed explicit thread comms
   //////////////////////////////////////////////////////////////////////////////////////////////////////
-  DhopComputeTime    -= usecond();
   {
     int interior=1;
     int exterior=0;
     Kernels::DhopImproved(st,lo,U,UUU,in,out,dag,interior,exterior);
   }
-  DhopComputeTime    += usecond();
 
   st.CommunicateComplete(requests);
-  DhopCommTime +=usecond();
 
   // First to enter, last to leave timing
-  DhopFaceTime    -= usecond();
   st.CommsMerge(compressor);
-  DhopFaceTime    -= usecond();
 
-  DhopComputeTime2    -= usecond();
   {
     int interior=0;
     int exterior=1;
     Kernels::DhopImproved(st,lo,U,UUU,in,out,dag,interior,exterior);
   }
-  DhopComputeTime2    += usecond();
 }
 
 
@@ -471,78 +454,16 @@ void ImprovedStaggeredFermion<Impl>::DhopInternalSerialComms(StencilImpl &st, Le
 {
   assert((dag == DaggerNo) || (dag == DaggerYes));
 
-  DhopTotalTime   -= usecond();
-
-  DhopCommTime    -= usecond();
   Compressor compressor;
   st.HaloExchange(in, compressor);
-  DhopCommTime    += usecond();
 
-  DhopComputeTime -= usecond();
   {
     int interior=1;
     int exterior=1;
     Kernels::DhopImproved(st,lo,U,UUU,in,out,dag,interior,exterior);
   }
-  DhopComputeTime += usecond();
-  DhopTotalTime   += usecond();
 };
 
-  ////////////////////////////////////////////////////////////////
-  // Reporting
-  ////////////////////////////////////////////////////////////////
-template<class Impl>
-void ImprovedStaggeredFermion<Impl>::Report(void) 
-{
-  Coordinate latt = _grid->GlobalDimensions();
-  RealD volume = 1;  for(int mu=0;mu<Nd;mu++) volume=volume*latt[mu];
-  RealD NP = _grid->_Nprocessors;
-  RealD NN = _grid->NodeCount();
-
-  std::cout << GridLogMessage << "#### Dhop calls report " << std::endl;
-
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion Number of DhopEO Calls   : " 
-	    << DhopCalls   << std::endl;
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion TotalTime   /Calls       : " 
-	    << DhopTotalTime   / DhopCalls << " us" << std::endl;
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion CommTime    /Calls       : " 
-	    << DhopCommTime    / DhopCalls << " us" << std::endl;
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion ComputeTime/Calls        : " 
-	    << DhopComputeTime / DhopCalls << " us" << std::endl;
-
-  // Average the compute time
-  _grid->GlobalSum(DhopComputeTime);
-  DhopComputeTime/=NP;
-
-  RealD mflops = 1154*volume*DhopCalls/DhopComputeTime/2; // 2 for red black counting
-  std::cout << GridLogMessage << "Average mflops/s per call                : " << mflops << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per rank       : " << mflops/NP << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per node       : " << mflops/NN << std::endl;
-  
-  RealD Fullmflops = 1154*volume*DhopCalls/(DhopTotalTime)/2; // 2 for red black counting
-  std::cout << GridLogMessage << "Average mflops/s per call (full)         : " << Fullmflops << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per rank (full): " << Fullmflops/NP << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per node (full): " << Fullmflops/NN << std::endl;
-
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion Stencil"    <<std::endl;  Stencil.Report();
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion StencilEven"<<std::endl;  StencilEven.Report();
-  std::cout << GridLogMessage << "ImprovedStaggeredFermion StencilOdd" <<std::endl;  StencilOdd.Report();
-}
-template<class Impl>
-void ImprovedStaggeredFermion<Impl>::ZeroCounters(void) 
-{
-  DhopCalls       = 0;
-  DhopTotalTime   = 0;
-  DhopCommTime    = 0;
-  DhopComputeTime = 0;
-  DhopFaceTime    = 0;
-
-  Stencil.ZeroCounters();
-  StencilEven.ZeroCounters();
-  StencilOdd.ZeroCounters();
-}
-
-
 //////////////////////////////////////////////////////// 
 // Conserved current - not yet implemented.
 ////////////////////////////////////////////////////////

Grid/qcd/action/fermion/implementation/MobiusEOFAFermionCache.h

@@ -55,9 +55,6 @@ void MobiusEOFAFermion<Impl>::M5D(const FermionField &psi_i, const FermionField
   auto plower = &lower[0];
 
   // Flops = 6.0*(Nc*Ns) *Ls*vol
-  this->M5Dcalls++;
-  this->M5Dtime -= usecond();
-
   int nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t ss = sss*Ls;
@@ -73,7 +70,6 @@ void MobiusEOFAFermion<Impl>::M5D(const FermionField &psi_i, const FermionField
     }
   });
 
-  this->M5Dtime += usecond();
 }
 
 template<class Impl>
@@ -99,9 +95,6 @@ void MobiusEOFAFermion<Impl>::M5D_shift(const FermionField &psi_i, const Fermion
   auto pshift_coeffs = &shift_coeffs[0];
 
   // Flops = 6.0*(Nc*Ns) *Ls*vol
-  this->M5Dcalls++;
-  this->M5Dtime -= usecond();
-
   int nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t ss = sss*Ls;
@@ -122,7 +115,6 @@ void MobiusEOFAFermion<Impl>::M5D_shift(const FermionField &psi_i, const Fermion
     }
   });
 
-  this->M5Dtime += usecond();
 }
 
 template<class Impl>
@@ -143,9 +135,6 @@ void MobiusEOFAFermion<Impl>::M5Ddag(const FermionField &psi_i, const FermionFie
   auto plower = &lower[0];
 
   // Flops = 6.0*(Nc*Ns) *Ls*vol
-  this->M5Dcalls++;
-  this->M5Dtime -= usecond();
-
   int nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(), {
     uint64_t ss = sss*Ls;
@@ -161,8 +150,6 @@ void MobiusEOFAFermion<Impl>::M5Ddag(const FermionField &psi_i, const FermionFie
       coalescedWrite(chi[ss+s], pdiag[s]*phi(ss+s) + pupper[s]*tmp1 + plower[s]*tmp2);
     }
   });
-
-  this->M5Dtime += usecond();
 }
 
 template<class Impl>
@@ -186,9 +173,6 @@ void MobiusEOFAFermion<Impl>::M5Ddag_shift(const FermionField &psi_i, const Ferm
   auto pshift_coeffs = &shift_coeffs[0];
 
   // Flops = 6.0*(Nc*Ns) *Ls*vol
-  this->M5Dcalls++;
-  this->M5Dtime -= usecond();
-
   auto pm = this->pm;
 
   int nloop = grid->oSites()/Ls;
@@ -217,7 +201,6 @@ void MobiusEOFAFermion<Impl>::M5Ddag_shift(const FermionField &psi_i, const Ferm
     }
   });
 
-  this->M5Dtime += usecond();
 }
 
 template<class Impl>
@@ -237,9 +220,6 @@ void MobiusEOFAFermion<Impl>::MooeeInv(const FermionField &psi_i, FermionField &
 
   if(this->shift != 0.0){ MooeeInv_shift(psi_i,chi_i); return; }
 
-  this->MooeeInvCalls++;
-  this->MooeeInvTime -= usecond();
-
   int nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t ss=sss*Ls;
@@ -277,7 +257,6 @@ void MobiusEOFAFermion<Impl>::MooeeInv(const FermionField &psi_i, FermionField &
     }
   });
    
-  this->MooeeInvTime += usecond();
 }
 
 template<class Impl>
@@ -297,8 +276,6 @@ void MobiusEOFAFermion<Impl>::MooeeInv_shift(const FermionField &psi_i, FermionF
   auto pueem= & this->ueem[0];
   auto pMooeeInv_shift_lc   = &MooeeInv_shift_lc[0];
   auto pMooeeInv_shift_norm = &MooeeInv_shift_norm[0];
-  this->MooeeInvCalls++;
-  this->MooeeInvTime -= usecond();
 
   int nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
@@ -343,7 +320,6 @@ void MobiusEOFAFermion<Impl>::MooeeInv_shift(const FermionField &psi_i, FermionF
       }
   });
 
-  this->MooeeInvTime += usecond();
 }
 
 template<class Impl>
@@ -363,9 +339,6 @@ void MobiusEOFAFermion<Impl>::MooeeInvDag(const FermionField &psi_i, FermionFiel
   auto pleem= & this->leem[0];
   auto pueem= & this->ueem[0];
 
-  this->MooeeInvCalls++;
-  this->MooeeInvTime -= usecond();
-
   int nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
     uint64_t ss=sss*Ls;
@@ -402,7 +375,6 @@ void MobiusEOFAFermion<Impl>::MooeeInvDag(const FermionField &psi_i, FermionFiel
       coalescedWrite(chi[ss+s],res);
     }
   });
-  this->MooeeInvTime += usecond();
 }
 
 template<class Impl>
@@ -423,9 +395,6 @@ void MobiusEOFAFermion<Impl>::MooeeInvDag_shift(const FermionField &psi_i, Fermi
   auto pMooeeInvDag_shift_lc   = &MooeeInvDag_shift_lc[0];
   auto pMooeeInvDag_shift_norm = &MooeeInvDag_shift_norm[0];
 
-  this->MooeeInvCalls++;
-  this->MooeeInvTime -= usecond();
-
   int nloop = grid->oSites()/Ls;
   accelerator_for(sss,nloop,Simd::Nsimd(),{
       uint64_t ss=sss*Ls;
@@ -469,7 +438,6 @@ void MobiusEOFAFermion<Impl>::MooeeInvDag_shift(const FermionField &psi_i, Fermi
       }
   });
 
-  this->MooeeInvTime += usecond();
 }
 
 NAMESPACE_END(Grid);

Grid/qcd/action/fermion/implementation/NaiveStaggeredFermionImplementation.h

@@ -263,7 +263,6 @@ void NaiveStaggeredFermion<Impl>::DhopDerivEO(GaugeField &mat, const FermionFiel
 template <class Impl>
 void NaiveStaggeredFermion<Impl>::Dhop(const FermionField &in, FermionField &out, int dag) 
 {
-  DhopCalls+=2;
   conformable(in.Grid(), _grid);  // verifies full grid
   conformable(in.Grid(), out.Grid());
 
@@ -275,7 +274,6 @@ void NaiveStaggeredFermion<Impl>::Dhop(const FermionField &in, FermionField &out
 template <class Impl>
 void NaiveStaggeredFermion<Impl>::DhopOE(const FermionField &in, FermionField &out, int dag) 
 {
-  DhopCalls+=1;
   conformable(in.Grid(), _cbgrid);    // verifies half grid
   conformable(in.Grid(), out.Grid());  // drops the cb check
 
@@ -288,7 +286,6 @@ void NaiveStaggeredFermion<Impl>::DhopOE(const FermionField &in, FermionField &o
 template <class Impl>
 void NaiveStaggeredFermion<Impl>::DhopEO(const FermionField &in, FermionField &out, int dag) 
 {
-  DhopCalls+=1;
   conformable(in.Grid(), _cbgrid);    // verifies half grid
   conformable(in.Grid(), out.Grid());  // drops the cb check
 
@@ -345,47 +342,33 @@ void NaiveStaggeredFermion<Impl>::DhopInternalOverlappedComms(StencilImpl &st, L
   Compressor compressor; 
   int len =  U.Grid()->oSites();
 
-  DhopTotalTime   -= usecond();
-
-  DhopFaceTime    -= usecond();
   st.Prepare();
   st.HaloGather(in,compressor);
-  DhopFaceTime    += usecond();
 
-  DhopCommTime -=usecond();
   std::vector<std::vector<CommsRequest_t> > requests;
   st.CommunicateBegin(requests);
 
-  DhopFaceTime-=usecond();
   st.CommsMergeSHM(compressor);
-  DhopFaceTime+= usecond();
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////
   // Removed explicit thread comms
   //////////////////////////////////////////////////////////////////////////////////////////////////////
-  DhopComputeTime    -= usecond();
   {
     int interior=1;
     int exterior=0;
     Kernels::DhopNaive(st,lo,U,in,out,dag,interior,exterior);
   }
-  DhopComputeTime    += usecond();
 
   st.CommunicateComplete(requests);
-  DhopCommTime +=usecond();
 
   // First to enter, last to leave timing
-  DhopFaceTime    -= usecond();
   st.CommsMerge(compressor);
-  DhopFaceTime    -= usecond();
 
-  DhopComputeTime2    -= usecond();
   {
     int interior=0;
     int exterior=1;
     Kernels::DhopNaive(st,lo,U,in,out,dag,interior,exterior);
   }
-  DhopComputeTime2    += usecond();
 }
 
 template <class Impl>
@@ -396,78 +379,16 @@ void NaiveStaggeredFermion<Impl>::DhopInternalSerialComms(StencilImpl &st, Lebes
 {
   assert((dag == DaggerNo) || (dag == DaggerYes));
 
-  DhopTotalTime   -= usecond();
-
-  DhopCommTime    -= usecond();
   Compressor compressor;
   st.HaloExchange(in, compressor);
-  DhopCommTime    += usecond();
 
-  DhopComputeTime -= usecond();
   {
     int interior=1;
     int exterior=1;
     Kernels::DhopNaive(st,lo,U,in,out,dag,interior,exterior);
   }
-  DhopComputeTime += usecond();
-  DhopTotalTime   += usecond();
 };
 
-  ////////////////////////////////////////////////////////////////
-  // Reporting
-  ////////////////////////////////////////////////////////////////
-template<class Impl>
-void NaiveStaggeredFermion<Impl>::Report(void) 
-{
-  Coordinate latt = _grid->GlobalDimensions();
-  RealD volume = 1;  for(int mu=0;mu<Nd;mu++) volume=volume*latt[mu];
-  RealD NP = _grid->_Nprocessors;
-  RealD NN = _grid->NodeCount();
-
-  std::cout << GridLogMessage << "#### Dhop calls report " << std::endl;
-
-  std::cout << GridLogMessage << "NaiveStaggeredFermion Number of DhopEO Calls   : " 
-	    << DhopCalls   << std::endl;
-  std::cout << GridLogMessage << "NaiveStaggeredFermion TotalTime   /Calls       : " 
-	    << DhopTotalTime   / DhopCalls << " us" << std::endl;
-  std::cout << GridLogMessage << "NaiveStaggeredFermion CommTime    /Calls       : " 
-	    << DhopCommTime    / DhopCalls << " us" << std::endl;
-  std::cout << GridLogMessage << "NaiveStaggeredFermion ComputeTime/Calls        : " 
-	    << DhopComputeTime / DhopCalls << " us" << std::endl;
-
-  // Average the compute time
-  _grid->GlobalSum(DhopComputeTime);
-  DhopComputeTime/=NP;
-
-  RealD mflops = 1154*volume*DhopCalls/DhopComputeTime/2; // 2 for red black counting
-  std::cout << GridLogMessage << "Average mflops/s per call                : " << mflops << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per rank       : " << mflops/NP << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per node       : " << mflops/NN << std::endl;
-  
-  RealD Fullmflops = 1154*volume*DhopCalls/(DhopTotalTime)/2; // 2 for red black counting
-  std::cout << GridLogMessage << "Average mflops/s per call (full)         : " << Fullmflops << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per rank (full): " << Fullmflops/NP << std::endl;
-  std::cout << GridLogMessage << "Average mflops/s per call per node (full): " << Fullmflops/NN << std::endl;
-
-  std::cout << GridLogMessage << "NaiveStaggeredFermion Stencil"    <<std::endl;  Stencil.Report();
-  std::cout << GridLogMessage << "NaiveStaggeredFermion StencilEven"<<std::endl;  StencilEven.Report();
-  std::cout << GridLogMessage << "NaiveStaggeredFermion StencilOdd" <<std::endl;  StencilOdd.Report();
-}
-template<class Impl>
-void NaiveStaggeredFermion<Impl>::ZeroCounters(void) 
-{
-  DhopCalls       = 0;
-  DhopTotalTime   = 0;
-  DhopCommTime    = 0;
-  DhopComputeTime = 0;
-  DhopFaceTime    = 0;
-
-  Stencil.ZeroCounters();
-  StencilEven.ZeroCounters();
-  StencilOdd.ZeroCounters();
-}
-
-
 //////////////////////////////////////////////////////// 
 // Conserved current - not yet implemented.
 ////////////////////////////////////////////////////////

Grid/qcd/action/fermion/implementation/WilsonFermion5DImplementation.h

@@ -103,8 +103,6 @@ WilsonFermion5D<Impl>::WilsonFermion5D(GaugeField &_Umu,
     Block = block;
   }
 
-  ZeroCounters();
-
   if (Impl::LsVectorised) { 
 
     int nsimd = Simd::Nsimd();
@@ -143,89 +141,6 @@ WilsonFermion5D<Impl>::WilsonFermion5D(GaugeField &_Umu,
    //                       <<" " << StencilEven.surface_list.size()<<std::endl;
 
 }
-     
-template<class Impl>
-void WilsonFermion5D<Impl>::Report(void)
-{
-  RealD NP     = _FourDimGrid->_Nprocessors;
-  RealD NN     = _FourDimGrid->NodeCount();
-  RealD volume = Ls;  
-  Coordinate latt = _FourDimGrid->GlobalDimensions();
-  for(int mu=0;mu<Nd;mu++) volume=volume*latt[mu];
-
-  if ( DhopCalls > 0 ) {
-    std::cout << GridLogMessage << "#### Dhop calls report " << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D Number of DhopEO Calls   : " << DhopCalls   << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D TotalTime   /Calls        : " << DhopTotalTime   / DhopCalls << " us" << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D CommTime    /Calls        : " << DhopCommTime    / DhopCalls << " us" << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D FaceTime    /Calls        : " << DhopFaceTime    / DhopCalls << " us" << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D ComputeTime1/Calls        : " << DhopComputeTime / DhopCalls << " us" << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D ComputeTime2/Calls        : " << DhopComputeTime2/ DhopCalls << " us" << std::endl;
-
-    // Average the compute time
-    _FourDimGrid->GlobalSum(DhopComputeTime);
-    DhopComputeTime/=NP;
-    RealD mflops = 1344*volume*DhopCalls/DhopComputeTime/2; // 2 for red black counting
-    std::cout << GridLogMessage << "Average mflops/s per call                : " << mflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per rank       : " << mflops/NP << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per node       : " << mflops/NN << std::endl;
-
-    RealD Fullmflops = 1344*volume*DhopCalls/(DhopTotalTime)/2; // 2 for red black counting
-    std::cout << GridLogMessage << "Average mflops/s per call (full)         : " << Fullmflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per rank (full): " << Fullmflops/NP << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per node (full): " << Fullmflops/NN << std::endl;
-
-   }
-
-  if ( DerivCalls > 0 ) {
-    std::cout << GridLogMessage << "#### Deriv calls report "<< std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D Number of Deriv Calls    : " <<DerivCalls <<std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D CommTime/Calls           : " <<DerivCommTime/DerivCalls<<" us" <<std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D ComputeTime/Calls        : " <<DerivComputeTime/DerivCalls<<" us" <<std::endl;
-    std::cout << GridLogMessage << "WilsonFermion5D Dhop ComputeTime/Calls   : " <<DerivDhopComputeTime/DerivCalls<<" us" <<std::endl;
-    
-    RealD mflops = 144*volume*DerivCalls/DerivDhopComputeTime;
-    std::cout << GridLogMessage << "Average mflops/s per call                : " << mflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per node       : " << mflops/NP << std::endl;
-
-    RealD Fullmflops = 144*volume*DerivCalls/(DerivDhopComputeTime+DerivCommTime)/2; // 2 for red black counting
-    std::cout << GridLogMessage << "Average mflops/s per call (full)         : " << Fullmflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per node (full): " << Fullmflops/NP << std::endl;  }
-
-  if (DerivCalls > 0 || DhopCalls > 0){
-    std::cout << GridLogMessage << "WilsonFermion5D Stencil"    <<std::endl;  Stencil.Report();
-    std::cout << GridLogMessage << "WilsonFermion5D StencilEven"<<std::endl;  StencilEven.Report();
-    std::cout << GridLogMessage << "WilsonFermion5D StencilOdd" <<std::endl;  StencilOdd.Report();
-  }
-  if ( DhopCalls > 0){
-    std::cout << GridLogMessage << "WilsonFermion5D Stencil     Reporti()"    <<std::endl;  Stencil.Reporti(DhopCalls);
-    std::cout << GridLogMessage << "WilsonFermion5D StencilEven Reporti()"<<std::endl;  StencilEven.Reporti(DhopCalls);
-    std::cout << GridLogMessage << "WilsonFermion5D StencilOdd  Reporti()" <<std::endl;  StencilOdd.Reporti(DhopCalls);
-  }
-}
-
-template<class Impl>
-void WilsonFermion5D<Impl>::ZeroCounters(void) {
-  DhopCalls       = 0;
-  DhopCommTime    = 0;
-  DhopComputeTime = 0;
-  DhopComputeTime2= 0;
-  DhopFaceTime    = 0;
-  DhopTotalTime   = 0;
-
-  DerivCalls       = 0;
-  DerivCommTime    = 0;
-  DerivComputeTime = 0;
-  DerivDhopComputeTime = 0;
-
-  Stencil.ZeroCounters();
-  StencilEven.ZeroCounters();
-  StencilOdd.ZeroCounters();
-  Stencil.ZeroCountersi();
-  StencilEven.ZeroCountersi();
-  StencilOdd.ZeroCountersi();
-}
-
 
 template<class Impl>
 void WilsonFermion5D<Impl>::ImportGauge(const GaugeField &_Umu)
@@ -233,12 +148,21 @@ void WilsonFermion5D<Impl>::ImportGauge(const GaugeField &_Umu)
   GaugeField HUmu(_Umu.Grid());
   HUmu = _Umu*(-0.5);
   if ( Dirichlet ) {
-    std::cout << GridLogMessage << " Dirichlet BCs 5d " <<Block<<std::endl;
+    std:: cout << GridLogMessage << "Checking block size multiple of rank boundaries for Dirichlet"<<std::endl;
+    for(int d=0;d<Nd;d++) {
+      int GaugeBlock = Block[d+1];
+      int ldim=GaugeGrid()->LocalDimensions()[d];
+      if (GaugeBlock) assert( (GaugeBlock%ldim)==0);
+    }
+  }
+  if ( Dirichlet && (!this->Params.partialDirichlet) ) {
+    std::cout << GridLogMessage << " Dirichlet filtering gauge field BCs block " <<Block<<std::endl;
     Coordinate GaugeBlock(Nd);
     for(int d=0;d<Nd;d++) GaugeBlock[d] = Block[d+1];
-    std::cout << GridLogMessage << " Dirichlet BCs 4d " <<GaugeBlock<<std::endl;
     DirichletFilter<GaugeField> Filter(GaugeBlock);
     Filter.applyFilter(HUmu);
+  } else {
+    std::cout << GridLogMessage << " Dirichlet "<< Dirichlet << " not filtered gauge field" <<std::endl;
   }
   Impl::DoubleStore(GaugeGrid(),Umu,HUmu);
   pickCheckerboard(Even,UmuEven,Umu);
@@ -281,7 +205,6 @@ void WilsonFermion5D<Impl>::DerivInternal(StencilImpl & st,
 					  const FermionField &B,
 					  int dag)
 {
-  DerivCalls++;
   assert((dag==DaggerNo) ||(dag==DaggerYes));
 
   conformable(st.Grid(),A.Grid());
@@ -292,15 +215,12 @@ void WilsonFermion5D<Impl>::DerivInternal(StencilImpl & st,
   FermionField Btilde(B.Grid());
   FermionField Atilde(B.Grid());
 
-  DerivCommTime-=usecond();
   st.HaloExchange(B,compressor);
-  DerivCommTime+=usecond();
 
   Atilde=A;
   int LLs = B.Grid()->_rdimensions[0];
 
 
-  DerivComputeTime-=usecond();
   for (int mu = 0; mu < Nd; mu++) {
     ////////////////////////////////////////////////////////////////////////
     // Flip gamma if dag
@@ -312,8 +232,6 @@ void WilsonFermion5D<Impl>::DerivInternal(StencilImpl & st,
     // Call the single hop
     ////////////////////////
 
-    DerivDhopComputeTime -= usecond();
-
     int Usites = U.Grid()->oSites();
 
     Kernels::DhopDirKernel(st, U, st.CommBuf(), Ls, Usites, B, Btilde, mu,gamma);
@@ -321,10 +239,8 @@ void WilsonFermion5D<Impl>::DerivInternal(StencilImpl & st,
     ////////////////////////////
     // spin trace outer product
     ////////////////////////////
-    DerivDhopComputeTime += usecond();
     Impl::InsertForce5D(mat, Btilde, Atilde, mu);
   }
-  DerivComputeTime += usecond();
 }
 
 template<class Impl>
@@ -382,12 +298,10 @@ void WilsonFermion5D<Impl>::DhopInternal(StencilImpl & st, LebesgueOrder &lo,
                                          DoubledGaugeField & U,
                                          const FermionField &in, FermionField &out,int dag)
 {
-  DhopTotalTime-=usecond();
   if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsAndCompute )
     DhopInternalOverlappedComms(st,lo,U,in,out,dag);
   else 
     DhopInternalSerialComms(st,lo,U,in,out,dag);
-  DhopTotalTime+=usecond();
 }
 
 
@@ -396,6 +310,7 @@ void WilsonFermion5D<Impl>::DhopInternalOverlappedComms(StencilImpl & st, Lebesg
 							DoubledGaugeField & U,
 							const FermionField &in, FermionField &out,int dag)
 {
+  GRID_TRACE("DhopInternalOverlappedComms");
   Compressor compressor(dag);
 
   int LLs = in.Grid()->_rdimensions[0];
@@ -404,53 +319,58 @@ void WilsonFermion5D<Impl>::DhopInternalOverlappedComms(StencilImpl & st, Lebesg
   /////////////////////////////
   // Start comms  // Gather intranode and extra node differentiated??
   /////////////////////////////
-  DhopFaceTime-=usecond();
-  st.HaloExchangeOptGather(in,compressor);
-  DhopFaceTime+=usecond();
-
-  DhopCommTime -=usecond();
+  {
+    GRID_TRACE("Gather");
+    st.HaloExchangeOptGather(in,compressor);
+    accelerator_barrier();
+  }
+  
   std::vector<std::vector<CommsRequest_t> > requests;
+  auto id=traceStart("Communicate overlapped");
   st.CommunicateBegin(requests);
 
   /////////////////////////////
   // Overlap with comms
   /////////////////////////////
-  DhopFaceTime-=usecond();
-  st.CommsMergeSHM(compressor);// Could do this inside parallel region overlapped with comms
-  DhopFaceTime+=usecond();
+  {
+    GRID_TRACE("MergeSHM");
+    st.CommsMergeSHM(compressor);// Could do this inside parallel region overlapped with comms
+  }
       
   /////////////////////////////
   // do the compute interior
   /////////////////////////////
   int Opt = WilsonKernelsStatic::Opt; // Why pass this. Kernels should know
-  DhopComputeTime-=usecond();
   if (dag == DaggerYes) {
+    GRID_TRACE("DhopDagInterior");
     Kernels::DhopDagKernel(Opt,st,U,st.CommBuf(),LLs,U.oSites(),in,out,1,0);
   } else {
+    GRID_TRACE("DhopInterior");
     Kernels::DhopKernel   (Opt,st,U,st.CommBuf(),LLs,U.oSites(),in,out,1,0);
   }
-  DhopComputeTime+=usecond();
 
   /////////////////////////////
   // Complete comms
   /////////////////////////////
   st.CommunicateComplete(requests);
-  DhopCommTime   +=usecond();
+  traceStop(id);
 
   /////////////////////////////
   // do the compute exterior
   /////////////////////////////
-  DhopFaceTime-=usecond();
-  st.CommsMerge(compressor);
-  DhopFaceTime+=usecond();
+  {
+    GRID_TRACE("Merge");
+    st.CommsMerge(compressor);
+  }
+  
 
-  DhopComputeTime2-=usecond();
   if (dag == DaggerYes) {
+    GRID_TRACE("DhopDagExterior");
     Kernels::DhopDagKernel(Opt,st,U,st.CommBuf(),LLs,U.oSites(),in,out,0,1);
   } else {
+    GRID_TRACE("DhopExterior");
     Kernels::DhopKernel   (Opt,st,U,st.CommBuf(),LLs,U.oSites(),in,out,0,1);
   }
-  DhopComputeTime2+=usecond();
 }
 
 
@@ -460,29 +380,30 @@ void WilsonFermion5D<Impl>::DhopInternalSerialComms(StencilImpl & st, LebesgueOr
 						    const FermionField &in, 
 						    FermionField &out,int dag)
 {
+  GRID_TRACE("DhopInternalSerialComms");
   Compressor compressor(dag);
 
   int LLs = in.Grid()->_rdimensions[0];
+
+  {
+    GRID_TRACE("HaloExchange");
+    st.HaloExchangeOpt(in,compressor);
+  }
   
-  DhopCommTime-=usecond();
-  st.HaloExchangeOpt(in,compressor);
-  DhopCommTime+=usecond();
-  
-  DhopComputeTime-=usecond();
   int Opt = WilsonKernelsStatic::Opt;
   if (dag == DaggerYes) {
+    GRID_TRACE("DhopDag");
     Kernels::DhopDagKernel(Opt,st,U,st.CommBuf(),LLs,U.oSites(),in,out);
   } else {
+    GRID_TRACE("Dhop");
     Kernels::DhopKernel(Opt,st,U,st.CommBuf(),LLs,U.oSites(),in,out);
   }
-  DhopComputeTime+=usecond();
 }
 
 
 template<class Impl>
 void WilsonFermion5D<Impl>::DhopOE(const FermionField &in, FermionField &out,int dag)
 {
-  DhopCalls++;
   conformable(in.Grid(),FermionRedBlackGrid());    // verifies half grid
   conformable(in.Grid(),out.Grid()); // drops the cb check
 
@@ -494,7 +415,6 @@ void WilsonFermion5D<Impl>::DhopOE(const FermionField &in, FermionField &out,int
 template<class Impl>
 void WilsonFermion5D<Impl>::DhopEO(const FermionField &in, FermionField &out,int dag)
 {
-  DhopCalls++;
   conformable(in.Grid(),FermionRedBlackGrid());    // verifies half grid
   conformable(in.Grid(),out.Grid()); // drops the cb check
 
@@ -506,7 +426,6 @@ void WilsonFermion5D<Impl>::DhopEO(const FermionField &in, FermionField &out,int
 template<class Impl>
 void WilsonFermion5D<Impl>::Dhop(const FermionField &in, FermionField &out,int dag)
 {
-  DhopCalls+=2;
   conformable(in.Grid(),FermionGrid()); // verifies full grid
   conformable(in.Grid(),out.Grid());
 
@@ -561,12 +480,17 @@ void WilsonFermion5D<Impl>::MomentumSpacePropagatorHt_5d(FermionField &out,const
   LatComplex    sk(_grid);  sk = Zero();
   LatComplex    sk2(_grid); sk2= Zero();
   LatComplex    W(_grid); W= Zero();
-  LatComplex    a(_grid); a= Zero();
   LatComplex    one  (_grid); one = ScalComplex(1.0,0.0);
   LatComplex 	cosha(_grid);
   LatComplex 	kmu(_grid);
   LatComplex 	Wea(_grid);
   LatComplex 	Wema(_grid);
+  LatComplex 	ea(_grid);
+  LatComplex 	ema(_grid);
+  LatComplex 	eaLs(_grid);
+  LatComplex 	emaLs(_grid);
+  LatComplex 	ea2Ls(_grid);
+  LatComplex 	ema2Ls(_grid);
   LatComplex 	sinha(_grid);
   LatComplex 	sinhaLs(_grid);
   LatComplex 	coshaLs(_grid);
@@ -601,39 +525,29 @@ void WilsonFermion5D<Impl>::MomentumSpacePropagatorHt_5d(FermionField &out,const
   ////////////////////////////////////////////
   cosha = (one + W*W + sk) / (abs(W)*2.0);
 
-  // FIXME Need a Lattice acosh
-
-  {
-    autoView(cosha_v,cosha,CpuRead);
-    autoView(a_v,a,CpuWrite);
-    for(int idx=0;idx<_grid->lSites();idx++){
-      Coordinate lcoor(Nd);
-      Tcomplex cc;
-      //    RealD sgn;
-      _grid->LocalIndexToLocalCoor(idx,lcoor);
-      peekLocalSite(cc,cosha_v,lcoor);
-      assert((double)real(cc)>=1.0);
-      assert(fabs((double)imag(cc))<=1.0e-15);
-      cc = ScalComplex(::acosh(real(cc)),0.0);
-      pokeLocalSite(cc,a_v,lcoor);
-    }
-  }
-
-  Wea = ( exp( a) * abs(W)  );
-  Wema= ( exp(-a) * abs(W)  );
-  sinha = 0.5*(exp( a) - exp(-a));
-  sinhaLs = 0.5*(exp( a*Ls) - exp(-a*Ls));
-  coshaLs = 0.5*(exp( a*Ls) + exp(-a*Ls));
+  ea = (cosha + sqrt(cosha*cosha-one));
+  ema= (cosha - sqrt(cosha*cosha-one));
+  eaLs = pow(ea,Ls);
+  emaLs= pow(ema,Ls);
+  ea2Ls = pow(ea,2.0*Ls);
+  ema2Ls= pow(ema,2.0*Ls);
+  Wea= abs(W) * ea;
+  Wema= abs(W) * ema;
+  //  a=log(ea);
+  
+  sinha = 0.5*(ea - ema);
+  sinhaLs = 0.5*(eaLs-emaLs);
+  coshaLs = 0.5*(eaLs+emaLs);
 
   A = one / (abs(W) * sinha * 2.0) * one / (sinhaLs * 2.0);
-  F = exp( a*Ls) * (one - Wea + (Wema - one) * mass*mass);
-  F = F + exp(-a*Ls) * (Wema - one + (one - Wea) * mass*mass);
+  F = eaLs * (one - Wea + (Wema - one) * mass*mass);
+  F = F + emaLs * (Wema - one + (one - Wea) * mass*mass);
   F = F - abs(W) * sinha * 4.0 * mass;
 
-  Bpp =  (A/F) * (exp(-a*Ls*2.0) - one) * (one - Wema) * (one - mass*mass * one);
-  Bmm =  (A/F) * (one - exp(a*Ls*2.0)) * (one - Wea) * (one - mass*mass * one);
-  App =  (A/F) * (exp(-a*Ls*2.0) - one) * exp(-a) * (exp(-a) - abs(W)) * (one - mass*mass * one);
-  Amm =  (A/F) * (one - exp(a*Ls*2.0)) * exp(a) * (exp(a) - abs(W)) * (one - mass*mass * one);
+  Bpp =  (A/F) * (ema2Ls - one) * (one - Wema) * (one - mass*mass * one);
+  Bmm =  (A/F) * (one - ea2Ls)  * (one - Wea) * (one - mass*mass * one);
+  App =  (A/F) * (ema2Ls - one) * ema * (ema - abs(W)) * (one - mass*mass * one);
+  Amm =  (A/F) * (one - ea2Ls)  * ea  * (ea  - abs(W)) * (one - mass*mass * one);
   ABpm = (A/F) * abs(W) * sinha * 2.0  * (one + mass * coshaLs * 2.0 + mass*mass * one);
 
   //P+ source, P- source
@@ -656,29 +570,29 @@ void WilsonFermion5D<Impl>::MomentumSpacePropagatorHt_5d(FermionField &out,const
       buf1_4d = Zero();
       ExtractSlice(buf1_4d, PRsource, (tt-1), 0);
       //G(s,t)
-      bufR_4d = bufR_4d + A * exp(a*Ls) * exp(-a*f) * signW * buf1_4d + A * exp(-a*Ls) * exp(a*f) * signW * buf1_4d;
+      bufR_4d = bufR_4d + A * eaLs * pow(ema,f) * signW * buf1_4d + A * emaLs * pow(ea,f) * signW * buf1_4d;
       //A++*exp(a(s+t))
-      bufR_4d = bufR_4d + App * exp(a*ss) * exp(a*tt) * signW * buf1_4d ;
+      bufR_4d = bufR_4d + App * pow(ea,ss) * pow(ea,tt) * signW * buf1_4d ;
       //A+-*exp(a(s-t))
-      bufR_4d = bufR_4d + ABpm * exp(a*ss) * exp(-a*tt) * signW * buf1_4d ;
+      bufR_4d = bufR_4d + ABpm * pow(ea,ss) * pow(ema,tt) * signW * buf1_4d ;
       //A-+*exp(a(-s+t))
-      bufR_4d = bufR_4d + ABpm * exp(-a*ss) * exp(a*tt) * signW * buf1_4d ;
+      bufR_4d = bufR_4d + ABpm * pow(ema,ss) * pow(ea,tt) * signW * buf1_4d ;
       //A--*exp(a(-s-t))
-      bufR_4d = bufR_4d + Amm * exp(-a*ss) * exp(-a*tt) * signW * buf1_4d ;
+      bufR_4d = bufR_4d + Amm * pow(ema,ss) * pow(ema,tt) * signW * buf1_4d ;
 
       //GL
       buf2_4d = Zero();
       ExtractSlice(buf2_4d, PLsource, (tt-1), 0);
       //G(s,t)
-      bufL_4d = bufL_4d + A * exp(a*Ls) * exp(-a*f) * signW * buf2_4d + A * exp(-a*Ls) * exp(a*f) * signW * buf2_4d;
+      bufL_4d = bufL_4d + A * eaLs * pow(ema,f) * signW * buf2_4d + A * emaLs * pow(ea,f) * signW * buf2_4d;
       //B++*exp(a(s+t))
-      bufL_4d = bufL_4d + Bpp * exp(a*ss) * exp(a*tt) * signW * buf2_4d ;
+      bufL_4d = bufL_4d + Bpp * pow(ea,ss) * pow(ea,tt) * signW * buf2_4d ;
       //B+-*exp(a(s-t))
-      bufL_4d = bufL_4d + ABpm * exp(a*ss) * exp(-a*tt) * signW * buf2_4d ;
+      bufL_4d = bufL_4d + ABpm * pow(ea,ss) * pow(ema,tt) * signW * buf2_4d ;
       //B-+*exp(a(-s+t))
-      bufL_4d = bufL_4d + ABpm * exp(-a*ss) * exp(a*tt) * signW * buf2_4d ;
+      bufL_4d = bufL_4d + ABpm * pow(ema,ss) * pow(ea,tt) * signW * buf2_4d ;
       //B--*exp(a(-s-t))
-      bufL_4d = bufL_4d + Bmm * exp(-a*ss) * exp(-a*tt) * signW * buf2_4d ;
+      bufL_4d = bufL_4d + Bmm * pow(ema,ss) * pow(ema,tt) * signW * buf2_4d ;
     }
     InsertSlice(bufR_4d, GR, (ss-1), 0);
     InsertSlice(bufL_4d, GL, (ss-1), 0);
@@ -797,28 +711,12 @@ void WilsonFermion5D<Impl>::MomentumSpacePropagatorHt(FermionField &out,const Fe
   W = one - M5 + sk2;
 
   ////////////////////////////////////////////
-  // Cosh alpha -> alpha
+  // Cosh alpha -> exp(+/- alpha)
   ////////////////////////////////////////////
   cosha =  (one + W*W + sk) / (abs(W)*2.0);
 
-  // FIXME Need a Lattice acosh
-  {
-  autoView(cosha_v,cosha,CpuRead);
-  autoView(a_v,a,CpuWrite);
-  for(int idx=0;idx<_grid->lSites();idx++){
-    Coordinate lcoor(Nd);
-    Tcomplex cc;
-    //    RealD sgn;
-    _grid->LocalIndexToLocalCoor(idx,lcoor);
-    peekLocalSite(cc,cosha_v,lcoor);
-    assert((double)real(cc)>=1.0);
-    assert(fabs((double)imag(cc))<=1.0e-15);
-    cc = ScalComplex(::acosh(real(cc)),0.0);
-    pokeLocalSite(cc,a_v,lcoor);
-  }}
-  
-  Wea = ( exp( a) * abs(W)  );
-  Wema= ( exp(-a) * abs(W)  );
+  Wea = abs(W)*(cosha + sqrt(cosha*cosha-one));
+  Wema= abs(W)*(cosha - sqrt(cosha*cosha-one));
   
   num   = num + ( one - Wema ) * mass * in;
   denom= ( Wea - one ) + mass*mass * (one - Wema); 

Grid/qcd/action/fermion/implementation/WilsonFermionImplementation.h

@@ -76,91 +76,6 @@ WilsonFermion<Impl>::WilsonFermion(GaugeField &_Umu, GridCartesian &Fgrid,
   StencilOdd.BuildSurfaceList(1,vol4);
 }
 
-template<class Impl>
-void WilsonFermion<Impl>::Report(void)
-{
-  RealD NP = _grid->_Nprocessors;
-  RealD NN = _grid->NodeCount();
-  RealD volume = 1;
-  Coordinate latt = _grid->GlobalDimensions();
-  for(int mu=0;mu<Nd;mu++) volume=volume*latt[mu];
-
-  if ( DhopCalls > 0 ) {
-    std::cout << GridLogMessage << "#### Dhop calls report " << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion Number of DhopEO Calls   : " << DhopCalls   << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion TotalTime   /Calls        : " << DhopTotalTime   / DhopCalls << " us" << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion CommTime    /Calls        : " << DhopCommTime    / DhopCalls << " us" << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion FaceTime    /Calls        : " << DhopFaceTime    / DhopCalls << " us" << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion ComputeTime1/Calls        : " << DhopComputeTime / DhopCalls << " us" << std::endl;
-    std::cout << GridLogMessage << "WilsonFermion ComputeTime2/Calls        : " << DhopComputeTime2/ DhopCalls << " us" << std::endl;
-
-    // Average the compute time
-    _grid->GlobalSum(DhopComputeTime);
-    DhopComputeTime/=NP;
-    RealD mflops = 1320*volume*DhopCalls/DhopComputeTime/2; // 2 for red black counting
-    std::cout << GridLogMessage << "Average mflops/s per call                : " << mflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per rank       : " << mflops/NP << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per node       : " << mflops/NN << std::endl;
-
-    RealD Fullmflops = 1320*volume*DhopCalls/(DhopTotalTime)/2; // 2 for red black counting
-    std::cout << GridLogMessage << "Average mflops/s per call (full)         : " << Fullmflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per rank (full): " << Fullmflops/NP << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per node (full): " << Fullmflops/NN << std::endl;
-
-   }
-
-  if ( DerivCalls > 0 ) {
-    std::cout << GridLogMessage << "#### Deriv calls report "<< std::endl;
-    std::cout << GridLogMessage << "WilsonFermion Number of Deriv Calls    : " <<DerivCalls <<std::endl;
-    std::cout << GridLogMessage << "WilsonFermion CommTime/Calls           : " <<DerivCommTime/DerivCalls<<" us" <<std::endl;
-    std::cout << GridLogMessage << "WilsonFermion ComputeTime/Calls        : " <<DerivComputeTime/DerivCalls<<" us" <<std::endl;
-    std::cout << GridLogMessage << "WilsonFermion Dhop ComputeTime/Calls   : " <<DerivDhopComputeTime/DerivCalls<<" us" <<std::endl;
-
-    // how to count flops here?
-    RealD mflops = 144*volume*DerivCalls/DerivDhopComputeTime;
-    std::cout << GridLogMessage << "Average mflops/s per call               ? : " << mflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per node      ? : " << mflops/NP << std::endl;
-
-    // how to count flops here?
-    RealD Fullmflops = 144*volume*DerivCalls/(DerivDhopComputeTime+DerivCommTime)/2; // 2 for red black counting
-    std::cout << GridLogMessage << "Average mflops/s per call (full)        ? : " << Fullmflops << std::endl;
-    std::cout << GridLogMessage << "Average mflops/s per call per node (full) ? : " << Fullmflops/NP << std::endl;  }
-
-  if (DerivCalls > 0 || DhopCalls > 0){
-    std::cout << GridLogMessage << "WilsonFermion Stencil"    <<std::endl;  Stencil.Report();
-    std::cout << GridLogMessage << "WilsonFermion StencilEven"<<std::endl;  StencilEven.Report();
-    std::cout << GridLogMessage << "WilsonFermion StencilOdd" <<std::endl;  StencilOdd.Report();
-  }
-  if ( DhopCalls > 0){
-    std::cout << GridLogMessage << "WilsonFermion Stencil     Reporti()"    <<std::endl;  Stencil.Reporti(DhopCalls);
-    std::cout << GridLogMessage << "WilsonFermion StencilEven Reporti()"<<std::endl;  StencilEven.Reporti(DhopCalls);
-    std::cout << GridLogMessage << "WilsonFermion StencilOdd  Reporti()" <<std::endl;  StencilOdd.Reporti(DhopCalls);
-  }
-}
-
-template<class Impl>
-void WilsonFermion<Impl>::ZeroCounters(void) {
-  DhopCalls       = 0; // ok
-  DhopCommTime    = 0;
-  DhopComputeTime = 0;
-  DhopComputeTime2= 0;
-  DhopFaceTime    = 0;
-  DhopTotalTime   = 0;
-
-  DerivCalls       = 0; // ok
-  DerivCommTime    = 0;
-  DerivComputeTime = 0;
-  DerivDhopComputeTime = 0;
-
-  Stencil.ZeroCounters();
-  StencilEven.ZeroCounters();
-  StencilOdd.ZeroCounters();
-  Stencil.ZeroCountersi();
-  StencilEven.ZeroCountersi();
-  StencilOdd.ZeroCountersi();
-}
-
-
 template <class Impl>
 void WilsonFermion<Impl>::ImportGauge(const GaugeField &_Umu)
 {
@@ -320,7 +235,6 @@ template <class Impl>
 void WilsonFermion<Impl>::DerivInternal(StencilImpl &st, DoubledGaugeField &U,
                                         GaugeField &mat, const FermionField &A,
                                         const FermionField &B, int dag) {
-  DerivCalls++;
   assert((dag == DaggerNo) || (dag == DaggerYes));
 
   Compressor compressor(dag);
@@ -329,11 +243,8 @@ void WilsonFermion<Impl>::DerivInternal(StencilImpl &st, DoubledGaugeField &U,
   FermionField Atilde(B.Grid());
   Atilde = A;
 
-  DerivCommTime-=usecond();
   st.HaloExchange(B, compressor);
-  DerivCommTime+=usecond();
 
-  DerivComputeTime-=usecond();
   for (int mu = 0; mu < Nd; mu++) {
     ////////////////////////////////////////////////////////////////////////
     // Flip gamma (1+g)<->(1-g) if dag
@@ -341,7 +252,6 @@ void WilsonFermion<Impl>::DerivInternal(StencilImpl &st, DoubledGaugeField &U,
     int gamma = mu;
     if (!dag) gamma += Nd;
 
-    DerivDhopComputeTime -= usecond();
     int Ls=1;
     Kernels::DhopDirKernel(st, U, st.CommBuf(), Ls, B.Grid()->oSites(), B, Btilde, mu, gamma);
 
@@ -349,9 +259,7 @@ void WilsonFermion<Impl>::DerivInternal(StencilImpl &st, DoubledGaugeField &U,
     // spin trace outer product
     //////////////////////////////////////////////////
     Impl::InsertForce4D(mat, Btilde, Atilde, mu);
-    DerivDhopComputeTime += usecond();
   }
-  DerivComputeTime += usecond();
 }
 
 template <class Impl>
@@ -398,7 +306,6 @@ void WilsonFermion<Impl>::DhopDerivEO(GaugeField &mat, const FermionField &U, co
 template <class Impl>
 void WilsonFermion<Impl>::Dhop(const FermionField &in, FermionField &out, int dag)
 {
-  DhopCalls+=2;
   conformable(in.Grid(), _grid);  // verifies full grid
   conformable(in.Grid(), out.Grid());
 
@@ -410,7 +317,6 @@ void WilsonFermion<Impl>::Dhop(const FermionField &in, FermionField &out, int da
 template <class Impl>
 void WilsonFermion<Impl>::DhopOE(const FermionField &in, FermionField &out, int dag)
 {
-  DhopCalls++;
   conformable(in.Grid(), _cbgrid);    // verifies half grid
   conformable(in.Grid(), out.Grid());  // drops the cb check
 
@@ -423,7 +329,6 @@ void WilsonFermion<Impl>::DhopOE(const FermionField &in, FermionField &out, int
 template <class Impl>
 void WilsonFermion<Impl>::DhopEO(const FermionField &in, FermionField &out,int dag)
 {
-  DhopCalls++;
   conformable(in.Grid(), _cbgrid);    // verifies half grid
   conformable(in.Grid(), out.Grid());  // drops the cb check
 
@@ -488,14 +393,12 @@ void WilsonFermion<Impl>::DhopInternal(StencilImpl &st, LebesgueOrder &lo,
                                        const FermionField &in,
                                        FermionField &out, int dag)
 {
-  DhopTotalTime-=usecond();
 #ifdef GRID_OMP
   if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsAndCompute )
     DhopInternalOverlappedComms(st,lo,U,in,out,dag);
   else
 #endif
     DhopInternalSerial(st,lo,U,in,out,dag);
-  DhopTotalTime+=usecond();
 }
 
 template <class Impl>
@@ -504,6 +407,7 @@ void WilsonFermion<Impl>::DhopInternalOverlappedComms(StencilImpl &st, LebesgueO
 						      const FermionField &in,
 						      FermionField &out, int dag)
 {
+  GRID_TRACE("DhopOverlapped");
   assert((dag == DaggerNo) || (dag == DaggerYes));
 
   Compressor compressor(dag);
@@ -514,53 +418,55 @@ void WilsonFermion<Impl>::DhopInternalOverlappedComms(StencilImpl &st, LebesgueO
   /////////////////////////////
   std::vector<std::vector<CommsRequest_t> > requests;
   st.Prepare();
-  DhopFaceTime-=usecond();
-  st.HaloGather(in,compressor);
-  DhopFaceTime+=usecond();
+  {
+    GRID_TRACE("Gather");
+    st.HaloGather(in,compressor);
+  }
 
-  DhopCommTime -=usecond();
+  tracePush("Communication");
   st.CommunicateBegin(requests);
 
   /////////////////////////////
   // Overlap with comms
   /////////////////////////////
-  DhopFaceTime-=usecond();
-  st.CommsMergeSHM(compressor);
-  DhopFaceTime+=usecond();
+  {
+    GRID_TRACE("MergeSHM");
+    st.CommsMergeSHM(compressor);
+  }
 
   /////////////////////////////
   // do the compute interior
   /////////////////////////////
   int Opt = WilsonKernelsStatic::Opt;
-  DhopComputeTime-=usecond();
   if (dag == DaggerYes) {
+    GRID_TRACE("DhopDagInterior");
     Kernels::DhopDagKernel(Opt,st,U,st.CommBuf(),1,U.oSites(),in,out,1,0);
   } else {
+    GRID_TRACE("DhopInterior");
     Kernels::DhopKernel(Opt,st,U,st.CommBuf(),1,U.oSites(),in,out,1,0);
   }
-  DhopComputeTime+=usecond();
 
   /////////////////////////////
   // Complete comms
   /////////////////////////////
   st.CommunicateComplete(requests);
-  DhopCommTime   +=usecond();
-
-  DhopFaceTime-=usecond();
-  st.CommsMerge(compressor);
-  DhopFaceTime+=usecond();
+  tracePop("Communication");
 
+  {
+    GRID_TRACE("Merge");
+    st.CommsMerge(compressor);
+  }
   /////////////////////////////
   // do the compute exterior
   /////////////////////////////
 
-  DhopComputeTime2-=usecond();
   if (dag == DaggerYes) {
+    GRID_TRACE("DhopDagExterior");
     Kernels::DhopDagKernel(Opt,st,U,st.CommBuf(),1,U.oSites(),in,out,0,1);
   } else {
+    GRID_TRACE("DhopExterior");
     Kernels::DhopKernel(Opt,st,U,st.CommBuf(),1,U.oSites(),in,out,0,1);
   }
-  DhopComputeTime2+=usecond();
 };
 
 
@@ -570,20 +476,22 @@ void WilsonFermion<Impl>::DhopInternalSerial(StencilImpl &st, LebesgueOrder &lo,
                                        const FermionField &in,
                                        FermionField &out, int dag)
 {
+  GRID_TRACE("DhopSerial");
   assert((dag == DaggerNo) || (dag == DaggerYes));
   Compressor compressor(dag);
-  DhopCommTime-=usecond();
-  st.HaloExchange(in, compressor);
-  DhopCommTime+=usecond();
+  {
+    GRID_TRACE("HaloExchange");
+    st.HaloExchange(in, compressor);
+  }
 
-  DhopComputeTime-=usecond();
   int Opt = WilsonKernelsStatic::Opt;
   if (dag == DaggerYes) {
+    GRID_TRACE("DhopDag");
     Kernels::DhopDagKernel(Opt,st,U,st.CommBuf(),1,U.oSites(),in,out);
   } else {
+    GRID_TRACE("Dhop");
     Kernels::DhopKernel(Opt,st,U,st.CommBuf(),1,U.oSites(),in,out);
   }
-  DhopComputeTime+=usecond();
 };
 /*Change ends */
 

Grid/qcd/action/fermion/implementation/WilsonKernelsImplementation.h

@@ -72,20 +72,15 @@ accelerator_inline void get_stencil(StencilEntry * mem, StencilEntry &chip)
   if (SE->_is_local) {						\
     int perm= SE->_permute;					\
     auto tmp = coalescedReadPermute(in[SE->_offset],ptype,perm,lane);	\
-    spProj(chi,tmp);						\
-  } else if ( st.same_node[Dir] ) {				\
-    chi = coalescedRead(buf[SE->_offset],lane);			\
-  }								\
-  acceleratorSynchronise();						\
-  if (SE->_is_local || st.same_node[Dir] ) {			\
-    Impl::multLink(Uchi, U[sU], chi, Dir, SE, st);		\
-    Recon(result, Uchi);					\
-  }								\
+    spProj(chi,tmp);							\
+    Impl::multLink(Uchi, U[sU], chi, Dir, SE, st);			\
+    Recon(result, Uchi);						\
+  }									\
   acceleratorSynchronise();
 
 #define GENERIC_STENCIL_LEG_EXT(Dir,spProj,Recon)		\
   SE = st.GetEntry(ptype, Dir, sF);				\
-  if ((!SE->_is_local) && (!st.same_node[Dir]) ) {		\
+  if (!SE->_is_local ) {		\
     auto chi = coalescedRead(buf[SE->_offset],lane);		\
     Impl::multLink(Uchi, U[sU], chi, Dir, SE, st);		\
     Recon(result, Uchi);					\
@@ -416,19 +411,6 @@ void WilsonKernels<Impl>::DhopDirKernel( StencilImpl &st, DoubledGaugeField &U,S
 #undef LoopBody
 }
 
-#define KERNEL_CALL_TMP(A) \
-  const uint64_t    NN = Nsite*Ls;					\
-  auto U_p = & U_v[0];							\
-  auto in_p = & in_v[0];						\
-  auto out_p = & out_v[0];						\
-  auto st_p = st_v._entries_p;						\
-  auto st_perm = st_v._permute_type;					\
-  accelerator_forNB( ss, NN, Simd::Nsimd(), {				\
-      int sF = ss;							\
-      int sU = ss/Ls;							\
-      WilsonKernels<Impl>::A(st_perm,st_p,U_p,buf,sF,sU,in_p,out_p);	\
-    });									\
-  accelerator_barrier();
 
 #define KERNEL_CALLNB(A)						\
   const uint64_t    NN = Nsite*Ls;					\
@@ -448,8 +430,7 @@ void WilsonKernels<Impl>::DhopDirKernel( StencilImpl &st, DoubledGaugeField &U,S
       int sF = ptr[ss];							\
       int sU = ss/Ls;							\
       WilsonKernels<Impl>::A(st_v,U_v,buf,sF,sU,in_v,out_v);		\
-    });									\
-  accelerator_barrier();
+    });									
 
 #define ASM_CALL(A)							\
   thread_for( ss, Nsite, {						\
@@ -471,7 +452,7 @@ void WilsonKernels<Impl>::DhopKernel(int Opt,StencilImpl &st,  DoubledGaugeField
    if( interior && exterior ) {
      if (Opt == WilsonKernelsStatic::OptGeneric    ) { KERNEL_CALL(GenericDhopSite); return;}
 #ifdef SYCL_HACK     
-     if (Opt == WilsonKernelsStatic::OptHandUnroll ) { KERNEL_CALL_TMP(HandDhopSiteSycl);    return; }
+     if (Opt == WilsonKernelsStatic::OptHandUnroll ) { KERNEL_CALL(HandDhopSiteSycl);    return; }
 #else
      if (Opt == WilsonKernelsStatic::OptHandUnroll ) { KERNEL_CALL(HandDhopSite);    return;}
 #endif     
@@ -509,6 +490,7 @@ void WilsonKernels<Impl>::DhopKernel(int Opt,StencilImpl &st,  DoubledGaugeField
 #ifndef GRID_CUDA
      if (Opt == WilsonKernelsStatic::OptInlineAsm  ) {  ASM_CALL(AsmDhopSiteDag);     return;}
 #endif
+     acceleratorFenceComputeStream();
    } else if( interior ) {
      if (Opt == WilsonKernelsStatic::OptGeneric    ) { KERNEL_CALL(GenericDhopSiteDagInt); return;}
      if (Opt == WilsonKernelsStatic::OptHandUnroll ) { KERNEL_CALL(HandDhopSiteDagInt);    return;}
@@ -516,11 +498,13 @@ void WilsonKernels<Impl>::DhopKernel(int Opt,StencilImpl &st,  DoubledGaugeField
      if (Opt == WilsonKernelsStatic::OptInlineAsm  ) {  ASM_CALL(AsmDhopSiteDagInt);     return;}
 #endif
    } else if( exterior ) {
+     acceleratorFenceComputeStream();
      if (Opt == WilsonKernelsStatic::OptGeneric    ) { KERNEL_CALL(GenericDhopSiteDagExt); return;}
      if (Opt == WilsonKernelsStatic::OptHandUnroll ) { KERNEL_CALL(HandDhopSiteDagExt);    return;}
 #ifndef GRID_CUDA
      if (Opt == WilsonKernelsStatic::OptInlineAsm  ) {  ASM_CALL(AsmDhopSiteDagExt);     return;}
 #endif
+     acceleratorFenceComputeStream();
    }
    assert(0 && " Kernel optimisation case not covered ");
   }

Grid/qcd/action/fermion/instantiation/generate_instantiations.sh

@@ -9,6 +9,7 @@ STAG5_IMPL_LIST=""
 WILSON_IMPL_LIST=" \
 	   WilsonImplF \
 	   WilsonImplD \
+	   WilsonImplD2 \
 	   WilsonAdjImplF \
 	   WilsonAdjImplD \
 	   WilsonTwoIndexSymmetricImplF \
@@ -25,8 +26,9 @@ COMPACT_WILSON_IMPL_LIST=" \
 DWF_IMPL_LIST=" \
 	   WilsonImplF \
 	   WilsonImplD \
+	   WilsonImplD2 \
 	   ZWilsonImplF \
-	   ZWilsonImplD "
+	   ZWilsonImplD2 "
 
 GDWF_IMPL_LIST=" \
 	   GparityWilsonImplF \

Grid/qcd/action/filters/DDHMCFilter.h

@@ -91,6 +91,19 @@ struct DDHMCFilter: public MomentumFilterBase<GaugeField>
 	  U_mu = where(mod(coor,B1)==Integer(B1-4),zzz_mu,U_mu); 
 	  PokeIndex<LorentzIndex>(U, U_mu, mu);
 	}
+	if ( Width==4) { 
+	  U    = where(mod(coor,B1)==Integer(B1-4),zzz,U);
+	  U    = where(mod(coor,B1)==Integer(B1-3),zzz,U);
+	  U    = where(mod(coor,B1)==Integer(B1-2),zzz,U);
+	  U    = where(mod(coor,B1)==Integer(B1-1),zzz,U);
+	  U    = where(mod(coor,B1)==Integer(0)   ,zzz,U); 
+	  U    = where(mod(coor,B1)==Integer(1)   ,zzz,U); 
+	  U    = where(mod(coor,B1)==Integer(2)   ,zzz,U); 
+	  U    = where(mod(coor,B1)==Integer(3)   ,zzz,U); 
+	  auto U_mu   = PeekIndex<LorentzIndex>(U,mu);
+	  U_mu = where(mod(coor,B1)==Integer(B1-5),zzz_mu,U_mu); 
+	  PokeIndex<LorentzIndex>(U, U_mu, mu);
+	}
       }
 
     }

Grid/qcd/action/filters/MomentumFilter.h

@@ -38,6 +38,7 @@ NAMESPACE_BEGIN(Grid);
 template<typename MomentaField>
 struct MomentumFilterBase{
   virtual void applyFilter(MomentaField &P) const = 0;
+  virtual ~MomentumFilterBase(){};
 };
 
 //Do nothing
@@ -83,7 +84,6 @@ struct MomentumFilterApplyPhase: public MomentumFilterBase<MomentaField>{
     
   }
 
-
 };
 
 

Grid/qcd/action/gauge/Photon.h

@@ -49,7 +49,7 @@ NAMESPACE_BEGIN(Grid);
     
     typedef Lattice<SiteLink>  LinkField;
     typedef Lattice<SiteField> Field;
-    typedef Field              ComplexField;
+    typedef LinkField          ComplexField;
   };
   
   typedef QedGImpl<vComplex> QedGImplR;

Grid/qcd/action/pseudofermion/GeneralEvenOddRationalRatio.h

@@ -59,7 +59,7 @@ NAMESPACE_BEGIN(Grid);
 
       typedef RationalActionParams Params;
       Params param;
-
+      RealD  RefreshAction;
       //For action evaluation
       MultiShiftFunction ApproxPowerAction   ;  //rational approx for X^{1/inv_pow}
       MultiShiftFunction ApproxNegPowerAction;  //rational approx for X^{-1/inv_pow}
@@ -115,6 +115,54 @@ NAMESPACE_BEGIN(Grid);
       
     public:
 
+      // allow non-uniform tolerances 
+      void SetTolerances(std::vector<RealD> action_tolerance,std::vector<RealD> md_tolerance)
+      {
+	assert(action_tolerance.size()==ApproxPowerAction.tolerances.size());
+	assert(    md_tolerance.size()==ApproxPowerMD.tolerances.size());
+	
+	// Fix up the tolerances
+	for(int i=0;i<ApproxPowerAction.tolerances.size();i++){
+	  ApproxPowerAction.tolerances[i]       = action_tolerance[i];
+	  ApproxNegPowerAction.tolerances[i]    = action_tolerance[i];
+	  ApproxHalfPowerAction.tolerances[i]   = action_tolerance[i];
+	  ApproxNegHalfPowerAction.tolerances[i]= action_tolerance[i];
+	  ApproxPowerMD.tolerances[i]       = md_tolerance[i];
+	  ApproxNegPowerMD.tolerances[i]    = md_tolerance[i];
+	  ApproxHalfPowerMD.tolerances[i]   = md_tolerance[i];
+	  ApproxNegHalfPowerMD.tolerances[i]= md_tolerance[i];
+	}
+	
+	// Print out - could deprecate
+	for(int i=0;i<ApproxPowerMD.tolerances.size();i++) {
+	  std::cout<<GridLogMessage << " ApproxPowerMD shift["<<i<<"] "
+		   <<" pole    "<<ApproxPowerMD.poles[i]
+		   <<" residue "<<ApproxPowerMD.residues[i]
+		   <<" tol     "<<ApproxPowerMD.tolerances[i]<<std::endl;
+	}
+	/*
+	  for(int i=0;i<ApproxNegPowerMD.tolerances.size();i++) {
+	  std::cout<<GridLogMessage << " ApproxNegPowerMD shift["<<i<<"] "
+		   <<" pole    "<<ApproxNegPowerMD.poles[i]
+		   <<" residue "<<ApproxNegPowerMD.residues[i]
+		   <<" tol     "<<ApproxNegPowerMD.tolerances[i]<<std::endl;
+	}
+	for(int i=0;i<ApproxHalfPowerMD.tolerances.size();i++) {
+	  std::cout<<GridLogMessage << " ApproxHalfPowerMD shift["<<i<<"] "
+		   <<" pole    "<<ApproxHalfPowerMD.poles[i]
+		   <<" residue "<<ApproxHalfPowerMD.residues[i]
+		   <<" tol     "<<ApproxHalfPowerMD.tolerances[i]<<std::endl;
+	}
+	for(int i=0;i<ApproxNegHalfPowerMD.tolerances.size();i++) {
+	  std::cout<<GridLogMessage << " ApproxNegHalfPowerMD shift["<<i<<"] "
+		   <<" pole    "<<ApproxNegHalfPowerMD.poles[i]
+		   <<" residue "<<ApproxNegHalfPowerMD.residues[i]
+		   <<" tol     "<<ApproxNegHalfPowerMD.tolerances[i]<<std::endl;
+	}
+	*/
+	
+      }
+      
       GeneralEvenOddRatioRationalPseudoFermionAction(FermionOperator<Impl>  &_NumOp, 
 						     FermionOperator<Impl>  &_DenOp, 
 						     const Params & p
@@ -149,6 +197,11 @@ NAMESPACE_BEGIN(Grid);
 	    ApproxNegHalfPowerMD.tolerances[i] = ApproxHalfPowerMD.tolerances[i] = param.md_tolerance;
 	}
 
+	std::vector<RealD> action_tolerance(ApproxHalfPowerAction.tolerances.size(),param.action_tolerance);
+	std::vector<RealD> md_tolerance    (ApproxHalfPowerMD.tolerances.size(),param.md_tolerance);
+
+	SetTolerances(action_tolerance, md_tolerance);
+	
 	std::cout<<GridLogMessage << action_name() << " initialize: complete" << std::endl;
       };
 
@@ -217,12 +270,18 @@ NAMESPACE_BEGIN(Grid);
 	assert(NumOp.ConstEE() == 1);
 	assert(DenOp.ConstEE() == 1);
 	PhiEven = Zero();
-	std::cout<<GridLogMessage << action_name() << " refresh: starting" << std::endl;
+
+	RefreshAction = norm2( etaOdd );
+        std::cout<<GridLogMessage << action_name() << " refresh: action is " << RefreshAction << std::endl;
       };
 
       //////////////////////////////////////////////////////
       // S_f = chi^dag* P(V^dag*V)/Q(V^dag*V)* N(M^dag*M)/D(M^dag*M)* P(V^dag*V)/Q(V^dag*V)* chi       
       //////////////////////////////////////////////////////
+      virtual RealD Sinitial(const GaugeField &U) {
+	return RefreshAction;
+      }
+
       virtual RealD S(const GaugeField &U) {
 	std::cout<<GridLogMessage << action_name() << " compute action: starting" << std::endl;
 	ImportGauge(U);

Grid/qcd/action/pseudofermion/GeneralEvenOddRationalRatioMixedPrec.h

@@ -36,14 +36,18 @@ NAMESPACE_BEGIN(Grid);
     // cf. GeneralEvenOddRational.h for details
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////
       
-    template<class ImplD, class ImplF>
+    template<class ImplD, class ImplF, class ImplD2>
     class GeneralEvenOddRatioRationalMixedPrecPseudoFermionAction : public GeneralEvenOddRatioRationalPseudoFermionAction<ImplD> {
     private:
+      typedef typename ImplD2::FermionField FermionFieldD2;
       typedef typename ImplD::FermionField FermionFieldD;
       typedef typename ImplF::FermionField FermionFieldF;
 
       FermionOperator<ImplD> & NumOpD;
       FermionOperator<ImplD> & DenOpD;
+
+      FermionOperator<ImplD2> & NumOpD2;
+      FermionOperator<ImplD2> & DenOpD2;
      
       FermionOperator<ImplF> & NumOpF;
       FermionOperator<ImplF> & DenOpF;
@@ -53,37 +57,70 @@ NAMESPACE_BEGIN(Grid);
 
       //Allow derived classes to override the multishift CG
       virtual void multiShiftInverse(bool numerator, const MultiShiftFunction &approx, const Integer MaxIter, const FermionFieldD &in, FermionFieldD &out){
-	SchurDifferentiableOperator<ImplD> schurOpD(numerator ? NumOpD : DenOpD);
+#if 0
+	SchurDifferentiableOperator<ImplD> schurOp(numerator ? NumOp : DenOp);
+	ConjugateGradientMultiShift<FermionFieldD> msCG(MaxIter, approx);
+	msCG(schurOp,in, out);
+#else
+	SchurDifferentiableOperator<ImplD2> schurOpD2(numerator ? NumOpD2 : DenOpD2);
 	SchurDifferentiableOperator<ImplF> schurOpF(numerator ? NumOpF : DenOpF);
-
-	ConjugateGradientMultiShiftMixedPrec<FermionFieldD, FermionFieldF> msCG(MaxIter, approx, NumOpF.FermionRedBlackGrid(), schurOpF, ReliableUpdateFreq);
-	msCG(schurOpD, in, out);
+	FermionFieldD2 inD2(NumOpD2.FermionRedBlackGrid());
+	FermionFieldD2 outD2(NumOpD2.FermionRedBlackGrid());
+	
+	ConjugateGradientMultiShiftMixedPrec<FermionFieldD2, FermionFieldF> msCG(MaxIter, approx, NumOpF.FermionRedBlackGrid(), schurOpF, ReliableUpdateFreq);
+	precisionChange(inD2,in);
+	std::cout << "msCG single solve "<<norm2(inD2)<<" " <<norm2(in)<<std::endl;
+	msCG(schurOpD2, inD2, outD2);
+	precisionChange(out,outD2);
+#endif
       }
       virtual void multiShiftInverse(bool numerator, const MultiShiftFunction &approx, const Integer MaxIter, const FermionFieldD &in, std::vector<FermionFieldD> &out_elems, FermionFieldD &out){
-	SchurDifferentiableOperator<ImplD> schurOpD(numerator ? NumOpD : DenOpD);
+	SchurDifferentiableOperator<ImplD2> schurOpD2(numerator ? NumOpD2 : DenOpD2);
 	SchurDifferentiableOperator<ImplF> schurOpF(numerator ? NumOpF : DenOpF);
 
-	ConjugateGradientMultiShiftMixedPrec<FermionFieldD, FermionFieldF> msCG(MaxIter, approx, NumOpF.FermionRedBlackGrid(), schurOpF, ReliableUpdateFreq);
-	msCG(schurOpD, in, out_elems, out);
+	FermionFieldD2 inD2(NumOpD2.FermionRedBlackGrid());
+	FermionFieldD2 outD2(NumOpD2.FermionRedBlackGrid());
+	std::vector<FermionFieldD2> out_elemsD2(out_elems.size(),NumOpD2.FermionRedBlackGrid());
+	ConjugateGradientMultiShiftMixedPrec<FermionFieldD2, FermionFieldF> msCG(MaxIter, approx, NumOpF.FermionRedBlackGrid(), schurOpF, ReliableUpdateFreq);
+	precisionChange(inD2,in);
+	std::cout << "msCG in "<<norm2(inD2)<<" " <<norm2(in)<<std::endl;
+	msCG(schurOpD2, inD2, out_elemsD2, outD2);
+	precisionChange(out,outD2);
+	for(int i=0;i<out_elems.size();i++){
+	  precisionChange(out_elems[i],out_elemsD2[i]);
+	}
       }
       //Allow derived classes to override the gauge import
       virtual void ImportGauge(const typename ImplD::GaugeField &Ud){
+
 	typename ImplF::GaugeField Uf(NumOpF.GaugeGrid());
+	typename ImplD2::GaugeField Ud2(NumOpD2.GaugeGrid());
 	precisionChange(Uf, Ud);
+	precisionChange(Ud2, Ud);
+
+	std::cout << "Importing "<<norm2(Ud)<<" "<< norm2(Uf)<<" " << norm2(Ud2)<<std::endl;
 	
 	NumOpD.ImportGauge(Ud);
 	DenOpD.ImportGauge(Ud);
 
 	NumOpF.ImportGauge(Uf);
 	DenOpF.ImportGauge(Uf);
+
+	NumOpD2.ImportGauge(Ud2);
+	DenOpD2.ImportGauge(Ud2);
       }
       
     public:
       GeneralEvenOddRatioRationalMixedPrecPseudoFermionAction(FermionOperator<ImplD>  &_NumOpD, FermionOperator<ImplD>  &_DenOpD, 
 							      FermionOperator<ImplF>  &_NumOpF, FermionOperator<ImplF>  &_DenOpF, 
+							      FermionOperator<ImplD2>  &_NumOpD2, FermionOperator<ImplD2>  &_DenOpD2, 
 							      const RationalActionParams & p, Integer _ReliableUpdateFreq
 							      ) : GeneralEvenOddRatioRationalPseudoFermionAction<ImplD>(_NumOpD, _DenOpD, p),
-								  ReliableUpdateFreq(_ReliableUpdateFreq), NumOpD(_NumOpD), DenOpD(_DenOpD), NumOpF(_NumOpF), DenOpF(_DenOpF){}
+								  ReliableUpdateFreq(_ReliableUpdateFreq),
+								  NumOpD(_NumOpD), DenOpD(_DenOpD),
+								  NumOpF(_NumOpF), DenOpF(_DenOpF),
+								  NumOpD2(_NumOpD2), DenOpD2(_DenOpD2)
+      {}
       
       virtual std::string action_name(){return "GeneralEvenOddRatioRationalMixedPrecPseudoFermionAction";}
     };

Grid/qcd/action/pseudofermion/OneFlavourEvenOddRationalRatio.h

@@ -67,6 +67,39 @@ NAMESPACE_BEGIN(Grid);
       virtual std::string action_name(){return "OneFlavourEvenOddRatioRationalPseudoFermionAction";}      
     };
 
+    template<class Impl,class ImplF,class ImplD2>
+    class OneFlavourEvenOddRatioRationalMixedPrecPseudoFermionAction
+      : public GeneralEvenOddRatioRationalMixedPrecPseudoFermionAction<Impl,ImplF,ImplD2> {
+    public:
+      typedef OneFlavourRationalParams Params;
+    private:
+      static RationalActionParams transcribe(const Params &in){
+	RationalActionParams out;
+	out.inv_pow = 2;
+	out.lo = in.lo;
+	out.hi = in.hi;
+	out.MaxIter = in.MaxIter;
+	out.action_tolerance = out.md_tolerance = in.tolerance;
+	out.action_degree = out.md_degree = in.degree;
+	out.precision = in.precision;
+	out.BoundsCheckFreq = in.BoundsCheckFreq;
+	return out;
+      }
+
+    public:
+      OneFlavourEvenOddRatioRationalMixedPrecPseudoFermionAction(FermionOperator<Impl>  &_NumOp, 
+								 FermionOperator<Impl>  &_DenOp, 
+								 FermionOperator<ImplF>  &_NumOpF, 
+								 FermionOperator<ImplF>  &_DenOpF, 
+								 FermionOperator<ImplD2>  &_NumOpD2, 
+								 FermionOperator<ImplD2>  &_DenOpD2, 
+								 const Params & p, Integer ReliableUpdateFreq
+							) : 
+	GeneralEvenOddRatioRationalMixedPrecPseudoFermionAction<Impl,ImplF,ImplD2>(_NumOp, _DenOp,_NumOpF, _DenOpF,_NumOpD2, _DenOpD2, transcribe(p),ReliableUpdateFreq){}
+
+      virtual std::string action_name(){return "OneFlavourEvenOddRatioRationalPseudoFermionAction";}      
+    };
+
 NAMESPACE_END(Grid);
 
 #endif

Grid/qcd/action/pseudofermion/OneFlavourRationalRatio.h

@@ -85,7 +85,12 @@ NAMESPACE_BEGIN(Grid);
 	PowerNegQuarter.Init(remez,param.tolerance,true);
       };
 
-      virtual std::string action_name(){return "OneFlavourRatioRationalPseudoFermionAction";}
+      virtual std::string action_name(){
+	std::stringstream sstream;
+	sstream<<"OneFlavourRatioRationalPseudoFermionAction("
+	       <<DenOp.Mass()<<") / det("<<NumOp.Mass()<<")";
+	return sstream.str();
+      }
       
       virtual std::string LogParameters(){
 	std::stringstream sstream;

Grid/qcd/action/pseudofermion/TwoFlavourEvenOddRatio.h

@@ -50,6 +50,8 @@ NAMESPACE_BEGIN(Grid);
       FermionField PhiOdd;   // the pseudo fermion field for this trajectory
       FermionField PhiEven;  // the pseudo fermion field for this trajectory
 
+      RealD RefreshAction;
+      
     public:
       TwoFlavourEvenOddRatioPseudoFermionAction(FermionOperator<Impl>  &_NumOp, 
                                                 FermionOperator<Impl>  &_DenOp, 
@@ -132,6 +134,9 @@ NAMESPACE_BEGIN(Grid);
         // Even det factors
         DenOp.MooeeDag(etaEven,tmp);
         NumOp.MooeeInvDag(tmp,PhiEven);
+
+	RefreshAction = norm2(etaEven)+norm2(etaOdd);
+	std::cout << " refresh " <<action_name()<< " action "<<RefreshAction<<std::endl;
       };
 
       //////////////////////////////////////////////////////

Grid/qcd/hmc/HMC.h

@@ -53,6 +53,7 @@ struct HMCparameters: Serializable {
                                   Integer, Trajectories, /* @brief Number of sweeps in this run */
                                   bool, MetropolisTest,
                                   Integer, NoMetropolisUntil,
+				  bool, PerformRandomShift, /* @brief Randomly shift the gauge configuration at the start of a trajectory */
                                   std::string, StartingType,
                                   IntegratorParameters, MD)
 
@@ -63,6 +64,7 @@ struct HMCparameters: Serializable {
     StartTrajectory   = 0;
     Trajectories      = 10;
     StartingType      = "HotStart";
+    PerformRandomShift = true;
     /////////////////////////////////
   }
 
@@ -83,6 +85,7 @@ struct HMCparameters: Serializable {
     std::cout << GridLogMessage << "[HMC parameters] Start trajectory        : " << StartTrajectory << "\n";
     std::cout << GridLogMessage << "[HMC parameters] Metropolis test (on/off): " << std::boolalpha << MetropolisTest << "\n";
     std::cout << GridLogMessage << "[HMC parameters] Thermalization trajs    : " << NoMetropolisUntil << "\n";
+    std::cout << GridLogMessage << "[HMC parameters] Doing random shift      : " << std::boolalpha << PerformRandomShift << "\n";
     std::cout << GridLogMessage << "[HMC parameters] Starting type           : " << StartingType << "\n";
     MD.print_parameters();
   }
@@ -95,6 +98,7 @@ private:
   const HMCparameters Params;
 
   typedef typename IntegratorType::Field Field;
+  typedef typename IntegratorType::FieldImplementation FieldImplementation;
   typedef std::vector< HmcObservable<Field> * > ObsListType;
 
   //pass these from the resource manager
@@ -138,26 +142,37 @@ private:
 
     GridBase *Grid = U.Grid();
 
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    // Mainly for DDHMC perform a random translation of U modulo volume
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    std::cout << GridLogMessage << "--------------------------------------------------\n";
-    std::cout << GridLogMessage << "Random shifting gauge field by [";
-    for(int d=0;d<Grid->Nd();d++) {
+    if(Params.PerformRandomShift){
+      //////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Mainly for DDHMC perform a random translation of U modulo volume
+      //////////////////////////////////////////////////////////////////////////////////////////////////////
+      std::cout << GridLogMessage << "--------------------------------------------------\n";
+      std::cout << GridLogMessage << "Random shifting gauge field by [";
 
-      int L = Grid->GlobalDimensions()[d];
+      std::vector<typename FieldImplementation::GaugeLinkField> Umu(Grid->Nd(), U.Grid());
+      for(int mu=0;mu<Grid->Nd();mu++) Umu[mu] = PeekIndex<LorentzIndex>(U, mu);
 
-      RealD rn_uniform;  random(sRNG, rn_uniform);
+      for(int d=0;d<Grid->Nd();d++) {
 
-      int shift = (int) (rn_uniform*L);
+	int L = Grid->GlobalDimensions()[d];
 
-      std::cout << shift;
-      if(d<Grid->Nd()-1) std::cout <<",";
-      else               std::cout <<"]\n";
+	RealD rn_uniform;  random(sRNG, rn_uniform);
+
+	int shift = (int) (rn_uniform*L);
+
+	std::cout << shift;
+	if(d<Grid->Nd()-1) std::cout <<",";
+	else               std::cout <<"]\n";
       
-      U = Cshift(U,d,shift);
+	//shift all fields together in a way that respects the gauge BCs
+	for(int mu=0; mu < Grid->Nd(); mu++)
+	  Umu[mu] = FieldImplementation::CshiftLink(Umu[mu],d,shift);
+      }
+
+      for(int mu=0;mu<Grid->Nd();mu++) PokeIndex<LorentzIndex>(U,Umu[mu],mu);
+      
+      std::cout << GridLogMessage << "--------------------------------------------------\n";
     }
-    std::cout << GridLogMessage << "--------------------------------------------------\n";
 
     TheIntegrator.reset_timer();
     
@@ -174,7 +189,7 @@ private:
     //////////////////////////////////////////////////////////////////////////////////////////////////////
     std::cout << GridLogMessage << "--------------------------------------------------\n";
     std::cout << GridLogMessage << "Compute initial action";
-    RealD H0 = TheIntegrator.S(U);  
+    RealD H0 = TheIntegrator.Sinitial(U);  
     std::cout << GridLogMessage << "--------------------------------------------------\n";
 
     std::streamsize current_precision = std::cout.precision();

Grid/qcd/hmc/integrators/Integrator.h

@@ -63,10 +63,10 @@ public:
 };
 
 /*! @brief Class for Molecular Dynamics management */
-template <class FieldImplementation, class SmearingPolicy, class RepresentationPolicy>
+template <class FieldImplementation_, class SmearingPolicy, class RepresentationPolicy>
 class Integrator {
 protected:
-
+  typedef FieldImplementation_ FieldImplementation;
   typedef typename FieldImplementation::Field MomentaField;  //for readability
   typedef typename FieldImplementation::Field Field;
 
@@ -143,9 +143,10 @@ protected:
       force = FieldImplementation::projectForce(force); // Ta for gauge fields
       double end_force = usecond();
 
+      //      DumpSliceNorm("force ",force,Nd-1);
       MomFilter->applyFilter(force);
-      std::cout << GridLogIntegrator << " update_P : Level [" << level <<"]["<<a <<"] "<<name<< std::endl;
-      DumpSliceNorm("force ",force,Nd-1);
+      std::cout << GridLogIntegrator << " update_P : Level [" << level <<"]["<<a <<"] "<<name<<" dt "<<ep<<  std::endl;
+      DumpSliceNorm("force filtered ",force,Nd-1);
       
       Real force_abs   = std::sqrt(norm2(force)/U.Grid()->gSites()); //average per-site norm.  nb. norm2(latt) = \sum_x norm2(latt[x]) 
       Real impulse_abs = force_abs * ep * HMC_MOMENTUM_DENOMINATOR;    
@@ -153,8 +154,9 @@ protected:
       Real force_max   = std::sqrt(maxLocalNorm2(force));
       Real impulse_max = force_max * ep * HMC_MOMENTUM_DENOMINATOR;    
 
-      as[level].actions.at(a)->deriv_log(force_abs,force_max);
+      as[level].actions.at(a)->deriv_log(force_abs,force_max,impulse_abs,impulse_max);
       
+      std::cout << GridLogIntegrator<< "["<<level<<"]["<<a<<"] dt           : " << ep <<" "<<name<<std::endl;
       std::cout << GridLogIntegrator<< "["<<level<<"]["<<a<<"] Force average: " << force_abs <<" "<<name<<std::endl;
       std::cout << GridLogIntegrator<< "["<<level<<"]["<<a<<"] Force max    : " << force_max <<" "<<name<<std::endl;
       std::cout << GridLogIntegrator<< "["<<level<<"]["<<a<<"] Fdt average  : " << impulse_abs <<" "<<name<<std::endl;
@@ -285,6 +287,8 @@ public:
 		  <<"["<<level<<"]["<< actionID<<"] : "
 		  <<" force max " << as[level].actions.at(actionID)->deriv_max_average()
 		  <<" norm "      << as[level].actions.at(actionID)->deriv_norm_average()
+		  <<" Fdt max  "  << as[level].actions.at(actionID)->Fdt_max_average()
+		  <<" Fdt norm "  << as[level].actions.at(actionID)->Fdt_norm_average()
 		  <<" calls "     << as[level].actions.at(actionID)->deriv_num
 		  << std::endl;
       }
@@ -415,6 +419,48 @@ public:
     return H;
   }
 
+  struct _Sinitial {
+    template <class FieldType, class Repr>
+    void operator()(std::vector<Action<FieldType>*> repr_set, Repr& Rep, int level, RealD& H) {
+      
+      for (int a = 0; a < repr_set.size(); ++a) {
+        RealD Hterm = repr_set.at(a)->Sinitial(Rep.U);
+        std::cout << GridLogMessage << "Sinitial Level " << level << " term " << a << " H Hirep = " << Hterm << std::endl;
+        H += Hterm;
+
+      }
+    }
+  } Sinitial_hireps{};
+
+  RealD Sinitial(Field& U) 
+  {  // here also U not used
+
+    std::cout << GridLogIntegrator << "Integrator initial action\n";
+
+    RealD H = - FieldImplementation::FieldSquareNorm(P)/HMC_MOMENTUM_DENOMINATOR; // - trace (P*P)/denom
+
+    RealD Hterm;
+
+    // Actions
+    for (int level = 0; level < as.size(); ++level) {
+      for (int actionID = 0; actionID < as[level].actions.size(); ++actionID) {
+        // get gauge field from the SmearingPolicy and
+        // based on the boolean is_smeared in actionID
+        Field& Us = Smearer.get_U(as[level].actions.at(actionID)->is_smeared);
+        std::cout << GridLogMessage << "S [" << level << "][" << actionID << "] action eval " << std::endl;
+	        as[level].actions.at(actionID)->S_timer_start();
+        Hterm = as[level].actions.at(actionID)->Sinitial(Us);
+   	        as[level].actions.at(actionID)->S_timer_stop();
+        std::cout << GridLogMessage << "S [" << level << "][" << actionID << "] H = " << Hterm << std::endl;
+        H += Hterm;
+      }
+      as[level].apply(Sinitial_hireps, Representations, level, H);
+    }
+
+    return H;
+  }
+
+  
   void integrate(Field& U) 
   {
     // reset the clocks

Grid/qcd/hmc/integrators/Integrator_algorithm.h

@@ -92,10 +92,11 @@ NAMESPACE_BEGIN(Grid);
  *  P 1/2                            P 1/2
  */
 
-template <class FieldImplementation, class SmearingPolicy, class RepresentationPolicy = Representations<FundamentalRepresentation> >
-class LeapFrog : public Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy> 
+template <class FieldImplementation_, class SmearingPolicy, class RepresentationPolicy = Representations<FundamentalRepresentation> >
+class LeapFrog : public Integrator<FieldImplementation_, SmearingPolicy, RepresentationPolicy> 
 {
 public:
+  typedef FieldImplementation_ FieldImplementation;
   typedef LeapFrog<FieldImplementation, SmearingPolicy, RepresentationPolicy> Algorithm;
   INHERIT_FIELD_TYPES(FieldImplementation);
 
@@ -135,13 +136,14 @@ public:
   }
 };
 
-template <class FieldImplementation, class SmearingPolicy, class RepresentationPolicy = Representations<FundamentalRepresentation> >
-class MinimumNorm2 : public Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy> 
+template <class FieldImplementation_, class SmearingPolicy, class RepresentationPolicy = Representations<FundamentalRepresentation> >
+class MinimumNorm2 : public Integrator<FieldImplementation_, SmearingPolicy, RepresentationPolicy> 
 {
 private:
   const RealD lambda = 0.1931833275037836;
 
 public:
+  typedef FieldImplementation_ FieldImplementation;
   INHERIT_FIELD_TYPES(FieldImplementation);
 
   MinimumNorm2(GridBase* grid, IntegratorParameters Par, ActionSet<Field, RepresentationPolicy>& Aset, SmearingPolicy& Sm)
@@ -192,8 +194,8 @@ public:
   }
 };
 
-template <class FieldImplementation, class SmearingPolicy, class RepresentationPolicy = Representations<FundamentalRepresentation> >
-class ForceGradient : public Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy> 
+template <class FieldImplementation_, class SmearingPolicy, class RepresentationPolicy = Representations<FundamentalRepresentation> >
+class ForceGradient : public Integrator<FieldImplementation_, SmearingPolicy, RepresentationPolicy> 
 {
 private:
   const RealD lambda = 1.0 / 6.0;
@@ -202,6 +204,7 @@ private:
   const RealD theta = 0.0;
 
 public:
+  typedef FieldImplementation_ FieldImplementation;
   INHERIT_FIELD_TYPES(FieldImplementation);
 
   // Looks like dH scales as dt^4. tested wilson/wilson 2 level.
@@ -227,7 +230,8 @@ public:
     // Presently 4 force evals, and should have 3, so 1.33x too expensive.
     // could reduce this with sloppy CG to perhaps 1.15x too expensive
     // even without prediction.
-    this->update_P(Pfg, Ufg, level, 1.0);
+    this->update_P(Pfg, Ufg, level, fg_dt);
+    Pfg = Pfg*(1.0/fg_dt);
     this->update_U(Pfg, Ufg, fg_dt);
     this->update_P(Ufg, level, ep);
   }

Grid/qcd/observables/topological_charge.h

@@ -31,15 +31,16 @@ directory
 
 NAMESPACE_BEGIN(Grid);
 
+
 struct TopologySmearingParameters : Serializable {
   GRID_SERIALIZABLE_CLASS_MEMBERS(TopologySmearingParameters,
-				  int, steps,
-				  float, step_size,
 				  int, meas_interval,
-				  float, maxTau);
+				  float, init_step_size,
+				  float, maxTau,
+				  float, tolerance);
 
-  TopologySmearingParameters(int s = 0, float ss = 0.0f, int mi = 0, float mT = 0.0f):
-    steps(s), step_size(ss), meas_interval(mi), maxTau(mT){}
+ TopologySmearingParameters(float ss = 0.0f, int mi = 0, float mT = 0.0f, float tol = 1e-4):
+  init_step_size(ss), meas_interval(mi), maxTau(mT), tolerance(tol){}
 
   template < class ReaderClass >
   TopologySmearingParameters(Reader<ReaderClass>& Reader){
@@ -97,8 +98,8 @@ public:
         
       if (Pars.do_smearing){
 	// using wilson flow by default here
-	WilsonFlow<PeriodicGimplR> WF(Pars.Smearing.steps, Pars.Smearing.step_size, Pars.Smearing.meas_interval);
-	WF.smear_adaptive(Usmear, U, Pars.Smearing.maxTau);
+	WilsonFlowAdaptive<PeriodicGimplR> WF(Pars.Smearing.init_step_size, Pars.Smearing.maxTau, Pars.Smearing.tolerance, Pars.Smearing.meas_interval);
+	WF.smear(Usmear, U);
 	Real T0   = WF.energyDensityPlaquette(Pars.Smearing.maxTau, Usmear);
 	std::cout << GridLogMessage << std::setprecision(std::numeric_limits<Real>::digits10 + 1)
 		  << "T0                : [ " << traj << " ] "<< T0 << std::endl;

Grid/qcd/smearing/WilsonFlow.h

@@ -33,27 +33,25 @@ directory
 NAMESPACE_BEGIN(Grid);
 
 template <class Gimpl>
-class WilsonFlow: public Smear<Gimpl>{
+class WilsonFlowBase: public Smear<Gimpl>{
 public:
   //Store generic measurements to take during smearing process using std::function
   typedef std::function<void(int, RealD, const typename Gimpl::GaugeField &)> FunctionType;  //int: step,  RealD: flow time,  GaugeField : the gauge field
-  
-private:
-  unsigned int Nstep;
-  RealD epsilon; //for regular smearing this is the time step, for adaptive it is the initial time step
- 
+
+protected:
   std::vector< std::pair<int, FunctionType> > functions; //The int maps to the measurement frequency
 
   mutable WilsonGaugeAction<Gimpl> SG;
-
-  //Evolve the gauge field by 1 step and update tau
-  void evolve_step(typename Gimpl::GaugeField &U, RealD &tau) const;
-  //Evolve the gauge field by 1 step and update tau and the current time step eps
-  void evolve_step_adaptive(typename Gimpl::GaugeField&U, RealD &tau, RealD &eps, RealD maxTau) const;
-
+   
 public:
   INHERIT_GIMPL_TYPES(Gimpl)
 
+  explicit WilsonFlowBase(unsigned int meas_interval =1):
+    SG(WilsonGaugeAction<Gimpl>(3.0)) {
+    // WilsonGaugeAction with beta 3.0
+    setDefaultMeasurements(meas_interval);
+  }
+    
   void resetActions(){ functions.clear(); }
 
   void addMeasurement(int meas_interval, FunctionType meas){ functions.push_back({meas_interval, meas}); }
@@ -64,34 +62,11 @@ public:
   //and output to stdout
   void setDefaultMeasurements(int topq_meas_interval = 1);
 
-  explicit WilsonFlow(unsigned int Nstep, RealD epsilon, unsigned int interval = 1):
-  Nstep(Nstep),
-    epsilon(epsilon),
-    SG(WilsonGaugeAction<Gimpl>(3.0)) {
-    // WilsonGaugeAction with beta 3.0
-    assert(epsilon > 0.0);
-    LogMessage();
-    setDefaultMeasurements(interval);
-  }
-
-  void LogMessage() {
-    std::cout << GridLogMessage
-	      << "[WilsonFlow] Nstep   : " << Nstep << std::endl;
-    std::cout << GridLogMessage
-	      << "[WilsonFlow] epsilon : " << epsilon << std::endl;
-    std::cout << GridLogMessage
-	      << "[WilsonFlow] full trajectory : " << Nstep * epsilon << std::endl;
-  }
-
-  virtual void smear(GaugeField&, const GaugeField&) const;
-
-  virtual void derivative(GaugeField&, const GaugeField&, const GaugeField&) const {
+  void derivative(GaugeField&, const GaugeField&, const GaugeField&) const override{
     assert(0);
     // undefined for WilsonFlow
   }
 
-  void smear_adaptive(GaugeField&, const GaugeField&, RealD maxTau) const;
-
   //Compute t^2 <E(t)> for time t from the plaquette
   static RealD energyDensityPlaquette(const RealD t, const GaugeField& U);
 
@@ -115,82 +90,63 @@ public:
   std::vector<RealD> flowMeasureEnergyDensityCloverleaf(const GaugeField& U, int measure_interval = 1);
 };
 
+//Basic iterative Wilson flow
+template <class Gimpl>
+class WilsonFlow: public WilsonFlowBase<Gimpl>{
+private:
+  int Nstep; //number of steps
+  RealD epsilon;  //step size
+
+  //Evolve the gauge field by 1 step of size eps and update tau
+  void evolve_step(typename Gimpl::GaugeField &U, RealD &tau) const;
+
+public:
+  INHERIT_GIMPL_TYPES(Gimpl)
+
+  //Integrate the Wilson flow for Nstep steps of size epsilon
+  WilsonFlow(const RealD epsilon, const int Nstep, unsigned int meas_interval = 1): WilsonFlowBase<Gimpl>(meas_interval), Nstep(Nstep), epsilon(epsilon){}
+
+  void smear(GaugeField& out, const GaugeField& in) const override;
+};
+
+//Wilson flow with adaptive step size
+template <class Gimpl>
+class WilsonFlowAdaptive: public WilsonFlowBase<Gimpl>{
+private:
+  RealD init_epsilon; //initial step size
+  RealD maxTau; //integrate to t=maxTau
+  RealD tolerance; //integration error tolerance
+
+  //Evolve the gauge field by 1 step and update tau and the current time step eps
+  //
+  //If the step size eps is too large that a significant integration error results,
+  //the gauge field (U) and tau will not be updated and the function will return 0; eps will be adjusted to a smaller
+  //value for the next iteration.
+  //
+  //For a successful integration step the function will return 1
+  int evolve_step_adaptive(typename Gimpl::GaugeField&U, RealD &tau, RealD &eps) const;
+
+public:
+  INHERIT_GIMPL_TYPES(Gimpl)
+
+  WilsonFlowAdaptive(const RealD init_epsilon, const RealD maxTau, const RealD tolerance, unsigned int meas_interval = 1): 
+  WilsonFlowBase<Gimpl>(meas_interval), init_epsilon(init_epsilon), maxTau(maxTau), tolerance(tolerance){}
+
+  void smear(GaugeField& out, const GaugeField& in) const override;
+};
 
 ////////////////////////////////////////////////////////////////////////////////
 // Implementations
 ////////////////////////////////////////////////////////////////////////////////
 template <class Gimpl>
-void WilsonFlow<Gimpl>::evolve_step(typename Gimpl::GaugeField &U, RealD &tau) const{
-  GaugeField Z(U.Grid());
-  GaugeField tmp(U.Grid());
-  SG.deriv(U, Z);
-  Z *= 0.25;                                  // Z0 = 1/4 * F(U)
-  Gimpl::update_field(Z, U, -2.0*epsilon);    // U = W1 = exp(ep*Z0)*W0
-
-  Z *= -17.0/8.0;
-  SG.deriv(U, tmp); Z += tmp;                 // -17/32*Z0 +Z1
-  Z *= 8.0/9.0;                               // Z = -17/36*Z0 +8/9*Z1
-  Gimpl::update_field(Z, U, -2.0*epsilon);    // U_= W2 = exp(ep*Z)*W1
-
-  Z *= -4.0/3.0;
-  SG.deriv(U, tmp); Z += tmp;                 // 4/3*(17/36*Z0 -8/9*Z1) +Z2
-  Z *= 3.0/4.0;                               // Z = 17/36*Z0 -8/9*Z1 +3/4*Z2
-  Gimpl::update_field(Z, U, -2.0*epsilon);    // V(t+e) = exp(ep*Z)*W2
-  tau += epsilon;
-}
-
-template <class Gimpl>
-void WilsonFlow<Gimpl>::evolve_step_adaptive(typename Gimpl::GaugeField &U, RealD &tau, RealD &eps, RealD maxTau) const{
-  if (maxTau - tau < eps){
-    eps = maxTau-tau;
-  }
-  //std::cout << GridLogMessage << "Integration epsilon : " << epsilon << std::endl;
-  GaugeField Z(U.Grid());
-  GaugeField Zprime(U.Grid());
-  GaugeField tmp(U.Grid()), Uprime(U.Grid());
-  Uprime = U;
-  SG.deriv(U, Z);
-  Zprime = -Z;
-  Z *= 0.25;                                  // Z0 = 1/4 * F(U)
-  Gimpl::update_field(Z, U, -2.0*eps);    // U = W1 = exp(ep*Z0)*W0
-
-  Z *= -17.0/8.0;
-  SG.deriv(U, tmp); Z += tmp;                 // -17/32*Z0 +Z1
-  Zprime += 2.0*tmp;
-  Z *= 8.0/9.0;                               // Z = -17/36*Z0 +8/9*Z1
-  Gimpl::update_field(Z, U, -2.0*eps);    // U_= W2 = exp(ep*Z)*W1
-    
-
-  Z *= -4.0/3.0;
-  SG.deriv(U, tmp); Z += tmp;                 // 4/3*(17/36*Z0 -8/9*Z1) +Z2
-  Z *= 3.0/4.0;                               // Z = 17/36*Z0 -8/9*Z1 +3/4*Z2
-  Gimpl::update_field(Z, U, -2.0*eps);    // V(t+e) = exp(ep*Z)*W2
-
-  // Ramos 
-  Gimpl::update_field(Zprime, Uprime, -2.0*eps); // V'(t+e) = exp(ep*Z')*W0
-  // Compute distance as norm^2 of the difference
-  GaugeField diffU = U - Uprime;
-  RealD diff = norm2(diffU);
-  // adjust integration step
-    
-  tau += eps;
-  //std::cout << GridLogMessage << "Adjusting integration step with distance: " << diff << std::endl;
-    
-  eps = eps*0.95*std::pow(1e-4/diff,1./3.);
-  //std::cout << GridLogMessage << "New epsilon : " << epsilon << std::endl;
-
-}
-
-
-template <class Gimpl>
-RealD WilsonFlow<Gimpl>::energyDensityPlaquette(const RealD t, const GaugeField& U){
+RealD WilsonFlowBase<Gimpl>::energyDensityPlaquette(const RealD t, const GaugeField& U){
   static WilsonGaugeAction<Gimpl> SG(3.0);
   return 2.0 * t * t * SG.S(U)/U.Grid()->gSites();
 }
 
 //Compute t^2 <E(t)> for time from the 1x1 cloverleaf form
 template <class Gimpl>
-RealD WilsonFlow<Gimpl>::energyDensityCloverleaf(const RealD t, const GaugeField& U){
+RealD WilsonFlowBase<Gimpl>::energyDensityCloverleaf(const RealD t, const GaugeField& U){
   typedef typename Gimpl::GaugeLinkField GaugeMat;
   typedef typename Gimpl::GaugeField GaugeLorentz;
 
@@ -215,7 +171,7 @@ RealD WilsonFlow<Gimpl>::energyDensityCloverleaf(const RealD t, const GaugeField
 
 
 template <class Gimpl>
-std::vector<RealD> WilsonFlow<Gimpl>::flowMeasureEnergyDensityPlaquette(GaugeField &V, const GaugeField& U, int measure_interval){
+std::vector<RealD> WilsonFlowBase<Gimpl>::flowMeasureEnergyDensityPlaquette(GaugeField &V, const GaugeField& U, int measure_interval){
   std::vector<RealD> out;
   resetActions();
   addMeasurement(measure_interval, [&out](int step, RealD t, const typename Gimpl::GaugeField &U){ 
@@ -227,13 +183,13 @@ std::vector<RealD> WilsonFlow<Gimpl>::flowMeasureEnergyDensityPlaquette(GaugeFie
 }
 
 template <class Gimpl>
-std::vector<RealD> WilsonFlow<Gimpl>::flowMeasureEnergyDensityPlaquette(const GaugeField& U, int measure_interval){
+std::vector<RealD> WilsonFlowBase<Gimpl>::flowMeasureEnergyDensityPlaquette(const GaugeField& U, int measure_interval){
   GaugeField V(U);
   return flowMeasureEnergyDensityPlaquette(V,U, measure_interval);
 }
 
 template <class Gimpl>
-std::vector<RealD> WilsonFlow<Gimpl>::flowMeasureEnergyDensityCloverleaf(GaugeField &V, const GaugeField& U, int measure_interval){
+std::vector<RealD> WilsonFlowBase<Gimpl>::flowMeasureEnergyDensityCloverleaf(GaugeField &V, const GaugeField& U, int measure_interval){
   std::vector<RealD> out;
   resetActions();
   addMeasurement(measure_interval, [&out](int step, RealD t, const typename Gimpl::GaugeField &U){ 
@@ -245,16 +201,52 @@ std::vector<RealD> WilsonFlow<Gimpl>::flowMeasureEnergyDensityCloverleaf(GaugeFi
 }
 
 template <class Gimpl>
-std::vector<RealD> WilsonFlow<Gimpl>::flowMeasureEnergyDensityCloverleaf(const GaugeField& U, int measure_interval){
+std::vector<RealD> WilsonFlowBase<Gimpl>::flowMeasureEnergyDensityCloverleaf(const GaugeField& U, int measure_interval){
   GaugeField V(U);
   return flowMeasureEnergyDensityCloverleaf(V,U, measure_interval);
 }
 
+template <class Gimpl>
+void WilsonFlowBase<Gimpl>::setDefaultMeasurements(int topq_meas_interval){
+  addMeasurement(1, [](int step, RealD t, const typename Gimpl::GaugeField &U){
+      std::cout << GridLogMessage << "[WilsonFlow] Energy density (plaq) : "  << step << "  " << t << "  " << energyDensityPlaquette(t,U) << std::endl;
+    });
+  addMeasurement(topq_meas_interval, [](int step, RealD t, const typename Gimpl::GaugeField &U){
+      std::cout << GridLogMessage << "[WilsonFlow] Top. charge           : "  << step << "  " << WilsonLoops<Gimpl>::TopologicalCharge(U) << std::endl;
+    });
+}
 
 
-//#define WF_TIMING 
+
+template <class Gimpl>
+void WilsonFlow<Gimpl>::evolve_step(typename Gimpl::GaugeField &U, RealD &tau) const{
+  GaugeField Z(U.Grid());
+  GaugeField tmp(U.Grid());
+  this->SG.deriv(U, Z);
+  Z *= 0.25;                                  // Z0 = 1/4 * F(U)
+  Gimpl::update_field(Z, U, -2.0*epsilon);    // U = W1 = exp(ep*Z0)*W0
+
+  Z *= -17.0/8.0;
+  this->SG.deriv(U, tmp); Z += tmp;                 // -17/32*Z0 +Z1
+  Z *= 8.0/9.0;                               // Z = -17/36*Z0 +8/9*Z1
+  Gimpl::update_field(Z, U, -2.0*epsilon);    // U_= W2 = exp(ep*Z)*W1
+
+  Z *= -4.0/3.0;
+  this->SG.deriv(U, tmp); Z += tmp;                 // 4/3*(17/36*Z0 -8/9*Z1) +Z2
+  Z *= 3.0/4.0;                               // Z = 17/36*Z0 -8/9*Z1 +3/4*Z2
+  Gimpl::update_field(Z, U, -2.0*epsilon);    // V(t+e) = exp(ep*Z)*W2
+  tau += epsilon;
+}
+
 template <class Gimpl>
 void WilsonFlow<Gimpl>::smear(GaugeField& out, const GaugeField& in) const{
+  std::cout << GridLogMessage
+	    << "[WilsonFlow] Nstep   : " << Nstep << std::endl;
+  std::cout << GridLogMessage
+	    << "[WilsonFlow] epsilon : " << epsilon << std::endl;
+  std::cout << GridLogMessage
+	    << "[WilsonFlow] full trajectory : " << Nstep * epsilon << std::endl;
+
   out = in;
   RealD taus = 0.;
   for (unsigned int step = 1; step <= Nstep; step++) { //step indicates the number of smearing steps applied at the time of measurement
@@ -266,37 +258,93 @@ void WilsonFlow<Gimpl>::smear(GaugeField& out, const GaugeField& in) const{
     std::cout << "Time to evolve " << diff.count() << " s\n";
 #endif
     //Perform measurements
-    for(auto const &meas : functions)
+    for(auto const &meas : this->functions)
       if( step % meas.first == 0 ) meas.second(step,taus,out);
   }
 }
 
+
+
 template <class Gimpl>
-void WilsonFlow<Gimpl>::smear_adaptive(GaugeField& out, const GaugeField& in, RealD maxTau) const{
-  out = in;
-  RealD taus = 0.;
-  RealD eps = epsilon;
-  unsigned int step = 0;
-  do{
-    step++;
-    //std::cout << GridLogMessage << "Evolution time :"<< taus << std::endl;
-    evolve_step_adaptive(out, taus, eps, maxTau);
-    //Perform measurements
-    for(auto const &meas : functions)
-      if( step % meas.first == 0 ) meas.second(step,taus,out);
-  } while (taus < maxTau);
+int WilsonFlowAdaptive<Gimpl>::evolve_step_adaptive(typename Gimpl::GaugeField &U, RealD &tau, RealD &eps) const{
+  if (maxTau - tau < eps){
+    eps = maxTau-tau;
+  }
+  //std::cout << GridLogMessage << "Integration epsilon : " << epsilon << std::endl;
+  GaugeField Z(U.Grid());
+  GaugeField Zprime(U.Grid());
+  GaugeField tmp(U.Grid()), Uprime(U.Grid()), Usave(U.Grid());
+  Uprime = U;
+  Usave = U;
+
+  this->SG.deriv(U, Z);
+  Zprime = -Z;
+  Z *= 0.25;                                  // Z0 = 1/4 * F(U)
+  Gimpl::update_field(Z, U, -2.0*eps);    // U = W1 = exp(ep*Z0)*W0
+
+  Z *= -17.0/8.0;
+  this->SG.deriv(U, tmp); Z += tmp;                 // -17/32*Z0 +Z1
+  Zprime += 2.0*tmp;
+  Z *= 8.0/9.0;                               // Z = -17/36*Z0 +8/9*Z1
+  Gimpl::update_field(Z, U, -2.0*eps);    // U_= W2 = exp(ep*Z)*W1
+    
+
+  Z *= -4.0/3.0;
+  this->SG.deriv(U, tmp); Z += tmp;                 // 4/3*(17/36*Z0 -8/9*Z1) +Z2
+  Z *= 3.0/4.0;                               // Z = 17/36*Z0 -8/9*Z1 +3/4*Z2
+  Gimpl::update_field(Z, U, -2.0*eps);    // V(t+e) = exp(ep*Z)*W2
+
+  // Ramos arXiv:1301.4388
+  Gimpl::update_field(Zprime, Uprime, -2.0*eps); // V'(t+e) = exp(ep*Z')*W0
+
+  // Compute distance using Ramos' definition
+  GaugeField diffU = U - Uprime;
+  RealD max_dist = 0;
+
+  for(int mu=0;mu<Nd;mu++){
+    typename Gimpl::GaugeLinkField diffU_mu = PeekIndex<LorentzIndex>(diffU, mu);
+    RealD dist_mu = sqrt( maxLocalNorm2(diffU_mu) ) /Nc/Nc; //maximize over sites
+    max_dist = std::max(max_dist, dist_mu); //maximize over mu
+  }
+  
+  int ret;
+  if(max_dist < tolerance) {
+    tau += eps;
+    ret = 1;
+  } else {
+    U = Usave;
+    ret = 0;
+  }
+  eps = eps*0.95*std::pow(tolerance/max_dist,1./3.);
+  std::cout << GridLogMessage << "Adaptive smearing : Distance: "<< max_dist <<" Step successful: " << ret << " New epsilon: " << eps << std::endl; 
+
+  return ret;
 }
 
 template <class Gimpl>
-void WilsonFlow<Gimpl>::setDefaultMeasurements(int topq_meas_interval){
-  addMeasurement(1, [](int step, RealD t, const typename Gimpl::GaugeField &U){
-      std::cout << GridLogMessage << "[WilsonFlow] Energy density (plaq) : "  << step << "  " << t << "  " << energyDensityPlaquette(t,U) << std::endl;
-    });
-  addMeasurement(topq_meas_interval, [](int step, RealD t, const typename Gimpl::GaugeField &U){
-      std::cout << GridLogMessage << "[WilsonFlow] Top. charge           : "  << step << "  " << WilsonLoops<Gimpl>::TopologicalCharge(U) << std::endl;
-    });
+void WilsonFlowAdaptive<Gimpl>::smear(GaugeField& out, const GaugeField& in) const{
+  std::cout << GridLogMessage
+	    << "[WilsonFlow] initial epsilon : " << init_epsilon << std::endl;
+  std::cout << GridLogMessage
+	    << "[WilsonFlow] full trajectory : " << maxTau << std::endl;
+  std::cout << GridLogMessage
+	    << "[WilsonFlow] tolerance   : " << tolerance << std::endl;
+  out = in;
+  RealD taus = 0.;
+  RealD eps = init_epsilon;
+  unsigned int step = 0;
+  do{
+    int step_success = evolve_step_adaptive(out, taus, eps); 
+    step += step_success; //step will not be incremented if the integration step fails
+
+    //Perform measurements
+    if(step_success)
+      for(auto const &meas : this->functions)
+	if( step % meas.first == 0 ) meas.second(step,taus,out);
+  } while (taus < maxTau);
 }
 
 
+
 NAMESPACE_END(Grid);
 

Grid/qcd/utils/CovariantCshift.h

@@ -227,26 +227,38 @@ namespace ConjugateBC {
   //shift = -1
   //Out(x) = U_\mu(x-mu)  | x_\mu != 0
   //       = U*_\mu(L-1)  | x_\mu == 0
+  //shift = 2
+  //Out(x) = U_\mu(x+2\hat\mu)  | x_\mu < L-2
+  //       = U*_\mu(1)  | x_\mu == L-1
+  //       = U*_\mu(0)  | x_\mu == L-2
+  //shift = -2
+  //Out(x) = U_\mu(x-2mu)  | x_\mu > 1
+  //       = U*_\mu(L-2)  | x_\mu == 0
+  //       = U*_\mu(L-1)  | x_\mu == 1
+  //etc
   template<class gauge> Lattice<gauge>
   CshiftLink(const Lattice<gauge> &Link, int mu, int shift)
   {
     GridBase *grid = Link.Grid();
-    int Lmu = grid->GlobalDimensions()[mu] - 1;
+    int Lmu = grid->GlobalDimensions()[mu];
+    assert(abs(shift) < Lmu && "Invalid shift value");
 
     Lattice<iScalar<vInteger>> coor(grid);
     LatticeCoordinate(coor, mu);
 
     Lattice<gauge> tmp(grid);
-    if(shift == 1){
-      tmp = Cshift(Link, mu, 1);
-      tmp = where(coor == Lmu, conjugate(tmp), tmp);
+    if(shift > 0){
+      tmp = Cshift(Link, mu, shift);
+      tmp = where(coor >= Lmu-shift, conjugate(tmp), tmp);
       return tmp;
-    }else if(shift == -1){
+    }else if(shift < 0){
       tmp = Link;
-      tmp = where(coor == Lmu, conjugate(tmp), tmp);
-      return Cshift(tmp, mu, -1);
-    }else assert(0 && "Invalid shift value");
-    return tmp; //shuts up the compiler fussing about the return type
+      tmp = where(coor >= Lmu+shift, conjugate(tmp), tmp);
+      return Cshift(tmp, mu, shift);
+    }
+    
+    //shift == 0
+    return Link;
   }
 
 }

Grid/qcd/utils/GaugeFix.h

@@ -72,12 +72,12 @@ public:
 
   //Fix the gauge field Umu
   //0 < alpha < 1 is related to the step size, cf https://arxiv.org/pdf/1405.5812.pdf
-  static void SteepestDescentGaugeFix(GaugeLorentz &Umu,Real & alpha,int maxiter,Real Omega_tol, Real Phi_tol,bool Fourier=false,int orthog=-1,bool err_on_no_converge=true) {
+  static void SteepestDescentGaugeFix(GaugeLorentz &Umu,Real alpha,int maxiter,Real Omega_tol, Real Phi_tol,bool Fourier=false,int orthog=-1,bool err_on_no_converge=true) {
     GridBase *grid = Umu.Grid();
     GaugeMat xform(grid);
     SteepestDescentGaugeFix(Umu,xform,alpha,maxiter,Omega_tol,Phi_tol,Fourier,orthog,err_on_no_converge);
   }
-  static void SteepestDescentGaugeFix(GaugeLorentz &Umu,GaugeMat &xform,Real & alpha,int maxiter,Real Omega_tol, Real Phi_tol,bool Fourier=false,int orthog=-1,bool err_on_no_converge=true) {
+  static void SteepestDescentGaugeFix(GaugeLorentz &Umu,GaugeMat &xform,Real alpha,int maxiter,Real Omega_tol, Real Phi_tol,bool Fourier=false,int orthog=-1,bool err_on_no_converge=true) {
   //Fix the gauge field Umu and also return the gauge transformation from the original gauge field, xform
 
     GridBase *grid = Umu.Grid();

Grid/qcd/utils/SUn.h

@@ -615,7 +615,6 @@ public:
     GridBase *grid = out.Grid();
 
     typedef typename LatticeMatrixType::vector_type vector_type;
-    typedef typename LatticeMatrixType::scalar_type scalar_type;
 
     typedef iSinglet<vector_type> vTComplexType;
 

Grid/serialisation/JSON_IO.cc

@@ -26,7 +26,7 @@
     *************************************************************************************/
     /*  END LEGAL */
 #include <Grid/Grid.h>
-#if (!defined(GRID_CUDA)) && (!defined(GRID_HIP))
+#ifndef GRID_HIP
 
 NAMESPACE_BEGIN(Grid);
 
@@ -82,7 +82,7 @@ void JSONWriter::writeDefault(const std::string &s,	const std::string &x)
   if (s.size())
     ss_ << "\""<< s << "\" : \"" << os.str() << "\" ," ;
   else
-    ss_ << os.str() << " ," ;
+    ss_ << "\""<< os.str() << "\" ," ;
 }
 
 // Reader implementation ///////////////////////////////////////////////////////

Grid/serialisation/JSON_IO.h

@@ -54,7 +54,7 @@ namespace Grid
     void pop(void);
     template <typename U>
     void writeDefault(const std::string &s, const U &x);
-#ifdef __NVCC__
+#if defined(GRID_CUDA) || defined(GRID_HIP)
     void writeDefault(const std::string &s, const Grid::ComplexD &x) 
     { 
       std::complex<double> z(real(x),imag(x));
@@ -101,7 +101,7 @@ namespace Grid
     void readDefault(const std::string &s, std::vector<U> &output);
     template <typename U, typename P>
     void readDefault(const std::string &s, std::pair<U,P> &output);
-#ifdef __NVCC__
+#if defined(GRID_CUDA) || defined(GRID_HIP)
     void readDefault(const std::string &s, ComplexD &output)
     { 
       std::complex<double> z;

Grid/serialisation/Serialisation.h

@@ -36,7 +36,7 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 #include "BinaryIO.h"
 #include "TextIO.h"
 #include "XmlIO.h"
-#if (!defined(GRID_CUDA)) && (!defined(GRID_HIP))
+#ifndef GRID_HIP
 #include "JSON_IO.h"
 #endif
 

Grid/simd/Grid_a64fx-2.h

@@ -501,7 +501,7 @@ struct Conj{
 struct TimesMinusI{
   // Complex
   template <typename T>
-  inline vec<T> operator()(vec<T> a, vec<T> b){
+  inline vec<T> operator()(vec<T> a){
     vec<T> out;
     const vec<typename acle<T>::uint> tbl_swap = acle<T>::tbl_swap();
     svbool_t pg1 = acle<T>::pg1();
@@ -520,7 +520,7 @@ struct TimesMinusI{
 struct TimesI{
   // Complex
   template <typename T>
-  inline vec<T> operator()(vec<T> a, vec<T> b){
+  inline vec<T> operator()(vec<T> a){
     vec<T> out;
     const vec<typename acle<T>::uint> tbl_swap = acle<T>::tbl_swap();
     svbool_t pg1 = acle<T>::pg1();

Grid/simd/Grid_a64fx-fixedsize.h

@@ -418,7 +418,7 @@ struct Conj{
 
 struct TimesMinusI{
   // Complex float
-  inline vecf operator()(vecf a, vecf b){
+  inline vecf operator()(vecf a){
     lutf tbl_swap = acle<float>::tbl_swap();
     pred pg1 = acle<float>::pg1();
     pred pg_odd = acle<float>::pg_odd();
@@ -428,7 +428,7 @@ struct TimesMinusI{
     return svneg_m(a_v, pg_odd, a_v);
   }
   // Complex double
-  inline vecd operator()(vecd a, vecd b){
+  inline vecd operator()(vecd a){
     lutd tbl_swap = acle<double>::tbl_swap();
     pred pg1 = acle<double>::pg1();
     pred pg_odd = acle<double>::pg_odd();
@@ -441,7 +441,7 @@ struct TimesMinusI{
 
 struct TimesI{
   // Complex float
-  inline vecf operator()(vecf a, vecf b){
+  inline vecf operator()(vecf a){
     lutf tbl_swap = acle<float>::tbl_swap();
     pred pg1 = acle<float>::pg1();
     pred pg_even = acle<float>::pg_even();
@@ -451,7 +451,7 @@ struct TimesI{
     return svneg_m(a_v, pg_even, a_v);
   }
   // Complex double
-  inline vecd operator()(vecd a, vecd b){
+  inline vecd operator()(vecd a){
     lutd tbl_swap = acle<double>::tbl_swap();
     pred pg1 = acle<double>::pg1();
     pred pg_even = acle<double>::pg_even();

Grid/simd/Grid_avx.h

@@ -405,12 +405,12 @@ struct Conj{
 
 struct TimesMinusI{
   //Complex single
-  inline __m256 operator()(__m256 in, __m256 ret){
+  inline __m256 operator()(__m256 in){
     __m256 tmp =_mm256_addsub_ps(_mm256_setzero_ps(),in);   // r,-i
     return _mm256_shuffle_ps(tmp,tmp,_MM_SELECT_FOUR_FOUR(2,3,0,1)); //-i,r
   }
   //Complex double
-  inline __m256d operator()(__m256d in, __m256d ret){
+  inline __m256d operator()(__m256d in){
     __m256d tmp = _mm256_addsub_pd(_mm256_setzero_pd(),in); // r,-i
     return _mm256_shuffle_pd(tmp,tmp,0x5);
   }
@@ -418,12 +418,12 @@ struct TimesMinusI{
 
 struct TimesI{
   //Complex single
-  inline __m256 operator()(__m256 in, __m256 ret){
+  inline __m256 operator()(__m256 in){
     __m256 tmp =_mm256_shuffle_ps(in,in,_MM_SELECT_FOUR_FOUR(2,3,0,1)); // i,r
     return _mm256_addsub_ps(_mm256_setzero_ps(),tmp);          // i,-r
   }
   //Complex double
-  inline __m256d operator()(__m256d in, __m256d ret){
+  inline __m256d operator()(__m256d in){
     __m256d tmp = _mm256_shuffle_pd(in,in,0x5);
     return _mm256_addsub_pd(_mm256_setzero_pd(),tmp); // i,-r
   }

Grid/simd/Grid_avx512.h

@@ -271,14 +271,14 @@ struct Conj{
 
 struct TimesMinusI{
   //Complex single
-  inline __m512 operator()(__m512 in, __m512 ret){
+  inline __m512 operator()(__m512 in){
     //__m512 tmp = _mm512_mask_sub_ps(in,0xaaaa,_mm512_setzero_ps(),in); // real -imag 
     //return _mm512_shuffle_ps(tmp,tmp,_MM_SELECT_FOUR_FOUR(2,3,1,0));   // 0x4E??
     __m512 tmp = _mm512_shuffle_ps(in,in,_MM_SELECT_FOUR_FOUR(2,3,0,1));
     return _mm512_mask_sub_ps(tmp,0xaaaa,_mm512_setzero_ps(),tmp);
   }
   //Complex double
-  inline __m512d operator()(__m512d in, __m512d ret){
+  inline __m512d operator()(__m512d in){
     //__m512d tmp = _mm512_mask_sub_pd(in,0xaa,_mm512_setzero_pd(),in); // real -imag 
     //return _mm512_shuffle_pd(tmp,tmp,0x55);
     __m512d tmp = _mm512_shuffle_pd(in,in,0x55);
@@ -288,17 +288,16 @@ struct TimesMinusI{
 
 struct TimesI{
   //Complex single
-  inline __m512 operator()(__m512 in, __m512 ret){
+  inline __m512 operator()(__m512 in){
     __m512 tmp = _mm512_shuffle_ps(in,in,_MM_SELECT_FOUR_FOUR(2,3,0,1));
     return _mm512_mask_sub_ps(tmp,0x5555,_mm512_setzero_ps(),tmp); 
   }
   //Complex double
-  inline __m512d operator()(__m512d in, __m512d ret){
+  inline __m512d operator()(__m512d in){
     __m512d tmp = _mm512_shuffle_pd(in,in,0x55);
     return _mm512_mask_sub_pd(tmp,0x55,_mm512_setzero_pd(),tmp); 
   }
 
-
 };
   
 // Gpermute utilities consider coalescing into 1 Gpermute

Grid/simd/Grid_doubled_vector.h

@@ -0,0 +1,666 @@
+/*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid
+
+    Source file: ./lib/simd/Grid_vector_types.h
+
+    Copyright (C) 2015
+
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    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 */
+#pragma once
+
+NAMESPACE_BEGIN(Grid);
+
+template <class Scalar_type, class Vector_type>
+class Grid_simd2 {
+public:
+  typedef typename RealPart<Scalar_type>::type Real;
+  typedef Vector_type vector_type;
+  typedef Scalar_type scalar_type;
+
+  typedef union conv_t_union {
+    Vector_type v;
+    Scalar_type s[sizeof(Vector_type) / sizeof(Scalar_type)];
+    accelerator_inline conv_t_union(){};
+  } conv_t;
+
+  static constexpr int nvec=2;
+  Vector_type v[nvec];
+
+  static accelerator_inline constexpr int Nsimd(void) {
+    static_assert( (sizeof(Vector_type) / sizeof(Scalar_type) >= 1), " size mismatch " );
+    
+    return nvec*sizeof(Vector_type) / sizeof(Scalar_type);
+  }
+  
+  accelerator_inline Grid_simd2 &operator=(const Grid_simd2 &&rhs) {
+    for(int n=0;n<nvec;n++) v[n] = rhs.v[n];
+    return *this;
+  };
+  accelerator_inline Grid_simd2 &operator=(const Grid_simd2 &rhs) {
+    for(int n=0;n<nvec;n++) v[n] = rhs.v[n];
+    return *this;
+  };  // faster than not declaring it and leaving to the compiler
+
+  accelerator Grid_simd2() = default;
+  accelerator_inline Grid_simd2(const Grid_simd2 &rhs) {    for(int n=0;n<nvec;n++) v[n] = rhs.v[n];  };
+  accelerator_inline Grid_simd2(const Grid_simd2 &&rhs){    for(int n=0;n<nvec;n++) v[n] = rhs.v[n];  };
+  accelerator_inline Grid_simd2(const Real a) { vsplat(*this, Scalar_type(a)); };
+  // Enable if complex type
+  template <typename S = Scalar_type> accelerator_inline
+  Grid_simd2(const typename std::enable_if<is_complex<S>::value, S>::type a) {
+      vsplat(*this, a);
+  };
+
+  /////////////////////////////
+  // Constructors
+  /////////////////////////////
+  accelerator_inline Grid_simd2 &  operator=(const Zero &z) {
+    vzero(*this);
+    return (*this);
+  }
+
+  ///////////////////////////////////////////////
+  // mac, mult, sub, add, adj
+  ///////////////////////////////////////////////
+
+  friend accelerator_inline void mac(Grid_simd2 *__restrict__ y,
+				     const Grid_simd2 *__restrict__ a,
+				     const Grid_simd2 *__restrict__ x) {
+    *y = (*a) * (*x) + (*y);
+  };
+
+  friend accelerator_inline void mult(Grid_simd2 *__restrict__ y,
+				      const Grid_simd2 *__restrict__ l,
+				      const Grid_simd2 *__restrict__ r) {
+    *y = (*l) * (*r);
+  }
+
+  friend accelerator_inline void sub(Grid_simd2 *__restrict__ y,
+				     const Grid_simd2 *__restrict__ l,
+				     const Grid_simd2 *__restrict__ r) {
+    *y = (*l) - (*r);
+  }
+  friend accelerator_inline void add(Grid_simd2 *__restrict__ y,
+				     const Grid_simd2 *__restrict__ l,
+				     const Grid_simd2 *__restrict__ r) {
+    *y = (*l) + (*r);
+  }
+  friend accelerator_inline void mac(Grid_simd2 *__restrict__ y,
+				     const Scalar_type *__restrict__ a,
+				     const Grid_simd2 *__restrict__ x) {
+    *y = (*a) * (*x) + (*y);
+  };
+  friend accelerator_inline void mult(Grid_simd2 *__restrict__ y,
+				      const Scalar_type *__restrict__ l,
+				      const Grid_simd2 *__restrict__ r) {
+    *y = (*l) * (*r);
+  }
+  friend accelerator_inline void sub(Grid_simd2 *__restrict__ y,
+				     const Scalar_type *__restrict__ l,
+				     const Grid_simd2 *__restrict__ r) {
+    *y = (*l) - (*r);
+  }
+  friend accelerator_inline void add(Grid_simd2 *__restrict__ y,
+				     const Scalar_type *__restrict__ l,
+				     const Grid_simd2 *__restrict__ r) {
+    *y = (*l) + (*r);
+  }
+
+  friend accelerator_inline void mac(Grid_simd2 *__restrict__ y,
+				     const Grid_simd2 *__restrict__ a,
+				     const Scalar_type *__restrict__ x) {
+    *y = (*a) * (*x) + (*y);
+  };
+  friend accelerator_inline void mult(Grid_simd2 *__restrict__ y,
+				      const Grid_simd2 *__restrict__ l,
+				      const Scalar_type *__restrict__ r) {
+    *y = (*l) * (*r);
+  }
+  friend accelerator_inline void sub(Grid_simd2 *__restrict__ y,
+				     const Grid_simd2 *__restrict__ l,
+				     const Scalar_type *__restrict__ r) {
+    *y = (*l) - (*r);
+  }
+  friend accelerator_inline void add(Grid_simd2 *__restrict__ y,
+				     const Grid_simd2 *__restrict__ l,
+				     const Scalar_type *__restrict__ r) {
+    *y = (*l) + (*r);
+  }
+
+  ////////////////////////////////////////////////////////////////////////
+  // FIXME:  gonna remove these load/store, get, set, prefetch
+  ////////////////////////////////////////////////////////////////////////
+  friend accelerator_inline void vset(Grid_simd2 &ret, Scalar_type *a) {
+    for(int n=0;n<nvec;n++) vset(ret.v[n],a);
+  }
+
+  ///////////////////////
+  // Vstore
+  ///////////////////////
+  friend accelerator_inline void vstore(const Grid_simd2 &ret, Scalar_type *a) {
+    for(int n=0;n<nvec;n++) vstore(ret.v[n],a);
+  }
+
+  ///////////////////////
+  // Vprefetch
+  ///////////////////////
+  friend accelerator_inline void vprefetch(const Grid_simd2 &v) {
+    vprefetch(v.v[0]);
+  }
+
+  ///////////////////////
+  // Reduce
+  ///////////////////////
+  friend accelerator_inline Scalar_type Reduce(const Grid_simd2 &in) {
+    return Reduce(in.v[0])+ Reduce(in.v[1]);
+  }
+
+  ////////////////////////////
+  // operator scalar * simd
+  ////////////////////////////
+  friend accelerator_inline Grid_simd2 operator*(const Scalar_type &a, Grid_simd2 b) {
+    Grid_simd2 va;
+    vsplat(va, a);
+    return va * b;
+  }
+  friend accelerator_inline Grid_simd2 operator*(Grid_simd2 b, const Scalar_type &a) {
+    return a * b;
+  }
+
+  //////////////////////////////////
+  // Divides
+  //////////////////////////////////
+  friend accelerator_inline Grid_simd2 operator/(const Scalar_type &a, Grid_simd2 b) {
+    Grid_simd2 va;
+    vsplat(va, a);
+    return va / b;
+  }
+  friend accelerator_inline Grid_simd2 operator/(Grid_simd2 b, const Scalar_type &a) {
+    Grid_simd2 va;
+    vsplat(va, a);
+    return b / a;
+  }
+
+  ///////////////////////
+  // Unary negation
+  ///////////////////////
+  friend accelerator_inline Grid_simd2 operator-(const Grid_simd2 &r) {
+    Grid_simd2 ret;
+    vzero(ret);
+    ret = ret - r;
+    return ret;
+  }
+  // *=,+=,-= operators
+  accelerator_inline Grid_simd2 &operator*=(const Grid_simd2 &r) {
+    *this = (*this) * r;
+    return *this;
+  }
+  accelerator_inline Grid_simd2 &operator+=(const Grid_simd2 &r) {
+    *this = *this + r;
+    return *this;
+  }
+  accelerator_inline Grid_simd2 &operator-=(const Grid_simd2 &r) {
+    *this = *this - r;
+    return *this;
+  }
+
+  ///////////////////////////////////////
+  // Not all functions are supported
+  // through SIMD and must breakout to
+  // scalar type and back again. This
+  // provides support
+  ///////////////////////////////////////
+  template <class functor>
+  friend accelerator_inline Grid_simd2 SimdApply(const functor &func, const Grid_simd2 &v) {
+    Grid_simd2 ret;
+    for(int n=0;n<nvec;n++){
+      ret.v[n]=SimdApply(func,v.v[n]);
+    }
+    return ret;
+  }
+  template <class functor>
+  friend accelerator_inline Grid_simd2 SimdApplyBinop(const functor &func,
+                                         const Grid_simd2 &x,
+                                         const Grid_simd2 &y) {
+    Grid_simd2 ret;
+    for(int n=0;n<nvec;n++){
+      ret.v[n]=SimdApplyBinop(func,x.v[n],y.v[n]);
+    }
+    return ret;
+  }
+  ///////////////////////
+  // Exchange
+  // Al Ah , Bl Bh -> Al Bl Ah,Bh
+  ///////////////////////
+  friend accelerator_inline void exchange0(Grid_simd2 &out1,Grid_simd2 &out2,Grid_simd2 in1,Grid_simd2 in2){
+      out1.v[0] = in1.v[0];
+      out1.v[1] = in2.v[0];
+      out2.v[0] = in1.v[1];
+      out2.v[1] = in2.v[1];
+  }
+  friend accelerator_inline void exchange1(Grid_simd2 &out1,Grid_simd2 &out2,Grid_simd2 in1,Grid_simd2 in2){
+    exchange0(out1.v[0],out2.v[0],in1.v[0],in2.v[0]);
+    exchange0(out1.v[1],out2.v[1],in1.v[1],in2.v[1]);
+  }
+  friend accelerator_inline void exchange2(Grid_simd2 &out1,Grid_simd2 &out2,Grid_simd2 in1,Grid_simd2 in2){
+    exchange1(out1.v[0],out2.v[0],in1.v[0],in2.v[0]);
+    exchange1(out1.v[1],out2.v[1],in1.v[1],in2.v[1]);
+  }
+  friend accelerator_inline void exchange3(Grid_simd2 &out1,Grid_simd2 &out2,Grid_simd2 in1,Grid_simd2 in2){
+    exchange2(out1.v[0],out2.v[0],in1.v[0],in2.v[0]);
+    exchange2(out1.v[1],out2.v[1],in1.v[1],in2.v[1]);
+  }
+  friend accelerator_inline void exchange4(Grid_simd2 &out1,Grid_simd2 &out2,Grid_simd2 in1,Grid_simd2 in2){
+    exchange3(out1.v[0],out2.v[0],in1.v[0],in2.v[0]);
+    exchange3(out1.v[1],out2.v[1],in1.v[1],in2.v[1]);
+  }
+  friend accelerator_inline void exchange(Grid_simd2 &out1,Grid_simd2 &out2,Grid_simd2 in1,Grid_simd2 in2,int n)
+  {
+    if       (n==3) {
+      exchange3(out1,out2,in1,in2);
+    } else if(n==2) {
+      exchange2(out1,out2,in1,in2);
+    } else if(n==1) {
+      exchange1(out1,out2,in1,in2);
+    } else if(n==0) {
+      exchange0(out1,out2,in1,in2);
+    }
+  }
+  ////////////////////////////////////////////////////////////////////
+  // General permute; assumes vector length is same across
+  // all subtypes; may not be a good assumption, but could
+  // add the vector width as a template param for BG/Q for example
+  ////////////////////////////////////////////////////////////////////
+  friend accelerator_inline void permute0(Grid_simd2 &y, Grid_simd2 b) {
+    y.v[0]=b.v[1];
+    y.v[1]=b.v[0];
+  }
+  friend accelerator_inline void permute1(Grid_simd2 &y, Grid_simd2 b) {
+    permute0(y.v[0],b.v[0]);
+    permute0(y.v[1],b.v[1]);
+  }
+  friend accelerator_inline void permute2(Grid_simd2 &y, Grid_simd2 b) {
+    permute1(y.v[0],b.v[0]);
+    permute1(y.v[1],b.v[1]);
+  }
+  friend accelerator_inline void permute3(Grid_simd2 &y, Grid_simd2 b) {
+    permute2(y.v[0],b.v[0]);
+    permute2(y.v[1],b.v[1]);
+  }
+  friend accelerator_inline void permute4(Grid_simd2 &y, Grid_simd2 b) {
+    permute3(y.v[0],b.v[0]);
+    permute3(y.v[1],b.v[1]);
+  }
+  friend accelerator_inline void permute(Grid_simd2 &y, Grid_simd2 b, int perm) {
+    if(perm==3) permute3(y, b);
+    else if(perm==2) permute2(y, b);
+    else if(perm==1) permute1(y, b);
+    else if(perm==0) permute0(y, b);
+  }
+
+  ///////////////////////////////
+  // Getting single lanes
+  ///////////////////////////////
+  accelerator_inline Scalar_type getlane(int lane) const {
+    if(lane < vector_type::Nsimd() ) return v[0].getlane(lane);
+    else                             return v[1].getlane(lane%vector_type::Nsimd());
+  }
+
+  accelerator_inline void putlane(const Scalar_type &S, int lane){
+    if(lane < vector_type::Nsimd() ) v[0].putlane(S,lane);
+    else                             v[1].putlane(S,lane%vector_type::Nsimd());
+  }
+};  // end of Grid_simd2 class definition
+
+///////////////////////////////
+// Define available types
+///////////////////////////////
+
+typedef Grid_simd2<complex<double>  , vComplexD>  vComplexD2;
+typedef Grid_simd2<double           , vRealD>     vRealD2;
+
+
+
+/////////////////////////////////////////
+// Some traits to recognise the types
+/////////////////////////////////////////
+template <typename T>
+struct is_simd : public std::false_type {};
+template <> struct is_simd<vRealF>     : public std::true_type {};
+template <> struct is_simd<vRealD>     : public std::true_type {};
+template <> struct is_simd<vRealH>     : public std::true_type {};
+template <> struct is_simd<vComplexF>  : public std::true_type {};
+template <> struct is_simd<vComplexD>  : public std::true_type {};
+template <> struct is_simd<vComplexH>  : public std::true_type {};
+template <> struct is_simd<vInteger>   : public std::true_type {};
+template <> struct is_simd<vRealD2>    : public std::true_type {};
+template <> struct is_simd<vComplexD2> : public std::true_type {};
+
+template <typename T> using IfSimd    = Invoke<std::enable_if<is_simd<T>::value, int> >;
+template <typename T> using IfNotSimd = Invoke<std::enable_if<!is_simd<T>::value, unsigned> >;
+
+///////////////////////////////////////////////
+// insert / extract with complex support
+///////////////////////////////////////////////
+template <class S, class V>
+accelerator_inline S getlane(const Grid_simd<S, V> &in,int lane) {
+  return in.getlane(lane);
+}
+template <class S, class V>
+accelerator_inline void putlane(Grid_simd<S, V> &vec,const S &_S, int lane){
+  vec.putlane(_S,lane);
+}
+template <class S,IfNotSimd<S> = 0 >
+accelerator_inline S getlane(const S &in,int lane) {
+  return in;
+}
+template <class S,IfNotSimd<S> = 0 >
+accelerator_inline void putlane(S &vec,const S &_S, int lane){
+  vec = _S;
+}
+template <class S, class V>
+accelerator_inline S getlane(const Grid_simd2<S, V> &in,int lane) {
+  return in.getlane(lane);
+}
+template <class S, class V>
+accelerator_inline void putlane(Grid_simd2<S, V> &vec,const S &_S, int lane){
+  vec.putlane(_S,lane);
+}
+
+
+////////////////////////////////////////////////////////////////////
+// General rotate
+////////////////////////////////////////////////////////////////////
+
+template <class S, class V>
+accelerator_inline void vbroadcast(Grid_simd2<S,V> &ret,const Grid_simd2<S,V> &src,int lane){
+  S* typepun =(S*) &src;
+  vsplat(ret,typepun[lane]);
+}
+template <class S, class V, IfComplex<S> =0>
+accelerator_inline void rbroadcast(Grid_simd2<S,V> &ret,const Grid_simd2<S,V> &src,int lane){
+  typedef typename V::vector_type vector_type;
+  S* typepun =(S*) &src;
+  ret.v[0].v = unary<vector_type>(real(typepun[lane]), VsplatSIMD());
+  ret.v[1].v = unary<vector_type>(real(typepun[lane]), VsplatSIMD());
+}
+
+
+///////////////////////
+// Splat
+///////////////////////
+
+// this is only for the complex version
+template <class S, class V, IfComplex<S> = 0, class ABtype>
+accelerator_inline void vsplat(Grid_simd2<S, V> &ret, ABtype a, ABtype b) {
+  vsplat(ret.v[0],a,b);
+  vsplat(ret.v[1],a,b);
+}
+
+// overload if complex
+template <class S, class V>
+accelerator_inline void vsplat(Grid_simd2<S, V> &ret, EnableIf<is_complex<S>, S> c) {
+  vsplat(ret, real(c), imag(c));
+}
+template <class S, class V>
+accelerator_inline void rsplat(Grid_simd2<S, V> &ret, EnableIf<is_complex<S>, S> c) {
+  vsplat(ret, real(c), real(c));
+}
+
+// if real fill with a, if complex fill with a in the real part (first function
+// above)
+template <class S, class V>
+accelerator_inline void vsplat(Grid_simd2<S, V> &ret, NotEnableIf<is_complex<S>, S> a)
+{
+  vsplat(ret.v[0],a);
+  vsplat(ret.v[1],a);
+}
+//////////////////////////
+
+///////////////////////////////////////////////
+// Initialise to 1,0,i for the correct types
+///////////////////////////////////////////////
+// For complex types
+template <class S, class V, IfComplex<S> = 0>
+accelerator_inline void vone(Grid_simd2<S, V> &ret) {
+  vsplat(ret, S(1.0, 0.0));
+}
+template <class S, class V, IfComplex<S> = 0>
+accelerator_inline void vzero(Grid_simd2<S, V> &ret) {
+  vsplat(ret, S(0.0, 0.0));
+}  // use xor?
+template <class S, class V, IfComplex<S> = 0>
+accelerator_inline void vcomplex_i(Grid_simd2<S, V> &ret) {
+  vsplat(ret, S(0.0, 1.0));
+}
+
+template <class S, class V, IfComplex<S> = 0>
+accelerator_inline void visign(Grid_simd2<S, V> &ret) {
+  vsplat(ret, S(1.0, -1.0));
+}
+template <class S, class V, IfComplex<S> = 0>
+accelerator_inline void vrsign(Grid_simd2<S, V> &ret) {
+  vsplat(ret, S(-1.0, 1.0));
+}
+
+// if not complex overload here
+template <class S, class V, IfReal<S> = 0>
+accelerator_inline void vone(Grid_simd2<S, V> &ret) {
+  vsplat(ret, S(1.0));
+}
+template <class S, class V, IfReal<S> = 0>
+accelerator_inline void vzero(Grid_simd2<S, V> &ret) {
+  vsplat(ret, S(0.0));
+}
+
+// For integral types
+template <class S, class V, IfInteger<S> = 0>
+accelerator_inline void vone(Grid_simd2<S, V> &ret) {
+  vsplat(ret, 1);
+}
+template <class S, class V, IfInteger<S> = 0>
+accelerator_inline void vzero(Grid_simd2<S, V> &ret) {
+  vsplat(ret, 0);
+}
+template <class S, class V, IfInteger<S> = 0>
+accelerator_inline void vtrue(Grid_simd2<S, V> &ret) {
+  vsplat(ret, 0xFFFFFFFF);
+}
+template <class S, class V, IfInteger<S> = 0>
+accelerator_inline void vfalse(Grid_simd2<S, V> &ret) {
+  vsplat(ret, 0);
+}
+template <class S, class V>
+accelerator_inline void zeroit(Grid_simd2<S, V> &z) {
+  vzero(z);
+}
+
+///////////////////////
+// Vstream
+///////////////////////
+template <class S, class V, IfReal<S> = 0>
+accelerator_inline void vstream(Grid_simd2<S, V> &out, const Grid_simd2<S, V> &in) {
+  vstream(out.v[0],in.v[0]);
+  vstream(out.v[1],in.v[1]);
+}
+template <class S, class V, IfComplex<S> = 0>
+accelerator_inline void vstream(Grid_simd2<S, V> &out, const Grid_simd2<S, V> &in) {
+  vstream(out.v[0],in.v[0]);
+  vstream(out.v[1],in.v[1]);
+}
+template <class S, class V, IfInteger<S> = 0>
+accelerator_inline void vstream(Grid_simd2<S, V> &out, const Grid_simd2<S, V> &in) {
+  vstream(out.v[0],in.v[0]);
+  vstream(out.v[1],in.v[1]);
+}
+
+////////////////////////////////////
+// Arithmetic operator overloads +,-,*
+////////////////////////////////////
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> operator+(Grid_simd2<S, V> a, Grid_simd2<S, V> b) {
+  Grid_simd2<S, V> ret;
+  ret.v[0] = a.v[0]+b.v[0];
+  ret.v[1] = a.v[1]+b.v[1];
+  return ret;
+};
+
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> operator-(Grid_simd2<S, V> a, Grid_simd2<S, V> b) {
+  Grid_simd2<S, V> ret;
+  ret.v[0] = a.v[0]-b.v[0];
+  ret.v[1] = a.v[1]-b.v[1];
+  return ret;
+};
+
+// Distinguish between complex types and others
+template <class S, class V, IfComplex<S> = 0>
+accelerator_inline Grid_simd2<S, V> real_mult(Grid_simd2<S, V> a, Grid_simd2<S, V> b) {
+  Grid_simd2<S, V> ret;
+  ret.v[0] =real_mult(a.v[0],b.v[0]);
+  ret.v[1] =real_mult(a.v[1],b.v[1]);
+  return ret;
+};
+template <class S, class V, IfComplex<S> = 0>
+accelerator_inline Grid_simd2<S, V> real_madd(Grid_simd2<S, V> a, Grid_simd2<S, V> b, Grid_simd2<S,V> c) {
+  Grid_simd2<S, V> ret;
+  ret.v[0] =real_madd(a.v[0],b.v[0],c.v[0]);
+  ret.v[1] =real_madd(a.v[1],b.v[1],c.v[1]);
+  return ret;
+};
+
+
+// Distinguish between complex types and others
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> operator*(Grid_simd2<S, V> a, Grid_simd2<S, V> b) {
+  Grid_simd2<S, V> ret;
+  ret.v[0] = a.v[0]*b.v[0];
+  ret.v[1] = a.v[1]*b.v[1];
+  return ret;
+};
+
+// Distinguish between complex types and others
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> operator/(Grid_simd2<S, V> a, Grid_simd2<S, V> b) {
+  Grid_simd2<S, V> ret;
+  ret.v[0] = a.v[0]/b.v[0];
+  ret.v[1] = a.v[1]/b.v[1];
+  return ret;
+};
+
+///////////////////////
+// Conjugate
+///////////////////////
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> conjugate(const Grid_simd2<S, V> &in) {
+  Grid_simd2<S, V> ret;
+  ret.v[0] = conjugate(in.v[0]);
+  ret.v[1] = conjugate(in.v[1]);
+  return ret;
+}
+template <class S, class V, IfNotInteger<S> = 0>
+accelerator_inline Grid_simd2<S, V> adj(const Grid_simd2<S, V> &in) {
+  return conjugate(in);
+}
+
+///////////////////////
+// timesMinusI
+///////////////////////
+template <class S, class V>
+accelerator_inline void timesMinusI(Grid_simd2<S, V> &ret, const Grid_simd2<S, V> &in) {
+  timesMinusI(ret.v[0],in.v[0]);
+  timesMinusI(ret.v[1],in.v[1]);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> timesMinusI(const Grid_simd2<S, V> &in) {
+  Grid_simd2<S, V> ret;
+  timesMinusI(ret.v[0],in.v[0]);
+  timesMinusI(ret.v[1],in.v[1]);
+  return ret;
+}
+
+///////////////////////
+// timesI
+///////////////////////
+template <class S, class V>
+accelerator_inline void timesI(Grid_simd2<S, V> &ret, const Grid_simd2<S, V> &in) {
+  timesI(ret.v[0],in.v[0]);
+  timesI(ret.v[1],in.v[1]);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> timesI(const Grid_simd2<S, V> &in) {
+  Grid_simd2<S, V> ret;
+  timesI(ret.v[0],in.v[0]);
+  timesI(ret.v[1],in.v[1]);
+  return ret;
+}
+
+/////////////////////
+// Inner, outer
+/////////////////////
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> innerProduct(const Grid_simd2<S, V> &l,const Grid_simd2<S, V> &r) {
+  return conjugate(l) * r;
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> outerProduct(const Grid_simd2<S, V> &l,const Grid_simd2<S, V> &r) {
+  return l * conjugate(r);
+}
+
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> trace(const Grid_simd2<S, V> &arg) {
+  return arg;
+}
+
+////////////////////////////////////////////////////////////
+// copy/splat complex real parts into real;
+// insert real into complex and zero imag;
+////////////////////////////////////////////////////////////
+accelerator_inline void precisionChange(vComplexD2 &out,const vComplexF  &in){
+  Optimization::PrecisionChange::StoD(in.v,out.v[0].v,out.v[1].v);
+}
+accelerator_inline void precisionChange(vComplexF  &out,const vComplexD2 &in){
+  out.v=Optimization::PrecisionChange::DtoS(in.v[0].v,in.v[1].v);
+}
+accelerator_inline void precisionChange(vComplexD2 *out,const vComplexF  *in,int nvec){
+  for(int m=0;m<nvec;m++){ precisionChange(out[m],in[m]); }
+}
+accelerator_inline void precisionChange(vComplexF  *out,const vComplexD2 *in,int nvec){
+  for(int m=0;m<nvec;m++){ precisionChange(out[m],in[m]); }
+}
+
+accelerator_inline void precisionChange(vRealD2 &out,const vRealF  &in){
+  Optimization::PrecisionChange::StoD(in.v,out.v[0].v,out.v[1].v);
+}
+accelerator_inline void precisionChange(vRealF  &out,const vRealD2 &in){
+  out.v=Optimization::PrecisionChange::DtoS(in.v[0].v,in.v[1].v);
+}
+accelerator_inline void precisionChange(vRealD2 *out,const vRealF  *in,int nvec){
+  for(int m=0;m<nvec;m++){ precisionChange(out[m],in[m]); }
+}
+accelerator_inline void precisionChange(vRealF  *out,const vRealD2 *in,int nvec){
+  for(int m=0;m<nvec;m++){ precisionChange(out[m],in[m]); }
+}
+
+NAMESPACE_END(Grid);
+
+

Grid/simd/Grid_generic.h

@@ -244,7 +244,7 @@ struct Conj{
 struct TimesMinusI{
   // Complex
   template <typename T>
-  accelerator_inline vec<T> operator()(vec<T> a, vec<T> b){
+  accelerator_inline vec<T> operator()(vec<T> a){
     vec<T> out;
       
     VECTOR_FOR(i, W<T>::c, 1)
@@ -265,7 +265,7 @@ struct TimesMinusI{
 struct TimesI{
   // Complex
   template <typename T>
-  accelerator_inline vec<T> operator()(vec<T> a, vec<T> b){
+  accelerator_inline vec<T> operator()(vec<T> a){
     vec<T> out;
       
     VECTOR_FOR(i, W<T>::c, 1)

Grid/simd/Grid_gpu_rrii.h

@@ -0,0 +1,878 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./lib/simd/Grid_gpu.h
+
+    Copyright (C) 2021
+
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    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 */
+//----------------------------------------------------------------------
+/*! @file Grid_gpu_rrii.h*/
+//----------------------------------------------------------------------
+
+//////////////////////////////
+// fp16
+//////////////////////////////
+#ifdef GRID_CUDA
+#include <cuda_fp16.h>
+#endif
+#ifdef GRID_HIP
+#include <hip/hip_fp16.h>
+#endif
+#if !defined(GRID_HIP) && !defined(GRID_CUDA) 
+namespace Grid {
+  typedef struct { uint16_t x;} half;
+}
+#endif
+namespace Grid {
+  accelerator_inline float half2float(half h)
+  {
+    float f;
+#if defined(GRID_CUDA) || defined(GRID_HIP)
+    f = __half2float(h);
+#else 
+    Grid_half hh; 
+    hh.x = h.x;
+    f=  sfw_half_to_float(hh);
+#endif
+    return f;
+  }
+  accelerator_inline half float2half(float f)
+  {
+    half h;
+#if defined(GRID_CUDA) || defined(GRID_HIP)
+    h = __float2half(f);
+#else
+    Grid_half hh = sfw_float_to_half(f);
+    h.x = hh.x;
+#endif
+    return h;
+  }
+}
+
+
+#define COALESCE_GRANULARITY ( GEN_SIMD_WIDTH )
+
+namespace Grid {
+
+////////////////////////////////////////////////////////////////////////
+// Real vector
+////////////////////////////////////////////////////////////////////////  
+template<int _N, class _datum>
+struct GpuVector {
+  _datum rrrr[_N];
+  static const int N = _N;
+  typedef _datum datum;
+};
+template<int N,class datum>
+inline accelerator GpuVector<N,datum> operator*(const GpuVector<N,datum> l,const GpuVector<N,datum> r) {
+  GpuVector<N,datum> ret;
+  for(int i=0;i<N;i++) { 
+    ret.rrrr[i] = l.rrrr[i]*r.rrrr[i];
+  }
+  return ret;
+}
+template<int N,class datum>
+inline accelerator GpuVector<N,datum> operator-(const GpuVector<N,datum> l,const GpuVector<N,datum> r) {
+  GpuVector<N,datum> ret;
+  for(int i=0;i<N;i++) { 
+    ret.rrrr[i] = l.rrrr[i]-r.rrrr[i];
+  }
+  return ret;
+}
+template<int N,class datum>
+inline accelerator GpuVector<N,datum> operator+(const GpuVector<N,datum> l,const GpuVector<N,datum> r) {
+  GpuVector<N,datum> ret;
+  for(int i=0;i<N;i++) { 
+    ret.rrrr[i] = l.rrrr[i]+r.rrrr[i];
+  }
+  return ret;
+}
+template<int N,class datum>
+inline accelerator GpuVector<N,datum> operator/(const GpuVector<N,datum> l,const GpuVector<N,datum> r) {
+  GpuVector<N,datum> ret;
+  for(int i=0;i<N;i++) { 
+    ret.rrrr[i] = l.rrrr[i]/r.rrrr[i];
+  }
+  return ret;
+}
+
+////////////////////////////////////////////////////////////////////////
+// Complex vector
+////////////////////////////////////////////////////////////////////////  
+template<int _N, class _datum>
+struct GpuComplexVector {
+  _datum rrrr[_N];
+  _datum iiii[_N];
+  static const int N = _N;
+  typedef _datum datum;
+};
+template<int N,class datum>
+inline accelerator GpuComplexVector<N,datum> operator*(const GpuComplexVector<N,datum> l,const GpuComplexVector<N,datum> r) {
+  GpuComplexVector<N,datum> ret;
+  for(int i=0;i<N;i++) { 
+    ret.rrrr[i] = l.rrrr[i]*r.rrrr[i] - l.iiii[i]*r.iiii[i];
+    ret.iiii[i] = l.rrrr[i]*r.iiii[i] + l.iiii[i]*r.rrrr[i];
+  }
+  return ret;
+}
+template<int N,class datum>
+inline accelerator GpuComplexVector<N,datum> operator-(const GpuComplexVector<N,datum> l,const GpuComplexVector<N,datum> r) {
+  GpuComplexVector<N,datum> ret;
+  for(int i=0;i<N;i++) { 
+    ret.rrrr[i] = l.rrrr[i]-r.rrrr[i];
+    ret.iiii[i] = l.iiii[i]-r.iiii[i];
+  }
+  return ret;
+}
+template<int N,class datum>
+inline accelerator GpuComplexVector<N,datum> operator+(const GpuComplexVector<N,datum> l,const GpuComplexVector<N,datum> r) {
+  GpuComplexVector<N,datum> ret;
+  for(int i=0;i<N;i++) { 
+    ret.rrrr[i] = l.rrrr[i]+r.rrrr[i];
+    ret.iiii[i] = l.iiii[i]+r.iiii[i];
+  }
+  return ret;
+}
+template<int N,class datum>
+inline accelerator GpuComplexVector<N,datum> operator/(const GpuComplexVector<N,datum> l,const GpuComplexVector<N,datum> r) {
+  GpuComplexVector<N,datum> ret;
+  for(int i=0;i<N;i++) { 
+    ret.rrrr[i] = l.rrrr[i]/r.rrrr[i];
+    ret.iiii[i] = l.iiii[i]/r.iiii[i];
+  }
+  return ret;
+}
+
+////////////////////////////////
+// SIMD counts
+////////////////////////////////
+
+constexpr int NSIMD_RealH    = COALESCE_GRANULARITY / sizeof(half);
+constexpr int NSIMD_ComplexH = COALESCE_GRANULARITY / sizeof(half);
+constexpr int NSIMD_RealF    = COALESCE_GRANULARITY / sizeof(float);
+constexpr int NSIMD_ComplexF = COALESCE_GRANULARITY / sizeof(float);
+constexpr int NSIMD_RealD    = COALESCE_GRANULARITY / sizeof(double);
+constexpr int NSIMD_ComplexD = COALESCE_GRANULARITY / sizeof(double);
+constexpr int NSIMD_Integer  = COALESCE_GRANULARITY / sizeof(Integer);
+
+typedef GpuVector<NSIMD_RealH   , half        > GpuVectorRH;
+typedef GpuComplexVector<NSIMD_ComplexH, half > GpuVectorCH;
+typedef GpuVector<NSIMD_RealF,    float       > GpuVectorRF;
+typedef GpuComplexVector<NSIMD_ComplexF, float> GpuVectorCF;
+typedef GpuVector<NSIMD_RealD,    double      > GpuVectorRD;
+typedef GpuComplexVector<NSIMD_ComplexD,double> GpuVectorCD;
+typedef GpuVector<NSIMD_Integer,  Integer     > GpuVectorI;
+
+namespace Optimization {
+
+  struct Vsplat{
+    //Complex float
+    accelerator_inline GpuVectorCF operator()(float a, float b){
+      GpuVectorCF ret;
+      for(int i=0;i<GpuVectorCF::N;i++){
+	ret.rrrr[i] = typename GpuVectorCF::datum(a);
+	ret.iiii[i] = typename GpuVectorCF::datum(b);
+      }
+      return ret;
+    }
+    // Real float
+    accelerator_inline GpuVectorRF operator()(float a){
+      GpuVectorRF ret;
+      for(int i=0;i<GpuVectorRF::N;i++){
+	ret.rrrr[i] = typename GpuVectorRF::datum(a);
+      }
+      return ret;
+    }
+    //Complex double
+    accelerator_inline GpuVectorCD operator()(double a, double b){
+      GpuVectorCD ret;
+      for(int i=0;i<GpuVectorCD::N;i++){
+	ret.rrrr[i] = typename GpuVectorCD::datum(a);
+	ret.iiii[i] = typename GpuVectorCD::datum(b);
+      }
+      return ret;
+    }
+    //Real double
+    accelerator_inline GpuVectorRD operator()(double a){
+      GpuVectorRD ret; 
+      for(int i=0;i<GpuVectorRD::N;i++){
+	ret.rrrr[i] = typename GpuVectorRD::datum(a);
+      }
+      return ret;
+    }
+    //Integer
+    accelerator_inline GpuVectorI operator()(Integer a){
+      GpuVectorI ret;
+      for(int i=0;i<GpuVectorI::N;i++){
+	ret.rrrr[i] = typename GpuVectorI::datum(a);
+      }
+      return ret;
+    }
+  };
+
+  struct Vstore{
+    template<int N,class datum,class P>
+    accelerator_inline void operator()(GpuVector<N,datum> a, P* Fp){
+      GpuVector<N,datum> *vF = (GpuVector<N,datum> *)Fp;
+      *vF = a;
+    }
+    template<int N,class datum,class P>
+    accelerator_inline void operator()(GpuComplexVector<N,datum> a, P* Fp){
+      GpuComplexVector<N,datum> *vF = (GpuComplexVector<N,datum> *)Fp;
+      *vF = a;
+    }
+  };
+
+  struct Vstream{
+    template<int N,class datum, class P>
+    accelerator_inline void operator()(P* F,GpuVector<N,datum> a){
+      GpuVector<N,datum> *vF = (GpuVector<N,datum> *)F;
+      *vF = a;
+    }
+    template<int N,class datum, class P>
+    accelerator_inline void operator()(P* F,GpuComplexVector<N,datum> a){
+      GpuComplexVector<N,datum> *vF = (GpuComplexVector<N,datum> *)F;
+      *vF = a;
+    }
+  };
+
+  struct Vset{
+    // Complex float 
+    accelerator_inline GpuVectorCF operator()(Grid::ComplexF *a){
+      typedef GpuVectorCF vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = vec::datum(a[i].real());
+	ret.iiii[i] = vec::datum(a[i].imag());
+      }
+      return ret;
+    }
+    // Complex double 
+    accelerator_inline GpuVectorCD operator()(Grid::ComplexD *a){
+      typedef GpuVectorCD vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = vec::datum(a[i].real());
+	ret.iiii[i] = vec::datum(a[i].imag());
+      }
+      return ret;
+    }
+    // Real float 
+    accelerator_inline GpuVectorRF operator()(float *a){
+      typedef GpuVectorRF vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = vec::datum(a[i]);
+      }
+      return ret;
+    }
+    // Real double
+    accelerator_inline GpuVectorRD operator()(double *a){
+      typedef GpuVectorRD vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = vec::datum(a[i]);
+      }
+      return ret;
+    }
+    // Integer
+    accelerator_inline GpuVectorI operator()(Integer *a){
+      typedef GpuVectorI vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = vec::datum(a[i]);
+      }
+      return ret;
+    }
+  };
+
+  template <typename Out_type, typename In_type>
+  struct Reduce{
+    //Need templated class to overload output type
+    //General form must generate error if compiled
+    accelerator_inline Out_type operator()(In_type in){
+      printf("Error, using wrong Reduce function\n");
+      exit(1);
+      return 0;
+    }
+  };
+
+  /////////////////////////////////////////////////////
+  // Arithmetic operations
+  /////////////////////////////////////////////////////
+  struct Sum{
+    //Real float
+    accelerator_inline GpuVectorRF operator()(GpuVectorRF a,GpuVectorRF b){
+      return a+b;
+    }
+    accelerator_inline GpuVectorRD operator()(GpuVectorRD a,GpuVectorRD b){
+      return a+b;
+    }
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF a,GpuVectorCF b){
+      return a+b;
+    }
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD a,GpuVectorCD b){
+      return a+b;
+    }
+    accelerator_inline GpuVectorI operator()(GpuVectorI a,GpuVectorI b){
+      return a+b;
+    }
+  };
+
+  struct Sub{
+    accelerator_inline GpuVectorRF operator()(GpuVectorRF a,GpuVectorRF b){
+      return a-b;
+    }
+    accelerator_inline GpuVectorRD operator()(GpuVectorRD a,GpuVectorRD b){
+      return a-b;
+    }
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF a,GpuVectorCF b){
+      return a-b;
+    }
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD a,GpuVectorCD b){
+      return a-b;
+    }
+    accelerator_inline GpuVectorI operator()(GpuVectorI a,GpuVectorI b){
+      return a-b;
+    }
+  };
+
+  struct MultRealPart{
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF a,GpuVectorCF b){
+      typedef GpuVectorCF vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = a.rrrr[i]*b.rrrr[i];
+	ret.iiii[i] = a.rrrr[i]*b.iiii[i];
+      }
+      return ret;
+    }
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD a,GpuVectorCD b){
+      typedef GpuVectorCD vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = a.rrrr[i]*b.rrrr[i];
+	ret.iiii[i] = a.rrrr[i]*b.iiii[i];
+      }
+      return ret;
+    }
+  };
+
+  struct MaddRealPart{
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF a,GpuVectorCF b,GpuVectorCF c){
+      typedef GpuVectorCF vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = a.rrrr[i]*b.rrrr[i]+c.rrrr[i];
+	ret.iiii[i] = a.rrrr[i]*b.iiii[i]+c.iiii[i];
+      }
+      return ret;
+    }
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD a,GpuVectorCD b,GpuVectorCD c){
+      typedef GpuVectorCD vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = a.rrrr[i]*b.rrrr[i]+c.rrrr[i];
+	ret.iiii[i] = a.rrrr[i]*b.iiii[i]+c.iiii[i];
+      }
+      return ret;
+    }
+  };
+
+  struct MultComplex{
+
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF a,GpuVectorCF b){
+      return a*b;
+    }
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD a,GpuVectorCD b){
+      return a*b;
+    }
+  };
+
+  struct Mult{
+    accelerator_inline void mac(GpuVectorRF &a, GpuVectorRF b, GpuVectorRF c){
+      a= a+b*c;
+    }
+    accelerator_inline void mac(GpuVectorRD &a, GpuVectorRD b, GpuVectorRD c){
+      a= a+b*c;
+    }
+    // Real float
+    accelerator_inline GpuVectorRF operator()(GpuVectorRF a, GpuVectorRF b){
+      return a*b;
+    }
+    // Real double
+    accelerator_inline GpuVectorRD operator()(GpuVectorRD a, GpuVectorRD b){
+      return a*b;
+    }
+    accelerator_inline GpuVectorI operator()(GpuVectorI a, GpuVectorI b){
+      return a*b;
+    }
+  };
+
+  struct Div{
+    // Real float
+    accelerator_inline GpuVectorRF operator()(GpuVectorRF a, GpuVectorRF b){
+      return a/b;
+    }
+    accelerator_inline GpuVectorRD operator()(GpuVectorRD a, GpuVectorRD b){
+      return a/b;
+    }
+    accelerator_inline GpuVectorI operator()(GpuVectorI a, GpuVectorI b){
+      return a/b;
+    }
+
+    // Danger -- element wise divide fro complex, not complex div. 
+    // See Grid_vector_types.h lines around 735, applied after "toReal"
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF a, GpuVectorCF b){
+      return a/b;
+    }
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD a, GpuVectorCD b){
+      return a/b;
+    }
+  };
+
+
+  struct Conj{
+    // Complex single
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF in){
+      typedef GpuVectorCF vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = in.rrrr[i];
+	ret.iiii[i] =-in.iiii[i];
+      }
+      return ret;
+    }
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD in){
+      typedef GpuVectorCD vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = in.rrrr[i];
+	ret.iiii[i] =-in.iiii[i];
+      }
+      return ret;
+    }
+  };
+
+  struct TimesMinusI{
+    //Complex single
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF in){
+      typedef GpuVectorCF vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = in.iiii[i];
+	ret.iiii[i] =-in.rrrr[i];
+      }
+      return ret;
+    }
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD in){
+      typedef GpuVectorCD vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] = in.iiii[i];
+	ret.iiii[i] =-in.rrrr[i];
+      }
+      return ret;
+    }
+  };
+
+  struct TimesI{
+    //Complex single
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF in){
+      typedef GpuVectorCF vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] =-in.iiii[i];
+	ret.iiii[i] = in.rrrr[i];
+      }
+      return ret;
+    }
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD in){
+      typedef GpuVectorCD vec;
+      vec ret;
+      for(int i=0;i<vec::N;i++){
+	ret.rrrr[i] =-in.iiii[i];
+	ret.iiii[i] = in.rrrr[i];
+      }
+      return ret;
+    }
+  };
+
+  struct Permute{
+
+    template <int n,int _N, class _datum >
+    static accelerator_inline GpuVector<_N,_datum> PermuteN(GpuVector<_N,_datum> &in) {   
+      typedef GpuVector<_N,_datum> vec;
+      vec out;					
+      unsigned int _mask = vec::N >> (n + 1);	
+      for(int i=0;i<vec::N;i++) {
+	out.rrrr[i] = in.rrrr[i^_mask];
+      }
+      return out;	
+    }
+    template <int n,int _N, class _datum >
+    static accelerator_inline GpuComplexVector<_N,_datum> PermuteN(GpuComplexVector<_N,_datum> &in) {   
+      typedef GpuComplexVector<_N,_datum> vec;
+      vec out;					
+      unsigned int _mask = vec::N >> (n + 1);	
+      for(int i=0;i<vec::N;i++) {
+	out.rrrr[i] = in.rrrr[i^_mask];
+	out.iiii[i] = in.iiii[i^_mask];
+      }
+      return out;	
+    }
+    
+    template <typename vec>  static accelerator_inline vec Permute0(vec in) { return PermuteN<0,vec::N,typename vec::datum>(in);  }
+    template <typename vec>  static accelerator_inline vec Permute1(vec in) { return PermuteN<1,vec::N,typename vec::datum>(in);  }
+    template <typename vec>  static accelerator_inline vec Permute2(vec in) { return PermuteN<2,vec::N,typename vec::datum>(in);  }
+    template <typename vec>  static accelerator_inline vec Permute3(vec in) { return PermuteN<3,vec::N,typename vec::datum>(in);  }
+    
+  };
+  
+  struct PrecisionChange {
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // Single / Half
+    ////////////////////////////////////////////////////////////////////////////////////
+     static accelerator_inline GpuVectorCH StoH (GpuVectorCF a,GpuVectorCF b) {
+      int N = GpuVectorCF::N;
+      GpuVectorCH h;
+      for(int i=0;i<N;i++) {
+        h.rrrr[i  ] = float2half(a.rrrr[i]);
+        h.iiii[i  ] = float2half(a.iiii[i]);
+	h.rrrr[i+N] = float2half(b.rrrr[i]);
+	h.iiii[i+N] = float2half(b.iiii[i]);
+      }
+      return h;
+    }
+    static accelerator_inline void  HtoS (GpuVectorCH h,GpuVectorCF &sa,GpuVectorCF &sb) {
+      int N = GpuVectorCF::N;
+      for(int i=0;i<N;i++) {
+	sa.rrrr[i] = half2float(h.rrrr[i  ]);
+	sa.iiii[i] = half2float(h.iiii[i  ]);
+	sb.rrrr[i] = half2float(h.rrrr[i+N]);
+	sb.iiii[i] = half2float(h.iiii[i+N]);
+      }
+    }
+    static accelerator_inline GpuVectorRH StoH (GpuVectorRF a,GpuVectorRF b) {
+      int N = GpuVectorRF::N;
+      GpuVectorRH h;
+      for(int i=0;i<N;i++) {
+        h.rrrr[i  ] = float2half(a.rrrr[i]);
+	h.rrrr[i+N] = float2half(b.rrrr[i]);
+      }
+      return h;
+    }
+    static accelerator_inline void  HtoS (GpuVectorRH h,GpuVectorRF &sa,GpuVectorRF &sb) {
+      int N = GpuVectorRF::N;
+      for(int i=0;i<N;i++) {
+	sa.rrrr[i] = half2float(h.rrrr[i  ]);
+	sb.rrrr[i] = half2float(h.rrrr[i+N]);
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // Double Single
+    ////////////////////////////////////////////////////////////////////////////////////
+    static accelerator_inline GpuVectorCF DtoS (GpuVectorCD a,GpuVectorCD b) {
+      int N = GpuVectorCD::N;
+      GpuVectorCF h;
+      for(int i=0;i<N;i++) {
+        h.rrrr[i  ] = a.rrrr[i];
+        h.iiii[i  ] = a.iiii[i];
+	h.rrrr[i+N] = b.rrrr[i];
+	h.iiii[i+N] = b.iiii[i];
+      }
+      return h;
+    }
+
+    static accelerator_inline void  StoD (GpuVectorCF h,GpuVectorCD &sa,GpuVectorCD &sb) {
+      int N = GpuVectorCD::N;
+      for(int i=0;i<N;i++) {
+	sa.rrrr[i] = h.rrrr[i  ];
+	sa.iiii[i] = h.iiii[i  ];
+	sb.rrrr[i] = h.rrrr[i+N];
+	sb.iiii[i] = h.iiii[i+N];
+      }
+    }
+
+    static accelerator_inline GpuVectorRF DtoS (GpuVectorRD a,GpuVectorRD b) {
+      int N = GpuVectorRD::N;
+      GpuVectorRF h;
+      for(int i=0;i<N;i++) {
+        h.rrrr[i  ] = a.rrrr[i];
+	h.rrrr[i+N] = b.rrrr[i];
+      }
+      return h;
+    }
+
+    static accelerator_inline void  StoD (GpuVectorRF h,GpuVectorRD &sa,GpuVectorRD &sb) {
+      int N = GpuVectorRD::N;
+      for(int i=0;i<N;i++) {
+	sa.rrrr[i] = h.rrrr[i  ];
+	sb.rrrr[i] = h.rrrr[i+N];
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // Double Half
+    ////////////////////////////////////////////////////////////////////////////////////
+    static accelerator_inline GpuVectorCH DtoH (GpuVectorCD a,GpuVectorCD b,GpuVectorCD c,GpuVectorCD d) {
+      GpuVectorCF sa,sb;
+      sa = DtoS(a,b);
+      sb = DtoS(c,d);
+      return StoH(sa,sb);
+    }
+    static accelerator_inline void HtoD (GpuVectorCH h,GpuVectorCD &a,GpuVectorCD &b,GpuVectorCD &c,GpuVectorCD &d) {
+      GpuVectorCF sa,sb;
+      HtoS(h,sa,sb);
+      StoD(sa,a,b);
+      StoD(sb,c,d);
+    }
+    static accelerator_inline GpuVectorRH DtoH (GpuVectorRD a,GpuVectorRD b,GpuVectorRD c,GpuVectorRD d) {
+      GpuVectorRF sa,sb;
+      sa = DtoS(a,b);
+      sb = DtoS(c,d);
+      return StoH(sa,sb);
+    }
+    static accelerator_inline void HtoD (GpuVectorRH h,GpuVectorRD &a,GpuVectorRD &b,GpuVectorRD &c,GpuVectorRD &d) {
+      GpuVectorRF sa,sb;
+      HtoS(h,sa,sb);
+      StoD(sa,a,b);
+      StoD(sb,c,d);
+    }
+  };
+
+struct Exchange{
+
+  template <int n,int _N, class _datum >
+  static accelerator_inline void ExchangeN(GpuVector<_N,_datum> &out1,
+					   GpuVector<_N,_datum> &out2,
+					   GpuVector<_N,_datum> &in1,
+					   GpuVector<_N,_datum> &in2 )
+  {   
+    typedef GpuVector<_N,_datum> vec;
+    unsigned int mask = vec::N >> (n + 1);
+    for(int i=0;i<vec::N;i++) {
+      int j1 = i&(~mask);
+      if  ( (i&mask) == 0 ) { out1.rrrr[i]=in1.rrrr[j1];}
+      else                  { out1.rrrr[i]=in2.rrrr[j1];}
+      int j2 = i|mask;
+      if  ( (i&mask) == 0 ) { out2.rrrr[i]=in1.rrrr[j2];}
+      else                  { out2.rrrr[i]=in2.rrrr[j2];}
+    }      
+  }
+  template <int n,int _N, class _datum >
+  static accelerator_inline void ExchangeN(GpuComplexVector<_N,_datum> &out1,
+					   GpuComplexVector<_N,_datum> &out2,
+					   GpuComplexVector<_N,_datum> &in1,
+					   GpuComplexVector<_N,_datum> &in2 )
+  {   
+    typedef GpuComplexVector<_N,_datum> vec;
+    unsigned int mask = vec::N >> (n + 1);
+    for(int i=0;i<vec::N;i++) {
+      int j1 = i&(~mask);
+      if  ( (i&mask) == 0 ) {
+	out1.rrrr[i]=in1.rrrr[j1];
+	out1.iiii[i]=in1.iiii[j1];
+      }
+      else                  {
+	out1.rrrr[i]=in2.rrrr[j1];
+	out1.iiii[i]=in2.iiii[j1];
+      }
+      int j2 = i|mask;
+      if  ( (i&mask) == 0 ) {
+	out2.rrrr[i]=in1.rrrr[j2];
+	out2.iiii[i]=in1.iiii[j2];
+      }
+      else                  {
+	out2.rrrr[i]=in2.rrrr[j2];
+	out2.iiii[i]=in2.iiii[j2];
+      }
+    }      
+  }
+  template <typename vec>
+  static accelerator_inline void Exchange0(vec &out1,vec &out2,vec &in1,vec &in2){
+    ExchangeN<0>(out1,out2,in1,in2);
+  };
+  template <typename vec>
+  static accelerator_inline void Exchange1(vec &out1,vec &out2,vec &in1,vec &in2){
+    ExchangeN<1>(out1,out2,in1,in2);
+  };
+  template <typename vec>
+  static accelerator_inline void Exchange2(vec &out1,vec &out2,vec &in1,vec &in2){
+    ExchangeN<2>(out1,out2,in1,in2);
+  };
+  template <typename vec>
+  static accelerator_inline void Exchange3(vec &out1,vec &out2,vec &in1,vec &in2){
+    ExchangeN<3>(out1,out2,in1,in2);
+  };
+
+};
+
+struct Rotate{
+
+  template <int n, typename vec> static accelerator_inline vec tRotate(vec in){
+    return rotate(in, n);
+  }
+    
+  template <int _N, class _datum >
+  static accelerator_inline GpuComplexVector<_N,_datum> rotate_template(GpuComplexVector<_N,_datum> &in, int n)
+  {
+    typedef GpuComplexVector<_N,_datum> vec;
+    vec out;
+    for(int i=0;i<vec::N;i++){
+      out.rrrr[i] = in.rrrr[(i + n)%vec::N];
+      out.iiii[i] = in.iiii[(i + n)%vec::N];
+    }
+    return out;
+  }
+
+  template <int _N, class _datum >
+  static accelerator_inline GpuVector<_N,_datum> rotate_template(GpuVector<_N,_datum> &in, int n)
+  {
+    typedef GpuVector<_N,_datum> vec;
+    vec out;
+    for(int i=0;i<vec::N;i++){
+      out.rrrr[i] = in.rrrr[(i + n)%vec::N];
+    }
+    return out;
+  }
+
+  typedef GpuVectorRH  SIMD_Htype; // Single precision type
+  typedef GpuVectorRF  SIMD_Ftype; // Single precision type
+  typedef GpuVectorRD  SIMD_Dtype; // Double precision type
+  typedef GpuVectorI   SIMD_Itype; // Integer type
+
+  typedef GpuVectorCH  SIMD_CHtype; // Single precision type
+  typedef GpuVectorCF  SIMD_CFtype; // Single precision type
+  typedef GpuVectorCD  SIMD_CDtype; // Double precision type
+
+  static accelerator_inline GpuVectorRH rotate(GpuVectorRH in, int n){ return rotate_template(in,n);}
+  static accelerator_inline GpuVectorRF rotate(GpuVectorRF in, int n){ return rotate_template(in,n);}
+  static accelerator_inline GpuVectorRD rotate(GpuVectorRD in, int n){ return rotate_template(in,n);}
+  static accelerator_inline GpuVectorI  rotate(GpuVectorI  in, int n){ return rotate_template(in,n);}
+  static accelerator_inline GpuVectorCH rotate(GpuVectorCH in, int n){ return rotate_template(in,n/2);} // Measure in complex not float
+  static accelerator_inline GpuVectorCF rotate(GpuVectorCF in, int n){ return rotate_template(in,n/2);}
+  static accelerator_inline GpuVectorCD rotate(GpuVectorCD in, int n){ return rotate_template(in,n/2);}
+
+};
+
+//////////////////////////////////////////////
+// Some Template specialization
+
+  //Complex float Reduce
+  template<>
+  accelerator_inline Grid::ComplexF 
+  Reduce<Grid::ComplexF, GpuVectorCF>::operator()(GpuVectorCF in)
+  {
+    Grid::ComplexF greduce(in.rrrr[0],in.iiii[0]);
+    for(int i=1;i<GpuVectorCF::N;i++) {
+      greduce = greduce+Grid::ComplexF(in.rrrr[i],in.iiii[i]);
+    }
+    return greduce;
+  }
+
+  template<>
+  accelerator_inline Grid::ComplexD
+  Reduce<Grid::ComplexD, GpuVectorCD>::operator()(GpuVectorCD in)
+  {
+    Grid::ComplexD greduce(in.rrrr[0],in.iiii[0]);
+    for(int i=1;i<GpuVectorCD::N;i++) {
+      greduce = greduce+ Grid::ComplexD(in.rrrr[i],in.iiii[i]);
+    }
+    return greduce;
+  }
+
+  // Real
+  template<>
+  accelerator_inline Grid::RealF 
+  Reduce<RealF, GpuVectorRF>::operator()(GpuVectorRF in)
+  {
+    RealF ret = in.rrrr[0];
+    for(int i=1;i<GpuVectorRF::N;i++) {
+      ret = ret+in.rrrr[i];
+    }
+    return ret;
+  }
+
+  template<>
+  accelerator_inline Grid::RealD 
+  Reduce<RealD, GpuVectorRD>::operator()(GpuVectorRD in)
+  {
+    RealD ret = in.rrrr[0];
+    for(int i=1;i<GpuVectorRD::N;i++) {
+      ret = ret+in.rrrr[i];
+    }
+    return ret;
+  }
+
+  template<>
+  accelerator_inline Integer
+  Reduce<Integer, GpuVectorI>::operator()(GpuVectorI in)
+  {
+    Integer ret = in.rrrr[0];
+    for(int i=1;i<GpuVectorI::N;i++) {
+      ret = ret+in.rrrr[i];
+    }
+    return ret;
+  }
+
+}// End optimizatoin
+
+//////////////////////////////////////////////////////////////////////////////////////
+// Here assign types 
+//////////////////////////////////////////////////////////////////////////////////////
+  typedef GpuVectorRH  SIMD_Htype; // Single precision type
+  typedef GpuVectorRF  SIMD_Ftype; // Single precision type
+  typedef GpuVectorRD  SIMD_Dtype; // Double precision type
+  typedef GpuVectorI   SIMD_Itype; // Integer type
+
+  typedef GpuVectorCH  SIMD_CHtype; // Single precision type
+  typedef GpuVectorCF  SIMD_CFtype; // Single precision type
+  typedef GpuVectorCD  SIMD_CDtype; // Double precision type
+
+  // prefetch utilities
+  accelerator_inline void v_prefetch0(int size, const char *ptr){};
+  accelerator_inline void prefetch_HINT_T0(const char *ptr){};
+
+  // Function name aliases
+  typedef Optimization::Vsplat   VsplatSIMD;
+  typedef Optimization::Vstore   VstoreSIMD;
+  typedef Optimization::Vset     VsetSIMD;
+  typedef Optimization::Vstream  VstreamSIMD;
+  template <typename S, typename T> using ReduceSIMD = Optimization::Reduce<S,T>;
+
+  // Arithmetic operations
+  typedef Optimization::Sum         SumSIMD;
+  typedef Optimization::Sub         SubSIMD;
+  typedef Optimization::Div         DivSIMD;
+  typedef Optimization::Mult        MultSIMD;
+  typedef Optimization::MultComplex MultComplexSIMD;
+  typedef Optimization::MultRealPart MultRealPartSIMD;
+  typedef Optimization::MaddRealPart MaddRealPartSIMD;
+  typedef Optimization::Conj        ConjSIMD;
+  typedef Optimization::TimesMinusI TimesMinusISIMD;
+  typedef Optimization::TimesI      TimesISIMD;
+
+}

Grid/simd/Grid_gpu_vec.h

@@ -38,7 +38,7 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 #ifdef GRID_HIP
 #include <hip/hip_fp16.h>
 #endif
-#ifdef GRID_SYCL
+#if !defined(GRID_CUDA) && !defined(GRID_HIP)
 namespace Grid {
   typedef struct { uint16_t x;} half;
   typedef struct { half   x; half   y;} half2;
@@ -486,7 +486,7 @@ namespace Optimization {
 
   struct TimesMinusI{
     //Complex single
-    accelerator_inline GpuVectorCF operator()(GpuVectorCF in,GpuVectorCF dummy){
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF in){
       typedef GpuVectorCF vec;
       vec ret;
       for(int i=0;i<vec::N;i++){
@@ -495,7 +495,7 @@ namespace Optimization {
       }
       return ret;
     }
-    accelerator_inline GpuVectorCD operator()(GpuVectorCD in,GpuVectorCD dummy){
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD in){
       typedef GpuVectorCD vec;
       vec ret;
       for(int i=0;i<vec::N;i++){
@@ -508,7 +508,7 @@ namespace Optimization {
 
   struct TimesI{
     //Complex single
-    accelerator_inline GpuVectorCF operator()(GpuVectorCF in,GpuVectorCF dummy){
+    accelerator_inline GpuVectorCF operator()(GpuVectorCF in){
       typedef GpuVectorCF vec;
       vec ret;
       for(int i=0;i<vec::N;i++){
@@ -517,7 +517,7 @@ namespace Optimization {
       }
       return ret;
     }
-    accelerator_inline GpuVectorCD operator()(GpuVectorCD in,GpuVectorCD dummy){
+    accelerator_inline GpuVectorCD operator()(GpuVectorCD in){
       typedef GpuVectorCD vec;
       vec ret;
       for(int i=0;i<vec::N;i++){

Grid/simd/Grid_qpx.h

@@ -356,7 +356,7 @@ struct Conj{
   
 struct TimesMinusI{
   //Complex double
-  inline vector4double operator()(vector4double v, vector4double ret){
+  inline vector4double operator()(vector4double v){
     return vec_xxcpnmadd(v, (vector4double){1., 1., 1., 1.},
 			 (vector4double){0., 0., 0., 0.});
   }
@@ -367,7 +367,7 @@ struct TimesMinusI{
   
 struct TimesI{
   //Complex double
-  inline vector4double operator()(vector4double v, vector4double ret){
+  inline vector4double operator()(vector4double v){
     return vec_xxcpnmadd(v, (vector4double){-1., -1., -1., -1.},
 			 (vector4double){0., 0., 0., 0.});
   }

Grid/simd/Grid_sse4.h

@@ -35,7 +35,7 @@ Author: neo <cossu@post.kek.jp>
 */
 // Time-stamp: <2015-06-16 23:27:54 neo>
 //----------------------------------------------------------------------
-
+#include <immintrin.h>
 #include <pmmintrin.h>
 
 NAMESPACE_BEGIN(Grid);
@@ -273,27 +273,25 @@ struct Conj{
 
 struct TimesMinusI{
   //Complex single
-  inline __m128 operator()(__m128 in, __m128 ret){
+  inline __m128 operator()(__m128 in){
     __m128 tmp =_mm_addsub_ps(_mm_setzero_ps(),in); // r,-i
     return _mm_shuffle_ps(tmp,tmp,_MM_SELECT_FOUR_FOUR(2,3,0,1));
   }
   //Complex double
-  inline __m128d operator()(__m128d in, __m128d ret){
+  inline __m128d operator()(__m128d in){
     __m128d tmp =_mm_addsub_pd(_mm_setzero_pd(),in); // r,-i
     return _mm_shuffle_pd(tmp,tmp,0x1);
   }
-
-
 };
 
 struct TimesI{
   //Complex single
-  inline __m128 operator()(__m128 in, __m128 ret){
+  inline __m128 operator()(__m128 in){
     __m128 tmp =_mm_shuffle_ps(in,in,_MM_SELECT_FOUR_FOUR(2,3,0,1));
     return _mm_addsub_ps(_mm_setzero_ps(),tmp); // r,-i
   }
   //Complex double
-  inline __m128d operator()(__m128d in, __m128d ret){
+  inline __m128d operator()(__m128d in){
     __m128d tmp = _mm_shuffle_pd(in,in,0x1);
     return _mm_addsub_pd(_mm_setzero_pd(),tmp); // r,-i
   }

Grid/simd/Grid_vector_types.h

@@ -110,11 +110,10 @@ accelerator_inline Grid_half sfw_float_to_half(float ff) {
 #ifdef GPU_VEC
 #include "Grid_gpu_vec.h"
 #endif
-/*
-#ifdef GEN
-#include "Grid_generic.h"
+
+#ifdef GPU_RRII
+#include "Grid_gpu_rrii.h"
 #endif
-*/
 
 #ifdef GEN
   #if defined(A64FX) || defined(A64FXFIXEDSIZE) // breakout A64FX SVE ACLE here
@@ -131,7 +130,6 @@ accelerator_inline Grid_half sfw_float_to_half(float ff) {
       #include "Grid_a64fx-fixedsize.h"
     #endif
   #else
-    //#pragma message("building GEN") // generic
     #include "Grid_generic.h"
   #endif
 #endif
@@ -150,23 +148,6 @@ accelerator_inline Grid_half sfw_float_to_half(float ff) {
   #endif
 #endif
 
-/*
-#ifdef A64FXVLA
-#pragma message("building A64FX VLA")
-#if defined(ARMCLANGCOMPAT)
-  #pragma message("applying data types patch")
-#endif
-#include <arm_sve.h>
-#include "Grid_a64fx-2.h"
-#endif
-
-#ifdef A64FXVLS
-#pragma message("building A64FX VLS")
-#include <arm_sve.h>
-#include "Grid_a64fx-fixedsize.h"
-#endif
-*/
-
 #ifdef SSE4
 #include "Grid_sse4.h"
 #endif
@@ -270,12 +251,14 @@ public:
   typedef Vector_type vector_type;
   typedef Scalar_type scalar_type;
 
+  /*
   typedef union conv_t_union {
     Vector_type v;
     Scalar_type s[sizeof(Vector_type) / sizeof(Scalar_type)];
     accelerator_inline conv_t_union(){};
   } conv_t;
-
+  */
+  
   Vector_type v;
 
   static accelerator_inline constexpr int Nsimd(void) {
@@ -555,15 +538,13 @@ public:
   template <class functor>
   friend accelerator_inline Grid_simd SimdApply(const functor &func, const Grid_simd &v) {
     Grid_simd ret;
-    Grid_simd::conv_t conv;
     Grid_simd::scalar_type s;
 
-    conv.v = v.v;
     for (int i = 0; i < Nsimd(); i++) {
-      s = conv.s[i];
-      conv.s[i] = func(s);
+      s = v.getlane(i);
+      s = func(s);
+      ret.putlane(s,i);
     }
-    ret.v = conv.v;
     return ret;
   }
   template <class functor>
@@ -571,18 +552,14 @@ public:
                                          const Grid_simd &x,
                                          const Grid_simd &y) {
     Grid_simd ret;
-    Grid_simd::conv_t cx;
-    Grid_simd::conv_t cy;
     Grid_simd::scalar_type sx,sy;
 
-    cx.v = x.v;
-    cy.v = y.v;
     for (int i = 0; i < Nsimd(); i++) {
-      sx = cx.s[i];
-      sy = cy.s[i];
-      cx.s[i] = func(sx,sy);
+      sx = x.getlane(i);
+      sy = y.getlane(i);
+      sx = func(sx,sy);
+      ret.putlane(sx,i);
     }
-    ret.v = cx.v;
     return ret;
   }
   ///////////////////////
@@ -645,15 +622,36 @@ public:
   ///////////////////////////////
   // Getting single lanes
   ///////////////////////////////
-  accelerator_inline Scalar_type getlane(int lane) {
+#ifdef GPU_RRII
+  template <class S = Scalar_type,IfComplex<S> = 0>
+  accelerator_inline Scalar_type getlane(int lane) const {
+    return Scalar_type(v.rrrr[lane],v.iiii[lane]);
+  }
+  template <class S = Scalar_type,IfComplex<S> = 0>
+  accelerator_inline void putlane(const Scalar_type &_S, int lane){
+    v.rrrr[lane] = real(_S);
+    v.iiii[lane] = imag(_S);
+  }
+  template <class S = Scalar_type,IfNotComplex<S> = 0>
+  accelerator_inline Scalar_type getlane(int lane) const {
+    return ((S*)&v)[lane];
+  }
+  template <class S = Scalar_type,IfNotComplex<S> = 0>
+  accelerator_inline void putlane(const S &_S, int lane){
+    ((Scalar_type*)&v)[lane] = _S;
+  }
+#else // Can pun to an array of complex
+  accelerator_inline Scalar_type getlane(int lane) const {
     return ((Scalar_type*)&v)[lane];
   }
-
   accelerator_inline void putlane(const Scalar_type &S, int lane){
     ((Scalar_type*)&v)[lane] = S;
   }
+#endif
+
 };  // end of Grid_simd class definition
 
+
 ///////////////////////////////
 // Define available types
 ///////////////////////////////
@@ -663,7 +661,7 @@ typedef Grid_simd<double , SIMD_Dtype> vRealD;
 typedef Grid_simd<Integer, SIMD_Itype> vInteger;
 typedef Grid_simd<uint16_t,SIMD_Htype> vRealH;
 
-#ifdef GPU_VEC
+#if defined(GPU_VEC) || defined(GPU_RRII)
 typedef Grid_simd<complex<uint16_t>, SIMD_CHtype> vComplexH;
 typedef Grid_simd<complex<float>   , SIMD_CFtype> vComplexF;
 typedef Grid_simd<complex<double>  , SIMD_CDtype> vComplexD;
@@ -763,6 +761,7 @@ accelerator_inline void vsplat(Grid_simd<S, V> &ret, NotEnableIf<is_complex<S>,
 }
 //////////////////////////
 
+
 ///////////////////////////////////////////////
 // Initialise to 1,0,i for the correct types
 ///////////////////////////////////////////////
@@ -907,34 +906,6 @@ accelerator_inline Grid_simd<S, V> fxmac(Grid_simd<S, V> a, Grid_simd<S, V> b, G
 // ----------------------------------------------
 
 
-// Distinguish between complex types and others
-template <class S, class V, IfComplex<S> = 0>
-accelerator_inline Grid_simd<S, V> operator/(Grid_simd<S, V> a, Grid_simd<S, V> b) {
-  typedef Grid_simd<S, V> simd;
-
-  simd ret;
-  simd den;
-  typename simd::conv_t conv;
-
-  ret = a * conjugate(b) ;
-  den = b * conjugate(b) ;
-
-  // duplicates real part
-  auto real_den  = toReal(den);
-  simd zden;
-  memcpy((void *)&zden.v,(void *)&real_den.v,sizeof(zden));
-  ret.v=binary<V>(ret.v, zden.v, DivSIMD());
-  return ret;
-};
-
-// Real/Integer types
-template <class S, class V, IfNotComplex<S> = 0>
-accelerator_inline Grid_simd<S, V> operator/(Grid_simd<S, V> a, Grid_simd<S, V> b) {
-  Grid_simd<S, V> ret;
-  ret.v = binary<V>(a.v, b.v, DivSIMD());
-  return ret;
-};
-
 ///////////////////////
 // Conjugate
 ///////////////////////
@@ -959,30 +930,29 @@ accelerator_inline Grid_simd<S, V> adj(const Grid_simd<S, V> &in) {
 ///////////////////////
 template <class S, class V, IfComplex<S> = 0>
 accelerator_inline void timesMinusI(Grid_simd<S, V> &ret, const Grid_simd<S, V> &in) {
-  ret.v = binary<V>(in.v, ret.v, TimesMinusISIMD());
+  ret.v = unary<V>(in.v, TimesMinusISIMD());
 }
 template <class S, class V, IfComplex<S> = 0>
 accelerator_inline Grid_simd<S, V> timesMinusI(const Grid_simd<S, V> &in) {
   Grid_simd<S, V> ret;
-  timesMinusI(ret, in);
+  ret.v=unary<V>(in.v, TimesMinusISIMD());
   return ret;
 }
 template <class S, class V, IfNotComplex<S> = 0>
 accelerator_inline Grid_simd<S, V> timesMinusI(const Grid_simd<S, V> &in) {
   return in;
 }
-
 ///////////////////////
 // timesI
 ///////////////////////
 template <class S, class V, IfComplex<S> = 0>
 accelerator_inline void timesI(Grid_simd<S, V> &ret, const Grid_simd<S, V> &in) {
-  ret.v = binary<V>(in.v, ret.v, TimesISIMD());
+  ret.v = unary<V>(in.v, TimesISIMD());
 }
 template <class S, class V, IfComplex<S> = 0>
 accelerator_inline Grid_simd<S, V> timesI(const Grid_simd<S, V> &in) {
   Grid_simd<S, V> ret;
-  timesI(ret, in);
+  ret.v= unary<V>(in.v, TimesISIMD());
   return ret;
 }
 template <class S, class V, IfNotComplex<S> = 0>
@@ -990,6 +960,35 @@ accelerator_inline Grid_simd<S, V> timesI(const Grid_simd<S, V> &in) {
   return in;
 }
 
+
+// Distinguish between complex types and others
+template <class S, class V, IfComplex<S> = 0>
+accelerator_inline Grid_simd<S, V> operator/(Grid_simd<S, V> a, Grid_simd<S, V> b) {
+  typedef Grid_simd<S, V> simd;
+
+  simd ret;
+  simd den;
+
+  ret = a * conjugate(b) ;
+  den = b * conjugate(b) ;
+
+  // duplicates real part
+  auto real_den  = toReal(den);
+  simd zden;
+  memcpy((void *)&zden.v,(void *)&real_den.v,sizeof(zden));
+  ret.v=binary<V>(ret.v, zden.v, DivSIMD());
+  return ret;
+};
+
+// Real/Integer types
+template <class S, class V, IfNotComplex<S> = 0>
+accelerator_inline Grid_simd<S, V> operator/(Grid_simd<S, V> a, Grid_simd<S, V> b) {
+  Grid_simd<S, V> ret;
+  ret.v = binary<V>(a.v, b.v, DivSIMD());
+  return ret;
+};
+
+
 /////////////////////
 // Inner, outer
 /////////////////////
@@ -1021,12 +1020,12 @@ template <class Csimd>  // must be a real arg
 accelerator_inline typename toRealMapper<Csimd>::Realified toReal(const Csimd &in) {
   typedef typename toRealMapper<Csimd>::Realified Rsimd;
   Rsimd ret;
-  typename Rsimd::conv_t conv;
-  memcpy((void *)&conv.v,(void *)&in.v,sizeof(conv.v));
+  int j=0;
   for (int i = 0; i < Rsimd::Nsimd(); i += 2) {
-    conv.s[i + 1] = conv.s[i];  // duplicate (r,r);(r,r);(r,r); etc...
+    auto s = real(in.getlane(j++));
+    ret.putlane(s,i);
+    ret.putlane(s,i+1);
   }
-  memcpy((void *)&ret.v,(void *)&conv.v,sizeof(ret.v));
   return ret;
 }
 
@@ -1039,23 +1038,24 @@ template <class Rsimd>  // must be a real arg
 accelerator_inline typename toComplexMapper<Rsimd>::Complexified toComplex(const Rsimd &in) {
 
   typedef typename toComplexMapper<Rsimd>::Complexified   Csimd;
-  typename Rsimd::conv_t conv;  // address as real
-
-  conv.v = in.v;
+  typedef typename Csimd::scalar_type scalar_type;
+  int j=0;
+  Csimd ret;
   for (int i = 0; i < Rsimd::Nsimd(); i += 2) {
-    assert(conv.s[i + 1] == conv.s[i]);
+    auto rr = in.getlane(i);
+    auto ri = in.getlane(i+1);
+    assert(rr==ri);
     // trap any cases where real was not duplicated
     // indicating the SIMD grids of real and imag assignment did not correctly
     // match
-    conv.s[i + 1] = 0.0;  // zero imaginary parts
+    scalar_type s(rr,0.0);
+    ret.putlane(s,j++);
   }
-  Csimd ret;
-  memcpy((void *)&ret.v,(void *)&conv.v,sizeof(ret.v));
   return ret;
 }
 
 
-accelerator_inline void precisionChange(vRealF    *out,vRealD    *in,int nvec)
+accelerator_inline void precisionChange(vRealF    *out,const vRealD    *in,int nvec)
 {
   assert((nvec&0x1)==0);
   for(int m=0;m*2<nvec;m++){
@@ -1063,7 +1063,7 @@ accelerator_inline void precisionChange(vRealF    *out,vRealD    *in,int nvec)
     out[m].v=Optimization::PrecisionChange::DtoS(in[n].v,in[n+1].v);
   }
 }
-accelerator_inline void precisionChange(vRealH    *out,vRealD    *in,int nvec)
+accelerator_inline void precisionChange(vRealH    *out,const vRealD    *in,int nvec)
 {
   assert((nvec&0x3)==0);
   for(int m=0;m*4<nvec;m++){
@@ -1071,7 +1071,7 @@ accelerator_inline void precisionChange(vRealH    *out,vRealD    *in,int nvec)
     out[m].v=Optimization::PrecisionChange::DtoH(in[n].v,in[n+1].v,in[n+2].v,in[n+3].v);
   }
 }
-accelerator_inline void precisionChange(vRealH    *out,vRealF    *in,int nvec)
+accelerator_inline void precisionChange(vRealH    *out,const vRealF    *in,int nvec)
 {
   assert((nvec&0x1)==0);
   for(int m=0;m*2<nvec;m++){
@@ -1079,7 +1079,7 @@ accelerator_inline void precisionChange(vRealH    *out,vRealF    *in,int nvec)
     out[m].v=Optimization::PrecisionChange::StoH(in[n].v,in[n+1].v);
   }
 }
-accelerator_inline void precisionChange(vRealD    *out,vRealF    *in,int nvec)
+accelerator_inline void precisionChange(vRealD    *out,const vRealF    *in,int nvec)
 {
   assert((nvec&0x1)==0);
   for(int m=0;m*2<nvec;m++){
@@ -1095,7 +1095,7 @@ accelerator_inline void precisionChange(vRealD    *out,vRealF    *in,int nvec)
     //  |                                                 ~~~~~~~^
   }
 }
-accelerator_inline void precisionChange(vRealD    *out,vRealH    *in,int nvec)
+accelerator_inline void precisionChange(vRealD    *out,const vRealH    *in,int nvec)
 {
   assert((nvec&0x3)==0);
   for(int m=0;m*4<nvec;m++){
@@ -1103,7 +1103,7 @@ accelerator_inline void precisionChange(vRealD    *out,vRealH    *in,int nvec)
     Optimization::PrecisionChange::HtoD(in[m].v,out[n].v,out[n+1].v,out[n+2].v,out[n+3].v);
   }
 }
-accelerator_inline void precisionChange(vRealF    *out,vRealH    *in,int nvec)
+accelerator_inline void precisionChange(vRealF    *out,const vRealH    *in,int nvec)
 {
   assert((nvec&0x1)==0);
   for(int m=0;m*2<nvec;m++){
@@ -1111,12 +1111,12 @@ accelerator_inline void precisionChange(vRealF    *out,vRealH    *in,int nvec)
     Optimization::PrecisionChange::HtoS(in[m].v,out[n].v,out[n+1].v);
   }
 }
-accelerator_inline void precisionChange(vComplexF *out,vComplexD *in,int nvec){ precisionChange((vRealF *)out,(vRealD *)in,nvec);}
-accelerator_inline void precisionChange(vComplexH *out,vComplexD *in,int nvec){ precisionChange((vRealH *)out,(vRealD *)in,nvec);}
-accelerator_inline void precisionChange(vComplexH *out,vComplexF *in,int nvec){ precisionChange((vRealH *)out,(vRealF *)in,nvec);}
-accelerator_inline void precisionChange(vComplexD *out,vComplexF *in,int nvec){ precisionChange((vRealD *)out,(vRealF *)in,nvec);}
-accelerator_inline void precisionChange(vComplexD *out,vComplexH *in,int nvec){ precisionChange((vRealD *)out,(vRealH *)in,nvec);}
-accelerator_inline void precisionChange(vComplexF *out,vComplexH *in,int nvec){ precisionChange((vRealF *)out,(vRealH *)in,nvec);}
+accelerator_inline void precisionChange(vComplexF *out,const vComplexD *in,int nvec){ precisionChange((vRealF *)out,(vRealD *)in,nvec);}
+accelerator_inline void precisionChange(vComplexH *out,const vComplexD *in,int nvec){ precisionChange((vRealH *)out,(vRealD *)in,nvec);}
+accelerator_inline void precisionChange(vComplexH *out,const vComplexF *in,int nvec){ precisionChange((vRealH *)out,(vRealF *)in,nvec);}
+accelerator_inline void precisionChange(vComplexD *out,const vComplexF *in,int nvec){ precisionChange((vRealD *)out,(vRealF *)in,nvec);}
+accelerator_inline void precisionChange(vComplexD *out,const vComplexH *in,int nvec){ precisionChange((vRealD *)out,(vRealH *)in,nvec);}
+accelerator_inline void precisionChange(vComplexF *out,const vComplexH *in,int nvec){ precisionChange((vRealF *)out,(vRealH *)in,nvec);}
 
 // Check our vector types are of an appropriate size.
 
@@ -1130,21 +1130,6 @@ static_assert(sizeof(SIMD_Ftype) == sizeof(SIMD_Itype), "SIMD vector lengths inc
 #endif
 #endif
 
-/////////////////////////////////////////
-// Some traits to recognise the types
-/////////////////////////////////////////
-template <typename T>
-struct is_simd : public std::false_type {};
-template <> struct is_simd<vRealF>     : public std::true_type {};
-template <> struct is_simd<vRealD>     : public std::true_type {};
-template <> struct is_simd<vRealH>     : public std::true_type {};
-template <> struct is_simd<vComplexF>  : public std::true_type {};
-template <> struct is_simd<vComplexD>  : public std::true_type {};
-template <> struct is_simd<vComplexH>  : public std::true_type {};
-template <> struct is_simd<vInteger>   : public std::true_type {};
-
-template <typename T> using IfSimd    = Invoke<std::enable_if<is_simd<T>::value, int> >;
-template <typename T> using IfNotSimd = Invoke<std::enable_if<!is_simd<T>::value, unsigned> >;
 
 NAMESPACE_END(Grid);
 

Grid/simd/Grid_vector_unops.h

@@ -29,8 +29,7 @@ See the full license in the file "LICENSE" in the top level distribution
 directory
 *************************************************************************************/
 			   /*  END LEGAL */
-#ifndef GRID_VECTOR_UNOPS
-#define GRID_VECTOR_UNOPS
+#pragma once
 
 #include <cmath>
 
@@ -112,6 +111,9 @@ template <class scalar>
 struct ImagFunctor {
   accelerator scalar operator()(const scalar &a) const { return imag(a); }
 };
+/////////////
+// Unary operations
+/////////////
 template <class S, class V>
 accelerator_inline Grid_simd<S, V> real(const Grid_simd<S, V> &r) {
   return SimdApply(RealFunctor<S>(), r);
@@ -168,6 +170,65 @@ template <class S, class V>
 accelerator_inline Grid_simd<S, V> div(const Grid_simd<S, V> &r, Integer y) {
   return SimdApply(DivIntFunctor<S>(y), r);
 }
+/// Double 2 cases
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> real(const Grid_simd2<S, V> &r) {
+  return SimdApply(RealFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> imag(const Grid_simd2<S, V> &r) {
+  return SimdApply(ImagFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> sqrt(const Grid_simd2<S, V> &r) {
+  return SimdApply(SqrtRealFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> cos(const Grid_simd2<S, V> &r) {
+  return SimdApply(CosRealFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> sin(const Grid_simd2<S, V> &r) {
+  return SimdApply(SinRealFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> acos(const Grid_simd2<S, V> &r) {
+  return SimdApply(AcosRealFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> asin(const Grid_simd2<S, V> &r) {
+  return SimdApply(AsinRealFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> log(const Grid_simd2<S, V> &r) {
+  return SimdApply(LogRealFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> abs(const Grid_simd2<S, V> &r) {
+  return SimdApply(AbsRealFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> exp(const Grid_simd2<S, V> &r) {
+  return SimdApply(ExpFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> Not(const Grid_simd2<S, V> &r) {
+  return SimdApply(NotFunctor<S>(), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> pow(const Grid_simd2<S, V> &r, double y) {
+  return SimdApply(PowRealFunctor<S>(y), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> mod(const Grid_simd2<S, V> &r, Integer y) {
+  return SimdApply(ModIntFunctor<S>(y), r);
+}
+template <class S, class V>
+accelerator_inline Grid_simd2<S, V> div(const Grid_simd2<S, V> &r, Integer y) {
+  return SimdApply(DivIntFunctor<S>(y), r);
+}
+
+
 ////////////////////////////////////////////////////////////////////////////
 // Allows us to assign into **conformable** real vectors from complex
 ////////////////////////////////////////////////////////////////////////////
@@ -193,23 +254,22 @@ struct OrOrFunctor {
 ////////////////////////////////
 template <class S, class V>
 accelerator_inline Grid_simd<S, V> operator&(const Grid_simd<S, V> &x,
-				 const Grid_simd<S, V> &y) {
+					     const Grid_simd<S, V> &y) {
   return SimdApplyBinop(AndFunctor<S>(), x, y);
 }
 template <class S, class V>
 accelerator_inline Grid_simd<S, V> operator&&(const Grid_simd<S, V> &x,
-				  const Grid_simd<S, V> &y) {
+					      const Grid_simd<S, V> &y) {
   return SimdApplyBinop(AndAndFunctor<S>(), x, y);
 }
 template <class S, class V>
 accelerator_inline Grid_simd<S, V> operator|(const Grid_simd<S, V> &x,
-				 const Grid_simd<S, V> &y) {
+					     const Grid_simd<S, V> &y) {
   return SimdApplyBinop(OrFunctor<S>(), x, y);
 }
 template <class S, class V>
 accelerator_inline Grid_simd<S, V> operator||(const Grid_simd<S, V> &x,
-				  const Grid_simd<S, V> &y) {
+					      const Grid_simd<S, V> &y) {
   return SimdApplyBinop(OrOrFunctor<S>(), x, y);
 }
 NAMESPACE_END(Grid);
-#endif

Grid/simd/Simd.h

@@ -69,6 +69,7 @@ typedef RealF  Real;
 typedef thrust::complex<RealF> ComplexF;
 typedef thrust::complex<RealD> ComplexD;
 typedef thrust::complex<Real>  Complex;
+typedef thrust::complex<uint16_t>  ComplexH;
 template<class T> using complex = thrust::complex<T>;
 
 accelerator_inline ComplexD pow(const ComplexD& r,RealD y){ return(thrust::pow(r,(double)y)); }
@@ -77,6 +78,7 @@ accelerator_inline ComplexF pow(const ComplexF& r,RealF y){ return(thrust::pow(r
 typedef std::complex<RealF> ComplexF;
 typedef std::complex<RealD> ComplexD;
 typedef std::complex<Real>  Complex;
+typedef std::complex<uint16_t>  ComplexH; // Hack
 template<class T> using complex = std::complex<T>;
 
 accelerator_inline ComplexD pow(const ComplexD& r,RealD y){ return(std::pow(r,y)); }
@@ -224,18 +226,14 @@ accelerator_inline void Gpermute(VectorSIMD &y,const VectorSIMD &b,int perm);
 NAMESPACE_END(Grid);
 
 #include <Grid/simd/Grid_vector_types.h>
+#include <Grid/simd/Grid_doubled_vector.h>
 #include <Grid/simd/Grid_vector_unops.h>
 
 NAMESPACE_BEGIN(Grid);
-// Default precision
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
+
+// Default precision is wired to double
 typedef vRealD vReal;
 typedef vComplexD vComplex;
-#else
-typedef vRealF vReal;
-typedef vComplexF vComplex;
-#endif
-
  
 inline std::ostream& operator<< (std::ostream& stream, const vComplexF &o){
   int nn=vComplexF::Nsimd();
@@ -262,6 +260,13 @@ inline std::ostream& operator<< (std::ostream& stream, const vComplexD &o){
   stream<<">";
   return stream;
 }
+inline std::ostream& operator<< (std::ostream& stream, const vComplexD2 &o){
+  stream<<"<";
+  stream<<o.v[0];
+  stream<<o.v[1];
+  stream<<">";
+  return stream;
+}
 
 inline std::ostream& operator<< (std::ostream& stream, const vRealF &o){
   int nn=vRealF::Nsimd();

Grid/stencil/SimpleCompressor.h

@@ -3,26 +3,108 @@
 
 NAMESPACE_BEGIN(Grid);
 
-template<class vobj>
-accelerator_inline void exchangeSIMT(vobj &mp0,vobj &mp1,const vobj &vp0,const vobj &vp1,Integer type)
-{
-    typedef decltype(coalescedRead(mp0)) sobj;
-    unsigned int Nsimd = vobj::Nsimd();
-    unsigned int mask = Nsimd >> (type + 1);
-    int lane = acceleratorSIMTlane(Nsimd);
-    int j0 = lane &(~mask); // inner coor zero
-    int j1 = lane |(mask) ; // inner coor one
-    const vobj *vpa = &vp0;
-    const vobj *vpb = &vp1;
-    const vobj *vp = (lane&mask) ? (vpb) : (vpa);
-    auto sa = coalescedRead(vp[0],j0);
-    auto sb = coalescedRead(vp[0],j1);
-    coalescedWrite(mp0,sa);
-    coalescedWrite(mp1,sb);
-}
+class SimpleStencilParams{
+public:
+  Coordinate dirichlet;
+  int partialDirichlet;
+  SimpleStencilParams() { partialDirichlet = 0; };
+};
 
-template<class vobj>
-class SimpleCompressor {
+
+// Compressors will inherit buffer management policies
+// Standard comms buffer management
+class FaceGatherSimple
+{
+public:
+  static int PartialCompressionFactor(GridBase *grid) {return 1;};
+  // Decompress is after merge so ok
+  template<class vobj,class cobj,class compressor> 
+  static void Gather_plane_simple (commVector<std::pair<int,int> >& table,
+				   const Lattice<vobj> &rhs,
+				   cobj *buffer,
+				   compressor &compress,
+				   int off,int so,int partial)
+  {
+    int num=table.size();
+    std::pair<int,int> *table_v = & table[0];
+    
+    auto rhs_v = rhs.View(AcceleratorRead);
+    accelerator_forNB( i,num, vobj::Nsimd(), {
+	compress.Compress(buffer[off+table_v[i].first],rhs_v[so+table_v[i].second]);
+    });
+    rhs_v.ViewClose();
+  }
+  template<class vobj,class cobj,class compressor>
+  static void Gather_plane_exchange(commVector<std::pair<int,int> >& table,const Lattice<vobj> &rhs,
+				    Vector<cobj *> pointers,int dimension,int plane,int cbmask,
+				    compressor &compress,int type,int partial)
+  {
+    assert( (table.size()&0x1)==0);
+    int num=table.size()/2;
+    int so  = plane*rhs.Grid()->_ostride[dimension]; // base offset for start of plane
+    
+    auto rhs_v = rhs.View(AcceleratorRead);
+    auto p0=&pointers[0][0];
+    auto p1=&pointers[1][0];
+    auto tp=&table[0];
+    auto rhs_p = &rhs_v[0];
+    accelerator_forNB(j, num, vobj::Nsimd(), {
+	compress.CompressExchange(p0[j],p1[j],
+				  rhs_p[so+tp[2*j  ].second],
+				  rhs_p[so+tp[2*j+1].second],
+				  type);
+    });
+    rhs_v.ViewClose();
+  }
+
+  template<class decompressor,class Decompression>
+  static void DecompressFace(decompressor decompress,Decompression &dd)
+  {
+    auto kp = dd.kernel_p;
+    auto mp = dd.mpi_p;
+    accelerator_forNB(o,dd.buffer_size,1,{
+      decompress.Decompress(kp[o],mp[o]);
+    });
+  }
+  template<class decompressor,class Merger>
+  static void MergeFace(decompressor decompress,Merger &mm)
+  {
+    auto mp = &mm.mpointer[0];
+    auto vp0= &mm.vpointers[0][0];
+    auto vp1= &mm.vpointers[1][0];
+    auto type= mm.type;
+    accelerator_forNB(o,mm.buffer_size/2,vobj::Nsimd(),{
+	decompress.Exchange(mp[2*o],mp[2*o+1],vp0[o],vp1[o],type);
+    });
+  }
+};
+
+////////////////////////////////////
+// Wilson compressor will add alternate policies for Dirichlet
+// and possibly partial Dirichlet for DWF
+////////////////////////////////////
+/*
+class FaceGatherDirichlet
+{
+  // If it's dirichlet we don't assemble comms buffers
+  //
+  // Rely on zeroes in gauge field to drive the correct result
+  // NAN propgagation: field will locally wrap, so fermion should NOT contain NAN and just permute
+  template<class vobj,class cobj,class compressor>
+  static void Gather_plane_simple (commVector<std::pair<int,int> >& table,const Lattice<vobj> &rhs,cobj *buffer,compressor &compress, int off,int so){};
+  template<class vobj,class cobj,class compressor>
+  static void Gather_plane_exchange(commVector<std::pair<int,int> >& table,const Lattice<vobj> &rhs,
+				   Vector<cobj *> pointers,int dimension,int plane,int cbmask,
+				   compressor &compress,int type) {}
+  template<class decompressor,class Merger>
+  static void Merge(decompressor decompress,Merge &mm)  {  }
+  template<class decompressor,class Decompression>
+  static void Decompress(decompressor decompress,Decompression &dd) {}
+};
+*/
+
+template<class vobj,class FaceGather>
+class SimpleCompressorGather : public FaceGather {
 public:
   void Point(int) {};
   accelerator_inline int  CommDatumSize(void) const { return sizeof(vobj); }
@@ -30,20 +112,19 @@ public:
   accelerator_inline void Compress(vobj &buf,const vobj &in) const {
     coalescedWrite(buf,coalescedRead(in));
   }
-  accelerator_inline void Exchange(vobj *mp,vobj *vp0,vobj *vp1,Integer type,Integer o) const {
+  accelerator_inline void Exchange(vobj &mp0,vobj &mp1,vobj &vp0,vobj &vp1,Integer type) const {
 #ifdef GRID_SIMT
-    exchangeSIMT(mp[2*o],mp[2*o+1],vp0[o],vp1[o],type);
+    exchangeSIMT(mp0,mp1,vp0,vp1,type);
 #else
-    exchange(mp[2*o],mp[2*o+1],vp0[o],vp1[o],type);
+    exchange(mp0,mp1,vp0,vp1,type);
 #endif
   }
-  accelerator_inline void Decompress(vobj *out,vobj *in, int o) const { assert(0); }
-  accelerator_inline void CompressExchange(vobj *out0,vobj *out1,const vobj *in,
-					   int j,int k, int m,int type) const {
+  accelerator_inline void Decompress(vobj &out,vobj &in) const {  };
+  accelerator_inline void CompressExchange(vobj &out0,vobj &out1,const vobj &in0,const vobj &in1,int type) const {
 #ifdef GRID_SIMT
-    exchangeSIMT(out0[j],out1[j],in[k],in[m],type);
+    exchangeSIMT(out0,out1,in0,in1,type);
 #else
-    exchange(out0[j],out1[j],in[k],in[m],type);
+    exchange(out0,out1,in0,in1,type);
 #endif
   }
   // For cshift. Cshift should drop compressor coupling altogether 
@@ -52,11 +133,18 @@ public:
     return arg;
   }
 };
-class SimpleStencilParams{
-public:
-  Coordinate dirichlet;
-  SimpleStencilParams() {};
-};
+
+// Standard compressor never needs dirichlet.
+//
+// Get away with a local period wrap and rely on dirac operator to use a zero gauge link as it is faster
+//
+// Compressors that inherit Dirichlet and Non-dirichlet behaviour.
+//
+// Currently run-time behaviour through StencilParameters paramaters, p.dirichlet
+// combined with the FaceGatherSimple behaviour
+
+template <class vobj> using SimpleCompressor = SimpleCompressorGather<vobj,FaceGatherSimple>;
+//template <class vobj> using SimpleCompressorDirichlet = SimpleCompressorGather<vobj,FaceGatherDirichlet>;
 
 NAMESPACE_END(Grid);
 

Grid/stencil/Stencil.h

@@ -59,6 +59,7 @@ NAMESPACE_BEGIN(Grid);
 void Gather_plane_table_compute (GridBase *grid,int dimension,int plane,int cbmask,
 				 int off,std::vector<std::pair<int,int> > & table);
 
+/*
 template<class vobj,class cobj,class compressor>
 void Gather_plane_simple_table (commVector<std::pair<int,int> >& table,const Lattice<vobj> &rhs,cobj *buffer,compressor &compress, int off,int so)   __attribute__((noinline));
 
@@ -103,6 +104,7 @@ void Gather_plane_exchange_table(commVector<std::pair<int,int> >& table,const La
   });
   rhs_v.ViewClose();
 }
+*/
 
 struct StencilEntry {
 #ifdef GRID_CUDA
@@ -133,8 +135,18 @@ class CartesianStencilAccelerator {
   int           _osites;
   StencilVector _directions;
   StencilVector _distances;
-  StencilVector _comms_send;
-  StencilVector _comms_recv;
+  ///////////////////////////////////////////////////
+  // If true, this is FULLY communicated per face
+  // Otherwise will either be full or partial dirichlet
+  ///////////////////////////////////////////////////
+  StencilVector _comms_send; 
+  StencilVector _comms_recv; // this is FULLY communicated per face
+  ///////////////////////////////////////////////////
+  // If true, this is partially communicated per face
+  ///////////////////////////////////////////////////
+  StencilVector _comms_partial_send; 
+  StencilVector _comms_partial_recv;
+  //
   StencilVector _comm_buf_size;
   StencilVector _permute_type;
   StencilVector same_node;
@@ -216,7 +228,6 @@ class CartesianStencil : public CartesianStencilAccelerator<vobj,cobj,Parameters
 public:
 
   typedef typename cobj::vector_type vector_type;
-  typedef typename cobj::scalar_type scalar_type;
   typedef typename cobj::scalar_object scalar_object;
   typedef const CartesianStencilView<vobj,cobj,Parameters> View_type;
   typedef typename View_type::StencilVector StencilVector;
@@ -230,7 +241,8 @@ public:
     Integer from_rank;
     Integer do_send;
     Integer do_recv;
-    Integer bytes;
+    Integer xbytes;
+    Integer rbytes;
   };
   struct Merge {
     cobj * mpointer;
@@ -238,11 +250,15 @@ public:
     Vector<cobj *> vpointers;
     Integer buffer_size;
     Integer type;
+    Integer partial; // partial dirichlet BCs
+    Coordinate dims;
   };
   struct Decompress {
     cobj * kernel_p;
     cobj * mpi_p;
     Integer buffer_size;
+    Integer partial; // partial dirichlet BCs
+    Coordinate dims;
   };
   struct CopyReceiveBuffer {
     void * from_p;
@@ -253,7 +269,8 @@ public:
     Integer direction;
     Integer OrthogPlane;
     Integer DestProc;
-    Integer bytes;
+    Integer xbytes;
+    Integer rbytes;
     Integer lane;
     Integer cb;
     void *recv_buf;
@@ -278,6 +295,7 @@ public:
   }
 
   int face_table_computed;
+  int partialDirichlet;
   std::vector<commVector<std::pair<int,int> > > face_table ;
   Vector<int> surface_list;
 
@@ -290,6 +308,8 @@ public:
   std::vector<Decompress> DecompressionsSHM;
   std::vector<CopyReceiveBuffer> CopyReceiveBuffers ;
   std::vector<CachedTransfer> CachedTransfers;
+  std::vector<CommsRequest_t> MpiReqs;
+  
   ///////////////////////////////////////////////////////////
   // Unified Comms buffers for all directions
   ///////////////////////////////////////////////////////////
@@ -357,54 +377,32 @@ public:
   ////////////////////////////////////////////////////////////////////////
   void CommunicateBegin(std::vector<std::vector<CommsRequest_t> > &reqs)
   {
-    reqs.resize(Packets.size());
+    accelerator_barrier();
     for(int i=0;i<Packets.size();i++){
-      _grid->StencilSendToRecvFromBegin(reqs[i],
+      _grid->StencilSendToRecvFromBegin(MpiReqs,
 					Packets[i].send_buf,
 					Packets[i].to_rank,Packets[i].do_send,
 					Packets[i].recv_buf,
 					Packets[i].from_rank,Packets[i].do_recv,
-					Packets[i].bytes,i);
+					Packets[i].xbytes,Packets[i].rbytes,i);
     }
   }
 
   void CommunicateComplete(std::vector<std::vector<CommsRequest_t> > &reqs)
   {
-    for(int i=0;i<Packets.size();i++){
-      _grid->StencilSendToRecvFromComplete(reqs[i],i);
-    }
+    _grid->StencilSendToRecvFromComplete(MpiReqs,0);
   }
   ////////////////////////////////////////////////////////////////////////
   // Blocking send and receive. Either sequential or parallel.
   ////////////////////////////////////////////////////////////////////////
   void Communicate(void)
   {
-    if ( CartesianCommunicator::CommunicatorPolicy == CartesianCommunicator::CommunicatorPolicySequential ){
-      /////////////////////////////////////////////////////////
-      // several way threaded on different communicators.
-      // Cannot combine with Dirichlet operators
-      // This scheme is needed on Intel Omnipath for best performance
-      // Deprecate once there are very few omnipath clusters
-      /////////////////////////////////////////////////////////
-      int nthreads = CartesianCommunicator::nCommThreads;
-      int old = GridThread::GetThreads();
-      GridThread::SetThreads(nthreads);
-      thread_for(i,Packets.size(),{
-	  _grid->StencilSendToRecvFrom(Packets[i].send_buf,
-				       Packets[i].to_rank,Packets[i].do_send,
-				       Packets[i].recv_buf,
-				       Packets[i].from_rank,Packets[i].do_recv,
-				       Packets[i].bytes,i);
-      });
-      GridThread::SetThreads(old);
-    } else { 
-      /////////////////////////////////////////////////////////
-      // Concurrent and non-threaded asynch calls to MPI
-      /////////////////////////////////////////////////////////
-      std::vector<std::vector<CommsRequest_t> > reqs;
-      this->CommunicateBegin(reqs);
-      this->CommunicateComplete(reqs);
-    }
+    /////////////////////////////////////////////////////////
+    // Concurrent and non-threaded asynch calls to MPI
+    /////////////////////////////////////////////////////////
+    std::vector<std::vector<CommsRequest_t> > reqs;
+    this->CommunicateBegin(reqs);
+    this->CommunicateComplete(reqs);
   }
 
   template<class compressor> void HaloExchange(const Lattice<vobj> &source,compressor &compress)
@@ -484,7 +482,6 @@ public:
     face_table_computed=1;
     assert(u_comm_offset==_unified_buffer_size);
 
-    accelerator_barrier();
   }
 
   /////////////////////////
@@ -499,6 +496,7 @@ public:
     Packets.resize(0);
     CopyReceiveBuffers.resize(0);
     CachedTransfers.resize(0);
+    MpiReqs.resize(0);
   }
   void AddCopy(void *from,void * to, Integer bytes)
   {
@@ -522,7 +520,9 @@ public:
     }
   }
   
-  Integer CheckForDuplicate(Integer direction, Integer OrthogPlane, Integer DestProc, void *recv_buf,Integer lane,Integer bytes,Integer cb)
+  Integer CheckForDuplicate(Integer direction, Integer OrthogPlane, Integer DestProc, void *recv_buf,Integer lane,
+			    Integer xbytes,Integer rbytes,
+			    Integer cb)
   {
     CachedTransfer obj;
     obj.direction   = direction;
@@ -530,19 +530,22 @@ public:
     obj.DestProc    = DestProc;
     obj.recv_buf    = recv_buf;
     obj.lane        = lane;
-    obj.bytes       = bytes;
+    obj.xbytes      = xbytes;
+    obj.rbytes      = rbytes;
     obj.cb          = cb;
 
     for(int i=0;i<CachedTransfers.size();i++){
       if (   (CachedTransfers[i].direction  ==direction)
 	   &&(CachedTransfers[i].OrthogPlane==OrthogPlane)
 	   &&(CachedTransfers[i].DestProc   ==DestProc)
-	   &&(CachedTransfers[i].bytes      ==bytes)
+	   &&(CachedTransfers[i].xbytes      ==xbytes)
+	   &&(CachedTransfers[i].rbytes      ==rbytes)
 	   &&(CachedTransfers[i].lane       ==lane)
 	   &&(CachedTransfers[i].cb         ==cb)
 	     ){
-
-	AddCopy(CachedTransfers[i].recv_buf,recv_buf,bytes);
+	// FIXME worry about duplicate with partial compression
+	// Wont happen as DWF has no duplicates, but...
+	AddCopy(CachedTransfers[i].recv_buf,recv_buf,rbytes);
 	return 1;
       }
     }
@@ -553,7 +556,7 @@ public:
   void AddPacket(void *xmit,void * rcv,
 		 Integer to, Integer do_send,
 		 Integer from, Integer do_recv,
-		 Integer bytes){
+		 Integer xbytes,Integer rbytes){
     Packet p;
     p.send_buf = xmit;
     p.recv_buf = rcv;
@@ -561,11 +564,16 @@ public:
     p.from_rank= from;
     p.do_send  = do_send;
     p.do_recv  = do_recv;
-    p.bytes    = bytes;
+    p.xbytes    = xbytes;
+    p.rbytes    = rbytes;
+    //    if (do_send) std::cout << GridLogMessage << " MPI packet to   "<<to<< " of size "<<xbytes<<std::endl;
+    //    if (do_recv) std::cout << GridLogMessage << " MPI packet from "<<from<< " of size "<<xbytes<<std::endl;
     Packets.push_back(p);
   }
   void AddDecompress(cobj *k_p,cobj *m_p,Integer buffer_size,std::vector<Decompress> &dv) {
     Decompress d;
+    d.partial  = this->partialDirichlet;
+    d.dims     = _grid->_fdimensions;
     d.kernel_p = k_p;
     d.mpi_p    = m_p;
     d.buffer_size = buffer_size;
@@ -573,6 +581,8 @@ public:
   }
   void AddMerge(cobj *merge_p,Vector<cobj *> &rpointers,Integer buffer_size,Integer type,std::vector<Merge> &mv) {
     Merge m;
+    m.partial  = this->partialDirichlet;
+    m.dims     = _grid->_fdimensions;
     m.type     = type;
     m.mpointer = merge_p;
     m.vpointers= rpointers;
@@ -592,21 +602,10 @@ public:
   void CommsMerge(decompressor decompress,std::vector<Merge> &mm,std::vector<Decompress> &dd)
   {
     for(int i=0;i<mm.size();i++){
-      auto mp = &mm[i].mpointer[0];
-      auto vp0= &mm[i].vpointers[0][0];
-      auto vp1= &mm[i].vpointers[1][0];
-      auto type= mm[i].type;
-      accelerator_forNB(o,mm[i].buffer_size/2,vobj::Nsimd(),{
-	  decompress.Exchange(mp,vp0,vp1,type,o);
-      });
+      decompressor::MergeFace(decompress,mm[i]);
     }
-
     for(int i=0;i<dd.size();i++){
-      auto kp = dd[i].kernel_p;
-      auto mp = dd[i].mpi_p;
-      accelerator_forNB(o,dd[i].buffer_size,1,{
-	decompress.Decompress(kp,mp,o);
-      });
+      decompressor::DecompressFace(decompress,dd[i]);
     }
   }
   ////////////////////////////////////////
@@ -685,6 +684,10 @@ public:
 	  if ( ( (ld*(pc+1) ) % block ) == 0 ) this->_comms_send[ii] = 0;
 	  if ( ( (ld*pc     ) % block ) == 0 ) this->_comms_recv[ii] = 0;
 	}
+	if ( partialDirichlet ) {
+	  this->_comms_partial_send[ii] = !this->_comms_send[ii];
+	  this->_comms_partial_recv[ii] = !this->_comms_recv[ii];
+	}
       }
     }
   }
@@ -711,7 +714,9 @@ public:
     this->_comms_recv.resize(npoints); 
     this->same_node.resize(npoints);
 
-    if ( p.dirichlet.size() ) DirichletBlock(p.dirichlet); // comms send/recv set up
+    if ( p.dirichlet.size() ==0 ) p.dirichlet.resize(grid->Nd(),0);
+    partialDirichlet = p.partialDirichlet;
+    DirichletBlock(p.dirichlet); // comms send/recv set up
 
     _unified_buffer_size=0;
     surface_list.resize(0);
@@ -793,7 +798,6 @@ public:
       u_simd_recv_buf[l] = (cobj *)_grid->ShmBufferMalloc(_unified_buffer_size*sizeof(cobj));
       u_simd_send_buf[l] = (cobj *)_grid->ShmBufferMalloc(_unified_buffer_size*sizeof(cobj));
     }
-
     PrecomputeByteOffsets();
   }
 
@@ -847,7 +851,7 @@ public:
     GridBase *grid=_grid;
     const int Nsimd = grid->Nsimd();
 
-    int comms_recv      = this->_comms_recv[point];
+    int comms_recv      = this->_comms_recv[point] || this->_comms_partial_recv[point] ;
     int fd              = _grid->_fdimensions[dimension];
     int ld              = _grid->_ldimensions[dimension];
     int rd              = _grid->_rdimensions[dimension];
@@ -1033,10 +1037,11 @@ public:
   int Gather(const Lattice<vobj> &rhs,int dimension,int shift,int cbmask,compressor & compress,int &face_idx, int point)
   {
     typedef typename cobj::vector_type vector_type;
-    typedef typename cobj::scalar_type scalar_type;
 
-    int comms_send   = this->_comms_send[point] ;
-    int comms_recv   = this->_comms_recv[point] ;
+    int comms_send   = this->_comms_send[point];
+    int comms_recv   = this->_comms_recv[point];
+    int comms_partial_send   = this->_comms_partial_send[point] ;
+    int comms_partial_recv   = this->_comms_partial_recv[point] ;
 
     assert(rhs.Grid()==_grid);
     //	  conformable(_grid,rhs.Grid());
@@ -1067,7 +1072,17 @@ public:
 	if (cbmask != 0x3) words=words>>1;
 
 	int bytes =  words * compress.CommDatumSize();
+	int xbytes;
+	int rbytes;
 
+	if ( comms_send ) xbytes = bytes; // Full send
+	else if ( comms_partial_send ) xbytes = bytes/compressor::PartialCompressionFactor(_grid);
+	else xbytes = 0; // full dirichlet
+
+	if ( comms_recv ) rbytes = bytes;
+	else if ( comms_partial_recv ) rbytes = bytes/compressor::PartialCompressionFactor(_grid);
+	else rbytes = 0;
+	
 	int so  = sx*rhs.Grid()->_ostride[dimension]; // base offset for start of plane
 	int comm_off = u_comm_offset;
 
@@ -1080,50 +1095,47 @@ public:
 	assert (xmit_to_rank   != _grid->ThisRank());
 	assert (recv_from_rank != _grid->ThisRank());
 
-	if( comms_send ) {
-
-	  if ( !face_table_computed ) {
-	    face_table.resize(face_idx+1);
-	    std::vector<std::pair<int,int> >  face_table_host ;
-	    Gather_plane_table_compute ((GridBase *)_grid,dimension,sx,cbmask,comm_off,face_table_host);
+	if ( !face_table_computed ) {
+	  face_table.resize(face_idx+1);
+	  std::vector<std::pair<int,int> >  face_table_host ;
+	  Gather_plane_table_compute ((GridBase *)_grid,dimension,sx,cbmask,comm_off,face_table_host);
+	  //	  std::cout << "bytes expect "<< bytes << " " << face_table_host.size()* compress.CommDatumSize()<<std::endl;
 	    face_table[face_idx].resize(face_table_host.size());
 	    acceleratorCopyToDevice(&face_table_host[0],
 				    &face_table[face_idx][0],
 				    face_table[face_idx].size()*sizeof(face_table_host[0]));
-	  }
-
-
-	  if ( compress.DecompressionStep() ) {
-	    recv_buf=u_simd_recv_buf[0];
-	  } else {
-	    recv_buf=this->u_recv_buf_p;
-	  }
-
-	  send_buf = this->u_send_buf_p; // Gather locally, must send
-	
-	  ////////////////////////////////////////////////////////
-	  // Gather locally
-	  ////////////////////////////////////////////////////////
-	  assert(send_buf!=NULL);
-
-	  Gather_plane_simple_table(face_table[face_idx],rhs,send_buf,compress,comm_off,so);
 	}
 
-	int duplicate = CheckForDuplicate(dimension,sx,comm_proc,(void *)&recv_buf[comm_off],0,bytes,cbmask);
-	if ( (!duplicate) ) { // Force comms for now
 
+	if ( (compress.DecompressionStep()&&comms_recv) || comms_partial_recv ) {
+	  recv_buf=u_simd_recv_buf[0];
+	} else {
+	  recv_buf=this->u_recv_buf_p;
+	}
+
+	////////////////////////////////////////////////////////
+	// Gather locally
+	////////////////////////////////////////////////////////
+	send_buf = this->u_send_buf_p; // Gather locally, must send
+	assert(send_buf!=NULL);
+
+	compressor::Gather_plane_simple(face_table[face_idx],rhs,send_buf,compress,comm_off,so,comms_partial_send);
+
+        int duplicate = CheckForDuplicate(dimension,sx,comm_proc,(void *)&recv_buf[comm_off],0,xbytes,rbytes,cbmask);
+	if ( !duplicate ) { // Force comms for now
+	  
 	  ///////////////////////////////////////////////////////////
 	  // Build a list of things to do after we synchronise GPUs
 	  // Start comms now???
 	  ///////////////////////////////////////////////////////////
 	  AddPacket((void *)&send_buf[comm_off],
 		    (void *)&recv_buf[comm_off],
-		    xmit_to_rank, comms_send,
-		    recv_from_rank, comms_recv,
-		    bytes);
+		    xmit_to_rank, comms_send|comms_partial_send,
+		    recv_from_rank, comms_recv|comms_partial_recv,
+		    xbytes,rbytes);
 	}
-	
-	if ( compress.DecompressionStep()  && comms_recv ) {
+
+	if ( (compress.DecompressionStep() && comms_recv) || comms_partial_recv ) {
 	  AddDecompress(&this->u_recv_buf_p[comm_off],
 			&recv_buf[comm_off],
 			words,Decompressions);
@@ -1131,7 +1143,6 @@ public:
 	
 	u_comm_offset+=words;
 	face_idx++;
-
       }
     }
     return 0;
@@ -1144,8 +1155,10 @@ public:
 
     const int maxl =2;// max layout in a direction
 
-    int comms_send   = this->_comms_send[point] ;
-    int comms_recv   = this->_comms_recv[point] ;
+    int comms_send   = this->_comms_send[point];
+    int comms_recv   = this->_comms_recv[point];
+    int comms_partial_send   = this->_comms_partial_send[point] ;
+    int comms_partial_recv   = this->_comms_partial_recv[point] ;
 
     int fd = _grid->_fdimensions[dimension];
     int rd = _grid->_rdimensions[dimension];
@@ -1175,6 +1188,11 @@ public:
 
     int datum_bytes = compress.CommDatumSize();
     int bytes = (reduced_buffer_size*datum_bytes)/simd_layout;
+
+    // how many bytes on wire : partial dirichlet or dirichlet may set to < bytes
+    int xbytes; 
+    int rbytes; 
+    
     assert(bytes*simd_layout == reduced_buffer_size*datum_bytes);
 
     Vector<cobj *> rpointers(maxl);
@@ -1204,21 +1222,37 @@ public:
 	if ( !face_table_computed ) {
 	  face_table.resize(face_idx+1);
 	  std::vector<std::pair<int,int> >  face_table_host ;
-				
+
 	  Gather_plane_table_compute ((GridBase *)_grid,dimension,sx,cbmask,comm_off,face_table_host);
 	  face_table[face_idx].resize(face_table_host.size());
 	  acceleratorCopyToDevice(&face_table_host[0],
 				  &face_table[face_idx][0],
 				  face_table[face_idx].size()*sizeof(face_table_host[0]));
+
 	}
 
-	if ( comms_send || comms_recv )
-	  Gather_plane_exchange_table(face_table[face_idx],rhs,spointers,dimension,sx,cbmask,compress,permute_type);
+	
+	if ( comms_send ) xbytes = bytes;
+	else if ( comms_partial_send ) xbytes = bytes/compressor::PartialCompressionFactor(_grid);
+	else xbytes = 0;
+
+	if ( comms_recv ) rbytes = bytes;
+	else if ( comms_partial_recv ) rbytes = bytes/compressor::PartialCompressionFactor(_grid);
+	else rbytes = 0;
+
+	// Gathers SIMD lanes for send and merge
+	// Different faces can be full comms or partial comms with  multiple ranks per node
+	if ( comms_send || comms_recv||comms_partial_send||comms_partial_recv ) {
+
+	  int partial = partialDirichlet;
+	  compressor::Gather_plane_exchange(face_table[face_idx],rhs,
+					    spointers,dimension,sx,cbmask,
+					    compress,permute_type,partial );
+	}
 	face_idx++;
 
-	//spointers[0] -- low
-	//spointers[1] -- high
-
+	//spointers[0] -- low simd coor
+	//spointers[1] -- high simd coor
 	for(int i=0;i<maxl;i++){
 
 	  int my_coor  = rd*i + x;            // self explanatory
@@ -1243,13 +1277,16 @@ public:
 	    _grid->ShiftedRanks(dimension,nbr_proc,xmit_to_rank,recv_from_rank);
 
 	    rpointers[i] = rp;
-
-	    int duplicate = CheckForDuplicate(dimension,sx,nbr_proc,(void *)rp,i,bytes,cbmask);
+	    
+	    int duplicate = CheckForDuplicate(dimension,sx,nbr_proc,(void *)rp,i,xbytes,rbytes,cbmask);
 	    if ( !duplicate  ) { 
+	      if ( (bytes != rbytes) && (rbytes!=0) ){
+		acceleratorMemSet(rp,0,bytes); // Zero prefill comms buffer to zero
+	      }
 	      AddPacket((void *)sp,(void *)rp,
-			xmit_to_rank,comms_send,
-			recv_from_rank,comms_recv,
-			bytes);
+			xmit_to_rank,comms_send|comms_partial_send,
+			recv_from_rank,comms_recv|comms_partial_recv,
+			xbytes,rbytes);
 	    }
 
 	  } else {
@@ -1259,7 +1296,7 @@ public:
 	  }
 	}
 
-	if ( comms_recv ) {
+	if ( comms_recv|comms_partial_recv ) {
 	  AddMerge(&this->u_recv_buf_p[comm_off],rpointers,reduced_buffer_size,permute_type,Mergers);
 	}
 
@@ -1270,10 +1307,6 @@ public:
     return 0;
   }
 
-  void ZeroCounters(void) { };
-
-  void Report(void) {   };
-
 };
 NAMESPACE_END(Grid);
 

Grid/tensors/Tensor_SIMT.h

@@ -31,6 +31,27 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 
 NAMESPACE_BEGIN(Grid);
 
+////////////////////////////////////////////////
+// Inside a GPU thread
+////////////////////////////////////////////////
+template<class vobj>
+accelerator_inline void exchangeSIMT(vobj &mp0,vobj &mp1,const vobj &vp0,const vobj &vp1,Integer type)
+{
+    typedef decltype(coalescedRead(mp0)) sobj;
+    unsigned int Nsimd = vobj::Nsimd();
+    unsigned int mask = Nsimd >> (type + 1);
+    int lane = acceleratorSIMTlane(Nsimd);
+    int j0 = lane &(~mask); // inner coor zero
+    int j1 = lane |(mask) ; // inner coor one
+    const vobj *vpa = &vp0;
+    const vobj *vpb = &vp1;
+    const vobj *vp = (lane&mask) ? (vpb) : (vpa);
+    auto sa = coalescedRead(vp[0],j0);
+    auto sb = coalescedRead(vp[0],j1);
+    coalescedWrite(mp0,sa);
+    coalescedWrite(mp1,sb);
+}
+
 
 #ifndef GRID_SIMT
 //////////////////////////////////////////

Grid/tensors/Tensor_class.h

@@ -178,6 +178,7 @@ public:
     stream << "S {" << o._internal << "}";
     return stream;
   };
+  // FIXME These will break with change of data layout
   strong_inline const scalar_type * begin() const { return reinterpret_cast<const scalar_type *>(&_internal); }
   strong_inline       scalar_type * begin()       { return reinterpret_cast<      scalar_type *>(&_internal); }
   strong_inline const scalar_type * end()   const { return begin() + Traits::count; }
@@ -288,6 +289,7 @@ public:
   //      return _internal[i];
   //    }
 
+  // FIXME These will break with change of data layout
   strong_inline const scalar_type * begin() const { return reinterpret_cast<const scalar_type *>(_internal); }
   strong_inline       scalar_type * begin()       { return reinterpret_cast<      scalar_type *>(_internal); }
   strong_inline const scalar_type * end()   const { return begin() + Traits::count; }
@@ -430,6 +432,7 @@ public:
   //    return _internal[i][j];
   //  }
 
+  // FIXME These will break with change of data layout
   strong_inline const scalar_type * begin() const { return reinterpret_cast<const scalar_type *>(_internal[0]); }
   strong_inline       scalar_type * begin()       { return reinterpret_cast<      scalar_type *>(_internal[0]); }
   strong_inline const scalar_type * end()   const { return begin() + Traits::count; }

Grid/tensors/Tensor_extract_merge.h

@@ -1,5 +1,5 @@
 /*************************************************************************************
-n
+
     Grid physics library, www.github.com/paboyle/Grid 
 
     Source file: ./lib/tensors/Tensor_extract_merge.h
@@ -62,8 +62,18 @@ void extract(const vobj &vec,ExtractBuffer<sobj> &extracted)
   const int words=sizeof(vobj)/sizeof(vector_type);
   const int Nsimd=vector_type::Nsimd();
   const int Nextr=extracted.size();
+  vector_type * vp = (vector_type *)&vec;
   const int s=Nsimd/Nextr;
   sobj_scalar_type *sp = (sobj_scalar_type *) &extracted[0];
+  sobj_scalar_type stmp;
+  for(int w=0;w<words;w++){
+    for(int i=0;i<Nextr;i++){
+      stmp = vp[w].getlane(i*s);
+      sp[i*words+w] =stmp;
+      //      memcpy((char *)&sp[i*words+w],(char *)&stmp,sizeof(stmp));
+    }
+  }
+  /*
   scalar_type *vp = (scalar_type *)&vec;
   scalar_type      vtmp;
   sobj_scalar_type stmp;
@@ -74,6 +84,8 @@ void extract(const vobj &vec,ExtractBuffer<sobj> &extracted)
       memcpy((char *)&sp[i*words+w],(char *)&stmp,sizeof(stmp));
     }
   }
+  */
+  
   return;
 }
 
@@ -93,7 +105,7 @@ void   merge(vobj &vec,ExtractBuffer<sobj> &extracted)
   const int s=Nsimd/Nextr;
 
   sobj_scalar_type *sp = (sobj_scalar_type *)&extracted[0];
-  scalar_type *vp = (scalar_type *)&vec;
+  vector_type *vp = (vector_type *)&vec;
   scalar_type      vtmp;
   sobj_scalar_type stmp;
   for(int w=0;w<words;w++){
@@ -101,7 +113,8 @@ void   merge(vobj &vec,ExtractBuffer<sobj> &extracted)
       for(int ii=0;ii<s;ii++){
 	memcpy((char *)&stmp,(char *)&sp[i*words+w],sizeof(stmp));
 	vtmp = stmp;
-	memcpy((char *)&vp[w*Nsimd+i*s+ii],(char *)&vtmp,sizeof(vtmp));
+	vp[w].putlane(vtmp,i*s+ii);
+	//	memcpy((char *)&vp[w*Nsimd+i*s+ii],(char *)&vtmp,sizeof(vtmp));
       }
     }
   }
@@ -117,16 +130,16 @@ typename vobj::scalar_object extractLane(int lane, const vobj & __restrict__ vec
   typedef typename vobj::scalar_object scalar_object;
   typedef typename vobj::vector_type   vector_type;
   typedef typename ExtractTypeMap<scalar_type>::extract_type extract_type;
-  typedef extract_type * pointer;
+  typedef scalar_type * pointer;
 
   constexpr int words=sizeof(vobj)/sizeof(vector_type);
   constexpr int Nsimd=vector_type::Nsimd();
 
   scalar_object extracted;
   pointer __restrict__  sp = (pointer)&extracted; // Type pun
-  pointer __restrict__  vp = (pointer)&vec;
+  vector_type *vp = (vector_type *)&vec;
   for(int w=0;w<words;w++){
-    sp[w]=vp[w*Nsimd+lane];
+    sp[w]=vp[w].getlane(lane);
   }
   return extracted;
 }
@@ -137,15 +150,15 @@ void insertLane(int lane, vobj & __restrict__ vec,const typename vobj::scalar_ob
   typedef typename vobj::vector_type vector_type;
   typedef typename vector_type::scalar_type scalar_type;
   typedef typename ExtractTypeMap<scalar_type>::extract_type extract_type;
-  typedef extract_type * pointer;
+  typedef scalar_type * pointer;
 
   constexpr int words=sizeof(vobj)/sizeof(vector_type);
   constexpr int Nsimd=vector_type::Nsimd();
 
   pointer __restrict__ sp = (pointer)&extracted;
-  pointer __restrict__ vp = (pointer)&vec;
+  vector_type *vp = (vector_type *)&vec;
   for(int w=0;w<words;w++){
-    vp[w*Nsimd+lane]=sp[w];
+    vp[w].putlane(sp[w],lane);
   }
 }
 
@@ -164,15 +177,13 @@ void extract(const vobj &vec,const ExtractPointerArray<sobj> &extracted, int off
   const int Nextr=extracted.size();
   const int s = Nsimd/Nextr;
 
-  scalar_type * vp = (scalar_type *)&vec;
+  vector_type * vp = (vector_type *)&vec;
   scalar_type      vtmp;
   sobj_scalar_type stmp;
   for(int w=0;w<words;w++){
     for(int i=0;i<Nextr;i++){
       sobj_scalar_type * pointer = (sobj_scalar_type *)& extracted[i][offset];
-      memcpy((char *)&vtmp,(char *)&vp[w*Nsimd+i*s],sizeof(vtmp));
-      stmp = vtmp;
-      memcpy((char *)&pointer[w],(char *)&stmp,sizeof(stmp)); // may do a precision conversion
+      pointer[w] = vp[w].getlane(i*s);
     }
   }
 }
@@ -192,23 +203,21 @@ void merge(vobj &vec,const ExtractPointerArray<sobj> &extracted, int offset)
   const int Nextr=extracted.size();
   const int s = Nsimd/Nextr;
 
-  scalar_type * vp = (scalar_type *)&vec;
+  vector_type * vp = (vector_type *)&vec;
   scalar_type      vtmp;
   sobj_scalar_type stmp;
   for(int w=0;w<words;w++){
     for(int i=0;i<Nextr;i++){
       sobj_scalar_type * pointer = (sobj_scalar_type *)& extracted[i][offset];
       for(int ii=0;ii<s;ii++){
-	memcpy((char *)&stmp,(char *)&pointer[w],sizeof(stmp));
-	vtmp=stmp;
-	memcpy((char *)&vp[w*Nsimd+i*s+ii],(char *)&vtmp,sizeof(vtmp));
+	vtmp=pointer[w];
+	vp[w].putlane(vtmp,i*s+ii);
       }
     }
   }
 }
 
 
-
 //////////////////////////////////////////////////////////////////////////////////
 //Copy a single lane of a SIMD tensor type from one object to another
 //Output object must be of the same tensor type but may be of a different precision (i.e. it can have a different root data type)
@@ -239,12 +248,12 @@ void copyLane(vobjOut & __restrict__ vecOut, int lane_out, const vobjIn & __rest
   iscalar_type itmp;
   oscalar_type otmp;
 
-  opointer __restrict__  op = (opointer)&vecOut;
-  ipointer __restrict__  ip = (ipointer)&vecIn;
+  ovector_type * __restrict__ op = (ovector_type *)&vecOut;
+  ivector_type * __restrict__ ip = (ivector_type *)&vecIn;
   for(int w=0;w<owords;w++){
-    memcpy( (char*)&itmp, (char*)(ip + lane_in + iNsimd*w), sizeof(iscalar_type) );
+    itmp = ip[iNsimd*w].getlane(lane_in);
     otmp = itmp; //potential precision change
-    memcpy( (char*)(op + lane_out + oNsimd*w), (char*)&otmp, sizeof(oscalar_type) );
+    op[oNsimd*w].putlane(otmp,lane_out);
   }
 }
 

Grid/tensors/Tensor_inner.h

@@ -214,24 +214,20 @@ accelerator_inline vRealD    innerProductD2(const vRealD    &l,const vRealD    &
 
 accelerator_inline vComplexD2 innerProductD2(const vComplexF &l,const vComplexF &r)
 {  
-  vComplexD la,lb;
-  vComplexD ra,rb;
-  Optimization::PrecisionChange::StoD(l.v,la.v,lb.v);
-  Optimization::PrecisionChange::StoD(r.v,ra.v,rb.v);
+  vComplexD2 dl,dr;
   vComplexD2 ret;
-  ret._internal[0] = innerProduct(la,ra);
-  ret._internal[1] = innerProduct(lb,rb);
+  precisionChange(dl,l);
+  precisionChange(dr,r);
+  ret = innerProduct(dl,dr);
   return ret;
 }
 accelerator_inline vRealD2 innerProductD2(const vRealF &l,const vRealF &r)
 {  
-  vRealD la,lb;
-  vRealD ra,rb;
-  Optimization::PrecisionChange::StoD(l.v,la.v,lb.v);
-  Optimization::PrecisionChange::StoD(r.v,ra.v,rb.v);
+  vRealD2 dl,dr;
   vRealD2 ret;
-  ret._internal[0]=innerProduct(la,ra);
-  ret._internal[1]=innerProduct(lb,rb); 
+  precisionChange(dl,l);
+  precisionChange(dr,r);
+  ret=innerProduct(dl,dr);
   return ret;
 }
 

Grid/tensors/Tensor_traits.h

@@ -42,39 +42,6 @@ NAMESPACE_BEGIN(Grid);
   template<typename T>     struct isGridScalar                : public std::false_type { static constexpr bool notvalue = true; };
   template<class T>        struct isGridScalar<iScalar<T>>    : public std::true_type  { static constexpr bool notvalue = false; };
 
-  // Store double-precision data in single-precision grids for precision promoted localInnerProductD
-  template<typename T>
-  class TypePair {
-  public:
-    T _internal[2];
-    accelerator TypePair<T>& operator=(const Grid::Zero& o) {
-      _internal[0] = Zero();
-      _internal[1] = Zero();
-      return *this;
-    }
-
-    accelerator TypePair<T> operator+(const TypePair<T>& o) const {
-      TypePair<T> r;
-      r._internal[0] = _internal[0] + o._internal[0];
-      r._internal[1] = _internal[1] + o._internal[1];
-      return r;
-    }
-
-    accelerator TypePair<T>& operator+=(const TypePair<T>& o) {
-      _internal[0] += o._internal[0];
-      _internal[1] += o._internal[1];
-      return *this;
-    }
-
-    friend accelerator_inline void add(TypePair<T>* ret, const TypePair<T>* a, const TypePair<T>* b) {
-      add(&ret->_internal[0],&a->_internal[0],&b->_internal[0]);
-      add(&ret->_internal[1],&a->_internal[1],&b->_internal[1]);
-    }
-  };
-  typedef TypePair<ComplexD> ComplexD2;
-  typedef TypePair<RealD> RealD2;
-  typedef TypePair<vComplexD> vComplexD2;
-  typedef TypePair<vRealD> vRealD2;
 
   // Traits to identify fundamental data types
   template<typename T>     struct isGridFundamental                : public std::false_type { static constexpr bool notvalue = true; };
@@ -88,8 +55,6 @@ NAMESPACE_BEGIN(Grid);
   template<>               struct isGridFundamental<RealD>         : public std::true_type  { static constexpr bool notvalue = false; };
   template<>               struct isGridFundamental<vComplexD2>    : public std::true_type  { static constexpr bool notvalue = false; };
   template<>               struct isGridFundamental<vRealD2>       : public std::true_type  { static constexpr bool notvalue = false; };
-  template<>               struct isGridFundamental<ComplexD2>     : public std::true_type  { static constexpr bool notvalue = false; };
-  template<>               struct isGridFundamental<RealD2>        : public std::true_type  { static constexpr bool notvalue = false; };
 
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -136,7 +101,7 @@ NAMESPACE_BEGIN(Grid);
     typedef ComplexF Complexified;
     typedef RealF Realified;
     typedef RealD DoublePrecision;
-    typedef RealD2 DoublePrecision2;
+    typedef RealD DoublePrecision2;
   };
   template<> struct GridTypeMapper<RealD> : public GridTypeMapper_Base {
     typedef RealD scalar_type;
@@ -151,19 +116,6 @@ NAMESPACE_BEGIN(Grid);
     typedef RealD DoublePrecision;
     typedef RealD DoublePrecision2;
   };
-  template<> struct GridTypeMapper<RealD2> : public GridTypeMapper_Base {
-    typedef RealD2 scalar_type;
-    typedef RealD2 scalar_typeD;
-    typedef RealD2 vector_type;
-    typedef RealD2 vector_typeD;
-    typedef RealD2 tensor_reduced;
-    typedef RealD2 scalar_object;
-    typedef RealD2 scalar_objectD;
-    typedef ComplexD2 Complexified;
-    typedef RealD2 Realified;
-    typedef RealD2 DoublePrecision;
-    typedef RealD2 DoublePrecision2;
-  };
   template<> struct GridTypeMapper<ComplexF> : public GridTypeMapper_Base {
     typedef ComplexF scalar_type;
     typedef ComplexD scalar_typeD;
@@ -175,7 +127,7 @@ NAMESPACE_BEGIN(Grid);
     typedef ComplexF Complexified;
     typedef RealF Realified;
     typedef ComplexD DoublePrecision;
-    typedef ComplexD2 DoublePrecision2;
+    typedef ComplexD DoublePrecision2;
   };
   template<> struct GridTypeMapper<ComplexD> : public GridTypeMapper_Base {
     typedef ComplexD scalar_type;
@@ -220,19 +172,6 @@ NAMESPACE_BEGIN(Grid);
   };
 #endif
 
-  template<> struct GridTypeMapper<ComplexD2> : public GridTypeMapper_Base {
-    typedef ComplexD2 scalar_type;
-    typedef ComplexD2 scalar_typeD;
-    typedef ComplexD2 vector_type;
-    typedef ComplexD2 vector_typeD;
-    typedef ComplexD2 tensor_reduced;
-    typedef ComplexD2 scalar_object;
-    typedef ComplexD2 scalar_objectD;
-    typedef ComplexD2 Complexified;
-    typedef RealD2 Realified;
-    typedef ComplexD2 DoublePrecision;
-    typedef ComplexD2 DoublePrecision2;
-  };
   template<> struct GridTypeMapper<Integer> : public GridTypeMapper_Base {
     typedef Integer scalar_type;
     typedef Integer scalar_typeD;
@@ -274,13 +213,13 @@ NAMESPACE_BEGIN(Grid);
     typedef vRealD DoublePrecision2;
   };
   template<> struct GridTypeMapper<vRealD2> : public GridTypeMapper_Base {
-    typedef RealD2  scalar_type;
-    typedef RealD2  scalar_typeD;
+    typedef RealD  scalar_type;
+    typedef RealD  scalar_typeD;
     typedef vRealD2 vector_type;
     typedef vRealD2 vector_typeD;
     typedef vRealD2 tensor_reduced;
-    typedef RealD2  scalar_object;
-    typedef RealD2  scalar_objectD;
+    typedef RealD  scalar_object;
+    typedef RealD  scalar_objectD;
     typedef vComplexD2 Complexified;
     typedef vRealD2 Realified;
     typedef vRealD2 DoublePrecision;
@@ -341,13 +280,13 @@ NAMESPACE_BEGIN(Grid);
     typedef vComplexD DoublePrecision2;
   };
   template<> struct GridTypeMapper<vComplexD2> : public GridTypeMapper_Base {
-    typedef ComplexD2  scalar_type;
-    typedef ComplexD2  scalar_typeD;
+    typedef ComplexD  scalar_type;
+    typedef ComplexD  scalar_typeD;
     typedef vComplexD2 vector_type;
     typedef vComplexD2 vector_typeD;
     typedef vComplexD2 tensor_reduced;
-    typedef ComplexD2  scalar_object;
-    typedef ComplexD2  scalar_objectD;
+    typedef ComplexD  scalar_object;
+    typedef ComplexD  scalar_objectD;
     typedef vComplexD2 Complexified;
     typedef vRealD2 Realified;
     typedef vComplexD2 DoublePrecision;

Grid/threads/Accelerator.cc

@@ -1,6 +1,7 @@
 #include <Grid/GridCore.h>
 
 NAMESPACE_BEGIN(Grid);
+int      world_rank; // Use to control world rank for print guarding
 int      acceleratorAbortOnGpuError=1;
 uint32_t accelerator_threads=2;
 uint32_t acceleratorThreads(void)       {return accelerator_threads;};
@@ -16,7 +17,7 @@ void     acceleratorThreads(uint32_t t) {accelerator_threads = t;};
 #ifdef GRID_CUDA
 cudaDeviceProp *gpu_props;
 cudaStream_t copyStream;
-cudaStream_t cpuStream;
+cudaStream_t computeStream;
 void acceleratorInit(void)
 {
   int nDevices = 1;
@@ -24,7 +25,8 @@ void acceleratorInit(void)
   gpu_props = new cudaDeviceProp[nDevices];
 
   char * localRankStr = NULL;
-  int rank = 0, world_rank=0; 
+  int rank = 0;
+  world_rank=0; 
   if ((localRankStr = getenv(ENV_RANK_OMPI   )) != NULL) { world_rank = atoi(localRankStr);}
   if ((localRankStr = getenv(ENV_RANK_MVAPICH)) != NULL) { world_rank = atoi(localRankStr);}
   if ((localRankStr = getenv(ENV_RANK_SLURM  )) != NULL) { world_rank = atoi(localRankStr);}
@@ -99,7 +101,7 @@ void acceleratorInit(void)
 
   cudaSetDevice(device);
   cudaStreamCreate(&copyStream);
-  cudaStreamCreate(&cpuStream);
+  cudaStreamCreate(&computeStream);
   const int len=64;
   char busid[len];
   if( rank == world_rank ) { 
@@ -114,7 +116,7 @@ void acceleratorInit(void)
 #ifdef GRID_HIP
 hipDeviceProp_t *gpu_props;
 hipStream_t copyStream;
-hipStream_t cpuStream;
+hipStream_t computeStream;
 void acceleratorInit(void)
 {
   int nDevices = 1;
@@ -122,7 +124,8 @@ void acceleratorInit(void)
   gpu_props = new hipDeviceProp_t[nDevices];
 
   char * localRankStr = NULL;
-  int rank = 0, world_rank=0; 
+  int rank = 0;
+  world_rank=0; 
   // We extract the local rank initialization using an environment variable
   if ((localRankStr = getenv(ENV_LOCAL_RANK_OMPI)) != NULL)
   {
@@ -183,7 +186,7 @@ void acceleratorInit(void)
 #endif
   hipSetDevice(device);
   hipStreamCreate(&copyStream);
-  hipStreamCreate(&cpuStream);
+  hipStreamCreate(&computeStream);
   const int len=64;
   char busid[len];
   if( rank == world_rank ) { 
@@ -198,19 +201,23 @@ void acceleratorInit(void)
 #ifdef GRID_SYCL
 
 cl::sycl::queue *theGridAccelerator;
+cl::sycl::queue *theCopyAccelerator;
 void acceleratorInit(void)
 {
   int nDevices = 1;
   cl::sycl::gpu_selector selector;
   cl::sycl::device selectedDevice { selector };
   theGridAccelerator = new sycl::queue (selectedDevice);
+  //  theCopyAccelerator = new sycl::queue (selectedDevice);
+  theCopyAccelerator = theGridAccelerator; // Should proceed concurrenlty anyway.
 
 #ifdef GRID_SYCL_LEVEL_ZERO_IPC
   zeInit(0);
 #endif
   
   char * localRankStr = NULL;
-  int rank = 0, world_rank=0; 
+  int rank = 0;
+  world_rank=0; 
 
   // We extract the local rank initialization using an environment variable
   if ((localRankStr = getenv(ENV_LOCAL_RANK_OMPI)) != NULL)

Grid/threads/Accelerator.h

@@ -107,7 +107,7 @@ void     acceleratorInit(void);
 
 extern int acceleratorAbortOnGpuError;
 extern cudaStream_t copyStream;
-extern cudaStream_t cpuStream;
+extern cudaStream_t computeStream;
 
 accelerator_inline int acceleratorSIMTlane(int Nsimd) {
 #ifdef GRID_SIMT
@@ -135,7 +135,7 @@ inline void cuda_mem(void)
     };									\
     dim3 cu_threads(nsimd,acceleratorThreads(),1);			\
     dim3 cu_blocks ((num1+nt-1)/nt,num2,1);				\
-    LambdaApply<<<cu_blocks,cu_threads,0,cpuStream>>>(num1,num2,nsimd,lambda);	\
+    LambdaApply<<<cu_blocks,cu_threads,0,computeStream>>>(num1,num2,nsimd,lambda);	\
   }
 
 #define accelerator_for6dNB(iter1, num1,				\
@@ -154,7 +154,7 @@ inline void cuda_mem(void)
     };									\
     dim3 cu_blocks (num1,num2,num3);					\
     dim3 cu_threads(num4,num5,num6);					\
-    Lambda6Apply<<<cu_blocks,cu_threads,0,cpuStream>>>(num1,num2,num3,num4,num5,num6,lambda); \
+    Lambda6Apply<<<cu_blocks,cu_threads,0,computeStream>>>(num1,num2,num3,num4,num5,num6,lambda); \
   }
 
 template<typename lambda>  __global__
@@ -190,7 +190,7 @@ void Lambda6Apply(uint64_t num1, uint64_t num2, uint64_t num3,
 
 #define accelerator_barrier(dummy)					\
   {									\
-    cudaStreamSynchronize(cpuStream);					\
+    cudaStreamSynchronize(computeStream);				\
     cudaError err = cudaGetLastError();					\
     if ( cudaSuccess != err ) {						\
       printf("accelerator_barrier(): Cuda error %s \n",			\
@@ -248,7 +248,6 @@ inline int  acceleratorIsCommunicable(void *ptr)
 //////////////////////////////////////////////
 // SyCL acceleration
 //////////////////////////////////////////////
-
 #ifdef GRID_SYCL
 NAMESPACE_END(Grid);
 #include <CL/sycl.hpp>
@@ -263,6 +262,7 @@ NAMESPACE_END(Grid);
 NAMESPACE_BEGIN(Grid);
 
 extern cl::sycl::queue *theGridAccelerator;
+extern cl::sycl::queue *theCopyAccelerator;
 
 #ifdef __SYCL_DEVICE_ONLY__
 #define GRID_SIMT
@@ -290,7 +290,7 @@ accelerator_inline int acceleratorSIMTlane(int Nsimd) {
       cgh.parallel_for(					\
       cl::sycl::nd_range<3>(global,local), \
       [=] (cl::sycl::nd_item<3> item) /*mutable*/     \
-      [[intel::reqd_sub_group_size(8)]]	      \
+      [[intel::reqd_sub_group_size(16)]]	      \
       {						      \
       auto iter1    = item.get_global_id(0);	      \
       auto iter2    = item.get_global_id(1);	      \
@@ -299,19 +299,19 @@ accelerator_inline int acceleratorSIMTlane(int Nsimd) {
      });	   			              \
     });
 
-#define accelerator_barrier(dummy) theGridAccelerator->wait();
+#define accelerator_barrier(dummy) { printf(" theGridAccelerator::wait()\n");  theGridAccelerator->wait(); }
 
 inline void *acceleratorAllocShared(size_t bytes){ return malloc_shared(bytes,*theGridAccelerator);};
 inline void *acceleratorAllocDevice(size_t bytes){ return malloc_device(bytes,*theGridAccelerator);};
 inline void acceleratorFreeShared(void *ptr){free(ptr,*theGridAccelerator);};
 inline void acceleratorFreeDevice(void *ptr){free(ptr,*theGridAccelerator);};
-inline void acceleratorCopyDeviceToDeviceAsynch(void *from,void *to,size_t bytes)  {
-  theGridAccelerator->memcpy(to,from,bytes);
-}
-inline void acceleratorCopySynchronise(void) {  theGridAccelerator->wait(); std::cout<<"acceleratorCopySynchronise() wait "<<std::endl; }
-inline void acceleratorCopyToDevice(void *from,void *to,size_t bytes)  { theGridAccelerator->memcpy(to,from,bytes); theGridAccelerator->wait();}
-inline void acceleratorCopyFromDevice(void *from,void *to,size_t bytes){ theGridAccelerator->memcpy(to,from,bytes); theGridAccelerator->wait();}
-inline void acceleratorMemSet(void *base,int value,size_t bytes) { theGridAccelerator->memset(base,value,bytes); theGridAccelerator->wait();}
+
+inline void acceleratorCopySynchronise(void) {  printf(" theCopyAccelerator::wait()\n"); theCopyAccelerator->wait(); }
+inline void acceleratorCopyDeviceToDeviceAsynch(void *from,void *to,size_t bytes)  {  theCopyAccelerator->memcpy(to,from,bytes);}
+inline void acceleratorCopyToDevice(void *from,void *to,size_t bytes)  { theCopyAccelerator->memcpy(to,from,bytes); theCopyAccelerator->wait();}
+inline void acceleratorCopyFromDevice(void *from,void *to,size_t bytes){ theCopyAccelerator->memcpy(to,from,bytes); theCopyAccelerator->wait();}
+inline void acceleratorMemSet(void *base,int value,size_t bytes) { theCopyAccelerator->memset(base,value,bytes); theCopyAccelerator->wait();}
+
 inline int  acceleratorIsCommunicable(void *ptr)
 {
 #if 0
@@ -340,7 +340,7 @@ NAMESPACE_BEGIN(Grid);
 #define accelerator_inline __host__ __device__ inline
 
 extern hipStream_t copyStream;
-extern hipStream_t cpuStream;
+extern hipStream_t computeStream;
 /*These routines define mapping from thread grid to loop & vector lane indexing */
 accelerator_inline int acceleratorSIMTlane(int Nsimd) {
 #ifdef GRID_SIMT
@@ -362,16 +362,15 @@ accelerator_inline int acceleratorSIMTlane(int Nsimd) {
     dim3 hip_blocks ((num1+nt-1)/nt,num2,1); \
     if(hip_threads.x * hip_threads.y * hip_threads.z <= 64){ \
       hipLaunchKernelGGL(LambdaApply64,hip_blocks,hip_threads,		\
-			 0,cpuStream,					\
+   	                 0,computeStream,						\
 			 num1,num2,nsimd, lambda);			\
     } else { \
       hipLaunchKernelGGL(LambdaApply,hip_blocks,hip_threads,		\
-			 0,cpuStream,					\
+			 0,computeStream,				\
 			 num1,num2,nsimd, lambda);			\
     } \
   }
 
-
 template<typename lambda>  __global__
 __launch_bounds__(64,1)
 void LambdaApply64(uint64_t numx, uint64_t numy, uint64_t numz, lambda Lambda)
@@ -400,7 +399,7 @@ void LambdaApply(uint64_t numx, uint64_t numy, uint64_t numz, lambda Lambda)
 
 #define accelerator_barrier(dummy)				\
   {								\
-    hipStreamSynchronize(cpuStream);					\
+    hipStreamSynchronize(computeStream);			\
     auto err = hipGetLastError();				\
     if ( err != hipSuccess ) {					\
       printf("After hipDeviceSynchronize() : HIP error %s \n", hipGetErrorString( err )); \
@@ -443,7 +442,7 @@ inline void acceleratorMemSet(void *base,int value,size_t bytes) { hipMemset(bas
 
 inline void acceleratorCopyDeviceToDeviceAsynch(void *from,void *to,size_t bytes) // Asynch
 {
-  hipMemcpy(to,from,bytes, hipMemcpyDeviceToDevice);
+  hipMemcpyDtoDAsync(to,from,bytes, copyStream);
 }
 inline void acceleratorCopySynchronise(void) { hipStreamSynchronize(copyStream); };
 
@@ -515,7 +514,16 @@ inline void *acceleratorAllocCpu(size_t bytes){return memalign(GRID_ALLOC_ALIGN,
 inline void acceleratorFreeCpu  (void *ptr){free(ptr);};
 #endif
 
+//////////////////////////////////////////////
+// Fencing needed ONLY for SYCL
+//////////////////////////////////////////////
 
+#ifdef GRID_SYCL
+inline void acceleratorFenceComputeStream(void){ accelerator_barrier();};
+#else
+// Ordering within a stream guaranteed on Nvidia & AMD
+inline void acceleratorFenceComputeStream(void){ };
+#endif
 
 ///////////////////////////////////////////////////
 // Synchronise across local threads for divergence resynch

Grid/util/Init.cc

@@ -356,6 +356,11 @@ void Grid_init(int *argc,char ***argv)
   //////////////////////////////////////////////////////////
   CartesianCommunicator::Init(argc,argv);
 
+  GridLogger::GlobalStopWatch.Stop();
+  CartesianCommunicator::BarrierWorld();
+  GridLogger::GlobalStopWatch.Reset();// Back to zero with synchronised clock
+  GridLogger::GlobalStopWatch.Start();
+
   ////////////////////////////////////
   // Banner after MPI (unless GPU)
   ////////////////////////////////////

Grid/util/Sha.h

@@ -27,6 +27,7 @@
     /*  END LEGAL */
 extern "C" {
 #include <openssl/sha.h>
+#include <openssl/evp.h>
 }
 #ifdef USE_IPP
 #include "ipp.h"
@@ -70,10 +71,8 @@ public:
   static inline std::vector<unsigned char> sha256(const 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);
+    auto digest = EVP_get_digestbyname("SHA256");
+    EVP_Digest(data, bytes, &hash[0], NULL, digest, NULL);
     return hash;
   }
   static inline std::vector<int> sha256_seeds(const std::string &s)

HMC/Mobius2p1f.cc

@@ -39,7 +39,7 @@ int main(int argc, char **argv) {
 
    // Typedefs to simplify notation
   typedef WilsonImplR FermionImplPolicy;
-  typedef MobiusFermionR FermionAction;
+  typedef MobiusFermionD FermionAction;
   typedef typename FermionAction::FermionField FermionField;
 
   typedef Grid::XmlReader       Serialiser;
@@ -133,8 +133,8 @@ int main(int argc, char **argv) {
   ////////////////////////////////////
 
   //  FermionAction StrangeOp(U,*FGrid,*FrbGrid,*GridPtr,*GridRBPtr,light_mass,M5,b,c, Params);
-  //  DomainWallEOFAFermionR Strange_Op_L(Umu, *FGrid, *FrbGrid, *UGrid, *UrbGrid, mf, mf, mb, shift_L, pm, M5);
-  //  DomainWallEOFAFermionR Strange_Op_R(Umu, *FGrid, *FrbGrid, *UGrid, *UrbGrid, mb, mf, mb, shift_R, pm, M5);
+  //  DomainWallEOFAFermionD Strange_Op_L(Umu, *FGrid, *FrbGrid, *UGrid, *UrbGrid, mf, mf, mb, shift_L, pm, M5);
+  //  DomainWallEOFAFermionD Strange_Op_R(Umu, *FGrid, *FrbGrid, *UGrid, *UrbGrid, mb, mf, mb, shift_R, pm, M5);
   //  ExactOneFlavourRatioPseudoFermionAction EOFA(Strange_Op_L,Strange_Op_R,CG,ofp, false);
 
   FermionAction StrangeOp (U,*FGrid,*FrbGrid,*GridPtr,*GridRBPtr,strange_mass,M5,b,c, Params);

HMC/Mobius2p1fEOFA.cc

@@ -175,9 +175,9 @@ int main(int argc, char **argv) {
 
    // Typedefs to simplify notation
   typedef WilsonImplR FermionImplPolicy;
-  typedef MobiusFermionR FermionAction;
+  typedef MobiusFermionD FermionAction;
   typedef MobiusFermionF FermionActionF;
-  typedef MobiusEOFAFermionR FermionEOFAAction;
+  typedef MobiusEOFAFermionD FermionEOFAAction;
   typedef MobiusEOFAFermionF FermionEOFAActionF;
   typedef typename FermionAction::FermionField FermionField;
   typedef typename FermionActionF::FermionField FermionFieldF;
@@ -293,9 +293,9 @@ int main(int argc, char **argv) {
   OFRp.precision= 50;
 
   
-  MobiusEOFAFermionR Strange_Op_L (U , *FGrid , *FrbGrid , *GridPtr , *GridRBPtr , strange_mass, strange_mass, pv_mass, 0.0, -1, M5, b, c);
+  MobiusEOFAFermionD Strange_Op_L (U , *FGrid , *FrbGrid , *GridPtr , *GridRBPtr , strange_mass, strange_mass, pv_mass, 0.0, -1, M5, b, c);
   MobiusEOFAFermionF Strange_Op_LF(UF, *FGridF, *FrbGridF, *GridPtrF, *GridRBPtrF, strange_mass, strange_mass, pv_mass, 0.0, -1, M5, b, c);
-  MobiusEOFAFermionR Strange_Op_R (U , *FGrid , *FrbGrid , *GridPtr , *GridRBPtr , pv_mass, strange_mass,      pv_mass, -1.0, 1, M5, b, c);
+  MobiusEOFAFermionD Strange_Op_R (U , *FGrid , *FrbGrid , *GridPtr , *GridRBPtr , pv_mass, strange_mass,      pv_mass, -1.0, 1, M5, b, c);
   MobiusEOFAFermionF Strange_Op_RF(UF, *FGridF, *FrbGridF, *GridPtrF, *GridRBPtrF, pv_mass, strange_mass,      pv_mass, -1.0, 1, M5, b, c);
 
   ConjugateGradient<FermionField>      ActionCG(ActionStoppingCondition,MaxCGIterations);

HMC/Mobius2p1fEOFA_F1.cc

@@ -159,9 +159,9 @@ int main(int argc, char **argv) {
 
    // Typedefs to simplify notation
   typedef WilsonImplR FermionImplPolicy;
-  typedef MobiusFermionR FermionAction;
+  typedef MobiusFermionD FermionAction;
   typedef MobiusFermionF FermionActionF;
-  typedef MobiusEOFAFermionR FermionEOFAAction;
+  typedef MobiusEOFAFermionD FermionEOFAAction;
   typedef MobiusEOFAFermionF FermionEOFAActionF;
   typedef typename FermionAction::FermionField FermionField;
   typedef typename FermionActionF::FermionField FermionFieldF;
@@ -281,9 +281,9 @@ int main(int argc, char **argv) {
   OFRp.precision= 50;
 
   
-  MobiusEOFAFermionR Strange_Op_L (U , *FGrid , *FrbGrid , *GridPtr , *GridRBPtr , strange_mass, strange_mass, pv_mass, 0.0, -1, M5, b, c);
+  MobiusEOFAFermionD Strange_Op_L (U , *FGrid , *FrbGrid , *GridPtr , *GridRBPtr , strange_mass, strange_mass, pv_mass, 0.0, -1, M5, b, c);
   MobiusEOFAFermionF Strange_Op_LF(UF, *FGridF, *FrbGridF, *GridPtrF, *GridRBPtrF, strange_mass, strange_mass, pv_mass, 0.0, -1, M5, b, c);
-  MobiusEOFAFermionR Strange_Op_R (U , *FGrid , *FrbGrid , *GridPtr , *GridRBPtr , pv_mass, strange_mass,      pv_mass, -1.0, 1, M5, b, c);
+  MobiusEOFAFermionD Strange_Op_R (U , *FGrid , *FrbGrid , *GridPtr , *GridRBPtr , pv_mass, strange_mass,      pv_mass, -1.0, 1, M5, b, c);
   MobiusEOFAFermionF Strange_Op_RF(UF, *FGridF, *FrbGridF, *GridPtrF, *GridRBPtrF, pv_mass, strange_mass,      pv_mass, -1.0, 1, M5, b, c);
 
   ConjugateGradient<FermionField>      ActionCG(ActionStoppingCondition,MaxCGIterations);

HMC/Mobius2p1fIDSDRGparityEOFA_40ID.cc

@@ -492,6 +492,7 @@ NAMESPACE_END(Grid);
 
 
 int main(int argc, char **argv) {
+#if 0
   Grid_init(&argc, &argv);
   int threads = GridThread::GetThreads();
   // here make a routine to print all the relevant information on the run
@@ -915,4 +916,5 @@ int main(int argc, char **argv) {
   std::cout << GridLogMessage << " Done" << std::endl;
   Grid_finalize();
   return 0;
+#endif
 } // main