formatting

Author: cwpearson

.clang-format

@@ -0,0 +1,5 @@
+---
+Language:        Cpp
+BasedOnStyle:  LLVM
+...
+

include/scope/barrier.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <memory>
 #include <condition_variable>
+#include <memory>
 
 // https://stackoverflow.com/questions/24465533/implementing-boostbarrier-in-c11
 class Barrier {

include/scope/chrono.hpp

@@ -1,7 +1,7 @@
 #include <chrono>
 
 namespace scope {
-    using clock = std::chrono::high_resolution_clock;
-    using duration = std::chrono::duration<double>;
-    using time_point = std::chrono::time_point<clock>;
-}
+using clock = std::chrono::high_resolution_clock;
+using duration = std::chrono::duration<double>;
+using time_point = std::chrono::time_point<clock>;
+} // namespace scope

include/scope/clobber.hpp

@@ -2,14 +2,12 @@
 
 namespace scope {
 
-__host__
-inline __attribute__((always_inline)) void clobber_memory() {
+__host__ inline __attribute__((always_inline)) void clobber_memory() {
   std::atomic_signal_fence(std::memory_order_acq_rel);
 }
 
-__device__
-inline __attribute__((always_inline)) void clobber_memory() {
+__device__ inline __attribute__((always_inline)) void clobber_memory() {
   asm volatile("" : : : "memory");
 }
 
-}
+} // namespace scope

include/scope/cuda.hpp

@@ -8,21 +8,20 @@
 
 cudaError_t cuda_reset_device(const int &id);
 
-
 namespace scope {
 namespace detail {
 inline void success_or_throw(cudaError err, const char *file, int line) {
-    if (cudaSuccess != err) {
-        std::stringstream ss;
-        ss << __FILE__ << ":" << __LINE__ << "CUDA error " << cudaGetErrorString(err);
-        throw std::runtime_error(ss.str());
-    }
+  if (cudaSuccess != err) {
+    std::stringstream ss;
+    ss << __FILE__ << ":" << __LINE__ << "CUDA error "
+       << cudaGetErrorString(err);
+    throw std::runtime_error(ss.str());
+  }
 }
 } // namespace detail
 
 cudaError hip_reset_device(const int &id);
 
 } // namespace scope
 
-
 #define CUDA_RUNTIME(x) scope::detail::success_or_throw(x, __FILE__, __LINE__)

include/scope/defer.hpp

@@ -5,24 +5,21 @@
 #include <type_traits>
 #include <utility>
 
-template <class Function>
-class defer_func {
+template <class Function> class defer_func {
 public:
   template <class F>
-  explicit defer_func(F &&f) noexcept : defer_function_(std::forward<F>(f)) {
-  }
+  explicit defer_func(F &&f) noexcept : defer_function_(std::forward<F>(f)) {}
 
-  ~defer_func() {
-    defer_function_();
-  }
+  ~defer_func() { defer_function_(); }
 
 private:
   Function defer_function_;
 };
 
 template <class F>
 defer_func<typename std::decay<F>::type> make_defer(F &&defer_function) {
-  return defer_func<typename std::decay<F>::type>(std::forward<F>(defer_function));
+  return defer_func<typename std::decay<F>::type>(
+      std::forward<F>(defer_function));
 }
 
 #define DEFER_1(x, y) x##y

include/scope/device.hpp

@@ -10,47 +10,40 @@
 
 class Device {
 public:
+  enum class Kind { cuda, hip };
 
-    enum class Kind {
-        cuda,
-        hip
-    };
+  Device(const Kind &kind, int id) : kind_(kind), id_(id) {}
 
-    Device(const Kind &kind, int id) : kind_(kind), id_(id) {}
+  int device_id() const;
 
-    int device_id() const;
+  operator int() const { return id_; }
 
-    operator int() const {
-        return id_;
-    }
+  /*
+  HIP: returns hipDeviceProp_t::canMapHostMemory
+  */
+  bool can_map_host_memory() const;
 
-    /*
-    HIP: returns hipDeviceProp_t::canMapHostMemory
-    */
-    bool can_map_host_memory() const;
-
-    #if defined(SCOPE_USE_HIP)
-    static Device hip_device(int id);
-    #endif
+#if defined(SCOPE_USE_HIP)
+  static Device hip_device(int id);
+#endif
 
-    #if defined(SCOPE_USE_CUDA)
-    static Device cuda_device(int id);
-    #endif
+#if defined(SCOPE_USE_CUDA)
+  static Device cuda_device(int id);
+#endif
 
 private:
-    Kind kind_;
-    int id_;
+  Kind kind_;
+  int id_;
 
 #if defined(SCOPE_USE_HIP)
-    hipDeviceProp_t hipDeviceProp_;
+  hipDeviceProp_t hipDeviceProp_;
 #endif
 
 #if defined(SCOPE_USE_CUDA)
 #if defined(SCOPE_HAVE_CUDA_DEVICE_PROP)
-    cudaDeviceProp cudaDeviceProp_;
+  cudaDeviceProp cudaDeviceProp_;
 #else
-    cudaDeviceProp_t cudaDeviceProp_;
+  cudaDeviceProp_t cudaDeviceProp_;
 #endif
 #endif
 };
-

include/scope/do_not_optimize.hpp

@@ -2,19 +2,18 @@
 
 namespace scope {
 template <class Tp>
-__device__
-void __attribute__((always_inline)) do_not_optimize(Tp const& value) {
+__device__ void __attribute__((always_inline))
+do_not_optimize(Tp const &value) {
   asm volatile("" : : "r,m"(value) : "memory");
 }
 
 // https://gcc.gnu.org/onlinedocs/gcc/Machine-Constraints.html#Machine-Constraints
 template <class Tp>
-__device__
-void __attribute__((always_inline)) do_not_optimize(Tp& value) {
+__device__ void __attribute__((always_inline)) do_not_optimize(Tp &value) {
 #if defined(__HIP_DEVICE_COMPILE__)
   asm volatile("" : "+v"(value) : : "memory");
 #else
   asm volatile("" : "+r,m"(value) : : "memory");
 #endif
 }
-}
+} // namespace scope