Large systems (>15000 atoms) re-sorted the PME atom grid every step,
skipping the step-counter amortization used for smaller systems. On
current GPUs the per-step sort is mostly wasted work, so re-sort every
2 steps instead. Smaller systems are unchanged. The sort only changes
charge-spread memory locality; results are identical up to floating-point
summation order.
* Make reference/CPU minimizer into a kernel
* Add per-platform support for GPU minimization
* Initial implementation of GPU minimization
* Fixes
* Increase robustness when initial gradient is huge
* Handle overflow leading to non-finite values gracefully
* Handle large forces in single precision more robustly
* Optimize kernels
* Fix kernel launch size
* Update banner years
* Don't create MinimizeKernel until first minimization requested
* Make some compile-time constants into kernel arguments
* Consolidate scale calculation kernel
* Condense alpha/beta reduction kernels using atomics
* Condense line search dot kernels with reductions
* Remove a download, and download grad norm separately
* Asynchronously check lbfgs convergence condition
* Restructure line search to avoid download waiting
* Start line search preemptively in case CPU evaluation is not needed
* In rare cases, constraint error might not decrease after one optimization round
* Better handling of unsupported 64-bit atomics, use FLT_MAX
* Pick gradient mode based on GPU vs. CPU evaluation
* Rework getDiff/getScale reduction, remove reduceBuffer
* Older CUDA might not like float hex literals
* Fix error in a comment
* API for querying devices
* CUDA and HIP implementations of getDevices()
* Fix test failures
* Fix test failures
* CUDA returns correct devices even if no context has been created
* Return a single device for Reference and CPU
* Fix CI failure
* Remove std::enable_if, warpRotateLeft is always used with TILE_SIZE
* Do not use built-in warpSize in constexpr contexts
Starting from ROCm 7 warpSize is no longer constexpr.
findInteractingBlocks.hip uses it for sizes of __shared__ arrays.
* Check if hipHostMallocNumaUser is allowed before using it
adaptFrictionPart1 is executed first, it reads randomForce and
segmentVelocity buffers before other kernels write them so they can
contain garbage after allocation (cuMemAlloc/hipMalloc/clCreateBuffer
do not clear allocated memory).
* Basic LCPO support
* Add basic test for LCPO from a prmtop file
* API for LCPOForce
* Started LCPO reference implementation
* Finished reference forces & test cases
* Use other test for finite difference since grid might have discontinuous forces
* Reference platform formatting
* Initial implementation of CPU platform
* Bugfixes
* More vectorization and improve neighbor list query speed
* Parallelize part of neighbor search
* Check box size for LCPO with periodic boundary conditions
* Fixes for updating parameters in context
* GBSAOBCForce doesn't use first & last indices for updates, so no need for this optimization here
* Changes to neighbor checking and optimization
* Fixes and minor changes
* Add global surface tension parameter
* Only process half of the pairs in the neighbor list
* Remove unnecessary checks
* Initial version of common platform implementation
* Asynchronously download neighbor list size
* Debugging
* Do pair precomputation in copyPairsToNeighborList
* Recompute interactions instead of scanning neighbor list in inner loop
* Condense position array before computations
* Also make neighbor count download asynchronous on device
* Fixes for kernel launching
* Topology-based LCPO parameter assignment
* Fixes, and use test system for LCPO with nucleic acids
* Always raise instead of warn when LCPO parameters can't be assigned
* Use Amber convention for phosphates
* Initial implementation of PythonForce
* Continuing implementation of PythonForce
* Tests for PythonForce
* Fix memory leaks
* Documentation for PythonForce
* Fixed incorrect return type
* Fix compilation error on Python older than 3.12
* Handle all dtypes
* Optimizations to PythonForce
* Optimized getPositions()
* Test all platforms
* Fix test failures
* Ensure that neighbor list is valid before solving for charges
* Add test with neighbor list that needs to be resized
* Try another approach to skip interactions for neighbor list generation only
* Increase CG error tolerance for test
* Initial implementation of C++ API
* Add kernel interface and information for API generation
* API updates for updating electrode parameters
* Add serialization proxy for ConstantPotentialForce
* Update file headers
* Add CG error tolerance and fix units on getCharges() return value
* Initial implementation of matrix solver
* Fixes and conjugate gradient solver
* Try to fix Linux and Windows builds
* Make sure charge constraint target is on total charge
* Restore handling of exceptions like NonbondedForce since they won't involve electrode atoms
* Ameliorate numerical instability in constrained conjugate gradient
* Fix uninitialized pointers, memory leak, and style
* Set CG tolerance units in Python API
* Test ConstantPotentialForce serialization
* Read/write ExceptionsUsePeriodicBoundaryConditions as bool
* Improve constrained conjugate gradient robustness to roundoff error accumulation
* Recompute matrix if electrode atoms move due to setPositions()
* Tolerance is now in gradient (potential) units again
* Add neutralizing background correction
* Add Python API tests
* Fixes for CG and nonbonded exceptions
* Add initial tests checking against existing NonbondedForce behavior
* Expand test suite and fix some implementation issues
* Add additional tests using larger reference system
* Add Gaussian test
* Finish test against reference computation
* CPU platform implementation
* Fixes for compilation on some platforms
* Fixes for constant potential with AVX/AVX2
* Test linking CPU PME library to constant potential test directly
* Older SWIG versions don't support Python set to C++ set conversion
* Add user guide entry
* Increase speed of reference test
* Conditional building constant potential CPU test is unreliable
* Debugging
* Miscellaneous fixes and improvements for CI
* Cache charges so solver will not run if system and coordinates have not changed
* Preconditioner flag, stability, and automatic detection improvements
* Add GPU platform-specific constant potential kernel classes
* PME and device-host I/O changes to support constant potential
* Initial common constant potential implementation
* Constant potential fixes:
* Fix preconditioner PME position/charge save/restore logic
* Fix reduction synchronization in constant potential solver kernels
* Add double-float accumulation for conjugate gradient solver when
double unsupported by hardware
* Improve conditioning of a test system, and make sure particles are in or
out of cutoff for consistency and ease of comparing between platforms
* Reorder guess charges for CG when atom reordering changes positions
* Remove PME queue for now
* Trying to debug optimized direct space derivative kernel
* Remove extraneous debugging lines
* Style updates; just make CPU preconditioner double precision
* Debugging updated optimized direct derivatives kernel for all but OpenCL CPU
* OpenCL CPU implementation of direct space derivatives, and cleanup
* Try to make test even shorter to not time out on CI
* Temporary - Debugging
* Debugging
* Debugging
* Debugging
* Debugging
* Remove debugging code and fix reduction synchronization
* Fix other reductions
* Debugging - are tests hanging or just slow on CI?
* Debugging
* Debugging
* Fix macro for case when double precision is available on hardware
* Remove changes for debugging again
* Try to improve matrix solver cache locality by uploading transpose
* Fixes for atom ordering and periodic images
* Can't rely on reorder listener for cell offset updates
* Test reducing number of contexts and timing for CI
* Debugging
* Remove timing code and revert debugging changes
* Matrix solver and plasma term optimizations
* Reduce CG solver kernel calls and downloads
* Don't read back convergence flag from global memory
* Update PME due to refactoring in master branch
* Faster matrix solver (1st step)
* Faster matrix solver for CUDA
* Faster matrix solver compatibility with non-CUDA platforms
* Matrix solver fixes
* Use warp shuffle reductions when possible
* Attempt to work around intermittent compiler crash in Intel CPU OpenCL
* Optimize CG solver kernel 1
* Rework CG solver so some kernels can use more than 1 block
* Don't run out of shared memory
* Asynchronously download convergence flag while clearing buffers
---------
Co-authored-by: Evan Pretti <pretti@sh03-17n15.int>
* Variable displacements based on particle positions
* set variable displacements when adding particles
* update documentation
* address compilation error in OpenMMFortranWrapper
* update python API tests
* fix stray 'and'
* addParticle() without arguments add a particle that is not displaced
* pack displacement particles into int4
* put back default displacement removed in error
* ATMForce interface with coordinate transformation objects
* revise variable displacement API
* documentation, formatting, serialization
* Fixed C and Fortran wrappers
* Fixed Python wrappers
* Fixed factory
* Sort files to ensure classes are listed in the correct order
* Converted APIUnits test to new ATMForce API
* write class name
* skip the documentation for forward declarations
* undo 9e91d0b since it does not fix the doc build
* remove temporary doc files for nested classes
* Clean away tabs
---------
Co-authored-by: Peter Eastman <peastman@stanford.edu>
* Began implementing QTBIntegrator
* Adaptation and deconvolution
* Continuing reference implementation
* Continuing to implement QTBIntegrator
* Use common thread pool
* More tests, documentation, and threading
* Fix segfault
* Serialize adapted friction when creating a State
* Beginning of GPU implementation
* Added missing files
* Bug fixes
* Fixed inverse FFT
* Continuing GPU implementation
* Checkpointing
* Bug fixes
* Test cases run faster
* Changes needed for latest main branch
* Minor optimizations
* Documentation
* Fixed atom reordering
* Added parahydrogen test case
* Workaround for bug in Microsoft's compiler
* Added a Python test
* Normalize kernel in deconvolution
* Minor documentation improvements
* Reference implementation of SymmetrySite
* Common implementation of SymmetrySite
* Removed duplicated code
* Serialization for SymmetrySite
* Fixed compilation error building C wrapper
* Added SymmetrySite to user guide
* Bug fix
* Added P21 test case
* Use fixed point spread charge on RDNA4 as it is faster
Even though RDNA4 (gfx12) has global_atomic_add_f32, micro-benchmarks and OpenMM benchmarks show
that it is very slow compared to global_atomic_add_u64.
* Add a workaround for fixed point gridSpreadCharge on RDNA4
Workaround for rare cases when few values of pmeGrid are very large and
incorrect. The cause is unknown. Why this workaround or other irrelevant
changes like printf help is also unknown.
* Add a workaround for infinite loop in computeNonbonded (HIP)
computeNonbonded hangs in some tests (without neighbor list).
Reproducible on ROCm 6.4 and 6.4.1 (maybe on older versions too) on various architectures (both CDNA and RDNA).
Affected tests: TestHipATMForce, TestHipMonteCarloBarostat, TestHipNonbondedForce, TestHipVirtualSites.
Disassembly shows that the compiler splits branches of `if (skipBase+tgx < NUM_TILES_WITH_EXCLUSIONS)` and does
`SHFL(skipTiles, TILE_SIZE-1) < pos` checks in them separately, even though `__builtin_amdgcn_ds_bpermute`
is a convergent function. Apparently in this case not all lanes participate in each call.
* Simplify includeTile check using ballot
