From 31b30dbd9d08dae9a9f538de4c1335384ad58e48 Mon Sep 17 00:00:00 2001 From: Kenneth Moreland Date: Mon, 25 Mar 2019 16:22:06 -0600 Subject: [PATCH] Update arguments to benchmarks With the functionality of vtkm::cont::Initialize's argument handling improved, parse the arguments of benchmarks better. --- benchmarking/BenchmarkArrayTransfer.cxx | 3 +- benchmarking/BenchmarkAtomicArray.cxx | 3 +- benchmarking/BenchmarkCopySpeeds.cxx | 9 +- benchmarking/BenchmarkDeviceAdapter.cxx | 308 +++++++++++++------ benchmarking/BenchmarkFieldAlgorithms.cxx | 16 +- benchmarking/BenchmarkFilters.cxx | 288 ++++++++++++----- benchmarking/BenchmarkRayTracing.cxx | 3 +- benchmarking/BenchmarkTopologyAlgorithms.cxx | 18 +- 8 files changed, 453 insertions(+), 195 deletions(-) diff --git a/benchmarking/BenchmarkArrayTransfer.cxx b/benchmarking/BenchmarkArrayTransfer.cxx index d3a689017..370556589 100644 --- a/benchmarking/BenchmarkArrayTransfer.cxx +++ b/benchmarking/BenchmarkArrayTransfer.cxx @@ -569,7 +569,8 @@ struct BenchmarkArrayTransfer int main(int argc, char* argv[]) { - auto opts = vtkm::cont::InitializeOptions::RequireDevice; + auto opts = + vtkm::cont::InitializeOptions::DefaultAnyDevice | vtkm::cont::InitializeOptions::Strict; auto config = vtkm::cont::Initialize(argc, argv, opts); using Benchmarks = vtkm::benchmarking::BenchmarkArrayTransfer; diff --git a/benchmarking/BenchmarkAtomicArray.cxx b/benchmarking/BenchmarkAtomicArray.cxx index b05ac8c1f..1790d82fa 100644 --- a/benchmarking/BenchmarkAtomicArray.cxx +++ b/benchmarking/BenchmarkAtomicArray.cxx @@ -578,7 +578,8 @@ public: int main(int argc, char* argv[]) { - auto opts = vtkm::cont::InitializeOptions::RequireDevice; + auto opts = + vtkm::cont::InitializeOptions::DefaultAnyDevice | vtkm::cont::InitializeOptions::Strict; auto config = vtkm::cont::Initialize(argc, argv, opts); try diff --git a/benchmarking/BenchmarkCopySpeeds.cxx b/benchmarking/BenchmarkCopySpeeds.cxx index 782a5c087..085abe5f7 100644 --- a/benchmarking/BenchmarkCopySpeeds.cxx +++ b/benchmarking/BenchmarkCopySpeeds.cxx @@ -178,7 +178,8 @@ struct BenchmarkValueTypeFunctor int main(int argc, char* argv[]) { - auto opts = vtkm::cont::InitializeOptions::RequireDevice; + auto opts = vtkm::cont::InitializeOptions::RequireDevice | + vtkm::cont::InitializeOptions::ErrorOnBadOption | vtkm::cont::InitializeOptions::AddHelp; auto config = vtkm::cont::Initialize(argc, argv, opts); @@ -186,12 +187,12 @@ int main(int argc, char* argv[]) int numThreads = tbb::task_scheduler_init::automatic; #endif // TBB - if (config.Arguments.size() == 2) + if (argc == 3) { - if (std::string(config.Arguments[0]) == "NumThreads") + if (std::string(argv[1]) == "NumThreads") { #ifdef VTKM_ENABLE_TBB - std::istringstream parse(config.Arguments[1]); + std::istringstream parse(argv[2]); parse >> numThreads; std::cout << "Selected " << numThreads << " TBB threads." << std::endl; #else diff --git a/benchmarking/BenchmarkDeviceAdapter.cxx b/benchmarking/BenchmarkDeviceAdapter.cxx index 8e94c8aaf..9791f857a 100644 --- a/benchmarking/BenchmarkDeviceAdapter.cxx +++ b/benchmarking/BenchmarkDeviceAdapter.cxx @@ -30,7 +30,7 @@ #include #include #include -#include +#include #include #include @@ -1217,33 +1217,220 @@ public: }; #undef ARRAY_SIZE + +struct Arg : vtkm::cont::internal::option::Arg +{ + static vtkm::cont::internal::option::ArgStatus Number( + const vtkm::cont::internal::option::Option& option, + bool msg) + { + bool argIsNum = ((option.arg != nullptr) && (option.arg[0] != '\0')); + const char* c = option.arg; + while (argIsNum && (*c != '\0')) + { + argIsNum &= static_cast(std::isdigit(*c)); + ++c; + } + + if (argIsNum) + { + return vtkm::cont::internal::option::ARG_OK; + } + else + { + if (msg) + { + std::cerr << "Option " << option.name << " requires a numeric argument." << std::endl; + } + + return vtkm::cont::internal::option::ARG_ILLEGAL; + } + } +}; } } // namespace vtkm::benchmarking +enum optionIndex +{ + UNKNOWN, + HELP, + NUM_THREADS, + TYPELIST, + ARRAY_SIZE, + MORE_OUTPUT_RANGE +}; + +enum typelistType +{ + BASE, + EXTENED +}; + +enum arraySizeType +{ + BYTES, + VALUES +}; + int main(int argc, char* argv[]) { - auto opt = vtkm::cont::InitializeOptions::RequireDevice; - auto initConfig = vtkm::cont::Initialize(argc, argv, opt); + auto initConfig = vtkm::cont::Initialize(argc, argv, vtkm::cont::InitializeOptions::None); - int numThreads{ 0 }; -#ifdef VTKM_ENABLE_TBB - if (initConfig.Device == vtkm::cont::DeviceAdapterTagTBB()) + if (initConfig.Device == vtkm::cont::DeviceAdapterTagUndefined()) { - numThreads = tbb::task_scheduler_init::automatic; + initConfig.Device = vtkm::cont::DeviceAdapterTagAny(); } -#endif -#ifdef VTKM_ENABLE_OPENMP - if (initConfig.Device == vtkm::cont::DeviceAdapterTagOpenMP()) + + namespace option = vtkm::cont::internal::option; + using Arg = vtkm::benchmarking::Arg; + + std::vector usage; + std::string usageHeader{ "Usage: " }; + usageHeader.append(argv[0]); + usageHeader.append(" [options] [benchmarks]"); + usage.push_back({ UNKNOWN, 0, "", "", Arg::None, usageHeader.c_str() }); + usage.push_back({ UNKNOWN, 0, "", "", Arg::None, "Options are:" }); + usage.push_back({ HELP, 0, "h", "help", Arg::None, " -h, --help\tDisplay this help." }); + usage.push_back({ UNKNOWN, 0, "", "", Arg::None, initConfig.Usage.c_str() }); + usage.push_back({ NUM_THREADS, + 0, + "", + "num-threads", + Arg::Number, + " --num-threads \tSpecify the number of threads to use." }); + usage.push_back({ TYPELIST, + BASE, + "", + "base-typelist", + Arg::None, + " --base-typelist \tBenchmark using the base set of types. (default)" }); + usage.push_back({ TYPELIST, + EXTENED, + "", + "extended-typelist", + Arg::None, + " --extended-tyupelist \tBenchmark using an extended set of types." }); + usage.push_back({ ARRAY_SIZE, + BYTES, + "", + "array-size-bytes", + Arg::Number, + " --array-size-bytes \tRun the benchmarks with arrays of the given " + "number of bytes. (Default is 2097152 (i.e. 2MB)" }); + usage.push_back({ ARRAY_SIZE, + VALUES, + "", + "array-size-values", + Arg::Number, + " --array-size-values \tRun the benchmarks with arrays of the given " + "number of values." }); + usage.push_back({ MORE_OUTPUT_RANGE, + 0, + "", + "more-output-range", + Arg::None, + " --more-output-range \tIf specified, operations like Unique will test with " + "a wider range of unique values (5%, 10%, 15%, 20%, 25%, 30%, 35%, 40%, 45%, " + "50%, 75%, 100% unique). By default, the range is limited to 5%, 25%, 50%, " + "75%, 100%." }); + usage.push_back({ UNKNOWN, 0, "", "", Arg::None, "Benchmarks are one or more of:" }); + usage.push_back({ UNKNOWN, + 0, + "", + "", + Arg::None, + "\tCopy, CopyIf, LowerBounds, Reduce, ReduceByKey, ScanExclusive, " + "ScanInclusive, Sort, SortByKey, StableSortIndices, StableSortIndicesUnique, " + "Unique, UpperBounds" }); + usage.push_back( + { UNKNOWN, 0, "", "", Arg::None, "If no benchmarks are listed, all will be run." }); + usage.push_back({ 0, 0, nullptr, nullptr, nullptr, nullptr }); + + vtkm::cont::internal::option::Stats stats(usage.data(), argc - 1, argv + 1); + std::unique_ptr options{ new option::Option[stats.options_max] }; + std::unique_ptr buffer{ new option::Option[stats.buffer_max] }; + option::Parser commandLineParse(usage.data(), argc - 1, argv + 1, options.get(), buffer.get()); + + if (options[UNKNOWN]) { - numThreads = omp_get_max_threads(); + std::cerr << "Unknown option: " << options[UNKNOWN].name << std::endl; + option::printUsage(std::cerr, usage.data()); + exit(1); + } + + if (options[HELP]) + { + option::printUsage(std::cerr, usage.data()); + exit(0); } -#endif vtkm::benchmarking::BenchDevAlgoConfig& config = vtkm::benchmarking::Config; - for (size_t i = 0; i < initConfig.Arguments.size(); ++i) + int numThreads{ 0 }; + if (options[NUM_THREADS]) { - std::string arg = initConfig.Arguments[i]; + std::istringstream parse(options[NUM_THREADS].arg); + parse >> numThreads; + if (initConfig.Device == vtkm::cont::DeviceAdapterTagTBB() || + initConfig.Device == vtkm::cont::DeviceAdapterTagOpenMP()) + { + std::cout << "Selected " << numThreads << " " << initConfig.Device.GetName() << " threads." + << std::endl; + } + else + { + std::cerr << options[NUM_THREADS].name << " not valid on this device. Ignoring." << std::endl; + } + } + + if (options[TYPELIST]) + { + switch (options[TYPELIST].last()->type()) + { + case BASE: + config.ExtendedTypeList = false; + break; + case EXTENED: + config.ExtendedTypeList = true; + break; + default: + std::cerr << "Internal error. Unknown typelist." << std::endl; + break; + } + } + + if (options[ARRAY_SIZE]) + { + config.TestArraySizeBytes = false; + config.TestArraySizeValues = false; + for (const option::Option* opt = options[ARRAY_SIZE]; opt; opt = opt->next()) + { + std::istringstream parse(opt->arg); + switch (opt->type()) + { + case BYTES: + config.TestArraySizeBytes = true; + parse >> config.ArraySizeBytes; + break; + case VALUES: + config.TestArraySizeValues = true; + parse >> config.ArraySizeValues; + break; + default: + std::cerr << "Internal error. Unknown array size type." << std::endl; + break; + } + } + } + + if (options[MORE_OUTPUT_RANGE]) + { + config.DetailedOutputRangeScaling = true; + } + + for (int i = 0; i < commandLineParse.nonOptionsCount(); ++i) + { + std::string arg = commandLineParse.nonOption(i); std::transform(arg.begin(), arg.end(), arg.begin(), [](char c) { return static_cast(std::tolower(static_cast(c))); }); @@ -1299,103 +1486,22 @@ int main(int argc, char* argv[]) { config.BenchmarkFlags |= vtkm::benchmarking::UPPER_BOUNDS; } - else if (arg == "typelist") - { - ++i; - arg = initConfig.Arguments[i]; - std::transform(arg.begin(), arg.end(), arg.begin(), [](char c) { - return static_cast(std::tolower(static_cast(c))); - }); - if (arg == "base") - { - config.ExtendedTypeList = false; - } - else if (arg == "extended") - { - config.ExtendedTypeList = true; - } - else - { - std::cerr << "Unrecognized TypeList: " << initConfig.Arguments[i] << std::endl; - return 1; - } - } - else if (arg == "fixbytes") - { - ++i; - arg = initConfig.Arguments[i]; - std::transform(arg.begin(), arg.end(), arg.begin(), [](char c) { - return static_cast(std::tolower(static_cast(c))); - }); - if (arg == "off") - { - config.TestArraySizeBytes = false; - } - else - { - std::istringstream parse(arg); - config.TestArraySizeBytes = true; - parse >> config.ArraySizeBytes; - } - } - else if (arg == "fixsizes") - { - ++i; - arg = initConfig.Arguments[i]; - std::transform(arg.begin(), arg.end(), arg.begin(), [](char c) { - return static_cast(std::tolower(static_cast(c))); - }); - if (arg == "off") - { - config.TestArraySizeValues = false; - } - else - { - std::istringstream parse(arg); - config.TestArraySizeValues = true; - parse >> config.ArraySizeValues; - } - } - else if (arg == "detailedoutputrange") - { - config.DetailedOutputRangeScaling = true; - } - else if (arg == "numthreads") - { - ++i; - if (initConfig.Device == vtkm::cont::DeviceAdapterTagTBB() || - initConfig.Device == vtkm::cont::DeviceAdapterTagOpenMP()) - { - std::istringstream parse(initConfig.Arguments[i]); - parse >> numThreads; - std::cout << "Selected " << numThreads << " " << initConfig.Device.GetName() << " threads." - << std::endl; - } - else - { - std::cerr << "NumThreads not valid on this device. Ignoring." << std::endl; - } - } else { - std::cerr << "Unrecognized benchmark: " << initConfig.Arguments[i] << std::endl; + std::cerr << "Unrecognized benchmark: " << arg << std::endl; + option::printUsage(std::cerr, usage.data()); return 1; } } #ifdef VTKM_ENABLE_TBB // Must not be destroyed as long as benchmarks are running: - if (initConfig.Device == vtkm::cont::DeviceAdapterTagTBB()) - { - tbb::task_scheduler_init init(numThreads); - } + tbb::task_scheduler_init init((numThreads > 0) ? numThreads + : tbb::task_scheduler_init::automatic); #endif #ifdef VTKM_ENABLE_OPENMP - if (initConfig.Device == vtkm::cont::DeviceAdapterTagOpenMP()) - { - omp_set_num_threads(numThreads); - } -#endif // TBB + omp_set_num_threads((numThreads > 0) ? numThreads : omp_get_max_threads()); +#endif if (config.BenchmarkFlags == 0) { diff --git a/benchmarking/BenchmarkFieldAlgorithms.cxx b/benchmarking/BenchmarkFieldAlgorithms.cxx index b9a75c5dc..f6979926f 100644 --- a/benchmarking/BenchmarkFieldAlgorithms.cxx +++ b/benchmarking/BenchmarkFieldAlgorithms.cxx @@ -931,19 +931,19 @@ public: int main(int argc, char* argv[]) { - auto opts = vtkm::cont::InitializeOptions::RequireDevice; + auto opts = vtkm::cont::InitializeOptions::DefaultAnyDevice; auto config = vtkm::cont::Initialize(argc, argv, opts); int benchmarks = 0; - if (!config.Arguments.size()) + if (argc < 2) { benchmarks = vtkm::benchmarking::ALL; } else { - for (size_t i = 0; i < config.Arguments.size(); ++i) + for (int i = 1; i < argc; ++i) { - std::string arg = config.Arguments[i]; + std::string arg = argv[i]; std::transform(arg.begin(), arg.end(), arg.begin(), [](char c) { return static_cast(std::tolower(static_cast(c))); }); @@ -969,7 +969,13 @@ int main(int argc, char* argv[]) } else { - std::cout << "Unrecognized benchmark: " << config.Arguments[i] << std::endl; + std::cerr << "Unrecognized benchmark: " << argv[i] << std::endl; + std::cerr << "Usage: " << argv[0] << " [options] [benchmarks]" << std::endl; + std::cerr << "options are:" << std::endl; + std::cerr << config.Usage; + std::cerr << "available benchmarks are:" << std::endl; + std::cerr << " blackscholes, math, fusedmath, interpolate, implicit_function" << std::endl; + std::cerr << "If no benchmarks are specified, all are run." << std::endl; return 1; } } diff --git a/benchmarking/BenchmarkFilters.cxx b/benchmarking/BenchmarkFilters.cxx index 1f583808e..34fdb07f8 100644 --- a/benchmarking/BenchmarkFilters.cxx +++ b/benchmarking/BenchmarkFilters.cxx @@ -37,6 +37,8 @@ #include #include +#include + #include #include #include @@ -1068,22 +1070,71 @@ void AssertFields(bool needPointScalars, bool needCellScalars, bool needPointVec } } -int BenchmarkBody(const std::vector& argv, vtkm::cont::DeviceAdapterId id) +struct Arg : vtkm::cont::internal::option::Arg { - int numThreads = 1; -#ifdef VTKM_ENABLE_TBB - if (id == vtkm::cont::DeviceAdapterTagTBB()) + static vtkm::cont::internal::option::ArgStatus Number( + const vtkm::cont::internal::option::Option& option, + bool msg) { - numThreads = tbb::task_scheduler_init::automatic; - } -#endif -#ifdef VTKM_ENABLE_OPENMP - if (id == vtkm::cont::DeviceAdapterTagOpenMP()) - { - numThreads = omp_get_max_threads(); - } -#endif + bool argIsNum = ((option.arg != nullptr) && (option.arg[0] != '\0')); + const char* c = option.arg; + while (argIsNum && (*c != '\0')) + { + argIsNum &= static_cast(std::isdigit(*c)); + ++c; + } + if (argIsNum) + { + return vtkm::cont::internal::option::ARG_OK; + } + else + { + if (msg) + { + std::cerr << "Option " << option.name << " requires a numeric argument." << std::endl; + } + + return vtkm::cont::internal::option::ARG_ILLEGAL; + } + } + + static vtkm::cont::internal::option::ArgStatus Required( + const vtkm::cont::internal::option::Option& option, + bool msg) + { + if ((option.arg != nullptr) && (option.arg[0] != '\0')) + { + if (msg) + { + std::cerr << "Option " << option.name << " requires an argument." << std::endl; + } + return vtkm::cont::internal::option::ARG_ILLEGAL; + } + else + { + return vtkm::cont::internal::option::ARG_OK; + } + } +}; + +enum optionIndex +{ + UNKNOWN, + HELP, + NUM_THREADS, + FILENAME, + POINT_SCALARS, + CELL_SCALARS, + POINT_VECTORS, + WAVELET_DIM, + TETRA, + REDUCED_OPTIONS +}; + +int BenchmarkBody(int argc, char** argv, const vtkm::cont::InitializeResult& config) +{ + int numThreads = 0; int benches = BenchmarkName::NONE; std::string filename; vtkm::Id waveletDim = 256; @@ -1094,9 +1145,144 @@ int BenchmarkBody(const std::vector& argv, vtkm::cont::DeviceAdapte ReducedOptions = false; - for (size_t i = 0; i < argv.size(); ++i) + namespace option = vtkm::cont::internal::option; + + std::vector usage; + std::string usageHeader{ "Usage: " }; + usageHeader.append(argv[0]); + usageHeader.append(" [options] [benchmarks]"); + usage.push_back({ UNKNOWN, 0, "", "", Arg::None, usageHeader.c_str() }); + usage.push_back({ UNKNOWN, 0, "", "", Arg::None, "Options are:" }); + usage.push_back({ HELP, 0, "h", "help", Arg::None, " -h, --help\tDisplay this help." }); + usage.push_back({ UNKNOWN, 0, "", "", Arg::None, config.Usage.c_str() }); + usage.push_back({ NUM_THREADS, + 0, + "", + "num-threads", + Arg::Number, + " --num-threads \tSpecify the number of threads to use." }); + usage.push_back({ FILENAME, + 0, + "", + "file", + Arg::Required, + " --file \tFile (in legacy vtk format) to read as input. " + "If not specified, a wavelet source is generated." }); + usage.push_back({ POINT_SCALARS, + 0, + "", + "point-scalars", + Arg::Required, + " --point-scalars \tName of the point scalar field to operate on." }); + usage.push_back({ CELL_SCALARS, + 0, + "", + "cell-scalars", + Arg::Required, + " --cell-scalars \tName of the cell scalar field to operate on." }); + usage.push_back({ POINT_VECTORS, + 0, + "", + "point-vectors", + Arg::Required, + " --point-vectors \tName of the point vector field to operate on." }); + usage.push_back({ WAVELET_DIM, + 0, + "", + "wavelet-dim", + Arg::Number, + " --wavelet-dim \tThe size in each dimension of the wavelet grid " + "(if generated)." }); + usage.push_back({ TETRA, + 0, + "", + "tetra", + Arg::None, + " --tetra \tTetrahedralize data set before running benchmark." }); + usage.push_back({ REDUCED_OPTIONS, + 0, + "", + "reduced-options", + Arg::None, + " --reduced-options \tRun fewer variants of each filter. " }); + usage.push_back({ UNKNOWN, 0, "", "", Arg::None, "Benchmarks are one or more of:" }); + usage.push_back({ UNKNOWN, + 0, + "", + "", + Arg::None, + "\tgradient, threshold, threshold_points, cell_average, point_average, " + "warp_scalar, warp_vector, marching_cubes, external_faces, " + "tetrahedralize, cell_to_point" }); + usage.push_back( + { UNKNOWN, 0, "", "", Arg::None, "If no benchmarks are listed, all will be run." }); + usage.push_back({ 0, 0, nullptr, nullptr, nullptr, nullptr }); + + + vtkm::cont::internal::option::Stats stats(usage.data(), argc - 1, argv + 1); + std::unique_ptr options{ new option::Option[stats.options_max] }; + std::unique_ptr buffer{ new option::Option[stats.buffer_max] }; + option::Parser commandLineParse(usage.data(), argc - 1, argv + 1, options.get(), buffer.get()); + + if (options[UNKNOWN]) { - std::string arg = argv[i]; + std::cerr << "Unknown option: " << options[UNKNOWN].name << std::endl; + option::printUsage(std::cerr, usage.data()); + exit(1); + } + + if (options[HELP]) + { + option::printUsage(std::cerr, usage.data()); + exit(0); + } + + if (options[NUM_THREADS]) + { + std::istringstream parse(options[NUM_THREADS].arg); + parse >> numThreads; + if (config.Device == vtkm::cont::DeviceAdapterTagTBB() || + config.Device == vtkm::cont::DeviceAdapterTagOpenMP()) + { + std::cout << "Selected " << numThreads << " " << config.Device.GetName() << " threads." + << std::endl; + } + else + { + std::cerr << options[NUM_THREADS].name << " not valid on this device. Ignoring." << std::endl; + } + } + + if (options[FILENAME]) + { + filename = options[FILENAME].arg; + } + + if (options[POINT_SCALARS]) + { + PointScalarsName = options[POINT_SCALARS].arg; + } + if (options[CELL_SCALARS]) + { + CellScalarsName = options[CELL_SCALARS].arg; + } + if (options[POINT_VECTORS]) + { + PointVectorsName = options[POINT_VECTORS].arg; + } + + if (options[WAVELET_DIM]) + { + std::istringstream parse(options[WAVELET_DIM].arg); + parse >> waveletDim; + } + + tetra = (options[TETRA] != nullptr); + ReducedOptions = (options[REDUCED_OPTIONS] != nullptr); + + for (int i = 0; i < commandLineParse.nonOptionsCount(); ++i) + { + std::string arg = commandLineParse.nonOption(i); std::transform(arg.begin(), arg.end(), arg.begin(), [](char c) { return static_cast(std::tolower(static_cast(c))); }); @@ -1158,73 +1344,21 @@ int BenchmarkBody(const std::vector& argv, vtkm::cont::DeviceAdapte { benches |= BenchmarkName::CELL_TO_POINT; } - else if (arg == "filename") - { - ++i; - filename = argv[i]; - } - else if (arg == "pointscalars") - { - ++i; - PointScalarsName = argv[i]; - } - else if (arg == "cellscalars") - { - ++i; - CellScalarsName = argv[i]; - } - else if (arg == "pointvectors") - { - ++i; - PointVectorsName = argv[i]; - } - else if (arg == "waveletdim") - { - ++i; - std::istringstream parse(argv[i]); - parse >> waveletDim; - } - else if (arg == "tetra") - { - tetra = true; - } - else if (arg == "reducedoptions") - { - ReducedOptions = true; - } - else if (arg == "numthreads") - { - ++i; - if (id == vtkm::cont::DeviceAdapterTagOpenMP() || id == vtkm::cont::DeviceAdapterTagTBB()) - { - std::istringstream parse(argv[i]); - parse >> numThreads; - std::cout << "Selected " << numThreads << " " << id.GetName() << " threads." << std::endl; - } - else - { - std::cerr << "NumThreads not valid on this device. Ignoring." << std::endl; - } - } else { - std::cerr << "Unrecognized option: " << argv[i] << std::endl; + std::cerr << "Unrecognized benchmark: " << arg << std::endl; + option::printUsage(std::cerr, usage.data()); return 1; } } #ifdef VTKM_ENABLE_TBB // Must not be destroyed as long as benchmarks are running: - if (id == vtkm::cont::DeviceAdapterTagTBB()) - { - tbb::task_scheduler_init init(numThreads); - } + tbb::task_scheduler_init init((numThreads > 0) ? numThreads + : tbb::task_scheduler_init::automatic); #endif #ifdef VTKM_ENABLE_OPENMP - if (id == vtkm::cont::DeviceAdapterTagOpenMP()) - { - omp_set_num_threads(numThreads); - } + omp_set_num_threads((numThreads > 0) ? numThreads : omp_get_max_threads()); #endif if (benches == BenchmarkName::NONE) @@ -1251,7 +1385,7 @@ int BenchmarkBody(const std::vector& argv, vtkm::cont::DeviceAdapte // WaveletGenerator needs a template device argument not a id to deduce the portal type. WaveletGeneratorDataFunctor genFunctor; - vtkm::cont::TryExecuteOnDevice(id, genFunctor, gen); + vtkm::cont::TryExecuteOnDevice(config.Device, genFunctor, gen); } if (tetra) @@ -1300,7 +1434,7 @@ int BenchmarkBody(const std::vector& argv, vtkm::cont::DeviceAdapte std::cout << "\n"; //now actually execute the benchmarks - int result = BenchmarkFilters::Run(benches, id); + int result = BenchmarkFilters::Run(benches, config.Device); // Explicitly free resources before exit. InputDataSet.Clear(); @@ -1312,13 +1446,13 @@ int BenchmarkBody(const std::vector& argv, vtkm::cont::DeviceAdapte int main(int argc, char* argv[]) { - auto opts = vtkm::cont::InitializeOptions::RequireDevice; - auto config = vtkm::cont::Initialize(argc, argv, opts); + auto opts = vtkm::cont::InitializeOptions::DefaultAnyDevice; + vtkm::cont::InitializeResult config = vtkm::cont::Initialize(argc, argv, opts); int retval = 1; try { - retval = BenchmarkBody(config.Arguments, config.Device); + retval = BenchmarkBody(argc, argv, config); } catch (std::exception& e) { diff --git a/benchmarking/BenchmarkRayTracing.cxx b/benchmarking/BenchmarkRayTracing.cxx index 92da753c9..64ef68117 100644 --- a/benchmarking/BenchmarkRayTracing.cxx +++ b/benchmarking/BenchmarkRayTracing.cxx @@ -145,7 +145,8 @@ VTKM_MAKE_BENCHMARK(RayTracing, BenchRayTracing); int main(int argc, char* argv[]) { - auto opts = vtkm::cont::InitializeOptions::RequireDevice; + auto opts = + vtkm::cont::InitializeOptions::DefaultAnyDevice | vtkm::cont::InitializeOptions::Strict; auto config = vtkm::cont::Initialize(argc, argv, opts); VTKM_RUN_BENCHMARK(RayTracing, vtkm::ListTagBase(), config.Device); diff --git a/benchmarking/BenchmarkTopologyAlgorithms.cxx b/benchmarking/BenchmarkTopologyAlgorithms.cxx index ab87a59cb..e892f104b 100644 --- a/benchmarking/BenchmarkTopologyAlgorithms.cxx +++ b/benchmarking/BenchmarkTopologyAlgorithms.cxx @@ -453,19 +453,19 @@ public: int main(int argc, char* argv[]) { - auto opts = vtkm::cont::InitializeOptions::RequireDevice; + auto opts = vtkm::cont::InitializeOptions::DefaultAnyDevice; auto config = vtkm::cont::Initialize(argc, argv, opts); int benchmarks = 0; - if (!config.Arguments.size()) + if (argc <= 1) { benchmarks = vtkm::benchmarking::ALL; } else { - for (size_t i = 0; i < config.Arguments.size(); ++i) + for (int i = 1; i < argc; ++i) { - std::string arg = config.Arguments[i]; + std::string arg = argv[i]; std::transform(arg.begin(), arg.end(), arg.begin(), [](char c) { return static_cast(std::tolower(static_cast(c))); }); @@ -483,7 +483,15 @@ int main(int argc, char* argv[]) } else { - std::cout << "Unrecognized benchmark: " << config.Arguments[i] << std::endl; + std::cerr << "Unrecognized benchmark: " << argv[i] << std::endl; + std::cerr << "USAGE: " << argv[0] << " [options] []" << std::endl; + std::cerr << "Options are: " << std::endl; + std::cerr << config.Usage << std::endl; + std::cerr << "Benchmarks are one or more of the following:" << std::endl; + std::cerr << " CellToPoint\tFind average of point data on each cell" << std::endl; + std::cerr << " PointToCell\tFind average of cell data on each point" << std::endl; + std::cerr << " Classify\tFind Marching Cube case of each cell" << std::endl; + std::cerr << "If no benchmarks are specified, all are run." << std::endl; return 1; } }