[PATCH] fix internal/external OpenMP thread affinity clash

Thread affinity set by the OpenMP library, either automatically or
requested by the user through environment variables, can conflict with
the mdrun internal affinity setting.
To avoid performance degradation, as Intel OpenMP has affinity setting
on by default, we will explicitly disable it unless the user manually
set OpenMP affinity through one of the KMP_AFFINITY or GOMP_CPU_AFFINITY
environment variables. If any of these variables is set, we honor the
externally set affinity and turn off the internal one.

Change-Id: I78c6347154d6f11695ee04243db17bbb2e5cb0a7


[PATCH] bugfix of set_coef introduced by
 c84cc28d1c5550876d2d648f905716ffa69335ef

The problem is that building the matrix from a set of triplets sums
the value provided in case several values at the same position are
provided. In order to overwrite a value, we have no other choice
than to build the matrix and set the value (with current Eigen API).
The following fix is as efficient if the matrix is assembled
in one pass. Using the boolean member of set_coef is very important now
as it can imply a premature building of the eigen matrix.


[PATCH] default to 1 thread, make the user manually specify the
 number of threads to avoid mpi/thread contention

git-svn-id: file:///Users/petejw/Documents/libmesh_svn_bak@2673 434f946d-2f3d-0410-ba4c-cb9f52fb0dbf


[PATCH] Don't construct perflog strings unless needed

Previously, if we disabled the perflog at runtime (rather than compile
time), it would *not* disable the implicit construction of C++
std::strings from C char* strings, which turns out to be the most
costly part of perf log operation.

We still need to rework this whole class for efficiency, but at the
very least it's now efficient when disabled.


[PATCH] Working on the umutual2b kernel, the tdipdip values are
 computed on the fly for now, maybe a seprate neigh list as in the CPU version
 will be more efficient


[PATCH] Add implementation of the mean squared error performance
 function.


[PATCH] Fast code now computes confidence bands


[PATCH] Set interior parent only when mesh contains multiple
 dimensions

This commit is to address the issues brought up in libMesh/libmesh/#709,
namely, handle ParallelMesh more appropriately by using
LIBMESH_BEST_UNORDERED_MAP and asserting when an element id is greater
than the maximum element id rather than the number of elements.  Also,
automatically setting the interior parent should occur when a mesh has
multiple dimensions and skipped when the mesh has only one dimension.

In order to utilize mesh.elem_dimensions(), which allows a user to
determine the dimensions of a mesh, the code to automatically set the
interior parent was moved into mesh_base.C as a separate method.  This
way mesh.cache_elem_dimensions() can be called prior to setting the
interior parents and thus mesh.elem_dimensions() will be available.

Also, the methods were moved prior to the partitioning in order to avoid
the complexities of one processor containing the interior parent of an
element on another processor.

Lastly, there is one noticeable performance penalty for moving the
automatic setting of the interior parents to a separate method and that
is populating the node_to_elem map which requires iterating through all
active elements.  Previously, the node_to_elem map was populated during
an existing element iteration inside find_neighbors().


[PATCH] Extend Force sub-counters

Need more data for understanding performance variation

Implemented subcounter "restart" and used it for accumulating
position-restraints time with FEP to the position-restraints
subcounter.

Noted TODOs for some future extensions not currently possible.

Also added logfile output from GMX_CYCLE_BARRIER where people
analyzing the performance will see it.

Refs #1686

Change-Id: I9d60d0a683f56549879bb739269e9466c96572c4


[PATCH] Replacing Mish and Derivative of Mish by Fast Mish and
 Derivative of Fast Mish resp.


[PATCH] moved performance fix for 7.30 compilers to FFLAGS


[PATCH] Made FAST OpenCL results match CUDA results


[PATCH] RJH: Inserted performance statistics into the SCF using
 pstat. RJH: File cscfps.fh contains the handles.


[PATCH] use problem-state pointer to write SPE mailbox with lower
 latency (makes a significant performance difference for N < 32k), thanks to
 Jan Wagner for suggestion [empty commit message]


[PATCH] Fix config for PERFORMANCE category build (#3632)

Some test executables have the default category (BASIC), so they
are not added in a build with "CATEGORIES PERFORMANCE". Check that
these executables exist before setting properties on them.


[PATCH] Add a barrier() to ~LibMeshInit

This didn't fix the bug I was trying to hunt down, and as best as I
can tell this won't fix any actual bugs (we'll be synchronizing at the
Finalize() calls later regardless), but it couldn't hurt to wait for
other processes to exit before we start spewing reference counter
and/or performance log data to the screen, lest other processes
console error messages get buried.


[PATCH] Updated article reference. Added configuration flags to
 support altivec on powerpc. Updated configuration files from gnu.org Removed
 the fast x86 truncation when double precision was used - it would just crash
 since the registers are 32bit only. Added powerpc altivec innerloop support
 to fnbf.c


[PATCH] Command-line override of default Metis-vs-Parmetis

Using Parmetis for ReplicatedMesh doesn't seem to make any difference in
performance on our benchmark set.


[PATCH] Modified some of the tests so that they run reasonably fast
 through Insure++.


[PATCH] Add IntRange helper class

This seems to be the tersest efficient way to iterate over a range of
integers, and since there are quite a few libMesh methods which take
local integer indices, we still have to iterate over those indices
quite often.


[PATCH] After merging pmatrix-dev, at least one thing got broken:
 ParMesh::Print for AMR meshes. Since in pmatrix-dev, slave faces are no
 longer considered shared (their P rows are not needed by the processor owning
 the master face), they are also not printed when visualizing the parallel
 solution. I suspect this also might have broken NC face neighbors. This
 branch contains a temporary solution, a downgrade of
 ParNCMesh::AddMasterSlaveRanks, so that it works the old way: slave faces are
 grouped with the masters. This fixes visualization and maybe other things,
 but may negatively impact performance of (or even break) the P matrix
 construction. I need to look more into this to find a permanent solution.


[PATCH] tuned performance of script; added linked index


[PATCH] undo slow dgemm/skylake microoptimization

the compare is more costly than the work


[PATCH] SDG Linf fast insertion examples

Signed-off-by: Panagiotis Cheilaris <philaris@cs.ntua.gr>


[PATCH] JN:  Solaris uses now PTR_ALIGN for performance and
 compatibility with JN:  different compilers


[PATCH] Moved FAST description to docs directory.

Additionally indented FAST parameter documentation.


[PATCH] performance updates G_indx replaced with Pack_G_indx...EJB


[PATCH] HvD: In response to the development of a new ARMCI over MPI
 implementation I have updated the build_nwchem script and the tools
 GNUmakefile to be able to drive this target. This implementation goes by the
 name MPI_TS (short for MPI Two-Sided) as it eliminates the data-server and
 uses MPI two-sided communications to implement the ARMCI functionality. It is
 expected to be highly portable as it relies only on MPI. Trying the
 performance of this implementation will be interesting.

In all cases it is currently required to set the environment variable

    EXP_GA

any value for this variable will do. This variable is currently required because
the implementation lives in a separate branch of GA. In addition you need to
run get-tools with this environment variable set to pick up the correct GA
branch.

The build_nwchem script will under certain conditions automatically pick the
MPI_TS implementation up. However, it is safer to set

    ARMCI_NETWORK=MPI_TS

as that eliminates any guess work that might lead to a different result.

If you want to try this implementation, please go ahead, as I am sure the GA
team will value any feedback we provide.


[PATCH] Preload Tile Offsets (#1795)

Particularly for cloud storage backends, loading tile offsets is a performance
sensitive path. Sequential reads perform much better than random reads because
they make better use of the read-ahead cache. This patch aims to increase
the number of sequential reads when loading tile offsets.

Currently, tile offsets are loaded in the following path:
for each attribute:
  read_tiles
    parallel_for each fragment:
      load_tile_offsets
    parallel_for each fragment:
      load_var_tile_offsets

This patch refactors it to:
parallel_for each fragment:
  for each attribute:
    load_tile_offsets
    load_var_tile_offsets
for each attribute:
  read_tiles

By inverting the order in which we iterate fragments and attributes, we can
sort the attributes by their index in the fragment metadaa file. By loading
attributes in ascending order of their offsets, we ensure a sequential read
to maximum hits in the read-ahead cache.

Additionally, this defers loading var offsets until all fixed offsets have
been loaded. This is because the fixed offsets exist before the var size
offsets in the file format: https://github.com/TileDB-Inc/TileDB/blob/dev/format_spec/fragment.md

Most importantly, this is a pre-requisite to parallelizing the read_tiles()
for each attribute. When read_tiles are parallel, we can't control the order
that they are executed and therefore load tiles, which may reduce hits in
the read-ahead.

Co-authored-by: Joe Maley <joe@tiledb.com>


[PATCH] Fast forward porting work to master

Change-Id: Ieb428e4a001efadf880dbe2c64c2a685cebdd4ae


[PATCH] Add a "sgemm direct" mode for small matrixes

OpenBLAS has a fancy algorithm for copying the input data while laying
it out in a more CPU friendly memory layout.

This is great for large matrixes; the cost of the copy is easily
ammortized by the gains from the better memory layout.

But for small matrixes (on CPUs that can do efficient unaligned loads) this
copy can be a net loss.

This patch adds (for SKYLAKEX initially) a "sgemm direct" mode, that bypasses
the whole copy machinary for ALPHA=1/BETA=0/... standard arguments,
for small matrixes only.

What is small? For the non-threaded case this has been measured to be
in the M*N*K = 28 * 512 * 512 range, while in the threaded case it's
less, around M*N*K = 1 * 512 * 512


[PATCH] Fixes for QM/MM MdModule

Several fixes for problems found in QM/MM during beta1:

* Additional check for external input files
* Changed writing from `gmx::TextWriter` to `gmx::TextOutputFile` (`TextWriter` tries to format lines which is very slow in case of big files)
* Added QM/MM to highlights

Refs #3172


[PATCH] driver: more reasonable thread wait timeout on Windows.

It used to be 5ms, which might not be long enough in some cases for the
thread to exit well, but then when set to 5000 (5s), it would slow down
any program depending on OpenBlas.

Let's just set it to 50ms, which is at least 10 times longer than
originally, but still reasonable in case of failed thread termination.


[PATCH] Fix bonded atom communication performance

The filtering of atoms to communicate for bonded interactions that
are beyond the non-bonded cut-off was effectively missing, because
the home atom indices were not set. This lead to many more atoms
being communicated.

Change-Id: I4bd5b9b561a3077e055186f312939221dba6cefa


[PATCH] Fix code so that gradient is not wrapped into the box fast
 exit out of symmetry routines if C1


[PATCH 1/9] Update all versions to v1.1.1.


[PATCH] Restarted the hierarchical pca algorithm, now replaced with
 Vempala's fast SVD algorithm. Need to finish the subspace combining part...


[PATCH] Added DefaultInitializationAllocator

Added an allocator that can be used to default initialize elements
of a std::vector on resize(). This is useful to avoid initialization
in performance critical code.

Change-Id: I65bd52a760c68c73555e8bb9e017de353a6e9a81


[PATCH] Update CUDA Performance Tests for Stream interoperability


[PATCH] Added ODE diagnostics to FixRxKokkos using Kokkos managed
 data.

- Added the diagnostics performance analysis routine to FixRxKokkos
  using Kokkos views.
TODO:
  - Switch to using Kokkos data for the per-iteration scratch data.
    How to allocate only enouch for each work-unit and not all
    iterations? Can the shared-memory scratch memory work for this,
    even for large sizes?


[PATCH] all modules and domqtests.mpi fast [travis skip]


[PATCH] Fix RDTSCP handling

Commit 13def2872ae5311d tried to make all builds default to using
RDTSCP, which would have broken non-x86 builds. But it also
deactivated the implementation of RDTSCP support because HAVE_RDTSCP
was left undefined. So all it did was make timing on x86 less
efficient (plus e.g. DLB effects from that).

Used GMX_RDTSCP everywhere. Only the GROMACS project depends on
thread-MPI, so it's reasonable to let a GMX symbol leak in there (and
it's easily fixed if ever needed).


[PATCH] Add access to base kernel in Efficient RANSAC traits


[PATCH] Don't preallocate USMObjectMem

This might hurt performance in a bad case, should profile & check.


[PATCH] fixed slow memory reallocation, especially at the start of
 runs and for large xvg file by replacing the linear increment by a scaling
 with a factor of 1.19 and renamed the dd over_alloc to over_alloc_dd


[PATCH] Set cmake build to release for LZ4/Zlib and Zstd

This enables vectorization which yields a boost in performance
for these compressors. #1033

PR #1034

(cherry picked from commit 3db1195e2e8df48ca399b18d0250256443651bda)


[PATCH] Compile without debugging or profiling symbols by default
 (i.e. be fast unless the user asks otherwise).


[PATCH] Remove use of omp 5.0 feature

omp_init_lock_with_hint is an OpenMP 5.0 feature.
This is not significant from a performance perspective.


[PATCH] The Viewer declares if the current drawing is a fast draw or
 not.


[PATCH] new version of forward and adjoint jacobian calculation for
 SXFunction, ticket #127, still need an efficient way of calculating seed
 matrices


[PATCH] moved some test after fast exit [ci skip]


[PATCH] Convert nbnxn_pairlist_set_t to class PairlistSet

This change is only refactoring.
Two implementation details have changed:
The CPU and GPU pairlist objects are now straight lists instead
of array of pointer to lists. This means that the pairlist objects are
no longer allocated on their respecitive thtreads. But since the lists
have buffers to avoid cache polution and the actual i- and j-lists are
llocated thread local, this should not affect performance
ignificantly.
The free-energy lists are now only allocated with perturbed atoms.

Change-Id: Ifc76608215518edfc61c0ca8eb71ea2a928cf57c


[PATCH] threading test performance updates


[PATCH] Fast KDE is now using submodule for organizing parameters


[PATCH] fast exit out of symmetry routines if C1 No longer print "ok"
 on first geomtry step


[PATCH] AABB tree: enrich performance section with a summary (general
 comments and advices about how to put the tree at work with good
 performances). this is not exhaustive nor conclusive of course but I believe
 a documentation must also tell the obvious.


[PATCH] Add content to user guide

Converted sections on environment variables, mdrun features, mdrun
performance to reStructuredText.

Change-Id: I2a18528729dc6756be093e52e6f87f9df9fe3b94


[PATCH] Add debug output; don't adjust second bound. This provides
 another minor speedup, but this still is nowhere near as fast as it should be
 with a properly working Hamerly prune.


[PATCH] Remove non-backported entry from NEWS

We decided against this one after all, due to risk of side effects
outweighing the fixes to performance issues in some cases.


[PATCH] Disable DD again in serial with GPU or without PME

Performance is better without DD in most of those cases.

Refs #4195, #4198, #4171


[PATCH] VT: Added a few lines about performance tuning


[PATCH] Implement user guide

Renamed former user manual to reference manual.

The content for the new user guide has mostly migrated in from the
wiki, install guide, and mdrun -h, and updated as appropriate. This
guide is intended for documenting practical use, whereas the reference
manual should document algorithms and high-level implementations, etc.

Established references.md to do automatic linking of frequently
used things. This can be automatically concatenated by pandoc
onto any Markdown file to do easy link generation.

Section on mdrun and performance imported and enhanced from the
Acceleration and Parallelization wiki page.

Added section on mdrun features, e.g. rerun and multi-simulation.

Section on getting started imported from online/getting_started.html
and updated - there used to be a tutorial here, but there isn't any
more. Linked to more up-to-date tutorials.

Added TNG to docs/manual/files.tex.

Removed gmx options, now that its content is in the user guide (in
tools.md).

Moved old mdp_opt.html to docs/mdp-options.html, for now. Removed from
reference manual, left pointer to new location. This is not an ideal
format or location either, but it's a step closer to being able to
generate it from the code. Some trivial fixes to content. Generating
links and references to follow in a future commit.

Moved environment-variable section from reference manual to user guide.
Minor fixes here.

Removed superseded reference manual sections on running in parallel or
with GPUs. Renamed install.tex as technical-details.tex, because that
is all that is left there. Moved section on use of floating-point
precision to chapter on definitions and units, and thus eliminated the
former Appendix A.

Cross-references from user-guide.pdf don't work well yet, but that
should be dealt with when we decide on the final publishing platform.

Some TODO comments for documentation sections remain for work in
future patches, but please note the other new content in existing
child patches, so we don't duplicate any work.

Change-Id: I026d67353863ae069c6c45b840a61fcaf205a377


[PATCH] HvD: In order to get reasonable performance out of the
 automatic differentiation approach the compiler has to inline the various
 overloaded operators. If the compiler fails to do that performance
 degradation exceeding an order of magnitude has been observed. For the GNU
 compilers code inlining requires all the code to be present in a single
 source file. The compiler cannot inline code from a different file. Hence the
 NWAD code module must be included into the same source file as the density
 functional subroutines that use it. To do that we need a fixed format version
 of NWAD module (typically identified to the compiler with the .F extension
 rather than the .F90 extension for free format Fortran). This commit creates
 the appropriate file that will be converted from free format to fixed format.
 At a later stage the original nwad.F90 file can be deleted.


[PATCH] Adding rough drafts of fast tridiagonalization on square
 process grids.


[PATCH] initial caching of AO integrals for triples; SO integrals;
 performance measurement for the triples


[PATCH] I tried several things but it is still slow


[PATCH] ATW: Interim commit - new sparse packing and IO OK but slow


[PATCH] Read tiles: fixing preallocation size for var and validity
 buffers. (#2781)

Preallocation size for var buffer and validity buffer was not using the
correct size, which will have a performance impact.


[PATCH] HvD: Eliminating a strange way of evaluating rho^1/3. If this
 costs performance then a better way would be to evaluate rho^4/3 = rho^1/3 *
 rho.


[PATCH] Accelerate GMM test by reducing number of EM iterations.


[PATCH] JJU: performance test for put get and acc


[PATCH] Avoid confusing message at end of non-dynamical runs

EM, TPI, NM, etc. are not targets for performance optimization
so we will not write performance reports. This commit fixes
and oversight whereby we would warn a user when the lack of
performance report is normal and expected.

Fixes #2172

Change-Id: I1097304d79701be748612510572382729f7f26be


[PATCH] rearranged TRANSPOSED format, numerous speedups

Split the TRANSPOSED and non-TRANSPOSED rank-geq2 solvers, and changed
the DFT TRANSPOSED format to be more like fftw2 (both globally and
locally transposed).  In general, more emphasis on arranging the data
contiguously for the DFTs, and more flexibility in intermediate
transposed formats.  Also disable NO_SLOW when planning transposes,
since otherwise non-square in-place transposes gratuitously put the
planner in SLOW mode.

Currently, dft-rank1-bigvec has 5 variants (or 10, if DESTROY_INPUT).
It looks like only 2 of these are commonly used, so I should probably
add some UGLY tags once I do more benchmarking.


[PATCH] Allow to pop the context menu with `Key_Menu`

As the item selection is rather slow, for the moment, that is a lot
faster than `Shift+Rightbutton`.


[PATCH] Target haswell or AVX2 for prebuilt libraries

Prebuilt artifacts that we publish for releases will now target
`haswell` for linux and macos and `AVX2` for windows to allow for
greater compatibility while maintaining the performance of AVX
optimizations.


[PATCH] More extensive performance logging of the Kelly Error
 Estimator.


[PATCH] ODESolvers: Add support for efficient ODE solver resizing

Note: this reuses the existing storage rather than costly reallocation
which requires the initial allocation to be sufficient for the largest
size the ODE system might have.  Attempt to set a size larger than the
initial size is a fatal error.


[PATCH] Fix slow QuadratureFunction::GetElementValues when provided
 int pt


[PATCH] Add Edge4::volume().

This speeds up calling volume() on every element in a mesh with 4M
Edge4's by about 450x. Though I'm not sure this was ever going to be a
performance concern, I still want to have a custom volume()
implementation for all the different Elem types for completeness.

The 4-pt quadrature is also reasonably accurate.  The biggest
discrepancies seem to be introduced by perturbing the interior nodes
of the EDGE4. For example, perturbing an interior node of the
reference element by 0.125 in the y (or z) direction leads to a
relative error of much less than 1%, compared to a 12th-order (7-pt)
approximation of the volume.

Approximate volume  = 2.0412301724043291e+00
Verification volume = 2.0410437292661414e+00
Rel err             = 9.1346959163268581e-03%


[PATCH] Keep track of FE requests for mapping data

Before, if *only* mapping data was requested, we wouldn't realize that,
we would think that nothing had been requested, and we would calculate
all data at reinit(), for backwards compatibility.  This was making the
Elem::volume() fallback code too slow in the general case, and was
breaking it (due to unimplemented second derivatives) in the Rational
Bezier case.


[PATCH] Added test to log the performance of the periodic Delaunay
 triangulation


[PATCH] removed order natoms^2 loops which made grompp vsite stuff
 extremely slow for large systems


[PATCH] fem_system_ex2 local->distributed solution

There doesn't seem to be any way to get this behavior back in reinit()
without creating a performance regression: most applications simply
never need to move data in that direction.


[PATCH] fix a few performance drop in some matrix size per data type

Signed-off-by: Wang,Long <long1.wang@intel.com>


[PATCH] Refactor threading model (#1766)

* Refactor threading model

Removes:
- global_tp_ (the replacement TBB thread pool)
- StorageManager::async_thread_pool_
- StorageManager::reader_thread_pool_
- StorageManager::writer_thread_pool_
- VFS::thread_pool_

Adds:
- StorageManager::compute_tp_
- StorageManager::io_tp_

Usage changes:
1. Our three parallel functions (`parallel_sort`, `parallel_for[_2d]`) now use
   the `StorageManager::compute_tp_`.
2. Both the `Reader::read_tiles()` and `Writer::write_tiles()` now execute on
   `StorageManager::io_tp_`.
3. The VFS is now initalized with a thread pool, where the storage manager
   initializes it with the `StorageManager::io_tp_`. This means that both the
   VFS and Reader/Writer io paths execute on the same thread pool. There was
   previously a deadlock scenario if both used the same thread pool, but that
   is no longer an issue now that the threadpools are recursive.
4. The async queries are executed on `StorageManager::compute_tp_`.

Config changes:
- Adds configuration parameters for the compute and IO thread pool "concurrency
  levels". A level of "1" is serial execution while all other levels have a
  maximum concurrency of N but allocate N-1 OS threads.
- Deprecate the async/reader/writer/vfs thread num configurations. If any of
  these are set and larger than the new "sm.compute_concurrency_level" and
  "sm.io_concurrency_level", the old values will be used instead. The motiviation
  is so that existing users will not see a drop in performance if they are
  currently using larger-than-default values.

* Recursive ThreadPool::execute() (#1772)

Currently, we break recursive deadlock in the ThreadPool:wait*() routines. This
works well for the type of "execute-and-wait" model we use. For instance:
```
ThreadPool tp;
auto task = tp.execute(...);
tp.wait_all(task);
```

We are currently unable to break recursive deadlock if the threadpool user does
not use our "wait" routine. For instance:
```
condition_variable cv;
auto task = tp.execute([&]() {
  cv.signal_all();
});
cv.wait(...);
```

The S3 client uses the above style of synchronization. With our compute/io
threadpool refactor, we encounter recursive deadlock. This patch allows breaking
recursive deadlock on the call to ThreadPool::execute().

With this patch, ThreadPool::execute() checks if 1) the calling thread belongs
to the thread pool instance and 2) all other threads are non-idle.

Co-authored-by: Joe Maley <joe@tiledb.com>

Co-authored-by: Joe Maley <joe@tiledb.com>


[PATCH] Tightening default tolerances on the ADMM algorithms where
 possible (the linear program solver was kept the same due to its slow
 convergence rate).


[PATCH] Refactor the performance measurement system


[PATCH] replaced fr->solvent_opt by fr->cginfo, which also contains
 the energy group id and implemented efficient cg sorting with DD, which is
 now done at every DD decomposition


[PATCH] Added support for (arbitrary) high-order Nedelec finite
 element discretizations in AMS.

Seems to be working quite well on hex meshes and reasonably well on tet meshes,
correlating with the performance of BoomerAMG on the associated high-order nodal
problems.


[PATCH] gemini performance updates for strided gets; code in the
 ARMCI_Get/Put/Acc subroutines should be incorporated into the ARMCI_Nb
 equivalent routines


[PATCH] - Some clean-up - Function get_number_of_bad_elements in the
 mesher levels (for debugging) - option
 CGAL_MESH_3_ADD_OUTSIDE_POINTS_ON_A_FAR_SPHERE to reduce contention on the
 infinite vertex


[PATCH] Fix performance report when init_step!=0

Change-Id: Ia4e15c2fb9b0e3debe7fc7f2aa8a1cdf346f90cb


[PATCH] Added complex routines for blas lapack but they compile as a
 separate library so that it doesn't slow down applications that do not need
 complex routines


[PATCH] Adding Changelog for Release 3.4.01

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.4


[PATCH] add comment regarding OpenMP performance


[PATCH] fix for no performance logging

git-svn-id: file:///Users/petejw/Documents/libmesh_svn_bak@485 434f946d-2f3d-0410-ba4c-cb9f52fb0dbf


[PATCH] First cut at the performance statistics library


[PATCH] MKK: A new classic test case for matmul that give the
 performance numbers


[PATCH] Add an example to show how to debug performance with loggers.


[PATCH] added docu for efficient MVJ and restart modefor MVJ


[PATCH] Fix input ndims validation in fast,orb,sift


[PATCH] Simplify handling of DD bonded distances

To simplify and clarify the DD setup code, we now always always store
the systemInfo.minCutoffForMultiBody and use a separate flag to tell
if we should increase the cut-off distance for bonded communication.
There is a minor behavioral change in that with large domains and
bonded communication filtering or DLB, the bonded cut-off is now
5% of the bonded cut-off longer as the margin is now included.
This has a negligible effect on performance in all cases.

Change-Id: Id409353c517181ac56e8d3f1f36c22c705aa8077


[PATCH] Remove OpenMP from KOKKOS_DEVICES in Kokkos CUDA Makefiles
 since normally this doesn't improve performance


[PATCH] Fixed performance figures. TODO: new graphs


[PATCH] Fix memory alloc for fast opencl


[PATCH] Enable dynamic pair list pruning

This change activates the dynamic pruning scheme and the pruning
only kernels added in previous commits.
A heuristic estimate is used to select value for nstlist and
nstlistPrune that should result in performance that is reasonably
close to optimal. The nstlist increase code has been moved from
runner.cpp to nbnxn_tuning.cpp. The KNL check in that code has been
replaced by a check for Xeon Phi.
A paragraph has been added to the manual to describe the dynamic
and rolling list pruning scheme. A reference with all the details
will be added once the paper has been published.

Change-Id: Ic625858a07083916c8aa3e07f7497488dcfaee9e


[PATCH] Allow Gromacs to run on more than 64 threads by default

Avoids Gromacs dying on machines when starting more than 64 threads,
which is getting more common today - including our own tests.

This increases the default (hard) OpenMP thread limit from
64 to 128, since at least Roland has not seen any performance
drawbacks from that.

Second, we no longer attempt to start more threads than Gromacs
has been configured for. In principle it would have been cleanest
to limit gmx_omp_get_max_threads() to GMX_OPENMP_MAX_THREADS,
but unfortunately the first value is used to detect the total
number of threads for all ranks, while the latter is rather used
as a limit for the number of threads to start inside each rank.
All this threading code needs to cleaned up later, but to avoid
severely limiting MPI parallelism on these machines, for now we
instead need to apply the limit once we have adjusted for the
number of ranks in the higher-level routine.

Closes #4370.


[PATCH] Added CUDA LJ-PME nbnxn kernels

This change implements CUDA non-bonded kernels for LJ-PME introduced
in the Verlet scheme with 99029d.

The CUDA kernels implement geometric as well as Lorentz-Berthelot (LB)
combinations rules (unlike the CPU SIMD) mostly because even though PME
is very slow with LB, it is still beneficial to let the user offload the
non-bondeds to a GPU and potentially bump up the cut-off to further
reduce the CPU PME load.

Note that as now we have 120 kernels compiled for up to four different
target architectures, the nbnxn_cuda module takes a very long time to
build and can become the bottleneck during compilation. We will deal
with this later.

Change-Id: I819b59a8948da0c8492eac6a43d4a7fb6dc98354


[PATCH] Enorme typo sur le parametre fast


[PATCH] Keep track of old dof_indices distribution between
 processors; this makes it easier to construct an efficient send_list in
 System::project_vector.


[PATCH] aabb tree: more on performance section (benchmark across
 kernels)


[PATCH] ManipulatedFrame issues : fix

- The call to bbox() at each top of a manipulated frame made it verry slow to manipulate frames
  on a big item, because the bbox was computed at every call. The result is now kept in a
  member and updated only when invalidate_buffers is called.

- The color of the cutting plane is repaired.


[PATCH] Add implementation of the cross-entropy error performance
 function.


[PATCH] Demo updates, (I added a "paint-like smoothing" feature but I
 am going to remove it since real-time smoothing is not efficient due to AABB
 reconstruction.


[PATCH] Run include order check in doc-check

Now the doc-check target also checks that all files conform to the
include ordering produced by the include sorter.

Add support into the include sorter for only checking the ordering
without changing anything, and partially improve things such that the
full contents of the file are no longer required for some parts of the
checking.  There seems to be no performance impact for now from storing
all the file contents in memory, so did not go through this, but the
partial changes also improve readability of the code.
Add support to gmxtree for loading the git attributes, to know which
files not to check for include ordering.

Change-Id: I919850dab2dfa742f9fb5b216cc163bc118082cc


[PATCH] removed explict assigment of BLASOPT=-mkl for MACX64. Iprefer
 have the slow blas baseline by default for generic users


[PATCH] tables added on cache performance


[PATCH] AABB tree: update performance section with more details about
 memory occupancy (table here is better than a curve as the memory grows
 linearly)


[PATCH] Changed FFTW warning from AVX to no SSE

Changed the cmake FFTW SIMD check warning from complaining about
AVX to complaining about missing SSE or SSE2.
With FFTW 3.3.4 the performance of FFTW with both SSE and AVX enabled
is often a bit better and never much worse than SSE along. Newer
Intel processors probably also perform better with AVX with FFTW 3.3.3
so we should not complain about the combination of SSE(2) and AVX,
but only when SSE is missing.

Change-Id: I3665a35ec98616f015d05e314c8fbb80a8862092


[PATCH] removed _infostream output (slow performance on massively
 parallel systems), documentation


[PATCH] fixed bugs in BLT sorting, added makeSemiExplicit function
 (working, but not as efficient as it coudl be)


[PATCH] Add performance graph for region growing


[PATCH] Fix for calculate_dphiref-only

I doubt anyone's ever triggered this, and it shouldn't have been more
than a performance issue if they had, but now that we're deprecating the
old fallback it'll become important.


[PATCH] Traits class inherits from Hyperbolic traits now; TODO:
 investigate why triangulation is so slow


[PATCH] TCE GPU: add environment varibale NWC_OFFLOAD_SPAN

The NWC_OFFLOAD_SPAN environment variable is meant to control which GA
ranks are offloading to GPUs.  When setting the variable, every
NWC_OFFLOAD_SPANth rank (staring at rank 0) will be offloading its work
to a GPU.

The current solution is a place holder for the final implementation that
still needs to be figured out with actual performance tests.


[PATCH] Revert "Use correct number of atoms in GPU Update kernels"

This reverts commit 4d9a6d110b614a299a5bab4120c87a04f9ac14c1 (MR !2523).

It was supposed to be a trivial fix, but things turned out to be more
complicated, and my testing was insufficient (#4401).

The fix is still needed, but the bug is not causing incorrect physics,
merely harmless sanitizer errors and slightly higher resource
consumption by kernels that are very fast regardless.

I suggest doing it in master or delaying till the patch release.
Right now is not the best time to fix such issues.

Refs #4398


[PATCH] Enabling a fast pass option for reorder


[PATCH] Introduced python typemaps for std::vector<int>,
 std::vector<double>.

Was having difficulties with 5-argument DMatrix constructor and numpy. Does seem to slow down compilation and linking significantly (factor 2?).


[PATCH] Adding Changelog for Release 3.2.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.2
Update Kokkos version macros to 3.2.0


[PATCH] Performance and thread-safety requires a lock around each
 constraint row acquisition, not just each constraint row entry.


[PATCH] Possible performance enhancement in Mesh::delete_elem. We use
 the passed Elems id() as a guess for the location of the Elem in the
 _elements vector. If the guess does not succeed, then we revert to the linear
 search.

git-svn-id: file:///Users/petejw/Documents/libmesh_svn_bak@1187 434f946d-2f3d-0410-ba4c-cb9f52fb0dbf


[PATCH] Optimizations to Compute[Yi/Zi/Bi], switching over to an
 AoSoA data layout on the GPU. CPU vs GPU code paths are now maximally
 divergent, will include some discussion of that in PR. Small performance
 tweaks in Compute[UiTot/FusedDeidrj].


[PATCH] Update citations.

Google scholar claims this paper cites libmesh but I obtained a copy and it does not...

@InProceedings{Monteiro_2016,
  author     = {S.~Monteiro and F.~Iandola and D.~Wong},
  title      = {{STOMP: Statistical Techniques for Optimizing and Modeling Performance of blocked sparse matrix vector multiplication}},
  booktitle  = {{28th International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD)}},
  pages      = {93--100},
  publisher  = {IEEE},
  month      = oct,
  year       = 2016,
  note       = {\url{http://dx.doi.org/10.1109/SBAC-PAD.2016.20}}
}


[PATCH] macos accelerate does not contain dcombossq


[PATCH] Ensure PME with OpenCL does not attempt to pin

Host-only memory pinning was designed with CUDA in mind, while OpenCL
requires managing both host and device memory buffer for efficient
mapping, which is not yet implemented.

This change teaches the PME module to understand what pinning policy
is appropriate to the build configuration, so that the setup of data
structures in various parts of the code can use a pinning policy that
always works.

Refs #2498

Change-Id: I2a294aee460947cd3aad5e23869cead1b99fd610


[PATCH] Fixing issues from @rcurtin's review + adding unit test for
 cross entropy performance function


[PATCH] Adding timers into ID to help facilitate @YingzhouLi's
 performance benchmarks


[PATCH] ex1p: implement pa jacobi preconditioning

Performance is disappointing at the moment.


[PATCH] convert coul/dsf/omp styles to use fast analytical erfc()


[PATCH] Removed AVX code, since it had very little effect on
 performance and would have required a more complicated build process.  Also
 worked around a compilation error with clang.


[PATCH] added performance figures in the doc


[PATCH] Modified waterChannel tutorial to make case better posed
 Existing case did not properly converge and suffered slow convergence with
 the water level failing to reach an equilibrium.  A slight rise in the
 channel appears to help the water level reach an equlibrium when the flow
 rate over the rise matches the inlet flow rate.


[PATCH] finished consolidating the InRCut device function.  It uses
 double3's for axes, halfAx, and dist.  It passes the currentPArticle,
 neighborParticle, and gpu_x,y,z arrays to calculate distance further down the
 trace.  Also, I replaces the diff_com and virComponents with double3s.  It
 would be more elegant to use an array of double3's as opposed to three
 separate arrays for coords.  Right now this change isn't implemented due to
 possible performance concerns.


[PATCH] efficient sparsity pattern computation for the case when the
 user specifies the DOF coupling

git-svn-id: file:///Users/petejw/Documents/libmesh_svn_bak@1130 434f946d-2f3d-0410-ba4c-cb9f52fb0dbf


[PATCH] s390x/GEMM: replace 0-init with peeled first iteration

... since it gains another ~2% of SGEMM and DGEMM performance on z15;
also, the code just called for that cleanup.

Signed-off-by: Marius Hillenbrand <mhillen@linux.ibm.com>


[PATCH] Misc. Doxygen build system improvements

- Only generate the installed header list once after CMake is run.
  It cannot change unless CMake is run again.  This wasn't particularly
  slow earlier either, but now it can be added as a dependency also in
  the -fast targets without any impact on the behavior.
- Do not update the Doxyfile-common each time CMake is run if
  GMX_COMPACT_DOXYGEN=ON.
- Partition the Markdown pages into subdirectories based on the
  documentation level where they should appear.  Exclude things from
  the documentation based on the directory, not individually.
- Use a CMake function to create the various Doxygen targets to remove
  some duplication.
- Some cleanup in the directories.cpp and misc.cpp documentation files.
- Some cleanup to use consistent casing throughout CMakeLists.txt.

Change-Id: I30de6f36841f25260700ec92284762e989f66507


[PATCH] Fixed FAST CPU backend case when no features are found


[PATCH] Add implementation of convolution using the naive approach
 (it's pretty fast for small filter).


[PATCH] Issue #724 Gradient of the Lagrangian function is always
 generated for NLP solvers Might slow down initialization a bit, but probably
 not much


[PATCH] - Performance issue, in Standard_criteria.h:   Quality were
 not defined correctly, and then facets were not ordered   correctly, in the
 Double_map.


[PATCH] add Apple Accelerate to the list of BLAS libraries

Signed-off-by: Jeff Hammond <jeff.science@gmail.com>


[PATCH] Added a little extra information (which inner loop) to the
 printout of performance info.


[PATCH] removed a lot of slow FFT grid sizes from calc_grid and made
 calcgrid.c thread safe


[PATCH] Added workaround for bad performance with CUDA 7.x on clover
 sigma oprod


[PATCH] added an efficient code path for plain leap-frog update


[PATCH] Introduce GMX_USE_SIMD_KERNELS cmake option

Most GROMACS development does not need to recompile the SIMD nbnxm
(and fep) kernels whenever their dependencies change. These
dependencies are large in number, and include frequently changed
files, including config.h and various utility and nbnxm module
headers. This flag permits people to efficiently recompile while
working on code that doesn't directly target changes to the SIMD
kernels.

It also means that CI builds not aimed at efficient mdrun execution
times can instead minimize compilation times and ccache db sizes. This
will also have the side effect of testing more of the reference NBNXM
kernels.

There's other SIMD code (particularly PME, bonded, LINCS, update)
which still compiles and runs in the usual way. Currently these are
less costly to compile and harder to disable. That could change in
future.


[PATCH] Fixed up bugs and add performance tests for get and
 accumulate.


[PATCH] Add an accurate but slow way to generate a sparse point set


[PATCH] avoid using epeck in slow (when using leda) tests


[PATCH] Set cmake build to release for LZ4/Zlib and Zstd

This enables vectorization which yields a boost in performance
for these compressors. #1033


[PATCH] Working on the performance tests


[PATCH] Workaround for very slow compilation on Windows


[PATCH] Fix for md_parallel_for for Cuda reported in #1057

md_parallel_for is intended to be deprecated, but fix the issue for not
respecting lower bounds while resolving difference in performance
between md_parallel_for and parallel_for calls with MDRangePolicy


[PATCH] Add functions to Quantity to compute the max, min, standard
 deviation (as the sqrt of the variance), and average, returning a Quantity
 with the proper units.

This should be reasonably efficient, as it takes advantage of numpy-accelerated
methods if they're present.


[PATCH] Bring performance estimation up to date

The performance estimation code for estimating the PME/PP load
and the optimal DD grid setup used outdated numbers.
We now estimate using actual cycle counts on Haswell and esimate
for other architectures through a scaling factor that takes into
account the SIMD width and FMA.
The DD grid automation now ignores PBC cost for exclusions with
the Verlet scheme and the for angles and dihedrals with SIMD.

The effect of this is a more reliable PME load estimate that's
now a factor 1.4 to 1.7 higher on Haswell.
The DD grid automation will now often choose a setup that better
matches the PME `decomposition and reduce the PME redist cost.

Change-Id: I5daa6a6856f2b09ba6d17fda0eea800b816d21e4


[PATCH] clang-tidy: more misc+readability

Auto fixes:
misc-macro-parentheses
readability-named-parameter

Enabled with few violations disabled by configuration:
misc-throw-by-value-catch-by-reference
readability-function-size

Set clang-tidy checks as list to allow comments.

Refactored the operator <<< used by GMX_THROW to take the exception by
value and return a copy, which is easier for tools to see is a proper
throw-by-value (of a temporary).  Performance on the throwing path is
not important, but is anyway not affected because the inlining of the
operator allows the compiler to elide multiple copies. This also
avoids casting away the constness.

Change-Id: I85c3e3c8a494119ef906c0492680c0d0b177a38d


[PATCH] Add data set that shows the performance gain when running
 self_intersections_example.cpp (4.6 sec master, 0.6 sec this PR when run
 sequentially


[PATCH] aabb tree: added curve in performance section


[PATCH] Replacement for pdb2gmx tests

This test directly asserts upon the .top and .gro files that are
written out, using fragments of the
regressiontests/complex/aminoacids/conf.gro because these cover all
basic amino acid types. It also adds testing for hydrogen vsites for
amber and charmm.

We now omit doing an energy minimization after the string checks,
which was always a doubtful way to test pdb2gmx. These tests are still
too slow to run with other pre- and post-submit testing, so a new
CTest category has been made for them, and that category is excluded
from Jenkins builds by default. Developers will still run these by
default with "make check" or "ctest" but that should be fast enough on
a workstation. Later we can probably refactor them to use in-memory
buffers and be fast enough to put with the other tests.

Modified pdb2gmx to avoid writing fractional charges for every atom in
the [atoms] output, which isn't very useful for users and makes
writing tests more difficult.

Fixed unstable sorting of dihedrals whose parameters are strings that
identify macros.

Added new capability for refdata tests to filter out lines that vary
at run time by supplying a regex that matches the lines to skip.
That's not ideal, but useful for now. Better would be to refactor
tools so that e.g. header output can go to a different stream, but
first we should have basic tests in place.

Added tests for Regex. Fixed minor bug in c++ stdlib regex
implementation of Regex. Noted the remaining reason why we have
Regex supported by two different implementations.

Minor updates to use compat::make_unique

Extended functionality of CommandLine for convenient use.

Refs #1587, #2566

Change-Id: I6a4aeb1a4c460621ca89a0dc6177567fa09d9200


[PATCH] Use inFastDrawing instead of quick_camera and provide direct
 access to fast drawing state


[PATCH] Replaced static arrays of cl::program/kernels with maps

fast, fftconvolve, orb and random kernels were using static
arrays which are not replaced with std::maps. This fixes the
pure virtual function error that is happening on windows for
intel OpenCL devices.


[PATCH] Code cleanup in swapcoords.cpp

For ion/water position exchanges with DD, the positions of the ion group,
the split group 0 and the split group 1 are assembled into an array known
on all processors (g->xc). Only if ion/water exchanges need to be done, the
positions of the solvent group need to be assembled as well.

Before this patch, the group index ran from 0 to eGrpNr, so therefore also
the solvent group positions were assembled in every swap step. This was
superfluous since they would be assembled again if bSwap is TRUE.

If the swap protocol is called very frequently (nstswap << 100), the
performance impact is now smaller.

Change-Id: I8eff6bbd33810d6641ec97aa00a537fe782214d3


[PATCH] ranks/device changed from 2 to 1. Value of 2 doubles memory
 usage (and hits MPOSS bugs) but does not help with performance


[PATCH] Add Line_2 to Efficient RANSAC traits


[PATCH] Ordinary slow Ewald electrostatics implemented for md runs


[PATCH] AdResS: lost performance tweak

Change-Id: I164bc6a60f62d117fef83844da74c3707455a980


[PATCH] r70387, r70573, r70574 from Mesh_3-experimental-GF

Add incident_cells_3(Vertex_handle, std::vector<Cell_handle>)

This function avoids the construction of two additional std::vectors.
The performance gain is between 30% (g++) and 50% (VC++)
for points on surfaces as well as for points filling space.

We at the same time change the implementation of the function
incident_cells(Vertex_handle, OutputIterator).
In order to save one additional std::vector,
the cells are reported in bfs and not in dfs order


[PATCH] Add CUDA bonded kernels

CUDA bonded kernels are added for the most common bonded and LJ-14
interactions.
The default auto settings of mdrun offloads these interactions
to the GPU when possible.
Currently these interactions are computed in the local or non-local
nbnxn non-bonded streams. We should consider using a separate stream.
This change uses synchronous transfers. A child change will change
these to asynchronous.

Updated release notes and performance guide.

Fixes #2678
Refs #2675

Change-Id: Ifc6d97854cc7afa8526602942ec3b1712ba45bac


[PATCH] use consistent constants from math_const.h and fast integer
 powers from math_special


[PATCH] Use numerical_jacobian_h_for_var

The refactoring required makes the ALE perturbations a little simpler
to boot.  This may be a tiny bit slower, but numerical jacobians are
slow to begin with and the difference shouldn't be noticeable.


[PATCH] The Lazy Kernel dont compile the assertion and the more
 efficient bbox() function. (Because Interval_nt<> dont have gamma(),
 is_rational(), etc...)


[PATCH] Adding pair style dpd/intel and dihedral style fourier/intel
 Adding raw performance numbers for Skylake xeon server. Fixes for using older
 Intel compilers and compiling without OpenMP. Fix adding in hooks for using
 USER-INTEL w/ minimization.


[PATCH] Don't store zero entries in IGA constraint rows

Most meshes aren't going to have many of these, but omitting them should
be a slight performance increase.  More importantly, this makes
debugging on trivial meshes much easier.


[PATCH] Remove Isidore_only_equalized_KLT_5000_with_normals.xyz from
 test suite as the Surface Mesher/APSS bug is fixed and processing
 Isidore_only_equalized_KLT_5000_with_normals.xyz is very slow


[PATCH] Reverting optimizations that hurt performance on some
 compilers

git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@15551 f3b2605a-c512-4ea7-a41b-209d697bcdaa


[PATCH] Added parentheses to performance logging messages


[PATCH] nishant, added efficient jackknifed m spacing estimator


[PATCH] Remove no-inline-max-size and suppress remark

To avoid the remark that inlining isn't possible I added the flag
in d28edf2a07dcf11. This causes slow compile and should be avoided.
Instead suppress the remark.

TODO (for later): Check whether the additional inlining can improve
permance and consider enable it for release build.

Change-Id: I5866fcc5865fb44ca3dca0cf217e0cab2afbea0c


[PATCH] More extensive performance logging of the Kelly Error
 Estimator.

git-svn-id: file:///Users/petejw/Documents/libmesh_svn_bak@1122 434f946d-2f3d-0410-ba4c-cb9f52fb0dbf


[PATCH] Fix issue with HWLOC + OpenMP on XeonPhi

Using omp_get_max_threads(); is problematic in conjunction with
Hwloc on Intel (essentially an initial call to the OpenMP runtime
without a parallel region before will set a process mask for a single core
The runtime will than bind threads for a parallel region to other cores on the
entering the first parallel region and make the process mask the aggregate of
the thread masks. The intend seems to be to make serial code run fast, if you
compile with OpenMP enabled but don't actually use parallel regions or so


[PATCH] less efficient but maybe portable logarithm


[PATCH] Templated options are now runtime compile options for opencl
 FAST


[PATCH] Guard performance test which uses Lambda dispatch #821


[PATCH] Enable mac CI testing on azure pipelines

- use native minio bin from brew because Docker for Mac launches slow,
  annoying, etc.


[PATCH] Request flushing denorms to zero in OpenCL

This change adds by default the -cl-denorms-are-zero to the flags used
for kernel compilation. This is done to:
- avoid a large performance penalty on AMD Vega with ROCm (which by
  default handles denorms on GFX9 or later).
- make the defaults uniform across CUDA and OpenCL.

Fixes #2593

Change-Id: I9e6183c4367b5960e0e21f1dd342d7695acfbc44


[PATCH] FAST will return (af_)features instead of (af_)features *


[PATCH] Fixed bug in 4th order 3D elements.  Serendipity now works up
 to order 4 in 3D.  Doing some performance testing + trying to get AMR to work
 with serendipity


[PATCH] Added some profiling to catch performance numbers.


[PATCH] Wrap up unit and performance testing

With OpenMP, the data-duplicated non-atomic
version is 4X faster than the non-duplicated
atomic version using 16 threads, and
2-3X faster using 2 threads.


[PATCH] Add a performance warning when a dynamic property map is used
 as index map


[PATCH] working but still slow, about to switch to intervals


[PATCH] Moving coord_string from returning a std::string to
 std::string_view. (#2704)

The coord_string function is used in a lot of performance critical paths.
Moving it to return a string_view as none of these paths benefit from
making a copy of the value.


[PATCH] additional precompiler lines for performance testing


[PATCH] 64-bit alignment makes a huge difference on ga_dgemm
 performance on KNL


[PATCH] Stabilize and accelerate the test case by using a smaller
 network architecture.


[PATCH] Reduce noise slightly and increase dataset size, which will
 slow down the test but make the results more accurate.


[PATCH]
 tutorials/combustion/reactingFoam/laminar/counterFlowFlame2D(LTS): changed to
 Wilke transport mixing

Changed the laminar methane combustion cases to use the Wilke mixing rule for
the transport properties obtained from the Sutherland model but with coefficient
mixing for thermodynamic properties for efficient evaluation of reaction
equilibria.

This provides significantly more accurate results for laminar combustion,
producing a thinner flame and a 10K reduction in peak temperature.


[PATCH] Redesigned experimental memory pool to eliminate race
 conditions by condensing state representation to a single integer and
 simplifying algorithm. Addresses issues #320 , #487 , #452

Creating power-of-two Kokkos::Impl::concurrent_bitset size to streamline
implementation and align with MemoryPool needs.

Unit testing over a range of superblocks the following sequence:
  1) allocate N of varying size
  2) deallocate N/3 of these
  3) reallocation deallocated
  4) concurrently deallocate and allocate N/3 of these

Add performance test for memory pool.
Add performance enhancement note for multiple hints per block size.


[PATCH] added synchs for main events again. this may have a negative
 performance influence in some case. such cases should however be really rare.
 otherwise, these events make no sense without a sync. imagine a master rank
 which is not at the interface


[PATCH] Adding benchmark directory and a bytes_and_flops benchmark

This directory is intended for hardware and software benchmarks.
These are not necessarily performance unit tests, but usually a bit
more complex than that.

And they are intended to be used on their own.


[PATCH] - Workaround bugs and misfeatures of GCC 3 in FPU.h.
 Unfortunately at a performance cost :((


[PATCH] Containers: DynRankView Performance Test was using to much
 memory.

The test was using close to 9GB in memory, with parallel testing this
lead to out of memory failures.


[PATCH] Tested a new locking grid with thread priorities. Actually,
 it decreases performance with the current algorithm, but we'll try it again
 later...


[PATCH] Extra options for computational electrophysiology.

* Added two extra .mdp file parameters 'bulk-offset' that allow to specify
an offset of the swap layers from the compartment midplanes. This is useful
for setups where e.g. a transmembrane protein extends far into at least one
of the compartments. Without an offset, ions would be swapped in the vicinity
of the protein, which is not wanted. Adding an extended water layer comes
at the cost of performance, which is not the case for the offset solution.
* Also made the wording a bit clearer in some places
* Described the new parameters in the PDF manual, updated figure
* replaced usage of sprintf in output routine print_ionlist_legend() by snprintf
* Turned comments describing the variables entering the swapcoords.cpp
  functions into doxygen comments

Change-Id: I2a5314d112384b30f9c910135047cc2441192421


[PATCH] SMD multi step added with fast Hv product in main


[PATCH] sgemm/dgemm: add a way for an arch kernel to specify prefered
 sizes

The current gemm threading code can make very unfortunate choices, for
example on my 10 core system a 1024x1024x1024 matrix multiply ends up
chunking into blocks of 102... which is not a vector friendly size
and performance ends up horrible.

this patch adds a helper define where an architecture can specify
a preference for size multiples.
This is different from existing defines that are minimum sizes and such.

The performance increase with this patch for the 1024x1024x1024 sgemm
is 2.3x (!!)


[PATCH] Add the NeighborSearchRules class, which defines how the
 SingleTreeDepthFirstTraverser can perform a NeighborSearch.  Adapt the
 NeighborSearch class to use this.  It is not as fast as it could be.


[PATCH] Distinghuish cases for performance reasons


[PATCH] Fix a warning

https://cgal.geometryfactory.com/CGAL/testsuite/CGAL-5.1-Ic-152/Installation/TestReport_Friedrich_Ubuntu-gcc-7.gz
```
CMake Warning at /home/gimeno/foutoir/cgal_root/CGAL-5.1-Ic-152/cmake/modules/CGAL_enable_end_of_configuration_hook.cmake:99 (message):
  =======================================================================

  CGAL performance notice:

  The variable CMAKE_BUILD_TYPE is set to "".  For performance reasons, you
  should set CMAKE_BUILD_TYPE to "Release".

  Set CGAL_DO_NOT_WARN_ABOUT_CMAKE_BUILD_TYPE to TRUE if you want to disable
  this warning.

  =======================================================================
Call Stack (most recent call first):
  CMakeLists.txt:9223372036854775807 (CGAL_run_at_the_end_of_configuration)
```


[PATCH] attempt to reduce the negative performance impact of adding
 the shift option


[PATCH] KokkosContainers: Mark perf tests as CATEGORY PERFORMANCE

Fix https://github.com/kokkos/kokkos/issues/374 by marking
KokkosContainers' performance tests as CATEGORY PERFORMANCE.  They
will always build, but they will only run when doing performance
tests.


[PATCH] Performance test for memory pool.  Update v2 API to better
 align with v1.


[PATCH] New version of dgemm_kernel_4x4_bulldozer.S The peak
 performance with 8 cores is now 90 GFlops


[PATCH] additional precomiler command for performance testing


[PATCH] Fixed backend API for join

* Removed output dimensions as parameter
* Fixed unitialized warnings for fast cpu


[PATCH] Added to PME on GPU information in mdrun performance

Added -pme to glossary

Moved and modified a previous mdrun with GPU example to follow
a more logical progression - first introduce the simpler use cases
of gputasks and show examples, then at the end show how to avoid a
graphics-dedicated GPU

Added more GPU task assignment examples

Change-Id: I63304a511d5d98d85fdbb1cea497627a80a14418


[PATCH] Timer: Available in Kokkos namespace

Updated unit tests, performance tests, and examples using
Kokkos::Impl::Timer to use Kokkos::Timer


[PATCH] Update paper.md

Specify SpMV performance results.


[PATCH] Layout on the bibliography page
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When having a bit a long citation description, the description runs, in the HTML output on the bibliography page, into 3 or more lines where the 3rd and following lines continue underneath the citation number like:
```
 [1]  Eric Berberich, Arno Eigenwillig, Michael Hemmer, Susan Hert, Lutz Kettner, Kurt Mehlhorn, Joachim Reichel, Susanne Schmitt, Elmar Schömer, and Nicola Wolpert. Exacus: Efficient and exact
       algorithms for curves and surfaces. In Gerth S. Brodal and Stefano Leonardi, editors, 13th Annual European Symposium on Algorithms (ESA 2005), volume 3669 of Lecture Notes in Computer Science,
pages 155–166, Palma de Mallorca, Spain, October 2005. European Association for Theoretical Computer Science (EATCS), Springer.
```

The example was found  in e.g. https://doc.cgal.org/latest/Algebraic_foundations/citelist.html

- corrected the "overflow"
- made the citation number right aligned


[PATCH] moved MeshBase::contract() up to Mesh.  Unfortunately, there
 is no good way to make MeshBase::delete_elem() efficient, so the old
 implementation of MeshBase::contract() was (potentially) O(n_elem^2), and
 consumed approximately 20 percent of the runtime in ex10.  This new
 implementation exploits the fact that the elements are stored in a vector
 (which is why it was moved up to the Mesh class) and is linear in the number
 of elements.  The new implementation is less that 1 percent of the run time
 in ex10.


[PATCH] Use much less PaddedRVecVector and more ArrayRef of RVec

Only code that handles allocations needs to know the concrete type of
the container. In some cases that do need the container type,
templating on the allocator will be needed in future, so that is
arranged here. This prepares for changing the allocator for state->x
so that we can use one that can be configured at run time for
efficient GPU transfers.

Also introduced PaddedArrayRef to use in code that relies on the
padding and/or alignedness attributes of the PaddedRVecVector.  This
keeps partial type safety, although a proper implementation of such a
view should replace the current typedef.

Had to make some associate changes to helper functionality to
use more ArrayRef, rather than rely on the way rvec pointers could
decay to real pointers.

Used some compat::make_unique since that is better style.

Change-Id: I1ed3feb016727665329e919433bece9773b46969


[PATCH] AABB tree: added internal search tree (CGAL K-orth search
 tree) to accelerate the projection queries. substantial complication... may
 be improved.


[PATCH] enable GPU sharing among tMPI ranks

It turns out that the only issue preventing sharing GPUs among thread-MPI
threads was that when the thread arriving to free_gpu() first destroys
the context, it is highly likely that the other thread(s) sharing a GPU
with this are still freeing their resources - operation which fails as
soon as the context is destroyed by the "fast" thread.

Simply placing a barrier between the GPU resource freeing and context
destruction solves the issue. However, there is still a very unlikely
concurrency hazard after CUDA texture reference updates (non-bonded
parameter table and coulomb force table initialization). To be on the
safe side, with tMPI a barrier is placed after these operations.

Change-Id: Iac7a39f841ca31a32ab979ee0012cfc18a811d76


[PATCH] Kokkos::Experimental View refactoring #define
 KOKKOS_USING_EXPERIMENTAL_VIEW to alias Kokkos::View to
 Kokkos::Experimental::View.

Revise core unit and performance tests to execute correctly.


[PATCH] - locate() cleanups, performance impact unnoticeable.


[PATCH] Evaluating Tom Forsyth's fast mesh reordering.


[PATCH] Fix performance regression in KOKKOS package


[PATCH] Adding Changelog for Release 3.2.01

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.2


[PATCH] More performance enhancements for the transformation --
 almost done now!


[PATCH] Adjust spin wait in attempt to address performance issue #935
 Bring Windows code back in, just in case...


[PATCH] Use fast returns in md5 computation

This logic is easier to follow than a recycled ret integer

Change-Id: Idc47cdae3d0453f1645a82582b13c86aa8eadcb8


[PATCH] Remove BoundaryInfo::n_boundary_ids(elem, side) copy/paste
 job.

It was basically an exact copy of the now-deprecated
BoundaryInfo::boundary_ids(elem, side).  Reusing the set filling code
might be *slightly* less efficient, but I think the savings in
maintainability and readability is worth it...


[PATCH] Move calcgrid.* to fft/

One more file out of gmxlib/.  These are related to selecting an FFT grid
size, and contain some numbers coming from performance measurements, so
fft/ should be a natural place.

Change-Id: I386965665a92bc47d4c0c3ca0201a6a4b13b5886


[PATCH] bug fix for fast box intersection in presense of the Infi Box


[PATCH] Completed the base fast SVD case for which the number of
 points is less than the dimension...


[PATCH] Make jenkins own-fftw verify use local tarball

We should not bombard the FFTW servers with downloads, plus these can be
relatively slow too, so use our local ftp server instead.

Change-Id: Id6ccebf0ac1ae6410cd4f7f13f2ff76d275af5d2


[PATCH] Handle a case where the step size ends up being 0 but the
 gradient is not yet the minimum gradient size.  Maybe it is a little slow
 (elementwise comparison is not incredibly fast)...


[PATCH] Serial-only atomics implementation

[#607] [#549]
A few details:
 - Accepting volatile pointers was necessary
   for compatibility with existing calls which
   pass in volatile pointers, hence the const_cast
 - Special implementations of atomic_increment
   were needed to get equal performance in the
   one application I tested (it was doing its
   own serial special cases before).
 - Compilers have a harder time matching templates
   as opposed to overloads, so some call sites
   had to be modified to specify the scalar
   type explicitly


[PATCH] Use fast PerfLog methods in PerfItem

This speeds up our LOG_SCOPE usage several fold.


[PATCH] Add implementation of the sum squared error performance
 function.


[PATCH] In debug mode it makes no sense to run a performance test


[PATCH] Adjust the performance function test; use the simplified
 performance function.


[PATCH] Override any OpenCL fast math JIT settings for
 born/coul/wolf{/cs}/gpu to resolve numerical deviations seen with some OpenCL
 implementations.


[PATCH] Draw points with line width 0, otherwise it is too slow when
 we have 1mio points


[PATCH] Removed init_state

Made a simple zero-initializing constructor for t_state and the
structs of some of its members. Called them classes. Later, we might
prefer to require explicit initialization with actual values, so that
tools can detect the use of uninitialized values and find our bugs,
but for now having a constructor is a useful initial step in that
direction.

Extracted some new functions that cover some of the incidental
functionality that was also present in init_state.

Made state.lambda a std::array, thereby removing the need to consider
resizing it, and converted client code to be passed an ArrayRef rather
than hard-code the name of the specific container. This caters for
convenient future refactoring of the underlying storage, and sometimes
needing to implicitly know what the size of the container is.

Passing an ArrayRef by value is consistent with the CppCoreGuidelines,
but has potential for performance impact. Doing this means that a
caller pushes onto the stack a copy of the object (containing two
pointers), rather than previous idioms such as pointer + size, or
pointer + implicit constant size from an enum, or pointer + implicit
size in some other parameter. This could mean an extra argument is
pushed to the stack for the function call, compared with the
alternatives of pushing a pointer to data, pointer to container, or
pointer to ArrayRef. In all cases, the caller has to load the pointer
value via an offset that is known to the compiler, so that aspect is
probably irrelevant. So, we would probably prefer to avoid calling
functions that take such parameters in a tight loop, or where multiple
containers share a common size. But the uses in this patch seem to be
of sufficiently high level to be an acceptable trade of possible
performance for improved maintainability.

Change-Id: I17e7d83cfc89566f76fa9949c425b950ad6aef62


[PATCH] Non-reduction boxloops done

The non-reduction boxloops are all in and pass the struct tests.
Performance is VERY slow, but this may just be due to the machine
I am running on. Reduction boxloops are in progress.


[PATCH] Reword CPU/GPU imbalance notes

Changes text in CPU/GPU imbalance from "performance loss" to "wasting
resources", since in some cases one can not get higher performance.
Replaced "GPU has less load" by "CPU has more load".
Removed hint to reduce the cut-off, since one often can not do this.
Note that with CUDA all theses notes are never printed, since we no
longer have timings on (by default), unlike with OpenCL.

Fixes #2253

Change-Id: Ib4a9752ad27c1cd2a3cd751a217249694a56d3b7


[PATCH] Distinguished mutexes from semaphores. The distinction is
 useful because the linux implementation of sem_post() in unnecessarily slow
 when semaphores are used for mutual exclusion.  This change made spinlocks
 messier to implement, so I excised them.


[PATCH] Worked on the performance of point location.


[PATCH] Added fast square tridiagonalization for lower-triangular
 storage.


[PATCH] Fixed essential dynamics / flooding group PBC serial

In former versions, the PBC representation of essential dynamics /
flooding group atoms could be incorrect in serial runs if the ED group
contained more than a single molecule. In multi-molecule cases, the required
steps to choose the correct PBC image in communicate_group_positions()
therefore need to be performed also in serial runs. Since the PBC representation
can only change in neigborsearching steps, we only need to check the
shifts then. In parallel, NS is signalled by the bUpdateShifts
variable, which is set in dd_make_local_ed_indices(). The latter
function is however not called in serial runs; but still we can pass
the bNS boolean to do_flood() to signal the NS status. For essential
dynamics, unfortunately, since do_edsam() is called from constrain(), there
is no information about the NS status at that point. Until someone
comes up with a better idea, we therefore do the PBC check in every step
in serial essential dynamics - the performance impact will be negligible
anyway.

Change-Id: I86336a5e34131bdeac7e28f35b1ccb633450e54e


[PATCH] reverted change to matrix product sparsity calculation: no
 one is interested in how fast you can calculate the wrong answer....


[PATCH] Apply suggestions from code review

Everything following are changes to the rcm implementation.
Remove unneccessary consts from rcm declaration.
Do not store adjacency matrix and degrees as members in the class.
Replace explicit gko::vector with vector.
replace std::memcpy with std::copy_n.
Various documentation improvments.
Reverse description order of return paramters.
Make IndexType explicit instead of auto.
Use std::min_elelemt
Fix various spelling errors, typos, rewordings.
Removes the 'explicit' from the ExectorAllocators rebinding construtor.
Changes occurences of array<bool> to vector<bool>, to save memory.
Minor cleanup
Remove the unnecessary test for the rcm adjacency matrix.
Add a test case for the correct rcm result.
Rewrite the assert_correct_permutation function to comparing with iota.
Move test matrices to test class.
Improve nested vector initialization.
Allocate degrees inside rcm::generate.
Change from goto to immediately evaluated lambda expression.
Refactor loop body into an inline helper function.
Relace some autos.
Reorganize includes to conform to include order.
Replace autos with IndexType where necessary.
Replace size_type with IndexType for num_vertices.
Refactor for the number of levels to be more explicit.
Make perm signal value -1.
Factor out sort_by_degree in a generalized, fast small sorting function.
Make level_processed a constexpr.
In the small_sort make some types explicit.
Wrap omp locks in a omp_mutex, use RAII guards.

Co-authored-by: Tobias Ribizel <ribizel@kit.edu>


[PATCH] Added timers to test performance of MPI_File_sync,
 collection, and compression


[PATCH] BJP: Initial checkin of test programs to test performance of
 put and get operations using mirrored arrays.


[PATCH] issue #1871, #1310: inv efficient for SX, evaluatable for MX


[PATCH] Tetrahedral mesh

- Displays the item after its creation without having to move the manipulated frame.

- Enhances the performance when moving the manipulated frame.


[PATCH] Fixed FAST type comparison mismatch warning


[PATCH] fixed a horrendously inefficient minibatch implementation.
 now the cardinality-k-index-set sampler (sampling without replacement) is
 very efficient


[PATCH] added precompiler commands for performance tests


[PATCH] New bench for comparing sweep performance


[PATCH] Some performance problem. I am looking into it.


[PATCH] #1044 disable some slow unittests by default


[PATCH] Create a AVX512 enabled version of DGEMM

This patch adds dgemm_kernel_4x8_skylakex.c which is
* dgemm_kernel_4x8_haswell.s converted to C + intrinsics
* 8x8 support added
* 8x8 kernel implemented using AVX512

Performance is a work in progress, but already shows a 10% - 20%
increase for a wide range of matrix sizes.


[PATCH] Due to decrease in code performance, calculation of pressure
 tensor for W12, W13, W23 is commented out and in log file only the diameter
 of pressure tensor W11, W22, W33 will be printed. In case if those
 calculation are required, they need to be uncommented.


[PATCH] Commit the new version of the static filter. Too slow for the
 moment.


[PATCH] Jeff: same as 6.0 branch.  should not include ARMCI build
 system headers.  support for T3D and T3E, especially something which is only
 for performance, not function, is silly.  s/TARGET/NWCHEM_TARGET/ for the
 RTDB case.  i don't see any reason for it in the first place but at least now
 the build system is cleaner.


[PATCH] Remove BoundaryInfo::n_edge_boundary_ids(elem, side)
 copy/paste job.

It was basically an exact copy of the now-deprecated
BoundaryInfo::edge_boundary_ids(elem, side).  Reusing the set filling code
might be *slightly* less efficient, but I think the savings in
maintainability and readability is worth it...


[PATCH] use MinMaxTuple as return value of minmax

This might slow things down.

Signed-off-by: Panagiotis Cheilaris <philaris@cs.ntua.gr>


[PATCH] first short a performance matrix stuff. Papi interface so
 far.


[PATCH] Coordinate Propagators

This change introduces the propagator element, which, thanks to templating,
can cover the different propagation types used in NVE MD. The combination
of templating, static functions, and having only the inner-most operations in
the static functions allows to have performance comparable to fused update
elements while keeping easily reordable single instructions.

Note that the two velocity update functions are only necessary to allow
exact replication of the legacy do_md code for both md and md-vv. The
parentheses or the lack thereof lead to numerical errors which build up very
rapidly to make the (very strict) integrator comparison test fail. Relaxing this
condition will make getting rid of one of the two variants possible.

An interesting further development would be to unify the OpenMP loops for
coordinate propagation and constraining by using loops over constraint
groups in both cases.

Change-Id: I1a1f66f1efe63c791ef3fe51ce2f99da3367adca


[PATCH] Add --skip-partitioning command line option

This makes testing tweaks to that option easier, and might be useful
later when doing performance testing.


[PATCH] Add basic list of performance factors to tutorials.


[PATCH] Sparse unordered with duplicates: Better vectorization for
 tile bitmaps.

When computing tile bitmaps, there are a few places where we were not
vectorizing properly and it caused performance impacts on some customer
scenario. Fixing the use of covered/overlap in the dimension class to
enable proper vectorization.


[PATCH] There is no need to switch off ITERATOR_DEBUGGING as the
 performance problem was somewhere else


[PATCH] Jan 29 1999	Calls to Robert's fast esp routines


[PATCH] << operator for segments does clipping (QT advice) only for
 the segments that intersect the boundaries of the screen rectangle use the
 old x_real function because the new one is too slow in doing the
 transformation (use GMP if CGAL_USE_GMP is defined) we should document the
 old one too, it will never be removed.


[PATCH] Various cleanup in Kokkos SNAP, replacing verbose Kokkos
 MDRangePolicy and TeamPolicy types with simpler `using` definitions. No
 performance implications.


[PATCH] normalize_border is there only for performance


[PATCH] Cherry-picking changes on top of our current hash. There are
 things that hurt performance in laster mfem@master commits, not sure what
 yet.

This includes:
- feature/artv3/cusparse-Spmv
- feature/tomstitt/temp-mem-type
- patches to tmop.cpp and tmop_tools.cpp to address memory issues
- patch to mem_manager/device to use mfem's default allcator instead of
the host umpire one


[PATCH] Break apart update_constraints

There are four distinct kinds of work being done, and never was any
call to update_constraints doing all of them, so it's better to have a
group of functions, each of which do one thing, and the relevant ones
called. This also makes it simpler to express by returning fast that
when we don't have constraints, we do nothing.

Made the logic for whether this is a log or energy step match that of
the main MD loop. The old implementation may not have prepared for the
last step correctly when it was triggered by something other than the
nsteps inputrec value.

Removed a commment mentioning iteration, which is a feature
that was removed a while ago.

Removed some ancient debug dump output.

Refs #2423, #1793

Change-Id: I21c10826721ddc9a79a33b1dc75971a20d0855d9


[PATCH] -Mvect option causes severe performance problems with
 R1.2.5.1 on Paragon


[PATCH] USER-DPD Kokkos: Remove the SSA's ALLOW_NON_DETERMINISTIC_DPD
 option. There was no measurable performance benefit to turning it on.


[PATCH] thermophysicalModels::coefficientWilkeMultiComponentMixture:
 New Wilke mixing model for gaseous transport properties

The new generalised framework for thermophysical mixing models has allowed the
efficient implementation of the useful combination for gases of coefficient
mixing for thermodynamic properties with the Wilke model for transport
properties:

Description
    Thermophysical properties mixing class which applies mass-fraction weighted
    mixing to the thermodynamic coefficients and Wilke's equation to
    transport properties.

    Reference:
    \verbatim
        Wilke, C. R. (1950).
        A viscosity equation for gas mixtures.
        The journal of chemical physics, 18(4), 517-519.
    \endverbatim


[PATCH] Policy performance tests: Added test and sample scripts

This commit address Github issue #737
RangePolicy and TeamPolicy tests with nested parallelism added for
benchmarking performance - e.g. compare master vs develop

policy_performance: add functor for parallel_scan


[PATCH] Fix conditional on when DtoH forces copy occur

d2d4a50b4c636c203028c5bff311924ec15e7825 introduced performance
regression with forces copied from device to host on each step.
This fixes the issue by reinstantiating proper condition on the
copy call.

Fixes #4001
Refs #2608


[PATCH] Fix bug in polyline simplification: We had hardwired that we
 use Exact_predicates_tag which is slow for EPEC in particular with
 Quotient<MP_float> or leda::real

We determine the appropriate tag using Algebraic_structure_traits<FT>::Is_exact


[PATCH] Speed up a slow test case by using a smaller topology file


[PATCH] completed adding of support point indices, made remark on
 buggy setup of problem in fast and exact case


[PATCH] Fix hardware topology detection for modern systems

This is a partial rewrite of our hardware topology detection
code to handle modern systems where we might not be allowed to
run on all threads present, where there might be cpu limits
that are lower than the total number of threads, or hybrid
CPUs that contain combinations of performance and efficiency
cores. In particular, it includes

- The hwloc detection has been fixed to work for more systems,
  and we are better at properly separating internal logical
  cpu indices from OS-provided logical indices.
- The cpuinfo code will properly handle the case where we
  are not allowed to run on some cores when detecting a simple
  topology.
- When compiled without hwloc support, we can now also parse
  cpu topologies from Linux filesystems, which is important
  for non-x86 processors.
- All detection layers properly handle the case where there is
  a cpuset mask that disallows some cpus from being used.
- When available, we use linux cgroups (either v1 or v2) to
  detect cpu limits set e.g. in container environments, and use
  this to decide the number of threads rather than the total
  logical core count. This should avoid overloading runs
  in container environments, including our CI system.
- We no longer assume that all sockets/cores are identical,
  which will commonly not be the case e.g. if slurm has set
  custom cpusets (so only those cpus are visible).


[PATCH] Reduce dataset sizes and number of iterations to accelerate
 tests.


[PATCH] Added Kokkos-like array datatype into RK4 and RHS in
 FixRXKokkos.

- Created an Array class that provides stride access for operator[]
  w/o needing Kokkos views. This was designed to avoid the performance
  issues encountered with Views and sub-views throughout the RHS and
  ODE solver functions.


[PATCH] The split source is unnecessary and slow on some machines.


[PATCH] Revert "suppress performance warning concerning an assertion"

This reverts commit 580b65d8a5937b99c6206885a6b0504399923501.

The warning was already fixed by commit
63ae26eb0ffa8460abddf6843345996f9e4de603.


[PATCH] Add CUDA compiler support for CC 5.0

With CUDA 6.5 and later compute capability 5.0 devices are supported, so
we generate cubin and PTX for these too and remove PTX 3.5.
This change also removes explicit optimization for CC 2.1 where
sm_20 binary code runs equally fast as sm_21.

Change-Id: I5a277c235b873afb2d1b2b12b5db64b370f1bade


[PATCH] Added the option to set a close_to_point tolerance in
 PointLocatorTree and MeshFunction, as a fallback option.

This is helpful when we have numerical tolerance issues which can lead to points being outside a mesh within
some tolerance. Note that we use a linear search with close_to_point, so it's slow, but at least it's a robust
backup.


[PATCH] Sun Performance Library debugged and tested


[PATCH] Used EAF for all IO on T and cleaned up IO operations so that
 reads/writes on T happen in oV blocks and all reads of T go thru one routine
 (mp2_read_tiajb).  Put in performance stats for the basic steps of the
 gradient.  Use screening of the density in the non-seperable part of the
 gradient.  Reduced the tol2e from 10^-12 to 10^-9/10 but it really needs to
 be an input parameter.


[PATCH] - Experiment with compacting the in_conflict_flag showed 7%
 performance drop.   So it's probably not worth it in practice.


[PATCH] Updated article reference. Added configuration flags to
 support altivec on powerpc. Updated configuration files from gnu.org Removed
 the fast x86 truncation when double precision was used - it would just crash
 since the registers are 32bit only. Added powerpc altivec innerloop support
 to fnbf.c Removed x86 assembly truncation when double precision is used - the
 registers can only handle 32 bits. Dont use general solvent loops when we
 have altivec support in the normal ones.


[PATCH] PetscMatrix::print_personal now prints to file when requested
 (rather than just cout).  The implementation is not particularly efficient
 (since print_personal gets passed an ostream) but it does work.  And how
 efficient do you need to be if you are printing out matrices anyway?


[PATCH] Core: fix another issue with the memory tracking, introduced
 recently

There was a bug introduced when solving the performance issues with
subviews. It seemed to not have trickered any errors in either Trilinos
tests nor kokkos tests, but did crash Nalu.


[PATCH] EA: test for ga_dgemm performance (N=400 1600 3200)


[PATCH] implemented plain-C SIMD macros for reference

This is mainly code reorganization.
Adds reference plain-C, slow, arbitrary width SIMD for testing.
Adds FMA for gmx_calc_rsq_pr.
Adds generic SIMD acceleration (also AVX or double) for pme solve.
Moved SIMD vector operations to gmx_simd_vec.h
The math functions invsqrt, inv, pmecorrF and pmecorrV have been
copied from the x86 specific single/double files to generic files
using the SIMD macros from gmx_simd_macros.h.
Moved all architecture specific nbnxn_kernel_simd_utils code to
separate files for each SIMD architecture and replaced all macros
by inline functions.
The SIMD reference nbnxn 2xnn kernels now support 16-wide SIMD.
Adds FMA for in nbnxn kernels for calc_rsq and Coulomb forces.

Refs #1173

Change-Id: Ieda78cc3bcb499e8c17ef8ef539c49cbc2d6d74d


[PATCH] fast point location should work now


[PATCH] rbOOmit change: If a CouplingMatrix is attached to an
 RBConstruction then we should only increment the designated blocks in matrix
 assembly, otherwise matrix assembly is extremely slow since we go outside the
 sparsity pattern.


[PATCH] Rebuild the OpenMP runtime library with Clang

To get rid of the warning:

clang-9: warning: No library 'libomptarget-nvptx-sm_70.bc' found in the default
clang lib directory or in LIBRARY_PATH. Expect degraded performance due to no
inlining of runtime functions on target devices. [-Wopenmp-target]


[PATCH] Reducers: fix performance issue #680

Adding non-volatile join helps.


[PATCH] chasing the performance issue on the aump2 QA test


[PATCH] performance are getting better with grid_nbfm


[PATCH] Make stepWorkload.useGpuXBufferOps flag consistent

On search steps we do not use x buffer ops, so the workload flag should
correctly reflect that.

Also slightly refactored a conditional block to clarify the scope of
workload flags.

Note that as a side-effect of this change, coordinate H2D copy will be
delayed from the beginning of do_force() to just before update on search
steps when there are no force tasks that require it (i.e. without PME).
While this is not ideal for performance, the code is easier to reason
about.

Refs #3915 #3913 #4268


[PATCH] remove peak_memory_sizer that uses Taucs, slow computation
 and is not working on all platforms.

By default poisson now uses Eigen is available and Taucs otherwise


[PATCH] Move .f to .F - Including log of .f

RCS file: /msrc/proj/mss/nwchem/src/ddscf/fast/cheby.f,v
Working file: cheby.f
head: 1.4
branch:
locks: strict
access list:
symbolic names:
        release-4-5-patches: 1.4.0.8
        release-4-5: 1.4
        bettis: 1.4
        release-4-1-patches: 1.4.0.6
        release-4-1: 1.4
        release-4-0-1: 1.4
        release-4-0-patches: 1.4.0.4
        release-4-0: 1.4
        v3-3-1: 1.4
        release-3-3-patches: 1.4.0.2
        release-3-3: 1.4
keyword substitution: kv
total revisions: 4;     selected revisions: 4
description:
----------------------------
revision 1.4
date: 1999/07/29 00:53:56;  author: d3e129;  state: Exp;  lines: +3 -0
added cvs ID tags
----------------------------
revision 1.3
date: 1999/05/10 18:43:30;  author: d3g681;  state: Exp;  lines: +37 -14
major changes to improve precision, speed, stability; fully dynamic FMM to permit deep trees; rtdb input parameters; this is the version used for the paper
----------------------------
revision 1.2
date: 1999/01/11 18:18:49;  author: d3g681;  state: Exp;  lines: +250 -124
better linear algebra in the fitting, more varied fit routines, removed dead code
----------------------------
revision 1.1
date: 1999/01/01 04:57:29;  author: d3g681;  state: Exp;
First phase of integrating the fast coulomb code into nwchem.  The nested grid evaluation of the density, fourier interpolation, FMM, and fourier solution of the free space Poisson equation


[PATCH] Fixing bug in build system noticed by Jeff. This should
 improve the performance of default builds


[PATCH] SIMD acceleration for F_FOURDIHS and F_PIDIHS

Since these are computed by the RB and proper dihedral code for which
we already have SIMD acceleration, this acceleration comes "for free"
(or rather, we have been stupid not to accelerate these before).

Change-Id: I456af11c23fe1cb3749a889c5d92ec3ba06ab237


[PATCH] Keep track of old dof_indices distribution between
 processors; this makes it easier to construct an efficient send_list in
 System::project_vector.

git-svn-id: file:///Users/petejw/Documents/libmesh_svn_bak@3796 434f946d-2f3d-0410-ba4c-cb9f52fb0dbf


[PATCH] Continue working on FParser JIT

* Path fix for Linux
* Add optimizer opcodes, fix bugs
* Vastly expand JIT opcode support, fix AD bug... oops!
* Add JIT support for if(a,b,c) control flow opcodes
* Make compares fuzzy using Fparser's epsilon
* Fix compile error when fpoptimizer is disabled
* Enable support for more Value_t types
* Fix stack recover bug, add test/example
* Add performance test code
* Fix another AD bug involving cDup
* Tweak/expand tests
* Put JIT cache files into subdirectory


[PATCH] rhoTabulated, hTabulatedThermo, tabulatedTransport: New (p,
 T) tabulated thermophysical functions

This is a prototype implementation of (p, T) tabulated density, enthalpy,
viscosity and thermal conductivity using a uniform table in pressure and
temperature for fast lookup and interpolation.  The standard Newton method is
used for h->T inversion which could be specifically optimised for this kind of
table in the future.


[PATCH] Add helper to reuse generated TPR files in testing

Used static class members in GoogleTest and provided option in
testfilemanager to allow file path specification before test case is
started.

This should speed up some of the test cases that have been slow due to
repeated calls to grompp.

Change-Id: I50e29d04550d78f2324e3665e903d45515464298


[PATCH] Attempt to accelerate the test a little bit.


[PATCH] Make OverlappingCouplingFunctor threadable

This *particular* fix is probably efficient enough for use, but when we
fix #2334 we should change this to use (and get test coverage of) the
new GhostingFunctor::clone() API instead.


[PATCH] Use much smaller GroupLens dataset.

This helps keep the repository a bit smaller and should accelerate some tests.


[PATCH] Concerning #100: implementing fast dependsOn for SX and MX


[PATCH] Shift transition to multithreading towards larger matrix
 sizes

See #1886 and JuliaRobotics issue 500. trsm benchmarks on Haswell and Zen showed that with these values performance is roughly doubled for matrix sizes between 8x8 and 14x14, and still 10 to 20 percent better near the new cutoff at 32x32.


[PATCH] Allow to do gemv and ger buffer allocation on the stack

ger and gemv call blas_memory_alloc/free which in their turn
call blas_lock. blas_lock create thread contention when matrices
are small and the number of thread is high enough. We avoid
call blas_memory_alloc by replacing it with stack allocation.
This can be enabled with:
make -DMAX_STACK_ALLOC=2048
The given size (in byte) must be high enough to avoid thread contention
and small enough to avoid stack overflow.

Fix #478


[PATCH] Restore wallcycle subcounter name to "Bonded F"

This makes it easier to check for performance behaviour

Change-Id: Icb67bd75ee58fe280beb9f1cb123d0eeca229f09


[PATCH] Adding Changelog for Release 2.7.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 2.7


[PATCH] reorder folders, so that the fast tests are run first


[PATCH] follow up of 2a71e019: VC performance warning


[PATCH] Identity: special type derived from SphericalTensor to
 provide the concept of identity (I)

Allows efficient operators to be defined for the interaction between
types and the equivalent identity.


[PATCH] Initial support for SkylakeX / AVX512

This patch adds the basic infrastructure for adding the SkylakeX (Intel Skylake server)
target. The SkylakeX target will use the AVX512 (AVX512VL level) instruction set,
which brings 2 basic things:
1) 512 bit wide SIMD (2x width of AVX2)
2) 32 SIMD registers (2x the number on AVX2)

This initial patch only contains a trivial transofrmation of the Haswell SGEMM kernel
to AVX512VL; more will follow later but this patch aims to get the infrastructure
in place for this "later".

Full performance tuning has not been done yet; with more registers and wider SIMD
it's in theory possible to retune the kernels but even without that there's an
interesting enough performance increase (30-40% range) with just this change.


[PATCH] Option to add temporary points on a far sphere before
 insertion

Helps to reduce contention on the infinite vertex
But removing those points in the end takes time
so it's only worth it when points lie on a surface.


[PATCH] 1 : Store performance function 2 : Pass error into Error
 function 3 : Pass network into Error function


[PATCH] Implement OpenCL support

StreamComputing (http://www.streamcomputing.eu) has implemented the
short-ranged non-bonded interaction accleration features previously
accelerated with CUDA using OpenCL 1.1. Supported devices include
GCN-based AMD GPUs and NVIDIA GPUs.

Compilation requires an OpenCL SDK installed. This is included in
the CUDA SDK in that case.

The overall project is not complete, but Gromacs runs correctly on
supported devices. It only runs fast on AMD devices, because of a
limitation in the Nvidia driver. A list of known TODO items can be
found in docs/OpenCLTODOList.txt. Only devices with a warp/wavefront
size that is a multiple of 32 are compatible with the implementation.

Known issues include that tabulated Ewald kernels do not work (but the
analytical kernels are on by default, as with CUDA), and the blocking
behaviour of clEnqueue in Nvidia drivers means no overlap of CPU and
GPU computation occurs. Concerns about concurrency correctness with
context management, JIT compilation, and JIT caching means several
features are disabled for now. FastGen is enabled by default, so the
JIT compilation will only compile kernels needed for the current
simulation.

There is some duplication between the two GPU implementations, but
the active development expected for both of them suggests it is
not worthwhile consolidating the implementations more closely.

Change-Id: Ideaf16929028eb60e785feb8298c08e917394d0f


[PATCH] Fixes MSVC warnings. Bugfix in gmx_density in single
 precision

Disables some unhelpful MSVC warnings for:
* forcing value to bool (C4800)
    performance warning: not an issue for our code
* "this" in initializer list (C4355)
    level 4 warning (informational) - shouldn't be shown at level 3
* deprecated (posix, secure) functions (C4996)
    won't be removed soon - so not helpful

Change-Id: I7ea62f88f687f45e169244ed60025c7c7d42f237


[PATCH] Moving coord_string from returning a std::string to
 std::string_view. (#2704) (#2707)

The coord_string function is used in a lot of performance critical paths.
Moving it to return a string_view as none of these paths benefit from
making a copy of the value.


[PATCH] New thread_mpi library: waits now yield to the OS scheduler
 without significant performance penalty.


[PATCH] Separate Windows ci(gh-action) workflow and some improvs

Splitting the windows ci job into a separate workflow enables the
ci to re-run windows specific jobs independent of unix jobs.

Updated Ninja dependency to 1.10.2 fix release in all ci(gh-actions)

Refactored boost dependency to be installed via packages managers as
GitHub Actions is removing pre-installed versions from March 8, 2021

Update VCPKG hash to newer version to enable fast and better ports.

(cherry picked from commit 58573eda4ded71fe4e0be6305a6f71386d175d12)


[PATCH] Finished initial implementation for arbitrary sizes atomic
 operations

This implements atomic operations for arbitrarily sized objects.
The implementation uses a hash table approach, where a lock is set
based on a hash of the memory address of the object for which an
atomic operation should be performed.
Initial performance results indicate that it is comparable to
other non-native atomics (i.e. CAS loops with casting to integer
types).
The commit implements the full set of supported atomics from
Kokkos and it works in all currently existing execution spaces.
The hashtables are static sized global arrays.

Note: this commit requires relocatable-device-code being
enabled for Cuda.


[PATCH] Domain decomposition and PME load balancing for modular
 simulator

This change introduces two infrastructure elements responsible for
domain decomposition and PME load balancing, respectively. These
encapsulate function calls which are important for performance, but
outside the scope of this effort. They rely on legacy data structures
for the state (both) and the topology (domdec).

The elements do not implement the ISimulatorElement interface, as
the Simulator is calling them explicitly between task queue population
steps. This allows elements to receive the new topology before
deciding what functionality they need to run.

This commit is part of the commit chain introducing the new modular
simulator. Please see docs/doxygen/lib/modularsimulator.md for details
on the chosen approach. As the elements of the new simulator cannot all
be introduced in one commit, it might be worth to view Iaae1e205 to see
a working prototype of the approach.

Change-Id: I1be444270e79cf1391f5a228c8ce3a9934d92701


[PATCH] committed gmx_random.c and .h written by Erik Lindahl; I have
 added an extremely fast tabulated gaussian random number generator


[PATCH] Change TopologyInformation implementation

This changes TopologyInformation so that we will be able to use it
also in the legacy tools, providing a better migration path for them,
as well as making progress to removing t_topology and a lot of calls
to legacy file-reading functions.

It can now lazily build and cache atom and expanded topology data
structures, re-using the gmx_localtop_t type (intended for use by the
DD code for domain-local topologies). The atoms data structure can
also be explicitly copied out, so that tools who need to modify it can
do so without necessarily incurring a performance penalty. All these
are convenient for tools to use.

The atom coordinate arrays are now maintained as std::vector, which
might want a getter overload to make rvec * for the legacy tools.

Added tests that the reading behaviour for various kinds of inputs is
as expected. Converted lysozyme.gro to pdb, added a 'B' chain ID,
generated a .top (which needed an HG for CYS) so updated pdb and gro
accordingly. Some sasa test refdata needed fixing for that minor
change.

Provided a convenience overload of gmx_rmpbc_init that takes
TopologyInformation as input, as this will frequently be used by
tools.

Extended getTopologyConf to also return velocities, which will
be needed by some tools.

Adapted the trajectoryanalysis modules to use the new approach, which
is well covered by tests.

Refs #1862

Change-Id: I2f43e62bc2d97f5e654f15c6e474b9b71d7106ec


[PATCH] Removed KV (key-value) functionality. We will add it back in
 a few months in a much more efficient way. (#1415)