func:
[PATCH] PME-gather: Use templated functor instead of preprocessor

Added restrict in several places, but this does not affect performance
with gcc and icc.

Change-Id: Id366621fa3ad02ca182b8a4da48cae940059cf46


func: [PATCH] Clean up documentation slightly for the case of slow runs.


func:
[PATCH] Adding Changelog for Release 2.8.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 2.8


func:
[PATCH] Adding Changelog for Release 2.9.99

Part of Kokkos C++ Performance Portability Programming EcoSystem 2.9.99


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


func:
[PATCH] Attempt to work-around old gcc bugs in a more efficient
 fashion that does not lose performance on newer gcc's. [empty commit message]


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


func:
[PATCH] Move clang-tidy build

This has seemed too slow when combined with the ASAN build.

Change-Id: I45ea5856ca05edbb6107b62f219e8afd3cdbda3f


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


func:
[PATCH] Add Elem::loose_bounding_box()

The default implementation is what we were using previously to
calculate bounding boxes for PointLocatorTree.  For higher order
elements we add fast approximations that are strict in the case of
linear geometry but that should still be bounds in the case of higher
order geometry.


func:
[PATCH] Added hacks for SIMD rvec/load store in lincs & bondeds

We have added proper gather/scatter operations to work on
rvecs for all SIMD architectures, but that will not make it into
Gromacs-5.1. Since Berk already wrote a few routines to use
maskloads at least for AVX & AVX2, this is a bit of a hack to
get the performance benefits of that code already in Gromacs-5.1
(for AVX/AVX2), without altering the SIMD module. This is definitely
a hack, and the code will be replaced once the extended SIMD
module is in place.

Change-Id: I385acb5f989b2ecf463948be84947fe1f6dfd19b


func:
[PATCH] Benchmark can now export performance data to an XML file +
 added Tanglecube function to benchmark


func:
[PATCH] replaced std::endl with \n in all file IO and stringstreams.
 std::endl forces a flush, which kills performance on some machines

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


func:
[PATCH] USER-DPD: specialize PairTableRXKokkos's compute_all_items()
 on NEWTON_PAIR No noticable performance change, but it does eliminate a deep
 conditional.


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


func:
[PATCH] Add a single-tree depth-first traverser.  It is not as fast
 as it could be.


func:
[PATCH] In the performance miniapps, add options to set the mesh
 refinements.

Run the miniapps/performance tests at coarser mesh resolutions, so that
the tests run faster.

Explicitly remove and ignore the temporary files created by the tests,
because, in some cases, they may not be removed automatically.


func:
[PATCH] Update to Kokkos r2.04.04 and add workaround for performance
 regression


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

see commit 4c477c853c82bb1ca77bb496cdce993178c3dfa2


func:
[PATCH] ClangCuda: Make Cuda compilation with clang 3.9.0 work

This makes all the unit and performance tests work, with only
one test disabled (view of views).
On the other hand it brakes the cuda build because clang is ok with
__device__ void foo() {}
void foo() {}
nvcc sees that as a redeclaration.


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

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


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


func:
[PATCH] Adding Changelog for Release 3.2.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.2


func:
[PATCH] First experimental prototype of Efficient Ransac (written by
 Yannick)

Plane detection only.
Some work to do to make it CGAL-conforming.


func:
[PATCH] subCycle: Add special treatment for nSubCycles = 1

Now running sub-cycling with nSubCycles = 1 is as efficient as running the same
code without the sub-cycling loop.


func:
[PATCH] Prevent PME tuning excessive grid scaling

We limit the maximum grid scaling to a factor 1.8. This allows
plenty of room for shifting work from PME on CPU to short-range
GPU kernels, but avoids excessive scaling for diminishing return
in performance for a significant increase in power consumption,
communication volume (which may with fluctuating network load not
show up during tuning) as well as limiting load balancing.

Change-Id: I85c02478faa6b67c063b6e1b45a9ac1755b2d81e


func:
[PATCH] This was the version of code used for the FastMKS benchmarks
 in the recently submitted paper, "Dual-tree Fast Exact Max-Kernel Search".


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


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.

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


func:
[PATCH] Remove RangeSet, DenseIntMap, and fast allocation routines.
 They were not used anywhere.


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


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


func: [PATCH] Some performance issues due to profiling


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


func:
[PATCH] Fixed OpenMP compile and added a tux regression test

The MGR OpenMP code has not been tested yet, so I commented it out for now
Added a tux OpenMP compile test and reorganized the tux tests from fast to slow (more or less)


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


func:
[PATCH] fixed a bug with efficient IMVJ and reuse of old data - need
 to clear the matrix Wtil after convergence of the current time step, as
 columns are the result of J*V and J is outdated now.


func:
[PATCH] Update unit tests and performance tests

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


func: [PATCH] add SDG Linf fast examples to doc file


func:
[PATCH] PERF Batching + Blocks images in rotate and transform

* Batching all images in single block set is slow at high blocks
* Divide batches of images into sets and launch blocks for that


func:
[PATCH] .EXPORT_ALL_VARIABLES: commented out since it seems to slow
 down the compilation


func:
[PATCH] Recursive ThreadPools (#1774)

Currently, ThreadPool instances are only recursive with their own isntance. This
patch allows multiple ThreadPool instances to recurse among themselves without
the potential for bottlenecking (either in performance reduction or a deadlock)
on available threads.

For instance, ThreadPool instances A and B may be called in any order:
A->execute([&]() {
  B->execute([&]() {
    A->execute([&]() {
      foo();
    });
  });
});

The motiviation for this patch is to allow us to use our `compute_tp` and
`io_tp` without worrying about their order in a call stack. This patch reduces
the runtime of our `bench_large_io` from 280587ms to 269621.

See the new unit tests in `unit-threadpool.cc` for more examples.


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


func:
[PATCH] Changed innerloop optimization options, and made SSE/3dnow
 loops default together with fast truncation on linux.


func:
[PATCH] for three star segments, return fast common point

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


func: [PATCH] Split up travis 'full' target; it became too slow


func:
[PATCH] Use Array<T> objects instead of Param objects in several
 functions

* Update SIFT with new RAII memAlloc
* Workaround for function resolution in ternary operator
* Fix Fast and Orb functions


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


func:
[PATCH] RJH: Tweaked slow convergence threshold and improved
 stability of RJH: the line search


func: [PATCH] removed call to fast localization for the time being...EJB


func:
[PATCH] Restore locking optimizations for OpenMP case

restore another accidentally dropped part of #1468 that was missed in #2004 to address performance regression reported in #1461


func:
[PATCH] fixed issue with slow insertion in the presence of dummy
 points


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


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


func: [PATCH] IA64: efc with Optimiz break moints2x and moints6x


func:
[PATCH] Keep COARSEN_INACTIVE flags in sync in corner case

This isn't the most efficient solution - I think we could probably let
these flags stay out of sync for a while, weaken the assertions that
complain, and trust to make_coarsening_compatible to eventually fix
the inconsistencies.

This is the safest solution, though.


func:
[PATCH] HvD: Adding a few performance tests to see if certain
 optimizations are needed. It turns out that aa**ii is about 20 times faster
 than aa**bb, where aa and bb are double precision numbers and ii is an
 integer. Whereas aa*ii is about as fast as aa*bb (measured by running "time
 <program>"). So it seems as if we need to add exponentiation to an integer
 power to the NWAD module.


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


func:
[PATCH] Fix nblib pairlist update function

Previously the function put_atoms_in_box was called only by the
nblib integrator, or when constructing a system via a SimulationState
object. In the case of the integrator, this is a needless performance
degradation. When using an nb force calculator without
first putting atoms in the box, this could lead to a cryptic
error from nbnxm grid search failure. Both of these issues are
rectified with this change, which also adds a member to the
non-bonded force calculator to hold the requested number of OMP
threads to use in a call to put_atoms_in_box_omp, which is faster
than the non OMP version.


func:
[PATCH] Initial fast reciprocal space LJPME implementation, with
 test.


func:
[PATCH] Got parallelization working with CollocationIntegrator, very
 slow


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


func: [PATCH] Further work on fast diagonalization


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


func:
[PATCH] Adding logic for detecting whether or not a Mac must link
 vecLib or Accelerate


func: [PATCH] Use pre-trained network to accelerate test


func:
[PATCH] need to slow down in some changes ... cancel eckart for the
 time being


func:
[PATCH] Change from single Performance test Executable to different
 executables per backend.


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] add generic Mac toolchain file

I prefer that CMake find the MPI compiler wrappers instead of the base
compilers, if for no other reason than this often means mixing clang and
gfortran, since clang will likely be found first in PATH.

this toolchain assumes MPI wrappers are in the PATH but one can set the
base directory (with a trailing "/") if desired.

the BLAS/LAPACK used is "-framework Accelerate"


func:
[PATCH] Workaround for Visual Studio bug that causes very slow
 compilation


func:
[PATCH] Adding BoundaryInfo::add_elements()

This allows us to easily add boundary elements to an existing mesh
without creating a new mesh for them.

Factoring out _find_id_maps simplifies the code a bit.  If
BoundaryInfo::sync() is too slow we might also factor out
_add_elements to avoid a redundant _find_id_maps call, but I doubt
the redundancy will ever show up in profiling.


func:
[PATCH] Make mallocs uniformly an error in PetscMatrix

This adds the setting to the other two init methods that
if a new malloc occurs during MatSetValues then it is an
error. I think this is an improvement because it establishes
uniformity across our init methods and it can prevent users
from running extremely slow simulations.

I fully expect this to cause failures in MOOSE...


func:
[PATCH] Add the possibility to remove the far points

The far points are added by the parallel version to reduce the contention
on the infinite vertex


func:
[PATCH] Use more accurate error message.

As discussed over in idaholab/moose#9097, Nanoflann does not actually
implement an *approximate* nearest node search algorithm. In contrast
to "exact" nearest node searches, approximate nearest node searches
are not guaranteed to return the nearest node, in return for potential
performance improvements.

See, for example, their README file [0], which states that Nanoflann
can "[Build] KD-trees with a single index (no randomized KD-trees, no
approximate searches)."

[0]: https://github.com/jlblancoc/nanoflann/blob/v1.2.3/README.md


func: [PATCH] Made FAST CPU results match CUDA results


func:
[PATCH] Remove OpenMP compile flag in CUDA backend

This flag isn't needed based on recent tests. If it is causing any
performance regression, it will be reverted and the following
flag to disable two-phase lookup for cuda backend on windows will
be added back.

/permissive flag does not work with two-phase-lookup enabled
for projects with openmp support enabled.


func:
[PATCH] WIP Fixed performance of multi-range subarray result
 estimation


func: [PATCH] Improve performance of random number generator calls


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


func:
[PATCH] new implemenation using boost CSR graph, it can be 1.5x
 faster from prev implementation but there is a performance problem that I
 couldn't solve using public functionality of graph (however there might be a
 solution) will look it back.


func:
[PATCH] Improve meanshift filter performance on CPU

Improved the meanshift filter performance on the CPU backend by replacing
vectors with std::arrays and moving them out of the for loops. Also
reduced a few conversion operations.


func:
[PATCH] 128-bit AVX2 SIMD for AMD Ryzen

While Ryzen supports 256-bit AVX2, the internal units are organized
to execute either a single 256-bit instruction or two 128-bit SIMD
instruction per cycle. Since most of our kernels are slightly
less efficient for wider SIMD, this improves performance by roughly
10%.

Change-Id: Ie601b1dbe13d70334cdf9284e236ad9132951ec9


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


func:
[PATCH] Better performance (~10-15% better)

By removing several tests (and use CGAL::max instead), the generated
assembly is more efficient.


func:
[PATCH] Replacing dynamic_cast with libmesh_cast where appropriate -
 depending on the error checking replaced this will either lead to slightly
 more efficient NDEBUG runs or slightly more run-time checking in debug mode
 runs.


func:
[PATCH] Adds sfence and lfence options if user builds with assembly
 to enable more efficient use of out of order engines


func:
[PATCH] Fix IR issue causing very slow to no convergence when using
 an inaccurate inner solver


func:
[PATCH] Add new constructor to Iso_rectangle_2(Point_2, Point_2,
 int). The additional dummy "int" specifies that the 2 points are the
 lower-left and upper-right corner.  This is more efficient when one knows
 they are already in this configuration.

Same thing for Iso_cuboid_3, and the functors.

Use them in Cartesian_converter and Homogeneous_converter.


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


func: [PATCH] Adjusted scheduling, removed slow atomic section


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


func:
[PATCH] allows requesting of multiple moments. restructures blocks
 for performance improvements


func: [PATCH] some more performance improvements


func:
[PATCH] Refactor threading model

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

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

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

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


func:
[PATCH] Modified nb_accv to improve performance of accumulates to
 processors on the same SMP node.


func: [PATCH] fast dynamic_cast in Lazy_kernel::Construct_point_3


func:
[PATCH] Disable CUDA textures on NVIDIA Volta

This has significant performance benefit for the nbnxm kernels with
tabulated Ewald correction and it has negligible impact on the PME kernels.

Partially addresses #3845


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


func:
[PATCH] #1295 Refactored MX::setSub(single argument) This should be
 significantly more efficient, though I didn't do any performance testing


func:
[PATCH] Performance improvments. BuildWeightMatrix() is probably
 unnecessary entirely.


func:
[PATCH] Move orb LUT in CUDA backend to texture memory

cuda::kernel::extract_orb is the CUDA kernel that uses the orb
lookup table. Shared below is performance of the kernel using constant
memory vs texture memory. There is neglible to no difference between two
versions. Hence, shifted to texture memory LUT to reduce global constant
memory usage.

Performance using constant memory LUT
-------------------------------------

Time(%)  Time   Calls      Avg       Min       Max  Name

3.02%  292.26us   24  12.177us  11.360us  14.528us  void cuda::kernel::extract_orb<float>
2.16%  209.00us   16  13.062us  11.616us  16.033us  void cuda::kernel::extract_orb<double>

Performance using texture LUT
-----------------------------

Time(%)    Time   Calls      Avg       Min       Max  Name

2.84%  270.63us     24  11.276us  9.6970us  15.040us  void cuda::kernel::extract_orb<float>
2.20%  209.28us     16  13.080us  10.688us  16.960us  void cuda::kernel::extract_orb<double>


func:
[PATCH] thermophysicalModels: Added caching of Cp and Cv for
 efficiency

In multi-specie systems the calculation of Cp and Cv is relatively expensive due
to the cost of mixing the coefficients of the specie thermo model, e.g. JANAF,
and it is significantly more efficient if these are calculated at the same time
as the rest of the thermo-physical properties following the energy solution.

Also the need for CpByCpv is also avoided by the specie thermo providing the
energy type in the form of a boolean 'enthalpy()' function which returns true if
the energy type is an enthalpy form.


func: [PATCH] performance improvements on grid_ssw


func:
[PATCH] Improved performance mostly by using hints to insert to the
 status line.


func: [PATCH] Made gmx_numzero static for performance reasons.


func:
[PATCH] PERFFIX: improved 2d convolve perf in cuda by 33%

* templating cuda kernel for filter lengths increased
  performance by 30% which is 93% of closed-source ArrayFire
  implementation of 2d convolution
* templating separable cuda kernel improved performance by 20%
* separated separable convolution kernel and wrapper into their
  own file to speed up compilation time


func:
[PATCH] modified to have 3c and 2c two electron eri sums also prints
 outer loop index to show user about where the computation is.  Also
 statically (modulo) parallelized for better performance

Rick Kendall


func:
[PATCH] lagrangian: Rationalized the handling of multi-component
 liquids and solids Ensures consistency between the mixture thermodynamics and
 composition specifications for the parcels. Simpler more efficient
 implementation. Resolves bug-report
 http://www.openfoam.org/mantisbt/view.php?id=1395 as well as other
 consistency issues not yet reported.


func: [PATCH] Optimize the performance of rot by using universal intrinsics


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] This commit introduces VariableGroups as an optimization when
 there are repeated variables of the same type inside a system.  Presently,
 these are only activated through the system.add_variables() API, but in the
 future there may be provisions for automatically identifying groups.

The memory usage for DofObjects now scales like
N_sys+N_var_group_per_sys instead of N_sys+N_vars.  The DofMap
distribution code has been refactored to use VariableGroups.

All existing loops over Variables within a system will work unchanged,
but can be replaced with more efficient loops over VariableGroups.


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


func: [PATCH] Fixed performance regression on Kepler


func:
[PATCH] Optimize load_tile_offsets for only relevant frags

This optimization is to adjust the `Reader::load_tile_offsets` class to
only loop over the relevant fragments as computed by the subarray class
based on intersection. This is a performance optimization for arrays
which have a large number of fragments and which we are incorrectly
fetching a large amount of unneeded data.


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


func:
[PATCH] Fix performances of Triangulation_2 with EPEC

There was a performance degradation between CGAL-3.7 and CGAL-3.8, when
Triangulation_2 is used with EPEC. This patch fixes the issue. Using a
functor that is specialized for EPEC, in inexact_orientation, to_double is
not called on p.x() but on p.approx().x().


func:
[PATCH] USER-DPD: performance optimizations to ssa_update() in
 fix_shardlow Overall improvements range from 2% to 18% on our benchmarks 1)
 Newton has to be turned on for SSA, so remove those conditionals 2) Rework
 the math in ssa_update() to eliminate many ops and temporaries 3) Split
 ssa_update() into two versions, based on DPD vs. DPDE 4) Reorder code in
 ssa_update_*() to reduce register pressure


func:
[PATCH] Sparse refactored readers: disable filtered buffer tile
 cache. (#2702)

From tests, it's been found that writing the cache for the filter
pipeline takes a significant amount of time for the tile unfiltering
operation. For example, 2.25 seconds with and 1.88 seconds without in
some cases. The cache improved performance before multi-range subarrays
were implemented, so dropping it is fine at least for the refactored
readers.


func: [PATCH] more efficient jacobian of mapping modes


func:
[PATCH] rocSPARSE does not require sorted columns for csrgemm

This is specific to the rocSPARSE CSR implementation of SpGEMM.
But this is a substantial performance savings.


func:
[PATCH] Step towards better performance regarding second convergence
 test in bicgstab


func:
[PATCH] Added code to improve performance for the structure factor
 calculations.....Works in serial...Still need to check parallel
 performance......EJB


func:
[PATCH] EA:increased MAXMEM size to 512 since it gives large
 performance improvement on big matrix multiplies


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


func: [PATCH] Improved GB performance in mixed precision


func:
[PATCH] added option to keep transpose to hybrid for better gpu
 performance


func:
[PATCH] changed DofMap::build_constraint_matrix to be more efficient
 in the (usual) case that the element has no constraints.  Also fixed for the
 case that an element has constraints in terms of its *own* dofs, (not others)

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


func: [PATCH] Use more efficient iterators in MeshCommunication


func:
[PATCH] Check in changes to improve performance for nb_puts and
 nb_gets on GPU-hosted global arrays.


func:
[PATCH] Fixed race condition in GPU restrictor.  Improved performance
 of both prolongator and restrictor using compile-time evaluated fine-spin ->
 coarse-spin mapper instead of an array.


func:
[PATCH] Improve mdrun performance user guide

- Extended GPU update related section;
- Tweaked the bonded GPU offload related section to reflect the current
  state of the code.

Change-Id: I89ed39750d449df8b273f36ee6530df29ff31b7e


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


func:
[PATCH] MultiReduce kernels now instantiate a series of power of two
 block sizes: this improves performance significantly


func:
[PATCH] Unroll dynamic indexing in SYCL gather kernel

Thread ID-based dynamic indexing of constant memory data in the SYCL
gather kernel caused a large amount of register spills and poor
performance of the gather kernel on AMD. Avoiding dynamic indexing
eliminates spills and improves performance of this kernel >10x.

Refs #3927


func: [PATCH] More efficient generation of random numbers


func:
[PATCH] replaced std::endl with \n in all file IO and stringstreams.
 std::endl forces a flush, which kills performance on some machines


func:
[PATCH] Performance improvements for find_*_neighbors, and a new
 find_point_neighbors version for finding neighbors at just one point


func: [PATCH] Improved performance of Python State objects


func:
[PATCH] On behalf of Ryan Olson: Checking in the changes for server
 side registration to improve performance


func: [PATCH] pathf90 v2.1 better performance with ro=1 vs. ro=2


func:
[PATCH] reworked the project_vector to be more efficient for Lagrange
 elements.  Changed the corresponding calls in reinit().  amr.cc now tests the
 projection stuff.

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


func: [PATCH] use local variables for more efficient force accumulation


func:
[PATCH] Optimize the performance of daxpy by using universal
 intrinsics


func:
[PATCH] Improved consistency of the ApplyPackedReflectors routines
 (as well as performance in several cases) and several more implementations,
 fixed mistakes in the build section of the documentation, added a short
 description of the new SVD function, and fixed mistakes in HouseholderSolve
 after adding a simple example driver.


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