clang-format runtime/vm

runtime/vm/thread_pool.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/thread_pool.h"
 
 #include "vm/dart.h"
 #include "vm/flags.h"
 #include "vm/lockers.h"
 
 namespace dart {
 
-DEFINE_FLAG(int, worker_timeout_millis, 5000,
+DEFINE_FLAG(int,
+            worker_timeout_millis,
+            5000,
             "Free workers when they have been idle for this amount of time.");
 
 ThreadPool::ThreadPool()
-  : shutting_down_(false),
-    all_workers_(NULL),
-    idle_workers_(NULL),
-    count_started_(0),
-    count_stopped_(0),
-    count_running_(0),
-    count_idle_(0),
-    shutting_down_workers_(NULL),
-    join_list_(NULL) {
-}
+    : shutting_down_(false),
+      all_workers_(NULL),
+      idle_workers_(NULL),
+      count_started_(0),
+      count_stopped_(0),
+      count_running_(0),
+      count_idle_(0),
+      shutting_down_workers_(NULL),
+      join_list_(NULL) {}
 
 
 ThreadPool::~ThreadPool() {
   Shutdown();
 }
 
 
 bool ThreadPool::Run(Task* task) {
   Worker* worker = NULL;
   bool new_worker = false;
@@ skipping 102 matching lines @@
   {
     MutexLocker ml(&mutex_);
     ASSERT(join_list_ == NULL);
   }
 #endif
 }
 
 
 bool ThreadPool::IsIdle(Worker* worker) {
   ASSERT(worker != NULL && worker->owned_);
-  for (Worker* current = idle_workers_;
-       current != NULL;
+  for (Worker* current = idle_workers_; current != NULL;
        current = current->idle_next_) {
     if (current == worker) {
       return true;
     }
   }
   return false;
 }
 
 
 bool ThreadPool::RemoveWorkerFromIdleList(Worker* worker) {
   ASSERT(worker != NULL && worker->owned_);
   if (idle_workers_ == NULL) {
     return false;
   }
 
   // Special case head of list.
   if (idle_workers_ == worker) {
     idle_workers_ = worker->idle_next_;
     worker->idle_next_ = NULL;
     return true;
   }
 
-  for (Worker* current = idle_workers_;
-       current->idle_next_ != NULL;
+  for (Worker* current = idle_workers_; current->idle_next_ != NULL;
        current = current->idle_next_) {
     if (current->idle_next_ == worker) {
       current->idle_next_ = worker->idle_next_;
       worker->idle_next_ = NULL;
       return true;
     }
   }
   return false;
 }
 
 
 bool ThreadPool::RemoveWorkerFromAllList(Worker* worker) {
   ASSERT(worker != NULL && worker->owned_);
   if (all_workers_ == NULL) {
     return false;
   }
 
   // Special case head of list.
   if (all_workers_ == worker) {
     all_workers_ = worker->all_next_;
     worker->all_next_ = NULL;
     worker->owned_ = false;
     worker->done_ = true;
     return true;
   }
 
-  for (Worker* current = all_workers_;
-       current->all_next_ != NULL;
+  for (Worker* current = all_workers_; current->all_next_ != NULL;
        current = current->all_next_) {
     if (current->all_next_ == worker) {
       current->all_next_ = worker->all_next_;
       worker->all_next_ = NULL;
       worker->owned_ = false;
       return true;
     }
   }
   return false;
 }
@@ skipping 78 matching lines @@
   ASSERT(exit_monitor_.IsOwnedByCurrentThread());
 
   // Special case head of list.
   if (shutting_down_workers_ == worker) {
     shutting_down_workers_ = worker->shutdown_next_;
     worker->shutdown_next_ = NULL;
     return true;
   }
 
   for (Worker* current = shutting_down_workers_;
-       current->shutdown_next_ != NULL;
-       current = current->shutdown_next_) {
+       current->shutdown_next_ != NULL; current = current->shutdown_next_) {
     if (current->shutdown_next_ == worker) {
       current->shutdown_next_ = worker->shutdown_next_;
       worker->shutdown_next_ = NULL;
       return true;
     }
   }
   return false;
 }
 
 
 void ThreadPool::JoinList::AddLocked(ThreadJoinId id, JoinList** list) {
   *list = new JoinList(id, *list);
 }
 
 
 void ThreadPool::JoinList::Join(JoinList** list) {
   while (*list != NULL) {
     JoinList* current = *list;
     *list = current->next();
     OSThread::Join(current->id());
     delete current;
   }
 }
 
 
-ThreadPool::Task::Task() {
-}
+ThreadPool::Task::Task() {}
 
 
-ThreadPool::Task::~Task() {
-}
+ThreadPool::Task::~Task() {}
 
 
 ThreadPool::Worker::Worker(ThreadPool* pool)
-  : pool_(pool),
-    task_(NULL),
-    id_(OSThread::kInvalidThreadId),
-    done_(false),
-    owned_(false),
-    all_next_(NULL),
-    idle_next_(NULL),
-    shutdown_next_(NULL) {
-}
+    : pool_(pool),
+      task_(NULL),
+      id_(OSThread::kInvalidThreadId),
+      done_(false),
+      owned_(false),
+      all_next_(NULL),
+      idle_next_(NULL),
+      shutdown_next_(NULL) {}
 
 
 ThreadId ThreadPool::Worker::id() {
   MonitorLocker ml(&monitor_);
   return id_;
 }
 
 
 void ThreadPool::Worker::StartThread() {
 #if defined(DEBUG)
   // Must call SetTask before StartThread.
-  { // NOLINT
+  {  // NOLINT
     MonitorLocker ml(&monitor_);
     ASSERT(task_ != NULL);
   }
 #endif
-  int result = OSThread::Start("Dart ThreadPool Worker",
-                               &Worker::Main,
+  int result = OSThread::Start("Dart ThreadPool Worker", &Worker::Main,
                                reinterpret_cast<uword>(this));
   if (result != 0) {
     FATAL1("Could not start worker thread: result = %d.", result);
   }
 }
 
 
 void ThreadPool::Worker::SetTask(Task* task) {
   MonitorLocker ml(&monitor_);
   ASSERT(task_ == NULL);
@@ skipping 97 matching lines @@
     // This worker is exiting because the thread pool is being shut down.
     // Inform the thread pool that we are exiting. We remove this worker from
     // shutting_down_workers_ list because there will be no need for the
     // ThreadPool to take action for this worker.
     ThreadJoinId join_id = OSThread::GetCurrentThreadJoinId(os_thread);
     {
       MutexLocker ml(&pool->mutex_);
       JoinList::AddLocked(join_id, &pool->join_list_);
     }
 
-    // worker->id_ should never be read again, so set to invalid in debug mode
-    // for asserts.
+// worker->id_ should never be read again, so set to invalid in debug mode
+// for asserts.
 #if defined(DEBUG)
     {
       MonitorLocker ml(&worker->monitor_);
       worker->id_ = OSThread::kInvalidThreadId;
     }
 #endif
 
     // Remove from the shutdown list, delete, and notify the thread pool.
     {
       MonitorLocker eml(&pool->exit_monitor_);
@@ skipping 12 matching lines @@
   }
 
   // Call the thread exit hook here to notify the embedder that the
   // thread pool thread is exiting.
   if (Dart::thread_exit_callback() != NULL) {
     (*Dart::thread_exit_callback())();
   }
 }
 
 }  // namespace dart