Clang-format and whitespace cleanup of source code

This patch contains the clang-format and cleanup of the entire code base. Some
of clang-formats changes made the code look worse in places. A best effort was
made to resolve the bulk of these problems, but many remain. Most of the
problems were mangling line-breaks and tabbing of comments.

Patch by Terry Wilmarth

Differential Revision: https://reviews.llvm.org/D32659

llvm-svn: 302929

1 files changed, 538 insertions, 546 deletions

diff --git a/openmp/runtime/src/kmp_stats.cpp b/openmp/runtime/src/kmp_stats.cpp
index 3ae25d5a46f..aeea4de1fc2 100644
--- a/openmp/runtime/src/kmp_stats.cpp
+++ b/openmp/runtime/src/kmp_stats.cpp
@@ -12,196 +12,186 @@
 //
 //===----------------------------------------------------------------------===//
 
+
 #include "kmp.h"
-#include "kmp_str.h"
 #include "kmp_lock.h"
 #include "kmp_stats.h"
+#include "kmp_str.h"
 
 #include <algorithm>
-#include <sstream>
-#include <iomanip>
-#include <stdlib.h>                             // for atexit
 #include <ctime>
+#include <iomanip>
+#include <sstream>
+#include <stdlib.h> // for atexit
 
 #define STRINGIZE2(x) #x
 #define STRINGIZE(x) STRINGIZE2(x)
 
-#define expandName(name,flags,ignore)  {STRINGIZE(name),flags},
+#define expandName(name, flags, ignore) {STRINGIZE(name), flags},
 statInfo timeStat::timerInfo[] = {
-    KMP_FOREACH_TIMER(expandName,0)
-    {"TIMER_LAST", 0}
-};
+    KMP_FOREACH_TIMER(expandName, 0){"TIMER_LAST", 0}};
 const statInfo counter::counterInfo[] = {
-    KMP_FOREACH_COUNTER(expandName,0)
-    {"COUNTER_LAST", 0}
-};
+    KMP_FOREACH_COUNTER(expandName, 0){"COUNTER_LAST", 0}};
 #undef expandName
 
-#define expandName(ignore1,ignore2,ignore3)  {0.0,0.0,0.0},
+#define expandName(ignore1, ignore2, ignore3) {0.0, 0.0, 0.0},
 kmp_stats_output_module::rgb_color kmp_stats_output_module::timerColorInfo[] = {
-    KMP_FOREACH_TIMER(expandName,0)
-    {0.0,0.0,0.0}
-};
+    KMP_FOREACH_TIMER(expandName, 0){0.0, 0.0, 0.0}};
 #undef expandName
 
-const kmp_stats_output_module::rgb_color kmp_stats_output_module::globalColorArray[] = {
-    {1.0, 0.0, 0.0}, // red
-    {1.0, 0.6, 0.0}, // orange
-    {1.0, 1.0, 0.0}, // yellow
-    {0.0, 1.0, 0.0}, // green
-    {0.0, 0.0, 1.0}, // blue
-    {0.6, 0.2, 0.8}, // purple
-    {1.0, 0.0, 1.0}, // magenta
-    {0.0, 0.4, 0.2}, // dark green
-    {1.0, 1.0, 0.6}, // light yellow
-    {0.6, 0.4, 0.6}, // dirty purple
-    {0.0, 1.0, 1.0}, // cyan
-    {1.0, 0.4, 0.8}, // pink
-    {0.5, 0.5, 0.5}, // grey
-    {0.8, 0.7, 0.5}, // brown
-    {0.6, 0.6, 1.0}, // light blue
-    {1.0, 0.7, 0.5}, // peach
-    {0.8, 0.5, 1.0}, // lavender
-    {0.6, 0.0, 0.0}, // dark red
-    {0.7, 0.6, 0.0}, // gold
-    {0.0, 0.0, 0.0}  // black
+const kmp_stats_output_module::rgb_color
+    kmp_stats_output_module::globalColorArray[] = {
+        {1.0, 0.0, 0.0}, // red
+        {1.0, 0.6, 0.0}, // orange
+        {1.0, 1.0, 0.0}, // yellow
+        {0.0, 1.0, 0.0}, // green
+        {0.0, 0.0, 1.0}, // blue
+        {0.6, 0.2, 0.8}, // purple
+        {1.0, 0.0, 1.0}, // magenta
+        {0.0, 0.4, 0.2}, // dark green
+        {1.0, 1.0, 0.6}, // light yellow
+        {0.6, 0.4, 0.6}, // dirty purple
+        {0.0, 1.0, 1.0}, // cyan
+        {1.0, 0.4, 0.8}, // pink
+        {0.5, 0.5, 0.5}, // grey
+        {0.8, 0.7, 0.5}, // brown
+        {0.6, 0.6, 1.0}, // light blue
+        {1.0, 0.7, 0.5}, // peach
+        {0.8, 0.5, 1.0}, // lavender
+        {0.6, 0.0, 0.0}, // dark red
+        {0.7, 0.6, 0.0}, // gold
+        {0.0, 0.0, 0.0} // black
 };
 
 // Ensure that the atexit handler only runs once.
 static uint32_t statsPrinted = 0;
 
 // output interface
-static kmp_stats_output_module* __kmp_stats_global_output = NULL;
+static kmp_stats_output_module *__kmp_stats_global_output = NULL;
 
-/* ****************************************************** */
 /* ************* statistic member functions ************* */
 
-void statistic::addSample(double sample)
-{
-    double delta = sample - meanVal;
+void statistic::addSample(double sample) {
+  double delta = sample - meanVal;
 
-    sampleCount = sampleCount + 1;
-    meanVal     = meanVal + delta/sampleCount;
-    m2          = m2 + delta*(sample - meanVal);
+  sampleCount = sampleCount + 1;
+  meanVal = meanVal + delta / sampleCount;
+  m2 = m2 + delta * (sample - meanVal);
 
-    minVal = std::min(minVal, sample);
-    maxVal = std::max(maxVal, sample);
+  minVal = std::min(minVal, sample);
+  maxVal = std::max(maxVal, sample);
 }
 
-statistic & statistic::operator+= (const statistic & other)
-{
-    if (sampleCount == 0)
-    {
-        *this = other;
-        return *this;
-    }
-
-    uint64_t newSampleCount = sampleCount + other.sampleCount;
-    double dnsc  = double(newSampleCount);
-    double dsc   = double(sampleCount);
-    double dscBydnsc = dsc/dnsc;
-    double dosc  = double(other.sampleCount);
-    double delta = other.meanVal - meanVal;
-
-    // Try to order these calculations to avoid overflows.
-    // If this were Fortran, then the compiler would not be able to re-order over brackets.
-    // In C++ it may be legal to do that (we certainly hope it doesn't, and CC+ Programming Language 2nd edition
-    // suggests it shouldn't, since it says that exploitation of associativity can only be made if the operation
-    // really is associative (which floating addition isn't...)).
-    meanVal     = meanVal*dscBydnsc + other.meanVal*(1-dscBydnsc);
-    m2          = m2 + other.m2 + dscBydnsc*dosc*delta*delta;
-    minVal      = std::min (minVal, other.minVal);
-    maxVal      = std::max (maxVal, other.maxVal);
-    sampleCount = newSampleCount;
-
-
+statistic &statistic::operator+=(const statistic &other) {
+  if (sampleCount == 0) {
+    *this = other;
     return *this;
+  }
+
+  uint64_t newSampleCount = sampleCount + other.sampleCount;
+  double dnsc = double(newSampleCount);
+  double dsc = double(sampleCount);
+  double dscBydnsc = dsc / dnsc;
+  double dosc = double(other.sampleCount);
+  double delta = other.meanVal - meanVal;
+
+  // Try to order these calculations to avoid overflows. If this were Fortran,
+  // then the compiler would not be able to re-order over brackets. In C++ it
+  // may be legal to do that (we certainly hope it doesn't, and CC+ Programming
+  // Language 2nd edition suggests it shouldn't, since it says that exploitation
+  // of associativity can only be made if the operation really is associative
+  // (which floating addition isn't...)).
+  meanVal = meanVal * dscBydnsc + other.meanVal * (1 - dscBydnsc);
+  m2 = m2 + other.m2 + dscBydnsc * dosc * delta * delta;
+  minVal = std::min(minVal, other.minVal);
+  maxVal = std::max(maxVal, other.maxVal);
+  sampleCount = newSampleCount;
+
+  return *this;
+}
+
+void statistic::scale(double factor) {
+  minVal = minVal * factor;
+  maxVal = maxVal * factor;
+  meanVal = meanVal * factor;
+  m2 = m2 * factor * factor;
+  return;
+}
+
+std::string statistic::format(char unit, bool total) const {
+  std::string result = formatSI(sampleCount, 9, ' ');
+
+  if (sampleCount == 0) {
+    result = result + std::string(", ") + formatSI(0.0, 9, unit);
+    result = result + std::string(", ") + formatSI(0.0, 9, unit);
+    result = result + std::string(", ") + formatSI(0.0, 9, unit);
+    if (total)
+      result = result + std::string(", ") + formatSI(0.0, 9, unit);
+    result = result + std::string(", ") + formatSI(0.0, 9, unit);
+  } else {
+    result = result + std::string(", ") + formatSI(minVal, 9, unit);
+    result = result + std::string(", ") + formatSI(meanVal, 9, unit);
+    result = result + std::string(", ") + formatSI(maxVal, 9, unit);
+    if (total)
+      result =
+          result + std::string(", ") + formatSI(meanVal * sampleCount, 9, unit);
+    result = result + std::string(", ") + formatSI(getSD(), 9, unit);
+  }
+  return result;
 }
 
-void statistic::scale(double factor)
-{
-    minVal = minVal*factor;
-    maxVal = maxVal*factor;
-    meanVal= meanVal*factor;
-    m2     = m2*factor*factor;
-    return;
-}
-
-std::string statistic::format(char unit, bool total) const
-{
-    std::string result = formatSI(sampleCount,9,' ');
-
-    if (sampleCount == 0)
-    {
-        result = result + std::string(", ") + formatSI(0.0, 9, unit);
-        result = result + std::string(", ") + formatSI(0.0, 9, unit);
-        result = result + std::string(", ") + formatSI(0.0, 9, unit);
-        if (total)
-            result = result + std::string(", ") + formatSI(0.0, 9, unit);
-        result = result + std::string(", ") + formatSI(0.0, 9, unit);
-    }
-    else
-    {
-        result = result + std::string(", ") + formatSI(minVal,  9, unit);
-        result = result + std::string(", ") + formatSI(meanVal, 9, unit);
-        result = result + std::string(", ") + formatSI(maxVal,  9, unit);
-        if (total)
-            result = result + std::string(", ") + formatSI(meanVal*sampleCount, 9, unit);
-        result = result + std::string(", ") + formatSI(getSD(), 9, unit);
-    }
-    return result;
-}
-
-/* ********************************************************** */
 /* ************* explicitTimer member functions ************* */
 
 void explicitTimer::start(timer_e timerEnumValue) {
-    startTime = tsc_tick_count::now();
-    totalPauseTime = 0;
-    if(timeStat::logEvent(timerEnumValue)) {
-        __kmp_stats_thread_ptr->incrementNestValue();
-    }
-    return;
+  startTime = tsc_tick_count::now();
+  totalPauseTime = 0;
+  if (timeStat::logEvent(timerEnumValue)) {
+    __kmp_stats_thread_ptr->incrementNestValue();
+  }
+  return;
 }
 
-void explicitTimer::stop(timer_e timerEnumValue, kmp_stats_list* stats_ptr /* = nullptr */) {
-    if (startTime.getValue() == 0)
-        return;
+void explicitTimer::stop(timer_e timerEnumValue,
+                         kmp_stats_list *stats_ptr /* = nullptr */) {
+  if (startTime.getValue() == 0)
+    return;
 
-    tsc_tick_count finishTime = tsc_tick_count::now();
+  tsc_tick_count finishTime = tsc_tick_count::now();
 
-    //stat->addSample ((tsc_tick_count::now() - startTime).ticks());
-    stat->addSample(((finishTime - startTime) - totalPauseTime).ticks());
+  // stat->addSample ((tsc_tick_count::now() - startTime).ticks());
+  stat->addSample(((finishTime - startTime) - totalPauseTime).ticks());
 
-    if(timeStat::logEvent(timerEnumValue)) {
-        if(!stats_ptr)
-            stats_ptr = __kmp_stats_thread_ptr;
-        stats_ptr->push_event(startTime.getValue() - __kmp_stats_start_time.getValue(), finishTime.getValue() - __kmp_stats_start_time.getValue(), __kmp_stats_thread_ptr->getNestValue(), timerEnumValue);
-        stats_ptr->decrementNestValue();
-    }
+  if (timeStat::logEvent(timerEnumValue)) {
+    if (!stats_ptr)
+      stats_ptr = __kmp_stats_thread_ptr;
+    stats_ptr->push_event(
+        startTime.getValue() - __kmp_stats_start_time.getValue(),
+        finishTime.getValue() - __kmp_stats_start_time.getValue(),
+        __kmp_stats_thread_ptr->getNestValue(), timerEnumValue);
+    stats_ptr->decrementNestValue();
+  }
 
-    /* We accept the risk that we drop a sample because it really did start at t==0. */
-    startTime = 0;
-    return;
+  /* We accept the risk that we drop a sample because it really did start at
+     t==0. */
+  startTime = 0;
+  return;
 }
 
-/* ************************************************************** */
 /* ************* partitionedTimers member functions ************* */
-partitionedTimers::partitionedTimers() {
-    timer_stack.reserve(8);
-}
+partitionedTimers::partitionedTimers() { timer_stack.reserve(8); }
 
 // add a timer to this collection of partitioned timers.
-void partitionedTimers::add_timer(explicit_timer_e timer_index, explicitTimer* timer_pointer) {
-    KMP_DEBUG_ASSERT((int)timer_index < (int)EXPLICIT_TIMER_LAST+1);
-    timers[timer_index] = timer_pointer;
+void partitionedTimers::add_timer(explicit_timer_e timer_index,
+                                  explicitTimer *timer_pointer) {
+  KMP_DEBUG_ASSERT((int)timer_index < (int)EXPLICIT_TIMER_LAST + 1);
+  timers[timer_index] = timer_pointer;
 }
 
 // initialize the paritioned timers to an initial timer
 void partitionedTimers::init(timerPair init_timer_pair) {
-    KMP_DEBUG_ASSERT(this->timer_stack.size() == 0);
-    timer_stack.push_back(init_timer_pair);
-    timers[init_timer_pair.get_index()]->start(init_timer_pair.get_timer());
+  KMP_DEBUG_ASSERT(this->timer_stack.size() == 0);
+  timer_stack.push_back(init_timer_pair);
+  timers[init_timer_pair.get_index()]->start(init_timer_pair.get_timer());
 }
 
 // stop/save the current timer, and start the new timer (timer_pair)
@@ -209,33 +199,33 @@ void partitionedTimers::init(timerPair init_timer_pair) {
 // the one you are trying to push, then it only manipulates the stack,
 // and it won't stop/start the currently running timer.
 void partitionedTimers::push(timerPair timer_pair) {
-    // get the current timer
-    // stop current timer
-    // push new timer
-    // start the new timer
-    KMP_DEBUG_ASSERT(this->timer_stack.size() > 0);
-    timerPair current_timer = timer_stack.back();
-    timer_stack.push_back(timer_pair);
-    if(current_timer != timer_pair) {
-        timers[current_timer.get_index()]->pause();
-        timers[timer_pair.get_index()]->start(timer_pair.get_timer());
-    }
+  // get the current timer
+  // stop current timer
+  // push new timer
+  // start the new timer
+  KMP_DEBUG_ASSERT(this->timer_stack.size() > 0);
+  timerPair current_timer = timer_stack.back();
+  timer_stack.push_back(timer_pair);
+  if (current_timer != timer_pair) {
+    timers[current_timer.get_index()]->pause();
+    timers[timer_pair.get_index()]->start(timer_pair.get_timer());
+  }
 }
 
 // stop/discard the current timer, and start the previously saved timer
 void partitionedTimers::pop() {
-    // get the current timer
-    // stop current timer
-    // pop current timer
-    // get the new current timer and start it back up
-    KMP_DEBUG_ASSERT(this->timer_stack.size() > 1);
-    timerPair current_timer = timer_stack.back();
-    timer_stack.pop_back();
-    timerPair new_timer = timer_stack.back();
-    if(current_timer != new_timer) {
-        timers[current_timer.get_index()]->stop(current_timer.get_timer());
-        timers[new_timer.get_index()]->resume();
-    }
+  // get the current timer
+  // stop current timer
+  // pop current timer
+  // get the new current timer and start it back up
+  KMP_DEBUG_ASSERT(this->timer_stack.size() > 1);
+  timerPair current_timer = timer_stack.back();
+  timer_stack.pop_back();
+  timerPair new_timer = timer_stack.back();
+  if (current_timer != new_timer) {
+    timers[current_timer.get_index()]->stop(current_timer.get_timer());
+    timers[new_timer.get_index()]->resume();
+  }
 }
 
 // Wind up all the currently running timers.
@@ -243,481 +233,483 @@ void partitionedTimers::pop() {
 // After this is called, init() must be run again to initialize the
 // stack of timers
 void partitionedTimers::windup() {
-    while(timer_stack.size() > 1) {
-        this->pop();
-    }
-    if(timer_stack.size() > 0) {
-        timerPair last_timer = timer_stack.back();
-        timer_stack.pop_back();
-        timers[last_timer.get_index()]->stop(last_timer.get_timer());
-    }
+  while (timer_stack.size() > 1) {
+    this->pop();
+  }
+  if (timer_stack.size() > 0) {
+    timerPair last_timer = timer_stack.back();
+    timer_stack.pop_back();
+    timers[last_timer.get_index()]->stop(last_timer.get_timer());
+  }
 }
 
-/* ******************************************************************* */
 /* ************* kmp_stats_event_vector member functions ************* */
 
 void kmp_stats_event_vector::deallocate() {
-    __kmp_free(events);
-    internal_size = 0;
-    allocated_size = 0;
-    events = NULL;
+  __kmp_free(events);
+  internal_size = 0;
+  allocated_size = 0;
+  events = NULL;
 }
 
 // This function is for qsort() which requires the compare function to return
-// either a negative number if event1 < event2, a positive number if event1 > event2
-// or zero if event1 == event2.
-// This sorts by start time (lowest to highest).
-int compare_two_events(const void* event1, const void* event2) {
-    kmp_stats_event* ev1 = (kmp_stats_event*)event1;
-    kmp_stats_event* ev2 = (kmp_stats_event*)event2;
+// either a negative number if event1 < event2, a positive number if event1 >
+// event2 or zero if event1 == event2. This sorts by start time (lowest to
+// highest).
+int compare_two_events(const void *event1, const void *event2) {
+  kmp_stats_event *ev1 = (kmp_stats_event *)event1;
+  kmp_stats_event *ev2 = (kmp_stats_event *)event2;
 
-    if(ev1->getStart() < ev2->getStart()) return -1;
-    else if(ev1->getStart() > ev2->getStart()) return 1;
-    else return 0;
+  if (ev1->getStart() < ev2->getStart())
+    return -1;
+  else if (ev1->getStart() > ev2->getStart())
+    return 1;
+  else
+    return 0;
 }
 
 void kmp_stats_event_vector::sort() {
-    qsort(events, internal_size, sizeof(kmp_stats_event), compare_two_events);
+  qsort(events, internal_size, sizeof(kmp_stats_event), compare_two_events);
 }
 
-/* *********************************************************** */
 /* ************* kmp_stats_list member functions ************* */
 
 // returns a pointer to newly created stats node
-kmp_stats_list* kmp_stats_list::push_back(int gtid) {
-    kmp_stats_list* newnode = (kmp_stats_list*)__kmp_allocate(sizeof(kmp_stats_list));
-    // placement new, only requires space and pointer and initializes (so __kmp_allocate instead of C++ new[] is used)
-    new (newnode) kmp_stats_list();
-    newnode->setGtid(gtid);
-    newnode->prev = this->prev;
-    newnode->next = this;
-    newnode->prev->next = newnode;
-    newnode->next->prev = newnode;
-    return newnode;
+kmp_stats_list *kmp_stats_list::push_back(int gtid) {
+  kmp_stats_list *newnode =
+      (kmp_stats_list *)__kmp_allocate(sizeof(kmp_stats_list));
+  // placement new, only requires space and pointer and initializes (so
+  // __kmp_allocate instead of C++ new[] is used)
+  new (newnode) kmp_stats_list();
+  newnode->setGtid(gtid);
+  newnode->prev = this->prev;
+  newnode->next = this;
+  newnode->prev->next = newnode;
+  newnode->next->prev = newnode;
+  return newnode;
 }
 void kmp_stats_list::deallocate() {
-    kmp_stats_list* ptr = this->next;
-    kmp_stats_list* delptr = this->next;
-    while(ptr != this) {
-        delptr = ptr;
-        ptr=ptr->next;
-        // placement new means we have to explicitly call destructor.
-        delptr->_event_vector.deallocate();
-        delptr->~kmp_stats_list();
-        __kmp_free(delptr);
-    }
+  kmp_stats_list *ptr = this->next;
+  kmp_stats_list *delptr = this->next;
+  while (ptr != this) {
+    delptr = ptr;
+    ptr = ptr->next;
+    // placement new means we have to explicitly call destructor.
+    delptr->_event_vector.deallocate();
+    delptr->~kmp_stats_list();
+    __kmp_free(delptr);
+  }
 }
 kmp_stats_list::iterator kmp_stats_list::begin() {
-    kmp_stats_list::iterator it;
-    it.ptr = this->next;
-    return it;
+  kmp_stats_list::iterator it;
+  it.ptr = this->next;
+  return it;
 }
 kmp_stats_list::iterator kmp_stats_list::end() {
-    kmp_stats_list::iterator it;
-    it.ptr = this;
-    return it;
+  kmp_stats_list::iterator it;
+  it.ptr = this;
+  return it;
 }
 int kmp_stats_list::size() {
-    int retval;
-    kmp_stats_list::iterator it;
-    for(retval=0, it=begin(); it!=end(); it++, retval++) {}
-    return retval;
+  int retval;
+  kmp_stats_list::iterator it;
+  for (retval = 0, it = begin(); it != end(); it++, retval++) {
+  }
+  return retval;
 }
 
-/* ********************************************************************* */
 /* ************* kmp_stats_list::iterator member functions ************* */
 
 kmp_stats_list::iterator::iterator() : ptr(NULL) {}
 kmp_stats_list::iterator::~iterator() {}
 kmp_stats_list::iterator kmp_stats_list::iterator::operator++() {
-    this->ptr = this->ptr->next;
-    return *this;
+  this->ptr = this->ptr->next;
+  return *this;
 }
 kmp_stats_list::iterator kmp_stats_list::iterator::operator++(int dummy) {
-    this->ptr = this->ptr->next;
-    return *this;
+  this->ptr = this->ptr->next;
+  return *this;
 }
 kmp_stats_list::iterator kmp_stats_list::iterator::operator--() {
-    this->ptr = this->ptr->prev;
-    return *this;
+  this->ptr = this->ptr->prev;
+  return *this;
 }
 kmp_stats_list::iterator kmp_stats_list::iterator::operator--(int dummy) {
-    this->ptr = this->ptr->prev;
-    return *this;
+  this->ptr = this->ptr->prev;
+  return *this;
 }
-bool kmp_stats_list::iterator::operator!=(const kmp_stats_list::iterator & rhs) {
-   return this->ptr!=rhs.ptr;
+bool kmp_stats_list::iterator::operator!=(const kmp_stats_list::iterator &rhs) {
+  return this->ptr != rhs.ptr;
 }
-bool kmp_stats_list::iterator::operator==(const kmp_stats_list::iterator & rhs) {
-   return this->ptr==rhs.ptr;
+bool kmp_stats_list::iterator::operator==(const kmp_stats_list::iterator &rhs) {
+  return this->ptr == rhs.ptr;
 }
-kmp_stats_list* kmp_stats_list::iterator::operator*() const {
-    return this->ptr;
+kmp_stats_list *kmp_stats_list::iterator::operator*() const {
+  return this->ptr;
 }
 
-/* *************************************************************** */
 /* *************  kmp_stats_output_module functions ************** */
 
-const char* kmp_stats_output_module::eventsFileName = NULL;
-const char* kmp_stats_output_module::plotFileName   = NULL;
-int kmp_stats_output_module::printPerThreadFlag       = 0;
+const char *kmp_stats_output_module::eventsFileName = NULL;
+const char *kmp_stats_output_module::plotFileName = NULL;
+int kmp_stats_output_module::printPerThreadFlag = 0;
 int kmp_stats_output_module::printPerThreadEventsFlag = 0;
 
-// init() is called very near the beginning of execution time in the constructor of __kmp_stats_global_output
-void kmp_stats_output_module::init()
-{
-    char * statsFileName  = getenv("KMP_STATS_FILE");
-    eventsFileName        = getenv("KMP_STATS_EVENTS_FILE");
-    plotFileName          = getenv("KMP_STATS_PLOT_FILE");
-    char * threadStats    = getenv("KMP_STATS_THREADS");
-    char * threadEvents   = getenv("KMP_STATS_EVENTS");
-
-    // set the stats output filenames based on environment variables and defaults
-    if(statsFileName) {
-        // append the process id to the output filename
-        // events.csv --> events-pid.csv
-        size_t index;
-        std::string baseFileName, pid, suffix;
-        std::stringstream ss;
-        outputFileName = std::string(statsFileName);
-        index = outputFileName.find_last_of('.');
-        if(index == std::string::npos) {
-            baseFileName = outputFileName;
-        } else {
-            baseFileName = outputFileName.substr(0, index);
-            suffix = outputFileName.substr(index);
-        }
-        ss << getpid();
-        pid = ss.str();
-        outputFileName = baseFileName + "-" + pid + suffix;
-    }
-    eventsFileName = eventsFileName ? eventsFileName : "events.dat";
-    plotFileName   = plotFileName   ? plotFileName   : "events.plt";
-
-    // set the flags based on environment variables matching: true, on, 1, .true. , .t. , yes
-    printPerThreadFlag        = __kmp_str_match_true(threadStats);
-    printPerThreadEventsFlag  = __kmp_str_match_true(threadEvents);
-
-    if(printPerThreadEventsFlag) {
-        // assigns a color to each timer for printing
-        setupEventColors();
+// init() is called very near the beginning of execution time in the constructor
+// of __kmp_stats_global_output
+void kmp_stats_output_module::init() {
+  char *statsFileName = getenv("KMP_STATS_FILE");
+  eventsFileName = getenv("KMP_STATS_EVENTS_FILE");
+  plotFileName = getenv("KMP_STATS_PLOT_FILE");
+  char *threadStats = getenv("KMP_STATS_THREADS");
+  char *threadEvents = getenv("KMP_STATS_EVENTS");
+
+  // set the stats output filenames based on environment variables and defaults
+  if (statsFileName) {
+    // append the process id to the output filename
+    // events.csv --> events-pid.csv
+    size_t index;
+    std::string baseFileName, pid, suffix;
+    std::stringstream ss;
+    outputFileName = std::string(statsFileName);
+    index = outputFileName.find_last_of('.');
+    if (index == std::string::npos) {
+      baseFileName = outputFileName;
     } else {
-        // will clear flag so that no event will be logged
-        timeStat::clearEventFlags();
+      baseFileName = outputFileName.substr(0, index);
+      suffix = outputFileName.substr(index);
     }
+    ss << getpid();
+    pid = ss.str();
+    outputFileName = baseFileName + "-" + pid + suffix;
+  }
+  eventsFileName = eventsFileName ? eventsFileName : "events.dat";
+  plotFileName = plotFileName ? plotFileName : "events.plt";
 
-    return;
-}
+  // set the flags based on environment variables matching: true, on, 1, .true.
+  // , .t. , yes
+  printPerThreadFlag = __kmp_str_match_true(threadStats);
+  printPerThreadEventsFlag = __kmp_str_match_true(threadEvents);
 
-void kmp_stats_output_module::setupEventColors() {
-    int i;
-    int globalColorIndex = 0;
-    int numGlobalColors = sizeof(globalColorArray) / sizeof(rgb_color);
-    for(i=0;i<TIMER_LAST;i++) {
-        if(timeStat::logEvent((timer_e)i)) {
-            timerColorInfo[i] = globalColorArray[globalColorIndex];
-            globalColorIndex = (globalColorIndex+1)%numGlobalColors;
-        }
-    }
-    return;
-}
+  if (printPerThreadEventsFlag) {
+    // assigns a color to each timer for printing
+    setupEventColors();
+  } else {
+    // will clear flag so that no event will be logged
+    timeStat::clearEventFlags();
+  }
 
-void kmp_stats_output_module::printTimerStats(FILE *statsOut, statistic const * theStats, statistic const * totalStats)
-{
-    fprintf (statsOut, "Timer,                      SampleCount,    Min,      Mean,       Max,     Total,        SD\n");
-    for (timer_e s = timer_e(0); s<TIMER_LAST; s = timer_e(s+1)) {
-        statistic const * stat = &theStats[s];
-        char tag = timeStat::noUnits(s) ? ' ' : 'T';
-
-        fprintf (statsOut, "%-28s, %s\n", timeStat::name(s), stat->format(tag, true).c_str());
-    }
-    // Also print the Total_ versions of times.
-    for (timer_e s = timer_e(0); s<TIMER_LAST; s = timer_e(s+1)) {
-        char tag = timeStat::noUnits(s) ? ' ' : 'T';
-        if (totalStats && !timeStat::noTotal(s))
-            fprintf(statsOut, "Total_%-22s, %s\n", timeStat::name(s), totalStats[s].format(tag, true).c_str());
-    }
-}
-
-void kmp_stats_output_module::printCounterStats(FILE *statsOut, statistic const * theStats)
-{
-    fprintf (statsOut, "Counter,                 ThreadCount,    Min,      Mean,       Max,     Total,        SD\n");
-    for (int s = 0; s<COUNTER_LAST; s++) {
-        statistic const * stat = &theStats[s];
-        fprintf (statsOut, "%-25s, %s\n", counter::name(counter_e(s)), stat->format(' ', true).c_str());
-    }
-}
-
-void kmp_stats_output_module::printCounters(FILE * statsOut, counter const * theCounters)
-{
-    // We print all the counters even if they are zero.
-    // That makes it easier to slice them into a spreadsheet if you need to.
-    fprintf (statsOut, "\nCounter,                    Count\n");
-    for (int c = 0; c<COUNTER_LAST; c++) {
-        counter const * stat = &theCounters[c];
-        fprintf (statsOut, "%-25s, %s\n", counter::name(counter_e(c)), formatSI(stat->getValue(), 9, ' ').c_str());
-    }
+  return;
 }
 
-void kmp_stats_output_module::printEvents(FILE* eventsOut, kmp_stats_event_vector* theEvents, int gtid) {
-    // sort by start time before printing
-    theEvents->sort();
-    for (int i = 0; i < theEvents->size(); i++) {
-        kmp_stats_event ev = theEvents->at(i);
-        rgb_color color = getEventColor(ev.getTimerName());
-        fprintf(eventsOut, "%d %lu %lu %1.1f rgb(%1.1f,%1.1f,%1.1f) %s\n",
-                gtid,
-                ev.getStart(),
-                ev.getStop(),
-                1.2 - (ev.getNestLevel() * 0.2),
-                color.r, color.g, color.b,
-                timeStat::name(ev.getTimerName())
-               );
+void kmp_stats_output_module::setupEventColors() {
+  int i;
+  int globalColorIndex = 0;
+  int numGlobalColors = sizeof(globalColorArray) / sizeof(rgb_color);
+  for (i = 0; i < TIMER_LAST; i++) {
+    if (timeStat::logEvent((timer_e)i)) {
+      timerColorInfo[i] = globalColorArray[globalColorIndex];
+      globalColorIndex = (globalColorIndex + 1) % numGlobalColors;
     }
-    return;
-}
-
-void kmp_stats_output_module::windupExplicitTimers()
-{
-    // Wind up any explicit timers. We assume that it's fair at this point to just walk all the explcit timers in all threads
-    // and say "it's over".
-    // If the timer wasn't running, this won't record anything anyway.
-    kmp_stats_list::iterator it;
-    for(it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
-        kmp_stats_list* ptr = *it;
-        ptr->getPartitionedTimers()->windup();
-        for (int timer=0; timer<EXPLICIT_TIMER_LAST; timer++) {
-            ptr->getExplicitTimer(explicit_timer_e(timer))->stop((timer_e)timer, ptr);
-        }
+  }
+  return;
+}
+
+void kmp_stats_output_module::printTimerStats(FILE *statsOut,
+                                              statistic const *theStats,
+                                              statistic const *totalStats) {
+  fprintf(statsOut, "Timer,                      SampleCount,    Min,      "
+                    "Mean,       Max,     Total,        SD\n");
+  for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
+    statistic const *stat = &theStats[s];
+    char tag = timeStat::noUnits(s) ? ' ' : 'T';
+
+    fprintf(statsOut, "%-28s, %s\n", timeStat::name(s),
+            stat->format(tag, true).c_str());
+  }
+  // Also print the Total_ versions of times.
+  for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
+    char tag = timeStat::noUnits(s) ? ' ' : 'T';
+    if (totalStats && !timeStat::noTotal(s))
+      fprintf(statsOut, "Total_%-22s, %s\n", timeStat::name(s),
+              totalStats[s].format(tag, true).c_str());
+  }
+}
+
+void kmp_stats_output_module::printCounterStats(FILE *statsOut,
+                                                statistic const *theStats) {
+  fprintf(statsOut, "Counter,                 ThreadCount,    Min,      Mean,  "
+                    "     Max,     Total,        SD\n");
+  for (int s = 0; s < COUNTER_LAST; s++) {
+    statistic const *stat = &theStats[s];
+    fprintf(statsOut, "%-25s, %s\n", counter::name(counter_e(s)),
+            stat->format(' ', true).c_str());
+  }
+}
+
+void kmp_stats_output_module::printCounters(FILE *statsOut,
+                                            counter const *theCounters) {
+  // We print all the counters even if they are zero.
+  // That makes it easier to slice them into a spreadsheet if you need to.
+  fprintf(statsOut, "\nCounter,                    Count\n");
+  for (int c = 0; c < COUNTER_LAST; c++) {
+    counter const *stat = &theCounters[c];
+    fprintf(statsOut, "%-25s, %s\n", counter::name(counter_e(c)),
+            formatSI(stat->getValue(), 9, ' ').c_str());
+  }
+}
+
+void kmp_stats_output_module::printEvents(FILE *eventsOut,
+                                          kmp_stats_event_vector *theEvents,
+                                          int gtid) {
+  // sort by start time before printing
+  theEvents->sort();
+  for (int i = 0; i < theEvents->size(); i++) {
+    kmp_stats_event ev = theEvents->at(i);
+    rgb_color color = getEventColor(ev.getTimerName());
+    fprintf(eventsOut, "%d %lu %lu %1.1f rgb(%1.1f,%1.1f,%1.1f) %s\n", gtid,
+            ev.getStart(), ev.getStop(), 1.2 - (ev.getNestLevel() * 0.2),
+            color.r, color.g, color.b, timeStat::name(ev.getTimerName()));
+  }
+  return;
+}
+
+void kmp_stats_output_module::windupExplicitTimers() {
+  // Wind up any explicit timers. We assume that it's fair at this point to just
+  // walk all the explcit timers in all threads and say "it's over".
+  // If the timer wasn't running, this won't record anything anyway.
+  kmp_stats_list::iterator it;
+  for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
+    kmp_stats_list *ptr = *it;
+    ptr->getPartitionedTimers()->windup();
+    for (int timer = 0; timer < EXPLICIT_TIMER_LAST; timer++) {
+      ptr->getExplicitTimer(explicit_timer_e(timer))->stop((timer_e)timer, ptr);
     }
+  }
 }
 
 void kmp_stats_output_module::printPloticusFile() {
-    int i;
-    int size = __kmp_stats_list->size();
-    FILE* plotOut = fopen(plotFileName, "w+");
-
-    fprintf(plotOut, "#proc page\n"
-                     "   pagesize: 15 10\n"
-                     "   scale: 1.0\n\n");
-
-    fprintf(plotOut, "#proc getdata\n"
-                     "   file: %s\n\n",
-                     eventsFileName);
-
-    fprintf(plotOut, "#proc areadef\n"
-                     "   title: OpenMP Sampling Timeline\n"
-                     "   titledetails: align=center size=16\n"
-                     "   rectangle: 1 1 13 9\n"
-                     "   xautorange: datafield=2,3\n"
-                     "   yautorange: -1 %d\n\n",
-                     size);
-
-    fprintf(plotOut, "#proc xaxis\n"
-                     "   stubs: inc\n"
-                     "   stubdetails: size=12\n"
-                     "   label: Time (ticks)\n"
-                     "   labeldetails: size=14\n\n");
-
-    fprintf(plotOut, "#proc yaxis\n"
-                     "   stubs: inc 1\n"
-                     "   stubrange: 0 %d\n"
-                     "   stubdetails: size=12\n"
-                     "   label: Thread #\n"
-                     "   labeldetails: size=14\n\n",
-                     size-1);
-
-    fprintf(plotOut, "#proc bars\n"
-                     "   exactcolorfield: 5\n"
-                     "   axis: x\n"
-                     "   locfield: 1\n"
-                     "   segmentfields: 2 3\n"
-                     "   barwidthfield: 4\n\n");
-
-    // create legend entries corresponding to the timer color
-    for(i=0;i<TIMER_LAST;i++) {
-        if(timeStat::logEvent((timer_e)i)) {
-            rgb_color c = getEventColor((timer_e)i);
-            fprintf(plotOut, "#proc legendentry\n"
-                             "   sampletype: color\n"
-                             "   label: %s\n"
-                             "   details: rgb(%1.1f,%1.1f,%1.1f)\n\n",
-                             timeStat::name((timer_e)i),
-                             c.r, c.g, c.b);
-
-        }
+  int i;
+  int size = __kmp_stats_list->size();
+  FILE *plotOut = fopen(plotFileName, "w+");
+
+  fprintf(plotOut, "#proc page\n"
+                   "   pagesize: 15 10\n"
+                   "   scale: 1.0\n\n");
+
+  fprintf(plotOut, "#proc getdata\n"
+                   "   file: %s\n\n",
+          eventsFileName);
+
+  fprintf(plotOut, "#proc areadef\n"
+                   "   title: OpenMP Sampling Timeline\n"
+                   "   titledetails: align=center size=16\n"
+                   "   rectangle: 1 1 13 9\n"
+                   "   xautorange: datafield=2,3\n"
+                   "   yautorange: -1 %d\n\n",
+          size);
+
+  fprintf(plotOut, "#proc xaxis\n"
+                   "   stubs: inc\n"
+                   "   stubdetails: size=12\n"
+                   "   label: Time (ticks)\n"
+                   "   labeldetails: size=14\n\n");
+
+  fprintf(plotOut, "#proc yaxis\n"
+                   "   stubs: inc 1\n"
+                   "   stubrange: 0 %d\n"
+                   "   stubdetails: size=12\n"
+                   "   label: Thread #\n"
+                   "   labeldetails: size=14\n\n",
+          size - 1);
+
+  fprintf(plotOut, "#proc bars\n"
+                   "   exactcolorfield: 5\n"
+                   "   axis: x\n"
+                   "   locfield: 1\n"
+                   "   segmentfields: 2 3\n"
+                   "   barwidthfield: 4\n\n");
+
+  // create legend entries corresponding to the timer color
+  for (i = 0; i < TIMER_LAST; i++) {
+    if (timeStat::logEvent((timer_e)i)) {
+      rgb_color c = getEventColor((timer_e)i);
+      fprintf(plotOut, "#proc legendentry\n"
+                       "   sampletype: color\n"
+                       "   label: %s\n"
+                       "   details: rgb(%1.1f,%1.1f,%1.1f)\n\n",
+              timeStat::name((timer_e)i), c.r, c.g, c.b);
     }
-
-    fprintf(plotOut, "#proc legend\n"
-                     "   format: down\n"
-                     "   location: max max\n\n");
-    fclose(plotOut);
-    return;
-}
-
-/*
- * Print some useful information about
- *    * the date and time this experiment ran.
- *    * the machine on which it ran.
- * We output all of this as stylised comments, though we may decide to parse some of it.
- */
-void kmp_stats_output_module::printHeaderInfo(FILE * statsOut)
-{
-    std::time_t now = std::time(0);
-    char buffer[40];
-    char hostName[80];
-
-    std::strftime(&buffer[0], sizeof(buffer), "%c", std::localtime(&now));
-    fprintf (statsOut, "# Time of run: %s\n", &buffer[0]);
-    if (gethostname(&hostName[0], sizeof(hostName)) == 0)
-        fprintf (statsOut,"# Hostname: %s\n", &hostName[0]);
+  }
+
+  fprintf(plotOut, "#proc legend\n"
+                   "   format: down\n"
+                   "   location: max max\n\n");
+  fclose(plotOut);
+  return;
+}
+
+/* Print some useful information about
+   * the date and time this experiment ran.
+   * the machine on which it ran.
+   We output all of this as stylised comments, though we may decide to parse
+   some of it. */
+void kmp_stats_output_module::printHeaderInfo(FILE *statsOut) {
+  std::time_t now = std::time(0);
+  char buffer[40];
+  char hostName[80];
+
+  std::strftime(&buffer[0], sizeof(buffer), "%c", std::localtime(&now));
+  fprintf(statsOut, "# Time of run: %s\n", &buffer[0]);
+  if (gethostname(&hostName[0], sizeof(hostName)) == 0)
+    fprintf(statsOut, "# Hostname: %s\n", &hostName[0]);
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-    fprintf (statsOut, "# CPU:  %s\n", &__kmp_cpuinfo.name[0]);
-    fprintf (statsOut, "# Family: %d, Model: %d, Stepping: %d\n", __kmp_cpuinfo.family, __kmp_cpuinfo.model, __kmp_cpuinfo.stepping);
-    if (__kmp_cpuinfo.frequency == 0)
-        fprintf (statsOut, "# Nominal frequency: Unknown\n");
-    else
-        fprintf (statsOut, "# Nominal frequency: %sz\n", formatSI(double(__kmp_cpuinfo.frequency),9,'H').c_str());
+  fprintf(statsOut, "# CPU:  %s\n", &__kmp_cpuinfo.name[0]);
+  fprintf(statsOut, "# Family: %d, Model: %d, Stepping: %d\n",
+          __kmp_cpuinfo.family, __kmp_cpuinfo.model, __kmp_cpuinfo.stepping);
+  if (__kmp_cpuinfo.frequency == 0)
+    fprintf(statsOut, "# Nominal frequency: Unknown\n");
+  else
+    fprintf(statsOut, "# Nominal frequency: %sz\n",
+            formatSI(double(__kmp_cpuinfo.frequency), 9, 'H').c_str());
 #endif
 }
 
-void kmp_stats_output_module::outputStats(const char* heading)
-{
-    // Stop all the explicit timers in all threads
-    // Do this before declaring the local statistics because thay have constructors so will take time to create.
-    windupExplicitTimers();
-
-    statistic allStats[TIMER_LAST];
-    statistic totalStats[TIMER_LAST];           /* Synthesized, cross threads versions of normal timer stats */
-    statistic allCounters[COUNTER_LAST];
-
-    FILE * statsOut = !outputFileName.empty() ? fopen (outputFileName.c_str(), "a+") : stderr;
-    if (!statsOut)
-        statsOut = stderr;
-
-    FILE * eventsOut;
+void kmp_stats_output_module::outputStats(const char *heading) {
+  // Stop all the explicit timers in all threads
+  // Do this before declaring the local statistics because thay have
+  // constructors so will take time to create.
+  windupExplicitTimers();
+
+  statistic allStats[TIMER_LAST];
+  statistic totalStats[TIMER_LAST]; /* Synthesized, cross threads versions of
+                                       normal timer stats */
+  statistic allCounters[COUNTER_LAST];
+
+  FILE *statsOut =
+      !outputFileName.empty() ? fopen(outputFileName.c_str(), "a+") : stderr;
+  if (!statsOut)
+    statsOut = stderr;
+
+  FILE *eventsOut;
+  if (eventPrintingEnabled()) {
+    eventsOut = fopen(eventsFileName, "w+");
+  }
+
+  printHeaderInfo(statsOut);
+  fprintf(statsOut, "%s\n", heading);
+  // Accumulate across threads.
+  kmp_stats_list::iterator it;
+  for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
+    int t = (*it)->getGtid();
+    // Output per thread stats if requested.
+    if (printPerThreadFlag) {
+      fprintf(statsOut, "Thread %d\n", t);
+      printTimerStats(statsOut, (*it)->getTimers(), 0);
+      printCounters(statsOut, (*it)->getCounters());
+      fprintf(statsOut, "\n");
+    }
+    // Output per thread events if requested.
     if (eventPrintingEnabled()) {
-        eventsOut = fopen(eventsFileName, "w+");
+      kmp_stats_event_vector events = (*it)->getEventVector();
+      printEvents(eventsOut, &events, t);
     }
 
-    printHeaderInfo (statsOut);
-    fprintf(statsOut, "%s\n",heading);
-    // Accumulate across threads.
-    kmp_stats_list::iterator it;
-    for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
-        int t = (*it)->getGtid();
-        // Output per thread stats if requested.
-        if (printPerThreadFlag) {
-            fprintf (statsOut, "Thread %d\n", t);
-            printTimerStats (statsOut, (*it)->getTimers(), 0);
-            printCounters   (statsOut, (*it)->getCounters());
-            fprintf (statsOut,"\n");
-        }
-        // Output per thread events if requested.
-        if (eventPrintingEnabled()) {
-            kmp_stats_event_vector events = (*it)->getEventVector();
-            printEvents(eventsOut, &events, t);
-        }
-
-        // Accumulate timers.
-        for (timer_e s = timer_e(0); s<TIMER_LAST; s = timer_e(s+1)) {
-            // See if we should ignore this timer when aggregating
-            if ((timeStat::masterOnly(s) && (t != 0)) || // Timer is only valid on the master and this thread is a worker
-                (timeStat::workerOnly(s) && (t == 0))    // Timer is only valid on a worker and this thread is the master
-               )
-            {
-                continue;
-            }
-
-            statistic * threadStat = (*it)->getTimer(s);
-            allStats[s] += *threadStat;
-
-            // Add Total stats for timers that are valid in more than one thread
-            if (!timeStat::noTotal(s))
-                totalStats[s].addSample(threadStat->getTotal());
-        }
-
-        // Accumulate counters.
-        for (counter_e c = counter_e(0); c<COUNTER_LAST; c = counter_e(c+1)) {
-            if (counter::masterOnly(c) && t != 0)
-                continue;
-            allCounters[c].addSample ((*it)->getCounter(c)->getValue());
-        }
+    // Accumulate timers.
+    for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
+      // See if we should ignore this timer when aggregating
+      if ((timeStat::masterOnly(s) && (t != 0)) || // Timer only valid on master
+          // and this thread is worker
+          (timeStat::workerOnly(s) && (t == 0)) // Timer only valid on worker
+          // and this thread is the master
+          ) {
+        continue;
+      }
+
+      statistic *threadStat = (*it)->getTimer(s);
+      allStats[s] += *threadStat;
+
+      // Add Total stats for timers that are valid in more than one thread
+      if (!timeStat::noTotal(s))
+        totalStats[s].addSample(threadStat->getTotal());
     }
 
-    if (eventPrintingEnabled()) {
-        printPloticusFile();
-        fclose(eventsOut);
+    // Accumulate counters.
+    for (counter_e c = counter_e(0); c < COUNTER_LAST; c = counter_e(c + 1)) {
+      if (counter::masterOnly(c) && t != 0)
+        continue;
+      allCounters[c].addSample((*it)->getCounter(c)->getValue());
     }
+  }
 
-    fprintf (statsOut, "Aggregate for all threads\n");
-    printTimerStats (statsOut, &allStats[0], &totalStats[0]);
-    fprintf (statsOut, "\n");
-    printCounterStats (statsOut, &allCounters[0]);
+  if (eventPrintingEnabled()) {
+    printPloticusFile();
+    fclose(eventsOut);
+  }
 
-    if (statsOut != stderr)
-        fclose(statsOut);
+  fprintf(statsOut, "Aggregate for all threads\n");
+  printTimerStats(statsOut, &allStats[0], &totalStats[0]);
+  fprintf(statsOut, "\n");
+  printCounterStats(statsOut, &allCounters[0]);
+
+  if (statsOut != stderr)
+    fclose(statsOut);
 }
 
-/* ************************************************** */
 /* *************  exported C functions ************** */
 
-// no name mangling for these functions, we want the c files to be able to get at these functions
+// no name mangling for these functions, we want the c files to be able to get
+// at these functions
 extern "C" {
 
-void __kmp_reset_stats()
-{
-    kmp_stats_list::iterator it;
-    for(it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
-        timeStat * timers     = (*it)->getTimers();
-        counter * counters    = (*it)->getCounters();
-        explicitTimer * eTimers = (*it)->getExplicitTimers();
+void __kmp_reset_stats() {
+  kmp_stats_list::iterator it;
+  for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
+    timeStat *timers = (*it)->getTimers();
+    counter *counters = (*it)->getCounters();
+    explicitTimer *eTimers = (*it)->getExplicitTimers();
 
-        for (int t = 0; t<TIMER_LAST; t++)
-            timers[t].reset();
+    for (int t = 0; t < TIMER_LAST; t++)
+      timers[t].reset();
 
-        for (int c = 0; c<COUNTER_LAST; c++)
-            counters[c].reset();
+    for (int c = 0; c < COUNTER_LAST; c++)
+      counters[c].reset();
 
-        for (int t=0; t<EXPLICIT_TIMER_LAST; t++)
-            eTimers[t].reset();
+    for (int t = 0; t < EXPLICIT_TIMER_LAST; t++)
+      eTimers[t].reset();
 
-        // reset the event vector so all previous events are "erased"
-        (*it)->resetEventVector();
-    }
+    // reset the event vector so all previous events are "erased"
+    (*it)->resetEventVector();
+  }
 }
 
-// This function will reset all stats and stop all threads' explicit timers if they haven't been stopped already.
-void __kmp_output_stats(const char * heading)
-{
-    __kmp_stats_global_output->outputStats(heading);
-    __kmp_reset_stats();
+// This function will reset all stats and stop all threads' explicit timers if
+// they haven't been stopped already.
+void __kmp_output_stats(const char *heading) {
+  __kmp_stats_global_output->outputStats(heading);
+  __kmp_reset_stats();
 }
 
-void __kmp_accumulate_stats_at_exit(void)
-{
-    // Only do this once.
-    if (KMP_XCHG_FIXED32(&statsPrinted, 1) != 0)
-        return;
+void __kmp_accumulate_stats_at_exit(void) {
+  // Only do this once.
+  if (KMP_XCHG_FIXED32(&statsPrinted, 1) != 0)
+    return;
 
-    __kmp_output_stats("Statistics on exit");
+  __kmp_output_stats("Statistics on exit");
 }
 
-void __kmp_stats_init(void)
-{
-    __kmp_init_tas_lock( & __kmp_stats_lock );
-    __kmp_stats_start_time = tsc_tick_count::now();
-    __kmp_stats_global_output = new kmp_stats_output_module();
-    __kmp_stats_list = new kmp_stats_list();
+void __kmp_stats_init(void) {
+  __kmp_init_tas_lock(&__kmp_stats_lock);
+  __kmp_stats_start_time = tsc_tick_count::now();
+  __kmp_stats_global_output = new kmp_stats_output_module();
+  __kmp_stats_list = new kmp_stats_list();
 }
 
-void __kmp_stats_fini(void)
-{
-    __kmp_accumulate_stats_at_exit();
-    __kmp_stats_list->deallocate();
-    delete __kmp_stats_global_output;
-    delete __kmp_stats_list;
+void __kmp_stats_fini(void) {
+  __kmp_accumulate_stats_at_exit();
+  __kmp_stats_list->deallocate();
+  delete __kmp_stats_global_output;
+  delete __kmp_stats_list;
 }
 
 } // extern "C"
-