diff --git a/.gitignore b/.gitignore
index bbe5206..6d1b0db 100644
--- a/.gitignore
+++ b/.gitignore
@@ -54,3 +54,5 @@ full-stats-*.txt
 stats-*.pkl
 summary-stats-*.pkl
 .hypothesis/*
+
+devel/*.yaml
diff --git a/devel/viscalc-performance/getperf.py b/devel/viscalc-performance/getperf.py
new file mode 100644
index 0000000..444b4ad
--- /dev/null
+++ b/devel/viscalc-performance/getperf.py
@@ -0,0 +1,361 @@
+"""Script to get the performance metric of a particular solver."""
+from __future__ import annotations
+
+import click
+import importlib
+import numpy as np
+import time
+import yaml
+from dataclasses import asdict, dataclass
+from methods._lib import RedundantSolver, Solver
+from pathlib import Path
+import json
+
+@dataclass
+class TimeResult:
+    times: list[float]
+    n: int
+
+    @property
+    def best(self):
+        return np.min(self.times)
+
+    @property
+    def mean(self):
+        return np.mean(self.times)
+
+    @property
+    def repeats(self):
+        return len(self.times)
+
+    @property
+    def std(self):
+        return np.std(self.times)
+
+
+def get_timing(sln, repeats: int = 3) -> float:
+    sln.setup()
+
+    t0 = time.time()
+    sln.compute()
+    t1 = time.time() - t0
+
+    times = []
+
+    if t1 > 2:  # assume overhead from compilation etc. is negligible compared to 5sec
+        times.append(t1)
+        n = 1
+
+    if repeats > len(times):
+        # Need to do it at least twice to check if the time comes down.
+
+        if t1 < 2:
+            t0 = time.time()
+            sln.compute()
+            t2 = time.time() - t0
+
+            n = int(2 / t2) + 1
+
+            if t2 > 2:
+                times.append(t2)
+
+        if n == 1:
+            for _ in range(max(0, repeats - len(times))):
+                t0 = time.time()
+                sln.compute()
+                times.append(time.time() - t0)
+
+        else:
+            for _ in range(repeats):
+                t0 = time.time()
+                for _ in range(n):
+                    sln.compute()
+                times.append((time.time() - t0) / n)
+
+    return TimeResult(times, n)
+
+
+def test_solver(solver, nants, nsrcs, ctype=complex, **opts):
+    z0 = getz((nants, nsrcs), ctype)
+    solver.test(z0, np.dot(z0, z0.T.conj()), **opts)
+
+
+def get_timings(
+    solver,
+    nants,
+    nsides,
+    nsrcs,
+    repeats: int = 3,
+    rerun: bool = False,
+    cache=Path("."),
+    ctype=complex,
+    nants_redundant: int | None = None,
+    pairs: dict | None = None,
+    transpose: bool = False,
+) -> dict[tuple[int, int], float]:
+    out = {}
+    cache = Path(cache)
+
+    # First, test the solver.
+    test_solver(solver, nants[0], nsrcs[0], ctype)
+
+    # Get the outer iterator.
+    outer = pairs.items() if solver.is_redundant else nants
+
+    for outer_thing in outer:
+        if solver.is_redundant:
+            label_outer = outer_thing[0]  # pairfrac
+            use_nants = nants_redundant
+        else:
+            label_outer = outer_thing  # nant
+            use_nants = outer_thing
+
+        for nside, nsrc in zip(nsides, nsrcs):
+            size = (use_nants, nsrc)
+            z = getz(size, ctype, transpose=transpose)
+
+            print((label_outer, nside), end=": ")
+            prec = "double" if ctype is complex else "single"
+            trns = "col" if transpose else "row"
+            pth = cache / f"{solver.__name__}_{label_outer}x{nside}_{prec}_{trns}.yaml"
+            if not rerun and pth.exists():
+                with open(pth) as fl:
+                    o = out[(label_outer, nside)] = TimeResult(**yaml.safe_load(fl))
+            else:
+                sln = solver(z, outer_thing[1]) if solver.is_redundant else solver(z)
+
+                o = out[(label_outer, nside)] = get_timing(sln, repeats=repeats)
+                del sln  # Ensure memory is freed.
+
+            print(f"{o.mean:1.3e}s ± {o.std:1.3e}s [{o.repeats} loops of {o.n}]")
+
+            # Cache it
+            with open(pth, "w") as fl:
+                yaml.dump(asdict(o), fl)
+
+    return out
+
+
+def getz(shape, ctype, transpose=False):
+    if transpose:
+        return (
+            np.random.random(shape[::-1]) + np.random.random(shape[::-1]) * 1j
+        ).astype(ctype)
+    else:
+        return (np.random.random(shape) + np.random.random(shape) * 1j).astype(ctype)
+
+
+def get_sizes(
+    max_nants: int,
+    max_nside: int,
+    n_nants: int,
+    n_nsides: int,
+):
+    # Note that "nants" here represents Nants * Nfeed, which is why we
+    # go to double the number of ants that HERA has.
+    nants = sorted([max_nants * 2 // 2**i for i in range(n_nants)])
+    nsides = sorted(max_nside // 2**i for i in range(n_nsides))
+    nsrcs = [2 * 12 * nside**2 for nside in nsides]
+
+    return nants, nsides, nsrcs
+
+
+def get_solver(solver):
+    mdl = importlib.import_module(f"methods.{solver}")
+
+    for k, v in mdl.__dict__.items():
+        if (
+            np.issubclass_(v, (Solver, RedundantSolver))
+            and v is not Solver
+            and v is not RedundantSolver
+            and not k.startswith("_")
+        ):
+            solver = v
+            break
+    else:
+        raise ValueError(f"Cannot find a solver in '{solver}'")
+
+    return solver
+
+
+cli = click.Group()
+
+
+@cli.command()
+@click.argument("solver", type=str, required=True)
+@click.option("--max-nants", type=int, default=350)
+@click.option("--n-nants", type=int, default=4)
+@click.option("--max-nside", type=int, default=256)
+@click.option("--n-nsides", type=int, default=4)
+@click.option("--double/--single", default=True)
+@click.option("--repeats", type=int, default=3)
+@click.option("--rerun/--use-cache", default=False)
+@click.option("--transpose/--no-transpose", default=False)
+@click.option(
+    "--cache", type=click.Path(exists=True, file_okay=False), default=Path(".")
+)
+def profile(
+    solver,
+    max_nants: int,
+    n_nants: int,
+    max_nside: int,
+    n_nsides: int,
+    double: bool,
+    repeats: int,
+    rerun: bool,
+    cache,
+    transpose: bool,
+):
+    """Get the performance metric of a particular solver."""
+
+    nants, nsides, nsrcs = get_sizes(
+        max_nants=max_nants, max_nside=max_nside, n_nants=n_nants, n_nsides=n_nsides
+    )
+
+    # Note that "nants" here represents Nants * Nfeed, which is why we
+    # go to double the number of ants that HERA has.
+    nants = sorted([max_nants * 2 // 2**i for i in range(n_nants)])
+    nsides = sorted(max_nside // 2**i for i in range(n_nsides))
+    nsrcs = [2 * 12 * nside**2 for nside in nsides]
+
+    redundant_nants = nants[-1] // 2
+
+    solver = get_solver(solver)
+
+    if solver.is_redundant:
+        allpairs = np.array(
+            [(0, 0)]
+            + [
+                (a, b)
+                for a in range(redundant_nants * 2)
+                for b in range(a + 1, redundant_nants * 2)
+            ]
+        )
+
+        pairs = {}
+        pairfracs = [3, 10, 25, 50, 100]
+
+        for pc in pairfracs:
+            pairs[pc] = allpairs[
+                np.sort(
+                    np.random.choice(
+                        np.arange(len(allpairs)),
+                        size=int(len(allpairs) * pc / 100),
+                        replace=False,
+                    )
+                )
+            ]
+    else:
+        pairs = None
+
+    get_timings(
+        solver,
+        nants=nants,
+        nsides=nsides,
+        nsrcs=nsrcs,
+        repeats=repeats,
+        rerun=rerun,
+        cache=cache,
+        ctype=complex if double else np.complex64,
+        nants_redundant=redundant_nants * 2,
+        pairs=pairs,
+        transpose=transpose,
+    )
+
+
+def get_redundancies(bls, ndecimals: int = 2):
+    uvbins = set()
+    pairs = []
+
+    # Everything here is in wavelengths
+    bls = np.round(bls, decimals=ndecimals)
+    nant = bls.shape[0]
+
+    # group redundant baselines
+    for i in range(nant):
+        for j in range(i + 1, nant):
+            u, v = bls[i, j]
+            if (u, v) not in uvbins and (-u, -v) not in uvbins:
+                uvbins.add((u, v))
+                pairs.append([i, j])
+
+    return pairs
+
+def make_polpairs(pairs, feed_moves_first: bool = False):
+    if feed_moves_first:
+        p = pairs * 2
+        p1 = p.copy()
+        p2 = p.copy(); p2[:, 0] += 1
+        p3 = p.copy(); p3[:, 1] += 1
+        p4 = p.copy(); p4 += 1
+        return np.array([p1,p2,p3,p4]).transpose((1, 0, 2)).reshape((-1, 2))
+    else:
+        nmax = pairs.max() + 1
+        p1 = pairs.copy()
+        p2 = pairs.copy(); p2[:, 0] += nmax
+        p3 = pairs.copy(); p3[:, 1] += nmax
+        p4 = pairs.copy(); p4 += nmax
+        return np.concatenate([p1,p2,p3,p4])
+
+def get_hera_pairs(hex_num: int, outriggers: bool=False, feed_moves_first: bool = True):
+    from py21cmsense.antpos import hera
+
+    cachename = Path("hera-pair-cache") / f'hex{hex_num}_outriggers{outriggers}_feedfirst{feed_moves_first}'
+    if cachename.exists():
+        d = np.load(cachename)
+        return d['antpos'], d['pairs']
+
+    antpos = hera(hex_num=hex_num, split_core=True, outriggers=2 if outriggers else 0)
+    bls = antpos[np.newaxis, :, :2] - antpos[:, np.newaxis, :2]
+    pairs = np.array(get_redundancies(bls.value))
+    pairs = make_polpairs(pairs, feed_moves_first=feed_moves_first)
+
+    np.savez(cachename, antpos=antpos, pairs=pairs)
+    return antpos, pairs
+
+@cli.command()
+@click.argument("solver", type=str, required=True)
+@click.option("--double/--single", default=True)
+@click.option("--transpose/--no-transpose", default=False)
+@click.option("--outriggers/--core", default=False)
+@click.option("--nside", type=int, default=256)
+@click.option("--feed-moves-first/--ant-moves-first", default=True)
+@click.option("--solver-opts",  type=str, default="{}", help="JSON-parsable options for the solver")
+@click.option(
+    "--cache", type=click.Path(exists=True, file_okay=False), default=Path(".")
+)
+@click.option("--hex-num", default=11, type=int, help="Size of side of HERA hex")
+def hera_profile(solver, double, transpose, outriggers, nside, feed_moves_first, solver_opts, cache, hex_num):
+    antpos, pairs = get_hera_pairs(hex_num, outriggers, feed_moves_first)
+
+    solver_opts = json.loads(solver_opts)
+    solver = get_solver(solver)
+
+    ctype = complex if double else np.complex64
+    #test_solver(solver, 50, 1000, ctype, **solver_opts)
+
+    nant = len(antpos)
+    nsrc = 12 * nside**2
+
+    # now run the actual computation
+    z = getz((2 * nant, 2 * nsrc), transpose=transpose, ctype=ctype)
+
+    if solver.is_redundant:
+        sln = solver(z, pairs=pairs, **solver_opts)
+    else:
+        sln = solver(z, **solver_opts)
+
+    res = get_timing(sln, repeats=3)
+
+    optstr = "_".join(f"{k.replace('_', '')}-{v}" for k, v in solver_opts.items())
+    # Cache it
+    dstr = 'd' if double else 's'
+    tstr = 't' if transpose else 'n'
+    ostr = 'o' if outriggers else 'c'
+    fstr = 'f' if feed_moves_first else 'a'
+    pth = Path(cache) / f"{solver.__name__}_{nside}_ants{len(antpos)}_{dstr}{tstr}{ostr}{fstr}_{optstr}.yaml"
+    with open(pth, "w") as fl:
+        yaml.dump(asdict(res), fl)
+
+if __name__ == "__main__":
+    cli()
diff --git a/devel/viscalc-performance/methods/__init__.py b/devel/viscalc-performance/methods/__init__.py
new file mode 100644
index 0000000..1e573a8
--- /dev/null
+++ b/devel/viscalc-performance/methods/__init__.py
@@ -0,0 +1,13 @@
+# from .arrayfire_gemm import ArrayFireGemm
+from .cublas_chunkedloop import CuBLASChunkedLoop
+from .cublas_vectorloop import CuBLASVectorLoop
+from .cublas_zgemm import CuBLASZgemm
+from .cublas_zherk import CuBLASZherk
+
+# from .jax_chunkedloop import JAXChunkedLoop
+# from .jax_dot import JAXDot
+# from .jax_vectorloop import JAXVectorLoop
+from .np_dot import NpDot
+from .np_zgemm import NpZgemm
+from .np_zherk import NpZherk
+from .numba_vectorloop import SingleLoopNumba
diff --git a/devel/viscalc-performance/methods/_cp.py b/devel/viscalc-performance/methods/_cp.py
new file mode 100644
index 0000000..54c8d6a
--- /dev/null
+++ b/devel/viscalc-performance/methods/_cp.py
@@ -0,0 +1,44 @@
+import cupy as cp
+from ._lib import Solver, RedundantSolver
+
+
+from skcuda.cublas import (
+    cublasCgemm,
+    cublasCgemv,
+    cublasCherk,
+    cublasZgemm,
+    cublasZgemv,
+    cublasZherk,
+    cublasCreate,
+)
+
+
+class _CuPyCommon:
+    def create(self):
+        self.h = cublasCreate()
+        if self._z.dtype.name == "complex128":
+            self.gemm = cublasZgemm
+            self.herk = cublasZherk
+            self.gemv = cublasZgemv
+        else:
+            self.gemm = cublasCgemm
+            self.herk = cublasCherk
+            self.gemv = cublasCgemv
+
+class _CuPy(_CuPyCommon, Solver):
+    def setup(self):
+        super().setup()
+        if self.transposed:
+            nant = self.z.shape[1]
+        else:
+            nant = self.z.shape[0]
+        self.out = cp.empty(shape=(nant, nant), dtype=self._z.dtype)
+        self.z = cp.asarray(self._z)
+        
+
+class _CuPyRed(_CuPyCommon, RedundantSolver):
+    def setup(self):
+        super().setup()
+        self.out = cp.empty(self.pairs.shape[0], dtype=self._z.dtype)
+        self.z = cp.asarray(self._z)
+        
\ No newline at end of file
diff --git a/devel/viscalc-performance/methods/_cublas.py b/devel/viscalc-performance/methods/_cublas.py
new file mode 100644
index 0000000..9ac6620
--- /dev/null
+++ b/devel/viscalc-performance/methods/_cublas.py
@@ -0,0 +1,209 @@
+import ctypes
+import numpy as np
+import os
+import warnings
+from functools import cache
+from jinja2 import Template
+
+from ._lib import RedundantSolver, Solver
+
+try:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+
+        from pycuda import autoinit
+        from pycuda import compiler
+        from pycuda import cumath as cm
+        from pycuda import driver, gpuarray
+        from skcuda.cublas import (
+            _libcublas,
+            cublasCgemm,
+            cublasCgemv,
+            cublasCherk,
+            cublasCreate,
+            cublasDestroy,
+            cublasZgemm,
+            cublasZgemv,
+            cublasZherk,
+            cuda,
+        )
+
+    HAVE_PYCUDA = True
+except Exception:
+    HAVE_PYCUDA = False
+
+
+def cublasZdotc_inplace(handle, n, x, incx, y, incy, result):
+    """In-place Zdotc that doesn't transfer data to the host."""
+    _libcublas.cublasZdotc_v2(handle, n, int(x), incx, int(y), incy, int(result))
+
+
+def cublasCdotc_inplace(handle, n, x, incx, y, incy, result):
+    """In-place Cdotc that doesn't transfer data to the host."""
+    _libcublas.cublasCdotc_v2(handle, n, int(x), incx, int(y), incy, int(result))
+
+
+class _CuBLASCommon:
+    def create(self):
+        self.h = cublasCreate()
+
+        if self._z.dtype.name == "complex128":
+            self.gemm = cublasZgemm
+            self.herk = cublasZherk
+            self.dotc = cublasZdotc_inplace
+            self.gemv = cublasZgemv
+        else:
+            self.gemm = cublasCgemm
+            self.herk = cublasCherk
+            self.dotc = cublasCdotc_inplace
+            self.gemv = cublasCgemv
+
+
+class _CuBLAS(_CuBLASCommon, Solver):
+    def setup(self):
+        self.create()
+        if self.transposed:
+            nant = self._z.shape[1]
+        else:
+            nant = self._z.shape[0]
+        self.z = gpuarray.to_gpu(self._z)
+
+        self.out = gpuarray.empty(shape=(nant, nant), dtype=self._z.dtype)
+
+
+class _CuBLASRed(_CuBLASCommon, RedundantSolver):
+    def setup(self):
+        self.create()
+        self.out = gpuarray.empty(self.pairs.shape[0], dtype=self._z.dtype)
+        self.z = gpuarray.to_gpu(self._z)
+
+
+
+take_along_axis_kernel_code = r"""
+// CUDA code for copying values from a 2D array into another 2D array along an axis.
+
+#include <cuComplex.h>
+#include <pycuda-helpers.hpp>
+#include <stdio.h>
+
+__global__ void TakeAlongFirstAxis2D(
+    {{ TYPE }} *in_matrix,
+    int m,
+    int n,
+    int *indices,
+    int k,
+    {{ TYPE }} *out_matrix
+){
+    const uint i    = blockIdx.x * blockDim.x + threadIdx.x;
+    const uint j    = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const uint outel = j*n + i;
+
+    // exit if we're out of scope
+    if (j >= k || i >= n) return;
+
+    int idx = indices[j];
+    out_matrix[outel] = in_matrix[idx*n+i];
+}
+
+
+__global__ void TakeAlongSecondAxis2D(
+    {{ TYPE }} *in_matrix,
+    int m,
+    int n,
+    int *indices,
+    int k,
+    {{ TYPE }} *out_matrix
+){
+    const uint i    = blockIdx.x * blockDim.x + threadIdx.x;
+    const uint j    = blockIdx.y * blockDim.y + threadIdx.y;
+
+
+    // exit if we're out of scope
+    if (i >= k || j >= m) return;
+
+    int idx = indices[i];
+    const uint outel = j*k + i;
+
+    out_matrix[j*k+i] = in_matrix[j*n+idx];
+}
+"""
+
+if HAVE_PYCUDA:
+
+    def sync():
+        autoinit.context.synchronize()
+
+    def _compile_take(dtype):
+        take_along_axis_template = Template(take_along_axis_kernel_code)
+        take_along_axis_code = take_along_axis_template.render(TYPE=dtype)
+        return (
+            compiler.SourceModule(take_along_axis_code).get_function(
+                "TakeAlongFirstAxis2D"
+            ),
+            compiler.SourceModule(take_along_axis_code).get_function(
+                "TakeAlongSecondAxis2D"
+            ),
+        )
+
+    take_along_first_axis_z, take_along_second_axis_z = _compile_take("cuDoubleComplex")
+    take_along_first_axis_c, take_along_second_axis_c = _compile_take("cuFloatComplex")
+
+    @cache
+    def _cudatake_blocksize(m: int, n: int, k: int, axis=0):
+        nthreads_max = 1024
+        if axis == 0:
+            threadsx = min(nthreads_max, n)
+            threadsy = min(k, nthreads_max // threadsx)
+            grid = (int(np.ceil(n / threadsx)), int(np.ceil(k / threadsy)), 1)
+
+        else:
+            threadsx = min(nthreads_max, k)
+            threadsy = min(m, nthreads_max // threadsx)
+            grid = (int(np.ceil(k / threadsx)), int(np.ceil(m / threadsy)), 1)
+
+        block = (threadsx, threadsy, 1)
+        return block, grid
+
+    def cuda_take_along_axis(
+        x: gpuarray.GPUArray, idx: gpuarray.GPUArray, axis=0
+    ) -> gpuarray.GPUArray:
+        """Create a new GPUArray by taking indices along a given axis."""
+        m, n = x.shape
+        if axis == 0:
+            out = gpuarray.empty((idx.shape[0], n), dtype=x.dtype)
+        else:
+            out = gpuarray.empty((m, idx.shape[0]), dtype=x.dtype)
+
+        if idx.dtype.name == "int64":
+            idx = idx.astype(np.int32)
+
+        block, grid = _cudatake_blocksize(m, n, idx.shape[0], axis=axis)
+        print(m, n, idx.shape[0], block, grid)
+        if axis == 0:
+            fnc = (
+                take_along_first_axis_z
+                if x.dtype.name == "complex128"
+                else take_along_first_axis_c
+            )
+        else:
+            fnc = (
+                take_along_second_axis_z
+                if x.dtype.name == "complex128"
+                else take_along_second_axis_c
+            )
+
+        fnc(
+            x.gpudata,
+            np.int32(m),
+            np.int32(n),
+            idx.gpudata,
+            np.int32(idx.shape[0]),
+            out.gpudata,
+            block=block,
+            grid=grid,
+        )
+        return out
+
+else:
+    cuda_take_along_axis = None
diff --git a/devel/viscalc-performance/methods/_jax.py b/devel/viscalc-performance/methods/_jax.py
new file mode 100644
index 0000000..639e000
--- /dev/null
+++ b/devel/viscalc-performance/methods/_jax.py
@@ -0,0 +1,49 @@
+from ._lib import RedundantSolver, Solver
+
+try:
+    import jax
+    import jax.numpy as jnp
+    from jax import config
+
+    HAVE_JAX = True
+except ImportError:
+    HAVE_JAX = False
+
+
+class JAXSolver(Solver):
+    def setup(self):
+        if self._z.dtype.name == "complex128":
+            config.update("jax_enable_x64", True)
+
+        self.z = jax.device_put(self._z)
+
+
+class JAXRed(RedundantSolver):
+    def setup(self):
+        if self._z.dtype.name == "complex128":
+            config.update("jax_enable_x64", True)
+
+        self.z = jax.device_put(self._z)
+        self.ant1 = jax.device_put(self.pairs[:, 0])
+        self.ant2 = jax.device_put(self.pairs[:, 1])
+        self.out = jnp.empty(len(self.ant1), dtype=self._z.dtype)
+
+    def compute(self):
+        nchunks = len(self.ant1) // self.chunksize
+
+        def doslc(slc):
+            s1 = self.z[self.ant1[slc]]
+            s2 = self.z[self.ant2[slc]]
+            s1 *= s2.conj()
+            sm = jnp.sum(s1, axis=1)
+            self.out = self.out.at[slc].set(sm)
+
+        for chunk in range(nchunks):
+            slc = slice(chunk * self.chunksize, (chunk + 1) * self.chunksize)
+            doslc(slc)
+
+        if len(self.ant1) % self.chunksize:
+            slc = slice((chunk + 1) * self.chunksize, None)
+            doslc(slc)
+
+        return jax.device_get(self.out)
diff --git a/devel/viscalc-performance/methods/_lib.py b/devel/viscalc-performance/methods/_lib.py
new file mode 100644
index 0000000..e541a0d
--- /dev/null
+++ b/devel/viscalc-performance/methods/_lib.py
@@ -0,0 +1,69 @@
+"""Some small library code to help with implementing different solvers."""
+
+import numpy as np
+
+
+class Solver:
+    is_redundant: bool = False
+
+    def __init__(self, z: np.ndarray):
+        self._z = z
+        if self._z.shape[0] > self._z.shape[1]:
+            self.transposed = True
+        else:
+            self.transposed = False
+
+    def setup(self):
+        self.z = self._z
+
+    def compute(self) -> np.ndarray:
+        pass
+
+    def teardown(self):
+        pass
+
+    def __call__(self) -> np.ndarray:
+        self.setup()
+        out = self.compute()
+        self.teardown()
+        return out
+
+    @classmethod
+    def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None, **opts):
+        if rtol is None:
+            rtol = 1e-5 if z0.dtype.name == "complex128" else 1e-3
+        if atol is None:
+            atol = 1e-5 if z0.dtype.name == "complex128" else 1e-3
+
+        obj = cls(z0, **opts)
+        result = obj()
+        np.testing.assert_allclose(np.triu(result), np.triu(v0), rtol=rtol, atol=atol)
+
+
+class RedundantSolver(Solver):
+    is_redundant: bool = True
+
+    def __init__(self, z: np.ndarray, pairs: np.ndarray):
+        self._z = z
+        if self._z.shape[0] > self._z.shape[1]:
+            self.transposed = True
+        else:
+            self.transposed = False
+
+        self.pairs = pairs
+
+    @classmethod
+    def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None, **opts):
+        if rtol is None:
+            rtol = 1e-5 if z0.dtype.name == "complex128" else 1e-3
+        if atol is None:
+            atol = 1e-5 if z0.dtype.name == "complex128" else 1e-3
+
+        # All the pairs.
+        nant = min(z0.shape)
+        pairs = np.array([(a, b) for a in range(nant) for b in range(nant)])
+        obj = cls(z0, pairs, **opts)
+        result = obj()
+        np.testing.assert_allclose(
+            np.triu(result.reshape((nant, nant))), np.triu(v0), rtol=rtol, atol=atol
+        )
diff --git a/devel/viscalc-performance/methods/_rowswap.py b/devel/viscalc-performance/methods/_rowswap.py
new file mode 100644
index 0000000..adf62b1
--- /dev/null
+++ b/devel/viscalc-performance/methods/_rowswap.py
@@ -0,0 +1,173 @@
+import numpy as np
+
+def get_submatrices(pairs, max_subs: int=4, verbose: bool=False):
+    """
+    Split a full matrix of antenna-pairs into submatrices that contain given pairs.
+
+    Notes
+    -----
+    This function is not gauranteed to return the optimal decomposition. It does the
+    following:
+
+    1. Gets the arrays of ant1 and ant2, and sorts each one (in reverse) in order of
+       how many times it appears in the pairs given. Since the pairs given (if 
+       representing unique baselines) are not a unique representative set, this is
+       is not necessarily optimum.   
+    2. Try different numbers of sub-matrices, starting with 1 and going up by one up 
+       to ``max_subs``. Each submatrix is limited to placing cuts in the ant1 array. 
+       That is, the final result is just a partition of ant1 into Nsub sections.
+    3. To decide where these cuts should be, we start with the first cut, try it at one 
+       antenna, check the density of unique pairs for that antenna matched with all ant2 
+       antennas it requires, and if it's above a certain threshold density, try 
+       including the next antenna in ant1, and so on until it crosses the threshold 
+       density (starting at 0.8).
+    4. Once it hits that threshold, it starts trying to place the next cut in the same 
+       way, starting from the antenna its up to.
+    5. Once all the cuts are placed, checks the density of the last matrix (which didn't
+       get checked when placing the cuts), and if it is below the threshold density, we 
+       start again with a lowered threshold.
+    
+    This obtains N submatrices that all have roughly the same density of desired pairs 
+    within the size of the matrices, as high as possible under the constraints of the 
+    method. Note that having a roughly uniform density for the sub-matrices is not 
+    strictly necessary to achieve optimum *overall* density, but is a reasonably simple
+    metric to optimize that correlates with the desired metric.
+
+    Furthermore, the "best" solution is the one that affords the fastest matrix
+    multiplication as a sum over all sub-matrices. This is not achieved simply by 
+    obtaining the highest density partition, but is also a function of the number of 
+    submatrices. 
+
+    Since the method is constrained to slicing up the ant1 array, it is not symmetric.
+    One should also try reversing the pairs as an input to see if that yields a better
+    solution. In principle, one can arbitrarily reverse individual pairs as well, but
+    we do not try that here.
+
+    Parameters
+    ----------
+    pairs : numpy.ndarray
+        A numpy array of shape (n, 2) representing pairs.
+    max_subs : int, optional
+        The maximum number of sub-matrices to try. Default is 4.
+    verbose : bool, optional
+        Whether to print verbose output. Default is False.
+
+    Returns
+    -------
+    antmap : dict
+        A dictionary mapping ants to pairs.
+    all_antlists : list
+        A list of lists of lists representing the ant lists for each sub-matrix.
+
+    Examples
+    --------
+    >>> pairs = np.array([[1, 2], [2, 3], [3, 4]])
+    >>> antmap, all_antlists = get_submatrices(pairs, max_subs=3, verbose=True)
+    There are 3 ants to go around
+    Trying 2 sub-matrices
+      With tol_density=0.80
+        Got 0 ants for submatrix 0 with final density 0.000 going to 0.000
+      With tol_density=0.77
+        Got 1 ants for submatrix 1 with final density 0.000 going to 0.000
+    Trying 3 sub-matrices
+      With tol_density=0.80
+        Got 0 ants for submatrix 0 with final density 0.000 going to 0.000
+      With tol_density=0.77
+        Got 1 ants for submatrix 1 with final density 0.000 going to 0.000
+      With tol_density=0.74
+        Got 2 ants for submatrix 2 with final density 0.000 going to 0.000
+    ({1: [2], 2: [3], 3: [4]}, [[[1]], [[2]], [[3]]])
+    """
+    # Here's where the magic happens. 
+    ant1, ant1_counts = np.unique(pairs[:, 0], return_counts=True)
+    ant2, ant2_counts = np.unique(pairs[:, 1], return_counts=True)
+
+    idx1 = np.argsort(ant1_counts)[::-1]
+    idx2 = np.argsort(ant2_counts)[::-1]
+
+    ant1 = ant1[idx1]
+    ant2 = ant2[idx2]
+    n1 = len(ant1)
+
+    if verbose:
+        print(f"There are {n1} ants to go around")
+    antmap = {a: [p[1] for p in pairs if p[0]==a] for a in ant1}
+
+    densities = [len(pairs) / (len(ant1)*len(ant2))]
+
+    all_densities = [densities]
+    all_antlists = [[ant1.tolist()]]
+
+    for n_subs in range(2, max_subs):  # try different numbers of sub-matrices
+        
+        if verbose:
+            print(f"Trying {n_subs} sub-matrices")
+
+        # the fraction of the area upper triangle to the blocky upper triangle made
+        # n_subs equal-height rectangles. This is the highest density we could 
+        # possibly get for this n_subs.
+        tol_density = 0.8
+
+        while True:
+            if verbose:
+                print(f"  With tol_density={tol_density:.2f}")
+
+            sub_densities = [0]*n_subs
+            antlists = []
+        
+            curr_ant = 0
+            next_densities = []
+            for subline in range(n_subs-1):  # play with where each submatrix starts and stops
+                cols_included = set()
+                pairs_included = []
+                antlist = []
+
+                for idx, ant in enumerate(ant1[curr_ant:], start=curr_ant): # try different number of rows
+                    cols_included.update(antmap[ant])
+                    pairs_included.extend(antmap[ant])
+                    #print(len(cols_included), len(pairs_included))
+                    this_density = len(pairs_included) / ((idx - curr_ant + 1) * len(cols_included))
+
+                    if this_density < tol_density:
+                        if verbose:
+                            print(f"    Got {idx-curr_ant} ants for submatrix {subline} with final density {sub_densities[subline]:.3f} going to {this_density}")
+                        curr_ant = idx
+                        next_densities.append(this_density)
+                        break
+
+                    antlist.append(ant)
+                    sub_densities[subline] = this_density
+                else:
+                    # We hit the end of all the ants and never broke the density!
+                    antlists.append(antlist)
+                    break
+                    
+                antlists.append(antlist)
+            else:
+                # The last square also should be above the tolerance.
+                pairs_included = sum((antmap[ant] for ant in ant1[curr_ant:]), start=[])
+                cols_included = set(pairs_included)
+                this_density = len(pairs_included) / ((n1-curr_ant) * len(cols_included))
+                sub_densities[-1] = this_density
+                antlists.append(ant1[curr_ant:])
+
+                if this_density < tol_density:
+                    # not good enough. try with a lower tolerance everywhere.
+                    if verbose:
+                        print(f"    Final sub-matrix density too low ({this_density:.3f}). Size={n1-curr_ant}x{len(cols_included)} Reducing required density...")
+                    tol_density = min(tol_density - 0.03, min(next_densities))
+                else:
+                    all_densities.append(sub_densities)
+                    all_antlists.append(antlists)
+                    if verbose:
+                        print(f"  Success! Final sub-matrix has {len(ant1)-curr_ant} ants with density {this_density:.3f}")
+                    break
+            
+            if len(antlists) < n_subs:
+                # In the case we hit the end without using all our submatrices
+                if verbose:
+                    print(f"  Success only required {len(antlists)} sub-matrices.")
+                all_antlists.append(antlists)
+                break
+
+    return antmap, all_antlists
\ No newline at end of file
diff --git a/devel/viscalc-performance/methods/arrayfire_gemm.py b/devel/viscalc-performance/methods/arrayfire_gemm.py
new file mode 100644
index 0000000..0491ec9
--- /dev/null
+++ b/devel/viscalc-performance/methods/arrayfire_gemm.py
@@ -0,0 +1,25 @@
+from ._lib import Solver
+
+try:
+    import arrayfire
+
+    HAVE_AF = True
+except:
+    HAVE_AF = False
+
+
+class ArrayFireGemm(Solver):
+    def setup(self):
+        self.out = arrayfire.Array(
+            dtype=self._z.dtype.char, dims=(self._z.shape[0], self._z.shape[0])
+        )
+        self.z = arrayfire.from_ndarray(self._z)
+
+    def compute(self):
+        return arrayfire.blas.gemm(
+            self.z,
+            self.z,
+            lhs_opts=arrayfire.MATPROP.NONE,
+            rhs_opts=arrayfire.MATPROP.CTRANS,
+            C=self.out,
+        )
diff --git a/devel/viscalc-performance/methods/cp_dot.py b/devel/viscalc-performance/methods/cp_dot.py
new file mode 100644
index 0000000..d2d9076
--- /dev/null
+++ b/devel/viscalc-performance/methods/cp_dot.py
@@ -0,0 +1,10 @@
+from ._cp import _CuPy
+import cupy as cp
+
+class CpDot(_CuPy):
+    def compute(self):
+        if self.transposed:
+            cp.dot(self.z.T, self.z.conj(), out=self.out)
+        else:
+            cp.dot(self.z, self.z.conj().T, out=self.out)
+        return self.out.get()
\ No newline at end of file
diff --git a/devel/viscalc-performance/methods/cp_rowswap.py b/devel/viscalc-performance/methods/cp_rowswap.py
new file mode 100644
index 0000000..c07aecb
--- /dev/null
+++ b/devel/viscalc-performance/methods/cp_rowswap.py
@@ -0,0 +1,105 @@
+from ._cp import _CuPyRed, cp
+import numpy as np
+from ._rowswap import get_submatrices
+from time import perf_counter
+
+class CpRowSwap(_CuPyRed):
+    """This follows a simple method to try make the matrix as dense as possible.
+    
+    For now, it uses only the default pairs given (it does not attempt to try use
+    different pairs in the redundant sets). It orders the ants in order of how many 
+    unique pairs they appear in, both for the first ant and second ant (rows and cols).
+    It then splits the matrix into some number of sub-matrices that attempt to maximise
+    the density in each.
+    """
+    def __init__(self, *args, revpairs: bool = False, nsubs: int=3, **kwargs ):
+        super().__init__(*args, **kwargs)
+        self.revpairs = revpairs
+        self.nsubs = nsubs
+
+    def setup(self):
+        self.create()
+        self.antmap, antlists = get_submatrices(
+            self.pairs[:, ::-1] if self.revpairs else self.pairs, 
+            max_subs=self.nsubs
+        )
+        self.antlist = antlists[-1]
+
+        self.ant1list = [
+            cp.array(np.sort(a)) for a in self.antlist
+        ]
+        self.ant2list = [
+            cp.array(np.sort(list(set(sum((self.antmap[a] for a in antlist), start=[]))))) for antlist in self.antlist
+        ]
+
+        self.out = [
+            cp.zeros(shape=(len(a), len(b)), dtype=self._z.dtype) for a, b in zip(self.ant1list, self.ant2list)
+        ]
+
+
+        # TODO: really should figure out the computable size automatically.
+        if max(self._z.shape) > 12*256**2:
+            nsrc = self._z.shape[1]
+            self.z = [slice(0, nsrc//4), slice(nsrc//4, 2*nsrc//4), slice(2*nsrc//4, 3*nsrc//4), slice(3*nsrc//4, None)]
+        else:
+            self.z = [cp.array(self._z)]
+
+    def compute(self):
+        outer = perf_counter()
+        takes_time = 0
+        gemms_time = 0
+        mem_time = 0
+        res = [0]*len(self.out)
+
+        for _z in self.z:
+            if isinstance(_z, slice):
+                _z = cp.array(self._z[:, _z])
+
+            nsrc = _z.shape[1]
+
+            for a, b, out, r in zip(self.ant1list, self.ant2list, self.out, res):
+                
+                #start_gpu = cp.cuda.Event()
+                #end_gpu = cp.cuda.Event()
+                #start_gpu.record()
+                za = _z[a]
+                zb = _z[b]
+                #end_gpu.record()
+                #end_gpu.synchronize()
+                #takes_time += cp.cuda.get_elapsed_time(start_gpu, end_gpu)
+
+                #gemms_in = cp.cuda.Event()
+                #gemms_out = cp.cuda.Event()
+                #gemms_in.record()
+                cp.dot(za, zb.conj().T, out=out)
+                # self.gemm(
+                #     self.h,
+                #     "c",  # conjugate transpose for first (remember fortran order)
+                #     "n",  # no transpose for second.
+                #     len(a),
+                #     len(b),
+                #     nsrc,
+                #     1.0,
+                #     za.data,
+                #     nsrc,
+                #     zb.data,
+                #     nsrc,
+                #     0.0,
+                #     out.data,
+                #     len(a),
+                # )
+                #gemms_out.record()
+                #gemms_out.synchronize()
+                #gemms_time += cp.cuda.get_elapsed_time(gemms_in, gemms_out)
+
+
+                t0 = perf_counter()
+                r += out.get()
+                mem_time += perf_counter() - t0
+        outer -= perf_counter()
+
+        print("Full compute time: ", -outer)
+        print("take_along_axis compute time: ", takes_time)
+        print("Gemms time: ", gemms_time)
+        print("Memory return time: ", mem_time)
+        return res
diff --git a/devel/viscalc-performance/methods/cublas_chunkedloop.py b/devel/viscalc-performance/methods/cublas_chunkedloop.py
new file mode 100644
index 0000000..84ee32b
--- /dev/null
+++ b/devel/viscalc-performance/methods/cublas_chunkedloop.py
@@ -0,0 +1,90 @@
+"""Chunked-loop implementation in CuBLAS."""
+import numpy as np
+
+from . import _cublas as _cu
+from ._cublas import _CuBLASRed, cuda_take_along_axis
+
+
+class CuBLASChunkedLoop(_CuBLASRed):
+    """Chunked-loop implementation in CuBLAS."""
+
+    def setup(self):
+        """Set it up."""
+        super().setup()
+
+        # Now, chunk the pairs into lists of pairs, where each list has the same
+        # first antenna.
+        ants = {}
+
+        for a, b in self.pairs:
+            if a not in ants:
+                ants[a] = [b]
+            else:
+                ants[a].append(b)
+
+        # Put them on the GPU
+        self.ants = {
+            k: _cu.gpuarray.to_gpu(np.sort(v).astype(np.int32)) for k, v in ants.items()
+        }
+        most_pairs = max(len(v) for v in ants.values())
+        self.out_chunk = _cu.gpuarray.empty((most_pairs,), dtype=self.z.dtype)
+
+    def compute(self):
+        """Compute it."""
+        out = np.zeros(len(self.pairs), dtype=self.z.dtype)
+        n = 0
+
+        if self.transposed:
+            nsrc, nant = self.z.shape
+            zc = self.z.conj()
+
+            for a, b in self.ants.items():
+                # Make new contiguous array for these antennas.
+                m = cuda_take_along_axis(zc, b, axis=1)
+                thisn = len(b)
+
+                self.gemv(
+                    self.h,
+                    "n",  # conjugate transpose for first (remember fortran order)
+                    thisn,
+                    nsrc,
+                    1.0,
+                    m.gpudata,
+                    thisn,
+                    self.z[:, a].gpudata,
+                    thisn,
+                    0.0,
+                    self.out_chunk.gpudata,
+                    1,
+                )
+                out[n : n + thisn] = self.out_chunk[:thisn].get()
+                n += thisn
+        else:
+            nant, nsrc = self.z.shape
+
+            out = np.zeros(len(self.pairs), dtype=self.z.dtype)
+
+            n = 0
+            for a, b in self.ants.items():
+                # Make new contiguous array for these antennas.
+                m = cuda_take_along_axis(self.z, b)
+                thisn = len(b)
+
+                self.gemv(
+                    self.h,
+                    "c",  # conjugate transpose for first (remember fortran order)
+                    nsrc,
+                    thisn,
+                    1.0,
+                    m.gpudata,
+                    nsrc,
+                    self.z[a].gpudata,
+                    1,
+                    0.0,
+                    self.out_chunk.gpudata,
+                    1,
+                )
+                out[n : n + thisn] = self.out_chunk[:thisn].get()
+                n += thisn
+
+        return out
diff --git a/devel/viscalc-performance/methods/cublas_rowswap.py b/devel/viscalc-performance/methods/cublas_rowswap.py
new file mode 100644
index 0000000..cc0d239
--- /dev/null
+++ b/devel/viscalc-performance/methods/cublas_rowswap.py
@@ -0,0 +1,99 @@
+from ._cublas import _CuBLASRed, cuda_take_along_axis
+from . import _cublas as _cu
+import numpy as np
+from ._rowswap import get_submatrices
+from time import perf_counter
+
+class CuBLASRowSwap(_CuBLASRed):
+    """This follows a simple method to try make the matrix as dense as possible.
+    
+    For now, it uses only the default pairs given (it does not attempt to try use
+    different pairs in the redundant sets). It orders the ants in order of how many 
+    unique pairs they appear in, both for the first ant and second ant (rows and cols).
+    It then splits the matrix into some number of sub-matrices that attempt to maximise
+    the density in each.
+    """
+    def __init__(self, *args, revpairs: bool = False, nsubs: int=3, **kwargs ):
+        super().__init__(*args, **kwargs)
+        self.revpairs = revpairs
+        self.nsubs = nsubs
+
+    def setup(self):
+        self.create()
+
+        self.antmap, antlists = get_submatrices(
+            self.pairs[:, ::-1] if self.revpairs else self.pairs, 
+            max_subs=self.nsubs
+        )
+        self.antlist = antlists[-1]
+
+        self.ant1list = [
+            _cu.gpuarray.to_gpu(np.sort(a)) for a in self.antlist
+        ]
+        self.ant2list = [
+            _cu.gpuarray.to_gpu(np.sort(list(set(sum((self.antmap[a] for a in antlist), start=[]))))) for antlist in self.antlist
+        ]
+
+        self.out = [
+            _cu.gpuarray.zeros(shape=(len(a), len(b)), dtype=self._z.dtype) for a, b in zip(self.ant1list, self.ant2list)
+        ]
+
+
+        # TODO: really should figure out the computable size automatically.
+        if max(self._z.shape) > 12*256**2:
+            nsrc = self._z.shape[1]
+            self.z = [slice(0, nsrc//4), slice(nsrc//4, 2*nsrc//4), slice(2*nsrc//4, 3*nsrc//4), slice(3*nsrc//4, None)]
+        else:
+            self.z = [_cu.gpuarray.to_gpu(self._z)]
+
+    def compute(self):
+        outer = perf_counter()
+        takes_time = 0
+        gemms_time = 0
+        mem_time = 0
+        res = [0]*len(self.out)
+
+        for _z in self.z:
+            if isinstance(_z, slice):
+                _z = _cu.gpuarray.to_gpu(self._z[:, _z])
+
+            nsrc = _z.shape[1]
+
+            for a, b, out, r in zip(self.ant1list, self.ant2list, self.out, res):
+                takes_in = perf_counter()
+                za = cuda_take_along_axis(_z, a)
+                zb = cuda_take_along_axis(_z, b)
+                _cu.autoinit.context.synchronize()
+                takes_time += perf_counter() - takes_in
+
+                gemms_in = perf_counter()
+                self.gemm(
+                    self.h,
+                    "c",  # conjugate transpose for first (remember fortran order)
+                    "n",  # no transpose for second.
+                    len(a),
+                    len(b),
+                    nsrc,
+                    1.0,
+                    za.gpudata,
+                    nsrc,
+                    zb.gpudata,
+                    nsrc,
+                    0.0,
+                    out.gpudata,
+                    len(a),
+                )
+                _cu.autoinit.context.synchronize()
+                gemms_time += perf_counter() - gemms_in
+
+
+                t0 = perf_counter()
+                r += out.get()
+                mem_time += perf_counter() - t0
+        outer -= perf_counter()
+
+        print("Full compute time: ", -outer)
+        print("take_along_axis compute time: ", takes_time)
+        print("Gemms time: ", gemms_time)
+        print("Memory return time: ", mem_time)
+        return res
diff --git a/devel/viscalc-performance/methods/cublas_vectorloop.py b/devel/viscalc-performance/methods/cublas_vectorloop.py
new file mode 100644
index 0000000..c9d87df
--- /dev/null
+++ b/devel/viscalc-performance/methods/cublas_vectorloop.py
@@ -0,0 +1,51 @@
+from ._cublas import _CuBLASRed
+from . import _cublas as _cu
+from time import perf_counter
+
+class CuBLASVectorLoop(_CuBLASRed):
+    def compute(self):
+        total = perf_counter()
+        dot = 0
+
+        if self.transposed:
+            size = self.z.shape[0]
+
+            for i, (a, b) in enumerate(self.pairs):
+                t0 = perf_counter()
+                self.dotc(
+                    self.h,
+                    size,
+                    self.z[:, b].gpudata,
+                    1,
+                    self.z[:, a].gpudata,
+                    1,
+                    self.out[i].gpudata,
+                )
+                _cu.sync()
+                dot += perf_counter() - t0
+        else:
+            size = self.z.shape[1]
+            t0 = perf_counter()
+            for i, (a, b) in enumerate(self.pairs):
+                self.dotc(
+                    self.h,
+                    size,
+                    self.z[b].gpudata,
+                    1,
+                    self.z[a].gpudata,
+                    1,
+                    self.out[i].gpudata,
+                )
+            _cu.sync()
+            dot += perf_counter() - t0
+
+        get = perf_counter()
+        res = self.out.get()
+        get -= perf_counter()
+        total -= perf_counter()
+
+        print("Total time: ", -total)
+        print("Dot time:", dot)
+        print("Memory get time: ", get)
+
+        return res
diff --git a/devel/viscalc-performance/methods/cublas_zgemm.py b/devel/viscalc-performance/methods/cublas_zgemm.py
new file mode 100644
index 0000000..a4029dc
--- /dev/null
+++ b/devel/viscalc-performance/methods/cublas_zgemm.py
@@ -0,0 +1,43 @@
+from ._cublas import _CuBLAS as _CB
+
+
+class CuBLASZgemm(_CB):
+    def compute(self):
+        if self.transposed:
+            nsrc, nant = self.z.shape
+            self.gemm(
+                self.h,
+                "n",  # conjugate transpose for first (remember fortran order)
+                "c",  # no transpose for second.
+                nant,
+                nant,
+                nsrc,
+                1.0,
+                self.z.gpudata,
+                nant,
+                self.z.gpudata,
+                nant,
+                0.0,
+                self.out.gpudata,
+                nant,
+            )
+        else:
+            nant, nsrc = self.z.shape
+
+            self.gemm(
+                self.h,
+                "c",  # conjugate transpose for first (remember fortran order)
+                "n",  # no transpose for second.
+                nant,
+                nant,
+                nsrc,
+                1.0,
+                self.z.gpudata,
+                nsrc,
+                self.z.gpudata,
+                nsrc,
+                0.0,
+                self.out.gpudata,
+                nant,
+            )
+        return self.out.get()
diff --git a/devel/viscalc-performance/methods/cublas_zherk.py b/devel/viscalc-performance/methods/cublas_zherk.py
new file mode 100644
index 0000000..cd399c3
--- /dev/null
+++ b/devel/viscalc-performance/methods/cublas_zherk.py
@@ -0,0 +1,37 @@
+from ._cublas import _CuBLAS as _CB
+
+
+class CuBLASZherk(_CB):
+    def compute(self):
+        if self.transposed:
+            nsrc, nant = self.z.shape
+            self.herk(
+                self.h,
+                uplo="L",
+                trans="n",
+                n=nant,
+                k=nsrc,
+                alpha=1.0,
+                A=self.z.gpudata,
+                lda=nant,
+                beta=0.0,
+                C=self.out.gpudata,
+                ldc=nant,
+            )
+        else:
+            nant, nsrc = self.z.shape
+
+            self.herk(
+                self.h,
+                uplo="L",
+                trans="c",
+                n=nant,
+                k=nsrc,
+                alpha=1.0,
+                A=self.z.gpudata,
+                lda=nsrc,
+                beta=0.0,
+                C=self.out.gpudata,
+                ldc=nant,
+            )
+        return self.out.get()
diff --git a/devel/viscalc-performance/methods/jax_chunkedloop.py b/devel/viscalc-performance/methods/jax_chunkedloop.py
new file mode 100644
index 0000000..9676800
--- /dev/null
+++ b/devel/viscalc-performance/methods/jax_chunkedloop.py
@@ -0,0 +1,28 @@
+import jax
+import jax.numpy as jnp
+
+from ._jax import JAXRed as _JR
+
+
+class JAXChunkedLoop(_JR):
+    chunksize = 350
+
+    def compute(self):
+        nchunks = len(self.ant1) // self.chunksize
+
+        def doslc(slc):
+            s1 = self.z[self.ant1[slc]]
+            s2 = self.z[self.ant2[slc]]
+            s1 *= s2.conj()
+            sm = jnp.sum(s1, axis=1)
+            self.out = self.out.at[slc].set(sm)
+
+        for chunk in range(nchunks):
+            slc = slice(chunk * self.chunksize, (chunk + 1) * self.chunksize)
+            doslc(slc)
+
+        if len(self.ant1) % self.chunksize:
+            slc = slice((chunk + 1) * self.chunksize, None)
+            doslc(slc)
+
+        return jax.device_get(self.out)
diff --git a/devel/viscalc-performance/methods/jax_dot.py b/devel/viscalc-performance/methods/jax_dot.py
new file mode 100644
index 0000000..1e84ab5
--- /dev/null
+++ b/devel/viscalc-performance/methods/jax_dot.py
@@ -0,0 +1,10 @@
+import jax
+import jax.numpy as jnp
+
+from ._jax import JAXSolver as _JXS
+
+
+class JAXDot(_JXS):
+    def compute(self):
+        out = jnp.dot(self.z, self.z.T.conj(), precision=jax.lax.Precision.HIGHEST)
+        return jax.device_get(out)
diff --git a/devel/viscalc-performance/methods/jax_vectorloop.py b/devel/viscalc-performance/methods/jax_vectorloop.py
new file mode 100644
index 0000000..456db3c
--- /dev/null
+++ b/devel/viscalc-performance/methods/jax_vectorloop.py
@@ -0,0 +1,19 @@
+import jax
+import jax.numpy as jnp
+
+from ._jax import JAXRed as _JR
+
+
+@jax.jit
+def _go_at_it(z: jnp.array, out: jnp.array, pairs: jnp.array):
+    zc = z.conj()
+
+    for i, (a, b) in enumerate(pairs):
+        out = out.at[i].set(jnp.dot(z[a], zc[b]))
+
+    return jax.device_get(out)
+
+
+class JAXVectorLoop(_JR):
+    def compute(self):
+        return _go_at_it(self.z, self.out, self.pairs)
diff --git a/devel/viscalc-performance/methods/np_dot.py b/devel/viscalc-performance/methods/np_dot.py
new file mode 100644
index 0000000..da62003
--- /dev/null
+++ b/devel/viscalc-performance/methods/np_dot.py
@@ -0,0 +1,11 @@
+import numpy as np
+
+from ._lib import Solver
+
+
+class NpDot(Solver):
+    def compute(self):
+        if self.transposed:
+            return np.dot(self.z.T, self.z.conj())
+        else:
+            return np.dot(self.z, self.z.conj().T)
diff --git a/devel/viscalc-performance/methods/np_zgemm.py b/devel/viscalc-performance/methods/np_zgemm.py
new file mode 100644
index 0000000..b9f0740
--- /dev/null
+++ b/devel/viscalc-performance/methods/np_zgemm.py
@@ -0,0 +1,11 @@
+from scipy.linalg import blas
+
+from ._lib import Solver
+
+
+class NpZgemm(Solver):
+    def compute(self):
+        if self.transposed:
+            return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_a=True)
+        else:
+            return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_b=True)
diff --git a/devel/viscalc-performance/methods/np_zherk.py b/devel/viscalc-performance/methods/np_zherk.py
new file mode 100644
index 0000000..a3c3c1a
--- /dev/null
+++ b/devel/viscalc-performance/methods/np_zherk.py
@@ -0,0 +1,11 @@
+from scipy.linalg import blas
+
+from ._lib import Solver
+
+
+class NpZherk(Solver):
+    def compute(self):
+        if self.transposed:
+            return blas.zherk(alpha=1, a=self.z.T)
+        else:
+            return blas.zherk(alpha=1, a=self.z)
diff --git a/devel/viscalc-performance/methods/numba_vectorloop.py b/devel/viscalc-performance/methods/numba_vectorloop.py
new file mode 100644
index 0000000..d868bb3
--- /dev/null
+++ b/devel/viscalc-performance/methods/numba_vectorloop.py
@@ -0,0 +1,21 @@
+import numba
+import numpy as np
+
+from ._lib import RedundantSolver
+
+
+@numba.njit
+def _dumbloopjit(z, pairs, out):
+    zc = z.conj()
+    for i, (a, b) in enumerate(pairs):
+        out[i] = np.dot(z[a], zc[b])
+
+
+class SingleLoopNumba(RedundantSolver):
+    def setup(self):
+        self.z = self._z
+        self.out = np.empty(len(self.pairs), dtype=self._z.dtype)
+
+    def compute(self):
+        _dumbloopjit(self.z, self.pairs, self.out)
+        return self.out
diff --git a/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb b/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb
new file mode 100644
index 0000000..c0c8c68
--- /dev/null
+++ b/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb
@@ -0,0 +1,654 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d80c2710",
+   "metadata": {},
+   "source": [
+    "# Performance Tests of Matrix Multiply Algorithms"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1100dba8",
+   "metadata": {},
+   "source": [
+    "The point of this notebook is to test different matrix-multiply algorithms for doing the vis-cpu algorithm's $V = ZZ^\\dagger$. In this notebook, we don't care about _how_ we got $Z$, only that it is complex-valued, and its shape is supposed to be $N_{\\rm feed} N_{\\rm ant} \\times N_{\\rm ax} N_{\\rm src}$, which is generally _very_ non-square. \n",
+    "\n",
+    "We define a number of methods that compute $V$, and test their performance on different shapes of $Z$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "31f6b315",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-03-11T23:58:52.927596Z",
+     "start_time": "2023-03-11T23:58:52.814891Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pathlib import Path\n",
+    "#import methods\n",
+    "import yaml\n",
+    "#from getperf import TimeResult\n",
+    "from dataclasses import dataclass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "bb4a2e45",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@dataclass\n",
+    "class TimeResult:\n",
+    "    times: list[float]\n",
+    "    n: int\n",
+    "\n",
+    "    @property\n",
+    "    def best(self):\n",
+    "        return np.min(self.times)\n",
+    "\n",
+    "    @property\n",
+    "    def mean(self):\n",
+    "        return np.mean(self.times)\n",
+    "\n",
+    "    @property\n",
+    "    def repeats(self):\n",
+    "        return len(self.times)\n",
+    "\n",
+    "    @property\n",
+    "    def std(self):\n",
+    "        return np.std(self.times)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c9ca126a-64fc-4f46-b84f-20c52e1a90da",
+   "metadata": {
+    "tags": [
+     "parameters"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "cache: str = \"/ocean/projects/phy210034p/sgm/visgpu-mm-profiling/cache\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "eb8b550d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cache = Path(cache)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "66b2c880",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_all_timings(cache: Path, precision: str, kind: str):\n",
+    "    timings = sorted(cache.glob(f\"*_{precision}_{kind}.yaml\"))\n",
+    "\n",
+    "    nsides = set()\n",
+    "    nants = set()\n",
+    "    redfracs = set()\n",
+    "\n",
+    "    normal = {}\n",
+    "    redund = {}\n",
+    "\n",
+    "    normal['redundant'] = False\n",
+    "    redund['redundant'] = True\n",
+    "\n",
+    "    for fl in timings:\n",
+    "        method, size, _, _ = fl.stem.split(\"_\")\n",
+    "        n1, nside = size.split('x')\n",
+    "        \n",
+    "        nside = int(nside)\n",
+    "        nsides.add(nside)\n",
+    "        #cls = getattr(methods, method)\n",
+    "        is_redundant = (int(size.split('x')[0]) in (3, 10, 25, 50, 100))\n",
+    "        \n",
+    "        with open(fl, 'r') as yml:\n",
+    "            d = yaml.safe_load(yml)\n",
+    "\n",
+    "\n",
+    "        if not is_redundant:\n",
+    "            nant = int(n1)\n",
+    "            nants.add(nant)\n",
+    "            if method not in normal:\n",
+    "                normal[method] = {}\n",
+    "\n",
+    "            normal[method][(nant, nside)] = TimeResult(**d)\n",
+    "        else:\n",
+    "            redfrac = int(n1)\n",
+    "            redfracs.add(redfrac)\n",
+    "            if method not in redund:\n",
+    "                redund[method] = {}\n",
+    "            redund[method][(redfrac, nside)] = TimeResult(**d)\n",
+    "    \n",
+    "    return normal, redund, sorted(nsides), sorted(nants), sorted(redfracs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "a8c7ea1b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Full Dot Product (single row):  6\n",
+      "Full Dot Product (double row):  6\n",
+      "Full Dot Product (single col):  6\n",
+      "Full Dot Product (double col):  6\n",
+      "Redundant (single row):  4\n",
+      "Redundant (double row):  4\n",
+      "Redundant (single col):  4\n",
+      "Redundant (double col):  4\n"
+     ]
+    }
+   ],
+   "source": [
+    "normal_single_row, redundant_single_row, nsides, nants, redfracs = get_all_timings(cache, 'single', 'row')\n",
+    "normal_double_row, redundant_double_row, _, _, _ = get_all_timings(cache, 'double', 'row')\n",
+    "normal_single_col, redundant_single_col, _, _, _ = get_all_timings(cache, 'single', 'col')\n",
+    "normal_double_col, redundant_double_col, _, _, _ = get_all_timings(cache, 'double', 'col')\n",
+    "\n",
+    "print(\"Full Dot Product (single row): \", len(normal_single_row))\n",
+    "print(\"Full Dot Product (double row): \", len(normal_double_row))\n",
+    "print(\"Full Dot Product (single col): \", len(normal_single_col))\n",
+    "print(\"Full Dot Product (double col): \", len(normal_double_col))\n",
+    "\n",
+    "print(\"Redundant (single row): \", len(redundant_single_row))\n",
+    "print(\"Redundant (double row): \", len(redundant_double_row))\n",
+    "print(\"Redundant (single col): \", len(redundant_single_col))\n",
+    "print(\"Redundant (double col): \", len(redundant_double_col))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "6cb07ac8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['redundant', 'CuBLASZgemm', 'CuBLASZherk', 'NpDot', 'NpZgemm', 'NpZherk'])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "normal_single_row.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "ee8f43c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nsrcs = [2 * 12*nside**2 for nside in nsides]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d508e80-aeb0-4f03-92c2-a580f3921ed0",
+   "metadata": {},
+   "source": [
+    "## Plotting Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "e1459e2b-6f80-435f-b7d6-ab415f7743f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_timings(timings: dict[str, dict[tuple[int, int], \"TimeResult\"]]):\n",
+    "    fig, ax = plt.subplots(2, max(len(nants), len(nsrcs)), figsize=(15, 8), constrained_layout=True, sharex='row', sharey='row')\n",
+    "\n",
+    "    for i, (nside, nsrc) in enumerate(zip(nsides, nsrcs)):\n",
+    "        for j, (method, results) in enumerate(timings.items()):\n",
+    "            if method == 'redundant':\n",
+    "                continue\n",
+    "            res = [results.get((n, nside), None) for n in nants]\n",
+    "            ax[0, i].plot(nants, [r.best if r is not None else np.nan for r in res], color=f'C{j}', label=method)\n",
+    "\n",
+    "        ax[0, i].set_title(f\"Nside={nside}\")\n",
+    "        ax[0, i].set_xlabel(\"Nants x Nfeeds\")\n",
+    "        ax[0, 0].set_ylabel(\"Time [sec]\")\n",
+    "#        ax[0, i].plot(nants, np.array(nants) * (results[(np.max(nants), nside)].best/np.max(nants)), ls='--', color='k')\n",
+    "        \n",
+    "        ax[0, i].set_xscale('log')\n",
+    "        ax[0, i].set_yscale('log')\n",
+    "    \n",
+    "    for j in range(i+1, ax.shape[1]):\n",
+    "        ax[0, j].axis('off')\n",
+    "        \n",
+    "        \n",
+    "    for i, nant in enumerate(nants):\n",
+    "        for j, (method, results) in enumerate(timings.items()):\n",
+    "            if method=='redundant':\n",
+    "                continue\n",
+    "            res = [results.get((nant, n), None) for n in nsides]\n",
+    "\n",
+    "            ax[1, i].plot(nsrcs, [r.best if r is not None else np.nan for r in res], color=f'C{j}')\n",
+    "\n",
+    "        ax[1,i].set_title(f\"Nant x Nfeed={nant}\")\n",
+    "        ax[1,i].set_xlabel(\"nsrc\")\n",
+    "        ax[1, i].set_xscale('log')\n",
+    "        ax[1, i].set_yscale('log')\n",
+    " #       ax[1, i].plot(nsrcs, np.array(nsrcs) * (results[(nant, np.max(nsides))].best/np.max(nsrcs)), ls='--', color='k')\n",
+    "    \n",
+    "    ax[0,0].legend(frameon=False, ncols=2)\n",
+    "    return fig, ax"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "52c3f3e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1080x576 with 8 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_timings(normal_single_row);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "3db2308c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_timings_reds(red_timings: dict[str, dict[tuple[int, int], TimeResult]], \n",
+    "                      timings: dict[str, dict[tuple[int, int], TimeResult]]):\n",
+    "    fig, ax = plt.subplots(1, 1, figsize=(15, 8), constrained_layout=True)\n",
+    "\n",
+    "    nants_redundant = np.max(nants)\n",
+    "\n",
+    "    for j, (method, results) in enumerate(timings.items()):\n",
+    "        if method=='redundant':\n",
+    "            continue\n",
+    "        res = [results.get((nants_redundant, n), None) for n in nsides]\n",
+    "        ax.plot(nsrcs, [r.best if r is not None else np.nan for r in res], color=f'C{j}', label=method)\n",
+    "        \n",
+    "    for j, (method, results) in enumerate(red_timings.items(), start=len(timings)):\n",
+    "        if method=='redundant':\n",
+    "            continue\n",
+    "        for k, frac in enumerate(redfracs):\n",
+    "            res = [results.get((frac, n), None) for n in nsides]\n",
+    "            ax.plot(\n",
+    "                nsrcs, [r.best if r is not None else np.nan for r in res], \n",
+    "                color=f'C{j%10}', ls=[':', '--', '-.', (0, (3, 5, 1, 5, 1, 5)), (0, (3, 1, 1, 1, 1, 1))][k], \n",
+    "                label=f\"{method} ({frac}% red.)\"\n",
+    "            )\n",
+    "        \n",
+    "    ax.set_title(f\"Nant x Nfeed={nants_redundant}\")\n",
+    "    ax.set_xlabel(\"nsrc\")\n",
+    "    ax.set_xscale('log')\n",
+    "    ax.set_yscale('log')\n",
+    "    #ax.plot(nsrcs, np.array(nsrcs) * (results[(350, np.max(nsrcs))].best/np.max(nsrcs)), ls='--', color='k')\n",
+    "\n",
+    "    ax.legend(frameon=False, ncols=3)\n",
+    "    return fig, ax"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "3f3e5f7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1080x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_timings_reds(redundant_single_row, normal_single_row);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "a52739ce",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1080x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_timings_reds(redundant_double_row, normal_double_row);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "3bd95843",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_comparison(\n",
+    "    t1: dict[str, dict[tuple[int, int], TimeResult]], \n",
+    "    t2: dict[str, dict[tuple[int, int], TimeResult]],\n",
+    "    outer_label: int\n",
+    "):\n",
+    "    fig, ax = plt.subplots(1, 1, figsize=(15, 8), constrained_layout=True)\n",
+    "\n",
+    "    def get_res(t, method):\n",
+    "        res = [t[method].get((outer_label, n), None) for n in nsides]    \n",
+    "        return np.array([r.best if r is not None else np.nan for r in res])\n",
+    "\n",
+    "    for j, method in enumerate(t1):\n",
+    "        if method == 'redundant':\n",
+    "            continue\n",
+    "        r1 = get_res(t1, method)\n",
+    "        r2 = get_res(t2, method)\n",
+    "\n",
+    "        ax.plot(nsrcs, r1 / r2, color=f'C{j}', label=method)\n",
+    "        \n",
+    "#    ax.set_title(f\"Nant x Nfeed={nants_redundant}\")\n",
+    "    ax.set_xlabel(\"nsrc\")\n",
+    "    ax.set_xscale('log')\n",
+    "    #ax.set_yscale('log')\n",
+    "    #ax.plot(nsrcs, np.array(nsrcs) * (results[(350, np.max(nsrcs))].best/np.max(nsrcs)), ls='--', color='k')\n",
+    "\n",
+    "    ax.legend(frameon=False, ncols=3)\n",
+    "    return fig, ax"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "c1ad42fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x7fb3047d6050>"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1080x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plot_comparison(normal_single_row, normal_double_row, 700)\n",
+    "plt.title(\"Single / Double Precision Dot-Product\")\n",
+    "plt.axhline(0.5, linestyle='--', color='k')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "4d393558",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x7fb304dbdf60>"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1080x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plot_comparison(redundant_single_row, redundant_double_row, 3)\n",
+    "plt.title(\"Single / Double Precision VectorLoop\")\n",
+    "plt.axhline(0.5, linestyle='--', color='k')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "d1d2d8de",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x7fb30536b010>"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1080x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plot_comparison(normal_single_row, normal_single_col, 700)\n",
+    "plt.title(\"Row / Column Major Ordering, Full Dot Product\")\n",
+    "plt.axhline(1.0, linestyle='--', color='k')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "45628dd4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x7fb30532d360>"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1080x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plot_comparison(normal_double_row, normal_double_col, 700)\n",
+    "plt.title(\"Row / Column Major Ordering, Full Dot Product\")\n",
+    "plt.axhline(1.0, linestyle='--', color='k')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "35a7b585",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "KeyError",
+     "evalue": "'CuBLASChunkedLoop'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
+      "\u001b[1;32m/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb Cell 21\u001b[0m line \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=0'>1</a>\u001b[0m fig, ax \u001b[39m=\u001b[39m plot_comparison(redundant_single_row, redundant_single_col, \u001b[39m3\u001b[39;49m)\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=1'>2</a>\u001b[0m plt\u001b[39m.\u001b[39mtitle(\u001b[39m\"\u001b[39m\u001b[39mRow / Column Major Ordering, Redundant\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=2'>3</a>\u001b[0m plt\u001b[39m.\u001b[39maxhline(\u001b[39m1.0\u001b[39m, linestyle\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39m--\u001b[39m\u001b[39m'\u001b[39m, color\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mk\u001b[39m\u001b[39m'\u001b[39m)\n",
+      "\u001b[1;32m/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb Cell 21\u001b[0m line \u001b[0;36mplot_comparison\u001b[0;34m(t1, t2, outer_label)\u001b[0m\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=13'>14</a>\u001b[0m             \u001b[39mcontinue\u001b[39;00m\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=14'>15</a>\u001b[0m         r1 \u001b[39m=\u001b[39m get_res(t1, method)\n\u001b[0;32m---> <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=15'>16</a>\u001b[0m         r2 \u001b[39m=\u001b[39m get_res(t2, method)\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=17'>18</a>\u001b[0m         ax\u001b[39m.\u001b[39mplot(nsrcs, r1 \u001b[39m/\u001b[39m r2, color\u001b[39m=\u001b[39m\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mC\u001b[39m\u001b[39m{\u001b[39;00mj\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m, label\u001b[39m=\u001b[39mmethod)\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=19'>20</a>\u001b[0m \u001b[39m#    ax.set_title(f\"Nant x Nfeed={nants_redundant}\")\u001b[39;00m\n",
+      "\u001b[1;32m/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb Cell 21\u001b[0m line \u001b[0;36mplot_comparison.<locals>.get_res\u001b[0;34m(t, method)\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=7'>8</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_res\u001b[39m(t, method):\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=8'>9</a>\u001b[0m     res \u001b[39m=\u001b[39m [t[method]\u001b[39m.\u001b[39mget((outer_label, n), \u001b[39mNone\u001b[39;00m) \u001b[39mfor\u001b[39;00m n \u001b[39min\u001b[39;00m nsides]    \n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=9'>10</a>\u001b[0m     \u001b[39mreturn\u001b[39;00m np\u001b[39m.\u001b[39marray([r\u001b[39m.\u001b[39mbest \u001b[39mif\u001b[39;00m r \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m np\u001b[39m.\u001b[39mnan \u001b[39mfor\u001b[39;00m r \u001b[39min\u001b[39;00m res])\n",
+      "\u001b[1;32m/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb Cell 21\u001b[0m line \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=7'>8</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_res\u001b[39m(t, method):\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=8'>9</a>\u001b[0m     res \u001b[39m=\u001b[39m [t[method]\u001b[39m.\u001b[39mget((outer_label, n), \u001b[39mNone\u001b[39;00m) \u001b[39mfor\u001b[39;00m n \u001b[39min\u001b[39;00m nsides]    \n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bbridges/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb#X42sdnNjb2RlLXJlbW90ZQ%3D%3D?line=9'>10</a>\u001b[0m     \u001b[39mreturn\u001b[39;00m np\u001b[39m.\u001b[39marray([r\u001b[39m.\u001b[39mbest \u001b[39mif\u001b[39;00m r \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m np\u001b[39m.\u001b[39mnan \u001b[39mfor\u001b[39;00m r \u001b[39min\u001b[39;00m res])\n",
+      "\u001b[0;31mKeyError\u001b[0m: 'CuBLASChunkedLoop'"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABEAAAAJICAYAAABhfJEYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZ+0lEQVR4nO3dX6jl91nv8c/TjFGotQVnDkhmYgJOrXN6hPZscnrohYX2yCQXMxf+IQNFK6FzcyKeYxEiSpV4VeUoCPHPiKVasDH2QjY4EkFTCmJKdqmGJiUyRE8zUchYc3JT2phznnOxl7K7nZm9Zu+19+z99PWCgfX7re9e67n5smfe81u/Vd0dAAAAgMnedLsHAAAAANhvAggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAw3o4BpKo+XlWvVNUXb/B8VdWvV9WVqnq2qt69+jEBAAAAdm+ZK0A+keTsTZ6/P8npxZ+LSX5z72MBAAAArM6OAaS7P5vkn2+y5HyS3+9NTyd5W1V916oGBAAAANirVdwD5K4kL205vro4BwAAAHAoHDvIN6uqi9n8mEze/OY3/+d3vOMdB/n2AAAAwBH2+c9//p+6+8RufnYVAeTlJKe2HJ9cnPt3uvtSkktJsra21hsbGyt4ewAAAOCbQVX9793+7Co+ArOe5McW3wbzniSvdfc/ruB1AQAAAFZixytAqupTSd6X5HhVXU3yC0m+JUm6+7eSXE7yQJIrSb6a5Cf2a1gAAACA3dgxgHT3hR2e7yT/fWUTAQAAAKzYKj4CAwAAAHCoCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjCSAAAADAeAIIAAAAMJ4AAgAAAIwngAAAAADjLRVAqupsVb1QVVeq6pHrPH93VT1VVV+oqmer6oHVjwoAAACwOzsGkKq6I8ljSe5PcibJhao6s23Zzyd5orvfleTBJL+x6kEBAAAAdmuZK0DuS3Klu1/s7teTPJ7k/LY1neQ7Fo/fmuQfVjciAAAAwN4cW2LNXUle2nJ8Ncl/2bbmF5P8WVX9ZJI3J/nASqYDAAAAWIFV3QT1QpJPdPfJJA8k+WRV/bvXrqqLVbVRVRvXrl1b0VsDAAAA3NwyAeTlJKe2HJ9cnNvqoSRPJEl3/1WSb0tyfPsLdfel7l7r7rUTJ07sbmIAAACAW7RMAHkmyemqureq7szmTU7Xt635cpL3J0lVfV82A4hLPAAAAIBDYccA0t1vJHk4yZNJvpTNb3t5rqoerapzi2UfSfLhqvqbJJ9K8qHu7v0aGgAAAOBWLHMT1HT35SSXt5376JbHzyd572pHAwAAAFiNVd0EFQAAAODQEkAAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGE0AAAACA8QQQAAAAYDwBBAAAABhPAAEAAADGWyqAVNXZqnqhqq5U1SM3WPOjVfV8VT1XVX+w2jEBAAAAdu/YTguq6o4kjyX5b0muJnmmqta7+/kta04n+dkk7+3uV6vqP+zXwAAAAAC3apkrQO5LcqW7X+zu15M8nuT8tjUfTvJYd7+aJN39ymrHBAAAANi9ZQLIXUle2nJ8dXFuq7cneXtV/WVVPV1VZ6/3QlV1sao2qmrj2rVru5sYAAAA4Bat6iaox5KcTvK+JBeS/E5VvW37ou6+1N1r3b124sSJFb01AAAAwM0tE0BeTnJqy/HJxbmtriZZ7+5/6e6/S/K32QwiAAAAALfdMgHkmSSnq+reqrozyYNJ1ret+eNsXv2RqjqezY/EvLi6MQEAAAB2b8cA0t1vJHk4yZNJvpTkie5+rqoerapzi2VPJvlKVT2f5KkkP9PdX9mvoQEAAABuRXX3bXnjtbW13tjYuC3vDQAAABw9VfX57l7bzc+u6iaoAAAAAIeWAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADCeAAIAAACMJ4AAAAAA4wkgAAAAwHgCCAAAADDeUgGkqs5W1QtVdaWqHrnJuh+qqq6qtdWNCAAAALA3OwaQqrojyWNJ7k9yJsmFqjpznXVvSfJTST636iEBAAAA9mKZK0DuS3Klu1/s7teTPJ7k/HXW/VKSjyX52grnAwAAANizZQLIXUle2nJ8dXHu31TVu5Oc6u4/udkLVdXFqtqoqo1r167d8rAAAAAAu7Hnm6BW1ZuS/GqSj+y0trsvdfdad6+dOHFir28NAAAAsJRlAsjLSU5tOT65OPev3pLknUk+U1V/n+Q9SdbdCBUAAAA4LJYJIM8kOV1V91bVnUkeTLL+r09292vdfby77+nue5I8neRcd2/sy8QAAAAAt2jHANLdbyR5OMmTSb6U5Inufq6qHq2qc/s9IAAAAMBeHVtmUXdfTnJ527mP3mDt+/Y+FgAAAMDq7PkmqAAAAACHnQACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4SwWQqjpbVS9U1ZWqeuQ6z/90VT1fVc9W1Z9X1XevflQAAACA3dkxgFTVHUkeS3J/kjNJLlTVmW3LvpBkrbu/P8mnk/zyqgcFAAAA2K1lrgC5L8mV7n6xu19P8niS81sXdPdT3f3VxeHTSU6udkwAAACA3VsmgNyV5KUtx1cX527koSR/upehAAAAAFbp2CpfrKo+mGQtyQ/c4PmLSS4myd13373KtwYAAAC4oWWuAHk5yaktxycX575BVX0gyc8lOdfdX7/eC3X3pe5e6+61EydO7GZeAAAAgFu2TAB5Jsnpqrq3qu5M8mCS9a0LqupdSX47m/HjldWPCQAAALB7OwaQ7n4jycNJnkzypSRPdPdzVfVoVZ1bLPuVJN+e5I+q6q+rav0GLwcAAABw4Ja6B0h3X05yedu5j255/IEVzwUAAACwMst8BAYAAADgSBNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxhNAAAAAgPEEEAAAAGA8AQQAAAAYTwABAAAAxlsqgFTV2ap6oaquVNUj13n+W6vqDxfPf66q7ln5pAAAAAC7tGMAqao7kjyW5P4kZ5JcqKoz25Y9lOTV7v6eJL+W5GOrHhQAAABgt5a5AuS+JFe6+8Xufj3J40nOb1tzPsnvLR5/Osn7q6pWNyYAAADA7i0TQO5K8tKW46uLc9dd091vJHktyXeuYkAAAACAvTp2kG9WVReTXFwcfr2qvniQ7w/DHE/yT7d7CDii7B/YG3sI9sYegt373t3+4DIB5OUkp7Ycn1ycu96aq1V1LMlbk3xl+wt196Ukl5Kkqja6e203QwP2EOyF/QN7Yw/B3thDsHtVtbHbn13mIzDPJDldVfdW1Z1JHkyyvm3NepIfXzz+4SR/0d2926EAAAAAVmnHK0C6+42qejjJk0nuSPLx7n6uqh5NstHd60l+N8knq+pKkn/OZiQBAAAAOBSWugdId19OcnnbuY9uefy1JD9yi+996RbXA9/IHoLds39gb+wh2Bt7CHZv1/unfFIFAAAAmG6Ze4AAAAAAHGn7HkCq6mxVvVBVV6rqkes8/61V9YeL5z9XVffs90xwVCyxf366qp6vqmer6s+r6rtvx5xwWO20h7as+6Gq6qpyR37YYpk9VFU/uvhd9FxV/cFBzwiH1RJ/j7u7qp6qqi8s/i73wO2YEw6jqvp4Vb1SVV+8wfNVVb++2F/PVtW7l3ndfQ0gVXVHkseS3J/kTJILVXVm27KHkrza3d+T5NeSfGw/Z4KjYsn984Uka939/Uk+neSXD3ZKOLyW3EOpqrck+akknzvYCeFwW2YPVdXpJD+b5L3d/R+T/I+DnhMOoyV/B/18kie6+13Z/BKJ3zjYKeFQ+0SSszd5/v4kpxd/Lib5zWVedL+vALkvyZXufrG7X0/yeJLz29acT/J7i8efTvL+qqp9nguOgh33T3c/1d1fXRw+neTkAc8Ih9kyv4OS5JeyGd+/dpDDwRGwzB76cJLHuvvVJOnuVw54Rjisltk/neQ7Fo/fmuQfDnA+ONS6+7PZ/IbZGzmf5Pd709NJ3lZV37XT6+53ALkryUtbjq8uzl13TXe/keS1JN+5z3PBUbDM/tnqoSR/uq8TwdGy4x5aXC55qrv/5CAHgyNimd9Db0/y9qr6y6p6uqpu9r918M1kmf3zi0k+WFVXs/mNmz95MKPBCLf6b6UkS34NLnC4VdUHk6wl+YHbPQscFVX1piS/muRDt3kUOMqOZfPy4/dl8yrEz1bVf+ru/3M7h4Ij4kKST3T3/6qq/5rkk1X1zu7+f7d7MJhqv68AeTnJqS3HJxfnrrumqo5l8/Kvr+zzXHAULLN/UlUfSPJzSc5199cPaDY4CnbaQ29J8s4kn6mqv0/yniTrboQK/2aZ30NXk6x39790998l+dtsBhH4ZrfM/nkoyRNJ0t1/leTbkhw/kOng6Fvq30rb7XcAeSbJ6aq6t6ruzObNfda3rVlP8uOLxz+c5C+6u/d5LjgKdtw/VfWuJL+dzfjhc9fwjW66h7r7te4+3t33dPc92byPzrnu3rg948Khs8zf4/44m1d/pKqOZ/MjMS8e4IxwWC2zf76c5P1JUlXfl80Acu1Ap4Sjaz3Jjy2+DeY9SV7r7n/c6Yf29SMw3f1GVT2c5MkkdyT5eHc/V1WPJtno7vUkv5vNy72uZPMmJw/u50xwVCy5f34lybcn+aPFvYO/3N3nbtvQcIgsuYeAG1hyDz2Z5Aer6vkk/zfJz3S3K3n5prfk/vlIkt+pqv+ZzRuifsh/BMOmqvpUNgP78cV9cn4hybckSXf/Vjbvm/NAkitJvprkJ5Z6XXsMAAAAmG6/PwIDAAAAcNsJIAAAAMB4AggAAAAwngACAAAAjCeAAAAAAOMJIAAAAMB4AggAAAAwngACAAAAjPf/AYiFrfVpG03qAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1080x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plot_comparison(redundant_single_row, redundant_single_col, 3)\n",
+    "plt.title(\"Row / Column Major Ordering, Redundant\")\n",
+    "plt.axhline(1.0, linestyle='--', color='k')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43edc168",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "hera-gpu",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  },
+  "latex_envs": {
+   "LaTeX_envs_menu_present": true,
+   "autoclose": true,
+   "autocomplete": false,
+   "bibliofile": "biblio.bib",
+   "cite_by": "apalike",
+   "current_citInitial": 1,
+   "eqLabelWithNumbers": true,
+   "eqNumInitial": 1,
+   "hotkeys": {
+    "equation": "Ctrl-E",
+    "itemize": "Ctrl-I"
+   },
+   "labels_anchors": false,
+   "latex_user_defs": false,
+   "report_style_numbering": false,
+   "user_envs_cfg": false
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/vis_cpu/gpu.py b/src/vis_cpu/gpu.py
index 234e400..608a9a7 100644
--- a/src/vis_cpu/gpu.py
+++ b/src/vis_cpu/gpu.py
@@ -426,7 +426,7 @@ def vis_gpu(
                     f"Using {block} = {np.prod(block)} threads in total, in a grid of {grid}, "
                     "for measurement equation."
                 )
-
+                
             meas_eq(
                 A_gpu,
                 Isqrt_lim_gpu,
@@ -441,6 +441,16 @@ def vis_gpu(
             )
             event["meas_eq"].record(stream)
 
+            if t==0:
+                # FOR DEBUGGING, write stuff to file
+                _a = np.zeros(A_gpu.shape[:-1] + (len(Isqrt),), dtype=complex_dtype)
+                _a[..., above_horizon] = A_gpu.get()
+                np.save(f"t0_f{freq}_sky.npy", Isqrt*_a)
+
+                vcpu = np.zeros((nfeed, nant, nax , nsrc), dtype=complex_dtype)
+                vcpu[..., above_horizon] = v_gpu.get().reshape((nfeed, nant, nax, nsrcs_up))
+                np.save(f"t0_f{freq}_v.npy", vcpu)
+
             _logdebug(v_gpu, "vant")
 
             # compute vis = dot(v, v.T)