[PATCH] fem_system_ex2 local->distributed solution

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

Refs #1593.


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

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

PR #1034

(cherry picked from commit 3db1195e2e8df48ca399b18d0250256443651bda)


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


[PATCH] minor changes for performance improvement and documentation


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


[PATCH] Adding Changelog for Release 2.9.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 2.9


[PATCH] Fix Kokkos performance regression for small systems


[PATCH] Improve performance of computeCoarseClover kernel: split
 triple matrix product into two steps to prevent redundant computation


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

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


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

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


[PATCH] Some simple memory leak fixes.

Although the fixed leaks are not important for performance, the less
there are leaks, the more convenient it is to run valgrind leak checking
on parts of the code.


[PATCH] Mesh_3: Address TBB performance warning on hashing


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


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


[PATCH] Fixed the bug where dumping distribution file would decrease
 the performance


[PATCH] additional pre-compiler command for performance testing


[PATCH] Minor tweaks to the DD setup

Dynamic load balancing is now turned on when the total performance
loss is more than 2% (lower than that will not help).
The check for large prime factors should be done on the PP node
count when -npme is set by the user.

Change-Id: Ib81b56a7cb071540b143a4bfc98758788a8ac07d


[PATCH] Misc. Doxygen build system improvements

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

Change-Id: I30de6f36841f25260700ec92284762e989f66507


[PATCH] Added wrappers for ScaLAPACK QR factorization (and an ability
 to test it from tests/lapack_like/QR) and subsequently revealed a (perhaps
 recently introduced) performance issue in Elemental's QR


[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


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


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


[PATCH] performance improvemnets that disable erf2 and ssf more
 changes needed


[PATCH] MKK: a test case to measure the performance of aggregate
 put/get calls.


[PATCH] SIMD acceleration for F_FOURDIHS and F_PIDIHS

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

Change-Id: I456af11c23fe1cb3749a889c5d92ec3ba06ab237


[PATCH] temporary changes to use MemoryType::HOST instead of
 HOST_UMPIRE for performance


[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


[PATCH] Import AMD Piledriver DGEMM kernel generated by AUGEM. So
 far, this kernel doesn't deal with edge.

AUGEM: Automatically Generate High Performance Dense Linear Algebra
Kernels on x86 CPUs.
Qian Wang, Xianyi Zhang, Yunquan Zhang, and Qing Yi. In the
International Conference for High Performance Computing, Networking,
Storage and Analysis (SC'13). Denver, CO. Nov, 2013.


[PATCH] Make performance ex1 and ex1p templated on dimension


[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


[PATCH] use fast insertion functions of arr


[PATCH] Made FAST CPU results match CUDA results


[PATCH] Improved CUDA SIFT coalescing and performance


[PATCH] mesh::data: Use a DynamicList for the performance data for
 efficiency


[PATCH] accelerate distance queries for offset meshing


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


[PATCH] Fixed an uninitialized memory read problem and a potential
 performance issue for problems in less than 3 dimensions.


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


[PATCH] fixed nbnxn x86 SIMD non-bonded performance regression

Commit f40969c2 broke the LJ combination detection,
which effectively made all runs use the full combination rule
matrix for x86 SIMD kernels. This is now corrected.

Change-Id: I1073801546fde23e6a53199120246697a7c61b5f


[PATCH] more efficient version, which only searches when necessary
 and only once per element


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


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


[PATCH] Accelerate CSR->Ell,Hybrid conversions on CUDA.

+ The previous grid dimensions for `initialize_zero_ell` were `stride *
  num_rows`, i.e. roughly the dense matrix dimension.
+ Using `max_nnz_per_row * num_rows` reduces significantly the amount of threads
  created which makes this kernel call more efficient (less useless thread
  creation).


[PATCH] Fix backwards atomic defaults

Thanks @stanmoore1 for reporting this.
This doesn't affect performance results
because those tests don't use the defaults.


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


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


[PATCH] Sparse refactored readers: disable filtered buffer tile
 cache.

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.


[PATCH] TurbulenceModels::kOmegaSST.*: Updated source-terms and
 associated functions to use volScalarField::Internal

This is more efficient, avoids divide-by-0 when evaluating unnecessary
boundary values and avoids unnecessary communications when running in parallel.


[PATCH] fixing performance of nwpw_gauss_weights...EJB


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


[PATCH] Latest modifications that increased the parallel performance


[PATCH] Tensor, SymmTensor: Simplified invariantII

Now the calculation of the 2nd-invariant is more efficient and
accumulates less round-off error.


[PATCH] Isolate PME GPU spline parameter indexing in inline functions

This makes the spread/gather kernels more readable and allows
to change the spline indexing scheme much easier in
the future. Performance should not be affected.
More TODO regarding the spline indexing scheme is marked.

Change-Id: If735cccf2ce82f46b483c9ada6f309425c51f67e


[PATCH] Modified Newton Raphson method added and some basic timers A
 modified newton raphson method has been added in place of the old pure newton
 raphson. It's nothing fancy it just sets the relaxation factor for the next
 time step to 0.5 if it notes that the ratio in the norm of the current
 residual and the previous residual hasn't decreased by a factor of 10 or
 greater. The relaxation factor is set to 1.0 if it is converging fast enough.
 The main motivation behind this is to push the solution in the right
 direction when it starts to oscillate the actual answer. Next, a few basic
 timers have been set around the entire solution set to provide some very
 basic profiling for how long each time step takes to solve.


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


[PATCH] Request flushing denorms to zero in OpenCL

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

Fixes #2593

Change-Id: I9e6183c4367b5960e0e21f1dd342d7695acfbc44


[PATCH] Adding a block diagonal preconditioner in the serial example
 to improve solver performance


[PATCH] Creating a boolean operations object from map overlay. It
 gives the user the possibility to create the boolean oepration object with
 the walk along aline point-location, which is more efficient when using
 sweep-line.


[PATCH] Fixed performance figures. TODO: new graphs


[PATCH] Improved GB performance in mixed precision


[PATCH] Added const& for gaining performance


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


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

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


[PATCH] Final bugs fixed, now have to look at the iterator
 performance for the subtable.


[PATCH] Added support of IBM's MASS library that optimizes
 performance on Power architectures


[PATCH] changed dim_type typedef to int from long long

Using long long for indexing data type is causing drastic
performance drop for CUDA and OpenCL kernels. Hence, changing the
typedef to point to int.


[PATCH] Task assignment for bonded interactions on CUDA GPUs

Made a query function to find whether any interactions of supported
times exist in the global topology, so that we can make efficient
high-level decisions.

Added free for gpuBondedLists pointer.

Minor cleanup in manage-threading.h

Fixes #2679

Change-Id: I0ebbbd33c2cba5808561111b0ec6160bfd2f840d


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


[PATCH] Add support for Hygon Dhyana processor

This change adds hardware detection and related task assignment
heuristics support for the Hygon Dhyana CPUs.

Chengdu Haiguang IC Design Co., Ltd (Hygon) is a Joint Venture
between AMD and Haiguang Information Technology Co.,Ltd., aims
at providing high performance x86 processor for China server
market. Its first generation processor codename is Dhyana, which
originates from AMD technology and shares most of the architecture
with AMD's family 17h, but with different CPU Vendor ID ("HygonGenuine")
/Family series number (Family 18h).

More details can be found on:
http://lkml.kernel.org/r/5ce86123a7b9dad925ac583d88d2f921040e859b.1538583282.git.puwen@hygon.cn

Change-Id: Ic91b032e69dfc13abad3fbfe6ab5e4f0e57fc7c0


[PATCH] Create a AVX512 enabled version of DGEMM

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

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


[PATCH] more efficient usage of mutex. The lock is only done if the
 build need to be done. We have an extra "if (m_need_build)" but otherwise we
 would need to use mutex::try_lock() which results in more code and as
 efficient.


[PATCH] resolved performance degrading changed introduced in revision
 1319 (3)


[PATCH] Fixed FAST memory leaks on CPU backend


[PATCH] fix for sigfpe (underflow) in ECPs: NWints/ecp is compiled
 with "-math_library accurate" instead of "-math_library fast"


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

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


[PATCH] VFS Read-Ahead Cache (#1785)

This introduces a read-ahead cache within VFS::read(). This is an LRU cache
that maintains a single cached buffer for an arbitrary number unique URIs, not
to exceed 10MiB (by default). Each cached buffer has a max size of 100KiB (by
default). These parameters can be tweaked with the following config items:

`vfs.read_ahead_size` (100KiB default)
`vfs.read_ahead_cache_size` (10Mib default)

The motiviation for this patch is to optimize IO patterns of small, relatively
sequential reads against cloud storage backends. Only the S3, Azure, and GCS
backends utilize this read cache. The POSIX/Windows/HDFS backends are
unaffected by this patch.

Both performing and caching the read-ahead incur a performance penalty:
1. We must read more than the requested bytes.
2. We must make a copy of the read buffer (one to store in the cache, one to
return to the user).

We will only perform a read-ahead if the requested read is smaller than the
default 100KB cached buffer size. IO patterns of large reads will be unaffected.
The assumption is that fragment data is large and that reading fragment
data will not incur a performance penalty. Additionally, reads to tile data
are bypassed because tiles have their own separate tile cache.

On the recent S3 workload we've been discussing, this read cache has a 78%
hit rate, where every cache hit is in the fragment metadata. I've observed a
best-case runtime of 6.5s with this patch, and a 27s runtime without this
patch.

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


[PATCH] it seems to work comments The armijo rule is really slow The
 statistical update of sigmas is good We need to stay sometime in low sigmas
 otherwise we do not optimize the trace Next setp is BFGS method


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

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


[PATCH] Code clean up in FAST and ORB for all backends

- C++ features class no longer used inside backends


[PATCH] POWER10: Update param.h

Increasing the values of DGEMM_DEFAULT_P and DGEMM_DEFAULT_Q helps
in improving performance ~10% for DGEMM.


[PATCH] Issue #2738 More efficient clearing of DaeBuilder cache Wait
 until it's really needed


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


[PATCH] Compile using g++ on OSX

The Accelerate framework requires -flax-vector-conversions to
compile on g++


[PATCH] Improving the performance, 10-20% slower than
 Triangulation_2, not removing the initial vertices


[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


[PATCH] Fix IBM VSX SIMD compiles with xlc

Remove most of the previous inline asm to improve
performance (the optimizer works better w/o asm),
and make sure the VSX SIMD code compiles with XLC.

Change-Id: I3e8e9b4dd6102dd5503210e3b49b844ee5492342


[PATCH] added a hybrid method that will first try to solve with
 diagonal scaled CG and then if convergence is too slow , attempt to use
 BoomerAMG


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


[PATCH] Make stepWorkload.useGpuXBufferOps flag consistent

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

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

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

Refs #3915 #3913 #4268


[PATCH] TCE GPU: add environment varibale NWC_OFFLOAD_SPAN

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

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


[PATCH] Add BoundaryVolumeSolutionTransfer class.

This class can be used for transferring solutions between the surface
of a volume mesh and the BoundaryMesh associated with that surface.
This is joint work with with Xikai Jiang from Argonne National
Laboratory (@xikaij) who is the original author of the transfer.

See also: X. Jiang et al., "An O(N) and parallel approach to integral
problems by a kernel-independent fast multipole method: Application to
polarization and magnetization of interacting particles," The Journal
of Chemical Physics vol. 145, 064307, http://dx.doi.org/10.1063/1.4960436.


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


[PATCH] Switch to unordered_multimap in UNVIO.

After trying out a few different container types, it was determined
that the cost of building every side (in order to search for it in the
multiset) killed the performance of the unordered_set<Elem*> method,
and that the unordered_multimap approach was superior to a standard
multimap across a range of mesh sizes (below, there are 6*N^2 sides to
search through in the container in question).

N    unordered_set multimap unordered_multimap
10   0.0012        0.0006   0.0005
15   0.0049        0.0021   0.0018
20   0.0102        0.0055   0.0058
25   0.0201        0.0118   0.0062
30   0.0415        0.0288   0.0126
35   0.0579        0.0377   0.0169
40   0.0946        0.0612   0.0281
45   0.1467        0.0996   0.0426
50   0.1929        0.1213   0.0499
55   0.2662        0.1688   0.0716
60   0.4040        0.2250   0.1018
65   0.5981        0.3388   0.1376
100  2.2838        1.5329   0.6257


[PATCH] more efficient comparison function


[PATCH] In OpenMP threading, preallocate the thread buffer instead of
 allocating the buffer every time. This patch improved the performance
 slightly.


[PATCH] Don't use Boost.Operators for +-*/ of Gmpq.

It shouldn't change the performance significantly (the time is spent in
malloc/free and the mpq_* calls), but at least I can follow the
(smaller) generated code.


[PATCH] tuned performance of script; added linked index


[PATCH] normalize_border is there only for performance


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


[PATCH] moved diff, fast, gradient, harris, histogram to kernel
 namespace


[PATCH] Fixing a performance bug in trsm_[LR].c.


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


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


[PATCH] added performance figures in the doc


[PATCH] Add CUDA nvcc >=7.0 support

With CUDA 7.x, there is a few % performance benefit to using sm_52
arch as target instead of JIT-ed compute_50, mostly relevant with
the newly released v7.5 (as v7.0 has other regressions which make it
slower).

This change adds a single new target architecture (5.2) and changes
the virtual architecture included in the binary from 5.0 to 5.2 with
new enough nvcc to make 5.1.x versions future-proof when new hardware is
released.

Change-Id: I062cc48a151da3ab15b0508f4ebd59d95880ae9a


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

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


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


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


[PATCH] s390x: allow clang to emit fused multiply-adds (replicates
 gcc's default behavior)

gcc's default setting for floating-point expression contraction is
"fast", which allows the compiler to emit fused multiply adds instead of
separate multiplies and adds (amongst others). Fused multiply-adds,
which assembly kernels typically apply, also bring a significant
performance advantage to the C implementation for matrix-matrix
multiplication on s390x. To enable that performance advantage for builds
with clang, add -ffp-contract=fast to the compiler options.

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


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


[PATCH] combustionModels::EDC: New Eddy Dissipation Concept (EDC)
 turbulent combustion model

including support for TDAC and ISAT for efficient chemistry calculation.

Description
    Eddy Dissipation Concept (EDC) turbulent combustion model.

    This model considers that the reaction occurs in the regions of the flow
    where the dissipation of turbulence kinetic energy takes place (fine
    structures). The mass fraction of the fine structures and the mean residence
    time are provided by an energy cascade model.

    There are many versions and developments of the EDC model, 4 of which are
    currently supported in this implementation: v1981, v1996, v2005 and
    v2016.  The model variant is selected using the optional \c version entry in
    the \c EDCCoeffs dictionary, \eg

    \verbatim
        EDCCoeffs
        {
            version v2016;
        }
    \endverbatim

    The default version is \c v2015 if the \c version entry is not specified.

    Model versions and references:
    \verbatim
        Version v2005:

            Cgamma = 2.1377
            Ctau = 0.4083
            kappa = gammaL^exp1 / (1 - gammaL^exp2),

            where exp1 = 2, and exp2 = 2.

            Magnussen, B. F. (2005, June).
            The Eddy Dissipation Concept -
            A Bridge Between Science and Technology.
            In ECCOMAS thematic conference on computational combustion
            (pp. 21-24).

        Version v1981:

            Changes coefficients exp1 = 3 and exp2 = 3

            Magnussen, B. (1981, January).
            On the structure of turbulence and a generalized
            eddy dissipation concept for chemical reaction in turbulent flow.
            In 19th Aerospace Sciences Meeting (p. 42).

        Version v1996:

            Changes coefficients exp1 = 2 and exp2 = 3

            Gran, I. R., & Magnussen, B. F. (1996).
            A numerical study of a bluff-body stabilized diffusion flame.
            Part 2. Influence of combustion modeling and finite-rate chemistry.
            Combustion Science and Technology, 119(1-6), 191-217.

        Version v2016:

            Use local constants computed from the turbulent Da and Re numbers.

            Parente, A., Malik, M. R., Contino, F., Cuoci, A., & Dally, B. B.
            (2016).
            Extension of the Eddy Dissipation Concept for
            turbulence/chemistry interactions to MILD combustion.
            Fuel, 163, 98-111.
    \endverbatim

Tutorials cases provided: reactingFoam/RAS/DLR_A_LTS, reactingFoam/RAS/SandiaD_LTS.

This codes was developed and contributed by

    Zhiyi Li
    Alessandro Parente
    Francesco Contino
    from BURN Research Group

and updated and tested for release by

    Henry G. Weller
    CFD Direct Ltd.


[PATCH] Improve the performance of rot by using AVX512 and AVX2
 intrinsic


[PATCH] reactingEulerFoam: Un-templated interface composition models

The recent field-evaluation additions to basicSpecieMixture means that
the interface composition models no longer need knowledge of the
thermodynamic type in order to do efficient evaluation of individual
specie properties, so templating on the thermodynamics is unnecessary.
This greatly simplifies the implementation.


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


[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


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

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


[PATCH] MeshCommunication new_nodes methods

These should be more efficient in many cases and may be necessary for
correctness in others.


[PATCH] Correct Pelleg-Moore prunes that finish a node. There were
 cases where a Pelleg-Moore prune would happen before committing the point.
 This is actually getting pretty fast in terms of base cases, so I am happy
 with that (for once).


[PATCH] Refactor parallel_algebra.h

We can simplify our derived types slightly by noting that the
LIBMESH_DIM entries are homogenous.

We should wrap MPI calls in the new error checking macro.

We should commit intermediate MPI types; failing to do so is
infinitesimally more efficient and seems to work in practice, but the
error descriptions in the resize docs I've read suggest that using an
uncommitted type may not be strictly allowed.


[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


[PATCH] Cache FEMContext::point_value() FE Objects

This really ought to be redone entirely, but hopefully we can get a
little performance improvement right away by just avoiding de and
reallocations.


[PATCH] Add Pelleg-Moore type prune.  This improves performance -- at
 least a bit.


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

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


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

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

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


[PATCH] More getElementByMass performance improvements

Reduces time taken from 15.7 seconds (last commit) to 2.2 seconds by avoiding
Quantity comparisons altogether.


[PATCH] Rebuild the OpenMP runtime library with Clang

To get rid of the warning:

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


[PATCH] Use block size stepping of 16 in new dslash kernels: improves
 performance of exterior-x kernels and 5 dimensional stencils.  Also, set max
 shared bytes to full dyanmic limit, since this gives a small improvement on
 Volta


[PATCH] Improvement of rectangular slicing: part 1 - memory efficient
 formulation


[PATCH] ARM64: Improve DAXPY for ThunderX2

Improve performance of DAXPY for ThunderX2
when the vector fits in L1 Cache.


[PATCH] Add TaskDAG performance test to CMake


[PATCH] QUDA: Overall of BLAS, better tuning, bugs fixed, fixed
 performance regressions, support for 32 way reductions, removed bank
 conflicts from complex and triple reductions

git-svn-id: http://lattice.bu.edu/qcdalg/cuda/quda@1121 be54200a-260c-0410-bdd7-ce6af2a381ab


[PATCH] Use gmx_mtop_t in selections, part 2

Use gmx_mtop_t throughout low-level selection routines, i.e.,
centerofmass.cpp, poscalc.cpp, and indexutil.cpp.  Adapt test code,
which is now using gmx_mtop_t throughout as well.

In places where gmx_mtop_t is actually accessed, the changes are as
local as possible.  In most cases, some additional restructuring could
give better performance and/or much clearer code, but that is outside
the scope of this change.

Part of #1862.

Change-Id: Icc99432bddec04a325aef733df56571d709130fb


[PATCH] Example now works in parallel. The solver is still slow but
 it works


[PATCH] Very simple change to get ~20% performance improvement in
 reading Amber prmtop files.


[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


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


[PATCH] Removed unnecessary synchronization that hurt performance on
 Nvidia


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


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


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


[PATCH] HvD: Adjusted the these scripts removing the use of
 "svnversion" and replacing it with "svn info | grep Revision:". Svnversion
 works out exactly what revisions are contributing to your source code. While
 it is accurate it also takes quite some time to work this. On systems with
 slow disk access it can take 15 minutes or so. Svn info by contrast only
 checks the revision of the current directory. Hence it is much faster but not
 so accurate. However, for the source code distributions we generate we take a
 clean copy of the repository anyway and then the svn info result must match
 svnversion. So this should be good enough and much faster.


[PATCH] Fixed up some bugs in the host to device accumulate for same
 process communication in nb_accv and added operations to support improved
 performance of scatter operation within same SMP node.


[PATCH] Fix issue with HWLOC + OpenMP on XeonPhi

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


[PATCH] some improvements in performance on it2 (previous name of
 routine was hferi.f)


[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


[PATCH] basicThermo: Cache thermal conductivity kappa rather than
 thermal diffusivity alpha

Now that Cp and Cv are cached it is more convenient and consistent and slightly
more efficient to cache thermal conductivity kappa rather than thermal
diffusivity alpha which is not a fundamental property, the appropriate form
depending on the energy solved for.  kappa is converted into the appropriate
thermal diffusivity for the energy form solved for by dividing by the
corresponding cached heat capacity when required, which is efficient.


[PATCH] KokkosContainers: Mark perf tests as CATEGORY PERFORMANCE

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


[PATCH] nishant, added efficient jackknifed m spacing estimator


[PATCH] Remove selective unfiltering. (#2410)

From what we know about our customer's use case, they either will read
the full array where this gains nothing (and actually this affects the
performance negatively because of the added code complexity), or very
targeted ones, for which the gains would be very small, unless the tile
capacity/extent is unusually large if the users have a poorly configured
array.

Also, this will allow us to implement compression codec for video and
imaging, which won't work with selective unfiltering.


[PATCH] Final performance tuning on the dense version of the
 algorithm


[PATCH] - Be more storage efficient, and general clean up.


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


[PATCH] Fix a warning

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

  CGAL performance notice:

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

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

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


[PATCH] enable GPU sharing among tMPI ranks

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

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

Change-Id: Iac7a39f841ca31a32ab979ee0012cfc18a811d76


[PATCH] Use [..] instead of at(..) in LINCS GPU data management code

The .at(..) was used to make sure that the indices are within bonds
while the code is not thoroughly tested. Now it can be replaced with
direct access [..] for performance reasons.


[PATCH] Changed some compiler flags for better performance


[PATCH] Sun Performance Library debugged and tested


[PATCH] Simplify gmx chi

This change is pure refactoring that prepares for performance
improvements to ResidueType handling that will benefit both grompp and
pdb2gmx.

Use vector and ArrayRef to replace C-style memory handling. Some
histogram vectors were being over-allocated by 1, which is no longer
safe to do now that the size of the vector is relevant when looping,
so those are reduced.

Eliminated and reduce scope of iteration variables. Removed an unused
function and some debug code in comments. Used const references rather
than pointers where possible. Used range-based for and algorithms in
some places that are now possible to do so.


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


[PATCH] Use HostVector for PME CPU Force Buffer

Fix performance bug: PME CPU force buffer should be a HostVector to
allow pinned memory GPU transfers (which occur in PME-PP
communications on virial steps).


[PATCH] HvD: Adding a small performance test to check whether it
 makes sense to use a Taylor series for exp().


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


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


[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


[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


[PATCH] performance improvements for Linear JIT CUDA kernels


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

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


[PATCH] New data parallel routines to improve performance


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


[PATCH] 28-30% improvement in cuda vs opencl speedup for bilateral

* Replacing exp cuda device function with __expf improved the cuda
  bilateral kernel performance vs opencl kernel.
* Removed redundant multiplication calculation in the for loop
  of cuda/opencl kernels


[PATCH] Improve Ginkgo device arch flags management.

1. Use a newer version of CAS which makes Auto become All when no
   architecture was detected. This ensures that compiling on a node without
   a GPU will provide good performance (at the cost of binary size and
   compile time), instead of failing to provide optimized architecture
   specific kernels.
2. Use the `variable` version of CAS instead of `target` so that we do
   not call the CAS redundantly in several tests.
3. Fix HIP AMDGPU flags which were not properly passed:
   `target_compile_options` do not seem to work with `hip_add_library`, so
   the flags need to be passed to `hip_add_libary` (or executable)
   directly.


[PATCH] Break apart update_constraints

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

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

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

Removed some ancient debug dump output.

Refs #2423, #1793

Change-Id: I21c10826721ddc9a79a33b1dc75971a20d0855d9


[PATCH] use MinMaxTuple as return value of minmax

This might slow things down.

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


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


[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


[PATCH] Tetrahedral mesh

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

- Enhances the performance when moving the manipulated frame.


[PATCH] added precompiler commands for performance tests bug fix in
 SNC_FM_decorator and SNC_constructor: plane sweep must be done on correct
 planes


[PATCH] Improved the performance of finding whether a halfedge is on
 the outer ccb


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


[PATCH] Fixed put_in_list for better performance


[PATCH] Use range for in dof_map.C

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


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


[PATCH] Use processor_id_type where appropriate

I was accidentally using dof_id_type instead, and since that will
always be equal or larger this mistake shouldn't have led to bugs, so
I won't bother turning this commit into a half dozen different fixup
commits to rebase.

However, using the correct type should be infintesimally more
efficient and significantly less confusing.


[PATCH] optimize create_atoms performance for large boxes and small
 regions. warn if taking a long time


[PATCH] Improve performance for SYCL parallel_reduce


[PATCH] Added OPTLD for optimized but slow loading which you want for
 time-critical programs such as mdrun.


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


[PATCH] improved efficiency for communication somewhat and fixed Ssw
 option to work correctly, albeit not as efficient as possible yet.


[PATCH] Fixed nbnxn_4xN performance regression

Commit 8e92fd67 changed the 2xNN kernel to use gmx_simd_blendnotzero_r
and the 4xN kernel to use gmx_simd_blendv_r. Making the 4xN kernel
consistent with the 2xNN kernel improves the performance with AVX2
with 4% and 3% for the RF and PME kernels, respectively.

Change-Id: Iac334865c2b2340493639300d07e7ab9c78e129f


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


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


[PATCH] Improve the performance of dasum and sasum when SMP is
 defined


[PATCH] Changed default cuda stream to be non-zero

* Added additional following api functions specific to cuda backend
    * afcu_get_stream
    * afcu_get_native_id
* Removed duplicate class in fast kernel that helps declare
  dynamic shared memory based on template type


[PATCH] a slow version of triangle split


[PATCH] Refactor sign to signbit internally

The operation being performance is equivalent of std::signbit
thus, using signbit is more apt and removes unnecessary redefine
of sign function in opencl jit kernel.


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


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


[PATCH] POWER10:  Change dgemm unroll factors

Changing the unroll factors for dgemm to 8 shows improved performance with
POWER10 MMA feature.   Also made some minor changes in sgemm for edge cases.


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


[PATCH] template cases: added cylindrical background mesh in rotating
 geometry cases

snappyHexMesh produces a far better quality AMI interface using a cylindrical background mesh,
leading to much more robust performance, even on a relatively coarse mesh.  The min/max AMI
weights remain close to 1 as the mesh moves, giving better conservation.

The rotating geometry template cases are configured with a blockMeshDict file for a cylindrical
background mesh aligned along the z-axis.  The details of use are found in the README and
blockMeshDict files.


[PATCH] more efficient comparison function

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


[PATCH] routines to control threading for Accelerate framework
 https://github.com/nwchemgit/nwchem/pull/331


[PATCH] moved warning of slow option to 'bugs'


[PATCH] slow draw of polyhedron_items fixed


[PATCH] Squeezed some air out of the spread, gather and solve
 routines. Should still be tested for parallel performance and correctness


[PATCH] Adding conditional compilation(#if defined(LOONGSON3A)) to
 avoid affecting the performance of other platforms.


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

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

    EXP_GA

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

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

    ARMCI_NETWORK=MPI_TS

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

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


[PATCH] Modified nb_putv to improve performance of transfers to
 processes on the same SMP node.


[PATCH] Added some profiling to catch performance numbers.


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


[PATCH] Signifcantly improved restrictor performance through the use
 of CTA index swizzling to improve spatial locality improving cache line
 utilization


[PATCH] Got parallelization working with CollocationIntegrator, very
 slow


[PATCH] Convert aligned moves to unaligned

should have no performance impact on reasonably modern cpus and fixes occasional crashes in actual user code.


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


[PATCH] more efficient live variables in SX virtual machine


[PATCH] Adding Changelog for Release 2.9.99

Part of Kokkos C++ Performance Portability Programming EcoSystem 2.9.99


[PATCH] Drastically improve performance of getElementByMass

The old approach iterated through the entire periodic table by atomic number and
subtracted the provided mass by the element's mass and kept track of the
smallest difference. The new approach steps through the elements in order of
atomic number and bails once it hits an element with a higher mass than the
target mass (assuming masses are monotonically increasing).

On my desktop, processing 4TVP-dmj_wat-ion.psf dropped from 297 s to 15.4 s. But
15.4 s is still a bit too long...


[PATCH] Continue working on FParser JIT

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


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


[PATCH] Add IntRange helper class

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


[PATCH] Use numerical_jacobian_h_for_var

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


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


[PATCH] Add PointLocatorBase::locate_node()

This isn't nearly as efficient as it could be if we override it in
PointLocatorTree, but it's simple and I'm not planning on using it in
any inner loops.


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


[PATCH] Use acq/rel semantics to pass flags/pointers in
 getrf_parallel.

The current implementation has locks, but the locks each only
have a critical section of one variable so atomic reads/writes
with barriers can be used to achieve the same behavior.

Like the previous patch, pthread_mutex_lock isn't fair, so in a
tight loop the previous thread that has the lock can keep it
starving another thread, even if that thread is about to write
the data that will stop the current thread from spinning.

On a 64c Arm system this improves performance by 20x on sgesv.goto.


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


[PATCH] SNAP optimizations, kernel fusion, large reduction of memory
 usage on the GPU, misc. performance optimizations.


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


[PATCH] Enable dynamic pair list pruning

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

Change-Id: Ic625858a07083916c8aa3e07f7497488dcfaee9e


[PATCH] Speed up mtop_util atom lookup

The lookup of atom indices and properties on global atom index have
been sped up by moving functions to a new header file mtop_lookup.h
and by storing start and end global atom indices in gmx_mtop_t.
Another performance improvement is that the previous molblock index is
used as starting value for the next search.
The atom+residue lookup function now also returns the reside index.
This change also simplifies the code, since we no longer need a lookup
data structure.
A large number of files are touched because the t_atom return pointer
is changed to const also in the atomloop functions.

Change-Id: I185b8c2e614604e9561190dd5e447077d88933ca


[PATCH] added a pragma to suppress a performance warning in std::map


[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


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


[PATCH] added a special cache for efficient conversion of
 Sqrt_extension to Bigfloat_interval, disabled by default


[PATCH] Use more efficient way of getting number of classes.


[PATCH] This is a more correct implementation. But it isn't efficient
 and it may fail on corner cases.

That can be a problem for another day... (are you reading this from the future?
Sorry...!)


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


[PATCH] Fix hardware topology detection for modern systems

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

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


[PATCH] Expanded the GetIrTest behavior to enable efficient testing


[PATCH] Parallelize closing of files on write

This change parallelizes the closing of files on writes. This solves a
performance problem when the user was using S3 or other object store
where we buffer the multi-part writes. If the user's data was below the
buffer size, then no io would have occurred until the closing when we
flush buffers. This causes a large performance penalty relative to
expected because up to three files per field had to be uploaded
serially.


[PATCH] Use non-allocating build_edge_ptr where possible

This may be noticeably more efficient in a few of these cases.


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

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


[PATCH] Added gpu implementation for second convergence test in
 bicgstab. Improved performance by moving x += alpha * y from step_3 to step_2
 in all implementations.


[PATCH] tables added on cache performance


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

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

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


[PATCH] more efficient treatment of geometries in qmmm


[PATCH] KokkosCore: Mark perf tests as CATEGORY PERFORMANCE

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


[PATCH] Make linspace() non-recursive

For a "linspace(a, b, num)" call with "a" and/or "b" symbolic expressions,
the recursive implementation would lead to a graph of "num" depth. For
large "num" this can lead to e.g. a very slow "is_equal" check due to the
depth requirement.

Another reason to prefer a multiplication over recursive addition is
eliminating the compounding error due to rounding when calling linspace
with numeric arguments.


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

Revise core unit and performance tests to execute correctly.


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


[PATCH] Fixed return value of gmx_mtop_bondeds_free_energy

The return value was always true, which was harmless, since it
could only cause a small performance hit of useless sorting.

Fixes #1387

Change-Id: I088a3747ddb3517fbb5e416b791bd542bd49fed2


[PATCH] Adding specific code for Tet + Bbox_3 do_intersect as it
 should be ok for Bbox_3 to degenerate.

Adding specific code for Tet + Bbox_3 do_intersect as it should be ok for Bbox_3 to degenerate.

The previous code failed in case Bbox_3 is degenerate.

I use the result = result || predicate(); to keep the maybe inside result.
If certain the code returns early.
I also avoid the %4 as this is a slow operation, but not sure that this is worth compared to the rest.


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


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


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


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


[PATCH] Pass Cell_handle and Vertex_handle by value instead of by
 const&.  This undoes :

    r19107 | afabri | 2003-10-17 10:49:19 +0200 (Ven 17 oct 2003) | 2 lignes
    Added const& for gaining performance

which was justified at the time by the fact that on VC++, handles encapsulated iterators.


[PATCH] Acquire BC lists outside the CheckPointIO id loop

This should be just as fast for restarts and O(Nsplits/Nprocs) times
faster for mesh splitting.  Thanks to @friedmud for the idea.


[PATCH] Support pinning in HostAllocator

We want the resize / reserve behaviour to handle page locking that is
useful for efficient GPU transfer, while making it possible to avoid
locking more pages than required for that vector. By embedding the
pin()/unpin() behaviour into malloc() and free() for the allocation
policy, this can be safely handled in all cases.

Additionally, high-level code can now choose for any individual vector
when and whether a pinning policy is required, and even manually
pin and unpin in any special cases that might arise.

When using the policy that does not support pinning, we now use
AlignedAllocator, so that we minimize memory consumption.

Change-Id: I807464222c7cc7718282b1e08204f563869322a0


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


[PATCH] SDG Linf fast insertion examples

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


[PATCH] Fix indexing issue in the pull code

When determining if the COM of pull groups should be computed,
the indexing range of group[] for each pull coordinate is one element
too long. In most cases this element is 0, so in which case it only
lead to extra, useless compute when a cylinder group is used.
Note that for dihedral geometry the extra element is actually dim[0]
in pull coord, which is 0 or 1, which is harmless.

No release note, since this did not affect results, it could only
cause a minor performance loss with cylinder pulling.

Fixes #2486

Change-Id: Ie5785181fbe28d8db57e37c58553ae3835e657b7


[PATCH] Incorporated Poisson solver in the mdrun code. It is dead
 slow but maybe parallellized easily and is a good reference code for PPPM,
 since it is about twice as accurate as PPPM at the same number of grid
 points.


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


[PATCH] bond/react: efficient competing reactions


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


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


[PATCH] Global thread pool when TBB is disabled (#1760)

This introduces a global thread pool for use when TBB is disabled. The
performance has not been exhaustively benchmarked against TBB. However, I did
test this on two readily available scenarios that I had been recently performance
benchmarking for other reasons. One scenario makes heavy use of the parallel_sort
path while the other does not. Surprisingly, disabling TBB performs about 10%
quicker with this pach.

// Scenario #1
TBB: 3.4s
TBB disabled, this patch: 3.0s
TBB disabled, on dev: 10.0s

// Scenario #2
TBB: 3.1
TBB disabled, this patch: 2.7s
TBB disabled, on dev: 9.1s

For now, this patch uses the threadpool at the same scope as the TBB scheduler.
It is a global thread pool, shared among a single process, and conditionally
compiled. The concurrency level that the thread pool is configured with is
determined from the "sm.num_tbb_threads" config.

This patch does not disable TBB by default.

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


[PATCH] type 2 instability fixed; type 2.5 still not fixed but Rick
 disabled texas in this case; significant performance optimizations for '95
 esp. gradients


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


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


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


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


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


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

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

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

Change-Id: I5866fcc5865fb44ca3dca0cf217e0cab2afbea0c


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


[PATCH] More efficient TNG selection group creation

Do not create a TNG selection group if no selection is specified
explicitly, or if the selection contains all atoms in the system.

Change-Id: Ibe2a14e55aff829fdb74de074447f00f0e85f090


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


[PATCH] performance improvemnts under ia64


[PATCH] Initial checkin of code to test performance of strided
 onesided operations.


[PATCH] performance measurement for the triples plus attempts at
 optimizing one routine on a pentium


[PATCH] Halved the cost of the pull communication

With DD the PBC reference coordinates are now only communicated
after DD repartitioning. This reduces the number of MPI_alltoall
calls from 2 to 1 per step, which can significantly improve
performance at high parallelization.

Added a cycle counter for pull potential.

Added checks for zero pull vectors to avoid div by 0.

Change-Id: Ib89ba9e14eaa887f59a5087135580bc29a20d7d0


[PATCH] Add workaround for performance regression


[PATCH] Adding Changelog for Release 3.2.01 [ci skip]

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.2

(cherry picked from commit 0e0b28fd78e696f74ab8d1d6bfc1c3e2b9667f49)


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


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


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

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


[PATCH] fem_system_ex2 local->distributed solution

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


[PATCH] Enhancement: replace SQRT and POW by more efficient
 computations


[PATCH] additional precompiler lines for performance testing


[PATCH] improved copy_ccb method by replacing the used insert methods
 with more efficient versions of those methods.


[PATCH] adding parallel region around gmx_parallel_3dfft_execute.
 Makes it work correctly but unnessary barrier should be removed for
 performance reasons


[PATCH] Restructured the subdivision package

-- Integrated the doc in the header files
-- Split and moved files to have a proper internal structure and to distinguish
   between hosts, stencils and methods at the filename level.
-- Removed all instances of Polyhedron to have PolygonMesh instead
-- Cleaned off useless functions (Polyhedron_decorator remnants)
-- Improved general documentation
-- Minor performance improvements


[PATCH] Simplified neighborlist setup with GB and enroute to more
 efficient DD performance


[PATCH] Optimize

- Makes the resizing of the points real fast
- Makes the resizing of the normals applied on slider released instead of every tick when the point set size is bigger than 300 000
- sets the initial value of the point size to 2 instead of 5


[PATCH] Fix mis-branching in CouplingMatrix iterator++

This was causing a *huge* performance penalty in cases where we had
many variables.

Hopefully https://github.com/idaholab/moose/issues/9480 will be fully
resolved by the fix.  I see orders of magnitude speedup in our test
case.


[PATCH] checked in the wrong file last time, this is the really
 efficient version !


[PATCH] made nbnxn analytical Ewald consistent

The recent addition of nbnxn analytical Ewald kernels switched those
kernels on for local interactions, but not for non-local domains.
This performance bug has been fixed.

Change-Id: I28abc822ee8f1cf8f7dbb5c516703145400441b2


[PATCH] Rewrote the BoxManGatherEntries() code for handling
 AddGraphEntries() to improve performance when using the assumed partition.


[PATCH] Fixed g_sham using more than three dimensions

When the value given with g_sham -n was greater than 3, arrays used to
overflow and pick_minima() did not work. pick_minima() has been updated
to treat an arbitrary number of dimensions, but retains the particular
code for the two- and three-dimensional cases in the hope that these
are faster. The logic of the complex conditionals has hopefully been
made easier to follow without compromising performance with modern
compilers. Index variables are now of gmx_large_int_t type, as
high-dimensional cases can have large numbers of grid points very fast.

Change-Id: If0c2f9d9ceaf2b5c4c8b1a28a942fae8349fb600


[PATCH] updated traits class by replacing Side_of_hyperbolic_triangle
 with Side_of_oriented_hyperbolic_segment; added function
 side_of_hyperbolic_triangle to class Periodic_4_hyperbolic_triangulation;
 changed locate() function to more efficient version


[PATCH] PERF: improvements to element wise operations in CPU backend

- Improved performance when all buffers can be indexed linearly


[PATCH] Remove support for sparse writes in dense arrays. (#2504)

Supporting sparse writes in dense arrays caused performance issues and
since customer use of the feature is infrequent, the decision was made
to remove support.


[PATCH] slight performance improvement for 4x4 search


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

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


[PATCH] Improve rendezvous performance when hardware is
 oversubscribed


[PATCH] foamDictionary: Added support for reading files as case
 IOdictionary in parallel

If the -case option is specified time is created from the case
system/controlDict enabling support for parallel operation, e.g.

mpirun -np 4 \
    foamDictionary -case . 0/U -entry boundaryField.movingWall.value \
    -set "uniform (2 0 0)" \
    -parallel

This will read and modify the 0/U field file from the processor directories even
if it is collated.  To also write the 0/U file in collated format the collated
fileHandler can be specified, e.g.

mpirun -np 4 \
    foamDictionary -case . 0/U -entry boundaryField.movingWall.value \
    -set "uniform (2 0 0)" \
    -fileHandler collated -parallel

This provides functionality for field manipulation equivalent to that provided
by the deprecated changeDictionary utility but in a more flexible and efficient
manner and with the support of fileHandlers for collated parallel operation.


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

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


[PATCH] Initially assign spans of empty superblocks to block sizes
 and enable stealing of empty superblocks among block sizes.

Expand block size superblock hint array to "N" values per block size
to provide space for TBD superblock search optimizations.

Construct memory pool with min block, max block, and superblock size
and introduce performance optimizations related to max vs. min block size.

Issues #487, #320, #738, #215


[PATCH] better performance with hanging nodes


[PATCH] Allow useful CI to run in forks

* Move the fast jobs with no dependencies to the first stage.
* Remove the global KTH-specific job runner tag from jobs in the pre-build stage.
* Use the `pre-build` stage as the dependency for all later stages, rather than the `simple-build` job, specifically.
* Convert rule sets to new *rules* syntax.
* Use '$CI_PROJECT_NAMESPACE == "gromacs"' to distinguish jobs created with access to GROMACS GitLab infrastructure.

Fixes #3458


[PATCH] dtrsm_kernel_LT_8x2_bulldozer.S performance optimization


[PATCH] Simplify handling of DD bonded distances

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

Change-Id: Id409353c517181ac56e8d3f1f36c22c705aa8077


[PATCH] Switching to Simple_cartesian leads to a performance gain of
 50% for 100K points


[PATCH] optimization, improve performance by more than 20%


[PATCH] Implemented reordering of loads and stores so that the real
 and imaginary part are loaded/stored together.  This should improve
 out-of-cache performance in the presence of associativity conflicts, and
 maybe worsen in-cache performance because of worse scheduling. Enabled for
 now, for experimental purposes.


[PATCH] added fast return, if m or n < 1


[PATCH] Modify aligned address of sa and sb to improve the
 performance of multi-threads.


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

By default poisson now uses Eigen is available and Taucs otherwise


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


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


[PATCH] Even better performance figures in Poisson reconstruction
 through less pre-allocation in CGAL::Eigen_matrix


[PATCH] - Handle_for memory leak fixed : initialize_with() now
 assigns instead of   constructing, so that it works correctly after
 Handle_for has been default   constructed.  There's a new way of constructing
 a Handle_for :   Handle_for(TO_BE_USED_ONLY_WITH_CONSTRUCT_WITH) followed by
  construct_with(), which is supposed to produce more efficient code.
 Simple_handle_for also accepts it.


[PATCH] Add locks only for non-OPENMP multithreading

to migitate performance problems caused by #1052 and #1299 as seen in #1461


[PATCH] Fixed FAST files to comply with new directory structure.


[PATCH] added while loops in pbc_dx to correct for multiple box
 vectors shifts, and added set_pbc_ss for efficient single shift pbc_dx


[PATCH] Switching to standard essential BC treatment for solver
 performance gain (thanks to Socratis for catching this!)


[PATCH] Replacement for pdb2gmx tests

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

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

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

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

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

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

Minor updates to use compat::make_unique

Extended functionality of CommandLine for convenient use.

Refs #1587, #2566

Change-Id: I6a4aeb1a4c460621ca89a0dc6177567fa09d9200


[PATCH] Serious performance bug in threaded code fixed. Now the main
 thread goes after the children are launched.


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


[PATCH] Attempting to add diffusion term in a more efficient manner


[PATCH] Fix automated GPU ID assignment

When we permitted separate PME-GPU ranks, we should have relaxed
this logic also.

However, the performance in such cases is not very predictable, so if
there's a distribution of tasks with more than one task to a GPU that
is uneven, then we should require the user to specify exactly what
they want. This also reinstates the 2016-era behaviour where, if
running multiple PP ranks on GPUs, that mdrun will not by default
produce an unbalanced mapping with more than one task per GPU.

Change-Id: I5b2fad317ecbb4e5e02fccd68e15350b678df34c


[PATCH] resolved performance degrading changed introduced in revision
 1319 (2)


[PATCH] Template free-energy kernel on soft-core

Templated the free-energy kernel on the presence of soft-core
and the soft-core r-power.
Not doing the soft-core math when not using soft-core doubles
the speed of the free-energy kernel.
Templating for the soft-core power gives 15% performance improvement
with soft-core power 6.
Double precision r variables are only needed with r-power 48.

Change-Id: I5a37307b2a83304a40343a0708afce46f4bdcf75


[PATCH] Ditch --enable-debug-malloc and --enable-debug-alignment

We wrote DEBUG_MALLOC in 1997 to debug memory leaks.  Nowadays
DEBUG_MALLOC is just confusing.  Better tools are available, and
DEBUG_MALLOC is not thread-safe and it does not respect SIMD
alignment.  It confused at least one user.

In the gcc-2.SOMETHING days, gcc would allocate doubles on the stack
at 4-byte boundary (vs. 8) reducing performance by a factor of 3.
That's when we introduced --enable-debug-alignment, which is totally
obsolete by now.


[PATCH] Switch to "parallel_for" for cell scan => Better performance,
 in particular with implicit function domain.


[PATCH] Improved performance of tranpose

* Using int instead of dim_type
* Unrolling loops using static consts
* Using output dimensions


[PATCH] Refs JuliaLang/julia#5728. Fix gemv performance bug on
 Haswell Mac OSX.

On Mac OS X, it should use .align 4 (equal to .align 16 on Linux).
I didn't get the performance benefit from .align. Thus, I deleted it.


[PATCH] Add CUDA bonded kernels

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

Updated release notes and performance guide.

Fixes #2678
Refs #2675

Change-Id: Ifc6d97854cc7afa8526602942ec3b1712ba45bac


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

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


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


[PATCH] rewrite of T double kernels to improve performance with Intel
 16


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


[PATCH] HvD: Committing this data mainly for future record. The
 timings in these outputs will be reported in the paper as a demonstration of
 the performance difference between different implementations of the density
 functionals. The automatic differentiation timings reported here were
 generated using the intrinsic POPCNT, LEADZ and TRAILZ functions. At the
 moment the code does not use those by default as they are Fortran 2008
 intrinsics that are not supported by every compiler yet. However, using these
 intrinsics speeds the automatic differentiation code up by a factor of about
 2.5 and it not generate a fair representation of the automatic
 differentiation technique not to use the intrinsics.


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

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


[PATCH] Stopping criterion: improve the performance one last time by
 using a kernel for the boolean initialization instead of a synchronous copy.


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


[PATCH] ORourkeCollision: Corrected bugs and added more efficient
 collision detection See http://bugs.openfoam.org/view.php?id=2097


[PATCH] Accelerate the distracted sequence recall test.


[PATCH] Undo deprecation of BoundaryInfo::add_side().

* Remove new version of add_side() that takes a reference to a std::set.
  We are now ensuring that the entries in the input vector are unique
  while storing them in the BoundaryInfo object.

* Refactor MeshTools::Modification::change_boundary_id().  This
  function used to call boundary_ids() for every side, edge, and node
  in the mesh, but it should be more efficient to only call that for
  sides, edges, and nodes that have boundary ids on them.


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


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


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


[PATCH] Parallelize s3 multipart on disconnect

On disconnect of S3 we can parallelize the marking of multi-part uploads
as complete. This allows us to remove the exclusive lock early and
increase performance if we have a large number of outstanding requests.


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


[PATCH] Fast code now computes confidence bands


[PATCH] Preload Tile Offsets (#1795)

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

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

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

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

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

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

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


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


[PATCH] Replaced LU by QR decomposition.

ColPivHouseholderQR is, according to the manual both fast and rank
revealing.

Related to #59.


[PATCH] Added Grsm_ggm_sym_dot subroutine for more efficient
 calculation of product that result in symmetry matrices...EJB


[PATCH] Fixed FAST C++ API, added proper destructor calls.


[PATCH] JN: ELAN_ACC for fast accumulate


[PATCH] Fix Wundef warnings

Also fixes a performance bug in gmx_simd_invsqrt_pair_d. Previuosly it
did unnecessary number of iterations because it used an non-existing
preprocessor variable.

Change-Id: Idcdf3872b5a169e8690721bbe83922a4ab280da8


[PATCH] Attempting to accelerate the build by only including most of
 the internal copy:: headers when necessary


[PATCH] nbnxn utils performance improvement for Phi

Also remove usage of unpack to load half/quarter aligned data, because
in case of misaligned data, instead of SegF it only loaded partial data.

Change-Id: Ib0f7807986e6fcbe998bd6ee41ce104666446321


[PATCH] Improving the performance, 0-10% slower than Triangulation_2,
 not removing the initial vertices


[PATCH] perf: minor performance improvements for bilateral


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


[PATCH] Modifying a couple paramaters in the "POWER10"-specific
 section of param.h, for performance enhancements for SGEMM and DGEMM.


[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


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


[PATCH] Modified vector calls to improve performance when copy data
 to same processor.


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


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


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


[PATCH] hypre's GPU SpGemm (#433)

This PR improves the performance of hypre's sparse matrix-matrix on NVIDIA GPUs, and fixes it on AMD GPUs with hip.

Co-authored-by: Ruipeng Li <coe0141@redwood.cm.cluster>
Co-authored-by: Paul T. Bauman <ptbauman@gmail.com>


[PATCH] Accelerate "Checking if non utf-8 characters are used"


[PATCH] Always more efficient Face Partial Assembly Kernels. Lot of
 simplifications in the design of Domain Kernels. Remove inefficient Kernels
 Based on Eigen.


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


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


[PATCH] Modified version of cgal_test_with_cmake which: - is
 cross-platform Unix/make and Cygwin/VisualC++ - concats all log files to
 cgal_test_with_cmake.log - does not clean up object files and executables
 (too slow when called by developer)


[PATCH] More efficient IntegratorInternal::getDerivative #936


[PATCH] Improved performance of building neighbor list on AMD GPUs


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


[PATCH] Quadrature rule fixes for >double precision

Make sure calculations are done in Real precision where possible; fall
back on less-efficient-but-more-accurate defaults where the more
efficient cases are tabulated in double precision.


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


[PATCH] More efficient ordering of constrained DoF index sets


[PATCH] * modified termination policies * fast SVDBatch
 implementation


[PATCH] Set default GMX_OPENMP_MAX_THREADS to 64

As there are many new CPU with more than 32 hardware threads and
GROMACS scales quite well to more than 32 threads,
GMX_OPENMP_MAX_THREADS is increased from 32 to 64 threads.
The performance impact of this is that bitmasks are by default
64-bit instead of 32-but integers, which on 64-bit systems should
only have a (negligible) effect on cache pressure.

Change-Id: I73d1c79e86f30f7fc69e1f49e1195271435e77b6