func:
[PATCH] s390x: Use new sgemm kernel also for strmm on Z14 and newer

Employ the newly added GEMM kernel also for STRMM on Z14. The
implementation in C with vector intrinsics exploits FP32 SIMD operations
and thereby gains performance over the existing assembly code. Extend
the implementation for handling triangular matrix multiplication,
accordingly. As added benefit, the more flexible C code enables us to
adjust register blocking in the subsequent commit.

Tested via make -C test / ctest / utest and by a couple of additional
unit tests that exercise blocking.

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


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


func:
[PATCH] Auto cache compiled CUDA kernels on disk to speed up
 compilation (#2848)

* Adds CMake variable AF_CACHE_KERNELS_TO_DISK to enable kernel caching. It is turned ON by default.
* cuda::buildKernel() now dumps cubin to disk for reuse
* Adds cuda::loadKernel() for loading cached cubin files
* cuda::loadKernel() returns empty kernel on failure
* Uses XDG_CACHE_HOME as cache directory for Linux
* Adds common::deterministicHash() - This uses the FNV-1a hashing algorithm for fast and reproducible hashing of string or binary data. This is meant to replace the use of std::hash in some place, since std::hash does not guarantee its return value will be the same in subsequence executions of the program.
* Write cached kernel to temporary file before moving into final file. This prevents data races where two threads or two processes might write to the same file.
* Uses deterministicHash() for hashing kernel names and kernel binary data.
* Adds kernel binary data file integrity check upon loading from disk


func:
[PATCH] Workaround for libHilbert bug until we manage to get it
 fixed. Part of this workaround may be permanent - the long term fix may
 require efficient user code to call some reinitialization, renumbering
 function manually after reading in a mesh and solution.


func:
[PATCH] Wrote the compute_children_node_keys() function in elem.h
 which allows one to generate appropriate node keys while reading in a mesh
 with multiple refinement levels. This allows us to avoid a linear search in
 the MeshRefinement::add_point routine since all the nodes can now be found in
 the nodes hash table.  The resulting performance improvement was significant.


func: [PATCH] Mesh_3: Address TBB performance warning on hashing


func:
[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


func: [PATCH] Added workaround for performance issue in CasADi 2.4


func:
[PATCH] performance analysis, use of multipoles for long range bits,
 lots of additional screening


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


func:
[PATCH] Refactor UpdateTree() to sometimes Hamerly prune. We aren't
 properly retaining pruned nodes between iterations, but this is definitely a
 start and it's basically as fast as any of these attempted algorithms I've
 written.


func:
[PATCH] Only use AVX512 in own-FFTW if GROMACS also uses it

Building the own FFTW with AVX512 enabled for all AVX-flavors means that
an AVX2 build can end up loosing a significant amount of performance due
to clock throttle if the FFTW auto-tuner inadvertently picks and AVX512
kernel. This is not unlikely as measurements at startup are very noisy
and often lead to inconsistent kernel choice (observed in practice).

Change-Id: I857326a13a7c4dd1a6f5ab44360211301b05d3ac


func:
[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;


func: [PATCH] Code for ordinary, slow, ewald electrostatics


func:
[PATCH] Accelerate KSInitialization tests by using fewer CV folds and
 fewer training epochs as well as relaxed tolerances.


func:
[PATCH] changed the ndelta to setting the number of cells per cut-off
 radius to per cut-off diameter and changed the default value to 3 in
 do_inputrec, this gives at most 64 cells per icg iso 125, this gives a few
 percent performance increase in ns and domain decomposition (the cg sorting)


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


func: [PATCH] Initial check in of performance test for read-only property


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


func:
[PATCH] rPolynomial: New equation of state for liquids and solids

Description
    Reciprocal polynomial equation of state for liquids and solids

    \f[
        1/\rho = C_0 + C_1 T + C_2 T^2 - C_3 p - C_4 p T
    \f]

    This polynomial for the reciprocal of the density provides a much better fit
    than the equivalent polynomial for the density and has the advantage that it
    support coefficient mixing to support liquid and solid mixtures in an
    efficient manner.

Usage
    \table
        Property     | Description
        C            | Density polynomial coefficients
    \endtable

    Example of the specification of the equation of state for pure water:
    \verbatim
    equationOfState
    {
        C (0.001278 -2.1055e-06 3.9689e-09 4.3772e-13 -2.0225e-16);
    }
    \endverbatim
    Note: This fit is based on the small amount of data which is freely
    available for the range 20-65degC and 1-100bar.

This equation of state is a much better fit for water and other liquids than
perfectFluid and in general polynomials for the reciprocal of the density
converge much faster than polynomials of the density.  Currently rPolynomial is
quadratic in the temperature and linear in the pressure which is sufficient for
modest ranges of pressure typically encountered in CFD but could be extended to
higher order in pressure and/temperature if necessary.  The other huge advantage
in formulating the equation of state in terms of the reciprocal of the density
is that coefficient mixing is simple.

Given these advantages over the perfectFluid equation of state the libraries and
tutorial cases have all been updated to us rPolynomial rather than perfectFluid
for liquids and water in particular.


func: [PATCH] Adding performance patch for trmm, just like #2836


func:
[PATCH] BJP: Initial checkin of test program for performance
 evaluation of DRA routines in 3 dimensions.


func: [PATCH] Add TaskDAG performance test to CMake


func:
[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


func:
[PATCH] performance miniapps: don't enable -march=native on ARM

See e.g. https://stackoverflow.com/questions/65966969/why-does-march-native-not-work-on-apple-m1


func: [PATCH] Made a pass on Performance tutorials in docs.


func: [PATCH] a slow version of triangle split


func:
[PATCH] Enable fp-exceptions

This can help with finding errors quicker because mdrun crashes as soon
as a floating point value overflows or is invalid. fp-exceptions are
only enabled for builds with asserts (without NDEBUG), mainly because
it isn't always possible to avoid invalid fp operations for SIMD math
without a performance penalty.

Also, fix a few places where we had 1/0 or other invalid fp operations.

Fixes #1582

Change-Id: Ib1b3afc525706f4b171564fcaf08ebf3b2be3122


func:
[PATCH] SYCL NBNXM offload support

Associated changes:

- Added function stubs to PME: necessary for compilation.
- Stricter SYCL hardware compatibility checks: limits on subgroup size
  and the availability of local memory.
- The kernel implementation and overall logic closely follow the OpenCL
  implementation. Divergences are documented locally.

Limitations:

- No fine-grained timings yet.
- Code-duplication with CUDA and OpenCL: see #2608.
- Minor differences in local/nonlocal synchronization: see #3895,
  related to #2608.
- Only the OpenCL backend was extensively tested. LevelZero works fine
  without MPI but stalls due to a known bug. The fix for DPCPP runtime
  is available, but not yet part of any OneAPI release:
  https://github.com/intel/llvm/pull/3045.
- The complex/position-restraints regression test fails: see #3846.
- No performance tuning: see #3847.

Performance on rnase-cubic system is similar to OpenCL implementation.


func:
[PATCH] Added parentheses to performance logging messages

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


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


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


func:
[PATCH] MDRange: Minor perf test fixes for KNL

Tests are still commented out for now, but removed running a slow test,
reduced the number of tests, and made minor fixes when checking results
during the first iteration (vectorization may have occurred and made
the check no longer bitwise correct; epsilon comparison should be added
as well as option to not check correctness which will speed up the tests)


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


func:
[PATCH] Continued stats refactor + subarray stats (#2200)

TYPE: IMPROVEMENT
DESC: Added additional stats for subarrays and subarray partitioners


func:
[PATCH] Fixup re-enable core performance tests

These had been inadvertently disbaled in #3839

Co-Authored-By: Nick Curtis <nicholas.curtis@amd.com>
Co-Authored-By: Bruno Turcksin <bruno.turcksin@gmail.com>


func:
[PATCH] Fixing a bug in measuring performance (didn't reset the
 timer)


func:
[PATCH] Mark closed flag in EigenSparseVector regardless of METHOD

I don't think it's a performance hit to set these flags
regardless of METHOD, and it's a nice state flag that the user
can check


func:
[PATCH] Update performance test case (to use polar_decomposition)
 Make polar default closest rotation computer


func: [PATCH] Added upper triangular fast tridiagonalization routines.


func:
[PATCH] fast nary union in OFF2nef3 also constructor finds more
 problems and handles them


func:
[PATCH] wallDist/patchDistMethods/Poisson: New method for fast
 calculation of an approximate wall-distance field by solving Poisson's
 equation


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


func: [PATCH] some more prints to debug comex_malloc performance


func:
[PATCH] Avoiding redundant metadata calculations in order to
 accelerate AbstractDistMatrix::QueueUpdate and
 AbstractDistMatrix::ProcessQueues (as well as generalizing
 AbstractDistMatrix::ProcessPullQueue to support not including 'viewer'
 processes)


func: [PATCH] Expanded the GetIrTest behavior to enable efficient testing


func:
[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


func:
[PATCH] Added support for manual load balancing with a -load option
 for grompp. It takes the relative performance of each of the processors in
 your system in arbitrary units, and normalizes it.


func: [PATCH] added driver for testing performance


func: [PATCH] WIP fast single-element neighbor calculation.


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


func:
[PATCH] Rename GPU launch/wait cycle counters

In preparation for the PME GPU task and GPU launch overhead to be
counted together in the same counter for all GPU tasks, the current main
counters have been renamed to be more general. The label of GPU waits in
the performance table have also been renamed to reflect the task name.
Additionally a non-bonded specific sub-counter is been added.

Change-Id: I65a15b0090c1ccebb300cf425c7b3be4100e17a0


func:
[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


func:
[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


func:
[PATCH] Create even less contention

All the readers are waiting on our writer thread to mark our condition
(`_array_is_present`) as ready before they can even attempt to read, so
there is no data race for our writer thread. Hence we can remove the
lock on the mutex the readers are using. And it's much better this way
because one could imagine that our writer hits the `std::unique_lock`
first which would then prevent our reader threads from even getting to
the condition variable `wait`, which is the logical place we want them
to get to while the writer thread is doing its job.

And the second change is unlocking as soon as we're through waiting
because we are through the read-write portion of the program and are
only reading so it's safe to let everyone through at once


func: [PATCH] remove int to bool conversion performance warning with VC


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

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


func:
[PATCH] --enable-distmesh, --with-mapvector-chunk-size

The parmesh argument probably should have been deprecated when the
ParallelMesh name was.

We'll want to select chunked_mapvector array size at configure time,
since the exact performance optimization/pessimization results are
likely to be system-dependent.


func:
[PATCH] vector<vector> specialization for parallel_sync

We can't do this the efficient way in the general algorithm, so let's
do it as best we can right now, with blocking receives.

This should be replaced by Derek's algorithm in #1684 as soon as we
can support that.


func:
[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


func:
[PATCH] Python 3 does not have dict.itervalues

Really we should move to using six and importing the iterator versions of dict
methods and range/zip from there, but for now just use "values" since using a
raw list doesn't seem like it will cause memory or performance problems here.


func:
[PATCH] DLB can now turn off, when slower

Under certain conditions, especially with (shared) GPUs, DLB can
decrease the performance. We now measure the cycles per step before
turning on DLB. When the running average of cycles per step with DLB
gets above the average without DLB, we turn off DLB. We then measure
again without DLB. DLB can then turn on again. If we turn on DLB of
DLB multiple times in close succesion and we measure performance loss,
we keep DLB off for the remainder of the run. This procedure ensures
that the performance will never deteriorate due to DLB.
Updated and expanded the DLB section in the manual.

Change-Id: I6e0291c1a41adf6da94fae46d36e0fcb95585a02


func:
[PATCH] Added configure flag to disable FFTW measurements, to enable
 binary reproducible runs. Note that this typically WILL deteriorate
 performance, so it is usually better to run the optimized versions and use
 the -reprod flag to mdrun when you need binary identity. However, if you
 compile FFTW3 with SSE support (which is NOT the default) the selected
 kernels seems to be close-to-optimal even without measurements, and then you
 can use this option to always get binary reproducible runs.


func: [PATCH] reformatted the flops and performance output


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


func:
[PATCH] 1.  BoomerAMG keeps track of the number of iterations
 accumulated over all calls.  This is needed for user-level performance
 monitoring if it is a preconditioner for a Krylov method such as PCG.  The
 regular iteration count only tells you about the last time PCG invoked
 BoomerAMG.  There are ifdefs so you can eliminate this if you like - remove
 #define CUMNUMIT.

2.  very minor code fixes, comments, etc.


func: [PATCH] problem with c-macro? but slow fabs works fine


func:
[PATCH] Use Evaluate(const arma::mat& parameters) instead of
 Evaluate(const arma::mat& parameters, const size_t i) to calculate the
 objective and to accelerate the evaluation process.


func:
[PATCH] Better workaround of g++ 4.1 optimizer bug:
 -fno-strict-aliasing. Performance penalty is 5% vs 24% with -O


func:
[PATCH] Reducing dependencies.  Print functions are generally not
 fast anyway, inlining them leads to unnecessary dependencies and larger
 headers.  Removing print functions from headers.


func:
[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


func: [PATCH] additional pre-compiler command for performance testing


func:
[PATCH] Add doSetup parameter to Matrix::init

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


func:
[PATCH] Don't resize() as that assembles the matrix and makes
 add_coef() slow


func:
[PATCH] update test (Cactus_deformation_session.cpp): make it
 suitable for test performance (not active by default) make it suitable for
 test suite (precomputed mesh difs active by default)


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


func:
[PATCH] log_name would be unused without perf_log on

So if we're not performance logging, we need to comment out that
variable entirely to avoid an unused variable warning.


func: [PATCH] Disks are too fast, fix formatting of speed as *****


func:
[PATCH] Deprecate version of BoundaryInfo::boundary_ids(const Node*)
 that returns a vector.

Add new version that must be passed a std::set.  The new version
should be more efficient for making repeated calls to boundary_ids(),
since the container does not need to be created and destroyed
repeatedly...


func:
[PATCH] performance improvement through avoiding function call and
 dereference overhead

- make i_to_potl() and ij_to_potl() functions inline and const
- don't dereference inside the functions, but cache, if possible in external variables
=> up to 15% speedup.


func: [PATCH] turned performance fix for 7.30 compilers off by default


func:
[PATCH] Use range for in dof_map.C

We can use more efficient iterators in a couple places here too.


func:
[PATCH] Greatly improved the performance of copy::GeneralPurpose by
 exploiting the tensor product structure of the integer metadata calculations


func:
[PATCH] Update RAS-IR.

Notes:
1. Overlap and row ordering have significant effects on convergence.
2. Lower the matrix bandwidth, better the performance ?
3. Sync is lower, but communication becomes higher, tradeoff!
4. Parallelism is higher, but overhead is also higher, tradeoff!
5. Very high accurate solves, do not provide anything.
6. Two level and multi-levels might significantly reduce number of
iterations to converge.


func:
[PATCH] resolved performance degrating changed introduced in revision
 1319


func:
[PATCH] Tiny libmesh_assert_valid_boundary_ids speedup

This is actually pretty slow in parallel.  Truly making it faster
would require lumping multiple verification communications together,
but eliminating redundant verification is a start, at a slightly lower
penalty to readability and usability.


func: [PATCH] Added preconditions and made it more efficient


func:
[PATCH] Added single-accuracy SIMD double math functions

Apart from double SIMD variables typically being
half the width of single, the math functions are
considerably more expensive due to higher-order
polynomials, which can drop the throughput to 25%
of single. In some cases we do not need the full
double precision in SIMD operations, so these
new math functions use double precision
SIMD variables but only target single precision
accuracy, which can improve performance twofold.
The patch also makes the target precision in
single and double SIMD an advanced CMake variable,
and the unit test tolerance is set based on these
variables. This can be used (decided by the user)
for a few platforms where the rsqrt/inv table
lookups provide one bit too little to get by
with a single N-R iteration based on our default
target accuracy of 22 bits.

Change-Id: Id4b1c7800e16cb0eb3d564e89a368b4db6eede3e


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


func:
[PATCH] Reworked function 'get_best_weight()' of Slivers_exuder.h

- Avoid computing incident cells multiple times
- Make it more efficient for P3M3 by not having to use
  tr.min_squared_distance() to compute the distance
  between neighboring vertices


func:
[PATCH] #1295 Refactored Matrix::setSub(IMatrix,IMatrix) The new
 implementation should be much more efficient and handle non-monotone indices
 correctly


func:
[PATCH] add (T) kernels optimized for OpenMP+SIMD

These kernels are taken from https://github.com/jeffhammond/nwchem-tce-triples-kernels/,
which were previously part of private development branch of NWChem hosted by Argonne.
The code was developed by Jeff Hammond from 2013-2014 with help from Karol Kowalski.

These kernels have been tested on Intel Xeon, Intel Xeon Phi, IBM Blue Gene/Q,
IBM POWER7, AMD Bulldozer and ARM32 processors using the Intel, Cray, IBM XL,
and GCC compilers.  In rare instances, the optimal loop order is different between
Intel, Cray and IBM compilers.  In such cases, we default to the Intel compiler case
because it is the most commonly used Fortran compiler for NWChem.  In particular,
NWChem as a whole cannot be compiled with Cray Fortran, so the only context in which
it would be used for these kernels is if someone did a mixed build.
The performance differences with XLF were observed on POWER7, which is a relatively
rare platform for NWChem.

In any case, these optimizations are better than the serial version any time OpenMP
is used.  Detailed performance information for some platforms can be found at
https://github.com/jeffhammond/nwchem-tce-triples-kernels/tree/master/results.

Finally, it should be noted that all of Jeff Hammond's developments for non-Intel
architectures were done prior to his employment at Intel, which can be verified
from the Github commit log associated with the aforementioned repo.


func: [PATCH] Improved performance of interaction groups on CPU


func:
[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


func:
[PATCH] wmkdep: Added path string substitution support

to avoid the need for sed'ing the output.  This improves performance by avoiding
the need for calling additional commands and generating a temporary file.


func:
[PATCH] Replaced Vertex_handle and Cell_handle by const & versions
 in order to regain performance


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


func:
[PATCH] AABB tree: the projection does not construct the KD-tree at
 the first projection query anymore. for efficient projection queries either
 the user calls for its explicit construction during the AABB construction or
 calls "construct_search_Tree()". otherwise the first primitive reference
 point is used as (naive) hint.


func: [PATCH] Improved ORB performance and memory usage on CUDA backend


func:
[PATCH] Introduce self-pairs search in nbsearch

Make it possible to search for all pairs within a single set of
positions using AnalysisNeighborhood.  This effectively excludes half of
the pairs from the search, speeding things up.

Not used yet anywhere, but this makes the code a better reference for
performance comparisons, and for places where this is applicable it has
potential for speeding things up quite a bit.

Change-Id: Ib0e6f36460b8dbda97704447222c864c149d8e56


func:
[PATCH] Improve the performance of the `Record` logger by using
 deques of `std::unique_ptr` instead of plain object.


func: [PATCH] Used sparse identity for more efficient memory utilization


func: [PATCH] bond/react: efficient competing reactions


func:
[PATCH] Fixed typo in HegstRLVar3/HegstRUVar3 and improved
 performance of Trmm and Symm for relatively small numbers of right-hand
 sides.


func:
[PATCH] Add initial reinit_func(1.) call in Euler2Solver

We need the call to reinit_func to set the time, t, in the context
to the correct value. Also added clarifying comments in EulerSolver
and Euler2Solver that we're also setting the time in addition to
possibly resetting the mesh if there's mesh motion.

There is probably a way to make this more efficient such that we
only call reinit_func twice in Euler2Solver, but I didn't put any
thought into it.


func:
[PATCH] Changed number of nonbonded thread blocks to improve
 performance


func:
[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


func: [PATCH] Fix performance problems for large molecular systems


func:
[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


func: [PATCH] more efficient live variables in SX virtual machine


func:
[PATCH] #1295 Refactored MX::setSub(IMatrix,IMatrix) The new
 implementation should be much more efficient and handle non-monotone indices
 correctly


func:
[PATCH] LJ combination rule kernels for OpenCL

The current implementation enables combination rules for both AMD and
NVIDIA OpenCL (also ports the changes to the "nowarp" test/CPU kernel).

Like in the CUDA implementation, all kernels support it, but only for
plain cut-off are combination rules used.

Notes:
- On AMD tested on Hawaii, Fiji, Spectre and Oland devices;
  combination rules in all cases improve performance, although combined
  with the i-prefetching, the improvement is typically only ~10%.
- On NVIDIA tested on Kepler and Maxwell; in most cases the combination
  rule kernels are fastest.
  However, with certain inputs these kernels are 25% slower on Maxwell
  (e.g. pure water box, cut-off LJ, pot shift), but not on Kepler.
  This is likely a compiler mis-optimization, so we'll just leave the
  defaults the same as AMD.

Change-Id: I05396e000cdf93c1d872729e6b477192af152495


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


func: [PATCH] more efficient comparison function


func: [PATCH] new, more efficient jacobian calculation for integrator


func:
[PATCH] Fix AMD OpenCL float3 array optimization bug

Because float3 by OpenCL spec is 16-byte, when used as an array type
the allocation needs to optimized to avoid unnecessary register use.
The nbnxm kernels use a float3 i-force accumulator array in registers.

Starting with ROCm 2.3 the AMD OpenCL compiler regressed and lost
its ability to effectively optimize code that uses float3 register
arrays. The large amount of extra registers used limits the kernel
occupancy and significantly impacts performance.
Only the AMD platform is affected, other vendors' compilers are able to
do the necessary transformations to avoid the extra register use.

This change converts the float3 array to a float[3] saving 8*4 bytes
register space. This improves nonbonded kernel performance
on an AMD Vega GPU by 25% and 40% for the most common flavor of the
Ewald and RF force-only kernels, respectively.

Note that eliminating the rest of the non-array use of float3 has no
significant impact.


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


func:
[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


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


func:
[PATCH] Improve performance of GEMM for small matrices when SMP is
 defined.

Always checking num_cpu_avail() regardless of whether threading will actually
be used adds noticeable overhead for small matrices.  Most other uses of
num_cpu_avail() do so only if threading will be used, so do the same here.


func:
[PATCH] Grid-based utility nbsearch implementation.

More efficient implementations are possible, but the present one should
work reasonably well in most cases, also for triclinic cells, without too
much complexity.


func:
[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


func:
[PATCH] make skylakex sgemm code more friendly for readers

BTW some kernels were adjusted to improve performance


func:
[PATCH] Minor performance improments

Mostly useful as lesson learned.

1) The double precision constant forces the compiler to convert
   the single precision variable to double, then do the multiplication
   in double and then convert back. Using the single precsion
   constant in double reduces the accuracy (the calculation is still done
   double but the constant has only single precision).
2) Using a temporary array instead of a temporary scalar causes ICC14 to
   generate an extra store.

Change-Id: Ib320ac2ae4ff80ce48277544abff468c483cc83a


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


func:
[PATCH] Beginning to add support for freezing the sparsity pattern of
 graphs and sparse matrices to improve the performance of subsequent updates


func:
[PATCH] Improving performance of BigInt/BigFloat routines (such as
 Cholesky) by more than a factor of three by avoiding allocations within the
 templated BLAS routines


func:
[PATCH] Encapsulate code in ifdef NUMPY clauses. Efficient pythoncode
 for toArray.


func:
[PATCH] Enforce memory alignment to improve performance of vector
 operations.  Also fixed bugs in an earlier optimization.


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


func:
[PATCH] Removed Reaction-Field-nec

The RF no exclusion correction option was only introduced for
backward compatibility and a performance advantage for systems
with only rigid molecules (e.g. water). For all other systems
the forces are incorrect. The Verlet scheme did not support this
option and if it would, it wouldn't even improve performance.

Change-Id: Ic22ccf76d50b5bb7951fcac2293621b5eef285c5


func:
[PATCH] Replace vpermpd with vpermilpd in the Haswell DTRMM kernel

to improve performance on AMD Zen (#2180) applying wjc404's improvement of the DGEMM kernel from #2186


func:
[PATCH] query t on side of bounded square

I moved a lot of the functionality for deciding the Linf incircle
test for four points to the side of bounded square predicate.

In the case of query point t being on one of the sides of the
bounded square, I use the predicate test1d. Maybe even this can
be optimized, or made even more robust with some more checks.

A bug that is fixed with the current commit is in the following
input:

$ cat ~/Dropbox/cgal/sdg/panos/sqch1a.cin
p -51 -180
p -180 -30
p -180 20
p -7 -180

I also fixed a small bug when expanding both sides of the bounded
square.

The next step is to completely remove the slow "side of oriented
square" test.

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


func:
[PATCH] all gonzalez stuff uploaded for trying to fix gonzalez, make
 it fast and accurate


func:
[PATCH] #1285 Refactred substituteInPlace. Now more efficient and has
 same signature for SX and MX.


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


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


func:
[PATCH] Adds a URIManager to manage all URIs within an array
 directory. This introduces several performance improvements, especially
 around redundant URI listings, parallelizing URI listings, etc. Also makes
 VFS::ls a noop for POSIX and HDFS when the listed directory does not exist
 instead of throwing an error, matching the functionality of the object
 stores. Finally, it removes partial vacuuming, as that leads to incorrect
 behavior with time traveling.


func:
[PATCH] using int instead of size_t should be more efficient and
 range doesn't seem to be needed


func:
[PATCH] Stage bonded kernel atomics through shared memory

Fixes performance bug introduced in 01b2f20bd5 by staging energy step
atomics through shared memory rather than have all threads write
atomically directly to global memory.

Fixes #3443


func: [PATCH] improved performance MatvecCommPkgCreate


func:
[PATCH] 2d convolve performance improvements

changed the shared memory loading access pattern in 2d convolve
kernel for cuda and opencl backends


func: [PATCH] Use new style with make_array(), more compact and efficient


func:
[PATCH] Restructured nonbonded calculation to allow more efficient
 vectorization


func:
[PATCH] tutorials: Changed compressed ascii output to binary to
 improve IO performance

also rationalized the writeCompression specification


func:
[PATCH] NumericVector::add_vector refactoring

Similar to #411 and #413

This was originally intended to be just another additional T* API plus
a refactoring; however, the new PetscVector::add_vector(DenseVector)
code path should be a performance improvement as well.


func:
[PATCH] Made some performance improvements and fixed a bug when
 running on a single processor but compiled with mpi.


func: [PATCH] bond/react: performance improvement


func:
[PATCH] 128-bit AVX2 SIMD support

Add 128 bit support for AVX2. Similar to AVX-128, this
improves slightly on SSE2 due to more efficient instructions,
and the shorter SIMD width is beneficial in some cases. Both
128- and 256-bit flavors will be built automatically with
--enable-avx2, and the timing routines will chose the best one
automatically.


func:
[PATCH] Use std::make_shared instead of new...

It is more efficient, since it requires only one memory allocation in
contrast to two.