diff --git a/src/KOKKOS/modify_kokkos.cpp b/src/KOKKOS/modify_kokkos.cpp
index b4a89c8e3..c9242f211 100644
--- a/src/KOKKOS/modify_kokkos.cpp
+++ b/src/KOKKOS/modify_kokkos.cpp
@@ -1,721 +1,761 @@
 /* ----------------------------------------------------------------------
    LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
    http://lammps.sandia.gov, Sandia National Laboratories
    Steve Plimpton, sjplimp@sandia.gov
 
    Copyright (2003) Sandia Corporation.  Under the terms of Contract
    DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
    certain rights in this software.  This software is distributed under
    the GNU General Public License.
 
    See the README file in the top-level LAMMPS directory.
 ------------------------------------------------------------------------- */
 
 #include "modify_kokkos.h"
 #include "atom_kokkos.h"
 #include "update.h"
 #include "fix.h"
 #include "compute.h"
 #include "kokkos.h"
 
 using namespace LAMMPS_NS;
 
 #define BIG 1.0e20
 
 /* ---------------------------------------------------------------------- */
 
 ModifyKokkos::ModifyKokkos(LAMMPS *lmp) : Modify(lmp)
 {
   atomKK = (AtomKokkos *) atom;
 }
 
 /* ----------------------------------------------------------------------
    setup for run, calls setup() of all fixes and computes
    called from Verlet, RESPA, Min
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::setup(int vflag)
 {
   // compute setup needs to come before fix setup
   // b/c NH fixes need use DOF of temperature computes
 
   for (int i = 0; i < ncompute; i++) compute[i]->setup();
 
   if (update->whichflag == 1)
     for (int i = 0; i < nfix; i++) {
       atomKK->sync(fix[i]->execution_space,fix[i]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[i]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[i]->setup(vflag);
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[i]->execution_space,fix[i]->datamask_modify);
     }
   else if (update->whichflag == 2)
     for (int i = 0; i < nfix; i++) {
       atomKK->sync(fix[i]->execution_space,fix[i]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[i]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[i]->min_setup(vflag);
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[i]->execution_space,fix[i]->datamask_modify);
     }
 }
 
 /* ----------------------------------------------------------------------
    setup pre_exchange call, only for fixes that define pre_exchange
    called from Verlet, RESPA, Min, and WriteRestart with whichflag = 0
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::setup_pre_exchange()
 {
   if (update->whichflag <= 1)
     for (int i = 0; i < n_pre_exchange; i++) {
       atomKK->sync(fix[list_pre_exchange[i]]->execution_space,
                    fix[list_pre_exchange[i]]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[list_pre_exchange[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[list_pre_exchange[i]]->setup_pre_exchange();
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[list_pre_exchange[i]]->execution_space,
                        fix[list_pre_exchange[i]]->datamask_modify);
     }
   else if (update->whichflag == 2)
     for (int i = 0; i < n_min_pre_exchange; i++) {
       atomKK->sync(fix[list_min_pre_exchange[i]]->execution_space,
                    fix[list_min_pre_exchange[i]]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[list_min_pre_exchange[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[list_min_pre_exchange[i]]->setup_pre_exchange();
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[list_min_pre_exchange[i]]->execution_space,
                        fix[list_min_pre_exchange[i]]->datamask_modify);
     }
 }
 
 /* ----------------------------------------------------------------------
    setup pre_neighbor call, only for fixes that define pre_neighbor
    called from Verlet, RESPA
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::setup_pre_neighbor()
 {
   if (update->whichflag == 1)
     for (int i = 0; i < n_pre_neighbor; i++) {
       atomKK->sync(fix[list_pre_neighbor[i]]->execution_space,
                    fix[list_pre_neighbor[i]]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[list_pre_neighbor[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[list_pre_neighbor[i]]->setup_pre_neighbor();
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[list_pre_neighbor[i]]->execution_space,
                        fix[list_pre_neighbor[i]]->datamask_modify);
     }
   else if (update->whichflag == 2)
     for (int i = 0; i < n_min_pre_neighbor; i++) {
       atomKK->sync(fix[list_min_pre_neighbor[i]]->execution_space,
                    fix[list_min_pre_neighbor[i]]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[list_min_pre_neighbor[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[list_min_pre_neighbor[i]]->setup_pre_neighbor();
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[list_min_pre_neighbor[i]]->execution_space,
                        fix[list_min_pre_neighbor[i]]->datamask_modify);
     }
 }
 
 /* ----------------------------------------------------------------------
    setup pre_force call, only for fixes that define pre_force
    called from Verlet, RESPA, Min
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::setup_pre_force(int vflag)
 {
   if (update->whichflag == 1)
     for (int i = 0; i < n_pre_force; i++) {
       atomKK->sync(fix[list_pre_force[i]]->execution_space,
                    fix[list_pre_force[i]]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[list_pre_force[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[list_pre_force[i]]->setup_pre_force(vflag);
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[list_pre_force[i]]->execution_space,
                        fix[list_pre_force[i]]->datamask_modify);
     }
   else if (update->whichflag == 2)
     for (int i = 0; i < n_min_pre_force; i++) {
       atomKK->sync(fix[list_min_pre_force[i]]->execution_space,
                    fix[list_min_pre_force[i]]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[list_min_pre_force[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[list_min_pre_force[i]]->setup_pre_force(vflag);
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[list_min_pre_force[i]]->execution_space,
                        fix[list_min_pre_force[i]]->datamask_modify);
     }
 }
 
 /* ----------------------------------------------------------------------
    setup pre_reverse call, only for fixes that define pre_reverse
    called from Verlet, RESPA, Min
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::setup_pre_reverse(int eflag, int vflag)
 {
   if (update->whichflag == 1)
     for (int i = 0; i < n_pre_reverse; i++) {
       atomKK->sync(fix[list_pre_reverse[i]]->execution_space,
                    fix[list_pre_reverse[i]]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[list_pre_reverse[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[list_pre_reverse[i]]->setup_pre_reverse(eflag,vflag);
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[list_pre_reverse[i]]->execution_space,
                        fix[list_pre_reverse[i]]->datamask_modify);
     }
   else if (update->whichflag == 2)
     for (int i = 0; i < n_min_pre_reverse; i++) {
       atomKK->sync(fix[list_min_pre_reverse[i]]->execution_space,
                    fix[list_min_pre_reverse[i]]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[list_min_pre_reverse[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[list_min_pre_reverse[i]]->setup_pre_reverse(eflag,vflag);
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[list_min_pre_reverse[i]]->execution_space,
                        fix[list_min_pre_reverse[i]]->datamask_modify);
     }
 }
 
 /* ----------------------------------------------------------------------
    1st half of integrate call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::initial_integrate(int vflag)
 {
   for (int i = 0; i < n_initial_integrate; i++) {
     atomKK->sync(fix[list_initial_integrate[i]]->execution_space,
                  fix[list_initial_integrate[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_initial_integrate[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_initial_integrate[i]]->initial_integrate(vflag);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_initial_integrate[i]]->execution_space,
                      fix[list_initial_integrate[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    post_integrate call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::post_integrate()
 {
   for (int i = 0; i < n_post_integrate; i++) {
     atomKK->sync(fix[list_post_integrate[i]]->execution_space,
                  fix[list_post_integrate[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_post_integrate[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_post_integrate[i]]->post_integrate();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_post_integrate[i]]->execution_space,
                      fix[list_post_integrate[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    pre_exchange call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::pre_exchange()
 {
   for (int i = 0; i < n_pre_exchange; i++) {
     atomKK->sync(fix[list_pre_exchange[i]]->execution_space,
                  fix[list_pre_exchange[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_pre_exchange[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_pre_exchange[i]]->pre_exchange();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_pre_exchange[i]]->execution_space,
                      fix[list_pre_exchange[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    pre_neighbor call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::pre_neighbor()
 {
   for (int i = 0; i < n_pre_neighbor; i++) {
     atomKK->sync(fix[list_pre_neighbor[i]]->execution_space,
                  fix[list_pre_neighbor[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_pre_neighbor[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_pre_neighbor[i]]->pre_neighbor();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_pre_neighbor[i]]->execution_space,
                      fix[list_pre_neighbor[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    pre_force call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::pre_force(int vflag)
 {
   for (int i = 0; i < n_pre_force; i++) {
     atomKK->sync(fix[list_pre_force[i]]->execution_space,
                  fix[list_pre_force[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_pre_force[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_pre_force[i]]->pre_force(vflag);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_pre_force[i]]->execution_space,
                      fix[list_pre_force[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    pre_reverse call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::pre_reverse(int eflag, int vflag)
 {
   for (int i = 0; i < n_pre_reverse; i++) {
     atomKK->sync(fix[list_pre_reverse[i]]->execution_space,
                  fix[list_pre_reverse[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_pre_reverse[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_pre_reverse[i]]->pre_reverse(eflag,vflag);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_pre_reverse[i]]->execution_space,
                      fix[list_pre_reverse[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    post_force call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::post_force(int vflag)
 {
   for (int i = 0; i < n_post_force; i++) {
     atomKK->sync(fix[list_post_force[i]]->execution_space,
                  fix[list_post_force[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_post_force[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_post_force[i]]->post_force(vflag);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_post_force[i]]->execution_space,
                      fix[list_post_force[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    2nd half of integrate call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::final_integrate()
 {
   for (int i = 0; i < n_final_integrate; i++) {
     atomKK->sync(fix[list_final_integrate[i]]->execution_space,
                  fix[list_final_integrate[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_final_integrate[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_final_integrate[i]]->final_integrate();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_final_integrate[i]]->execution_space,
                      fix[list_final_integrate[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    end-of-timestep call, only for relevant fixes
    only call fix->end_of_step() on timesteps that are multiples of nevery
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::end_of_step()
 {
   for (int i = 0; i < n_end_of_step; i++)
     if (update->ntimestep % end_of_step_every[i] == 0) {
       atomKK->sync(fix[list_end_of_step[i]]->execution_space,
                    fix[list_end_of_step[i]]->datamask_read);
+      int prev_auto_sync = lmp->kokkos->auto_sync;
       if (!fix[list_end_of_step[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
       fix[list_end_of_step[i]]->end_of_step();
-      lmp->kokkos->auto_sync = 0;
+      lmp->kokkos->auto_sync = prev_auto_sync;
       atomKK->modified(fix[list_end_of_step[i]]->execution_space,
                        fix[list_end_of_step[i]]->datamask_modify);
     }
 }
 
 /* ----------------------------------------------------------------------
    thermo energy call, only for relevant fixes
    called by Thermo class
    compute_scalar() is fix call to return energy
 ------------------------------------------------------------------------- */
 
 double ModifyKokkos::thermo_energy()
 {
   double energy = 0.0;
   for (int i = 0; i < n_thermo_energy; i++) {
     atomKK->sync(fix[list_thermo_energy[i]]->execution_space,
                  fix[list_thermo_energy[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_thermo_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     energy += fix[list_thermo_energy[i]]->compute_scalar();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_thermo_energy[i]]->execution_space,
                      fix[list_thermo_energy[i]]->datamask_modify);
   }
   return energy;
 }
 
 /* ----------------------------------------------------------------------
    post_run call
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::post_run()
 {
   for (int i = 0; i < nfix; i++) {
     atomKK->sync(fix[i]->execution_space,
                  fix[i]->datamask_read);
     fix[i]->post_run();
     atomKK->modified(fix[i]->execution_space,
                      fix[i]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    setup rRESPA pre_force call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::setup_pre_force_respa(int vflag, int ilevel)
 {
   for (int i = 0; i < n_pre_force; i++) {
     atomKK->sync(fix[list_pre_force[i]]->execution_space,
                  fix[list_pre_force[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_pre_force[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_pre_force[i]]->setup_pre_force_respa(vflag,ilevel);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_pre_force[i]]->execution_space,
                      fix[list_pre_force[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    1st half of rRESPA integrate call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::initial_integrate_respa(int vflag, int ilevel, int iloop)
 {
   for (int i = 0; i < n_initial_integrate_respa; i++) {
     atomKK->sync(fix[list_initial_integrate_respa[i]]->execution_space,
                  fix[list_initial_integrate_respa[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_initial_integrate_respa[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_initial_integrate_respa[i]]->
       initial_integrate_respa(vflag,ilevel,iloop);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_initial_integrate_respa[i]]->execution_space,
                      fix[list_initial_integrate_respa[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    rRESPA post_integrate call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::post_integrate_respa(int ilevel, int iloop)
 {
   for (int i = 0; i < n_post_integrate_respa; i++) {
     atomKK->sync(fix[list_post_integrate_respa[i]]->execution_space,
                  fix[list_post_integrate_respa[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_post_integrate_respa[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_post_integrate_respa[i]]->post_integrate_respa(ilevel,iloop);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_post_integrate_respa[i]]->execution_space,
                      fix[list_post_integrate_respa[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    rRESPA pre_force call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::pre_force_respa(int vflag, int ilevel, int iloop)
 {
   for (int i = 0; i < n_pre_force_respa; i++) {
     atomKK->sync(fix[list_pre_force_respa[i]]->execution_space,
                  fix[list_pre_force_respa[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_pre_force_respa[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_pre_force_respa[i]]->pre_force_respa(vflag,ilevel,iloop);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_pre_force_respa[i]]->execution_space,
                      fix[list_pre_force_respa[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    rRESPA post_force call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::post_force_respa(int vflag, int ilevel, int iloop)
 {
   for (int i = 0; i < n_post_force_respa; i++) {
     atomKK->sync(fix[list_post_force_respa[i]]->execution_space,
                  fix[list_post_force_respa[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_post_force_respa[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_post_force_respa[i]]->post_force_respa(vflag,ilevel,iloop);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_post_force_respa[i]]->execution_space,
                      fix[list_post_force_respa[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    2nd half of rRESPA integrate call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::final_integrate_respa(int ilevel, int iloop)
 {
   for (int i = 0; i < n_final_integrate_respa; i++) {
     atomKK->sync(fix[list_final_integrate_respa[i]]->execution_space,
                  fix[list_final_integrate_respa[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_final_integrate_respa[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_final_integrate_respa[i]]->final_integrate_respa(ilevel,iloop);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_final_integrate_respa[i]]->execution_space,
                      fix[list_final_integrate_respa[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    minimizer pre-exchange call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::min_pre_exchange()
 {
   for (int i = 0; i < n_min_pre_exchange; i++) {
     atomKK->sync(fix[list_min_pre_exchange[i]]->execution_space,
                  fix[list_min_pre_exchange[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_pre_exchange[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_min_pre_exchange[i]]->min_pre_exchange();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_pre_exchange[i]]->execution_space,
                      fix[list_min_pre_exchange[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    minimizer pre-neighbor call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::min_pre_neighbor()
 {
   for (int i = 0; i < n_min_pre_neighbor; i++) {
     atomKK->sync(fix[list_min_pre_neighbor[i]]->execution_space,
                  fix[list_min_pre_neighbor[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_pre_neighbor[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_min_pre_neighbor[i]]->min_pre_neighbor();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_pre_neighbor[i]]->execution_space,
                      fix[list_min_pre_neighbor[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    minimizer pre-force call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::min_pre_force(int vflag)
 {
   for (int i = 0; i < n_min_pre_force; i++) {
     atomKK->sync(fix[list_min_pre_force[i]]->execution_space,
                  fix[list_min_pre_force[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_pre_force[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_min_pre_force[i]]->min_pre_force(vflag);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_pre_force[i]]->execution_space,
                      fix[list_min_pre_force[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    minimizer pre-reverse call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::min_pre_reverse(int eflag, int vflag)
 {
   for (int i = 0; i < n_min_pre_reverse; i++) {
     atomKK->sync(fix[list_min_pre_reverse[i]]->execution_space,
                  fix[list_min_pre_reverse[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_pre_reverse[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_min_pre_reverse[i]]->min_pre_reverse(eflag,vflag);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_pre_reverse[i]]->execution_space,
                      fix[list_min_pre_reverse[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    minimizer force adjustment call, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::min_post_force(int vflag)
 {
   for (int i = 0; i < n_min_post_force; i++) {
     atomKK->sync(fix[list_min_post_force[i]]->execution_space,
                  fix[list_min_post_force[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_post_force[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_min_post_force[i]]->min_post_force(vflag);
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_post_force[i]]->execution_space,
                      fix[list_min_post_force[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    minimizer energy/force evaluation, only for relevant fixes
    return energy and forces on extra degrees of freedom
 ------------------------------------------------------------------------- */
 
 double ModifyKokkos::min_energy(double *fextra)
 {
   int ifix,index;
 
   index = 0;
   double eng = 0.0;
   for (int i = 0; i < n_min_energy; i++) {
     ifix = list_min_energy[i];
     atomKK->sync(fix[ifix]->execution_space,fix[ifix]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[ifix]->kokkosable) lmp->kokkos->auto_sync = 1;
     eng += fix[ifix]->min_energy(&fextra[index]);
     index += fix[ifix]->min_dof();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[ifix]->execution_space,fix[ifix]->datamask_modify);
   }
   return eng;
 }
 
 /* ----------------------------------------------------------------------
    store current state of extra dof, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::min_store()
 {
   for (int i = 0; i < n_min_energy; i++) {
     atomKK->sync(fix[list_min_energy[i]]->execution_space,
                  fix[list_min_energy[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_min_energy[i]]->min_store();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_energy[i]]->execution_space,
                      fix[list_min_energy[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    mange state of extra dof on a stack, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::min_clearstore()
 {
   for (int i = 0; i < n_min_energy; i++) {
     atomKK->sync(fix[list_min_energy[i]]->execution_space,
                  fix[list_min_energy[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_min_energy[i]]->min_clearstore();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_energy[i]]->execution_space,
                      fix[list_min_energy[i]]->datamask_modify);
   }
 }
 
 void ModifyKokkos::min_pushstore()
 {
   for (int i = 0; i < n_min_energy; i++) {
     atomKK->sync(fix[list_min_energy[i]]->execution_space,
                  fix[list_min_energy[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_min_energy[i]]->min_pushstore();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_energy[i]]->execution_space,
                      fix[list_min_energy[i]]->datamask_modify);
   }
 }
 
 void ModifyKokkos::min_popstore()
 {
   for (int i = 0; i < n_min_energy; i++) {
     atomKK->sync(fix[list_min_energy[i]]->execution_space,
                  fix[list_min_energy[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[list_min_energy[i]]->min_popstore();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_energy[i]]->execution_space,
                      fix[list_min_energy[i]]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    displace extra dof along vector hextra, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 void ModifyKokkos::min_step(double alpha, double *hextra)
 {
   int ifix,index;
 
   index = 0;
   for (int i = 0; i < n_min_energy; i++) {
     ifix = list_min_energy[i];
     atomKK->sync(fix[ifix]->execution_space,fix[ifix]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[ifix]->kokkosable) lmp->kokkos->auto_sync = 1;
     fix[ifix]->min_step(alpha,&hextra[index]);
     index += fix[ifix]->min_dof();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[ifix]->execution_space,fix[ifix]->datamask_modify);
   }
 }
 
 /* ----------------------------------------------------------------------
    compute max allowed step size along vector hextra, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 double ModifyKokkos::max_alpha(double *hextra)
 {
   int ifix,index;
 
   double alpha = BIG;
   index = 0;
   for (int i = 0; i < n_min_energy; i++) {
     ifix = list_min_energy[i];
     atomKK->sync(fix[ifix]->execution_space,fix[ifix]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[ifix]->kokkosable) lmp->kokkos->auto_sync = 1;
     double alpha_one = fix[ifix]->max_alpha(&hextra[index]);
     alpha = MIN(alpha,alpha_one);
     index += fix[ifix]->min_dof();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[ifix]->execution_space,fix[ifix]->datamask_modify);
   }
   return alpha;
 }
 
 /* ----------------------------------------------------------------------
    extract extra dof for minimization, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 int ModifyKokkos::min_dof()
 {
   int ndof = 0;
   for (int i = 0; i < n_min_energy; i++) {
     atomKK->sync(fix[list_min_energy[i]]->execution_space,
                  fix[list_min_energy[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     ndof += fix[list_min_energy[i]]->min_dof();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     atomKK->modified(fix[list_min_energy[i]]->execution_space,
                      fix[list_min_energy[i]]->datamask_modify);
   }
   return ndof;
 }
 
 /* ----------------------------------------------------------------------
    reset reference state of fix, only for relevant fixes
 ------------------------------------------------------------------------- */
 
 int ModifyKokkos::min_reset_ref()
 {
   int itmp,itmpall;
   itmpall = 0;
   for (int i = 0; i < n_min_energy; i++) {
     atomKK->sync(fix[list_min_energy[i]]->execution_space,
                  fix[list_min_energy[i]]->datamask_read);
+    int prev_auto_sync = lmp->kokkos->auto_sync;
     if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
     itmp = fix[list_min_energy[i]]->min_reset_ref();
-    lmp->kokkos->auto_sync = 0;
+    lmp->kokkos->auto_sync = prev_auto_sync;
     if (itmp) itmpall = 1;
     atomKK->modified(fix[list_min_energy[i]]->execution_space,
                      fix[list_min_energy[i]]->datamask_modify);
   }
   return itmpall;
 }