#include <synchronized_allocator.h>

Inheritance diagram for pw::allocator::SynchronizedAllocator< LockType >:

Public Member Functions
	SynchronizedAllocator (Allocator &allocator) noexcept

Pointer	Borrow () const

Public Member Functions inherited from pw::Allocator
void *	Allocate (Layout layout)

template<typename T , int &... kExplicitGuard, typename... Args>
std::enable_if_t<!std::is_array_v< T >, T * >	New (Args &&... args)

template<typename T , int &... kExplicitGuard, typename ElementType = std::remove_extent_t<T>, std::enable_if_t< is_unbounded_array_v< T >, int > = 0>
ElementType *	New (size_t count)

template<typename T , int &... kExplicitGuard, typename ElementType = std::remove_extent_t<T>, std::enable_if_t< is_unbounded_array_v< T >, int > = 0>
ElementType *	New (size_t count, size_t alignment)

template<typename T >
T *	NewArray (size_t count)

template<typename T >
T *	NewArray (size_t count, size_t alignment)

template<typename T , int &... kExplicitGuard, std::enable_if_t<!std::is_array_v< T >, int > = 0, typename... Args>
UniquePtr< T >	MakeUnique (Args &&... args)

template<typename T , int &... kExplicitGuard, std::enable_if_t< is_unbounded_array_v< T >, int > = 0>
UniquePtr< T >	MakeUnique (size_t size)

template<typename T , int &... kExplicitGuard, std::enable_if_t< is_unbounded_array_v< T >, int > = 0>
UniquePtr< T >	MakeUnique (size_t size, size_t alignment)

template<typename T >
UniquePtr< T[]>	MakeUniqueArray (size_t size)

template<typename T >
UniquePtr< T[]>	MakeUniqueArray (size_t size, size_t alignment)

template<typename T , int &... kExplicitGuard, std::enable_if_t< is_bounded_array_v< T >, int > = 0, typename... Args>
void	MakeUnique (Args &&...)=delete

template<typename T , int &... kExplicitGuard, std::enable_if_t<!std::is_array_v< T >, int > = 0, typename... Args>
SharedPtr< T >	MakeShared (Args &&... args)

template<typename T , int &... kExplicitGuard, std::enable_if_t< is_unbounded_array_v< T >, int > = 0>
SharedPtr< T >	MakeShared (size_t size)

template<typename T , int &... kExplicitGuard, std::enable_if_t< is_unbounded_array_v< T >, int > = 0>
SharedPtr< T >	MakeShared (size_t size, size_t alignment)

template<typename T , int &... kExplicitGuard, std::enable_if_t< is_bounded_array_v< T >, int > = 0, typename... Args>
std::enable_if_t< is_bounded_array_v< T > >	MakeShared (Args &&...)=delete

bool	Resize (void *ptr, size_t new_size)

bool	Resize (void *ptr, Layout layout, size_t new_size)

void *	Reallocate (void *ptr, Layout new_layout)

void *	Reallocate (void *ptr, Layout old_layout, size_t new_size)

size_t	GetAllocated () const

Public Member Functions inherited from pw::Deallocator
constexpr const Capabilities &	capabilities () const

bool	HasCapability (Capability capability) const
	Returns whether a given capabilityis enabled for this object.

void	Deallocate (void *ptr)

void	Deallocate (void *ptr, Layout layout)

template<typename T >
void	Delete (T *ptr)

StatusWithSize	GetCapacity () const

bool	IsEqual (const Deallocator &other) const

template<typename T , int &... kExplicitGuard, std::enable_if_t< is_bounded_array_v< T >, int > = 0, typename... Args>
void	WrapUnique (Args &&...)=delete

Private Member Functions
void *	DoAllocate (Layout layout) override

void	DoDeallocate (void *ptr) override

void	DoDeallocate (void *ptr, Layout) override

bool	DoResize (void *ptr, size_t new_size) override

void *	DoReallocate (void *ptr, Layout new_layout) override

size_t	DoGetAllocated () const override

Result< Layout >	DoGetInfo (InfoType info_type, const void *ptr) const override

Additional Inherited Members
Public Types inherited from pw::Deallocator
using	Capabilities = allocator::Capabilities

using	Capability = allocator::Capability

using	Layout = allocator::Layout

Protected Member Functions inherited from pw::Allocator
constexpr	Allocator ()=default
	TODO(b/326509341): Remove when downstream consumers migrate.

constexpr	Allocator (const Capabilities &capabilities)

Protected Member Functions inherited from pw::Deallocator
constexpr	Deallocator ()=default
	TODO(b/326509341): Remove when downstream consumers migrate.

constexpr	Deallocator (const Capabilities &capabilities)

template<typename T , std::enable_if_t<!std::is_array_v< T >, int > = 0>
UniquePtr< T >	WrapUnique (T *ptr)

template<typename T , int &... kExplicitGuard, typename ElementType = std::remove_extent_t<T>, std::enable_if_t< is_unbounded_array_v< T >, int > = 0>
UniquePtr< T >	WrapUnique (ElementType *ptr, size_t size)

template<typename T >
UniquePtr< T[]>	WrapUniqueArray (T *ptr, size_t size)

Static Protected Attributes inherited from pw::Deallocator
template<typename T >
static constexpr bool	is_bounded_array_v

template<typename T >
static constexpr bool	is_unbounded_array_v

Detailed Description

template<typename LockType>
class pw::allocator::SynchronizedAllocator< LockType >

Wraps an Allocator with a lock to synchronize access.

Depending on the LockType, this object may be thread- and/or interrupt- safe. For example, SynchronizedAllocator<pw::sync::Mutex> is thread-safe, while SynchronizedAllocator<pw::sync::InterruptSpinLock> is thread- and interrupt-safe.

Template Parameters

LockType The type of the lock used to synchronize allocator access. Must be default-constructible.

Member Function Documentation

◆ Borrow()

template<typename LockType >

Pointer pw::allocator::SynchronizedAllocator< LockType >::Borrow ( ) const

inline

Returns a borrowed pointer to the allocator.

When an allocator being wrapped implements an interface that extends pw::Allocator, this method can be used to safely access a downcastable pointer. The usual warnings apply to the returned value; namely the caller MUST NOT leak the raw pointer.

Example:

pw::allocator::BestFitAllocator<> best_fit(heap);
pw::allocator::SynchronizedAllocator<pw::sync::Mutex> synced(best_fit);
// ...
auto borrowed = synced.Borrow();
auto allocator =
  static_cast<pw::allocator::BestFitAllocator<>&>(*borrowed);

◆ DoAllocate()

template<typename LockType >

void * pw::allocator::SynchronizedAllocator< LockType >::DoAllocate ( Layout layout )

inlineoverrideprivatevirtual

Allocates a block of memory with the specified size and alignment.

Returns nullptr if the allocation cannot be made, or the layout has a size of 0.

Parameters

[in] layout Describes the memory to be allocated.

Implements pw::Allocator.

◆ DoDeallocate() [1/2]

template<typename LockType >

void pw::allocator::SynchronizedAllocator< LockType >::DoDeallocate ( void * ptr )

inlineoverrideprivate

Releases a previously-allocated block of memory.

The given pointer must have been previously provided by this memory resource; otherwise the behavior is undefined.

Parameters

[in] ptr Pointer to previously-allocated memory.

◆ DoDeallocate() [2/2]

template<typename LockType >

void pw::allocator::SynchronizedAllocator< LockType >::DoDeallocate	(	void *	ptr,
		Layout
	)

inlineoverrideprivate

Releases a previously-allocated block of memory.

The given pointer must have been previously provided by this memory resource; otherwise the behavior is undefined.

Parameters

[in] ptr Pointer to previously-allocated memory.

◆ DoGetAllocated()

template<typename LockType >

size_t pw::allocator::SynchronizedAllocator< LockType >::DoGetAllocated ( ) const

inlineoverrideprivatevirtual

Returns the total bytes that have been allocated by this allocator, or size_t(-1) if this allocator does not track its total allocated bytes.

Reimplemented from pw::Allocator.

◆ DoGetInfo()

template<typename LockType >

Result< Layout > pw::allocator::SynchronizedAllocator< LockType >::DoGetInfo	(	InfoType	info_type,
		const void *	ptr
	)		const

inlineoverrideprivate

◆ DoReallocate()

template<typename LockType >

void * pw::allocator::SynchronizedAllocator< LockType >::DoReallocate	(	void *	ptr,
		Layout	new_layout
	)

inlineoverrideprivatevirtual

Virtual Reallocate function that can be overridden by derived classes.

The default implementation will first try to Resize the data. If that is unsuccessful, it will allocate an entirely new block, copy existing data, and deallocate the given block.

Parameters

[in]	ptr	Pointer to memory, guaranteed to not be null.
[in]	new_layout	Describes the memory to be allocated. Guaranteed to have a non-zero size.

Reimplemented from pw::Allocator.

◆ DoResize()

template<typename LockType >

bool pw::allocator::SynchronizedAllocator< LockType >::DoResize	(	void *	ptr,
		size_t	new_size
	)

inlineoverrideprivatevirtual

Modifies the size of an previously-allocated block of memory without copying any data.

Returns true if its size was changed without copying data to a new allocation; otherwise returns false.

In particular, it always returns true if the old_layout.size() equals new_size, and always returns false if the given pointer is null, the old_layout.size() is 0, or the new_size is 0.

Parameters

[in]	ptr	Pointer to previously-allocated memory.
[in]	new_size	Requested new size for the memory allocation.

Reimplemented from pw::Allocator.

The documentation for this class was generated from the following file:

pw_allocator/public/pw_allocator/synchronized_allocator.h

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ Borrow()

◆ DoAllocate()

◆ DoDeallocate() [1/2]

◆ DoDeallocate() [2/2]

◆ DoGetAllocated()

◆ DoGetInfo()

◆ DoReallocate()

◆ DoResize()