chromium/third_party/angle/src/common/FixedQueue.h

//
// Copyright 2023 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// FixedQueue.h:
//   An array based fifo queue class that supports concurrent push and pop.
//

#ifndef COMMON_FIXEDQUEUE_H_
#define COMMON_FIXEDQUEUE_H_

#include "common/debug.h"

#include <algorithm>
#include <array>
#include <atomic>

namespace angle
{
// class FixedQueue: An vector based fifo queue class that supports concurrent push and
// pop. Caller must ensure queue is not empty before pop and not full before push. This class
// supports concurrent push and pop from different threads, but only with single producer single
// consumer usage. If caller want to push from two different threads, proper mutex must be used to
// ensure the access is serialized. You can also call updateCapacity to adjust the storage size, but
// caller must take proper mutex lock to ensure no one is accessing the storage. In a typical usage
// case is that you have two mutex lock, enqueueLock and dequeueLock. You use enqueueLock to push
// and use dequeueLock to pop. You dont need the lock for checking size (i.e, call empty/full). You
// take both lock in a given order to call updateCapacity. See unit test
// FixedQueue.ConcurrentPushPopWithResize for example.
template <class T>
class FixedQueue final : angle::NonCopyable
{ … };

template <class T>
FixedQueue<T>::FixedQueue(size_t capacity)
    : … { … }

template <class T>
FixedQueue<T>::~FixedQueue()
{ … }

template <class T>
ANGLE_INLINE typename FixedQueue<T>::size_type FixedQueue<T>::size() const
{ … }

template <class T>
ANGLE_INLINE bool FixedQueue<T>::empty() const
{ … }

template <class T>
ANGLE_INLINE bool FixedQueue<T>::full() const
{ … }

template <class T>
ANGLE_INLINE typename FixedQueue<T>::size_type FixedQueue<T>::capacity() const
{ … }

template <class T>
ANGLE_INLINE void FixedQueue<T>::updateCapacity(size_t newCapacity)
{ … }

template <class T>
ANGLE_INLINE typename FixedQueue<T>::reference FixedQueue<T>::front()
{ … }

template <class T>
ANGLE_INLINE typename FixedQueue<T>::const_reference FixedQueue<T>::front() const
{ … }

template <class T>
void FixedQueue<T>::push(const value_type &value)
{ … }

template <class T>
void FixedQueue<T>::push(value_type &&value)
{ … }

template <class T>
ANGLE_INLINE typename FixedQueue<T>::reference FixedQueue<T>::back()
{ … }

template <class T>
ANGLE_INLINE typename FixedQueue<T>::const_reference FixedQueue<T>::back() const
{ … }

template <class T>
void FixedQueue<T>::pop()
{ … }

template <class T>
void FixedQueue<T>::clear()
{ … }
}  // namespace angle

#endif  // COMMON_FIXEDQUEUE_H_