Clang format fix

NVSL · Jan 17, 2024 · 1718b83 · 1718b83
1 parent 31d3e76
commit 1718b83
Show file tree

Hide file tree

Showing 11 changed files with 104 additions and 79 deletions.
diff --git a/.clang-format b/.clang-format
@@ -3,7 +3,6 @@ Language: Cpp
 ColumnLimit: 80
 
 AllowShortFunctionsOnASingleLine: Inline
-IndentPPDirectives: BeforeHash
 
 AlignEscapedNewlines: Left
 AllowShortIfStatementsOnASingleLine: WithoutElse
@@ -24,4 +23,4 @@ AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
 
 # Do not indent preprocessing directives
-IndentPPDirectives: None
+IndentPPDirectives: None
diff --git a/include/nvsl/clock.hh b/include/nvsl/clock.hh
@@ -27,8 +27,7 @@ namespace nvsl {
     const size_t s = ns_total / (1000000000);
     const size_t ms = (ns_total - s * 1000000000) / (1000000);
     const size_t us = (ns_total - s * 1000000000 - ms * 1000000) / (1000);
-    const size_t ns =
-        (ns_total - s * 1000000000 - ms * 1000000 - us * 1000);
+    const size_t ns = (ns_total - s * 1000000000 - ms * 1000000 - us * 1000);
 
     ss << s << "s " << ms << "ms " << us << "us " << ns << "ns";
 
@@ -46,12 +45,11 @@ namespace nvsl {
     size_t events = 0;
 
     /**< Total number of values to store */
-    static constexpr size_t RAW_VAL_CNT = 1024*1024*100;
+    static constexpr size_t RAW_VAL_CNT = 1024 * 1024 * 100;
+
   public:
-    Clock() {
-      raw_values.reserve(RAW_VAL_CNT);
-    }
-
+    Clock() { raw_values.reserve(RAW_VAL_CNT); }
+
     /** @brief Start the timer */
     void tick() {
       running = true;
@@ -73,12 +71,14 @@ namespace nvsl {
       }
 
       running = false;
-      const auto elapsed = duration_cast<nanoseconds>(end_clk - start_clk).count();
+      const auto elapsed =
+          duration_cast<nanoseconds>(end_clk - start_clk).count();
       this->total_ns += elapsed;
 
-#define OVERFLOW_MSG "Raw values buffer overflow, increase array size or " \
-        "operations/loop"
-#if defined(NVSL_ASSERT) && defined(DBGE)      
+#define OVERFLOW_MSG                                    \
+  "Raw values buffer overflow, increase array size or " \
+  "operations/loop"
+#if defined(NVSL_ASSERT) && defined(DBGE)
       NVSL_ASSERT(this->raw_values.size() < RAW_VAL_CNT, OVERFLOW_MSG);
 #else
       if (this->raw_values.size() > RAW_VAL_CNT) {
@@ -136,10 +136,10 @@ namespace nvsl {
         assert(0 && "Clock not reconciled. Call reconcile()");
 #endif
       }
-      
+
       const auto sz = sorted_raw_values.size();
-      const auto idx = std::max(0UL, (size_t)((sz*pc)/100.0)-1);
-      
+      const auto idx = std::max(0UL, (size_t)((sz * pc) / 100.0) - 1);
+
       return sorted_raw_values[idx];
     }
 
@@ -156,20 +156,20 @@ namespace nvsl {
 #else
       assert(total_ops != 0 && "Total ops cannot be zero");
 #endif
-      
-      size_t ops_per_iter = total_ops/raw_values.size();
+
+      size_t ops_per_iter = total_ops / raw_values.size();
       ss << this->summarize()
          << "ops/s: " << (total_ops * (1000000000)) / ((double)this->ns())
          << "\ntime/op: "
          << ns_to_hr_clk((size_t)(this->ns() / (double)total_ops))
          << "\nns/op: " << (this->ns() / (double)total_ops);
       if (distribution) {
         ss << "\np50/op: "
-           << ns_to_hr_clk((size_t)(this->percentile(50))/ops_per_iter)
+           << ns_to_hr_clk((size_t)(this->percentile(50)) / ops_per_iter)
            << "\np90/op: "
-           << ns_to_hr_clk((size_t)(this->percentile(90))/ops_per_iter)
+           << ns_to_hr_clk((size_t)(this->percentile(90)) / ops_per_iter)
            << "\np99/op: "
-           << ns_to_hr_clk((size_t)(this->percentile(99))/ops_per_iter)
+           << ns_to_hr_clk((size_t)(this->percentile(99)) / ops_per_iter)
            << "\ntime/op: "
            << ns_to_hr_clk((size_t)(this->ns() / (double)total_ops));
       }

diff --git a/include/nvsl/common.hh b/include/nvsl/common.hh
@@ -167,17 +167,17 @@ struct DBGH {
                                 std::ostream &(*f)(std::ios_base &));
 };
 
-  template <typename T>
-  inline const DBGH &operator<<(const DBGH &dbgh, const T &obj) {
-    if (dbgh.enabled) {
-      DBG << obj;
-    }
-
-    return dbgh;
+template <typename T>
+inline const DBGH &operator<<(const DBGH &dbgh, const T &obj) {
+  if (dbgh.enabled) {
+    DBG << obj;
   }
 
-  inline const DBGH &operator<<(const DBGH &s,
-                                std::ostream &(*f)(std::ostream &)) {
+  return dbgh;
+}
+
+inline const DBGH &operator<<(const DBGH &s,
+                              std::ostream &(*f)(std::ostream &)) {
 #ifndef RELEASE
   if (s.enabled) f(DBG);
 #endif

diff --git a/include/nvsl/pmemops.hh b/include/nvsl/pmemops.hh
@@ -6,20 +6,19 @@
  * @brief  Common abstraction for PMEM operations (clwb, fence, clflush...)
  */
 
- #pragma once
+#pragma once
 
 #include <cassert>
 #include <cstdint>
 #include <stddef.h>
 
-
 #undef NVSL_PMEMOPS_MASTER_FILE
 #define NVSL_PMEMOPS_MASTER_FILE
 
 #include "nvsl/pmemops/declarations.hh"
 #include "nvsl/pmemops/pmemops_clflushopt.hh"
 #include "nvsl/pmemops/pmemops_clwb.hh"
-#include "nvsl/pmemops/pmemops_nopersist.hh"
 #include "nvsl/pmemops/pmemops_msync.hh"
+#include "nvsl/pmemops/pmemops_nopersist.hh"
 
 #undef NVSL_PMEMOPS_MASTER_FILE
diff --git a/include/nvsl/pmemops/declarations.hh b/include/nvsl/pmemops/declarations.hh
@@ -3,7 +3,7 @@
 /**
  * @file   definitions.hh
  * @date   mars 29, 2022
- * @brief  All declarations for the pmemops class 
+ * @brief  All declarations for the pmemops class
  */
 
 #pragma once

diff --git a/include/nvsl/pmemops/pmemops_clflushopt.hh b/include/nvsl/pmemops/pmemops_clflushopt.hh
@@ -10,8 +10,8 @@
 #include <sys/mman.h>
 #include <xmmintrin.h>
 
-#include "nvsl/pmemops/declarations.hh"
 #include "nvsl/error.hh"
+#include "nvsl/pmemops/declarations.hh"
 
 inline void nvsl::PMemOpsClflushOpt::persist(void *base, size_t size) const {
   DBGH(4) << "Persisting " << (base) << "of size " << (void *)(size)
@@ -38,7 +38,7 @@ inline void nvsl::PMemOpsClflushOpt::flush(void *base, size_t size) const {
     this->clflush_opt((void *)uptr);
 #else
     NVSL_ERROR("This version of libpuddles was built on a platform "
-             "that doesn't support clflushopt");
+               "that doesn't support clflushopt");
 #endif
   }
 }
@@ -48,28 +48,28 @@ inline void nvsl::PMemOpsClflushOpt::drain() const {
   _mm_sfence();
 #else
   NVSL_ERROR("This version of libpuddles was built on a platform "
-           "that doesn't support sfence");
+             "that doesn't support sfence");
 #endif
 }
 
-inline void nvsl::PMemOpsClflushOpt::memcpy(void *dest, void *src, size_t size)
-  const {
+inline void nvsl::PMemOpsClflushOpt::memcpy(void *dest, void *src,
+                                            size_t size) const {
   DBGH(4) << "MEMCPY :: pmemdest " << (void *)(dest) << " src " << (void *)(src)
           << " len " << size << std::endl;
 
   this->memmove(dest, src, size);
 }
 
-inline void nvsl::PMemOpsClflushOpt::memmove(void *dest, void *src, size_t size)
-  const {
+inline void nvsl::PMemOpsClflushOpt::memmove(void *dest, void *src,
+                                             size_t size) const {
   std::memmove(dest, src, size);
 
   this->flush(dest, size);
   this->drain();
 }
 
-inline void nvsl::PMemOpsClflushOpt::memset(void *base, char c, size_t size)
-  const {
+inline void nvsl::PMemOpsClflushOpt::memset(void *base, char c,
+                                            size_t size) const {
   DBGH(4) << "MEMSET :: start " << (void *)(base) << " size " << (void *)(size)
           << " char " << c << std::endl;
 

diff --git a/include/nvsl/pmemops/pmemops_clwb.hh b/include/nvsl/pmemops/pmemops_clwb.hh
@@ -165,7 +165,7 @@ inline void nvsl::PMemOpsClwb::flush(void *base, size_t size) const {
     this->clwb((void *)uptr);
 #else
     NVSL_ERROR("This version of libpuddles was built on a platform "
-             "that doesn't support clwb");
+               "that doesn't support clwb");
 #endif
   }
 }
@@ -175,18 +175,20 @@ inline void nvsl::PMemOpsClwb::drain() const {
   _mm_sfence();
 #else
   NVSL_ERROR("This version of libpuddles was built on a platform "
-           "that doesn't support sfence");
+             "that doesn't support sfence");
 #endif
 }
 
-inline void nvsl::PMemOpsClwb::memcpy(void *dest, void *src, size_t size) const {
+inline void nvsl::PMemOpsClwb::memcpy(void *dest, void *src,
+                                      size_t size) const {
   DBGH(4) << "MEMCPY :: pmemdest " << (void *)(dest) << " src " << (void *)(src)
           << " len " << size << std::endl;
 
   this->memmove(dest, src, size);
 }
 
-inline void nvsl::PMemOpsClwb::memmove(void *dest, void *src, size_t size) const {
+inline void nvsl::PMemOpsClwb::memmove(void *dest, void *src,
+                                       size_t size) const {
   std::memmove(dest, src, size);
 
   flush(dest, size);

diff --git a/include/nvsl/pmemops/pmemops_msync.hh b/include/nvsl/pmemops/pmemops_msync.hh
@@ -24,14 +24,16 @@ inline void nvsl::PMemOpsMsync::drain() const {
   /* Do nothing */
 }
 
-inline void nvsl::PMemOpsMsync::memcpy(void *dest, void *src, size_t size) const {
+inline void nvsl::PMemOpsMsync::memcpy(void *dest, void *src,
+                                       size_t size) const {
   DBGH(4) << "MEMCPY :: pmemdest " << (void *)(dest) << " src " << (void *)(src)
           << " len " << size << std::endl;
 
   this->memmove(dest, src, size);
 }
 
-inline void nvsl::PMemOpsMsync::memmove(void *dest, void *src, size_t size) const {
+inline void nvsl::PMemOpsMsync::memmove(void *dest, void *src,
+                                        size_t size) const {
   std::memmove(dest, src, size);
 
   this->flush(dest, size);

diff --git a/include/nvsl/pmemops/pmemops_nopersist.hh b/include/nvsl/pmemops/pmemops_nopersist.hh
@@ -24,21 +24,21 @@ inline void nvsl::PMemOpsNoPersist::flush(void *base, size_t size) const {
 
 inline void nvsl::PMemOpsNoPersist::drain() const {}
 
-inline void nvsl::PMemOpsNoPersist::memcpy(void *dest, void *src, size_t size)
-  const {
+inline void nvsl::PMemOpsNoPersist::memcpy(void *dest, void *src,
+                                           size_t size) const {
   DBGH(4) << "MEMCPY :: pmemdest " << (void *)(dest) << " src " << (void *)(src)
           << " len " << size << std::endl;
 
   this->memmove(dest, src, size);
 }
 
-inline void nvsl::PMemOpsNoPersist::memmove(void *dest, void *src, size_t size)
-  const {
+inline void nvsl::PMemOpsNoPersist::memmove(void *dest, void *src,
+                                            size_t size) const {
   std::memmove(dest, src, size);
 }
 
-inline void nvsl::PMemOpsNoPersist::memset(void *base, char c, size_t size)
-  const {
+inline void nvsl::PMemOpsNoPersist::memset(void *base, char c,
+                                           size_t size) const {
   DBGH(4) << "MEMSET :: start " << (void *)(base) << " size " << (void *)(size)
           << " char " << c << std::endl;