[PATCH] functionObjects: surfaceFieldValue, volFieldValue: Various
 improvements

A number of changes have been made to the surfaceFieldValue and
volFieldValue function objects to improve their usability and
performance, and to extend them so that similar duplicate functionality
elsewhere in OpenFOAM can be removed.

Weighted operations have been removed. Weighting for averages and sums
is now triggered simply by the existence of the "weightField" or
"weightFields" entry. Multiple weight fields are now supported in both
functions.

The distinction between oriented and non-oriented fields has been
removed from surfaceFieldValue. There is now just a single list of
fields which are operated on. Instead of oriented fields, an
"orientedSum" operation has been added, which should be used for
flowRate calculations and other similar operations on fluxes.

Operations minMag and maxMag have been added to both functions, to
calculate the minimum and maximum field magnitudes respectively. The min
and max operations are performed component-wise, as was the case
previously.

In volFieldValue, minMag and maxMag (and min and mag operations when
applied to scalar fields) will report the location, cell and processor
of the maximum or minimum value. There is also a "writeLocation" option
which if set will write this location information into the output file.
The fieldMinMax function has been made obsolete by this change, and has
therefore been removed.

surfaceFieldValue now operates in parallel without accumulating the
entire surface on the master processor for calculation of the operation.
Collecting the entire surface on the master processor is now only done
if the surface itself is to be written out.


[PATCH] Speed up mtop_util atom lookup

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

Change-Id: I185b8c2e614604e9561190dd5e447077d88933ca


[PATCH] Add temporary allocations to PCG to avoid continual
 allocation / freeing.  This restores performance to regular CG level


[PATCH] Non-PME OPT calculations now use a much more efficient
 Cartesian field algorithm for the dipole response force terms.


[PATCH] Fixed a potential performance bug in the KDE code that
 resulted in a stricter pruning criterion.


[PATCH] Fixed a performance regression in multi-GPU on CUDA


[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] potentially improved performance of coarsening and
 interpolation by using different Commpkg for strength matrix S. Added a new
 parameter S_commpkg_switch which sets the smallest strength threshold, for
 which this capability is used. This required the addition of a new parameter
 (int array that maps S-indices to A-indices) to the interpolation routine.
 Note that while this change does not affect Falgout, CLJP, PMIS and HMIS
 convergence behaviour and complexities, it affects ruge, ruge2b and ruge3c.
 This can be avoided by setting S_commpkg_switch to 1.


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

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

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

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


[PATCH] More efficient constructor for Rep


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


[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] Additional parameter tweaking for performance enhancement.


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


[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] Set default GMX_OPENMP_MAX_THREADS to 64

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

Change-Id: I73d1c79e86f30f7fc69e1f49e1195271435e77b6


[PATCH] small performance fix: reuse conic1, conic2 in set(5)


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


[PATCH] Added a base class with a lookup table for functions cw(int)
 and ccw(int).  It results in a performance improvement.


[PATCH] Anisotropic smoothing perf improvements in CUDA

This improves CUDA backend performance by about 24%


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


[PATCH] Implemented the efficient computation of the second centroid.

The hierarchical clustering algorithm gets about 15% faster
(on test Eglise Fontaine, from 91s to 76s).


[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 efficient version, which only searches when necessary
 and only once per element


[PATCH] fixed performance issue for vacuum with DD


[PATCH] More efficient SystemBase::reinit, flux_jump indicator should
 work but needs testing


[PATCH] Adding optional wrappers for MKL CSR mat-vec, allowing for
 more configure-time math library detection, adding a Hermitian version of
 Lanczos, and greatly improving the performance of right
 DiagonalScale/DiagonalSolve. It appears that the current distributed sparse
 matrix-vector multiplication has scalability issues.


[PATCH] allow compilation to optimize for CUDA compute cap. 3.5

Enabling optimizations targeting compute capability 3.5 devices
(GK110) slightly improves performance of both PME and RF kernels.
This requires a hint for the compiler optimization indicating
the maximum number of threads/block and minimum number of
blocks/multiprocessor. This change allows nvcc >=5.0 to generate
code for CC 3.5 devices and switches to including PTX 3.5 code
(instead of 3.0) in the binary.

Change-Id: If7e14d31165bc05859250db7468bf6bd8c186264


[PATCH] Pair of send(vector) -> send(vector<pair>)

This may be more efficient in some cases and it should be easier to
refactor shortly.


[PATCH] Add class ListOfLists

This is a replacement for t_blocka, i.e. a performance optimized
implementation of a list of lists. It only allows appending a list
at the end of the list of lists.

Change-Id: Ib4b7f5f0e57b82c939f53e9805dc16e9d76db22b


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


[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] Modified nb_putv to improve performance of transfers to
 processes on the same SMP node.


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


[PATCH] Replacing FT by RT, more efficient Sign_at


[PATCH] Unroll middle jm loop in the nbnxm kernels on Ampere

The unrolling improves performance of the non-bonded kernels by up to
12%.

Note: cherry-picked backport, skip when merging.

Refs #3873


[PATCH] minor performance fix; map double_conic to
 double_coefficients


[PATCH] Further improvements to multi-GPU performance


[PATCH] GetPot: Use a more efficient container for UFO detection


[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] Fixed performance problems when many boxes are on a process:
 Removed a Sort from the communication stuff. Reordered the periodic boxes in
 the neighborhood. Changed the CommInfoFromStencil algorithm.


[PATCH] Latest modifications that increased the parallel performance


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


[PATCH] Fixed slow COO SpMV for the OpenMP executor

Moved the `omp parallel for` to the most outer loop of the apply,
so it is parallelized over the matrix entries instead over the number
of right hand sides for every single matrix entry.


[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] Optimize the performance of dot by using universal intrinsics
 in X86/ARM


[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] Improve the performance of dasum and sasum when SMP is
 defined


[PATCH] Improved performance of prolongator through exposing
 intstruction-level parallelism.  This enables full bandwidth to be achieved
 on Maxwell.


[PATCH] Moved various operations for polynomial smoothers into setup
 phase to improve performance and added new parameters to allow use of
 different polynomials


[PATCH] performance improvement through moving inlinable functions to
 header file


[PATCH] Hopefully improve singledot performance


[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] GEMM: skylake: improve the performance when m is small


[PATCH] Exploiting memory layout for better performance in
 matrix-free restriction


[PATCH] CouplingMatrix::operator&=

The user and library may need to use the output of a bunch of coupling
functors, and this should be more efficient than carrying around a
bunch of matrices and iterating through all of them.


[PATCH] perf: minor performance improvements for bilateral


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


[PATCH] Replace vpermpd with vpermilpd

to improve performance on Zen/Zen2 (as demonstrated by wjc404 in #2180)


[PATCH] bug fixes in double_conic, minor performance improvements


[PATCH] Test show an improvement in octree performance


[PATCH] nbnxn utils performance improvement for Phi

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

Change-Id: Ib0f7807986e6fcbe998bd6ee41ce104666446321


[PATCH] 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] clover::FloatNOrder now uses vectorized load/store for
 improved performance of all algorithms that use this (clover inversion sees a
 1.5x speedup).  Added missing support for clover norm field save/restore in
 tuning.


[PATCH] Fixed nbnxn_4xN performance regression

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

Change-Id: Iac334865c2b2340493639300d07e7ab9c78e129f


[PATCH] More performance tweak in Monte Carlo sampling.


[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] Switching to Simple_cartesian leads to a performance gain of
 50% for 100K points


[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] implemented efficient sparsity detection for SXFunction,
 ticket #126


[PATCH] Fix OMP num specify issue

In current code, no matter what number of threads specified, all
available CPU count is used when invoking OMP, which leads to very bad
performance if the workload is small while all available CPUs are big.
Lots of time are wasted on inter-thread sync. Fix this issue by really
using the number specified by the variable 'num' from calling API.

Signed-off-by: Chen, Guobing <guobing.chen@intel.com>


[PATCH] Improving performance of Kokkos ReaxFF

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


[PATCH] Remove memory churn in compute_affine_map, improving
 threading performance


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

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


[PATCH] More efficient SetNonzerosSlice::evaluate


[PATCH] HvD: The density functionals with derivatives up to and
 including third order generated by automatic differentiation using the
 univariate Taylor series approach by Griewank et al. DOI:
 10.1090/S0025-5718-00-01120-0.

For this code to perform well it is essential that the compiler inlines a lot
of code. If the overloaded operators are evaluated as function calls the
calculations slow down by more than an order of magnitude. Some compilers
can only inline code within a single file. Hence the addition of nwxc.F
that includes all the source code of the various functionals. In particular
the GCC generated code saw significant performance improvements as a result.
For GCC one is adviced to use compiler versions post 4.6 as apparently
significant improvements to the inline capabilities were introduced at that
point.

At this point the gradient and 2nd derivative evaluation have been tested.
For the 3rd order derivatives test cases that actually exploit those derivatives
are still needed. If there are any deficiencies at that level they are most
likely to stem from the driver routine NWXC_EVAL_DF3_DRIVER which has to
generate the appropriate partial derivatives and interpolate the final results.
The generation of the derivatives themselves should work alright as the unit
tests in src/nwxc/nwad/unit_tests work and the lower order order derivatives
of the functionals work.

At the moment the performance is still not as good as I would like it. I suspect
that the univariate approach is in part to blame for that. The fact that all
lower order derivatives need to be re-evaluated for every highest order partial
derivative introduces an overhead that is close to proportional to the
highest order of derivative requested. I am planning to try a multivariate
approach instead. This however has increased memory access as a downside,
in particular during assignments. We will see what is best on balance.


[PATCH] Optimizations to kspace_style MSM, including improving the
 single-core performance and increasing the parallel scalability. A bug in MSM
 for mixed periodic and non-periodic boundary conditions was also fixed.

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


[PATCH] Unroll middle jm loop in the nbnxm kernels on Ampere

The unrolling improves performance of the non-bonded kernels by up to
12%.

Refs #3872


[PATCH] Made Triangulation_data_structure_2::create_face more
 efficient


[PATCH] Tree serialization is more efficient now.


[PATCH] fixed remains of xj shifting in legacy CUDA NB kernel

This removes three extra useless flops, there the fix results in a
slight performance improvement.


[PATCH] Fix performance unnecessary copy initialization


[PATCH] Temporary fix for OpenCL PME gather

There is a race on the z-component of the PME forces in the OpenCL
force reduction in the gather kernel. This change avoid that race.
But a better solution is a different, more efficient reduction.

Refs #2737

Change-Id: I45068c9187873548dff585044d2c8541444e385c


[PATCH] Deprecate the Side class

For repeated use our new Elem-based side_ptr APIs are more efficient
now.


[PATCH] Enabling of NVidia PTX backend for SYCL & nbnxmKernel
 performance optimizations


[PATCH] removed (harmless) left-over in nbnxn SIMD kernels

This improves performance of PME + p-coupling by about 5%.
With Ewald and virial, the nbnxn SIMD energy kernels were used
(some left-over development code). The plain-C code did not do this.

Change-Id: I039044fcb393bf0bcaa06f38498b2a57d60cf080


[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] Use non caching segment traits to accelerate arrangement
 computations


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


[PATCH] Deprecate attempts to build proxy Side objects

Now that we've made Elem side objects much more efficient, we don't need
the old proxies anymore.


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


[PATCH] More efficient Sparsity::serialize


[PATCH] Fixed a performance bug in the sweep. When calling the insert
 functions on the planar map, I made sure the non-intersect version of the
 inserts are being called. I also cleaned up the code a bit.


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


[PATCH] avoid computing factorization of linear matrix again, clean,
 use more efficient code by avoiding duplicates when calculating stiffness
 matrix


[PATCH] AABB tree: do_intersect now calls the First_primitive
 traversal traits (much faster) performance section updated


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


[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] Inverse and make_sqrt functions added. RT / Root_of_2<RT>
 division added. Some operations with int. Comparisons function performance
 improved. Added the idea of representing a rational (when we know, by using
 the Root_of_2(FT) construction) inside the Root_of_2. The constructor
 Root_of_2<RT>(const RT&, const RT&, const RT&, bool) has now another boolean
 parameter at the end, in the case you know delta is not zero. Some others
 goodies.


[PATCH] Complete OMP version except for the inner product.
 Performance below host.


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


[PATCH] Replace some std::endl with newline character

Note that std::endl flushes the buffer, so we can get better
performance by using newlines when there is no need to flush.


[PATCH] Fixed FAST memory leaks on CPU backend


[PATCH] Accelerate distance queries with a kd-tree


[PATCH] Improvements to multi-GPU performance


[PATCH] Adjust serialized query buffer sizes (#2115)

Adjust serialized query buffer sizes

This change the client/server flow to always send the server the
original user requested buffer sizes. This solves a bug in which with
serialized queries incompletes would cause the "server" to use smaller
buffers for each iteration of the incomplete query. This yield
decreasing performance as the buffers approached zero. The fix here lets
the server always get the original user's buffer size.


[PATCH] made nbnxn analytical Ewald consistent

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

Change-Id: I28abc822ee8f1cf8f7dbb5c516703145400441b2


[PATCH] dgemm: use dgemm_ncopy_8_skylakex.c also for Haswell

The dgemm_ncopy_8_skylakex.c code is not avx512 specific and gives
a nice performance boost for medium sized matrices


[PATCH] AABB tree: more on internal KD-tree used to accelerate the
 distance queries.


[PATCH] Use new ranges in MeshTools

Plus manual caching, where it's more efficient


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


[PATCH] Improvement of rectangular slicing: part 2  -  fast
 implementation for large blocks of sparse matrices


[PATCH] Fast transfers and diffusion kernels


[PATCH] Accelerate AABB tree traversal by passing the tolerance as
 initial min_dist


[PATCH] More efficient SetNonzerosSlice2::evaluate


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


[PATCH] Improved the performance on Powerpc by tweaking the altivec
 innerloops and changing sqrt(x) to x*invsqrt(x)


[PATCH] Fixed FAST memory leaks on OpenCL backend


[PATCH] Inline a more efficient implementation of
 BoundingBox::intersects.

This ends up being about 9x faster due to inlining and improved short
circuiting.


[PATCH] sbgemm: spr: enlarge P to 256 for performance


[PATCH] This should slightly improve performance in non-threaded proj
 constraint generation, may save us from a race condition leading to
 inaccurate proj constraints in a few corner cases (3D, level one rule off; or
 AMR combined with periodic BCs) when we're threaded.


[PATCH] Update RAS-IR.

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


[PATCH] This should slightly improve performance in non-threaded proj
 constraint generation, may save us from a race condition leading to
 inaccurate proj constraints in a few corner cases (3D, level one rule off; or
 AMR combined with periodic BCs) when we're threaded.

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


[PATCH] Fix IBM VSX SIMD compiles with xlc

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

Change-Id: I3e8e9b4dd6102dd5503210e3b49b844ee5492342


[PATCH] s390x: Optimize SGEMM/DGEMM blocks for z14 with explicit loop
 unrolling/interleaving

Improve performance of SGEMM and DGEMM on z14 and z15 by unrolling and
interleaving the inner loop of the SGEMM 16x4 and DGEMM 8x4 blocks.
Specifically, we explicitly interleave vector register loads and
computation of two iterations.

Note that this change only adds one C function, since SGEMM 16x4 and
DGEMM 8x4 actually map to the same C code: they both hold intermediate
results in a 4x4 grid of vector registers, and the C implementation is
built around that.

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


[PATCH] Use SIMD transpose scatter in bondeds

The angle and dihedral SIMD functions now use the SIMD transpose
scatter functions for force reduction. This change gives a massive
performance improvement for bondeds, mainly because the dihedral
force update did a lot of vector operations without SIMD that are
now fully replaced by SIMD operations.

Change-Id: Id08e6c83d4c9943d790bfe2a40c70fa4697077af


[PATCH] Improved CUDA SIFT coalescing and performance


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


[PATCH] JN: ELAN_ACC for fast accumulate


[PATCH] Code factorization + "manual" min/max for slightly better
 performance


[PATCH] More getElementByMass performance improvements

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


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

- Improved performance when all buffers can be indexed linearly


[PATCH] Use boost::thread::hardware_concurrency instead of the
 std::thread one

std::thread::hardware_concurrency is not implemented in my GCC version
Was causing a huge performance problem on Linux.


[PATCH] Add DofMap::is_evaluable()

This is O(log(send_list.size())), which may be fast enough for most
users; there's no obvious way to do better without unsorted_set.


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


[PATCH] made the code MUCH more efficient in various places


[PATCH] Improve performance running on multiple GPUs (#3347)

* Use multiple streams to broadcast positions

* Use multiple streams to reduce forces

* Adds sync between default stream and peer-copy

* Minor cleanup

Co-authored-by: David Clark <daclark@nvidia.com>


[PATCH] HvD: Mainly optimized bits of code. The automatic
 differentiation module still has scope for optimization (which was also
 pointed out by one of the reviewers of the paper). So I have improved a few
 things:

1. I have added USE_FORTRAN2008 a flag, when set, to use the popcnt, trailz and
   leadz Fortran 2008 intrinsics rather than the corresponding Fortran
   implementations util_popcnt, util_leadz and util_trailz. The util routines
   are still used by default.

2. I optimized the powx routine which calculates x**y to use less exponentiation
   evaluations.

3. I added a routine (powix) to do x**i where i is an integer as that is 20
   times faster than doing x**y where y is a double precision variable with an
   integer value. This is the only case for an integer argument because in this
   specific case the performance difference is really significant.

4. I have also changed nwad_print_int_opx to print double precision numbers that
   hold integer values as integers rather than floating point numbers in the
   expectation that that will filter through the code generated by Maxima.

Overall performance improvement was only 10% though.


[PATCH] Adding manually inlined variants of Sweep functions since
 they were observed to be more efficient in practice


[PATCH] Improve rendezvous performance when hardware is
 oversubscribed


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


[PATCH] Removing gigaflop utility functions, removing illegal 'const'
 declarations in unblocked TwoSidedTrmm routines, fixing comments in several
 DistMatrix declarations, and adding a Trsv test driver in preparation for a
 significant performance improvement from an upcoming patch.


[PATCH] Drastically improve performance of getElementByMass

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

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


[PATCH] Use templates to improve performance when not using triclinic
 boxes


[PATCH] NumericVector::add_vector refactoring

Similar to #411 and #413

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


[PATCH] Added allow_rules_with_negative_weights flag to QBase.
 Default is true (which was the standard behavior) but you can set this to
 false to use more expensive (but potentially safer) quadrature rules instead.

Replaced the 15-point tet Gauss quadrature rule with a 14-point rule
by Walkington of equivalent order.

Added Dunavant quadrature rules for triangles up to THIRTEENTH order.  These
are more efficient than the conical product rules they are replacing.  Up to
TWENTIETH order still to come.

Replaced SECOND-order rule for triangles with a rule having interior integration
points.  The previous rule had points on the boundary of the reference element.

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


[PATCH] Comment out the do_intersect tests

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


[PATCH] Conditional tweak in the nonbonded GPU kernels

GPU compilers miss an easy optimization of a loop invariant in the
inner-lop conditional. Precomputing part of the conditional together
with using bitwise instead of logical and/or improves performance with
most compilers by up to 5%.

Change-Id: I3ba0b9025b11af3d8465e0d26ca69a78e32a0ece


[PATCH] issue #939: more efficient kronecker product for
 Sparsity/Matrix


[PATCH] GetPot: Use a more efficient container for UFO detection

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


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

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

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

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


[PATCH] 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] take out assert to avoid performance issue


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


[PATCH] same as commit 76d5bddd5c3dfdef76beaab8222231624eb75e89:
 Split ga_acc  in smaller ga_acc on MPI-PR since gives large performance
 improvement on NERSC Cori


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


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


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


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


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


[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] fix obvious performance bug in Isolate_1


[PATCH] fixing performance of nwpw_gauss_weights...EJB


[PATCH] made the domain decompostion a bit more efficient and cleaned
 up the DD code


[PATCH] Performance improvement differentiating between sparse and
 dense arrays when computing sparse results (#1605)


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


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


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


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


[PATCH] Improve performance of SSAMGRelax


[PATCH] Replace the comparison of 2 lines with a more efficient one
 (just for this specific case where direction doesnt matter).


[PATCH] Fixes for style and performance issues found by cppcheck

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


[PATCH] Improve object_type detection performance (#2792)

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


[PATCH] Rewriting of Attribute_elevation (shorter and more efficient
 code)


[PATCH] Use stack allocation in zgemv and zger

For better performance with small matrices
Ref #727


[PATCH] PERF improvements and bugfixes for select and replace

- Performance improvements to CUDA backend
- Bugs fixed in OpenCL backend


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

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


[PATCH] * modified termination policies * fast SVDBatch
 implementation


[PATCH] better performance with hanging nodes


[PATCH] Removed unnecessary synchronization that hurt performance on
 Nvidia


[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] fix performance issue--forgot to move name parameters


[PATCH] More efficient IntegratorInternal::getDerivative #936


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


[PATCH] s390x/Z14: Change register blocking for SGEMM to 16x4

Change register blocking for SGEMM (and STRMM) on z14 from 8x4 to 16x4
by adjusting SGEMM_DEFAULT_UNROLL_M and choosing the appropriate copy
implementations. Actually make KERNEL.Z14 more flexible, so that the
change in param.h suffices. As a result, performance for SGEMM improves
by around 30% on z15.

On z14, FP SIMD instructions can operate on float-sized scalars in
vector registers, while z13 could do that for double-sized scalars only.
Thus, we can double the amount of elements of C that are held in
registers in an SGEMM kernel.

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


[PATCH] Simplify gmx chi

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

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

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


[PATCH] #914 Replaced casadi_copy_sparse runtime function with
 casadi_project With work vector and more cache efficient


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


[PATCH] Minor code reordering in GPU kernels

Updating bCalcFshift just before use instead at the top of the kernel
improves performance by 1-2% on CUDA. This also improves readability.
Making specialized (no)shift kernels will only add 1% gain.
Also updated the OpenCL kernels for consistency and readability
(the perfromance impact is negligible with current hardware/compiler).

Change-Id: I309f90ad61e5815726d55254e2cd38d5e4e7662d


[PATCH] Try to improve parallel performance of CBMC


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


[PATCH] Optimize cf_vs parallel performance


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


[PATCH] avoid casts to the wrong derived class, which upsets code
 analysis tools. seems to improve performance, too.


[PATCH] Added allow_rules_with_negative_weights flag to QBase.
 Default is true (which was the standard behavior) but you can set this to
 false to use more expensive (but potentially safer) quadrature rules instead.

Replaced the 15-point tet Gauss quadrature rule with a 14-point rule
by Walkington of equivalent order.

Added Dunavant quadrature rules for triangles up to THIRTEENTH order.  These
are more efficient than the conical product rules they are replacing.  Up to
TWENTIETH order still to come.

Replaced SECOND-order rule for triangles with a rule having interior integration
points.  The previous rule had points on the boundary of the reference element.


[PATCH] JN:  memcpy on T3D is now fast enough


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

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


[PATCH] made PME load balancing + DD DLB more efficient

The DD dynamic load balancing is now limited, such that the fastest
timed PME load balancing cut-off setting can always be used.
Fixes #1089

Change-Id: I3216dfd5a8b2b0676eee5519e08cf36e06047251


[PATCH] Refactor CalculateTopRecommendations(), including a complete
 overhaul of how recommendations are actually calculated.  std::pair<> and
 std::map<> are often quite slow, especially in that implementation.  This is
 faster.


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


[PATCH] more efficient treatment of geometries in qmmm


[PATCH] Extending LLL to support linearly dependent bases (and
 returning the nullity). A small performance optimization was also made by
 removing lll::ExpandQR from lll::HouseholderStep


[PATCH] New DCEL structure that allows more efficient handling of
 holes and isolated vertices. (Ron) Automatic handling of holes to remove in
 the construction visitor. (Baruch)


[PATCH] Improve the performance of read_data of gzip'ed files using
 taskset. Normally, the gzip process would be pinned to the same core as the
 MPI rank 0 process, which makes the pipe stay in one core's cache, but forces
 the two process to fight for that core, slowing things down.


[PATCH] Revert "Minor changes to use libmesh indentation,
 initialization styles."

This reverts commit ddf20ff42df730dfb38bf0d618b7d1d9264948b7.

Revert "Write element truth table to exodus to improve performance"

This reverts commit 3c400489f41dbd72fe704c3dfe94db6e9bcd200e.


[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] Fix performance for resize, and deep_copy


[PATCH] Performance drop fix - Added a QTime to reduce the number of
 calls to deform().


[PATCH] Fix excessive list splitting

Due to a possible integer overflow, the pair list splitting code could
end up over-splitting pair lists and causing large performance
degradation. Due to the larger processor count, runs using AMD GPUs,
using 100k+ simulation systems are more prone to suffer from the issue.

Fixes #1904

Change-Id: I29139ec80aa75c78fa93de0858f7c60cdae88d5b


[PATCH] Fix the integer overflow issue for large matrix size

For large matrix, e.g. M=N=K, and M>1290, int mnk=M*N*K will overflow.
This will lead to wrong branching to single-threading. The performance
is downgraded significantly.

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


[PATCH] Fixed a performance regression on AMD GPUs


[PATCH] Fixing bug that arose in parallel performance example ex1p


[PATCH] Working on performance improvements


[PATCH] Fix for #1139 performance regression bug (and #1140 for
 tracking). Set default CUDA launch bounds to <0,0> and when do not use CUDA
 __launch_bounds__ unless CUDA launch bounds are explicitly specified.


[PATCH] Cache n_nodes/sides/edges in DofMap constraints

We loop over each of these ranges multiple times, so doing the loop
end manually should more efficient than even the new range idiom.


[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] Use efficient intersection traits, Used the kernel
 appropriately, Added a constructor


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

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


[PATCH] Improved performance of bicgstab after adding the second
 convergence test.


[PATCH] POWER10: Improving dasum performance

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


[PATCH] Extending QP and NNLS to handle multiple right-hand sides in
 an efficient way and adding a Non-negative Matrix Factorization (NMF).


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


[PATCH] Improving the performance of the HessenbergSchur QR sweeps


[PATCH] Use a map for pushed_ids

We won't be handing this to parallel_sync but we want it to be more
efficient in the large processor count case anyway.


[PATCH] More efficient TNG selection group creation

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

Change-Id: Ibe2a14e55aff829fdb74de074447f00f0e85f090


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


[PATCH] changed dim_type typedef to int from long long

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


[PATCH] Global optimizers: better parallel performance

- We used to have a thread-local variable for cell::TDS_data to make
  incident_cells concurrently callable but it was slow and memory-consuming
  => new incident_cells function which do not use cell::TDS_data
  => faster and lighter
- update_restricted_delaunay now uses parallel_for instead of parallel_do
  (it was quite slow with the implicit oracle)
  => faster (but requires to fill a temporary vector)


[PATCH] improved performance in some of the
 IsoparametricTransformation::*RevDiff methods by stack allocating dFdx_bar
 inside. Added additional FiniteElement::*RevDiff methods for differentiating
 various methods. Added EvalRevDiff methods to additional coefficient classes,
 and added tests for the coefficient differentiation as well as the finite
 element differentiation


[PATCH] CUDA PME kernels with analytical Ewald correction

The analytical Ewald kernels have been used in the CPU SIMD kernels, but
due to CUDA compiler issues it has been difficult to determine in which
cases does this provide a performance advantage compared to the
tabulated kernels.Although the nvcc optimizations are rather unreliable,
on Kepler (SM 3.x) the analytical Ewald kernels are up to 5% faster, but
on Fermi (SM 2.x) 7% slower than the tabulated. Hence, this commit
enables the analytical kernels as default for Kepler GPUs, but keeps the
tabulated kernels as default on Fermi.

Note that the analytical Ewald correction is not implemented in the
legacy kernels as these are anyway only used on Fermi.

Additional minor change is the back-port of some variable (re)naming and
simple optimizations from the default to the legacy CUDA kernels which
give 2-3% performance improvement and better code readability.

Change-Id: Idd4659ef3805609356fe8865dc57fd19b0b614fe


[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] Improved CUDA non-bonded kernel performance

Some old tweak which was supposed to improve performance had in fact
the opposite effect. Removing this tweak and with it eliminating
shared memory bank conflicts it caused improved performance by up
to 2.5% in the force-only CUDA kernel.

Change-Id: I7fcb24defed2c68627457522c39805afc83b3276


[PATCH] Improve performance of some mathematical functions


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

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


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

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


[PATCH] THUNDERX2T99: Performance fix for ZGEMM


[PATCH] Adjust serialized query buffer sizes (#2115) (#2117)

Adjust serialized query buffer sizes

This change the client/server flow to always send the server the
original user requested buffer sizes. This solves a bug in which with
serialized queries incompletes would cause the "server" to use smaller
buffers for each iteration of the incomplete query. This yield
decreasing performance as the buffers approached zero. The fix here lets
the server always get the original user's buffer size.


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

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

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


[PATCH] Removed FillSubcellsForNode, due to more efficient
 implementation where I add contributions for all nodes of a certain subcell.


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


[PATCH] More efficient CEED matrix assembly


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


[PATCH] Performance bug fix in single node case.


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

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


[PATCH] Use the Side<> class as a proxy when building element sides.
 This eliminates the need for allocating and deallocating connectivity storage
 arrays when building sides, thus making the Elem::build_side() member more
 efficient.  Note that this has not been implemented yet in the case of
 infinite elements, however it would be easy to add.  Assuming there are many
 more interior elements than infinite elements there is also probably little
 performance impact.


[PATCH] added fast global atom nr. to molecule lookup

Most atom search functions in mtop_util now use binary search.


[PATCH] More efficient IntegratorInternal::getDerivative for
 SXFunction #936


[PATCH] Simplify AVX integer load/store

Also has the potential to improve performance on some architectures
(if there is a domain crossing penalty - not sure whether any AVX capable
generation has a penalty).

Change-Id: Icc7b136571fc9ad1dbabeabe446c93e8816ec678


[PATCH] Implement a suggestion from cppcheck.

Using vector::empty() to check for emptiness, instead of vector::size()
== 0 may be better for performance, since it's guaranteed, to be 0(1).
Related to #30.


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


[PATCH] Use a priority queue (heap) to store the list of candidates
 while searching. This makes the code more efficient, especially when k is
 greater. For example, for knn, given a list of k candidates neighbors, we
 need to do 2 fast operations:  - know the furthest of them.  - insert a new
 candidate. This is the appropiate situation for using a heap.


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


[PATCH] 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] More efficient implementation of atoms class.


[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 size optimization to HashedMap

The table size in HashedMap is now optimized when calling clear()
using the old number of keys. Also the number of keys is now set
to a power of 2, so we can use bit masking instead of modulo.
The bit masking allows for negative keys, which is also tested.

This is preparation for replacing gmx_hash_t with HashedMap,
but also improves performance for gmx_ga2la_t.

Change-Id: I90c5a602cb7e213eb6d2e8259a0effc4fd7c4e14


[PATCH] minor changes for performance improvement and documentation


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


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


[PATCH] Use processor_id_type where appropriate

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

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


[PATCH] 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] QUDA: Overall of BLAS, better tuning, bugs fixed, fixed
 performance regressions, support for 32 way reductions, removed bank
 conflicts from complex and triple reductions

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


[PATCH] NVIDIA Volta performance tweaks

Removed ballot syncs and replaced all computed masks with full warp
mask (as all branches in question are warp-synchronous).
This improves performance by 7-12%.

Change-Id: I769d6d8f0d171eb528d30868d567624d5e246dbf


[PATCH] * Refactored stats * Fixed performance of multi-range
 subarray result estimation * Fixed bug in multi-range result estimation


[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] 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] 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] fast pool allocator

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


[PATCH] reactingMultiphaseEulerFoam: Added referencePhase option

In multiphase systems it is only necessary to solve for all but one of the
moving phases.  The new referencePhase option allows the user to specify which
of the moving phases should not be solved, e.g. in constant/phaseProperties of the
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed tutorial case with

phases (particles air);

referencePhase air;

the particles phase is solved for and the air phase fraction and fluxes obtained
from the particles phase which provides equivalent behaviour to
reactingTwoPhaseEulerFoam and is more efficient than solving for both phases.


[PATCH] performance optimizations for sgemv_n


[PATCH] Fixes for style and performance issues found by cppcheck


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


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


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


[PATCH] Use smaller block size on smaller system I/O - this seems to
 fix a performance problem found by Jens Lohne Eftang


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


[PATCH] 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] ReplicateMesh should only read once

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


[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] use fast insertion functions of arr


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


[PATCH] Some debug instrumentation and big performance improvements.


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


[PATCH] Use analysis nbsearch in insert-molecules

Advantages:
 - This reduces the amount of code by ~90% compared to what addconf.c
   has, making it significantly easier to understand.
 - Now the tool is independent of potential changes in the
   mdrun-specific neighborhood search.
 - Memory leaks related to addconf.c are gone.
 - The neighborhood search is terminated as soon as one pair within the
   cutoff is found, potentially making it faster. This likely offsets
   any performance differences between the nbsearch implementations.
   The unit tests are ~35% faster.
 - Confusing mdrun-specific output related to the neighborhood
   searching is gone. This includes notes that "This file uses the
   deprecated 'group' cutoff_scheme" and references to Coulomb or VdW
   tables and cutoffs.

Change-Id: Iba82858b9a2b43b6e10a49cd3964b99b22996166


[PATCH] Refactor parallel_algebra.h

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

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

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


[PATCH] Add performance improvement features to matrix loading.


[PATCH] Update RAS-IR.

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


[PATCH] Add SIMD intrinsics version of simple update

To get better performance in cases where the compiler can't vectorize
the simple leap frog integrator loop and to reduce cache pressure of
the invMassPerDim, introduced a SIMD intrinsics version of the simple
leap-frog update without pressure coupling and one T-scale factor.
To achieve this md->invmass now uses the aligned allocation policy
and is padded by GMX_REAL_MAX_SIMD_WIDTH elements.
Asserts have been added to check for the padding.

Change-Id: I98f766e32adc292403782dc67f941a816609e304


[PATCH] Add locks only for non-OPENMP multithreading

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


[PATCH] PERF: Anisotropic smoothing improvements (#2713)

This improves CUDA/OpenCL backend performance by about 24%


[PATCH] Use reference to improve performance in pair_reaxc_kokkos


[PATCH] performance fixes in fftconvolve kernels


[PATCH] replace patch routines that call scatter with more efficient
 ones; combine multiple ddots into one call to reduce no. of gops; added
 inheritance to print control


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


[PATCH] efficient jacobian of parallelizer, little speed penalty
 remaining


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

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

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

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

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

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


[PATCH] Fix performance regression with gcc-3.3


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


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

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

Change-Id: I1073801546fde23e6a53199120246697a7c61b5f


[PATCH] Sparse refactored readers: Better vectorization for tile
 bitmaps calculations. (#2711)

* 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] Use Traits::Vector to accelerate 2D optimization


[PATCH] general SIMD acceleration for angles+dihedrals

Implemented SIMD intrinsics for angle potential and pbc_dx.
Changed SSE2 intrinsics to general SIMD using gmx_simd_macros.h.
Improves performance significantly, especially with AVX-256
and reduces load imbalance, especially with GPUs.

Change-Id: Ic83441cce68714ae91c6d5ca2a6e1069a62cd2ae


[PATCH] Optimized the performance of the CG-based LPR algorithm


[PATCH] Improved performance of computing sums with CustomIntegrator


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


[PATCH] Tabulated function parameters are hardcoded in the kernel
 instead of being stored in an array.  This makes the code simpler and may
 help performance slightly.


[PATCH] fixed slow reading of large xvg files with LAM MPI


[PATCH] Avoid setting config on transient subarray (#2740)

For the existing `tiledb_query_add_range` APIs there is a transient
subarray object that is referenced. In one API the query config was also
being set on this subarray. This is not required, and other variations
of `tiledb_query_add_range` did not set the config. Removing this saves
a few seconds of the WALL time when a user is setting hundreds of
thousands of ranges.

The performance bottleneck comes in when the config is copied which is a
full copy of the config map. This was being done once per range setting.

Instead to maintain current behavior setting the query config also sets
the subarray config.


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


[PATCH] Parallel Performance bug in structure factor fixed for pspw.
 The new code works ok in serial, but still need to check parallel
 performance.

...EJB


[PATCH] More efficient SetNonzeros::propagateSparsities


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

for facets vertices
this should be a lot more efficient


[PATCH] fixed SD and BD integrator OpenMP performance

SD and BD integrator always integrated single threaded.
Really fixes #1121

Change-Id: I2217c40e9c188c7cd57801e413750035c6488f56


[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] 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] improve skylakex paralleled sgemm performance


[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] Made DD exclusion processing more efficient

With the Verlet scheme exclusions no longer need to be assigned only
once and there are no charge groups. This means the global to local
exclusion conversion can be more than twice as fast.

Change-Id: I80e1213715f051864d2989389212510428896cb8


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


[PATCH] Hard CPU affinity is set when Nthreads == Ncores.

This causes a slight thread_mpi performance gain on NUMA systems.


[PATCH] made changes which removed further operations and made CLJP
 and Falgout coarsenings more efficient


[PATCH] converted part of rhogen to daxpy getting performance
 improvement on ia64


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

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

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

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

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

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

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

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


[PATCH] Added a few lines regarding the GA array distribution but,
 only performance bug and results were still correct.


[PATCH] Update RAS-IR.

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


[PATCH] New traits classes for efficient handling of circles.


[PATCH] introducing info on elements in the overlap regions for more
 efficient calculation of the characteristic function (restriction to part of
 the mesh)


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


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


[PATCH] replace custom kdtree by a fast version of
 Orthogonal_k_neighbor_search


[PATCH] Fix false sharing in RandomNumber Pools

The pool arrays are accessed by all threads, but the
elements per thread are rather small and thus share cachelines.

Making the arrays 2D using the second dimension for padding only,
solves that problem. I have seen up to 200x improvement for
20 threads on skylake running the random number example with 100k and 1
as parameters. Serial performance is slightly reduced, but it only makes
the "grep a generator slower" by the equivalent of one double load more
and a few integer ops.


[PATCH] DynRankView: operator() performance improvements

Debug macros added to check active memory space, rank, and bounds
DynRankView: Simple performance test added
 compare performance to View and rank 7 View


[PATCH] Improve the performance of BoundingBox::contains_point by
 marking is_between as an inline function

3.28s  130:      if (bboxes[i_from].contains_point(*node + _to_positions[i_to]))

520ms  130:      if (bboxes[i_from].contains_point(*node + _to_positions[i_to]))


[PATCH] Removed unnecessary synchronization that hurt performance on
 Nvidia


[PATCH] slow draw of polyhedron_items fixed


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


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

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

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


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

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


[PATCH] Significant DBSCAN refactoring and improvements.

 - Use PARAM_MATRIX() instead of strings.
 - Add a single-point mode that handles RAM better.
 - Use UnionFind for much more efficient cluster finding.
 - Make --single_mode use the single point mode.


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

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

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


[PATCH] improved CUDA kernel performance by pre-loading cj

Change-Id: Ic725a82d550e2ecffd4d32edd2c44205aef99b8d


[PATCH] Fixed FAST memory leaks on CUDA backend


[PATCH] Reorder indices of Gamma_P_ia

This step increases spatial cache locality of the exchange of Gamma_P_ia. The increased locality increase the performance of its redistribution.


[PATCH] Improve performance for SYCL parallel_reduce


[PATCH] Using fast approximation for erfc instead of tabulated values


[PATCH] Improve performance of MIC exponential

The limited precision is due to argument scaling
rather than the exponential function lookup, so
instead of iterating we can improve the accuracy
with a simple correction step, similar to what
was done for the recent AVX-512ER implementation.

Change-Id: If55e7c4cefac5022e7211dfa56686cb9ee03a54a


[PATCH] MeshCommunication new_nodes methods

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


[PATCH] Fix Kokkos performance regression for small systems


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


[PATCH] accelerate distance queries for offset meshing


[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] Added more constructors, for more efficient handling of
 circles with rational radii.


[PATCH] more efficient comparison function

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


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


[PATCH] PERF: Improve performance for sort_by_key

- Has added benefit of cutting build times by half


[PATCH] Improve the performance of sending the AmoebaVdwLambda to
 Cuda using pinned host memory; Updated the AmoebaVdwForceProxy to version 3,
 and added backward compatibility to version 2; updated TestAPIUnits.py to
 handle the per particle lambda flag


[PATCH] Adding the ability to convert the dist rank, cross rank, and
 redundant rank for a particular distribution to the VC rank and subsequently
 making use of this to improve the performance of the GetSubmatrix routine for
 AbstractDistMatrix


[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] Fixed the bug where dumping distribution file would decrease
 the performance


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

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


[PATCH] small performance optimization for pair style comb


[PATCH] Tabulated log(x) to improve GB performance


[PATCH] small performance improvement for nbnxn SSE kernels


[PATCH] Converts PADiffusionSetup3D and
 QuadratureInterpolator::Eval3D kernels from 1 element per thread to 1 qpt/dof
 per thread for better performance when offloading (there are not enough units
 of work with 1 element/thread)


[PATCH] Performance improvements and fixed bug with memory budget and
 multi-range subarrays


[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] improved load balancing on the GPU

For the GPU, small pair list entries are now sorted to the end.
The improves performance by 5 to 20%.

Change-Id: I25e5efeb813ad5dde48f0955366519db699f21a2


[PATCH] Clean up and use fast pool allocator (faster)


[PATCH] Slightly improved performance, and small refinements


[PATCH] Performance optimization of Tokenizer

Reduces string allocations and removes std::vector from Tokenizer
Most processing now happens on-demand.


[PATCH] Small improvements for readability and performance


[PATCH] Issue #2056 More efficient mapped evaluation


[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] Adjust s3 multi-part locking to unlock early

This switches from iteraters to using find + at to take references to
the state objects for manipulations. This allows us to release the S3 class
level locks earlier and faster removing performance bottlenecks.


[PATCH] Speedup of kernel caching mechanism by hashing sources at
 compile time (#3043)

* Reduced overhead of kernel caching for OpenCL & CUDA.

The program source files memory footprint is reduced (-30%) by eliminating
comments in the generated kernel headers.  Hash calculation of each source
file  is performed at compile time and incrementally extended at runtime
with the options & tInstance vectors.  Overall performance increased up to
21%, up to the point that the GPU becomes the bottleneck, and the overhead
to launch the same (small) kernel was improved by 63%.

* Fix couple of minor cmake changes

* Move spdlog fetch to use it in bin2cpp link command

Co-authored-by: pradeep <pradeep@arrayfire.com>
(cherry picked from commit 3cde757face979cd9f51a4c01bd26107e69e4605)


[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] 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] Enhancement: replace SQRT and POW by more efficient
 computations


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


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


[PATCH] More efficient SystemBase::reinit, flux_jump indicator should
 work but needs testing

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


[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] Improve implementation of cycle subcounting

Configuring with GMX_CYCLE_SUBCOUNTERS on is intended to make active
some counters that show finer-grained timing details, but its
implementation with the preprocessor was more complex and more bug
prone than this one. Static analysis now finds the bug where we
over-run buf (fixed here and in release-5-1).

The only place we care about performance of the subcounter
implementation is that it doesn't do work when GMX_CYCLE_SUBCOUNTERS
is off, and constant propagation and dead code elimination will handle
that.

Also moved some declarations into the blocks where they are used.

Change-Id: I3d7a06a65c636c11557a094997a7a81f86a1ed8a


[PATCH] finally fixed a major performance bug. New implementation now
 slightly faster than multiple on old implementation


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


[PATCH] OPENCL: Disabling greedy assignment for csrmm and csrmv

- Was causing performance issues on intel and amd devices


[PATCH] Replace SIMD copy patch routine to obtain better parallel
 performance


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


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

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


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


[PATCH] implemented more efficient Ruge-coarsening


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


[PATCH] Added an efficient parallel version of the ADMM linear
 program solver of Boyd et al.


[PATCH] Improved OpenCL SIFT coalescing and performance


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


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


[PATCH] - Added the ability to add points on a sphere outside the
 domain in the sequential case => better performance for the fandisk model
 (x2). I'm still wondering why... - Code refactoring/clean-up


[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] When need to realloc, double the size.  This is more
 efficient if the ultimate size is very large.


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


[PATCH] Improved performance on AMD GPUs


[PATCH] fixed GPU particle gridding performance issue

The scaling factor for the grid binning for the GPU pair search
was set incorrectly, which made the binning 50% slower.

Change-Id: I146592c37094a3d81a7ae50b3903fcc615e748d5


[PATCH] Acquire BC lists outside the CheckPointIO id loop

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


[PATCH] Try to use inline in boxDimension class to increase the
 performance


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

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

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


[PATCH] Optimize multi-fragment unfiltering, part 1 (#1692)

This patch improves the execution time of the attribute unfiltering path.

```
// Current
Total read query time (array open + init state + read): 15.0957 secs
  Time to unfilter attribute tiles: 8.86625 secs
```

```
// With this patch
Total read query time (array open + init state + read): 7.32202 secs
  Time to unfilter attribute tiles: 1.80354 secs
```

The issue is that the destruction time of `forward_list` is obscenely
slow within my OSX environrment. On the Linux environment that I
originally wrote this in, the `forward_list` did not cause a performance
problem. This patch just replaces the `forward_list` with a `vector`.

I have titled this as a "part 1" because I have tentatively explored
multi-threading the `unfilter_tiles` path and have observed a speedup.
More on this later.

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


[PATCH] Replaced LU by QR decomposition.

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

Related to #59.


[PATCH] POWER10:  Change dgemm unroll factors

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


[PATCH] Fixing Performance Bug with Atomics

Calling templated versions of atomics will prevent matching of
non-templated code, thus it would never call the optimized atomic
routines. This effected in particular atomic increment and decrement.


[PATCH] Core: Atomic Performance Test Reduce Loop count

This was taking to long, reduced the loop count.


[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] Improved the performance of the gmx_sum routines on cluster
 with multi-core nodes by using a two step communication procedure


[PATCH] slight performance improvement for 4x4 search


[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] Parallelize closing of files on write

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


[PATCH] CUDA nb kernel performance improvement for CUDA 4.1

The manual unrolling of the jm4 loop improves somewhat the performance
of the nobonded CUDA kernels, but there is still a 5-7% performance
regression with CUDA 4.1 compared to 3.2/4.0.