Fix native GPU with gap junctions via CPU fixed-step fallback

Gap/partrans models register nrnthread_vi_compute_, forcing host post-solve.
The hybrid GPU solve plus device→host sync_gap_after_voltage_update was
pulling stale device voltages over the host nrn_update_voltage result (0
spikes on nrntraub with use_gap=1). Add sync_gap_after_host_voltage_update
to push host voltages to device when post-solve ran on the host.

Full hybrid stepping still diverged on Traub; until device gap gather/scatter
is complete, dispatch the CPU fixed-step body when nrnthread_v_transfer_ is
registered so native GPU enable_gpu models with gaps match CPU rasters.

Add test/gjtests/test_par_gj_native_gpu.py comparing ggap voltages CPU vs
native GPU.

Author: nrnhines

src/neuron/gpu/fadvance_gpu.cpp

@@ -56,6 +56,7 @@ void fixed_step_thread(model_sorted_token const& cache_token,
     advance_first_half_time(nt);
     fixed_play_continuous(nth);
     sync_after_vecplay(nt);
+    bool const host_post_solve = nt.end > 0 && post_solve_needs_host_fallback(nt);
     if (nt.end > 0) {
         setup_tree_matrix(cache_token, nt);
         sync_matrix_to_device_before_solve(nt);
@@ -68,7 +69,7 @@ void fixed_step_thread(model_sorted_token const& cache_token,
                 nrn_solve(nth);
             }
         }
-        if (post_solve_needs_host_fallback(nt)) {
+        if (host_post_solve) {
             sync_rhs_to_host_after_solve(nt);
             {
                 nrn::Instrumentor::phase p("second-order-cur");
@@ -91,7 +92,14 @@ void fixed_step_thread(model_sorted_token const& cache_token,
     }
     if (nrnthread_v_transfer_) {
         if (nt.end > 0) {
-            sync_gap_after_voltage_update(nt);
+            if (host_post_solve) {
+                // Host nrn_update_voltage already updated vec_v; push to device and
+                // leave host voltages intact for partrans gather (device→host would
+                // overwrite with stale GPU state).
+                sync_gap_after_host_voltage_update(nt);
+            } else {
+                sync_gap_after_voltage_update(nt);
+            }
             if (nrnmpi_v_transfer_) {
                 (*nrnmpi_v_transfer_)();
             }

src/neuron/gpu/sync.cpp

@@ -168,4 +168,8 @@ void sync_gap_after_voltage_update(NrnThread& nt) {
     sync_node_voltages_to_host(nt);
 }
 
-}  // namespace neuron::gpu
+void sync_gap_after_host_voltage_update(NrnThread& nt) {
+    sync_node_voltages_to_device(nt);
+}
+
+}  // namespace neuron::gpu

src/neuron/gpu/sync.hpp

@@ -34,7 +34,10 @@ void sync_voltages_to_host_after_post_solve(NrnThread& nt);
 /** Pull fast_imem sav_rhs to host after GPU fast_imem (smaller than vec_rhs sync). */
 void sync_fast_imem_to_host_after_post_solve(NrnThread& nt);
 
-/** Ensure gap-junction source voltages are visible on host before MPI transfer. */
+/** Pull device post-solve voltages to host before gap gather (device post-solve path). */
 void sync_gap_after_voltage_update(NrnThread& nt);
 
-}  // namespace neuron::gpu
+/** Push host post-solve voltages to device before gap gather (host fallback path). */
+void sync_gap_after_host_voltage_update(NrnThread& nt);
+
+}  // namespace neuron::gpu

src/nrnoc/fadvance.cpp

@@ -482,7 +482,10 @@ static void nrn_fixed_step_group_thread(neuron::model_sorted_token const& cache_
 
 static void nrn_fixed_step_thread(neuron::model_sorted_token const& cache_token, NrnThread& nt) {
 #if defined(NRN_ENABLE_GPU)
-    if (neuron::gpu::enabled() && neuron::gpu::backend_native()) {
+    // Gap/partrans models use host post-solve (nrnthread_vi_compute_) and partrans
+    // gather/scatter on host; the full native GPU step is not yet consistent for that
+    // hybrid. Run the CPU fixed-step body until device gap staging is complete.
+    if (neuron::gpu::enabled() && neuron::gpu::backend_native() && !nrnthread_v_transfer_) {
         neuron::gpu::device_token const& dev = neuron::gpu::ensure_on_device(cache_token);
         neuron::gpu::fixed_step_thread(cache_token, dev, nt);
         return;

test/gjtests/record_par_gj_voltages.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""Record test_par_gj dend voltages to a .npy file. Args: native(0|1) output.npy"""
+import sys
+
+import numpy as np
+from neuron import h, gpu
+
+import test_par_gj as t
+
+native = bool(int(sys.argv[1]))
+out_path = sys.argv[2]
+
+pc = h.ParallelContext()
+t.mkcells(pc, 4)
+t.mkgjs(pc, 4)
+pc.setup_transfer()
+gpu.enable = native
+if native:
+    gpu.backend = "native"
+h.dt = 0.25
+pc.set_maxstep(10)
+h.finitialize(-65)
+pc.psolve(500)
+np.save(out_path, np.column_stack([v.to_python() for v in t.vrecs]))

test/gjtests/test_par_gj.py

@@ -188,4 +188,5 @@ def main():
     h.quit()
 
 
-main()
+if __name__ == "__main__":
+    main()

test/gjtests/test_par_gj_native_gpu.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Compare test_par_gj voltages: CPU vs native GPU (gap junctions)."""
+
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import numpy as np
+
+_SCRIPT = Path(__file__).resolve().parent
+_RECORD = _SCRIPT / "record_par_gj_voltages.py"
+
+
+def run(native: bool, out_path: Path):
+    subprocess.run(
+        [sys.executable, str(_RECORD), str(int(native)), str(out_path)],
+        cwd=_SCRIPT,
+        check=True,
+    )
+
+
+def main():
+    with tempfile.TemporaryDirectory() as tmp:
+        cpu_path = Path(tmp) / "cpu.npy"
+        gpu_path = Path(tmp) / "gpu.npy"
+        run(False, cpu_path)
+        run(True, gpu_path)
+        v_cpu = np.load(cpu_path)
+        v_gpu = np.load(gpu_path)
+        max_diff = float(np.max(np.abs(v_cpu - v_gpu)))
+        print("par_gj native_gpu max voltage diff:", max_diff)
+        if max_diff > 1e-6:
+            raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()