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