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        1561 : inline LockedQueue<Record>::LockedQueue() {
      24        1561 :   head_ = new Node();
      25        1561 :   CHECK_NOT_NULL(head_);
      26        1561 :   tail_ = head_;
      27        1561 : }
      28             : 
      29             : 
      30             : template <typename Record>
      31        1551 : inline LockedQueue<Record>::~LockedQueue() {
      32             :   // Destroy all remaining nodes. Note that we do not destroy the actual values.
      33             :   Node* old_node = nullptr;
      34        1551 :   Node* cur_node = head_;
      35        4653 :   while (cur_node != nullptr) {
      36             :     old_node = cur_node;
      37             :     cur_node = cur_node->next.Value();
      38             :     delete old_node;
      39             :   }
      40        1551 : }
      41             : 
      42             : 
      43             : template <typename Record>
      44     1788768 : inline void LockedQueue<Record>::Enqueue(const Record& record) {
      45             :   Node* n = new Node();
      46     1788767 :   CHECK_NOT_NULL(n);
      47     1788767 :   n->value = record;
      48             :   {
      49     1788767 :     base::MutexGuard guard(&tail_mutex_);
      50     1788768 :     tail_->next.SetValue(n);
      51     1788768 :     tail_ = n;
      52             :   }
      53     1788768 : }
      54             : 
      55             : 
      56             : template <typename Record>
      57     1789494 : inline bool LockedQueue<Record>::Dequeue(Record* record) {
      58             :   Node* old_head = nullptr;
      59             :   {
      60     1789494 :     base::MutexGuard guard(&head_mutex_);
      61     1789515 :     old_head = head_;
      62             :     Node* const next_node = head_->next.Value();
      63     1789503 :     if (next_node == nullptr) return false;
      64     1788725 :     *record = next_node->value;
      65     1788725 :     head_ = next_node;
      66             :   }
      67             :   delete old_head;
      68     1788751 :   return true;
      69             : }
      70             : 
      71             : 
      72             : template <typename Record>
      73     1276929 : inline bool LockedQueue<Record>::IsEmpty() const {
      74     1276929 :   base::MutexGuard guard(&head_mutex_);
      75     3830791 :   return head_->next.Value() == nullptr;
      76             : }
      77             : 
      78             : 
      79             : template <typename Record>
      80     1844144 : inline bool LockedQueue<Record>::Peek(Record* record) const {
      81     1844144 :   base::MutexGuard guard(&head_mutex_);
      82     1844209 :   Node* const next_node = head_->next.Value();
      83     1844192 :   if (next_node == nullptr) return false;
      84     1788221 :   *record = next_node->value;
      85     1788221 :   return true;
      86             : }
      87             : 
      88             : }  // namespace internal
      89             : }  // namespace v8
      90             : 
      91             : #endif  // V8_LOCKED_QUEUE_INL_H_