Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
502787b1a0
vtk-m/vtkm/benchmarking/BenchmarkDeviceAdapter.cxx

929 lines
28 KiB
C++
Raw Normal View History

Adding micro benchmark suite
2015-07-06 21:44:29 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
Update copyright for Sandia Sandia National Laboratories recently changed management from the Sandia Corporation to the National Technology & Engineering Solutions of Sandia, LLC (NTESS). The copyright statements need to be updated accordingly.
2017-09-20 21:33:44 +00:00
// Copyright 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
Adding micro benchmark suite
2015-07-06 21:44:29 +00:00
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
Update copyright for Sandia Sandia National Laboratories recently changed management from the Sandia Corporation to the National Technology & Engineering Solutions of Sandia, LLC (NTESS). The copyright statements need to be updated accordingly.
2017-09-20 21:33:44 +00:00
// Under the terms of Contract DE-NA0003525 with NTESS,
Adding micro benchmark suite
2015-07-06 21:44:29 +00:00
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
#include <vtkm/TypeTraits.h>
clang-format: sort include directives
2017-05-18 14:51:24 +00:00
#include <vtkm/benchmarking/Benchmarker.h>
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleConstant.h>
clang-format: sort include directives
2017-05-18 14:51:24 +00:00
#include <vtkm/cont/ArrayHandleCounting.h>
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/ArrayHandleZip.h>
#include <vtkm/cont/ArrayPortalToIterators.h>
clang-format: sort include directives
2017-05-18 14:51:24 +00:00
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
#include <vtkm/cont/ErrorExecution.h>
#include <vtkm/cont/StorageBasic.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/cont/internal/DeviceAdapterError.h>
#include <vtkm/cont/testing/Testing.h>
Adding micro benchmark suite
2015-07-06 21:44:29 +00:00
Add StableSortIndices worklet. This worklet produces an index array that permutes a key array into a stable sorted order.
2017-09-22 15:54:02 +00:00
#include <vtkm/worklet/StableSortIndices.h>
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
#include <algorithm>
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
#include <cmath>
Move over from boost/random to c++11 random.
2016-09-08 15:54:41 +00:00
#include <random>
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
#include <string>
Move over from boost/random to c++11 random.
2016-09-08 15:54:41 +00:00
#include <utility>
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Consistently include windows.h by making a wrapper header. We previously included windows.h in numerous locations using different techniques to guard against bringing in parts of the file that are bad (min/max macros, etc). This solves the problem by consistently using vtkm/internal/Windows.h to setup everything.
2016-11-23 21:14:56 +00:00
#include <vtkm/internal/Windows.h>
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace vtkm
{
namespace benchmarking
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
#define ARRAY_SIZE (1 << 21)
const static std::string DIVIDER(40, '-');
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
enum BenchmarkName
{
COPY = 1,
COPY_IF = 1 << 1,
LOWER_BOUNDS = 1 << 2,
REDUCE = 1 << 3,
REDUCE_BY_KEY = 1 << 4,
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
SCAN_INCLUSIVE = 1 << 5,
SCAN_EXCLUSIVE = 1 << 6,
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
SORT = 1 << 7,
SORT_BY_KEY = 1 << 8,
Add StableSortIndices worklet. This worklet produces an index array that permutes a key array into a stable sorted order.
2017-09-22 15:54:02 +00:00
STABLE_SORT_INDICES = 1 << 9,
STABLE_SORT_INDICES_UNIQUE = 1 << 10,
UNIQUE = 1 << 11,
UPPER_BOUNDS = 1 << 12,
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
ALL = COPY | COPY_IF | LOWER_BOUNDS | REDUCE | REDUCE_BY_KEY | SCAN_INCLUSIVE | SCAN_EXCLUSIVE |
SORT |
SORT_BY_KEY |
Add StableSortIndices worklet. This worklet produces an index array that permutes a key array into a stable sorted order.
2017-09-22 15:54:02 +00:00
STABLE_SORT_INDICES |
STABLE_SORT_INDICES_UNIQUE |
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
UNIQUE |
UPPER_BOUNDS
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
};
/// This class runs a series of micro-benchmarks to measure
/// performance of the parallel primitives provided by each
/// device adapter
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <class DeviceAdapterTag>
class BenchmarkDeviceAdapter
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::StorageTagBasic StorageTag;
typedef vtkm::cont::ArrayHandle<vtkm::Id, StorageTag> IdArrayHandle;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapterTag> Algorithm;
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::Timer<DeviceAdapterTag> Timer;
public:
// Various kernels used by the different benchmarks to accelerate
// initialization of data
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct FillTestValueKernel : vtkm::exec::FunctorBase
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef typename ValueArrayHandle::template ExecutionTypes<DeviceAdapterTag>::Portal PortalType;
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
PortalType Output;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
FillTestValueKernel(PortalType out)
: Output(out)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_EXEC void operator()(vtkm::Id i) const { Output.Set(i, TestValue(i, Value())); }
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct FillScaledTestValueKernel : vtkm::exec::FunctorBase
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef typename ValueArrayHandle::template ExecutionTypes<DeviceAdapterTag>::Portal PortalType;
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
PortalType Output;
const vtkm::Id IdScale;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
FillScaledTestValueKernel(vtkm::Id id_scale, PortalType out)
: Output(out)
, IdScale(id_scale)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_EXEC void operator()(vtkm::Id i) const { Output.Set(i, TestValue(i * IdScale, Value())); }
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct FillModuloTestValueKernel : vtkm::exec::FunctorBase
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef typename ValueArrayHandle::template ExecutionTypes<DeviceAdapterTag>::Portal PortalType;
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
PortalType Output;
const vtkm::Id Modulus;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
FillModuloTestValueKernel(vtkm::Id modulus, PortalType out)
: Output(out)
, Modulus(modulus)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_EXEC void operator()(vtkm::Id i) const { Output.Set(i, TestValue(i % Modulus, Value())); }
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct FillBinaryTestValueKernel : vtkm::exec::FunctorBase
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef typename ValueArrayHandle::template ExecutionTypes<DeviceAdapterTag>::Portal PortalType;
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
PortalType Output;
const vtkm::Id Modulus;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
FillBinaryTestValueKernel(vtkm::Id modulus, PortalType out)
: Output(out)
, Modulus(modulus)
{
}
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_EXEC void operator()(vtkm::Id i) const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Output.Set(i, i % Modulus == 0 ? TestValue(vtkm::Id(1), Value()) : Value());
}
};
private:
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchCopy
{
Add a Copy benchmark
2016-05-10 19:22:55 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
ValueArrayHandle ValueHandle_src;
ValueArrayHandle ValueHandle_dst;
Move over from boost/random to c++11 random.
2016-09-08 15:54:41 +00:00
std::mt19937 Rng;
Add a Copy benchmark
2016-05-10 19:22:55 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchCopy()
{
Add a Copy benchmark
2016-05-10 19:22:55 +00:00
ValueHandle_src.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag());
ValueHandle_dst.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag());
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
for (vtkm::Id i = 0; i < ValueHandle_src.GetNumberOfValues(); ++i)
{
ValueHandle_src.GetPortalControl().Set(vtkm::Id(i), TestValue(vtkm::Id(Rng()), Value()));
Add a Copy benchmark
2016-05-10 19:22:55 +00:00
}
Timer timer;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Algorithm::Copy(ValueHandle_src, ValueHandle_dst);
Add a Copy benchmark
2016-05-10 19:22:55 +00:00
return timer.GetElapsedTime();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Add a Copy benchmark
2016-05-10 19:22:55 +00:00
std::stringstream description;
description << "Copy " << ARRAY_SIZE << " values";
return description.str();
}
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_MAKE_BENCHMARK(Copy, BenchCopy);
Add a Copy benchmark
2016-05-10 19:22:55 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchCopyIf
{
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
const vtkm::Id N_VALID;
ValueArrayHandle ValueHandle, OutHandle;
IdArrayHandle StencilHandle;
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchCopyIf(vtkm::Id percent_valid)
: N_VALID((ARRAY_SIZE * percent_valid) / 100)
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
{
vtkm::Id modulo = ARRAY_SIZE / N_VALID;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Algorithm::Schedule(
FillTestValueKernel<Value>(ValueHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Algorithm::Schedule(FillBinaryTestValueKernel<vtkm::Id>(
modulo, StencilHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
}
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
Timer timer;
Algorithm::CopyIf(ValueHandle, StencilHandle, OutHandle);
return timer.GetElapsedTime();
}
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
std::stringstream description;
description << "CopyIf on " << ARRAY_SIZE << " "
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
<< " values with " << OutHandle.GetNumberOfValues() << " valid values";
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
return description.str();
}
};
VTKM_MAKE_BENCHMARK(CopyIf5, BenchCopyIf, 5);
VTKM_MAKE_BENCHMARK(CopyIf10, BenchCopyIf, 10);
VTKM_MAKE_BENCHMARK(CopyIf15, BenchCopyIf, 15);
VTKM_MAKE_BENCHMARK(CopyIf20, BenchCopyIf, 20);
VTKM_MAKE_BENCHMARK(CopyIf25, BenchCopyIf, 25);
VTKM_MAKE_BENCHMARK(CopyIf30, BenchCopyIf, 30);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchLowerBounds
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
const vtkm::Id N_VALS;
ValueArrayHandle InputHandle, ValueHandle;
IdArrayHandle OutHandle;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchLowerBounds(vtkm::Id value_percent)
: N_VALS((ARRAY_SIZE * value_percent) / 100)
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Algorithm::Schedule(
FillTestValueKernel<Value>(InputHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Algorithm::Schedule(FillScaledTestValueKernel<Value>(
2, ValueHandle.PrepareForOutput(N_VALS, DeviceAdapterTag())),
N_VALS);
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Timer timer;
Algorithm::LowerBounds(InputHandle, ValueHandle, OutHandle);
return timer.GetElapsedTime();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::stringstream description;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
description << "LowerBounds on " << ARRAY_SIZE << " input and " << N_VALS << " values";
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
return description.str();
}
};
VTKM_MAKE_BENCHMARK(LowerBounds5, BenchLowerBounds, 5);
VTKM_MAKE_BENCHMARK(LowerBounds10, BenchLowerBounds, 10);
VTKM_MAKE_BENCHMARK(LowerBounds15, BenchLowerBounds, 15);
VTKM_MAKE_BENCHMARK(LowerBounds20, BenchLowerBounds, 20);
VTKM_MAKE_BENCHMARK(LowerBounds25, BenchLowerBounds, 25);
VTKM_MAKE_BENCHMARK(LowerBounds30, BenchLowerBounds, 30);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchReduce
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
ValueArrayHandle InputHandle;
Prevent compiler from optimizing out benchmark body. Since the result of the Reduce call was not used, several compilers were omitting the call completely on release builds.
2017-09-19 18:22:42 +00:00
// We don't actually use this, but we need it to prevent sufficently
// smart compilers from optimizing the Reduce call out.
Value Result;
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchReduce()
{
Algorithm::Schedule(
FillTestValueKernel<Value>(InputHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Prevent compiler from optimizing out benchmark body. Since the result of the Reduce call was not used, several compilers were omitting the call completely on release builds.
2017-09-19 18:22:42 +00:00
this->Result =
Algorithm::Reduce(this->InputHandle, vtkm::TypeTraits<Value>::ZeroInitialization());
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Timer timer;
Prevent compiler from optimizing out benchmark body. Since the result of the Reduce call was not used, several compilers were omitting the call completely on release builds.
2017-09-19 18:22:42 +00:00
Value tmp = Algorithm::Reduce(InputHandle, vtkm::TypeTraits<Value>::ZeroInitialization());
vtkm::Float64 time = timer.GetElapsedTime();
if (tmp != this->Result)
{
this->Result = tmp;
}
return time;
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::stringstream description;
description << "Reduce on " << ARRAY_SIZE << " values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(Reduce, BenchReduce);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchReduceByKey
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
const vtkm::Id N_KEYS;
ValueArrayHandle ValueHandle, ValuesOut;
IdArrayHandle KeyHandle, KeysOut;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchReduceByKey(vtkm::Id key_percent)
: N_KEYS((ARRAY_SIZE * key_percent) / 100)
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Algorithm::Schedule(
FillTestValueKernel<Value>(ValueHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Algorithm::Schedule(FillModuloTestValueKernel<vtkm::Id>(
N_KEYS, KeyHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Algorithm::SortByKey(KeyHandle, ValueHandle);
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Timer timer;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Algorithm::ReduceByKey(KeyHandle, ValueHandle, KeysOut, ValuesOut, vtkm::Add());
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
return timer.GetElapsedTime();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::stringstream description;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
description << "ReduceByKey on " << ARRAY_SIZE << " values with " << N_KEYS
<< " distinct vtkm::Id keys";
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
return description.str();
}
};
VTKM_MAKE_BENCHMARK(ReduceByKey5, BenchReduceByKey, 5);
VTKM_MAKE_BENCHMARK(ReduceByKey10, BenchReduceByKey, 10);
VTKM_MAKE_BENCHMARK(ReduceByKey15, BenchReduceByKey, 15);
VTKM_MAKE_BENCHMARK(ReduceByKey20, BenchReduceByKey, 20);
VTKM_MAKE_BENCHMARK(ReduceByKey25, BenchReduceByKey, 25);
VTKM_MAKE_BENCHMARK(ReduceByKey30, BenchReduceByKey, 30);
Add StableSortIndices worklet. This worklet produces an index array that permutes a key array into a stable sorted order.
2017-09-22 15:54:02 +00:00
VTKM_MAKE_BENCHMARK(ReduceByKey100, BenchReduceByKey, 100);
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchScanInclusive
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
ValueArrayHandle ValueHandle, OutHandle;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchScanInclusive()
{
Algorithm::Schedule(
FillTestValueKernel<Value>(ValueHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Timer timer;
Algorithm::ScanInclusive(ValueHandle, OutHandle);
return timer.GetElapsedTime();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::stringstream description;
description << "ScanInclusive on " << ARRAY_SIZE << " values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(ScanInclusive, BenchScanInclusive);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchScanExclusive
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
ValueArrayHandle ValueHandle, OutHandle;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchScanExclusive()
{
Algorithm::Schedule(
FillTestValueKernel<Value>(ValueHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Timer timer;
Algorithm::ScanExclusive(ValueHandle, OutHandle);
return timer.GetElapsedTime();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::stringstream description;
description << "ScanExclusive on " << ARRAY_SIZE << " values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(ScanExclusive, BenchScanExclusive);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchSort
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
ValueArrayHandle ValueHandle;
Move over from boost/random to c++11 random.
2016-09-08 15:54:41 +00:00
std::mt19937 Rng;
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchSort() { ValueHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag()); }
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
for (vtkm::Id i = 0; i < ValueHandle.GetNumberOfValues(); ++i)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
ValueHandle.GetPortalControl().Set(vtkm::Id(i), TestValue(vtkm::Id(Rng()), Value()));
}
Timer timer;
Algorithm::Sort(ValueHandle);
return timer.GetElapsedTime();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::stringstream description;
description << "Sort on " << ARRAY_SIZE << " random values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(Sort, BenchSort);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchSortByKey
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
Move over from boost/random to c++11 random.
2016-09-08 15:54:41 +00:00
std::mt19937 Rng;
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
vtkm::Id N_KEYS;
ValueArrayHandle ValueHandle;
IdArrayHandle KeyHandle;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchSortByKey(vtkm::Id percent_key)
: N_KEYS((ARRAY_SIZE * percent_key) / 100)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
ValueHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag());
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
for (vtkm::Id i = 0; i < ValueHandle.GetNumberOfValues(); ++i)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
ValueHandle.GetPortalControl().Set(vtkm::Id(i), TestValue(vtkm::Id(Rng()), Value()));
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Algorithm::Schedule(FillModuloTestValueKernel<vtkm::Id>(
N_KEYS, KeyHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Timer timer;
Algorithm::SortByKey(ValueHandle, KeyHandle);
return timer.GetElapsedTime();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::stringstream description;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
description << "SortByKey on " << ARRAY_SIZE << " random values with " << N_KEYS
<< " different vtkm::Id keys";
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
return description.str();
}
};
VTKM_MAKE_BENCHMARK(SortByKey5, BenchSortByKey, 5);
VTKM_MAKE_BENCHMARK(SortByKey10, BenchSortByKey, 10);
VTKM_MAKE_BENCHMARK(SortByKey15, BenchSortByKey, 15);
VTKM_MAKE_BENCHMARK(SortByKey20, BenchSortByKey, 20);
VTKM_MAKE_BENCHMARK(SortByKey25, BenchSortByKey, 25);
VTKM_MAKE_BENCHMARK(SortByKey30, BenchSortByKey, 30);
Add StableSortIndices worklet. This worklet produces an index array that permutes a key array into a stable sorted order.
2017-09-22 15:54:02 +00:00
VTKM_MAKE_BENCHMARK(SortByKey100, BenchSortByKey, 100);
template <typename Value>
struct BenchStableSortIndices
{
using SSI = vtkm::worklet::StableSortIndices<DeviceAdapterTag>;
using ValueArrayHandle = vtkm::cont::ArrayHandle<Value, StorageTag>;
ValueArrayHandle ValueHandle;
std::mt19937 Rng;
VTKM_CONT
BenchStableSortIndices()
{
this->ValueHandle.Allocate(ARRAY_SIZE);
auto portal = this->ValueHandle.GetPortalControl();
for (vtkm::Id i = 0; i < portal.GetNumberOfValues(); ++i)
{
portal.Set(vtkm::Id(i), TestValue(vtkm::Id(Rng()), Value()));
}
}
VTKM_CONT
vtkm::Float64 operator()()
{
vtkm::cont::ArrayHandle<vtkm::Id> indices;
Algorithm::Copy(vtkm::cont::ArrayHandleIndex(ARRAY_SIZE), indices);
Timer timer;
SSI::Sort(ValueHandle, indices);
return timer.GetElapsedTime();
}
VTKM_CONT
std::string Description() const
{
std::stringstream description;
description << "StableSortIndices::Sort on " << ARRAY_SIZE << " random values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(StableSortIndices, BenchStableSortIndices);
template <typename Value>
struct BenchStableSortIndicesUnique
{
using SSI = vtkm::worklet::StableSortIndices<DeviceAdapterTag>;
using IndexArrayHandle = typename SSI::IndexArrayType;
using ValueArrayHandle = vtkm::cont::ArrayHandle<Value, StorageTag>;
const vtkm::Id N_VALID;
ValueArrayHandle ValueHandle;
VTKM_CONT
BenchStableSortIndicesUnique(vtkm::Id percent_valid)
: N_VALID((ARRAY_SIZE * percent_valid) / 100)
{
Algorithm::Schedule(
FillModuloTestValueKernel<Value>(
N_VALID, this->ValueHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
}
VTKM_CONT
vtkm::Float64 operator()()
{
IndexArrayHandle indices = SSI::Sort(this->ValueHandle);
Timer timer;
SSI::Unique(this->ValueHandle, indices);
return timer.GetElapsedTime();
}
VTKM_CONT
std::string Description() const
{
std::stringstream description;
description << "StableSortIndices::Unique on " << ARRAY_SIZE << " values with "
<< this->N_VALID << " valid values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(StableSortIndicesUnique5, BenchStableSortIndicesUnique, 5);
VTKM_MAKE_BENCHMARK(StableSortIndicesUnique10, BenchStableSortIndicesUnique, 10);
VTKM_MAKE_BENCHMARK(StableSortIndicesUnique15, BenchStableSortIndicesUnique, 15);
VTKM_MAKE_BENCHMARK(StableSortIndicesUnique20, BenchStableSortIndicesUnique, 20);
VTKM_MAKE_BENCHMARK(StableSortIndicesUnique25, BenchStableSortIndicesUnique, 25);
VTKM_MAKE_BENCHMARK(StableSortIndicesUnique30, BenchStableSortIndicesUnique, 30);
VTKM_MAKE_BENCHMARK(StableSortIndicesUnique100, BenchStableSortIndicesUnique, 100);
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchUnique
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
const vtkm::Id N_VALID;
ValueArrayHandle ValueHandle;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchUnique(vtkm::Id percent_valid)
: N_VALID((ARRAY_SIZE * percent_valid) / 100)
{
}
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
Algorithm::Schedule(FillModuloTestValueKernel<Value>(
N_VALID, ValueHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Algorithm::Sort(ValueHandle);
Timer timer;
Algorithm::Unique(ValueHandle);
return timer.GetElapsedTime();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::stringstream description;
description << "Unique on " << ARRAY_SIZE << " values with "
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
<< ValueHandle.GetNumberOfValues() << " valid values";
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
return description.str();
}
};
VTKM_MAKE_BENCHMARK(Unique5, BenchUnique, 5);
VTKM_MAKE_BENCHMARK(Unique10, BenchUnique, 10);
VTKM_MAKE_BENCHMARK(Unique15, BenchUnique, 15);
VTKM_MAKE_BENCHMARK(Unique20, BenchUnique, 20);
VTKM_MAKE_BENCHMARK(Unique25, BenchUnique, 25);
VTKM_MAKE_BENCHMARK(Unique30, BenchUnique, 30);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Value>
struct BenchUpperBounds
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
const vtkm::Id N_VALS;
ValueArrayHandle InputHandle, ValueHandle;
IdArrayHandle OutHandle;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
BenchUpperBounds(vtkm::Id percent_vals)
: N_VALS((ARRAY_SIZE * percent_vals) / 100)
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Algorithm::Schedule(
FillTestValueKernel<Value>(InputHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag())),
ARRAY_SIZE);
Algorithm::Schedule(FillScaledTestValueKernel<Value>(
2, ValueHandle.PrepareForOutput(N_VALS, DeviceAdapterTag())),
N_VALS);
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Float64 operator()()
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
Timer timer;
Algorithm::UpperBounds(InputHandle, ValueHandle, OutHandle);
return timer.GetElapsedTime();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::string Description() const
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::stringstream description;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
description << "UpperBounds on " << ARRAY_SIZE << " input and " << N_VALS << " values";
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
return description.str();
}
};
VTKM_MAKE_BENCHMARK(UpperBounds5, BenchUpperBounds, 5);
VTKM_MAKE_BENCHMARK(UpperBounds10, BenchUpperBounds, 10);
VTKM_MAKE_BENCHMARK(UpperBounds15, BenchUpperBounds, 15);
VTKM_MAKE_BENCHMARK(UpperBounds20, BenchUpperBounds, 20);
VTKM_MAKE_BENCHMARK(UpperBounds25, BenchUpperBounds, 25);
VTKM_MAKE_BENCHMARK(UpperBounds30, BenchUpperBounds, 30);
public:
Respect VTK-m convention of parameters all or nothing on a line clang-format BinPack settings have been disabled to make sure that the VTK-m style guideline is obeyed.
2017-05-26 17:53:28 +00:00
struct ValueTypes : vtkm::ListTagBase<vtkm::UInt8,
vtkm::UInt32,
vtkm::Int32,
vtkm::Int64,
vtkm::Vec<vtkm::Int32, 2>,
vtkm::Vec<vtkm::UInt8, 4>,
vtkm::Float32,
vtkm::Float64,
vtkm::Vec<vtkm::Float64, 3>,
vtkm::Vec<vtkm::Float32, 4>>
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
};
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
static VTKM_CONT int Run(int benchmarks)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << DIVIDER << "\nRunning DeviceAdapter benchmarks\n";
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & COPY)
{
Add a Copy benchmark
2016-05-10 19:22:55 +00:00
std::cout << DIVIDER << "\nBenchmarking Copy\n";
VTKM_RUN_BENCHMARK(Copy, ValueTypes());
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & COPY_IF)
{
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
std::cout << "\n" << DIVIDER << "\nBenchmarking CopyIf\n";
VTKM_RUN_BENCHMARK(CopyIf5, ValueTypes());
VTKM_RUN_BENCHMARK(CopyIf10, ValueTypes());
VTKM_RUN_BENCHMARK(CopyIf15, ValueTypes());
VTKM_RUN_BENCHMARK(CopyIf20, ValueTypes());
VTKM_RUN_BENCHMARK(CopyIf25, ValueTypes());
VTKM_RUN_BENCHMARK(CopyIf30, ValueTypes());
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & LOWER_BOUNDS)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << DIVIDER << "\nBenchmarking LowerBounds\n";
VTKM_RUN_BENCHMARK(LowerBounds5, ValueTypes());
VTKM_RUN_BENCHMARK(LowerBounds10, ValueTypes());
VTKM_RUN_BENCHMARK(LowerBounds15, ValueTypes());
VTKM_RUN_BENCHMARK(LowerBounds20, ValueTypes());
VTKM_RUN_BENCHMARK(LowerBounds25, ValueTypes());
VTKM_RUN_BENCHMARK(LowerBounds30, ValueTypes());
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & REDUCE)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << "\n" << DIVIDER << "\nBenchmarking Reduce\n";
VTKM_RUN_BENCHMARK(Reduce, ValueTypes());
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & REDUCE_BY_KEY)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << "\n" << DIVIDER << "\nBenchmarking ReduceByKey\n";
VTKM_RUN_BENCHMARK(ReduceByKey5, ValueTypes());
VTKM_RUN_BENCHMARK(ReduceByKey10, ValueTypes());
VTKM_RUN_BENCHMARK(ReduceByKey15, ValueTypes());
VTKM_RUN_BENCHMARK(ReduceByKey20, ValueTypes());
VTKM_RUN_BENCHMARK(ReduceByKey25, ValueTypes());
VTKM_RUN_BENCHMARK(ReduceByKey30, ValueTypes());
Add StableSortIndices worklet. This worklet produces an index array that permutes a key array into a stable sorted order.
2017-09-22 15:54:02 +00:00
VTKM_RUN_BENCHMARK(ReduceByKey100, ValueTypes());
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & SCAN_INCLUSIVE)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << "\n" << DIVIDER << "\nBenchmarking ScanInclusive\n";
VTKM_RUN_BENCHMARK(ScanInclusive, ValueTypes());
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & SCAN_EXCLUSIVE)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << "\n" << DIVIDER << "\nBenchmarking ScanExclusive\n";
VTKM_RUN_BENCHMARK(ScanExclusive, ValueTypes());
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & SORT)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << "\n" << DIVIDER << "\nBenchmarking Sort\n";
VTKM_RUN_BENCHMARK(Sort, ValueTypes());
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & SORT_BY_KEY)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << "\n" << DIVIDER << "\nBenchmarking SortByKey\n";
VTKM_RUN_BENCHMARK(SortByKey5, ValueTypes());
VTKM_RUN_BENCHMARK(SortByKey10, ValueTypes());
VTKM_RUN_BENCHMARK(SortByKey15, ValueTypes());
VTKM_RUN_BENCHMARK(SortByKey20, ValueTypes());
VTKM_RUN_BENCHMARK(SortByKey25, ValueTypes());
VTKM_RUN_BENCHMARK(SortByKey30, ValueTypes());
Add StableSortIndices worklet. This worklet produces an index array that permutes a key array into a stable sorted order.
2017-09-22 15:54:02 +00:00
VTKM_RUN_BENCHMARK(SortByKey100, ValueTypes());
}
if (benchmarks & STABLE_SORT_INDICES)
{
std::cout << "\n" << DIVIDER << "\nBenchmarking StableSortIndices::Sort\n";
VTKM_RUN_BENCHMARK(StableSortIndices, ValueTypes());
}
if (benchmarks & STABLE_SORT_INDICES_UNIQUE)
{
std::cout << "\n" << DIVIDER << "\nBenchmarking StableSortIndices::Unique\n";
VTKM_RUN_BENCHMARK(StableSortIndicesUnique5, ValueTypes());
VTKM_RUN_BENCHMARK(StableSortIndicesUnique10, ValueTypes());
VTKM_RUN_BENCHMARK(StableSortIndicesUnique15, ValueTypes());
VTKM_RUN_BENCHMARK(StableSortIndicesUnique20, ValueTypes());
VTKM_RUN_BENCHMARK(StableSortIndicesUnique25, ValueTypes());
VTKM_RUN_BENCHMARK(StableSortIndicesUnique30, ValueTypes());
VTKM_RUN_BENCHMARK(StableSortIndicesUnique100, ValueTypes());
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & UNIQUE)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << "\n" << DIVIDER << "\nBenchmarking Unique\n";
VTKM_RUN_BENCHMARK(Unique5, ValueTypes());
VTKM_RUN_BENCHMARK(Unique10, ValueTypes());
VTKM_RUN_BENCHMARK(Unique15, ValueTypes());
VTKM_RUN_BENCHMARK(Unique20, ValueTypes());
VTKM_RUN_BENCHMARK(Unique25, ValueTypes());
VTKM_RUN_BENCHMARK(Unique30, ValueTypes());
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (benchmarks & UPPER_BOUNDS)
{
Make all benchmarking sources listed in build The benchmarking header files were not listed. Not a huge deal since these files do not need to be installed, but they should be listed anyway. Changed the vtkm_save_benchmarks CMake macro to be able to list headers. Also moved everything from BenchmarkDeviceAdapter.h to BenchmarkDeviceAdapter.cxx. Since this code shouldn't need to be included by anything except this benchmark, there is no need to have it in a header file. Plus, the build changes would mean that any change in the header (where most of the source was) could cause all code in this directory to recompile. I do not want to set that precedent.
2016-06-02 16:06:56 +00:00
std::cout << "\n" << DIVIDER << "\nBenchmarking UpperBounds\n";
VTKM_RUN_BENCHMARK(UpperBounds5, ValueTypes());
VTKM_RUN_BENCHMARK(UpperBounds10, ValueTypes());
VTKM_RUN_BENCHMARK(UpperBounds15, ValueTypes());
VTKM_RUN_BENCHMARK(UpperBounds20, ValueTypes());
VTKM_RUN_BENCHMARK(UpperBounds25, ValueTypes());
VTKM_RUN_BENCHMARK(UpperBounds30, ValueTypes());
}
return 0;
}
};
#undef ARRAY_SIZE
}
} // namespace vtkm::benchmarking
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
int main(int argc, char* argv[])
Adding micro benchmark suite
2015-07-06 21:44:29 +00:00
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
int benchmarks = 0;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (argc < 2)
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks = vtkm::benchmarking::ALL;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else
{
for (int i = 1; i < argc; ++i)
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
std::string arg = argv[i];
std::transform(arg.begin(), arg.end(), arg.begin(), ::tolower);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
if (arg == "copy")
{
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
benchmarks |= vtkm::benchmarking::COPY;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "copyif")
{
Rename StreamCompact to CopyIf Plus, removes the version that uses one array as both input and stencil.
2017-03-03 22:17:43 +00:00
benchmarks |= vtkm::benchmarking::COPY_IF;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "lowerbounds")
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks |= vtkm::benchmarking::LOWER_BOUNDS;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "reduce")
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks |= vtkm::benchmarking::REDUCE;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "reducebykey")
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks |= vtkm::benchmarking::REDUCE_BY_KEY;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "scaninclusive")
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks |= vtkm::benchmarking::SCAN_INCLUSIVE;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "scanexclusive")
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks |= vtkm::benchmarking::SCAN_EXCLUSIVE;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "sort")
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks |= vtkm::benchmarking::SORT;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "sortbykey")
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks |= vtkm::benchmarking::SORT_BY_KEY;
}
Add StableSortIndices worklet. This worklet produces an index array that permutes a key array into a stable sorted order.
2017-09-22 15:54:02 +00:00
else if (arg == "stablesortindices")
{
benchmarks |= vtkm::benchmarking::STABLE_SORT_INDICES;
}
else if (arg == "stablesortindicesunique")
{
benchmarks |= vtkm::benchmarking::STABLE_SORT_INDICES_UNIQUE;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "unique")
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks |= vtkm::benchmarking::UNIQUE;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else if (arg == "upperbounds")
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
benchmarks |= vtkm::benchmarking::UPPER_BOUNDS;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
else
{
Measurement and general improvements to the benchmark suite - A warm up run is done and not timed to allow for any allocation of room for output data without accounting for it in the run times. Previously this time spent allocating memory would be included in the time we measured for the benchmark. - Benchmarks are run multiple times and we then compute some statistics about the run time of the benchmark to give a better picture of the expected run time of the function. To this end we run the benchmark either 500 times or for 1.5s, whichever comes sooner (though these are easily changeable). We then perform outlier limiting by Winsorising the data (similar to how Rust's benchmarking library works) and print out the median, mean, min and max run times along with the median absolute deviation and standard deviation. - Because benchmarks are run many times they can now perform some initial setup in the constructor, eg. to fill some test input data array with values to let the main benchmark loop run faster. - To allow for benchmarks to have members of the data type being benchmarked the struct must now be templated on this type, leading to a bit of awkwardness. I've worked around this by adding the `VTKM_MAKE_BENCHMARK` and `VTKM_RUN_BENCHMARK` macros, the make benchmark macro generates a struct that has an `operator()` templated on the value type which will construct and return the benchmark functor templated on that type. The run macro will then use this generated struct to run the benchmark functor on the type list passed. You can also pass arguments to the benchmark functor's constructor through the make macro however this makes things more awkward because the name of the MakeBench struct must be different for each variation of constructor arguments (for example see `BenchLowerBounds`). - Added a short comment on how to add benchmarks in `vtkm/benchmarking/Benchmarker.h` as the new system is a bit different from how the tests work. - You can now pass an extra argument when running the benchmark suite to only benchmark specific functions, eg. `Benchmarks_TBB BenchmarkDeviceAdapter ScanInclusive Sort` will only benchmark ScanInclusive and Sort. Running without any extra arguments will run all the benchmarks as before.
2015-07-24 21:22:10 +00:00
std::cout << "Unrecognized benchmark: " << argv[i] << std::endl;
return 1;
}
}
}
It is now easier to use the device adapter benchmark code. For example to now benchmark only the sortbykey algorithm ./bin/BenchmarkDeviceAdapter_TBB sortbykey
2016-05-03 19:53:09 +00:00
//now actually execute the benchmarks
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return vtkm::benchmarking::BenchmarkDeviceAdapter<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Run(
benchmarks);
Adding micro benchmark suite
2015-07-06 21:44:29 +00:00
}
Reference in New Issue Copy Permalink