Line data    Source code

       1             : // Copyright 2015 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             : #ifndef V8_LOCKED_QUEUE_INL_H_
       6             : #define V8_LOCKED_QUEUE_INL_H_
       7             : 
       8             : #include "src/base/atomic-utils.h"
       9             : #include "src/locked-queue.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14             : template <typename Record>
      15             : struct LockedQueue<Record>::Node : Malloced {
      16             :   Node() : next(nullptr) {}
      17             :   Record value;
      18             :   base::AtomicValue<Node*> next;
      19             : };
      20             : 
      21             : 
      22             : template <typename Record>
      23        1629 : inline LockedQueue<Record>::LockedQueue() {
      24        1629 :   head_ = new Node();
      25        1629 :   CHECK_NOT_NULL(head_);
      26        1629 :   tail_ = head_;
      27        1629 : }
      28             : 
      29             : 
      30             : template <typename Record>
      31        1619 : inline LockedQueue<Record>::~LockedQueue() {
      32             :   // Destroy all remaining nodes. Note that we do not destroy the actual values.
      33             :   Node* old_node = nullptr;
      34        1619 :   Node* cur_node = head_;
      35        3238 :   while (cur_node != nullptr) {
      36             :     old_node = cur_node;
      37             :     cur_node = cur_node->next.Value();
      38             :     delete old_node;
      39             :   }
      40        1619 : }
      41             : 
      42             : 
      43             : template <typename Record>
      44     1826191 : inline void LockedQueue<Record>::Enqueue(const Record& record) {
      45             :   Node* n = new Node();
      46     1826191 :   CHECK_NOT_NULL(n);
      47     1826191 :   n->value = record;
      48             :   {
      49     1826191 :     base::MutexGuard guard(&tail_mutex_);
      50     1826191 :     tail_->next.SetValue(n);
      51     1826191 :     tail_ = n;
      52             :   }
      53     1826191 : }
      54             : 
      55             : 
      56             : template <typename Record>
      57     1827000 : inline bool LockedQueue<Record>::Dequeue(Record* record) {
      58             :   Node* old_head = nullptr;
      59             :   {
      60     1827000 :     base::MutexGuard guard(&head_mutex_);
      61     1827003 :     old_head = head_;
      62             :     Node* const next_node = head_->next.Value();
      63     1827002 :     if (next_node == nullptr) return false;
      64     1826190 :     *record = next_node->value;
      65     1826190 :     head_ = next_node;
      66             :   }
      67             :   delete old_head;
      68     1826188 :   return true;
      69             : }
      70             : 
      71             : 
      72             : template <typename Record>
      73     1013618 : inline bool LockedQueue<Record>::IsEmpty() const {
      74     1013618 :   base::MutexGuard guard(&head_mutex_);
      75     3040854 :   return head_->next.Value() == nullptr;
      76             : }
      77             : 
      78             : 
      79             : template <typename Record>
      80     1954825 : inline bool LockedQueue<Record>::Peek(Record* record) const {
      81     1954825 :   base::MutexGuard guard(&head_mutex_);
      82     1954829 :   Node* const next_node = head_->next.Value();
      83     1954828 :   if (next_node == nullptr) return false;
      84     1825445 :   *record = next_node->value;
      85     1825445 :   return true;
      86             : }
      87             : 
      88             : }  // namespace internal
      89             : }  // namespace v8
      90             : 
      91             : #endif  // V8_LOCKED_QUEUE_INL_H_