[PATCH] thermophysicalModels: Changed specie thermodynamics from mole
 to mass basis

The fundamental properties provided by the specie class hierarchy were
mole-based, i.e. provide the properties per mole whereas the fundamental
properties provided by the liquidProperties and solidProperties classes are
mass-based, i.e. per unit mass.  This inconsistency made it impossible to
instantiate the thermodynamics packages (rhoThermo, psiThermo) used by the FV
transport solvers on liquidProperties.  In order to combine VoF with film and/or
Lagrangian models it is essential that the physical propertied of the three
representations of the liquid are consistent which means that it is necessary to
instantiate the thermodynamics packages on liquidProperties.  This requires
either liquidProperties to be rewritten mole-based or the specie classes to be
rewritten mass-based.  Given that most of OpenFOAM solvers operate
mass-based (solve for mass-fractions and provide mass-fractions to sub-models it
is more consistent and efficient if the low-level thermodynamics is also
mass-based.

This commit includes all of the changes necessary for all of the thermodynamics
in OpenFOAM to operate mass-based and supports the instantiation of
thermodynamics packages on liquidProperties.

Note that most users, developers and contributors to OpenFOAM will not notice
any difference in the operation of the code except that the confusing

    nMoles     1;

entries in the thermophysicalProperties files are no longer needed or used and
have been removed in this commet.  The only substantial change to the internals
is that species thermodynamics are now "mixed" with mass rather than mole
fractions.  This is more convenient except for defining reaction equilibrium
thermodynamics for which the molar rather than mass composition is usually know.
The consequence of this can be seen in the adiabaticFlameT, equilibriumCO and
equilibriumFlameT utilities in which the species thermodynamics are
pre-multiplied by their molecular mass to effectively convert them to mole-basis
to simplify the definition of the reaction equilibrium thermodynamics, e.g. in
equilibriumCO

    // Reactants (mole-based)
    thermo FUEL(thermoData.subDict(fuelName)); FUEL *= FUEL.W();

    // Oxidant (mole-based)
    thermo O2(thermoData.subDict("O2")); O2 *= O2.W();
    thermo N2(thermoData.subDict("N2")); N2 *= N2.W();

    // Intermediates (mole-based)
    thermo H2(thermoData.subDict("H2")); H2 *= H2.W();

    // Products (mole-based)
    thermo CO2(thermoData.subDict("CO2")); CO2 *= CO2.W();
    thermo H2O(thermoData.subDict("H2O")); H2O *= H2O.W();
    thermo CO(thermoData.subDict("CO")); CO *= CO.W();

    // Product dissociation reactions

    thermo CO2BreakUp
    (
        CO2 == CO + 0.5*O2
    );

    thermo H2OBreakUp
    (
        H2O == H2 + 0.5*O2
    );

Please report any problems with this substantial but necessary rewrite of the
thermodynamic at https://bugs.openfoam.org

Henry G. Weller
CFD Direct Ltd.


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


[PATCH] Identity: special type derived from SphericalTensor to
 provide the concept of identity (I)

Allows efficient operators to be defined for the interaction between
types and the equivalent identity.


[PATCH] Use much smaller GroupLens dataset.

This helps keep the repository a bit smaller and should accelerate some tests.


[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] Add Edge4::volume().

This speeds up calling volume() on every element in a mesh with 4M
Edge4's by about 450x. Though I'm not sure this was ever going to be a
performance concern, I still want to have a custom volume()
implementation for all the different Elem types for completeness.

The 4-pt quadrature is also reasonably accurate.  The biggest
discrepancies seem to be introduced by perturbing the interior nodes
of the EDGE4. For example, perturbing an interior node of the
reference element by 0.125 in the y (or z) direction leads to a
relative error of much less than 1%, compared to a 12th-order (7-pt)
approximation of the volume.

Approximate volume  = 2.0412301724043291e+00
Verification volume = 2.0410437292661414e+00
Rel err             = 9.1346959163268581e-03%


[PATCH] Try to improve parallel performance of CBMC


[PATCH] More efficient generation of random numbers


[PATCH] refactor reading last line of potential file code to be more
 efficient


[PATCH]  - Added C++ include guards to all installed .h files

 - Modified PCG:
    - usage is consistent with SMG
    - no HYPRE_*pcg.h files
    - no need to allocate extra work-space vectors
    - more efficient matvec (does not do setup everytime)
    - default preconditioner is identity, i.e. default PCG is CG

 - All HYPRE_* interface routines are now consistently HYPRE_Struct*


[PATCH] Implement user guide

Renamed former user manual to reference manual.

The content for the new user guide has mostly migrated in from the
wiki, install guide, and mdrun -h, and updated as appropriate. This
guide is intended for documenting practical use, whereas the reference
manual should document algorithms and high-level implementations, etc.

Established references.md to do automatic linking of frequently
used things. This can be automatically concatenated by pandoc
onto any Markdown file to do easy link generation.

Section on mdrun and performance imported and enhanced from the
Acceleration and Parallelization wiki page.

Added section on mdrun features, e.g. rerun and multi-simulation.

Section on getting started imported from online/getting_started.html
and updated - there used to be a tutorial here, but there isn't any
more. Linked to more up-to-date tutorials.

Added TNG to docs/manual/files.tex.

Removed gmx options, now that its content is in the user guide (in
tools.md).

Moved old mdp_opt.html to docs/mdp-options.html, for now. Removed from
reference manual, left pointer to new location. This is not an ideal
format or location either, but it's a step closer to being able to
generate it from the code. Some trivial fixes to content. Generating
links and references to follow in a future commit.

Moved environment-variable section from reference manual to user guide.
Minor fixes here.

Removed superseded reference manual sections on running in parallel or
with GPUs. Renamed install.tex as technical-details.tex, because that
is all that is left there. Moved section on use of floating-point
precision to chapter on definitions and units, and thus eliminated the
former Appendix A.

Cross-references from user-guide.pdf don't work well yet, but that
should be dealt with when we decide on the final publishing platform.

Some TODO comments for documentation sections remain for work in
future patches, but please note the other new content in existing
child patches, so we don't duplicate any work.

Change-Id: I026d67353863ae069c6c45b840a61fcaf205a377


[PATCH] Modified some of the tests so that they run reasonably fast
 through Insure++.


[PATCH] Optimize atomic accumulation in CUDA NB kernel

As a result of this reorganization of the reduction, the final atomic
accumulation of the three force components can happen on three threads
concurrently. As this can be serviced by the hardware in a single
instruction, the optimization improves overall performance by a few %.
This also results in fewer shuffle operations.

Change-Id: I29519469b1e1848c026ee5b7a32256440031dbce


[PATCH] Small Matrix: skylakex: sgemm nn: add n6 to improve
 performance


[PATCH] Changed the way FAST handles different datatypes internally


[PATCH] r70387, r70573, r70574 from Mesh_3-experimental-GF

Add incident_cells_3(Vertex_handle, std::vector<Cell_handle>)

This function avoids the construction of two additional std::vectors.
The performance gain is between 30% (g++) and 50% (VC++)
for points on surfaces as well as for points filling space.

We at the same time change the implementation of the function
incident_cells(Vertex_handle, OutputIterator).
In order to save one additional std::vector,
the cells are reported in bfs and not in dfs order


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


[PATCH] Restarted the hierarchical pca algorithm, now replaced with
 Vempala's fast SVD algorithm. Need to finish the subspace combining part...


[PATCH] Remove non-backported entry from NEWS

We decided against this one after all, due to risk of side effects
outweighing the fixes to performance issues in some cases.


[PATCH] eliminate it extra assignement to increase performance


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

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


[PATCH] Fast KDE is now using submodule for organizing parameters


[PATCH] Use Traits::Vector to accelerate 2D optimization


[PATCH] New edge_map(), not inverse_map(), in edge reinit

This should be much more efficient, and on top of that it seems to fix
the edge projection problems I was seeing on the Reactor Pressure Vessel
IGA mesh.


[PATCH] Timer: Available in Kokkos namespace

Updated unit tests, performance tests, and examples using
Kokkos::Impl::Timer to use Kokkos::Timer


[PATCH] added docu for efficient MVJ and restart modefor MVJ


[PATCH] MKK: Tuned to optimize performance by setting an optimized
 chunk size


[PATCH] Fix code so that gradient is not wrapped into the box fast
 exit out of symmetry routines if C1


[PATCH] decreased hl_tol (level shift threshold) from 0.05 to 0.01
 introduce 2 new keywords: stable (same as default) fast  (faster than default
 but less safe)


[PATCH] A few, perhaps not so useless and dangerous, changes to qmmm
 code 1) more efficient use of Bq module 2) enabling QMMM runs for property
 calculations


[PATCH] some more performance improvements from Krys. Mostly in
 gradients


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


[PATCH] Precalculate pbc shift for analysis nbsearch

Instead of using pbc_dx_aiuc(), precalculate the PBC shift between grid
cells outside the inner loop when doing grid searching for analysis
neighborhood searching.  In addition to improving the performance, this
encapsulates another piece of code that needs to be changed to implement
more generic grids.

Change-Id: Ifbbe54596f820b01572fe7bb97a5354556a4981d


[PATCH] Initial implementation of LP IPM-based real Basis Pursuit,
 fixing performance bugs in the real sequential KKT matrix construction for
 LPs and QPs, and adding DistSparseMatrix<T>::GlobalRow


[PATCH] Add CUDA compiler support for CC 5.0

With CUDA 6.5 and later compute capability 5.0 devices are supported, so
we generate cubin and PTX for these too and remove PTX 3.5.
This change also removes explicit optimization for CC 2.1 where
sm_20 binary code runs equally fast as sm_21.

Change-Id: I5a277c235b873afb2d1b2b12b5db64b370f1bade


[PATCH] Replacing FT by RT, more efficient Sign_at


[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] fixed weak scaling performance which was hampered to do a
 commit on Apr 27 2010


[PATCH] Allow to pop the context menu with `Key_Menu`

As the item selection is rather slow, for the moment, that is a lot
faster than `Shift+Rightbutton`.


[PATCH] Fixes MSVC warnings. Bugfix in gmx_density in single
 precision

Disables some unhelpful MSVC warnings for:
* forcing value to bool (C4800)
    performance warning: not an issue for our code
* "this" in initializer list (C4355)
    level 4 warning (informational) - shouldn't be shown at level 3
* deprecated (posix, secure) functions (C4996)
    won't be removed soon - so not helpful

Change-Id: I7ea62f88f687f45e169244ed60025c7c7d42f237


[PATCH] Accelerate distance queries with a kd-tree


[PATCH] Cuda: Adding performance test for instance overlapping


[PATCH] More efficient GetNonzeros::evaluateGen (sensitivities)


[PATCH] Added shared memory carve out setting for Volta - improves
 dslash performance by ~5%


[PATCH] Adding Changelog for Release 3.2.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.2


[PATCH] reverted change to matrix product sparsity calculation: no
 one is interested in how fast you can calculate the wrong answer....


[PATCH] In coarse dslash, added parallelization of color-column
 multiplication by splitting up the warp into different regions of the
 column-wise multiplication across the space-time dimention.  Presently 1-way,
 2-way and 4-way warp splitting is implemented.  Prior to writing out the
 result a warp-level reduction into the first segment is performed, which
 writes out the result.  This adds additional levels of parallelsim that
 improves the performance on small lattices.  The level of warp splitting is
 autotuned using the auxillary tuning dimension.


[PATCH] Optimizations to Compute[Yi/Zi/Bi], switching over to an
 AoSoA data layout on the GPU. CPU vs GPU code paths are now maximally
 divergent, will include some discussion of that in PR. Small performance
 tweaks in Compute[UiTot/FusedDeidrj].


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


[PATCH] Use fast PerfLog methods in PerfItem

This speeds up our LOG_SCOPE usage several fold.


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


[PATCH] ReplicateMesh should only read once

Reading once and broadcasting should be more efficient than hammering
the filesystem on every processor.


[PATCH] Some debug instrumentation and big performance improvements.


[PATCH] Enable some performance tests again


[PATCH] fvOptions: Changed to be a MeshObject to support automatic
 update for mesh changes

Now cellSetOption correctly handles the update of the cell set following mesh
topology changes rather than every time any of the fvOption functions are
called for moving meshes.  This is more efficient and consistent with the rest
of OpenFOAM and avoids a lot of unnecessary clutter in the log.


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

also rationalized the writeCompression specification


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


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


[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] 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 (ish) slow serachbox on windows.


[PATCH] Move fast LUT in CUDA backend to texture memory

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

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

Time(%)    Time   Calls      Avg       Min       Max  Name
1.48%  101.09us      3  33.696us  32.385us  34.976us  void cuda::kernel::locate_features<float, int=9>
1.34%  91.713us      2  45.856us  45.792us  45.921us  void cuda::kernel::locate_features<double, int=9>
1.02%  69.505us      2  34.752us  34.400us  35.105us  void cuda::kernel::locate_features<unsigned int, int=9>
0.99%  67.456us      2  33.728us  32.768us  34.688us  void cuda::kernel::locate_features<int, int=9>
0.95%  65.186us      2  32.593us  31.201us  33.985us  void cuda::kernel::locate_features<short, int=9>
0.93%  63.874us      2  31.937us  30.817us  33.057us  void cuda::kernel::locate_features<unsigned short, int=9>

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

Time(%)    Time   Calls      Avg       Min       Max  Name
1.45%  99.776us      3  33.258us  32.896us  33.504us  void cuda::kernel::locate_features<float, int=9>
1.33%  91.105us      2  45.552us  44.961us  46.144us  void cuda::kernel::locate_features<double, int=9>
1.02%  70.017us      2  35.008us  34.273us  35.744us  void cuda::kernel::locate_features<unsigned int, int=9>
0.97%  66.689us      2  33.344us  32.065us  34.624us  void cuda::kernel::locate_features<int, int=9>
0.95%  65.249us      2  32.624us  31.585us  33.664us  void cuda::kernel::locate_features<short, int=9>
0.95%  65.025us      2  32.512us  30.945us  34.080us  void cuda::kernel::locate_features<unsigned short, int=9>


[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 implemenation using boost CSR graph, it can be 1.5x
 faster from prev implementation but there is a performance problem that I
 couldn't solve using public functionality of graph (however there might be a
 solution) will look it back.


[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


[PATCH] Ordinary slow Ewald electrostatics implemented for md runs


[PATCH] Added free-energy kernel performance note

Change-Id: Iea5d2b124633c4188753c7b1ebb6f964edb2f644


[PATCH] removed _infostream output (slow performance on massively
 parallel systems), documentation


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


[PATCH] New version of dgemm_kernel_4x4_bulldozer.S The peak
 performance with 8 cores is now 90 GFlops


[PATCH] Fix RDTSCP handling

Commit 13def2872ae5311d tried to make all builds default to using
RDTSCP, which would have broken non-x86 builds. But it also
deactivated the implementation of RDTSCP support because HAVE_RDTSCP
was left undefined. So all it did was make timing on x86 less
efficient (plus e.g. DLB effects from that).

Used GMX_RDTSCP everywhere. Only the GROMACS project depends on
thread-MPI, so it's reasonable to let a GMX symbol leak in there (and
it's easily fixed if ever needed).


[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] Initial volume() optimization for HEX27.

This initial, relatively straightforward optimization improved the
performance of Hex27::volume() by about 16x (1476.46s down to 92.09s
for 150^3 elements).  This is good, but I still think it can be made
faster.


[PATCH] SYCL NBNXM offload support

Associated changes:

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

Limitations:

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

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


[PATCH] Disable DD again in serial with GPU or without PME

Performance is better without DD in most of those cases.

Refs #4195, #4198, #4171


[PATCH] Pass Uncertain<T> and T (enum or bool) by value instead of by
 reference. It is generally accepted that it is more efficient for small
 classes like this (and it's definitely shorter and more readable).


[PATCH] Workaround for very slow compilation on Windows


[PATCH] The Lazy Kernel dont compile the assertion and the more
 efficient bbox() function. (Because Interval_nt<> dont have gamma(),
 is_rational(), etc...)


[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] 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] Kokkos: ViewAssignment: fix critical performance bug for
 unmanaged

Turns out the unmanaged views were not actually unmanaged. The trait
was not actually used in the determination of tracking in case of
assigning a managed view to an unmanaged. The only way to get a truly
unmanaged view was to start with an unmanaged view wrapping a pointer.


[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] Preserve an old partitioning in copy_nodes_and_elements -
 should be more efficient and more reliable.


[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] Clean up and use fast pool allocator (faster)


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


[PATCH] Optimize consolidated fragment metadata loading

This is part one of two changes for optimizing consolidated fragment
metadata loading. This changes removes using VFS to always fetch the
metadata file size. Instead we select the file size only if not reading
from a consolidated file buffer. We also adjust the `fragment_size`
function, used by consolidation, to fetch the fragment metadata file
size on request. The fetching of the size on-demand for consolidation
will yield the same performance degredation we see in open array,
however this is acceptable for patch one and will be addressed in the
next series with a format change.


[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] USER-DPD: specialize PairTableRXKokkos's compute_all_items()
 on NEWTON_PAIR No noticable performance change, but it does eliminate a deep
 conditional.


[PATCH] Core: fix another issue with the memory tracking, introduced
 recently

There was a bug introduced when solving the performance issues with
subviews. It seemed to not have trickered any errors in either Trilinos
tests nor kokkos tests, but did crash Nalu.


[PATCH] 2d convolve performance improvements

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


[PATCH] Containers: DynRankView Performance Test was using to much
 memory.

The test was using close to 9GB in memory, with parallel testing this
lead to out of memory failures.


[PATCH] whitespace cleanup, fix bug in looking for empty strings,
 improve read performance and handling of comments


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


[PATCH] Added full double precision support to the hisq-force
 routines. Replaced the macro used to write the hisq fermion force to global
 memory with a much more efficient device function.


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


[PATCH] Performance increase for charge-implicit ReaxFF/changed
 cutoff selection


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


[PATCH] Performance improvements and fixed bug with memory budget and
 multi-range subarrays (#1601)


[PATCH] Make mallocs uniformly an error in PetscMatrix

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

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


[PATCH] Don't use _Atomic for jobs sometimes...

The use of _Atomic leads to really bad code generation in the compiler
(on x86, you get 2 "mfence" memory barriers around each access with gcc8, despite
x86 being ordered and cache coherent). But there's a fallback in the code that
just uses volatile which is more than plenty in practice.

If we're nervous about cross thread synchronization for these variables, we should
make the YIELD function be a compiler/memory barrier instead.

performance before (after last commit)

   Matrix          SGEMM cycles    MPC                                   DGEMM cycles      MPC
  48 x 48               10630.0   10.6       0.7%                             18112.8      6.2      -0.7%
  64 x 64               20374.8   13.0       1.9%                             40487.0      6.5       0.4%
  65 x 65              141955.2    1.9    -428.3%                            146708.8      1.9    -179.2%
  80 x 80              178921.1    2.9    -369.6%                            186032.7      2.8    -156.6%
  96 x 96              205436.2    4.3    -233.4%                            224513.1      3.9     -97.0%
 112 x 112             244408.2    5.8    -162.7%                            262158.7      5.4     -47.1%
 128 x 128             321334.5    6.5    -141.3%                            333829.0      6.3     -29.2%

Performance with this patch (roughly a 2x improvement):

   Matrix          SGEMM cycles    MPC                                   DGEMM cycles      MPC
  48 x 48               10756.0   10.5      -0.5%                             18296.7      6.1      -1.7%
  64 x 64               20490.0   12.9       1.4%                             40615.0      6.5       0.0%
  65 x 65               83528.3    3.3    -210.9%                             96319.0      2.9     -83.3%
  80 x 80              101453.5    5.1    -166.3%                            128021.7      4.0     -76.6%
  96 x 96              149795.1    5.9    -143.1%                            168059.4      5.3     -47.4%
 112 x 112             191481.2    7.3    -105.8%                            204165.0      6.9     -14.6%
 128 x 128             265019.2    7.9     -99.0%                            272006.4      7.7      -5.3%


[PATCH] Made Triangulation_data_structure_2::create_face more
 efficient


[PATCH] Use efficient intersection traits, Used the kernel
 appropriately, Added a constructor


[PATCH] Implemented basic serial 2D fast diagonalization


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


[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] Performance improvement differentiating between sparse and
 dense arrays when computing sparse results (#1605)


[PATCH] After merging pmatrix-dev, at least one thing got broken:
 ParMesh::Print for AMR meshes. Since in pmatrix-dev, slave faces are no
 longer considered shared (their P rows are not needed by the processor owning
 the master face), they are also not printed when visualizing the parallel
 solution. I suspect this also might have broken NC face neighbors. This
 branch contains a temporary solution, a downgrade of
 ParNCMesh::AddMasterSlaveRanks, so that it works the old way: slave faces are
 grouped with the masters. This fixes visualization and maybe other things,
 but may negatively impact performance of (or even break) the P matrix
 construction. I need to look more into this to find a permanent solution.


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


[PATCH] More efficient constructor for Rep


[PATCH] PERF: Improve performance for sort_by_key

- Has added benefit of cutting build times by half


[PATCH] Revert "Use correct number of atoms in GPU Update kernels"

This reverts commit 4d9a6d110b614a299a5bab4120c87a04f9ac14c1 (MR !2523).

It was supposed to be a trivial fix, but things turned out to be more
complicated, and my testing was insufficient (#4401).

The fix is still needed, but the bug is not causing incorrect physics,
merely harmless sanitizer errors and slightly higher resource
consumption by kernels that are very fast regardless.

I suggest doing it in master or delaying till the patch release.
Right now is not the best time to fix such issues.

Refs #4398


[PATCH] Matrix: Replace the row-start pointer array with computed
 offsets

The row-start pointer array provided performance benefits on old
computers but now that computation is often cache-miss limited the
benefit of avoiding a integer multiply is more than offset by the
addition memory access into a separately allocated array.

With the new addressing scheme LUsolve is 15% faster.


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


[PATCH] Build a default DiffSolver at init() not at construction, to
 be more efficient when the user wants to create a DiffSolver themselves

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


[PATCH] performance fixes in fftconvolve kernels


[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] Changes to internal memory manager

- Manager now contains list of locked and free buffers separately
- Should improve performance when allocationg new buffers
- Added proper documentation


[PATCH] make ::localize() more efficient, still need to handle
 ::localize_to_one()

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


[PATCH] Add framework for extensible ArrayFire memory managers
 (#2461)

Many different use cases require performance across many different memory
allocation patterns. Even different devices/backends have different costs
associated with memory allocations/manipulations. Having the flexibility to
implement different memory management schemes can help optimize performance for
the use case and backend.

This commit adds the ability to replace the default memory manager to a
specialized user defined memory manager. This commit also exposes the events API
to the user which allows you to synchronize tasks between two streams. The
events API will be disabled in a future commit but it can be used in the future
once we add support for streams.

ArrayFire will use the user defined memory manager whenever it allocates or
frees memory. The memory manager is exposed using the C API using function
pointers. The memory manager handle is created by the user during initialization
and the user sets several function pointers to define the behavior.

The default memory manager behavior has not changed with this commit.


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


[PATCH] s390x/GEMM: replace 0-init with peeled first iteration

... since it gains another ~2% of SGEMM and DGEMM performance on z15;
also, the code just called for that cleanup.

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


[PATCH] Fixed essential dynamics / flooding group PBC serial

In former versions, the PBC representation of essential dynamics /
flooding group atoms could be incorrect in serial runs if the ED group
contained more than a single molecule. In multi-molecule cases, the required
steps to choose the correct PBC image in communicate_group_positions()
therefore need to be performed also in serial runs. Since the PBC representation
can only change in neigborsearching steps, we only need to check the
shifts then. In parallel, NS is signalled by the bUpdateShifts
variable, which is set in dd_make_local_ed_indices(). The latter
function is however not called in serial runs; but still we can pass
the bNS boolean to do_flood() to signal the NS status. For essential
dynamics, unfortunately, since do_edsam() is called from constrain(), there
is no information about the NS status at that point. Until someone
comes up with a better idea, we therefore do the PBC check in every step
in serial essential dynamics - the performance impact will be negligible
anyway.

Change-Id: I86336a5e34131bdeac7e28f35b1ccb633450e54e


[PATCH] added a switch -Ssw which can lead to better performance
 during AMG setup


[PATCH] AdResS: lost performance tweak

Change-Id: I164bc6a60f62d117fef83844da74c3707455a980


[PATCH] GPU+DD performance improvements and code clean-up


[PATCH] take out assert to avoid performance issue


[PATCH] LJ combination rule kernels for OpenCL

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

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

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

Change-Id: I05396e000cdf93c1d872729e6b477192af152495


[PATCH] s390x: Use new sgemm kernel also for DGEMM and DTRMM on Z14

Apply our new GEMM kernel implementation, written in C with vector intrinsics,
also for DGEMM and DTRMM on Z14 and newer (i.e., architectures with FP32 SIMD
instructions). As a result, we gain around 10% in performance on z15, in
addition to improving maintainability.

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


[PATCH] Revert "Updated boost compute version tags"

This reverts commit b6d8e2d85c358f9d2be69bd09fb8b64bda9fcc04.

This commit was causing performance drops on certain hardware


[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] Optimize the performance of sum by using universal intrinsics


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


[PATCH] Code for measuring performance presented in user manual and
 associated data


[PATCH] Add an accurate but slow way to generate a sparse point set


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

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


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


[PATCH] Jeff: same as 6.0 branch.  should not include ARMCI build
 system headers.  support for T3D and T3E, especially something which is only
 for performance, not function, is silly.  s/TARGET/NWCHEM_TARGET/ for the
 RTDB case.  i don't see any reason for it in the first place but at least now
 the build system is cleaner.


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


[PATCH] Optimize cf_vs parallel performance


[PATCH] threading test performance updates


[PATCH] HvD: Adding a first pass of the 2nd and 3rd derivatives
 generated with the Maxima symbolic algebra program. Starting the code
 generation on Sunday at 10:41 AM and finishing on Wednesday at 00:11 AM it
 took approximately 62 hours to generate this code (for most part using two
 cores on my machine). The main offender was the TPSS correlation functional
 which took well over 12 hours. Part of this was due to Maxima exhausting all
 4 GB of physical memory in my desktop machine and the subsequent paging
 reduced the performance significantly.

Nevertheless the results look good right now (still need to test the higher
order derivative which could significantly impact this assessment). In
particular the code for the M06 correlation functional was originally 44 MB
in size. This was the result of simply generating the relevant derivative
expressions and expressing them as Fortran code. Now that the autoxc script
has been enhanced to optimize the expressions before generating Fortran the
same routines only amount to 470 KB (a reduction of almost a factor 100 (98 to
be precise)).

It is obvious that optimizing these expressions does take time. However, the
good thing is that with this result the compiler does not need to take that time
when you try to build NWChem. I am sure that anyone compiling NWChem will be
grateful for not having to wait 62 hours.


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


[PATCH] Improvements to multi-GPU performance


[PATCH] Restructured nonbonded calculation to allow more efficient
 vectorization


[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] WIP fast single-element neighbor calculation.


[PATCH] Rename GPU launch/wait cycle counters

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

Change-Id: I65a15b0090c1ccebb300cf425c7b3be4100e17a0


[PATCH] More efficient GetNonzeros::evaluateGen


[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] fix a few performance drop in some matrix size per data type

Signed-off-by: Wang,Long <long1.wang@intel.com>


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


[PATCH] Add --skip-partitioning command line option

This makes testing tweaks to that option easier, and might be useful
later when doing performance testing.


[PATCH] Use the simplified performance function.


[PATCH] Replacing Mish and Derivative of Mish by Fast Mish and
 Derivative of Fast Mish resp.


[PATCH] rbOOmit change: If a CouplingMatrix is attached to an
 RBConstruction then we should only increment the designated blocks in matrix
 assembly, otherwise matrix assembly is extremely slow since we go outside the
 sparsity pattern.


[PATCH] Add implementation of the mean squared error performance
 function.


[PATCH] Apply suggestions from code review

Everything following are changes to the rcm implementation.
Remove unneccessary consts from rcm declaration.
Do not store adjacency matrix and degrees as members in the class.
Replace explicit gko::vector with vector.
replace std::memcpy with std::copy_n.
Various documentation improvments.
Reverse description order of return paramters.
Make IndexType explicit instead of auto.
Use std::min_elelemt
Fix various spelling errors, typos, rewordings.
Removes the 'explicit' from the ExectorAllocators rebinding construtor.
Changes occurences of array<bool> to vector<bool>, to save memory.
Minor cleanup
Remove the unnecessary test for the rcm adjacency matrix.
Add a test case for the correct rcm result.
Rewrite the assert_correct_permutation function to comparing with iota.
Move test matrices to test class.
Improve nested vector initialization.
Allocate degrees inside rcm::generate.
Change from goto to immediately evaluated lambda expression.
Refactor loop body into an inline helper function.
Relace some autos.
Reorganize includes to conform to include order.
Replace autos with IndexType where necessary.
Replace size_type with IndexType for num_vertices.
Refactor for the number of levels to be more explicit.
Make perm signal value -1.
Factor out sort_by_degree in a generalized, fast small sorting function.
Make level_processed a constexpr.
In the small_sort make some types explicit.
Wrap omp locks in a omp_mutex, use RAII guards.

Co-authored-by: Tobias Ribizel <ribizel@kit.edu>


[PATCH] Modifications in sweepline algorithm for is_simple: - Made
 replacing edge by another edge more efficient (using insert with hint). -
 altered the output during debugging somewhat.


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

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


[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] use CUDA texture objects when supported

CUDA texture objects are more efficient than texture references, their
use reduces the kernel launch overhead by up to 20%. The kernel
performance is not affected.

Change-Id: Ifa7c148eb2eea8e33ed0b2f1d8ef092d59ba768e


[PATCH] Layout on the bibliography page
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When having a bit a long citation description, the description runs, in the HTML output on the bibliography page, into 3 or more lines where the 3rd and following lines continue underneath the citation number like:
```
 [1]  Eric Berberich, Arno Eigenwillig, Michael Hemmer, Susan Hert, Lutz Kettner, Kurt Mehlhorn, Joachim Reichel, Susanne Schmitt, Elmar Schömer, and Nicola Wolpert. Exacus: Efficient and exact
       algorithms for curves and surfaces. In Gerth S. Brodal and Stefano Leonardi, editors, 13th Annual European Symposium on Algorithms (ESA 2005), volume 3669 of Lecture Notes in Computer Science,
pages 155–166, Palma de Mallorca, Spain, October 2005. European Association for Theoretical Computer Science (EATCS), Springer.
```

The example was found  in e.g. https://doc.cgal.org/latest/Algebraic_foundations/citelist.html

- corrected the "overflow"
- made the citation number right aligned


[PATCH] Improve the performance of zasum and casum with AVX512
 intrinsic


[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] Reverting optimizations that hurt performance on some
 compilers

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


[PATCH] BUGFIX Fixed memory leak in image io, performance
 improvements


[PATCH] JJU: performance test for put get and acc


[PATCH] USER-DPD Kokkos: Remove the SSA's ALLOW_NON_DETERMINISTIC_DPD
 option. There was no measurable performance benefit to turning it on.


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


[PATCH] Add non-virtual Elem::vertex_average() and update
 Elem::centroid()

When the Elem has an elevated p_level, this will affect the Order of
the FE that gets reinit()'d for computing the centroid. Rather than do
any non-const hacking of the p_level value, we just work around this
issue by making a copy of the Elem with non-elevated p_level and
return its centroid instead.

This obviously introduces an additional performance hit, but truly
optimized code should not be calling the base class Elem::centroid()
implementation to begin with. This approach also has the benefit of
not requiring const_cast and avoiding potential thread safety issues.


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

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


[PATCH] When need to realloc, double the size.  This is more
 efficient if the ultimate size is very large.


[PATCH] Preserve an old partitioning in copy_nodes_and_elements -
 should be more efficient and more reliable.

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


[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] 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] Deprecate version of BoundaryInfo::boundary_ids(const Node*)
 that returns a vector.

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


[PATCH] Improve GPU performance especially without electrostatics


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

Same thing for Iso_cuboid_3, and the functors.

Use them in Cartesian_converter and Homogeneous_converter.


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


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


[PATCH] bond/react: performance improvement


[PATCH] Fixes to internal functions

- Was using incorrect number of elements for the total
- Fixed copy because right now isOwner() does not mean isLinear()
  - Potentially improves performance when isLinear() is not isOwner()


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


[PATCH] Enabling a fast pass option for reorder


[PATCH] Build a default DiffSolver at init() not at construction, to
 be more efficient when the user wants to create a DiffSolver themselves


[PATCH] Used EAF for all IO on T and cleaned up IO operations so that
 reads/writes on T happen in oV blocks and all reads of T go thru one routine
 (mp2_read_tiajb).  Put in performance stats for the basic steps of the
 gradient.  Use screening of the density in the non-seperable part of the
 gradient.  Reduced the tol2e from 10^-12 to 10^-9/10 but it really needs to
 be an input parameter.


[PATCH] Specialized dotInterpolate for the efficient calculation of
 flux fields

e.g. (fvc::interpolate(HbyA) & mesh.Sf()) -> fvc::flux(HbyA)

This removes the need to create an intermediate face-vector field when
computing fluxes which is more efficient, reduces the peak storage and
improved cache coherency in addition to providing a simpler and cleaner
API.


[PATCH] First cut at the performance statistics library


[PATCH] Fix performance noexcept move constructor


[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] Performance improvements and fixed bug with memory budget and
 multi-range subarrays


[PATCH] Fix for calculate_dphiref-only

I doubt anyone's ever triggered this, and it shouldn't have been more
than a performance issue if they had, but now that we're deprecating the
old fallback it'll become important.


[PATCH] Improve performance of Python integrator (NVE_Opt version)

Removing the loop over atoms by using NumPy array indexing allows to recover
performance close to that of plain fix nve.


[PATCH] turned simplewater on again and added performance fix for
 7.30 compilers


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


[PATCH] use consistent constants from math_const.h and fast integer
 powers from math_special


[PATCH] Use inFastDrawing instead of quick_camera and provide direct
 access to fast drawing state


[PATCH] reformatted the flops and performance output


[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] 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] fixed slow reading of large xvg files with LAM MPI


[PATCH] Further work on fast diagonalization


[PATCH] Use efficient intersection traits, Used kernel as template
 parameters


[PATCH] Improved performance of interaction groups on CPU


[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] - locate() cleanups, performance impact unnoticeable.


[PATCH] Fixed performance regression on Kepler


[PATCH] CUDA: change heuristic for BlockSize to prefer 128 threads

Some experiments deomnstrated that for certain kernels the
current heuristic isn't great. In particular copy and memset
kernels were bad.

Using the updated stream benchmark I got before this change:

Set               327316.30 MB/s
Copy              654344.27 MB/s
Scale             654263.20 MB/s
Add               846497.84 MB/s
Triad             844604.40 MB/s

With this change:

Set               652713.29 MB/s
Copy              807649.65 MB/s
Scale             808014.29 MB/s
Add               847403.47 MB/s
Triad             845885.63 MB/s

ExaminidMD also improved from 2.48e+08 to 2.82e+08:

1 256000 | 0.906401 0.480328 0.142917 0.165107 0.117937 | 1103.264687 2.824358e+08 2.824358e+08 PERFORMANCE

1 256000 | 1.030611 0.501819 0.243033 0.163163 0.122484 | 970.297956 2.483963e+08 2.483963e+08 PERFORMANCE


[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] This test was too slow in Debug mode


[PATCH] Added a little extra information (which inner loop) to the
 printout of performance info.


[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] Changed innerloop optimization options, and made SSE/3dnow
 loops default together with fast truncation on linux.


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

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


[PATCH] Issue #724 Gradient of the Lagrangian function is always
 generated for NLP solvers Might slow down initialization a bit, but probably
 not much


[PATCH] Improved OpenCL SIFT coalescing and performance


[PATCH] travis: try to make the slow tests pass again


[PATCH] Specialized the new estimate_errors() version for more
 efficient use in UniformRefinementEstimator


[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] make ::localize() more efficient, still need to handle
 ::localize_to_one()


[PATCH] SOLVE, MATMUL and INVERSE now use af_mat_prop

af_mat_prop values can be used for performance improvements
by calling specialized routines


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

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


[PATCH] Fix memory alloc for fast opencl


[PATCH] Switching to Simple_cartesian gives better performance"


[PATCH] fixed reallocation of nsbox bounding boxes with SSE

The reallocation of the bounding box array was not aligned and not initialized.
This probably did not give incorrect results, but could give a performance hit.


[PATCH] Removed Reaction-Field-nec

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

Change-Id: Ic22ccf76d50b5bb7951fcac2293621b5eef285c5


[PATCH] Make sure multiprocessor performance for single vectors is
 unaffected by the multivector capability.


[PATCH] small performance improvement for nbnxn SSE kernels


[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] Removed init_state

Made a simple zero-initializing constructor for t_state and the
structs of some of its members. Called them classes. Later, we might
prefer to require explicit initialization with actual values, so that
tools can detect the use of uninitialized values and find our bugs,
but for now having a constructor is a useful initial step in that
direction.

Extracted some new functions that cover some of the incidental
functionality that was also present in init_state.

Made state.lambda a std::array, thereby removing the need to consider
resizing it, and converted client code to be passed an ArrayRef rather
than hard-code the name of the specific container. This caters for
convenient future refactoring of the underlying storage, and sometimes
needing to implicitly know what the size of the container is.

Passing an ArrayRef by value is consistent with the CppCoreGuidelines,
but has potential for performance impact. Doing this means that a
caller pushes onto the stack a copy of the object (containing two
pointers), rather than previous idioms such as pointer + size, or
pointer + implicit constant size from an enum, or pointer + implicit
size in some other parameter. This could mean an extra argument is
pushed to the stack for the function call, compared with the
alternatives of pushing a pointer to data, pointer to container, or
pointer to ArrayRef. In all cases, the caller has to load the pointer
value via an offset that is known to the compiler, so that aspect is
probably irrelevant. So, we would probably prefer to avoid calling
functions that take such parameters in a tight loop, or where multiple
containers share a common size. But the uses in this patch seem to be
of sufficiently high level to be an acceptable trade of possible
performance for improved maintainability.

Change-Id: I17e7d83cfc89566f76fa9949c425b950ad6aef62


[PATCH] Improve performance of SSAMGRelax


[PATCH] improve skylakex paralleled sgemm performance


[PATCH] Further improvements to multi-GPU performance


[PATCH] Add implementation of the sum squared error performance
 function.


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

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

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


[PATCH] 128-bit AVX2 SIMD for AMD Ryzen

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

Change-Id: Ie601b1dbe13d70334cdf9284e236ad9132951ec9


[PATCH] Adjust the performance function test; use the simplified
 performance function.


[PATCH] Moving quantities around in ExactSolution::_compute_error

This is in preparation for updating to support mixed-dimension
meshes. Although this is a bit more inefficient, the code is simpler
and I thnk that since this is usually used for debugging/regression
purposes, simpler code would be preferred over higher performance
code.


[PATCH] Add Fast LSTM layer implementation.


[PATCH] make skylakex sgemm code more friendly for readers

BTW some kernels were adjusted to improve performance


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


[PATCH] #1044 disable some slow unittests by default


[PATCH] Restore locking optimizations for OpenMP case

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


[PATCH] More efficient gain calculation in SQPMethod, #551


[PATCH] avoid name clash with fast directory


[PATCH] Made some modifications that hopefully improve the
 performance of the non-blocking code. Test functionality is still sketchy.


[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] IA64: efc with Optimiz break moints2x and moints6x


[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] VT: Added a few lines about performance tuning


[PATCH] constrainPressure: Updated to use the more efficient
 patch-based MRF::relative function


[PATCH] HvD: It turns out that the performance improvements of a
 number of the optimizations don't carry over to other platforms. So I am
 removing most of them again. The ones that are here to stay are: the
 USE_FORTRAN2008 flag to pick Fortran 2008 intrinsic functions up for POPCNT,
 LEADZ, TRAILZ and ERF where available; the nwxc_dble_powix function to
 exploit that exponentiation with an integer power is much faster than
 exponentiation with a double precision power of the same value.


[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] add more efficient getppn for BGQ and MPI-3

BGQ has a system call for PPN etc.
MPI-3 has a routine to get a node communicator and the size of this communicator is the number of PPN.

I have efficient implementations for Cray, but since Cray has supported MPI-3 for over a year, there is no need.

The MPI-2 implementation could be optimized but it should not be bottleneck and is unlikely to be used except
by users that insist on using old MPI implementations, since all relevant platforms support MPI-3 or are BGQ.


[PATCH] Some performance problem. I am looking into it.


[PATCH] Transitioning and cleaning up toward a more efficient load
 balancer.


[PATCH] undo slow dgemm/skylake microoptimization

the compare is more costly than the work


[PATCH] Convert nbnxn_pairlist_set_t to class PairlistSet

This change is only refactoring.
Two implementation details have changed:
The CPU and GPU pairlist objects are now straight lists instead
of array of pointer to lists. This means that the pairlist objects are
no longer allocated on their respecitive thtreads. But since the lists
have buffers to avoid cache polution and the actual i- and j-lists are
llocated thread local, this should not affect performance
ignificantly.
The free-energy lists are now only allocated with perturbed atoms.

Change-Id: Ifc76608215518edfc61c0ca8eb71ea2a928cf57c


[PATCH] implemented efficient sparsity detection for SXFunction,
 ticket #126


[PATCH] Use reference to improve performance in pair_reaxc_kokkos


[PATCH] Change TopologyInformation implementation

This changes TopologyInformation so that we will be able to use it
also in the legacy tools, providing a better migration path for them,
as well as making progress to removing t_topology and a lot of calls
to legacy file-reading functions.

It can now lazily build and cache atom and expanded topology data
structures, re-using the gmx_localtop_t type (intended for use by the
DD code for domain-local topologies). The atoms data structure can
also be explicitly copied out, so that tools who need to modify it can
do so without necessarily incurring a performance penalty. All these
are convenient for tools to use.

The atom coordinate arrays are now maintained as std::vector, which
might want a getter overload to make rvec * for the legacy tools.

Added tests that the reading behaviour for various kinds of inputs is
as expected. Converted lysozyme.gro to pdb, added a 'B' chain ID,
generated a .top (which needed an HG for CYS) so updated pdb and gro
accordingly. Some sasa test refdata needed fixing for that minor
change.

Provided a convenience overload of gmx_rmpbc_init that takes
TopologyInformation as input, as this will frequently be used by
tools.

Extended getTopologyConf to also return velocities, which will
be needed by some tools.

Adapted the trajectoryanalysis modules to use the new approach, which
is well covered by tests.

Refs #1862

Change-Id: I2f43e62bc2d97f5e654f15c6e474b9b71d7106ec


[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 improvement through moving inlinable functions to
 header file


[PATCH] Update VSX SIMD to avoid inline assembly

Thanks to some help from Michael Gschwind of
IBM, this removes the remaining inline assembly
calls and replace the with vector functions. This
avoid interfering with the optimizer both on GCC
and XLC, and gets us another 3-10% of performance
when using VSX SIMD. Tested with GCC-4.9, XLC-13.1
in single and double on little-endian power 8.


[PATCH] Tree serialization is more efficient now.


[PATCH] Added to PME on GPU information in mdrun performance

Added -pme to glossary

Moved and modified a previous mdrun with GPU example to follow
a more logical progression - first introduce the simpler use cases
of gputasks and show examples, then at the end show how to avoid a
graphics-dedicated GPU

Added more GPU task assignment examples

Change-Id: I63304a511d5d98d85fdbb1cea497627a80a14418


[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] suppress performance warning concerning an assertion


[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] Send Points rather than individual coordinates

This should fix a bug with LIBMESH_DIM!=3 and DistributedMesh, and it
should be more efficient in some cases, and it should be easier to
refactor.


[PATCH] more efficient way to extract submatrices, remove some
 unnecessary members, better naming of functions and variables


[PATCH] Draw points with line width 0, otherwise it is too slow when
 we have 1mio points


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

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


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

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


[PATCH] Fix performance regression with gcc-3.3


[PATCH] - Some clean-up - Function get_number_of_bad_elements in the
 mesher levels (for debugging) - option
 CGAL_MESH_3_ADD_OUTSIDE_POINTS_ON_A_FAR_SPHERE to reduce contention on the
 infinite vertex


[PATCH] The Viewer declares if the current drawing is a fast draw or
 not.


[PATCH] POWER10: Improving dasum performance

Unrolling a loop in dasum micro code to help in improving
POWER10 performance.


[PATCH] Use of WallClockTimer to measure performance


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

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

Change-Id: I385acb5f989b2ecf463948be84947fe1f6dfd19b


[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] Correct CUDA kernel energy flag

The CUDA kernels calculated energies based on the GMX_FORCE_VIRIAL
flag. This did not cause errors, since (currently) GMX_FORCE_ENERGY
is always set when the virial flag is set. But using the latter flag
gives a small performance improvement when using pressure coupling.

Change-Id: If874e651058dc06c464f0fa810b17ba83146c9a3


[PATCH] Used sparse identity for more efficient memory utilization


[PATCH] EA: test for ga_dgemm performance (N=400 1600 3200)


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


[PATCH] Cuda: Enabling SHFL based reduction for static
 value_type>128bit

This improves performance significantly when reducing structs, since
the shared memory footprint is massively reduced. On smaller reduction
types it is still benefitial to go through SHMEM.


[PATCH] Fix performance penalty in bspline derivatives


[PATCH] Create even less contention

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

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


[PATCH] Extensive commenting and instructions on how to run fast kde
 is completed


[PATCH] replace std::set<Vertex_handle> with
 std::array<Vertex_handle>

for facets vertices
this should be a lot more efficient


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


[PATCH] DynaIO option to keep or drop spline nodes

This should let us easily build meshes that retain the exact geometry of
an IsoGeometric Analysis mesh but that don't have any topologically
disconnected NodeElem elements (so they should scale better with our
existing partitioner code) and don't have constraint equations (so they
might be more efficient with our existing solvers and should be
compatible with our reduced_basis code).


[PATCH] Completed the base fast SVD case for which the number of
 points is less than the dimension...


[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] Improve performance of random number generator calls


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


[PATCH] Add Quad8::volume().

This speeds up a test code which calls elem->volume() on each
distorted QUAD9 in a 4M element mesh by approximately 650x (from about
206s down to 0.3146s).

As far as the accuracy of the four-point quadrature rule goes, it
appears to be quite good up to about 15% distorted elements (in the
context of MeshTools::Modification::distort()).  More distortion than
this is probably not really usable for finite element analysis,
anyway.  In the table below, max_rel_diff is computed using a
twelfth-order quadrature rule (49 points) in the reference volume
computation.

distortion max_rel_diff
0.05       3.0166222190035792e-15 (<1%)
0.1        2.9337828206309171e-15 (<1%)
0.15       1.9220118208802948e-02 (2%)
0.2        1.4316734561689504e-01 (14%)
0.3        3.6570789827049105e-01 (36.5%)

It would also be possible to implement an "early return" branch for
this function, but you would have to check the value of 8 different
3-vectors against zero so I didn't think it was worth the extra
complexity for the minimal performance improvement.


[PATCH] More fine grained ParmetisPartitioner logging

This is ludicrously slow outside opt mode


[PATCH] Fixing issues from @rcurtin's review + adding unit test for
 cross entropy performance function


[PATCH] checking in change for 1-1-48 pathway, a more efficient free
 energy path. See Pham and Shirts,
 http://jcp.aip.org/resource/1/jcpsa6/v135/i3/p034114_s1


[PATCH] removed a lot of slow FFT grid sizes from calc_grid and made
 calcgrid.c thread safe


[PATCH] fast point location should work now


[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] Add Elem::loose_bounding_box()

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


[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] Comment out the do_intersect tests

They caused a performance problem when used with the tweaked AABB_traits
of Surface_mesh_segmentation.


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


[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] Various performance improvements: (#1573)

- Each fragment metadata directory is now associated with an empty file with the same name as the directory, but with added suffix '.ok'. This prevents an extra REST request on object stores when opening the array.
- Consolidation does not delete the consolidated fragments or array metadata. This is to prevent locking the array during consolidation and to enable time traveling and fine granularities.
- Added new consolidation functionality that enables consolidation of all fragment metadata footers in a single file. This boosts the performance of opening an array significantly.
- Added vacuum API to clean up consolidated fragments, array metadata, or consolidated fragment metadata.
- Parallelized the reader in various places, significantly boosting the read performance.


[PATCH] more efficient binary operations in MX, ticket #192


[PATCH] Adding Changelog for Release 3.2.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.2
Update Kokkos version macros to 3.2.0


[PATCH] Updated whitespace, implemented low hanging performance
 boosts


[PATCH] More efficient SetNonzeros::propagateSparsities


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


[PATCH] Adding Changelog for Release 2.8.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 2.8


[PATCH] some more performance improvements


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


[PATCH] on itanium (with Intel compiler) **2 was verrrry slow,
 replaced with ()*()


[PATCH] fast exit out of symmetry routines if C1 No longer print "ok"
 on first geomtry step


[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] 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] Enable SIMD register calling convention with gmx_simdcall

Cmake now checks if the compiler supports __vectorcall or
__regcall calling convention modifiers, and sets gmx_simdcall
to one of these if supported, otherwise a blank string.
This should enable 32-bit MSVC to accept our SIMD routines
(starting from MSVC 2013), and with ICC it can at least in
theory improve performance slightly by using more registers
for argument passing in 64-bit mode too. Presently this is
only useful on x86, but the infrastructure will work if we
find similar calling conventions on other architectures.

Fixes #1541.

Change-Id: I7026fb4e1fb6b88c8aa18b060a631cbb80231cd4


[PATCH] Added parallel LCG, a way to avoid an MPI performance bug on
 BG/P, a function for creating random Hermitian matrices, and modified LAPACK
 wrappers to throw an error if the 'info' parameter is nonzero, even in
 RELEASE mode.


[PATCH] Fix AMD OpenCL float3 array optimization bug

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

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

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

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


[PATCH] Code for ordinary, slow, ewald electrostatics


[PATCH] Called MPI_Send_Recv at appropriate locations instead of the
 more elaborate dual calls. Performance improvement is not measurable on Linux
 though. But in principle an MPI implementation could optimize that.


[PATCH] new optimization of dgemm kernel for bulldozer: 10%
 performance increase


[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] Distinguished mutexes from semaphores. The distinction is
 useful because the linux implementation of sem_post() in unnecessarily slow
 when semaphores are used for mutual exclusion.  This change made spinlocks
 messier to implement, so I excised them.


[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] fixed a bug with efficient IMVJ and reuse of old data - need
 to clear the matrix Wtil after convergence of the current time step, as
 columns are the result of J*V and J is outdated now.


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

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


[PATCH] wmkdep: Added path string substitution support

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


[PATCH] Fix for md_parallel_for for Cuda reported in #1057

md_parallel_for is intended to be deprecated, but fix the issue for not
respecting lower bounds while resolving difference in performance
between md_parallel_for and parallel_for calls with MDRangePolicy


[PATCH] MDRange: Minor perf test fixes for KNL

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


[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] Add a new example called `custom-logger`.

The purpose of this example is to show the users how to customize Ginkgo by
adding a new logger, which is useful and more efficient for application specific
problems. This is also one of the most basic (and simple) ways of customizing
Ginkgo, therefore this is a good entry level example.

This example simply prints a table of the recurrent residual norm against the
real residual norm.

This example is documented as much as well as the `simple-solver` example for
the user's convenience.


[PATCH] Sparse unordered with duplicates: Better vectorization for
 tile bitmaps.

When computing tile bitmaps, there are a few places where we were not
vectorizing properly and it caused performance impacts on some customer
scenario. Fixing the use of covered/overlap in the dimension class to
enable proper vectorization.


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


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


[PATCH] Explaining the performance test better.


[PATCH] bugfix of set_coef introduced by
 c84cc28d1c5550876d2d648f905716ffa69335ef

The problem is that building the matrix from a set of triplets sums
the value provided in case several values at the same position are
provided. In order to overwrite a value, we have no other choice
than to build the matrix and set the value (with current Eigen API).
The following fix is as efficient if the matrix is assembled
in one pass. Using the boolean member of set_coef is very important now
as it can imply a premature building of the eigen matrix.


[PATCH] Fix for processors being offline on Arm

Use the number of configured rather than online CPUs.
We will still get a warning about failures when trying to
pin to offline CPUs, which hurts performance slightly.
To fix this, we also check if there is a mismatch between
configured and online processors and warn the user that
they should force all their processors online
for better performance.

Change-Id: Iebdf0d5b820edcd7d06859a2b814adf06589ef96


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


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

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

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

Time(%)  Time   Calls      Avg       Min       Max  Name

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

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

Time(%)    Time   Calls      Avg       Min       Max  Name

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


[PATCH] fixed bug with Verlet + DD + bonded atom communication

Atoms communicated for bonded interactions can be beyond the cut-off
distance. Such atoms are now put placed in an extra row in the grid.
Fixes #1114

Also improved the performance of the nbnxn grid sorting, especially
for inhomogeneous systems.

Change-Id: Ibe5ba24af95959f5dadd89584e2315da60b55091


[PATCH] Move calcgrid.* to fft/

One more file out of gmxlib/.  These are related to selecting an FFT grid
size, and contain some numbers coming from performance measurements, so
fft/ should be a natural place.

Change-Id: I386965665a92bc47d4c0c3ca0201a6a4b13b5886


[PATCH] Speed improvement with CGAL_HEADER_ONLY and
 WITH_{tests|examples}..

When `CGAL_HEADER_ONLY` and `WITH_{examples|tests|demos}`, then only
the first call to `find_package(CGAL)` does the job. The subsequent
calls return very fast, by caching the results in global properties.


[PATCH] improved nbnxn PME kernel performance on AMD

The performance of the nbnxn PME kernels on AMD was much worse with
gcc than with icc. Now the table load macro has been changed,
which roughly halves the performance difference.