Add .clang-tidy and fix clang-tidy warnings

.clang-tidy

@@ -0,0 +1,61 @@
+---
+Checks:          'clang-diagnostic-*,
+                  clang-analyzer-*,
+                  cppcoreguidelines-*,
+                  modernize-*,
+                  bugprone-*,
+                  performance-*,
+                  readability-*,
+                  llvm-*,
+                  -modernize-use-trailing-return-type,
+                  -cppcoreguidelines-macro-usage'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
+AnalyzeTemporaryDtors: false
+FormatStyle:     none
+CheckOptions:
+  - key:             cert-dcl16-c.NewSuffixes
+    value:           'L;LL;LU;LLU'
+  - key:             cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
+    value:           '0'
+  - key:             cert-str34-c.DiagnoseSignedUnsignedCharComparisons
+    value:           '0'
+  - key:             cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
+    value:           '1'
+  - key:             cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value:           '1'
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '1'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
+  - key:             llvm-else-after-return.WarnOnConditionVariables
+    value:           '0'
+  - key:             llvm-else-after-return.WarnOnUnfixable
+    value:           '0'
+  - key:             llvm-qualified-auto.AddConstToQualified
+    value:           '0'
+  - key:             modernize-loop-convert.MaxCopySize
+    value:           '16'
+  - key:             modernize-loop-convert.MinConfidence
+    value:           reasonable
+  - key:             modernize-loop-convert.NamingStyle
+    value:           CamelCase
+  - key:             modernize-pass-by-value.IncludeStyle
+    value:           llvm
+  - key:             modernize-replace-auto-ptr.IncludeStyle
+    value:           llvm
+  - key:             modernize-use-nullptr.NullMacros
+    value:           'NULL'
+  - key:             readability-identifier-length.IgnoredParameterNames
+    value:           'mr|os'
+  - key:             readability-identifier-length.IgnoredVariableNames
+    value:           'mr|_'
+  - key:             readability-function-cognitive-complexity.IgnoreMacros
+    value:           '1'
+  - key:             bugprone-easily-swappable-parameters.IgnoredParameterNames
+    value:           'alignment'
+...

benchmarks/cuda_stream_pool/cuda_stream_pool_bench.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, NVIDIA CORPORATION.
+ * Copyright (c) 2020-2021, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,36 +14,36 @@
  * limitations under the License.
  */
 
-#include <benchmark/benchmark.h>
-
 #include <rmm/cuda_stream_pool.hpp>
 #include <rmm/detail/error.hpp>
 
 #include <cuda_runtime_api.h>
 
+#include <benchmark/benchmark.h>
+
 #include <stdexcept>
 
 static void BM_StreamPoolGetStream(benchmark::State& state)
 {
   rmm::cuda_stream_pool stream_pool{};
 
-  for (auto _ : state) {
-    auto s = stream_pool.get_stream();
-    cudaStreamQuery(s.value());
+  for (auto _ : state) {  // NOLINT(clang-analyzer-deadcode.DeadStores)
+    auto stream = stream_pool.get_stream();
+    cudaStreamQuery(stream.value());
   }
 
-  state.SetItemsProcessed(state.iterations());
+  state.SetItemsProcessed(static_cast<int64_t>(state.iterations()));
 }
 BENCHMARK(BM_StreamPoolGetStream)->Unit(benchmark::kMicrosecond);
 
 static void BM_CudaStreamClass(benchmark::State& state)
 {
-  for (auto _ : state) {
-    auto s = rmm::cuda_stream{};
-    cudaStreamQuery(s.view().value());
+  for (auto _ : state) {  // NOLINT(clang-analyzer-deadcode.DeadStores)
+    auto stream = rmm::cuda_stream{};
+    cudaStreamQuery(stream.view().value());
   }
 
-  state.SetItemsProcessed(state.iterations());
+  state.SetItemsProcessed(static_cast<int64_t>(state.iterations()));
 }
 BENCHMARK(BM_CudaStreamClass)->Unit(benchmark::kMicrosecond);
 

benchmarks/device_uvector/device_uvector_bench.cu

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, NVIDIA CORPORATION.
+ * Copyright (c) 2020-2021, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,33 +14,39 @@
  * limitations under the License.
  */
 
-#include <benchmark/benchmark.h>
-
-#include <cuda_runtime_api.h>
 #include <rmm/device_uvector.hpp>
 #include <rmm/device_vector.hpp>
 #include <rmm/mr/device/cuda_memory_resource.hpp>
 #include <rmm/mr/device/per_device_resource.hpp>
 #include <rmm/mr/device/pool_memory_resource.hpp>
 
+#include <benchmark/benchmark.h>
+
+#include <cuda_runtime_api.h>
+
 static void BM_UvectorSizeConstruction(benchmark::State& state)
 {
   rmm::mr::cuda_memory_resource cuda_mr{};
   rmm::mr::pool_memory_resource<rmm::mr::cuda_memory_resource> mr{&cuda_mr};
   rmm::mr::set_current_device_resource(&mr);
 
-  for (auto _ : state) {
+  for (auto _ : state) {  // NOLINT(clang-analyzer-deadcode.DeadStores)
     rmm::device_uvector<int32_t> vec(state.range(0), rmm::cuda_stream_view{});
     cudaDeviceSynchronize();
   }
 
-  state.SetItemsProcessed(state.iterations());
+  state.SetItemsProcessed(static_cast<int64_t>(state.iterations()));
 
   rmm::mr::set_current_device_resource(nullptr);
 }
+
+const auto range_multiplier{10};
+const auto range_start{10'000};
+const auto range_end{1'000'000'000};
+
 BENCHMARK(BM_UvectorSizeConstruction)
-  ->RangeMultiplier(10)
-  ->Range(10'000, 1'000'000'000)
+  ->RangeMultiplier(range_multiplier)
+  ->Range(range_start, range_end)
   ->Unit(benchmark::kMicrosecond);
 
 static void BM_ThrustVectorSizeConstruction(benchmark::State& state)
@@ -49,19 +55,19 @@ static void BM_ThrustVectorSizeConstruction(benchmark::State& state)
   rmm::mr::pool_memory_resource<rmm::mr::cuda_memory_resource> mr{&cuda_mr};
   rmm::mr::set_current_device_resource(&mr);
 
-  for (auto _ : state) {
+  for (auto _ : state) {  // NOLINT(clang-analyzer-deadcode.DeadStores)
     rmm::device_vector<int32_t> vec(state.range(0));
     cudaDeviceSynchronize();
   }
 
-  state.SetItemsProcessed(state.iterations());
+  state.SetItemsProcessed(static_cast<int64_t>(state.iterations()));
 
   rmm::mr::set_current_device_resource(nullptr);
 }
 
 BENCHMARK(BM_ThrustVectorSizeConstruction)
-  ->RangeMultiplier(10)
-  ->Range(10'000, 1'000'000'000)
+  ->RangeMultiplier(range_multiplier)
+  ->Range(range_start, range_end)
   ->Unit(benchmark::kMicrosecond);
 
 BENCHMARK_MAIN();

benchmarks/multi_stream_allocations/multi_stream_allocations_bench.cu

@@ -16,8 +16,6 @@
 
 #include <benchmarks/utilities/cxxopts.hpp>
 
-#include <benchmark/benchmark.h>
-
 #include <rmm/cuda_stream.hpp>
 #include <rmm/cuda_stream_pool.hpp>
 #include <rmm/device_uvector.hpp>
@@ -31,15 +29,18 @@
 
 #include <cuda_runtime_api.h>
 
+#include <benchmark/benchmark.h>
+
 #include <cstddef>
 
 __global__ void compute_bound_kernel(int64_t* out)
 {
   clock_t clock_begin   = clock64();
   clock_t clock_current = clock_begin;
+  auto const million{1'000'000};
 
-  if (threadIdx.x == 0) {
-    while (clock_current - clock_begin < 1000000) {
+  if (threadIdx.x == 0) {  // NOLINT(readability-static-accessed-through-instance)
+    while (clock_current - clock_begin < million) {
       clock_current = clock64();
     }
   }
@@ -69,26 +70,26 @@ static void run_test(std::size_t num_kernels,
   }
 }
 
-static void BM_MultiStreamAllocations(benchmark::State& state, MRFactoryFunc factory)
+static void BM_MultiStreamAllocations(benchmark::State& state, MRFactoryFunc const& factory)
 {
   auto mr = factory();
 
   rmm::mr::set_current_device_resource(mr.get());
 
   auto num_streams = state.range(0);
   auto num_kernels = state.range(1);
-  auto do_prewarm  = state.range(2);
+  bool do_prewarm  = state.range(2) != 0;
 
   auto stream_pool = rmm::cuda_stream_pool(num_streams);
 
   if (do_prewarm) { run_prewarm(stream_pool, mr.get()); }
 
-  for (auto _ : state) {
+  for (auto _ : state) {  // NOLINT(clang-analyzer-deadcode.DeadStores)
     run_test(num_kernels, stream_pool, mr.get());
     cudaDeviceSynchronize();
   }
 
-  state.SetItemsProcessed(state.iterations() * num_kernels);
+  state.SetItemsProcessed(static_cast<int64_t>(state.iterations() * num_kernels));
 
   rmm::mr::set_current_device_resource(nullptr);
 }
@@ -124,7 +125,7 @@ static void benchmark_range(benchmark::internal::Benchmark* b)
     ->Unit(benchmark::kMicrosecond);
 }
 
-MRFactoryFunc get_mr_factory(std::string resource_name)
+MRFactoryFunc get_mr_factory(std::string const& resource_name)
 {
   if (resource_name == "cuda") { return &make_cuda; }
 #ifdef RMM_CUDA_MALLOC_ASYNC_SUPPORT
@@ -139,7 +140,7 @@ MRFactoryFunc get_mr_factory(std::string resource_name)
   RMM_FAIL();
 }
 
-void declare_benchmark(std::string name)
+void declare_benchmark(std::string const& name)
 {
   if (name == "cuda") {
     BENCHMARK_CAPTURE(BM_MultiStreamAllocations, cuda, &make_cuda)  //
@@ -176,7 +177,7 @@ void declare_benchmark(std::string name)
   std::cout << "Error: invalid memory_resource name: " << name << std::endl;
 }
 
-void run_profile(std::string resource_name, int kernel_count, int stream_count, bool prewarm)
+void run_profile(std::string const& resource_name, int kernel_count, int stream_count, bool prewarm)
 {
   auto mr_factory  = get_mr_factory(resource_name);
   auto mr          = mr_factory();
@@ -228,7 +229,11 @@ int main(int argc, char** argv)
     auto num_kernels   = args["kernels"].as<int>();
     auto num_streams   = args["streams"].as<int>();
     auto prewarm       = args["warm"].as<bool>();
-    run_profile(resource_name, num_kernels, num_streams, prewarm);
+    try {
+      run_profile(resource_name, num_kernels, num_streams, prewarm);
+    } catch (std::exception const& e) {
+      std::cout << "Exception caught: " << e.what() << std::endl;
+    }
   } else {
     auto resource_names = std::vector<std::string>();