[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] Code for measuring performance presented in user manual and
 associated data


[PATCH] Use vector in atoms2md instead of pointer

At all call sites for atoms2md the underlying vector was cast to an int pointer.
This change makes it easier to inspect the values passed to atoms2md in a
debugger while incurring no performance penalty.


[PATCH] Implemented basic serial 2D fast diagonalization


[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] 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] Reduce number of points to accelerate test.


[PATCH] Shape smoothing: some comments added to accelerate matrix
 construction. Konstantinos: this is what is so slow, not the solver!


[PATCH] Converted iir, fir, fftconvolve to async calls

Added eval, sync statements to orb, fast to make them work with
their asynchronous counter parts. Currently, one test of ORB is failing.
Will fix it later.


[PATCH] Use importlib_resources in Python 3.6 images.

Python 3.7 adds importlib.resources to the standard library, which
provides an efficient built in alternative to pkg_resources.
Backported functionality is available in the importlib_resources
package. We should add it to our Docker images to allow testing new
features while we still officially support Python 3.6.

See also issue #2961


[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] aabb tree: added performance section [to be completed with
 distance queries and curves]


[PATCH] added reduce operation (op=sum) in communication class.
 Efficient MPI_Reduce for MPIDirect, inefficient trivial loop over all slaves
 for all other communication methods. Added simple test in
 ParallelMAtrixOperationsTest.cpp


[PATCH] Avoid corner-only mesh connection in SlitMesh test

I've long said we don't support meshes where a manifold is only
connected at one node, but apparently we did kind of support it
accidentally in at least simple cases?  But improving
GhostPointNeighbors performance breaks this case, so let's extend the
mesh to something we've actually committed to handle.


[PATCH] Adding: 1. two reading functions. (one with a default
 scanner, and one taking it as a parameter). 2. Copy constructor.

Rewriting the assignment operator to be efficient as the copy constructor.


[PATCH] Enable some performance tests again


[PATCH] Fix cycle counting in StatePropagatorDataGpu

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

Fixes #3764


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


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


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


[PATCH] dgecop is a matrix transpose routine.  since ESSL has this
 routine in it, i added a link to that.  also, Qingda wrote a fast transpose
 routine that can be used if one has the OSU source code.

by default, nothing changes.  the faster transposes must be activated manually with ESSL_TRANSPOSE or OSU_TRANSPOSE.


[PATCH] HvD: Moved the printing routine of the NWAD library out from
 nwxc.F to a separate file nwxc_print.F. The performance of the expression
 printing is not performance critical but when the routines are included in
 nwxc.F they become candidates for inlining. This causes the compiler to spend
 effort on inlining and optimizing these printing routines which is effort
 wasted. By moving these routines into a file of their own they are not
 getting inlined and the compiler can spend its time on optimizing the actual
 compute routines.


[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] travis: try to make the slow tests pass again


[PATCH] Fix SIMD configuration management

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

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

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

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

Change-Id: Id9605ccff0903c55e2621ddd8af10c8da523bebe


[PATCH] SolverPerformance: Complete the integration of the templated
 SolverPerformance<Type>

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

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

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

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


[PATCH] Remove mdrun -testverlet

This was only intended for quick performance testing of old .tpr files
during the transition period. The window where that was useful has
passed, and ongoing abuse of it has been observed. There is no need to
preserve this until the formal removal of the group scheme.

Fixes #1424

Change-Id: I589a8e316beeba6819cd01d9655bfc069bcbb174


[PATCH] Updated whitespace, implemented low hanging performance
 boosts


[PATCH] - added performance note to solving functions doc - changed
 unbounded direction w so that x + tw is the unbounded ray - aded certificate
 iterators to QP_solution - added example programs that demonstrate the
 certificates - fixed examples so that 2D instead of D is given


[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] Amendments to density fitting manual section

 - Fixed a sign error in the energy and force definition
 - Added performance considerations
 - Fixed whitespace
 - Changed vector notation to mathbf as in the other parts of the manual
 - Added pressure-coupling considerations
 - Added considerations when using multiple-time-stepping

refs #2282

Change-Id: I8421ccf09ac960fa04508234e738967f51a27fab


[PATCH] Fix performance noexcept move constructor


[PATCH] Modernize read_inpfile

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

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

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

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

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

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

Refs #2074

Change-Id: Id9c46d60a3ec7ecdcdb9529bba2fdb68ce241914


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


[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] Start nvprof profiling at counter reset

When running in the NVIDIA profiler, to eliminate initial kernel
performance fluctuations, load balancing effects, as well as
initialization API calls from the traces, we now start the NVIDIA
profiler through the CUDA runtime API at the performance counter
resetting. This has an effect only if mdrun is started in nvprof with
profiling off.

Change-Id: Idfb3c86a96cb8b55cd874f641f4922b5517de6e3


[PATCH] commented out fast f77 compile options


[PATCH] added performance in ps/hour (CPU and Real)


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

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


[PATCH] Update tmop_pa_h3m kernel with fast mode


[PATCH] Adding Changelog for Release 3.4.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.4


[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] 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] PASSMESS_LOG_SCOPE - disabled for now

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


[PATCH] New test file for simple performance test


[PATCH] As std::fabs is slow on Windows, we switch to an
 implementation using sse2.

This version is already in CGAL, but it is protected with an #ifdef
So this commit consists of a #define for VC++


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


[PATCH] Use MPI_IN_PLACE in minloc/maxloc

We've already broken MPI-2 compatibility; in for a penny, in for a
pound.

In addition to the infintestimal performance gain, this quells a gcc
8.1 -Wmaybe-initialized false positive.


[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] Issue #2779 Ensure outputs up-to-date before linearization
 Not sure if this adds overhead and, if so, can be replaced by something more
 efficient


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


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

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


[PATCH] Turn assert into error in PBCs::neighbor()

This should fix #2958

I don't like putting opt mode tests into anything called on a single
element; that's just asking to bloat kernel runtimes ... but in this
case, when we don't actually have broken PBC ids/displacements, we never
hit the test on a replicated or serialized mesh, and we never hit the
test when calling PBCs::neighbor() on a local element, and at least
within the library itself it looks like we're only calling
PBCs::neighbor from local elements.  So this change ought to be safe for
performance after all.


[PATCH] Removed #error in case the file gets included twice. There
 are protected #ifdefs anyway. Also, we do not care about protected includes
 within the .C file anymore. It does not make compilation slow as before.


[PATCH] issue #2155: setting initial guesses slow


[PATCH] added the hybrid PCG solver which uses diagonal scaling first
 and switches to AMG if convergence too slow, solver 20


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


[PATCH] Adding Changelog for Release 3.3.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.3

(cherry picked from commit bd0c2c3713448f4d00b54998a42696ced1c1a188)


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


[PATCH] avoid name clash with fast directory


[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] polygonTriangulate: Added robust polygon triangulation
 algorithm

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

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

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


[PATCH] Add checks for inefficient resource usage

Checks have been added for using too many OpenMP threads and when
using GPUs for using single OpenMP thread. A fatal error is generated
in case where we are quite sure performance is very sub-optimal. This
is nasty, but a fatal error is the only way to ensure that users don't
ignore this warning. The fatal error can be circumvented by explicitly
setting -ntomp, in that case a note is printed to log and stderr.

Now also avoids ranks counts with thread-MPI that don't fit with the
total number of threads requested.

With a GPU without DD thread count limit is now doubled.

Disabled GPU sharing with OpenCL.

Change-Id: Ib2d892dbac3d5716246fbfdb2e8f246cdc169787


[PATCH] New and reorganized documentation

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

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

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

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

Change-Id: I6410ba9fc08bb133ec8669e14dba11bcbd454fe3


[PATCH] Use of WallClockTimer to measure performance


[PATCH] Gredner performance benchmark test


[PATCH] too conservative check removed, for fast removal in delaunay
 2d


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


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


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

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


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

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

Refs #2326

Change-Id: I07bfb3ca8d334bce18ed0b6989405bbc02c25b7b


[PATCH] Added parallel performance to the doc


[PATCH] Created Qt Demo for Polyhedron_shortest_path

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


[PATCH] moved ocl kernel resources from stack to heap

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


[PATCH] skylake dgemm: Add a 16x8 kernel

The next step for the avx512 dgemm code is adding a 16x8 kernel.
In the 8x8 kernel, each FMA has a matching load (the broadcast);
in the 16x8 kernel we can reuse this load for 2 FMAs, which
in turn reduces pressure on the load ports of the CPU and gives
a nice performance boost (in the 25% range).


[PATCH] Add example for distributed spmv scaling performance


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


[PATCH] making the thread checker (valgrind drd) happy has no
 performance disadvantage because it is in the planning phase


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

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


[PATCH] Loosen default tolerance: accelerate convergence.

For larger optimizations the default termination value of 1e-10 may be way too small.
So 1e-5 is generally better, but the user can always change it themselves...


[PATCH] Changed the performance test application


[PATCH] BUILD Adding option MIN_BUILD_TIME to CMake. Options sets O0
 for fast compile

* Od on MSVC
* Default is OFF. Flags are set when toggled to ON.
* Resets the flags to default release when toggled back to OFF.


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


[PATCH] ring non-axis parallel segment in pps subcase

This is only partially implemented. Still, it improves the
performance of the norway.cin benchmark.

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


[PATCH] Disable tests using EPECK (for performance reasons)


[PATCH] Explaining the performance test better.


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

- C++ features class no longer used inside backends


[PATCH] fix parallel build issues with APFS/HFS+/ext2/3 in
 netlib-lapack

The problem is that OpenBLAS sets the LAPACKE_LIB and the TMGLIB to the
same object and uses the `ar` feature to update the archive file. If the
underlying filesystem does not have sub-second timestamp resolution and
the system is fast enough (or `ccache` is used), the timestamp of the
builds which should be added to the previously generated archive is the
same as the archive file itself and therefore `make` does not update the
archive.

Since OpenBLAS takes care to not run the different targets updating the
archive in parallel, the easiest solution is to declare the respective
targets `.PHONY`, forcing `make` to always update them.

fixes #1682


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


[PATCH] Update citations.

Rahman_2020 and Wimmer_2020 both cite BISON as a fuel performance code
and Wimmer actually discusses some of the coefficients used in BISON,
but neither present simulation results using BISON. Chen_2020 talks
about some models that are in MARMOT, but does not use MOOSE.


[PATCH] Accelerate the distracted sequence recall test.


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

(cherry picked from commit 2c8fb67ce5d07e573396eb8764470fb79086c797)


[PATCH] HvD: On the Macintosh the BLAS and LAPACK libraries provided
 as part of the compiler framework are broken according to Jeff Daily. They
 work for small matrices but start to produce rubbish for large matrices.

Also the GA configure scans the machine for linear algebra routines on its
own account. Now setting BLAS_LIB=" " will force the --without-blas option
on the GA configure. This way the GA will build BLAS from source. This avoids
conflicts between NWChem and GA where NWChem built BLAS from source and GA
planned to load BLAS from a library, introducing conflicting views of the
integer types.

Finally on contemporary Macintosh machines there does not seem to be a need
to specify "--framework veclib" or "--framework accelerate" anymore. The
compilers and linkers seem to use this automatically. So we can remove that
from LIST_LINLIBS again.


[PATCH] ATW: Fast sparsity-optimized sigma AB and more scalable sigma
 AA using dgop


[PATCH] Revert "Adding a Fast configuration"

This reverts commit 091cdf9143a944784c5e35671927509d4f8b3d70.


[PATCH] tutorials/lagrangian: Added mixedVesselAMI2D

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

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


[PATCH] 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] Clang-tidy: enable further tests

Those out of misc, performance, readiability, mpi with managable
number of required fixes.

Remaining checks:
      4 readability-redundant-smartptr-get
      4 readability-redundant-string-cstr
      4 readability-simplify-boolean-expr
      5 misc-misplaced-widening-cast
      5 readability-named-parameter
      6 performance-noexcept-move-constructor
      8 readability-misleading-indentation
     10 readability-container-size-empty
     13 misc-suspicious-string-compare
     13 readability-redundant-control-flow
     17 performance-unnecessary-value-param
     17 readability-static-definition-in-anonymous-namespace
     18 misc-suspicious-missing-comma
     20 readability-redundant-member-init
     40 misc-misplaced-const
     75 performance-type-promotion-in-math-fn
     88 misc-incorrect-roundings
    105 misc-macro-parentheses
    151 readability-function-size
    201 readability-else-after-return
    202 readability-inconsistent-declaration-parameter-name
    316 misc-throw-by-value-catch-by-reference
    383 readability-non-const-parameter
  10284 readability-implicit-bool-conversion

Change-Id: I5b35ce33e723349fa583f527fec55bbf29a57508


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


[PATCH] trivial change for DofMap::dof_indices to increase
 performance when there are no element-based DOFs


[PATCH] Update performance tables with more details (memory, etc.)


[PATCH] Switch to a RWLock for S3 Class multipart upload

A new RWLock class is introduced into the common folder. @joe-maley
provided this excellent class. We then use this RWLock in the S3 VFS
class to handle the multipart uploads and to manage the locks more
granular to remove locking and contention for multiple concurrent upload
operations.


[PATCH] Near final release version. Performance for 300^3 is 4.64
 1.96 3.13s on 1,4 and 20 ranks. Upto 4% variation if temps above 40C on GPU


[PATCH] thermophysicalModels: Added new tabulated equation of state,
 thermo and transport models

using the new nonUniformTable to interpolate between the values vs temperature
provided.  All properties (density, heat capacity, viscosity and thermal
conductivite) are considered functions of temperature only and the equation of
state is thus incompressible.  Built-in mixing rules corresponding to those in
the other thermo and transport models are not efficient or practical for
tabulated data and so these models are currently only instantiated for the pure
specie/mixture rhoThermo package but a general external mixing method will be
added in the future.

To handle reactions the Jacobian function dKcdTbyKc has been rewritten to use
the Gstd and S functions directly removing the need for the miss-named dGdT
function and hence removing the bugs in the implementation of that function for
some of the thermo models.  Additionally the Hc() function has been renamed
Hf() (heat of formation) which is more commonly used terminology and consistent
with the internals of the thermo models.


[PATCH] enable GPU emulation without GPU support

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

Change-Id: I0b90b8ec1c6e3116f28f66aac4f3c8ae0831239d


[PATCH] 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] 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] moved warning of slow option to 'bugs'


[PATCH] Use .p2align instead of .align for portability

The OSX assembler apparently mishandles the argument to decimal .align, leading to a significant loss of performance
as observed in #730, #901 and most recently #1470


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


[PATCH] MDRange: Refactored HostIterateTile to use macros

Removes the recursive way for nesting the for loops which may hinder
chances at vectorization during iteration over tiles.
Performance test revised to perform a stencil-like operation


[PATCH] Make the use of GpuEventSynchronizer in SYCL conformant with
 CUDA/OpenCL

MR !1035 refactored the use of GpuEventSynchronizer in CUDA and OpenCL
to make merging the code paths easier. Here, we update SYCL to the same
standard.

Note, that it introduces additional synchronization between local and
non-local queues. It is present in CUDA and OpenCL, but was implicit in
SYCL. To simplify code, it is added here. If it turns out to be
detrimental to performance, it can be (conditionally) NOPed.

Refs #2608, #3895.


[PATCH] Change tolerance as it becomes pretty slow


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

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


[PATCH] Refactor nbnxn exclusion setting

Consolidate common parts of the simple and GPU exclusion mask
generation code. Made variable names more descriptive.
No functionality and performance changes, except that the direct
j-cluster lookup now also works when the first j-cluster does not
equal the i-cluster.

Change-Id: I3ef6344ae2796e649ae30bf5ff0668a4548c011f


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


[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] Don't print invalid performance data

If mdrun finished before a scheduled reset of the timing information
(e.g. from mdrun -resetstep or mdrun -resethway), then misleading
timing information should not be reported.

Fixes #2041

Change-Id: I4bd4383c924a342c01e9a3f06b521da128f96a35


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


[PATCH] Deprecate Node/DofObject copy methods

Fixes #1451

Any Node object copying is almost certainly a bug (always in
performance, sometimes in functionality), in code that should have
been taking references instead.  Since the node_ref_range() method
makes it too easy to write such bugs, we should deprecate the Node
copy constructor and make it impossible soon.

The only places where DofObject(DofObject) was being used were in the
Node copy constructor (no longer relevant) and in old_dof_object
creation (where the not-quite-a-proper-copy-constructor behavior is
intentional), so for added safety let's deprecate non-private access
to that constructor.  Since it was already protected before this
shouldn't cause any hardship to downstream users.


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


[PATCH] Threw away the manual text-parsing, xml parser is fast enough


[PATCH] Fix a critical performance issue

As decided by `MainWindow`, the `Scene_c3t3_item::toolTip()` method is
called by `MainWindow::updateInfo()` for each `modified()` event of the
manipulated frame. While the frame is manipulated, that generates a lot
of events, and a lot of calls to `toolTip()`.

Before this commit, the call to `Scene_c3t3_item::toolTip()`
was `O(n)`. After this commit it is `O(1)`.

That speeds up a lot the drawing of the item while the frame is
manipulated!


[PATCH] Cuda: Adding performance test for instance overlapping


[PATCH] Simplify the uniform-refinement mesh methods.

In the classes Mesh and ParMesh:

* Small optimization in Mixed3DUniformRefinement for hex-only meshes.
* In Mixed3DUniformRefinement, use marker array instead of std::map.
* Rename the methods Mixed{2D,3D}UniformRefinement to
  UniformRefinement{2D,3D}.
* Remove the methods {Quad,Hex,Wedge}UniformRefinement and use
  UniformRefinement{2D,3D} instead. In terms of performance, the
  difference was negligible.


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

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

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

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

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


[PATCH] Use a separate Performance log line for compute_affine_map

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


[PATCH] changed the performance figure note: this version can test
 the parallel performance


[PATCH] Expand Performance section of the user guide

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

Change-Id: I39aba257c4c761a3a1ef428c64424da6fa449158


[PATCH] 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] s390x: for clang use fp-contract=on instead of fast

Make clang slightly more cautious when contracting floating-point
operations (e.g., when applying fused multiply add) by setting
-ffp-contract=on (instead of fast).

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


[PATCH] FEAT: Enabling additional interpolation types

- Enabling cubic support for rotate and transform
- resize fallsback to use scale

Resize is not using common interp.cl because of compilation
issues that arose from using too much constant memory when
compiling FAST in CUDA backend.


[PATCH] gmres restart converges but slow


[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] More fine grained ParmetisPartitioner logging

This is ludicrously slow outside opt mode


[PATCH] Make current slow growth behaviour consistent and communicate
 it better

In lambda dynamics/slow growth, lambda can be used to interpolate the lambda vector or to set its components directly if no lambda vector is provided by the user. In this latter case, lambda was allowed to be > 1, but it was silently kept within [0,1] if a lambda vector was specified. Moreover, setting the components of the lambda vector > 1 as a user produced an error.

Now, it is consistently ensured that lambda vector components are in [0,inf), but warnings are issued if a user provides settings that somehow result in lambda vector components being > 1. If soft-core potentials are used, lambda vector components for Coulomb and vdW are consistently enforced to be in [0,1] (errors are issued else). If lambda is used to interpolate a user-provided lambda vector, it is kept in [0,1]. If user input results in lambda leaving the above ranges during the simulation, lambda will be kept at the respective interval boundary, and warnings are issued from which simulation step on the lambda vector will not change anymore.

Fixes #3584.


[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] MKK: a test case to measure the performance of aggregate
 put/get calls.


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


[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 01/29] Add support for factorization in
 create_new_algorithm.sh


[PATCH] AMG-DD implementation (#145)

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

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

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

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

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


[PATCH] MDRange: Disabling performance test for MDRange: takes way to
 long on KNL


[PATCH] In the performance miniapps, print the MFEM SIMD width.

In the miniapps/performance makefile, print the auto-detected compiler
and if that fails, the print the output used for auto-dection.


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

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

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

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

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

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


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

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


[PATCH] Changed the way hardwall works.

There are several ways to go about this, but the latest seems
most sensible in the context of DD.  The hardwall function now
uses local shells to get coordinates and such.  The problem is
that after make_local_shells(), the indices are all messed up.
Committing this to preserve the logic, but need to fix this
otherwise parallelization is limited to only OpenMP and performance
is not very good above 4 threads.

Change-Id: I3208519d8704da622b81835604249771d634a28a


[PATCH] ATW: Removed slow serial code from density construction


[PATCH] Use the simplified performance function.


[PATCH] Adding Changelog for Release 3.5.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.5


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

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


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

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

Replaced gmx_bool with bool

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

Refs #2877

Change-Id: Ibbe8c452f6f480e9a357fe1b87da3ab0ae166317


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


[PATCH] * Refactored stats (#1594)

* Fixed performance of multi-range subarray result estimation
* Fixed bug in multi-range result estimation


[PATCH] AVX512 CGEMM & ZGEMM kernels

96-99% 1-thread performance of MKL2018


[PATCH] Adding Changelog for Release 2.9.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 2.9


[PATCH] Make performance ex1 and ex1p templated on dimension


[PATCH] The current version allows for triclinic boxes as well. It is
 very slow though.


[PATCH] MKK: Non-blocking performance test


[PATCH] Changing switchpoint of kernel of local HerkLN update to be
 twice the blocksize times the grid width. This preserves the local gemm
 performance at the kernel.


[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] 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] additional output for performance tests


[PATCH] HvD: Initial Maxima generated code for the various
 functionals. At present only the energy expressions and the 1st order
 derivatives are implemented. This is sufficient to test whether the energy
 expressions are correct. Next the 2nd and 3rd order derivatives will be
 generated but optimizing the expressions to generate fast Fortran will take a
 while.


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

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

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

Minor style improvements around set_over_alloc_dd.

Part of #3892


[PATCH] Add Fast LSTM layer implementation.


[PATCH] WIP: add CPR approach and fast small block inverse.


[PATCH] Extend performance considerations on bonded offload

Refs #2793

Change-Id: I4a8ae8554cf2aad540eb4eb485898f8cabeb3966


[PATCH] use integer and reduce the number of tests

leda_rational is not automatically doing gcd calls so Quotient<leda_integer>
is faster for our applications.
The test is still slow with EPECK


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


[PATCH] First phase of integrating the fast coulomb code into nwchem.
  The nested grid evaluation of the density, fourier interpolation, FMM, and
 fourier solution of the free space Poisson equation


[PATCH] Add task dag performance test based upon fibonnaci


[PATCH] Compile using g++ on OSX

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


[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] Append all ICC Performance flags only to Release Flags

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

Change-Id: Iadfaa29fb347f24208e6f2406e0d1ad41f037804


[PATCH] New normals orientation method:
 radial_normals_orientation_3() does a radial orientation of the normals of a
 point set. Normals are oriented towards exterior of the point set. This very
 simple and very fast method is intended to convex objects.


[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] Make Constraints a proper class

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

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

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

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

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

Added some const correctness where it now became necessary.

Refs #2423

Change-Id: I7a3833489b675f30863ca37c0359cd3e950b5494


[PATCH] Fixing bugs in slow (non-shared memory) variant of
 lj/charmm/coul/charmm/gpu


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


[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] Experimental new template class Set. * This class is similar
 to Jakub's new HashTable class from the   'ncmesh-mem-opt-dev' branch, but
 more generic. * It is a container for unique elements of any type T. *
 Supports fast insertion, removal, and searching of elements. * Each element
 is assigned an index (int) upon insertion. * Indices of removed elements are
 reused when inserting new elements. * Elements are stored in a random access
 container that supports fast   insertion at the end, like mfem::Array or
 std::vector. * Such container classes require a simple adaptor class to be
 used with   class Set. * The indices assigned to elements are indices into
 the container   object, which stores "nodes", a struct with two fields one of
 type T,   and second of type int (index of next element in a bin). * The
 entries of the Set are separated into bins using a generic hash   function.
 Bins are represented as linked lists where instead of   pointers, the
 link-"nodes" use int indices.

This class can be useful in various contexts:
* Creating a local enumeration for a set of processor ranks, e.g.
  enumerating the processor neighbors in class GroupTopology.
* Creating off-diagonal column maps for HypreParMatrix, given a set of
  global column indices.
* Enumeration of edges and faces as Sets of (sorted) pairs or 3-tuples,
  similar to HashTable - which can be build on top of Set as well.


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


[PATCH] Reduce number of epochs for training to accelerate tests.


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

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

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

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


[PATCH] 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] 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] Minor changes to mdrun -h descriptions

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

Change-Id: I7bc6172a70c39c02f6ca6db17e26b08d2ca3b444


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


[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] added (inner and outer) relaxation parameters to Gauss-Seidel
 routines, also added a backward solve procedure. This required an additional
 parameter for hypre_BoomerAMGRelax. Complete list of  choices for smoothers
 are now: relax_type = 0 -> Jacobi or CF-Jacobi relax_type = 1 -> Gauss-Seidel
 <--- very slow, sequential relax_type = 2 -> Gauss_Seidel: interior points in
 parallel, boundary sequential relax_type = 3 -> hybrid: SOR-J mix
 off-processor, SOR on-processor with outer relaxation parameters (forward
 solve) relax_type = 4 -> hybrid: SOR-J mix off-processor, SOR on-processor
 with outer relaxation parameters (backward solve) relax_type = 5 -> hybrid:
 GS-J mix off-processor, chaotic GS on-node relax_type = 6 -> hybrid: SSOR-J
 mix off-processor, SSOR on-processor  with outer relaxation parameters
 relax_type = 9 -> Direct Solve


[PATCH] Complete all the complex single-precision functions of
 level3, but the performance needs further improve.


[PATCH] Fix performance penalty in bspline derivatives


[PATCH] Adding a SymvCtrl<T> data structure and subsequently
 extending HermitianTridiagCtrl<F> and HermitianEigCtrl<F> to support it due
 to the large differences in performance from different approaches to the
 local portion of a distributed Symv


[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] Iterative version of the incident_...(vertex) methods.

See Andreas' e-mail:

> I just had a look at the code. The problem is that it calls
> incident_cells, which is implemented recursively, and for a
> vertex with many incident cells, as in your case the infinite
> vertex, the stack is full.
>
> We have to put it on our todo list.

I did it for 3D only because the degenerate 2D case should be
handled by the circulator anyway.

I did not add the test which explodes the call stack (in case we plug
the recursive version): too slow for a testsuite. But incident_...
methods are used everywhere in the code anyway.


[PATCH] Adding Changelog for Release 3.3.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.3


[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] moved diff, fast, gradient, harris, histogram to kernel
 namespace


[PATCH] Faster version, making use of the fast /tmp directory. Also
 removes diffs*.gz from web server.


[PATCH] Add DenseMatrix::svd_solve().

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

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


[PATCH] C++ math function cleanup

math/functions.h now implements a number of old and new math
functions with either float, double, or integer arguments.
Manual SIMD versions of 1/sqrt have been tested with gcc and icc
on x86, Power8, Arm32 and Arm64, but with correct 'f' suffixes
on constants there is only 10-15% performance difference, so for
now we always use the system versions to avoid having this file
depend on config.h. Functions for third and sixth roots have
been introduced to replace many of our pow() calls, and the code
has been cleaned up to use the new functions.

Refs #1111.

Change-Id: I74340987fff68bc70d268f07dbddf63eb706db32


[PATCH] Fixed data filename on FAST unit test.


[PATCH] Revert "move update of the status outside of the constructor"

This reverts commit 6378a51191df7cb28a24dadc1706112c0c7df926.

The commit was incorrect and was introducing a huge performance issue


[PATCH] Changed the way FAST handles different datatypes internally


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

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

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

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

Fixes #1354


[PATCH] Added several HemmAccumulate routines so that Hegst could
 avoid cache-unfriendly SumScatter routines. The warning messages for calling
 these potentially slow redistribution routines were also toned down.


[PATCH] Removed lots of units code from AMBER file loader, which made
 it unnecessarily slow


[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] corrected bug in performance testing


[PATCH] Add Conjugate Gradient example to benchmarks - Includes
 sparse matrix

Compare the performance and memory usage of sparse vs dense using conjugate
gradient example


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


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


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


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


[PATCH] Multi-phase solvers: Improved handling of inflow/outflow BCs
 in MULES

Avoids slight phase-fraction unboundedness at entertainment BCs and improved
robustness.

Additionally the phase-fractions in the multi-phase (rather than two-phase)
solvers are adjusted to avoid the slow growth of inconsistency ("drift") caused
by solving for all of the phase-fractions rather than deriving one from the
others.


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


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


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


[PATCH] Replaced Vertex_circulator by Edge_circulator to gain
 performance


[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] 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] Changed slow convergence stop criteria.


[PATCH] EA: VCALLS turned off for ELAN4 because of performance and
 stability


[PATCH] Fix the Jacobi compilation time.

This is an approach at fixing the Jacobi kernels compilation which aims at
sacrificing as little as possible the runtime performance and get down the total
compilation time for this file as much as possible, all the while having a way
to enable the full performance optimizations in an easy way.

This approach only touches the `generate` kernels in the end, and provides the
full performance for the `apply` and other kernels as they are fast enough to
compile.

+ Split the Jacobi kernels into multiple files for parallel compilation and
   smaller code size.
+ Tone down some optimizations, namely use `noinline` for one function and
   `#pragma unroll 1` in two places to prevent unrolling. This impacts the
   Jacobi `generate` kernels only.
+ Add a compilation flag for enabling back the full optimizations.

__NOTE:__ the generate kernel compilation with full optimizations still takes
above 30 minutes on my laptop for one architecture (Maxwell). Without the
optimizations enabled, it takes less than 3 minutes.


[PATCH] MDRange: Performance test (3D)

Runs test over multiple ranges (3D), adjusting the tile dims by powers of 2.
Compare results of MDRange to RangePolicy implemented as Collapse<2> and
Collapse<3>


[PATCH] Add fix elstop to USER-MISC

Implements inelastic energy loss for fast particles in solids.


[PATCH] The test was too slow in Debug mode


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


[PATCH] Add evaluable_elements_begin()/end()

I put these in MeshBase like all the other iterator ranges, for
simplicity and consistency, but we do still need a DofMap reference to
initialize them.

Iterating through these might be slow, but creating a correct mutable
cache instead will definitely be a huge pain, so let's just get the
code correct for now and optimize later if we need to.


[PATCH] Limit SMT with PME on GPU

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

Change-Id: I1a6b83bc81f68e89bf443e2b0ddb1fde44e2361d


[PATCH] Next-generation SIMD, for SSE2, SSE4.1 and 128-bit AVX

This adds the same functionality that was previously done for the
reference SIMD implementation This includes all the 128-bit x86
flavors, since SSE4.1 and AVX-128 only overrides a few SSE2
instructions/functions. Performance appears to be identical to the
state before the new SIMD code on x86 when using SSE2. For the most
performance-sensitive functions I expect we will later test a few
different alternative implementations once we can benchmark the
routines inside actual kernels using them.

Change-Id: I59d5741df345b38745f9a6d1ea3a4d27b0a66034


[PATCH] AMOEBA uses fast approximation for erfc()


[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 log performance stats

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


[PATCH] Move early return for nbnxm force reduction

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

Change-Id: I3315699e15918482b321b702f6ba24209aa3a6b2


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


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


[PATCH] Minor cleanup of NMF code; I think the residue should be
 displayed in non-debugging mode (optionally with -v) so I switched to
 Log::Info.  Comment on the change to pinv() then rewrite
 RandomAcolInitialization a little bit to avoid allocating memory
 unnecessarily.  Unfortunately insert_cols() is a little slow because it
 allocates more memory and memcpy()s.


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

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


[PATCH] Update management of linear algebra libraries

Management of detection and/or linking to BLAS and LAPACK libraries is
re-organized. The code has migrated to its own module. This will
help future extension and maintenance. This version communicates
things that are newsworthy and stays out of the way when nothing
is changing.

We no longer over-write the values specified by the user for
GMX_EXTERNAL_(BLAS|LAPACK). Previously, this was used to signal
whether detection succeeded, but that does not really get the job
done. Instead, the user is notified that detection failed (repeatedly,
if they deliberately set such an option on).

Correct usage and expected behaviour in all cases is documented both
in the code and the install guide.

The user interface is pretty much unchanged. We still don't offer full
configurability (e.g. MKL for FFTs must use MKL for linear algebra
unless GMX_*_USER is used, and the only way to get MKL for linear
algebra is to use it for FFTs). The size of any performance difference
is probably very small, and if the user really needs mdrun with
certain FFT and tools with certain linear algebra library, they can do
two configurations. Note that mdrun never calls any linear algebra
routines (tested empirically)!

Expanded the solution of #771 by testing that the user supplied
libraries that actually work. If not, we emit a warning and try to use
them anyway.

We also now check that MKL really does provide linear algebra
routines, and fall back to the default treatment if it does not.

Refs #771,#1186

Change-Id: Ife5c59694e29a3ce73fc55975e26f6c083317d9b


[PATCH] Use a separate Performance log line for compute_affine_map


[PATCH] Tests for valid periodic actions

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

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

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

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

Change-Id: I88ea643873ebec0e5e2b12181f4b51ad90c7b0f7


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


[PATCH] 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] Convert nbnxn_atomdata_t to C++

Changed all manually managed pointer to std::vector.
Split of a Params and a SimdMasks struct.
Changed some data members to be private, more to be done.

This change is ony refactoring, no functional changes.

Note: minor, negligible performance impact of the nbnxn gridding
due to (unnecessary) initialization of std::vector during resize().

Change-Id: I9c70a1f8f272c80a7cf335fcbd867bd79c4102a2


[PATCH] This test was too slow in Debug mode


[PATCH] Update tests for changed APIs.

Random forests generally work better, but it is not guaranteed for the vc2
dataset, so I am still requiring only that it gets 90% of the decision tree
performance in the worst case.  I expect it will generally be better, but there
are still situations where it may not be (because of the randomness).


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


[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 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] Added free-energy kernel performance note

Change-Id: Iea5d2b124633c4188753c7b1ebb6f964edb2f644


[PATCH] #1009 Matrix return type for det, getMinor and cofactor Could
 result in a performance loss, but the implementation is not efficient anyway.
 No deprecation since users (and unit tests) have relied on automatic
 typecasting to Matrix.


[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] Make sure multiprocessor performance for single vectors is
 unaffected by the multivector capability.


[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] 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] Extensive commenting and instructions on how to run fast kde
 is completed


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


[PATCH] trivial change for DofMap::dof_indices to increase
 performance when there are no element-based DOFs

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


[PATCH] Added FAST feature detector example


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


[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] fixed performance print when run is terminated or with
 minimizers


[PATCH] Revert "Updated boost compute version tags"

This reverts commit b6d8e2d85c358f9d2be69bd09fb8b64bda9fcc04.

This commit was causing performance drops on certain hardware


[PATCH] flag two more subroutines can trigger the variable tracking
 message and slow down compilation


[PATCH] some performance stuff (matrix products)


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

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


[PATCH] Add workaround for performance regression


[PATCH] suppress performance warning concerning an assertion


[PATCH] Separate CPU NB kernel and buffer clearing subcounters

This is aimed to allow comparing the performance of the pair-interaction
kernels separately from the force buffer clearing.

Change-Id: Ifb2b4b3e5a43ac2ee547da651f9432a22fe58421


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


[PATCH] List: Reinstated construction from two iterators and added
 construction from an initializer list

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

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

which for some types conflicts with

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

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

    List<scalar> sl(5, 0);

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

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

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

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

or

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


[PATCH] Fixed performance bug in mixed precision


[PATCH] added early quit option to accelerate distance vs user
 defined distance check


[PATCH] Copy team rendezvous implementation from master to address
 performance issue #936


[PATCH] Re-enable i-atom type local mem prefetch in OpenCL

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

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

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

Change-Id: I8324d62d3d78e0a1577dd3125edf059d3b311c2f


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


[PATCH] Write element truth table to exodus to improve performance

The Exodus API allows for an element truth table to optionally be
sent to the Exodus library before any element data is written.  The
truth table simply tells which variables exist on which blocks.
Sending this truth table to Exodus allows for memory to be allocated
in advance, making for much more efficient writing of data,
especially if there is a large number of element blocks.

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


[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] 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] moved loading of harmonic bonds to the top level, more
 efficient this way


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

* Performance improvments to CPU Anisotropic Diffusion

(cherry picked from commit a4713f1aa102ad693129086bfdb9aa2a9d2fb1f7)


[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] Fix CUDA architecture dependent issues

Only device code gets generated in multiple passes and therefore
target architecture-dependent macros like __CUDA_ARCH__ or our own
IATYPE_SHMEM (which also depends on __CUDA_ARCH__) are not usable in
host code as these will be both undefined. As a result, current code
over-allocated dynamic shared memory. This has no negative side-effect.
This change replaces the use of macros with runtime device compute
capability checks. Also texture objects are now actually enabled,
which give very minor performance improvements.
Note that on Maxwell + CUDA 7.0 there is a 20% performance regression
for the tabulated Ewald kernel (which is not used by default), which
magically disappears when texture references are used instead.

Change-Id: I1f911caad85eb38d6a8e95f3b3923561dbfccd0e


[PATCH] Improve object_type detection performance (#2792) (#2793)

This improves the object APIs performance for detecting types by
switching from listing all items in the URI to checking only for the
existence of the group indicator, array schema file or array schema
folder. We also switch the order to check for the array schema folder
first, since it is most likely to exist based on the assumption that
there are more arrays than there are groups.

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


[PATCH] Fix performance of 4-dslash_domain_Wall_4d.cuh kernels with
 xpay enabled: store coefficients in __constant__ memory to remove register
 spilling


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


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


[PATCH] Avoid calculating distances after an Elkan prune. Slight,
 nearly negligible performance gains.


[PATCH] Fixed put_in_list for better performance


[PATCH] Add TypeTensor::solve().

This is slightly more efficient than inversion followed by multiplication.


[PATCH] POWER10:  Optimize dgemv_n

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


[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] Added the CGAL::Multiset class (based on a red-black tree),
 which extends the std::multiset class and makes it more efficient in many
 cases.


[PATCH] Convert aligned moves to unaligned

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


[PATCH] More efficient nlp_solver_evaluate


[PATCH] adding requested size threshold to improve performance of
 small size requests, removed bug check


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

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

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


[PATCH] fixed several bugs in the load balance performance prints


[PATCH] Remove unnecessary ICC flags affecting performance

Since we add -msse/../-mavx based on the acceleration we shouldn't
add -mtune=core2 anymore. Especially because it is added later
and takes precedence over the (higher) acceleration flag.

-ip and -funroll-all-loops could also be deleted because they don't
seem to give any significant performance improvement, and might
increase compilation time, but they don't hurt gromacs performance.

In theory it could help to use -xavx instead of -mavx but I can't
measure a difference.

Change-Id: Icd11c40c3cd3ef2ae6ef42f07d5d75c228593f51


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


[PATCH] Optimize get_nz by avoiding integer division

Integer divisions are very costly, and typically take ~20-26 clocks
cycles for 32-bit integers, and ~85-100 clock cycles for 64-bit
integers. The default size of indices was changed to 64-bit in commit
a0c6de6c6, causing a significant performance hit in one of the get_nz
methods.

This commit rewrites said get_nz method to avoid divisions, and instead
use additions. These have a typical latency of 1 cycle, and a throughput
of 0.25-0.33 cycles, regardless of argument size.


[PATCH] add collisions, split vectors into components for performance


[PATCH] make use of CUDA stream priorities

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

Change-Id: I4efc65546e4135f12006c0422e1fca42a788129f


[PATCH] Optimize Hex8::volume() slightly.

If my calculations are correct, the "geometric" formula I used
previously had about 12 dot products and 12 cross products, while the
current one only has 4 of each.  This formula is derived by writing out the
standard volume formula and dropping terms which are zero due to the
symmetry of the integrand and/or triple products containing two copies
of the same vector.

While the original geometric formula was already pretty fast, this one
is about 1.7x faster (about 0.1697s vs 0.2866s to call volume() on
3.375M Hex8 elements).


[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] shorten ESTIMATE planning time for certain weird sizes

FFTW includes a collection of "solvers" that apply to a subset of
"problems".  Assume for simplicity that a "problem" is a single 1D
complex transform of size N, even though real "problems" are much more
general than that.  FFTW includes three "prime" solvers called
"generic", "bluestein", and "rader", which implement different
algorithms for prime sizes.

Now, for a "problem" of size 13 (say) FFTW also includes special code
that handles that size at high speed.  It would be a waste of time to
measure the execution time of the prime solvers, since we know that
the special code is way faster.  However, FFTW is modular and one may
or may not include the special code for size 13, in which case we must
resort to one of the "prime" solvers.  To address this issue, the
"prime" solvers (and others) are proclaimed to be SLOW".  When
planning, FFTW first tries to produce a plan ignoring all the SLOW
solvers, and if this fails FFTW tries again allowing SLOW solvers.

This heuristic works ok unless the sizes are too large.  For example
for 1044000=2*2*2*2*2*3*3*5*5*5*29 FFTW explores a huge search tree of
all zillion factorizations of 1044000/29, failing every time because
29 is SLOW; then it finally allows SLOW solvers and finds a solution
immediately.

This patch proclaims solvers to be SLOW only for small values of N.
For example, the "generic" solver implements an O(n^2) DFT algorithm;
we say that it is SLOW only for N<=16.

The side effects of this choice are as follows.  If one modifies FFTW to
include a fast solver of size 17, then planning for N=17*K will be
slower than today, because FFTW till try both the fast solver and the
generic solver (which is SLOW today and therefore not tried, but is no
longer SLOW after the patch).  If one removes a fast solver, of size say
13, then he may still fall into the current exponential-search behavior
for "problems" of size 13*HIGHLY_FACTORIZABLE_N.

If somebody had compleined about transforms of size 1044000 ten years
ago, "don't do that" would have been an acceptable answer.  I guess the
bar is higher today, so I am going to include this patch in our 3.3.1
release despite their side-effects for people who want to modify FFTW.


[PATCH] New data parallel routines to improve performance


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


[PATCH] Add check to remove zero Charmm dihedrals

Proper torsions where the force constant is zero
in both A and B states are now removed. We also
check for other angle, torsion, and restraint
functional types, and if all parameters are zero
for these the interaction is not added. This will
not change any results, but increase performance
slightly by not calculating unnecessary interactions.
Fixes #810.

Change-Id: I37ecd06d0641008593edab29e5b08433bde7b6cc


[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] optimize create_atoms performance for large boxes and small
 regions. warn if taking a long time


[PATCH] Improve performance of pair_reaxc, this change is safe
 because the non-bonded i-loop doesn't include ghost atoms; this optimization
 is already included in the USER-OMP version


[PATCH] Add FEMContext algebraic_type(), custom_solution()

The NONE and DOFS_ONLY options enable more efficient use of FEMContext
in cases where it's only used as a container of FE objects.

The OLD option (with a properly parallelized custom_solution) enables
the use of FEMContext to assist in evaluating old solutions during
projections.


[PATCH] ResultTile::coord() performance (#1689)

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

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

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


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


[PATCH] Template free-energy kernel on differing coul/vdw soft-core

The power function used for the soft-core potential is expensive.
When using the same lambda and alpha parameters for Coulomb and VdW,
we can skip one power core, giving a 10% performance improvement.

Change-Id: I8733838c6c32ef2b6fee5a6fb97657679f9bd3b3


[PATCH] Performance fix - Stop setting the color of each edge to
 black, which could be quite long for a big item, and set the attribute value
 of the shader to black instead.


[PATCH] Use CUSPARSE_CSRMV_ALG2 for seemingly better performance


[PATCH] Fix (ish) slow serachbox on windows.


[PATCH] Change fix box/relax example to be more efficient

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


[PATCH] s390x: Add vectorized sgemm kernel for Z14 and newer

Add a new GEMM kernel implementation to exploit the FP32 SIMD
operations introduced with z14 and employ it for SGEMM on z14 and newer
architectures.

The SIMD extensions introduced with z13 support operations on
double-sized scalars in vector registers. Thus, the existing SGEMM code
would extend floats to doubles before operating on them. z14 extended
SIMD support to operations on 32-bit floats. By employing these
instructions, we can operate on twice the number of scalars per
instruction (four floats in each vector registers) and avoid the
conversion operations.

The code is written in C with explicit vectorization. In experiments,
this kernel improves performance on z14 and z15 by around 2x over the
current implementation in assembly. The flexibilty of the C code paves
the way for adjustments in subsequent commits.

Tested via make -C test / ctest / utest and by a couple of additional
unit tests that exercise blocking (e.g., partial register blocks with
fewer than UNROLL_M rows and/or fewer than UNROLL_N columns).

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


[PATCH] Improve performance of PairReaxCKokkos