tools/gn/scheduler.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "tools/gn/scheduler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "tools/gn/standard_out.h"
  11 #include "tools/gn/switches.h"
  12
  13 Scheduler* g_scheduler = nullptr;
  14
  15 namespace {
  16
  17 int GetThreadCount() {
  18   std::string thread_count =
  19       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
  20           switches::kThreads);
  21
  22   int result;
  23   if (thread_count.empty() || !base::StringToInt(thread_count, &result))
  24     return 32;
  25   return result;
  26 }
  27
  28 }  // namespace
  29
  30 Scheduler::Scheduler()
  31     : pool_(new base::SequencedWorkerPool(GetThreadCount(), "worker_")),
  32       input_file_manager_(new InputFileManager),
  33       verbose_logging_(false),
  34       work_count_(0),
  35       is_failed_(false),
  36       has_been_shutdown_(false) {
  37   g_scheduler = this;
  38 }
  39
  40 Scheduler::~Scheduler() {
  41   if (!has_been_shutdown_)
  42     pool_->Shutdown();
  43   g_scheduler = nullptr;
  44 }
  45
  46 bool Scheduler::Run() {
  47   runner_.Run();
  48   bool local_is_failed;
  49   {
  50     base::AutoLock lock(lock_);
  51     local_is_failed = is_failed();
  52     has_been_shutdown_ = true;
  53   }
  54   // Don't do this inside the lock since it will block on the workers, which
  55   // may be in turn waiting on the lock.
  56   pool_->Shutdown();
  57   return !local_is_failed;
  58 }
  59
  60 void Scheduler::Log(const std::string& verb, const std::string& msg) {
  61   if (base::MessageLoop::current() == &main_loop_) {
  62     LogOnMainThread(verb, msg);
  63   } else {
  64     // The run loop always joins on the sub threads, so the lifetime of this
  65     // object outlives the invocations of this function, hence "unretained".
  66     main_loop_.PostTask(FROM_HERE,
  67                         base::Bind(&Scheduler::LogOnMainThread,
  68                                    base::Unretained(this), verb, msg));
  69   }
  70 }
  71
  72 void Scheduler::FailWithError(const Err& err) {
  73   DCHECK(err.has_error());
  74   {
  75     base::AutoLock lock(lock_);
  76
  77     if (is_failed_ || has_been_shutdown_)
  78       return;  // Ignore errors once we see one.
  79     is_failed_ = true;
  80   }
  81
  82   if (base::MessageLoop::current() == &main_loop_) {
  83     FailWithErrorOnMainThread(err);
  84   } else {
  85     // The run loop always joins on the sub threads, so the lifetime of this
  86     // object outlives the invocations of this function, hence "unretained".
  87     main_loop_.PostTask(FROM_HERE,
  88                         base::Bind(&Scheduler::FailWithErrorOnMainThread,
  89                                    base::Unretained(this), err));
  90   }
  91 }
  92
  93 void Scheduler::ScheduleWork(const base::Closure& work) {
  94   IncrementWorkCount();
  95   pool_->PostWorkerTaskWithShutdownBehavior(
  96       FROM_HERE, base::Bind(&Scheduler::DoWork,
  97                             base::Unretained(this), work),
  98       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
  99 }
 100
 101 void Scheduler::AddGenDependency(const base::FilePath& file) {
 102   base::AutoLock lock(lock_);
 103   gen_dependencies_.push_back(file);
 104 }
 105
 106 std::vector<base::FilePath> Scheduler::GetGenDependencies() const {
 107   base::AutoLock lock(lock_);
 108   return gen_dependencies_;
 109 }
 110
 111 void Scheduler::IncrementWorkCount() {
 112   base::AtomicRefCountInc(&work_count_);
 113 }
 114
 115 void Scheduler::DecrementWorkCount() {
 116   if (!base::AtomicRefCountDec(&work_count_)) {
 117     if (base::MessageLoop::current() == &main_loop_) {
 118       OnComplete();
 119     } else {
 120       main_loop_.PostTask(FROM_HERE,
 121                           base::Bind(&Scheduler::OnComplete,
 122                                      base::Unretained(this)));
 123     }
 124   }
 125 }
 126
 127 void Scheduler::LogOnMainThread(const std::string& verb,
 128                                 const std::string& msg) {
 129   OutputString(verb, DECORATION_YELLOW);
 130   OutputString(" " + msg + "\n");
 131 }
 132
 133 void Scheduler::FailWithErrorOnMainThread(const Err& err) {
 134   err.PrintToStdout();
 135   runner_.Quit();
 136 }
 137
 138 void Scheduler::DoWork(const base::Closure& closure) {
 139   closure.Run();
 140   DecrementWorkCount();
 141 }
 142
 143 void Scheduler::OnComplete() {
 144   // Should be called on the main thread.
 145   DCHECK(base::MessageLoop::current() == main_loop());
 146   runner_.Quit();
 147 }