#include <TensorBlock.h>

Classes
struct	Allocation

Public Member Functions
	TensorBlockScratchAllocator (const Device &device)

	~TensorBlockScratchAllocator ()

void *	allocate (size_t size)

void	reset ()

Private Attributes
const Device &	m_device

int	m_allocation_index

std::vector< Allocation >	m_allocations

Constructor & Destructor Documentation

◆ TensorBlockScratchAllocator()

template<typename Device >

Eigen::internal::TensorBlockScratchAllocator< Device >::TensorBlockScratchAllocator ( const Device & device )

inlineexplicit

477 : m_device(device), m_allocation_index(0) {}

Eigen::internal::TensorBlockScratchAllocator::m_allocation_index

int m_allocation_index

Definition: TensorBlock.h:530

Eigen::internal::TensorBlockScratchAllocator::m_device

const Device & m_device

Definition: TensorBlock.h:529

◆ ~TensorBlockScratchAllocator()

template<typename Device >

Eigen::internal::TensorBlockScratchAllocator< Device >::~TensorBlockScratchAllocator ( )

inline

                                  {
     for (size_t i = 0; i < m_allocations.size(); ++i) {
       m_device.deallocate(m_allocations[i].ptr);
     }
   }

References i, Eigen::internal::TensorBlockScratchAllocator< Device >::m_allocations, and Eigen::internal::TensorBlockScratchAllocator< Device >::m_device.

Member Function Documentation

◆ allocate()

template<typename Device >

void* Eigen::internal::TensorBlockScratchAllocator< Device >::allocate ( size_t size )

inline

                               {
     // TODO(ezhulenev): Remove when replaced with inlined vector.
     if (m_allocations.capacity() == 0) m_allocations.reserve(8);
  
     // Check if we already have an existing allocation att current index.
     const int num_allocations = static_cast<int>(m_allocations.size());
     const bool has_allocation = m_allocation_index < num_allocations;
  
     // Allocation index can't be larger than the number of allocations.
     eigen_assert(m_allocation_index <= num_allocations);
  
     // If we have existing allocation, and its size is larger or equal to
     // requested size, we do nothing.
  
     // If current allocation can't fit requested size, we deallocate it, and
     // replace with a larger allocation.
     if (has_allocation && m_allocations[m_allocation_index].size < size) {
       m_device.deallocate(m_allocations[m_allocation_index].ptr);
       m_allocations[m_allocation_index].ptr = m_device.allocate(size);
       m_allocations[m_allocation_index].size = size;
     }
  
     // Make a new allocation if we don't have and existing one.
     if (!has_allocation) {
       Allocation allocation;
       allocation.ptr = m_device.allocate(size);
       allocation.size = size;
       m_allocations.push_back(allocation);
     }
  
     eigen_assert(m_allocations[m_allocation_index].ptr != NULL);
     eigen_assert(m_allocations[m_allocation_index].size >= size);
  
     return m_allocations[m_allocation_index++].ptr;
   }