[PATCH] Introduced python typemaps for std::vector<int>,
 std::vector<double>.

Was having difficulties with 5-argument DMatrix constructor and numpy. Does seem to slow down compilation and linking significantly (factor 2?).


[PATCH] Performance optimization of Tokenizer

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


[PATCH] More efficient SetNonzerosSlice::evaluate


[PATCH] Fix performance bug when LDC is a multiple of 1024


[PATCH] #1285 Refactred substituteInPlace. Now more efficient and has
 same signature for SX and MX.


[PATCH] Policy performance tests: Added test and sample scripts

This commit address Github issue #737
RangePolicy and TeamPolicy tests with nested parallelism added for
benchmarking performance - e.g. compare master vs develop

policy_performance: add functor for parallel_scan


[PATCH] MDRange: Refactored HostIterateTile to use macros

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


[PATCH] 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] Fix input ndims validation in fast,orb,sift


[PATCH] Remove OpenMP compile flag in CUDA backend

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

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


[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 1/9] Update all versions to v1.1.1.


[PATCH] Update performance test case (to use polar_decomposition)
 Make polar default closest rotation computer


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


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


[PATCH] Added FAST feature detector example


[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] Code cleanup in swapcoords.cpp

For ion/water position exchanges with DD, the positions of the ion group,
the split group 0 and the split group 1 are assembled into an array known
on all processors (g->xc). Only if ion/water exchanges need to be done, the
positions of the solvent group need to be assembled as well.

Before this patch, the group index ran from 0 to eGrpNr, so therefore also
the solvent group positions were assembled in every swap step. This was
superfluous since they would be assembled again if bSwap is TRUE.

If the swap protocol is called very frequently (nstswap << 100), the
performance impact is now smaller.

Change-Id: I8eff6bbd33810d6641ec97aa00a537fe782214d3


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


[PATCH] Bring performance estimation up to date

The performance estimation code for estimating the PME/PP load
and the optimal DD grid setup used outdated numbers.
We now estimate using actual cycle counts on Haswell and esimate
for other architectures through a scaling factor that takes into
account the SIMD width and FMA.
The DD grid automation now ignores PBC cost for exclusions with
the Verlet scheme and the for angles and dihedrals with SIMD.

The effect of this is a more reliable PME load estimate that's
now a factor 1.4 to 1.7 higher on Haswell.
The DD grid automation will now often choose a setup that better
matches the PME `decomposition and reduce the PME redist cost.

Change-Id: I5daa6a6856f2b09ba6d17fda0eea800b816d21e4


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

* Performance improvments to CPU Anisotropic Diffusion

(cherry picked from commit a4713f1aa102ad693129086bfdb9aa2a9d2fb1f7)


[PATCH] Made some performance improvements and fixed a bug when
 running on a single processor but compiled with mpi.


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


[PATCH] Updated article reference. Added configuration flags to
 support altivec on powerpc. Updated configuration files from gnu.org Removed
 the fast x86 truncation when double precision was used - it would just crash
 since the registers are 32bit only. Added powerpc altivec innerloop support
 to fnbf.c Removed x86 assembly truncation when double precision is used - the
 registers can only handle 32 bits. Dont use general solvent loops when we
 have altivec support in the normal ones. Added workaround for clash with
 altivec keyword.


[PATCH] The test was too slow in Debug mode


[PATCH] macos accelerate does not contain dcombossq


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

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


[PATCH] Refactor threading model (#1766)

* Refactor threading model

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

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

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

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

* Recursive ThreadPool::execute() (#1772)

Currently, we break recursive deadlock in the ThreadPool:wait*() routines. This
works well for the type of "execute-and-wait" model we use. For instance:
```
ThreadPool tp;
auto task = tp.execute(...);
tp.wait_all(task);
```

We are currently unable to break recursive deadlock if the threadpool user does
not use our "wait" routine. For instance:
```
condition_variable cv;
auto task = tp.execute([&]() {
  cv.signal_all();
});
cv.wait(...);
```

The S3 client uses the above style of synchronization. With our compute/io
threadpool refactor, we encounter recursive deadlock. This patch allows breaking
recursive deadlock on the call to ThreadPool::execute().

With this patch, ThreadPool::execute() checks if 1) the calling thread belongs
to the thread pool instance and 2) all other threads are non-idle.

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

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


[PATCH] Use more efficient iterators in MeshCommunication


[PATCH] More performance tweak in Monte Carlo sampling.


[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] Remove RangeSet, DenseIntMap, and fast allocation routines.
 They were not used anywhere.


[PATCH] Adding Changelog for Release 3.4.01

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.4


[PATCH] new, more efficient jacobian calculation for integrator


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


[PATCH] Fix performance regression in KOKKOS package


[PATCH] Added DefaultInitializationAllocator

Added an allocator that can be used to default initialize elements
of a std::vector on resize(). This is useful to avoid initialization
in performance critical code.

Change-Id: I65bd52a760c68c73555e8bb9e017de353a6e9a81


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


[PATCH] 128-bit AVX2 SIMD support

Add 128 bit support for AVX2. Similar to AVX-128, this
improves slightly on SSE2 due to more efficient instructions,
and the shorter SIMD width is beneficial in some cases. Both
128- and 256-bit flavors will be built automatically with
--enable-avx2, and the timing routines will chose the best one
automatically.


[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] changed the redistribution to x/y/z only moves, which
 improves the performance for especially 3D decomposition


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

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

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


[PATCH] fixed performance print when run is terminated or with
 minimizers


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


[PATCH] bug fixes in double_conic, minor performance improvements


[PATCH] New bench for comparing sweep performance


[PATCH] Use a separate Performance log line for compute_affine_map


[PATCH] More extensive performance logging of the Kelly Error
 Estimator.


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


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


[PATCH] ranks/device changed from 2 to 1. Value of 2 doubles memory
 usage (and hits MPOSS bugs) but does not help with performance


[PATCH] Jan 29 1999	Calls to Robert's fast esp routines


[PATCH] Converted lots of ints to unsigned ints (might help
 performance a little by avoiding conversions)


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

See Andreas' e-mail:

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

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

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


[PATCH] Fixed performance bug in mixed precision


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


[PATCH] 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] - 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] Call to  change_notf->update_all_faces(result, a1, a2), which
 is the notifier function updating all the faces features. This was added
 since the Map overlay should use from now on the Post precessing notifier,
 rather then the In processing notifier, since the former is more efficient
 than the latter.


[PATCH] Working on the performance tests


[PATCH] Add example for distributed spmv scaling performance


[PATCH] fixed SD and BD integrator OpenMP performance

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

Change-Id: I2217c40e9c188c7cd57801e413750035c6488f56


[PATCH] Test show an improvement in octree performance


[PATCH] Changed FFTW warning from AVX to no SSE

Changed the cmake FFTW SIMD check warning from complaining about
AVX to complaining about missing SSE or SSE2.
With FFTW 3.3.4 the performance of FFTW with both SSE and AVX enabled
is often a bit better and never much worse than SSE along. Newer
Intel processors probably also perform better with AVX with FFTW 3.3.3
so we should not complain about the combination of SSE(2) and AVX,
but only when SSE is missing.

Change-Id: I3665a35ec98616f015d05e314c8fbb80a8862092


[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] use integer and reduce the number of tests

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


[PATCH] 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] Remove mdrun -testverlet

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

Fixes #1424

Change-Id: I589a8e316beeba6819cd01d9655bfc069bcbb174


[PATCH] Added ODE diagnostics to FixRxKokkos using Kokkos managed
 data.

- Added the diagnostics performance analysis routine to FixRxKokkos
  using Kokkos views.
TODO:
  - Switch to using Kokkos data for the per-iteration scratch data.
    How to allocate only enouch for each work-unit and not all
    iterations? Can the shared-memory scratch memory work for this,
    even for large sizes?


[PATCH] Finished initial implementation for arbitrary sizes atomic
 operations

This implements atomic operations for arbitrarily sized objects.
The implementation uses a hash table approach, where a lock is set
based on a hash of the memory address of the object for which an
atomic operation should be performed.
Initial performance results indicate that it is comparable to
other non-native atomics (i.e. CAS loops with casting to integer
types).
The commit implements the full set of supported atomics from
Kokkos and it works in all currently existing execution spaces.
The hashtables are static sized global arrays.

Note: this commit requires relocatable-device-code being
enabled for Cuda.


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


[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] 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] 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] added early quit option to accelerate distance vs user
 defined distance check


[PATCH] Guard performance test which uses Lambda dispatch #821


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


[PATCH] Serial-only atomics implementation

[#607] [#549]
A few details:
 - Accepting volatile pointers was necessary
   for compatibility with existing calls which
   pass in volatile pointers, hence the const_cast
 - Special implementations of atomic_increment
   were needed to get equal performance in the
   one application I tested (it was doing its
   own serial special cases before).
 - Compilers have a harder time matching templates
   as opposed to overloads, so some call sites
   had to be modified to specify the scalar
   type explicitly


[PATCH] s390x: Use new sgemm kernel also for strmm on Z14 and newer

Employ the newly added GEMM kernel also for STRMM on Z14. The
implementation in C with vector intrinsics exploits FP32 SIMD operations
and thereby gains performance over the existing assembly code. Extend
the implementation for handling triangular matrix multiplication,
accordingly. As added benefit, the more flexible C code enables us to
adjust register blocking in the subsequent commit.

Tested via make -C test / ctest / utest and by a couple of additional
unit tests that exercise blocking.

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


[PATCH] Added parentheses to performance logging messages

git-svn-id: file:///Users/petejw/Documents/libmesh_svn_bak@1518 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] Remove use of omp 5.0 feature

omp_init_lock_with_hint is an OpenMP 5.0 feature.
This is not significant from a performance perspective.


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

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


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


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


[PATCH] fix internal/external OpenMP thread affinity clash

Thread affinity set by the OpenMP library, either automatically or
requested by the user through environment variables, can conflict with
the mdrun internal affinity setting.
To avoid performance degradation, as Intel OpenMP has affinity setting
on by default, we will explicitly disable it unless the user manually
set OpenMP affinity through one of the KMP_AFFINITY or GOMP_CPU_AFFINITY
environment variables. If any of these variables is set, we honor the
externally set affinity and turn off the internal one.

Change-Id: I78c6347154d6f11695ee04243db17bbb2e5cb0a7


[PATCH] Cherry-picking changes on top of our current hash. There are
 things that hurt performance in laster mfem@master commits, not sure what
 yet.

This includes:
- feature/artv3/cusparse-Spmv
- feature/tomstitt/temp-mem-type
- patches to tmop.cpp and tmop_tools.cpp to address memory issues
- patch to mem_manager/device to use mfem's default allcator instead of
the host umpire one


[PATCH] Coordinate Propagators

This change introduces the propagator element, which, thanks to templating,
can cover the different propagation types used in NVE MD. The combination
of templating, static functions, and having only the inner-most operations in
the static functions allows to have performance comparable to fused update
elements while keeping easily reordable single instructions.

Note that the two velocity update functions are only necessary to allow
exact replication of the legacy do_md code for both md and md-vv. The
parentheses or the lack thereof lead to numerical errors which build up very
rapidly to make the (very strict) integrator comparison test fail. Relaxing this
condition will make getting rid of one of the two variants possible.

An interesting further development would be to unify the OpenMP loops for
coordinate propagation and constraining by using loops over constraint
groups in both cases.

Change-Id: I1a1f66f1efe63c791ef3fe51ce2f99da3367adca


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


[PATCH] Fast transfers and diffusion kernels


[PATCH] performance optimizations for sgemv_n


[PATCH] Use vector in atoms2md instead of pointer

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


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


[PATCH] performance are getting better with grid_nbfm


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


[PATCH] Tightening default tolerances on the ADMM algorithms where
 possible (the linear program solver was kept the same due to its slow
 convergence rate).


[PATCH] Changed the way hardwall works.

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

Change-Id: I3208519d8704da622b81835604249771d634a28a


[PATCH] Avoiding redundant metadata calculations in order to
 accelerate AbstractDistMatrix::QueueUpdate and
 AbstractDistMatrix::ProcessQueues (as well as generalizing
 AbstractDistMatrix::ProcessPullQueue to support not including 'viewer'
 processes)


[PATCH] Grid-based utility nbsearch implementation.

More efficient implementations are possible, but the present one should
work reasonably well in most cases, also for triclinic cells, without too
much complexity.


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


[PATCH] Use CUSPARSE_CSRMV_ALG2 for seemingly better performance


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

This causes a slight thread_mpi performance gain on NUMA systems.


[PATCH] Add performance graph for region growing


[PATCH] Due to decrease in code performance, calculation of pressure
 tensor for W12, W13, W23 is commented out and in log file only the diameter
 of pressure tensor W11, W22, W33 will be printed. In case if those
 calculation are required, they need to be uncommented.


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


[PATCH] - Performance issue, in Standard_criteria.h:   Quality were
 not defined correctly, and then facets were not ordered   correctly, in the
 Double_map.


[PATCH] AMOEBA uses fast approximation for erfc()


[PATCH] dgemm: Use the skylakex beta function also for haswell

it's more efficient for certain tall/skinny matrices


[PATCH] additional precomiler command for performance testing


[PATCH] Add basic list of performance factors to tutorials.


[PATCH] log_name would be unused without perf_log on

So if we're not performance logging, we need to comment out that
variable entirely to avoid an unused variable warning.


[PATCH] Use Evaluate(const arma::mat& parameters) instead of
 Evaluate(const arma::mat& parameters, const size_t i) to calculate the
 objective and to accelerate the evaluation process.


[PATCH] Use more accurate error message.

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

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

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


[PATCH] Update CUDA Performance Tests for Stream interoperability


[PATCH] Adding Changelog for Release 3.2.01

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.2


[PATCH] attempt to reduce the negative performance impact of adding
 the shift option


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


[PATCH] Reduce dataset sizes and number of iterations to accelerate
 tests.


[PATCH] Add TypeTensor::solve().

This is slightly more efficient than inversion followed by multiplication.


[PATCH] Reduce number of points to accelerate test.


[PATCH] Remove BoundaryInfo::n_boundary_ids(elem, side) copy/paste
 job.

It was basically an exact copy of the now-deprecated
BoundaryInfo::boundary_ids(elem, side).  Reusing the set filling code
might be *slightly* less efficient, but I think the savings in
maintainability and readability is worth it...


[PATCH] Some performance issues due to profiling


[PATCH] fast nary union in OFF2nef3 also constructor finds more
 problems and handles them


[PATCH] Disable CUDA textures on NVIDIA Volta

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

Partially addresses #3845


[PATCH] Override any OpenCL fast math JIT settings for
 born/coul/wolf{/cs}/gpu to resolve numerical deviations seen with some OpenCL
 implementations.


[PATCH] Added test to log the performance of the periodic Delaunay
 triangulation


[PATCH] GEMM: skylake: improve the performance when m is small


[PATCH] Improved FAST performance on CUDA backend


[PATCH] Worked on the performance of point location.


[PATCH] Use std::make_shared instead of new...

It is more efficient, since it requires only one memory allocation in
contrast to two.


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


[PATCH] BJP: Changed determination of io procs so that IO is more
 efficient for single files using parallel IO.


[PATCH] implemented plain-C SIMD macros for reference

This is mainly code reorganization.
Adds reference plain-C, slow, arbitrary width SIMD for testing.
Adds FMA for gmx_calc_rsq_pr.
Adds generic SIMD acceleration (also AVX or double) for pme solve.
Moved SIMD vector operations to gmx_simd_vec.h
The math functions invsqrt, inv, pmecorrF and pmecorrV have been
copied from the x86 specific single/double files to generic files
using the SIMD macros from gmx_simd_macros.h.
Moved all architecture specific nbnxn_kernel_simd_utils code to
separate files for each SIMD architecture and replaced all macros
by inline functions.
The SIMD reference nbnxn 2xnn kernels now support 16-wide SIMD.
Adds FMA for in nbnxn kernels for calc_rsq and Coulomb forces.

Refs #1173

Change-Id: Ieda78cc3bcb499e8c17ef8ef539c49cbc2d6d74d


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


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


[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] added the hybrid PCG solver which uses diagonal scaling first
 and switches to AMG if convergence too slow, solver 20


[PATCH] Fix CUDA architecture dependent issues

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

Change-Id: I1f911caad85eb38d6a8e95f3b3923561dbfccd0e


[PATCH] JN:  Solaris uses now PTR_ALIGN for performance and
 compatibility with JN:  different compilers


[PATCH] Improving performance of BigInt/BigFloat routines (such as
 Cholesky) by more than a factor of three by avoiding allocations within the
 templated BLAS routines


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


[PATCH] * Refactored stats (#1594)

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


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


[PATCH] Made gmx_numzero static for performance reasons.


[PATCH] fixed a horrendously inefficient minibatch implementation.
 now the cardinality-k-index-set sampler (sampling without replacement) is
 very efficient


[PATCH] fixed bug in CRSSparsity append, now efficient concat


[PATCH] Make jenkins own-fftw verify use local tarball

We should not bombard the FFTW servers with downloads, plus these can be
relatively slow too, so use our local ftp server instead.

Change-Id: Id6ccebf0ac1ae6410cd4f7f13f2ff76d275af5d2


[PATCH] THUNDERX2T99: Performance fix for ZGEMM


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


[PATCH] skylake dgemm: Add a 16x8 kernel

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


[PATCH] Separate CPU NB kernel and buffer clearing subcounters

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

Change-Id: Ifb2b4b3e5a43ac2ee547da651f9432a22fe58421


[PATCH] Evaluating Tom Forsyth's fast mesh reordering.


[PATCH] Avoid confusing message at end of non-dynamical runs

EM, TPI, NM, etc. are not targets for performance optimization
so we will not write performance reports. This commit fixes
and oversight whereby we would warn a user when the lack of
performance report is normal and expected.

Fixes #2172

Change-Id: I1097304d79701be748612510572382729f7f26be


[PATCH] Clang-tidy: enable further tests

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

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

Change-Id: I5b35ce33e723349fa583f527fec55bbf29a57508


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


[PATCH] Python 3 does not have dict.itervalues

Really we should move to using six and importing the iterator versions of dict
methods and range/zip from there, but for now just use "values" since using a
raw list doesn't seem like it will cause memory or performance problems here.


[PATCH] Revert "Adding a Fast configuration"

This reverts commit 091cdf9143a944784c5e35671927509d4f8b3d70.


[PATCH] PERF improvements and bugfixes for select and replace

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


[PATCH] removed explict assigment of BLASOPT=-mkl for MACX64. Iprefer
 have the slow blas baseline by default for generic users


[PATCH] -Mvect option causes severe performance problems with
 R1.2.5.1 on Paragon


[PATCH] Fix performance unnecessary copy initialization


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

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

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

Fixes #3584.


[PATCH] 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] Introduce GMX_USE_SIMD_KERNELS cmake option

Most GROMACS development does not need to recompile the SIMD nbnxm
(and fep) kernels whenever their dependencies change. These
dependencies are large in number, and include frequently changed
files, including config.h and various utility and nbnxm module
headers. This flag permits people to efficiently recompile while
working on code that doesn't directly target changes to the SIMD
kernels.

It also means that CI builds not aimed at efficient mdrun execution
times can instead minimize compilation times and ccache db sizes. This
will also have the side effect of testing more of the reference NBNXM
kernels.

There's other SIMD code (particularly PME, bonded, LINCS, update)
which still compiles and runs in the usual way. Currently these are
less costly to compile and harder to disable. That could change in
future.


[PATCH] Domain decomposition and PME load balancing for modular
 simulator

This change introduces two infrastructure elements responsible for
domain decomposition and PME load balancing, respectively. These
encapsulate function calls which are important for performance, but
outside the scope of this effort. They rely on legacy data structures
for the state (both) and the topology (domdec).

The elements do not implement the ISimulatorElement interface, as
the Simulator is calling them explicitly between task queue population
steps. This allows elements to receive the new topology before
deciding what functionality they need to run.

This commit is part of the commit chain introducing the new modular
simulator. Please see docs/doxygen/lib/modularsimulator.md for details
on the chosen approach. As the elements of the new simulator cannot all
be introduced in one commit, it might be worth to view Iaae1e205 to see
a working prototype of the approach.

Change-Id: I1be444270e79cf1391f5a228c8ce3a9934d92701


[PATCH] More efficient CEED matrix assembly


[PATCH] Add an example to show how to debug performance with loggers.


[PATCH] Moving coord_string from returning a std::string to
 std::string_view. (#2704)

The coord_string function is used in a lot of performance critical paths.
Moving it to return a string_view as none of these paths benefit from
making a copy of the value.


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

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

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


[PATCH] Added parentheses to performance logging messages


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

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

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

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

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

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


[PATCH] Residuals: New MeshObject class to store solver performance
 residuals

This is more efficient and modular than the previous approach of storing the
residuals in the mesh data dictionary.


[PATCH] Fix performance for resize, and deep_copy


[PATCH] s390x: for clang use fp-contract=on instead of fast

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

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


[PATCH] Add task dag performance test based upon fibonnaci


[PATCH] thermophysicalModels::coefficientWilkeMultiComponentMixture:
 New Wilke mixing model for gaseous transport properties

The new generalised framework for thermophysical mixing models has allowed the
efficient implementation of the useful combination for gases of coefficient
mixing for thermodynamic properties with the Wilke model for transport
properties:

Description
    Thermophysical properties mixing class which applies mass-fraction weighted
    mixing to the thermodynamic coefficients and Wilke's equation to
    transport properties.

    Reference:
    \verbatim
        Wilke, C. R. (1950).
        A viscosity equation for gas mixtures.
        The journal of chemical physics, 18(4), 517-519.
    \endverbatim


[PATCH] Improve general performance, set up 1-attribute, fix
 correspondence issue between original and copied map


[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] Shape smoothing: some comments added to accelerate matrix
 construction. Konstantinos: this is what is so slow, not the solver!


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


[PATCH] Add functions to Quantity to compute the max, min, standard
 deviation (as the sqrt of the variance), and average, returning a Quantity
 with the proper units.

This should be reasonably efficient, as it takes advantage of numpy-accelerated
methods if they're present.


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


[PATCH] Removed AVX code, since it had very little effect on
 performance and would have required a more complicated build process.  Also
 worked around a compilation error with clang.


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


[PATCH] Use non caching segment traits to accelerate arrangement
 computations


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


[PATCH] Accelerate L-BFGS with a couple of tricks.

1. Function objective calculation after optimization isn't needed.
2. minPointIterate isn't actually used anywhere, so get rid of it.
3. Return best result from line search, not the last result.

Also I cleaned up a few no-longer-needed sections of code and simplified a few
lines.


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


[PATCH] New thread_mpi library: waits now yield to the OS scheduler
 without significant performance penalty.


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


[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] Various cleanup in Kokkos SNAP, replacing verbose Kokkos
 MDRangePolicy and TeamPolicy types with simpler `using` definitions. No
 performance implications.


[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] finally fixed a major performance bug. New implementation now
 slightly faster than multiple on old implementation


[PATCH] Keep COARSEN_INACTIVE flags in sync in corner case

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

This is the safest solution, though.


[PATCH] More efficient implementation of atoms class.


[PATCH] Made a pass on Performance tutorials in docs.


[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] problem with c-macro? but slow fabs works fine


[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] Greatly improved the performance of copy::GeneralPurpose by
 exploiting the tensor product structure of the integer metadata calculations


[PATCH] add generic Mac toolchain file

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

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

the BLAS/LAPACK used is "-framework Accelerate"


[PATCH] Implement OpenCL support

StreamComputing (http://www.streamcomputing.eu) has implemented the
short-ranged non-bonded interaction accleration features previously
accelerated with CUDA using OpenCL 1.1. Supported devices include
GCN-based AMD GPUs and NVIDIA GPUs.

Compilation requires an OpenCL SDK installed. This is included in
the CUDA SDK in that case.

The overall project is not complete, but Gromacs runs correctly on
supported devices. It only runs fast on AMD devices, because of a
limitation in the Nvidia driver. A list of known TODO items can be
found in docs/OpenCLTODOList.txt. Only devices with a warp/wavefront
size that is a multiple of 32 are compatible with the implementation.

Known issues include that tabulated Ewald kernels do not work (but the
analytical kernels are on by default, as with CUDA), and the blocking
behaviour of clEnqueue in Nvidia drivers means no overlap of CPU and
GPU computation occurs. Concerns about concurrency correctness with
context management, JIT compilation, and JIT caching means several
features are disabled for now. FastGen is enabled by default, so the
JIT compilation will only compile kernels needed for the current
simulation.

There is some duplication between the two GPU implementations, but
the active development expected for both of them suggests it is
not worthwhile consolidating the implementations more closely.

Change-Id: Ideaf16929028eb60e785feb8298c08e917394d0f


[PATCH] Add performance improvement features to matrix loading.


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

Change-Id: Ic725a82d550e2ecffd4d32edd2c44205aef99b8d


[PATCH] Restore wallcycle subcounter name to "Bonded F"

This makes it easier to check for performance behaviour

Change-Id: Icb67bd75ee58fe280beb9f1cb123d0eeca229f09


[PATCH] Improving the performance of the HessenbergSchur QR sweeps


[PATCH] Update management of linear algebra libraries

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

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

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

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

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

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

Refs #771,#1186

Change-Id: Ife5c59694e29a3ce73fc55975e26f6c083317d9b


[PATCH] Changed the performance test application


[PATCH] Improved ORB performance and memory usage on CUDA backend


[PATCH] Hopefully improve singledot performance


[PATCH] POWER10: Improve dgemm performance

This patch uses vector pair pointer for input load operation
which helps to generate power10 lxvp instructions.


[PATCH] more efficient way to display a combinatorial map


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

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


[PATCH] SMD multi step added with fast Hv product in main


[PATCH] fast pool allocator

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


[PATCH] BJP: Initial checkin of test program for performance
 evaluation of DRA routines in 3 dimensions.


[PATCH] added synchs for main events again. this may have a negative
 performance influence in some case. such cases should however be really rare.
 otherwise, these events make no sense without a sync. imagine a master rank
 which is not at the interface


[PATCH] Issue #2779 Ensure outputs up-to-date before linearization
 Not sure if this adds overhead and, if so, can be replaced by something more
 efficient


[PATCH] Remove BoundaryInfo::n_edge_boundary_ids(elem, side)
 copy/paste job.

It was basically an exact copy of the now-deprecated
BoundaryInfo::edge_boundary_ids(elem, side).  Reusing the set filling code
might be *slightly* less efficient, but I think the savings in
maintainability and readability is worth it...


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


[PATCH] small performance optimization for pair style comb


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


[PATCH] chasing the performance issue on the aump2 QA test


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


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


[PATCH] Stage bonded kernel atomics through shared memory

Fixes performance bug introduced in 01b2f20bd5 by staging energy step
atomics through shared memory rather than have all threads write
atomically directly to global memory.

Fixes #3443


[PATCH] Added preconditions and made it more efficient


[PATCH] completed adding of support point indices, made remark on
 buggy setup of problem in fast and exact case


[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] Allow Gromacs to run on more than 64 threads by default

Avoids Gromacs dying on machines when starting more than 64 threads,
which is getting more common today - including our own tests.

This increases the default (hard) OpenMP thread limit from
64 to 128, since at least Roland has not seen any performance
drawbacks from that.

Second, we no longer attempt to start more threads than Gromacs
has been configured for. In principle it would have been cleanest
to limit gmx_omp_get_max_threads() to GMX_OPENMP_MAX_THREADS,
but unfortunately the first value is used to detect the total
number of threads for all ranks, while the latter is rather used
as a limit for the number of threads to start inside each rank.
All this threading code needs to cleaned up later, but to avoid
severely limiting MPI parallelism on these machines, for now we
instead need to apply the limit once we have adjusted for the
number of ranks in the higher-level routine.

Closes #4370.


[PATCH] add comment regarding OpenMP performance


[PATCH] wallDist/patchDistMethods/Poisson: New method for fast
 calculation of an approximate wall-distance field by solving Poisson's
 equation


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


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


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

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


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

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


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

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

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

fixes #1682


[PATCH] Only use AVX512 in own-FFTW if GROMACS also uses it

Building the own FFTW with AVX512 enabled for all AVX-flavors means that
an AVX2 build can end up loosing a significant amount of performance due
to clock throttle if the FFTW auto-tuner inadvertently picks and AVX512
kernel. This is not unlikely as measurements at startup are very noisy
and often lead to inconsistent kernel choice (observed in practice).

Change-Id: I857326a13a7c4dd1a6f5ab44360211301b05d3ac


[PATCH] some performance stuff (matrix products)


[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] Threw away the manual text-parsing, xml parser is fast enough


[PATCH] Add the NeighborSearchRules class, which defines how the
 SingleTreeDepthFirstTraverser can perform a NeighborSearch.  Adapt the
 NeighborSearch class to use this.  It is not as fast as it could be.


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


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


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


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


[PATCH] clang-tidy: more misc+readability

Auto fixes:
misc-macro-parentheses
readability-named-parameter

Enabled with few violations disabled by configuration:
misc-throw-by-value-catch-by-reference
readability-function-size

Set clang-tidy checks as list to allow comments.

Refactored the operator <<< used by GMX_THROW to take the exception by
value and return a copy, which is easier for tools to see is a proper
throw-by-value (of a temporary).  Performance on the throwing path is
not important, but is anyway not affected because the inlining of the
operator allows the compiler to elide multiple copies. This also
avoids casting away the constness.

Change-Id: I85c3e3c8a494119ef906c0492680c0d0b177a38d


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


[PATCH] Reword CPU/GPU imbalance notes

Changes text in CPU/GPU imbalance from "performance loss" to "wasting
resources", since in some cases one can not get higher performance.
Replaced "GPU has less load" by "CPU has more load".
Removed hint to reduce the cut-off, since one often can not do this.
Note that with CUDA all theses notes are never printed, since we no
longer have timings on (by default), unlike with OpenCL.

Fixes #2253

Change-Id: Ib4a9752ad27c1cd2a3cd751a217249694a56d3b7


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


[PATCH] Speed up a slow test case by using a smaller topology file


[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] AABB tree: more on internal KD-tree used to accelerate the
 distance queries.


[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] AABB tree: do_intersect now calls the First_primitive
 traversal traits (much faster) performance section updated


[PATCH] Fix a critical performance issue

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

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

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


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

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

Change-Id: Id366621fa3ad02ca182b8a4da48cae940059cf46


[PATCH] Changed increment ordering for performance


[PATCH] More efficient way of creating point set from selected points


[PATCH] DLB can now turn off, when slower

Under certain conditions, especially with (shared) GPUs, DLB can
decrease the performance. We now measure the cycles per step before
turning on DLB. When the running average of cycles per step with DLB
gets above the average without DLB, we turn off DLB. We then measure
again without DLB. DLB can then turn on again. If we turn on DLB of
DLB multiple times in close succesion and we measure performance loss,
we keep DLB off for the remainder of the run. This procedure ensures
that the performance will never deteriorate due to DLB.
Updated and expanded the DLB section in the manual.

Change-Id: I6e0291c1a41adf6da94fae46d36e0fcb95585a02


[PATCH] Non-reduction boxloops done

The non-reduction boxloops are all in and pass the struct tests.
Performance is VERY slow, but this may just be due to the machine
I am running on. Reduction boxloops are in progress.


[PATCH] Removed unnecessary synchronization that hurt performance on
 Nvidia


[PATCH] More efficient SetNonzerosSlice2::evaluate


[PATCH] AVX512 CGEMM & ZGEMM kernels

96-99% 1-thread performance of MKL2018


[PATCH] Fixed a performance regression on AMD GPUs


[PATCH] fixed bugs in BLT sorting, added makeSemiExplicit function
 (working, but not as efficient as it coudl be)


[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] 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] Avoid calculating distances after an Elkan prune. Slight,
 nearly negligible performance gains.


[PATCH] Adding BoundaryInfo::add_elements()

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

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


[PATCH] some more prints to debug comex_malloc performance


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

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

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


[PATCH] VT:for infiniband VT:disabled HBNA get for performance
 reasons, needs to be enabled in the future


[PATCH] Added upper triangular fast tridiagonalization routines.


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


[PATCH] Enorme typo sur le parametre fast


[PATCH] Updated article reference. Added configuration flags to
 support altivec on powerpc. Updated configuration files from gnu.org Removed
 the fast x86 truncation when double precision was used - it would just crash
 since the registers are 32bit only. Added powerpc altivec innerloop support
 to fnbf.c Removed x86 assembly truncation when double precision is used - the
 registers can only handle 32 bits. Dont use general solvent loops when we
 have altivec support in the normal ones.


[PATCH] Removed one star. Nomore five stars record. This makes that
 mollocs are larger, therefore more efficient, and it works around buggy
 malloc library routines.


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


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


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


[PATCH] Refactor sign to signbit internally

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

(cherry picked from commit 2c8fb67ce5d07e573396eb8764470fb79086c797)


[PATCH] Reworked function 'get_best_weight()' of Slivers_exuder.h

- Avoid computing incident cells multiple times
- Make it more efficient for P3M3 by not having to use
  tr.min_squared_distance() to compute the distance
  between neighboring vertices


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


[PATCH] Fix the Jacobi compilation time.

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

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

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

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


[PATCH] Auto cache compiled CUDA kernels on disk to speed up
 compilation (#2848)

* Adds CMake variable AF_CACHE_KERNELS_TO_DISK to enable kernel caching. It is turned ON by default.
* cuda::buildKernel() now dumps cubin to disk for reuse
* Adds cuda::loadKernel() for loading cached cubin files
* cuda::loadKernel() returns empty kernel on failure
* Uses XDG_CACHE_HOME as cache directory for Linux
* Adds common::deterministicHash() - This uses the FNV-1a hashing algorithm for fast and reproducible hashing of string or binary data. This is meant to replace the use of std::hash in some place, since std::hash does not guarantee its return value will be the same in subsequence executions of the program.
* Write cached kernel to temporary file before moving into final file. This prevents data races where two threads or two processes might write to the same file.
* Uses deterministicHash() for hashing kernel names and kernel binary data.
* Adds kernel binary data file integrity check upon loading from disk


[PATCH] 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] MDRange: Disabling performance test for MDRange: takes way to
 long on KNL


[PATCH] issue #2155: setting initial guesses slow


[PATCH] Adding performance patch for trmm, just like #2836


[PATCH] Adjust spin wait in attempt to address performance issue #935
 Bring Windows code back in, just in case...


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


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

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

Change-Id: I59d5741df345b38745f9a6d1ea3a4d27b0a66034


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


[PATCH] Extra options for computational electrophysiology.

* Added two extra .mdp file parameters 'bulk-offset' that allow to specify
an offset of the swap layers from the compartment midplanes. This is useful
for setups where e.g. a transmembrane protein extends far into at least one
of the compartments. Without an offset, ions would be swapped in the vicinity
of the protein, which is not wanted. Adding an extended water layer comes
at the cost of performance, which is not the case for the offset solution.
* Also made the wording a bit clearer in some places
* Described the new parameters in the PDF manual, updated figure
* replaced usage of sprintf in output routine print_ionlist_legend() by snprintf
* Turned comments describing the variables entering the swapcoords.cpp
  functions into doxygen comments

Change-Id: I2a5314d112384b30f9c910135047cc2441192421


[PATCH] 1.  BoomerAMG keeps track of the number of iterations
 accumulated over all calls.  This is needed for user-level performance
 monitoring if it is a preconditioner for a Krylov method such as PCG.  The
 regular iteration count only tells you about the last time PCG invoked
 BoomerAMG.  There are ifdefs so you can eliminate this if you like - remove
 #define CUMNUMIT.

2.  very minor code fixes, comments, etc.


[PATCH] Replaced static arrays of cl::program/kernels with maps

fast, fftconvolve, orb and random kernels were using static
arrays which are not replaced with std::maps. This fixes the
pure virtual function error that is happening on windows for
intel OpenCL devices.


[PATCH] Fixing a bug in measuring performance (didn't reset the
 timer)


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

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


[PATCH] 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] OPENCL: Disabling greedy assignment for csrmm and csrmv

- Was causing performance issues on intel and amd devices


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


[PATCH] add (T) kernels optimized for OpenMP+SIMD

These kernels are taken from https://github.com/jeffhammond/nwchem-tce-triples-kernels/,
which were previously part of private development branch of NWChem hosted by Argonne.
The code was developed by Jeff Hammond from 2013-2014 with help from Karol Kowalski.

These kernels have been tested on Intel Xeon, Intel Xeon Phi, IBM Blue Gene/Q,
IBM POWER7, AMD Bulldozer and ARM32 processors using the Intel, Cray, IBM XL,
and GCC compilers.  In rare instances, the optimal loop order is different between
Intel, Cray and IBM compilers.  In such cases, we default to the Intel compiler case
because it is the most commonly used Fortran compiler for NWChem.  In particular,
NWChem as a whole cannot be compiled with Cray Fortran, so the only context in which
it would be used for these kernels is if someone did a mixed build.
The performance differences with XLF were observed on POWER7, which is a relatively
rare platform for NWChem.

In any case, these optimizations are better than the serial version any time OpenMP
is used.  Detailed performance information for some platforms can be found at
https://github.com/jeffhammond/nwchem-tce-triples-kernels/tree/master/results.

Finally, it should be noted that all of Jeff Hammond's developments for non-Intel
architectures were done prior to his employment at Intel, which can be verified
from the Github commit log associated with the aforementioned repo.


[PATCH] More performance enhancements for the transformation --
 almost done now!


[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] FEAT: Enabling additional interpolation types

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

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


[PATCH] More extensive performance logging of the Kelly Error
 Estimator.

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


[PATCH] Use a separate Performance log line for compute_affine_map

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


[PATCH] Move clang-tidy build

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

Change-Id: I45ea5856ca05edbb6107b62f219e8afd3cdbda3f


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


[PATCH] Adding pair style dpd/intel and dihedral style fourier/intel
 Adding raw performance numbers for Skylake xeon server. Fixes for using older
 Intel compilers and compiling without OpenMP. Fix adding in hooks for using
 USER-INTEL w/ minimization.


[PATCH] shorten ESTIMATE planning time for certain weird sizes

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

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

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

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

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

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


[PATCH] made some bondeds slightly more efficient


[PATCH] Convert nbnxn_atomdata_t to C++

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

This change is ony refactoring, no functional changes.

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

Change-Id: I9c70a1f8f272c80a7cf335fcbd867bd79c4102a2


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


[PATCH] Adding Changelog for Release 3.4.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.4


[PATCH] USER-DPD: propagate a minor performance bugfix throughout the
 DPDE code

The fix_shardlow_kokkos.cpp code had already factored out a redundant
sqrt() calculation in the innermost loop of ssa_update_dpde().  This
changeset propagates an equivilent optimization to:
  fix_shardlow.cpp
  pair_dpd_fdt_energy.cpp
  pair_dpd_fdt_energy_kokkos.cpp
The alpha_ij variable was really just an [itype][jtype] lookup parameter,
replacing a sqrt() and two multiplies per interacting particle pair
by a cached memory read.  Even if there isn't much time savings, the
code is now consistent across the various versions.


[PATCH] Performance bug fix in single node case.


[PATCH] fixed performance issue for vacuum with DD


[PATCH] all gonzalez stuff uploaded for trying to fix gonzalez, make
 it fast and accurate


[PATCH] Update citations.

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


[PATCH] Recursive ThreadPools (#1774)

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

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

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

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


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


[PATCH] minor performance fix; map double_conic to
 double_coefficients


[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] 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] The current version allows for triclinic boxes as well. It is
 very slow though.


[PATCH] query t on side of bounded square

I moved a lot of the functionality for deciding the Linf incircle
test for four points to the side of bounded square predicate.

In the case of query point t being on one of the sides of the
bounded square, I use the predicate test1d. Maybe even this can
be optimized, or made even more robust with some more checks.

A bug that is fixed with the current commit is in the following
input:

$ cat ~/Dropbox/cgal/sdg/panos/sqch1a.cin
p -51 -180
p -180 -30
p -180 20
p -7 -180

I also fixed a small bug when expanding both sides of the bounded
square.

The next step is to completely remove the slow "side of oriented
square" test.

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


[PATCH] Enable fp-exceptions

This can help with finding errors quicker because mdrun crashes as soon
as a floating point value overflows or is invalid. fp-exceptions are
only enabled for builds with asserts (without NDEBUG), mainly because
it isn't always possible to avoid invalid fp operations for SIMD math
without a performance penalty.

Also, fix a few places where we had 1/0 or other invalid fp operations.

Fixes #1582

Change-Id: Ib1b3afc525706f4b171564fcaf08ebf3b2be3122


[PATCH] avoid using epeck in slow (when using leda) tests


[PATCH] remove legacy CUDA non-bonded kernels

This commit drops the legacy set of kernels which were optimized for use
with CUDA compilers 3.2 and 4.0 (previous to the switch to llvm backend
in 4.1).

For now the only consequence is slight performance degradation with CUDA
3.2/4.0, the build system still requires CUDA >=3.2 as the kernels do
build with the older CUDA compilers. Whether to require at least CUDA
4.1 will be decided later.

Refs #1382

Change-Id: I75d31b449e5b5e10f823408e23f35b9a7ac68bae


[PATCH] Extend Force sub-counters

Need more data for understanding performance variation

Implemented subcounter "restart" and used it for accumulating
position-restraints time with FEP to the position-restraints
subcounter.

Noted TODOs for some future extensions not currently possible.

Also added logfile output from GMX_CYCLE_BARRIER where people
analyzing the performance will see it.

Refs #1686

Change-Id: I9d60d0a683f56549879bb739269e9466c96572c4


[PATCH] Add node ranking for increased nearest neighbour performance,
 currently failing tests for k > 1


[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] Gredner performance benchmark test


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


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

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


[PATCH] fast dynamic_cast in Lazy_kernel::Construct_point_3


[PATCH] Deprecate the Side class

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


[PATCH] Optimize load_tile_offsets for only relevant frags

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


[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] 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] Core: Atomic Performance Test Reduce Loop count

This was taking to long, reduced the loop count.


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

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


[PATCH] first short a performance matrix stuff. Papi interface so
 far.


[PATCH] Added Kokkos-like array datatype into RK4 and RHS in
 FixRXKokkos.

- Created an Array class that provides stride access for operator[]
  w/o needing Kokkos views. This was designed to avoid the performance
  issues encountered with Views and sub-views throughout the RHS and
  ODE solver functions.


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


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


[PATCH] Fix conditional on when DtoH forces copy occur

d2d4a50b4c636c203028c5bff311924ec15e7825 introduced performance
regression with forces copied from device to host on each step.
This fixes the issue by reinstantiating proper condition on the
copy call.

Fixes #4001
Refs #2608


[PATCH] Small improvements for readability and performance


[PATCH] Distinghuish cases for performance reasons


[PATCH] Changed number of nonbonded thread blocks to improve
 performance


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


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

Rick Kendall


[PATCH] ATW: Interim commit - new sparse packing and IO OK but slow


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


[PATCH] efficient sparsity pattern computation for the case when the
 user specifies the DOF coupling


[PATCH] Replaced Vertex_circulator by Edge_circulator to gain
 performance


[PATCH] << operator for segments does clipping (QT advice) only for
 the segments that intersect the boundaries of the screen rectangle use the
 old x_real function because the new one is too slow in doing the
 transformation (use GMP if CGAL_USE_GMP is defined) we should document the
 old one too, it will never be removed.


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

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


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


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


[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] Add access to base kernel in Efficient RANSAC traits


[PATCH] using int instead of size_t should be more efficient and
 range doesn't seem to be needed


[PATCH] Fix performance regresssion bug of unnecessary destruction of
 IPC comms buffers


[PATCH] Adding Changelog for Release 3.5.00

Part of Kokkos C++ Performance Portability Programming EcoSystem 3.5


[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] Use stack allocation in zgemv and zger

For better performance with small matrices
Ref #727


[PATCH] turned performance fix for 7.30 compilers off by default


[PATCH] Improve performance of PairReaxCKokkos


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

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


[PATCH] Optimize `copy_cells`, part 2 (#1695)

This patch optimizes the `copy_cells` path for multi-fragment reads. The
following benchmarks are for the multi-fragment read scenario discussed
offline:

```
// Current
Read time: 4.75082 secs
  * Time to copy result attribute values: 3.54192 secs
    > Time to read attribute tiles: 0.311707 secs
    > Time to unfilter attribute tiles: 0.370434 secs
    > Time to copy fixed-sized attribute values: 0.898421 secs
    > Time to copy var-sized attribute values: 0.954925 secs
```

```
// With this patch
Read time: 3.04627 secs
  * Time to copy result attribute values: 1.83972 secs
    > Time to read attribute tiles: 0.274928 secs
    > Time to unfilter attribute tiles: 0.38196 secs
    > Time to copy fixed-sized attribute values: 0.517415 secs
    > Time to copy var-sized attribute values: 0.461847 secs
```

For context, here are the benchmark results for the single-fragment read. The
stats are similar with and without this patch:
```
Read time: 1.86883 secs
  * Time to copy result attribute values: 1.19411 secs
    > Time to read attribute tiles: 0.304055 secs
    > Time to unfilter attribute tiles: 0.351332 secs
    > Time to copy fixed-sized attribute values: 0.289661 secs
    > Time to copy var-sized attribute values: 0.142405 secs
```

This patch does three things:
1. Converts the `offset_offsets_per_cs` and `var_offsets_per_cs` in the var-sized
   path from a 2D array (vector<vector<uint64_t>>) to a 1D array (vector<uint64_t).
   The big win is construction and destruction time for the nested vector
   elements.
2. Partitions cell copying for both fixed and var-sized paths. The motivation
   is to reduce contention on the TBB threads and minimize time spent context
   switching between the individual cell slab copies.
3. Added a context cache for the fixed size path, similar to the existing
   var-sized context cache.

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


[PATCH] Mark closed flag in EigenSparseVector regardless of METHOD

I don't think it's a performance hit to set these flags
regardless of METHOD, and it's a nice state flag that the user
can check


[PATCH] Improve the performance of the `Record` logger by using
 deques of `std::unique_ptr` instead of plain object.


[PATCH] --enable-distmesh, --with-mapvector-chunk-size

The parmesh argument probably should have been deprecated when the
ParallelMesh name was.

We'll want to select chunked_mapvector array size at configure time,
since the exact performance optimization/pessimization results are
likely to be system-dependent.


[PATCH] Target haswell or AVX2 for prebuilt libraries

Prebuilt artifacts that we publish for releases will now target
`haswell` for linux and macos and `AVX2` for windows to allow for
greater compatibility while maintaining the performance of AVX
optimizations.


[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] 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] Improving performance of Kokkos ReaxFF

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


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

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


[PATCH] Adjusted scheduling, removed slow atomic section


[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] made changes which removed further operations and made CLJP
 and Falgout coarsenings more efficient


[PATCH] Added fast square tridiagonalization for lower-triangular
 storage.