[PATCH] removed (harmless) left-over in nbnxn SIMD kernels

This improves performance of PME + p-coupling by about 5%.
With Ewald and virial, the nbnxn SIMD energy kernels were used
(some left-over development code). The plain-C code did not do this.

Change-Id: I039044fcb393bf0bcaa06f38498b2a57d60cf080


[PATCH] Extending LLL to support linearly dependent bases (and
 returning the nullity). A small performance optimization was also made by
 removing lll::ExpandQR from lll::HouseholderStep


[PATCH] JN:  memcpy on T3D is now fast enough


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


[PATCH] POWER10:  Optimize dgemv_n

Handling as 4x8 with vector pairs gives better performance than
existing code in POWER10.


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


[PATCH] Changed workgroup size to work around NVIDIA bug.  This also
 improves performance slightly.


[PATCH] - Anti-aliasing is quite slow (but in OpenGL mode). It is
 deactivated by default.

- Add a temp message in the status bar when the aliasing mode is changed.


[PATCH] less efficient but maybe portable logarithm


[PATCH] Replace gmx::Mutex with std::mutex

We use no mutexes during the MD loop, so performance is not a serious
consideration and we should simplify by using std components.
Eliminated components of thread-MPI that are now unused.

In particular, this reduces the cross-dependencies between the
libgromacs and threadMPI libraries.

Minor style improvements around set_over_alloc_dd.

Part of #3892


[PATCH] Enabling of NVidia PTX backend for SYCL & nbnxmKernel
 performance optimizations


[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] Improvement of rectangular slicing: part 2  -  fast
 implementation for large blocks of sparse matrices


[PATCH] More efficient IntegratorInternal::getDerivative for
 SXFunction #936


[PATCH] Simplify the usage of the performance function by reducing
 the template parameter.


[PATCH] Use a fixed-length arrays, avoid heap allocation.

Also reduce the default number of elements so that it runs fast enough in DBG mode.


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


[PATCH] Fixed a performance regression in multi-GPU on CUDA


[PATCH] additional output for performance tests


[PATCH] Replace vpermpd with vpermilpd

to improve performance on Zen/Zen2 (as demonstrated by wjc404 in #2180)


[PATCH] Tabulated function parameters are hardcoded in the kernel
 instead of being stored in an array.  This makes the code simpler and may
 help performance slightly.


[PATCH] New DCEL structure that allows more efficient handling of
 holes and isolated vertices. (Ron) Automatic handling of holes to remove in
 the construction visitor. (Baruch)


[PATCH] aabb tree: added plane queries in the performance section and
 demo.


[PATCH] Modernize read_inpfile

Used std::string and gmx::TextReader to simplify this. It is likely no
longer as efficient because it now makes several std::string objects
per line, but this is not a significant part of the execution time of
e.g. grompp.

Move COMMENTSIGN to cstringutil.cpp, now that this is an
implementation detail of string-handling code, rather than also used
in readinp.cpp.

Moved responsibility for stripping of comments to TextReader, reworked
its whitespace-trimming behaviour, and introduced some tests for that
class.

Introduced some TODO items to reconsider multiple behaviours where
read_inpfile ignores what could be malformed input. It is used for
grompp, xpm2ps and membed, however, so it is not immediately clear
what fixes might be appropriate, and we might anyway remove this
code shortly.

Introduced catches for exceptions that might be thrown while calling
read_inpfile (and related code that might change soon).

Added tests for newly introduced split-and-trim functionality that
supports read_inpfile.

Refs #2074

Change-Id: Id9c46d60a3ec7ecdcdb9529bba2fdb68ce241914


[PATCH] Improved performance of g_bar while reading .edr files with
 small nstenergy.


[PATCH] Add SIMD intrinsics version of simple update

To get better performance in cases where the compiler can't vectorize
the simple leap frog integrator loop and to reduce cache pressure of
the invMassPerDim, introduced a SIMD intrinsics version of the simple
leap-frog update without pressure coupling and one T-scale factor.
To achieve this md->invmass now uses the aligned allocation policy
and is padded by GMX_REAL_MAX_SIMD_WIDTH elements.
Asserts have been added to check for the padding.

Change-Id: I98f766e32adc292403782dc67f941a816609e304


[PATCH] WIP NCMesh fast single element neighbor calculation, works
 for quads


[PATCH] Added support for gettimeofday() when available to get
 microsecond resolution for wallclock time. This enables accurate performance
 benchmarks from short simulations even in parallel. When gettimeofday() is
 not available, we use time(). Time is still stored as seconds, but now as
 double instead of time_t.


[PATCH] Minor changes to mdrun -h descriptions

Hopefully these are easier to understand. The suggested application
for -pinoffset is covered in the new mdrun performance section
of the user guide, on release-5-0 branch.

Change-Id: I7bc6172a70c39c02f6ca6db17e26b08d2ca3b444


[PATCH] Interactive Molecular Dynamics (IMD)

IMD allows to interact with and to monitor a running molecular dynamics
simulation. The protocol goes back to 2001 ("A system for interactive
molecular dynamics simulation", JE Stone, J Gullingsrud, K Schulten,
P Grayson, in: ACM symposium on interactive 3D graphics, Ed. JF Hughes
and CH Sequin, pp. 191--194, ACM SIGGRAPH). The user can watch the
running simulation (e.g. using VMD) and optionally interact with
it by pulling atoms or residues with a mouse or a force-feedback
device.
Communitcation between GROMACS and VMD is achieved via TCP sockets
and thus enables controlling an mdrun locally or one running on a
remote cluster. Every N steps, mdrun receives the applied forces from
the VMD client and sends the new positions to VMD.
Other features:
- correct PBC treatment, molecules of a (parallel) simulation are made
  whole (with respect to the configuration found in the .tpr file)
- in the .mdp file, one can define an IMD group (including the protein
  but not the water for example is useful). Only the coordinates of
  atoms belonging to this group are then transferred between mdrun and
  VMD. This can be used to reduce the performance impact to an almost
  negligible level.
- adds only two single-line function calls in the main MD loop
- and mdrun test fixture checks whether grompp and mdrun understand
  the IMD options

Change-Id: I235e07e204f2fb77f05c2f06a14b37efca5e70ea


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


[PATCH] 1. Removed "task uccsdt energy"-related input examples
 because they may not work and are pointless and distracting. 2. Added 2EMET
 subsection and filled in details for all new 2emet options. 3. Added
 subsection on RESTART which is complete except for examples. 4. Updated
 response properties section slightly. 5. Added new section on performance
 suggestions since so many users need this, but only the outline exists.  I
 will fill in this content in a few days. 6. Removed other Hirata-era stuff
 that just seems out of place now.


[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] Initial check in of performance test for read-only property


[PATCH] improved performance of free energy runs in water
 significantly by allowing water-water loops and added a slight speed up for
 neighborsearching for free-energy runs


[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] More efficient SystemBase::reinit, flux_jump indicator should
 work but needs testing

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


[PATCH] Update tmop_pa_h3m kernel with fast mode


[PATCH] Create dedicated subcounter for nonbonded FEP

Now all nonbonded work has their own separate subcoutners which allows
measuring the performance of each task separately.

Refs #2997

Change-Id: I601445364592923d08087a858da4629b0b58ae76


[PATCH] introducing info on elements in the overlap regions for more
 efficient calculation of the characteristic function (restriction to part of
 the mesh)


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


[PATCH] genbox now performs as expected. fast and reliable.


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


[PATCH] Improve implementation of cycle subcounting

Configuring with GMX_CYCLE_SUBCOUNTERS on is intended to make active
some counters that show finer-grained timing details, but its
implementation with the preprocessor was more complex and more bug
prone than this one. Static analysis now finds the bug where we
over-run buf (fixed here and in release-5-1).

The only place we care about performance of the subcounter
implementation is that it doesn't do work when GMX_CYCLE_SUBCOUNTERS
is off, and constant propagation and dead code elimination will handle
that.

Also moved some declarations into the blocks where they are used.

Change-Id: I3d7a06a65c636c11557a094997a7a81f86a1ed8a


[PATCH] improved performance MatvecCommPkgCreate


[PATCH] Use SIMD transpose scatter in bondeds

The angle and dihedral SIMD functions now use the SIMD transpose
scatter functions for force reduction. This change gives a massive
performance improvement for bondeds, mainly because the dihedral
force update did a lot of vector operations without SIMD that are
now fully replaced by SIMD operations.

Change-Id: Id08e6c83d4c9943d790bfe2a40c70fa4697077af


[PATCH] Changed par_amg_setup so that
 hypre_BoomerAMGBuildCoarseGridOperator() is no longer used (Ulrike ran some
 performance studies of this).  Two separate mat-mults are now used to compute
 (P^T (A P)).  This change is important to the non-Galerkin code, because
 here, AP[Cpts,:] is used to compute a minimal sparsity pattern.  So, by
 keeping (A P) from (P^T (A P)), we avoid a lot of duplicate communication and
 computation in non-Galerkin code.

This commit also removes any lumping to the diagonal inside the non-Galerkin
code.


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


[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] Fixed FAST type comparison mismatch warning


[PATCH] Optimize the performance of dot by using universal intrinsics
 in X86/ARM


[PATCH] More efficient Sparsity::serialize


[PATCH] Added parallel performance to the doc


[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] Increase release build timeout, macos is being a bit slow on
 Azure (#2495) (#2496)

Co-authored-by: Seth Shelnutt <seth@tiledb.io>


[PATCH] increased granularity of performance logging, fixed a bug in
 DofMap::add_neighbors_to_send_list() which caused the _send_list to become
 excessively large.  Further, this slowed the DofMap::sort_send_list() method
 considerably.


[PATCH] Avoid setting config on transient subarray (#2740)

For the existing `tiledb_query_add_range` APIs there is a transient
subarray object that is referenced. In one API the query config was also
being set on this subarray. This is not required, and other variations
of `tiledb_query_add_range` did not set the config. Removing this saves
a few seconds of the WALL time when a user is setting hundreds of
thousands of ranges.

The performance bottleneck comes in when the config is copied which is a
full copy of the config map. This was being done once per range setting.

Instead to maintain current behavior setting the query config also sets
the subarray config.


[PATCH] Performance Improvements - changed Cartesian to
 Simple_cartesian in the examples - changed list to vector in the code -
 removed unnecessary includes - introduced multipass_distance


[PATCH] Slightly improved performance, and small refinements


[PATCH] Fixed a potential performance bug in the KDE code that
 resulted in a stricter pruning criterion.


[PATCH] Knowing when the tree fails and we're stuck with a linear
 search is useful for performance testing too


[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] GetPot: Use a more efficient container for UFO detection


[PATCH] functionObjects: surfaceFieldValue, volFieldValue: Various
 improvements

A number of changes have been made to the surfaceFieldValue and
volFieldValue function objects to improve their usability and
performance, and to extend them so that similar duplicate functionality
elsewhere in OpenFOAM can be removed.

Weighted operations have been removed. Weighting for averages and sums
is now triggered simply by the existence of the "weightField" or
"weightFields" entry. Multiple weight fields are now supported in both
functions.

The distinction between oriented and non-oriented fields has been
removed from surfaceFieldValue. There is now just a single list of
fields which are operated on. Instead of oriented fields, an
"orientedSum" operation has been added, which should be used for
flowRate calculations and other similar operations on fluxes.

Operations minMag and maxMag have been added to both functions, to
calculate the minimum and maximum field magnitudes respectively. The min
and max operations are performed component-wise, as was the case
previously.

In volFieldValue, minMag and maxMag (and min and mag operations when
applied to scalar fields) will report the location, cell and processor
of the maximum or minimum value. There is also a "writeLocation" option
which if set will write this location information into the output file.
The fieldMinMax function has been made obsolete by this change, and has
therefore been removed.

surfaceFieldValue now operates in parallel without accumulating the
entire surface on the master processor for calculation of the operation.
Collecting the entire surface on the master processor is now only done
if the surface itself is to be written out.


[PATCH] Replaced the "visited_facets" array (parallel version) by an
 atomic char

It's as fast, and it required less memory.


[PATCH] issue #2389: re-adding MapSum Function fore efficient
 reduce_in/out


[PATCH] Fixed FAST memory leaks on CUDA backend


[PATCH] IQN-ILS modified such that the coomunication of the rhs uses
 the efficient MPI_Reduce operation if MasterSlave comm is configured with
 mpi-single, i.e., MPIDirect. All tests are working ... still check coupling
 iterations, i.e., performance of IQN-ILS


[PATCH] convert pair styles in USER-OMP to use fast DP analytical
 coulomb


[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] Add content to user guide

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

Change-Id: I2a18528729dc6756be093e52e6f87f9df9fe3b94


[PATCH] implemented more efficient Ruge-coarsening


[PATCH] fix minor CUDA NB kernel performance regression

Commit f2b9db26 introduced the thread index z component as a stride in
the middle j4 loop. As this index is not a constant but a value
loaded from a special register, this change caused up to a few %
performance loss in the force kernels. This went unnoticed because
some architectures (cc 3.5/5.2) and some compilers (CUDA 7.0) were
barely affected.

Change-Id: I423790e8fb01a35f7234d26ff064dcc555e73c48


[PATCH] Moved FAST description to docs directory.

Additionally indented FAST parameter documentation.


[PATCH] sbgemm: spr: enlarge P to 256 for performance


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


[PATCH] Modified locate region to use more efficient algorithms for
 most block-cyclic distributions.


[PATCH] Working on performance improvements


[PATCH] document "slow" and "unstable" labels for unit tests


[PATCH] Use a priority queue (heap) to store the list of candidates
 while searching. This makes the code more efficient, especially when k is
 greater. For example, for knn, given a list of k candidates neighbors, we
 need to do 2 fast operations:  - know the furthest of them.  - insert a new
 candidate. This is the appropiate situation for using a heap.


[PATCH] CouplingMatrix::operator&=

The user and library may need to use the output of a bunch of coupling
functors, and this should be more efficient than carrying around a
bunch of matrices and iterating through all of them.


[PATCH] Significant DBSCAN refactoring and improvements.

 - Use PARAM_MATRIX() instead of strings.
 - Add a single-point mode that handles RAM better.
 - Use UnionFind for much more efficient cluster finding.
 - Make --single_mode use the single point mode.


[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] 1 : Store performance function 2 : Pass error into Error
 function 3 : Pass network into Error function


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


[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] List: Reinstated construction from two iterators and added
 construction from an initializer list

Until C++ supports 'concepts' the only way to support construction from
two iterators is to provide a constructor of the form:

        template<class InputIterator>
        List(InputIterator first, InputIterator last);

which for some types conflicts with

        //- Construct with given size and value for all elements
        List(const label, const T&);

e.g. to construct a list of 5 scalars initialized to 0:

    List<scalar> sl(5, 0);

causes a conflict because the initialization type is 'int' rather than
'scalar'.  This conflict may be resolved by specifying the type of the
initialization value:

    List<scalar> sl(5, scalar(0));

The new initializer list contructor provides a convenient and efficient alternative
to using 'IStringStream' to provide an initial list of values:

    List<vector> list4(IStringStream("((0 1 2) (3 4 5) (6 7 8))")());

or

    List<vector> list4
    {
        vector(0, 1, 2),
        vector(3, 4, 5),
        vector(6, 7, 8)
    };


[PATCH] UList::swap: implemented fast version which swaps the size
 and storage pointer


[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.

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


[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] Step towards better performance regarding second convergence
 test in bicgstab


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


[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] Improved performance of Python State objects


[PATCH] -added support for the new version of RS -fixed some minor
 bugs -now the kernel uses directly the extremely fast RS refinement function
 -updated the generic kernel tests accordingly


[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] ex1p: implement pa jacobi preconditioning

Performance is disappointing at the moment.


[PATCH] Minor fixes to mdrun performance documentation

In "Examples for mdrun on one node," third example description, the respective number
of thread-mpi ranks and OpenMP threads per rank were reversed.

In "Examples for mdrun on one node," 6th example. For 12 logical cores, the pinoffsets
should be 0 and 6, respectively (I think)

A few command line examples of running mdrun with more than 1 node used gmx rather
than gmx_mpi

Several spelling/grammar/tense error/linking issues addressed.

Change-Id: I014bc52d55cda1cbd05843cb8e960c2a2d7cbb47


[PATCH] Replace some std::endl with newline character

Note that std::endl flushes the buffer, so we can get better
performance by using newlines when there is no need to flush.


[PATCH] Use AVX512 also for DGEMM

this required switching to the generic gemm_beta code (which is faster anyway on SKX)
for both DGEMM and SGEMM

Performance for the not-retuned version is in the 30% range


[PATCH] Use fast returns in md5 computation

This logic is easier to follow than a recycled ret integer

Change-Id: Idc47cdae3d0453f1645a82582b13c86aa8eadcb8


[PATCH] Don't preallocate USMObjectMem

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


[PATCH] Rationalize HAVE_FMA

Distinguish ARCH_PREFERS_FMA, for architectures that "naturally"
prefer FMA (e.g., powerpc), from ISA_EXTENSION_PREFERS_FMA, for
instruction-set extensions that favor FMA where the base architecture
does not (e.g., avx2 on x86).

Previously, --enable-avx2 would use FMA code for scalar and avx
codelets, which is wrong.

This change improves performance by a few percent on Ryzen (where FMA
doesn't really do anything), and is a wash on Haswell.


[PATCH] Make ImdSession into a Pimpl-ed class with factory function

This prepares to make IMD into a proper module. No
functionality changes in this commit.

Replaced gmx_bool with bool

Used fast returns when IMD is inactive, for better
readability of code.

Refs #2877

Change-Id: Ibbe8c452f6f480e9a357fe1b87da3ab0ae166317


[PATCH] Simplifying ARMv8 build parameters

ARMv8 builds were a bit mixed up, with ThunderX2 code in ARMv8 mode
(which is not right because TX2 is ARMv8.1) as well as requiring a few
redundancies in the defines, making it harder to maintain and understand
what core has what. A few other minor issues were also fixed.

Tests were made on the following cores: A53, A57, A72, Falkor, ThunderX,
ThunderX2, and XGene.

Tests were: OpenBLAS/test, OpenBLAS/benchmark, BLAS-Tester.

A summary:
 * Removed TX2 code from ARMv8 build, to make sure it is compatible with
   all ARMv8 cores, not just v8.1. Also, the TX2 code has actually
   harmed performance on big cores.
 * Commoned up ARMv8 architectures' defines in params.h, to make sure
   that all will benefit from ARMv8 settings, in addition to their own.
 * Adding a few more cores, using ARMv8's include strategy, to benefit
   from compiler optimisations using mtune. Also updated cache
   information from the manuals, making sure we set good conservative
   values by default. Removed Vulcan, as it's an alias to TX2.
 * Auto-detecting most of those cores, but also updating the forced
   compilation in getarch.c, to make sure the parameters are the same
   whether compiled natively or forced arch.

Benefits:
 * ARMv8 build is now guaranteed to work on all ARMv8 cores
 * Improved performance for ARMv8 builds on some cores (A72, Falkor,
   ThunderX1 and 2: up to 11%) over current develop
 * Improved performance for *all* cores comparing to develop branch
   before TX2's patch (9% ~ 36%)
 * ThunderX1 builds are 14% faster than ARMv8 on TX1, 9% faster than
   current develop's branch and 8% faster than deveop before tx2 patches

Issues:
 * Regression from current develop branch for A53 (-12%) and A57 (-3%)
   with ARMv8 builds, but still faster than before TX2's commit (+15%
   and +24% respectively). This can be improved with a simplification of
   TX2's code, to be done in future patches. At least the code is
   guaranteed to be ARMv8.0 now.

Comments:
 * CortexA57 builds are unchanged on A57 hardware from develop's branch,
   which makes sense, as it's untouched.
 * CortexA72 builds improve over A57 on A72 hardware, even if they're
   using the same includes due to new compiler tunning in the makefile.


[PATCH] Adding Changelog for Release 3.3.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.3


[PATCH] more efficient jacobian of mapping modes


[PATCH] Pair of send(vector) -> send(vector<pair>)

This may be more efficient in some cases and it should be easier to
refactor shortly.


[PATCH] Update GMM code.  It should be a little faster training, but
 it is still too slow for my preferences.  I am not sure what is making it so
 slow.


[PATCH] Use smaller block size on smaller system I/O - this seems to
 fix a performance problem found by Jens Lohne Eftang


[PATCH] Exploiting memory layout for better performance in
 matrix-free restriction


[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] Crucial bug fix - table lookup was too slow in the previous
 version.


[PATCH] Fixes for style and performance issues found by cppcheck


[PATCH] Tests for valid periodic actions

We expect that mdrun propagation is unaffected by changing mdp options
that determine whether output is written. However, orchestrating mdrun
to collect and compute such data without affecting the propagation is
complex and currently very fragile. New propagation approaches must be
able to be tested.

Many mdrun combinations of periodic outputs and periodic action of
simulation modules that affect propagation are compared for
correctness against a simulation that did every action at every step.

These tests are fairly slow, so are in their own test binary and
annotated appropriately. They run by default only in release-type
builds. As they target testing the kind of coordination issues that
tend to appear in multi-rank runs, those runs are specifically
targeted.

The energy tolerance for the mdrun test were far too tight. It seems
that tests passed anyhow because they compared runs under exactly
the same run conditions using (nearly) the same summation order.
This change slightly increases the tolerance for energies and
massively the tolerance for pressure comparison.

Change-Id: I88ea643873ebec0e5e2b12181f4b51ad90c7b0f7


[PATCH] Fix cycle counting in StatePropagatorDataGpu

Double-counting resulted in broken/truncated performance acounting
table.

Fixes #3764


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

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


[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] Traits class inherits from Hyperbolic traits now; TODO:
 investigate why triangulation is so slow


[PATCH] made GMX_FORCE_ENERGY a separate flag

GMX_FORCE_ENERGY was (temporarily) defined as GMX_FORCE_VIRIAL.
Now it is a separate flags, which is less confusing. This allows
nstcalcenergy to be larger than nstpcouple, which improves performance
with the SSE and CUDA kernels.


[PATCH] Accelerate AABB tree traversal by passing the tolerance as
 initial min_dist


[PATCH] Add a CMake warning about FFTW with --enable-avx

FFTW_MEASURE runs single-threaded tests for FFT performance, which is
very different from the GROMACS usage pattern, particularly with how
the cache access pattern works. In practice, with FFTW 3.3.2 and
3.3.3, the performance of FFTW with --enable-avx is considerably
worse than that of FFTW with --enable-sse or --enable-sse2. It's
unlikely but theoretically possible that performance might change,
so we prompt the user both to avoid --enable-avx now, and to
perhaps consider it in the future.

Change-Id: Ib4906645587cfc6a6306a7f7f46d612a6446b156


[PATCH] Fix fast for CUDA 9. Use CUB library for reductions

FAST was failing on CUDA 9 because of insufficient synchronization in the
reduction of the non_max_count function. The reduction is now implemented
using BlockReduce from CUB.

This also adds CUB as a dependency which is brought in as a submodule.


[PATCH] QN update is now in Base class - subclasses onla compute the
 update. Changed computation of QN-Update for MVQN: use QR decomposition of
 matrix V, instead of LU decomposition of VTV. More efficient and more robust
 implementation


[PATCH] added fast global atom nr. to molecule lookup

Most atom search functions in mtop_util now use binary search.


[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] reactingMultiphaseEulerFoam: Added referencePhase option

In multiphase systems it is only necessary to solve for all but one of the
moving phases.  The new referencePhase option allows the user to specify which
of the moving phases should not be solved, e.g. in constant/phaseProperties of the
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed tutorial case with

phases (particles air);

referencePhase air;

the particles phase is solved for and the air phase fraction and fluxes obtained
from the particles phase which provides equivalent behaviour to
reactingTwoPhaseEulerFoam and is more efficient than solving for both phases.


[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] #1295 Refactored MX::setSub(single argument) This should be
 significantly more efficient, though I didn't do any performance testing


[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] tutorials/lagrangian: Added mixedVesselAMI2D

This tutorial demonstrates moving mesh and AMI with a Lagrangian cloud.
It is very slow, as interaction lists (required to compute collisions)
are not optimised for moving meshes. The simulation time has therefore
been made very short, so that it finishes in a reasonable time. The
mixer only completes a small fraction of a rotation in this time. This
is still sufficient to test tracking and collisions in the presence of
AMI and mesh motion.

In order to generate a convincing animation, however, the end time must
be increased and the simulation run for a number of days.


[PATCH] gauge_field::FloatNOrder can now use __ldg loads.  Generally
 improves performance across the board, but some regressions at 12/8
 reconstruct so left switched off for now (USE_LDG macro in
 include/gauge_field_order.h).


[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] Improved performance of prolongator through exposing
 intstruction-level parallelism.  This enables full bandwidth to be achieved
 on Maxwell.


[PATCH] Update unit tests and performance tests

Co-authored-by: Daniel Arndt <arndtd@ornl.gov>


[PATCH] Cache n_nodes/sides/edges in DofMap constraints

We loop over each of these ranges multiple times, so doing the loop
end manually should more efficient than even the new range idiom.


[PATCH] Enable mac CI testing on azure pipelines

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


[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] Better workaround of g++ 4.1 optimizer bug:
 -fno-strict-aliasing. Performance penalty is 5% vs 24% with -O


[PATCH] Cleaning code, Sylvain should take a look to the previous
 version of this file and Root_of_2.h because there is an obvious slow down in
 the execution of all the filtering kernels


[PATCH] aabb tree: added curve in performance section


[PATCH] Expand Performance section of the user guide

Salvage and clean up the content from the wiki to expand the user
guide. Minor fixes to the rest of the Performance section.

Change-Id: I39aba257c4c761a3a1ef428c64424da6fa449158


[PATCH] Add Line_2 to Efficient RANSAC traits


[PATCH] resolved an exception issue which could make PME slow


[PATCH] Better optimized ICC release flags

Add those flags included in -fast which both helps performance
and are appropriate for GROMACS.

The flags included in -fast for Linux we weren't using were:
-ipo, -no-prec-div, -static, -fimf-domain-exclusion=15

Full static depends on static libraries to be installed and thus
will not always work. IPO increases compile time by a huge factor.
We do require that extreme values (e.g. large negative arguments
to exp and large positive to erfc) are computed correctly.

This leaves -no-prec-div -fimf-domain-exclusion=14 -static-intel
as safe and useful flags for GROMACS.

Change-Id: Ifbee69431841e3051c95f0b4c0ad204aac965c4e


[PATCH] Optimize the script (from 20 minutes to 0.3 seconds!)

- avoid opening and reading the file `processed_test_results` thousands
  of time: its content is stored once in a hash, for fast lookup,

- do not call `fuser` for files that are already processed


[PATCH] updated log performance stats

- added #of threads column
- renamed "Number" column to "Count"
- swapped "Second" and "G-cycles" columns to have the former aligned
  with the GPU timing table
- removed Mnbf/s and GFlops from default output, turning these back on is
  still possible via the GMX_DETAILED_PERF_STATS env var
- normalized the NODE time and % stats with the number of cores


[PATCH] Simplify AVX integer load/store

Also has the potential to improve performance on some architectures
(if there is a domain crossing penalty - not sure whether any AVX capable
generation has a penalty).

Change-Id: Icc7b136571fc9ad1dbabeabe446c93e8816ec678


[PATCH] Improving performance of right Trsm routines based on
 suggestions from Bryan Marker.


[PATCH] Force field updates.

New order for SWM4-NDP and SWM6 topologies, with SETTLE
instead of 3 constraints.  Performance is slightly better
in this case.  Uploading a SWM4-NDP water box that has
been equilibrated for 100 ps to serve as input for gmx
solvate.

Change-Id: I67e10693ca76e77b99b371ea9887402e7ac0acc1


[PATCH] Adding the ability to convert the dist rank, cross rank, and
 redundant rank for a particular distribution to the VC rank and subsequently
 making use of this to improve the performance of the GetSubmatrix routine for
 AbstractDistMatrix


[PATCH] Added a few lines regarding the GA array distribution but,
 only performance bug and results were still correct.


[PATCH] converted part of rhogen to daxpy getting performance
 improvement on ia64


[PATCH] Increase memory allocation for NPT simulation in Ewald.cpp.
 Assign linear molecule with 3 and more atoms to DCGraph at higher level to
 improve code performance


[PATCH] fix performance issue--forgot to move name parameters


[PATCH] add slow tag to about 60 tests that take about as much time
 as the 430 others


[PATCH] reverted commit 76d5bddd5c3dfdef76beaab8222231624eb75e89.
 Split ga_acc in moints2x_trf2K in smaller ga_acc on MPI-PR since gives large
 performance improvement on NERSC Cori


[PATCH] 1 : Store performance function 2 : Pass error into Error
 function 3 : Pass network into Error function 4 : Add public api to access
 underlying network 5 : Use perfect forwarding to accept LayerTypes


[PATCH] Add DenseMatrix::svd_solve().

This function fills a missing requirement in the DenseMatrix classes,
allowing us to solve non-square systems of equations in a
least-squares sense.  The user can pass a tolerance to svd_solve()
which determines the cutoff for small singular values. svd_solve() is
a const member function: we make a copy internally instead of allowing
Lapack to modify A.

Note that Eigen also has the capability to solve non-square systems of
equations, but it is relatively slow, as discussed in this thread:
https://forum.kde.org/viewtopic.php?f=74&t=102088, so having our own
Lapack-based implementation is worthwhile.


[PATCH] Use pre-trained network to accelerate test


[PATCH] Add DofMap::is_evaluable()

This is O(log(send_list.size())), which may be fast enough for most
users; there's no obvious way to do better without unsorted_set.


[PATCH] convert a few more styles to use fast full DP erfc()


[PATCH] Fixed FAST memory leaks on OpenCL backend


[PATCH] BJP: Cleaned up code a little to make it easier to use for
 performance testing.


[PATCH] polygonTriangulate: Added robust polygon triangulation
 algorithm

The new algorithm provides robust quality triangulations of non-convex
polygons. It also produces a best attempt for polygons that are badly
warped or self intersecting by minimising the area in which the local
normal is in the opposite direction to the overal polygon normal. It is
memory efficient when applied to multiple polygons as it maintains and
reuses its workspace.

This algorithm replaces implementations in the face and
faceTriangulation classes, which have been removed.

Faces can no longer be decomposed into mixtures of tris and
quadrilaterals. Polygonal faces with more than 4 sides are now
decomposed into triangles in foamToVTK and in paraFoam.


[PATCH] GetPot: Use a more efficient container for UFO detection

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


[PATCH] Knowing when the tree fails and we're stuck with a linear
 search is useful for performance testing too

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


[PATCH] Optimized the performance of the CG-based LPR algorithm


[PATCH] Global optimizers: better parallel performance

- We used to have a thread-local variable for cell::TDS_data to make
  incident_cells concurrently callable but it was slow and memory-consuming
  => new incident_cells function which do not use cell::TDS_data
  => faster and lighter
- update_restricted_delaunay now uses parallel_for instead of parallel_do
  (it was quite slow with the implicit oracle)
  => faster (but requires to fill a temporary vector)


[PATCH] Added missing memory deletions on FAST unit test.


[PATCH] switch from int to bool to avoid a performance warning


[PATCH] sbgemm: cooperlake: reorder ptr increase for performance


[PATCH] Reduced the cost of the pull communication

With more than 32 ranks, a sub-communicator will be used
for the pull communication. This reduces the pull communication
significantly with small pull groups. With large pull groups the total
simulation performance might not improve much, because ranks
that are not in the sub-communicator will later wait for the pull
ranks during the communication for the constraints.

Added a pull_comm_t struct to separate the data used for communication.

Change-Id: I92b64d098b508b11718ef3ae175b771032ad7be2


[PATCH] Changed slow convergence stop criteria.


[PATCH] New and reorganized documentation

Covers more mdrun options, moves a bit of "practical" content from the
reference manual to the user guide.

Imported and updated information from wiki page on cutoff
schemes. Consolidated with information from reference manual.

Updated some use of "atom" to "particle" in both guides.

We could update the performance numbers, but with the impending
removal of the group scheme, I don't think that's worth bothering
about. e.g. on Haswell, Erik already tested performance of group is a
bit slower than Verlet, even for unbuffered water systems.

Change-Id: I6410ba9fc08bb133ec8669e14dba11bcbd454fe3


[PATCH] propagate lower bound for culling on TM1 to accelerate
 symmetric distance


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


[PATCH] Make Constraints a proper class

Converted the opaque C struct to a pimpl-ed C++ class.

Numerous callers of constraint routines now don't have to pass
parameters that are embedded within the class at setup time,
e.g. for logging, communication, per-atom information,
performance counters.

Some of those parameters have been converted to use const references
per style, which requires various callers and callees to be modified
accordingly. In particular, the mtop utility functions that take const
pointers have been deprecated, and some temporary wrapper functions
used so that we can defer the update of code completely unrelated to
constraints until another time. Similarly, t_commrec is retained as a
pointer, since it also makes sense to change globally.

Made ConstraintVariable an enum class. This generates some compiler
warnings to force us to cover potential bug cases with fatal errors.
Used more complete names for some of the enum members.

Introduced a factory function to continue the design that constr is
nullptr when we're not using constraints.

Added some const correctness where it now became necessary.

Refs #2423

Change-Id: I7a3833489b675f30863ca37c0359cd3e950b5494


[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] Limit SMT with PME on GPU

For small numbers of atoms per core, SMT can seriously deteriorate
performance when running both non-bondeds and PME on GPU.
With fewer than 10000 atoms per core, SMT is now always off by default
with PME on GPU and auto settings.

Change-Id: I1a6b83bc81f68e89bf443e2b0ddb1fde44e2361d


[PATCH] - Insert a random sample of the polyhedron points, instead of
 the first   points, to avoid having a triangulation of dimension < 3 - Set
 the error_behavior to ABORT, so that the try/catch of the Qt4 main   loop
 does not intercept our CGAL assertions (that prevents efficient   debugging).


[PATCH] Finally, a fully parallel version of the refinement. Not very
 efficient, though, but the idea was to identify all data races and to protect
 it using locks, atomics, TLS... Needs some tests now, to check if we didn't
 miss any rare data race.


[PATCH] Fixed data filename on FAST unit test.


[PATCH] Fixes for style and performance issues found by cppcheck

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


[PATCH] PASSMESS_LOG_SCOPE - disabled for now

I don't really want to drag the whole PerfLog into PassMess, but can't
think of a better way to do built-in performance logging here.


[PATCH] Performance improvements to kd_tree_test, added peer bounds
 checking.


[PATCH] resolved performance degrating changed introduced in revision
 1319


[PATCH] Adding Changelog for Release 3.3.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.3

(cherry picked from commit bd0c2c3713448f4d00b54998a42696ced1c1a188)


[PATCH] Move early return for nbnxm force reduction

To reduce dependencies and code complexity, the early return for
avoiding overhead of a force reduction reducing no forces at all
has been moved from nonbonded_verlet_t to atomdata.cpp. The check
has been changed from no non-local work to no non-local atoms, which
should not affect performance much.

Change-Id: I3315699e15918482b321b702f6ba24209aa3a6b2


[PATCH] Improved performance on AMD GPUs


[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] commented out fast f77 compile options


[PATCH] Fix performance report when init_step!=0

Change-Id: Ia4e15c2fb9b0e3debe7fc7f2aa8a1cdf346f90cb


[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.


[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] SolverPerformance: Complete the integration of the templated
 SolverPerformance<Type>

Now solvers return solver performance information for all components
with backward compatibility provided by the "max" function which created
the scalar solverPerformance from the maximum component residuals from
the SolverPerformance<Type>.

The residuals functionObject has been upgraded to support
SolverPerformance<Type> so that now the initial residuals for all
(valid) components are tabulated, e.g. for the cavity tutorial case the
residuals for p, Ux and Uy are listed vs time.

Currently the residualControl option of pimpleControl and simpleControl
is supported in backward compatibility mode (only the maximum component
residual is considered) but in the future this will be upgraded to
support convergence control for the components individually.

This development started from patches provided by Bruno Santos, See
http://www.openfoam.org/mantisbt/view.php?id=1824


[PATCH] the mistery of the missing MIC performance on Intel 16 might
 be fixed with -qopt-assume-safe-padding


[PATCH] PBiCGStab: New preconditioned bi-conjugate gradient
 stabilized solver for asymmetric lduMatrices using a run-time selectable
 preconditioner

References:
    Van der Vorst, H. A. (1992).
    Bi-CGSTAB: A fast and smoothly converging variant of Bi-CG
    for the solution of nonsymmetric linear systems.
    SIAM Journal on scientific and Statistical Computing, 13(2), 631-644.

    Barrett, R., Berry, M. W., Chan, T. F., Demmel, J., Donato, J.,
    Dongarra, J., Eijkhout, V., Pozo, R., Romine, C. & Van der Vorst, H.
    (1994).
    Templates for the solution of linear systems:
    building blocks for iterative methods
    (Vol. 43). Siam.

See also: https://en.wikipedia.org/wiki/Biconjugate_gradient_stabilized_method

Tests have shown that PBiCGStab with the DILU preconditioner is more
robust, reliable and shows faster convergence (~2x) than PBiCG with
DILU, in particular in parallel where PBiCG occasionally diverges.

This remarkable improvement over PBiCG prompted the update of all
tutorial cases currently using PBiCG to use PBiCGStab instead.  If any
issues arise with this update please report on Mantis: http://bugs.openfoam.org


[PATCH] HvD: Dealing with the issues associated with higher order
 derivatives in automatic differentiation and closed shell calculations. The
 problem addressed in particular is that of triplet excited states in TDDFT.
 Even though the ground state is closed shell the excitation energy is clearly
 a spin dependent quantity. Essentially we can deal with this situation
 effectively only if we evaluate the functional as if we are doing an open
 shell calculation. Doing so degrades performance but the automatic
 differentiation approach is significantly slower than the symbolic algebra
 generated code anyway. Hence performance cannot be the main reason for using
 this code in any case.


[PATCH] Improved performance of bicgstab after adding the second
 convergence test.


[PATCH] Fixed slow COO SpMV for the OpenMP executor

Moved the `omp parallel for` to the most outer loop of the apply,
so it is parallelized over the matrix entries instead over the number
of right hand sides for every single matrix entry.


[PATCH] enable GPU emulation without GPU support

GPU emulation can be useful to estimate the performance one could get
by adding GPU(s) to the machine by running with GMX_EMULATE_GPU and
GMX_NO_NONBONDED environment variables set. As this feature is useful
even with mdrun compiled without GPU support, this commit makes GPU
emulation mode always available.

Change-Id: I0b90b8ec1c6e3116f28f66aac4f3c8ae0831239d


[PATCH] replace the edge map by a vector of flat_map

it is very efficient since there should not be isolated vertices.
On large data, the runtime of the function is divided by 3 to 4


[PATCH] performance improvement for DD assignment of settles with
 cg's


[PATCH] added benchmark comparing the performance of the two traits
 classes (CK vs CORE::Expr)


[PATCH] Fix for #1139 performance regression bug (and #1140 for
 tracking). Set default CUDA launch bounds to <0,0> and when do not use CUDA
 __launch_bounds__ unless CUDA launch bounds are explicitly specified.


[PATCH] #1295 More efficient implementation of A[I] = B


[PATCH] functionObjects::wallHeatFlux: More efficient evaluation of
 heat-flux

which avoids the need for field interpolation and snGrad specification and
evaluation.

Resolves patch request https://bugs.openfoam.org/view.php?id=2725


[PATCH] nonUniformTableThermophysicalFunction: New non-uniform table
 thermophysicalFunction for liquid properties

Description
    Non-uniform tabulated property function that linearly interpolates between
    the values.

    To speed-up the search of the non-uniform table a uniform jump-table is
    created on construction which is used for fast indirect addressing into
    the table.

Usage
    \nonUniformTable
        Property    | Description
        values      | List of (temperature property) value pairs
    \endnonUniformTable

    Example for the density of water between 280 and 350K
    \verbatim
    rho
    {
        type    nonUniformTable;

        values
        (
            (280 999.87)
            (300 995.1)
            (350 973.7)
        );
    }
    \endverbatim


[PATCH] Reducers: fix performance issue #680

Adding non-volatile join helps.


[PATCH] issue #939: more efficient kronecker product for
 Sparsity/Matrix


[PATCH] Sparse refactored readers: Better vectorization for tile
 bitmaps calculations. (#2711)

* 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] Update paper.md

Specify SpMV performance results.


[PATCH] Performance improvments to CPU Anisotropic Diffusion (#2174)

* Performance improvments to CPU Anisotropic Diffusion


[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] performance optimizations in sgemm_kernel_16x2_bulldozer.S


[PATCH] fix for no performance logging

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


[PATCH] Add doSetup parameter to Matrix::init

Not calling doSetup can give you performance gains when using
preallocation on the matrix.


[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] Adding optional wrappers for MKL CSR mat-vec, allowing for
 more configure-time math library detection, adding a Hermitian version of
 Lanczos, and greatly improving the performance of right
 DiagonalScale/DiagonalSolve. It appears that the current distributed sparse
 matrix-vector multiplication has scalability issues.


[PATCH] Remove use of interaction_mask_indices on BG/Q

This field was degrading cache performance ~1% on x86. It probably
made little difference on BG/Q, because the extra integer operations
can use the second instruction-issue port, assuming the use of OpenMP
to use more than one hardware thread per core. Overall, this code is
about 1% faster on BG/Q.

Minor fix to the gmx_load_simd_4xn_interactions() function that looks
up the exclusion masks, so that new non-x86 platforms won't silently
fail for want of an implementation of this function.

Minor simplication to always pass simd_interaction_indices to
gmx_load_simd_4xn_interactions(), since it is only used on BG/Q and
then it is non-null.

Change-Id: I140a11607810e9cf08b702cae0b48426c3592fec


[PATCH] Removing gigaflop utility functions, removing illegal 'const'
 declarations in unblocked TwoSidedTrmm routines, fixing comments in several
 DistMatrix declarations, and adding a Trsv test driver in preparation for a
 significant performance improvement from an upcoming patch.


[PATCH] Improve performance of MIC exponential

The limited precision is due to argument scaling
rather than the exponential function lookup, so
instead of iterating we can improve the accuracy
with a simple correction step, similar to what
was done for the recent AVX-512ER implementation.

Change-Id: If55e7c4cefac5022e7211dfa56686cb9ee03a54a


[PATCH] performance improvements on grid_ssw


[PATCH] Fix performance problems for large molecular systems


[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] Removed KV (key-value) functionality. We will add it back in
 a few months in a much more efficient way. (#1415)


[PATCH] Use new ranges in MeshTools

Plus manual caching, where it's more efficient


[PATCH] Fast forward porting work to master

Change-Id: Ieb428e4a001efadf880dbe2c64c2a685cebdd4ae


[PATCH] On second thoughts, follow Kokkos best performance
 recommendations when setting OpenMP env vars


[PATCH] Call full Kokkos::initialize in performance tests


[PATCH] Replace the comparison of 2 lines with a more efficient one
 (just for this specific case where direction doesnt matter).


[PATCH] Append all ICC Performance flags only to Release Flags

Some of the ICC performance flags were appended to GMXC_CFLAGS
and thus also used e.g. for Debug.

Change-Id: Iadfaa29fb347f24208e6f2406e0d1ad41f037804


[PATCH] Accelerate 3D version of inexact_locate as we do it for 2D

see commit 4c477c853c82bb1ca77bb496cdce993178c3dfa2


[PATCH] Fix SIMD configuration management

Subsequent runs of cmake gave inconsistent diagnostic messages because
SUGGEST_BINUTILS_UPDATE was not set on subsequent runs because we were
caching the result of logic, as well as caching the results of
compilation tests. This made life confusing, e.g. when compiling with
gcc on MacOS with clang assembler not available.

Instead, we now re-run the fast logic (quietly, if this is a
subsequent run).

Improved the handling of ${VARIABLE}, because there was no need to use
FORCE because the semantics of an unset variable in CMake just work.
There was also no need for such variables to be put into the cache,
and we were using one more variable than we needed to use. This meant
it was no longer worth implementing the redundant hints about perhaps
updating the binutils package, nor suppressing the redundant special
status-line output.

Noted some TODOs for future simplification. Changed the use of SIMD to
SOURCE, since this utility code doesn't have to relate to SIMD flags.

Change-Id: Id9605ccff0903c55e2621ddd8af10c8da523bebe


[PATCH] corrected accidental disables of fast global to local atom
 lookup for large systems


[PATCH] Conditional tweak in the nonbonded GPU kernels

GPU compilers miss an easy optimization of a loop invariant in the
inner-lop conditional. Precomputing part of the conditional together
with using bitwise instead of logical and/or improves performance with
most compilers by up to 5%.

Change-Id: I3ba0b9025b11af3d8465e0d26ca69a78e32a0ece


[PATCH] AABB tree demo: - added color ramps for signed and unsigned
 distance functions (thermal for unsigned, and red/blue for signed) - fix moc
 warning issue (thanks Manuel Caroli) - fix strange value in performance
 section of user manual (we now understand that the KD-tree is making
 something really nasty only for large point sets - and we'll investigate the
 KD tree more)


[PATCH] New traits classes for efficient handling of circles.


[PATCH] replace custom kdtree by a fast version of
 Orthogonal_k_neighbor_search


[PATCH] Inverse and make_sqrt functions added. RT / Root_of_2<RT>
 division added. Some operations with int. Comparisons function performance
 improved. Added the idea of representing a rational (when we know, by using
 the Root_of_2(FT) construction) inside the Root_of_2. The constructor
 Root_of_2<RT>(const RT&, const RT&, const RT&, bool) has now another boolean
 parameter at the end, in the case you know delta is not zero. Some others
 goodies.


[PATCH] Improved the performance of the gmx_sum routines on cluster
 with multi-core nodes by using a two step communication procedure


[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] ResultTile::coord() performance (#1689)

This removes the branch within the ResultTile::coord() implementation to
test if it contains zipped or unzipped coordinates.

The function contract is slightly modified because now the caller must ensure
that an underlying coordinate exists at there requested position and dimension.
Currently, the `ResultTile::coord()` may return null if nothing is found. This
does not appear to be an expected output anywhere in the unit tests or code.

In a certain read benchmark that paths through this routine multiple times,
this patch reduces the avg execution time from 18.15s to 17.00s.


[PATCH] Removed debug code with would slow down mdrun when writing
 trajectories


[PATCH] add SDG Linf fast examples to doc file


[PATCH] Fixed a performance bug in the sweep. When calling the insert
 functions on the planar map, I made sure the non-intersect version of the
 inserts are being called. I also cleaned up the code a bit.


[PATCH] Fix false sharing in RandomNumber Pools

The pool arrays are accessed by all threads, but the
elements per thread are rather small and thus share cachelines.

Making the arrays 2D using the second dimension for padding only,
solves that problem. I have seen up to 200x improvement for
20 threads on skylake running the random number example with 100k and 1
as parameters. Serial performance is slightly reduced, but it only makes
the "grep a generator slower" by the equivalent of one double load more
and a few integer ops.


[PATCH] erased the function Oriented_Side::oriented_side(Plane_3,
 Point_3): it was buggy before and not efficient enough after it has been
 corrected.


[PATCH] This should slightly improve performance in non-threaded proj
 constraint generation, may save us from a race condition leading to
 inaccurate proj constraints in a few corner cases (3D, level one rule off; or
 AMR combined with periodic BCs) when we're threaded.


[PATCH] Robust retries for S3 request-limit retries (#1651)

This patch provides a retry handler that is identical to the existing, default
handler with an exception for CoreErrors::SLOW_DOWN. For this error, we will
unconditionally retry every 1.25-1.75 seconds.

The motivation for this patch is to allow the TileDB client to remain functional
even when performance may be bottlenecked on this error. The server returns
this error when we exceed a fixed number of requests per second. The client
will eventually make progress.


[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] Revert "Minor changes to use libmesh indentation,
 initialization styles."

This reverts commit ddf20ff42df730dfb38bf0d618b7d1d9264948b7.

Revert "Write element truth table to exodus to improve performance"

This reverts commit 3c400489f41dbd72fe704c3dfe94db6e9bcd200e.


[PATCH] Sort cell slab ranges for ND arrays (#1736)

The selective decompression intersection algorithm requires cell slab ranges
to be sorted in ascending order. This is true for 1D arrays, but not for ND
arrays. In this scenario, we must sort them.

The ranges are sorted in vectors that have already been partitioned per-tile.
This should keep the sort runtimes relatively quick. In the future, we can
benchmark this on large arrays+queries and measure its timing. With this sort,
we now may coalesce cell ranges as a future optimization.

If the N*LOG(N) sorting is too slow, the alternative approach is to leave them
unsorted and perform O(N*M) range-chunk intersection comparisons, where M is
the number of chunks. If the number of chunks is less than LOG(N), this may
be faster.

This solves the following error message:
[TileDB::ChunkedBuffer] Error: Chunk read error; chunk unallocated error

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


[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] moved performance fix for 7.30 compilers to FFLAGS


[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] Add fix elstop to USER-MISC

Implements inelastic energy loss for fast particles in solids.


[PATCH] Anisotropic smoothing perf improvements in CUDA

This improves CUDA backend performance by about 24%


[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] allows requesting of multiple moments. restructures blocks
 for performance improvements


[PATCH] Move performance logging of solve()s into solver classes

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


[PATCH] replace patch routines that call scatter with more efficient
 ones; combine multiple ddots into one call to reduce no. of gops; added
 inheritance to print control


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


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


[PATCH] Unroll middle jm loop in the nbnxm kernels on Ampere

The unrolling improves performance of the non-bonded kernels by up to
12%.

Refs #3872


[PATCH] Improve performance of some mathematical functions


[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] 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] Remove constant acceleration groups

Per Redmine discussion, this has been broken for about 10
years. Simplifying the update and global energy code is nice, and some
integrators will now be a trifle faster.

The value of SimulationAtomGroupType::Count can't change because reading old .tpr files relies
on it, but the enumeration value has a new name so that any relevant
code rebasing over this change can't silently still compile. This does
mean that loops over egcNR are now slightly less efficient than they
could be, and some of those are in the per-step update code. But that
is likely not worth changing in the current form of the code.

Originally authored by Mark Abraham at
https://gerrit.gromacs.org/c/gromacs/+/8944.

Fixes #1354


[PATCH] use local variables for more efficient force accumulation


[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] Fix clang-3.7 build warnings in core unit and performance
 tests

Fix mismatched use of array new and scalar delete
T * data =  new T[1];
...
delete [] data;


[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] Lazily Init AWS ClientConfiguration

AWS changes the ClientConfiguration in the 1.8 SDK to do the checking for env
variables and ec2 metadata in [1]. This can cause TileDB to behavior slow if
S3 support is built but the environment is not configured. The AWS SDK
check for the ec2 metadata and has to wait for a timeout. We need to
lazily init the ClientConfiguration.

[1] https://github.com/aws/aws-sdk-cpp/commit/147469373c9fec1037bd2d75d7cd949250c6f7c5


[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] improved load balancing on the GPU

For the GPU, small pair list entries are now sorted to the end.
The improves performance by 5 to 20%.

Change-Id: I25e5efeb813ad5dde48f0955366519db699f21a2


[PATCH] Adjust s3 multi-part locking to unlock early

This switches from iteraters to using find + at to take references to
the state objects for manipulations. This allows us to release the S3 class
level locks earlier and faster removing performance bottlenecks.


[PATCH] gmres restart converges but slow


[PATCH] Fixed backend API for join

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


[PATCH] - Changed Hash_map to Unique_hash_map. Kept old file. -
 Separated Handle_hash_function into own file. - Improved performance of
 default Handle_hash_function. - Rewrote manual pages including the
 UniqueHandleFunction concept. - Made protected methods in chained_map.h
 public such that   Unique_hash_map can be implemented using a private member
  instead of private inheritance.


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


[PATCH] make use of CUDA stream priorities

CUDA 5.5 introduced steam priorities with 2 levels. We make use of this
feature by launching the non-local non-bonded kernel in a high priority
stream. As a consequence, the non-local kernel will preempt the local
one and finish first. This will improve performance in multi-node runs
by reducing the possibility of late arrival of non-local forces.

Change-Id: I4efc65546e4135f12006c0422e1fca42a788129f


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


[PATCH] Change tolerance as it becomes pretty slow


[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] 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] HvD: The density functionals with derivatives up to and
 including third order generated by automatic differentiation using the
 univariate Taylor series approach by Griewank et al. DOI:
 10.1090/S0025-5718-00-01120-0.

For this code to perform well it is essential that the compiler inlines a lot
of code. If the overloaded operators are evaluated as function calls the
calculations slow down by more than an order of magnitude. Some compilers
can only inline code within a single file. Hence the addition of nwxc.F
that includes all the source code of the various functionals. In particular
the GCC generated code saw significant performance improvements as a result.
For GCC one is adviced to use compiler versions post 4.6 as apparently
significant improvements to the inline capabilities were introduced at that
point.

At this point the gradient and 2nd derivative evaluation have been tested.
For the 3rd order derivatives test cases that actually exploit those derivatives
are still needed. If there are any deficiencies at that level they are most
likely to stem from the driver routine NWXC_EVAL_DF3_DRIVER which has to
generate the appropriate partial derivatives and interpolate the final results.
The generation of the derivatives themselves should work alright as the unit
tests in src/nwxc/nwad/unit_tests work and the lower order order derivatives
of the functionals work.

At the moment the performance is still not as good as I would like it. I suspect
that the univariate approach is in part to blame for that. The fact that all
lower order derivatives need to be re-evaluated for every highest order partial
derivative introduces an overhead that is close to proportional to the
highest order of derivative requested. I am planning to try a multivariate
approach instead. This however has increased memory access as a downside,
in particular during assignments. We will see what is best on balance.


[PATCH] Modified operations so that MPI_Type_free is called after
 wait. Also tried adding and MPI_Win_flush_local call to force both local and
 remote completion before calling MPI_Type_free, but does not seem to get rid
 of failures in some of the performance tests.


[PATCH] MKK: Non-blocking performance test


[PATCH] Because I wasn't seeing a speed-up on grapes, I made the
 accumulation put (add_hash_block) non-blocking in hopes that that
 communication, which probably hits more contention because it is a write, can
 be overlapped with all the local computation going on prior to it.


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


[PATCH] NVIDIA Volta performance tweaks

Removed ballot syncs and replaced all computed masks with full warp
mask (as all branches in question are warp-synchronous).
This improves performance by 7-12%.

Change-Id: I769d6d8f0d171eb528d30868d567624d5e246dbf


[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] Add implementation of convolution using the naive approach
 (it's pretty fast for small filter).


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


[PATCH] Tabulated log(x) to improve GB performance


[PATCH] More efficient nlp_solver_evaluate


[PATCH] [ZARCH] Improve loading performance for camax/icamax


[PATCH] Enforced rotation: Minor performance optimization in
 do_flex[1,2]_lowlevel


[PATCH] Update MFEM to not run the performance miniapp if code
 coverage is enabled.  Runtime exceeds automated testing engine allowance.


[PATCH] Use arma::pow to use fast armadillo computation


[PATCH] Introduce HostAllocationPolicy

This permits host-side standard containers and smart pointers to have
their contents placed in memory suitable for efficient GPU transfer.

The behaviour can be configured at run time during simulation setup,
so that if we are not running on a GPU, then none of the buffers that
might be affected actually are. The downside is that all such
containers now have state.

Change-Id: I9367d0f996de04c21312cef2081cc08148f80561


[PATCH] Removed unnecassary flush of trn,xtc,edr. Important for
 performance for very frequent writes (on small systems) Fixed a bug related
 to setting the duty of pp/pme/io


[PATCH] AMG-DD implementation (#145)

This includes the implementation of the AMG-DD algorithm, a variant of BoomerAMG designed to limit communication.

AMG-DD may be used as a standalone solver or a preconditioner for Krylov methods (note that AMG-DD is a non-symmetric preconditioner). For an example of how to set up and use AMG-DD, see the IJ driver (src/test/ij.c).

A list with the parameters of AMG-DD is given below:

Padding (recommended default 1): HYPRE_BoomerAMGDDSetPadding(...)
Number of ghost layers (recommended default 1): HYPRE_BoomerAMGDDSetNumGhostLayers(...)
Number of inner FAC cycles per AMG-DD iteration (default 2): HYPRE_BoomerAMGDDSetFACNumCycles(...)
FAC cycle type: HYPRE_BoomerAMGDDSetFACCycleType(...)
1 = V-cycle (default)
2 = W-cycle
3 = F-cycle
Number of relaxations on each level during FAC cycle: HYPRE_BoomerAMGDDSetFACNumRelax(...)
Type of local relaxation during FAC cycle: HYPRE_BoomerAMGDDSetFACRelaxType(...)
0 = Jacobi
1 = Gauss-Seidel
2 = ordered Gauss-Seidel
3 = C/F L1-scaled Jacobi (default)

For more details of the algorithm, see Mitchell W.B., R. Strzodka, and R.D. Falgout (2020), Parallel Performance of Algebraic Multigrid Domain Decomposition (AMG-DD).


[PATCH] aabb tree: added performance section [to be completed with
 distance queries and curves]


[PATCH] Added more constructors, for more efficient handling of
 circles with rational radii.


[PATCH] added precompiler commands for performance tests


[PATCH] Use templates to improve performance when not using triclinic
 boxes


[PATCH] New test file for simple performance test


[PATCH] Made FAST OpenCL results match CUDA results


[PATCH] Use boost::thread::hardware_concurrency instead of the
 std::thread one

std::thread::hardware_concurrency is not implemented in my GCC version
Was causing a huge performance problem on Linux.


[PATCH] s390x/Z14: Change register blocking for SGEMM to 16x4

Change register blocking for SGEMM (and STRMM) on z14 from 8x4 to 16x4
by adjusting SGEMM_DEFAULT_UNROLL_M and choosing the appropriate copy
implementations. Actually make KERNEL.Z14 more flexible, so that the
change in param.h suffices. As a result, performance for SGEMM improves
by around 30% on z15.

On z14, FP SIMD instructions can operate on float-sized scalars in
vector registers, while z13 could do that for double-sized scalars only.
Thus, we can double the amount of elements of C that are held in
registers in an SGEMM kernel.

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


[PATCH] Random engines & distributions as proper C++11 classes

This change implements the ThreeFry2x64 random engine with flexible
number of encryption rounds and internal counter bits. The class is
compatible with the C++11 random number generators, and the GROMACS
tabulated normal distribution has likewise been turned into a
random distribution compatible with C++11, meaning they can be used in
almost any combination with the standard library distributions.
- The ThreeFry2x64 implementation uses John Salmon's idea of a template-
  selected internal counter so a number of bits are reserved to generate
  an arbitrary random stream. This makes it possible to use ThreeFry as
  a normal random engine, and even in counter mode it is possible to
  draw an arbitrary amount of random numbers before restarting counters.
- Both accurate (20-round) and fast (13-round) versions are available.
- There is a gmx::DefaultRandomEngine when we don't care about details.
- gmx::GammaDistribution has been added to work around bugs in
  libstdc++-4.4.7 headers, and to avoid getting different results
  for libstdc++ vs. libc++.
- Custom Uniform, normal, and exponential distributions have been added
  to make all results reproducible across platforms since stdlibc++ and
  libc++ do not use the same generating algorithms.
- Code using random numbers has been updated, but no changes have been
  made to turn random seeds into 64bits yet.
- The selection nbsearch unit test was a bit fragile and very sensitive
  to the coordinate specific values; this has been fixed so it should
  be resilient no matter what RNG is used in the future.

Change-Id: I47a04d03e2f264e1a6ef0aa0a2174cb464ed9af7


[PATCH] PERF: Anisotropic smoothing improvements (#2713)

This improves CUDA/OpenCL backend performance by about 24%


[PATCH] Fixed performance problems when many boxes are on a process:
 Removed a Sort from the communication stuff. Reordered the periodic boxes in
 the neighborhood. Changed the CommInfoFromStencil algorithm.


[PATCH] Removed nbnxn kernel blendv optimization

The nbnxn simd kernel blendv optmization, which was accidentally
deactivated since 5.0, has been removed. It made assumptions about
the internal storage of SIMD representations. With gcc 4.x blendv
would give a small performance improvement, but with gcc 5 performance
is equal or deteriorates.

Change-Id: I2b07895257a2fde0ade2a627369ed22683dd89e1


[PATCH] Issue #2056 More efficient mapped evaluation


[PATCH] Refactor the performance measurement system


[PATCH] Added workaround for performance issue in CasADi 2.4


[PATCH] s390x: Optimize SGEMM/DGEMM blocks for z14 with explicit loop
 unrolling/interleaving

Improve performance of SGEMM and DGEMM on z14 and z15 by unrolling and
interleaving the inner loop of the SGEMM 16x4 and DGEMM 8x4 blocks.
Specifically, we explicitly interleave vector register loads and
computation of two iterations.

Note that this change only adds one C function, since SGEMM 16x4 and
DGEMM 8x4 actually map to the same C code: they both hold intermediate
results in a 4x4 grid of vector registers, and the C implementation is
built around that.

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


[PATCH] Sparse refactored readers: Better vectorization for tile
 bitmaps calculations. (#2711) (#2734)

* 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] Re-enable i-atom type local mem prefetch in OpenCL

For reasons unknown this has been disabled in the original OpenCL
implementation. However, it turns out that prefetching does have
substantial performance benefits, especially on AMD (>10%) and in some
cases on NVIDIA too (although not on Maxwell).

This change re-enables prefetching code-path and turns it on
for AMD devices. For NVIDIA the decision will be revisited later.

The GMX_OCL_ENABLE_I_PREFETCH/GMX_OCL_DISABLE_I_PREFETCH environment
variables allow testing prefetching with future architectures/compilers.

Change-Id: I8324d62d3d78e0a1577dd3125edf059d3b311c2f


[PATCH] Increase release build timeout, macos is being a bit slow on
 Azure (#2495)


[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@2672 434f946d-2f3d-0410-ba4c-cb9f52fb0dbf


[PATCH] Speedup of kernel caching mechanism by hashing sources at
 compile time (#3043)

* Reduced overhead of kernel caching for OpenCL & CUDA.

The program source files memory footprint is reduced (-30%) by eliminating
comments in the generated kernel headers.  Hash calculation of each source
file  is performed at compile time and incrementally extended at runtime
with the options & tInstance vectors.  Overall performance increased up to
21%, up to the point that the GPU becomes the bottleneck, and the overhead
to launch the same (small) kernel was improved by 63%.

* Fix couple of minor cmake changes

* Move spdlog fetch to use it in bin2cpp link command

Co-authored-by: pradeep <pradeep@arrayfire.com>
(cherry picked from commit 3cde757face979cd9f51a4c01bd26107e69e4605)


[PATCH] added driver for testing performance


[PATCH] Use the Side<> class as a proxy when building element sides.
 This eliminates the need for allocating and deallocating connectivity storage
 arrays when building sides, thus making the Elem::build_side() member more
 efficient.  Note that this has not been implemented yet in the case of
 infinite elements, however it would be easy to add.  Assuming there are many
 more interior elements than infinite elements there is also probably little
 performance impact.


[PATCH] More efficient SystemBase::reinit, flux_jump indicator should
 work but needs testing


[PATCH] improved performance in some of the
 IsoparametricTransformation::*RevDiff methods by stack allocating dFdx_bar
 inside. Added additional FiniteElement::*RevDiff methods for differentiating
 various methods. Added EvalRevDiff methods to additional coefficient classes,
 and added tests for the coefficient differentiation as well as the finite
 element differentiation


[PATCH] Add class ListOfLists

This is a replacement for t_blocka, i.e. a performance optimized
implementation of a list of lists. It only allows appending a list
at the end of the list of lists.

Change-Id: Ib4b7f5f0e57b82c939f53e9805dc16e9d76db22b


[PATCH] Improved the performance on Powerpc by tweaking the altivec
 innerloops and changing sqrt(x) to x*invsqrt(x)


[PATCH] Created Qt Demo for Polyhedron_shortest_path

A shortest paths object is created using 'Make Shortest Path' from the
menu on a polyhedron.
Source points are created by shift-clicking on the polyhedron.
Points can also be removed by selecting the appropriate option in the
combo box.  Point locations can be snapped to the nearest edge or vertex,
or placed anywhere on the face.  Choosing 'Shortest Path' from the combo
box and shift-clicking will create a polyline object representing the
shortest path from any of the source points to that destination.  Note
that computing the shortest paths tree may be slow on the first query.


[PATCH] fixed problem with index group for system size and made the
 diameter calculation more efficient


[PATCH] output detailed multi-thread performance data only with
 "timer full"


[PATCH] Revert simd-avx.h changes from b606e3191

They didn't improve performance at all as far as I can tell,
and they ended up breaking the PGI compiler.

It is always tempting to use the fancy addsub instructions in FFTW to
do complex multiplications, but the reality is that FFTW is designed
to avoid complex multiplications in most cases (we started in the SSE
days), and thus they don't make any difference.  We are better off
using the minimal possible set of AVX instructions to minimize the
chance of triggering compiler bugs.

The same statement holds for _mm256_shuffle_pd() versus
_mm256_permute_pd(): in theory the latter is better, in practice
either one is rarely used.  However, SHUFFLE is older (since the SSE
days) and has a higher chance of working.


[PATCH] Update testing matrices for coverage and speed

Moved slow aspect of pre-submit matrix to nightly (icc with release
mode and SIMD support).

Removed slow gcc-7 config adjusting similar builds to achieve its
former objectives.

Removed outdated TODOs, noted new ones

Added hwloc test specifier, and todo for hwloc 2

Added tng test logic, and a specfier for each non-default case.  Fixed
missing return values for no-tng case, and clarified the docs.

Change-Id: I340b9a64dc4e4958f260657d3d82480be62ef979


[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] new version of forward and adjoint jacobian calculation for
 SXFunction, ticket #127, still need an efficient way of calculating seed
 matrices


[PATCH] add a warning if the bonded cutoff is large

This should print a warning when 2x the bonded interaction cutoff list larger then other cutoffs, as was the setting before the performance optimization with the change in https://github.com/lammps/lammps/pull/758/commits/269007540569589aa7c81d9ba1a4b93d34b8c95d


[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] Extend performance considerations on bonded offload

Refs #2793

Change-Id: I4a8ae8554cf2aad540eb4eb485898f8cabeb3966


[PATCH] made the code MUCH more efficient in various places


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


[PATCH] Duplicate and modify functions as they are more efficient


[PATCH] moved ocl kernel resources from stack to heap

cl::Program and cl::Kernel objects were being created on global
stack earlier. Even though that is efficient and worked fine on
linux and macosx platforms. It caused out of control runtime errors
on windows platforms at the exit of the application that is using
the library. This could be mostly a driver bug in OpenCL drivers
for windows, therefore this change might be reverted in future.


[PATCH] fix obvious performance bug in Isolate_1


[PATCH] Improved performance of computing sums with CustomIntegrator


[PATCH] Fix pme gather in double with AVX(2)_128

The 4NSIMD PME gather change did not change the conditional
for grid alignment. This is made consistent here.
Note that the 4NSIMD change lowered the performance of PME gather
on AVX_128_FMA and AVX2_128 in double precision. We should consider
using 256-bit AVX for double precision instead.

Refs #2326

Change-Id: I07bfb3ca8d334bce18ed0b6989405bbc02c25b7b


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

This reverts commit 580b65d8a5937b99c6206885a6b0504399923501.

The warning was already fixed by commit
63ae26eb0ffa8460abddf6843345996f9e4de603.


[PATCH] In the performance miniapps, print the SIMD width in terms of
 "doubles".


[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] for three star segments, return fast common point

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


[PATCH] dcopy hack into util/diff & reversing performance degradation
 change