Line data    Source code

       1             : // Copyright 2013 the V8 project 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 "src/libplatform/task-queue.h"
       6             : 
       7             : #include "include/v8-platform.h"
       8             : #include "src/base/logging.h"
       9             : #include "src/base/platform/platform.h"
      10             : #include "src/base/platform/time.h"
      11             : 
      12             : namespace v8 {
      13             : namespace platform {
      14             : 
      15           8 : TaskQueue::TaskQueue() : process_queue_semaphore_(0), terminated_(false) {}
      16             : 
      17             : 
      18           8 : TaskQueue::~TaskQueue() {
      19           4 :   base::MutexGuard guard(&lock_);
      20             :   DCHECK(terminated_);
      21             :   DCHECK(task_queue_.empty());
      22           4 : }
      23             : 
      24          12 : void TaskQueue::Append(std::unique_ptr<Task> task) {
      25          12 :   base::MutexGuard guard(&lock_);
      26             :   DCHECK(!terminated_);
      27             :   task_queue_.push(std::move(task));
      28          12 :   process_queue_semaphore_.Signal();
      29          12 : }
      30             : 
      31          19 : std::unique_ptr<Task> TaskQueue::GetNext() {
      32           3 :   for (;;) {
      33             :     {
      34          22 :       base::MutexGuard guard(&lock_);
      35          22 :       if (!task_queue_.empty()) {
      36             :         std::unique_ptr<Task> result = std::move(task_queue_.front());
      37             :         task_queue_.pop();
      38             :         return result;
      39             :       }
      40          10 :       if (terminated_) {
      41           7 :         process_queue_semaphore_.Signal();
      42             :         return nullptr;
      43             :       }
      44             :     }
      45           3 :     process_queue_semaphore_.Wait();
      46             :   }
      47             : }
      48             : 
      49             : 
      50           4 : void TaskQueue::Terminate() {
      51           4 :   base::MutexGuard guard(&lock_);
      52             :   DCHECK(!terminated_);
      53           4 :   terminated_ = true;
      54           4 :   process_queue_semaphore_.Signal();
      55           4 : }
      56             : 
      57           1 : void TaskQueue::BlockUntilQueueEmptyForTesting() {
      58           1 :   for (;;) {
      59             :     {
      60           2 :       base::MutexGuard guard(&lock_);
      61           3 :       if (task_queue_.empty()) return;
      62             :     }
      63           1 :     base::OS::Sleep(base::TimeDelta::FromMilliseconds(5));
      64             :   }
      65             : }
      66             : 
      67             : }  // namespace platform
      68             : }  // namespace v8