Merge 32e6d58356 into aa67a5b095

BLAS_benchmark/BatchBlasBench.cc

@@ -120,7 +120,7 @@ inline void acceleratorMemSet(void *base,int value,size_t bytes) { cudaMemset(ba
 	     cudaGetErrorString( err ));				\
       printf("File %s Line %d\n",__FILE__,__LINE__);			\
       fflush(stdout);							\
-      if (acceleratorAbortOnGpuError) GRID_ASSERT(err==cudaSuccess);		\
+      if (acceleratorAbortOnGpuError) assert(err==cudaSuccess);		\
     }									\
   }
 
@@ -168,7 +168,7 @@ public:
     if ( (_Tp*)ptr == (_Tp *) NULL ) {
       printf("Grid Device Allocator got NULL for %lu bytes\n",(unsigned long) bytes );
     }
-    GRID_ASSERT( ( (_Tp*)ptr != (_Tp *)NULL ) );
+    assert( ( (_Tp*)ptr != (_Tp *)NULL ) );
     return ptr;
   }
 
@@ -276,11 +276,11 @@ public:
   {
 #ifdef GRID_HIP
     auto err = hipDeviceSynchronize();
-    GRID_ASSERT(err==hipSuccess);
+    assert(err==hipSuccess);
 #endif
 #ifdef GRID_CUDA
     auto err = cudaDeviceSynchronize();
-    GRID_ASSERT(err==cudaSuccess);
+    assert(err==cudaSuccess);
 #endif
 #ifdef GRID_SYCL
     accelerator_barrier();
@@ -305,8 +305,8 @@ public:
   {
     RealD t2=usecond();
 
-    GRID_ASSERT(OpA!=GridBLAS_OP_T); // Complex case expect no transpose
+    assert(OpA!=GridBLAS_OP_T); // Complex case expect no transpose
-    GRID_ASSERT(OpB!=GridBLAS_OP_T);
+    assert(OpB!=GridBLAS_OP_T);
 
     int lda = m; // m x k column major
     int ldb = k; // k x n column major
@@ -341,7 +341,7 @@ public:
 			    (hipblasDoubleComplex *) Bkn, ldb,
 			    (hipblasDoubleComplex *) &beta_p[0],
 			    (hipblasDoubleComplex *) Cmn, ldc);
-    GRID_ASSERT(err==HIPBLAS_STATUS_SUCCESS);
+    assert(err==HIPBLAS_STATUS_SUCCESS);
 #endif
 #ifdef GRID_CUDA
     cublasOperation_t hOpA;
@@ -361,7 +361,7 @@ public:
 			   (cuDoubleComplex *) Bkn, ldb,
 			   (cuDoubleComplex *) &beta_p[0],
 			   (cuDoubleComplex *) Cmn, ldc);
-    GRID_ASSERT(err==CUBLAS_STATUS_SUCCESS);
+    assert(err==CUBLAS_STATUS_SUCCESS);
 #endif
 #ifdef GRID_SYCL
       int64_t m64=m;
@@ -433,8 +433,8 @@ public:
   {
     RealD t2=usecond();
 
-    GRID_ASSERT(OpA!=GridBLAS_OP_T); // Complex case expect no transpose
+    assert(OpA!=GridBLAS_OP_T); // Complex case expect no transpose
-    GRID_ASSERT(OpB!=GridBLAS_OP_T);
+    assert(OpB!=GridBLAS_OP_T);
 
     int lda = m; // m x k column major
     int ldb = k; // k x n column major
@@ -469,7 +469,7 @@ public:
 			    (hipblasComplex *) Bkn, ldb,
 			    (hipblasComplex *) &beta_p[0],
 			    (hipblasComplex *) Cmn, ldc);
-    GRID_ASSERT(err==HIPBLAS_STATUS_SUCCESS);
+    assert(err==HIPBLAS_STATUS_SUCCESS);
 #endif
 #ifdef GRID_CUDA
     cublasOperation_t hOpA;
@@ -489,7 +489,7 @@ public:
 			   (cuComplex *) Bkn, ldb,
 			   (cuComplex *) &beta_p[0],
 			   (cuComplex *) Cmn, ldc);
-    GRID_ASSERT(err==CUBLAS_STATUS_SUCCESS);
+    assert(err==CUBLAS_STATUS_SUCCESS);
 #endif
 #ifdef GRID_SYCL
       int64_t m64=m;
@@ -595,11 +595,11 @@ public:
   {
     RealD t2=usecond();
     int32_t batchCount = Amk.size();
-    GRID_ASSERT(Bkn.size()==batchCount);
+    assert(Bkn.size()==batchCount);
-    GRID_ASSERT(Cmn.size()==batchCount);
+    assert(Cmn.size()==batchCount);
 
-    GRID_ASSERT(OpA!=GridBLAS_OP_T); // Complex case expect no transpose
+    assert(OpA!=GridBLAS_OP_T); // Complex case expect no transpose
-    GRID_ASSERT(OpB!=GridBLAS_OP_T);
+    assert(OpB!=GridBLAS_OP_T);
 
     int lda = m; // m x k column major
     int ldb = k; // k x n column major
@@ -636,7 +636,7 @@ public:
 				   (hipblasDoubleComplex **)&Cmn[0], ldc,
 				   batchCount);
     //	 std::cout << " hipblas return code " <<(int)err<<std::endl;
-    GRID_ASSERT(err==HIPBLAS_STATUS_SUCCESS);
+    assert(err==HIPBLAS_STATUS_SUCCESS);
 #endif
 #ifdef GRID_CUDA
     cublasOperation_t hOpA;
@@ -657,7 +657,7 @@ public:
 				  (cuDoubleComplex *) &beta_p[0],
 				  (cuDoubleComplex **)&Cmn[0], ldc,
 				  batchCount);
-    GRID_ASSERT(err==CUBLAS_STATUS_SUCCESS);
+    assert(err==CUBLAS_STATUS_SUCCESS);
 #endif
 #ifdef GRID_SYCL
       int64_t m64=m;
@@ -804,8 +804,8 @@ public:
     RealD t2=usecond();
     int32_t batchCount = Amk.size();
 
-    GRID_ASSERT(OpA!=GridBLAS_OP_T); // Complex case expect no transpose
+    assert(OpA!=GridBLAS_OP_T); // Complex case expect no transpose
-    GRID_ASSERT(OpB!=GridBLAS_OP_T);
+    assert(OpB!=GridBLAS_OP_T);
 
     int lda = m; // m x k column major
     int ldb = k; // k x n column major
@@ -821,8 +821,8 @@ public:
     acceleratorCopyToDevice((void *)&beta ,(void *)&beta_p[0],sizeof(ComplexF));
     RealD t0=usecond();
 
-    GRID_ASSERT(Bkn.size()==batchCount);
+    assert(Bkn.size()==batchCount);
-    GRID_ASSERT(Cmn.size()==batchCount);
+    assert(Cmn.size()==batchCount);
 #ifdef GRID_HIP
     hipblasOperation_t hOpA;
     hipblasOperation_t hOpB;
@@ -843,7 +843,7 @@ public:
 				   (hipblasComplex **)&Cmn[0], ldc,
 				   batchCount);
 
-    GRID_ASSERT(err==HIPBLAS_STATUS_SUCCESS);
+    assert(err==HIPBLAS_STATUS_SUCCESS);
 #endif
 #ifdef GRID_CUDA
     cublasOperation_t hOpA;
@@ -864,7 +864,7 @@ public:
 				  (cuComplex *) &beta_p[0],
 				  (cuComplex **)&Cmn[0], ldc,
 				  batchCount);
-    GRID_ASSERT(err==CUBLAS_STATUS_SUCCESS);
+    assert(err==CUBLAS_STATUS_SUCCESS);
 #endif
 #ifdef GRID_SYCL
       int64_t m64=m;

CLAUDE.md

@@ -1,183 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## What This Is
-
-Grid is a data-parallel C++ library for lattice QCD. It provides SIMD-vectorised lattice containers, MPI-based domain decomposition, GPU acceleration (CUDA/HIP/SYCL), and a full suite of QCD algorithms including HMC.
-
-## Build
-
-Uses GNU Autotools. The bootstrap step only needs to run once (or after `configure.ac` changes).
-
-```bash
-./bootstrap.sh                    # downloads Eigen 3.4.0, generates configure
-mkdir build && cd build
-../configure [options]
-make -j$(nproc)
-make check                        # run root-level tests
-make install
-```
-
-Key configure options:
-
-| Option | Common values |
-|--------|---------------|
-| `--enable-simd=` | `AVX2`, `AVX512`, `KNL`, `A64FX`, `NEONv8`, `GPU` |
-| `--enable-comms=` | `mpi-auto`, `mpi3-auto`, `none` |
-| `--enable-accelerator=` | `cuda`, `hip`, `sycl` |
-| `--enable-shm=` | `shmopen`, `hugetlbfs`, `nvlink` |
-| `--enable-Nc=` | `3` (default), `2`, `4`, `5` |
-| `--with-gmp=`, `--with-mpfr=`, `--with-fftw=`, `--with-lime=` | paths to libs |
-| `--enable-hdf5`, `--enable-mkl`, `--enable-lapack` | optional features |
-
-GPU builds additionally need `--enable-gen-simd-width=64` (sets 512-bit SIMD width for GPU warp/wavefront sizing) and `--enable-unified=no --enable-shm=nvlink` for multi-GPU runs.
-
-To speed up compilation, `--disable-fermion-reps --disable-gparity` skips instantiating G-parity and higher-representation fermion operators.
-
-Platform recipes from `README.md`:
-- **KNL**: `--enable-simd=KNL --enable-comms=mpi3-auto --enable-mkl`
-- **Skylake/Haswell**: `--enable-simd=AVX512` or `AVX2` + `--enable-comms=mpi3-auto`
-- **AMD EPYC**: `--enable-simd=AVX2 --enable-comms=mpi3`
-- **A64FX (Fugaku)**: `--enable-simd=A64FX --enable-comms=mpi3 --enable-shm=shmget` (see `SVE_README.txt`)
-
-Complete, working `configure` invocations for specific HPC systems (Frontier/ROCm, Perlmutter/CUDA, Summit, SDCC-A100, etc.) live in `systems/<platform>/config-command`. These are the canonical references for production builds.
-
-Required external libs: GMP, MPFR, OpenSSL, zlib.
-
-### Use `systems/` for real machines
-
-`systems/<machine>/` holds the known-good build for each production platform (`Frontier`, `Aurora`, `Perlmutter`, `Summit`, `Tursa`, `Lumi`, `Booster`, `Crusher`, `SDCC-*`, `mac-arm`, …). Each contains a `config-command` (the exact `../../configure` invocation) and a `sourceme.sh` (module loads and env). **Prefer copying/adapting these over hand-rolling configure flags** — they encode compiler workarounds, `LDFLAGS`, and shared-memory settings that are easy to get wrong. `systems/WorkArounds.txt` records known vendor bugs.
-
-Note the GPU builds use `--enable-simd=GPU --enable-gen-simd-width=64`, so `Nsimd` is *not* 1 on device (it is `64/sizeof(scalar)`).
-
-### Regenerating `Make.inc` — required after adding or deleting source files
-
-`Make.inc` files are generated, not tracked in git (`.gitignore`d). `scripts/filelist` walks `Grid/`, `tests/*`, `benchmarks/`, `examples/`, and `HMC/` and writes the file lists and per-test `bin_PROGRAMS` rules. Every new `.cc`/`.h` in `Grid/`, and every new `Test_*.cc` / `Benchmark_*.cc` / `Example_*.cc`, is invisible to the build until you run:
-
-```bash
-./scripts/filelist    # from the source root, then re-run configure/make
-```
-
-`bootstrap.sh` runs it for you on the first setup.
-
-## Running Tests and Benchmarks
-
-```bash
-# From build directory
-make check                          # root-level tests (Test_simd, Test_cshift, etc.)
-make -C tests/<subdir> tests        # build tests in a subdirectory
-make tests                          # build all tests across all subdirectories
-./tests/core/Test_simd              # run a single test binary directly
-mpirun -n 4 ./tests/core/Test_cshift --grid 16.16.16.16 --mpi 1.1.1.4
-```
-
-`make check` is a thin smoke test — building a subdirectory with `make -C tests/<subdir> tests` and running the relevant binaries directly is the normal development loop. Test binaries take Grid's standard command-line arguments (`--grid`, `--mpi`, `--accelerator-threads`, `--threads`, `--debug-signals`, `--log`); see `Grid/util/Init.cc`.
-
-Test subdirectories and their focus: `core` (SIMD, stencil, comms), `solver` (CG, GMRES, eigensolvers), `hmc` (MD integrators), `forces` (fermion forces), `lanczos`, `IO`, `smearing`, `sp2n`, `debug`.
-
-Tests and benchmarks that need optional fermion representations are guarded by `disable_tests_without_instantiations.h` / `disable_benchmarks_without_instantiations.h`, so a `--disable-fermion-reps --disable-gparity` build silently compiles them to no-ops.
-
-## Architecture
-
-### Layer stack (bottom to top)
-
-1. **SIMD layer** (`Grid/simd/`) — platform-specific intrinsics wrapped into `vRealF`, `vComplexD`, etc. The SIMD width and layout are compile-time constants controlled by `--enable-simd`.
-
-2. **Tensor layer** (`Grid/tensors/`) — Lorentz/colour/spin tensor algebra built on top of SIMD types. `iMatrix`, `iVector`, `iScalar` templates compose into QCD types like `ColourMatrix`, `SpinColourVector`.
-
-3. **Lattice layer** (`Grid/lattice/`) — `Lattice<T>` container: a site-local tensor replicated across a distributed Cartesian grid. All arithmetic is site-parallel and expression-template-fused.
-
-4. **Cartesian/comms layer** (`Grid/cartesian/`, `Grid/communicator/`) — `GridCartesian` holds the MPI topology and local/global geometry. `Grid/cshift/` implements nearest-neighbour halo exchange; `Grid/stencil/` is the optimised multi-hop stencil used by Dirac operators.
-
-5. **Algorithm layer** (`Grid/algorithms/`) — iterative solvers (CG, GMRES, BiCGSTAB, mixed-precision), eigensolvers (Lanczos, LAPACK), FFT, smearing, and multigrid.
-
-6. **QCD layer** (`Grid/qcd/`) — gauge and fermion actions, HMC integrators, observables.
-
-### QCD subsystem (`Grid/qcd/`)
-
-- `action/fermion/` — Wilson, Clover, DWF (Mobius), Staggered, twisted-mass, G-parity variants
-- `action/gauge/` — Wilson gauge, Symanzik, Iwasaki, DBW2, plaquette+rect
-- `representations/` — Fundamental, Adjoint, Two-index, Sp(2n)
-- `hmc/` — Leapfrog, OMF2/OMF4 integrators; pseudofermion refreshment; Metropolis accept/reject
-- `smearing/` — APE, Stout, HEX, gradient flow
-- `observables/` — Polyakov loop, plaquette, topological charge
-
-### GPU acceleration and the view/memory-manager discipline
-### Multigrid (`Grid/algorithms/multigrid/`)
-
-Aggregation-based algebraic multigrid for Wilson-type fermions. Key files: `CoarsenedMatrix.h` (coarse operator), `GeneralCoarsenedMatrix.h` and `GeneralCoarsenedMatrixMultiRHS.h` (general coarsening supporting multi-RHS solves), `Aggregates.h` (near-null vector construction), `Geometry.h` (coarse-grid geometry). `MultiGrid.h` is the top-level include.
-
-### GPU acceleration
-
-GPU support is injected via macros in `Grid/threads/Accelerator.h` — `accelerator_for(i, n, nsimd, {...})`, `accelerator_forNB` (non-blocking, must be followed by `accelerator_barrier()`), `accelerator_for2dNB`, and `accelerator_inline`. On a CPU build these degrade to `thread_for` (OpenMP). Unified virtual memory is on by default (`--enable-unified=yes`); device-aware MPI (`--enable-accelerator-aware-mpi`) avoids device→host copies on transfers.
-
-Lattice data is **not** directly addressable inside a kernel. You must open a view with the correct access mode so `Grid/allocator/MemoryManager.h` can move/mark the data:
-
-```cpp
-autoView(out_v, out, AcceleratorWriteDiscard);   // RAII; closes at end of scope
-autoView(in_v,  in,  AcceleratorRead);
-accelerator_for(ss, grid->oSites(), Nsimd, {
-    coalescedWrite(out_v[ss], coalescedRead(in_v[ss]));
-});
-```
-
-Modes are `AcceleratorRead/Write/WriteDiscard` and `CpuRead/Write/WriteDiscard`. Getting the mode wrong (e.g. `AcceleratorRead` on a field you write) produces stale-data bugs that only appear on GPU builds. Inside kernels use `coalescedRead`/`coalescedWrite` rather than raw `operator[]` — they map the SIMD lane onto `threadIdx.x` so accesses stay coalesced.
-
-### Repo-local debugging skills (`skills/`)
-
-`skills/` contains hard-won, Grid-specific playbooks written as invocable skill files. Consult them before debugging in these areas rather than reasoning from first principles:
-
-| File | Covers |
-|---|---|
-| `gpu-memory-performance.md` | `acceleratorThreads()`, LambdaApply thread mapping, `coalescedRead` idiom, fused vs staged HBM access |
-| `gpu-runtime-correctness.md` | GPU runtime returning early from sync, silent wrong answers |
-| `communication-overlap.md` | 7-phase halo pipeline, per-packet events, host-staging vs GPU-direct RDMA |
-| `mpi-heterogeneous.md` | `MPI_Sendrecv` device-buffer aliasing, deterministic reductions |
-| `compiler-validation.md` | Isolating GPU compiler codegen bugs, minimal reproducers |
-| `correctness-verification.md` | Double-run fingerprinting, per-packet checksums, flight recorder |
-| `hang-diagnosis.md` | Diagnosing MPI/accelerator hangs |
-
-The key loop macros (defined in `Grid/threads/Accelerator.h`) are:
-- `accelerator_for(iter, num, nsimd, {...})` — maps to CUDA/HIP kernel or OpenMP loop; `nsimd` is the innermost SIMD lane count
-- `accelerator_forNB(...)` — non-blocking variant (no implicit barrier)
-- `accelerator_for2dNB(iter1, num1, iter2, num2, nsimd, {...})` — 2D kernel launch
-- `thread_for(iter, num, {...})` — CPU OpenMP loop (never dispatches to GPU)
-
-On CPU builds, `accelerator_for` aliases to `thread_for`.
-
-### Solver patterns
-
-`SchurRedBlack` (`Grid/algorithms/iterative/SchurRedBlack.h`) implements red-black (even/odd) preconditioning for fermion operators. Most production fermion solves use `SchurRedBlackDiagMooeeSolve` or similar wrappers that internally call a `ConjugateGradient` on the Schur complement.
-
-Mixed-precision solvers (`ConjugateGradientMixedPrec`, `BiCGSTABMixedPrec`) drive a double-precision outer loop with single-precision inner solves.
-
-### Memory and I/O
-
-- `Grid/allocator/` — aligned/NUMA-aware allocators; caching allocator via `--enable-alloc-cache`
-- `Grid/parallelIO/` — distributed parallel reader/writer for ILDG (via LIME), SciDAC, and native binary formats
-- `Grid/serialisation/` — text, binary, HDF5, XML/JSON serialisation of arbitrary Grid objects
-
-### Executables
-
-- `HMC/` — production HMC driver programmes (e.g. `Mobius2p1f.cc`, `DWF_plus_DSDR_nf2plus1_Shamir_Gparity.cc`)
-- `benchmarks/` — `Benchmark_dwf`, `Benchmark_ITT`, `Benchmark_comms`, `Benchmark_memory_bandwidth`, … used to qualify a new machine
-- `examples/` — small, readable programmes (`Example_plaquette.cc`, `Example_Mobius_spectrum.cc`) that are the best starting point for learning the API
-
-Each of these directories auto-builds every top-level `.cc` as its own binary via `scripts/filelist`.
-
-Every programme is wrapped in `Grid_init(&argc, &argv)` / `Grid_finalize()` (`Grid/util/Init.h`).
-
-## Key Conventions
-
-- **C++17** is required throughout.
-- Template structure: most classes are templated on `<_FImpl>` (fermion impl) or `<Gimpl>` (gauge impl), which encode the representation and precision. Instantiation is controlled by `--enable-fermion-instantiations`.
-- **Tensor indices are positional, not labelled.** The `Grid/tensors/` arithmetic recurses structurally over the `iScalar`/`iVector`/`iMatrix` nest: each level defines only the {scalar,vector,matrix}² products at its own level, with element types resolved by automatic type deduction, so every colour/spin/lorentz combination composes from ~200 lines (versus the pre-C++11 QDP++/PETE approach of machine-generating every case). An index's meaning derives entirely from its nesting depth counted from the outside; `iScalar` is the identity/broadcast case at every level. Never insert or remove a nesting level casually — the multiplication tables contract by position.
-- **Multigrid coarsening deepens the tensor nest by one level.** A coarse site vector is `iVector<CComplex,nbasis>`, and `innerProduct` on it returns `iScalar<CComplex>` — one level deeper than the fine block scalar. So the block-inner-product scalar type gains one `iScalar` wrapper per MG level (fine: `vTComplex`; level 2: `iScalar<vTComplex>`; see `examples/Example_pvdagm_3level.cc`). When calling `blockInnerProduct`/`blockZAXPY`/`blockOrthogonalise` on coarse fields, the coarse scalar type must match `decltype(innerProduct(siteVector(),siteVector()))` exactly; a wrong depth fails to compile (no viable `operator=` deep in the instantiation chain) rather than mis-contracting.
-- The `RealD`/`RealF`/`ComplexD`/`ComplexF` typedefs are used everywhere; avoid raw `double`/`float`.
-- Use `GRID_ASSERT(cond)` (defined in `Grid/GridStd.h`), not bare `assert` — it prints a Grid-formatted message and aborts cleanly under MPI.
-- Logging is stream-based, not macro-based: `std::cout << GridLogMessage << ... << std::endl;`. Channels declared in `Grid/log/Log.h` include `GridLogError`, `GridLogWarning`, `GridLogDebug`, `GridLogPerformance`, `GridLogIterative`, `GridLogSolver`, `GridLogHMC`, `GridLogComms`, `GridLogMemory`, `GridLogDslash`, `GridLogIRL`, `GridLogMG`. A subset is switched on at runtime with e.g. `--log Error,Warning,Message,Performance,Iterative,Integrator,Debug,Colours` (names given without the `GridLog` prefix).
-- Performance-critical paths use `GRID_TRACE(name)` from `Grid/perfmon/Tracing.h` (compiled out unless `--enable-tracing` selects a backend) and the `GridStopWatch` timers in `Grid/perfmon/Timer.h`.
-- Reductions across MPI ranks go through `GridBase::GlobalSum` / `GlobalMax`; never reduce with bare MPI calls inside library code.
-- Everything lives in `NAMESPACE_BEGIN(Grid)` / `NAMESPACE_END(Grid)` macros; follow the surrounding file rather than writing `namespace Grid { }`.
-- British spelling is used in identifiers and comments (`colour`, `neighbour`, `serialisation`).

Grid/DisableWarnings.h

@@ -51,13 +51,11 @@ directory
 #pragma nv_diag_suppress cast_to_qualified_type
  //disables nvcc specific warning in many files
 #pragma nv_diag_suppress esa_on_defaulted_function_ignored
-#pragma nv_diag_suppress declared_but_not_referenced
 #pragma nv_diag_suppress extra_semicolon
 #else
  //disables nvcc specific warning in json.hpp
 #pragma diag_suppress unsigned_compare_with_zero
 #pragma diag_suppress cast_to_qualified_type
-#pragma diag_suppress declared_but_not_referenced
  //disables nvcc specific warning in many files
 #pragma diag_suppress esa_on_defaulted_function_ignored
 #pragma diag_suppress extra_semicolon

Grid/GridStd.h

@@ -1,17 +1,9 @@
 #ifndef GRID_STD_H
 #define GRID_STD_H
 
-///////////////////
-// Grid config
-///////////////////
-#include "Config.h"
-
 ///////////////////
 // Std C++ dependencies
 ///////////////////
-#define _NBACKTRACE (256)
-extern void * Grid_backtrace_buffer[_NBACKTRACE];
-
 #include <cassert>
 #include <complex>
 #include <memory>
@@ -23,9 +15,7 @@ extern void * Grid_backtrace_buffer[_NBACKTRACE];
 #include <random>
 #include <functional>
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
-#include <unistd.h>
 #include <strings.h>
 #include <stdio.h>
 #include <signal.h>
@@ -33,36 +23,11 @@ extern void * Grid_backtrace_buffer[_NBACKTRACE];
 #include <sys/time.h>
 #include <chrono>
 #include <zlib.h>
-#ifdef HAVE_EXECINFO_H
-#include <execinfo.h>
-#endif
-
-void GridAbort(void);
-
-#define ASSLOG(A) ::write(STDERR_FILENO,A,::strlen(A));
-#ifdef HAVE_EXECINFO_H
-#define GRID_ASSERT(b) if(!(b)) {					\
-    fflush(stdout); \
-    ASSLOG(" GRID_ASSERT failure: ");					\
-    ASSLOG(__FILE__);							\
-    ASSLOG(" : ");							\
-    ASSLOG(#b);								\
-    ASSLOG(" : ");							\
-    int symbols = backtrace(Grid_backtrace_buffer,_NBACKTRACE);		\
-    backtrace_symbols_fd(Grid_backtrace_buffer,symbols,STDERR_FILENO);	\
-    GridAbort();							\
-  };
-#else
-#define GRID_ASSERT(b) if(!(b)) {					\
-    ASSLOG(" GRID_ASSERT failure: ");					\
-    ASSLOG(__FILE__);							\
-    ASSLOG(" : ");							\
-    ASSLOG(#b);								\
-    ASSLOG(" : ");							\
-    GridAbort();							\
-  };
-#endif
 
+///////////////////
+// Grid config
+///////////////////
+#include "Config.h"
 
 #ifdef TOFU
 #undef GRID_COMMS_THREADS

Grid/Makefile.am

@@ -54,7 +54,6 @@ Version.h: version-cache
 include Make.inc
 include Eigen.inc
 
-if BUILD_FERMION_INSTANTIATIONS
 extra_sources+=$(WILS_FERMION_FILES)
 extra_sources+=$(STAG_FERMION_FILES)
 if BUILD_ZMOBIUS
@@ -69,11 +68,8 @@ if BUILD_FERMION_REPS
 endif
 if BUILD_SP
     extra_sources+=$(SP_FERMION_FILES)
-if BUILD_FERMION_REPS
     extra_sources+=$(SP_TWOIND_FERMION_FILES)
 endif
-endif
-endif
 
 lib_LIBRARIES = libGrid.a
 

Grid/Namespace.h

@@ -29,8 +29,8 @@ directory
 #pragma once
 
 #include <type_traits>
-#include <exception>
 #include <cassert>
+#include <exception>
 
 #define NAMESPACE_BEGIN(A) namespace A {
 #define NAMESPACE_END(A)   }

Grid/algorithms/Algorithms.h

@@ -51,8 +51,6 @@ NAMESPACE_CHECK(approx);
 #include <Grid/algorithms/deflation/MultiRHSBlockProject.h>
 #include <Grid/algorithms/deflation/MultiRHSDeflation.h>
 #include <Grid/algorithms/deflation/MultiRHSBlockCGLinalg.h>
-// Not really deflation, but useful
-#include <Grid/algorithms/blas/MomentumProject.h>
 NAMESPACE_CHECK(deflation);
 #include <Grid/algorithms/iterative/ConjugateGradient.h>
 NAMESPACE_CHECK(ConjGrad);

Grid/algorithms/FFT.h

@@ -28,15 +28,6 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 #ifndef _GRID_FFT_H_
 #define _GRID_FFT_H_
 
-#ifdef GRID_CUDA
-#include <cufft.h>
-#endif
-
-#ifdef GRID_HIP
-#include <hipfft/hipfft.h>
-#endif
-
-#if !defined(GRID_CUDA) && !defined(GRID_HIP)
 #ifdef HAVE_FFTW
 #if defined(USE_MKL) || defined(GRID_SYCL)
 #include <fftw/fftw3.h>
@@ -44,167 +35,89 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 #include <fftw3.h>
 #endif
 #endif
-#endif
 
 NAMESPACE_BEGIN(Grid);
 
-#ifndef FFTW_FORWARD
+template<class scalar> struct FFTW { };
-#define FFTW_FORWARD (-1)
-#define FFTW_BACKWARD (+1)
-#define FFTW_ESTIMATE (0)
-#endif
 
-template<class scalar> struct FFTW {
-};
-
-#ifdef GRID_HIP
-template<> struct FFTW<ComplexD> {
-public:
-  static const int forward=FFTW_FORWARD;
-  static const int backward=FFTW_BACKWARD;
-  typedef hipfftDoubleComplex FFTW_scalar;
-  typedef hipfftHandle        FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    FFTW_plan p;
-    auto rv = hipfftPlanMany(&p,rank,n,n,istride,idist,n,ostride,odist,HIPFFT_Z2Z,howmany);
-    GRID_ASSERT(rv==HIPFFT_SUCCESS);
-    return p;
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    hipfftResult rv;
-    if ( sign == forward ) rv =hipfftExecZ2Z(p,in,out,HIPFFT_FORWARD);
-    else                   rv =hipfftExecZ2Z(p,in,out,HIPFFT_BACKWARD);
-    accelerator_barrier();
-    GRID_ASSERT(rv==HIPFFT_SUCCESS);
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { hipfftDestroy(p); }
-};
-template<> struct FFTW<ComplexF> {
-public:
-  static const int forward=FFTW_FORWARD;
-  static const int backward=FFTW_BACKWARD;
-  typedef hipfftComplex FFTW_scalar;
-  typedef hipfftHandle  FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    FFTW_plan p;
-    auto rv = hipfftPlanMany(&p,rank,n,n,istride,idist,n,ostride,odist,HIPFFT_C2C,howmany);
-    GRID_ASSERT(rv==HIPFFT_SUCCESS);
-    return p;
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    hipfftResult rv;
-    if ( sign == forward ) rv =hipfftExecC2C(p,in,out,HIPFFT_FORWARD);
-    else                   rv =hipfftExecC2C(p,in,out,HIPFFT_BACKWARD);
-    accelerator_barrier();
-    GRID_ASSERT(rv==HIPFFT_SUCCESS);
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { hipfftDestroy(p); }
-};
-#endif
-
-#ifdef GRID_CUDA
-template<> struct FFTW<ComplexD> {
-public:
-  static const int forward=FFTW_FORWARD;
-  static const int backward=FFTW_BACKWARD;
-  typedef cufftDoubleComplex FFTW_scalar;
-  typedef cufftHandle        FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    FFTW_plan p;
-    cufftPlanMany(&p,rank,n,n,istride,idist,n,ostride,odist,CUFFT_Z2Z,howmany);
-    return p;
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    if ( sign == forward ) cufftExecZ2Z(p,in,out,CUFFT_FORWARD);
-    else                   cufftExecZ2Z(p,in,out,CUFFT_INVERSE);
-    accelerator_barrier();
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { cufftDestroy(p); }
-};
-template<> struct FFTW<ComplexF> {
-public:
-  static const int forward=FFTW_FORWARD;
-  static const int backward=FFTW_BACKWARD;
-  typedef cufftComplex FFTW_scalar;
-  typedef cufftHandle  FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    FFTW_plan p;
-    cufftPlanMany(&p,rank,n,n,istride,idist,n,ostride,odist,CUFFT_C2C,howmany);
-    return p;
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    if ( sign == forward ) cufftExecC2C(p,in,out,CUFFT_FORWARD);
-    else                   cufftExecC2C(p,in,out,CUFFT_INVERSE);
-    accelerator_barrier();
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { cufftDestroy(p); }
-};
-#endif
-
-#if !defined(GRID_CUDA) && !defined(GRID_HIP)
 #ifdef HAVE_FFTW	
 template<> struct FFTW<ComplexD> {
 public:
+
   typedef fftw_complex FFTW_scalar;
   typedef fftw_plan    FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
+
-				      FFTW_scalar *in, int *inembed,
+  static FFTW_plan fftw_plan_many_dft(int rank, const int *n,int howmany,
+				      FFTW_scalar *in, const int *inembed,		
 				      int istride, int idist,		
-				      FFTW_scalar *out, int *onembed,
+				      FFTW_scalar *out, const int *onembed,		
 				      int ostride, int odist,		
 				      int sign, unsigned flags) {
     return ::fftw_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags);
   }	  
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
+    
+  static void fftw_flops(const FFTW_plan p,double *add, double *mul, double *fmas){
+    ::fftw_flops(p,add,mul,fmas);
+  }
+
+  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out) {
     ::fftw_execute_dft(p,in,out);
   }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { ::fftw_destroy_plan(p); }
+  inline static void fftw_destroy_plan(const FFTW_plan p) {
+    ::fftw_destroy_plan(p);
+  }
 };
+
 template<> struct FFTW<ComplexF> {
 public:
+
   typedef fftwf_complex FFTW_scalar;
   typedef fftwf_plan    FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
+
-				      FFTW_scalar *in, int *inembed,
+  static FFTW_plan fftw_plan_many_dft(int rank, const int *n,int howmany,
+				      FFTW_scalar *in, const int *inembed,		
 				      int istride, int idist,		
-				      FFTW_scalar *out, int *onembed,
+				      FFTW_scalar *out, const int *onembed,		
 				      int ostride, int odist,		
 				      int sign, unsigned flags) {
     return ::fftwf_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags);
   }	  
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
+    
+  static void fftw_flops(const FFTW_plan p,double *add, double *mul, double *fmas){
+    ::fftwf_flops(p,add,mul,fmas);
+  }
+
+  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out) {
     ::fftwf_execute_dft(p,in,out);
   }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { ::fftwf_destroy_plan(p); }
+  inline static void fftw_destroy_plan(const FFTW_plan p) {
+    ::fftwf_destroy_plan(p);
+  }
 };
-#endif
+
 #endif
 
-struct FFTbase {
+#ifndef FFTW_FORWARD
+#define FFTW_FORWARD (-1)
+#define FFTW_BACKWARD (+1)
+#endif
+
+class FFT {
+private:
+    
+  GridCartesian *vgrid;
+  GridCartesian *sgrid;
+    
+  int Nd;
   double flops;
   double flops_call;
   uint64_t usec;
-  GridCartesian *_grid;
+    
+  Coordinate dimensions;
+  Coordinate processors;
+  Coordinate processor_coor;
+    
+public:
     
   static const int forward=FFTW_FORWARD;
   static const int backward=FFTW_BACKWARD;
@@ -213,280 +126,168 @@ struct FFTbase {
   double MFlops(void) {return flops/usec;}
   double USec(void)   {return (double)usec;}    
 
-  FFTbase(GridCartesian *grid) : _grid(grid), flops(0), flops_call(0), usec(0) {}
+  FFT ( GridCartesian * grid ) :
+    vgrid(grid),
+    Nd(grid->_ndimension),
+    dimensions(grid->_fdimensions),
+    processors(grid->_processors),
+    processor_coor(grid->_processor_coor)
+  {
+    flops=0;
+    usec =0;
+    Coordinate layout(Nd,1);
+    sgrid = new GridCartesian(dimensions,layout,processors,*grid);
   };
     
-// Barrel-shift gather, FFT execute, and insert. Called by both FFT and PlannedFFT.
+  ~FFT ( void)  {
-// The caller is responsible for plan acquisition and destruction.
+    delete sgrid;
+  }
+    
   template<class vobj>
-static void FFT_dim_execute(
+  void FFT_dim_mask(Lattice<vobj> &result,const Lattice<vobj> &source,Coordinate mask,int sign){
-    Lattice<vobj>       &result,
+
-    const Lattice<vobj> &source,
+    conformable(result.Grid(),vgrid);
-    int dim, int sign,
+    conformable(source.Grid(),vgrid);
-    typename FFTW<typename vobj::scalar_type>::FFTW_plan p,
+    Lattice<vobj> tmp(vgrid);
-    GridCartesian *grid,
+    tmp = source;
-    double &flops, double &flops_call, uint64_t &usec)
+    for(int d=0;d<Nd;d++){
-{
+      if( mask[d] ) {
-  typedef typename vobj::scalar_type   scalar;
+	FFT_dim(result,tmp,d,sign);
+	tmp=result;
+      }
+    }
+  }
+
+  template<class vobj>
+  void FFT_all_dim(Lattice<vobj> &result,const Lattice<vobj> &source,int sign){
+    Coordinate mask(Nd,1);
+    FFT_dim_mask(result,source,mask,sign);
+  }
+
+
+  template<class vobj>
+  void FFT_dim(Lattice<vobj> &result,const Lattice<vobj> &source,int dim, int sign){
+#ifndef HAVE_FFTW
+    assert(0);
+#else
+    conformable(result.Grid(),vgrid);
+    conformable(source.Grid(),vgrid);
+
+    int L = vgrid->_ldimensions[dim];
+    int G = vgrid->_fdimensions[dim];
+      
+    Coordinate layout(Nd,1);
+    Coordinate pencil_gd(vgrid->_fdimensions);
+      
+    pencil_gd[dim] = G*processors[dim];
+      
+    // Pencil global vol LxLxGxLxL per node
+    GridCartesian pencil_g(pencil_gd,layout,processors,*vgrid);
+      
+    // Construct pencils
     typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type   scalar_type;
+    typedef typename sobj::scalar_type   scalar;
-  typedef typename vobj::vector_type   vector_type;
+      
+    Lattice<sobj> pgbuf(&pencil_g);
+    autoView(pgbuf_v , pgbuf, CpuWrite);
+
     typedef typename FFTW<scalar>::FFTW_scalar FFTW_scalar;
+    typedef typename FFTW<scalar>::FFTW_plan   FFTW_plan;
       
-  const int Ndim = grid->Nd();
-  int L = grid->_ldimensions[dim];
-  int G = grid->_fdimensions[dim];
     int Ncomp = sizeof(sobj)/sizeof(scalar);
-  int64_t Nlow = 1, Nhigh = 1;
+    int Nlow  = 1;
-  for (int d = 0; d < dim;      d++) Nlow  *= grid->_ldimensions[d];
+    for(int d=0;d<dim;d++){
-  for (int d = dim+1; d < Ndim; d++) Nhigh *= grid->_ldimensions[d];
+      Nlow*=vgrid->_ldimensions[d];
-  int64_t Nperp = Nlow * Nhigh;
+    }
       
-  deviceVector<scalar> pgbuf(Nperp * Ncomp * G);
+    int rank = 1;  /* 1d transforms */
-  scalar *pgbuf_v = &pgbuf[0];
+    int n[] = {G}; /* 1d transforms of length G */
-  int howmany = Ncomp * Nperp;
+    int howmany = Ncomp;
+    int odist,idist,istride,ostride;
+    idist   = odist   = 1;          /* Distance between consecutive FT's */
+    istride = ostride = Ncomp*Nlow; /* distance between two elements in the same FT */
+    int *inembed = n, *onembed = n;
       
     scalar div;
-  if      (sign == FFTW_BACKWARD) div = 1.0 / G;
+    if ( sign == backward ) div = 1.0/G;
-  else if (sign == FFTW_FORWARD)  div = 1.0;
+    else if ( sign == forward ) div = 1.0;
-  else GRID_ASSERT(0);
+    else assert(0);
       
-  double t_pencil = 0, t_fft = 0, t_copy = 0, t_shift = 0;
+    FFTW_plan p;
-  double t_total  = -usecond();
+    {
+      FFTW_scalar *in = (FFTW_scalar *)&pgbuf_v[0];
+      FFTW_scalar *out= (FFTW_scalar *)&pgbuf_v[0];
+      p = FFTW<scalar>::fftw_plan_many_dft(rank,n,howmany,
+					   in,inembed,
+					   istride,idist,
+					   out,onembed,
+					   ostride, odist,
+					   sign,FFTW_ESTIMATE);
+    }
       
+    // Barrel shift and collect global pencil
+    Coordinate lcoor(Nd), gcoor(Nd);
     result = source;
-  int pc = grid->_processor_coor[dim];
+    int pc = processor_coor[dim];
-
+    for(int p=0;p<processors[dim];p++) {
-  const Coordinate ldims      = grid->_ldimensions;
-  const Coordinate rdims      = grid->_rdimensions;
-  const Coordinate sdims      = grid->_simd_layout;
-  const Coordinate processors = grid->_processors;
-
-  Coordinate pgdims(Ndim);
-  pgdims[0] = G;
-  for (int d = 0, dd = 1; d < Ndim; d++)
-    if (d != dim) pgdims[dd++] = ldims[d];
-  int64_t pgvol = 1;
-  for (int d = 0; d < Ndim; d++) pgvol *= pgdims[d];
-
-  const int Nsimd = vobj::Nsimd();
-  t_pencil = -usecond();
-  for (int p_idx = 0; p_idx < processors[dim]; p_idx++) {
-    t_copy -= usecond();
-    autoView(r_v, result, AcceleratorRead);
-    accelerator_for(idx, grid->oSites(), vobj::Nsimd(), {
-#ifdef GRID_SIMT
       {
-      int lane = acceleratorSIMTlane(Nsimd);
+	autoView(r_v,result,CpuRead);
-#else
+	autoView(p_v,pgbuf,CpuWrite);
-    for (int lane = 0; lane < Nsimd; lane++) {
+	thread_for(idx, sgrid->lSites(),{
-#endif
+          Coordinate cbuf(Nd);
-      Coordinate icoor, ocoor, pgcoor;
+          sobj s;
-      Lexicographic::CoorFromIndex(icoor, lane, sdims);
+	  sgrid->LocalIndexToLocalCoor(idx,cbuf);
-      Lexicographic::CoorFromIndex(ocoor, idx,  rdims);
+	  peekLocalSite(s,r_v,cbuf);
-      pgcoor[0] = ocoor[dim] + icoor[dim]*rdims[dim] + ((pc+p_idx)%processors[dim])*L;
+	  cbuf[dim]+=((pc+p) % processors[dim])*L;
-      for (int d = 0, dd = 1; d < Ndim; d++)
+	  pokeLocalSite(s,p_v,cbuf);
-        if (d != dim) { pgcoor[dd] = ocoor[d] + icoor[d]*rdims[d]; dd++; }
-      int64_t pgidx;
-      Lexicographic::IndexFromCoor(pgcoor, pgidx, pgdims);
-      vector_type *from = (vector_type *)&r_v[idx];
-      scalar_type  stmp;
-      for (int w = 0; w < Ncomp; w++) {
-        stmp = getlane(from[w], lane);
-        pgbuf_v[pgidx + w*pgvol] = stmp;
-      }
-#ifdef GRID_SIMT
-    }
-#else
-    }
-#endif
         });
-    t_copy += usecond();
+      }
-    if (p_idx != processors[dim] - 1) {
+      if (p != processors[dim] - 1) {
-      Lattice<vobj> temp(grid);
+	result = Cshift(result,dim,L);
-      t_shift -= usecond();
-      temp = Cshift(result, dim, L); result = temp;
-      t_shift += usecond();
       }
     }
-  t_pencil += usecond();
       
-  FFTW_scalar *in  = (FFTW_scalar *)pgbuf_v;
+    // Loop over orthog coords
-  FFTW_scalar *out = (FFTW_scalar *)pgbuf_v;
+    int NN=pencil_g.lSites();
-  t_fft = -usecond();
+    GridStopWatch timer;
-  FFTW<scalar>::fftw_execute_dft(p, in, out, sign);
+    timer.Start();
-  t_fft += usecond();
+    thread_for( idx,NN,{
+        Coordinate cbuf(Nd);
+	pencil_g.LocalIndexToLocalCoor(idx, cbuf);
+	if ( cbuf[dim] == 0 ) {  // restricts loop to plane at lcoor[dim]==0
+	  FFTW_scalar *in = (FFTW_scalar *)&pgbuf_v[idx];
+	  FFTW_scalar *out= (FFTW_scalar *)&pgbuf_v[idx];
+	  FFTW<scalar>::fftw_execute_dft(p,in,out);
+	}
+    });
+    timer.Stop();
       
-  flops_call = 5.0 * howmany * G * log2(G);
+    // performance counting
-  usec  = t_fft;
+    double add,mul,fma;
-  flops = flops_call;
+    FFTW<scalar>::fftw_flops(p,&add,&mul,&fma);
+    flops_call = add+mul+2.0*fma;
+    usec += timer.useconds();
+    flops+= flops_call*NN;
       
-  result = Zero();
+    // writing out result
-  double t_insert = -usecond();
     {
-    autoView(r_v, result, AcceleratorWrite);
+      autoView(pgbuf_v,pgbuf,CpuRead);
-    accelerator_for(idx, grid->oSites(), Nsimd, {
+      autoView(result_v,result,CpuWrite);
-#ifdef GRID_SIMT
+      thread_for(idx,sgrid->lSites(),{
-    {
+	Coordinate clbuf(Nd), cgbuf(Nd);
-      int lane = acceleratorSIMTlane(Nsimd);
+	sobj s;
-#else
+	sgrid->LocalIndexToLocalCoor(idx,clbuf);
-    for (int lane = 0; lane < Nsimd; lane++) {
+	cgbuf = clbuf;
-#endif
+	cgbuf[dim] = clbuf[dim]+L*pc;
-      Coordinate icoor(Ndim), ocoor(Ndim), pgcoor(Ndim);
+	peekLocalSite(s,pgbuf_v,cgbuf);
-      Lexicographic::CoorFromIndex(icoor, lane, sdims);
+	pokeLocalSite(s,result_v,clbuf);
-      Lexicographic::CoorFromIndex(ocoor, idx,  rdims);
-      pgcoor[0] = ocoor[dim] + icoor[dim]*rdims[dim] + pc*L;
-      for (int d = 0, dd = 1; d < Ndim; d++)
-        if (d != dim) { pgcoor[dd] = ocoor[d] + icoor[d]*rdims[d]; dd++; }
-      int64_t pgidx;
-      Lexicographic::IndexFromCoor(pgcoor, pgidx, pgdims);
-      vector_type *to  = (vector_type *)&r_v[idx];
-      scalar_type  stmp;
-      for (int w = 0; w < Ncomp; w++) {
-        stmp = pgbuf_v[pgidx + w*pgvol];
-        putlane(to[w], stmp, lane);
-      }
-#ifdef GRID_SIMT
-    }
-#else
-    }
-#endif
       });
     }
     result = result*div;
-  t_insert += usecond();
-  t_total  += usecond();
       
-  std::cout << GridLogPerformance << " FFT took   " << t_total/1.0e6  << " s" << std::endl;
+    // destroying plan
-  std::cout << GridLogPerformance << " FFT pencil " << t_pencil/1.0e6 << " s" << std::endl;
-  std::cout << GridLogPerformance << "  of which copy " << t_copy/1.0e6  << " s" << std::endl;
-  std::cout << GridLogPerformance << "  of which shift" << t_shift/1.0e6 << " s" << std::endl;
-  std::cout << GridLogPerformance << " FFT kernels " << t_fft/1.0e6    << " s" << std::endl;
-  std::cout << GridLogPerformance << " FFT insert  " << t_insert/1.0e6 << " s" << std::endl;
-}
-
-class FFT : public FFTbase {
-public:
-  FFT(GridCartesian *grid) : FFTbase(grid) {}
-  ~FFT() {}
-
-  template<class vobj>
-  void FFT_dim_mask(Lattice<vobj> &result, const Lattice<vobj> &source, Coordinate mask, int sign) {
-    const int Ndim = _grid->Nd();
-    Lattice<vobj> tmp = source;
-    for (int d = 0; d < Ndim; d++) {
-      if (mask[d]) {
-        FFT_dim(result, tmp, d, sign);
-        tmp = result;
-      }
-    }
-  }
-
-  template<class vobj>
-  void FFT_all_dim(Lattice<vobj> &result, const Lattice<vobj> &source, int sign) {
-    Coordinate mask(_grid->Nd(), 1);
-    FFT_dim_mask(result, source, mask, sign);
-  }
-
-  template<class vobj>
-  void FFT_dim(Lattice<vobj> &result, const Lattice<vobj> &source, int dim, int sign) {
-    GRID_ASSERT(source.Grid() == _grid);
-    GRID_ASSERT(result.Grid() == _grid);
-    conformable(result.Grid(), source.Grid());
-
-    typedef typename vobj::scalar_type   scalar;
-    typedef typename vobj::scalar_object sobj;
-    typedef typename FFTW<scalar>::FFTW_scalar FFTW_scalar;
-    typedef typename FFTW<scalar>::FFTW_plan   FFTW_plan;
-
-    const int Ndim = _grid->Nd();
-    int G     = _grid->_fdimensions[dim];
-    int Ncomp = sizeof(sobj) / sizeof(scalar);
-    int64_t Nperp = 1;
-    for (int d = 0; d < Ndim; d++)
-      if (d != dim) Nperp *= _grid->_ldimensions[d];
-    int n[]     = {G};
-    int howmany = Ncomp * Nperp;
-
-    deviceVector<scalar> dummy(2);
-    FFTW_scalar *buf = (FFTW_scalar *)&dummy[0];
-    FFTW_plan p = FFTW<scalar>::fftw_plan_many_dft(1, n, howmany,
-                                                    buf, n, 1, G,
-                                                    buf, n, 1, G,
-                                                    sign, FFTW_ESTIMATE);
-    FFT_dim_execute(result, source, dim, sign, p, _grid, flops, flops_call, usec);
     FFTW<scalar>::fftw_destroy_plan(p);
-  }
+#endif
-};
-
-template<class vobj>
-class PlannedFFT : public FFTbase {
-private:
-  typedef typename vobj::scalar_type   scalar;
-  typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::vector_type   vector_type;
-  typedef typename FFTW<scalar>::FFTW_scalar FFTW_scalar;
-  typedef typename FFTW<scalar>::FFTW_plan   FFTW_plan;
-
-  std::vector<FFTW_plan> forward_plans;
-  std::vector<FFTW_plan> backward_plans;
-
-  void PlanCreate() {
-    const int Ndim = _grid->Nd();
-    forward_plans.resize(Ndim);
-    backward_plans.resize(Ndim);
-
-    for (int d = 0; d < Ndim; d++) {
-      int G       = _grid->_fdimensions[d];
-      int Ncomp   = sizeof(sobj) / sizeof(scalar);
-      int64_t Nperp = 1;
-      for (int dd = 0; dd < Ndim; dd++)
-        if (dd != d) Nperp *= _grid->_ldimensions[dd];
-      int howmany = Ncomp * (int)Nperp;
-      int n[]     = {G};
-
-      deviceVector<scalar> dummy(2);
-      FFTW_scalar *buf = (FFTW_scalar *)&dummy[0];
-
-      forward_plans[d]  = FFTW<scalar>::fftw_plan_many_dft(1, n, howmany, buf, n, 1, G, buf, n, 1, G, FFTW_FORWARD,  FFTW_ESTIMATE);
-      backward_plans[d] = FFTW<scalar>::fftw_plan_many_dft(1, n, howmany, buf, n, 1, G, buf, n, 1, G, FFTW_BACKWARD, FFTW_ESTIMATE);
-    }
-  }
-
-  void PlanDestroy() {
-    for (auto p : forward_plans)  FFTW<scalar>::fftw_destroy_plan(p);
-    for (auto p : backward_plans) FFTW<scalar>::fftw_destroy_plan(p);
-    forward_plans.clear();
-    backward_plans.clear();
-  }
-
-public:
-  PlannedFFT(GridCartesian *grid) : FFTbase(grid) { PlanCreate(); }
-  ~PlannedFFT() { PlanDestroy(); }
-
-  void FFT_dim_mask(Lattice<vobj> &result, const Lattice<vobj> &source, Coordinate mask, int sign) {
-    const int Ndim = _grid->Nd();
-    Lattice<vobj> tmp = source;
-    for (int d = 0; d < Ndim; d++) {
-      if (mask[d]) {
-        FFT_dim(result, tmp, d, sign);
-        tmp = result;
-      }
-    }
-  }
-
-  void FFT_all_dim(Lattice<vobj> &result, const Lattice<vobj> &source, int sign) {
-    Coordinate mask(_grid->Nd(), 1);
-    FFT_dim_mask(result, source, mask, sign);
-  }
-
-  void FFT_dim(Lattice<vobj> &result, const Lattice<vobj> &source, int dim, int sign) {
-    GRID_ASSERT(source.Grid() == _grid);
-    GRID_ASSERT(result.Grid() == _grid);
-    GRID_ASSERT((int)forward_plans.size() == _grid->Nd());
-    conformable(result.Grid(), source.Grid());
-    FFTW_plan p = (sign == forward ? forward_plans : backward_plans)[dim];
-    FFT_dim_execute(result, source, dim, sign, p, _grid, flops, flops_call, usec);
   }
 };
 

Grid/algorithms/LinearOperator.h

@@ -64,7 +64,7 @@ public:
 //
 // I'm not entirely happy with implementation; to share the Schur code between herm and non-herm
 // while still having a "OpAndNorm" in the abstract base I had to implement it in both cases
-// with an GRID_ASSERT trap in the non-herm. This isn't right; there must be a better C++ way to
+// with an assert trap in the non-herm. This isn't right; there must be a better C++ way to
 // do it, but I fear it required multiple inheritance and mixed in abstract base classes
 /////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -148,22 +148,22 @@ public:
   // Support for coarsening to a multigrid
   void OpDiag (const Field &in, Field &out) {
     _Mat.Mdiag(in,out);
-    GRID_ASSERT(0);
+    assert(0);
   }
   void OpDir  (const Field &in, Field &out,int dir,int disp) {
     _Mat.Mdir(in,out,dir,disp);
-    GRID_ASSERT(0);
+    assert(0);
   }
   void OpDirAll  (const Field &in, std::vector<Field> &out){
-    GRID_ASSERT(0);
+    assert(0);
   };
   void Op     (const Field &in, Field &out){
     _Mat.M(in,out);
-    GRID_ASSERT(0);
+    assert(0);
   }
   void AdjOp     (const Field &in, Field &out){
     _Mat.Mdag(in,out);
-    GRID_ASSERT(0);
+    assert(0);
   }
   void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
     HermOp(in,out);
@@ -188,13 +188,13 @@ public:
   ShiftedHermOpLinearOperator(LinearOperatorBase<Field> &Mat,RealD shift): _Mat(Mat), _shift(shift){};
   // Support for coarsening to a multigrid
   void OpDiag (const Field &in, Field &out) {
-    GRID_ASSERT(0);
+    assert(0);
   }
   void OpDir  (const Field &in, Field &out,int dir,int disp) {
-    GRID_ASSERT(0);
+    assert(0);
   }
   void OpDirAll  (const Field &in, std::vector<Field> &out){
-    GRID_ASSERT(0);
+    assert(0);
   };
   void Op     (const Field &in, Field &out){
     HermOp(in,out);
@@ -271,42 +271,10 @@ public:
     _Mat.Mdag(in,out);
   }
   void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    GRID_ASSERT(0);
+    assert(0);
   }
   void HermOp(const Field &in, Field &out){
-    GRID_ASSERT(0);
+    assert(0);
-  }
-};
-template<class Matrix,class Field>
-class ShiftedNonHermitianLinearOperator : public LinearOperatorBase<Field> {
-  Matrix &_Mat;
-  RealD shift;
-public:
-  ShiftedNonHermitianLinearOperator(Matrix &Mat,RealD shft): _Mat(Mat),shift(shft){};
-  // Support for coarsening to a multigrid
-  void OpDiag (const Field &in, Field &out) {
-    _Mat.Mdiag(in,out);
-    out = out + shift*in;
-  }
-  void OpDir  (const Field &in, Field &out,int dir,int disp) {
-    _Mat.Mdir(in,out,dir,disp);
-  }
-  void OpDirAll  (const Field &in, std::vector<Field> &out){
-    _Mat.MdirAll(in,out);
-  };
-  void Op     (const Field &in, Field &out){
-    _Mat.M(in,out);
-    out = out + shift * in;
-  }
-  void AdjOp     (const Field &in, Field &out){
-    _Mat.Mdag(in,out);
-    out = out + shift * in;
-  }
-  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    GRID_ASSERT(0);
-  }
-  void HermOp(const Field &in, Field &out){
-    GRID_ASSERT(0);
   }
 };
 
@@ -345,13 +313,13 @@ class SchurOperatorBase :  public LinearOperatorBase<Field> {
   }
   // Support for coarsening to a multigrid
   void OpDiag (const Field &in, Field &out) {
-    GRID_ASSERT(0); // must coarsen the unpreconditioned system
+    assert(0); // must coarsen the unpreconditioned system
   }
   void OpDir  (const Field &in, Field &out,int dir,int disp) {
-    GRID_ASSERT(0);
+    assert(0);
   }
   void OpDirAll  (const Field &in, std::vector<Field> &out){
-    GRID_ASSERT(0);
+    assert(0);
   };
 };
 template<class Matrix,class Field>
@@ -447,10 +415,10 @@ class NonHermitianSchurOperatorBase :  public LinearOperatorBase<Field>
     MpcDag(tmp,out);
   }
   virtual void HermOpAndNorm(const Field& in, Field& out, RealD& n1, RealD& n2) {
-    GRID_ASSERT(0);
+    assert(0);
   }
   virtual void HermOp(const Field& in, Field& out) {
-    GRID_ASSERT(0);
+    assert(0);
   }
   void Op(const Field& in, Field& out) {
     Mpc(in, out);
@@ -460,13 +428,13 @@ class NonHermitianSchurOperatorBase :  public LinearOperatorBase<Field>
   }
   // Support for coarsening to a multigrid
   void OpDiag(const Field& in, Field& out) {
-    GRID_ASSERT(0); // must coarsen the unpreconditioned system
+    assert(0); // must coarsen the unpreconditioned system
   }
   void OpDir(const Field& in, Field& out, int dir, int disp) {
-    GRID_ASSERT(0);
+    assert(0);
   }
   void OpDirAll(const Field& in, std::vector<Field>& out){
-    GRID_ASSERT(0);
+    assert(0);
   };
 };
 
@@ -580,7 +548,7 @@ class SchurStaggeredOperator :  public SchurOperatorBase<Field> {
  public:
   SchurStaggeredOperator (Matrix &Mat): _Mat(Mat), tmp(_Mat.RedBlackGrid()) 
   { 
-    GRID_ASSERT( _Mat.isTrivialEE() );
+    assert( _Mat.isTrivialEE() );
     mass = _Mat.Mass();
   }
   virtual void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
@@ -611,7 +579,7 @@ class SchurStaggeredOperator :  public SchurOperatorBase<Field> {
     Mpc(in,out);
   }
   virtual void MpcDagMpc(const Field &in, Field &out) {
-    GRID_ASSERT(0);// Never need with staggered
+    assert(0);// Never need with staggered
   }
 };
 template<class Matrix,class Field> using SchurStagOperator = SchurStaggeredOperator<Matrix,Field>;
@@ -623,7 +591,7 @@ template<class Field> class OperatorFunction {
 public:
   virtual void operator() (LinearOperatorBase<Field> &Linop, const Field &in, Field &out) = 0;
   virtual void operator() (LinearOperatorBase<Field> &Linop, const std::vector<Field> &in,std::vector<Field> &out) {
-    GRID_ASSERT(in.size()==out.size());
+    assert(in.size()==out.size());
     for(int k=0;k<in.size();k++){
       (*this)(Linop,in[k],out[k]);
     }
@@ -637,7 +605,7 @@ public:
 
   virtual void operator() (const std::vector<Field> &in, std::vector<Field> &out)
   {
-    GRID_ASSERT(in.size() == out.size());
+    assert(in.size() == out.size());
 
     for (unsigned int i = 0; i < in.size(); ++i)
     {

Grid/algorithms/approx/Chebyshev.h

@@ -269,9 +269,7 @@ public:
     RealD xscale = 2.0/(hi-lo);
     RealD mscale = -(hi+lo)/(hi-lo);
     Linop.HermOp(T0,y);
-    grid->Barrier();
     axpby(T1,xscale,mscale,y,in);
-    grid->Barrier();
 
     // sum = .5 c[0] T0 + c[1] T1
     //    out = ()*T0 + Coeffs[1]*T1;

Grid/algorithms/approx/Remez.cc

@@ -121,7 +121,7 @@ double AlgRemez::generateApprox(int num_degree, int den_degree,
   // Reallocate arrays, since degree has changed
   if (num_degree != n || den_degree != d) allocate(num_degree,den_degree);
 
-  GRID_ASSERT(a_len<=SUM_MAX);
+  assert(a_len<=SUM_MAX);
 
   step = new bigfloat[num_degree+den_degree+2];
 
@@ -151,9 +151,9 @@ double AlgRemez::generateApprox(int num_degree, int den_degree,
     equations();
     if (delta < tolerance) {
       std::cout<<"Delta too small, try increasing precision\n";
-      GRID_ASSERT(0);
+      assert(0);
     };    
-    GRID_ASSERT( delta>= tolerance);
+    assert( delta>= tolerance);
 
     search(step);
   }

Grid/algorithms/approx/Remez.h

@@ -134,7 +134,7 @@ class AlgRemez
   virtual ~AlgRemez();
 
   int getDegree(void){ 
-    GRID_ASSERT(n==d);
+    assert(n==d);
     return n;
   }
   // Reset the bounds of the approximation

Grid/algorithms/approx/RemezGeneral.cc

@@ -28,11 +28,11 @@ void AlgRemezGeneral::setupPolyProperties(int num_degree, int den_degree, PolyTy
   pow_n = num_degree;
   pow_d = den_degree;
 
-  if(pow_n % 2 == 0 && num_type_in == PolyType::Odd) GRID_ASSERT(0);
+  if(pow_n % 2 == 0 && num_type_in == PolyType::Odd) assert(0);
-  if(pow_n % 2 == 1 && num_type_in == PolyType::Even) GRID_ASSERT(0);
+  if(pow_n % 2 == 1 && num_type_in == PolyType::Even) assert(0);
 
-  if(pow_d % 2 == 0 && den_type_in == PolyType::Odd) GRID_ASSERT(0);
+  if(pow_d % 2 == 0 && den_type_in == PolyType::Odd) assert(0);
-  if(pow_d % 2 == 1 && den_type_in == PolyType::Even) GRID_ASSERT(0);
+  if(pow_d % 2 == 1 && den_type_in == PolyType::Even) assert(0);
 
   num_type = num_type_in;
   den_type = den_type_in;
@@ -112,9 +112,9 @@ double AlgRemezGeneral::generateApprox(const int num_degree, const int den_degre
     equations();
     if (delta < tolerance) {
       std::cout<<"Iteration " << iter-1 << " delta too small (" << delta << "<" << tolerance << "), try increasing precision\n";
-      GRID_ASSERT(0);
+      assert(0);
     };    
-    GRID_ASSERT( delta>= tolerance );
+    assert( delta>= tolerance );
 
     search();
   }
@@ -278,7 +278,7 @@ void AlgRemezGeneral::equations(){
       if(num_pows[j] != -1){ *aa++ = z; t++; }
       z *= x;
     }
-    GRID_ASSERT(t == n+1);
+    assert(t == n+1);
 
     z = (bigfloat)1l;
     t = 0;
@@ -286,7 +286,7 @@ void AlgRemezGeneral::equations(){
       if(den_pows[j] != -1){ *aa++ = -y * z; t++; }
       z *= x;
     }
-    GRID_ASSERT(t == d);
+    assert(t == d);
 
     B[i] = y * z;		// Right hand side vector
   }

Grid/algorithms/approx/RemezGeneral.h

@@ -106,7 +106,7 @@ class AlgRemezGeneral{
 		  bigfloat (*f)(bigfloat x, void *data), void *data);
 
   inline int getDegree(void) const{ 
-    GRID_ASSERT(n==d);
+    assert(n==d);
     return n;
   }
   // Reset the bounds of the approximation

Grid/algorithms/approx/ZMobius.cc

@@ -74,7 +74,7 @@ bigfloat epsilonMobius(bigfloat x, void* data){
 void computeZmobiusOmega(std::vector<ComplexD> &omega_out, const int Ls_out,
 			 const std::vector<RealD> &omega_in, const int Ls_in,
 			 const RealD lambda_bound){
-  GRID_ASSERT(omega_in.size() == Ls_in);
+  assert(omega_in.size() == Ls_in);
   omega_out.resize(Ls_out);
 
   //Use the Remez algorithm to generate the appropriate rational polynomial

Grid/algorithms/blas/BatchedInverse.h

@@ -1,282 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: BatchedInverse.h
-
-    Copyright (C) 2026
-
-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
-
-#include <Grid/algorithms/blas/BatchedBlas.h>
-
-#ifdef GRID_HIP
-#include <rocsolver/rocsolver.h>
-#endif
-// GRID_CUDA: batched LU inversion lives in cuBLAS (getrfBatched/getriBatched);
-//            cublas_v2.h already included via BatchedBlas.h.
-// GRID_SYCL: oneapi/mkl.hpp already included via BatchedBlas.h (lapack::getrf/getri).
-
-NAMESPACE_BEGIN(Grid);
-
-///////////////////////////////////////////////////////////////////////////////
-// GridBLASInverse: cross-platform batched dense matrix inversion.
-//
-// HIGH LEVEL contract (deliberately NOT a getrf/getrs interface): invert a
-// batch of dense N x N matrices IN PLACE,
-//
-//     A[i] <- A[i]^{-1}       i = 0 .. batchCount-1
-//
-// Layout: column major, lda = N, contiguous per batch element; pointer list
-// exactly as GridBLAS::gemmBatched (deviceVector<T*> of device pointers).
-// Each backend chooses HOW:
-//   HIP  : rocSOLVER getrf_batched + getri_batched
-//   CUDA : cuBLAS getrfBatched + getriBatched (out-of-place getri; workspace
-//          hidden here, result copied back so the surface stays in-place)
-//   SYCL : oneMKL LAPACK getrf + getri per batch element (USM, in-order queue)
-//   CPU  : Eigen PartialPivLU (the correctness oracle for all of the above)
-//
-// The int32 vendor-batched entry points bound N < 2^31 (asserted); the huge
-// single-matrix ILP64 path (getrf_64 + blocked identity-getrs harvest, proven
-// in the dense coarse-coarse setup at N=69120) migrates here as a batch==1
-// large-N dispatch in a follow-up -- the recursive Schur leaves are the
-// batched consumers this surface is shaped for.
-//
-// NB GPU-backend call signatures are written to vendor documentation but the
-// air-gapped development loop compiles only the CPU/Eigen path; verify the
-// rocSOLVER/cuBLAS/oneMKL calls against headers on first device compile.
-// Semantics are locked by the CPU unit test (Test_batched_blas).
-///////////////////////////////////////////////////////////////////////////////
-class GridBLASInverse {
-public:
-
-#ifdef GRID_HIP
-  // rocSOLVER runs on a rocblas_handle (distinct type from hipblasHandle_t)
-  static rocblas_handle & Handle(void) {
-    static rocblas_handle h;
-    static int init = 0;
-    if ( !init ) {
-      auto st = rocblas_create_handle(&h);
-      GRID_ASSERT(st == rocblas_status_success);
-      init = 1;
-    }
-    return h;
-  }
-#endif
-#ifdef GRID_CUDA
-  // cuBLAS batched LU shares the GridBLAS handle
-  static cublasHandle_t & Handle(void) {
-    GridBLAS::Init();
-    return GridBLAS::gridblasHandle;
-  }
-#endif
-#ifdef GRID_SYCL
-  static sycl::queue * & Handle(void) {
-    GridBLAS::Init();
-    return GridBLAS::gridblasHandle;
-  }
-#endif
-
-  GridBLASInverse() {};
-  ~GridBLASInverse() {};
-
-  void inverseBatched(int64_t N, deviceVector<ComplexF*> &Amat)
-  {
-    int32_t batchCount = Amat.size();
-    GRID_ASSERT(batchCount > 0);
-
-#ifdef GRID_HIP
-    GRID_ASSERT( N < 2147483647L );
-    rocblas_int n   = (rocblas_int)N;
-    rocblas_int lda = (rocblas_int)N;
-
-    deviceVector<rocblas_int> ipiv((uint64_t)batchCount*N);
-    deviceVector<rocblas_int> info(batchCount);
-
-    auto st1 = rocsolver_cgetrf_batched(Handle(), n, n,
-					(rocblas_float_complex *const *)&Amat[0], lda,
-					&ipiv[0], (rocblas_stride)N,
-					&info[0], batchCount);
-    GRID_ASSERT(st1 == rocblas_status_success);
-    auto st2 = rocsolver_cgetri_batched(Handle(), n,
-					(rocblas_float_complex *const *)&Amat[0], lda,
-					&ipiv[0], (rocblas_stride)N,
-					&info[0], batchCount);
-    GRID_ASSERT(st2 == rocblas_status_success);
-    accelerator_barrier();
-    std::vector<rocblas_int> info_h(batchCount);
-    acceleratorCopyFromDevice(&info[0],&info_h[0],batchCount*sizeof(rocblas_int));
-    for(int i=0;i<batchCount;i++) GRID_ASSERT(info_h[i]==0); // singular pivot => abort loudly
-#endif
-#ifdef GRID_CUDA
-    GRID_ASSERT( N < 2147483647L );
-    int n = (int)N;
-
-    deviceVector<int> ipiv((uint64_t)batchCount*N);
-    deviceVector<int> info(batchCount);
-
-    auto st1 = cublasCgetrfBatched(Handle(), n,
-				   (cuComplex **)&Amat[0], n,
-				   &ipiv[0], &info[0], batchCount);
-    GRID_ASSERT(st1 == CUBLAS_STATUS_SUCCESS);
-
-    // getri is OUT of place: hidden workspace keeps the surface in-place
-    deviceVector<ComplexF>  work((uint64_t)batchCount*N*N);
-    deviceVector<ComplexF*> Cptr(batchCount);
-    std::vector<ComplexF*>  Cptr_h(batchCount);
-    std::vector<ComplexF*>  Aptr_h(batchCount);
-    for(int i=0;i<batchCount;i++) Cptr_h[i] = &work[(uint64_t)i*N*N];
-    acceleratorCopyToDevice(&Cptr_h[0],&Cptr[0],batchCount*sizeof(ComplexF*));
-    acceleratorCopyFromDevice(&Amat[0],&Aptr_h[0],batchCount*sizeof(ComplexF*));
-
-    auto st2 = cublasCgetriBatched(Handle(), n,
-				   (const cuComplex *const *)&Amat[0], n,
-				   &ipiv[0],
-				   (cuComplex **)&Cptr[0], n,
-				   &info[0], batchCount);
-    GRID_ASSERT(st2 == CUBLAS_STATUS_SUCCESS);
-    accelerator_barrier();
-    std::vector<int> info_h(batchCount);
-    acceleratorCopyFromDevice(&info[0],&info_h[0],batchCount*sizeof(int));
-    for(int i=0;i<batchCount;i++) GRID_ASSERT(info_h[i]==0);
-    for(int i=0;i<batchCount;i++)
-      acceleratorCopyDeviceToDevice(Cptr_h[i],Aptr_h[i],(uint64_t)N*N*sizeof(ComplexF));
-#endif
-#ifdef GRID_SYCL
-    // Per-element oneMKL LAPACK on the in-order queue; group API optimisation later.
-    sycl::queue *q = Handle();
-    std::vector<ComplexF*> Aptr_h(batchCount);
-    acceleratorCopyFromDevice(&Amat[0],&Aptr_h[0],batchCount*sizeof(ComplexF*));
-
-    int64_t lwf = oneapi::mkl::lapack::getrf_scratchpad_size<std::complex<float> >(*q,N,N,N);
-    int64_t lwi = oneapi::mkl::lapack::getri_scratchpad_size<std::complex<float> >(*q,N,N);
-    deviceVector<ComplexF> scratchf(lwf);
-    deviceVector<ComplexF> scratchi(lwi);
-    deviceVector<int64_t>  ipiv(N);
-    for(int i=0;i<batchCount;i++){
-      oneapi::mkl::lapack::getrf(*q,N,N,(std::complex<float>*)Aptr_h[i],N,&ipiv[0],
-				 (std::complex<float>*)&scratchf[0],lwf);
-      oneapi::mkl::lapack::getri(*q,N,  (std::complex<float>*)Aptr_h[i],N,&ipiv[0],
-				 (std::complex<float>*)&scratchi[0],lwi);
-    }
-    q->wait();
-#endif
-#if !defined(GRID_SYCL) && !defined(GRID_CUDA) && !defined(GRID_HIP)
-    // Reference implementation; the oracle the unit test locks semantics with.
-    thread_for (p, batchCount, {
-      Eigen::Map<Eigen::MatrixXcf> eA(Amat[p],N,N);
-      Eigen::PartialPivLU<Eigen::MatrixXcf> lu(eA);
-      eA = lu.inverse();
-      });
-#endif
-  }
-
-  void inverseBatched(int64_t N, deviceVector<ComplexD*> &Amat)
-  {
-    int32_t batchCount = Amat.size();
-    GRID_ASSERT(batchCount > 0);
-
-#ifdef GRID_HIP
-    GRID_ASSERT( N < 2147483647L );
-    rocblas_int n   = (rocblas_int)N;
-    rocblas_int lda = (rocblas_int)N;
-
-    deviceVector<rocblas_int> ipiv((uint64_t)batchCount*N);
-    deviceVector<rocblas_int> info(batchCount);
-
-    auto st1 = rocsolver_zgetrf_batched(Handle(), n, n,
-					(rocblas_double_complex *const *)&Amat[0], lda,
-					&ipiv[0], (rocblas_stride)N,
-					&info[0], batchCount);
-    GRID_ASSERT(st1 == rocblas_status_success);
-    auto st2 = rocsolver_zgetri_batched(Handle(), n,
-					(rocblas_double_complex *const *)&Amat[0], lda,
-					&ipiv[0], (rocblas_stride)N,
-					&info[0], batchCount);
-    GRID_ASSERT(st2 == rocblas_status_success);
-    accelerator_barrier();
-    std::vector<rocblas_int> info_h(batchCount);
-    acceleratorCopyFromDevice(&info[0],&info_h[0],batchCount*sizeof(rocblas_int));
-    for(int i=0;i<batchCount;i++) GRID_ASSERT(info_h[i]==0);
-#endif
-#ifdef GRID_CUDA
-    GRID_ASSERT( N < 2147483647L );
-    int n = (int)N;
-
-    deviceVector<int> ipiv((uint64_t)batchCount*N);
-    deviceVector<int> info(batchCount);
-
-    auto st1 = cublasZgetrfBatched(Handle(), n,
-				   (cuDoubleComplex **)&Amat[0], n,
-				   &ipiv[0], &info[0], batchCount);
-    GRID_ASSERT(st1 == CUBLAS_STATUS_SUCCESS);
-
-    deviceVector<ComplexD>  work((uint64_t)batchCount*N*N);
-    deviceVector<ComplexD*> Cptr(batchCount);
-    std::vector<ComplexD*>  Cptr_h(batchCount);
-    std::vector<ComplexD*>  Aptr_h(batchCount);
-    for(int i=0;i<batchCount;i++) Cptr_h[i] = &work[(uint64_t)i*N*N];
-    acceleratorCopyToDevice(&Cptr_h[0],&Cptr[0],batchCount*sizeof(ComplexD*));
-    acceleratorCopyFromDevice(&Amat[0],&Aptr_h[0],batchCount*sizeof(ComplexD*));
-
-    auto st2 = cublasZgetriBatched(Handle(), n,
-				   (const cuDoubleComplex *const *)&Amat[0], n,
-				   &ipiv[0],
-				   (cuDoubleComplex **)&Cptr[0], n,
-				   &info[0], batchCount);
-    GRID_ASSERT(st2 == CUBLAS_STATUS_SUCCESS);
-    accelerator_barrier();
-    std::vector<int> info_h(batchCount);
-    acceleratorCopyFromDevice(&info[0],&info_h[0],batchCount*sizeof(int));
-    for(int i=0;i<batchCount;i++) GRID_ASSERT(info_h[i]==0);
-    for(int i=0;i<batchCount;i++)
-      acceleratorCopyDeviceToDevice(Cptr_h[i],Aptr_h[i],(uint64_t)N*N*sizeof(ComplexD));
-#endif
-#ifdef GRID_SYCL
-    sycl::queue *q = Handle();
-    std::vector<ComplexD*> Aptr_h(batchCount);
-    acceleratorCopyFromDevice(&Amat[0],&Aptr_h[0],batchCount*sizeof(ComplexD*));
-
-    int64_t lwf = oneapi::mkl::lapack::getrf_scratchpad_size<std::complex<double> >(*q,N,N,N);
-    int64_t lwi = oneapi::mkl::lapack::getri_scratchpad_size<std::complex<double> >(*q,N,N);
-    deviceVector<ComplexD> scratchf(lwf);
-    deviceVector<ComplexD> scratchi(lwi);
-    deviceVector<int64_t>  ipiv(N);
-    for(int i=0;i<batchCount;i++){
-      oneapi::mkl::lapack::getrf(*q,N,N,(std::complex<double>*)Aptr_h[i],N,&ipiv[0],
-				 (std::complex<double>*)&scratchf[0],lwf);
-      oneapi::mkl::lapack::getri(*q,N,  (std::complex<double>*)Aptr_h[i],N,&ipiv[0],
-				 (std::complex<double>*)&scratchi[0],lwi);
-    }
-    q->wait();
-#endif
-#if !defined(GRID_SYCL) && !defined(GRID_CUDA) && !defined(GRID_HIP)
-    thread_for (p, batchCount, {
-      Eigen::Map<Eigen::MatrixXcd> eA(Amat[p],N,N);
-      Eigen::PartialPivLU<Eigen::MatrixXcd> lu(eA);
-      eA = lu.inverse();
-      });
-#endif
-  }
-};
-
-NAMESPACE_END(Grid);

Grid/algorithms/blas/MomentumProject.h

@@ -1,300 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: MomentumProject.h
-
-    Copyright (C) 2025
-
-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);
-/* 
-   MultiMomProject
-
-   Import vectors -> nxyz x (ncomponent x nt)
-   Import complex phases -> nmom x nxy
-
-   apply = via (possibly batched) GEMM
-*/
-template<class Field, class ComplexField>
-class MomentumProject
-{
-public:
-
-  typedef typename Field::scalar_type   scalar;
-  typedef typename Field::scalar_object scalar_object;
-
-  GridBase *grid;
-  uint64_t nmom;
-  uint64_t nxyz;
-  uint64_t nt;
-  uint64_t nbtw;
-  uint64_t words;
-
-  deviceVector<scalar> BLAS_V;      // 
-  deviceVector<scalar> BLAS_M;      // 
-  deviceVector<scalar> BLAS_P;      // 
-  
-  MomentumProject(){};
- ~MomentumProject(){ Deallocate(); };
-  
-  void Deallocate(void)
-  {
-    grid=nullptr;
-    nmom=0;
-    nxyz=0;
-    nt=0;
-    nbtw=0;
-    words=0;
-    BLAS_V.resize(0);
-    BLAS_M.resize(0);
-    BLAS_P.resize(0);
-  }
-  void Allocate(int _nmom,GridBase *_grid)
-  {
-    grid=_grid;
-    Coordinate ldims = grid->LocalDimensions();
-
-    nmom=_nmom;
-    nt   = ldims[grid->Nd()-1];
-    nxyz = grid->lSites()/nt;
-    words = sizeof(scalar_object)/sizeof(scalar);
-    nbtw = nt * words;
-
-    BLAS_V.resize (nxyz * nt * words );
-    BLAS_M.resize (nmom * nxyz       );
-    BLAS_P.resize (nmom * nt * words );
-  }
-  void ImportMomenta(const std::vector <ComplexField> &momenta)
-  {
-    GRID_ASSERT(momenta.size()==nmom);
-    //    might as well just make the momenta here
-    typedef typename Field::vector_object vobj;
-
-    int nd = grid->_ndimension;
-
-    uint64_t sz = BLAS_M.size();
-
-    GRID_ASSERT(momenta.size()==nmom)
-    GRID_ASSERT(momenta[0].Grid()==grid);
-    GRID_ASSERT(sz = nxyz * nmom);
-    
-    Coordinate rdimensions = grid->_rdimensions;
-    Coordinate ldims       = grid->LocalDimensions();
-    int64_t osites         = grid->oSites();
-    Coordinate simd        = grid->_simd_layout;
-    const int Nsimd        = vobj::Nsimd();
-    uint64_t lwords        = words; // local variable for copy in to GPU
-    int64_t Nxyz = nxyz;
-    auto blasData_p  = &BLAS_M[0];
-    for(int m=0;m<momenta.size();m++){
-
-      autoView( Data   , momenta[m], AcceleratorRead);
-      auto Data_p  = &Data[0];
-
-      accelerator_for(xyz,nxyz,1,{
-	  //////////////////////////////////////////
-	  // isite -- map lane within buffer to lane within lattice
-	  ////////////////////////////////////////////
-	    Coordinate lcoor(nd,0);
-	    Lexicographic::CoorFromIndex(lcoor,xyz,ldims);
-	    
-	    Coordinate icoor(nd);
-	    Coordinate ocoor(nd);
-	    for (int d = 0; d < nd; d++) {
-	      icoor[d] = lcoor[d]/rdimensions[d];
-	      ocoor[d] = lcoor[d]%rdimensions[d];
-	    }
-	    int64_t osite;
-	    int64_t isite;
-	    Lexicographic::IndexFromCoor(ocoor,osite,rdimensions);
-	    Lexicographic::IndexFromCoor(icoor,isite,simd);
-	    
-	    // BLAS_M[nmom][slice_vol]
-	    // Fortran Column major BLAS layout is M_xyz,mom
-	    scalar data = extractLane(isite,Data[osite]);
-	    uint64_t idx = xyz+m*Nxyz;
-	    blasData_p[idx] = data;
-	});
-    }
-  }
-  void ImportVector(Field &vec)
-  {
-    typedef typename Field::vector_object vobj;
-
-    int nd = grid->_ndimension;
-
-    uint64_t sz = BLAS_V.size();
-
-    GRID_ASSERT(sz = nxyz * words * nt);
-    
-    Coordinate rdimensions = grid->_rdimensions;
-    Coordinate ldims= grid->LocalDimensions();
-    int64_t osites = grid->oSites();
-    Coordinate simd = grid->_simd_layout;
-    const int Nsimd = vobj::Nsimd();
-    uint64_t lwords= words; // local variable for copy in to GPU
-
-    auto blasData_p  = &BLAS_V[0];
-    autoView( Data   , vec, AcceleratorRead);
-    auto Data_p  = &Data[0];
-
-    int64_t nwords = words;// for capture
-    int64_t Nt     = nt;// for capture
-    
-    accelerator_for(sf,osites,Nsimd,{
-#ifdef GRID_SIMT
-        {
-	  int lane=acceleratorSIMTlane(Nsimd); // buffer lane
-#else
-	  for(int lane=0;lane<Nsimd;lane++) {
-#endif
-	  //////////////////////////////////////////
-	  // isite -- map lane within buffer to lane within lattice
-	  ////////////////////////////////////////////
-	    Coordinate lcoor(nd,0);
-	    Coordinate icoor(nd);
-	    Coordinate ocoor(nd);
-	    
-	    Lexicographic::CoorFromIndex(icoor,lane,simd);
-	    Lexicographic::CoorFromIndex(ocoor,sf,rdimensions);
-
-	  
-	    int64_t l_xyz = 0;
-	    for (int d = 0; d < nd; d++) {
-	      lcoor[d] = rdimensions[d]*icoor[d] + ocoor[d];
-	    }
-	    uint64_t l_t   = lcoor[nd-1];
-
-	    Coordinate xyz_coor = lcoor;
-	    xyz_coor[nd-1] =0;
-	    Lexicographic::IndexFromCoor(xyz_coor,l_xyz,ldims);
-
-	    
-	    scalar_object data = extractLane(lane,Data[sf]);
-	    scalar *data_words = (scalar *) &data;
-	    for(int w = 0 ; w < nwords; w++) {
-	      // BLAS_V[slice_vol][nt][words]
-	      // Fortran Column major BLAS layout is V_(t,w)_xyz
-	      uint64_t idx = w+l_t*nwords + l_xyz * nwords * Nt;
-	      blasData_p[idx] = data_words[w];
-	    }
-#ifdef GRID_SIMT
-	}
-#else
-	}
-#endif
-	});
-  }
-  void ExportMomentumProjection(std::vector<typename Field::scalar_object> &projection)
-  {
-    projection.resize(nmom*nt);
-    acceleratorCopyFromDevice(&BLAS_P[0],(scalar *)&projection[0],BLAS_P.size()*sizeof(scalar));
-    // Could decide on a layout late?
-  }
-
-  // Row major layout "C" order:
-  // BLAS_V[slice_vol][nt][words]
-  // BLAS_M[nmom][slice_vol]
-  // BLAS_P[nmom][nt][words]
-  //
-  // Fortran Column major BLAS layout is V_(w,t)_xyz
-  // Fortran Column major BLAS layout is M_xyz,mom
-  // Fortran Column major BLAS layout is P_(w,t),mom
-  //
-  // Projected
-  //
-  // P = (V * M)_(w,t),mom
-  //
-  void Project(Field &data,std::vector< typename Field::scalar_object > & projected_gdata)
-  {
-    double t_import=0;
-    double t_export=0;
-    double t_gemm  =0;
-    double t_allreduce=0;
-    t_import-=usecond();
-    this->ImportVector(data);
-
-    std::vector< typename Field::scalar_object > projected_planes;
-
-    deviceVector<scalar *> Vd(1);
-    deviceVector<scalar *> Md(1);
-    deviceVector<scalar *> Pd(1);
-
-    scalar * Vh = & BLAS_V[0];
-    scalar * Mh = & BLAS_M[0];
-    scalar * Ph = & BLAS_P[0];
-
-    acceleratorPut(Vd[0],Vh);
-    acceleratorPut(Md[0],Mh);
-    acceleratorPut(Pd[0],Ph);
-    t_import+=usecond();
-
-    GridBLAS BLAS;
-
-    /////////////////////////////////////////
-    // P_im = VMmx . Vxi
-    /////////////////////////////////////////
-    t_gemm-=usecond();
-    BLAS.gemmBatched(GridBLAS_OP_N,GridBLAS_OP_N, 
-    		     words*nt,nmom,nxyz,
-		     scalar(1.0),
-		     Vd,
-		     Md,
-		     scalar(0.0),  // wipe out result
-		     Pd);
-    BLAS.synchronise();
-    t_gemm+=usecond();
-
-    t_export-=usecond();
-    ExportMomentumProjection(projected_planes); // resizes
-    t_export+=usecond();
-
-    /////////////////////////////////
-    // Reduce across MPI ranks
-    /////////////////////////////////
-    int nd = grid->Nd();
-    int gt = grid->GlobalDimensions()[nd-1];
-    int lt = grid->LocalDimensions()[nd-1];
-    projected_gdata.resize(gt*nmom);
-    for(int t=0;t<gt*nmom;t++){ // global Nt array with zeroes for stuff not on this node
-      projected_gdata[t]=Zero();
-    }
-    for(int t=0;t<lt;t++){
-    for(int m=0;m<nmom;m++){
-      int st = grid->LocalStarts()[nd-1];
-      projected_gdata[t+st + gt*m] = projected_planes[t+lt*m];
-    }}
-    t_allreduce-=usecond();
-    grid->GlobalSumVector((scalar *)&projected_gdata[0],gt*nmom*words);
-    t_allreduce+=usecond();
-
-    std::cout << GridLogPerformance<<" MomentumProject t_import  "<<t_import<<"us"<<std::endl;
-    std::cout << GridLogPerformance<<" MomentumProject t_export  "<<t_export<<"us"<<std::endl;
-    std::cout << GridLogPerformance<<" MomentumProject t_gemm    "<<t_gemm<<"us"<<std::endl;
-    std::cout << GridLogPerformance<<" MomentumProject t_reduce  "<<t_allreduce<<"us"<<std::endl;
-
-  }
-};
-
-NAMESPACE_END(Grid);

Grid/algorithms/deflation/Deflation.h

@@ -69,8 +69,8 @@ public:
   DeflatedGuesser(const std::vector<Field> & _evec, const std::vector<RealD> & _eval, const unsigned int _N)
   : evec(_evec), eval(_eval), N(_N)
   {
-    GRID_ASSERT(evec.size()==eval.size());
+    assert(evec.size()==eval.size());
-    GRID_ASSERT(N <= evec.size());
+    assert(N <= evec.size());
   } 
 
   virtual void operator()(const Field &src,Field &guess) {
@@ -141,7 +141,8 @@ public:
     }
     //postprocessing
     std::cout << GridLogMessage << "Start BlockPromote for loop" << std::endl;
-    for (int j=0;j<Nsrc;j++) {
+    for (int j=0;j<Nsrc;j++)
+    {
     std::cout << GridLogMessage << "BlockProject iter: " << j << std::endl;
     blockPromote(guess_coarse[j],guess[j],subspace);
     guess[j].Checkerboard() = src[j].Checkerboard();

Grid/algorithms/deflation/MultiRHSBlockCGLinalg.h

@@ -144,11 +144,11 @@ public:
       acceleratorCopyDeviceToDevice(&BLAS_Y[offset],&y_v[0],sizeof(scalar_object)*vol);
     }    
     RealD t4 = usecond();
-    std::cout <<GridLogPerformance << "MulMatrix alloc    took "<< t1-t0<<" us"<<std::endl;
+    std::cout << "MulMatrix alloc    took "<< t1-t0<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "MulMatrix preamble took "<< t2-t1<<" us"<<std::endl;
+    std::cout << "MulMatrix preamble took "<< t2-t1<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "MulMatrix blas     took "<< t3-t2<<" us"<<std::endl;
+    std::cout << "MulMatrix blas     took "<< t3-t2<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "MulMatrix copy     took "<< t4-t3<<" us"<<std::endl;
+    std::cout << "MulMatrix copy     took "<< t4-t3<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "MulMatrix total "<< t4-t0<<" us"<<std::endl;
+    std::cout << "MulMatrix total "<< t4-t0<<" us"<<std::endl;
   }
   
   void InnerProductMatrix(Eigen::MatrixXcd &m , const std::vector<Field> &X, const std::vector<Field> &Y)
@@ -160,7 +160,7 @@ public:
     uint64_t words;
 
     nrhs = X.size();
-    GRID_ASSERT(X.size()==Y.size());
+    assert(X.size()==Y.size());
     conformable(X[0],Y[0]);
 
     grid  = X[0].Grid();
@@ -242,16 +242,16 @@ public:
     RealD flops = 8.0*M*N*K;
     flops = flops/(t4-t3)/1.e3;
     bytes = bytes/(t4-t3)/1.e3;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix m,n,k "<< M<<","<<N<<","<<K<<std::endl;
+    std::cout << "InnerProductMatrix m,n,k "<< M<<","<<N<<","<<K<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix alloc t1 "<< t1-t0<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix alloc t1 "<< t1-t0<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix cp    t2 "<< t2-t1<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix cp    t2 "<< t2-t1<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix setup t3 "<< t3-t2<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix setup t3 "<< t3-t2<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas t4 "<< t4-t3<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix blas t4 "<< t4-t3<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas    "<< flops<<" GF/s"<<std::endl;
+    std::cout << "InnerProductMatrix blas    "<< flops<<" GF/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas    "<< bytes<<" GB/s"<<std::endl;
+    std::cout << "InnerProductMatrix blas    "<< bytes<<" GB/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix gsum t5 "<< t5-t4<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix gsum t5 "<< t5-t4<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix cp   t6 "<< t6-t5<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix cp   t6 "<< t6-t5<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix took "<< t6-t0<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix took "<< t6-t0<<" us"<<std::endl;
 #else
     int nrhs;
     GridBase *grid;
@@ -259,7 +259,7 @@ public:
     uint64_t words;
 
     nrhs = X.size();
-    GRID_ASSERT(X.size()==Y.size());
+    assert(X.size()==Y.size());
     conformable(X[0],Y[0]);
 
     grid  = X[0].Grid();
@@ -267,7 +267,7 @@ public:
     vol   = grid->oSites()/rd0;
     words = rd0*sizeof(vector_object)/sizeof(scalar);
     int64_t vw = vol * words;
-    GRID_ASSERT(vw == grid->lSites()*sizeof(scalar_object)/sizeof(scalar));
+    assert(vw == grid->lSites()*sizeof(scalar_object)/sizeof(scalar));
 
     RealD t0 = usecond();
     BLAS_X.resize(nrhs * vw); // cost free if size doesn't change
@@ -358,17 +358,17 @@ public:
     flops = flops/(t4-t3)/1.e3;
     bytes = bytes/(t4-t3)/1.e3;
     xybytes = 4*xybytes/(t2-t1)/1.e3;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix m,n,k "<< M<<","<<N<<","<<K<<std::endl;
+    std::cout << "InnerProductMatrix m,n,k "<< M<<","<<N<<","<<K<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix alloc t1 "<< t1-t0<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix alloc t1 "<< t1-t0<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix cp    t2 "<< t2-t1<<" us "<<xybytes<<" GB/s"<<std::endl;
+    std::cout << "InnerProductMatrix cp    t2 "<< t2-t1<<" us "<<xybytes<<" GB/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix setup t3 "<< t3-t2<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix setup t3 "<< t3-t2<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas t4 "<< t4-t3<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix blas t4 "<< t4-t3<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas    "<< flops<<" GF/s"<<std::endl;
+    std::cout << "InnerProductMatrix blas    "<< flops<<" GF/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas    "<< bytes<<" GB/s"<<std::endl;
+    std::cout << "InnerProductMatrix blas    "<< bytes<<" GB/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix cp     t5 "<< t5-t4<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix cp     t5 "<< t5-t4<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix lsum   t6l "<< t6l-t5<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix lsum   t6l "<< t6l-t5<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix gsum   t6 "<< t6-t6l<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix gsum   t6 "<< t6-t6l<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix took "<< t6-t0<<" us"<<std::endl;
+    std::cout << "InnerProductMatrix took "<< t6-t0<<" us"<<std::endl;
 #endif
   }
 };

Grid/algorithms/deflation/MultiRHSBlockProject.h

@@ -131,12 +131,12 @@ public:
     typedef typename Field::vector_object vobj;
     //    std::cout << GridLogMessage <<" BlockProjector importing "<<nvec<< " fine grid vectors" <<std::endl;
 
-    GRID_ASSERT(vecs[0].Grid()==fine_grid);
+    assert(vecs[0].Grid()==fine_grid);
 
     subdivides(coarse_grid,fine_grid); // require they map
 
     int _ndimension = coarse_grid->_ndimension;
-    GRID_ASSERT(block_vol == fine_grid->oSites() / coarse_grid->oSites());
+    assert(block_vol == fine_grid->oSites() / coarse_grid->oSites());
     
     Coordinate  block_r      (_ndimension);
     for(int d=0 ; d<_ndimension;d++){
@@ -164,7 +164,7 @@ public:
       const int Nsimd = vobj::Nsimd();
       //      std::cout << "sz "<<sz<<std::endl;
       //      std::cout << "prod "<<Nsimd * coarse_grid->oSites() * block_vol * nvec * words<<std::endl;
-      GRID_ASSERT(sz == Nsimd * coarse_grid->oSites() * block_vol * nvec * words);
+      assert(sz == Nsimd * coarse_grid->oSites() * block_vol * nvec * words);
       uint64_t lwords= words; // local variable for copy in to GPU
       accelerator_for(sf,osites,Nsimd,{
 #ifdef GRID_SIMT
@@ -198,7 +198,7 @@ public:
    	               + v*bv
 	               + sb;
 
-	  //	  GRID_ASSERT(site*lwords<sz);
+	  //	  assert(site*lwords<sz);
 
 	  scalar_object * ptr = (scalar_object *)&blasData_p[site*lwords];
 
@@ -219,12 +219,12 @@ public:
 
     int nvec = vecs.size();
 
-    GRID_ASSERT(vecs[0].Grid()==fine_grid);
+    assert(vecs[0].Grid()==fine_grid);
 
     subdivides(coarse_grid,fine_grid); // require they map
 
     int _ndimension = coarse_grid->_ndimension;
-    GRID_ASSERT(block_vol == fine_grid->oSites() / coarse_grid->oSites());
+    assert(block_vol == fine_grid->oSites() / coarse_grid->oSites());
     
     Coordinate  block_r      (_ndimension);
     for(int d=0 ; d<_ndimension;d++){
@@ -299,7 +299,7 @@ public:
 
     //    std::cout << " BlockProjector importing "<<nvec<< " coarse grid vectors" <<std::endl;
 
-    GRID_ASSERT(vecs[0].Grid()==coarse_grid);
+    assert(vecs[0].Grid()==coarse_grid);
 
     int _ndimension = coarse_grid->_ndimension;
 
@@ -320,7 +320,7 @@ public:
       // loop over fine sites
       const int Nsimd = vobj::Nsimd();
       uint64_t cwords=sizeof(typename vobj::scalar_object)/sizeof(scalar);
-      GRID_ASSERT(cwords==nbasis);
+      assert(cwords==nbasis);
       
       accelerator_for(sc,osites,Nsimd,{
 #ifdef GRID_SIMT
@@ -353,7 +353,7 @@ public:
     typedef typename vobj::scalar_object coarse_scalar_object;
     //    std::cout << GridLogMessage<<" BlockProjector exporting "<<nvec<< " coarse grid vectors" <<std::endl;
 
-    GRID_ASSERT(vecs[0].Grid()==coarse_grid);
+    assert(vecs[0].Grid()==coarse_grid);
 
     int _ndimension = coarse_grid->_ndimension;
     
@@ -375,7 +375,7 @@ public:
       // loop over fine sites
       const int Nsimd = vobj::Nsimd();
       uint64_t cwords=sizeof(typename vobj::scalar_object)/sizeof(scalar);
-      GRID_ASSERT(cwords==nbasis);
+      assert(cwords==nbasis);
       
       accelerator_for(sc,osites,Nsimd,{
 	  // Wrap in a macro "FOR_ALL_LANES(lane,{ ... });
@@ -409,7 +409,7 @@ public:
     int nrhs=fine.size();
     int _nbasis = sizeof(typename cobj::scalar_object)/sizeof(scalar);
     //    std::cout << "blockProject nbasis " <<nbasis<<" " << _nbasis<<std::endl;
-    GRID_ASSERT(nbasis==_nbasis);
+    assert(nbasis==_nbasis);
     
     BLAS_F.resize (fine_vol * words * nrhs );
     BLAS_C.resize (coarse_vol * nbasis * nrhs );
@@ -464,7 +464,7 @@ public:
   {
     int nrhs=fine.size();
     int _nbasis = sizeof(typename cobj::scalar_object)/sizeof(scalar);
-    GRID_ASSERT(nbasis==_nbasis);
+    assert(nbasis==_nbasis);
     
     BLAS_F.resize (fine_vol * words * nrhs );
     BLAS_C.resize (coarse_vol * nbasis * nrhs );

Grid/algorithms/deflation/MultiRHSDeflation.h

@@ -98,7 +98,7 @@ public:
   void ImportEigenVector(Field &evec,RealD &_eval, int ev)
   {
     //    std::cout << " ev " <<ev<<" eval "<<_eval<< std::endl;
-    GRID_ASSERT(ev<eval.size());
+    assert(ev<eval.size());
     eval[ev] = _eval;
 
     int64_t offset = ev*vol*words;
@@ -113,7 +113,7 @@ public:
   // Could use to import a batch of eigenvectors
   void ImportEigenBasis(std::vector<Field> &evec,std::vector<RealD> &_eval, int _ev0, int _nev)
   {
-    GRID_ASSERT(_ev0+_nev<=evec.size());
+    assert(_ev0+_nev<=evec.size());
 
     Allocate(_nev,evec[0].Grid());
     
@@ -126,8 +126,8 @@ public:
   void DeflateSources(std::vector<Field> &source,std::vector<Field> & guess)
   {
     int nrhs = source.size();
-    GRID_ASSERT(source.size()==guess.size());
+    assert(source.size()==guess.size());
-    GRID_ASSERT(grid == guess[0].Grid());
+    assert(grid == guess[0].Grid());
     conformable(guess[0],source[0]);
 
     int64_t vw = vol * words;
@@ -189,7 +189,7 @@ public:
 		     Cd);
     BLAS.synchronise();
 
-    GRID_ASSERT(BLAS_C.size()==nev*nrhs);
+    assert(BLAS_C.size()==nev*nrhs);
 
     std::vector<scalar> HOST_C(BLAS_C.size());      // nrhs . nev -- the coefficients 
     acceleratorCopyFromDevice(&BLAS_C[0],&HOST_C[0],BLAS_C.size()*sizeof(scalar));

Grid/algorithms/iterative/AdefGeneric.h

@@ -54,21 +54,6 @@ class TwoLevelCG : public LinearFunction<Field>
   LinearOperatorBase<Field>   &_FineLinop;
   LinearFunction<Field>   &_Smoother;
   
-  GridStopWatch ProjectTimer;
-  GridStopWatch PromoteTimer;
-  GridStopWatch CoarseTimer;
-  GridStopWatch SmoothTimer;
-  GridStopWatch MatrixTimer;
-  GridStopWatch M3Timer;
-  GridStopWatch LinalgTimer;
-
-  int64_t M3Calls;
-  int64_t SmoothCalls;
-  int64_t MatrixCalls;
-  int64_t ProjectCalls;
-  int64_t CoarseCalls;
-  int64_t PromoteCalls;
-
   // more most opertor functions
   TwoLevelCG(RealD tol,
 	     Integer maxit,
@@ -118,14 +103,6 @@ class TwoLevelCG : public LinearFunction<Field>
     RealD tn;
     
     GridStopWatch HDCGTimer;
-    ProjectTimer.Reset();
-    PromoteTimer.Reset();
-    CoarseTimer.Reset();
-    SmoothTimer.Reset();
-    MatrixTimer.Reset();
-    M3Timer.Reset();
-    LinalgTimer.Reset();
-    M3Calls = SmoothCalls = MatrixCalls = ProjectCalls = CoarseCalls = PromoteCalls = 0;
     HDCGTimer.Start();
     //////////////////////////
     // x0 = Vstart -- possibly modify guess
@@ -168,19 +145,14 @@ class TwoLevelCG : public LinearFunction<Field>
       int peri_kp = (k+1) % mmax;
 
       rtz=rtzp;
-      M3Timer.Start();
       d= PcgM3(p[peri_k],mmp[peri_k]);
-      M3Timer.Stop();
-      M3Calls++;
       a = rtz/d;
     
       // Memorise this
       pAp[peri_k] = d;
       
-      LinalgTimer.Start();
       axpy(x,a,p[peri_k],x);
       RealD rn = axpy_norm(r,-a,mmp[peri_k],r);
-      LinalgTimer.Stop();
 
       // Compute z = M x
       PcgM1(r,z);
@@ -191,9 +163,7 @@ class TwoLevelCG : public LinearFunction<Field>
 	n2=norm2(z);
 	std::cout << GridLogMessage<<"HDCG::fPcg iteration "<<k<<" : vector r,z "<<n1<<" "<<n2<<"\n";
       }
-      LinalgTimer.Start();
       rtzp =real(innerProduct(r,z));
-      LinalgTimer.Stop();
       std::cout << GridLogMessage<<"HDCG::fPcg iteration "<<k<<" : inner rtzp "<<rtzp<<"\n";
 
       //    PcgM2(z,p[0]);
@@ -232,24 +202,7 @@ class TwoLevelCG : public LinearFunction<Field>
       if ( rn <= rsq ) { 
 
 	HDCGTimer.Stop();
-	std::cout<<GridLogMessage<<"HDCG: fPcg converged in "<<k<<" iterations and "<<HDCGTimer.Elapsed()<<std::endl;
+	std::cout<<GridLogMessage<<"HDCG: fPcg converged in "<<k<<" iterations and "<<HDCGTimer.Elapsed()<<std::endl;;
-	std::cout<<GridLogMessage<<"HDCG: fPcg breakdown"<<std::endl;
-	auto mspc = [](GridStopWatch &sw, int64_t n) -> double {
-	  return (n > 0) ? sw.useconds() * 1e-3 / n : 0.0;
-	};
-	std::cout<<GridLogMessage<<"HDCG: fPcg M3 (fine MVM)  "<<M3Timer.Elapsed()
-		 <<"  "<<M3Calls<<" calls  "<<mspc(M3Timer,M3Calls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg linalg         "<<LinalgTimer.Elapsed()<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg smoother       "<<SmoothTimer.Elapsed()
-		 <<"  "<<SmoothCalls<<" calls  "<<mspc(SmoothTimer,SmoothCalls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg matrix (in M1) "<<MatrixTimer.Elapsed()
-		 <<"  "<<MatrixCalls<<" calls  "<<mspc(MatrixTimer,MatrixCalls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg project        "<<ProjectTimer.Elapsed()
-		 <<"  "<<ProjectCalls<<" calls  "<<mspc(ProjectTimer,ProjectCalls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg coarse         "<<CoarseTimer.Elapsed()
-		 <<"  "<<CoarseCalls<<" calls  "<<mspc(CoarseTimer,CoarseCalls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg promote        "<<PromoteTimer.Elapsed()
-		 <<"  "<<PromoteCalls<<" calls  "<<mspc(PromoteTimer,PromoteCalls)<<" ms/call"<<std::endl;
 	
 	_FineLinop.HermOp(x,mmp[0]);			  
 	axpy(tmp,-1.0,src,mmp[0]);
@@ -317,7 +270,7 @@ class TwoLevelCG : public LinearFunction<Field>
     std::vector<RealD> src_nrm(nrhs);
     for(int rhs=0;rhs<nrhs;rhs++) {
       src_nrm[rhs]=norm2(src[rhs]);
-      GRID_ASSERT(src_nrm[rhs]!=0.0);
+      assert(src_nrm[rhs]!=0.0);
     }
     std::vector<RealD> tn(nrhs);
 
@@ -522,29 +475,35 @@ class TwoLevelADEF2 : public TwoLevelCG<Field>
     CoarseField PleftProj(this->coarsegrid);
     CoarseField PleftMss_proj(this->coarsegrid);
 
-    this->SmoothTimer.Start();
+    GridStopWatch SmootherTimer;
+    GridStopWatch MatrixTimer;
+    SmootherTimer.Start();
     this->_Smoother(in,Min);
-    this->SmoothTimer.Stop();
+    SmootherTimer.Stop();
-    this->SmoothCalls++;
 
-    this->MatrixTimer.Start();
+    MatrixTimer.Start();
     this->_FineLinop.HermOp(Min,out);
-    this->MatrixTimer.Stop();
+    MatrixTimer.Stop();
-    this->MatrixCalls++;
     axpy(tmp,-1.0,out,in);          // tmp  = in - A Min
 
-    this->ProjectTimer.Start();
+    GridStopWatch ProjTimer;
+    GridStopWatch CoarseTimer;
+    GridStopWatch PromTimer;
+    ProjTimer.Start();
     this->_Aggregates.ProjectToSubspace(PleftProj,tmp);     
-    this->ProjectTimer.Stop();
+    ProjTimer.Stop();
-    this->ProjectCalls++;
+    CoarseTimer.Start();
-    this->CoarseTimer.Start();
     this->_CoarseSolver(PleftProj,PleftMss_proj); // Ass^{-1} [in - A Min]_s
-    this->CoarseTimer.Stop();
+    CoarseTimer.Stop();
-    this->CoarseCalls++;
+    PromTimer.Start();
-    this->PromoteTimer.Start();
     this->_Aggregates.PromoteFromSubspace(PleftMss_proj,tmp);// tmp = Q[in - A Min]  
-    this->PromoteTimer.Stop();
+    PromTimer.Stop();
-    this->PromoteCalls++;
+    std::cout << GridLogPerformance << "PcgM1 breakdown "<<std::endl;
+    std::cout << GridLogPerformance << "\tSmoother   " << SmootherTimer.Elapsed() <<std::endl;
+    std::cout << GridLogPerformance << "\tMatrix     " << MatrixTimer.Elapsed() <<std::endl;
+    std::cout << GridLogPerformance << "\tProj       " << ProjTimer.Elapsed() <<std::endl;
+    std::cout << GridLogPerformance << "\tCoarse     " << CoarseTimer.Elapsed() <<std::endl;
+    std::cout << GridLogPerformance << "\tProm       " << PromTimer.Elapsed() <<std::endl;
 
     axpy(out,1.0,Min,tmp); // Min+tmp
   }

Grid/algorithms/iterative/AdefMrhs.h

@@ -63,12 +63,7 @@ class TwoLevelCGmrhs
   GridStopWatch SmoothTimer;
   GridStopWatch InsertTimer;
 
-  /*
+  
-    Field rrr;
-  Field sss;
-  Field qqq;
-  Field zzz;
-  */  
   // more most opertor functions
   TwoLevelCGmrhs(RealD tol,
 		 Integer maxit,
@@ -79,12 +74,6 @@ class TwoLevelCGmrhs
     MaxIterations(maxit),
     _FineLinop(FineLinop),
     _Smoother(Smoother)
-    /*
-    rrr(fine),
-    sss(fine),
-    qqq(fine),
-    zzz(fine)
-*/
   {
     grid       = fine;
   };
@@ -161,7 +150,7 @@ class TwoLevelCGmrhs
     ////////////////////////////////////////////
     std::vector<RealD> ssq(nrhs);
     for(int rhs=0;rhs<nrhs;rhs++){
-      ssq[rhs]=norm2(src[rhs]); GRID_ASSERT(ssq[rhs]!=0.0);
+      ssq[rhs]=norm2(src[rhs]); assert(ssq[rhs]!=0.0);
     }      
 
     ///////////////////////////
@@ -382,7 +371,7 @@ class TwoLevelCGmrhs
     }
     HDCGTimer.Stop();
     std::cout<<GridLogMessage<<"HDCG: PrecBlockCGrQ not converged "<<HDCGTimer.Elapsed()<<std::endl;
-    GRID_ASSERT(0);
+    assert(0);
   }
 
   virtual void SolveSingleSystem (std::vector<Field> &src, std::vector<Field> &x)
@@ -415,7 +404,7 @@ class TwoLevelCGmrhs
     std::vector<RealD> src_nrm(nrhs);
     for(int rhs=0;rhs<nrhs;rhs++) {
       src_nrm[rhs]=norm2(src[rhs]);
-      GRID_ASSERT(src_nrm[rhs]!=0.0);
+      assert(src_nrm[rhs]!=0.0);
     }
     std::vector<RealD> tn(nrhs);
 
@@ -668,8 +657,6 @@ public:
     CoarseField PleftProjMrhs(this->coarsegridmrhs);
     CoarseField PleftMss_projMrhs(this->coarsegridmrhs);
 
-    //    this->rrr=in[0];
-
 #undef SMOOTHER_BLOCK_SOLVE
 #if SMOOTHER_BLOCK_SOLVE
     this->SmoothTimer.Start();
@@ -682,7 +669,6 @@ public:
       this->SmoothTimer.Stop();
     }
 #endif
-    //    this->sss=Min[0];
     
     for(int rhs=0;rhs<nrhs;rhs++) {
       
@@ -719,11 +705,9 @@ public:
     this->_Projector.blockPromote(tmp,PleftMss_proj);// tmp= Q[in - A Min]  
     this->PromoteTimer.Stop();
     this->FineTimer.Start();
-    //    this->qqq=tmp[0];
     for(int rhs=0;rhs<nrhs;rhs++) {
       axpy(out[rhs],1.0,Min[rhs],tmp[rhs]); // Min+tmp
     }
-    //    this->zzz=out[0];
     this->FineTimer.Stop();
   }
 };

Grid/algorithms/iterative/BiCGSTAB.h

@@ -47,7 +47,7 @@ class BiCGSTAB : public OperatorFunction<Field>
   public:
     using OperatorFunction<Field>::operator();
     
-    bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
+    bool ErrorOnNoConverge;  // throw an assert when the CG fails to converge.
                              // Defaults true.
     RealD Tolerance;
     Integer MaxIterations;
@@ -77,7 +77,7 @@ class BiCGSTAB : public OperatorFunction<Field>
 
       // Initial residual computation & set up
       RealD guess = norm2(psi);
-      GRID_ASSERT(std::isnan(guess) == 0);
+      assert(std::isnan(guess) == 0);
     
       Linop.Op(psi, v);
       b = norm2(v);
@@ -214,7 +214,7 @@ class BiCGSTAB : public OperatorFunction<Field>
           std::cout << GridLogMessage << "\tAxpyNorm   " << AxpyNormTimer.Elapsed() << std::endl;
           std::cout << GridLogMessage << "\tLinearComb " << LinearCombTimer.Elapsed() << std::endl;
 
-          if(ErrorOnNoConverge){ GRID_ASSERT(true_residual / Tolerance < 10000.0); }
+          if(ErrorOnNoConverge){ assert(true_residual / Tolerance < 10000.0); }
 
           IterationsToComplete = k;	
 
@@ -224,7 +224,7 @@ class BiCGSTAB : public OperatorFunction<Field>
       
       std::cout << GridLogMessage << "BiCGSTAB did NOT converge" << std::endl;
 
-      if(ErrorOnNoConverge){ GRID_ASSERT(0); }
+      if(ErrorOnNoConverge){ assert(0); }
       IterationsToComplete = k;
     }
 };

Grid/algorithms/iterative/BlockConjugateGradient.h

@@ -98,7 +98,7 @@ class BlockConjugateGradient : public OperatorFunction<Field> {
   int Nblock;
 
   BlockCGtype CGtype;
-  bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
+  bool ErrorOnNoConverge;  // throw an assert when the CG fails to converge.
                            // Defaults true.
   RealD Tolerance;
   Integer MaxIterations;
@@ -201,7 +201,7 @@ void operator()(LinearOperatorBase<Field> &Linop, const Field &Src, Field &Psi)
   } else if (CGtype == CGmultiRHS ) {
     CGmultiRHSsolve(Linop,Src,Psi);
   } else {
-    GRID_ASSERT(0);
+    assert(0);
   }
 }
 virtual void operator()(LinearOperatorBase<Field> &Linop, const std::vector<Field> &Src, std::vector<Field> &Psi) 
@@ -209,7 +209,7 @@ virtual void operator()(LinearOperatorBase<Field> &Linop, const std::vector<Fiel
   if ( CGtype == BlockCGrQVec ) {
     BlockCGrQsolveVec(Linop,Src,Psi);
   } else {
-    GRID_ASSERT(0);
+    assert(0);
   }
 }
 
@@ -259,10 +259,10 @@ void BlockCGrQsolve(LinearOperatorBase<Field> &Linop, const Field &B, Field &X)
   for(int b=0;b<Nblock;b++) std::cout << "src["<<b<<"]" << ssq[b] <<std::endl;
 
   sliceNorm(residuals,B,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }
 
   sliceNorm(residuals,X,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }
 
   /************************************************************************
    * Block conjugate gradient rQ (Sebastien Birk Thesis, after Dubrulle 2001)
@@ -402,7 +402,7 @@ void BlockCGrQsolve(LinearOperatorBase<Field> &Linop, const Field &B, Field &X)
   std::cout << GridLogMessage << "BlockConjugateGradient(rQ) did NOT converge "<<k<<" / "<<MaxIterations
 	    <<" residual "<< std::sqrt(max_resid)<< std::endl;
 
-  if (ErrorOnNoConverge) GRID_ASSERT(0);
+  if (ErrorOnNoConverge) assert(0);
   IterationsToComplete = k;
 }
 //////////////////////////////////////////////////////////////////////////
@@ -438,10 +438,10 @@ void CGmultiRHSsolve(LinearOperatorBase<Field> &Linop, const Field &Src, Field &
   for(int b=0;b<Nblock;b++) sssum+=ssq[b];
 
   sliceNorm(residuals,Src,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }
 
   sliceNorm(residuals,Psi,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }
 
   // Initial search dir is guess
   Linop.HermOp(Psi, AP);
@@ -540,7 +540,7 @@ void CGmultiRHSsolve(LinearOperatorBase<Field> &Linop, const Field &Src, Field &
   }
   std::cout << GridLogMessage << "MultiRHSConjugateGradient did NOT converge" << std::endl;
 
-  if (ErrorOnNoConverge) GRID_ASSERT(0);
+  if (ErrorOnNoConverge) assert(0);
   IterationsToComplete = k;
 }
 
@@ -554,7 +554,7 @@ void CGmultiRHSsolve(LinearOperatorBase<Field> &Linop, const Field &Src, Field &
 void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field> &B, std::vector<Field> &X) 
 {
   Nblock = B.size();
-  GRID_ASSERT(Nblock == X.size());
+  assert(Nblock == X.size());
 
   std::cout<<GridLogMessage<<" Block Conjugate Gradient Vec rQ : Nblock "<<Nblock<<std::endl;
 
@@ -594,10 +594,10 @@ void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field
   for(int b=0;b<Nblock;b++) sssum+=ssq[b];
 
   for(int b=0;b<Nblock;b++){ residuals[b] = norm2(B[b]);}
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }
 
   for(int b=0;b<Nblock;b++){ residuals[b] = norm2(X[b]);}
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }
 
   /************************************************************************
    * Block conjugate gradient rQ (Sebastien Birk Thesis, after Dubrulle 2001)
@@ -731,7 +731,7 @@ void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field
   }
   std::cout << GridLogMessage << "BlockConjugateGradient(rQ) did NOT converge" << std::endl;
 
-  if (ErrorOnNoConverge) GRID_ASSERT(0);
+  if (ErrorOnNoConverge) assert(0);
   IterationsToComplete = k;
 }
 

Grid/algorithms/iterative/CommunicationAvoidingGeneralisedMinimalResidual.h

@@ -36,7 +36,7 @@ class CommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<
  public:
   using OperatorFunction<Field>::operator();
 
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when CAGMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when CAGMRES fails to converge,
                           // defaults to true
 
   RealD   Tolerance;
@@ -82,7 +82,7 @@ class CommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<
     conformable(psi, src);
 
     RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);
 
     RealD cp;
     RealD ssq = norm2(src);
@@ -137,7 +137,7 @@ class CommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<
     std::cout << GridLogMessage << "CommunicationAvoidingGeneralisedMinimalResidual did NOT converge" << std::endl;
 
     if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
   }
 
   RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
@@ -185,7 +185,7 @@ class CommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<
       }
     }
 
-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
     return cp;
   }
 

Grid/algorithms/iterative/ConjugateGradient.h

@@ -45,7 +45,7 @@ public:
 
   using OperatorFunction<Field>::operator();
   
-  bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
+  bool ErrorOnNoConverge;  // throw an assert when the CG fails to converge.
                            // Defaults true.
   RealD Tolerance;
   Integer MaxIterations;
@@ -94,7 +94,7 @@ public:
     ssq = norm2(src);
     RealD guess = norm2(psi);
     NormTimer.Stop();
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);
     AssignTimer.Start();
     if ( guess == 0.0 ) {
       r = src;
@@ -212,21 +212,17 @@ public:
 		  << "\tTarget " << Tolerance << std::endl;
 
 	//	std::cout << GridLogMessage << "\tPreamble   " << PreambleTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tPreamble   " << PreambleTimer.Elapsed() <<std::endl;
+	std::cout << GridLogMessage << "\tSolver Elapsed    " << SolverTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tConstruct  " << ConstructTimer.Elapsed() <<std::endl;
+        std::cout << GridLogPerformance << "Time breakdown "<<std::endl;
-	std::cout << GridLogMessage << "\tNorm       " << NormTimer.Elapsed() <<std::endl;
+	std::cout << GridLogPerformance << "\tMatrix     " << MatrixTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tAssign     " << AssignTimer.Elapsed() <<std::endl;
+	std::cout << GridLogPerformance << "\tLinalg     " << LinalgTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tSolver     " << SolverTimer.Elapsed() <<std::endl;
+	std::cout << GridLogPerformance << "\t\tInner      " << InnerTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "Solver breakdown "<<std::endl;
+	std::cout << GridLogPerformance << "\t\tAxpyNorm   " << AxpyNormTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed() <<std::endl;
+	std::cout << GridLogPerformance << "\t\tLinearComb " << LinearCombTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tLinalg     " << LinalgTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\t\tInner      " << InnerTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\t\tAxpyNorm   " << AxpyNormTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\t\tLinearComb " << LinearCombTimer.Elapsed() <<std::endl;
 
 	std::cout << GridLogDebug << "\tMobius flop rate " << DwfFlops/ usecs<< " Gflops " <<std::endl;
 
-        if (ErrorOnNoConverge) GRID_ASSERT(true_residual / Tolerance < 10000.0);
+        if (ErrorOnNoConverge) assert(true_residual / Tolerance < 10000.0);
 
 	IterationsToComplete = k;	
 	TrueResidual = true_residual;
@@ -255,7 +251,7 @@ public:
     std::cout << GridLogPerformance << "\t\tAxpyNorm   " << AxpyNormTimer.Elapsed() <<std::endl;
     std::cout << GridLogPerformance << "\t\tLinearComb " << LinearCombTimer.Elapsed() <<std::endl;
 
-    if (ErrorOnNoConverge) GRID_ASSERT(0);
+    if (ErrorOnNoConverge) assert(0);
     IterationsToComplete = k;
 
   }

Grid/algorithms/iterative/ConjugateGradientMixedPrec.h

@@ -116,14 +116,14 @@ NAMESPACE_BEGIN(Grid);
       //Compute double precision rsd and also new RHS vector.
       Linop_d.HermOp(sol_d, tmp_d);
       RealD norm = axpy_norm(src_d, -1., tmp_d, src_d_in); //src_d is residual vector
-      std::cout<<GridLogMessage<<" rsd norm "<<norm<<std::endl;
+      
       std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradient: Outer iteration " <<outer_iter<<" residual "<< norm<< " target "<< stop<<std::endl;
 
       if(norm < OuterLoopNormMult * stop){
 	std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradient: Outer iteration converged on iteration " <<outer_iter <<std::endl;
 	break;
       }
-      while(norm * inner_tol * inner_tol < stop*1.01) inner_tol *= 2;  // inner_tol = sqrt(stop/norm) ??
+      while(norm * inner_tol * inner_tol < stop) inner_tol *= 2;  // inner_tol = sqrt(stop/norm) ??
 
       PrecChangeTimer.Start();
       precisionChange(src_f, src_d, pc_wk_dp_to_sp);

Grid/algorithms/iterative/ConjugateGradientMixedPrecBatched.h

@@ -77,7 +77,7 @@ public:
   }
 
   void operator() (const std::vector<FieldD> &src_d_in, std::vector<FieldD> &sol_d){
-    GRID_ASSERT(src_d_in.size() == sol_d.size());
+    assert(src_d_in.size() == sol_d.size());
     int NBatch = src_d_in.size();
 
     std::cout << GridLogMessage << "NBatch = " << NBatch << std::endl;

Grid/algorithms/iterative/ConjugateGradientMultiShift.h

@@ -98,15 +98,15 @@ public:
     std::vector<RealD> alpha(nshift,1.0);
     std::vector<Field>   ps(nshift,grid);// Search directions
 
-    GRID_ASSERT(psi.size()==nshift);
+    assert(psi.size()==nshift);
-    GRID_ASSERT(mass.size()==nshift);
+    assert(mass.size()==nshift);
-    GRID_ASSERT(mresidual.size()==nshift);
+    assert(mresidual.size()==nshift);
   
-    // remove dynamic sized arrays on stack; 2d is a pain with vector
+    // dynamic sized arrays on stack; 2d is a pain with vector
-    std::vector<RealD>  bs(nshift);
+    RealD  bs[nshift];
-    std::vector<RealD>  rsq(nshift);
+    RealD  rsq[nshift];
-    std::vector<std::array<RealD,2> >  z(nshift);
+    RealD  z[nshift][2];
-    std::vector<int>     converged(nshift);
+    int     converged[nshift];
   
     const int       primary =0;
   
@@ -122,7 +122,7 @@ public:
   
     // Check lightest mass
     for(int s=0;s<nshift;s++){
-      GRID_ASSERT( mass[s]>= mass[primary] );
+      assert( mass[s]>= mass[primary] );
       converged[s]=0;
     }
   
@@ -338,7 +338,7 @@ public:
     }
     // ugly hack
     std::cout<<GridLogMessage<<"CG multi shift did not converge"<<std::endl;
-    //  GRID_ASSERT(0);
+    //  assert(0);
   }
 
 };

Grid/algorithms/iterative/ConjugateGradientMultiShiftCleanup.h

@@ -118,16 +118,16 @@ public:
     FieldF r_f(SinglePrecGrid);
     FieldD mmp_d(DoublePrecGrid);
 
-    GRID_ASSERT(psi_d.size()==nshift);
+    assert(psi_d.size()==nshift);
-    GRID_ASSERT(mass.size()==nshift);
+    assert(mass.size()==nshift);
-    GRID_ASSERT(mresidual.size()==nshift);
+    assert(mresidual.size()==nshift);
   
     // dynamic sized arrays on stack; 2d is a pain with vector
-    std::vector<RealD>  bs(nshift);
+    RealD  bs[nshift];
-    std::vector<RealD>  rsq(nshift);
+    RealD  rsq[nshift];
-    std::vector<RealD>  rsqf(nshift);
+    RealD  rsqf[nshift];
-    std::vector<std::array<RealD,2> >  z(nshift);
+    RealD  z[nshift][2];
-    std::vector<int>     converged(nshift);
+    int     converged[nshift];
   
     const int       primary =0;
   
@@ -141,7 +141,7 @@ public:
 
     // Check lightest mass
     for(int s=0;s<nshift;s++){
-      GRID_ASSERT( mass[s]>= mass[primary] );
+      assert( mass[s]>= mass[primary] );
       converged[s]=0;
     }
   
@@ -179,7 +179,7 @@ public:
     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;
-    //    GRID_ASSERT(norm2(tmp_d)< 1.0e-4);
+    //    assert(norm2(tmp_d)< 1.0e-4);
 
     axpy(mmp_d,mass[0],p_d,mmp_d);
     RealD rn = norm2(p_d);
@@ -365,7 +365,7 @@ public:
    
     }
     std::cout<<GridLogMessage<<"CG multi shift did not converge"<<std::endl;
-    GRID_ASSERT(0);
+    assert(0);
   }
 
 };

Grid/algorithms/iterative/ConjugateGradientMultiShiftMixedPrec.h

@@ -48,12 +48,12 @@ public:
 
   ShiftedLinop(LinearOperatorBase<Field> &_linop_base, RealD _shift): linop_base(_linop_base), shift(_shift){}
 
-  void OpDiag (const Field &in, Field &out){ GRID_ASSERT(0); }
+  void OpDiag (const Field &in, Field &out){ assert(0); }
-  void OpDir  (const Field &in, Field &out,int dir,int disp){ GRID_ASSERT(0); }
+  void OpDir  (const Field &in, Field &out,int dir,int disp){ assert(0); }
-  void OpDirAll  (const Field &in, std::vector<Field> &out){ GRID_ASSERT(0); }
+  void OpDirAll  (const Field &in, std::vector<Field> &out){ assert(0); }
   
-  void Op     (const Field &in, Field &out){ GRID_ASSERT(0); }
+  void Op     (const Field &in, Field &out){ assert(0); }
-  void AdjOp  (const Field &in, Field &out){ GRID_ASSERT(0); }
+  void AdjOp  (const Field &in, Field &out){ assert(0); }
 
   void HermOp(const Field &in, Field &out){
     linop_base.HermOp(in, out);
@@ -151,16 +151,16 @@ public:
     FieldD r_d(DoublePrecGrid);
     FieldD mmp_d(DoublePrecGrid);
 
-    GRID_ASSERT(psi_d.size()==nshift);
+    assert(psi_d.size()==nshift);
-    GRID_ASSERT(mass.size()==nshift);
+    assert(mass.size()==nshift);
-    GRID_ASSERT(mresidual.size()==nshift);
+    assert(mresidual.size()==nshift);
   
     // dynamic sized arrays on stack; 2d is a pain with vector
-    std::vector<RealD>  bs(nshift);
+    RealD  bs[nshift];
-    std::vector<RealD>  rsq(nshift);
+    RealD  rsq[nshift];
-    std::vector<RealD>  rsqf(nshift);
+    RealD  rsqf[nshift];
-    std::vector<std::array<RealD,2> >  z(nshift);
+    RealD  z[nshift][2];
-    std::vector<int>     converged(nshift);
+    int     converged[nshift];
   
     const int       primary =0;
   
@@ -174,7 +174,7 @@ public:
 
     // Check lightest mass
     for(int s=0;s<nshift;s++){
-      GRID_ASSERT( mass[s]>= mass[primary] );
+      assert( mass[s]>= mass[primary] );
       converged[s]=0;
     }
   
@@ -211,7 +211,7 @@ public:
     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;
-    GRID_ASSERT(norm2(tmp_d)< 1.0);
+    assert(norm2(tmp_d)< 1.0);
 
     axpy(mmp_d,mass[0],p_d,mmp_d);
     RealD rn = norm2(p_d);
@@ -408,7 +408,7 @@ public:
    
     }
     std::cout<<GridLogMessage<<"CG multi shift did not converge"<<std::endl;
-    GRID_ASSERT(0);
+    assert(0);
   }
 
 };

Grid/algorithms/iterative/ConjugateGradientReliableUpdate.h

@@ -35,7 +35,7 @@ template<class FieldD,class FieldF,
 	 typename std::enable_if< getPrecision<FieldF>::value == 1, int>::type = 0> 
 class ConjugateGradientReliableUpdate : public LinearFunction<FieldD> {
 public:
-  bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
+  bool ErrorOnNoConverge;  // throw an assert when the CG fails to converge.
   // Defaults true.
   RealD Tolerance;
   Integer MaxIterations;
@@ -66,7 +66,7 @@ public:
       DoFinalCleanup(true),
       Linop_fallback(NULL)
   {
-    GRID_ASSERT(Delta > 0. && Delta < 1. && "Expect  0 < Delta < 1");
+    assert(Delta > 0. && Delta < 1. && "Expect  0 < Delta < 1");
   };
 
   void setFallbackLinop(LinearOperatorBase<FieldF> &_Linop_fallback, const RealD _fallback_transition_tol){
@@ -90,7 +90,7 @@ public:
 
     // Initial residual computation & set up
     RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);
     
     Linop_d.HermOpAndNorm(psi, mmp, d, b);
     
@@ -217,7 +217,7 @@ public:
 	  CG(Linop_d,src,psi);
 	  IterationsToCleanup = CG.IterationsToComplete;
 	}
-	else if (ErrorOnNoConverge) GRID_ASSERT(true_residual / Tolerance < 10000.0);
+	else if (ErrorOnNoConverge) assert(true_residual / Tolerance < 10000.0);
 
 	std::cout << GridLogMessage << "ConjugateGradientReliableUpdate complete.\n";
 	return;
@@ -263,7 +263,7 @@ public:
     std::cout << GridLogMessage << "ConjugateGradientReliableUpdate did NOT converge"
 	      << std::endl;
       
-    if (ErrorOnNoConverge) GRID_ASSERT(0);
+    if (ErrorOnNoConverge) assert(0);
     IterationsToComplete = k;
     ReliableUpdatesPerformed = l;      
   }    

Grid/algorithms/iterative/ConjugateResidual.h

@@ -106,7 +106,7 @@ public:
     }
 
     std::cout<<GridLogMessage<<"ConjugateResidual did NOT converge"<<std::endl;
-    GRID_ASSERT(0);
+    assert(0);
   }
 };
 NAMESPACE_END(Grid);

Grid/algorithms/iterative/FlexibleCommunicationAvoidingGeneralisedMinimalResidual.h

@@ -36,7 +36,7 @@ class FlexibleCommunicationAvoidingGeneralisedMinimalResidual : public OperatorF
  public:
   using OperatorFunction<Field>::operator();
 
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when FCAGMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when FCAGMRES fails to converge,
                           // defaults to true
 
   RealD   Tolerance;
@@ -87,7 +87,7 @@ class FlexibleCommunicationAvoidingGeneralisedMinimalResidual : public OperatorF
     conformable(psi, src);
 
     RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);
 
     RealD cp;
     RealD ssq = norm2(src);
@@ -144,7 +144,7 @@ class FlexibleCommunicationAvoidingGeneralisedMinimalResidual : public OperatorF
     std::cout << GridLogMessage << "FlexibleCommunicationAvoidingGeneralisedMinimalResidual did NOT converge" << std::endl;
 
     if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
   }
 
   RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
@@ -191,7 +191,7 @@ class FlexibleCommunicationAvoidingGeneralisedMinimalResidual : public OperatorF
       }
     }
 
-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
     return cp;
   }
 

Grid/algorithms/iterative/FlexibleGeneralisedMinimalResidual.h

@@ -36,7 +36,7 @@ class FlexibleGeneralisedMinimalResidual : public OperatorFunction<Field> {
  public:
   using OperatorFunction<Field>::operator();
 
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when FGMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when FGMRES fails to converge,
                           // defaults to true
 
   RealD   Tolerance;
@@ -85,7 +85,7 @@ class FlexibleGeneralisedMinimalResidual : public OperatorFunction<Field> {
     conformable(psi, src);
 
     RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);
 
     RealD cp;
     RealD ssq = norm2(src);
@@ -142,7 +142,7 @@ class FlexibleGeneralisedMinimalResidual : public OperatorFunction<Field> {
     std::cout << GridLogMessage << "FlexibleGeneralisedMinimalResidual did NOT converge" << std::endl;
 
     if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
   }
 
   RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
@@ -189,7 +189,7 @@ class FlexibleGeneralisedMinimalResidual : public OperatorFunction<Field> {
       }
     }
 
-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
     return cp;
   }
 

Grid/algorithms/iterative/GeneralisedMinimalResidual.h

@@ -36,7 +36,7 @@ class GeneralisedMinimalResidual : public OperatorFunction<Field> {
  public:
   using OperatorFunction<Field>::operator();
 
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when GMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when GMRES fails to converge,
                           // defaults to true
 
   RealD   Tolerance;
@@ -80,7 +80,7 @@ class GeneralisedMinimalResidual : public OperatorFunction<Field> {
     conformable(psi, src);
 
     RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);
 
     RealD cp;
     RealD ssq = norm2(src);
@@ -135,7 +135,7 @@ class GeneralisedMinimalResidual : public OperatorFunction<Field> {
     std::cout << GridLogMessage << "GeneralisedMinimalResidual did NOT converge" << std::endl;
 
     if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
   }
 
   RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
@@ -181,7 +181,7 @@ class GeneralisedMinimalResidual : public OperatorFunction<Field> {
       }
     }
 
-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
     return cp;
   }
 

Grid/algorithms/iterative/ImplicitlyRestartedBlockLanczos.h

@@ -175,7 +175,7 @@ public:
       eresid(_eresid),  MaxIter(_MaxIter),
       diagonalisation(_diagonalisation),split_test(0),
       Nevec_acc(_Nu)
-  { GRID_ASSERT( (Nk%Nu==0) && (Nm%Nu==0) ); };
+  { assert( (Nk%Nu==0) && (Nm%Nu==0) ); };
 
   ////////////////////////////////
   // Helpers
@@ -206,7 +206,7 @@ public:
           Glog<<"orthogonalize after: "<<j<<" of "<<k<<" "<< ip <<std::endl;
       }
     }
-    GRID_ASSERT(normalize(w,if_print) != 0);
+    assert(normalize(w,if_print) != 0);
   }
   void reorthogonalize(Field& w, std::vector<Field>& evec, int k)
   {
@@ -225,7 +225,7 @@ public:
       w[i] = w[i] - ip * evec[j];
     }}
     for(int i=0; i<_Nu; ++i)
-    GRID_ASSERT(normalize(w[i],if_print) !=0);
+    assert(normalize(w[i],if_print) !=0);
   }
 
 
@@ -244,7 +244,7 @@ public:
     const uint64_t sites = grid->lSites();
 
     int Nbatch = R/Nevec_acc;
-    GRID_ASSERT( R%Nevec_acc == 0 );
+    assert( R%Nevec_acc == 0 );
 //    Glog << "nBatch, Nevec_acc, R, Nu = " 
 //         << Nbatch << "," << Nevec_acc << "," << R << "," << Nu << std::endl;
     
@@ -302,7 +302,7 @@ public:
       }
     }
     for (int i=0; i<Nu; ++i) {
-      GRID_ASSERT(normalize(w[i],do_print)!=0);
+      assert(normalize(w[i],do_print)!=0);
     }
     
     Glog << "cuBLAS Zgemm done"<< std::endl;
@@ -374,8 +374,8 @@ cudaStat = cudaMallocManaged((void **)&evec_acc, Nevec_acc*sites*12*sizeof(CUDA_
   {
     std::string fname = std::string(cname+"::calc_irbl()"); 
     GridBase *grid = evec[0].Grid();
-    GRID_ASSERT(grid == src[0].Grid());
+    assert(grid == src[0].Grid());
-    GRID_ASSERT( Nu = src.size() );
+    assert( Nu = src.size() );
     
     Glog << std::string(74,'*') << std::endl;
     Glog << fname + " starting iteration 0 /  "<< MaxIter<< std::endl;
@@ -396,7 +396,7 @@ cudaStat = cudaMallocManaged((void **)&evec_acc, Nevec_acc*sites*12*sizeof(CUDA_
     }
     Glog << std::string(74,'*') << std::endl;
     
-    GRID_ASSERT(Nm == evec.size() && Nm == eval.size());
+    assert(Nm == evec.size() && Nm == eval.size());
 
     std::vector<std::vector<ComplexD>> lmd(Nu,std::vector<ComplexD>(Nm,0.0));  
     std::vector<std::vector<ComplexD>> lme(Nu,std::vector<ComplexD>(Nm,0.0));  
@@ -579,8 +579,8 @@ cudaStat = cudaMallocManaged((void **)&evec_acc, Nevec_acc*sites*12*sizeof(CUDA_
   {
     std::string fname = std::string(cname+"::calc_rbl()"); 
     GridBase *grid = evec[0].Grid();
-    GRID_ASSERT(grid == src[0].Grid());
+    assert(grid == src[0].Grid());
-    GRID_ASSERT( Nu = src.size() );
+    assert( Nu = src.size() );
 
     int Np = (Nm-Nk);
     if (Np > 0 && MaxIter > 1) Np /= MaxIter;
@@ -607,7 +607,7 @@ cudaStat = cudaMallocManaged((void **)&evec_acc, Nevec_acc*sites*12*sizeof(CUDA_
     }
     Glog << std::string(74,'*') << std::endl;
     
-    GRID_ASSERT(Nm == evec.size() && Nm == eval.size());
+    assert(Nm == evec.size() && Nm == eval.size());
 	
     std::vector<std::vector<ComplexD>> lmd(Nu,std::vector<ComplexD>(Nm,0.0));  
     std::vector<std::vector<ComplexD>> lme(Nu,std::vector<ComplexD>(Nm,0.0));  
@@ -785,7 +785,7 @@ private:
     
     int Nu = w.size();
     int Nm = evec.size();
-    GRID_ASSERT( b < Nm/Nu );
+    assert( b < Nm/Nu );
 //    GridCartesian *grid = evec[0]._grid;
     
     // converts block index to full indicies for an interval [L,R)
@@ -796,7 +796,7 @@ private:
 
     Glog << "Using split grid"<< std::endl;
 //   LatticeGaugeField s_Umu(SGrid);
-   GRID_ASSERT((Nu%mrhs)==0);
+   assert((Nu%mrhs)==0);
    std::vector<Field>   in(mrhs,f_grid);
      
     Field s_in(sf_grid);
@@ -906,7 +906,7 @@ if(split_test){
     
     for (int u=0; u<Nu; ++u) {
 //      Glog << "norm2(w[" << u << "])= "<< norm2(w[u]) << std::endl;
-      GRID_ASSERT (!isnan(norm2(w[u])));
+      assert (!isnan(norm2(w[u])));
       for (int k=L+u; k<R; ++k) {
         Glog <<" In block "<< b << "," <<" beta[" << u << "," << k-L << "] = " << lme[u][k] << std::endl;
       }
@@ -929,8 +929,8 @@ if(split_test){
 			 Eigen::MatrixXcd & Qt, // Nm x Nm
 			 GridBase *grid)
   {
-    GRID_ASSERT( Nk%Nu == 0 && Nm%Nu == 0 );
+    assert( Nk%Nu == 0 && Nm%Nu == 0 );
-    GRID_ASSERT( Nk <= Nm );
+    assert( Nk <= Nm );
     Eigen::MatrixXcd BlockTriDiag = Eigen::MatrixXcd::Zero(Nk,Nk);
     
     for ( int u=0; u<Nu; ++u ) {
@@ -970,8 +970,8 @@ if(split_test){
 			 GridBase *grid)
   {
     Glog << "diagonalize_lapack: Nu= "<<Nu<<" Nk= "<<Nk<<" Nm= "<<std::endl;
-    GRID_ASSERT( Nk%Nu == 0 && Nm%Nu == 0 );
+    assert( Nk%Nu == 0 && Nm%Nu == 0 );
-    GRID_ASSERT( Nk <= Nm );
+    assert( Nk <= Nm );
     Eigen::MatrixXcd BlockTriDiag = Eigen::MatrixXcd::Zero(Nk,Nk);
     
     for ( int u=0; u<Nu; ++u ) {
@@ -1119,7 +1119,7 @@ if (1){
       diagonalize_lapack(eval,lmd,lme,Nu,Nk,Nm,Qt,grid);
 #endif
     } else { 
-      GRID_ASSERT(0);
+      assert(0);
     }
   }
   
@@ -1131,8 +1131,8 @@ if (1){
          Eigen::MatrixXcd& M)
   {
     //Glog << "unpackHermitBlockTriDiagMatToEigen() begin" << '\n'; 
-    GRID_ASSERT( Nk%Nu == 0 && Nm%Nu == 0 );
+    assert( Nk%Nu == 0 && Nm%Nu == 0 );
-    GRID_ASSERT( Nk <= Nm );
+    assert( Nk <= Nm );
     M = Eigen::MatrixXcd::Zero(Nk,Nk);
     
     // rearrange 
@@ -1159,8 +1159,8 @@ if (1){
          Eigen::MatrixXcd& M)
   {
     //Glog << "packHermitBlockTriDiagMatfromEigen() begin" << '\n'; 
-    GRID_ASSERT( Nk%Nu == 0 && Nm%Nu == 0 );
+    assert( Nk%Nu == 0 && Nm%Nu == 0 );
-    GRID_ASSERT( Nk <= Nm );
+    assert( Nk <= Nm );
     
     // rearrange 
     for ( int u=0; u<Nu; ++u ) {

Grid/algorithms/iterative/ImplicitlyRestartedBlockLanczosCoarse.h

@@ -121,7 +121,7 @@ public:
       eresid(_eresid),  MaxIter(_MaxIter),
       diagonalisation(_diagonalisation),
       Nevec_acc(_Nu)
-  { GRID_ASSERT( (Nk%Nu==0) && (Nm%Nu==0) ); };
+  { assert( (Nk%Nu==0) && (Nm%Nu==0) ); };
 
   ////////////////////////////////
   // Helpers
@@ -151,7 +151,7 @@ public:
           Glog<<"orthogonalize after: "<<j<<" of "<<k<<" "<< ip <<std::endl;
       }
     }
-    GRID_ASSERT(normalize(w,if_print) != 0);
+    assert(normalize(w,if_print) != 0);
   }
   void reorthogonalize(Field& w, std::vector<Field>& evec, int k)
   {
@@ -169,7 +169,7 @@ public:
       w[i] = w[i] - ip * evec[j];
     }}
     for(int i=0; i<_Nu; ++i)
-    GRID_ASSERT(normalize(w[i],if_print) !=0);
+    assert(normalize(w[i],if_print) !=0);
   }
   
   void orthogonalize_blockhead(Field& w, std::vector<Field>& evec, int k, int Nu)
@@ -205,8 +205,8 @@ public:
   {
     std::string fname = std::string(cname+"::calc_irbl()"); 
     GridBase *grid = evec[0].Grid();
-    GRID_ASSERT(grid == src[0].Grid());
+    assert(grid == src[0].Grid());
-    GRID_ASSERT( Nu = src.size() );
+    assert( Nu = src.size() );
     
     Glog << std::string(74,'*') << std::endl;
     Glog << fname + " starting iteration 0 /  "<< MaxIter<< std::endl;
@@ -227,7 +227,7 @@ public:
     }
     Glog << std::string(74,'*') << std::endl;
     
-    GRID_ASSERT(Nm == evec.size() && Nm == eval.size());
+    assert(Nm == evec.size() && Nm == eval.size());
 
     std::vector<std::vector<ComplexD>> lmd(Nu,std::vector<ComplexD>(Nm,0.0));  
     std::vector<std::vector<ComplexD>> lme(Nu,std::vector<ComplexD>(Nm,0.0));  
@@ -413,8 +413,8 @@ public:
   {
     std::string fname = std::string(cname+"::calc_rbl()"); 
     GridBase *grid = evec[0].Grid();
-    GRID_ASSERT(grid == src[0].Grid());
+    assert(grid == src[0].Grid());
-    GRID_ASSERT( Nu = src.size() );
+    assert( Nu = src.size() );
 
     int Np = (Nm-Nk);
     if (Np > 0 && MaxIter > 1) Np /= MaxIter;
@@ -441,7 +441,7 @@ public:
     }
     Glog << std::string(74,'*') << std::endl;
     
-    GRID_ASSERT(Nm == evec.size() && Nm == eval.size());
+    assert(Nm == evec.size() && Nm == eval.size());
 	
     std::vector<std::vector<ComplexD>> lmd(Nu,std::vector<ComplexD>(Nm,0.0));  
     std::vector<std::vector<ComplexD>> lme(Nu,std::vector<ComplexD>(Nm,0.0));  
@@ -622,7 +622,7 @@ private:
     
     int Nu = w.size();
     int Nm = evec.size();
-    GRID_ASSERT( b < Nm/Nu );
+    assert( b < Nm/Nu );
     
     // converts block index to full indicies for an interval [L,R)
     int L = Nu*b;
@@ -630,7 +630,7 @@ private:
 
     Real beta;
 
-    GRID_ASSERT((Nu%mrhs)==0);
+    assert((Nu%mrhs)==0);
     std::vector<Field>   in(mrhs,f_grid);
     std::vector<Field>   out(mrhs,f_grid);
 
@@ -711,7 +711,7 @@ private:
     
     for (int u=0; u<Nu; ++u) {
       //      Glog << "norm2(w[" << u << "])= "<< norm2(w[u]) << std::endl;
-      GRID_ASSERT (!isnan(norm2(w[u])));
+      assert (!isnan(norm2(w[u])));
       for (int k=L+u; k<R; ++k) {
 	//        Glog <<" In block "<< b << "," <<" beta[" << u << "," << k-L << "] = " << lme[u][k] << std::endl;
       }
@@ -734,8 +734,8 @@ private:
 			 Eigen::MatrixXcd & Qt, // Nm x Nm
 			 GridBase *grid)
   {
-    GRID_ASSERT( Nk%Nu == 0 && Nm%Nu == 0 );
+    assert( Nk%Nu == 0 && Nm%Nu == 0 );
-    GRID_ASSERT( Nk <= Nm );
+    assert( Nk <= Nm );
     Eigen::MatrixXcd BlockTriDiag = Eigen::MatrixXcd::Zero(Nk,Nk);
     
     for ( int u=0; u<Nu; ++u ) {
@@ -775,8 +775,8 @@ private:
 			 GridBase *grid)
   {
     Glog << "diagonalize_lapack: Nu= "<<Nu<<" Nk= "<<Nk<<" Nm= "<<std::endl;
-    GRID_ASSERT( Nk%Nu == 0 && Nm%Nu == 0 );
+    assert( Nk%Nu == 0 && Nm%Nu == 0 );
-    GRID_ASSERT( Nk <= Nm );
+    assert( Nk <= Nm );
     Eigen::MatrixXcd BlockTriDiag = Eigen::MatrixXcd::Zero(Nk,Nk);
     
     for ( int u=0; u<Nu; ++u ) {
@@ -924,7 +924,7 @@ if (1){
       diagonalize_lapack(eval,lmd,lme,Nu,Nk,Nm,Qt,grid);
 #endif
     } else { 
-      GRID_ASSERT(0);
+      assert(0);
     }
   }
   
@@ -936,8 +936,8 @@ if (1){
          Eigen::MatrixXcd& M)
   {
     //    Glog << "unpackHermitBlockTriDiagMatToEigen() begin" << '\n'; 
-    GRID_ASSERT( Nk%Nu == 0 && Nm%Nu == 0 );
+    assert( Nk%Nu == 0 && Nm%Nu == 0 );
-    GRID_ASSERT( Nk <= Nm );
+    assert( Nk <= Nm );
     M = Eigen::MatrixXcd::Zero(Nk,Nk);
     
     // rearrange 
@@ -964,8 +964,8 @@ if (1){
          Eigen::MatrixXcd& M)
   {
     //    Glog << "packHermitBlockTriDiagMatfromEigen() begin" << '\n'; 
-    GRID_ASSERT( Nk%Nu == 0 && Nm%Nu == 0 );
+    assert( Nk%Nu == 0 && Nm%Nu == 0 );
-    GRID_ASSERT( Nk <= Nm );
+    assert( Nk <= Nm );
     
     // rearrange 
     for ( int u=0; u<Nu; ++u ) {

Grid/algorithms/iterative/ImplicitlyRestartedLanczos.h

@@ -211,7 +211,7 @@ until convergence
   void calc(std::vector<RealD>& eval, std::vector<Field>& evec,  const Field& src, int& Nconv, bool reverse=false)
   {
     GridBase *grid = src.Grid();
-    GRID_ASSERT(grid == evec[0].Grid());
+    assert(grid == evec[0].Grid());
     
     //    GridLogIRL.TimingMode(1);
     std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
@@ -231,7 +231,7 @@ until convergence
     }
     std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
 	
-    GRID_ASSERT(Nm <= evec.size() && Nm <= eval.size());
+    assert(Nm <= evec.size() && Nm <= eval.size());
     
     // quickly get an idea of the largest eigenvalue to more properly normalize the residuum
     RealD evalMaxApprox = 0.0;
@@ -245,10 +245,9 @@ until convergence
 	_HermOp(src_n,tmp);
 	//	std::cout << GridLogMessage<< tmp<<std::endl; exit(0);
 	//	std::cout << GridLogIRL << " _HermOp " << norm2(tmp) << std::endl;
-//	RealD vnum = real(innerProduct(src_n,tmp)); // HermOp.
+	RealD vnum = real(innerProduct(src_n,tmp)); // HermOp.
-	RealD vnum = real(innerProduct(tmp,tmp)); // HermOp^2.
 	RealD vden = norm2(src_n);
-	RealD na = std::sqrt(vnum/vden);
+	RealD na = vnum/vden;
 	if (fabs(evalMaxApprox/na - 1.0) < 0.0001)
 	  i=_MAX_ITER_IRL_MEVAPP_;
 	evalMaxApprox = na;
@@ -256,7 +255,6 @@ until convergence
 	src_n = tmp;
       }
     }
-    std::cout << GridLogIRL << " Final evalMaxApprox  " << evalMaxApprox << std::endl;
 	
     std::vector<RealD> lme(Nm);  
     std::vector<RealD> lme2(Nm);
@@ -337,7 +335,7 @@ until convergence
       }
       std::cout<<GridLogIRL <<"QR decomposed "<<std::endl;
 
-      GRID_ASSERT(k2<Nm);      GRID_ASSERT(k2<Nm);      GRID_ASSERT(k1>0);
+      assert(k2<Nm);      assert(k2<Nm);      assert(k1>0);
 
       basisRotate(evec,Qt,k1-1,k2+1,0,Nm,Nm); /// big constraint on the basis
       std::cout<<GridLogIRL <<"basisRotated  by Qt *"<<k1-1<<","<<k2+1<<")"<<std::endl;
@@ -463,7 +461,7 @@ until convergence
   {
     std::cout<<GridLogDebug << "Lanczos step " <<k<<std::endl;
     const RealD tiny = 1.0e-20;
-    GRID_ASSERT( k< Nm );
+    assert( k< Nm );
 
     GridStopWatch gsw_op,gsw_o;
 
@@ -597,7 +595,7 @@ until convergence
     }  else if ( diagonalisation == IRLdiagonaliseWithEigen ) { 
       diagonalize_Eigen(lmd,lme,Nk,Nm,Qt,grid);
     } else { 
-      GRID_ASSERT(0);
+      assert(0);
     }
   }
 
@@ -687,7 +685,7 @@ void diagonalize_lapack(std::vector<RealD>& lmd,
     }
   }
 #else 
-  GRID_ASSERT(0);
+  assert(0);
 #endif
 }
 

Grid/algorithms/iterative/LocalCoherenceLanczos.h

@@ -80,7 +80,7 @@ public:
   ProjectedHermOp(LinearOperatorBase<FineField>& linop, std::vector<FineField> & _subspace) : 
     _Linop(linop), subspace(_subspace)
   {  
-    GRID_ASSERT(subspace.size() >0);
+    assert(subspace.size() >0);
   };
 
   void operator()(const CoarseField& in, CoarseField& out) {
@@ -346,12 +346,12 @@ public:
 
   void testFine(RealD resid) 
   {
-    GRID_ASSERT(evals_fine.size() == nbasis);
+    assert(evals_fine.size() == nbasis);
-    GRID_ASSERT(subspace.size() == nbasis);
+    assert(subspace.size() == nbasis);
     PlainHermOp<FineField>    Op(_FineOp);
     ImplicitlyRestartedLanczosHermOpTester<FineField> SimpleTester(Op);
     for(int k=0;k<nbasis;k++){
-      GRID_ASSERT(SimpleTester.ReconstructEval(k,resid,subspace[k],evals_fine[k],1.0)==1);
+      assert(SimpleTester.ReconstructEval(k,resid,subspace[k],evals_fine[k],1.0)==1);
     }
   }
 
@@ -359,8 +359,8 @@ public:
   //hence the smoother can be tuned after running the coarse Lanczos by using a different smoother here
   void testCoarse(RealD resid,ChebyParams cheby_smooth,RealD relax) 
   {
-    GRID_ASSERT(evals_fine.size() == nbasis);
+    assert(evals_fine.size() == nbasis);
-    GRID_ASSERT(subspace.size() == nbasis);
+    assert(subspace.size() == nbasis);
     //////////////////////////////////////////////////////////////////////////////////////////////////
     // create a smoother and see if we can get a cheap convergence test and smooth inside the IRL
     //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -380,7 +380,7 @@ public:
   void calcFine(ChebyParams cheby_parms,int Nstop,int Nk,int Nm,RealD resid, 
 		RealD MaxIt, RealD betastp, int MinRes)
   {
-    GRID_ASSERT(nbasis<=Nm);
+    assert(nbasis<=Nm);
     Chebyshev<FineField>      Cheby(cheby_parms);
     FunctionHermOp<FineField> ChebyOp(Cheby,_FineOp);
     PlainHermOp<FineField>    Op(_FineOp);
@@ -400,8 +400,8 @@ public:
     IRL.calc(evals_fine,subspace,src,Nconv,false);
     
     // Shrink down to number saved
-    GRID_ASSERT(Nstop>=nbasis);
+    assert(Nstop>=nbasis);
-    GRID_ASSERT(Nconv>=nbasis);
+    assert(Nconv>=nbasis);
     evals_fine.resize(nbasis);
     subspace.resize(nbasis,_FineGrid);
   }
@@ -433,7 +433,7 @@ public:
     ImplicitlyRestartedLanczos<CoarseField> IRL(ChebyOp,ChebyOp,ChebySmoothTester,Nstop,Nk,Nm,resid,MaxIt,betastp,MinRes);
     int Nconv=0;
     IRL.calc(evals_coarse,evec_coarse,src,Nconv,false);
-    GRID_ASSERT(Nconv>=Nstop);
+    assert(Nconv>=Nstop);
     evals_coarse.resize(Nstop);
     evec_coarse.resize (Nstop,_CoarseGrid);
     for (int i=0;i<Nstop;i++){

Grid/algorithms/iterative/MinimalResidual.h

@@ -35,7 +35,7 @@ template<class Field> class MinimalResidual : public OperatorFunction<Field> {
  public:
   using OperatorFunction<Field>::operator();
 
-  bool ErrorOnNoConverge; // throw an GRID_ASSERT when the MR fails to converge.
+  bool ErrorOnNoConverge; // throw an assert when the MR fails to converge.
                           // Defaults true.
   RealD   Tolerance;
   Integer MaxIterations;
@@ -59,7 +59,7 @@ template<class Field> class MinimalResidual : public OperatorFunction<Field> {
 
     // Initial residual computation & set up
     RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);
 
     RealD ssq = norm2(src);
     RealD rsq = Tolerance * Tolerance * ssq;
@@ -136,7 +136,7 @@ template<class Field> class MinimalResidual : public OperatorFunction<Field> {
         std::cout << GridLogMessage << "MR Time elapsed: Linalg  " << LinalgTimer.Elapsed() << std::endl;
 
         if (ErrorOnNoConverge)
-          GRID_ASSERT(true_residual / Tolerance < 10000.0);
+          assert(true_residual / Tolerance < 10000.0);
 
         IterationsToComplete = k;
 
@@ -148,7 +148,7 @@ template<class Field> class MinimalResidual : public OperatorFunction<Field> {
               << std::endl;
 
     if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
 
     IterationsToComplete = k;
   }

Grid/algorithms/iterative/MixedPrecisionFlexibleGeneralisedMinimalResidual.h

@@ -37,7 +37,7 @@ class MixedPrecisionFlexibleGeneralisedMinimalResidual : public OperatorFunction
 
   using OperatorFunction<FieldD>::operator();
 
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when MPFGMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when MPFGMRES fails to converge,
                           // defaults to true
 
   RealD   Tolerance;
@@ -91,7 +91,7 @@ class MixedPrecisionFlexibleGeneralisedMinimalResidual : public OperatorFunction
     conformable(psi, src);
 
     RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);
 
     RealD cp;
     RealD ssq = norm2(src);
@@ -150,7 +150,7 @@ class MixedPrecisionFlexibleGeneralisedMinimalResidual : public OperatorFunction
     std::cout << GridLogMessage << "MPFGMRES did NOT converge" << std::endl;
 
     if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
   }
 
   RealD outerLoopBody(LinearOperatorBase<FieldD> &LinOp, const FieldD &src, FieldD &psi, RealD rsq) {
@@ -197,7 +197,7 @@ class MixedPrecisionFlexibleGeneralisedMinimalResidual : public OperatorFunction
       }
     }
 
-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
     return cp;
   }
 

Grid/algorithms/iterative/PrecConjugateResidual.h

@@ -112,7 +112,7 @@ public:
     }
 
     std::cout<<GridLogMessage<<"PrecConjugateResidual did NOT converge"<<std::endl;
-    GRID_ASSERT(0);
+    assert(0);
   }
 };
 NAMESPACE_END(Grid);

Grid/algorithms/iterative/PrecGeneralisedConjugateResidual.h

@@ -118,7 +118,7 @@ public:
 
     }
     GCRLogLevel<<"Variable Preconditioned GCR did not converge"<<std::endl;
-    //    GRID_ASSERT(0);
+    //    assert(0);
   }
 
   RealD GCRnStep(const Field &src, Field &psi,RealD rsq){
@@ -221,7 +221,7 @@ public:
       int northog = ((kp)>(mmax-1))?(mmax-1):(kp);  // if more than mmax done, we orthog all mmax history.
       for(int back=0;back<northog;back++){
 
-	int peri_back=(k-back)%mmax;   	  GRID_ASSERT((k-back)>=0);
+	int peri_back=(k-back)%mmax;   	  assert((k-back)>=0);
 
 	b=-real(innerProduct(q[peri_back],Az))/qq[peri_back];
 	p[peri_kp]=p[peri_kp]+b*p[peri_back];
@@ -231,10 +231,9 @@ public:
       qq[peri_kp]=norm2(q[peri_kp]); // could use axpy_norm
       LinalgTimer.Stop();
     }
-    GRID_ASSERT(0); // never reached
+    assert(0); // never reached
     return cp;
   }
 };
 NAMESPACE_END(Grid);
-#undef GCRLogLevel
 #endif

Grid/algorithms/iterative/PrecGeneralisedConjugateResidualNonHermitian.h

@@ -38,14 +38,13 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 NAMESPACE_BEGIN(Grid);
 
-#define GCRLogLevel std::cout << GridLogMessage <<std::string(level,'\t')<< name<<" "
+#define GCRLogLevel std::cout << GridLogMessage <<std::string(level,'\t')<< " Level "<<level<<" " 
 
 template<class Field>
 class PrecGeneralisedConjugateResidualNonHermitian : public LinearFunction<Field> {
 public:                                                
   using LinearFunction<Field>::operator();
   RealD   Tolerance;
-  RealD   SSQ;
   Integer MaxIterations;
   int verbose;
   int mmax;
@@ -55,18 +54,11 @@ public:
   GridStopWatch PrecTimer;
   GridStopWatch MatTimer;
   GridStopWatch LinalgTimer;
-  std::string name;
-  int ZeroGuess  = 0;  // caller contract: guess is always zero => first-cycle r0 = src, skip the apply
-  int FirstCycle = 0;
 
   LinearFunction<Field>     &Preconditioner;
   LinearOperatorBase<Field> &Linop;
 
-  void Name(std::string _name) { name = _name; };
+  void Level(int lv) { level=lv; };
-
-  void Level(int n) { Name("Level " + std::to_string(n)); level = n; }
-
-  void SetZeroGuess(int z) { ZeroGuess = z; };
 
   PrecGeneralisedConjugateResidualNonHermitian(RealD tol,Integer maxit,LinearOperatorBase<Field> &_Linop,LinearFunction<Field> &Prec,int _mmax,int _nstep) : 
     Tolerance(tol), 
@@ -76,16 +68,15 @@ public:
     mmax(_mmax),
     nstep(_nstep)
   { 
-    Level(1);
+    level=1;
     verbose=1;
   };
 
   void operator() (const Field &src, Field &psi){
 
-    //    psi=Zero();
+    psi=Zero();
     RealD cp, ssq,rsq;
     ssq=norm2(src);
-    SSQ=ssq;
     rsq=Tolerance*Tolerance*ssq;
       
     Field r(src.Grid());
@@ -98,12 +89,11 @@ public:
     SolverTimer.Start();
 
     steps=0;
-    FirstCycle=1;
     for(int k=0;k<MaxIterations;k++){
 
       cp=GCRnStep(src,psi,rsq);
 
-      GCRLogLevel <<"PGCR("<<mmax<<","<<nstep<<") "<< steps <<" steps cp = "<<sqrt(cp/ssq)<<" target "<<sqrt(rsq/ssq) <<std::endl;
+      GCRLogLevel <<"PGCR("<<mmax<<","<<nstep<<") "<< steps <<" steps cp = "<<cp<<" target "<<rsq <<std::endl;
 
       if(cp<rsq) {
 
@@ -123,7 +113,7 @@ public:
 
     }
     GCRLogLevel<<"Variable Preconditioned GCR did not converge"<<std::endl;
-    //    GRID_ASSERT(0);
+    //    assert(0);
   }
 
   RealD GCRnStep(const Field &src, Field &psi,RealD rsq){
@@ -152,24 +142,20 @@ public:
     GCRLogLevel<< "PGCR nStep("<<nstep<<")"<<std::endl;
 
     //////////////////////////////////
-    // r0 = src - A x0.  ZeroGuess: on the first cycle x0==0 by caller
+    // initial guess x0 is taken as nonzero.
-    // contract (enforced here), so r0 = src exactly; skip the apply.
+    // r0=src-A x0 = src
-    // Restart cycles (psi!=0) always do the full computation.
     //////////////////////////////////
-    if (ZeroGuess && FirstCycle) {
-      psi = Zero();
-      LinalgTimer.Start();
-      r = src;
-      LinalgTimer.Stop();
-    } else {
     MatTimer.Start();
     Linop.Op(psi,Az);
+    //    zAz = innerProduct(Az,psi);
+    zAAz= norm2(Az);
     MatTimer.Stop();
+    
+
     LinalgTimer.Start();
     r=src-Az;
     LinalgTimer.Stop();
-    }
+    GCRLogLevel<< "PGCR true residual r = src - A psi   "<<norm2(r) <<std::endl;
-    FirstCycle=0;
     
     /////////////////////
     // p = Prec(r)
@@ -195,7 +181,6 @@ public:
     
     cp =norm2(r);
     LinalgTimer.Stop();
-    GCRLogLevel<< "PGCR true residual "<< sqrt(cp/SSQ)     <<std::endl;
 
     for(int k=0;k<nstep;k++){
 
@@ -214,12 +199,13 @@ public:
       cp = axpy_norm(r,-a,q[peri_k],r);
       LinalgTimer.Stop();
 
-      GCRLogLevel<< "PGCR step["<<steps<<"]  resid " << sqrt(cp/SSQ)<<std::endl;
+      GCRLogLevel<< "PGCR step["<<steps<<"]  resid " << cp << " target " <<rsq<<std::endl; 
 
       if((k==nstep-1)||(cp<rsq)){
 	return cp;
       }
 
+
       PrecTimer.Start();
       Preconditioner(r,z);// solve Az = r
       PrecTimer.Stop();
@@ -238,7 +224,7 @@ public:
       int northog = ((kp)>(mmax-1))?(mmax-1):(kp);  // if more than mmax done, we orthog all mmax history.
       for(int back=0;back<northog;back++){
 
-	int peri_back=(k-back)%mmax;   	  GRID_ASSERT((k-back)>=0);
+	int peri_back=(k-back)%mmax;   	  assert((k-back)>=0);
 
 	b=-real(innerProduct(q[peri_back],Az))/qq[peri_back];
 	p[peri_kp]=p[peri_kp]+b*p[peri_back];
@@ -248,11 +234,9 @@ public:
       qq[peri_kp]=norm2(q[peri_kp]); // could use axpy_norm
       LinalgTimer.Stop();
     }
-    GRID_ASSERT(0); // never reached
+    assert(0); // never reached
     return cp;
   }
 };
 NAMESPACE_END(Grid);
-
-#undef GCRLogLevel
 #endif

Grid/algorithms/iterative/QuasiMinimalResidual.h

@@ -79,7 +79,7 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {
 
     LinOp.Op(x,r); r = b - r;
 
-    GRID_ASSERT(normb> 0.0);
+    assert(normb> 0.0);
 
     resid = norm2(r)/normb;
     if (resid <= Tolerance) {
@@ -105,8 +105,8 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {
     for (int i = 1; i <= MaxIterations; i++) {
 
       // Breakdown tests
-      GRID_ASSERT( rho != 0.0);
+      assert( rho != 0.0);
-      GRID_ASSERT( xi  != 0.0);
+      assert( xi  != 0.0);
 
       v = (1. / rho) * v_tld;
       y = (1. / rho) * y;
@@ -134,10 +134,10 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {
       ep=Zep.real();
       std::cout << "Zep "<<Zep <<std::endl;
       // Complex Audit
-      GRID_ASSERT(abs(ep)>0);
+      assert(abs(ep)>0);
 
       beta = ep / delta;
-      GRID_ASSERT(abs(beta)>0);
+      assert(abs(beta)>0);
 
       v_tld = p_tld - beta * v;
       y = v_tld;
@@ -158,7 +158,7 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {
       std::cout << "theta "<<theta<<std::endl;
       std::cout << "gamma "<<gamma<<std::endl;
 
-      GRID_ASSERT(abs(gamma)> 0.0);
+      assert(abs(gamma)> 0.0);
 
       eta = -eta * rho_1 * gamma* gamma / (beta * gamma_1 * gamma_1);
 
@@ -178,7 +178,7 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {
       }
       std::cout << "Iteration "<<i<<" resid " << resid<<std::endl;
     }
-    GRID_ASSERT(0);
+    assert(0);
     return;                            // no convergence
   }
 #else

Grid/algorithms/iterative/SchurRedBlack.h

@@ -327,9 +327,9 @@ namespace Grid {
       /////////////////////////////////////////////////////
       // src_o = (source_o - Moe MeeInv source_e)
       /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     GRID_ASSERT(  tmp.Checkerboard() ==Even);
+      _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.Checkerboard() ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      GRID_ASSERT( Mtmp.Checkerboard() ==Odd);     
+      _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.Checkerboard() ==Odd);     
-      tmp=src_o-Mtmp;                  GRID_ASSERT(  tmp.Checkerboard() ==Odd);     
+      tmp=src_o-Mtmp;                  assert(  tmp.Checkerboard() ==Odd);     
 
       _Matrix.Mooee(tmp,src_o); // Extra factor of "m" in source from dumb choice of matrix norm.
     }
@@ -347,17 +347,17 @@ namespace Grid {
       ///////////////////////////////////////////////////
       // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
       ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o,tmp);        GRID_ASSERT(  tmp.Checkerboard()   ==Even);
+      _Matrix.Meooe(sol_o,tmp);        assert(  tmp.Checkerboard()   ==Even);
-      src_e = src_e-tmp;               GRID_ASSERT(  src_e.Checkerboard() ==Even);
+      src_e = src_e-tmp;               assert(  src_e.Checkerboard() ==Even);
-      _Matrix.MooeeInv(src_e,sol_e);   GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.Checkerboard() ==Even);
      
-      setCheckerboard(sol,sol_e); GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      setCheckerboard(sol,sol_e); assert(  sol_e.Checkerboard() ==Even);
-      setCheckerboard(sol,sol_o); GRID_ASSERT(  sol_o.Checkerboard() ==Odd );
+      setCheckerboard(sol,sol_o); assert(  sol_o.Checkerboard() ==Odd );
     }
     virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
     {
       SchurStaggeredOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  GRID_ASSERT(sol_o.Checkerboard()==Odd);
+      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.Checkerboard()==Odd);
     };
     virtual void RedBlackSolve   (Matrix & _Matrix,const std::vector<Field> &src_o,  std::vector<Field> &sol_o)
     {
@@ -396,13 +396,13 @@ namespace Grid {
       /////////////////////////////////////////////////////
       // src_o = Mdag * (source_o - Moe MeeInv source_e)
       /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     GRID_ASSERT(  tmp.Checkerboard() ==Even);
+      _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.Checkerboard() ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      GRID_ASSERT( Mtmp.Checkerboard() ==Odd);     
+      _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.Checkerboard() ==Odd);     
-      tmp=src_o-Mtmp;                  GRID_ASSERT(  tmp.Checkerboard() ==Odd);     
+      tmp=src_o-Mtmp;                  assert(  tmp.Checkerboard() ==Odd);     
 
       // get the right MpcDag
       SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
-      _HermOpEO.MpcDag(tmp,src_o);     GRID_ASSERT(src_o.Checkerboard() ==Odd);       
+      _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.Checkerboard() ==Odd);       
 
     }
     virtual void RedBlackSolution(Matrix & _Matrix,const Field &sol_o, const Field &src_e,Field &sol)
@@ -416,17 +416,17 @@ namespace Grid {
       ///////////////////////////////////////////////////
       // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
       ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o,tmp);          GRID_ASSERT(  tmp.Checkerboard()   ==Even);
+      _Matrix.Meooe(sol_o,tmp);          assert(  tmp.Checkerboard()   ==Even);
-      src_e_i = src_e-tmp;               GRID_ASSERT(  src_e_i.Checkerboard() ==Even);
+      src_e_i = src_e-tmp;               assert(  src_e_i.Checkerboard() ==Even);
-      _Matrix.MooeeInv(src_e_i,sol_e);   GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      _Matrix.MooeeInv(src_e_i,sol_e);   assert(  sol_e.Checkerboard() ==Even);
      
-      setCheckerboard(sol,sol_e); GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      setCheckerboard(sol,sol_e); assert(  sol_e.Checkerboard() ==Even);
-      setCheckerboard(sol,sol_o); GRID_ASSERT(  sol_o.Checkerboard() ==Odd );
+      setCheckerboard(sol,sol_o); assert(  sol_o.Checkerboard() ==Odd );
     }
     virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
     {
       SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  GRID_ASSERT(sol_o.Checkerboard()==Odd);
+      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.Checkerboard()==Odd);
     };
     virtual void RedBlackSolve   (Matrix & _Matrix,const std::vector<Field> &src_o,  std::vector<Field> &sol_o)
     {
@@ -461,9 +461,9 @@ namespace Grid {
         /////////////////////////////////////////////////////
         // src_o = Mdag * (source_o - Moe MeeInv source_e)
         /////////////////////////////////////////////////////
-        _Matrix.MooeeInv(src_e, tmp);   GRID_ASSERT(   tmp.Checkerboard() == Even );
+        _Matrix.MooeeInv(src_e, tmp);   assert(   tmp.Checkerboard() == Even );
-        _Matrix.Meooe   (tmp, Mtmp);    GRID_ASSERT(  Mtmp.Checkerboard() == Odd  );     
+        _Matrix.Meooe   (tmp, Mtmp);    assert(  Mtmp.Checkerboard() == Odd  );     
-        src_o -= Mtmp;                  GRID_ASSERT( src_o.Checkerboard() == Odd  );     
+        src_o -= Mtmp;                  assert( src_o.Checkerboard() == Odd  );     
       }
       
       virtual void RedBlackSolution(Matrix& _Matrix, const Field& sol_o, const Field& src_e, Field& sol)
@@ -478,18 +478,18 @@ namespace Grid {
         ///////////////////////////////////////////////////
         // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
         ///////////////////////////////////////////////////
-        _Matrix.Meooe(sol_o, tmp);         GRID_ASSERT(     tmp.Checkerboard() == Even );
+        _Matrix.Meooe(sol_o, tmp);         assert(     tmp.Checkerboard() == Even );
-        src_e_i = src_e - tmp;             GRID_ASSERT( src_e_i.Checkerboard() == Even );
+        src_e_i = src_e - tmp;             assert( src_e_i.Checkerboard() == Even );
-        _Matrix.MooeeInv(src_e_i, sol_e);  GRID_ASSERT(   sol_e.Checkerboard() == Even );
+        _Matrix.MooeeInv(src_e_i, sol_e);  assert(   sol_e.Checkerboard() == Even );
        
-        setCheckerboard(sol, sol_e); GRID_ASSERT( sol_e.Checkerboard() == Even );
+        setCheckerboard(sol, sol_e); assert( sol_e.Checkerboard() == Even );
-        setCheckerboard(sol, sol_o); GRID_ASSERT( sol_o.Checkerboard() == Odd  );
+        setCheckerboard(sol, sol_o); assert( sol_o.Checkerboard() == Odd  );
       }
 
       virtual void RedBlackSolve(Matrix& _Matrix, const Field& src_o, Field& sol_o)
       {
         NonHermitianSchurDiagMooeeOperator<Matrix,Field> _OpEO(_Matrix);
-        this->_HermitianRBSolver(_OpEO, src_o, sol_o);  GRID_ASSERT(sol_o.Checkerboard() == Odd);
+        this->_HermitianRBSolver(_OpEO, src_o, sol_o);  assert(sol_o.Checkerboard() == Odd);
       }
 
       virtual void RedBlackSolve(Matrix& _Matrix, const std::vector<Field>& src_o, std::vector<Field>& sol_o)
@@ -539,13 +539,13 @@ namespace Grid {
       /////////////////////////////////////////////////////
       // src_o = Mpcdag *MooeeInv * (source_o - Moe MeeInv source_e)
       /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     GRID_ASSERT(  tmp.Checkerboard() ==Even);
+      _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.Checkerboard() ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      GRID_ASSERT( Mtmp.Checkerboard() ==Odd);     
+      _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.Checkerboard() ==Odd);     
       Mtmp=src_o-Mtmp;                 
-      _Matrix.MooeeInv(Mtmp,tmp);      GRID_ASSERT( tmp.Checkerboard() ==Odd);     
+      _Matrix.MooeeInv(Mtmp,tmp);      assert( tmp.Checkerboard() ==Odd);     
       
       // get the right MpcDag
-      _HermOpEO.MpcDag(tmp,src_o);     GRID_ASSERT(src_o.Checkerboard() ==Odd);       
+      _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.Checkerboard() ==Odd);       
     }
 
     virtual void RedBlackSolution(Matrix & _Matrix,const Field &sol_o, const Field &src_e,Field &sol)
@@ -560,12 +560,12 @@ namespace Grid {
       ///////////////////////////////////////////////////
       // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
       ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o,tmp);    GRID_ASSERT(  tmp.Checkerboard()   ==Even);
+      _Matrix.Meooe(sol_o,tmp);    assert(  tmp.Checkerboard()   ==Even);
-      tmp = src_e-tmp;             GRID_ASSERT(  src_e.Checkerboard() ==Even);
+      tmp = src_e-tmp;             assert(  src_e.Checkerboard() ==Even);
-      _Matrix.MooeeInv(tmp,sol_e); GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      _Matrix.MooeeInv(tmp,sol_e); assert(  sol_e.Checkerboard() ==Even);
      
-      setCheckerboard(sol,sol_e);  GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      setCheckerboard(sol,sol_e);  assert(  sol_e.Checkerboard() ==Even);
-      setCheckerboard(sol,sol_o);  GRID_ASSERT(  sol_o.Checkerboard() ==Odd );
+      setCheckerboard(sol,sol_o);  assert(  sol_o.Checkerboard() ==Odd );
     };
 
     virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
@@ -612,12 +612,12 @@ namespace Grid {
       /////////////////////////////////////////////////////
       // src_o = Mdag * (source_o - Moe MeeInv source_e)
       /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     GRID_ASSERT(  tmp.Checkerboard() ==Even);
+      _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.Checkerboard() ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      GRID_ASSERT( Mtmp.Checkerboard() ==Odd);     
+      _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.Checkerboard() ==Odd);     
-      tmp=src_o-Mtmp;                  GRID_ASSERT(  tmp.Checkerboard() ==Odd);     
+      tmp=src_o-Mtmp;                  assert(  tmp.Checkerboard() ==Odd);     
 
       // get the right MpcDag
-      _HermOpEO.MpcDag(tmp,src_o);     GRID_ASSERT(src_o.Checkerboard() ==Odd);       
+      _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.Checkerboard() ==Odd);       
     }
 
     virtual void RedBlackSolution(Matrix & _Matrix,const Field &sol_o, const Field &src_e,Field &sol)
@@ -638,12 +638,12 @@ namespace Grid {
       ///////////////////////////////////////////////////
       // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
       ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o_i,tmp);    GRID_ASSERT(  tmp.Checkerboard()   ==Even);
+      _Matrix.Meooe(sol_o_i,tmp);    assert(  tmp.Checkerboard()   ==Even);
-      tmp = src_e-tmp;               GRID_ASSERT(  src_e.Checkerboard() ==Even);
+      tmp = src_e-tmp;               assert(  src_e.Checkerboard() ==Even);
-      _Matrix.MooeeInv(tmp,sol_e);   GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      _Matrix.MooeeInv(tmp,sol_e);   assert(  sol_e.Checkerboard() ==Even);
      
-      setCheckerboard(sol,sol_e);    GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      setCheckerboard(sol,sol_e);    assert(  sol_e.Checkerboard() ==Even);
-      setCheckerboard(sol,sol_o_i);  GRID_ASSERT(  sol_o_i.Checkerboard() ==Odd );
+      setCheckerboard(sol,sol_o_i);  assert(  sol_o_i.Checkerboard() ==Odd );
     };
 
     virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
@@ -684,9 +684,9 @@ namespace Grid {
         /////////////////////////////////////////////////////
         // src_o = Mdag * (source_o - Moe MeeInv source_e)
         /////////////////////////////////////////////////////
-        _Matrix.MooeeInv(src_e, tmp);   GRID_ASSERT(   tmp.Checkerboard() == Even );
+        _Matrix.MooeeInv(src_e, tmp);   assert(   tmp.Checkerboard() == Even );
-        _Matrix.Meooe   (tmp, Mtmp);    GRID_ASSERT(  Mtmp.Checkerboard() == Odd  );     
+        _Matrix.Meooe   (tmp, Mtmp);    assert(  Mtmp.Checkerboard() == Odd  );     
-        src_o -= Mtmp;                  GRID_ASSERT( src_o.Checkerboard() == Odd  );     
+        src_o -= Mtmp;                  assert( src_o.Checkerboard() == Odd  );     
       }
 
       virtual void RedBlackSolution(Matrix& _Matrix, const Field& sol_o, const Field& src_e, Field& sol)
@@ -707,12 +707,12 @@ namespace Grid {
         ///////////////////////////////////////////////////
         // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
         ///////////////////////////////////////////////////
-        _Matrix.Meooe(sol_o_i, tmp);    GRID_ASSERT(   tmp.Checkerboard() == Even );
+        _Matrix.Meooe(sol_o_i, tmp);    assert(   tmp.Checkerboard() == Even );
-        tmp = src_e - tmp;              GRID_ASSERT( src_e.Checkerboard() == Even );
+        tmp = src_e - tmp;              assert( src_e.Checkerboard() == Even );
-        _Matrix.MooeeInv(tmp, sol_e);   GRID_ASSERT( sol_e.Checkerboard() == Even );
+        _Matrix.MooeeInv(tmp, sol_e);   assert( sol_e.Checkerboard() == Even );
        
-        setCheckerboard(sol, sol_e);    GRID_ASSERT(   sol_e.Checkerboard() == Even );
+        setCheckerboard(sol, sol_e);    assert(   sol_e.Checkerboard() == Even );
-        setCheckerboard(sol, sol_o_i);  GRID_ASSERT( sol_o_i.Checkerboard() == Odd  );
+        setCheckerboard(sol, sol_o_i);  assert( sol_o_i.Checkerboard() == Odd  );
       };
 
       virtual void RedBlackSolve(Matrix& _Matrix, const Field& src_o, Field& sol_o)

Grid/algorithms/multigrid/Aggregates.h

@@ -30,8 +30,6 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 /*  END LEGAL */
 #pragma once
 
-#include <Grid/algorithms/iterative/PrecGeneralisedConjugateResidualNonHermitian.h>
-
 NAMESPACE_BEGIN(Grid);
 
 inline RealD AggregatePowerLaw(RealD x)
@@ -66,21 +64,7 @@ public:
   {
   };
   
-  void GlobalOrthonormalise(void)
+  
-  {
-    // Normalise all vectors
-    for(int i=0;i<nbasis; i++){
-      RealD scale = std::pow(norm2(subspace[i]),-0.5); 
-      subspace[i] = subspace[i]*scale;
-    }
-    for(int i=0;i<nbasis; i++){
-      for(int j=0;j<i; j++){
-	basisOrthogonalize(subspace,subspace[i],j);
-      }
-      RealD scale = std::pow(norm2(subspace[i]),-0.5); 
-      subspace[i] = subspace[i]*scale;
-    }
-  }  
   void Orthogonalise(void){
     CoarseScalar InnerProd(CoarseGrid); 
     //    std::cout << GridLogMessage <<" Block Gramm-Schmidt pass 1"<<std::endl;
@@ -111,7 +95,7 @@ public:
 
     RealD scale;
 
-    ConjugateGradient<FineField> CG(1.0e-4,2000,false);
+    ConjugateGradient<FineField> CG(1.0e-2,100,false);
     FineField noise(FineGrid);
     FineField Mn(FineGrid);
 
@@ -124,7 +108,7 @@ public:
       
       hermop.Op(noise,Mn); std::cout<<GridLogMessage << "noise   ["<<b<<"] <n|MdagM|n> "<<norm2(Mn)<<std::endl;
 
-      for(int i=0;i<2;i++){
+      for(int i=0;i<1;i++){
 
 	CG(hermop,noise,subspace[b]);
 
@@ -132,8 +116,6 @@ public:
 	scale = std::pow(norm2(noise),-0.5); 
 	noise=noise*scale;
 
-	hermop.Op(noise,Mn); std::cout<<GridLogMessage << "intermediate["<<i<<"] <i|MdagM|i> "<<norm2(Mn)<<std::endl;
-	
       }
 
       hermop.Op(noise,Mn); std::cout<<GridLogMessage << "filtered["<<b<<"] <f|MdagM|f> "<<norm2(Mn)<<std::endl;
@@ -142,60 +124,6 @@ public:
     }
   }
 
-  virtual void CreateSubspaceGCR(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &DiracOp,int nn=nbasis)
-  {
-    RealD scale;
-
-    TrivialPrecon<FineField> simple_fine;
-    //    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.001,10,DiracOp,simple_fine,30,30);
-    //    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.001,10,DiracOp,simple_fine,12,12);
-    //    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.001,30,DiracOp,simple_fine,12,12);
-    //    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.0005,30,DiracOp,simple_fine,20,20);
-    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.0005,30,DiracOp,simple_fine,10,10);
-    FineField noise(FineGrid);
-    FineField src(FineGrid);
-    FineField guess(FineGrid);
-    FineField Mn(FineGrid);
-
-    for(int b=0;b<nn;b++){
-      
-      subspace[b] = Zero();
-      gaussian(RNG,noise);
-      scale = std::pow(norm2(noise),-0.5); 
-      noise=noise*scale;
-      
-      DiracOp.Op(noise,Mn); std::cout<<GridLogMessage << "noise   ["<<b<<"] <n|Op|n> "<<innerProduct(noise,Mn)<<std::endl;
-
-      for(int i=0;i<3;i++){
-	//  void operator() (const Field &src, Field &psi){
-#if 1
-	if (i==0)std::cout << GridLogMessage << " inverting on noise "<<std::endl;
-	src = noise;
-	guess=Zero();
-	GCR(src,guess);
-	subspace[b] = guess;
-#else
-	if (i==0)std::cout << GridLogMessage << " inverting on zero "<<std::endl;
-	src=Zero();
-	guess = noise;
-	GCR(src,guess);
-	subspace[b] = guess;
-#endif
-	noise = subspace[b];
-	scale = std::pow(norm2(noise),-0.5); 
-	noise=noise*scale;
-	
-	DiracOp.Op(noise,Mn); std::cout<<GridLogMessage << "intermediate["<<i<<"] <f|Op|f> "<<innerProduct(noise,Mn)<<" <f|OpDagOp|f>"<<norm2(Mn)<<std::endl;
-
-      }
-
-      DiracOp.Op(noise,Mn); std::cout<<GridLogMessage << "filtered["<<b<<"] <f|Op|f> "<<innerProduct(noise,Mn)<<" <f|OpDagOp|f>"<<norm2(Mn)<<std::endl;
-      subspace[b]   = noise;
-
-    }
-    GlobalOrthonormalise();
-  }
-
   ////////////////////////////////////////////////////////////////////////////////////////////////
   // World of possibilities here. But have tried quite a lot of experiments (250+ jobs run on Summit)
   // and this is the best I found
@@ -232,21 +160,14 @@ public:
 
     int b =0;
     {
-      ComplexD ip;
       // Filter
       Chebyshev<FineField> Cheb(lo,hi,orderfilter);
       Cheb(hermop,noise,Mn);
       // normalise
       scale = std::pow(norm2(Mn),-0.5); 	Mn=Mn*scale;
       subspace[b]   = Mn;
-
       hermop.Op(Mn,tmp); 
-      ip= innerProduct(Mn,tmp); 
+      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|Op|n> "<<norm2(tmp)<<" "<<ip<<std::endl;
-
-      hermop.AdjOp(Mn,tmp); 
-      ip = innerProduct(Mn,tmp); 
-      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|AdjOp|n> "<<norm2(tmp)<<" "<<ip<<std::endl;
       b++;
     }
 
@@ -292,18 +213,8 @@ public:
 	  Mn=*Tnp;
 	  scale = std::pow(norm2(Mn),-0.5);         Mn=Mn*scale;
 	  subspace[b] = Mn;
-
-
-	  ComplexD ip;
-
 	  hermop.Op(Mn,tmp); 
-	  ip= innerProduct(Mn,tmp); 
+	  std::cout<<GridLogMessage << n<<" filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-	  std::cout<<GridLogMessage << "filt ["<<b<<"] <n|Op|n> "<<norm2(tmp)<<" "<<ip<<std::endl;
-
-	  hermop.AdjOp(Mn,tmp); 
-	  ip = innerProduct(Mn,tmp); 
-	  std::cout<<GridLogMessage << "filt ["<<b<<"] <n|AdjOp|n> "<<norm2(tmp)<<" "<<ip<<std::endl;
-	  
 	  b++;
 	}
 
@@ -315,72 +226,8 @@ public:
 	  
       }
     }
-    GRID_ASSERT(b==nn);
+    assert(b==nn);
   }
-
-
-  virtual void CreateSubspacePolyCheby(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
-				       int nn,
-				       double hi,
-				       double lo1,
-				       int orderfilter,
-				       double lo2,
-				       int orderstep)
-  {
-    RealD scale;
-
-    FineField noise(FineGrid);
-    FineField Mn(FineGrid);
-    FineField tmp(FineGrid);
-
-    // New normalised noise
-    gaussian(RNG,noise);
-    scale = std::pow(norm2(noise),-0.5); 
-    noise=noise*scale;
-
-    std::cout << GridLogMessage<<" CreateSubspacePolyCheby "<<std::endl;
-    // Initial matrix element
-    hermop.Op(noise,Mn);
-    std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
-
-    int b =0;
-    {
-      // Filter
-      std::cout << GridLogMessage << "Cheby "<<lo1<<","<<hi<<" "<<orderstep<<std::endl;
-      Chebyshev<FineField> Cheb(lo1,hi,orderfilter);
-      Cheb(hermop,noise,Mn);
-      // normalise
-      scale = std::pow(norm2(Mn),-0.5); 	Mn=Mn*scale;
-      subspace[b]   = Mn;
-      hermop.Op(Mn,tmp); 
-      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|n> "<<norm2(Mn)<<std::endl;
-    }
-
-    // Generate a full sequence of Chebyshevs
-    for(int n=1;n<nn;n++){
-      std::cout << GridLogMessage << "Cheby "<<lo2<<","<<hi<<" "<<orderstep<<std::endl;
-      Chebyshev<FineField> Cheb(lo2,hi,orderstep);
-      Cheb(hermop,subspace[n-1],Mn);
-
-      for(int m=0;m<n;m++){
-	ComplexD c = innerProduct(subspace[m],Mn);
-	Mn = Mn - c*subspace[m];
-      }
-      
-      // normalise
-      scale = std::pow(norm2(Mn),-0.5);
-      Mn=Mn*scale;
-      
-      subspace[n]=Mn;
-      
-      hermop.Op(Mn,tmp); 
-      std::cout<<GridLogMessage << "filt ["<<n<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-      std::cout<<GridLogMessage << "filt ["<<n<<"] <n|n> "<<norm2(Mn)<<std::endl;
-
-    }
-  }
-
   virtual void CreateSubspaceChebyshev(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
 				       int nn,
 				       double hi,

Grid/algorithms/multigrid/CoarsenedMatrix.h

@@ -99,7 +99,7 @@ public:
   CoarseMatrix AselfInvEven;
   CoarseMatrix AselfInvOdd;
 
-  deviceVector<RealD> dag_factor;
+  Vector<RealD> dag_factor;
 
   ///////////////////////
   // Interface
@@ -124,13 +124,9 @@ public:
     int npoint = geom.npoint;
     typedef LatticeView<Cobj> Aview;
       
-    deviceVector<Aview> AcceleratorViewContainer(geom.npoint);
+    Vector<Aview> AcceleratorViewContainer;
-    hostVector<Aview>   hAcceleratorViewContainer(geom.npoint);
   
-    for(int p=0;p<geom.npoint;p++) {
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer.push_back(A[p].View(AcceleratorRead));
-      hAcceleratorViewContainer[p] = A[p].View(AcceleratorRead);
-      acceleratorPut(AcceleratorViewContainer[p],hAcceleratorViewContainer[p]);
-    }
     Aview *Aview_p = & AcceleratorViewContainer[0];
 
     const int Nsimd = CComplex::Nsimd();
@@ -165,7 +161,7 @@ public:
       coalescedWrite(out_v[ss](b),res);
       });
 
-    for(int p=0;p<geom.npoint;p++) hAcceleratorViewContainer[p].ViewClose();
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer[p].ViewClose();
   };
 
   void Mdag (const CoarseVector &in, CoarseVector &out)
@@ -194,14 +190,9 @@ public:
     int npoint = geom.npoint;
     typedef LatticeView<Cobj> Aview;
 
+    Vector<Aview> AcceleratorViewContainer;
 
-    deviceVector<Aview> AcceleratorViewContainer(geom.npoint);
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer.push_back(A[p].View(AcceleratorRead));
-    hostVector<Aview>   hAcceleratorViewContainer(geom.npoint);
-  
-    for(int p=0;p<geom.npoint;p++) {
-      hAcceleratorViewContainer[p] = A[p].View(AcceleratorRead);
-      acceleratorPut(AcceleratorViewContainer[p],hAcceleratorViewContainer[p]);
-    }
     Aview *Aview_p = & AcceleratorViewContainer[0];
 
     const int Nsimd = CComplex::Nsimd();
@@ -210,10 +201,10 @@ public:
 
     int osites=Grid()->oSites();
 
-    deviceVector<int> points(geom.npoint);
+    Vector<int> points(geom.npoint, 0);
-    for(int p=0; p<geom.npoint; p++) { 
+    for(int p=0; p<geom.npoint; p++)
-      acceleratorPut(points[p],geom.points_dagger[p]);
+      points[p] = geom.points_dagger[p];
-    }
+
     auto points_p = &points[0];
 
     RealD* dag_factor_p = &dag_factor[0];
@@ -245,7 +236,7 @@ public:
       coalescedWrite(out_v[ss](b),res);
       });
 
-    for(int p=0;p<geom.npoint;p++) hAcceleratorViewContainer[p].ViewClose();
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer[p].ViewClose();
   }
 
   void MdirComms(const CoarseVector &in)
@@ -260,14 +251,8 @@ public:
     out.Checkerboard() = in.Checkerboard();
 
     typedef LatticeView<Cobj> Aview;
-
+    Vector<Aview> AcceleratorViewContainer;
-    deviceVector<Aview> AcceleratorViewContainer(geom.npoint);
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer.push_back(A[p].View(AcceleratorRead));
-    hostVector<Aview>   hAcceleratorViewContainer(geom.npoint);
-  
-    for(int p=0;p<geom.npoint;p++) {
-      hAcceleratorViewContainer[p] = A[p].View(AcceleratorRead);
-      acceleratorPut(AcceleratorViewContainer[p],hAcceleratorViewContainer[p]);
-    }
     Aview *Aview_p = & AcceleratorViewContainer[0];
 
     autoView( out_v , out, AcceleratorWrite);
@@ -300,7 +285,7 @@ public:
       }
       coalescedWrite(out_v[ss](b),res);
     });
-    for(int p=0;p<geom.npoint;p++) hAcceleratorViewContainer[p].ViewClose();
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer[p].ViewClose();
   }
   void MdirAll(const CoarseVector &in,std::vector<CoarseVector> &out)
   {
@@ -309,7 +294,7 @@ public:
     if ((out.size()!=ndir)&&(out.size()!=ndir+1)) { 
       std::cout <<"MdirAll out size "<< out.size()<<std::endl;
       std::cout <<"MdirAll ndir "<< ndir<<std::endl;
-      GRID_ASSERT(0);
+      assert(0);
     }
     for(int p=0;p<ndir;p++){
       MdirCalc(in,out[p],p);
@@ -373,7 +358,7 @@ public:
     conformable(in.Grid(), _cbgrid);    // verifies half grid
     conformable(in.Grid(), out.Grid()); // drops the cb check
 
-    GRID_ASSERT(in.Checkerboard() == Even);
+    assert(in.Checkerboard() == Even);
     out.Checkerboard() = Odd;
 
     DhopInternal(StencilEven, Aodd, in, out, dag);
@@ -383,7 +368,7 @@ public:
     conformable(in.Grid(), _cbgrid);    // verifies half grid
     conformable(in.Grid(), out.Grid()); // drops the cb check
 
-    GRID_ASSERT(in.Checkerboard() == Odd);
+    assert(in.Checkerboard() == Odd);
     out.Checkerboard() = Even;
 
     DhopInternal(StencilOdd, Aeven, in, out, dag);
@@ -391,7 +376,7 @@ public:
 
   void MooeeInternal(const CoarseVector &in, CoarseVector &out, int dag, int inv) {
     out.Checkerboard() = in.Checkerboard();
-    GRID_ASSERT(in.Checkerboard() == Odd || in.Checkerboard() == Even);
+    assert(in.Checkerboard() == Odd || in.Checkerboard() == Even);
 
     CoarseMatrix *Aself = nullptr;
     if(in.Grid()->_isCheckerBoarded) {
@@ -406,7 +391,7 @@ public:
       Aself = (inv) ? &AselfInv : &A[geom.npoint-1];
       DselfInternal(Stencil, *Aself, in, out, dag);
     }
-    GRID_ASSERT(Aself != nullptr);
+    assert(Aself != nullptr);
   }
 
   void DselfInternal(CartesianStencil<siteVector,siteVector,DefaultImplParams> &st, CoarseMatrix &a,
@@ -484,20 +469,14 @@ public:
 
     // determine in what order we need the points
     int npoint = geom.npoint-1;
-    deviceVector<int> points(npoint);
+    Vector<int> points(npoint, 0);
-    for(int p=0; p<npoint; p++) {
+    for(int p=0; p<npoint; p++)
-      int val = (dag && !hermitian) ? geom.points_dagger[p] : p;
+      points[p] = (dag && !hermitian) ? geom.points_dagger[p] : p;
-      acceleratorPut(points[p], val);
+
-    }
     auto points_p = &points[0];
 
-    deviceVector<Aview> AcceleratorViewContainer(geom.npoint);
+    Vector<Aview> AcceleratorViewContainer;
-    hostVector<Aview>   hAcceleratorViewContainer(geom.npoint);
+    for(int p=0;p<npoint;p++) AcceleratorViewContainer.push_back(a[p].View(AcceleratorRead));
-  
-    for(int p=0;p<geom.npoint;p++) {
-      hAcceleratorViewContainer[p] = a[p].View(AcceleratorRead);
-      acceleratorPut(AcceleratorViewContainer[p],hAcceleratorViewContainer[p]);
-    }
     Aview *Aview_p = & AcceleratorViewContainer[0];
 
     const int Nsimd = CComplex::Nsimd();
@@ -560,7 +539,7 @@ public:
       });
     }
 
-    for(int p=0;p<npoint;p++) hAcceleratorViewContainer[p].ViewClose();
+    for(int p=0;p<npoint;p++) AcceleratorViewContainer[p].ViewClose();
   }
   
   CoarsenedMatrix(GridCartesian &CoarseGrid, int hermitian_=0) 	:
@@ -611,13 +590,11 @@ public:
     }
 
     // GPU readable prefactor
-    std::vector<RealD> h_dag_factor(nbasis*nbasis);
     thread_for(i, nbasis*nbasis, {
       int j = i/nbasis;
       int k = i%nbasis;
-      h_dag_factor[i] = dag_factor_eigen(j, k);
+      dag_factor[i] = dag_factor_eigen(j, k);
     });
-    acceleratorCopyToDevice(&h_dag_factor[0],&dag_factor[0],dag_factor.size()*sizeof(RealD));
   }
 
   void CoarsenOperator(GridBase *FineGrid,LinearOperatorBase<Lattice<Fobj> > &linop,
@@ -697,7 +674,7 @@ public:
     evenmask = where(mod(bcb,2)==(Integer)0,one,zero);
     oddmask  = one-evenmask;
 
-    GRID_ASSERT(self_stencil!=-1);
+    assert(self_stencil!=-1);
 
     for(int i=0;i<nbasis;i++){
 

Grid/algorithms/multigrid/DenseCoarseMatrix.h

@@ -1,702 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./lib/algorithms/multigrid/DenseCoarseMatrix.h
-
-    Copyright (C) 2026
-
-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
-
-#include <Grid/algorithms/blas/BatchedBlas.h>
-#include <Grid/algorithms/blas/BatchedInverse.h>
-
-#include <unordered_map>
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////////////////////
-// DenseCoarseMatrix: a coarsened operator treated as a DENSE matrix -- explicit,
-// row-distributed A^{-1} of a GeneralCoarsenedMatrix.  Library-grade successor of
-// the example-local DistributedDenseInverse (Example_pvdagm_mrhs_3level_dense.cc,
-// FROZEN as the regression baseline).
-//
-// What is new versus the example class:
-//  - Stencil -> dense DIRECT IMPORT.  The coarse operator IS the dense matrix
-//    unrolled: Dense[(s,a),(s+shift_p,b)] += A[p][s]_{a,b}.  Rows of my sites are
-//    assembled from purely LOCAL _A[p] data: no operator applies, no comms -- the
-//    O(N) probe assembly (93 s at N=69120) is retired.  ACCUMULATE (+=) because on
-//    short axes distinct shifts wrap to the same neighbour.  An IMPORT CERTIFICATE
-//    compares the dense apply against Op.M on a NON-CONSTANT vector (a constant one
-//    cannot see a shift-sign error); DENSE_IMPORT_SIGN=-1 flips the convention
-//    without recompiling.
-//  - Split-K apply through GridBLAS.gemmBatched with EXPLICIT leading dimensions
-//    (arXiv:2409.03904 fig 11): the tiny-output/huge-K GEMM Y = slab^T X becomes
-//    DENSE_SPLITK chunk-GEMMs by pointer offset into the resident slab (lda = N),
-//    partials reduced in one accelerator_for.  Platform-agnostic: deviceVector +
-//    GridBLAS run the SAME code on HIP/CUDA/SYCL and CPU(Eigen).
-//  - deviceVector everywhere in the apply path; the ONE surviving naked-HIP block
-//    is the boss inversion buffer (quarantined below, documented).
-//
-// Setup: SLAB_FILE=<stem> loads per-rank <stem>.<rank> (header-guarded N/nrows/
-// nbasis -- the interchange format shared with the frozen example; the STEM must
-// encode cfg/mass/blocking/nbasis, only the header is guarded).  Absent: direct
-// import -> import certificate -> chunked zero-fill+GlobalSum gather streamed to
-// the boss GCD -> cgetrf_64 (ILP64) -> rows of A^{-1} via blocked identity
-// cgetrs_64 + broadcast, each rank keeping the rows of its own sites -> save.
-// VERIFY ||A Ainv x - x||/||x|| runs in BOTH paths (and now certifies the DEVICE
-// slab + split-K path, since the single-RHS apply routes through the same core).
-//
-// Env: SLAB_FILE  DENSE_SPLITK (default 32, snapped to a divisor of N)
-//      DENSE_DEVICE_SUM  DENSE_IMPORT_SIGN  DENSE_APPLY_PROFILE  DENSE_CC_CHECK
-//
-// Eventual internal upgrade (unchanged surface): RecursiveSchur distributed
-// factorisation replacing the single-GCD gather/invert, lifting BOTH the fp32
-// N ~ 90k boss-HBM ceiling AND the CC-grid 256-rank SIMD cap; leaves land on
-// GridBLASInverse::inverseBatched.
-//
-// Tensor-depth agnostic: site scalar objects treated as contiguous ComplexD
-// (iScalar wrappers add no data), so any MG level's coarse operator imports.
-//////////////////////////////////////////////////////////////////////////////////////
-template<class Fobj,class CComplex,int nbasis>
-class DenseCoarseMatrix : public LinearFunction<typename GeneralCoarsenedMatrix<Fobj,CComplex,nbasis>::CoarseVector> {
-public:
-  typedef GeneralCoarsenedMatrix<Fobj,CComplex,nbasis> GeneralCoarseOp;
-  typedef typename GeneralCoarseOp::CoarseVector       Field;
-  typedef typename GeneralCoarseOp::CoarseMatrix       CoarseMatrix;
-  using LinearFunction<Field>::operator();
-  typedef typename Field::vector_object vobj;
-  typedef typename vobj::scalar_object  sobj;
-  typedef typename CoarseMatrix::vector_object Mvobj;
-  typedef typename Mvobj::scalar_object        Msobj;
-
-  GeneralCoarseOp &_Op;             // the coarse operator: stencil source + certificate oracle
-  GridBase *grid;
-  int      nd;
-  int64_t  N;                       // dense rank = gSites * nbasis
-  int      lsites;                  // my local sites
-  int64_t  nrows;                   // my rows = lsites * nbasis
-  std::vector<Coordinate> myLcoor;  // local coordinate of my site ss
-  std::vector<int64_t>    myGsite;  // global lex site index of my site ss
-  std::vector<ComplexF>   slab;     // nrows x N row-major: A during setup, rows of A^{-1} after
-
-  static const int64_t CHUNKROWS = 1024;  // getrs harvest block (trsm efficiency + fewer broadcasts)
-  static const int MRHS_MAX = 32;
-
-  // Apply machinery: resident slab + persistent buffers + AOT split-K pointers.
-  GridBLAS BLAS;
-  deviceVector<ComplexF>  dSlab;
-  deviceVector<ComplexF>  dX;       // N x MRHS_MAX
-  deviceVector<ComplexF>  dY;       // nrows x MRHS_MAX
-  deviceVector<ComplexF>  dPartial; // NK x (nrows x MRHS_MAX)
-  deviceVector<ComplexF*> aptrs;    // slab K-chunk pointers   (lda = N)
-  deviceVector<ComplexF*> xptrs;    // X    K-chunk pointers   (ldb = N)
-  deviceVector<ComplexF*> cptrs;    // partial buffers         (ldc = nrows)
-  std::vector<ComplexF>   hX;
-  std::vector<ComplexF>   hY;
-  int NK;                           // split-K chunk count (divides N)
-  int devSum;
-
-  DenseCoarseMatrix(GeneralCoarseOp &Op, GridBase *g)
-    : _Op(Op), grid(g)
-  {
-    GRID_ASSERT( sizeof(sobj)  == nbasis*sizeof(ComplexD) );
-    GRID_ASSERT( sizeof(Msobj) == nbasis*nbasis*sizeof(ComplexD) );
-    GRID_ASSERT( grid == Op.Grid() );
-    nd     = grid->_ndimension;
-    N      = grid->gSites() * nbasis;
-    lsites = grid->lSites();
-    nrows  = (int64_t)lsites * nbasis;
-
-    std::cout << GridLogMessage << "DenseCoarseMatrix: N = " << N
-              << " (" << grid->gSites() << " sites x " << nbasis << ")"
-              << "  rows/rank = " << nrows
-              << "  slab = " << (double)nrows*N*sizeof(ComplexF)/1024./1024. << " MB/rank"
-              << std::endl;
-
-    ////////////////////////////////////////////////////////////////////
-    // Enumerate my sites: local coords and global lexicographic indices
-    ////////////////////////////////////////////////////////////////////
-    Coordinate ldims = grid->LocalDimensions();
-    Coordinate gdims = grid->GlobalDimensions();
-    myLcoor.resize(lsites);
-    myGsite.resize(lsites);
-    for(int ss=0; ss<lsites; ss++){
-      Coordinate lcoor(nd);
-      Lexicographic::CoorFromIndex(lcoor, ss, ldims);
-      Coordinate gcoor(nd);
-      for(int d=0; d<nd; d++) gcoor[d] = grid->_lstart[d] + lcoor[d];
-      int64_t gsite;
-      Lexicographic::IndexFromCoor(gcoor, gsite, gdims);
-      myLcoor[ss] = lcoor;
-      myGsite[ss] = gsite;
-    }
-
-    slab.resize((uint64_t)nrows * N);
-
-    double t0 = usecond();
-    ////////////////////////////////////////////////////////////////////
-    // 0. Slab cache: SLAB_FILE=<stem> -> per-rank raw file <stem>.<rank>.
-    //    SAME format as the frozen example (interchange compatible).
-    ////////////////////////////////////////////////////////////////////
-    bool loaded = false;
-    char *sfile = getenv("SLAB_FILE");
-    std::string slabfile;
-    if (sfile) {
-      slabfile = std::string(sfile) + "." + std::to_string(grid->ThisRank());
-      FILE *f = fopen(slabfile.c_str(),"rb");
-      if (f) {
-        int64_t hdr[4] = {0,0,0,0};
-        GRID_ASSERT( fread(hdr,sizeof(int64_t),4,f) == 4 );
-        GRID_ASSERT( hdr[0] == (int64_t)0x44454E5345 );  // magic "DENSE"
-        GRID_ASSERT( hdr[1] == N && hdr[2] == (int64_t)nrows && hdr[3] == (int64_t)nbasis );
-        uint64_t nelem = (uint64_t)nrows * N;
-        GRID_ASSERT( fread(&slab[0], sizeof(ComplexF), nelem, f) == nelem );
-        fclose(f);
-        loaded = true;
-        std::cout << GridLogMessage << "DenseCoarseMatrix: slab loaded from "
-                  << slabfile << " -- skipping import/factor/solve" << std::endl;
-      } else {
-        std::cout << GridLogMessage << "DenseCoarseMatrix: slab cache " << slabfile
-                  << " absent -- full setup, will write it" << std::endl;
-      }
-    }
-    if (!loaded) {
-      ImportDense();          // slab <- my rows of A   (LOCAL, no comms)
-      ImportCertificate();    // dense apply == Op.M on a non-constant vector
-      InvertDense();          // slab <- my rows of A^{-1}
-      double t1 = usecond();
-      if (sfile) {
-        FILE *f = fopen(slabfile.c_str(),"wb");
-        GRID_ASSERT(f != nullptr);
-        int64_t hdr[4] = { (int64_t)0x44454E5345, N, (int64_t)nrows, (int64_t)nbasis };
-        GRID_ASSERT( fwrite(hdr,sizeof(int64_t),4,f) == 4 );
-        uint64_t nelem = (uint64_t)nrows * N;
-        GRID_ASSERT( fwrite(&slab[0], sizeof(ComplexF), nelem, f) == nelem );
-        fclose(f);
-        std::cout << GridLogMessage << "DenseCoarseMatrix: slab written to " << slabfile << std::endl;
-      }
-      std::cout << GridLogMessage << "DenseCoarseMatrix: import+invert took "
-                << (t1-t0)/1.0e6 << " s" << std::endl;
-    }
-
-    ////////////////////////////////////////////////////////////////////
-    // Device residency + persistent apply buffers + AOT split-K pointers
-    ////////////////////////////////////////////////////////////////////
-    {
-      uint64_t sbytes = (uint64_t)nrows * N * sizeof(ComplexF);
-      dSlab.resize((uint64_t)nrows*N);
-      acceleratorCopyToDevice(&slab[0],&dSlab[0],sbytes);
-
-      // DENSE_SPLITK: requested chunk count, snapped DOWN to a divisor of N.
-      int req = getenv("DENSE_SPLITK") ? atoi(getenv("DENSE_SPLITK")) : 32;
-      if (req < 1) req = 1;
-      NK = 1;
-      for(int j=1;j<=req;j++) if ( (N % j) == 0 ) NK = j;
-      int64_t Kc = N / NK;
-
-      dX.resize((uint64_t)N*MRHS_MAX);
-      dY.resize((uint64_t)nrows*MRHS_MAX);
-      dPartial.resize((uint64_t)NK*nrows*MRHS_MAX);
-      hX.resize((uint64_t)N*MRHS_MAX);
-      hY.resize((uint64_t)nrows*MRHS_MAX);
-
-      aptrs.resize(NK); xptrs.resize(NK); cptrs.resize(NK);
-      std::vector<ComplexF*> h(NK);
-      for(int j=0;j<NK;j++) h[j] = &dSlab[0]    + (uint64_t)j*Kc;              // K-offset, lda=N
-      acceleratorCopyToDevice(&h[0],&aptrs[0],NK*sizeof(ComplexF*));
-      for(int j=0;j<NK;j++) h[j] = &dX[0]       + (uint64_t)j*Kc;              // K-offset, ldb=N
-      acceleratorCopyToDevice(&h[0],&xptrs[0],NK*sizeof(ComplexF*));
-      for(int j=0;j<NK;j++) h[j] = &dPartial[0] + (uint64_t)j*nrows*MRHS_MAX;  // compact, ldc=nrows
-      acceleratorCopyToDevice(&h[0],&cptrs[0],NK*sizeof(ComplexF*));
-
-      devSum = getenv("DENSE_DEVICE_SUM") ? 1 : 0;
-      std::cout << GridLogMessage << "DenseCoarseMatrix: slab resident on device ("
-                << sbytes/1024./1024. << " MB/rank), split-K NK=" << NK << " (Kc=" << Kc << "); "
-                << (devSum ? "DEVICE-buffer allreduce (GPU-aware MPI)" : "host allreduce")
-                << std::endl;
-    }
-
-    ////////////////////////////////////////////////////////////////////
-    // VERIFY: || A (Ainv x) - x || / ||x|| through the DEVICE split-K core.
-    ////////////////////////////////////////////////////////////////////
-    {
-      Field x(grid); Field y(grid); Field z(grid);
-      x = ComplexD(1.0,0.0);
-      double ta = usecond();
-      (*this)(x, y);
-      double tb = usecond();
-      _Op.M(y, z);
-      z = z - x;
-      RealD rel = std::sqrt(norm2(z)/norm2(x));
-      std::cout << GridLogMessage << "DenseCoarseMatrix: VERIFY ||A Ainv x - x||/||x|| = "
-                << rel << "   (one apply took " << (tb-ta)/1000.0 << " ms)" << std::endl;
-      GRID_ASSERT(rel < 1.0e-2);
-    }
-    std::cout << GridLogMessage << "DenseCoarseMatrix: setup complete, total "
-              << (usecond()-t0)/1.0e6 << " s" << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 1. Direct stencil -> dense import of MY ROWS of A (no comms):
-  //      Dense[(s,a),(wrap(s+shift_p),b)] += A[p][s]_{a,b}
-  ////////////////////////////////////////////////////////////////////
-  void ImportDense(void)
-  {
-    double t = -usecond();
-    Coordinate gdims = grid->GlobalDimensions();
-    int sign = getenv("DENSE_IMPORT_SIGN") ? atoi(getenv("DENSE_IMPORT_SIGN")) : 1;
-    GRID_ASSERT( sign==1 || sign==-1 );
-
-    uint64_t nelem = (uint64_t)nrows * N;
-    thread_for(i, nelem, { slab[i] = ComplexF(0.0,0.0); });
-
-    for(int p=0; p<_Op.geom.npoint; p++){
-      Coordinate shift = _Op.geom.shifts[p];
-      autoView(Av, _Op._A[p], CpuRead);
-      thread_for(ss, lsites, {
-        Coordinate ncoor(nd);
-        for(int d=0; d<nd; d++){
-          int64_t g = grid->_lstart[d] + myLcoor[ss][d] + sign*shift[d];
-          ncoor[d] = (int)((g % gdims[d] + gdims[d]) % gdims[d]);
-        }
-        int64_t nsite;
-        Lexicographic::IndexFromCoor(ncoor, nsite, gdims);
-        Msobj m;
-        peekLocalSite(m, Av, myLcoor[ss]);
-        ComplexD *md = (ComplexD *)&m;
-        for(int a=0; a<nbasis; a++){
-          ComplexF *row = &slab[(uint64_t)(ss*nbasis+a)*N + nsite*nbasis];
-          for(int b=0; b<nbasis; b++)
-            row[b] += ComplexF(md[a*nbasis+b]);   // += : wrapped shifts may collide
-        }
-      });
-    }
-    t += usecond();
-    std::cout << GridLogMessage << "DenseCoarseMatrix: stencil->dense import took "
-              << t/1.0e6 << " s  (" << _Op.geom.npoint << " points, local, no comms)" << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 2. IMPORT CERTIFICATE: dense rows vs Op.M on a NON-CONSTANT vector.
-  //    (Constant x has x[s+d]==x[s-d]: blind to a shift-sign error.)
-  ////////////////////////////////////////////////////////////////////
-  void ImportCertificate(void)
-  {
-    Field x(grid); Field Ax(grid); Field Dx(grid);
-    for(int ss=0; ss<lsites; ss++){
-      sobj s;
-      for(int b=0; b<nbasis; b++){
-        double ph = 0.37*(double)(myGsite[ss]*nbasis+b);
-        ((ComplexD *)&s)[b] = ComplexD(std::cos(ph),std::sin(0.61*ph));
-      }
-      pokeLocalSite(s, x, myLcoor[ss]);
-    }
-    // gather full x (zero-fill + exact GlobalSum), dense rows on host
-    std::vector<ComplexD> xh((uint64_t)N, ComplexD(0.0,0.0));
-    for(int ss=0; ss<lsites; ss++){
-      sobj s;
-      peekLocalSite(s, x, myLcoor[ss]);
-      for(int b=0; b<nbasis; b++) xh[ myGsite[ss]*nbasis + b ] = ((ComplexD *)&s)[b];
-    }
-    grid->GlobalSumVector(&xh[0], (int)N);
-    std::vector<ComplexD> yh(nrows);
-    thread_for(r, nrows, {
-      ComplexD acc(0.0,0.0);
-      const ComplexF *row = &slab[(uint64_t)r * N];
-      for(int64_t j=0; j<N; j++) acc += ComplexD(row[j]) * xh[j];
-      yh[r] = acc;
-    });
-    for(int ss=0; ss<lsites; ss++){
-      sobj s;
-      for(int b=0; b<nbasis; b++) ((ComplexD *)&s)[b] = yh[ss*nbasis+b];
-      pokeLocalSite(s, Dx, myLcoor[ss]);
-    }
-    _Op.M(x, Ax);
-    Field d(grid); d = Dx - Ax;
-    RealD rel = std::sqrt(norm2(d)/norm2(Ax));
-    std::cout << GridLogMessage << "DenseCoarseMatrix: IMPORT CERTIFICATE ||Dense x - A x||/||A x|| = "
-              << rel << std::endl;
-    if ( rel >= 1.0e-3 ) {
-      std::cout << GridLogMessage << "DenseCoarseMatrix: IMPORT CERTIFICATE FAILED. If O(1), the "
-                << "stencil shift-sign convention is opposite: rerun with DENSE_IMPORT_SIGN=-1"
-                << std::endl;
-    }
-    GRID_ASSERT(rel < 1.0e-3);
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 3. Invert: chunked zero-fill+GlobalSum gather of A streamed to the
-  //    boss GCD, cgetrf_64 (ILP64), rows of A^{-1} by blocked identity
-  //    cgetrs_64 + broadcast; each rank keeps its own rows (in `slab`,
-  //    overwriting A).  Ported proven path from the frozen example.
-  ////////////////////////////////////////////////////////////////////
-  void InvertDense(void)
-  {
-    double t1 = usecond();
-    int boss = grid->IsBoss();
-    std::vector<ComplexF> Afull;
-#ifdef GRID_HIP
-    // QUARANTINED naked HIP: the boss-only N^2 inversion buffer (34GB at
-    // N=65536) must come from raw HBM; EvictAll flushes the device-copy
-    // layer to make the window.  (FreePool of the allocator free-list
-    // awaits the type-dispatched fix.)  Confined to setup; the apply path
-    // is pure Grid primitives.
-    rocblas_float_complex *dA = nullptr;
-    rocblas_float_complex *dB = nullptr;
-    int64_t *dIpiv = nullptr;
-    uint64_t Abytes = (uint64_t)N * N * sizeof(ComplexF);
-    MemoryManager::EvictAll();
-    if (boss) {
-      auto aerr = hipMalloc((void **)&dA, Abytes);
-      if (aerr != hipSuccess) {
-        std::cout << GridLogMessage << "DenseCoarseMatrix: hipMalloc of "
-                  << Abytes/1024./1024./1024. << " GB FAILED -- reduce --device-mem" << std::endl;
-        GRID_ASSERT(aerr == hipSuccess);
-      }
-      std::cout << GridLogMessage << "DenseCoarseMatrix: device inversion buffer allocated ("
-                << Abytes/1024./1024./1024. << " GB)" << std::endl;
-    }
-#else
-    if (boss) Afull.resize((uint64_t)N * N);
-#endif
-    {
-      std::unordered_map<int64_t,int> rowmap;   // global row -> my slab row
-      for(int ss=0; ss<lsites; ss++)
-        for(int a=0; a<nbasis; a++)
-          rowmap[ myGsite[ss]*nbasis + a ] = ss*nbasis + a;
-
-      std::vector<ComplexF> chunk((uint64_t)CHUNKROWS * N);
-      for(int64_t row0=0; row0<N; row0+=CHUNKROWS){
-        int64_t nrow = std::min(CHUNKROWS, N-row0);
-        uint64_t nelem = (uint64_t)nrow * N;
-        for(uint64_t i=0;i<nelem;i++) chunk[i]=ComplexF(0.0,0.0);
-        for(int64_t r=row0; r<row0+nrow; r++){
-          auto it = rowmap.find(r);
-          if (it != rowmap.end()) {
-            uint64_t src = (uint64_t)(it->second) * N;
-            uint64_t dst = (uint64_t)(r-row0) * N;
-            for(int64_t j=0;j<N;j++) chunk[dst+j] = slab[src+j];
-          }
-        }
-        grid->GlobalSumVector(&chunk[0], (int)nelem);
-        if (boss) {
-#ifdef GRID_HIP
-          GRID_ASSERT( hipMemcpy((char *)dA + (uint64_t)row0*N*sizeof(ComplexF),
-                                 &chunk[0], nelem*sizeof(ComplexF),
-                                 hipMemcpyHostToDevice) == hipSuccess );
-#else
-          uint64_t dst = (uint64_t)row0 * N;
-          for(uint64_t i=0;i<nelem;i++) Afull[dst+i] = chunk[i];
-#endif
-        }
-      }
-    }
-    double t2 = usecond();
-    std::cout << GridLogMessage << "DenseCoarseMatrix: gather to boss took "
-              << (t2-t1)/1.0e6 << " s" << std::endl;
-
-    ////////////////////////////////////////////////////////////////////
-    // Factor in place on the boss (fp32, ILP64).  Row-major buffer handed
-    // to column-major LAPACK => LU of A^T.
-    ////////////////////////////////////////////////////////////////////
-    if (boss) {
-#ifdef GRID_HIP
-      std::cout << GridLogMessage << "DenseCoarseMatrix: rocSOLVER cgetrf_64 (ILP64 LU) N=" << N
-                << " in place on resident device buffer" << std::endl;
-      rocblas_handle handle = GridBLASInverse::Handle();
-      int64_t *dInfo;
-      GRID_ASSERT( hipMalloc((void **)&dIpiv, N*sizeof(int64_t)) == hipSuccess );
-      GRID_ASSERT( hipMalloc((void **)&dInfo, sizeof(int64_t))   == hipSuccess );
-      auto st1 = rocsolver_cgetrf_64(handle, (int64_t)N, (int64_t)N, dA, (int64_t)N, dIpiv, dInfo);
-      hipDeviceSynchronize();
-      int64_t info_h = -1;
-      hipMemcpy(&info_h, dInfo, sizeof(int64_t), hipMemcpyDeviceToHost);
-      std::cout << GridLogMessage << "DenseCoarseMatrix: cgetrf_64 status " << (int)st1
-                << " info = " << (int)info_h << std::endl;
-      GRID_ASSERT(st1 == rocblas_status_success);
-      GRID_ASSERT(info_h == 0);
-      hipFree(dInfo);
-      GRID_ASSERT( hipMalloc((void **)&dB, (uint64_t)CHUNKROWS*N*sizeof(ComplexF)) == hipSuccess );
-      // dA holds the LU of A^T; rows of A^{-1} are produced blockwise below via
-      // cgetrs_64 on identity-column blocks: A^T X = E => X columns = rows of
-      // A^{-1}, in exactly the linear layout the harvest expects.
-#else
-      // Eigen fallback: small local CPU tests only.
-      std::cout << GridLogMessage << "DenseCoarseMatrix: Eigen fallback inversion N=" << N
-                << (N > 10000 ? "  (WARNING: SLOW; use the HIP/rocSOLVER path)" : "")
-                << std::endl;
-      typedef Eigen::Matrix<std::complex<float>,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor> MatF;
-      Eigen::Map<MatF> A(reinterpret_cast<std::complex<float>*>(&Afull[0]), N, N);
-      MatF Ainv = A.inverse();
-      A = Ainv;
-#endif
-    }
-    double t3 = usecond();
-    std::cout << GridLogMessage << "DenseCoarseMatrix: factorisation took "
-              << (t3-t2)/1.0e6 << " s" << std::endl;
-
-    ////////////////////////////////////////////////////////////////////
-    // Blocked solve + broadcast: rows of A^{-1} chunk by chunk; each
-    // rank keeps the rows of its own sites (ownership-aligned).
-    ////////////////////////////////////////////////////////////////////
-    {
-      std::unordered_map<int64_t,int> rowmap;
-      for(int ss=0; ss<lsites; ss++)
-        for(int a=0; a<nbasis; a++)
-          rowmap[ myGsite[ss]*nbasis + a ] = ss*nbasis + a;
-
-      std::vector<ComplexF> chunk((uint64_t)CHUNKROWS * N);
-      for(int64_t row0=0; row0<N; row0+=CHUNKROWS){
-        int64_t nrow = std::min(CHUNKROWS, N-row0);
-        uint64_t nelem = (uint64_t)nrow * N;
-        if (boss) {
-#ifdef GRID_HIP
-          // Identity block E: column j = e_{row0+j}; solve A^T X = E so X's
-          // columns are rows [row0,row0+nrow) of A^{-1}.
-          for(uint64_t i=0;i<nelem;i++) chunk[i] = ComplexF(0.0,0.0);
-          for(int64_t j=0;j<nrow;j++) chunk[(uint64_t)j*N + (uint64_t)(row0+j)] = ComplexF(1.0,0.0);
-          GRID_ASSERT( hipMemcpy(dB, &chunk[0], nelem*sizeof(ComplexF), hipMemcpyHostToDevice) == hipSuccess );
-          auto strs = rocsolver_cgetrs_64(GridBLASInverse::Handle(), rocblas_operation_none,
-                                          (int64_t)N, (int64_t)nrow,
-                                          dA, (int64_t)N, dIpiv, dB, (int64_t)N);
-          GRID_ASSERT(strs == rocblas_status_success);
-          hipDeviceSynchronize();
-          GRID_ASSERT( hipMemcpy(&chunk[0], dB, nelem*sizeof(ComplexF), hipMemcpyDeviceToHost) == hipSuccess );
-#else
-          uint64_t src = (uint64_t)row0 * N;
-          for(uint64_t i=0;i<nelem;i++) chunk[i] = Afull[src+i];
-#endif
-        }
-        grid->Broadcast(0, &chunk[0], nelem*sizeof(ComplexF));
-        for(int64_t r=row0; r<row0+nrow; r++){
-          auto it = rowmap.find(r);
-          if (it != rowmap.end()) {
-            uint64_t dst = (uint64_t)(it->second) * N;
-            uint64_t src = (uint64_t)(r-row0) * N;
-            for(int64_t j=0;j<N;j++) slab[dst+j] = chunk[src+j];
-          }
-        }
-      }
-    }
-#ifdef GRID_HIP
-    if (boss) {
-      if (dA)    hipFree(dA);
-      if (dB)    hipFree(dB);
-      if (dIpiv) hipFree(dIpiv);
-    }
-#endif
-    double t4 = usecond();
-    std::cout << GridLogMessage << "DenseCoarseMatrix: blocked getrs solve+scatter took "
-              << (t4-t3)/1.0e6 << " s" << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // CORE apply on packed data: hX[N x nr] (zero-filled, my sites only)
-  // -> allreduce -> split-K GEMM against the resident slab -> reduce
-  // partials -> hY[nrows x nr] (column major).  Platform-agnostic:
-  // deviceVector + GridBLAS (Eigen fallback on CPU builds).
-  // fp32 allreduce is EXACT: zero-fill assembly gives every element
-  // exactly one contributing rank.
-  ////////////////////////////////////////////////////////////////////
-  void SlabApplyPacked(int nr, double *tprof)
-  {
-    GRID_ASSERT(nr <= MRHS_MAX);
-    uint64_t nX = (uint64_t)N * nr;
-    uint64_t nY = (uint64_t)nrows * nr;
-    int64_t  Kc = N / NK;
-    double t1 = usecond();
-    double t2, t3;
-    if (devSum) {
-      acceleratorCopyToDevice(&hX[0],&dX[0],nX*sizeof(ComplexF));
-      t2 = usecond();
-      grid->GlobalSumVector((ComplexF *)&dX[0], (int)nX);
-      t3 = usecond();
-    } else {
-      grid->GlobalSumVector(&hX[0], (int)nX);
-      t2 = usecond();
-      acceleratorCopyToDevice(&hX[0],&dX[0],nX*sizeof(ComplexF));
-      t3 = usecond();
-    }
-    // Y = op(slab,T) . X : row-major slab (nrows x N) == col-major A^T
-    // (N x nrows, lda=N) => transpose gives the nrows x N operator.
-    // Split-K: NK chunk-GEMMs by pointer offset (AOT lists), then reduce.
-    ComplexF one (1.0,0.0);
-    ComplexF zero(0.0,0.0);
-    BLAS.gemmBatched(GridBLAS_OP_T, GridBLAS_OP_N,
-                     (int)nrows, nr, (int)Kc,
-                     one,  aptrs, (int)N,
-                           xptrs, (int)N,
-                     zero, cptrs, (int)nrows);
-    BLAS.synchronise();
-    {
-      ComplexF *pp = &dPartial[0];
-      ComplexF *py = &dY[0];
-      uint64_t stride = (uint64_t)nrows*MRHS_MAX;
-      int nk = NK;
-      accelerator_for(i, nY, 1, {
-        ComplexF acc(0.0,0.0);
-        for(int j=0;j<nk;j++) acc += pp[(uint64_t)j*stride + i];
-        py[i] = acc;
-      });
-    }
-    double t4 = usecond();
-    acceleratorCopyFromDevice(&dY[0],&hY[0],nY*sizeof(ComplexF));
-    double t5 = usecond();
-    if (tprof) {
-      tprof[0] = devSum ? (t3-t2) : (t2-t1);   // allreduce
-      tprof[1] = devSum ? (t2-t1) : (t3-t2);   // H2D
-      tprof[2] = t4-t3;                        // gemm+reduce
-      tprof[3] = t5-t4;                        // D2H
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Single-RHS apply (also the VERIFY path => certifies device slab).
-  ////////////////////////////////////////////////////////////////////
-  virtual void operator()(const Field &src, Field &psi)
-  {
-    uint64_t nX = (uint64_t)N;
-    thread_for(i, nX, { hX[i]=ComplexF(0.0,0.0); });
-    for(int ss=0; ss<lsites; ss++){
-      sobj s;
-      peekLocalSite(s, src, myLcoor[ss]);
-      for(int b=0; b<nbasis; b++)
-        hX[ myGsite[ss]*nbasis + b ] = ComplexF(((ComplexD *)&s)[b]);
-    }
-    SlabApplyPacked(1, nullptr);
-    for(int ss=0; ss<lsites; ss++){
-      sobj s;
-      for(int b=0; b<nbasis; b++)
-        ((ComplexD *)&s)[b] = ComplexD(hY[ss*nbasis + b]);
-      pokeLocalSite(s, psi, myLcoor[ss]);
-    }
-    if ( getenv("DENSE_CC_CHECK") ) {
-      Field tmp(grid);
-      _Op.M(psi, tmp);
-      tmp = tmp - src;
-      std::cout << GridLogMessage << "DenseCoarseMatrix: apply defect ||A x - b||/||b|| = "
-                << std::sqrt(norm2(tmp)/norm2(src)) << std::endl;
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Batched (vector-of-fields) apply.
-  ////////////////////////////////////////////////////////////////////
-  void ApplyBatch(std::vector<Field> &src, std::vector<Field> &psi)
-  {
-    int nr = src.size();
-    GRID_ASSERT(nr <= MRHS_MAX);
-    double t0 = usecond();
-    uint64_t nX = (uint64_t)N*nr;
-    thread_for(i, nX, { hX[i]=ComplexF(0.0,0.0); });
-    for(int rr=0; rr<nr; rr++){
-      for(int ss=0; ss<lsites; ss++){
-        sobj s;
-        peekLocalSite(s, src[rr], myLcoor[ss]);
-        for(int b=0; b<nbasis; b++)
-          hX[ (uint64_t)rr*N + myGsite[ss]*nbasis + b ] = ComplexF(((ComplexD *)&s)[b]);
-      }
-    }
-    SlabApplyPacked(nr, nullptr);
-    for(int rr=0; rr<nr; rr++){
-      for(int ss=0; ss<lsites; ss++){
-        sobj s;
-        for(int b=0; b<nbasis; b++)
-          ((ComplexD *)&s)[b] = ComplexD(hY[(uint64_t)rr*nrows + (ss*nbasis+b)]);
-        pokeLocalSite(s, psi[rr], myLcoor[ss]);
-      }
-    }
-    double t1 = usecond();
-    std::cout << GridLogMessage << "DenseCoarseMatrix: batched apply " << nr << " rhs took "
-              << (t1-t0)/1000.0 << " ms  (" << (t1-t0)/1000.0/nr << " ms/rhs)" << std::endl;
-    if ( getenv("DENSE_CC_CHECK") ) {
-      Field tmp(grid);
-      for(int rr=0; rr<nr; rr++){
-        _Op.M(psi[rr], tmp);
-        tmp = tmp - src[rr];
-        std::cout << GridLogMessage << "DenseCoarseMatrix: batch defect["<<rr<<"] = "
-                  << std::sqrt(norm2(tmp)/norm2(src[rr])) << std::endl;
-      }
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 6D mrhs apply: operates DIRECTLY on the packed 6D field (rhs = dim 0).
-  ////////////////////////////////////////////////////////////////////
-  void ApplyBatch6D(const Field &in6, Field &out6, int nr)
-  {
-    GRID_ASSERT(nr <= MRHS_MAX);
-    GRID_ASSERT(in6.Grid()->_ndimension == nd+1);   // {rhs, s, x,y,z,t}
-    double t0 = usecond();
-    Field &in = const_cast<Field &>(in6);
-    uint64_t nX = (uint64_t)N * nr;
-    thread_for(i, nX, { hX[i]=ComplexF(0.0,0.0); });
-    {
-      autoView(iv, in, CpuRead);
-      Coordinate c6(nd+1);
-      for(int ss=0; ss<lsites; ss++){
-        for(int d=0; d<nd; d++) c6[d+1] = myLcoor[ss][d];
-        for(int rr=0; rr<nr; rr++){
-          c6[0] = rr;
-          sobj s;
-          peekLocalSite(s, iv, c6);
-          for(int b=0; b<nbasis; b++)
-            hX[(uint64_t)rr*N + myGsite[ss]*nbasis + b] = ComplexF(((ComplexD *)&s)[b]);
-        }
-      }
-    }
-    double t1 = usecond();
-    double tprof[4];
-    SlabApplyPacked(nr, tprof);
-    double t5 = usecond();
-    {
-      autoView(ov, out6, CpuWrite);
-      Coordinate c6(nd+1);
-      for(int ss=0; ss<lsites; ss++){
-        for(int d=0; d<nd; d++) c6[d+1] = myLcoor[ss][d];
-        for(int rr=0; rr<nr; rr++){
-          c6[0] = rr;
-          sobj s;
-          for(int b=0; b<nbasis; b++)
-            ((ComplexD *)&s)[b] = ComplexD(hY[(uint64_t)rr*nrows + (ss*nbasis+b)]);  // Y col-major
-          pokeLocalSite(s, ov, c6);
-        }
-      }
-    }
-    double t6 = usecond();
-    std::cout << GridLogMessage << "DenseCoarseMatrix: apply6D " << nr << " rhs took "
-              << (t6-t0)/1000.0 << " ms" << std::endl;
-    if ( getenv("DENSE_APPLY_PROFILE") ) {
-      std::cout << GridLogMessage << "DenseCoarseMatrix: apply6D profile:"
-                << " pack "        << (t1-t0)/1000.0
-                << "  allreduce "  << tprof[0]/1000.0
-                << "  H2D "        << tprof[1]/1000.0
-                << "  gemm+reduce "<< tprof[2]/1000.0
-                << "  D2H "        << tprof[3]/1000.0
-                << "  unpack "     << (t6-t5)/1000.0
-                << "  ms" << std::endl;
-    }
-  }
-};
-
-NAMESPACE_END(Grid);

Grid/algorithms/multigrid/GeneralCoarsenedMatrix.h

@@ -31,7 +31,6 @@ Author: Peter Boyle <pboyle@bnl.gov>
 
 #include <Grid/lattice/PaddedCell.h>
 #include <Grid/stencil/GeneralLocalStencil.h>
-#include <Grid/algorithms/deflation/MultiRHSBlockProject.h>
 
 NAMESPACE_BEGIN(Grid);
 
@@ -67,10 +66,6 @@ public:
   std::vector<CoarseMatrix> _Adag;
   std::vector<CoarseVector> MultTemporaries;
 
-  int64_t MultCalls;
-  double  MultFlopsAccum;
-  double  MultUsecAccum;
-
   ///////////////////////
   // Interface
   ///////////////////////
@@ -104,25 +99,24 @@ public:
 	}
       }
     }
-    GRID_ASSERT(nfound==geom.npoint);
+    assert(nfound==geom.npoint);
     ExchangeCoarseLinks();
   }
   */
   
-  GeneralCoarsenedMatrix(NonLocalStencilGeometry &_geom,GridBase *FineGrid, GridCartesian * CoarseGrid,int _herm=1)
+  GeneralCoarsenedMatrix(NonLocalStencilGeometry &_geom,GridBase *FineGrid, GridCartesian * CoarseGrid)
     : geom(_geom),
       _FineGrid(FineGrid),
       _CoarseGrid(CoarseGrid),
-      hermitian(_herm),
+      hermitian(1),
       Cell(_geom.Depth(),_CoarseGrid),
-      Stencil(Cell.grids.back(),geom.shifts),
+      Stencil(Cell.grids.back(),geom.shifts)
-      MultCalls(0), MultFlopsAccum(0.0), MultUsecAccum(0.0)
   {
     {
       int npoint = _geom.npoint;
     }
     _A.resize(geom.npoint,CoarseGrid);
-    if ( !hermitian ) _Adag.resize(geom.npoint,CoarseGrid);
+    //    _Adag.resize(geom.npoint,CoarseGrid);
   }
   void M (const CoarseVector &in, CoarseVector &out)
   {
@@ -130,10 +124,10 @@ public:
   }
   void Mdag (const CoarseVector &in, CoarseVector &out)
   {
-    if(hermitian)
+    assert(hermitian);
     Mult(_A,in,out);
-    else
+    //    if ( hermitian ) M(in,out);
-      Mult(_Adag,in,out);
+    //    else Mult(_Adag,in,out);
   }
   void Mult (std::vector<CoarseMatrix> &A,const CoarseVector &in, CoarseVector &out)
   {
@@ -233,24 +227,25 @@ public:
     text+=usecond();
     ttot+=usecond();
     
-    MultCalls++;
+    std::cout << GridLogPerformance<<"Coarse 1rhs Mult Aviews "<<tviews<<" us"<<std::endl;
-    MultFlopsAccum += flops;
+    std::cout << GridLogPerformance<<"Coarse Mult exch "<<texch<<" us"<<std::endl;
-    MultUsecAccum  += ttot;
+    std::cout << GridLogPerformance<<"Coarse Mult mult "<<tmult<<" us"<<std::endl;
-    std::cout << GridLogPerformance
+    std::cout << GridLogPerformance<<" of which mult2  "<<tmult2<<" us"<<std::endl;
-	      << "Coarse Mult call " << MultCalls
+    std::cout << GridLogPerformance<<"Coarse Mult ext  "<<text<<" us"<<std::endl;
-	      << "  tot " << ttot << " us"
+    std::cout << GridLogPerformance<<"Coarse Mult temps "<<ttemps<<" us"<<std::endl;
-	      << "  kernel " << tmult << " us"
+    std::cout << GridLogPerformance<<"Coarse Mult copy  "<<tcopy<<" us"<<std::endl;
-	      << "  kernel " << flops/tmult*1e-3 << " GFlop/s"
+    std::cout << GridLogPerformance<<"Coarse Mult tot  "<<ttot<<" us"<<std::endl;
-	      << "  overall " << MultFlopsAccum/MultUsecAccum*1e-3 << " GFlop/s (cumul)"
+    //    std::cout << GridLogPerformance<<std::endl;
-	      << "  bw " << bytes/tmult*1e-3 << " GB/s"
+    std::cout << GridLogPerformance<<"Coarse Kernel flops "<< flops<<std::endl;
-	      << std::endl;
+    std::cout << GridLogPerformance<<"Coarse Kernel flop/s "<< flops/tmult<<" mflop/s"<<std::endl;
+    std::cout << GridLogPerformance<<"Coarse Kernel bytes/s "<< bytes/tmult<<" MB/s"<<std::endl;
+    std::cout << GridLogPerformance<<"Coarse overall flops/s "<< flops/ttot<<" mflop/s"<<std::endl;
+    std::cout << GridLogPerformance<<"Coarse total bytes   "<< bytes/1e6<<" MB"<<std::endl;
 
   };
   
   void PopulateAdag(void)
   {
-#if 0
-    // Serial global peek/poke reference implementation
     for(int64_t bidx=0;bidx<CoarseGrid()->gSites() ;bidx++){
       Coordinate bcoor;
       CoarseGrid()->GlobalIndexToGlobalCoor(bidx,bcoor);
@@ -267,36 +262,6 @@ public:
 	pokeSite(adj(link),_Adag[pp],bcoor);
       }
     }
-#else
-    // Parallel: _Adag[pp](x) = adj( _A[p](x + s_pp) ),  pp = Reverse(p), s_pp = -s_p.
-    // The neighbour fetch reuses the same padded-cell + stencil machinery as Mult,
-    // reading one matrix element per coalesced access so no whole site matrix
-    // (230KB at nbasis=60) ever lands on a GPU thread stack (HIP limit 128KB).
-    // Halo sites compute garbage neighbours; Cell.Extract discards them.
-    // Must run on the unpadded _A, i.e. before ExchangeCoarseLinks.
-    const int Nsimd = CComplex::Nsimd();
-    for(int p=0;p<geom.npoint;p++){
-      int pp = geom.Reverse(p);
-      CoarseMatrix Apad = Cell.ExchangePeriodic(_A[p]);
-      CoarseMatrix Dpad(Apad.Grid());
-      int64_t osites = Apad.Grid()->oSites();
-      {
-	autoView( Apad_v   , Apad, AcceleratorRead);
-	autoView( Dpad_v   , Dpad, AcceleratorWriteDiscard);
-	autoView( Stencil_v, Stencil, AcceleratorRead);
-	accelerator_for(sj, osites*nbasis, Nsimd, {
-	    int32_t ss = sj/nbasis;
-	    int32_t j  = sj%nbasis;
-	    auto SE = Stencil_v.GetEntry(pp,ss);
-	    for(int i=0;i<nbasis;i++){
-	      auto z = coalescedReadGeneralPermute(Apad_v[SE->_offset](i,j),SE->_permute,Nd);
-	      coalescedWrite(Dpad_v[ss](j,i),conjugate(z));
-	    }
-	});
-      }
-      _Adag[pp] = Cell.Extract(Dpad);
-    }
-#endif
   }
   /////////////////////////////////////////////////////////////
   // 
@@ -452,9 +417,10 @@ public:
 	int osites=CoarseGrid()->oSites();
 	autoView( A_v  , _A[k], AcceleratorWrite);
 	autoView( FT_v  , FT[k], AcceleratorRead);
-	accelerator_for(sss, osites, nbasis, {
+	accelerator_for(sss, osites, 1, {
-	    int j = acceleratorSIMTlane(nbasis);
+	    for(int j=0;j<nbasis;j++){
 	      A_v[sss](i,j) = FT_v[sss](j);
+	    }
         });
       }
       tinv+=usecond();
@@ -462,8 +428,8 @@ public:
 
     // Only needed if nonhermitian
     if ( ! hermitian ) {
-      std::cout << GridLogMessage<<"PopulateAdag  "<<std::endl;
+      //      std::cout << GridLogMessage<<"PopulateAdag  "<<std::endl;
-      PopulateAdag();
+      //      PopulateAdag();
     }
 
     // Need to write something to populate Adag from A
@@ -475,20 +441,8 @@ public:
     std::cout << GridLogMessage<<"CoarsenOperator inv    "<<tinv<<" us"<<std::endl;
   }
 #else
-  //////////////////////////////////////////////////////////////////////
-  // Galerkin projection of matrix
-  //////////////////////////////////////////////////////////////////////
   void CoarsenOperator(LinearOperatorBase<Lattice<Fobj> > &linop,
 		       Aggregation<Fobj,CComplex,nbasis> & Subspace)
-  {
-    CoarsenOperator(linop,Subspace,Subspace);
-  }
-  //////////////////////////////////////////////////////////////////////
-  // Petrov - Galerkin projection of matrix
-  //////////////////////////////////////////////////////////////////////
-  void CoarsenOperator(LinearOperatorBase<Lattice<Fobj> > &linop,
-		       Aggregation<Fobj,CComplex,nbasis> & U,
-		       Aggregation<Fobj,CComplex,nbasis> & V)
   {
     std::cout << GridLogMessage<< "GeneralCoarsenMatrix "<< std::endl;
     GridBase *grid = FineGrid();
@@ -504,9 +458,11 @@ public:
     // Orthogonalise the subblocks over the basis
     /////////////////////////////////////////////////////////////
     CoarseScalar InnerProd(CoarseGrid()); 
-    blockOrthogonalise(InnerProd,V.subspace);
+    blockOrthogonalise(InnerProd,Subspace.subspace);
-    blockOrthogonalise(InnerProd,U.subspace);
 
+    //    for(int s=0;s<Subspace.subspace.size();s++){
+      //      std::cout << " subspace norm "<<norm2(Subspace.subspace[s])<<std::endl;
+    //    }
     const int npoint = geom.npoint;
       
     Coordinate clatt = CoarseGrid()->GlobalDimensions();
@@ -551,9 +507,13 @@ public:
     // Now compute the matrix elements of linop between the orthonormal
     // set of vectors.
     ///////////////////////////////////////////////////////////////////////
+    FineField phaV(grid); // Phased block basis vector
+    FineField MphaV(grid);// Matrix applied
     std::vector<FineComplexField> phaF(npoint,grid);
     std::vector<CoarseComplexField> pha(npoint,CoarseGrid());
     
+    CoarseVector coarseInner(CoarseGrid());
+    
     typedef typename CComplex::scalar_type SComplex;
     FineComplexField one(grid); one=SComplex(1.0);
     FineComplexField zz(grid); zz = Zero();
@@ -576,48 +536,33 @@ public:
     }
     tphase+=usecond();
     
-    // Import basis into BLAS layout once; blockProject then reads it once per
-    // basis vector rather than once per (i,p) as in scalar blockProject.
-    // Process all npoint in a single batch.
-    MultiRHSBlockProject<FineField> Projector;
-    Projector.Allocate(nbasis, grid, CoarseGrid());
-    Projector.ImportBasis(U.subspace);
-
-    std::vector<FineField>    phaV_batch(npoint, grid);
-    std::vector<FineField>    MphaV_batch(npoint, grid);
-    std::vector<CoarseVector> proj_batch(npoint, CoarseGrid());
     std::vector<CoarseVector> ComputeProj(npoint,CoarseGrid());
     std::vector<CoarseVector>          FT(npoint,CoarseGrid());
-
-    // Pre-allocate BLAS_F and BLAS_C to avoid repeated hipMalloc/hipFree of
-    // ~5.6 GB per blockProject call, which hangs on ROCm for large allocations.
-    Projector.BLAS_F.resize(Projector.fine_vol * Projector.words * npoint);
-    Projector.BLAS_C.resize(Projector.coarse_vol * nbasis * npoint);
-
     for(int i=0;i<nbasis;i++){// Loop over basis vectors
-      accelerator_barrier(); // ensure prior iteration's async writes are retired
       std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<"/"<<nbasis<< std::endl;
-
+      for(int p=0;p<npoint;p++){ // Loop over momenta in npoint
 	tphaseBZ-=usecond();
-      for(int p=0;p<npoint;p++)
+	phaV = phaF[p]*Subspace.subspace[i];
-	phaV_batch[p] = phaF[p] * V.subspace[i];
 	tphaseBZ+=usecond();
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<" phaseBZ done"<< std::endl;
 
+	/////////////////////////////////////////////////////////////////////
+	// Multiple phased subspace vector by matrix and project to subspace
+	// Remove local bulk phase to leave relative phases
+	/////////////////////////////////////////////////////////////////////
 	tmat-=usecond();
-      for(int p=0;p<npoint;p++)
+	linop.Op(phaV,MphaV);
-	linop.Op(phaV_batch[p], MphaV_batch[p]);
 	tmat+=usecond();
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<" mat done"<< std::endl;
+	//	std::cout << i << " " <<p << " MphaV "<<norm2(MphaV)<<" "<<norm2(phaV)<<std::endl;
 
-      // One batched GEMM reads BLAS_V once for all npoint vectors.
 	tproj-=usecond();
-      Projector.blockProject(MphaV_batch, proj_batch);
+	blockProject(coarseInner,MphaV,Subspace.subspace);
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<" blockProject done"<< std::endl;
+	coarseInner = conjugate(pha[p]) * coarseInner;
-      for(int p=0;p<npoint;p++)
+
-	ComputeProj[p] = conjugate(pha[p]) * proj_batch[p];
+	ComputeProj[p] = coarseInner;
 	tproj+=usecond();
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<" proj done"<< std::endl;
+	//	std::cout << i << " " <<p << " ComputeProj "<<norm2(ComputeProj[p])<<std::endl;
+
+      }
 
       tinv-=usecond();
       for(int k=0;k<npoint;k++){
@@ -629,9 +574,10 @@ public:
 	int osites=CoarseGrid()->oSites();
 	autoView( A_v  , _A[k], AcceleratorWrite);
 	autoView( FT_v  , FT[k], AcceleratorRead);
-	accelerator_for(sss, osites, nbasis, {
+	accelerator_for(sss, osites, 1, {
-	    int j = acceleratorSIMTlane(nbasis);
+	    for(int j=0;j<nbasis;j++){
 	      A_v[sss](i,j) = FT_v[sss](j);
+	    }
         });
       }
       tinv+=usecond();
@@ -639,13 +585,13 @@ public:
 
     // Only needed if nonhermitian
     if ( ! hermitian ) {
-      std::cout << GridLogMessage<<"PopulateAdag  "<<std::endl;
+      //      std::cout << GridLogMessage<<"PopulateAdag  "<<std::endl;
-      PopulateAdag();
+      //      PopulateAdag();
     }
 
-    //    for(int p=0;p<geom.npoint;p++){
+    for(int p=0;p<geom.npoint;p++){
-    //      std::cout << " _A["<<p<<"] "<<norm2(_A[p])<<std::endl;
+      std::cout << " _A["<<p<<"] "<<norm2(_A[p])<<std::endl;
-    //    }
+    }
 
     // Need to write something to populate Adag from A
     ExchangeCoarseLinks();
@@ -660,10 +606,10 @@ public:
   void ExchangeCoarseLinks(void){
     for(int p=0;p<geom.npoint;p++){
       _A[p] = Cell.ExchangePeriodic(_A[p]);
-      if ( !hermitian ) _Adag[p]= Cell.ExchangePeriodic(_Adag[p]);
+      //      _Adag[p]= Cell.ExchangePeriodic(_Adag[p]);
     }
   }
-  virtual  void Mdiag    (const Field &in, Field &out){ GRID_ASSERT(0);};
+  virtual  void Mdiag    (const Field &in, Field &out){ assert(0);};
   virtual  void Mdir     (const Field &in, Field &out,int dir, int disp){assert(0);};
   virtual  void MdirAll  (const Field &in, std::vector<Field> &out){assert(0);};
 };

Grid/algorithms/multigrid/GeneralCoarsenedMatrixMultiRHS.h

@@ -80,12 +80,12 @@ public:
   // Can be used to do I/O on the operator matrices externally
   void SetMatrix (int p,CoarseMatrix & A)
   {
-    GRID_ASSERT(A.size()==geom_srhs.npoint);
+    assert(A.size()==geom_srhs.npoint);
     GridtoBLAS(A[p],BLAS_A[p]);
   }
   void GetMatrix (int p,CoarseMatrix & A)
   {
-    GRID_ASSERT(A.size()==geom_srhs.npoint);
+    assert(A.size()==geom_srhs.npoint);
     BLAStoGrid(A[p],BLAS_A[p]);
   }
   void CopyMatrix (GeneralCoarseOp &_Op)
@@ -178,14 +178,14 @@ public:
 	for(int32_t point = 0 ; point < geom.npoint; point++){
 	  int i=s*orhs*geom.npoint+point;
  	  int32_t nbr = Stencil._entries[i]._offset*CComplex::Nsimd(); // oSite -> lSite
-	  GRID_ASSERT(nbr<BLAS_B.size());
+	  assert(nbr<BLAS_B.size());
 	  ComplexD * ptr = (ComplexD *)&BLAS_B[nbr];
 	  acceleratorPut(BLAS_BP[point][j],ptr); // neighbour indexing in ghost zone volume
 	}
 	j++;
       }
     }
-    GRID_ASSERT(j==unpadded_sites);
+    assert(j==unpadded_sites);
   }
   template<class vobj> void GridtoBLAS(const Lattice<vobj> &from,deviceVector<typename vobj::scalar_object> &to)
   {
@@ -194,7 +194,7 @@ public:
   typedef typename vobj::vector_type vector_type;
 
   GridBase *Fg = from.Grid();
-  GRID_ASSERT(!Fg->_isCheckerBoarded);
+  assert(!Fg->_isCheckerBoarded);
   int nd = Fg->_ndimension;
 
   to.resize(Fg->lSites());
@@ -241,10 +241,10 @@ public:
   typedef typename vobj::vector_type vector_type;
 
   GridBase *Tg = grid.Grid();
-  GRID_ASSERT(!Tg->_isCheckerBoarded);
+  assert(!Tg->_isCheckerBoarded);
   int nd = Tg->_ndimension;
   
-  GRID_ASSERT(in.size()==Tg->lSites());
+  assert(in.size()==Tg->lSites());
 
   Coordinate LocalLatt = Tg->LocalDimensions();
   size_t nsite = 1;
@@ -669,7 +669,7 @@ Grid : Message : 328.193436 s : CoarsenOperator mat    122213270 us
     const int Nsimd = CComplex::Nsimd();
 
     int64_t nrhs  =pin.Grid()->GlobalDimensions()[0];
-    GRID_ASSERT(nrhs>=1);
+    assert(nrhs>=1);
 
     RealD flops,bytes;
     int64_t osites=in.Grid()->oSites(); // unpadded
@@ -721,7 +721,7 @@ Grid : Message : 328.193436 s : CoarsenOperator mat    122213270 us
     //    std::cout << GridLogMessage<<"Coarse overall flops/s "<< flops/t_tot<<" mflop/s"<<std::endl;
     //    std::cout << GridLogMessage<<"Coarse total bytes   "<< bytes/1e6<<" MB"<<std::endl;
   };
-  virtual  void Mdiag    (const Field &in, Field &out){ GRID_ASSERT(0);};
+  virtual  void Mdiag    (const Field &in, Field &out){ assert(0);};
   virtual  void Mdir     (const Field &in, Field &out,int dir, int disp){assert(0);};
   virtual  void MdirAll  (const Field &in, std::vector<Field> &out){assert(0);};
 };

Grid/algorithms/multigrid/Geometry.h

@@ -67,8 +67,8 @@ public:
   }
 
   int point(int dir, int disp) {
-    GRID_ASSERT(disp == -1 || disp == 0 || disp == 1);
+    assert(disp == -1 || disp == 0 || disp == 1);
-    GRID_ASSERT(base+0 <= dir && dir < base+4);
+    assert(base+0 <= dir && dir < base+4);
 
     // directions faster index = new indexing
     // 4d (base = 0):
@@ -131,7 +131,7 @@ public:
 	return p;
       }
     }
-    GRID_ASSERT(0);
+    assert(0);
     return -1;
   }
   void BuildShifts(void)

Grid/allocator/AlignedAllocator.h

@@ -57,7 +57,7 @@ public:
     if ( (_Tp*)ptr == (_Tp *) NULL ) {
       printf("Grid CPU Allocator got NULL for %lu bytes\n",(unsigned long) bytes );
     }
-    GRID_ASSERT( ( (_Tp*)ptr != (_Tp *)NULL ) );
+    assert( ( (_Tp*)ptr != (_Tp *)NULL ) );
     return ptr;
   }
 
@@ -69,7 +69,7 @@ public:
   }
 
   // FIXME: hack for the copy constructor: it must be avoided to avoid single thread loop
-  void construct(pointer __p, const _Tp& __val) { };
+  void construct(pointer __p, const _Tp& __val) { assert(0);};
   void construct(pointer __p) { };
   void destroy(pointer __p) { };
 };
@@ -106,7 +106,7 @@ public:
     if ( (_Tp*)ptr == (_Tp *) NULL ) {
       printf("Grid Shared Allocator got NULL for %lu bytes\n",(unsigned long) bytes );
     }
-    GRID_ASSERT( ( (_Tp*)ptr != (_Tp *)NULL ) );
+    assert( ( (_Tp*)ptr != (_Tp *)NULL ) );
     return ptr;
   }
 
@@ -154,7 +154,7 @@ public:
     if ( (_Tp*)ptr == (_Tp *) NULL ) {
       printf("Grid Device Allocator got NULL for %lu bytes\n",(unsigned long) bytes );
     }
-    GRID_ASSERT( ( (_Tp*)ptr != (_Tp *)NULL ) );
+    assert( ( (_Tp*)ptr != (_Tp *)NULL ) );
     return ptr;
   }
 
@@ -174,10 +174,19 @@ template<typename _Tp>  inline bool operator!=(const devAllocator<_Tp>&, const d
 ////////////////////////////////////////////////////////////////////////////////
 // Template typedefs
 ////////////////////////////////////////////////////////////////////////////////
-template<class T> using hostVector          = std::vector<T,alignedAllocator<T> >;           // Needs autoview
+#ifdef ACCELERATOR_CSHIFT
-template<class T> using Vector              = std::vector<T,uvmAllocator<T> >;               // Really want to deprecate
+// Cshift on device
-template<class T> using uvmVector           = std::vector<T,uvmAllocator<T> >;               // auto migrating page
+template<class T> using cshiftAllocator = devAllocator<T>;
-template<class T> using deviceVector        = std::vector<T,devAllocator<T> >;               // device vector
+#else
+// Cshift on host
+template<class T> using cshiftAllocator = std::allocator<T>;
+#endif
+
+template<class T> using Vector        = std::vector<T,uvmAllocator<T> >;           
+template<class T> using stencilVector = std::vector<T,alignedAllocator<T> >;           
+template<class T> using commVector    = std::vector<T,devAllocator<T> >;
+template<class T> using deviceVector  = std::vector<T,devAllocator<T> >;
+template<class T> using cshiftVector  = std::vector<T,cshiftAllocator<T> >;
 
 /*
 template<class T> class vecView
@@ -188,9 +197,8 @@ template<class T> class vecView
   ViewMode mode;
   void * cpu_ptr;
  public:
-  // Rvalue accessor
   accelerator_inline T & operator[](size_t i) const { return this->data[i]; };
-  vecView(Vector<T> &refer_to_me,ViewMode _mode)
+  vecView(std::vector<T> &refer_to_me,ViewMode _mode)
   {
     cpu_ptr = &refer_to_me[0];
     size = refer_to_me.size();
@@ -206,12 +214,22 @@ template<class T> class vecView
   }
 };
 
-template<class T> vecView<T> VectorView(Vector<T> &vec,ViewMode _mode)
+template<class T> vecView<T> VectorView(std::vector<T> &vec,ViewMode _mode)
 {
   vecView<T> ret(vec,_mode); // does the open
   return ret;                // must be closed
 }
 
+// Little autoscope assister
+template<class View> 
+class VectorViewCloser
+{
+  View v;  // Take a copy of view and call view close when I go out of scope automatically
+ public:
+  VectorViewCloser(View &_v) : v(_v) {};
+  ~VectorViewCloser() { auto ptr = v.cpu_ptr; v.ViewClose();  MemoryManager::NotifyDeletion(ptr);}
+};
+
 #define autoVecView(v_v,v,mode)					\
   auto v_v = VectorView(v,mode);				\
   ViewCloser<decltype(v_v)> _autoView##v_v(v_v);

Grid/allocator/MemoryManager.cc

@@ -63,10 +63,12 @@ void MemoryManager::PrintBytes(void)
   std::cout << " MemoryManager : "<<(total_device>>20)<<" accelerator Mbytes "<<std::endl;
   std::cout << " MemoryManager : "<<(total_host>>20)  <<" cpu         Mbytes "<<std::endl;
   uint64_t cacheBytes;
-  cacheBytes = HostCacheBytes();
+  cacheBytes = CacheBytes[Cpu];
-  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" cpu alloc cache Mbytes "<<std::endl;
+  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" cpu cache Mbytes "<<std::endl;
-  cacheBytes = DeviceCacheBytes();
+  cacheBytes = CacheBytes[Acc];
-  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" acc alloc cache Mbytes "<<std::endl;
+  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" acc cache Mbytes "<<std::endl;
+  cacheBytes = CacheBytes[Shared];
+  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" shared cache Mbytes "<<std::endl;
   
 #ifdef GRID_CUDA
   cuda_mem();
@@ -290,7 +292,7 @@ void *MemoryManager::Insert(void *ptr,size_t bytes,int type)
 void *MemoryManager::Insert(void *ptr,size_t bytes,AllocationCacheEntry *entries,int ncache,int &victim, uint64_t &cacheBytes) 
 {
 #ifdef GRID_OMP
-  GRID_ASSERT(omp_in_parallel()==0);
+  assert(omp_in_parallel()==0);
 #endif 
 
   if (ncache == 0) return ptr;
@@ -343,7 +345,7 @@ void *MemoryManager::Lookup(size_t bytes,int type)
 void *MemoryManager::Lookup(size_t bytes,AllocationCacheEntry *entries,int ncache,uint64_t & cacheBytes) 
 {
 #ifdef GRID_OMP
-  GRID_ASSERT(omp_in_parallel()==0);
+  assert(omp_in_parallel()==0);
 #endif 
   for(int e=0;e<ncache;e++){
     if ( entries[e].valid && ( entries[e].bytes == bytes ) ) {

Grid/allocator/MemoryManager.h

@@ -215,7 +215,6 @@ public:
   static void NotifyDeletion(void * CpuPtr);
   static void Print(void);
   static void PrintAll(void);
-  static void EvictAll(void);
   static void PrintState( void* CpuPtr);
   static int   isOpen   (void* CpuPtr);
   static void  ViewClose(void* CpuPtr,ViewMode mode);

Grid/allocator/MemoryManagerCache.cc

@@ -1,15 +1,16 @@
 #include <Grid/GridCore.h>
 #ifndef GRID_UVM
 
+#warning "Using explicit device memory copies"
 NAMESPACE_BEGIN(Grid);
 
 #define MAXLINE 512
 static char print_buffer [ MAXLINE ];
 
-#define mprintf(...) snprintf (print_buffer,MAXLINE, __VA_ARGS__ ); std::cout << GridLogMemory << print_buffer << std::endl;
+#define mprintf(...) snprintf (print_buffer,MAXLINE, __VA_ARGS__ ); std::cout << GridLogMemory << print_buffer;
-#define dprintf(...) snprintf (print_buffer,MAXLINE, __VA_ARGS__ ); std::cout << GridLogDebug  << print_buffer << std::endl;
+#define dprintf(...) snprintf (print_buffer,MAXLINE, __VA_ARGS__ ); std::cout << GridLogDebug << print_buffer;
 //#define dprintf(...) 
-//#define mprintf(...) 
+
 
 ////////////////////////////////////////////////////////////
 // For caching copies of data on device
@@ -50,12 +51,12 @@ int   MemoryManager::EntryPresent(uint64_t CpuPtr)
 {
   if(AccViewTable.empty()) return 0;
 
-  auto count = AccViewTable.count(CpuPtr);  GRID_ASSERT((count==0)||(count==1));
+  auto count = AccViewTable.count(CpuPtr);  assert((count==0)||(count==1));
   return count;
 }
 void  MemoryManager::EntryCreate(uint64_t CpuPtr,size_t bytes,ViewMode mode,ViewAdvise hint)
 {
-  GRID_ASSERT(!EntryPresent(CpuPtr));
+  assert(!EntryPresent(CpuPtr));
   AcceleratorViewEntry AccCache;
   AccCache.CpuPtr = CpuPtr;
   AccCache.AccPtr = (uint64_t)NULL;
@@ -69,9 +70,9 @@ void  MemoryManager::EntryCreate(uint64_t CpuPtr,size_t bytes,ViewMode mode,View
 }
 MemoryManager::AccViewTableIterator MemoryManager::EntryLookup(uint64_t CpuPtr)
 {
-  GRID_ASSERT(EntryPresent(CpuPtr));
+  assert(EntryPresent(CpuPtr));
   auto AccCacheIterator = AccViewTable.find(CpuPtr);
-  GRID_ASSERT(AccCacheIterator!=AccViewTable.end());
+  assert(AccCacheIterator!=AccViewTable.end());
   return AccCacheIterator;
 }
 void MemoryManager::EntryErase(uint64_t CpuPtr)
@@ -79,28 +80,9 @@ void MemoryManager::EntryErase(uint64_t CpuPtr)
   auto AccCache = EntryLookup(CpuPtr);
   AccViewTable.erase(CpuPtr);
 }
-/////////////////////////////////////////////////////////////////////////////////
-// LRU membership invariant:
-//
-//    LRU_valid == 1   <=>   AccPtr != NULL  &&  accLock == 0  &&  cpuLock == 0
-//
-// i.e. the LRU queue contains exactly the device-resident, completely unlocked
-// entries -- the evictable set.  Membership is maintained EAGERLY at the lock
-// 0<->1 edges, O(1) via the stored LRU_entry iterator:
-//
-//    AcceleratorViewOpen   lock 0->1 : LRUremove   (gated on LRU_valid)
-//    AcceleratorViewClose  accLock->0: LRUinsert   (AccPtr necessarily exists)
-//    CpuViewOpen           lock 0->1 : LRUremove   (gated on LRU_valid)
-//    CpuViewClose          cpuLock->0: LRUinsert   (iff AccPtr exists)
-//    Evict/AccDiscard                : LRUremove   (frees the device copy)
-//
-// Consequences: victims taken from LRU.back() are evictable by construction;
-// Evict() on a locked entry is an invariant violation (asserted), and the
-// eviction loops (EvictVictims/EvictAll) cannot spin.
-/////////////////////////////////////////////////////////////////////////////////
 void  MemoryManager::LRUinsert(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.LRU_valid==0);
+  assert(AccCache.LRU_valid==0);
   if (AccCache.transient) { 
     LRU.push_back(AccCache.CpuPtr);
     AccCache.LRU_entry = --LRU.end();
@@ -113,7 +95,7 @@ void  MemoryManager::LRUinsert(AcceleratorViewEntry &AccCache)
 }
 void  MemoryManager::LRUremove(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.LRU_valid==1);
+  assert(AccCache.LRU_valid==1);
   LRU.erase(AccCache.LRU_entry);
   AccCache.LRU_valid = 0;
   DeviceLRUBytes-=AccCache.bytes;
@@ -127,19 +109,19 @@ void MemoryManager::AccDiscard(AcceleratorViewEntry &AccCache)
   // Remove from Accelerator, remove entry, without flush
   // Cannot be locked. If allocated Must be in LRU pool.
   ///////////////////////////////////////////////////////////
-  GRID_ASSERT(AccCache.state!=Empty);
+  assert(AccCache.state!=Empty);
   
-  dprintf("MemoryManager: Discard(%lx) %lx",(uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr); 
+  dprintf("MemoryManager: Discard(%lx) %lx\n",(uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr); 
-  GRID_ASSERT(AccCache.accLock==0);
+  assert(AccCache.accLock==0);
-  GRID_ASSERT(AccCache.cpuLock==0);
+  assert(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.CpuPtr!=(uint64_t)NULL);
+  assert(AccCache.CpuPtr!=(uint64_t)NULL);
   if(AccCache.AccPtr) {
     AcceleratorFree((void *)AccCache.AccPtr,AccCache.bytes);
     DeviceDestroy++;
     DeviceBytes   -=AccCache.bytes;
     LRUremove(AccCache);
     AccCache.AccPtr=(uint64_t) NULL;
-    dprintf("MemoryManager: Free(%lx) LRU %ld Total %ld",(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);
@@ -149,21 +131,21 @@ void MemoryManager::Evict(AcceleratorViewEntry &AccCache)
 {
   ///////////////////////////////////////////////////////////////////////////
   // Make CPU consistent, remove from Accelerator, remove from LRU, LEAVE CPU only entry
-  // Cannot be locked. If allocated must be in LRU pool.
+  // Cannot be acclocked. If allocated must be in LRU pool.
   //
-  // (Historical: a Nov 2022 incident (two CpuPtrs; eviction called from
+  // Nov 2022... Felix issue: Allocating two CpuPtrs, can have an entry in LRU-q with CPUlock.
-  //  CpuViewOpen -- since excised) could present a cpuLocked entry here, and
+  //                          and require to evict the AccPtr copy. Eviction was a mistake in CpuViewOpen
-  //  silent-return guards were added.  The LRU membership invariant (see
+  //                          but there is a weakness where CpuLock entries are attempted for erase
-  //  LRUinsert) now excludes ALL locked entries from the queue eagerly at the
+  //                          Take these OUT LRU queue when CPU locked?
-  //  lock edges, so a locked victim is an invariant violation: asserted.)
+  //                          Cannot take out the table as cpuLock data is important.
   ///////////////////////////////////////////////////////////////////////////
-  GRID_ASSERT(AccCache.state!=Empty);
+  assert(AccCache.state!=Empty);
   
-  mprintf("MemoryManager: Evict CpuPtr %lx AccPtr %lx cpuLock %ld accLock %ld",
+  mprintf("MemoryManager: Evict CpuPtr %lx AccPtr %lx cpuLock %ld accLock %ld\n",
 	  (uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr,
 	  (uint64_t)AccCache.cpuLock,(uint64_t)AccCache.accLock); 
-  GRID_ASSERT(AccCache.accLock==0);
+  if (AccCache.accLock!=0) return;
-  GRID_ASSERT(AccCache.cpuLock==0);
+  if (AccCache.cpuLock!=0) return;
   if(AccCache.state==AccDirty) {
     Flush(AccCache);
   }
@@ -173,7 +155,7 @@ void MemoryManager::Evict(AcceleratorViewEntry &AccCache)
     AccCache.AccPtr=(uint64_t)NULL;
     AccCache.state=CpuDirty; // CPU primary now
     DeviceBytes   -=AccCache.bytes;
-    dprintf("MemoryManager: Free(AccPtr %lx) footprint now %ld ",(uint64_t)AccCache.AccPtr,DeviceBytes);  
+    dprintf("MemoryManager: Free(AccPtr %lx) footprint now %ld \n",(uint64_t)AccCache.AccPtr,DeviceBytes);  
   }
   //  uint64_t CpuPtr = AccCache.CpuPtr;
   DeviceEvictions++;
@@ -181,30 +163,28 @@ void MemoryManager::Evict(AcceleratorViewEntry &AccCache)
 }
 void MemoryManager::Flush(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.state==AccDirty);
+  assert(AccCache.state==AccDirty);
-  GRID_ASSERT(AccCache.cpuLock==0);
+  assert(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.accLock==0);
+  assert(AccCache.accLock==0);
-  GRID_ASSERT(AccCache.AccPtr!=(uint64_t)NULL);
+  assert(AccCache.AccPtr!=(uint64_t)NULL);
-  GRID_ASSERT(AccCache.CpuPtr!=(uint64_t)NULL);
+  assert(AccCache.CpuPtr!=(uint64_t)NULL);
   acceleratorCopyFromDevice((void *)AccCache.AccPtr,(void *)AccCache.CpuPtr,AccCache.bytes);
-  mprintf("MemoryManager: acceleratorCopyFromDevice Flush size %ld AccPtr %lx -> CpuPtr %lx",(uint64_t)AccCache.bytes,(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
+  mprintf("MemoryManager: acceleratorCopyFromDevice Flush AccPtr %lx -> CpuPtr %lx\n",(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
   DeviceToHostBytes+=AccCache.bytes;
   DeviceToHostXfer++;
   AccCache.state=Consistent;
 }
 void MemoryManager::Clone(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.state==CpuDirty);
+  assert(AccCache.state==CpuDirty);
-  GRID_ASSERT(AccCache.cpuLock==0);
+  assert(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.accLock==0);
+  assert(AccCache.accLock==0);
-  GRID_ASSERT(AccCache.CpuPtr!=(uint64_t)NULL);
+  assert(AccCache.CpuPtr!=(uint64_t)NULL);
   if(AccCache.AccPtr==(uint64_t)NULL){
     AccCache.AccPtr=(uint64_t)AcceleratorAllocate(AccCache.bytes);
     DeviceBytes+=AccCache.bytes;
   }
-  mprintf("MemoryManager: acceleratorCopyToDevice   Clone size %ld AccPtr %lx <- CpuPtr %lx",
+  mprintf("MemoryManager: acceleratorCopyToDevice   Clone AccPtr %lx <- CpuPtr %lx\n",(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
-	  (uint64_t)AccCache.bytes,
-	  (uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
   acceleratorCopyToDevice((void *)AccCache.CpuPtr,(void *)AccCache.AccPtr,AccCache.bytes);
   HostToDeviceBytes+=AccCache.bytes;
   HostToDeviceXfer++;
@@ -213,10 +193,10 @@ void MemoryManager::Clone(AcceleratorViewEntry &AccCache)
 
 void MemoryManager::CpuDiscard(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.state!=Empty);
+  assert(AccCache.state!=Empty);
-  GRID_ASSERT(AccCache.cpuLock==0);
+  assert(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.accLock==0);
+  assert(AccCache.accLock==0);
-  GRID_ASSERT(AccCache.CpuPtr!=(uint64_t)NULL);
+  assert(AccCache.CpuPtr!=(uint64_t)NULL);
   if(AccCache.AccPtr==(uint64_t)NULL){
     AccCache.AccPtr=(uint64_t)AcceleratorAllocate(AccCache.bytes);
     DeviceBytes+=AccCache.bytes;
@@ -230,49 +210,33 @@ void MemoryManager::CpuDiscard(AcceleratorViewEntry &AccCache)
 void MemoryManager::ViewClose(void* Ptr,ViewMode mode)
 {
   if( (mode==AcceleratorRead)||(mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard) ){
-    dprintf("AcceleratorViewClose %lx",(uint64_t)Ptr);
+    dprintf("AcceleratorViewClose %lx\n",(uint64_t)Ptr);
     AcceleratorViewClose((uint64_t)Ptr);
   } else if( (mode==CpuRead)||(mode==CpuWrite)){
     CpuViewClose((uint64_t)Ptr);
   } else { 
-    GRID_ASSERT(0);
+    assert(0);
   }
 }
 void *MemoryManager::ViewOpen(void* _CpuPtr,size_t bytes,ViewMode mode,ViewAdvise hint)
 {
   uint64_t CpuPtr = (uint64_t)_CpuPtr;
   if( (mode==AcceleratorRead)||(mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard) ){
-    dprintf("AcceleratorViewOpen %lx",(uint64_t)CpuPtr);
+    dprintf("AcceleratorViewOpen %lx\n",(uint64_t)CpuPtr);
     return (void *) AcceleratorViewOpen(CpuPtr,bytes,mode,hint);
   } else if( (mode==CpuRead)||(mode==CpuWrite)){
     return (void *)CpuViewOpen(CpuPtr,bytes,mode,hint);
   } else { 
-    GRID_ASSERT(0);
+    assert(0);
     return NULL;
   }
 }
 void  MemoryManager::EvictVictims(uint64_t bytes)
 {
-  if(bytes>=DeviceMaxBytes) {
+  assert(bytes<DeviceMaxBytes);
-    printf("EvictVictims bytes %ld DeviceMaxBytes %ld\n",bytes,DeviceMaxBytes);
-  }
-  GRID_ASSERT(bytes<DeviceMaxBytes);
   while(bytes+DeviceLRUBytes > DeviceMaxBytes){
     if ( DeviceLRUBytes > 0){
-      GRID_ASSERT(LRU.size()>0);
+      assert(LRU.size()>0);
-      uint64_t victim = LRU.back(); // From the LRU
-      auto AccCacheIterator = EntryLookup(victim);
-      auto & AccCache = AccCacheIterator->second;
-      Evict(AccCache);
-    } else {
-      return;
-    }
-  }
-}
-void  MemoryManager::EvictAll(void)
-{
-  while(LRU.size()>0){
-    if ( DeviceLRUBytes > 0){
       uint64_t victim = LRU.back(); // From the LRU
       auto AccCacheIterator = EntryLookup(victim);
       auto & AccCache = AccCacheIterator->second;
@@ -296,19 +260,19 @@ uint64_t MemoryManager::AcceleratorViewOpen(uint64_t CpuPtr,size_t bytes,ViewMod
   if (!AccCache.AccPtr) {
     EvictVictims(bytes); 
   } 
-  GRID_ASSERT((mode==AcceleratorRead)||(mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard));
+  assert((mode==AcceleratorRead)||(mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard));
 
-  GRID_ASSERT(AccCache.cpuLock==0);  // Programming error
+  assert(AccCache.cpuLock==0);  // Programming error
 
   if(AccCache.state!=Empty) {
-    dprintf("ViewOpen found entry %lx %lx : sizes %ld %ld accLock %ld",
+    dprintf("ViewOpen found entry %lx %lx : %ld %ld accLock %ld\n",
 		    (uint64_t)AccCache.CpuPtr,
 		    (uint64_t)CpuPtr,
 		    (uint64_t)AccCache.bytes,
 	            (uint64_t)bytes,
 		    (uint64_t)AccCache.accLock);
-    GRID_ASSERT(AccCache.CpuPtr == CpuPtr);
+    assert(AccCache.CpuPtr == CpuPtr);
-    GRID_ASSERT(AccCache.bytes  ==bytes);
+    assert(AccCache.bytes  ==bytes);
   }
 /*
  *  State transitions and actions
@@ -325,7 +289,7 @@ uint64_t MemoryManager::AcceleratorViewOpen(uint64_t CpuPtr,size_t bytes,ViewMod
  *  AccWrite AccDirty   AccDirty       -        - 
  */
   if(AccCache.state==Empty) {
-    GRID_ASSERT(AccCache.LRU_valid==0);
+    assert(AccCache.LRU_valid==0);
     AccCache.CpuPtr = CpuPtr;
     AccCache.AccPtr = (uint64_t)NULL;
     AccCache.bytes  = bytes;
@@ -341,7 +305,7 @@ uint64_t MemoryManager::AcceleratorViewOpen(uint64_t CpuPtr,size_t bytes,ViewMod
       AccCache.state  = Consistent; // Empty + AccRead => Consistent
     }
     AccCache.accLock= 1;
-    dprintf("Copied Empty entry into device accLock= %d",AccCache.accLock);
+    dprintf("Copied Empty entry into device accLock= %d\n",AccCache.accLock);
   } else if(AccCache.state==CpuDirty ){
     if(mode==AcceleratorWriteDiscard) {
       CpuDiscard(AccCache);
@@ -354,30 +318,30 @@ uint64_t MemoryManager::AcceleratorViewOpen(uint64_t CpuPtr,size_t bytes,ViewMod
       AccCache.state  = Consistent; // CpuDirty + AccRead => Consistent
     }
     AccCache.accLock++;
-    dprintf("CpuDirty entry into device ++accLock= %d",AccCache.accLock);
+    dprintf("CpuDirty entry into device ++accLock= %d\n",AccCache.accLock);
   } else if(AccCache.state==Consistent) {
     if((mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard))
       AccCache.state  = AccDirty;   // Consistent + AcceleratorWrite=> AccDirty
     else
       AccCache.state  = Consistent; // Consistent + AccRead => Consistent
     AccCache.accLock++;
-    dprintf("Consistent entry into device ++accLock= %d",AccCache.accLock);
+    dprintf("Consistent entry into device ++accLock= %d\n",AccCache.accLock);
   } else if(AccCache.state==AccDirty) {
     if((mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard))
       AccCache.state  = AccDirty; // AccDirty + AcceleratorWrite=> AccDirty
     else
       AccCache.state  = AccDirty; // AccDirty + AccRead => AccDirty
     AccCache.accLock++;
-    dprintf("AccDirty entry ++accLock= %d",AccCache.accLock);
+    dprintf("AccDirty entry ++accLock= %d\n",AccCache.accLock);
   } else {
-    GRID_ASSERT(0);
+    assert(0);
   }
 
-  GRID_ASSERT(AccCache.accLock>0);
+  assert(AccCache.accLock>0);
   // If view is opened on device must remove from LRU
   if(AccCache.LRU_valid==1){
     // must possibly remove from LRU as now locked on GPU
-    dprintf("AccCache entry removed from LRU ");
+    dprintf("AccCache entry removed from LRU \n");
     LRUremove(AccCache);
   }
 
@@ -394,16 +358,16 @@ void MemoryManager::AcceleratorViewClose(uint64_t CpuPtr)
   auto AccCacheIterator = EntryLookup(CpuPtr);
   auto & AccCache = AccCacheIterator->second;
 
-  GRID_ASSERT(AccCache.cpuLock==0);
+  assert(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.accLock>0);
+  assert(AccCache.accLock>0);
 
   AccCache.accLock--;
   // Move to LRU queue if not locked and close on device
   if(AccCache.accLock==0) {
-    dprintf("AccleratorViewClose %lx AccLock decremented to %ld move to LRU queue",(uint64_t)CpuPtr,(uint64_t)AccCache.accLock);
+    dprintf("AccleratorViewClose %lx AccLock decremented to %ld move to LRU queue\n",(uint64_t)CpuPtr,(uint64_t)AccCache.accLock);
     LRUinsert(AccCache);
   } else {
-    dprintf("AccleratorViewClose %lx AccLock decremented to %ld",(uint64_t)CpuPtr,(uint64_t)AccCache.accLock);
+    dprintf("AccleratorViewClose %lx AccLock decremented to %ld\n",(uint64_t)CpuPtr,(uint64_t)AccCache.accLock);
   }
 }
 void MemoryManager::CpuViewClose(uint64_t CpuPtr)
@@ -411,17 +375,10 @@ void MemoryManager::CpuViewClose(uint64_t CpuPtr)
   auto AccCacheIterator = EntryLookup(CpuPtr);
   auto & AccCache = AccCacheIterator->second;
 
-  GRID_ASSERT(AccCache.cpuLock>0);
+  assert(AccCache.cpuLock>0);
-  GRID_ASSERT(AccCache.accLock==0);
+  assert(AccCache.accLock==0);
 
   AccCache.cpuLock--;
-  // Return to LRU queue when fully unlocked -- mirrors AcceleratorViewClose.
-  // Asymmetry vs the Acc side: a device copy need not exist for a host view;
-  // only device-resident entries belong in the (evictable) LRU queue.
-  if( (AccCache.cpuLock==0) && (AccCache.AccPtr!=(uint64_t)NULL) ) {
-    dprintf("CpuViewClose %lx cpuLock decremented to zero, move to LRU queue",(uint64_t)CpuPtr);
-    LRUinsert(AccCache);
-  }
 }
 /*
  *  Action  State   StateNext         Flush    Clone
@@ -452,12 +409,12 @@ uint64_t MemoryManager::CpuViewOpen(uint64_t CpuPtr,size_t bytes,ViewMode mode,V
   //    EvictVictims(bytes);
   //  }
 
-  GRID_ASSERT((mode==CpuRead)||(mode==CpuWrite));
+  assert((mode==CpuRead)||(mode==CpuWrite));
-  GRID_ASSERT(AccCache.accLock==0);  // Programming error
+  assert(AccCache.accLock==0);  // Programming error
 
   if(AccCache.state!=Empty) {
-    GRID_ASSERT(AccCache.CpuPtr == CpuPtr);
+    assert(AccCache.CpuPtr == CpuPtr);
-    GRID_ASSERT(AccCache.bytes==bytes);
+    assert(AccCache.bytes==bytes);
   }
 
   if(AccCache.state==Empty) {
@@ -472,28 +429,20 @@ uint64_t MemoryManager::CpuViewOpen(uint64_t CpuPtr,size_t bytes,ViewMode mode,V
     AccCache.state = CpuDirty; // CpuDirty +CpuRead/CpuWrite => CpuDirty
     AccCache.cpuLock++;
   } else if(AccCache.state==Consistent) {
-    GRID_ASSERT(AccCache.AccPtr != (uint64_t)NULL);
+    assert(AccCache.AccPtr != (uint64_t)NULL);
     if(mode==CpuWrite)
       AccCache.state = CpuDirty;   // Consistent +CpuWrite => CpuDirty
     else 
       AccCache.state = Consistent; // Consistent +CpuRead  => Consistent
     AccCache.cpuLock++;
   } else if(AccCache.state==AccDirty) {
-    GRID_ASSERT(AccCache.AccPtr != (uint64_t)NULL);
+    assert(AccCache.AccPtr != (uint64_t)NULL);
     Flush(AccCache);
     if(mode==CpuWrite) AccCache.state = CpuDirty;   // AccDirty +CpuWrite => CpuDirty, Flush
     else            AccCache.state = Consistent; // AccDirty +CpuRead  => Consistent, Flush
     AccCache.cpuLock++;
   } else {
-    GRID_ASSERT(0); // should be unreachable
+    assert(0); // should be unreachable
-  }
-
-  GRID_ASSERT(AccCache.cpuLock>0);
-  // If view is opened on host must remove from LRU -- mirrors AcceleratorViewOpen.
-  // LRU_valid==1 here implies this is the 0->1 lock edge of a device-resident entry.
-  if(AccCache.LRU_valid==1){
-    dprintf("CpuViewOpen: entry removed from LRU ");
-    LRUremove(AccCache);
   }
 
   AccCache.transient= transient? EvictNext : 0;
@@ -575,12 +524,12 @@ void MemoryManager::Audit(std::string s)
   std::cout << " Memory Manager::Audit() from "<<s<<std::endl;
   for(auto it=LRU.begin();it!=LRU.end();it++){
     uint64_t cpuPtr = *it;
-    GRID_ASSERT(EntryPresent(cpuPtr));
+    assert(EntryPresent(cpuPtr));
     auto AccCacheIterator = EntryLookup(cpuPtr);
     auto & AccCache = AccCacheIterator->second;
     LruBytes2+=AccCache.bytes;
-    GRID_ASSERT(AccCache.LRU_valid==1);
+    assert(AccCache.LRU_valid==1);
-    GRID_ASSERT(AccCache.LRU_entry==it);
+    assert(AccCache.LRU_entry==it);
   }
   std::cout << " Memory Manager::Audit() LRU queue matches table entries "<<std::endl;
 
@@ -599,7 +548,7 @@ void MemoryManager::Audit(std::string s)
     if( AccCache.LRU_valid ) LruCnt++;
     
     if ( AccCache.cpuLock || AccCache.accLock ) {
-      GRID_ASSERT(AccCache.LRU_valid==0);
+      assert(AccCache.LRU_valid==0);
 
       std::cout << GridLogError << s<< "\n\t 0x"<<std::hex<<AccCache.CpuPtr<<std::dec
 		<< "\t0x"<<std::hex<<AccCache.AccPtr<<std::dec<<"\t" <<str
@@ -608,16 +557,16 @@ void MemoryManager::Audit(std::string s)
 		<< "\t LRUvalid " << AccCache.LRU_valid<<std::endl;
     }
 
-    GRID_ASSERT( AccCache.cpuLock== 0 ) ;
+    assert( AccCache.cpuLock== 0 ) ;
-    GRID_ASSERT( AccCache.accLock== 0 ) ;
+    assert( AccCache.accLock== 0 ) ;
   }
   std::cout << " Memory Manager::Audit() no locked table entries "<<std::endl;
-  GRID_ASSERT(LruBytes1==LruBytes2);
+  assert(LruBytes1==LruBytes2);
-  GRID_ASSERT(LruBytes1==DeviceLRUBytes);
+  assert(LruBytes1==DeviceLRUBytes);
   std::cout << " Memory Manager::Audit() evictable bytes matches sum over table "<<std::endl;
-  GRID_ASSERT(AccBytes==DeviceBytes);
+  assert(AccBytes==DeviceBytes);
   std::cout << " Memory Manager::Audit() device bytes matches sum over table "<<std::endl;
-  GRID_ASSERT(LruCnt == LRU.size());
+  assert(LruCnt == LRU.size());
   std::cout << " Memory Manager::Audit() LRU entry count matches "<<std::endl;
 
 }

Grid/allocator/MemoryStats.cc

@@ -10,16 +10,16 @@ void check_huge_pages(void *Buf,uint64_t BYTES)
 {
 #ifdef __linux__
   int fd = open("/proc/self/pagemap", O_RDONLY);
-  GRID_ASSERT(fd >= 0);
+  assert(fd >= 0);
   const int page_size = 4096;
   uint64_t virt_pfn = (uint64_t)Buf / page_size;
   off_t offset = sizeof(uint64_t) * virt_pfn;
   uint64_t npages = (BYTES + page_size-1) / page_size;
-  std::vector<uint64_t> pagedata(npages);
+  uint64_t pagedata[npages];
   uint64_t ret = lseek(fd, offset, SEEK_SET);
-  GRID_ASSERT(ret == offset);
+  assert(ret == offset);
-  ret = ::read(fd, &pagedata[0], sizeof(uint64_t)*npages);
+  ret = ::read(fd, pagedata, sizeof(uint64_t)*npages);
-  GRID_ASSERT(ret == sizeof(uint64_t) * npages);
+  assert(ret == sizeof(uint64_t) * npages);
   int nhugepages = npages / 512;
   int n4ktotal, nnothuge;
   n4ktotal = 0;

Grid/cartesian/Cartesian_base.h

@@ -165,7 +165,7 @@ public:
     //
     if ( _simd_layout[dimension] > 2 ) { 
       for(int d=0;d<_ndimension;d++){
-	if ( d != dimension ) GRID_ASSERT ( (_simd_layout[d]==1)  );
+	if ( d != dimension ) assert ( (_simd_layout[d]==1)  );
       }
       permute_type = RotateBit; // How to specify distance; this is not just direction.
       return permute_type;
@@ -187,7 +187,7 @@ public:
   inline int64_t gSites(void) const { return (int64_t)_isites*(int64_t)_osites*(int64_t)_Nprocessors; }; 
   inline int Nd    (void) const { return _ndimension;};
 
-  inline const Coordinate &LocalStarts(void)            { return _lstart;    };
+  inline const Coordinate LocalStarts(void)             { return _lstart;    };
   inline const Coordinate &FullDimensions(void)         { return _fdimensions;};
   inline const Coordinate &GlobalDimensions(void)       { return _gdimensions;};
   inline const Coordinate &LocalDimensions(void)        { return _ldimensions;};
@@ -216,11 +216,11 @@ public:
   // Global addressing
   ////////////////////////////////////////////////////////////////
   void GlobalIndexToGlobalCoor(int64_t gidx,Coordinate &gcoor){
-    GRID_ASSERT(gidx< gSites());
+    assert(gidx< gSites());
     Lexicographic::CoorFromIndex(gcoor,gidx,_gdimensions);
   }
   void LocalIndexToLocalCoor(int lidx,Coordinate &lcoor){
-    GRID_ASSERT(lidx<lSites());
+    assert(lidx<lSites());
     Lexicographic::CoorFromIndex(lcoor,lidx,_ldimensions);
   }
   void GlobalCoorToGlobalIndex(const Coordinate & gcoor,int64_t & gidx){

Grid/cartesian/Cartesian_full.h

@@ -128,10 +128,10 @@ public:
         // Use a reduced simd grid
         _ldimensions[d] = _gdimensions[d] / _processors[d]; //local dimensions
         //std::cout << _ldimensions[d] << "  " << _gdimensions[d] << "  " << _processors[d] << std::endl;
-        GRID_ASSERT(_ldimensions[d] * _processors[d] == _gdimensions[d]);
+        assert(_ldimensions[d] * _processors[d] == _gdimensions[d]);
 
         _rdimensions[d] = _ldimensions[d] / _simd_layout[d]; //overdecomposition
-        GRID_ASSERT(_rdimensions[d] * _simd_layout[d] == _ldimensions[d]);
+        assert(_rdimensions[d] * _simd_layout[d] == _ldimensions[d]);
 
         _lstart[d] = _processor_coor[d] * _ldimensions[d];
         _lend[d] = _processor_coor[d] * _ldimensions[d] + _ldimensions[d] - 1;

Grid/cartesian/Cartesian_red_black.h

@@ -67,7 +67,7 @@ public:
   }
   virtual int CheckerBoard(const Coordinate &site){
     int linear=0;
-    GRID_ASSERT(site.size()==_ndimension);
+    assert(site.size()==_ndimension);
     for(int d=0;d<_ndimension;d++){ 
       if(_checker_dim_mask[d])
 	linear=linear+site[d];
@@ -160,11 +160,11 @@ public:
 
       _isCheckerBoarded = true;
     _checker_dim = checker_dim;
-    GRID_ASSERT(checker_dim_mask[checker_dim] == 1);
+    assert(checker_dim_mask[checker_dim] == 1);
     _ndimension = dimensions.size();
-    GRID_ASSERT(checker_dim_mask.size() == _ndimension);
+    assert(checker_dim_mask.size() == _ndimension);
-    GRID_ASSERT(processor_grid.size() == _ndimension);
+    assert(processor_grid.size() == _ndimension);
-    GRID_ASSERT(simd_layout.size() == _ndimension);
+    assert(simd_layout.size() == _ndimension);
 
     _fdimensions.resize(_ndimension);
     _gdimensions.resize(_ndimension);
@@ -190,20 +190,20 @@ public:
 
         if (d == _checker_dim)
 	  {
-	    GRID_ASSERT((_gdimensions[d] & 0x1) == 0);
+	    assert((_gdimensions[d] & 0x1) == 0);
 	    _gdimensions[d] = _gdimensions[d] / 2; // Remove a checkerboard
 	    _gsites /= 2;
 	  }
         _ldimensions[d] = _gdimensions[d] / _processors[d];
-        GRID_ASSERT(_ldimensions[d] * _processors[d] == _gdimensions[d]);
+        assert(_ldimensions[d] * _processors[d] == _gdimensions[d]);
         _lstart[d] = _processor_coor[d] * _ldimensions[d];
         _lend[d] = _processor_coor[d] * _ldimensions[d] + _ldimensions[d] - 1;
 
         // Use a reduced simd grid
         _simd_layout[d] = simd_layout[d];
         _rdimensions[d] = _ldimensions[d] / _simd_layout[d]; // this is not checking if this is integer
-        GRID_ASSERT(_rdimensions[d] * _simd_layout[d] == _ldimensions[d]);
+        assert(_rdimensions[d] * _simd_layout[d] == _ldimensions[d]);
-        GRID_ASSERT(_rdimensions[d] > 0);
+        assert(_rdimensions[d] > 0);
 
         // all elements of a simd vector must have same checkerboard.
         // If Ls vectorised, this must still be the case; e.g. dwf rb5d

Grid/communicator/Communicator_base.cc

@@ -57,29 +57,18 @@ int                      CartesianCommunicator::ProcessorCount(void)    { return
 // very VERY rarely (Log, serial RNG) we need world without a grid
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifdef USE_GRID_REDUCTION
-void CartesianCommunicator::GlobalSum(ComplexF &c)
-{
-  GlobalSumP2P(c);
-}
-void CartesianCommunicator::GlobalSum(ComplexD &c)
-{
-  GlobalSumP2P(c);
-}
-#else
 void CartesianCommunicator::GlobalSum(ComplexF &c)
 {
   GlobalSumVector((float *)&c,2);
 }
-void CartesianCommunicator::GlobalSum(ComplexD &c)
-{
-  GlobalSumVector((double *)&c,2);
-}
-#endif
 void CartesianCommunicator::GlobalSumVector(ComplexF *c,int N)
 {
   GlobalSumVector((float *)c,2*N);
 }
+void CartesianCommunicator::GlobalSum(ComplexD &c)
+{
+  GlobalSumVector((double *)&c,2);
+}
 void CartesianCommunicator::GlobalSumVector(ComplexD *c,int N)
 {
   GlobalSumVector((double *)c,2*N);

Grid/communicator/Communicator_base.h

@@ -33,8 +33,6 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 ///////////////////////////////////
 #include <Grid/communicator/SharedMemory.h>
 
-#define NVLINK_GET
-
 NAMESPACE_BEGIN(Grid);
 
 extern bool Stencil_force_mpi ;
@@ -108,7 +106,7 @@ public:
   // very VERY rarely (Log, serial RNG) we need world without a grid
   ////////////////////////////////////////////////////////////////////////////////
   static int  RankWorld(void) ;
-  static void BroadcastWorld(int root,void* data, uint64_t bytes);
+  static void BroadcastWorld(int root,void* data, int bytes);
   static void BarrierWorld(void);
   
   ////////////////////////////////////////////////////////////
@@ -130,35 +128,6 @@ public:
   void GlobalXOR(uint32_t &);
   void GlobalXOR(uint64_t &);
   
-  template<class obj> void GlobalSumP2P(obj &o)
-  {
-    std::vector<obj> column;
-    obj accum = o;
-    int source,dest;
-    for(int d=0;d<_ndimension;d++){
-      column.resize(_processors[d]);
-      column[0] = accum;
-      std::vector<MpiCommsRequest_t> list;
-      for(int p=1;p<_processors[d];p++){
-	ShiftedRanks(d,p,source,dest);
-	SendToRecvFromBegin(list,
-			    &column[0],
-			    dest,
-			    &column[p],
-			    source,
-			    sizeof(obj),d*100+p);
-
-      }
-      if (!list.empty()) // avoid triggering GRID_ASSERT in comms == none
-	CommsComplete(list);
-      for(int p=1;p<_processors[d];p++){
-	accum = accum + column[p];
-      }
-    }
-    Broadcast(0,accum);
-    o=accum;
-  }
-
   template<class obj> void GlobalSum(obj &o){
     typedef typename obj::scalar_type scalar_type;
     int words = sizeof(obj)/sizeof(scalar_type);
@@ -169,44 +138,32 @@ public:
   ////////////////////////////////////////////////////////////
   // Face exchange, buffer swap in translational invariant way
   ////////////////////////////////////////////////////////////
-  void CommsComplete(std::vector<MpiCommsRequest_t> &list);
+  void CommsComplete(std::vector<CommsRequest_t> &list);
-  void SendToRecvFromBegin(std::vector<MpiCommsRequest_t> &list,
+  void SendToRecvFromBegin(std::vector<CommsRequest_t> &list,
 			   void *xmit,
 			   int dest,
 			   void *recv,
 			   int from,
-			   uint64_t bytes,int dir);
+			   int bytes,int dir);
   
   void SendToRecvFrom(void *xmit,
 		      int xmit_to_rank,
 		      void *recv,
 		      int recv_from_rank,
-		      uint64_t bytes);
+		      int bytes);
   
-  int IsOffNode(int rank);
   double StencilSendToRecvFrom(void *xmit,
 			       int xmit_to_rank,int do_xmit,
 			       void *recv,
 			       int recv_from_rank,int do_recv,
-			       uint64_t bytes,int dir);
+			       int bytes,int dir);
 
-  double StencilSendToRecvFromPrepare(std::vector<CommsRequest_t> &list,
+  double StencilSendToRecvFromBegin(std::vector<CommsRequest_t> &list,
 				    void *xmit,
 				    int xmit_to_rank,int do_xmit,
 				    void *recv,
 				    int recv_from_rank,int do_recv,
-				      uint64_t xbytes,uint64_t rbytes,int dir);
+				    int xbytes,int rbytes,int dir);
-
-  // Could do a PollHtoD and have a CommsMerge dependence
-  void StencilSendToRecvFromPollDtoH (std::vector<CommsRequest_t> &list);
-  void StencilSendToRecvFromPollIRecv(std::vector<CommsRequest_t> &list);
-
-  double StencilSendToRecvFromBegin(std::vector<CommsRequest_t> &list,
-				    void *xmit,void *xmit_comp,
-				    int xmit_to_rank,int do_xmit,
-				    void *recv,void *recv_comp,
-				    int recv_from_rank,int do_recv,
-				    uint64_t xbytes,uint64_t rbytes,int dir);
   
   
   void StencilSendToRecvFromComplete(std::vector<CommsRequest_t> &waitall,int i);
@@ -220,35 +177,25 @@ public:
   ////////////////////////////////////////////////////////////
   // Broadcast a buffer and composite larger
   ////////////////////////////////////////////////////////////
-  void Broadcast(int root,void* data, uint64_t bytes);
+  void Broadcast(int root,void* data, int bytes);
 
   ////////////////////////////////////////////////////////////
   // All2All down one dimension
   ////////////////////////////////////////////////////////////
   template<class T> void AllToAll(int dim,std::vector<T> &in, std::vector<T> &out){
-    GRID_ASSERT(dim>=0);
+    assert(dim>=0);
-    GRID_ASSERT(dim<_ndimension);
+    assert(dim<_ndimension);
-    GRID_ASSERT(in.size()==out.size());
+    assert(in.size()==out.size());
     int numnode = _processors[dim];
     uint64_t bytes=sizeof(T);
     uint64_t words=in.size()/numnode;
-    GRID_ASSERT(numnode * words == in.size());
+    assert(numnode * words == in.size());
-    GRID_ASSERT(words < (1ULL<<31));
+    assert(words < (1ULL<<31));
     AllToAll(dim,(void *)&in[0],(void *)&out[0],words,bytes);
   }
   void AllToAll(int dim  ,void *in,void *out,uint64_t words,uint64_t bytes);
   void AllToAll(void  *in,void *out,uint64_t words         ,uint64_t bytes);
   
-  ////////////////////////////////////////////////////////////////////////////
-  // Variable count all to all. Counts and displacements are in units of
-  // "bytes" sized words and are indexed by rank within this communicator.
-  // For exchanges that are a permutation but do not divide evenly between
-  // ranks; AllToAll above is the uniform count special case.
-  ////////////////////////////////////////////////////////////////////////////
-  void AllToAllV(void *in ,const std::vector<int> &sendcounts,const std::vector<int> &senddispls,
-                 void *out,const std::vector<int> &recvcounts,const std::vector<int> &recvdispls,
-                 uint64_t bytes);
-  
   template<class obj> void Broadcast(int root,obj &data)
   {
     Broadcast(root,(void *)&data,sizeof(data));

Grid/communicator/Communicator_mpi3.cc

@@ -28,17 +28,9 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 #include <Grid/GridCore.h>
 #include <Grid/communicator/SharedMemory.h>
 
-void GridAbort(void) { MPI_Abort(MPI_COMM_WORLD,SIGABRT); }
-extern void * Grid_backtrace_buffer[_NBACKTRACE];
-
 NAMESPACE_BEGIN(Grid);
 
-
 Grid_MPI_Comm       CartesianCommunicator::communicator_world;
-#ifdef GRID_CHECKSUM_COMMS
-uint64_t checksum_index = 1;
-#endif
-
 
 ////////////////////////////////////////////
 // First initialise of comms system
@@ -63,11 +55,11 @@ void CartesianCommunicator::Init(int *argc, char ***argv)
 #endif
     //If only 1 comms thread we require any threading mode other than SINGLE, but for multiple comms threads we need MULTIPLE
     if( (nCommThreads == 1) && (provided == MPI_THREAD_SINGLE) ) {
-      GRID_ASSERT(0);
+      assert(0);
     }
 
     if( (nCommThreads > 1) && (provided != MPI_THREAD_MULTIPLE) ) {
-      GRID_ASSERT(0);
+      assert(0);
     }
   }
 
@@ -88,20 +80,20 @@ void CartesianCommunicator::Init(int *argc, char ***argv)
 void CartesianCommunicator::ShiftedRanks(int dim,int shift,int &source,int &dest)
 {
   int ierr=MPI_Cart_shift(communicator,dim,shift,&source,&dest);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 int CartesianCommunicator::RankFromProcessorCoor(Coordinate &coor)
 {
   int rank;
   int ierr=MPI_Cart_rank  (communicator, &coor[0], &rank);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
   return rank;
 }
 void  CartesianCommunicator::ProcessorCoorFromRank(int rank, Coordinate &coor)
 {
   coor.resize(_ndimension);
   int ierr=MPI_Cart_coords  (communicator, rank, _ndimension,&coor[0]);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -128,8 +120,8 @@ CartesianCommunicator::CartesianCommunicator(const Coordinate &processors)
 //////////////////////////////////
 CartesianCommunicator::CartesianCommunicator(const Coordinate &processors,const CartesianCommunicator &parent,int &srank)
 {
-  _ndimension = processors.size();  GRID_ASSERT(_ndimension>=1);
+  _ndimension = processors.size();  assert(_ndimension>=1);
-  int parent_ndimension = parent._ndimension; GRID_ASSERT(_ndimension >= parent._ndimension);
+  int parent_ndimension = parent._ndimension; assert(_ndimension >= parent._ndimension);
   Coordinate parent_processor_coor(_ndimension,0);
   Coordinate parent_processors    (_ndimension,1);
   Coordinate shm_processors       (_ndimension,1);
@@ -153,7 +145,7 @@ CartesianCommunicator::CartesianCommunicator(const Coordinate &processors,const
     childsize *= processors[d];
   }
   int Nchild = Nparent/childsize;
-  GRID_ASSERT (childsize * Nchild == Nparent);
+  assert (childsize * Nchild == Nparent);
 
   Coordinate ccoor(_ndimension); // coor within subcommunicator
   Coordinate scoor(_ndimension); // coor of split within parent
@@ -179,12 +171,12 @@ CartesianCommunicator::CartesianCommunicator(const Coordinate &processors,const
     // Split the communicator
     ////////////////////////////////////////////////////////////////
     int ierr= MPI_Comm_split(parent.communicator,srank,crank,&comm_split);
-    GRID_ASSERT(ierr==0);
+    assert(ierr==0);
 
   } else {
     srank = 0;
     int ierr = MPI_Comm_dup (parent.communicator,&comm_split);
-    GRID_ASSERT(ierr==0);
+    assert(ierr==0);
   }
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -209,7 +201,7 @@ CartesianCommunicator::CartesianCommunicator(const Coordinate &processors,const
     }
   }
   for(int d=0;d<processors.size();d++){
-    GRID_ASSERT(_processor_coor[d] == ccoor[d] );
+    assert(_processor_coor[d] == ccoor[d] );
   }
 }
 
@@ -251,7 +243,7 @@ void CartesianCommunicator::InitFromMPICommunicator(const Coordinate &processors
   for(int i=0;i<_ndimension*2;i++){
     MPI_Comm_dup(communicator,&communicator_halo[i]);
   }
-  GRID_ASSERT(Size==_Nprocessors);
+  assert(Size==_Nprocessors);
 }
 
 CartesianCommunicator::~CartesianCommunicator()
@@ -265,103 +257,82 @@ CartesianCommunicator::~CartesianCommunicator()
     }
   }
 }
-#ifdef USE_GRID_REDUCTION
-void CartesianCommunicator::GlobalSum(float &f){
-  FlightRecorder::StepLog("GlobalSumP2P");
-  CartesianCommunicator::GlobalSumP2P(f);
-}
-void CartesianCommunicator::GlobalSum(double &d)
-{
-  FlightRecorder::StepLog("GlobalSumP2P");
-  CartesianCommunicator::GlobalSumP2P(d);
-}
-#else
-void CartesianCommunicator::GlobalSum(float &f){
-  FlightRecorder::StepLog("AllReduce float");
-  int ierr=MPI_Allreduce(MPI_IN_PLACE,&f,1,MPI_FLOAT,MPI_SUM,communicator);
-  GRID_ASSERT(ierr==0);
-}
-void CartesianCommunicator::GlobalSum(double &d)
-{
-  FlightRecorder::StepLog("AllReduce double");
-  int ierr = MPI_Allreduce(MPI_IN_PLACE,&d,1,MPI_DOUBLE,MPI_SUM,communicator);
-  GRID_ASSERT(ierr==0);
-}
-#endif
 void CartesianCommunicator::GlobalSum(uint32_t &u){
-  FlightRecorder::StepLog("AllReduce uint32_t");
   int ierr=MPI_Allreduce(MPI_IN_PLACE,&u,1,MPI_UINT32_T,MPI_SUM,communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 void CartesianCommunicator::GlobalSum(uint64_t &u){
-  FlightRecorder::StepLog("AllReduce uint64_t");
   int ierr=MPI_Allreduce(MPI_IN_PLACE,&u,1,MPI_UINT64_T,MPI_SUM,communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 void CartesianCommunicator::GlobalSumVector(uint64_t* u,int N){
-  FlightRecorder::StepLog("AllReduceVector");
   int ierr=MPI_Allreduce(MPI_IN_PLACE,u,N,MPI_UINT64_T,MPI_SUM,communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 void CartesianCommunicator::GlobalXOR(uint32_t &u){
   int ierr=MPI_Allreduce(MPI_IN_PLACE,&u,1,MPI_UINT32_T,MPI_BXOR,communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 void CartesianCommunicator::GlobalXOR(uint64_t &u){
-  FlightRecorder::StepLog("GlobalXOR");
   int ierr=MPI_Allreduce(MPI_IN_PLACE,&u,1,MPI_UINT64_T,MPI_BXOR,communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 void CartesianCommunicator::GlobalMax(float &f)
 {
-  FlightRecorder::StepLog("GlobalMax");
   int ierr=MPI_Allreduce(MPI_IN_PLACE,&f,1,MPI_FLOAT,MPI_MAX,communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 void CartesianCommunicator::GlobalMax(double &d)
 {
-  FlightRecorder::StepLog("GlobalMax");
   int ierr = MPI_Allreduce(MPI_IN_PLACE,&d,1,MPI_DOUBLE,MPI_MAX,communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
+}
+void CartesianCommunicator::GlobalSum(float &f){
+  int ierr=MPI_Allreduce(MPI_IN_PLACE,&f,1,MPI_FLOAT,MPI_SUM,communicator);
+  assert(ierr==0);
 }
 void CartesianCommunicator::GlobalSumVector(float *f,int N)
 {
-  FlightRecorder::StepLog("GlobalSumVector(float *)");
   int ierr=MPI_Allreduce(MPI_IN_PLACE,f,N,MPI_FLOAT,MPI_SUM,communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
+}
+void CartesianCommunicator::GlobalSum(double &d)
+{
+  int ierr = MPI_Allreduce(MPI_IN_PLACE,&d,1,MPI_DOUBLE,MPI_SUM,communicator);
+  assert(ierr==0);
 }
 void CartesianCommunicator::GlobalSumVector(double *d,int N)
 {
-  FlightRecorder::StepLog("GlobalSumVector(double *)");
   int ierr = MPI_Allreduce(MPI_IN_PLACE,d,N,MPI_DOUBLE,MPI_SUM,communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 
-void CartesianCommunicator::SendToRecvFromBegin(std::vector<MpiCommsRequest_t> &list,
+void CartesianCommunicator::SendToRecvFromBegin(std::vector<CommsRequest_t> &list,
 						void *xmit,
 						int dest,
 						void *recv,
 						int from,
-						uint64_t bytes,int dir)
+						int bytes,int dir)
 {
   MPI_Request xrq;
   MPI_Request rrq;
 
-  GRID_ASSERT(dest != _processor);
+  assert(dest != _processor);
-  GRID_ASSERT(from != _processor);
+  assert(from != _processor);
+
   int tag;
 
   tag= dir+from*32;
-  int ierr=MPI_Irecv(recv,(int)( bytes/sizeof(int32_t)), MPI_INT32_T,from,tag,communicator,&rrq);
+  int ierr=MPI_Irecv(recv, bytes, MPI_CHAR,from,tag,communicator,&rrq);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
   list.push_back(rrq);
   
   tag= dir+_processor*32;
-  ierr =MPI_Isend(xmit,(int)(bytes/sizeof(int32_t)), MPI_INT32_T,dest,tag,communicator,&xrq);
+  ierr =MPI_Isend(xmit, bytes, MPI_CHAR,dest,tag,communicator,&xrq);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
   list.push_back(xrq);
 }
-void CartesianCommunicator::CommsComplete(std::vector<MpiCommsRequest_t> &list)
+void CartesianCommunicator::CommsComplete(std::vector<CommsRequest_t> &list)
 {
   int nreq=list.size();
 
@@ -369,7 +340,7 @@ void CartesianCommunicator::CommsComplete(std::vector<MpiCommsRequest_t> &list)
 
   std::vector<MPI_Status> status(nreq);
   int ierr = MPI_Waitall(nreq,&list[0],&status[0]);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
   list.resize(0);
 }
 
@@ -378,63 +349,50 @@ void CartesianCommunicator::SendToRecvFrom(void *xmit,
 					   int dest,
 					   void *recv,
 					   int from,
-					   uint64_t bytes)
+					   int bytes)
 {
-  std::vector<MpiCommsRequest_t> reqs(0);
+  std::vector<CommsRequest_t> reqs(0);
+  unsigned long  xcrc = crc32(0L, Z_NULL, 0);
+  unsigned long  rcrc = crc32(0L, Z_NULL, 0);
 
   int myrank = _processor;
   int ierr;
 
   // Enforce no UVM in comms, device or host OK
-  GRID_ASSERT(acceleratorIsCommunicable(xmit));
+  assert(acceleratorIsCommunicable(xmit));
-  GRID_ASSERT(acceleratorIsCommunicable(recv));
+  assert(acceleratorIsCommunicable(recv));
 
   // Give the CPU to MPI immediately; can use threads to overlap optionally
   //  printf("proc %d SendToRecvFrom %d bytes Sendrecv \n",_processor,bytes);
-  ierr=MPI_Sendrecv(xmit,(int)(bytes/sizeof(int32_t)),MPI_INT32_T,dest,myrank,
+  ierr=MPI_Sendrecv(xmit,bytes,MPI_CHAR,dest,myrank,
-		    recv,(int)(bytes/sizeof(int32_t)),MPI_INT32_T,from, from,
+		    recv,bytes,MPI_CHAR,from, from,
 		    communicator,MPI_STATUS_IGNORE);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 
+  //  xcrc = crc32(xcrc,(unsigned char *)xmit,bytes);
+  //  rcrc = crc32(rcrc,(unsigned char *)recv,bytes);
+  //  printf("proc %d SendToRecvFrom %d bytes xcrc %lx rcrc %lx\n",_processor,bytes,xcrc,rcrc); fflush
 }
 // Basic Halo comms primitive
 double CartesianCommunicator::StencilSendToRecvFrom( void *xmit,
 						     int dest, int dox,
 						     void *recv,
 						     int from, int dor,
-						     uint64_t bytes,int dir)
+						     int bytes,int dir)
 {
   std::vector<CommsRequest_t> list;
-  double offbytes = StencilSendToRecvFromPrepare(list,xmit,dest,dox,recv,from,dor,bytes,bytes,dir);
+  double offbytes = StencilSendToRecvFromBegin(list,xmit,dest,dox,recv,from,dor,bytes,bytes,dir);
-  offbytes       += StencilSendToRecvFromBegin(list,xmit,xmit,dest,dox,recv,recv,from,dor,bytes,bytes,dir);
   StencilSendToRecvFromComplete(list,dir);
   return offbytes;
 }
-int CartesianCommunicator::IsOffNode(int rank)
-{
-  int grank = ShmRanks[rank];
-  if ( grank == MPI_UNDEFINED ) return true;
-  else return false;
-}
 
-#ifdef ACCELERATOR_AWARE_MPI
+#undef NVLINK_GET // Define to use get instead of put DMA
-void CartesianCommunicator::StencilSendToRecvFromPollIRecv(std::vector<CommsRequest_t> &list) {};
+double CartesianCommunicator::StencilSendToRecvFromBegin(std::vector<CommsRequest_t> &list,
-void CartesianCommunicator::StencilSendToRecvFromPollDtoH(std::vector<CommsRequest_t> &list) {};
-double CartesianCommunicator::StencilSendToRecvFromPrepare(std::vector<CommsRequest_t> &list,
 							 void *xmit,
 							 int dest,int dox,
 							 void *recv,
 							 int from,int dor,
-							   uint64_t xbytes,uint64_t rbytes,int dir)
+							 int xbytes,int rbytes,int dir)
-{
-  return 0.0; // Do nothing -- no preparation required
-}
-double CartesianCommunicator::StencilSendToRecvFromBegin(std::vector<CommsRequest_t> &list,
-							 void *xmit,void *xmit_comp,
-							 int dest,int dox,
-							 void *recv,void *recv_comp,
-							 int from,int dor,
-							 uint64_t xbytes,uint64_t rbytes,int dir)
 {
   int ncomm  =communicator_halo.size();
   int commdir=dir%ncomm;
@@ -447,431 +405,62 @@ double CartesianCommunicator::StencilSendToRecvFromBegin(std::vector<CommsReques
   int gfrom = ShmRanks[from];
   int gme   = ShmRanks[_processor];
 
-  GRID_ASSERT(dest != _processor);
+  assert(dest != _processor);
-  GRID_ASSERT(from != _processor);
+  assert(from != _processor);
-  GRID_ASSERT(gme  == ShmRank);
+  assert(gme  == ShmRank);
   double off_node_bytes=0.0;
   int tag;
 
   if ( dor ) {
     if ( (gfrom ==MPI_UNDEFINED) || Stencil_force_mpi ) {
       tag= dir+from*32;
-      //      std::cout << " StencilSendToRecvFrom "<<dir<<" MPI_Irecv "<<std::hex<<recv<<std::dec<<std::endl;
+      ierr=MPI_Irecv(recv, rbytes, MPI_CHAR,from,tag,communicator_halo[commdir],&rrq);
-      ierr=MPI_Irecv(recv_comp,(int)(rbytes/sizeof(int32_t)), MPI_INT32_T,from,tag,communicator_halo[commdir],&rrq);
+      assert(ierr==0);
-      GRID_ASSERT(ierr==0);
       list.push_back(rrq);
       off_node_bytes+=rbytes;
     }
 #ifdef NVLINK_GET
-    else { 
       void *shm = (void *) this->ShmBufferTranslate(from,xmit);
-      GRID_ASSERT(shm!=NULL);
+      assert(shm!=NULL);
-      //      std::cout << " StencilSendToRecvFrom "<<dir<<" CopyDeviceToDevice recv "<<std::hex<<recv<<" remote "<<shm <<std::dec<<std::endl;
       acceleratorCopyDeviceToDeviceAsynch(shm,recv,rbytes);
-    }
 #endif
   }
-  // This is a NVLINK PUT  
+  
   if (dox) {
+    //  rcrc = crc32(rcrc,(unsigned char *)recv,bytes);
     if ( (gdest == MPI_UNDEFINED) || Stencil_force_mpi ) {
       tag= dir+_processor*32;
-      ierr =MPI_Isend(xmit_comp,(int)(xbytes/sizeof(int32_t)), MPI_INT32_T,dest,tag,communicator_halo[commdir],&xrq);
+      ierr =MPI_Isend(xmit, xbytes, MPI_CHAR,dest,tag,communicator_halo[commdir],&xrq);
-      GRID_ASSERT(ierr==0);
+      assert(ierr==0);
       list.push_back(xrq);
       off_node_bytes+=xbytes;
     } else {
 #ifndef NVLINK_GET
       void *shm = (void *) this->ShmBufferTranslate(dest,recv);
-      GRID_ASSERT(shm!=NULL);
+      assert(shm!=NULL);
       acceleratorCopyDeviceToDeviceAsynch(xmit,shm,xbytes);
 #endif
+      
     }
   }
-  return off_node_bytes;
-}
 
+  return off_node_bytes;
+}
 void CartesianCommunicator::StencilSendToRecvFromComplete(std::vector<CommsRequest_t> &list,int dir)
 {
   int nreq=list.size();
-  /*finishes Get/Put*/
+
   acceleratorCopySynchronise();
 
   if (nreq==0) return;
+
   std::vector<MPI_Status> status(nreq);
   int ierr = MPI_Waitall(nreq,&list[0],&status[0]);
-  GRID_ASSERT(ierr==0);
-  list.resize(0);
-  this->StencilBarrier(); 
-}
-
-#else /* NOT     ... ACCELERATOR_AWARE_MPI */
-///////////////////////////////////////////
-// Pipeline mode through host memory
-///////////////////////////////////////////
-  /*
-   * In prepare (phase 1):
-   * PHASE 1: (prepare)
-   * - post MPI receive buffers asynch
-   * - post device - host send buffer transfer asynch
-   * PHASE 2: (Begin)
-   * - complete all copies
-   * - post MPI send asynch
-   * - post device - device transfers
-   * PHASE 3: (Complete)
-   * - MPI_waitall
-   * - host-device transfers
-   *
-   *********************************
-   * NB could split this further:
-   *--------------------------------
-   * PHASE 1: (Prepare)
-   * - post MPI receive buffers asynch
-   * - post device - host send buffer transfer asynch
-   * PHASE 2: (BeginInterNode)
-   * - complete all copies 
-   * - post MPI send asynch
-   * PHASE 3: (BeginIntraNode)
-   * - post device - device transfers
-   * PHASE 4: (Complete)
-   * - MPI_waitall
-   * - host-device transfers asynch
-   * - (complete all copies) 
-   */
-double CartesianCommunicator::StencilSendToRecvFromPrepare(std::vector<CommsRequest_t> &list,
-							   void *xmit,
-							   int dest,int dox,
-							   void *recv,
-							   int from,int dor,
-							   uint64_t xbytes,uint64_t rbytes,int dir)
-{
-/*
- * Bring sequence from Stencil.h down to lower level.
- * Assume using XeLink is ok
- */  
-  int ncomm  =communicator_halo.size();
-  int commdir=dir%ncomm;
-
-  MPI_Request xrq;
-  MPI_Request rrq;
-
-  int ierr;
-  int gdest = ShmRanks[dest];
-  int gfrom = ShmRanks[from];
-  int gme   = ShmRanks[_processor];
-
-  GRID_ASSERT(dest != _processor);
-  GRID_ASSERT(from != _processor);
-  GRID_ASSERT(gme  == ShmRank);
-  double off_node_bytes=0.0;
-  int tag;
-
-  void * host_recv = NULL;
-  void * host_xmit = NULL;
-
-  /*
-   * PHASE 1: (Prepare)
-   * - post MPI receive buffers asynch
-   * - post device - host send buffer transfer asynch
-   */
-  
-#ifdef GRID_CHECKSUM_COMMS
-  rbytes += 8;
-  xbytes += 8;
-#endif
-
-  if ( dor ) {
-    if ( (gfrom ==MPI_UNDEFINED) || Stencil_force_mpi ) {
-      tag= dir+from*32;
-      host_recv = this->HostBufferMalloc(rbytes);
-      ierr=MPI_Irecv(host_recv,(int)(rbytes/sizeof(int32_t)), MPI_INT32_T,from,tag,communicator_halo[commdir],&rrq);
-      GRID_ASSERT(ierr==0);
-      CommsRequest_t srq;
-      srq.PacketType = InterNodeRecv;
-      srq.bytes      = rbytes;
-      srq.req        = rrq;
-      srq.host_buf   = host_recv;
-      srq.device_buf = recv;
-      srq.tag        = tag;
-      list.push_back(srq);
-      off_node_bytes+=rbytes;
-    }
-  }
-  
-  if (dox) {
-    if ( (gdest == MPI_UNDEFINED) || Stencil_force_mpi ) {
-
-      tag= dir+_processor*32;
-
-      host_xmit = this->HostBufferMalloc(xbytes);
-      CommsRequest_t srq;
-
-#ifdef GRID_CHECKSUM_COMMS
-      uint64_t xbytes_data = xbytes - 8;
-      srq.ev = acceleratorCopyFromDeviceAsynch(xmit, host_xmit,xbytes_data); // Make this Asynch
-      GRID_ASSERT(xbytes % 8 == 0);
-      // flip one bit so that a zero buffer is not consistent
-      uint64_t xsum = checksum_gpu((uint64_t*)xmit, xbytes_data / 8) ^ (checksum_index + 1 + 1000 * tag); 
-      *(uint64_t*)(((char*)host_xmit) + xbytes_data) = xsum;
-#else
-      srq.ev = acceleratorCopyFromDeviceAsynch(xmit, host_xmit,xbytes); // Make this Asynch
-#endif
-      
-      //      ierr =MPI_Isend(host_xmit, xbytes, MPI_CHAR,dest,tag,communicator_halo[commdir],&xrq);
-      //      GRID_ASSERT(ierr==0);
-      //      off_node_bytes+=xbytes;
-
-      srq.PacketType = InterNodeXmit;
-      srq.bytes      = xbytes;
-      //      srq.req        = xrq;
-      srq.host_buf   = host_xmit;
-      srq.device_buf = xmit;
-      srq.tag        = tag;
-      srq.dest       = dest;
-      srq.commdir    = commdir;
-      list.push_back(srq);
-    }
-  }
-
-  return off_node_bytes;
-}
-/*
- * In the interest of better pipelining, poll for completion on each DtoH and 
- * start MPI_ISend in the meantime
- */
-void CartesianCommunicator::StencilSendToRecvFromPollIRecv(std::vector<CommsRequest_t> &list)
-{
-  int pending = 0;
-  do {
-
-    pending = 0;
-
-    for(int idx = 0; idx<list.size();idx++){
-
-      if ( list[idx].PacketType==InterNodeRecv ) {
-
-	int flag = 0;
-	MPI_Status status;
-	int ierr = MPI_Test(&list[idx].req,&flag,&status);
   assert(ierr==0);
-
+  list.resize(0);
-	if ( flag ) {
-	  //	  std::cout << " PollIrecv "<<idx<<" flag "<<flag<<std::endl;
-#ifdef GRID_CHECKSUM_COMMS
- 	  acceleratorCopyToDeviceAsynch(list[idx].host_buf,list[idx].device_buf,list[idx].bytes - 8);
-#else
-	  acceleratorCopyToDeviceAsynch(list[idx].host_buf,list[idx].device_buf,list[idx].bytes);
-#endif
-	  list[idx].PacketType=InterNodeReceiveHtoD;
-	} else {
-	  pending ++;
 }
-      }
-    }
-    //    std::cout << " PollIrecv "<<pending<<" pending requests"<<std::endl;
-  } while ( pending );
-  
-}
-void CartesianCommunicator::StencilSendToRecvFromPollDtoH(std::vector<CommsRequest_t> &list)
-{
-  int pending = 0;
-  do {
-
-    pending = 0;
-
-    for(int idx = 0; idx<list.size();idx++){
-
-      if ( list[idx].PacketType==InterNodeXmit ) {
-
-	if ( acceleratorEventIsComplete(list[idx].ev) ) {
-
-	  void *host_xmit = list[idx].host_buf;
-	  uint64_t xbytes = list[idx].bytes;
-	  int dest        = list[idx].dest;
-	  int tag         = list[idx].tag;
-	  int commdir     = list[idx].commdir;
-	  ///////////////////
-	  // Send packet
-	  ///////////////////
-
-	  //	  std::cout << " DtoH is complete for index "<<idx<<" calling MPI_Isend "<<std::endl;
-	  
-	  MPI_Request xrq;
-	  int ierr =MPI_Isend(host_xmit, (int)(xbytes/sizeof(int32_t)), MPI_INT32_T,dest,tag,communicator_halo[commdir],&xrq);
-	  GRID_ASSERT(ierr==0);
-
-	  list[idx].req        = xrq; // Update the MPI request in the list
-
-	  list[idx].PacketType=InterNodeXmitISend;
-
-	} else {
-	  // not done, so return to polling loop
-	  pending++;
-	}
-      }
-    }
-  } while (pending);
-}  
-
-double CartesianCommunicator::StencilSendToRecvFromBegin(std::vector<CommsRequest_t> &list,
-							 void *xmit,void *xmit_comp,
-							 int dest,int dox,
-							 void *recv,void *recv_comp,
-							 int from,int dor,
-							 uint64_t xbytes,uint64_t rbytes,int dir)
-{
-  int ncomm  =communicator_halo.size();
-  int commdir=dir%ncomm;
-
-  MPI_Request xrq;
-  MPI_Request rrq;
-
-  int ierr;
-  int gdest = ShmRanks[dest];
-  int gfrom = ShmRanks[from];
-  int gme   = ShmRanks[_processor];
-
-  GRID_ASSERT(dest != _processor);
-  GRID_ASSERT(from != _processor);
-  GRID_ASSERT(gme  == ShmRank);
-  double off_node_bytes=0.0;
-  int tag;
-
-  void * host_xmit = NULL;
-
-  ////////////////////////////////
-  // Receives already posted
-  // Copies already started
-  ////////////////////////////////
-  /*  
-   * PHASE 2: (Begin)
-   * - complete all copies
-   * - post MPI send asynch
-   */
-#ifdef NVLINK_GET
-  if ( dor ) {
-
-    if ( ! ( (gfrom ==MPI_UNDEFINED) || Stencil_force_mpi ) ) {
-      // Intranode
-      void *shm = (void *) this->ShmBufferTranslate(from,xmit);
-      GRID_ASSERT(shm!=NULL);
-
-      CommsRequest_t srq;
-
-      srq.ev = acceleratorCopyDeviceToDeviceAsynch(shm,recv,rbytes);
-
-      srq.PacketType = IntraNodeRecv;
-      srq.bytes      = xbytes;
-      //      srq.req        = xrq;
-      srq.host_buf   = NULL;
-      srq.device_buf = xmit;
-      srq.tag        = -1;
-      srq.dest       = dest;
-      srq.commdir    = dir;
-      list.push_back(srq);
-    }
-  }  
-#else
-  if (dox) {
-
-    if ( !( (gdest == MPI_UNDEFINED) || Stencil_force_mpi ) ) {
-      // Intranode
-      void *shm = (void *) this->ShmBufferTranslate(dest,recv);
-      GRID_ASSERT(shm!=NULL);
-
-      CommsRequest_t srq;
-      
-      srq.ev = acceleratorCopyDeviceToDeviceAsynch(xmit,shm,xbytes);
-
-      srq.PacketType = IntraNodeXmit;
-      srq.bytes      = xbytes;
-      //      srq.req        = xrq;
-      srq.host_buf   = NULL;
-      srq.device_buf = xmit;
-      srq.tag        = -1;
-      srq.dest       = dest;
-      srq.commdir    = dir;
-      list.push_back(srq);
-      
-    }
-  }
-#endif
-  return off_node_bytes;
-}
-void CartesianCommunicator::StencilSendToRecvFromComplete(std::vector<CommsRequest_t> &list,int dir)
-{
-  acceleratorCopySynchronise(); // Complete all pending copy transfers D2D
-
-  std::vector<MPI_Status> status;
-  std::vector<MPI_Request> MpiRequests;
-    
-  for(int r=0;r<list.size();r++){
-    // Must check each Send buf is clear to reuse
-    if ( list[r].PacketType == InterNodeXmitISend ) MpiRequests.push_back(list[r].req);
-    //    if ( list[r].PacketType == InterNodeRecv ) MpiRequests.push_back(list[r].req); // Already "Test" passed
-  }
-
-  int nreq=MpiRequests.size();
-
-  if (nreq>0) {
-    status.resize(MpiRequests.size());
-    int ierr = MPI_Waitall(MpiRequests.size(),&MpiRequests[0],&status[0]); // Sends are guaranteed in order. No harm in not completing.
-    GRID_ASSERT(ierr==0);
-  }
-  
-  //  for(int r=0;r<nreq;r++){
-  //    if ( list[r].PacketType==InterNodeRecv ) {
-  //      acceleratorCopyToDeviceAsynch(list[r].host_buf,list[r].device_buf,list[r].bytes);
-  //    }
-  //  }
-#ifdef GRID_CHECKSUM_COMMS
-  for(int r=0;r<list.size();r++){
-    if ( list[r].PacketType == InterNodeReceiveHtoD ) {
-      uint64_t rbytes_data = list[r].bytes - 8;
-      uint64_t expected_cs = *(uint64_t*)(((char*)list[r].host_buf) + rbytes_data);
-      uint64_t computed_cs = checksum_gpu((uint64_t*)list[r].device_buf, rbytes_data / 8) ^ (checksum_index + 1 + 1000 * list[r].tag); //
-      if (expected_cs != computed_cs) {
-	// TODO: error message, backtrace, quit
-
-	fprintf(stderr, "GRID_CHECKSUM_COMMS error:\n");
-	fprintf(stderr, " processor = %d\n", (int)_processor);
-	for(int d=0;d<_processors.size();d++)
-	  fprintf(stderr, " processor_coord[%d] = %d\n", d, _processor_coor[d]);
-	fprintf(stderr, " hostname: %s\n", GridHostname());
-	fprintf(stderr, " expected_cs: %ld\n", expected_cs);
-	fprintf(stderr, " computed_cs: %ld\n", computed_cs);
-	fprintf(stderr, " dest: %d\n", list[r].dest);
-	fprintf(stderr, " tag: %d\n", list[r].tag);
-	fprintf(stderr, " commdir: %d\n", list[r].commdir);
-	fprintf(stderr, " bytes: %ld\n", (uint64_t)list[r].bytes);
-
-	fflush(stderr);
-
-	// backtrace
-	int symbols = backtrace(Grid_backtrace_buffer,_NBACKTRACE);
-	backtrace_symbols_fd(Grid_backtrace_buffer,symbols, 2);
-
-	exit(1);
-      }
-    }
-  }
-
-  checksum_index += 1;
-#endif
-  
-  list.resize(0);               // Delete the list
-  this->HostBufferFreeAll();    // Clean up the buffer allocs
-#ifndef NVLINK_GET
-  this->StencilBarrier(); // if PUT must check our nbrs have filled our receive buffers.
-#endif   
-}
-#endif
-////////////////////////////////////////////
-// END PIPELINE MODE / NO CUDA AWARE MPI
-////////////////////////////////////////////
-
 void CartesianCommunicator::StencilBarrier(void)
 {
-  FlightRecorder::StepLog("NodeBarrier");
   MPI_Barrier  (ShmComm);
 }
 //void CartesianCommunicator::SendToRecvFromComplete(std::vector<CommsRequest_t> &list)
@@ -879,19 +468,17 @@ void CartesianCommunicator::StencilBarrier(void)
 //}
 void CartesianCommunicator::Barrier(void)
 {
-  FlightRecorder::StepLog("GridBarrier");
   int ierr = MPI_Barrier(communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
-void CartesianCommunicator::Broadcast(int root,void* data,uint64_t bytes)
+void CartesianCommunicator::Broadcast(int root,void* data, int bytes)
 {
-  FlightRecorder::StepLog("Broadcast");
   int ierr=MPI_Bcast(data,
-		     (int)bytes,
+		     bytes,
 		     MPI_BYTE,
 		     root,
 		     communicator);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 int CartesianCommunicator::RankWorld(void){
   int r;
@@ -899,25 +486,23 @@ int CartesianCommunicator::RankWorld(void){
   return r;
 }
 void CartesianCommunicator::BarrierWorld(void){
-  FlightRecorder::StepLog("BarrierWorld");
   int ierr = MPI_Barrier(communicator_world);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
-void CartesianCommunicator::BroadcastWorld(int root,void* data, uint64_t bytes)
+void CartesianCommunicator::BroadcastWorld(int root,void* data, int bytes)
 {
-  FlightRecorder::StepLog("BroadcastWorld");
   int ierr= MPI_Bcast(data,
-		      (int)bytes,
+		      bytes,
 		      MPI_BYTE,
 		      root,
 		      communicator_world);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 
 void CartesianCommunicator::AllToAll(int dim,void  *in,void *out,uint64_t words,uint64_t bytes)
 {
   Coordinate row(_ndimension,1);
-  GRID_ASSERT(dim>=0 && dim<_ndimension);
+  assert(dim>=0 && dim<_ndimension);
 
   //  Split the communicator
   row[dim] = _processors[dim];
@@ -928,7 +513,6 @@ void CartesianCommunicator::AllToAll(int dim,void  *in,void *out,uint64_t words,
 }
 void CartesianCommunicator::AllToAll(void  *in,void *out,uint64_t words,uint64_t bytes)
 {
-  FlightRecorder::StepLog("AllToAll");
   // MPI is a pain and uses "int" arguments
   // 64*64*64*128*16 == 500Million elements of data.
   // When 24*4 bytes multiples get 50x 10^9 >>> 2x10^9 Y2K bug.
@@ -938,32 +522,12 @@ void CartesianCommunicator::AllToAll(void  *in,void *out,uint64_t words,uint64_t
   int ibytes;
   iwords = words;
   ibytes = bytes;
-  GRID_ASSERT(words == iwords); // safe to cast to int ?
+  assert(words == iwords); // safe to cast to int ?
-  GRID_ASSERT(bytes == ibytes); // safe to cast to int ?
+  assert(bytes == ibytes); // safe to cast to int ?
   MPI_Type_contiguous(ibytes,MPI_BYTE,&object);
   MPI_Type_commit(&object);
   MPI_Alltoall(in,iwords,object,out,iwords,object,communicator);
   MPI_Type_free(&object);
 }
-void CartesianCommunicator::AllToAllV(void *in ,const std::vector<int> &sendcounts,const std::vector<int> &senddispls,
-                                      void *out,const std::vector<int> &recvcounts,const std::vector<int> &recvdispls,
-                                      uint64_t bytes)
-{
-  FlightRecorder::StepLog("AllToAllV");
-  GRID_ASSERT(sendcounts.size()==(size_t)_Nprocessors);
-  GRID_ASSERT(senddispls.size()==(size_t)_Nprocessors);
-  GRID_ASSERT(recvcounts.size()==(size_t)_Nprocessors);
-  GRID_ASSERT(recvdispls.size()==(size_t)_Nprocessors);
-  // MPI counts are "int"; the caller sizes the word to keep them in range
-  int ibytes = bytes;
-  GRID_ASSERT(bytes == (uint64_t)ibytes);
-  MPI_Datatype object;
-  MPI_Type_contiguous(ibytes,MPI_BYTE,&object);
-  MPI_Type_commit(&object);
-  int ierr = MPI_Alltoallv(in ,(int *)&sendcounts[0],(int *)&senddispls[0],object,
-                           out,(int *)&recvcounts[0],(int *)&recvdispls[0],object,communicator);
-  GRID_ASSERT(ierr==0);
-  MPI_Type_free(&object);
-}
 
 NAMESPACE_END(Grid);

Grid/communicator/Communicator_none.cc

@@ -27,8 +27,6 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 /*  END LEGAL */
 #include <Grid/GridCore.h>
 
-void GridAbort(void) { abort(); }
-
 NAMESPACE_BEGIN(Grid);
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -36,7 +34,6 @@ NAMESPACE_BEGIN(Grid);
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 Grid_MPI_Comm       CartesianCommunicator::communicator_world;
 
-
 void CartesianCommunicator::Init(int *argc, char *** arv)
 {
   GlobalSharedMemory::Init(communicator_world);
@@ -57,14 +54,14 @@ CartesianCommunicator::CartesianCommunicator(const Coordinate &processors)
 {
   _shm_processors = Coordinate(processors.size(),1);
   _processors = processors;
-  _ndimension = processors.size();  GRID_ASSERT(_ndimension>=1);
+  _ndimension = processors.size();  assert(_ndimension>=1);
   _processor_coor.resize(_ndimension);
   
   // Require 1^N processor grid for fake
   _Nprocessors=1;
   _processor = 0;
   for(int d=0;d<_ndimension;d++) {
-    GRID_ASSERT(_processors[d]==1);
+    assert(_processors[d]==1);
     _processor_coor[d] = 0;
   }
   SetCommunicator(communicator_world);
@@ -90,19 +87,19 @@ void CartesianCommunicator::SendToRecvFrom(void *xmit,
 					   int dest,
 					   void *recv,
 					   int from,
-					   uint64_t bytes)
+					   int bytes)
 {
-  GRID_ASSERT(0);
+  assert(0);
 }
-void CartesianCommunicator::CommsComplete(std::vector<CommsRequest_t> &list){ GRID_ASSERT(list.size()==0);}
+void CartesianCommunicator::CommsComplete(std::vector<CommsRequest_t> &list){ assert(0);}
 void CartesianCommunicator::SendToRecvFromBegin(std::vector<CommsRequest_t> &list,
 						void *xmit,
 						int dest,
 						void *recv,
 						int from,
-						uint64_t bytes,int dir)
+						int bytes,int dir)
 {
-  GRID_ASSERT(0);
+  assert(0);
 }
 
 void CartesianCommunicator::AllToAll(int dim,void  *in,void *out,uint64_t words,uint64_t bytes)
@@ -113,22 +110,11 @@ void CartesianCommunicator::AllToAll(void  *in,void *out,uint64_t words,uint64_t
 {
   bcopy(in,out,bytes*words);
 }
-void CartesianCommunicator::AllToAllV(void *in ,const std::vector<int> &sendcounts,const std::vector<int> &senddispls,
-                                      void *out,const std::vector<int> &recvcounts,const std::vector<int> &recvdispls,
-                                      uint64_t bytes)
-{
-  // Single rank: the exchange degenerates to a copy of our own segment
-  GRID_ASSERT(sendcounts.size()==1);
-  GRID_ASSERT(recvcounts.size()==1);
-  GRID_ASSERT(sendcounts[0]==recvcounts[0]);
-  bcopy((char *)in +(uint64_t)senddispls[0]*bytes,
-        (char *)out+(uint64_t)recvdispls[0]*bytes,bytes*(uint64_t)sendcounts[0]);
-}
 
 int  CartesianCommunicator::RankWorld(void){return 0;}
 void CartesianCommunicator::Barrier(void){}
-void CartesianCommunicator::Broadcast(int root,void* data, uint64_t bytes) {}
+void CartesianCommunicator::Broadcast(int root,void* data, int bytes) {}
-void CartesianCommunicator::BroadcastWorld(int root,void* data, uint64_t 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; }
@@ -138,33 +124,20 @@ void CartesianCommunicator::ShiftedRanks(int dim,int shift,int &source,int &dest
   dest=0;
 }
 
-int CartesianCommunicator::IsOffNode(int rank) { return false; }
-
 double CartesianCommunicator::StencilSendToRecvFrom( void *xmit,
 						     int xmit_to_rank,int dox,
 						     void *recv,
 						     int recv_from_rank,int dor,
-						     uint64_t bytes, int dir)
+						     int bytes, int dir)
 {
   return 2.0*bytes;
 }
-void CartesianCommunicator::StencilSendToRecvFromPollIRecv(std::vector<CommsRequest_t> &list) {};
+double CartesianCommunicator::StencilSendToRecvFromBegin(std::vector<CommsRequest_t> &list,
-void CartesianCommunicator::StencilSendToRecvFromPollDtoH(std::vector<CommsRequest_t> &list) {};
-double CartesianCommunicator::StencilSendToRecvFromPrepare(std::vector<CommsRequest_t> &list,
 							 void *xmit,
 							 int xmit_to_rank,int dox,
 							 void *recv,
 							 int recv_from_rank,int dor,
-							   uint64_t xbytes,uint64_t rbytes, int dir)
+							 int xbytes,int rbytes, int dir)
-{
-  return 0.0;
-}
-double CartesianCommunicator::StencilSendToRecvFromBegin(std::vector<CommsRequest_t> &list,
-							 void *xmit, void *xmit_comp,
-							 int xmit_to_rank,int dox,
-							 void *recv, void *recv_comp,
-							 int recv_from_rank,int dor,
-							 uint64_t xbytes,uint64_t rbytes, int dir)
 {
   return xbytes+rbytes;
 }

Grid/communicator/SharedMemory.cc

@@ -58,8 +58,8 @@ int                 GlobalSharedMemory::WorldNode;
 
 void GlobalSharedMemory::SharedMemoryFree(void)
 {
-  GRID_ASSERT(_ShmAlloc);
+  assert(_ShmAlloc);
-  GRID_ASSERT(_ShmAllocBytes>0);
+  assert(_ShmAllocBytes>0);
   for(int r=0;r<WorldShmSize;r++){
     munmap(WorldShmCommBufs[r],_ShmAllocBytes);
   }
@@ -80,7 +80,7 @@ void *SharedMemory::HostBufferMalloc(size_t bytes){
     std::cout<< " Current alloc is " << (bytes/(1024*1024)) <<"MB"<<std::endl;
     std::cout<< " Current bytes is " << (host_heap_bytes/(1024*1024)) <<"MB"<<std::endl;
     std::cout<< " Current heap  is " << (host_heap_size/(1024*1024)) <<"MB"<<std::endl;
-    GRID_ASSERT(host_heap_bytes<host_heap_size);
+    assert(host_heap_bytes<host_heap_size);
   }
   return ptr;
 }
@@ -100,7 +100,7 @@ void *SharedMemory::ShmBufferMalloc(size_t bytes){
     std::cout<< " Current alloc is " << (bytes/(1024*1024)) <<"MB"<<std::endl;
     std::cout<< " Current bytes is " << (heap_bytes/(1024*1024)) <<"MB"<<std::endl;
     std::cout<< " Current heap  is " << (heap_size/(1024*1024)) <<"MB"<<std::endl;
-    GRID_ASSERT(heap_bytes<heap_size);
+    assert(heap_bytes<heap_size);
   }
   //std::cerr << "ShmBufferMalloc "<<std::hex<< ptr<<" - "<<((uint64_t)ptr+bytes)<<std::dec<<std::endl;
   return ptr;
@@ -127,13 +127,13 @@ void GlobalSharedMemory::GetShmDims(const Coordinate &WorldDims,Coordinate &ShmD
   if ( str ) {
     std::vector<int> IntShmDims;
     GridCmdOptionIntVector(std::string(str),IntShmDims);
-    GRID_ASSERT(IntShmDims.size() == WorldDims.size());
+    assert(IntShmDims.size() == WorldDims.size());
     long ShmSize = 1;
     for (int dim=0;dim<WorldDims.size();dim++) {
       ShmSize *= (ShmDims[dim] = IntShmDims[dim]);
-      GRID_ASSERT(divides(ShmDims[dim],WorldDims[dim]));
+      assert(divides(ShmDims[dim],WorldDims[dim]));
     }
-    GRID_ASSERT(ShmSize == WorldShmSize);
+    assert(ShmSize == WorldShmSize);
     return;
   }
   

Grid/communicator/SharedMemory.h

@@ -46,40 +46,8 @@ NAMESPACE_BEGIN(Grid);
 
 #if defined (GRID_COMMS_MPI3) 
 typedef MPI_Comm    Grid_MPI_Comm;
-typedef MPI_Request MpiCommsRequest_t;
-#ifdef ACCELERATOR_AWARE_MPI
 typedef MPI_Request CommsRequest_t;
 #else 
-/*
- * Enable state transitions as each packet flows.
- */
-enum PacketType_t {
-  FaceGather,
-  InterNodeXmit,
-  InterNodeRecv,
-  IntraNodeXmit,
-  IntraNodeRecv,
-  InterNodeXmitISend,
-  InterNodeReceiveHtoD
-};
-/*
- *Package arguments needed for various actions along packet flow
- */
-typedef struct {
-  PacketType_t PacketType;
-  void *host_buf;
-  void *device_buf;
-  int dest;
-  int tag;
-  int commdir;
-  unsigned long bytes;
-  acceleratorEvent_t ev;
-  MpiCommsRequest_t req;
-} CommsRequest_t;
-#endif
-
-#else 
-typedef int MpiCommsRequest_t;
 typedef int CommsRequest_t;
 typedef int Grid_MPI_Comm;
 #endif
@@ -137,7 +105,7 @@ public:
   ///////////////////////////////////////////////////
   static void SharedMemoryAllocate(uint64_t bytes, int flags);
   static void SharedMemoryFree(void);
-  //  static void SharedMemoryCopy(void *dest,void *src,size_t bytes);
+  static void SharedMemoryCopy(void *dest,void *src,size_t bytes);
   static void SharedMemoryZero(void *dest,size_t bytes);
 
 };

Grid/communicator/SharedMemoryMPI.cc

@@ -42,7 +42,6 @@ Author: Christoph Lehner <christoph@lhnr.de>
 #ifdef ACCELERATOR_AWARE_MPI
 #define GRID_SYCL_LEVEL_ZERO_IPC
 #define SHM_SOCKETS
-#else
 #endif 
 #include <syscall.h>
 #endif
@@ -67,7 +66,7 @@ public:
   {
     int errnum;
 
-    sock = socket(AF_UNIX, SOCK_DGRAM, 0);  GRID_ASSERT(sock>0);
+    sock = socket(AF_UNIX, SOCK_DGRAM, 0);  assert(sock>0);
 
     struct sockaddr_un sa_un = { 0 };
     sa_un.sun_family = AF_UNIX;
@@ -158,7 +157,7 @@ public:
 /*Construct from an MPI communicator*/
 void GlobalSharedMemory::Init(Grid_MPI_Comm comm)
 {
-  GRID_ASSERT(_ShmSetup==0);
+  assert(_ShmSetup==0);
   WorldComm = comm;
   MPI_Comm_rank(WorldComm,&WorldRank);
   MPI_Comm_size(WorldComm,&WorldSize);
@@ -184,7 +183,7 @@ void GlobalSharedMemory::Init(Grid_MPI_Comm comm)
 
   // WorldNodes
   WorldNodes = WorldSize/WorldShmSize;
-  GRID_ASSERT( (WorldNodes * WorldShmSize) == WorldSize );
+  assert( (WorldNodes * WorldShmSize) == WorldSize );
 
 
   // FIXME: Check all WorldShmSize are the same ?
@@ -209,7 +208,7 @@ void GlobalSharedMemory::Init(Grid_MPI_Comm comm)
   MyGroup.resize(WorldShmSize);
   for(int rank=0;rank<WorldSize;rank++){
     if(WorldShmRanks[rank]!=MPI_UNDEFINED){
-      GRID_ASSERT(g<WorldShmSize);
+      assert(g<WorldShmSize);
       MyGroup[g++] = rank;
     }
   }
@@ -225,7 +224,7 @@ void GlobalSharedMemory::Init(Grid_MPI_Comm comm)
   // global sum leaders over comm world
   ///////////////////////////////////////////////////////////////////
   int ierr=MPI_Allreduce(MPI_IN_PLACE,&leaders_1hot[0],WorldSize,MPI_INT,MPI_SUM,WorldComm);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 
   ///////////////////////////////////////////////////////////////////
   // find the group leaders world rank
@@ -246,7 +245,7 @@ void GlobalSharedMemory::Init(Grid_MPI_Comm comm)
       WorldNode=g;
     }
   }
-  GRID_ASSERT(WorldNode!=-1);
+  assert(WorldNode!=-1);
   _ShmSetup=1;
 }
 // Gray encode support 
@@ -288,7 +287,7 @@ void GlobalSharedMemory::OptimalCommunicatorHypercube(const Coordinate &processo
   // Assert power of two shm_size.
   ////////////////////////////////////////////////////////////////
   int log2size = Log2Size(WorldShmSize,MAXLOG2RANKSPERNODE);
-  GRID_ASSERT(log2size != -1);
+  assert(log2size != -1);
 
   ////////////////////////////////////////////////////////////////
   // Identify the hypercube coordinate of this node using hostname
@@ -309,7 +308,7 @@ void GlobalSharedMemory::OptimalCommunicatorHypercube(const Coordinate &processo
   // Parse ICE-XA hostname to get hypercube location
   gethostname(name,namelen);
   int nscan = sscanf(name,"r%di%dn%d",&R,&I,&N) ;
-  GRID_ASSERT(nscan==3);
+  assert(nscan==3);
 
   int nlo = N%9;
   int nhi = N/9;
@@ -333,8 +332,8 @@ void GlobalSharedMemory::OptimalCommunicatorHypercube(const Coordinate &processo
   //////////////////////////////////////////////////////////////////
   MPI_Bcast(&rootcoor, sizeof(rootcoor), MPI_BYTE, 0, WorldComm); 
   hypercoor=hypercoor-rootcoor;
-  GRID_ASSERT(hypercoor<WorldSize);
+  assert(hypercoor<WorldSize);
-  GRID_ASSERT(hypercoor>=0);
+  assert(hypercoor>=0);
 
   //////////////////////////////////////
   // Printing
@@ -382,7 +381,7 @@ void GlobalSharedMemory::OptimalCommunicatorHypercube(const Coordinate &processo
   for(int i=0;i<ndimension;i++){
     Nprocessors*=processors[i];
   }
-  GRID_ASSERT(WorldSize==Nprocessors);
+  assert(WorldSize==Nprocessors);
 
   ////////////////////////////////////////////////////////////////
   // Establish mapping between lexico physics coord and WorldRank
@@ -401,7 +400,7 @@ void GlobalSharedMemory::OptimalCommunicatorHypercube(const Coordinate &processo
   // Build the new communicator
   /////////////////////////////////////////////////////////////////
   int ierr= MPI_Comm_split(WorldComm,0,rank,&optimal_comm);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 void GlobalSharedMemory::OptimalCommunicatorSharedMemory(const Coordinate &processors,Grid_MPI_Comm & optimal_comm,Coordinate &SHM)
 {
@@ -431,8 +430,7 @@ void GlobalSharedMemory::OptimalCommunicatorSharedMemory(const Coordinate &proce
   for(int i=0;i<ndimension;i++){
     Nprocessors*=processors[i];
   }
-  //  std::cerr << " WorldSize "<<WorldSize << " Nprocessors "<<Nprocessors<<" "<<processors<<std::endl; 
+  assert(WorldSize==Nprocessors);
-  GRID_ASSERT(WorldSize==Nprocessors);
 
   ////////////////////////////////////////////////////////////////
   // Establish mapping between lexico physics coord and WorldRank
@@ -448,7 +446,7 @@ void GlobalSharedMemory::OptimalCommunicatorSharedMemory(const Coordinate &proce
   // Build the new communicator
   /////////////////////////////////////////////////////////////////
   int ierr= MPI_Comm_split(WorldComm,0,rank,&optimal_comm);
-  GRID_ASSERT(ierr==0);
+  assert(ierr==0);
 }
 ////////////////////////////////////////////////////////////////////////////////////////////
 // SHMGET
@@ -457,8 +455,8 @@ void GlobalSharedMemory::OptimalCommunicatorSharedMemory(const Coordinate &proce
 void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 {
   std::cout << Mheader "SharedMemoryAllocate "<< bytes<< " shmget implementation "<<std::endl;
-  GRID_ASSERT(_ShmSetup==1);
+  assert(_ShmSetup==1);
-  GRID_ASSERT(_ShmAlloc==0);
+  assert(_ShmAlloc==0);
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////////
   // allocate the shared windows for our group
@@ -519,8 +517,8 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 {
   void * ShmCommBuf ; 
-  GRID_ASSERT(_ShmSetup==1);
+  assert(_ShmSetup==1);
-  GRID_ASSERT(_ShmAlloc==0);
+  assert(_ShmAlloc==0);
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////////
   // allocate the pointer array for shared windows for our group
@@ -539,8 +537,7 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
   // Each MPI rank should allocate our own buffer
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 #ifndef ACCELERATOR_AWARE_MPI
-  // printf("Host buffer allocate for GPU non-aware MPI\n");
+  HostCommBuf= malloc(bytes);
-  HostCommBuf= malloc(bytes); /// CHANGE THIS TO malloc_host
 #endif  
   ShmCommBuf = acceleratorAllocDevice(bytes);
   if (ShmCommBuf == (void *)NULL ) {
@@ -548,13 +545,11 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
     exit(EXIT_FAILURE);  
   }
   if ( WorldRank == 0 ){
-    std::cout << Mheader " acceleratorAllocDevice "<< bytes 
+    std::cout << WorldRank << Mheader " SharedMemoryMPI.cc acceleratorAllocDevice "<< bytes 
 	      << "bytes at "<< std::hex<< ShmCommBuf << " - "<<(bytes-1+(uint64_t)ShmCommBuf) <<std::dec<<" for comms buffers " <<std::endl;
   }
   SharedMemoryZero(ShmCommBuf,bytes);
-  if ( WorldRank == 0 ){
+  std::cout<< "Setting up IPC"<<std::endl;
-    std::cout<< Mheader "Setting up IPC"<<std::endl;
-  }
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////
   // Loop over ranks/gpu's on our node
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -574,8 +569,8 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 #ifdef GRID_SYCL_LEVEL_ZERO_IPC
     typedef struct { int fd; pid_t pid ; ze_ipc_mem_handle_t ze; } clone_mem_t;
 
-    auto zeDevice    = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(theGridAccelerator->get_device());
+    auto zeDevice    = cl::sycl::get_native<cl::sycl::backend::ext_oneapi_level_zero>(theGridAccelerator->get_device());
-    auto zeContext   = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(theGridAccelerator->get_context());
+    auto zeContext   = cl::sycl::get_native<cl::sycl::backend::ext_oneapi_level_zero>(theGridAccelerator->get_context());
       
     ze_ipc_mem_handle_t ihandle;
     clone_mem_t handle;
@@ -585,6 +580,8 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
       if ( err != ZE_RESULT_SUCCESS ) {
 	std::cerr << "SharedMemoryMPI.cc zeMemGetIpcHandle failed for rank "<<r<<" "<<std::hex<<err<<std::dec<<std::endl;
 	exit(EXIT_FAILURE);
+      } else {
+	std::cout << "SharedMemoryMPI.cc zeMemGetIpcHandle succeeded for rank "<<r<<" "<<std::hex<<err<<std::dec<<std::endl;
       }
       memcpy((void *)&handle.fd,(void *)&ihandle,sizeof(int));
       handle.pid = getpid();
@@ -629,7 +626,7 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 			 MPI_BYTE,
 			 r,
 			 WorldShmComm);
-      GRID_ASSERT(ierr==0);
+      assert(ierr==0);
     }
     
     ///////////////////////////////////////////////////////////////
@@ -643,12 +640,12 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 #ifdef SHM_SOCKETS
       myfd=UnixSockets::RecvFileDescriptor();
 #else
-      //      std::cout<<"mapping seeking remote pid/fd "
+      std::cout<<"mapping seeking remote pid/fd "
-      //	       <<handle.pid<<"/"
+	       <<handle.pid<<"/"
-      //	       <<handle.fd<<std::endl;
+	       <<handle.fd<<std::endl;
 
       int pidfd = syscall(SYS_pidfd_open,handle.pid,0);
-      //      std::cout<<"Using IpcHandle pidfd "<<pidfd<<"\n";
+      std::cout<<"Using IpcHandle pidfd "<<pidfd<<"\n";
       //      int myfd  = syscall(SYS_pidfd_getfd,pidfd,handle.fd,0);
       myfd  = syscall(438,pidfd,handle.fd,0);
       int err_t = errno;
@@ -658,7 +655,7 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 	assert(0);
       }
 #endif
-      //      std::cout<<"Using IpcHandle mapped remote pid "<<handle.pid <<" FD "<<handle.fd <<" to myfd "<<myfd<<"\n";
+      std::cout<<"Using IpcHandle mapped remote pid "<<handle.pid <<" FD "<<handle.fd <<" to myfd "<<myfd<<"\n";
       memcpy((void *)&ihandle,(void *)&handle.ze,sizeof(ihandle));
       memcpy((void *)&ihandle,(void *)&myfd,sizeof(int));
 
@@ -667,8 +664,11 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 	std::cerr << "SharedMemoryMPI.cc "<<zeContext<<" "<<zeDevice<<std::endl;
 	std::cerr << "SharedMemoryMPI.cc zeMemOpenIpcHandle failed for rank "<<r<<" "<<std::hex<<err<<std::dec<<std::endl; 
 	exit(EXIT_FAILURE);
+      } else {
+	std::cout << "SharedMemoryMPI.cc zeMemOpenIpcHandle succeeded for rank "<<r<<std::endl;
+	std::cout << "SharedMemoryMPI.cc zeMemOpenIpcHandle pointer is "<<std::hex<<thisBuf<<std::dec<<std::endl;
       }
-      GRID_ASSERT(thisBuf!=nullptr);
+      assert(thisBuf!=nullptr);
     }
 #endif
 #ifdef GRID_CUDA
@@ -709,8 +709,8 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 {
   std::cout << Mheader "SharedMemoryAllocate "<< bytes<< " MMAP implementation "<< GRID_SHM_PATH <<std::endl;
-  GRID_ASSERT(_ShmSetup==1);
+  assert(_ShmSetup==1);
-  GRID_ASSERT(_ShmAlloc==0);
+  assert(_ShmAlloc==0);
   //////////////////////////////////////////////////////////////////////////////////////////////////////////
   // allocate the shared windows for our group
   //////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -740,14 +740,13 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
     void *ptr = (void *) mmap(NULL, bytes, PROT_READ | PROT_WRITE, mmap_flag,fd, 0); 
     if ( ptr == (void *)MAP_FAILED ) {    
       printf("mmap %s failed\n",shm_name);
-      perror("failed mmap");      GRID_ASSERT(0);    
+      perror("failed mmap");      assert(0);    
     }
-    GRID_ASSERT(((uint64_t)ptr&0x3F)==0);
+    assert(((uint64_t)ptr&0x3F)==0);
     close(fd);
     WorldShmCommBufs[r] =ptr;
     //    std::cout << Mheader "Set WorldShmCommBufs["<<r<<"]="<<ptr<< "("<< bytes<< "bytes)"<<std::endl;
   }
-  std::cout<< Mheader " Intra-node IPC setup is complete "<<std::endl;
   _ShmAlloc=1;
   _ShmAllocBytes  = bytes;
 };
@@ -757,8 +756,8 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 {
   std::cout << Mheader "SharedMemoryAllocate "<< bytes<< " MMAP anonymous implementation "<<std::endl;
-  GRID_ASSERT(_ShmSetup==1);
+  assert(_ShmSetup==1);
-  GRID_ASSERT(_ShmAlloc==0);
+  assert(_ShmAlloc==0);
   //////////////////////////////////////////////////////////////////////////////////////////////////////////
   // allocate the shared windows for our group
   //////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -769,7 +768,7 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
   // Hugetlbf and others map filesystems as mappable huge pages
   ////////////////////////////////////////////////////////////////////////////////////////////
   char shm_name [NAME_MAX];
-  GRID_ASSERT(WorldShmSize == 1);
+  assert(WorldShmSize == 1);
   for(int r=0;r<WorldShmSize;r++){
     
     int fd=-1;
@@ -783,9 +782,9 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
     void *ptr = (void *) mmap(NULL, bytes, PROT_READ | PROT_WRITE, mmap_flag,fd, 0); 
     if ( ptr == (void *)MAP_FAILED ) {    
       printf("mmap %s failed\n",shm_name);
-      perror("failed mmap");      GRID_ASSERT(0);    
+      perror("failed mmap");      assert(0);    
     }
-    GRID_ASSERT(((uint64_t)ptr&0x3F)==0);
+    assert(((uint64_t)ptr&0x3F)==0);
     close(fd);
     WorldShmCommBufs[r] =ptr;
     //    std::cout << "Set WorldShmCommBufs["<<r<<"]="<<ptr<< "("<< bytes<< "bytes)"<<std::endl;
@@ -804,8 +803,8 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 { 
   std::cout << Mheader "SharedMemoryAllocate "<< bytes<< " SHMOPEN implementation "<<std::endl;
-  GRID_ASSERT(_ShmSetup==1);
+  assert(_ShmSetup==1);
-  GRID_ASSERT(_ShmAlloc==0); 
+  assert(_ShmAlloc==0); 
   MPI_Barrier(WorldShmComm);
   WorldShmCommBufs.resize(WorldShmSize);
 
@@ -836,7 +835,7 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 	perror("failed mmap");     
 	assert(0);    
       }
-      GRID_ASSERT(((uint64_t)ptr&0x3F)==0);
+      assert(((uint64_t)ptr&0x3F)==0);
       
       WorldShmCommBufs[r] =ptr;
       close(fd);
@@ -857,8 +856,8 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
       if ( fd<0 ) {	perror("failed shm_open");	assert(0);      }
       
       void * ptr =  mmap(NULL,size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-      if ( ptr == MAP_FAILED ) {       perror("failed mmap");      GRID_ASSERT(0);    }
+      if ( ptr == MAP_FAILED ) {       perror("failed mmap");      assert(0);    }
-      GRID_ASSERT(((uint64_t)ptr&0x3F)==0);
+      assert(((uint64_t)ptr&0x3F)==0);
       WorldShmCommBufs[r] =ptr;
 
       close(fd);
@@ -881,14 +880,14 @@ void GlobalSharedMemory::SharedMemoryZero(void *dest,size_t bytes)
   bzero(dest,bytes);
 #endif
 }
-//void GlobalSharedMemory::SharedMemoryCopy(void *dest,void *src,size_t bytes)
+void GlobalSharedMemory::SharedMemoryCopy(void *dest,void *src,size_t bytes)
-//{
+{
-//#if defined(GRID_CUDA) || defined(GRID_HIP) || defined(GRID_SYCL)
+#if defined(GRID_CUDA) || defined(GRID_HIP) || defined(GRID_SYCL)
-//  acceleratorCopyToDevice(src,dest,bytes);
+  acceleratorCopyToDevice(src,dest,bytes);
-//#else   
+#else   
-//  bcopy(src,dest,bytes);
+  bcopy(src,dest,bytes);
-//#endif
+#endif
-//}
+}
 ////////////////////////////////////////////////////////
 // Global shared functionality finished
 // Now move to per communicator functionality
@@ -915,7 +914,7 @@ void SharedMemory::SetCommunicator(Grid_MPI_Comm comm)
   //////////////////////////////////////////////////////////////////////
   // Map ShmRank to WorldShmRank and use the right buffer
   //////////////////////////////////////////////////////////////////////
-  GRID_ASSERT (GlobalSharedMemory::ShmAlloc()==1);
+  assert (GlobalSharedMemory::ShmAlloc()==1);
   heap_size = GlobalSharedMemory::ShmAllocBytes();
   for(int r=0;r<ShmSize;r++){
 
@@ -924,7 +923,6 @@ void SharedMemory::SetCommunicator(Grid_MPI_Comm comm)
     MPI_Allreduce(MPI_IN_PLACE,&wsr,1,MPI_UINT32_T,MPI_SUM,ShmComm);
 
     ShmCommBufs[r] = GlobalSharedMemory::WorldShmCommBufs[wsr];
-    //    std::cerr << " SetCommunicator rank "<<r<<" comm "<<ShmCommBufs[r] <<std::endl;
   }
   ShmBufferFreeAll();
 
@@ -977,18 +975,19 @@ void SharedMemory::SharedMemoryTest(void)
        check[0]=GlobalSharedMemory::WorldNode;
        check[1]=r;
        check[2]=magic;
-       acceleratorCopyToDevice(check,ShmCommBufs[r],3*sizeof(uint64_t));
+       GlobalSharedMemory::SharedMemoryCopy( ShmCommBufs[r], check, 3*sizeof(uint64_t));
     }
   }
   ShmBarrier();
   for(uint64_t r=0;r<ShmSize;r++){
-    acceleratorCopyFromDevice(ShmCommBufs[r],check,3*sizeof(uint64_t));
-    GRID_ASSERT(check[0]==GlobalSharedMemory::WorldNode);
-    GRID_ASSERT(check[1]==r);
-    GRID_ASSERT(check[2]==magic);
-  }
     ShmBarrier();
-  std::cout << GridLogDebug << " SharedMemoryTest has passed "<<std::endl;
+    GlobalSharedMemory::SharedMemoryCopy(check,ShmCommBufs[r], 3*sizeof(uint64_t));
+    ShmBarrier();
+    assert(check[0]==GlobalSharedMemory::WorldNode);
+    assert(check[1]==r);
+    assert(check[2]==magic);
+    ShmBarrier();
+  }
 }
 
 void *SharedMemory::ShmBuffer(int rank)
@@ -1003,14 +1002,12 @@ void *SharedMemory::ShmBuffer(int rank)
 void *SharedMemory::ShmBufferTranslate(int rank,void * local_p)
 {
   int gpeer = ShmRanks[rank];
-  GRID_ASSERT(gpeer!=ShmRank); // never send to self
+  assert(gpeer!=ShmRank); // never send to self
-  //  std::cout << "ShmBufferTranslate for rank " << rank<<" peer "<<gpeer<<std::endl;
   if (gpeer == MPI_UNDEFINED){
     return NULL;
   } else { 
     uint64_t offset = (uint64_t)local_p - (uint64_t)ShmCommBufs[ShmRank];
     uint64_t remote = (uint64_t)ShmCommBufs[gpeer]+offset;
-    //    std::cout << "ShmBufferTranslate : local,offset,remote "<<std::hex<<local_p<<" "<<offset<<" "<<remote<<std::dec<<std::endl;
     return (void *) remote;
   }
 }

Grid/communicator/SharedMemoryNone.cc

@@ -34,7 +34,7 @@ NAMESPACE_BEGIN(Grid);
 /*Construct from an MPI communicator*/
 void GlobalSharedMemory::Init(Grid_MPI_Comm comm)
 {
-  GRID_ASSERT(_ShmSetup==0);
+  assert(_ShmSetup==0);
   WorldComm = 0;
   WorldRank = 0;
   WorldSize = 1;
@@ -62,8 +62,8 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 {
   std::cout << header "SharedMemoryAllocate "<< bytes<< " GPU implementation "<<std::endl;
   void * ShmCommBuf ; 
-  GRID_ASSERT(_ShmSetup==1);
+  assert(_ShmSetup==1);
-  GRID_ASSERT(_ShmAlloc==0);
+  assert(_ShmAlloc==0);
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////
   // Each MPI rank should allocate our own buffer
@@ -92,8 +92,8 @@ void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 void GlobalSharedMemory::SharedMemoryAllocate(uint64_t bytes, int flags)
 {
   void * ShmCommBuf ; 
-  GRID_ASSERT(_ShmSetup==1);
+  assert(_ShmSetup==1);
-  GRID_ASSERT(_ShmAlloc==0);
+  assert(_ShmAlloc==0);
   int mmap_flag =0;
 #ifdef MAP_ANONYMOUS
   mmap_flag = mmap_flag| MAP_SHARED | MAP_ANONYMOUS;
@@ -122,17 +122,17 @@ void GlobalSharedMemory::SharedMemoryZero(void *dest,size_t bytes)
 {
   acceleratorMemSet(dest,0,bytes);
 }
-//void GlobalSharedMemory::SharedMemoryCopy(void *dest,void *src,size_t bytes)
+void GlobalSharedMemory::SharedMemoryCopy(void *dest,void *src,size_t bytes)
-//{
+{
-//  acceleratorCopyToDevice(src,dest,bytes);
+  acceleratorCopyToDevice(src,dest,bytes);
-//}
+}
 ////////////////////////////////////////////////////////
 // Global shared functionality finished
 // Now move to per communicator functionality
 ////////////////////////////////////////////////////////
 void SharedMemory::SetCommunicator(Grid_MPI_Comm comm)
 {
-  GRID_ASSERT(GlobalSharedMemory::ShmAlloc()==1);
+  assert(GlobalSharedMemory::ShmAlloc()==1);
   ShmRanks.resize(1);
   ShmCommBufs.resize(1);
   ShmRanks[0] = 0;

Grid/cshift/Cshift.h

@@ -51,6 +51,7 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 #endif 
 
 NAMESPACE_BEGIN(Grid);
+
 template<class Expression,typename std::enable_if<is_lattice_expr<Expression>::value,void>::type * = nullptr> 
 auto Cshift(const Expression &expr,int dim,int shift)  -> decltype(closure(expr)) 
 {

Grid/cshift/Cshift_common.h

@@ -30,11 +30,12 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 NAMESPACE_BEGIN(Grid);
 
 extern std::vector<std::pair<int,int> > Cshift_table; 
-extern deviceVector<std::pair<int,int> > Cshift_table_device; 
+extern commVector<std::pair<int,int> > Cshift_table_device; 
 
 inline std::pair<int,int> *MapCshiftTable(void)
 {
   // GPU version
+#ifdef ACCELERATOR_CSHIFT    
   uint64_t sz=Cshift_table.size();
   if (Cshift_table_device.size()!=sz )    {
     Cshift_table_device.resize(sz);
@@ -44,13 +45,16 @@ inline std::pair<int,int> *MapCshiftTable(void)
 			  sizeof(Cshift_table[0])*sz);
 
   return &Cshift_table_device[0];
+#else 
+  return &Cshift_table[0];
+#endif
   // CPU version use identify map
 }
 ///////////////////////////////////////////////////////////////////
 // Gather for when there is no need to SIMD split 
 ///////////////////////////////////////////////////////////////////
 template<class vobj> void 
-Gather_plane_simple (const Lattice<vobj> &rhs,deviceVector<vobj> &buffer,int dimension,int plane,int cbmask, int off=0)
+Gather_plane_simple (const Lattice<vobj> &rhs,cshiftVector<vobj> &buffer,int dimension,int plane,int cbmask, int off=0)
 {
   int rd = rhs.Grid()->_rdimensions[dimension];
 
@@ -90,10 +94,17 @@ Gather_plane_simple (const Lattice<vobj> &rhs,deviceVector<vobj> &buffer,int dim
   {
     auto buffer_p = & buffer[0];
     auto table = MapCshiftTable();
+#ifdef ACCELERATOR_CSHIFT
     autoView(rhs_v , rhs, AcceleratorRead);
     accelerator_for(i,ent,vobj::Nsimd(),{
 	coalescedWrite(buffer_p[table[i].first],coalescedRead(rhs_v[table[i].second]));
     });
+#else
+    autoView(rhs_v , rhs, CpuRead);
+    thread_for(i,ent,{
+      buffer_p[table[i].first]=rhs_v[table[i].second];
+    });
+#endif
   }
 }
 
@@ -118,6 +129,7 @@ Gather_plane_extract(const Lattice<vobj> &rhs,
   int n1=rhs.Grid()->_slice_stride[dimension];
 
   if ( cbmask ==0x3){
+#ifdef ACCELERATOR_CSHIFT
     autoView(rhs_v , rhs, AcceleratorRead);
     accelerator_for(nn,e1*e2,1,{
 	int n = nn%e1;
@@ -128,10 +140,21 @@ Gather_plane_extract(const Lattice<vobj> &rhs,
 	vobj temp =rhs_v[so+o+b];
 	extract<vobj>(temp,pointers,offset);
       });
+#else
+    autoView(rhs_v , rhs, CpuRead);
+    thread_for2d(n,e1,b,e2,{
+	int o      =   n*n1;
+	int offset = b+n*e2;
+	
+	vobj temp =rhs_v[so+o+b];
+	extract<vobj>(temp,pointers,offset);
+      });
+#endif
   } else { 
     Coordinate rdim=rhs.Grid()->_rdimensions;
     Coordinate cdm =rhs.Grid()->_checker_dim_mask;
     std::cout << " Dense packed buffer WARNING " <<std::endl; // Does this get called twice once for each cb?
+#ifdef ACCELERATOR_CSHIFT    
     autoView(rhs_v , rhs, AcceleratorRead);
     accelerator_for(nn,e1*e2,1,{
 	int n = nn%e1;
@@ -152,13 +175,33 @@ Gather_plane_extract(const Lattice<vobj> &rhs,
 	  extract<vobj>(temp,pointers,offset);
 	}
       });
+#else
+    autoView(rhs_v , rhs, CpuRead);
+    thread_for2d(n,e1,b,e2,{
+
+	Coordinate coor;
+
+	int o=n*n1;
+	int oindex = o+b;
+
+       	int cb = RedBlackCheckerBoardFromOindex(oindex, rdim, cdm);
+
+	int ocb=1<<cb;
+	int offset = b+n*e2;
+
+	if ( ocb & cbmask ) {
+	  vobj temp =rhs_v[so+o+b];
+	  extract<vobj>(temp,pointers,offset);
+	}
+      });
+#endif
   }
 }
 
 //////////////////////////////////////////////////////
 // Scatter for when there is no need to SIMD split
 //////////////////////////////////////////////////////
-template<class vobj> void Scatter_plane_simple (Lattice<vobj> &rhs,deviceVector<vobj> &buffer, int dimension,int plane,int cbmask)
+template<class vobj> void Scatter_plane_simple (Lattice<vobj> &rhs,cshiftVector<vobj> &buffer, int dimension,int plane,int cbmask)
 {
   int rd = rhs.Grid()->_rdimensions[dimension];
 
@@ -202,10 +245,17 @@ template<class vobj> void Scatter_plane_simple (Lattice<vobj> &rhs,deviceVector<
   {
     auto buffer_p = & buffer[0];
     auto table = MapCshiftTable();
-    autoView( rhs_v, rhs, AcceleratorWriteDiscard);
+#ifdef ACCELERATOR_CSHIFT    
+    autoView( rhs_v, rhs, AcceleratorWrite);
     accelerator_for(i,ent,vobj::Nsimd(),{
 	coalescedWrite(rhs_v[table[i].first],coalescedRead(buffer_p[table[i].second]));
     });
+#else
+    autoView( rhs_v, rhs, CpuWrite);
+    thread_for(i,ent,{
+      rhs_v[table[i].first]=buffer_p[table[i].second];
+    });
+#endif
   }
 }
 
@@ -228,7 +278,8 @@ template<class vobj> void Scatter_plane_merge(Lattice<vobj> &rhs,ExtractPointerA
   if(cbmask ==0x3 ) {
     int _slice_stride = rhs.Grid()->_slice_stride[dimension];
     int _slice_block = rhs.Grid()->_slice_block[dimension];
-    autoView( rhs_v , rhs, AcceleratorWriteDiscard);
+#ifdef ACCELERATOR_CSHIFT    
+    autoView( rhs_v , rhs, AcceleratorWrite);
     accelerator_for(nn,e1*e2,1,{
 	int n = nn%e1;
 	int b = nn/e1;
@@ -236,13 +287,21 @@ template<class vobj> void Scatter_plane_merge(Lattice<vobj> &rhs,ExtractPointerA
 	int offset = b+n*_slice_block;
 	merge(rhs_v[so+o+b],pointers,offset);
       });
+#else
+    autoView( rhs_v , rhs, CpuWrite);
+    thread_for2d(n,e1,b,e2,{
+	int o      = n*_slice_stride;
+	int offset = b+n*_slice_block;
+	merge(rhs_v[so+o+b],pointers,offset);
+    });
+#endif
   } else { 
 
     // Case of SIMD split AND checker dim cannot currently be hit, except in 
     // Test_cshift_red_black code.
-    std::cout << "Scatter_plane merge GRID_ASSERT(0); think this is buggy FIXME "<< std::endl;// think this is buggy FIXME
+    std::cout << "Scatter_plane merge assert(0); think this is buggy FIXME "<< std::endl;// think this is buggy FIXME
     std::cout<<" Unthreaded warning -- buffer is not densely packed ??"<<std::endl;
-    GRID_ASSERT(0); // This will fail if hit on GPU
+    assert(0); // This will fail if hit on GPU
     autoView( rhs_v, rhs, CpuWrite);
     for(int n=0;n<e1;n++){
       for(int b=0;b<e2;b++){
@@ -301,11 +360,19 @@ template<class vobj> void Copy_plane(Lattice<vobj>& lhs,const Lattice<vobj> &rhs
 
   {
     auto table = MapCshiftTable();
+#ifdef ACCELERATOR_CSHIFT    
     autoView(rhs_v , rhs, AcceleratorRead);
-    autoView(lhs_v , lhs, AcceleratorWriteDiscard);
+    autoView(lhs_v , lhs, AcceleratorWrite);
     accelerator_for(i,ent,vobj::Nsimd(),{
       coalescedWrite(lhs_v[table[i].first],coalescedRead(rhs_v[table[i].second]));
     });
+#else
+    autoView(rhs_v , rhs, CpuRead);
+    autoView(lhs_v , lhs, CpuWrite);
+    thread_for(i,ent,{
+      lhs_v[table[i].first]=rhs_v[table[i].second];
+    });
+#endif
   }
 }
 
@@ -345,11 +412,19 @@ template<class vobj> void Copy_plane_permute(Lattice<vobj>& lhs,const Lattice<vo
 
   {
     auto table = MapCshiftTable();
+#ifdef ACCELERATOR_CSHIFT    
     autoView( rhs_v, rhs, AcceleratorRead);
     autoView( lhs_v, lhs, AcceleratorWrite);
     accelerator_for(i,ent,1,{
       permute(lhs_v[table[i].first],rhs_v[table[i].second],permute_type);
     });
+#else
+    autoView( rhs_v, rhs, CpuRead);
+    autoView( lhs_v, lhs, CpuWrite);
+    thread_for(i,ent,{
+      permute(lhs_v[table[i].first],rhs_v[table[i].second],permute_type);
+    });
+#endif
   }
 }
 

Grid/cshift/Cshift_mpi.h

@@ -29,13 +29,9 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 #ifndef _GRID_CSHIFT_MPI_H_
 #define _GRID_CSHIFT_MPI_H_
 
+
 NAMESPACE_BEGIN(Grid); 
 
-#ifdef GRID_CHECKSUM_COMMS
-extern uint64_t checksum_index;
-#endif
-
-const int Cshift_verbose=0;
 template<class vobj> Lattice<vobj> Cshift(const Lattice<vobj> &rhs,int dimension,int shift)
 {
   typedef typename vobj::vector_type vector_type;
@@ -49,20 +45,6 @@ template<class vobj> Lattice<vobj> Cshift(const Lattice<vobj> &rhs,int dimension
   // Map to always positive shift modulo global full dimension.
   shift = (shift+fd)%fd;
 
-  if( shift ==0 ) {
-    ret = rhs;
-    return ret;
-  }
-  //
-  // Potential easy fast cases:
-  // Shift is a multiple of the local lattice extent.
-  // Then need only to shift whole subvolumes
-  int L = rhs.Grid()->_ldimensions[dimension];
-  if ( (shift%L )==0 && !rhs.Grid()->CheckerBoarded(dimension) ) {
-    Cshift_simple(ret,rhs,dimension,shift);
-    return ret;
-  }
-  
   ret.Checkerboard() = rhs.Grid()->CheckerBoardDestination(rhs.Checkerboard(),shift,dimension);
         
   // the permute type
@@ -83,59 +65,10 @@ template<class vobj> Lattice<vobj> Cshift(const Lattice<vobj> &rhs,int dimension
     Cshift_comms(ret,rhs,dimension,shift);
   }
   t1=usecond();
-  if(Cshift_verbose) std::cout << GridLogPerformance << "Cshift took "<< (t1-t0)/1e3 << " ms"<<std::endl;
+  //  std::cout << GridLogPerformance << "Cshift took "<< (t1-t0)/1e3 << " ms"<<std::endl;
   return ret;
 }
 
-template<class vobj> void Cshift_simple(Lattice<vobj>& ret,const Lattice<vobj> &rhs,int dimension,int shift)
-{
-  GridBase *grid=rhs.Grid();
-  int comm_proc, xmit_to_rank, recv_from_rank;
-  
-  int fd              = rhs.Grid()->_fdimensions[dimension];
-  int rd              = rhs.Grid()->_rdimensions[dimension];
-  int ld              = rhs.Grid()->_ldimensions[dimension];
-  int pd              = rhs.Grid()->_processors[dimension];
-  int simd_layout     = rhs.Grid()->_simd_layout[dimension];
-  int comm_dim        = rhs.Grid()->_processors[dimension] >1 ;
-
-  comm_proc = ((shift)/ld)%pd;
-
-  grid->ShiftedRanks(dimension,comm_proc,xmit_to_rank,recv_from_rank);
-  if(comm_dim) {
-
-    int64_t bytes = sizeof(vobj) * grid->oSites();
-
-    autoView(rhs_v , rhs, AcceleratorRead);
-    autoView(ret_v , ret, AcceleratorWrite);
-    void *send_buf  = (void *)&rhs_v[0];
-    void *recv_buf  = (void *)&ret_v[0];
-
-#ifdef ACCELERATOR_AWARE_MPI
-    grid->SendToRecvFrom(send_buf,
-			 xmit_to_rank,
-			 recv_buf,
-			 recv_from_rank,
-			 bytes);
-#else
-    static hostVector<vobj> hrhs; hrhs.resize(grid->oSites());
-    static hostVector<vobj> hret; hret.resize(grid->oSites());
-
-    void *hsend_buf = (void *)&hrhs[0];
-    void *hrecv_buf = (void *)&hret[0];
-
-    acceleratorCopyFromDevice(send_buf,hsend_buf,bytes);
-
-    grid->SendToRecvFrom(hsend_buf,
-			 xmit_to_rank,
-			 hrecv_buf,
-			 recv_from_rank,
-			 bytes);
-
-    acceleratorCopyToDevice(hrecv_buf,recv_buf,bytes);
-#endif
-  }
-}
 template<class vobj> void Cshift_comms(Lattice<vobj>& ret,const Lattice<vobj> &rhs,int dimension,int shift)
 {
   int sshift[2];
@@ -161,7 +94,7 @@ template<class vobj> void Cshift_comms_simd(Lattice<vobj>& ret,const Lattice<vob
   sshift[0] = rhs.Grid()->CheckerBoardShiftForCB(rhs.Checkerboard(),dimension,shift,Even);
   sshift[1] = rhs.Grid()->CheckerBoardShiftForCB(rhs.Checkerboard(),dimension,shift,Odd);
 
-  //  std::cout << "Cshift_comms_simd dim "<<dimension<<"cb "<<rhs.Checkerboard()<<"shift "<<shift<<" sshift " << sshift[0]<<" "<<sshift[1]<<std::endl;
+  //std::cout << "Cshift_comms_simd dim "<<dimension<<"cb "<<rhs.checkerboard<<"shift "<<shift<<" sshift " << sshift[0]<<" "<<sshift[1]<<std::endl;
   if ( sshift[0] == sshift[1] ) {
     //std::cout << "Single pass Cshift_comms" <<std::endl;
     Cshift_comms_simd(ret,rhs,dimension,shift,0x3);
@@ -171,6 +104,8 @@ template<class vobj> void Cshift_comms_simd(Lattice<vobj>& ret,const Lattice<vob
     Cshift_comms_simd(ret,rhs,dimension,shift,0x2);// both with block stride loop iteration
   }
 }
+#define ACCELERATOR_CSHIFT_NO_COPY
+#ifdef ACCELERATOR_CSHIFT_NO_COPY
 template<class vobj> void Cshift_comms(Lattice<vobj> &ret,const Lattice<vobj> &rhs,int dimension,int shift,int cbmask)
 {
   typedef typename vobj::vector_type vector_type;
@@ -184,19 +119,14 @@ template<class vobj> void Cshift_comms(Lattice<vobj> &ret,const Lattice<vobj> &r
   int pd              = rhs.Grid()->_processors[dimension];
   int simd_layout     = rhs.Grid()->_simd_layout[dimension];
   int comm_dim        = rhs.Grid()->_processors[dimension] >1 ;
-  GRID_ASSERT(simd_layout==1);
+  assert(simd_layout==1);
-  GRID_ASSERT(comm_dim==1);
+  assert(comm_dim==1);
-  GRID_ASSERT(shift>=0);
+  assert(shift>=0);
-  GRID_ASSERT(shift<fd);
+  assert(shift<fd);
   
   int buffer_size = rhs.Grid()->_slice_nblock[dimension]*rhs.Grid()->_slice_block[dimension];
-  static deviceVector<vobj> send_buf; send_buf.resize(buffer_size);
+  static cshiftVector<vobj> send_buf; send_buf.resize(buffer_size);
-  static deviceVector<vobj> recv_buf; recv_buf.resize(buffer_size);
+  static cshiftVector<vobj> recv_buf; recv_buf.resize(buffer_size);
-#ifndef ACCELERATOR_AWARE_MPI
-  int pad = (8 + sizeof(vobj) - 1) / sizeof(vobj);
-  static hostVector<vobj> hsend_buf; hsend_buf.resize(buffer_size+pad);
-  static hostVector<vobj> hrecv_buf; hrecv_buf.resize(buffer_size+pad);
-#endif
     
   int cb= (cbmask==0x2)? Odd : Even;
   int sshift= rhs.Grid()->CheckerBoardShiftForCB(rhs.Checkerboard(),dimension,shift,cb);
@@ -211,11 +141,9 @@ template<class vobj> void Cshift_comms(Lattice<vobj> &ret,const Lattice<vobj> &r
     int comm_proc = ((x+sshift)/rd)%pd;
     
     if (comm_proc==0) {
-      FlightRecorder::StepLog("Cshift_Copy_plane");
       tcopy-=usecond();
       Copy_plane(ret,rhs,dimension,x,sx,cbmask); 
       tcopy+=usecond();
-      FlightRecorder::StepLog("Cshift_Copy_plane_complete");
     } else {
 
       int words = buffer_size;
@@ -223,84 +151,39 @@ template<class vobj> void Cshift_comms(Lattice<vobj> &ret,const Lattice<vobj> &r
 
       int bytes = words * sizeof(vobj);
 
-      FlightRecorder::StepLog("Cshift_Gather_plane");
       tgather-=usecond();
       Gather_plane_simple (rhs,send_buf,dimension,sx,cbmask);
       tgather+=usecond();
-      FlightRecorder::StepLog("Cshift_Gather_plane_complete");
 
       //      int rank           = grid->_processor;
       int recv_from_rank;
       int xmit_to_rank;
-
       grid->ShiftedRanks(dimension,comm_proc,xmit_to_rank,recv_from_rank);
       
       tcomms-=usecond();
-      grid->Barrier();
+      //      grid->Barrier();
 
-      FlightRecorder::StepLog("Cshift_SendRecv");
-#ifdef ACCELERATOR_AWARE_MPI
       grid->SendToRecvFrom((void *)&send_buf[0],
 			   xmit_to_rank,
 			   (void *)&recv_buf[0],
 			   recv_from_rank,
 			   bytes);
-#else
-      // bouncy bouncy
-      acceleratorCopyFromDevice(&send_buf[0],&hsend_buf[0],bytes);
-
-#ifdef GRID_CHECKSUM_COMMS
-      GRID_ASSERT(bytes % 8 == 0);
-      checksum_index++;
-      uint64_t xsum = checksum_gpu((uint64_t*)&send_buf[0], bytes / 8) ^ (1 + checksum_index);
-      *(uint64_t*)(((char*)&hsend_buf[0]) + bytes) = xsum;
-      bytes += 8;
-#endif
-
-      grid->SendToRecvFrom((void *)&hsend_buf[0],
-			   xmit_to_rank,
-			   (void *)&hrecv_buf[0],
-			   recv_from_rank,
-			   bytes);
-
-#ifdef GRID_CHECKSUM_COMMS
-      bytes -= 8;
-      acceleratorCopyToDevice(&hrecv_buf[0],&recv_buf[0],bytes);
-      uint64_t expected_cs = *(uint64_t*)(((char*)&hrecv_buf[0]) + bytes);
-      uint64_t computed_cs = checksum_gpu((uint64_t*)&recv_buf[0], bytes / 8) ^ (1 + checksum_index);
-      std::cout << GridLogComms<< " Cshift: "
-		<<" dim"<<dimension
-		<<" shift "<<shift
-		<< " rank "<< grid->ThisRank()
-		<<" Coor "<<grid->ThisProcessorCoor()
-		<<" send "<<xsum<<" to   "<<xmit_to_rank
-		<<" recv "<<computed_cs<<" from "<<recv_from_rank
-		<<std::endl;
-      GRID_ASSERT(expected_cs == computed_cs);
-#else
-      acceleratorCopyToDevice(&hrecv_buf[0],&recv_buf[0],bytes);
-#endif
-
-#endif
-      FlightRecorder::StepLog("Cshift_SendRecv_complete");
-
       xbytes+=bytes;
-      grid->Barrier();
+      //      grid->Barrier();
       tcomms+=usecond();
-      FlightRecorder::StepLog("Cshift_barrier_complete");
 
       tscatter-=usecond();
       Scatter_plane_simple (ret,recv_buf,dimension,x,cbmask);
       tscatter+=usecond();
     }
   }
-  if (Cshift_verbose){
+  /*
   std::cout << GridLogPerformance << " Cshift copy    "<<tcopy/1e3<<" ms"<<std::endl;
   std::cout << GridLogPerformance << " Cshift gather  "<<tgather/1e3<<" ms"<<std::endl;
   std::cout << GridLogPerformance << " Cshift scatter "<<tscatter/1e3<<" ms"<<std::endl;
   std::cout << GridLogPerformance << " Cshift comm    "<<tcomms/1e3<<" ms"<<std::endl;
   std::cout << GridLogPerformance << " Cshift BW      "<<(2.0*xbytes)/tcomms<<" MB/s "<<2*xbytes<< " Bytes "<<std::endl;
-  }
+  */
 }
 
 template<class vobj> void  Cshift_comms_simd(Lattice<vobj> &ret,const Lattice<vobj> &rhs,int dimension,int shift,int cbmask)
@@ -322,10 +205,10 @@ template<class vobj> void  Cshift_comms_simd(Lattice<vobj> &ret,const Lattice<vo
   //    << " ld "<<ld<<" pd " << pd<<" simd_layout "<<simd_layout 
   //    << " comm_dim " << comm_dim << " cbmask " << cbmask <<std::endl;
 
-  GRID_ASSERT(comm_dim==1);
+  assert(comm_dim==1);
-  GRID_ASSERT(simd_layout==2);
+  assert(simd_layout==2);
-  GRID_ASSERT(shift>=0);
+  assert(shift>=0);
-  GRID_ASSERT(shift<fd);
+  assert(shift<fd);
 
   RealD tcopy=0.0;
   RealD tgather=0.0;
@@ -341,8 +224,8 @@ template<class vobj> void  Cshift_comms_simd(Lattice<vobj> &ret,const Lattice<vo
   int buffer_size = grid->_slice_nblock[dimension]*grid->_slice_block[dimension];
   //  int words = sizeof(vobj)/sizeof(vector_type);
 
-  static std::vector<deviceVector<scalar_object> >  send_buf_extract; send_buf_extract.resize(Nsimd);
+  static std::vector<cshiftVector<scalar_object> >  send_buf_extract; send_buf_extract.resize(Nsimd);
-  static std::vector<deviceVector<scalar_object> >  recv_buf_extract; recv_buf_extract.resize(Nsimd);
+  static std::vector<cshiftVector<scalar_object> >  recv_buf_extract; recv_buf_extract.resize(Nsimd);
   scalar_object *  recv_buf_extract_mpi;
   scalar_object *  send_buf_extract_mpi;
  
@@ -350,18 +233,6 @@ template<class vobj> void  Cshift_comms_simd(Lattice<vobj> &ret,const Lattice<vo
     send_buf_extract[s].resize(buffer_size);
     recv_buf_extract[s].resize(buffer_size);
   }
-#ifndef ACCELERATOR_AWARE_MPI
-#ifdef GRID_CHECKSUM_COMMS
-  buffer_size += (8 + sizeof(vobj) - 1) / sizeof(vobj);
-#endif
-
-  static hostVector<vobj> hsend_buf; hsend_buf.resize(buffer_size);
-  static hostVector<vobj> hrecv_buf; hrecv_buf.resize(buffer_size);
-
-#ifdef GRID_CHECKSUM_COMMS
-  buffer_size -= (8 + sizeof(vobj) - 1) / sizeof(vobj);
-#endif
-#endif
 
   int bytes = buffer_size*sizeof(scalar_object);
 
@@ -404,60 +275,24 @@ template<class vobj> void  Cshift_comms_simd(Lattice<vobj> &ret,const Lattice<vo
 
       if (nbr_ic) nbr_lane|=inner_bit;
 
-      GRID_ASSERT (sx == nbr_ox);
+      assert (sx == nbr_ox);
 
       if(nbr_proc){
 	grid->ShiftedRanks(dimension,nbr_proc,xmit_to_rank,recv_from_rank); 
 
 	tcomms-=usecond();
-	grid->Barrier();
+	//	grid->Barrier();
 
 	send_buf_extract_mpi = &send_buf_extract[nbr_lane][0];
 	recv_buf_extract_mpi = &recv_buf_extract[i][0];
-#ifdef ACCELERATOR_AWARE_MPI
 	grid->SendToRecvFrom((void *)send_buf_extract_mpi,
 			     xmit_to_rank,
 			     (void *)recv_buf_extract_mpi,
 			     recv_from_rank,
 			     bytes);
-#else
-      // bouncy bouncy
-	acceleratorCopyFromDevice((void *)send_buf_extract_mpi,(void *)&hsend_buf[0],bytes);
-#ifdef GRID_CHECKSUM_COMMS
-	assert(bytes % 8 == 0);
-	checksum_index++;
-	uint64_t xsum = checksum_gpu((uint64_t*)send_buf_extract_mpi, bytes / 8) ^ (1 + checksum_index);
-	*(uint64_t*)(((char*)&hsend_buf[0]) + bytes) = xsum;
-	bytes += 8;
-#endif
-	grid->SendToRecvFrom((void *)&hsend_buf[0],
-			     xmit_to_rank,
-			     (void *)&hrecv_buf[0],
-			     recv_from_rank,
-			     bytes);
-#ifdef GRID_CHECKSUM_COMMS
-	bytes -= 8;
-	acceleratorCopyToDevice((void *)&hrecv_buf[0],(void *)recv_buf_extract_mpi,bytes);
-	uint64_t expected_cs = *(uint64_t*)(((char*)&hrecv_buf[0]) + bytes);
-	uint64_t computed_cs = checksum_gpu((uint64_t*)recv_buf_extract_mpi, bytes / 8) ^ (1 + checksum_index);
-
-	std::cout << GridLogComms<< " Cshift_comms_simd: "
-		<<" dim"<<dimension
-		<<" shift "<<shift
-		<< " rank "<< grid->ThisRank()
-		<<" Coor "<<grid->ThisProcessorCoor()
-		<<" send "<<xsum<<" to   "<<xmit_to_rank
-		<<" recv "<<computed_cs<<" from "<<recv_from_rank
-		<<std::endl;
-	assert(expected_cs == computed_cs);
-#else
-	acceleratorCopyToDevice((void *)&hrecv_buf[0],(void *)recv_buf_extract_mpi,bytes);
-#endif
-
-#endif
 
 	xbytes+=bytes;
-	grid->Barrier();
+	//	grid->Barrier();
 	tcomms+=usecond();
 
 	rpointers[i] = &recv_buf_extract[i][0];
@@ -470,15 +305,242 @@ template<class vobj> void  Cshift_comms_simd(Lattice<vobj> &ret,const Lattice<vo
     Scatter_plane_merge(ret,rpointers,dimension,x,cbmask);
     tscatter+=usecond();
   }
-  if(Cshift_verbose){
+  /*
   std::cout << GridLogPerformance << " Cshift (s) copy    "<<tcopy/1e3<<" ms"<<std::endl;
   std::cout << GridLogPerformance << " Cshift (s) gather  "<<tgather/1e3<<" ms"<<std::endl;
   std::cout << GridLogPerformance << " Cshift (s) scatter "<<tscatter/1e3<<" ms"<<std::endl;
   std::cout << GridLogPerformance << " Cshift (s) comm    "<<tcomms/1e3<<" ms"<<std::endl;
   std::cout << GridLogPerformance << " Cshift BW      "<<(2.0*xbytes)/tcomms<<" MB/s "<<2*xbytes<< " Bytes "<<std::endl;
+  */
 }
+#else 
+template<class vobj> void Cshift_comms(Lattice<vobj> &ret,const Lattice<vobj> &rhs,int dimension,int shift,int cbmask)
+{
+  typedef typename vobj::vector_type vector_type;
+  typedef typename vobj::scalar_type scalar_type;
+
+  GridBase *grid=rhs.Grid();
+  Lattice<vobj> temp(rhs.Grid());
+
+  int fd              = rhs.Grid()->_fdimensions[dimension];
+  int rd              = rhs.Grid()->_rdimensions[dimension];
+  int pd              = rhs.Grid()->_processors[dimension];
+  int simd_layout     = rhs.Grid()->_simd_layout[dimension];
+  int comm_dim        = rhs.Grid()->_processors[dimension] >1 ;
+  assert(simd_layout==1);
+  assert(comm_dim==1);
+  assert(shift>=0);
+  assert(shift<fd);
+  RealD tcopy=0.0;
+  RealD tgather=0.0;
+  RealD tscatter=0.0;
+  RealD tcomms=0.0;
+  uint64_t xbytes=0;
+  
+  int buffer_size = rhs.Grid()->_slice_nblock[dimension]*rhs.Grid()->_slice_block[dimension];
+  static cshiftVector<vobj> send_buf_v; send_buf_v.resize(buffer_size);
+  static cshiftVector<vobj> recv_buf_v; recv_buf_v.resize(buffer_size);
+  vobj *send_buf;
+  vobj *recv_buf;
+  {
+    grid->ShmBufferFreeAll();
+    size_t bytes = buffer_size*sizeof(vobj);
+    send_buf=(vobj *)grid->ShmBufferMalloc(bytes);
+    recv_buf=(vobj *)grid->ShmBufferMalloc(bytes);
   }
     
+  int cb= (cbmask==0x2)? Odd : Even;
+  int sshift= rhs.Grid()->CheckerBoardShiftForCB(rhs.Checkerboard(),dimension,shift,cb);
+
+  for(int x=0;x<rd;x++){       
+
+    int sx        =  (x+sshift)%rd;
+    int comm_proc = ((x+sshift)/rd)%pd;
+    
+    if (comm_proc==0) {
+
+      tcopy-=usecond();
+      Copy_plane(ret,rhs,dimension,x,sx,cbmask); 
+      tcopy+=usecond();
+
+    } else {
+
+      int words = buffer_size;
+      if (cbmask != 0x3) words=words>>1;
+
+      int bytes = words * sizeof(vobj);
+
+      tgather-=usecond();
+      Gather_plane_simple (rhs,send_buf_v,dimension,sx,cbmask);
+      tgather+=usecond();
+
+      //      int rank           = grid->_processor;
+      int recv_from_rank;
+      int xmit_to_rank;
+      grid->ShiftedRanks(dimension,comm_proc,xmit_to_rank,recv_from_rank);
+
+
+      tcomms-=usecond();
+      //      grid->Barrier();
+
+      acceleratorCopyDeviceToDevice((void *)&send_buf_v[0],(void *)&send_buf[0],bytes);
+      grid->SendToRecvFrom((void *)&send_buf[0],
+			   xmit_to_rank,
+			   (void *)&recv_buf[0],
+			   recv_from_rank,
+			   bytes);
+      xbytes+=bytes;
+      acceleratorCopyDeviceToDevice((void *)&recv_buf[0],(void *)&recv_buf_v[0],bytes);
+
+      //      grid->Barrier();
+      tcomms+=usecond();
+
+      tscatter-=usecond();
+      Scatter_plane_simple (ret,recv_buf_v,dimension,x,cbmask);
+      tscatter+=usecond();
+    }
+  }
+  /*
+  std::cout << GridLogPerformance << " Cshift copy    "<<tcopy/1e3<<" ms"<<std::endl;
+  std::cout << GridLogPerformance << " Cshift gather  "<<tgather/1e3<<" ms"<<std::endl;
+  std::cout << GridLogPerformance << " Cshift scatter "<<tscatter/1e3<<" ms"<<std::endl;
+  std::cout << GridLogPerformance << " Cshift comm    "<<tcomms/1e3<<" ms"<<std::endl;
+  std::cout << GridLogPerformance << " Cshift BW      "<<(2.0*xbytes)/tcomms<<" MB/s "<<2*xbytes<< " Bytes "<<std::endl;
+  */
+}
+
+template<class vobj> void  Cshift_comms_simd(Lattice<vobj> &ret,const Lattice<vobj> &rhs,int dimension,int shift,int cbmask)
+{
+  GridBase *grid=rhs.Grid();
+  const int Nsimd = grid->Nsimd();
+  typedef typename vobj::vector_type vector_type;
+  typedef typename vobj::scalar_object scalar_object;
+  typedef typename vobj::scalar_type scalar_type;
+   
+  int fd = grid->_fdimensions[dimension];
+  int rd = grid->_rdimensions[dimension];
+  int ld = grid->_ldimensions[dimension];
+  int pd = grid->_processors[dimension];
+  int simd_layout     = grid->_simd_layout[dimension];
+  int comm_dim        = grid->_processors[dimension] >1 ;
+
+  //std::cout << "Cshift_comms_simd dim "<< dimension << " fd "<<fd<<" rd "<<rd
+  //    << " ld "<<ld<<" pd " << pd<<" simd_layout "<<simd_layout 
+  //    << " comm_dim " << comm_dim << " cbmask " << cbmask <<std::endl;
+
+  assert(comm_dim==1);
+  assert(simd_layout==2);
+  assert(shift>=0);
+  assert(shift<fd);
+  RealD tcopy=0.0;
+  RealD tgather=0.0;
+  RealD tscatter=0.0;
+  RealD tcomms=0.0;
+  uint64_t xbytes=0;
+
+  int permute_type=grid->PermuteType(dimension);
+
+  ///////////////////////////////////////////////
+  // Simd direction uses an extract/merge pair
+  ///////////////////////////////////////////////
+  int buffer_size = grid->_slice_nblock[dimension]*grid->_slice_block[dimension];
+  //  int words = sizeof(vobj)/sizeof(vector_type);
+
+  static std::vector<cshiftVector<scalar_object> >  send_buf_extract; send_buf_extract.resize(Nsimd);
+  static std::vector<cshiftVector<scalar_object> >  recv_buf_extract; recv_buf_extract.resize(Nsimd);
+  scalar_object *  recv_buf_extract_mpi;
+  scalar_object *  send_buf_extract_mpi;
+  {
+    size_t bytes = sizeof(scalar_object)*buffer_size;
+    grid->ShmBufferFreeAll();
+    send_buf_extract_mpi = (scalar_object *)grid->ShmBufferMalloc(bytes);
+    recv_buf_extract_mpi = (scalar_object *)grid->ShmBufferMalloc(bytes);
+  }
+  for(int s=0;s<Nsimd;s++){
+    send_buf_extract[s].resize(buffer_size);
+    recv_buf_extract[s].resize(buffer_size);
+  }
+
+  int bytes = buffer_size*sizeof(scalar_object);
+
+  ExtractPointerArray<scalar_object>  pointers(Nsimd); // 
+  ExtractPointerArray<scalar_object> rpointers(Nsimd); // received pointers
+
+  ///////////////////////////////////////////
+  // Work out what to send where
+  ///////////////////////////////////////////
+  int cb    = (cbmask==0x2)? Odd : Even;
+  int sshift= grid->CheckerBoardShiftForCB(rhs.Checkerboard(),dimension,shift,cb);
+
+  // loop over outer coord planes orthog to dim
+  for(int x=0;x<rd;x++){       
+
+    // FIXME call local permute copy if none are offnode.
+    for(int i=0;i<Nsimd;i++){       
+      pointers[i] = &send_buf_extract[i][0];
+    }
+    tgather-=usecond();
+    int sx   = (x+sshift)%rd;
+    Gather_plane_extract(rhs,pointers,dimension,sx,cbmask);
+    tgather+=usecond();
+
+    for(int i=0;i<Nsimd;i++){
+      
+      int inner_bit = (Nsimd>>(permute_type+1));
+      int ic= (i&inner_bit)? 1:0;
+
+      int my_coor          = rd*ic + x;
+      int nbr_coor         = my_coor+sshift;
+      int nbr_proc = ((nbr_coor)/ld) % pd;// relative shift in processors
+
+      int nbr_ic   = (nbr_coor%ld)/rd;    // inner coord of peer
+      int nbr_ox   = (nbr_coor%rd);       // outer coord of peer
+      int nbr_lane = (i&(~inner_bit));
+
+      int recv_from_rank;
+      int xmit_to_rank;
+
+      if (nbr_ic) nbr_lane|=inner_bit;
+
+      assert (sx == nbr_ox);
+
+      if(nbr_proc){
+	grid->ShiftedRanks(dimension,nbr_proc,xmit_to_rank,recv_from_rank); 
+
+	tcomms-=usecond();
+	//	grid->Barrier();
+
+	acceleratorCopyDeviceToDevice((void *)&send_buf_extract[nbr_lane][0],(void *)send_buf_extract_mpi,bytes);
+	grid->SendToRecvFrom((void *)send_buf_extract_mpi,
+			     xmit_to_rank,
+			     (void *)recv_buf_extract_mpi,
+			     recv_from_rank,
+			     bytes);
+	acceleratorCopyDeviceToDevice((void *)recv_buf_extract_mpi,(void *)&recv_buf_extract[i][0],bytes);
+	xbytes+=bytes;
+
+	//	grid->Barrier();
+	tcomms+=usecond();
+	rpointers[i] = &recv_buf_extract[i][0];
+      } else { 
+	rpointers[i] = &send_buf_extract[nbr_lane][0];
+      }
+
+    }
+    tscatter-=usecond();
+    Scatter_plane_merge(ret,rpointers,dimension,x,cbmask);
+    tscatter+=usecond();
+
+  }
+  /*
+  std::cout << GridLogPerformance << " Cshift (s) copy    "<<tcopy/1e3<<" ms"<<std::endl;
+  std::cout << GridLogPerformance << " Cshift (s) gather  "<<tgather/1e3<<" ms"<<std::endl;
+  std::cout << GridLogPerformance << " Cshift (s) scatter "<<tscatter/1e3<<" ms"<<std::endl;
+  std::cout << GridLogPerformance << " Cshift (s) comm    "<<tcomms/1e3<<" ms"<<std::endl;
+  std::cout << GridLogPerformance << " Cshift BW      "<<(2.0*xbytes)/tcomms<<" MB/s"<<std::endl;
+  */
+}
+#endif
 NAMESPACE_END(Grid); 
 
 #endif

Grid/cshift/Cshift_table.cc

@@ -1,5 +1,5 @@
 #include <Grid/GridCore.h>       
 NAMESPACE_BEGIN(Grid);
 std::vector<std::pair<int,int> > Cshift_table; 
-deviceVector<std::pair<int,int> > Cshift_table_device; 
+commVector<std::pair<int,int> > Cshift_table_device; 
 NAMESPACE_END(Grid);

Grid/lattice/Lattice_ET.h

@@ -245,7 +245,7 @@ template <class T1,typename std::enable_if<is_lattice<T1>::value, T1>::type * =
 inline void CBFromExpression(int &cb, const T1 &lat)  // Lattice leaf
 {
   if ((cb == Odd) || (cb == Even)) {
-    GRID_ASSERT(cb == lat.Checkerboard());
+    assert(cb == lat.Checkerboard());
   }
   cb = lat.Checkerboard();
 }

Grid/lattice/Lattice_arith.h

@@ -257,30 +257,17 @@ void axpby(Lattice<vobj> &ret,sobj a,sobj b,const Lattice<vobj> &x,const Lattice
   });
 }
 
-#define FAST_AXPY_NORM
 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");
-#ifdef FAST_AXPY_NORM
     return axpy_norm_fast(ret,a,x,y);
-#else
-  ret = a*x+y;
-  RealD nn=norm2(ret);
-  return nn;
-#endif
 }
 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");
-#ifdef FAST_AXPY_NORM
     return axpby_norm_fast(ret,a,b,x,y);
-#else
-  ret = a*x+b*y;
-  RealD nn=norm2(ret);
-  return nn;
-#endif
 }
 
 /// Trace product

Grid/lattice/Lattice_base.h

@@ -120,12 +120,12 @@ public:
     GRID_TRACE("ExpressionTemplateEval");
     GridBase *egrid(nullptr);
     GridFromExpression(egrid,expr);
-    GRID_ASSERT(egrid!=nullptr);
+    assert(egrid!=nullptr);
     conformable(this->_grid,egrid);
 
     int cb=-1;
     CBFromExpression(cb,expr);
-    GRID_ASSERT( (cb==Odd) || (cb==Even));
+    assert( (cb==Odd) || (cb==Even));
     this->checkerboard=cb;
     
     auto exprCopy = expr;
@@ -144,12 +144,12 @@ public:
     GRID_TRACE("ExpressionTemplateEval");
     GridBase *egrid(nullptr);
     GridFromExpression(egrid,expr);
-    GRID_ASSERT(egrid!=nullptr);
+    assert(egrid!=nullptr);
     conformable(this->_grid,egrid);
 
     int cb=-1;
     CBFromExpression(cb,expr);
-    GRID_ASSERT( (cb==Odd) || (cb==Even));
+    assert( (cb==Odd) || (cb==Even));
     this->checkerboard=cb;
 
     auto exprCopy = expr;
@@ -168,12 +168,12 @@ public:
     GRID_TRACE("ExpressionTemplateEval");
     GridBase *egrid(nullptr);
     GridFromExpression(egrid,expr);
-    GRID_ASSERT(egrid!=nullptr);
+    assert(egrid!=nullptr);
     conformable(this->_grid,egrid);
 
     int cb=-1;
     CBFromExpression(cb,expr);
-    GRID_ASSERT( (cb==Odd) || (cb==Even));
+    assert( (cb==Odd) || (cb==Even));
     this->checkerboard=cb;
     auto exprCopy = expr;
     ExpressionViewOpen(exprCopy);
@@ -191,11 +191,11 @@ public:
   Lattice(const LatticeUnaryExpression<Op,T1> & expr) {
     this->_grid = nullptr;
     GridFromExpression(this->_grid,expr);
-    GRID_ASSERT(this->_grid!=nullptr);
+    assert(this->_grid!=nullptr);
 
     int cb=-1;
     CBFromExpression(cb,expr);
-    GRID_ASSERT( (cb==Odd) || (cb==Even));
+    assert( (cb==Odd) || (cb==Even));
     this->checkerboard=cb;
 
     resize(this->_grid->oSites());
@@ -206,11 +206,11 @@ public:
   Lattice(const LatticeBinaryExpression<Op,T1,T2> & expr) {
     this->_grid = nullptr;
     GridFromExpression(this->_grid,expr);
-    GRID_ASSERT(this->_grid!=nullptr);
+    assert(this->_grid!=nullptr);
 
     int cb=-1;
     CBFromExpression(cb,expr);
-    GRID_ASSERT( (cb==Odd) || (cb==Even));
+    assert( (cb==Odd) || (cb==Even));
     this->checkerboard=cb;
 
     resize(this->_grid->oSites());
@@ -221,11 +221,11 @@ public:
   Lattice(const LatticeTrinaryExpression<Op,T1,T2,T3> & expr) {
     this->_grid = nullptr;
     GridFromExpression(this->_grid,expr);
-    GRID_ASSERT(this->_grid!=nullptr);
+    assert(this->_grid!=nullptr);
 
     int cb=-1;
     CBFromExpression(cb,expr);
-    GRID_ASSERT( (cb==Odd) || (cb==Even));
+    assert( (cb==Odd) || (cb==Even));
     this->checkerboard=cb;
 
     resize(this->_grid->oSites());
@@ -236,13 +236,10 @@ public:
   template<class sobj> inline Lattice<vobj> & operator = (const sobj & r){
     vobj vtmp;
     vtmp = r;
-#if 1
+#if defined(GRID_HIP) || defined(GRID_CUDA) || defined (GRID_SYCL)
-    deviceVector<vobj> vvtmp(1);
-    acceleratorPut(vvtmp[0],vtmp);
-    vobj *vvtmp_p = & vvtmp[0];
     auto me  = View(AcceleratorWrite);
     accelerator_for(ss,me.size(),vobj::Nsimd(),{
-	auto stmp=coalescedRead(*vvtmp_p);
+	auto stmp=coalescedRead(vtmp);
 	coalescedWrite(me[ss],stmp);
     });
 #else    
@@ -264,7 +261,7 @@ public:
   Lattice(GridBase *grid,ViewMode mode=AcceleratorWriteDiscard) { 
     this->_grid = grid;
     resize(this->_grid->oSites());
-    GRID_ASSERT((((uint64_t)&this->_odata[0])&0xF) ==0);
+    assert((((uint64_t)&this->_odata[0])&0xF) ==0);
     this->checkerboard=0;
     SetViewMode(mode);
   }
@@ -289,7 +286,7 @@ public:
   ///////////////////////////////////////////
   // move constructor
   ///////////////////////////////////////////
-  Lattice(Lattice && r) noexcept { 
+  Lattice(Lattice && r){ 
     this->_grid = r.Grid();
     this->_odata      = r._odata;
     this->_odata_size = r._odata_size;
@@ -330,7 +327,7 @@ public:
   ///////////////////////////////////////////
   // Move assignment possible if same type
   ///////////////////////////////////////////
-  inline Lattice<vobj> & operator = (Lattice<vobj> && r) noexcept {
+  inline Lattice<vobj> & operator = (Lattice<vobj> && r){
 
     resize(0); // deletes if appropriate
     this->_grid       = r.Grid();

Grid/lattice/Lattice_basis.h

@@ -53,19 +53,36 @@ void basisRotate(VField &basis,Matrix& Qt,int j0, int j1, int k0,int k1,int Nm)
   typedef decltype(basis[0]) Field;
   typedef decltype(basis[0].View(AcceleratorRead)) View;
 
-  hostVector<View>  h_basis_v(basis.size());
+  Vector<View> basis_v; basis_v.reserve(basis.size());
-  deviceVector<View> d_basis_v(basis.size());
+  typedef typename std::remove_reference<decltype(basis_v[0][0])>::type vobj;
-  typedef typename std::remove_reference<decltype(h_basis_v[0][0])>::type vobj;
   typedef typename std::remove_reference<decltype(Qt(0,0))>::type Coeff_t;
-
   GridBase* grid = basis[0].Grid();
       
   for(int k=0;k<basis.size();k++){
-    h_basis_v[k] = basis[k].View(AcceleratorWrite);
+    basis_v.push_back(basis[k].View(AcceleratorWrite));
-    acceleratorPut(d_basis_v[k],h_basis_v[k]);
   }
 
-  View *basis_vp = &d_basis_v[0];
+#if ( !(defined(GRID_CUDA) || defined(GRID_HIP) || defined(GRID_SYCL)) )
+  int max_threads = thread_max();
+  Vector < vobj > Bt(Nm * max_threads);
+  thread_region
+    {
+      vobj* B = &Bt[Nm * thread_num()];
+      thread_for_in_region(ss, grid->oSites(),{
+	  for(int j=j0; j<j1; ++j) B[j]=0.;
+      
+	  for(int j=j0; j<j1; ++j){
+	    for(int k=k0; k<k1; ++k){
+	      B[j] +=Qt(j,k) * basis_v[k][ss];
+	    }
+	  }
+	  for(int j=j0; j<j1; ++j){
+	    basis_v[j][ss] = B[j];
+	  }
+	});
+    }
+#else
+  View *basis_vp = &basis_v[0];
 
   int nrot = j1-j0;
   if (!nrot) // edge case not handled gracefully by Cuda
@@ -74,19 +91,17 @@ void basisRotate(VField &basis,Matrix& Qt,int j0, int j1, int k0,int k1,int Nm)
   uint64_t oSites   =grid->oSites();
   uint64_t siteBlock=(grid->oSites()+nrot-1)/nrot; // Maximum 1 additional vector overhead
 
-  deviceVector <vobj> Bt(siteBlock * nrot); 
+  Vector <vobj> Bt(siteBlock * nrot); 
   auto Bp=&Bt[0];
 
   // GPU readable copy of matrix
-  hostVector<Coeff_t> h_Qt_jv(Nm*Nm);
+  Vector<Coeff_t> Qt_jv(Nm*Nm);
-  deviceVector<Coeff_t> Qt_jv(Nm*Nm);
   Coeff_t *Qt_p = & Qt_jv[0];
   thread_for(i,Nm*Nm,{
       int j = i/Nm;
       int k = i%Nm;
-      h_Qt_jv[i]=Qt(j,k);
+      Qt_p[i]=Qt(j,k);
   });
-  acceleratorCopyToDevice(&h_Qt_jv[0],Qt_p,Nm*Nm*sizeof(Coeff_t));
 
   // Block the loop to keep storage footprint down
   for(uint64_t s=0;s<oSites;s+=siteBlock){
@@ -122,8 +137,9 @@ void basisRotate(VField &basis,Matrix& Qt,int j0, int j1, int k0,int k1,int Nm)
 	coalescedWrite(basis_vp[jj][sss],coalescedRead(Bp[ss*nrot+j]));
       });
   }
+#endif
 
-  for(int k=0;k<basis.size();k++) h_basis_v[k].ViewClose();
+  for(int k=0;k<basis.size();k++) basis_v[k].ViewClose();
 }
 
 // Extract a single rotated vector
@@ -136,19 +152,16 @@ void basisRotateJ(Field &result,std::vector<Field> &basis,Eigen::MatrixXd& Qt,in
 
   result.Checkerboard() = basis[0].Checkerboard();
 
-  hostVector<View>  h_basis_v(basis.size());
+  Vector<View> basis_v; basis_v.reserve(basis.size());
-  deviceVector<View> d_basis_v(basis.size());
   for(int k=0;k<basis.size();k++){
-    h_basis_v[k]=basis[k].View(AcceleratorRead);
+    basis_v.push_back(basis[k].View(AcceleratorRead));
-    acceleratorPut(d_basis_v[k],h_basis_v[k]);
   }
-
   vobj zz=Zero();
-  deviceVector<double> Qt_jv(Nm);
+  Vector<double> Qt_jv(Nm);
   double * Qt_j = & Qt_jv[0];
-  for(int k=0;k<Nm;++k) acceleratorPut(Qt_j[k],Qt(j,k));
+  for(int k=0;k<Nm;++k) Qt_j[k]=Qt(j,k);
 
-  auto basis_vp=& d_basis_v[0];
+  auto basis_vp=& basis_v[0];
   autoView(result_v,result,AcceleratorWrite);
   accelerator_for(ss, grid->oSites(),vobj::Nsimd(),{
     vobj zzz=Zero();
@@ -158,7 +171,7 @@ void basisRotateJ(Field &result,std::vector<Field> &basis,Eigen::MatrixXd& Qt,in
     }
     coalescedWrite(result_v[ss], B);
   });
-  for(int k=0;k<basis.size();k++) h_basis_v[k].ViewClose();
+  for(int k=0;k<basis.size();k++) basis_v[k].ViewClose();
 }
 
 template<class Field>
@@ -166,9 +179,9 @@ void basisReorderInPlace(std::vector<Field> &_v,std::vector<RealD>& sort_vals, s
 {
   int vlen = idx.size();
 
-  GRID_ASSERT(vlen>=1);
+  assert(vlen>=1);
-  GRID_ASSERT(vlen<=sort_vals.size());
+  assert(vlen<=sort_vals.size());
-  GRID_ASSERT(vlen<=_v.size());
+  assert(vlen<=_v.size());
 
   for (size_t i=0;i<vlen;i++) {
 
@@ -186,7 +199,7 @@ void basisReorderInPlace(std::vector<Field> &_v,std::vector<RealD>& sort_vals, s
 	if (idx[j]==i)
 	  break;
 
-      GRID_ASSERT(idx[i] > i);     GRID_ASSERT(j!=idx.size());      GRID_ASSERT(idx[j]==i);
+      assert(idx[i] > i);     assert(j!=idx.size());      assert(idx[j]==i);
 
       swap(_v[i],_v[idx[i]]); // should use vector move constructor, no data copy
       std::swap(sort_vals[i],sort_vals[idx[i]]);
@@ -224,7 +237,7 @@ void basisSortInPlace(std::vector<Field> & _v,std::vector<RealD>& sort_vals, boo
 template<class Field>
 void basisDeflate(const std::vector<Field> &_v,const std::vector<RealD>& eval,const Field& src_orig,Field& result) {
   result = Zero();
-  GRID_ASSERT(_v.size()==eval.size());
+  assert(_v.size()==eval.size());
   int N = (int)_v.size();
   for (int i=0;i<N;i++) {
     Field& tmp = _v[i];

Grid/lattice/Lattice_conformable.h

@@ -32,8 +32,8 @@ NAMESPACE_BEGIN(Grid);
 
 template<class obj1,class obj2> void conformable(const Lattice<obj1> &lhs,const Lattice<obj2> &rhs)
 {
-  GRID_ASSERT(lhs.Grid() == rhs.Grid());
+  assert(lhs.Grid() == rhs.Grid());
-  GRID_ASSERT(lhs.Checkerboard() == rhs.Checkerboard());
+  assert(lhs.Checkerboard() == rhs.Checkerboard());
 }
 
 NAMESPACE_END(Grid);

Grid/lattice/Lattice_matrix_reduction.h

@@ -42,7 +42,7 @@ static void sliceMaddMatrix (Lattice<vobj> &R,Eigen::MatrixXcd &aa,const Lattice
   //  Lattice<vobj> Xslice(SliceGrid);
   //  Lattice<vobj> Rslice(SliceGrid);
 
-  GRID_ASSERT( FullGrid->_simd_layout[Orthog]==1);
+  assert( FullGrid->_simd_layout[Orthog]==1);
 
   //FIXME package in a convenient iterator
   //Should loop over a plane orthogonal to direction "Orthog"
@@ -86,7 +86,7 @@ static void sliceMulMatrix (Lattice<vobj> &R,Eigen::MatrixXcd &aa,const Lattice<
   int Nblock = X.Grid()->GlobalDimensions()[Orthog];
 
   GridBase *FullGrid  = X.Grid();
-  GRID_ASSERT( FullGrid->_simd_layout[Orthog]==1);
+  assert( FullGrid->_simd_layout[Orthog]==1);
 
   //FIXME package in a convenient iterator
   //Should loop over a plane orthogonal to direction "Orthog"
@@ -140,7 +140,7 @@ static void sliceInnerProductMatrix(  Eigen::MatrixXcd &mat, const Lattice<vobj>
   
   mat = Eigen::MatrixXcd::Zero(Nblock,Nblock);
 
-  GRID_ASSERT( FullGrid->_simd_layout[Orthog]==1);
+  assert( FullGrid->_simd_layout[Orthog]==1);
   //  int nh =  FullGrid->_ndimension;
   //  int nl = SliceGrid->_ndimension;
   //  int nl = nh-1;

Grid/lattice/Lattice_peekpoke.h

@@ -98,8 +98,8 @@ void pokeSite(const sobj &s,Lattice<vobj> &l,const Coordinate &site){
 
   int Nsimd = grid->Nsimd();
 
-  GRID_ASSERT( l.Checkerboard()== l.Grid()->CheckerBoard(site));
+  assert( l.Checkerboard()== l.Grid()->CheckerBoard(site));
-  GRID_ASSERT( sizeof(sobj)*Nsimd == sizeof(vobj));
+  assert( sizeof(sobj)*Nsimd == sizeof(vobj));
 
   int rank,odx,idx;
   // Optional to broadcast from node 0.
@@ -135,7 +135,7 @@ void peekSite(sobj &s,const Lattice<vobj> &l,const Coordinate &site){
 
   int Nsimd = grid->Nsimd();
 
-  GRID_ASSERT( l.Checkerboard() == l.Grid()->CheckerBoard(site));
+  assert( l.Checkerboard() == l.Grid()->CheckerBoard(site));
 
   int rank,odx,idx;
   grid->GlobalCoorToRankIndex(rank,odx,idx,site);
@@ -159,14 +159,14 @@ template<class vobj,class sobj>
 inline void peekLocalSite(sobj &s,const LatticeView<vobj> &l,Coordinate &site)
 {
   GridBase *grid = l.getGrid();
-  GRID_ASSERT(l.mode==CpuRead);
+  assert(l.mode==CpuRead);
   typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
 
   int Nsimd = grid->Nsimd();
 
-  //  GRID_ASSERT( l.Checkerboard()== grid->CheckerBoard(site));
+  //  assert( l.Checkerboard()== grid->CheckerBoard(site));
-  GRID_ASSERT( sizeof(sobj)*Nsimd == sizeof(vobj));
+  assert( sizeof(sobj)*Nsimd == sizeof(vobj));
 
   static const int words=sizeof(vobj)/sizeof(vector_type);
   int odx,idx;
@@ -195,15 +195,15 @@ template<class vobj,class sobj>
 inline void pokeLocalSite(const sobj &s,LatticeView<vobj> &l,Coordinate &site)
 {
   GridBase *grid=l.getGrid();
-  GRID_ASSERT(l.mode==CpuWrite);
+  assert(l.mode==CpuWrite);
 
   typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
 
   int Nsimd = grid->Nsimd();
 
-  //  GRID_ASSERT( l.Checkerboard()== grid->CheckerBoard(site));
+  //  assert( l.Checkerboard()== grid->CheckerBoard(site));
-  GRID_ASSERT( sizeof(sobj)*Nsimd == sizeof(vobj));
+  assert( sizeof(sobj)*Nsimd == sizeof(vobj));
 
   static const int words=sizeof(vobj)/sizeof(vector_type);
   int odx,idx;

Grid/lattice/Lattice_reduction.h

@@ -46,7 +46,7 @@ inline typename vobj::scalar_object sum_cpu(const vobj *arg, Integer osites)
   //  const int Nsimd = vobj::Nsimd();
   const int nthread = GridThread::GetThreads();
 
-  std::vector<sobj> sumarray(nthread);
+  Vector<sobj> sumarray(nthread);
   for(int i=0;i<nthread;i++){
     sumarray[i]=Zero();
   }
@@ -75,7 +75,7 @@ inline typename vobj::scalar_objectD sumD_cpu(const vobj *arg, Integer osites)
 
   const int nthread = GridThread::GetThreads();
 
-  std::vector<sobj> sumarray(nthread);
+  Vector<sobj> sumarray(nthread);
   for(int i=0;i<nthread;i++){
     sumarray[i]=Zero();
   }
@@ -290,45 +290,23 @@ template<class vobj>
 inline ComplexD innerProduct(const Lattice<vobj> &left,const Lattice<vobj> &right) {
   GridBase *grid = left.Grid();
 
-  bool ok;
 #ifdef GRID_SYCL
-  //  uint64_t csum=0;
+  uint64_t csum=0;
-  //  uint64_t csum2=0;
+  if ( FlightRecorder::LoggingMode != FlightRecorder::LoggingModeNone)
-  //  if ( FlightRecorder::LoggingMode != FlightRecorder::LoggingModeNone)
+  {
-  //  {
     // Hack
     // Fast integer xor checksum. Can also be used in comms now.
-  //    autoView(l_v,left,AcceleratorRead);
+    autoView(l_v,left,AcceleratorRead);
-  //    Integer words = left.Grid()->oSites()*sizeof(vobj)/sizeof(uint64_t);
+    Integer words = left.Grid()->oSites()*sizeof(vobj)/sizeof(uint64_t);
-  //    uint64_t *base= (uint64_t *)&l_v[0];
+    uint64_t *base= (uint64_t *)&l_v[0];
-  //    csum=svm_xor(base,words);
+    csum=svm_xor(base,words);
-  //    ok = FlightRecorder::CsumLog(csum);
-  //    if ( !ok ) {
-  //      csum2=svm_xor(base,words);
-  //      std::cerr<< " Bad CSUM " << std::hex<< csum << " recomputed as "<<csum2<<std::dec<<std::endl;
-  //    } else {
-  //      csum2=svm_xor(base,words);
-  //      std::cerr<< " ok CSUM " << std::hex<< csum << " recomputed as "<<csum2<<std::dec<<std::endl;
-  //    }
-  //    GRID_ASSERT(ok);
-  // }
-#endif
-  FlightRecorder::StepLog("rank inner product");
-  ComplexD nrm = rankInnerProduct(left,right);
-  //  ComplexD nrmck=nrm;
-  RealD local = real(nrm);
-  ok = FlightRecorder::NormLog(real(nrm));
-  if ( !ok ) {
-    ComplexD nrm2 = rankInnerProduct(left,right);
-    RealD local2 = real(nrm2);
-    std::cerr<< " Bad NORM " << local << " recomputed as "<<local2<<std::endl;
-    GRID_ASSERT(ok);
   }
-  FlightRecorder::StepLog("Start global sum");
+  FlightRecorder::CsumLog(csum);
-  grid->GlobalSumP2P(nrm);
+#endif
-  //  grid->GlobalSum(nrm);
+  ComplexD nrm = rankInnerProduct(left,right);
-  FlightRecorder::StepLog("Finished global sum");
+  RealD local = real(nrm);
-  //  std::cout << " norm "<< nrm << " p2p norm "<<nrmck<<std::endl;
+  FlightRecorder::NormLog(real(nrm)); 
+  grid->GlobalSum(nrm);
   FlightRecorder::ReductionLog(local,real(nrm)); 
   return nrm;
 }
@@ -365,6 +343,18 @@ axpby_norm_fast(Lattice<vobj> &z,sobj a,sobj b,const Lattice<vobj> &x,const Latt
   autoView( x_v, x, AcceleratorRead);
   autoView( y_v, y, AcceleratorRead);
   autoView( z_v, z, AcceleratorWrite);
+#if 0
+  typedef decltype(innerProductD(x_v[0],y_v[0])) inner_t;
+  Vector<inner_t> inner_tmp(sites);
+  auto inner_tmp_v = &inner_tmp[0];
+
+  accelerator_for( ss, sites, nsimd,{
+      auto tmp = a*x_v(ss)+b*y_v(ss);
+      coalescedWrite(inner_tmp_v[ss],innerProductD(tmp,tmp));
+      coalescedWrite(z_v[ss],tmp);
+  });
+  nrm = real(TensorRemove(sum(inner_tmp_v,sites)));
+#else
   typedef decltype(innerProduct(x_v[0],y_v[0])) inner_t;
   deviceVector<inner_t> inner_tmp;
   inner_tmp.resize(sites);
@@ -375,13 +365,9 @@ axpby_norm_fast(Lattice<vobj> &z,sobj a,sobj b,const Lattice<vobj> &x,const Latt
       coalescedWrite(inner_tmp_v[ss],innerProduct(tmp,tmp));
       coalescedWrite(z_v[ss],tmp);
   });
-  bool ok;
   nrm = real(TensorRemove(sumD(inner_tmp_v,sites)));
-  ok = FlightRecorder::NormLog(real(nrm));
+#endif
-  GRID_ASSERT(ok);
-  RealD local = real(nrm);
   grid->GlobalSum(nrm);
-  FlightRecorder::ReductionLog(local,real(nrm));
   return nrm; 
 }
  
@@ -391,7 +377,7 @@ innerProductNorm(ComplexD& ip, RealD &nrm, const Lattice<vobj> &left,const Latti
   conformable(left,right);
 
   typedef typename vobj::vector_typeD vector_type;
-  std::vector<ComplexD> tmp(2);
+  Vector<ComplexD> tmp(2);
 
   GridBase *grid = left.Grid();
 
@@ -401,8 +387,8 @@ innerProductNorm(ComplexD& ip, RealD &nrm, const Lattice<vobj> &left,const Latti
   // GPU
   typedef decltype(innerProductD(vobj(),vobj())) inner_t;
   typedef decltype(innerProductD(vobj(),vobj())) norm_t;
-  deviceVector<inner_t> inner_tmp(sites);
+  Vector<inner_t> inner_tmp(sites);
-  deviceVector<norm_t>  norm_tmp(sites);
+  Vector<norm_t>  norm_tmp(sites);
   auto inner_tmp_v = &inner_tmp[0];
   auto norm_tmp_v = &norm_tmp[0];
   {
@@ -452,9 +438,7 @@ inline auto sum(const LatticeTrinaryExpression<Op,T1,T2,T3> & expr)
 // sliceSum, sliceInnerProduct, sliceAxpy, sliceNorm etc...
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-template<class vobj> inline void sliceSum(const Lattice<vobj> &Data,
+template<class vobj> inline void sliceSum(const Lattice<vobj> &Data,std::vector<typename vobj::scalar_object> &result,int orthogdim)
-					  std::vector<typename vobj::scalar_object> &result,
-					  int orthogdim)
 {
   ///////////////////////////////////////////////////////
   // FIXME precision promoted summation
@@ -464,20 +448,20 @@ template<class vobj> inline void sliceSum(const Lattice<vobj> &Data,
   typedef typename vobj::scalar_object sobj;
   typedef typename vobj::scalar_object::scalar_type scalar_type;
   GridBase  *grid = Data.Grid();
-  GRID_ASSERT(grid!=NULL);
+  assert(grid!=NULL);
 
   const int    Nd = grid->_ndimension;
   const int Nsimd = grid->Nsimd();
 
-  GRID_ASSERT(orthogdim >= 0);
+  assert(orthogdim >= 0);
-  GRID_ASSERT(orthogdim < Nd);
+  assert(orthogdim < Nd);
 
   int fd=grid->_fdimensions[orthogdim];
   int ld=grid->_ldimensions[orthogdim];
   int rd=grid->_rdimensions[orthogdim];
 
-  std::vector<vobj> lvSum(rd); // will locally sum vectors first
+  Vector<vobj> lvSum(rd); // will locally sum vectors first
-  std::vector<sobj> lsSum(ld,Zero());                    // sum across these down to scalars
+  Vector<sobj> lsSum(ld,Zero());                    // sum across these down to scalars
   ExtractBuffer<sobj> extracted(Nsimd);                  // splitting the SIMD
 
   result.resize(fd); // And then global sum to return the same vector to every node 
@@ -525,8 +509,6 @@ template<class vobj> inline void sliceSum(const Lattice<vobj> &Data,
   scalar_type * ptr = (scalar_type *) &result[0];
   int words = fd*sizeof(sobj)/sizeof(scalar_type);
   grid->GlobalSumVector(ptr, words);
-  //  std::cout << GridLogMessage << " sliceSum local"<<t_sum<<" us, host+mpi "<<t_rest<<std::endl;
-  
 }
 template<class vobj> inline
 std::vector<typename vobj::scalar_object> 
@@ -557,21 +539,21 @@ static void sliceInnerProductVector( std::vector<ComplexD> & result, const Latti
   typedef typename vobj::vector_type   vector_type;
   typedef typename vobj::scalar_type   scalar_type;
   GridBase  *grid = lhs.Grid();
-  GRID_ASSERT(grid!=NULL);
+  assert(grid!=NULL);
   conformable(grid,rhs.Grid());
 
   const int    Nd = grid->_ndimension;
   const int Nsimd = grid->Nsimd();
 
-  GRID_ASSERT(orthogdim >= 0);
+  assert(orthogdim >= 0);
-  GRID_ASSERT(orthogdim < Nd);
+  assert(orthogdim < Nd);
 
   int fd=grid->_fdimensions[orthogdim];
   int ld=grid->_ldimensions[orthogdim];
   int rd=grid->_rdimensions[orthogdim];
 
-  std::vector<vector_type> lvSum(rd); // will locally sum vectors first
+  Vector<vector_type> lvSum(rd); // will locally sum vectors first
-  std::vector<scalar_type > lsSum(ld,scalar_type(0.0));                    // sum across these down to scalars
+  Vector<scalar_type > lsSum(ld,scalar_type(0.0));                    // sum across these down to scalars
   ExtractBuffer<iScalar<scalar_type> > extracted(Nsimd);   // splitting the SIMD  
 
   result.resize(fd); // And then global sum to return the same vector to every node for IO to file

Grid/lattice/Lattice_reduction_gpu.h

@@ -197,9 +197,6 @@ __global__ void reduceKernel(const vobj *lat, sobj *buffer, Iterator n) {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Possibly promote to double and sum
 /////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#undef GRID_REDUCTION_TIMING
-
 template <class vobj>
 inline typename vobj::scalar_objectD sumD_gpu_small(const vobj *lat, Integer osites) 
 {
@@ -211,191 +208,54 @@ inline typename vobj::scalar_objectD sumD_gpu_small(const vobj *lat, Integer osi
 
   Integer numThreads, numBlocks;
   int ok = getNumBlocksAndThreads(size, sizeof(sobj), numThreads, numBlocks);
-  GRID_ASSERT(ok);
+  assert(ok);
 
   Integer smemSize = numThreads * sizeof(sobj);
-  deviceVector<sobj> buffer(numBlocks);
+  // Move out of UVM
+  // Turns out I had messed up the synchronise after move to compute stream
+  // as running this on the default stream fools the synchronise
+#undef UVM_BLOCK_BUFFER  
+#ifndef UVM_BLOCK_BUFFER  
+  commVector<sobj> buffer(numBlocks);
   sobj *buffer_v = &buffer[0];
   sobj result;
-
-#ifdef GRID_REDUCTION_TIMING
-  RealD t_kernel = -usecond();
-#endif
   reduceKernel<<< numBlocks, numThreads, smemSize, computeStream >>>(lat, buffer_v, size);
   accelerator_barrier();
-#ifdef GRID_REDUCTION_TIMING
-  t_kernel += usecond();
-  RealD t_d2h = -usecond();
-#endif
   acceleratorCopyFromDevice(buffer_v,&result,sizeof(result));
-#ifdef GRID_REDUCTION_TIMING
+#else
-  t_d2h += usecond();
+  Vector<sobj> buffer(numBlocks);
-  std::cout << GridLogDebug << "  sumD_gpu_small"
+  sobj *buffer_v = &buffer[0];
-            << " sizeof(sobj)=" << sizeof(sobj)
+  sobj result;
-            << " blocks=" << numBlocks << " threads=" << numThreads
+  reduceKernel<<< numBlocks, numThreads, smemSize, computeStream >>>(lat, buffer_v, size);
-            << " kernel+barrier=" << t_kernel << " us"
+  accelerator_barrier();
-            << " D2H=" << t_d2h << " us" << std::endl;
+  result = *buffer_v;
 #endif
   return result;
 }
 
-// Fused pack+reduce: reads R words of each vobj at word offset 'base',
-// accumulates directly into iVector<iScalar<scalarD>,R> without staging
-// through an intermediate bundle buffer.  One HBM pass instead of three.
-template <int R, class vobj, class sobj, class Iterator>
-__device__ void packReduceBlocks(
-    const iScalar<typename vobj::vector_type> *idat,
-    sobj *g_odata, Iterator osites, int base, int words)
-{
-  constexpr Iterator nsimd = vobj::Nsimd();
-  Iterator blockSize = blockDim.x;
-
-  extern __shared__ __align__(COALESCE_GRANULARITY) unsigned char shmem_pointer[];
-  sobj *sdata = (sobj *)shmem_pointer;
-
-  Iterator tid      = threadIdx.x;
-  Iterator i        = blockIdx.x * (blockSize * 2) + threadIdx.x;
-  Iterator gridSize = blockSize * 2 * gridDim.x;
-  sobj mySum = Zero();
-
-  while (i < osites * nsimd) {
-    Iterator lane = i % nsimd;
-    Iterator ss   = i / nsimd;
-    sobj tmpD; zeroit(tmpD);
-    for (int k = 0; k < R; k++) {
-      auto w = extractLane(lane, idat[ss * words + base + k]);
-      iScalar<typename vobj::scalar_typeD> wd; wd = w;
-      tmpD._internal[k] = wd;
-    }
-    mySum += tmpD;
-
-    if (i + blockSize < osites * nsimd) {
-      lane = (i + blockSize) % nsimd;
-      ss   = (i + blockSize) / nsimd;
-      sobj tmpD2; zeroit(tmpD2);
-      for (int k = 0; k < R; k++) {
-        auto w = extractLane(lane, idat[ss * words + base + k]);
-        iScalar<typename vobj::scalar_typeD> wd; wd = w;
-        tmpD2._internal[k] = wd;
-      }
-      mySum += tmpD2;
-    }
-    i += gridSize;
-  }
-
-  reduceBlock(sdata, mySum, tid);
-  if (tid == 0) g_odata[blockIdx.x] = sdata[0];
-}
-
-template <int R, class vobj, class sobj, class Iterator>
-__global__ void packReduceKernel(
-    const iScalar<typename vobj::vector_type> *idat,
-    sobj *buffer, Iterator osites, int base, int words)
-{
-  Iterator blockSize = blockDim.x;
-
-  packReduceBlocks<R, vobj, sobj>(idat, buffer, osites, base, words);
-
-  if (gridDim.x > 1) {
-    const Iterator tid = threadIdx.x;
-    __shared__ bool amLast;
-    extern __shared__ __align__(COALESCE_GRANULARITY) unsigned char shmem_pointer[];
-    sobj *smem = (sobj *)shmem_pointer;
-
-    acceleratorFence();
-
-    if (tid == 0) {
-      unsigned int ticket = atomicInc(&retirementCount, gridDim.x);
-      amLast = (ticket == gridDim.x - 1);
-    }
-    acceleratorSynchroniseAll();
-
-    if (amLast) {
-      Iterator i = tid;
-      sobj mySum = Zero();
-      while (i < (Iterator)gridDim.x) {
-        mySum += buffer[i];
-        i += blockSize;
-      }
-      reduceBlock(smem, mySum, tid);
-      if (tid == 0) {
-        buffer[0] = smem[0];
-        retirementCount = 0;
-      }
-    }
-  }
-}
-
-template<int R, class vobj>
-inline void sumD_gpu_reduce_words(const vobj *lat, Integer osites,
-                                   typename vobj::scalar_typeD *ret_p, int base)
-{
-  typedef typename vobj::vector_type  vector;
-  typedef typename vobj::scalar_typeD scalarD;
-  using BundleScalarD = iVector<iScalar<scalarD>, R>;
-
-  constexpr int Nsimd = vobj::Nsimd();
-  const int words = sizeof(vobj) / sizeof(vector);
-  const iScalar<vector> *idat = (const iScalar<vector> *)lat;
-
-  Integer size = (Integer)osites * Nsimd;
-  Integer numThreads, numBlocks;
-  int ok = getNumBlocksAndThreads(size, sizeof(BundleScalarD), numThreads, numBlocks);
-  GRID_ASSERT(ok);
-
-  Integer smemSize = numThreads * sizeof(BundleScalarD);
-  deviceVector<BundleScalarD> buffer(numBlocks);
-  BundleScalarD *buffer_v = &buffer[0];
-  BundleScalarD result;
-
-#ifdef GRID_REDUCTION_TIMING
-  RealD t_kernel = -usecond();
-#endif
-  packReduceKernel<R, vobj, BundleScalarD, Integer>
-    <<<numBlocks, numThreads, smemSize, computeStream>>>
-    (idat, buffer_v, osites, base, words);
-  accelerator_barrier();
-#ifdef GRID_REDUCTION_TIMING
-  t_kernel += usecond();
-  RealD t_d2h = -usecond();
-#endif
-  acceleratorCopyFromDevice(buffer_v, &result, sizeof(result));
-#ifdef GRID_REDUCTION_TIMING
-  t_d2h += usecond();
-  std::cout << GridLogDebug << " sumD_gpu_reduce_words R=" << R
-            << " base=" << base
-            << " kernel=" << t_kernel << " D2H=" << t_d2h << " us" << std::endl;
-#endif
-
-  for (int k = 0; k < R; k++)
-    ret_p[base + k] = TensorRemove(result._internal[k]);
-}
-
 template <class vobj>
 inline typename vobj::scalar_objectD sumD_gpu_large(const vobj *lat, Integer osites)
 {
   typedef typename vobj::vector_type  vector;
   typedef typename vobj::scalar_typeD scalarD;
-  typedef typename vobj::scalar_objectD sobjD;
+  typedef typename vobj::scalar_objectD sobj;
-
+  sobj ret;
-  const int words = sizeof(vobj) / sizeof(vector);
-  sobjD ret; zeroit(ret);
   scalarD *ret_p = (scalarD *)&ret;
   
-#ifdef GRID_REDUCTION_TIMING
+  const int words = sizeof(vobj)/sizeof(vector);
-  RealD t_large = -usecond();
-#endif
-  int w = 0;
-  while (w + 12 <= words) { sumD_gpu_reduce_words<12>(lat, osites, ret_p, w); w += 12; }
-  while (w +  4 <= words) { sumD_gpu_reduce_words< 4>(lat, osites, ret_p, w); w +=  4; }
-  while (w      <  words) { sumD_gpu_reduce_words< 1>(lat, osites, ret_p, w); w +=  1; }
-#ifdef GRID_REDUCTION_TIMING
-  t_large += usecond();
-  std::cout << GridLogDebug << "sumD_gpu_large"
-            << " sizeof(sobjD)=" << sizeof(sobjD)
-            << " words=" << words << " total=" << t_large << " us" << std::endl;
-#endif
 
+  Vector<vector> buffer(osites);
+  vector *dat = (vector *)lat;
+  vector *buf = &buffer[0];
+  iScalar<vector> *tbuf =(iScalar<vector> *)  &buffer[0];
+  for(int w=0;w<words;w++) {
+
+    accelerator_for(ss,osites,1,{
+	buf[ss] = dat[ss*words+w];
+      });
+      
+    ret_p[w] = sumD_gpu_small(tbuf,osites);
+  }
   return ret;
 }
 
@@ -438,11 +298,5 @@ inline typename vobj::scalar_object sum_gpu_large(const vobj *lat, Integer osite
   result = sumD_gpu_large(lat,osites);
   return result;
 }
-template<class Word> Word checksum_gpu(Word *vec,uint64_t L)
-{
-  Word w;
-  bzero(&w,sizeof(w));
-  return w;
-}
 
 NAMESPACE_END(Grid);

Grid/lattice/Lattice_reduction_sycl.h

@@ -4,29 +4,35 @@ NAMESPACE_BEGIN(Grid);
 // Possibly promote to double and sum
 /////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-
 template <class vobj>
 inline typename vobj::scalar_objectD sumD_gpu_tensor(const vobj *lat, Integer osites) 
 {
   typedef typename vobj::scalar_object sobj;
   typedef typename vobj::scalar_objectD sobjD;
+  static Vector<sobj> mysum;
+  mysum.resize(1);
+  sobj *mysum_p = & mysum[0];
+  sobj identity; zeroit(identity);
+  mysum[0] = identity;
+  sobj ret ; 
 
-  sobjD identity; zeroit(identity);
+  Integer nsimd= vobj::Nsimd();
-  sobjD ret;      zeroit(ret);
+
-  {
+  const cl::sycl::property_list PropList ({ cl::sycl::property::reduction::initialize_to_identity() });
-    sycl::buffer<sobjD, 1> abuff(&ret, {1});
+  theGridAccelerator->submit([&](cl::sycl::handler &cgh) {
-    theGridAccelerator->submit([&](sycl::handler &cgh) {
+    auto Reduction = cl::sycl::reduction(mysum_p,identity,std::plus<>(),PropList);
-      auto Reduction = sycl::reduction(abuff, cgh, identity, std::plus<>());
+     cgh.parallel_for(cl::sycl::range<1>{osites},
-      cgh.parallel_for(sycl::range<1>{(size_t)osites},
 		      Reduction,
-                       [=](sycl::id<1> item, auto &sum) {
+		      [=] (cl::sycl::id<1> item, auto &sum) {
-                         sobj s = Reduce(lat[item[0]]);
+      auto osite   = item[0];
-                         sobjD sd; sd = s;
+      sum +=Reduce(lat[osite]);
-                         sum += sd;
      });
    });
-  }
+  theGridAccelerator->wait();
-  return ret;
+  ret = mysum[0];
+  //  free(mysum,*theGridAccelerator);
+  sobjD dret; convertType(dret,ret);
+  return dret;
 }
 
 template <class vobj>
@@ -70,41 +76,59 @@ inline typename vobj::scalar_object sum_gpu_large(const vobj *lat, Integer osite
 
 template<class Word> Word svm_xor(Word *vec,uint64_t L)
 {
+  Word xorResult; xorResult = 0;
+  static Vector<Word> d_sum;
+  d_sum.resize(1);
+  Word *d_sum_p=&d_sum[0];
   Word identity;  identity=0;
-  Word ret = 0;
+  d_sum[0] = identity;
-  { 
+  const cl::sycl::property_list PropList ({ cl::sycl::property::reduction::initialize_to_identity() });
-    sycl::buffer<Word, 1> abuff(&ret, {1});
+  theGridAccelerator->submit([&](cl::sycl::handler &cgh) {
-    theGridAccelerator->submit([&](sycl::handler &cgh) {
+    auto Reduction = cl::sycl::reduction(d_sum_p,identity,std::bit_xor<>(),PropList);
-      auto Reduction = sycl::reduction(abuff,cgh,identity,std::bit_xor<>());
+     cgh.parallel_for(cl::sycl::range<1>{L},
-      cgh.parallel_for(sycl::range<1>{L},
 		      Reduction,
-                      [=] (sycl::id<1> index, auto &sum) {
+		      [=] (cl::sycl::id<1> index, auto &sum) {
 	 sum^=vec[index];
      });
    });
-  }
-  theGridAccelerator->wait();
-  return ret;
-}
-template<class Word> Word checksum_gpu(Word *vec,uint64_t L)
-{
-  Word identity;  identity=0;
-  Word ret = 0;
-  { 
-    sycl::buffer<Word, 1> abuff(&ret, {1});
-    theGridAccelerator->submit([&](sycl::handler &cgh) {
-      auto Reduction = sycl::reduction(abuff,cgh,identity,std::bit_xor<>());
-      cgh.parallel_for(sycl::range<1>{L},
-                       Reduction,
-                       [=] (sycl::id<1> index, auto &sum) {
-			 auto l = index % 61;
-                         sum ^= vec[index]<<l | vec[index]>>(64-l);
-                       });
-    });
-  }
   theGridAccelerator->wait();
+  Word ret = d_sum[0];
+  //  free(d_sum,*theGridAccelerator);
   return ret;
 }
 
 NAMESPACE_END(Grid);
 
+/*
+
+template <class vobj>
+inline typename vobj::scalar_objectD sumD_gpu_repack(const vobj *lat, Integer osites)
+{
+  typedef typename vobj::vector_type  vector;
+  typedef typename vobj::scalar_type  scalar;
+
+  typedef typename vobj::scalar_typeD scalarD;
+  typedef typename vobj::scalar_objectD sobjD;
+
+  sobjD ret;
+  scalarD *ret_p = (scalarD *)&ret;
+  
+  const int nsimd = vobj::Nsimd();
+  const int words = sizeof(vobj)/sizeof(vector);
+
+  Vector<scalar> buffer(osites*nsimd);
+  scalar *buf = &buffer[0];
+  vector *dat = (vector *)lat;
+
+  for(int w=0;w<words;w++) {
+
+    accelerator_for(ss,osites,nsimd,{
+	int lane = acceleratorSIMTlane(nsimd);
+	buf[ss*nsimd+lane] = dat[ss*words+w].getlane(lane);
+    });
+    //Precision change at this point is to late to gain precision
+    ret_p[w] = svm_reduce(buf,nsimd*osites);
+  }
+  return ret;
+}
+*/

Grid/lattice/Lattice_rng.h

@@ -53,10 +53,10 @@ inline int RNGfillable(GridBase *coarse,GridBase *fine)
 
   // trivially extended in higher dims, with locality guaranteeing RNG state is local to node
   int lowerdims   = fine->_ndimension - coarse->_ndimension;
-  GRID_ASSERT(lowerdims >= 0);
+  assert(lowerdims >= 0);
   for(int d=0;d<lowerdims;d++){
-    GRID_ASSERT(fine->_simd_layout[d]==1);
+    assert(fine->_simd_layout[d]==1);
-    GRID_ASSERT(fine->_processors[d]==1);
+    assert(fine->_processors[d]==1);
   }
 
   int multiplicity=1;
@@ -66,9 +66,9 @@ inline int RNGfillable(GridBase *coarse,GridBase *fine)
   // local and global volumes subdivide cleanly after SIMDization
   for(int d=0;d<rngdims;d++){
     int fd= d+lowerdims;
-    GRID_ASSERT(coarse->_processors[d]  == fine->_processors[fd]);
+    assert(coarse->_processors[d]  == fine->_processors[fd]);
-    GRID_ASSERT(coarse->_simd_layout[d] == fine->_simd_layout[fd]);
+    assert(coarse->_simd_layout[d] == fine->_simd_layout[fd]);
-    GRID_ASSERT(((fine->_rdimensions[fd] / coarse->_rdimensions[d])* coarse->_rdimensions[d])==fine->_rdimensions[fd]); 
+    assert(((fine->_rdimensions[fd] / coarse->_rdimensions[d])* coarse->_rdimensions[d])==fine->_rdimensions[fd]); 
 
     multiplicity = multiplicity *fine->_rdimensions[fd] / coarse->_rdimensions[d]; 
   }
@@ -83,18 +83,18 @@ inline int RNGfillable_general(GridBase *coarse,GridBase *fine)
   int rngdims = coarse->_ndimension;
     
   // trivially extended in higher dims, with locality guaranteeing RNG state is local to node
-  int lowerdims   = fine->_ndimension - coarse->_ndimension;  GRID_ASSERT(lowerdims >= 0);
+  int lowerdims   = fine->_ndimension - coarse->_ndimension;  assert(lowerdims >= 0);
   // assumes that the higher dimensions are not using more processors
   // all further divisions are local
-  for(int d=0;d<lowerdims;d++) GRID_ASSERT(fine->_processors[d]==1);
+  for(int d=0;d<lowerdims;d++) assert(fine->_processors[d]==1);
-  for(int d=0;d<rngdims;d++) GRID_ASSERT(coarse->_processors[d] == fine->_processors[d+lowerdims]);
+  for(int d=0;d<rngdims;d++) assert(coarse->_processors[d] == fine->_processors[d+lowerdims]);
 
   // then divide the number of local sites
   // check that the total number of sims agree, meanse the iSites are the same
-  GRID_ASSERT(fine->Nsimd() == coarse->Nsimd());
+  assert(fine->Nsimd() == coarse->Nsimd());
 
   // check that the two grids divide cleanly
-  GRID_ASSERT( (fine->lSites() / coarse->lSites() ) * coarse->lSites() == fine->lSites() );
+  assert( (fine->lSites() / coarse->lSites() ) * coarse->lSites() == fine->lSites() );
 
   return fine->lSites() / coarse->lSites();
 }
@@ -177,7 +177,7 @@ public:
 
     skip = skip<<shift;
 
-    GRID_ASSERT((skip >> shift)==site); // check for overflow
+    assert((skip >> shift)==site); // check for overflow
 
     eng.discard(skip);
 #else
@@ -218,7 +218,7 @@ public:
     GetState(saved,_generators[gen]);
   }
   void SetState(std::vector<RngStateType> & saved,RngEngine &eng){
-    GRID_ASSERT(saved.size()==RngStateCount);
+    assert(saved.size()==RngStateCount);
     std::stringstream ss;
     for(int i=0;i<RngStateCount;i++){
       ss<< saved[i]<<" ";

Grid/lattice/Lattice_slicesum_core.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #if defined(GRID_CUDA)
+
 #include <cub/cub.cuh>
 #define gpucub cub
 #define gpuError_t cudaError_t
@@ -20,18 +21,9 @@ NAMESPACE_BEGIN(Grid);
 
 
 #if defined(GRID_CUDA) || defined(GRID_HIP)
-template<class vobj>
+template<class vobj> inline void sliceSumReduction_cub_small(const vobj *Data, Vector<vobj> &lvSum, const int rd, const int e1, const int e2, const int stride, const int ostride, const int Nsimd) {
-inline void sliceSumReduction_cub_small(const vobj *Data,
-					std::vector<vobj> &lvSum,
-					const int rd,
-					const int e1,
-					const int e2,
-					const int stride,
-					const int ostride,
-					const int Nsimd)
-{
   size_t subvol_size = e1*e2;
-  deviceVector<vobj> reduction_buffer(rd*subvol_size);
+  commVector<vobj> reduction_buffer(rd*subvol_size);
   auto rb_p = &reduction_buffer[0];
   vobj zero_init;
   zeroit(zero_init);
@@ -54,15 +46,10 @@ inline void sliceSumReduction_cub_small(const vobj *Data,
   d_offsets = static_cast<int*>(acceleratorAllocDevice((rd+1)*sizeof(int)));
   
   //copy offsets to device
-  acceleratorCopyToDeviceAsynch(&offsets[0],d_offsets,sizeof(int)*(rd+1),computeStream);
+  acceleratorCopyToDeviceAsync(&offsets[0],d_offsets,sizeof(int)*(rd+1),computeStream);
   
-#if defined(__CUDACC__) && (__CUDACC_VER_MAJOR__ >= 13)
-  #define GRID_CUB_SUM_OP ::cuda::std::plus<>{}
-#else
-  #define GRID_CUB_SUM_OP ::gpucub::Sum()
-#endif
   
-  gpuError_t gpuErr = gpucub::DeviceSegmentedReduce::Reduce(temp_storage_array, temp_storage_bytes, rb_p,d_out, rd, d_offsets, d_offsets+1, GRID_CUB_SUM_OP, zero_init, computeStream);
+  gpuError_t gpuErr = gpucub::DeviceSegmentedReduce::Reduce(temp_storage_array, temp_storage_bytes, rb_p,d_out, rd, d_offsets, d_offsets+1, ::gpucub::Sum(), zero_init, computeStream);
   if (gpuErr!=gpuSuccess) {
     std::cout << GridLogError << "Lattice_slicesum_gpu.h: Encountered error during gpucub::DeviceSegmentedReduce::Reduce (setup)! Error: " << gpuErr <<std::endl;
     exit(EXIT_FAILURE);
@@ -86,15 +73,13 @@ inline void sliceSumReduction_cub_small(const vobj *Data,
   });
   
   //issue segmented reductions in computeStream
-  gpuErr = gpucub::DeviceSegmentedReduce::Reduce(temp_storage_array, temp_storage_bytes, rb_p, d_out, rd, d_offsets, d_offsets+1, GRID_CUB_SUM_OP, zero_init, computeStream);
+  gpuErr = gpucub::DeviceSegmentedReduce::Reduce(temp_storage_array, temp_storage_bytes, rb_p, d_out, rd, d_offsets, d_offsets+1,::gpucub::Sum(), zero_init, computeStream);
   if (gpuErr!=gpuSuccess) {
     std::cout << GridLogError << "Lattice_slicesum_gpu.h: Encountered error during gpucub::DeviceSegmentedReduce::Reduce! Error: " << gpuErr <<std::endl;
     exit(EXIT_FAILURE);
   }
   
-#undef GRID_CUB_SUM_OP
+  acceleratorCopyFromDeviceAsync(d_out,&lvSum[0],rd*sizeof(vobj),computeStream);
-  
-  acceleratorCopyFromDeviceAsynch(d_out,&lvSum[0],rd*sizeof(vobj),computeStream);
   
   //sync after copy
   accelerator_barrier();
@@ -109,15 +94,7 @@ inline void sliceSumReduction_cub_small(const vobj *Data,
 
 
 #if defined(GRID_SYCL)
-template<class vobj>
+template<class vobj> inline void sliceSumReduction_sycl_small(const vobj *Data, Vector <vobj> &lvSum, const int  &rd, const int &e1, const int &e2, const int &stride, const int &ostride, const int &Nsimd)
-inline void sliceSumReduction_sycl_small(const vobj *Data,
-					 std::vector <vobj> &lvSum,
-					 const int  &rd,
-					 const int &e1,
-					 const int &e2,
-					 const int &stride,
-					 const int &ostride,
-					 const int &Nsimd)
 {
   size_t subvol_size = e1*e2;
 
@@ -128,7 +105,7 @@ inline void sliceSumReduction_sycl_small(const vobj *Data,
     mysum[r] = vobj_zero; 
   }
 
-  deviceVector<vobj> reduction_buffer(rd*subvol_size);    
+  commVector<vobj> reduction_buffer(rd*subvol_size);    
 
   auto rb_p = &reduction_buffer[0];
 
@@ -147,11 +124,11 @@ inline void sliceSumReduction_sycl_small(const vobj *Data,
   });
 
   for (int r = 0; r < rd; r++) {
-      theGridAccelerator->submit([&](sycl::handler &cgh) {
+      theGridAccelerator->submit([&](cl::sycl::handler &cgh) {
-          auto Reduction = sycl::reduction(&mysum[r],std::plus<>());
+          auto Reduction = cl::sycl::reduction(&mysum[r],std::plus<>());
-          cgh.parallel_for(sycl::range<1>{subvol_size},
+          cgh.parallel_for(cl::sycl::range<1>{subvol_size},
           Reduction,
-          [=](sycl::id<1> item, auto &sum) {
+          [=](cl::sycl::id<1> item, auto &sum) {
               auto s = item[0];
               sum += rb_p[r*subvol_size+s];
           });
@@ -167,23 +144,14 @@ inline void sliceSumReduction_sycl_small(const vobj *Data,
 }
 #endif
 
-template<class vobj>
+template<class vobj> inline void sliceSumReduction_large(const vobj *Data, Vector<vobj> &lvSum, const int rd, const int e1, const int e2, const int stride, const int ostride, const int Nsimd) {
-inline void sliceSumReduction_large(const vobj *Data,
-				    std::vector<vobj> &lvSum,
-				    const int rd,
-				    const int e1,
-				    const int e2,
-				    const int stride,
-				    const int ostride,
-				    const int Nsimd)
-{
   typedef typename vobj::vector_type vector;
   const int words = sizeof(vobj)/sizeof(vector);
   const int osites = rd*e1*e2;
-  deviceVector<vector>buffer(osites);
+  commVector<vector>buffer(osites);
   vector *dat = (vector *)Data;
   vector *buf = &buffer[0];
-  std::vector<vector> lvSum_small(rd);
+  Vector<vector> lvSum_small(rd);
   vector *lvSum_ptr = (vector *)&lvSum[0];
 
   for (int w = 0; w < words; w++) {
@@ -200,18 +168,13 @@ inline void sliceSumReduction_large(const vobj *Data,
     for (int r = 0; r < rd; r++) {
       lvSum_ptr[w+words*r]=lvSum_small[r];
     }
-  }
+
   }
 
-template<class vobj>
+  
-inline void sliceSumReduction_gpu(const Lattice<vobj> &Data,
+}
-				  std::vector<vobj> &lvSum,
+
-				  const int rd,
+template<class vobj> inline void sliceSumReduction_gpu(const Lattice<vobj> &Data, Vector<vobj> &lvSum, const int rd, const int e1, const int e2, const int stride, const int ostride, const int Nsimd)
-				  const int e1,
-				  const int e2,
-				  const int stride,
-				  const int ostride,
-				  const int Nsimd)
 {
   autoView(Data_v, Data, AcceleratorRead); //reduction libraries cannot deal with large vobjs so we split into small/large case.
     if constexpr (sizeof(vobj) <= 256) { 
@@ -229,15 +192,7 @@ inline void sliceSumReduction_gpu(const Lattice<vobj> &Data,
 }
 
 
-template<class vobj>
+template<class vobj> inline void sliceSumReduction_cpu(const Lattice<vobj> &Data, Vector<vobj> &lvSum, const int &rd, const int &e1, const int &e2, const int &stride, const int &ostride, const int &Nsimd)
-inline void sliceSumReduction_cpu(const Lattice<vobj> &Data,
-				  std::vector<vobj> &lvSum,
-				  const int &rd,
-				  const int &e1,
-				  const int &e2,
-				  const int &stride,
-				  const int &ostride,
-				  const int &Nsimd)
 {
   // sum over reduced dimension planes, breaking out orthog dir
   // Parallel over orthog direction
@@ -253,19 +208,15 @@ inline void sliceSumReduction_cpu(const Lattice<vobj> &Data,
   });
 }
 
-template<class vobj> inline void sliceSumReduction(const Lattice<vobj> &Data,
+template<class vobj> inline void sliceSumReduction(const Lattice<vobj> &Data, Vector<vobj> &lvSum, const int &rd, const int &e1, const int &e2, const int &stride, const int &ostride, const int &Nsimd) 
-						   std::vector<vobj> &lvSum,
-						   const int &rd,
-						   const int &e1,
-						   const int &e2,
-						   const int &stride,
-						   const int &ostride,
-						   const int &Nsimd) 
 {
   #if defined(GRID_CUDA) || defined(GRID_HIP) || defined(GRID_SYCL)
+  
   sliceSumReduction_gpu(Data, lvSum, rd, e1, e2, stride, ostride, Nsimd);
+  
   #else
   sliceSumReduction_cpu(Data, lvSum, rd, e1, e2, stride, ostride, Nsimd);
+
   #endif
 }
 

Grid/lattice/Lattice_trace.h

@@ -124,68 +124,6 @@ Lattice<iScalar<iScalar<iMatrix<vComplexD, N> > > > Inverse(const Lattice<iScala
   return ret;
 }
 
-template<int N>
-Lattice<iMatrix<iScalar<iScalar<iScalar<vComplexD> > > , N> > Inverse(const Lattice<iMatrix<iScalar<iScalar<iScalar<vComplexD> > >, N> > &Umu)
-{
-  GridBase *grid=Umu.Grid();
-  auto lvol = grid->lSites();
-  Lattice<iMatrix<iScalar<iScalar<iScalar<vComplexD> > >, N > > ret(grid);
-  
-  autoView(Umu_v,Umu,CpuRead);
-  autoView(ret_v,ret,CpuWrite);
-  thread_for(site,lvol,{
-    Eigen::MatrixXcd EigenU = Eigen::MatrixXcd::Zero(N,N);
-    Coordinate lcoor;
-    grid->LocalIndexToLocalCoor(site, lcoor);
-    iMatrix<iScalar<iScalar<iScalar<ComplexD> > >, N > Us;
-    iMatrix<iScalar<iScalar<iScalar<ComplexD> > >, N > Ui;
-    peekLocalSite(Us, Umu_v, lcoor);
-    for(int i=0;i<N;i++){
-      for(int j=0;j<N;j++){
-	EigenU(i,j) = Us(i,j)()()();
-      }}
-    Eigen::MatrixXcd EigenUinv = EigenU.inverse();
-    for(int i=0;i<N;i++){
-      for(int j=0;j<N;j++){
-	Ui(i,j)()()() = EigenUinv(i,j);
-      }}
-    pokeLocalSite(Ui,ret_v,lcoor);
-  });
-  return ret;
-}
-
-template<int N>
-Lattice<iMatrix<iScalar<iScalar<iScalar<iScalar<vComplexD> > > > , N> > Inverse(const Lattice<iMatrix<iScalar<iScalar<iScalar<iScalar<vComplexD> > > >, N> > &Umu)
-{
-  GridBase *grid=Umu.Grid();
-  auto lvol = grid->lSites();
-  Lattice<iMatrix<iScalar<iScalar<iScalar<iScalar<vComplexD> > > >, N > > ret(grid);
-  
-  autoView(Umu_v,Umu,CpuRead);
-  autoView(ret_v,ret,CpuWrite);
-  thread_for(site,lvol,{
-    Eigen::MatrixXcd EigenU = Eigen::MatrixXcd::Zero(N,N);
-    Coordinate lcoor;
-    grid->LocalIndexToLocalCoor(site, lcoor);
-    iMatrix<iScalar<iScalar<iScalar<iScalar<ComplexD> > > >, N > Us;
-    iMatrix<iScalar<iScalar<iScalar<iScalar<ComplexD> > > >, N > Ui;
-    peekLocalSite(Us, Umu_v, lcoor);
-    for(int i=0;i<N;i++){
-      for(int j=0;j<N;j++){
-	EigenU(i,j) = Us(i,j)()()()();
-      }}
-    Eigen::MatrixXcd EigenUinv = EigenU.inverse();
-    for(int i=0;i<N;i++){
-      for(int j=0;j<N;j++){
-	Ui(i,j)()()()() = EigenUinv(i,j);
-      }}
-    pokeLocalSite(Ui,ret_v,lcoor);
-  });
-  return ret;
-}
-
-
-
 
 NAMESPACE_END(Grid);
 #endif

Grid/lattice/Lattice_transfer.h

@@ -31,15 +31,15 @@ NAMESPACE_BEGIN(Grid);
 
 inline void subdivides(GridBase *coarse,GridBase *fine)
 {
-  GRID_ASSERT(coarse->_ndimension == fine->_ndimension);
+  assert(coarse->_ndimension == fine->_ndimension);
 
   int _ndimension = coarse->_ndimension;
 
   // local and global volumes subdivide cleanly after SIMDization
   for(int d=0;d<_ndimension;d++){
-    GRID_ASSERT(coarse->_processors[d]  == fine->_processors[d]);
+    assert(coarse->_processors[d]  == fine->_processors[d]);
-    GRID_ASSERT(coarse->_simd_layout[d] == fine->_simd_layout[d]);
+    assert(coarse->_simd_layout[d] == fine->_simd_layout[d]);
-    GRID_ASSERT((fine->_rdimensions[d] / coarse->_rdimensions[d])* coarse->_rdimensions[d]==fine->_rdimensions[d]); 
+    assert((fine->_rdimensions[d] / coarse->_rdimensions[d])* coarse->_rdimensions[d]==fine->_rdimensions[d]); 
   }
 }
 
@@ -309,7 +309,7 @@ inline void batchBlockProject(std::vector<Lattice<iVector<CComplex,nbasis>>> &co
                                const VLattice &Basis)
 {
   int NBatch = fineData.size();
-  GRID_ASSERT(coarseData.size() == NBatch);
+  assert(coarseData.size() == NBatch);
 
   GridBase * fine  = fineData[0].Grid();
   GridBase * coarse= coarseData[0].Grid();
@@ -344,7 +344,7 @@ template<class vobj,class vobj2,class CComplex>
   GridBase * coarse= coarseA.Grid();
 
   fineZ.Checkerboard()=fineX.Checkerboard();
-  GRID_ASSERT(fineX.Checkerboard()==fineY.Checkerboard());
+  assert(fineX.Checkerboard()==fineY.Checkerboard());
   subdivides(coarse,fine); // require they map
   conformable(fineX,fineY);
   conformable(fineX,fineZ);
@@ -356,7 +356,7 @@ template<class vobj,class vobj2,class CComplex>
   // FIXME merge with subdivide checking routine as this is redundant
   for(int d=0 ; d<_ndimension;d++){
     block_r[d] = fine->_rdimensions[d] / coarse->_rdimensions[d];
-    GRID_ASSERT(block_r[d]*coarse->_rdimensions[d]==fine->_rdimensions[d]);
+    assert(block_r[d]*coarse->_rdimensions[d]==fine->_rdimensions[d]);
   }
 
   autoView( fineZ_  , fineZ, AcceleratorWrite);
@@ -613,7 +613,7 @@ inline void blockPromote(const Lattice<iVector<CComplex,nbasis > > &coarseData,
   int  _ndimension = coarse->_ndimension;
 
   // checks
-  GRID_ASSERT( nbasis == Basis.size() );
+  assert( nbasis == Basis.size() );
   subdivides(coarse,fine); 
   for(int i=0;i<nbasis;i++){
     conformable(Basis[i].Grid(),fine);
@@ -687,7 +687,7 @@ inline void batchBlockPromote(const std::vector<Lattice<iVector<CComplex,nbasis>
                                const VLattice &Basis)
 {
   int NBatch = coarseData.size();
-  GRID_ASSERT(fineData.size() == NBatch);
+  assert(fineData.size() == NBatch);
 
   GridBase * fine   = fineData[0].Grid();
   GridBase * coarse = coarseData[0].Grid();
@@ -715,12 +715,12 @@ void localConvert(const Lattice<vobj> &in,Lattice<vvobj> &out)
   int ni = ig->_ndimension;
   int no = og->_ndimension;
 
-  GRID_ASSERT(ni == no);
+  assert(ni == no);
 
   for(int d=0;d<no;d++){
-    GRID_ASSERT(ig->_processors[d]  == og->_processors[d]);
+    assert(ig->_processors[d]  == og->_processors[d]);
-    GRID_ASSERT(ig->_ldimensions[d] == og->_ldimensions[d]);
+    assert(ig->_ldimensions[d] == og->_ldimensions[d]);
-    GRID_ASSERT(ig->lSites() == og->lSites());
+    assert(ig->lSites() == og->lSites());
   }
 
   autoView(in_v,in,CpuRead);
@@ -752,16 +752,16 @@ void localCopyRegion(const Lattice<vobj> &From,Lattice<vobj> & To,Coordinate Fro
 
   GridBase *Fg = From.Grid();
   GridBase *Tg = To.Grid();
-  GRID_ASSERT(!Fg->_isCheckerBoarded);
+  assert(!Fg->_isCheckerBoarded);
-  GRID_ASSERT(!Tg->_isCheckerBoarded);
+  assert(!Tg->_isCheckerBoarded);
   int Nsimd = Fg->Nsimd();
   int nF = Fg->_ndimension;
   int nT = Tg->_ndimension;
   int nd = nF;
-  GRID_ASSERT(nF == nT);
+  assert(nF == nT);
 
   for(int d=0;d<nd;d++){
-    GRID_ASSERT(Fg->_processors[d]  == Tg->_processors[d]);
+    assert(Fg->_processors[d]  == Tg->_processors[d]);
   }
 
   ///////////////////////////////////////////////////////////
@@ -821,12 +821,12 @@ void InsertSliceFast(const Lattice<vobj> &From,Lattice<vobj> & To,int slice, int
   //////////////////////////////////////////////////////////////////////////////////////////
   GridBase *Fg = From.Grid();
   GridBase *Tg = To.Grid();
-  GRID_ASSERT(!Fg->_isCheckerBoarded);
+  assert(!Fg->_isCheckerBoarded);
-  GRID_ASSERT(!Tg->_isCheckerBoarded);
+  assert(!Tg->_isCheckerBoarded);
   int Nsimd = Fg->Nsimd();
   int nF = Fg->_ndimension;
   int nT = Tg->_ndimension;
-  GRID_ASSERT(nF+1 == nT);
+  assert(nF+1 == nT);
 
   ///////////////////////////////////////////////////////////
   // do the index calc on the GPU
@@ -890,12 +890,12 @@ void ExtractSliceFast(Lattice<vobj> &To,const Lattice<vobj> & From,int slice, in
   //////////////////////////////////////////////////////////////////////////////////////////
   GridBase *Fg = From.Grid();
   GridBase *Tg = To.Grid();
-  GRID_ASSERT(!Fg->_isCheckerBoarded);
+  assert(!Fg->_isCheckerBoarded);
-  GRID_ASSERT(!Tg->_isCheckerBoarded);
+  assert(!Tg->_isCheckerBoarded);
   int Nsimd = Fg->Nsimd();
   int nF = Fg->_ndimension;
   int nT = Tg->_ndimension;
-  GRID_ASSERT(nT+1 == nF);
+  assert(nT+1 == nF);
 
   ///////////////////////////////////////////////////////////
   // do the index calc on the GPU
@@ -955,16 +955,16 @@ void InsertSlice(const Lattice<vobj> &lowDim,Lattice<vobj> & higherDim,int slice
   int nl = lg->_ndimension;
   int nh = hg->_ndimension;
 
-  GRID_ASSERT(nl+1 == nh);
+  assert(nl+1 == nh);
-  GRID_ASSERT(orthog<nh);
+  assert(orthog<nh);
-  GRID_ASSERT(orthog>=0);
+  assert(orthog>=0);
-  GRID_ASSERT(hg->_processors[orthog]==1);
+  assert(hg->_processors[orthog]==1);
 
   int dl; dl = 0;
   for(int d=0;d<nh;d++){
     if ( d != orthog) {
-      GRID_ASSERT(lg->_processors[dl]  == hg->_processors[d]);
+      assert(lg->_processors[dl]  == hg->_processors[d]);
-      GRID_ASSERT(lg->_ldimensions[dl] == hg->_ldimensions[d]);
+      assert(lg->_ldimensions[dl] == hg->_ldimensions[d]);
       dl++;
     }
   }
@@ -1005,17 +1005,17 @@ void ExtractSlice(Lattice<vobj> &lowDim,const Lattice<vobj> & higherDim,int slic
   int nl = lg->_ndimension;
   int nh = hg->_ndimension;
 
-  GRID_ASSERT(nl+1 == nh);
+  assert(nl+1 == nh);
-  GRID_ASSERT(orthog<nh);
+  assert(orthog<nh);
-  GRID_ASSERT(orthog>=0);
+  assert(orthog>=0);
-  GRID_ASSERT(hg->_processors[orthog]==1);
+  assert(hg->_processors[orthog]==1);
   lowDim.Checkerboard() = higherDim.Checkerboard();
 
   int dl; dl = 0;
   for(int d=0;d<nh;d++){
     if ( d != orthog) {
-      GRID_ASSERT(lg->_processors[dl]  == hg->_processors[d]);
+      assert(lg->_processors[dl]  == hg->_processors[d]);
-      GRID_ASSERT(lg->_ldimensions[dl] == hg->_ldimensions[d]);
+      assert(lg->_ldimensions[dl] == hg->_ldimensions[d]);
       dl++;
     }
   }
@@ -1056,14 +1056,14 @@ void InsertSliceLocal(const Lattice<vobj> &lowDim, Lattice<vobj> & higherDim,int
   int nl = lg->_ndimension;
   int nh = hg->_ndimension;
 
-  GRID_ASSERT(nl == nh);
+  assert(nl == nh);
-  GRID_ASSERT(orthog<nh);
+  assert(orthog<nh);
-  GRID_ASSERT(orthog>=0);
+  assert(orthog>=0);
 
   for(int d=0;d<nh;d++){
     if ( d!=orthog ) {
-      GRID_ASSERT(lg->_processors[d]  == hg->_processors[d]);
+      assert(lg->_processors[d]  == hg->_processors[d]);
-      GRID_ASSERT(lg->_ldimensions[d] == hg->_ldimensions[d]);
+      assert(lg->_ldimensions[d] == hg->_ldimensions[d]);
     }
   }
   Coordinate sz = lg->_ldimensions;
@@ -1093,7 +1093,7 @@ void Replicate(const Lattice<vobj> &coarse,Lattice<vobj> & fine)
 
   subdivides(cg,fg); 
 
-  GRID_ASSERT(cg->_ndimension==fg->_ndimension);
+  assert(cg->_ndimension==fg->_ndimension);
 
   Coordinate ratio(cg->_ndimension);
 
@@ -1157,7 +1157,7 @@ unvectorizeToLexOrdArray(std::vector<sobj> &out, const Lattice<vobj> &in)
 
       int lex;
       Lexicographic::IndexFromCoor(lcoor, lex, in_grid->_ldimensions);
-      GRID_ASSERT(lex < out.size());
+      assert(lex < out.size());
       out_ptrs[lane] = &out[lex];
     }
     
@@ -1221,7 +1221,7 @@ vectorizeFromLexOrdArray( std::vector<sobj> &in, Lattice<vobj> &out)
   typedef typename vobj::vector_type vtype;
   
   GridBase* grid = out.Grid();
-  GRID_ASSERT(in.size()==grid->lSites());
+  assert(in.size()==grid->lSites());
   
   const int ndim     = grid->Nd();
   constexpr int nsimd    = vtype::Nsimd();
@@ -1268,7 +1268,7 @@ vectorizeFromRevLexOrdArray( std::vector<sobj> &in, Lattice<vobj> &out)
   typedef typename vobj::vector_type vtype;
   
   GridBase* grid = out._grid;
-  GRID_ASSERT(in.size()==grid->lSites());
+  assert(in.size()==grid->lSites());
   
   int ndim     = grid->Nd();
   int nsimd    = vtype::Nsimd();
@@ -1329,9 +1329,9 @@ void precisionChangeFast(Lattice<VobjOut> &out, const Lattice<VobjIn> &in)
 template<class VobjOut, class VobjIn>
 void precisionChangeOrig(Lattice<VobjOut> &out, const Lattice<VobjIn> &in)
 {
-  GRID_ASSERT(out.Grid()->Nd() == in.Grid()->Nd());
+  assert(out.Grid()->Nd() == in.Grid()->Nd());
   for(int d=0;d<out.Grid()->Nd();d++){
-    GRID_ASSERT(out.Grid()->FullDimensions()[d] == in.Grid()->FullDimensions()[d]);
+    assert(out.Grid()->FullDimensions()[d] == in.Grid()->FullDimensions()[d]);
   }
   out.Checkerboard() = in.Checkerboard();
   GridBase *in_grid=in.Grid();
@@ -1382,9 +1382,9 @@ class precisionChangeWorkspace{
 public:
   precisionChangeWorkspace(GridBase *out_grid, GridBase *in_grid): _out_grid(out_grid), _in_grid(in_grid){
     //Build a map between the sites and lanes of the output field and the input field as we cannot use the Grids on the device
-    GRID_ASSERT(out_grid->Nd() == in_grid->Nd());
+    assert(out_grid->Nd() == in_grid->Nd());
     for(int d=0;d<out_grid->Nd();d++){
-      GRID_ASSERT(out_grid->FullDimensions()[d] == in_grid->FullDimensions()[d]);
+      assert(out_grid->FullDimensions()[d] == in_grid->FullDimensions()[d]);
     }
     int Nsimd_out = out_grid->Nsimd();
 
@@ -1549,7 +1549,7 @@ void Grid_split(std::vector<Lattice<Vobj> > & full,Lattice<Vobj>   & split)
 
   int full_vecs   = full.size();
 
-  GRID_ASSERT(full_vecs>=1);
+  assert(full_vecs>=1);
 
   GridBase * full_grid = full[0].Grid();
   GridBase *split_grid = split.Grid();
@@ -1567,18 +1567,18 @@ void Grid_split(std::vector<Lattice<Vobj> > & full,Lattice<Vobj>   & split)
   //////////////////////////////
   // Checks
   //////////////////////////////
-  GRID_ASSERT(full_grid->_ndimension==split_grid->_ndimension);
+  assert(full_grid->_ndimension==split_grid->_ndimension);
   for(int n=0;n<full_vecs;n++){
-    GRID_ASSERT(full[n].Checkerboard() == cb);
+    assert(full[n].Checkerboard() == cb);
     for(int d=0;d<ndim;d++){
-      GRID_ASSERT(full[n].Grid()->_gdimensions[d]==split.Grid()->_gdimensions[d]);
+      assert(full[n].Grid()->_gdimensions[d]==split.Grid()->_gdimensions[d]);
-      GRID_ASSERT(full[n].Grid()->_fdimensions[d]==split.Grid()->_fdimensions[d]);
+      assert(full[n].Grid()->_fdimensions[d]==split.Grid()->_fdimensions[d]);
     }
   }
 
   int   nvector   =full_nproc/split_nproc; 
-  GRID_ASSERT(nvector*split_nproc==full_nproc);
+  assert(nvector*split_nproc==full_nproc);
-  GRID_ASSERT(nvector == full_vecs);
+  assert(nvector == full_vecs);
 
   Coordinate ratio(ndim);
   for(int d=0;d<ndim;d++){
@@ -1622,7 +1622,7 @@ void Grid_split(std::vector<Lattice<Vobj> > & full,Lattice<Vobj>   & split)
 
       int fvol   = lsites;
       
-      int chunk  = (nvec*fvol)/sP;          GRID_ASSERT(chunk*sP == nvec*fvol);
+      int chunk  = (nvec*fvol)/sP;          assert(chunk*sP == nvec*fvol);
 
       // Loop over reordered data post A2A
       thread_for(c, chunk, {
@@ -1675,7 +1675,7 @@ void Grid_unsplit(std::vector<Lattice<Vobj> > & full,Lattice<Vobj>   & split)
 
   int full_vecs   = full.size();
 
-  GRID_ASSERT(full_vecs>=1);
+  assert(full_vecs>=1);
 
   GridBase * full_grid = full[0].Grid();
   GridBase *split_grid = split.Grid();
@@ -1693,18 +1693,18 @@ void Grid_unsplit(std::vector<Lattice<Vobj> > & full,Lattice<Vobj>   & split)
   //////////////////////////////
   // Checks
   //////////////////////////////
-  GRID_ASSERT(full_grid->_ndimension==split_grid->_ndimension);
+  assert(full_grid->_ndimension==split_grid->_ndimension);
   for(int n=0;n<full_vecs;n++){
-    GRID_ASSERT(full[n].Checkerboard() == cb);
+    assert(full[n].Checkerboard() == cb);
     for(int d=0;d<ndim;d++){
-      GRID_ASSERT(full[n].Grid()->_gdimensions[d]==split.Grid()->_gdimensions[d]);
+      assert(full[n].Grid()->_gdimensions[d]==split.Grid()->_gdimensions[d]);
-      GRID_ASSERT(full[n].Grid()->_fdimensions[d]==split.Grid()->_fdimensions[d]);
+      assert(full[n].Grid()->_fdimensions[d]==split.Grid()->_fdimensions[d]);
     }
   }
 
   int   nvector   =full_nproc/split_nproc; 
-  GRID_ASSERT(nvector*split_nproc==full_nproc);
+  assert(nvector*split_nproc==full_nproc);
-  GRID_ASSERT(nvector == full_vecs);
+  assert(nvector == full_vecs);
 
   Coordinate ratio(ndim);
   for(int d=0;d<ndim;d++){
@@ -1740,7 +1740,7 @@ void Grid_unsplit(std::vector<Lattice<Vobj> > & full,Lattice<Vobj>   & split)
       auto lsites= rsites/M;                // Decreases rsites by M
       
       int fvol   = lsites;
-      int chunk  = (nvec*fvol)/sP;          GRID_ASSERT(chunk*sP == nvec*fvol);
+      int chunk  = (nvec*fvol)/sP;          assert(chunk*sP == nvec*fvol);
 	
       {
 	// Loop over reordered data post A2A

Grid/lattice/Lattice_view.h

@@ -106,47 +106,6 @@ public:
   }
 
 };
-
-#ifdef GRID_LOG_VIEWS
-// Little autoscope assister
-template<class View> 
-class ViewCloser
-{
-  View v;  // Take a copy of view and call view close when I go out of scope automatically
-  const char* filename; int line, mode;
-public:
-  ViewCloser(View &_v, const char* _filename, int _line, int _mode) :
-    v(_v), filename(_filename), line(_line), mode(_mode) {
-    
-    switch (mode){
-    case AcceleratorRead:
-    case AcceleratorWrite:
-    case CpuRead:
-    case CpuWrite:
-      ViewLogger::LogOpen(filename, line, 1, mode, &v[0], v.size() * sizeof(v[0]));
-      break;
-    } 
-    
-  };
-  ~ViewCloser() {
-    
-    switch (mode) {
-    case AcceleratorWriteDiscard:
-    case AcceleratorWrite:
-    case CpuWrite:
-      ViewLogger::LogClose(filename, line, -1, mode, &v[0], v.size() * sizeof(v[0]));
-      break;
-    }
-    
-    v.ViewClose();
-  }
-};
-
-#define autoView(l_v,l,mode)				\
-	  auto l_v = l.View(mode);			\
-	  ViewCloser<decltype(l_v)> _autoView##l_v(l_v,__FILE__,__LINE__,mode);
-
-#else
 // Little autoscope assister
 template<class View> 
 class ViewCloser
@@ -160,7 +119,6 @@ class ViewCloser
 #define autoView(l_v,l,mode)				\
 	  auto l_v = l.View(mode);			\
 	  ViewCloser<decltype(l_v)> _autoView##l_v(l_v);
-#endif
 
 /////////////////////////////////////////////////////////////////////////////////////////
 // Lattice expression types used by ET to assemble the AST

Grid/lattice/PaddedCell.h

@@ -54,7 +54,7 @@ struct CshiftImplGauge: public CshiftImplBase<typename Gimpl::GaugeLinkField::ve
  *
  */
 
-template<class vobj> inline void ScatterSlice(const deviceVector<vobj> &buf,
+template<class vobj> inline void ScatterSlice(const cshiftVector<vobj> &buf,
 					      Lattice<vobj> &lat,
 					      int x,
 					      int dim,
@@ -82,10 +82,10 @@ template<class vobj> inline void ScatterSlice(const deviceVector<vobj> &buf,
 
   int rNsimd = 1; for(int d=0;d<Nd;d++) rNsimd*=rsimd[d];
   int rNsimda= Nsimd/simd[dim]; // should be equal
-  GRID_ASSERT(rNsimda==rNsimd);
+  assert(rNsimda==rNsimd);
   int face_ovol=block*nblock;
 
-  //  GRID_ASSERT(buf.size()==face_ovol*rNsimd);
+  //  assert(buf.size()==face_ovol*rNsimd);
 
   /*This will work GPU ONLY unless rNsimd is put in the lexico index*/
   //Let's make it work on GPU and then make a special accelerator_for that
@@ -140,7 +140,7 @@ template<class vobj> inline void ScatterSlice(const deviceVector<vobj> &buf,
   });
 }
 
-template<class vobj> inline void GatherSlice(deviceVector<vobj> &buf,
+template<class vobj> inline void GatherSlice(cshiftVector<vobj> &buf,
 					     const Lattice<vobj> &lat,
 					     int x,
 					     int dim,
@@ -172,7 +172,7 @@ template<class vobj> inline void GatherSlice(deviceVector<vobj> &buf,
   
   int face_ovol=block*nblock;
 
-  //  GRID_ASSERT(buf.size()==face_ovol*rNsimd);
+  //  assert(buf.size()==face_ovol*rNsimd);
 
   /*This will work GPU ONLY unless rNsimd is put in the lexico index*/
   //Let's make it work on GPU and then make a special accelerator_for that
@@ -247,7 +247,7 @@ public:
     Coordinate local     =unpadded_grid->LocalDimensions();
     Coordinate procs     =unpadded_grid->ProcessorGrid();
     for(int d=0;d<dims;d++){
-      if ( procs[d] > 1 ) GRID_ASSERT(local[d]>=depth);
+      if ( procs[d] > 1 ) assert(local[d]>=depth);
     }
   }
   void DeleteGrids(void)
@@ -448,9 +448,9 @@ public:
     int nld   = to.Grid()->_ldimensions[dimension];
     const int Nsimd = vobj::Nsimd();
 
-    GRID_ASSERT(depth<=lds[dimension]); // A must be on neighbouring node
+    assert(depth<=lds[dimension]); // A must be on neighbouring node
-    GRID_ASSERT(depth>0);   // A caller bug if zero
+    assert(depth>0);   // A caller bug if zero
-    GRID_ASSERT(ld+2*depth==nld);
+    assert(ld+2*depth==nld);
     ////////////////////////////////////////////////////////////////////////////
     // Face size and byte calculations
     ////////////////////////////////////////////////////////////////////////////
@@ -460,21 +460,15 @@ public:
     }
     buffer_size = buffer_size  / Nsimd;
     int rNsimd = Nsimd / simd[dimension];
-    GRID_ASSERT( buffer_size == from.Grid()->_slice_nblock[dimension]*from.Grid()->_slice_block[dimension] / simd[dimension]);
+    assert( buffer_size == from.Grid()->_slice_nblock[dimension]*from.Grid()->_slice_block[dimension] / simd[dimension]);
 
-    static deviceVector<vobj> send_buf; 
+    static cshiftVector<vobj> send_buf; 
-    static deviceVector<vobj> recv_buf;
+    static cshiftVector<vobj> recv_buf;
     send_buf.resize(buffer_size*2*depth);    
     recv_buf.resize(buffer_size*2*depth);
-#ifndef ACCELERATOR_AWARE_MPI
-    static hostVector<vobj> hsend_buf; 
-    static hostVector<vobj> hrecv_buf;
-    hsend_buf.resize(buffer_size*2*depth);    
-    hrecv_buf.resize(buffer_size*2*depth);
-#endif    
 
-    std::vector<MpiCommsRequest_t> fwd_req;   
+    std::vector<CommsRequest_t> fwd_req;   
-    std::vector<MpiCommsRequest_t> bwd_req;   
+    std::vector<CommsRequest_t> bwd_req;   
 
     int words = buffer_size;
     int bytes = words * sizeof(vobj);
@@ -501,16 +495,9 @@ public:
       t_gather+=usecond()-t;
 
       t=usecond();
-#ifdef ACCELERATOR_AWARE_MPI
       grid->SendToRecvFromBegin(fwd_req,
 				(void *)&send_buf[d*buffer_size], xmit_to_rank,
 				(void *)&recv_buf[d*buffer_size], recv_from_rank, bytes, tag);
-#else
-      acceleratorCopyFromDevice(&send_buf[d*buffer_size],&hsend_buf[d*buffer_size],bytes);
-      grid->SendToRecvFromBegin(fwd_req,
-				(void *)&hsend_buf[d*buffer_size], xmit_to_rank,
-				(void *)&hrecv_buf[d*buffer_size], recv_from_rank, bytes, tag);
-#endif
       t_comms+=usecond()-t;
      }
     for ( int d=0;d < depth ; d ++ ) {
@@ -521,16 +508,9 @@ public:
       t_gather+= usecond() - t;
 
       t=usecond();
-#ifdef ACCELERATOR_AWARE_MPI
       grid->SendToRecvFromBegin(bwd_req,
 				(void *)&send_buf[(d+depth)*buffer_size], recv_from_rank,
 				(void *)&recv_buf[(d+depth)*buffer_size], xmit_to_rank, bytes,tag);
-#else
-      acceleratorCopyFromDevice(&send_buf[(d+depth)*buffer_size],&hsend_buf[(d+depth)*buffer_size],bytes);
-      grid->SendToRecvFromBegin(bwd_req,
-				(void *)&hsend_buf[(d+depth)*buffer_size], recv_from_rank,
-				(void *)&hrecv_buf[(d+depth)*buffer_size], xmit_to_rank, bytes,tag);
-#endif      
       t_comms+=usecond()-t;
     }
 
@@ -553,11 +533,6 @@ public:
 
     t=usecond();
     grid->CommsComplete(fwd_req);
-#ifndef ACCELERATOR_AWARE_MPI
-    for ( int d=0;d < depth ; d ++ ) {
-      acceleratorCopyToDevice(&hrecv_buf[d*buffer_size],&recv_buf[d*buffer_size],bytes);
-    }
-#endif
     t_comms+= usecond() - t;
 
     t=usecond();
@@ -568,11 +543,6 @@ public:
 
     t=usecond();
     grid->CommsComplete(bwd_req);
-#ifndef ACCELERATOR_AWARE_MPI
-    for ( int d=0;d < depth ; d ++ ) {
-      acceleratorCopyToDevice(&hrecv_buf[(d+depth)*buffer_size],&recv_buf[(d+depth)*buffer_size],bytes);
-    }
-#endif
     t_comms+= usecond() - t;
     
     t=usecond();

Grid/log/Log.cc

@@ -69,7 +69,6 @@ GridLogger GridLogMemory (1, "Memory", GridLogColours, "NORMAL");
 GridLogger GridLogTracing(1, "Tracing", GridLogColours, "NORMAL");
 GridLogger GridLogDebug  (1, "Debug", GridLogColours, "PURPLE");
 GridLogger GridLogPerformance(1, "Performance", GridLogColours, "GREEN");
-GridLogger GridLogComms      (1, "Comms",  GridLogColours, "BLUE");
 GridLogger GridLogDslash     (1, "Dslash", GridLogColours, "BLUE");
 GridLogger GridLogIterative  (1, "Iterative", GridLogColours, "BLUE");
 GridLogger GridLogIntegrator (1, "Integrator", GridLogColours, "BLUE");
@@ -85,7 +84,6 @@ void GridLogConfigure(std::vector<std::string> &logstreams) {
   GridLogDebug.Active(0);
   GridLogPerformance.Active(0);
   GridLogDslash.Active(0);
-  GridLogComms.Active(0);
   GridLogIntegrator.Active(1);
   GridLogColours.Active(0);
   GridLogHMC.Active(1);
@@ -99,7 +97,6 @@ void GridLogConfigure(std::vector<std::string> &logstreams) {
     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("Comms"))       GridLogComms.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

@@ -33,6 +33,10 @@
 #ifndef GRID_LOG_H
 #define GRID_LOG_H
 
+#ifdef HAVE_EXECINFO_H
+#include <execinfo.h>
+#endif
+
 NAMESPACE_BEGIN(Grid);
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -176,7 +180,6 @@ extern GridLogger GridLogError;
 extern GridLogger GridLogWarning;
 extern GridLogger GridLogMessage;
 extern GridLogger GridLogDebug;
-extern GridLogger GridLogComms;
 extern GridLogger GridLogPerformance;
 extern GridLogger GridLogDslash;
 extern GridLogger GridLogIterative;
@@ -223,6 +226,8 @@ inline void Grid_pass(Args&&... args) {
     std::cout << "\033[32m" << GridLogMessage << msg << "\033[0m" << std::endl;
 }
 
+#define _NBACKTRACE (256)
+extern void * Grid_backtrace_buffer[_NBACKTRACE];
 
 #define BACKTRACEFILE() {						\
     char string[20];							\

Grid/parallelIO/BinaryIO.cc

@@ -2,7 +2,3 @@
 
 int                    Grid::BinaryIO::latticeWriteMaxRetry = -1;
 Grid::BinaryIO::IoPerf Grid::BinaryIO::lastPerf;
-
-// Target size of a single contiguous file extent under BINARYIO_AGGREGATE.
-// 4MB is around the knee for Lustre; exposed so it can be swept at runtime.
-uint64_t               Grid::BinaryIO::aggregateTargetBytes = 4*1024*1024;

Grid/parallelIO/BinaryIO.h

@@ -39,7 +39,6 @@
 #endif
 
 #include <arpa/inet.h>
-#include <sys/stat.h>
 #include <algorithm>
 
 NAMESPACE_BEGIN(Grid);
@@ -88,7 +87,6 @@ class BinaryIO {
 
   static IoPerf lastPerf;
   static int latticeWriteMaxRetry;
-  static uint64_t aggregateTargetBytes;
 
   /////////////////////////////////////////////////////////////////////////////
   // more byte manipulation helpers
@@ -255,392 +253,12 @@ class BinaryIO {
   // Read or Write distributed lexico array of ANY object to a specific location in file 
   //////////////////////////////////////////////////////////////////////////////////////
 
-  static const int BINARYIO_AGGREGATE     = 0x20;
   static const int BINARYIO_MASTER_APPEND = 0x10;
   static const int BINARYIO_UNORDERED     = 0x08;
   static const int BINARYIO_LEXICOGRAPHIC = 0x04;
   static const int BINARYIO_READ          = 0x02;
   static const int BINARYIO_WRITE         = 0x01;
 
-#ifdef USE_MPI_IO
-  /////////////////////////////////////////////////////////////////////////////
-  // Aggregation: self controlled transposition onto an I/O friendly layout.
-  //
-  // Under BINARYIO_LEXICOGRAPHIC the subarray file view handed to MPI-IO has
-  // contiguous runs of only lLattice[0]*sizeof(fobj) bytes -- a few KB for
-  // typical local volumes. Rather than rely on collective buffering to repair
-  // that, redistribute the payload ourselves so every rank owns a contiguous
-  // range of the global lexicographic site ordering, then issue large plain
-  // contiguous writes.
-  //
-  // "Un-splitting" the nunsplit fastest dimensions means the row of ranks
-  // sharing the remaining process coordinates collectively owns whole global
-  // hyperplanes. All data movement is then confined to that row communicator.
-  // Every rank still owns exactly lSites() sites afterwards, so the exchange is
-  // a pure permutation and needs no divisibility condition on the process grid.
-  /////////////////////////////////////////////////////////////////////////////
-  struct AggregationPlan {
-    int      nunsplit{0};  // number of fastest dimensions un-split
-    int      rowsize{0};   // ranks in the aggregation (row) communicator
-    int      rowrank{0};   // our logical (lexicographic) index within the row
-    uint64_t lsites{0};    // sites per rank -- invariant under the permutation
-    uint64_t chunk{0};     // sites in one globally contiguous run owned by the row
-    std::unique_ptr<CartesianCommunicator> rowcomm;
-    // counts and displacements are indexed by rank within rowcomm
-    std::vector<int>      sendcounts, senddispls, recvcounts, recvdispls;
-    std::vector<uint64_t> scatter;     // recv slot -> slot in the aggregated buffer
-    std::vector<uint64_t> extentGsite; // global lex site index of extent start
-    std::vector<uint64_t> extentLocal; // offset of extent within aggregated buffer
-    std::vector<uint64_t> extentSites; // sites in this extent
-  };
-
-  static inline void BuildAggregationPlan(GridBase *grid,uint64_t fobjSize,AggregationPlan &p)
-  {
-    int ndim           = grid->Dimensions();
-    Coordinate psizes  = grid->ProcessorGrid();
-    Coordinate pcoor   = grid->ThisProcessorCoor();
-    Coordinate gLattice= grid->GlobalDimensions();
-    Coordinate lLattice= grid->LocalDimensions();
-    Coordinate lstart  = grid->LocalStarts();
-
-    uint64_t lsites = grid->lSites();
-    p.lsites = lsites;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Un-splitting dims 0..k-1 gives the row a contiguous run of
-    //     chunk(k) = prod_{d<k} gLattice[d] * lLattice[k]
-    // sites, and each rank writes extents of min(chunk,lsites). Take the
-    // smallest k that reaches the target so we disturb as few dimensions --
-    // and move as little data -- as possible.
-    //////////////////////////////////////////////////////////////////////////
-    int k = ndim-1;
-    for(int trial=1; trial<ndim; trial++){
-      uint64_t chunk = lLattice[trial];
-      for(int d=0; d<trial; d++) chunk *= gLattice[d];
-      if ( std::min(chunk,lsites)*fobjSize >= aggregateTargetBytes ) { k = trial; break; }
-    }
-    p.nunsplit = k;
-
-    //////////////////////////////////////////////////////////////////////////
-    // The box the row collectively owns, expressed in global coordinates.
-    // Restricting the global lexicographic order to this box preserves the
-    // ordering, so the row index below is monotone in the global index.
-    //////////////////////////////////////////////////////////////////////////
-    Coordinate B(ndim), S(ndim);
-    for(int d=0; d<ndim; d++){
-      if ( d<k ) { B[d] = gLattice[d]; S[d] = 0;         }
-      else       { B[d] = lLattice[d]; S[d] = lstart[d]; }
-    }
-
-    uint64_t chunk = lLattice[k];
-    for(int d=0; d<k; d++) chunk *= gLattice[d];
-    p.chunk = chunk;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Row communicator: the ranks sharing the process coordinates of the slow
-    // (still split) dimensions. This is the sub-division the Cartesian
-    // communicator already performs for AllToAll(dim,...), widened from one
-    // dimension to the k fastest.
-    //////////////////////////////////////////////////////////////////////////
-    Coordinate row(ndim,1);
-    for(int d=0; d<k; d++) row[d] = psizes[d];
-    int srank;
-    p.rowcomm.reset(new CartesianCommunicator(row,*grid,srank));
-    p.rowsize = p.rowcomm->ProcessorCount();
-
-    //////////////////////////////////////////////////////////////////////////
-    // Our logical index in the row is the forward lexicographic index of the
-    // un-split process coordinates, so that increasing logical index means
-    // increasing global lexicographic position in the file. The communicator
-    // numbers its own ranks by the reversed (MPI) convention, so build the map
-    // between the two rather than assuming either.
-    //////////////////////////////////////////////////////////////////////////
-    int64_t logical=0, lstride=1;
-    for(int d=0; d<k; d++){ logical += pcoor[d]*lstride; lstride *= psizes[d]; }
-    GRID_ASSERT(lstride == (int64_t)p.rowsize);
-    p.rowrank = (int)logical;
-
-    std::vector<uint64_t> commOf(p.rowsize,0);
-    commOf[p.rowrank] = (uint64_t)p.rowcomm->ThisRank();
-    p.rowcomm->GlobalSumVector(&commOf[0],p.rowsize);
-
-    uint64_t mystart = (uint64_t)p.rowrank * lsites;
-    uint64_t myend   = mystart + lsites;
-
-    Coordinate lcoor(ndim), bcoor(ndim), gcoor(ndim);
-
-    //////////////////////////////////////////////////////////////////////////
-    // Send side. Walking our local sites in local lexicographic order walks
-    // the row index monotonically, so the send buffer is iodata untouched and
-    // we need only the per destination counts.
-    //////////////////////////////////////////////////////////////////////////
-    std::vector<int> sendLogical(p.rowsize,0);
-    for(uint64_t L=0; L<lsites; L++){
-      Lexicographic::CoorFromIndex(lcoor,L,lLattice);
-      for(int d=0; d<ndim; d++) bcoor[d] = (d<k) ? (lstart[d]+lcoor[d]) : lcoor[d];
-      int64_t ri; Lexicographic::IndexFromCoor(bcoor,ri,B);
-      sendLogical[ ri/(int64_t)lsites ]++;
-    }
-    p.sendcounts.assign(p.rowsize,0);
-    p.senddispls.assign(p.rowsize,0);
-    { int64_t disp=0;
-      for(int d=0; d<p.rowsize; d++){          // send buffer is in logical order
-        int c = (int)commOf[d];
-        p.sendcounts[c] = sendLogical[d];
-        p.senddispls[c] = (int)disp;
-        disp += sendLogical[d];
-      }
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Receive side. For each slot of our aggregated range work out which rank
-    // of the row owns it. Within one source the slots arrive in increasing row
-    // index order, which is the order the source sends them in.
-    //////////////////////////////////////////////////////////////////////////
-    std::vector<int> recvLogical(p.rowsize,0), recvDisplLogical(p.rowsize,0);
-    std::vector<int> source(lsites);
-    for(uint64_t pos=0; pos<lsites; pos++){
-      Lexicographic::CoorFromIndex(bcoor,(int64_t)(mystart+pos),B);
-      int64_t j=0, jstride=1;
-      for(int d=0; d<k; d++){ j += (bcoor[d]/lLattice[d])*jstride; jstride *= psizes[d]; }
-      source[pos] = (int)j;
-      recvLogical[j]++;
-    }
-    p.recvcounts.assign(p.rowsize,0);
-    p.recvdispls.assign(p.rowsize,0);
-    { int64_t disp=0;
-      for(int s=0; s<p.rowsize; s++){         // recv buffer is in logical order
-        int c = (int)commOf[s];
-        recvDisplLogical[s] = (int)disp;
-        p.recvcounts[c] = recvLogical[s];
-        p.recvdispls[c] = (int)disp;
-        disp += recvLogical[s];
-      }
-    }
-    p.scatter.resize(lsites);
-    {
-      std::vector<int> fill(p.rowsize,0);
-      for(uint64_t pos=0; pos<lsites; pos++){
-        int j = source[pos];
-        p.scatter[ recvDisplLogical[j] + fill[j]++ ] = pos;
-      }
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // The two sides are derived independently; make them check each other.
-    //////////////////////////////////////////////////////////////////////////
-    {
-      std::vector<uint64_t> sendc(p.rowsize),recvc(p.rowsize);
-      for(int c=0;c<p.rowsize;c++) sendc[c]=(uint64_t)p.sendcounts[c];
-      p.rowcomm->AllToAll(&sendc[0],&recvc[0],1,sizeof(uint64_t));
-      for(int c=0;c<p.rowsize;c++) GRID_ASSERT((int)recvc[c]==p.recvcounts[c]);
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Decompose our range into globally contiguous file extents.
-    //////////////////////////////////////////////////////////////////////////
-    for(uint64_t c = mystart/chunk; c <= (myend-1)/chunk; c++){
-      uint64_t lo = std::max(mystart, c*chunk);
-      uint64_t hi = std::min(myend, (c+1)*chunk);
-      Lexicographic::CoorFromIndex(bcoor,(int64_t)(c*chunk),B);
-      for(int d=0;d<ndim;d++) gcoor[d] = (d<k) ? bcoor[d] : bcoor[d]+S[d];
-      int64_t gbase; Lexicographic::IndexFromCoor(gcoor,gbase,gLattice);
-      p.extentGsite.push_back( (uint64_t)gbase + (lo - c*chunk) );
-      p.extentLocal.push_back( lo - mystart );
-      p.extentSites.push_back( hi - lo );
-    }
-  }
-
-  static inline void ReportAggregationPlan(GridBase *grid,const AggregationPlan &p,uint64_t fobjSize,const char *what)
-  {
-    if ( !grid->IsBoss() ) return;
-    std::cout << GridLogMessage << "IOobject: aggregate " << what
-              << " un-splitting " << p.nunsplit << " fastest dimensions, row of "
-              << p.rowsize << " ranks" << std::endl;
-    std::cout << GridLogMessage << "IOobject: aggregate " << p.extentSites.size()
-              << " extent(s)/rank, first " << p.extentSites[0]*fobjSize/1024./1024. << " MB"
-              << " (target " << aggregateTargetBytes/1024./1024. << " MB)" << std::endl;
-    std::cout << GridLogMessage << "IOobject: aggregate buffer overhead "
-              << p.lsites*fobjSize/1024./1024. << " MB/rank" << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////////////
-  // Stage timings.  The interesting quantity is the slowest rank, since every
-  // stage is followed sooner or later by a synchronisation, so reduce with
-  // GlobalMax rather than reporting whatever the boss happened to see.
-  ////////////////////////////////////////////////////////////////////////////
-  static inline void ReportStages(GridBase *grid,const char *what,
-                                  const std::vector<const char *> &names,
-                                  std::vector<RealD> &useconds)
-  {
-    GRID_ASSERT(names.size()==useconds.size());
-    for(uint64_t i=0;i<useconds.size();i++) grid->GlobalMax(useconds[i]);
-    if ( grid->IsBoss() ) {
-      std::cout << GridLogMessage << "IOobject: aggregate " << what << " stages (max over ranks, s):";
-      for(uint64_t i=0;i<names.size();i++)
-        std::cout << " " << names[i] << " " << useconds[i]/1.0e6;
-      std::cout << std::endl;
-    }
-  }
-
-  template<class fobj>
-  static inline void AggregateExchange(GridBase *grid,AggregationPlan &p,std::vector<fobj> &iodata,
-                                       std::vector<fobj> &aggregated,int forward)
-  {
-    uint64_t lsites = p.lsites;
-    GridStopWatch talloc,tperm,tcomm;
-
-    talloc.Start();
-    std::vector<fobj> tmp(lsites);
-    talloc.Stop();
-
-    if ( forward ) { // iodata (local order) -> aggregated (lexicographic order)
-      tcomm.Start();
-      p.rowcomm->AllToAllV(&iodata[0],p.sendcounts,p.senddispls,
-                           &tmp[0],   p.recvcounts,p.recvdispls,sizeof(fobj));
-      tcomm.Stop();
-      tperm.Start();
-      thread_for(s,lsites,{ aggregated[p.scatter[s]] = tmp[s]; });
-      tperm.Stop();
-    } else {         // aggregated -> iodata, the exact mirror
-      tperm.Start();
-      thread_for(s,lsites,{ tmp[s] = aggregated[p.scatter[s]]; });
-      tperm.Stop();
-      tcomm.Start();
-      p.rowcomm->AllToAllV(&tmp[0],   p.recvcounts,p.recvdispls,
-                           &iodata[0],p.sendcounts,p.senddispls,sizeof(fobj));
-      tcomm.Stop();
-    }
-
-    std::vector<RealD> us = { (RealD)talloc.useconds(), (RealD)tperm.useconds(), (RealD)tcomm.useconds() };
-    ReportStages(grid,forward?"exchange (write)":"exchange (read)",
-                 {"alloc","permute","alltoallv"},us);
-  }
-
-  template<class fobj>
-  static inline void AggregateWrite(GridBase *grid,AggregationPlan &p,std::vector<fobj> &aggregated,
-                                    std::string file,uint64_t offset)
-  {
-    //////////////////////////////////////////////////////////////////////////
-    // All ranks write concurrently into a shared file, so the file must exist
-    // before any of them open it for update, but it does NOT have to be the
-    // right length first: the extents tile the record exactly, so writing them
-    // extends a short file to precisely offset+payload.
-    //
-    // Records are created in sequence, so this payload ends the file: the
-    // length must end up precisely offset+payload. Anything beyond is left
-    // over from whatever the file previously held and must not survive -- a
-    // shorter new record written over a longer old one would otherwise leave
-    // a trailing fragment of the previous contents masquerading as data.
-    // That is the only case needing a truncate, so stat first and truncate
-    // afterwards only when the size actually came out wrong. Measured on
-    // Frontier, an unconditional truncate up front cost 0.22 to 5.4 s per
-    // record -- 15 to 25% of a 19 GB write and 100% of a small one -- while
-    // create, open and close together cost a few milliseconds. It is per
-    // record, so multi record files do not amortise it away.
-    //
-    // ::truncate is used because the C++ standard library cannot express this.
-    // std::filebuf has no length operation at all; ios::trunc only truncates to
-    // zero; seeking past the end and writing a byte can grow a file but never
-    // shrink one; and there is no portable way to recover a descriptor from a
-    // stream in order to call ftruncate. C++17 does finally offer
-    // std::filesystem::resize_file, but that would be Grid's first <filesystem>
-    // dependency and needs -lstdc++fs on the older toolchains still in use.
-    //////////////////////////////////////////////////////////////////////////
-    GridStopWatch tcreate,ttrunc,tbar,topen,twrite,tclose,tskew;
-    uint64_t need = offset + (uint64_t)grid->_gsites*sizeof(fobj);
-
-    tcreate.Start();
-    if ( grid->IsBoss() ) {
-      // opening for update needs the file to exist; create one only if not
-      std::fstream probe(file,std::ios::binary|std::ios::out|std::ios::in);
-      if ( !probe.is_open() ) {
-        std::ofstream create(file,std::ios::binary|std::ios::out);
-        create.close();
-      }
-    }
-    tcreate.Stop();
-
-    tbar.Start();
-    grid->Barrier();
-    tbar.Stop();
-
-    std::ofstream fout;
-    fout.exceptions( std::fstream::failbit | std::fstream::badbit );
-    try {
-      topen.Start();
-      fout.open(file,std::ios::binary|std::ios::out|std::ios::in);
-      topen.Stop();
-      twrite.Start();
-      for(uint64_t e=0;e<p.extentSites.size();e++){
-        fout.seekp(offset + p.extentGsite[e]*sizeof(fobj));
-        fout.write((char *)&aggregated[p.extentLocal[e]],p.extentSites[e]*sizeof(fobj));
-      }
-      twrite.Stop();
-      tclose.Start();
-      fout.close();   // flushes the stream buffer; does not force writeback
-      tclose.Stop();
-    } catch (const std::fstream::failure& exc) {
-      std::cout << GridLogError << "Error in aggregate write to " << file << std::endl;
-      std::cout << GridLogError << "Exception description: " << exc.what() << std::endl;
-      GridAbort();
-    }
-
-    ////////////////////////////////////////////////////////////////////////
-    // Timed apart from the truncate that follows it.  seek+write above is the
-    // slowest rank; this barrier is what the fastest rank then waits, so the
-    // pair separates the write cost from the spread across ranks. Folding it
-    // into the truncate makes a millisecond stat look like a second.
-    ////////////////////////////////////////////////////////////////////////
-    tskew.Start();
-    grid->Barrier();                 // every extent must be on its way first
-    tskew.Stop();
-
-    ttrunc.Start();
-    if ( grid->IsBoss() ) {
-      struct stat sb;
-      int ierr = ::stat(file.c_str(),&sb);
-      GRID_ASSERT(ierr==0);
-      if ( (uint64_t)sb.st_size != need ) {   // only when a longer record preceded us
-        ierr = ::truncate(file.c_str(),(off_t)need);
-        GRID_ASSERT(ierr==0);
-      }
-    }
-    grid->Barrier();
-    ttrunc.Stop();
-
-    std::vector<RealD> us = { (RealD)tcreate.useconds(), (RealD)tbar.useconds(),
-                              (RealD)topen.useconds(),   (RealD)twrite.useconds(),
-                              (RealD)tclose.useconds(),  (RealD)tskew.useconds(),
-                              (RealD)ttrunc.useconds() };
-    ReportStages(grid,"write",{"create","barrier","open","seek+write","close","skew","stat+truncate"},us);
-  }
-
-  template<class fobj>
-  static inline void AggregateRead(GridBase *grid,AggregationPlan &p,std::vector<fobj> &aggregated,
-                                   std::string file,uint64_t offset)
-  {
-    GridStopWatch topen,tread,tclose;
-    std::ifstream fin;
-    topen.Start();
-    fin.open(file,std::ios::binary|std::ios::in);
-    topen.Stop();
-    tread.Start();
-    for(uint64_t e=0;e<p.extentSites.size();e++){
-      fin.seekg(offset + p.extentGsite[e]*sizeof(fobj));
-      fin.read((char *)&aggregated[p.extentLocal[e]],p.extentSites[e]*sizeof(fobj));
-      GRID_ASSERT(fin.fail()==0);
-    }
-    tread.Stop();
-    tclose.Start();
-    fin.close();
-    tclose.Stop();
-
-    std::vector<RealD> us = { (RealD)topen.useconds(), (RealD)tread.useconds(), (RealD)tclose.useconds() };
-    ReportStages(grid,"read",{"open","seek+read","close"},us);
-  }
-#endif
-
   template<class word,class fobj>
   static inline void IOobject(word w,
 			      GridBase *grid,
@@ -675,27 +293,15 @@ class BinaryIO {
     // Flatten the file
     uint64_t lsites = grid->lSites();
     if ( control & BINARYIO_MASTER_APPEND )  {
-      GRID_ASSERT(iodata.size()==1);
+      assert(iodata.size()==1);
     } else {
-      GRID_ASSERT(lsites==iodata.size());
+      assert(lsites==iodata.size());
     }
     for(int d=0;d<ndim;d++){
       gStart[d] = lLattice[d]*pcoor[d];
       lStart[d] = 0;
     }
 
-    //////////////////////////////////////////////////////////////////////////////
-    // Aggregate the lexicographic layout onto contiguous per rank extents
-    // ourselves rather than leaving it to MPI-IO collective buffering
-    //////////////////////////////////////////////////////////////////////////////
-    int aggregate = (control & BINARYIO_AGGREGATE)
-                 && (control & BINARYIO_LEXICOGRAPHIC)
-                 && !(control & BINARYIO_MASTER_APPEND)
-                 && (nrank > 1);
-#ifndef USE_MPI_IO
-    GRID_ASSERT(aggregate==0); // BINARYIO_AGGREGATE requires MPI
-#endif
-
 #ifdef USE_MPI_IO
     std::vector<int> distribs(ndim,MPI_DISTRIBUTE_BLOCK);
     std::vector<int> dargs   (ndim,MPI_DISTRIBUTE_DFLT_DARG);
@@ -720,23 +326,20 @@ class BinaryIO {
     // Sobj in MPI phrasing
     //////////////////////////////////////////////////////////////////////////////
     int ierr;
-    ierr = MPI_Type_contiguous(numword,mpiword,&mpiObject);    GRID_ASSERT(ierr==0);
+    ierr = MPI_Type_contiguous(numword,mpiword,&mpiObject);    assert(ierr==0);
     ierr = MPI_Type_commit(&mpiObject);
 
-    // The subarray view is what aggregation exists to avoid; do not build it
-    if ( !aggregate ) {
     //////////////////////////////////////////////////////////////////////////////
     // File global array data type
     //////////////////////////////////////////////////////////////////////////////
-    ierr=MPI_Type_create_subarray(ndim,&gLattice[0],&lLattice[0],&gStart[0],MPI_ORDER_FORTRAN, mpiObject,&fileArray);    GRID_ASSERT(ierr==0);
+    ierr=MPI_Type_create_subarray(ndim,&gLattice[0],&lLattice[0],&gStart[0],MPI_ORDER_FORTRAN, mpiObject,&fileArray);    assert(ierr==0);
-    ierr=MPI_Type_commit(&fileArray);    GRID_ASSERT(ierr==0);
+    ierr=MPI_Type_commit(&fileArray);    assert(ierr==0);
 
     //////////////////////////////////////////////////////////////////////////////
     // local lattice array
     //////////////////////////////////////////////////////////////////////////////
-    ierr=MPI_Type_create_subarray(ndim,&lLattice[0],&lLattice[0],&lStart[0],MPI_ORDER_FORTRAN, mpiObject,&localArray);    GRID_ASSERT(ierr==0);
+    ierr=MPI_Type_create_subarray(ndim,&lLattice[0],&lLattice[0],&lStart[0],MPI_ORDER_FORTRAN, mpiObject,&localArray);    assert(ierr==0);
-    ierr=MPI_Type_commit(&localArray);    GRID_ASSERT(ierr==0);
+    ierr=MPI_Type_commit(&localArray);    assert(ierr==0);
-    }
 #endif
 
     //////////////////////////////////////////////////////////////////////////////
@@ -746,8 +349,8 @@ class BinaryIO {
     int ieee32    = (format == std::string("IEEE32"));
     int ieee64big = (format == std::string("IEEE64BIG"));
     int ieee64    = (format == std::string("IEEE64") || format == std::string("IEEE64LITTLE"));
-    GRID_ASSERT(ieee64||ieee32|ieee64big||ieee32big);
+    assert(ieee64||ieee32|ieee64big||ieee32big);
-    GRID_ASSERT((ieee64+ieee32+ieee64big+ieee32big)==1);
+    assert((ieee64+ieee32+ieee64big+ieee32big)==1);
     //////////////////////////////////////////////////////////////////////////////
     // Do the I/O
     //////////////////////////////////////////////////////////////////////////////
@@ -755,24 +358,12 @@ class BinaryIO {
 
       timer.Start();
 
-      if ( aggregate ) {
+      if ( (control & BINARYIO_LEXICOGRAPHIC) && (nrank > 1) ) {
-#ifdef USE_MPI_IO
-        std::cout<< GridLogMessage<<"IOobject: aggregate read I/O "<< file<< std::endl;
-        AggregationPlan plan;
-        BuildAggregationPlan(grid,sizeof(fobj),plan);
-        ReportAggregationPlan(grid,plan,sizeof(fobj),"read");
-        std::vector<fobj> aggregated(lsites);
-        AggregateRead(grid,plan,aggregated,file,offset);
-        AggregateExchange(grid,plan,iodata,aggregated,0);
-#else
-        GRID_ASSERT(0);
-#endif
-      } else if ( (control & BINARYIO_LEXICOGRAPHIC) && (nrank > 1) ) {
 #ifdef USE_MPI_IO
 	std::cout<< GridLogMessage<<"IOobject: MPI read I/O "<< file<< std::endl;
-	ierr=MPI_File_open(grid->communicator,(char *) file.c_str(), MPI_MODE_RDONLY, MPI_INFO_NULL, &fh);    GRID_ASSERT(ierr==0);
+	ierr=MPI_File_open(grid->communicator,(char *) file.c_str(), MPI_MODE_RDONLY, MPI_INFO_NULL, &fh);    assert(ierr==0);
-	ierr=MPI_File_set_view(fh, disp, mpiObject, fileArray, "native", MPI_INFO_NULL);    GRID_ASSERT(ierr==0);
+	ierr=MPI_File_set_view(fh, disp, mpiObject, fileArray, "native", MPI_INFO_NULL);    assert(ierr==0);
-	ierr=MPI_File_read_all(fh, &iodata[0], 1, localArray, &status);    GRID_ASSERT(ierr==0);
+	ierr=MPI_File_read_all(fh, &iodata[0], 1, localArray, &status);    assert(ierr==0);
 	MPI_File_close(&fh);
 	MPI_Type_free(&fileArray);
 	MPI_Type_free(&localArray);
@@ -793,14 +384,13 @@ class BinaryIO {
           fin.seekg(offset + myrank * lsites * sizeof(fobj));
         }
         fin.read((char *)&iodata[0], iodata.size() * sizeof(fobj));
-        GRID_ASSERT(fin.fail() == 0);
+        assert(fin.fail() == 0);
         fin.close();
       }
+      timer.Stop();
 
       grid->Barrier();
 
-	  timer.Stop();
-
       bstimer.Start();
       ScidacChecksum(grid,iodata,scidac_csuma,scidac_csumb);
       if (ieee32big) be32toh_v((void *)&iodata[0], sizeof(fobj)*iodata.size());
@@ -825,25 +415,7 @@ class BinaryIO {
       grid->Barrier();
 
       timer.Start();
-      if ( aggregate ) {
+      if ( (control & BINARYIO_LEXICOGRAPHIC) && (nrank > 1) ) {
-#ifdef USE_MPI_IO
-        std::cout << GridLogMessage <<"IOobject: aggregate write I/O " << file << std::endl;
-        AggregationPlan plan;
-        BuildAggregationPlan(grid,sizeof(fobj),plan);
-        ReportAggregationPlan(grid,plan,sizeof(fobj),"write");
-        std::vector<fobj> aggregated(lsites);
-        AggregateExchange(grid,plan,iodata,aggregated,1);
-        AggregateWrite(grid,plan,aggregated,file,offset);
-        ////////////////////////////////////////////////////////////////////////
-        // Not every rank ends at the end of the payload, so the position can
-        // not be recovered from a file handle. Callers (Lime record chaining)
-        // rely on this being the first byte past the record.
-        ////////////////////////////////////////////////////////////////////////
-        offset = offset + (uint64_t)grid->_gsites*sizeof(fobj);
-#else
-        GRID_ASSERT(0);
-#endif
-      } else if ( (control & BINARYIO_LEXICOGRAPHIC) && (nrank > 1) ) {
 #ifdef USE_MPI_IO
         std::cout << GridLogMessage <<"IOobject: MPI write I/O " << file << std::endl;
         ierr = MPI_File_open(grid->communicator, (char *)file.c_str(), MPI_MODE_RDWR | MPI_MODE_CREATE, MPI_INFO_NULL, &fh);
@@ -863,11 +435,11 @@ class BinaryIO {
 
         std::cout << GridLogDebug << "MPI write I/O set view " << file << std::endl;
         ierr = MPI_File_set_view(fh, disp, mpiObject, fileArray, "native", MPI_INFO_NULL);
-        GRID_ASSERT(ierr == 0);
+        assert(ierr == 0);
 
         std::cout << GridLogDebug << "MPI write I/O write all " << file << std::endl;
         ierr = MPI_File_write_all(fh, &iodata[0], 1, localArray, &status);
-        GRID_ASSERT(ierr == 0);
+        assert(ierr == 0);
 
         MPI_Offset os;
         MPI_File_get_position(fh, &os);
@@ -888,26 +460,12 @@ class BinaryIO {
         
 	std::ofstream fout; 
 	fout.exceptions ( std::fstream::failbit | std::fstream::badbit );
-
-        ////////////////////////////////////////////////////////////////////
-        // Grid's model is that the boss rank performs the metadata
-        // operations and every other rank only seeks and writes into a file
-        // that already exists. Opening with ios::out on all ranks broke that:
-        // it is O_TRUNC, so a rank opening late truncated the file back to
-        // zero after an earlier rank had written its segment, leaving a hole
-        // in its place. The barriers around this block are outside it and do
-        // not order the opens against the writes. Let the boss create and
-        // empty the file, then everyone opens for update only. Same resulting
-        // length, one metadata operation instead of one per rank, no race.
-        ////////////////////////////////////////////////////////////////////
-        if ( !offset && grid->IsBoss() ) { // offset zero: this record starts the file
-          std::ofstream create(file,std::ios::binary|std::ios::out);
-          create.close();
-        }
-        grid->Barrier();
-
 	try {
+	  if (offset) { // Must already exist and contain data
 	    fout.open(file,std::ios::binary|std::ios::out|std::ios::in);
+	  } else {     // Allow create
+	    fout.open(file,std::ios::binary|std::ios::out);
+	  }
 	} catch (const std::fstream::failure& exc) {
 	  std::cout << GridLogError << "Error in opening the file " << file << " for output" <<std::endl;
 	  std::cout << GridLogError << "Exception description: " << exc.what() << std::endl;
@@ -948,7 +506,6 @@ class BinaryIO {
   offset  = fout.tellp();
 	fout.close();
       }
-      grid->Barrier();
       timer.Stop();
     }
     
@@ -989,7 +546,7 @@ class BinaryIO {
 				       uint32_t &nersc_csum,
 				       uint32_t &scidac_csuma,
 				       uint32_t &scidac_csumb,
-				       int control=BINARYIO_LEXICOGRAPHIC|BINARYIO_AGGREGATE
+				       int control=BINARYIO_LEXICOGRAPHIC
 				       )
   {
     typedef typename vobj::scalar_object sobj;
@@ -1028,7 +585,7 @@ class BinaryIO {
 					  uint32_t &nersc_csum,
 					  uint32_t &scidac_csuma,
 					  uint32_t &scidac_csumb,
-					  int control=BINARYIO_LEXICOGRAPHIC|BINARYIO_AGGREGATE)
+					  int control=BINARYIO_LEXICOGRAPHIC)
   {
     typedef typename vobj::scalar_object sobj;
     typedef typename vobj::Realified::scalar_type word;    word w=0;
@@ -1115,7 +672,7 @@ class BinaryIO {
     std::cout << GridLogMessage << "RNG read I/O on file " << file << std::endl;
 
     std::vector<RNGstate> iodata(lsites);
-    IOobject(w,grid,iodata,file,offset,format,BINARYIO_READ|BINARYIO_LEXICOGRAPHIC|BINARYIO_AGGREGATE,
+    IOobject(w,grid,iodata,file,offset,format,BINARYIO_READ|BINARYIO_LEXICOGRAPHIC,
 	     nersc_csum,scidac_csuma,scidac_csumb);
 
     timer.Start();
@@ -1194,7 +751,7 @@ class BinaryIO {
     });
     timer.Stop();
 
-    IOobject(w,grid,iodata,file,offset,format,BINARYIO_WRITE|BINARYIO_LEXICOGRAPHIC|BINARYIO_AGGREGATE,
+    IOobject(w,grid,iodata,file,offset,format,BINARYIO_WRITE|BINARYIO_LEXICOGRAPHIC,
 	     nersc_csum,scidac_csuma,scidac_csumb);
     iodata.resize(1);
     {

Grid/parallelIO/IldgIO.h

@@ -212,7 +212,7 @@ class GridLimeReader : public BinaryIO {
   // Read a generic lattice field and verify checksum
   ////////////////////////////////////////////
   template<class vobj>
-  void readLimeLatticeBinaryObject(Lattice<vobj> &field,std::string record_name,int control=BINARYIO_LEXICOGRAPHIC|BINARYIO_AGGREGATE)
+  void readLimeLatticeBinaryObject(Lattice<vobj> &field,std::string record_name,int control=BINARYIO_LEXICOGRAPHIC)
   {
     typedef typename vobj::scalar_object sobj;
     scidacChecksum scidacChecksum_;
@@ -289,7 +289,7 @@ class GridLimeReader : public BinaryIO {
 	return;
       }      
     }
-    GRID_ASSERT(0);
+    assert(0);
   }
   ////////////////////////////////////////////
   // Read a generic serialisable object
@@ -314,7 +314,7 @@ class GridLimeReader : public BinaryIO {
       }
 
     }  
-    GRID_ASSERT(0);
+    assert(0);
   }
 
   template<class serialisable_object>
@@ -348,7 +348,7 @@ class GridLimeWriter : public BinaryIO
      filename= _filename;
      if ( boss_node ) {
        File = fopen(filename.c_str(), "w");
-       LimeW = limeCreateWriter(File); GRID_ASSERT(LimeW != NULL );
+       LimeW = limeCreateWriter(File); assert(LimeW != NULL );
      }
    }
    /////////////////////////////////////////////
@@ -368,7 +368,7 @@ class GridLimeWriter : public BinaryIO
     if ( boss_node ) {
       LimeRecordHeader *h;
       h = limeCreateHeader(MB, ME, const_cast<char *>(message.c_str()), PayloadSize);
-      GRID_ASSERT(limeWriteRecordHeader(h, LimeW) >= 0);
+      assert(limeWriteRecordHeader(h, LimeW) >= 0);
       limeDestroyHeader(h);
     }
     return LIME_SUCCESS;
@@ -386,11 +386,11 @@ class GridLimeWriter : public BinaryIO
       //    std::cout << " xmlstring "<< nbytes<< " " << xmlstring <<std::endl;
       int err;
       LimeRecordHeader *h = limeCreateHeader(MB, ME,const_cast<char *>(record_name.c_str()), nbytes); 
-      GRID_ASSERT(h!= NULL);
+      assert(h!= NULL);
       
-      err=limeWriteRecordHeader(h, LimeW);                    GRID_ASSERT(err>=0);
+      err=limeWriteRecordHeader(h, LimeW);                    assert(err>=0);
-      err=limeWriteRecordData(&xmlstring[0], &nbytes, LimeW); GRID_ASSERT(err>=0);
+      err=limeWriteRecordData(&xmlstring[0], &nbytes, LimeW); assert(err>=0);
-      err=limeWriterCloseRecord(LimeW);                       GRID_ASSERT(err>=0);
+      err=limeWriterCloseRecord(LimeW);                       assert(err>=0);
       limeDestroyHeader(h);
     }
   }
@@ -414,7 +414,7 @@ class GridLimeWriter : public BinaryIO
   // in communicator used by the field.Grid()
   ////////////////////////////////////////////////////
   template<class vobj>
-  void writeLimeLatticeBinaryObject(Lattice<vobj> &field,std::string record_name,int control=BINARYIO_LEXICOGRAPHIC|BINARYIO_AGGREGATE)
+  void writeLimeLatticeBinaryObject(Lattice<vobj> &field,std::string record_name,int control=BINARYIO_LEXICOGRAPHIC)
   {
     ////////////////////////////////////////////////////////////////////
     // NB: FILE and iostream are jointly writing disjoint sequences in the
@@ -431,7 +431,7 @@ class GridLimeWriter : public BinaryIO
     ////////////////////////////////////////////////////////////////////
     
     GridBase *grid = field.Grid();
-    GRID_ASSERT(boss_node == field.Grid()->IsBoss() );
+    assert(boss_node == field.Grid()->IsBoss() );
 
     FieldNormMetaData FNMD; FNMD.norm2 = norm2(field);
 
@@ -473,7 +473,7 @@ class GridLimeWriter : public BinaryIO
     if ( boss_node ) {
       fseek(File,0,SEEK_END);             
       uint64_t offset2 = ftello(File);     //    std::cout << " now at offset "<<offset2 << std::endl;
-      GRID_ASSERT( (offset2-offset1) == PayloadSize);
+      assert( (offset2-offset1) == PayloadSize);
     }
 
     /////////////////////////////////////////////////////////////
@@ -481,7 +481,7 @@ class GridLimeWriter : public BinaryIO
     /////////////////////////////////////////////////////////////
 
     if ( boss_node ) { 
-      err=limeWriterCloseRecord(LimeW);  GRID_ASSERT(err>=0);
+      err=limeWriterCloseRecord(LimeW);  assert(err>=0);
     }
     ////////////////////////////////////////
     // Write checksum element, propagaing forward from the BinaryIO
@@ -519,7 +519,7 @@ class ScidacWriter : public GridLimeWriter {
   template <class vobj, class userRecord>
   void writeScidacFieldRecord(Lattice<vobj> &field,userRecord _userRecord,
                               const unsigned int recordScientificPrec = 0,
-			      int control=BINARYIO_LEXICOGRAPHIC|BINARYIO_AGGREGATE)
+			      int control=BINARYIO_LEXICOGRAPHIC)
   {
     GridBase * grid = field.Grid();
 
@@ -561,7 +561,7 @@ class ScidacReader : public GridLimeReader {
   ////////////////////////////////////////////////
   template <class vobj, class userRecord>
   void readScidacFieldRecord(Lattice<vobj> &field,userRecord &_userRecord,
-			     int control=BINARYIO_LEXICOGRAPHIC|BINARYIO_AGGREGATE) 
+			     int control=BINARYIO_LEXICOGRAPHIC) 
   {
     typedef typename vobj::scalar_object sobj;
     GridBase * grid = field.Grid();
@@ -621,8 +621,8 @@ class IldgWriter : public ScidacWriter {
     uint64_t PayloadSize = LFN.size();
     int err;
     createLimeRecordHeader(ILDG_DATA_LFN, 0 , 0, PayloadSize);
-    err=limeWriteRecordData(const_cast<char*>(LFN.c_str()), &PayloadSize,LimeW); GRID_ASSERT(err>=0);
+    err=limeWriteRecordData(const_cast<char*>(LFN.c_str()), &PayloadSize,LimeW); assert(err>=0);
-    err=limeWriterCloseRecord(LimeW); GRID_ASSERT(err>=0);
+    err=limeWriterCloseRecord(LimeW); assert(err>=0);
   }
 
   ////////////////////////////////////////////////////////////////
@@ -656,7 +656,7 @@ class IldgWriter : public ScidacWriter {
     header.sequence_number = sequence;
     header.ildg_lfn = LFN;
 
-    GRID_ASSERT ( (format == std::string("IEEE32BIG"))  
+    assert ( (format == std::string("IEEE32BIG"))  
            ||(format == std::string("IEEE64BIG")) );
 
     //////////////////////////////////////////////////////
@@ -676,8 +676,8 @@ class IldgWriter : public ScidacWriter {
     ildgfmt.ly = header.dimension[1];
     ildgfmt.lz = header.dimension[2];
     ildgfmt.lt = header.dimension[3];
-    GRID_ASSERT(header.nd==4);
+    assert(header.nd==4);
-    GRID_ASSERT(header.nd==header.dimension.size());
+    assert(header.nd==header.dimension.size());
 
     //////////////////////////////////////////////////////////////////////////////
     // Field norm tests
@@ -734,7 +734,7 @@ class IldgReader : public GridLimeReader {
 
     Coordinate dims = Umu.Grid()->FullDimensions();
 
-    GRID_ASSERT(dims.size()==4);
+    assert(dims.size()==4);
 
     // Metadata holders
     ildgFormat     ildgFormat_    ;
@@ -793,10 +793,10 @@ class IldgReader : public GridLimeReader {
 	  if ( ildgFormat_.precision == 64 ) format = std::string("IEEE64BIG");
 	  if ( ildgFormat_.precision == 32 ) format = std::string("IEEE32BIG");
 
-	  GRID_ASSERT( ildgFormat_.lx == dims[0]);
+	  assert( ildgFormat_.lx == dims[0]);
-	  GRID_ASSERT( ildgFormat_.ly == dims[1]);
+	  assert( ildgFormat_.ly == dims[1]);
-	  GRID_ASSERT( ildgFormat_.lz == dims[2]);
+	  assert( ildgFormat_.lz == dims[2]);
-	  GRID_ASSERT( ildgFormat_.lt == dims[3]);
+	  assert( ildgFormat_.lt == dims[3]);
 
 	  found_ildgFormat = 1;
 	}
@@ -813,10 +813,10 @@ class IldgReader : public GridLimeReader {
 
 	  format = FieldMetaData_.floating_point;
 
-	  GRID_ASSERT(FieldMetaData_.dimension[0] == dims[0]);
+	  assert(FieldMetaData_.dimension[0] == dims[0]);
-	  GRID_ASSERT(FieldMetaData_.dimension[1] == dims[1]);
+	  assert(FieldMetaData_.dimension[1] == dims[1]);
-	  GRID_ASSERT(FieldMetaData_.dimension[2] == dims[2]);
+	  assert(FieldMetaData_.dimension[2] == dims[2]);
-	  GRID_ASSERT(FieldMetaData_.dimension[3] == dims[3]);
+	  assert(FieldMetaData_.dimension[3] == dims[3]);
 
 	  found_FieldMetaData = 1;
 	}
@@ -866,13 +866,13 @@ class IldgReader : public GridLimeReader {
     // Minimally must find binary segment and checksum
     // Since this is an ILDG reader require ILDG format
     //////////////////////////////////////////////////////
-    GRID_ASSERT(found_ildgLFN);
+    assert(found_ildgLFN);
-    GRID_ASSERT(found_ildgBinary);
+    assert(found_ildgBinary);
-    GRID_ASSERT(found_ildgFormat);
+    assert(found_ildgFormat);
-    GRID_ASSERT(found_scidacChecksum);
+    assert(found_scidacChecksum);
 
     // Must find something with the lattice dimensions
-    GRID_ASSERT(found_FieldMetaData||found_ildgFormat);
+    assert(found_FieldMetaData||found_ildgFormat);
 
     if ( found_FieldMetaData ) {
 
@@ -880,9 +880,9 @@ class IldgReader : public GridLimeReader {
 
     } else { 
 
-      GRID_ASSERT(found_ildgFormat);
+      assert(found_ildgFormat);
       const std::string stNC = std::to_string( Nc ) ;
-      GRID_ASSERT ( ildgFormat_.field == std::string("su"+stNC+"gauge") );
+      assert ( ildgFormat_.field == std::string("su"+stNC+"gauge") );
 
       ///////////////////////////////////////////////////////////////////////////////////////
       // Populate our Grid metadata as best we can
@@ -927,20 +927,20 @@ class IldgReader : public GridLimeReader {
       FieldMetaData_.scidac_checksuma = stoull(scidacChecksum_.suma,0,16);
       FieldMetaData_.scidac_checksumb = stoull(scidacChecksum_.sumb,0,16);
       scidacChecksumVerify(scidacChecksum_,scidac_csuma,scidac_csumb);
-      GRID_ASSERT( scidac_csuma ==FieldMetaData_.scidac_checksuma);
+      assert( scidac_csuma ==FieldMetaData_.scidac_checksuma);
-      GRID_ASSERT( scidac_csumb ==FieldMetaData_.scidac_checksumb);
+      assert( scidac_csumb ==FieldMetaData_.scidac_checksumb);
       std::cout << GridLogMessage<<"SciDAC checksums match " << std::endl;
     } else { 
       std::cout << GridLogWarning<<"SciDAC checksums not found. This is unsafe. " << std::endl;
-      GRID_ASSERT(0); // Can I insist always checksum ?
+      assert(0); // Can I insist always checksum ?
     }
 
     if ( found_FieldMetaData || found_usqcdInfo ) {
       FieldMetaData checker;
       stats Stats;
       Stats(Umu,checker);
-      GRID_ASSERT(fabs(checker.plaquette  - FieldMetaData_.plaquette )<1.0e-5);
+      assert(fabs(checker.plaquette  - FieldMetaData_.plaquette )<1.0e-5);
-      GRID_ASSERT(fabs(checker.link_trace - FieldMetaData_.link_trace)<1.0e-5);
+      assert(fabs(checker.link_trace - FieldMetaData_.link_trace)<1.0e-5);
       std::cout << GridLogMessage<<"Plaquette and link trace match " << std::endl;
     }
   }

Grid/parallelIO/MetaData.h

@@ -203,7 +203,7 @@ template<> inline void PrepareMetaData<vLorentzColourMatrixD>(Lattice<vLorentzCo
 //////////////////////////////////////////////////////////////////////
 inline void reconstruct3(LorentzColourMatrix & cm)
 {
-  GRID_ASSERT( Nc < 4 && Nc > 1 ) ;
+  assert( Nc < 4 && Nc > 1 ) ;
   for(int mu=0;mu<Nd;mu++){
     #if Nc == 2
       cm(mu)()(1,0) = -adj(cm(mu)()(0,y)) ;
@@ -240,7 +240,7 @@ struct BinarySimpleUnmunger {
     sobj_stype *in_buffer = (sobj_stype *)&in;
     size_t fobj_words = sizeof(out) / sizeof(fobj_stype);
     size_t sobj_words = sizeof(in) / sizeof(sobj_stype);
-    GRID_ASSERT(fobj_words == sobj_words);
+    assert(fobj_words == sobj_words);
     
     for (unsigned int word = 0; word < sobj_words; word++)
       out_buffer[word] = in_buffer[word];  // type conversion on the fly
@@ -259,7 +259,7 @@ struct BinarySimpleMunger {
     sobj_stype *out_buffer = (sobj_stype *)&out;
     size_t fobj_words = sizeof(in) / sizeof(fobj_stype);
     size_t sobj_words = sizeof(out) / sizeof(sobj_stype);
-    GRID_ASSERT(fobj_words == sobj_words);
+    assert(fobj_words == sobj_words);
     
     for (unsigned int word = 0; word < sobj_words; word++)
       out_buffer[word] = in_buffer[word];  // type conversion on the fly

Grid/parallelIO/NerscIO.h

@@ -76,7 +76,7 @@ public:
     removeWhitespace(line);
     std::cout << GridLogMessage << "* " << line << std::endl;
 
-    GRID_ASSERT(line==std::string("BEGIN_HEADER"));
+    assert(line==std::string("BEGIN_HEADER"));
 
     do {
       getline(fin,line); // read one line
@@ -106,9 +106,9 @@ public:
     field.dimension[2] = std::stol(header["DIMENSION_3"]);
     field.dimension[3] = std::stol(header["DIMENSION_4"]);
 
-    GRID_ASSERT(grid->_ndimension == 4);
+    assert(grid->_ndimension == 4);
     for(int d=0;d<4;d++){
-      GRID_ASSERT(grid->_fdimensions[d]==field.dimension[d]);
+      assert(grid->_fdimensions[d]==field.dimension[d]);
     }
 
     field.link_trace = std::stod(header["LINK_TRACE"]);
@@ -183,7 +183,7 @@ public:
 	   nersc_csum,scidac_csuma,scidac_csumb);
       }
     } else {
-      GRID_ASSERT(0);
+      assert(0);
     }
 
     GaugeStats Stats; Stats(Umu,clone);
@@ -205,9 +205,9 @@ public:
       std::cerr << " nersc_csum  " <<std::hex<< nersc_csum << " " << header.checksum<< std::dec<< std::endl;
       exit(0);
     }
-    if(exitOnReadPlaquetteMismatch()) GRID_ASSERT(fabs(clone.plaquette -header.plaquette ) < 1.0e-5 );
+    if(exitOnReadPlaquetteMismatch()) assert(fabs(clone.plaquette -header.plaquette ) < 1.0e-5 );
-    GRID_ASSERT(fabs(clone.link_trace-header.link_trace) < 1.0e-6 );
+    assert(fabs(clone.link_trace-header.link_trace) < 1.0e-6 );
-    GRID_ASSERT(nersc_csum == header.checksum );
+    assert(nersc_csum == header.checksum );
       
     std::cout<<GridLogMessage <<"NERSC Configuration "<<file<< " and plaquette, link trace, and checksum agree"<<std::endl;
   }
@@ -246,7 +246,7 @@ public:
     GridBase *grid = Umu.Grid();
 
     GridMetaData(grid,header);
-    GRID_ASSERT(header.nd==4);
+    assert(header.nd==4);
     GaugeStats Stats; Stats(Umu,header);
     MachineCharacteristics(header);
 
@@ -302,7 +302,7 @@ public:
     GridBase *grid = parallel.Grid();
 
     GridMetaData(grid,header);
-    GRID_ASSERT(header.nd==4);
+    assert(header.nd==4);
     header.link_trace=0.0;
     header.plaquette=0.0;
     MachineCharacteristics(header);
@@ -355,16 +355,16 @@ public:
     std::string data_type(header.data_type);
 
 #ifdef RNG_RANLUX
-    GRID_ASSERT(format == std::string("UINT64"));
+    assert(format == std::string("UINT64"));
-    GRID_ASSERT(data_type == std::string("RANLUX48"));
+    assert(data_type == std::string("RANLUX48"));
 #endif
 #ifdef RNG_MT19937
-    GRID_ASSERT(format == std::string("UINT32"));
+    assert(format == std::string("UINT32"));
-    GRID_ASSERT(data_type == std::string("MT19937"));
+    assert(data_type == std::string("MT19937"));
 #endif
 #ifdef RNG_SITMO
-    GRID_ASSERT(format == std::string("UINT64"));
+    assert(format == std::string("UINT64"));
-    GRID_ASSERT(data_type == std::string("SITMO"));
+    assert(data_type == std::string("SITMO"));
 #endif
 
     // depending on datatype, set up munger;
@@ -376,7 +376,7 @@ public:
       std::cerr << "checksum mismatch "<<std::hex<< nersc_csum <<" "<<header.checksum<<std::dec<<std::endl;
       exit(0);
     }
-    GRID_ASSERT(nersc_csum == header.checksum );
+    assert(nersc_csum == header.checksum );
 
     std::cout<<GridLogMessage <<"Read NERSC RNG file "<<file<< " format "<< data_type <<std::endl;
   }

Grid/parallelIO/OpenQcdIO.h

@@ -49,7 +49,7 @@ public:
     {
       std::ifstream fin(file, std::ios::in | std::ios::binary);
       fin.read(reinterpret_cast<char*>(&header), sizeof(OpenQcdHeader));
-      GRID_ASSERT(!fin.fail());
+      assert(!fin.fail());
       field.data_start = fin.tellg();
       fin.close();
     }
@@ -57,10 +57,10 @@ public:
     header.plaq /= normalisationFactor;
 
     // sanity check (should trigger on endian issues)
-    GRID_ASSERT(0 < header.Nt && header.Nt <= 1024);
+    assert(0 < header.Nt && header.Nt <= 1024);
-    GRID_ASSERT(0 < header.Nx && header.Nx <= 1024);
+    assert(0 < header.Nx && header.Nx <= 1024);
-    GRID_ASSERT(0 < header.Ny && header.Ny <= 1024);
+    assert(0 < header.Ny && header.Ny <= 1024);
-    GRID_ASSERT(0 < header.Nz && header.Nz <= 1024);
+    assert(0 < header.Nz && header.Nz <= 1024);
 
     field.dimension[0] = header.Nx;
     field.dimension[1] = header.Ny;
@@ -71,9 +71,9 @@ public:
     std::cout << GridLogDebug << "grid dimensions: " << grid->_fdimensions << std::endl;
     std::cout << GridLogDebug << "file dimensions: " << field.dimension << std::endl;
 
-    GRID_ASSERT(grid->_ndimension == Nd);
+    assert(grid->_ndimension == Nd);
     for(int d = 0; d < Nd; d++)
-      GRID_ASSERT(grid->_fdimensions[d] == field.dimension[d]);
+      assert(grid->_fdimensions[d] == field.dimension[d]);
 
     field.plaquette = header.plaq;
 
@@ -86,10 +86,10 @@ public:
                                        std::string                           file) {
     typedef Lattice<iDoubleStoredColourMatrix<vsimd>> DoubleStoredGaugeField;
 
-    GRID_ASSERT(Ns == 4 and Nd == 4 and Nc == 3);
+    assert(Ns == 4 and Nd == 4 and Nc == 3);
 
     auto grid = dynamic_cast<GridCartesian*>(Umu.Grid());
-    GRID_ASSERT(grid != nullptr); GRID_ASSERT(grid->_ndimension == Nd);
+    assert(grid != nullptr); assert(grid->_ndimension == Nd);
 
     uint64_t offset = readHeader(file, Umu.Grid(), header);
 
@@ -171,7 +171,7 @@ public:
 
     if(plaq_diff >= tol)
       std::cout << " Plaquette mismatch (diff = " << plaq_diff << ", tol = " << tol << ")" << std::endl;
-    GRID_ASSERT(plaq_diff < tol);
+    assert(plaq_diff < tol);
 
     std::cout << GridLogMessage << "OpenQcd Configuration " << file << " and plaquette agree" << std::endl;
   }

Grid/parallelIO/OpenQcdIOChromaReference.h

@@ -62,7 +62,7 @@ public:
     : swap(false)
     , grid(gridPtr) {
     err = MPI_File_open(comm, const_cast<char*>(filename.c_str()), MPI_MODE_RDONLY, MPI_INFO_NULL, &fp);
-    GRID_ASSERT(err == MPI_SUCCESS);
+    assert(err == MPI_SUCCESS);
   }
 
   virtual ~ParRdr() { MPI_File_close(&fp); }
@@ -76,8 +76,8 @@ public:
   }
 
   int readHeader(FieldMetaData& field) {
-    GRID_ASSERT((grid->_ndimension == Nd) && (Nd == 4));
+    assert((grid->_ndimension == Nd) && (Nd == 4));
-    GRID_ASSERT(Nc == 3);
+    assert(Nc == 3);
 
     OpenQcdHeader header;
 
@@ -86,10 +86,10 @@ public:
     header.plaq /= 3.; // TODO change this into normalizationfactor
 
     // sanity check (should trigger on endian issues) TODO remove?
-    GRID_ASSERT(0 < header.Nt && header.Nt <= 1024);
+    assert(0 < header.Nt && header.Nt <= 1024);
-    GRID_ASSERT(0 < header.Nx && header.Nx <= 1024);
+    assert(0 < header.Nx && header.Nx <= 1024);
-    GRID_ASSERT(0 < header.Ny && header.Ny <= 1024);
+    assert(0 < header.Ny && header.Ny <= 1024);
-    GRID_ASSERT(0 < header.Nz && header.Nz <= 1024);
+    assert(0 < header.Nz && header.Nz <= 1024);
 
     field.dimension[0] = header.Nx;
     field.dimension[1] = header.Ny;
@@ -97,7 +97,7 @@ public:
     field.dimension[3] = header.Nt;
 
     for(int d = 0; d < Nd; d++)
-      GRID_ASSERT(grid->FullDimensions()[d] == field.dimension[d]);
+      assert(grid->FullDimensions()[d] == field.dimension[d]);
 
     field.plaquette = header.plaq;
 
@@ -114,15 +114,15 @@ public:
     int read = -1;
     MPI_Get_count(&status, datatype, &read);
     // CHECK_VAR(read)
-    GRID_ASSERT(nbytes == (uint64_t)read);
+    assert(nbytes == (uint64_t)read);
-    GRID_ASSERT(err == MPI_SUCCESS);
+    assert(err == MPI_SUCCESS);
   }
 
   void createTypes() {
     constexpr int elem_size = Nd * 2 * 2 * Nc * Nc * sizeof(double); // 2_complex 2_fwdbwd
 
-    err = MPI_Type_contiguous(elem_size, MPI_BYTE, &oddSiteType); GRID_ASSERT(err == MPI_SUCCESS);
+    err = MPI_Type_contiguous(elem_size, MPI_BYTE, &oddSiteType); assert(err == MPI_SUCCESS);
-    err = MPI_Type_commit(&oddSiteType); GRID_ASSERT(err == MPI_SUCCESS);
+    err = MPI_Type_commit(&oddSiteType); assert(err == MPI_SUCCESS);
 
     Coordinate const L = grid->GlobalDimensions();
     Coordinate const l = grid->LocalDimensions();
@@ -132,20 +132,20 @@ public:
     Coordinate subsizes({l[2] / 2, l[1], l[0], l[3]});
     Coordinate starts({i[2] * l[2] / 2, i[1] * l[1], i[0] * l[0], i[3] * l[3]});
 
-    err = MPI_Type_create_subarray(grid->_ndimension, &sizes[0], &subsizes[0], &starts[0], MPI_ORDER_FORTRAN, oddSiteType, &fileViewType); GRID_ASSERT(err == MPI_SUCCESS);
+    err = MPI_Type_create_subarray(grid->_ndimension, &sizes[0], &subsizes[0], &starts[0], MPI_ORDER_FORTRAN, oddSiteType, &fileViewType); assert(err == MPI_SUCCESS);
-    err = MPI_Type_commit(&fileViewType); GRID_ASSERT(err == MPI_SUCCESS);
+    err = MPI_Type_commit(&fileViewType); assert(err == MPI_SUCCESS);
   }
 
   void freeTypes() {
-    err = MPI_Type_free(&fileViewType); GRID_ASSERT(err == MPI_SUCCESS);
+    err = MPI_Type_free(&fileViewType); assert(err == MPI_SUCCESS);
-    err = MPI_Type_free(&oddSiteType); GRID_ASSERT(err == MPI_SUCCESS);
+    err = MPI_Type_free(&oddSiteType); assert(err == MPI_SUCCESS);
   }
 
   bool readGauge(std::vector<ColourMatrixD>& domain_buff, FieldMetaData& meta) {
     auto hdr_offset = readHeader(meta);
     CHECK
     createTypes();
-    err = MPI_File_set_view(fp, hdr_offset, oddSiteType, fileViewType, "native", MPI_INFO_NULL); errInfo(err, "MPI_File_set_view0"); GRID_ASSERT(err == MPI_SUCCESS);
+    err = MPI_File_set_view(fp, hdr_offset, oddSiteType, fileViewType, "native", MPI_INFO_NULL); errInfo(err, "MPI_File_set_view0"); assert(err == MPI_SUCCESS);
     CHECK
     int const domainSites = grid->lSites();
     domain_buff.resize(Nd * domainSites); // 2_fwdbwd * 4_Nd * domainSites / 2_onlyodd
@@ -166,7 +166,7 @@ public:
     CHECK
     err = MPI_File_set_view(fp, 0, MPI_BYTE, MPI_BYTE, "native", MPI_INFO_NULL);
   errInfo(err, "MPI_File_set_view1");
-    GRID_ASSERT(err == MPI_SUCCESS);
+    assert(err == MPI_SUCCESS);
     freeTypes();
 
     std::cout << GridLogMessage << "read sum: " << n_os * os_size << " bytes" << std::endl;
@@ -182,7 +182,7 @@ public:
                                        std::string                           file) {
     typedef Lattice<iDoubleStoredColourMatrix<vsimd>> DoubledGaugeField;
 
-    GRID_ASSERT(Ns == 4 and Nd == 4 and Nc == 3);
+    assert(Ns == 4 and Nd == 4 and Nc == 3);
 
     auto grid = Umu.Grid();
 
@@ -225,7 +225,7 @@ public:
 
     if(plaq_diff >= tol)
       std::cout << " Plaquette mismatch (diff = " << plaq_diff << ", tol = " << tol << ")" << std::endl;
-    GRID_ASSERT(plaq_diff < tol);
+    assert(plaq_diff < tol);
 
     std::cout << GridLogMessage << "OpenQcd Configuration " << file << " and plaquette agree" << std::endl;
   }
@@ -246,7 +246,7 @@ private:
   static inline void copyToLatticeObject(std::vector<DoubleStoredColourMatrix>& u_fb,
                                          std::vector<ColourMatrixD> const&      node_buff,
                                          GridBase*                              grid) {
-    GRID_ASSERT(node_buff.size() == Nd * grid->lSites());
+    assert(node_buff.size() == Nd * grid->lSites());
 
     Coordinate const& l = grid->LocalDimensions();
 
@@ -274,7 +274,7 @@ private:
             buff_idx += 2 * Nd;
           }
 
-    GRID_ASSERT(node_buff.size() == buff_idx);
+    assert(node_buff.size() == buff_idx);
   }
 };