maia::container::Container< Derived, Invalid > Class Template Reference

#include <container.h>

Inheritance diagram for maia::container::Container< Derived, Invalid >:

Classes
struct	Copy

Public Member Functions
constexpr	Container ()=default
	Default c'tor does nothing. More...
constexpr MInt	capacity () const
	Return capacity (i.e., maximum number of nodes) More...
void	reset (const MInt capacity)
	Reset tree, re-create data structures with given capacity, and set size to zero. More...
void	resize (const MInt capacity)
	Resize the container capacity. More...
constexpr MInt	size () const
	Return size (i.e., currently used number of nodes) More...
void	size (const MInt size_)
	Resize tree WITHOUT CONSIDERING ANY NODE CONSISTENCY! Use at own risk and remove ASAP... More...
void	append (const MInt count)
	Append nodes to end of tree. More...
void	append ()
void	shrink (const MInt count)
	Remove nodes from end of tree. More...
void	shrink ()
template<class T >
void	copy (const T &source, const MInt begin, const MInt end, const MInt to)
	Copy nodes to another location without changing any parent/child/neighbor information. More...
template<class T >
void	copy (const T &source, const MInt from, const MInt to)
void	copy (const MInt begin, const MInt end, const MInt to)
void	copy (const MInt from, const MInt to)
void	move (const MInt begin, const MInt end, const MInt to)
	Move nodes to another location and update parent/child/neighbor information accordingly. More...
void	move (const MInt from, const MInt to)
void	swap (const MInt a, const MInt b)
	Swap two nodes and update parent/child/neighbor information accordingly. More...
void	insert (const MInt begin, const MInt count)
void	insert (const MInt id)
void	erase (const MInt begin, const MInt end)
	Erase nodes in range [begin, end) and update parent/child/neighbor information. More...
void	erase (const MInt id)
void	removeAndShift (const MInt begin, const MInt end)
void	removeAndShift (const MInt id)
void	removeAndFill (const MInt begin, const MInt end)
void	removeAndFill (const MInt id)
void	clear ()
	Clear tree by invalidating all nodes and setting size to zero. More...
Derived &	derived ()
const Derived &	derived () const
template<class T >
void	rawCopy (const T &source, const MInt begin, const MInt end, const MInt to)
	Copy range of nodes [begin, end) to range starting at 'to'. More...
template<class T >
void	rawCopy (const T &source, const MInt from, const MInt to)
void	deleteConnectivity (const MInt NotUsed(begin), const MInt NotUsed(end))
void	moveConnectivity (const MInt NotUsed(begin), const MInt NotUsed(end), const MInt NotUsed(to))
void	moveConnectivity (const MInt from, const MInt to)
constexpr MInt	dummy () const

Protected Types
template<class T >
using	Storage = std::vector< T >

Protected Member Functions
template<class T >
void	resetStorage (const MInt n, Storage< T > &c)
	Create new container with given size and replace original one. More...
template<class T >
void	resizeStorage (const MInt n, Storage< T > &c)
	Resize container with given size. More...
virtual void	resize ()
template<typename Container_ , typename T = typename Container_::value_type>
void	fill_invalid (Container_ &c, const MInt begin, const MInt end, const MInt solverSize=1, const T value=Invalid< T >::value())
template<typename Container_ , typename Functor >
void	copyData (const Container_ &source, Container_ &target, Functor &&f, const MInt begin, const MInt end, const MInt dest, const MInt solverSize=1)
	Copy [begin, end) range with given solver size from source to dest position of target. More...
MBool	isValidId (const MInt id) const
	Return whether given id refers to a valid node (auxiliary method). More...

Private Attributes
MInt	m_capacity = 0
MInt	m_size = 0

Detailed Description

template<class Derived, template< class > class Invalid>
class maia::container::Container< Derived, Invalid >

Base class for collector-like containers.

To use this as a base class for a specific container type, a derived class must implement the following:

• template <class Functor, class T>
• void invalidate(MInt begin, MInt end)
• void reset()
• void resize() Optionally, the following methods may be implemented to maintain internal connectivity on delete and move operations:
• void moveConnectivity(MInt begin, MInt end, MInt to)
• void deleteConnectivity(MInt begin, MInt end)

Definition at line 77 of file container.h.

Member Typedef Documentation

Storage

template<class Derived , template< class > class Invalid>

template<class T >

using maia::container::Container< Derived, Invalid >::Storage = std::vector<T>

protected

Definition at line 121 of file container.h.

Constructor & Destructor Documentation

Container()

template<class Derived , template< class > class Invalid>

constexpr maia::container::Container< Derived, Invalid >::Container ( )

constexprdefault

Member Function Documentation

append() [1/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::append ( )

inline

Definition at line 94 of file container.h.

{ append(1); }

append() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::append

(

const MInt

count

)

Definition at line 223 of file container.h.

                                                         {
  ENSURE_CONDITION(count >= 0, "Count must be non-negative");
 
  if(size() + count > capacity()) {
    std::cerr << "Container capacity exceeded: is:" + std::to_string(capacity())
                     + ", desired: " + std::to_string(size() + count)
              << std::endl;
    // Allow containers to grow if required -> for now resize with +10% capacity
    const MInt newCapacity = 1.1 * (size() + count);
    std::cerr << "New container capacity is: " << newCapacity << std::endl;
    resize(size() + count);
  }
  derived().invalidate(size(), size() + count);
  m_size += count;
}

capacity()

template<class Derived , template< class > class Invalid>

constexpr MInt maia::container::Container< Derived, Invalid >::capacity ( ) const

inlineconstexpr

Definition at line 85 of file container.h.

{ return m_capacity; }

clear()

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::clear

Definition at line 395 of file container.h.

                                        {
  derived().invalidate(0, size());
  m_size = 0;
}

copy() [1/4]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::copy ( const MInt  begin, const MInt  end, const MInt  to  )

inline

Definition at line 103 of file container.h.

{ copy(derived(), begin, end, to); }

copy() [2/4]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::copy ( const MInt  from, const MInt  to  )

inline

Definition at line 104 of file container.h.

{ copy(from, from + 1, to); }

copy() [3/4]

template<class Derived , template< class > class Invalid>

template<class T >

void maia::container::Container< Derived, Invalid >::copy	(	const T &	source,
		const MInt	begin,
		const MInt	end,
		const MInt	to
	)

Definition at line 253 of file container.h.

                                                                                                       {
  ENSURE_CONDITION(begin >= 0 && begin < source.size(), "Begin position outside valid range");
  ENSURE_CONDITION(end - 1 < source.size(), "End position outside valid range");
  ENSURE_VALID_ID(to);
  ENSURE_CONDITION(to + (end - begin) <= size(), "Target range outside valid size");
 
  // Exit early if there is nothing to do
  if(end <= begin || (&source == this && begin == to)) {
    return;
  }
 
  rawCopy(source, begin, end, to);
}

copy() [4/4]

template<class Derived , template< class > class Invalid>

template<class T >

void maia::container::Container< Derived, Invalid >::copy ( const T &  source, const MInt  from, const MInt  to  )

inline

Definition at line 100 of file container.h.

                                                             {
    copy(source, from, from + 1, to);
  }

copyData()

template<class Derived , template< class > class Invalid>

template<typename Container_ , typename Functor >

void maia::container::Container< Derived, Invalid >::copyData ( const Container_ &  source, Container_ &  target, Functor &&  f, const MInt  begin, const MInt  end, const MInt  dest, const MInt  solverSize = 1  )

inlineprotected

Definition at line 138 of file container.h.

                                                            {
    f(source.data() + begin * solverSize, source.data() + end * solverSize, target.data() + dest * solverSize);
  }

deleteConnectivity()

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::deleteConnectivity ( const MInt   NotUsedbegin, const MInt   NotUsedend  )

inline

Definition at line 169 of file container.h.

{}

derived() [1/2]

template<class Derived , template< class > class Invalid>

Derived & maia::container::Container< Derived, Invalid >::derived ( )

inline

Definition at line 146 of file container.h.

{ return static_cast<Derived&>(*this); }

derived() [2/2]

template<class Derived , template< class > class Invalid>

const Derived & maia::container::Container< Derived, Invalid >::derived ( ) const

inline

Definition at line 147 of file container.h.

{ return static_cast<const Derived&>(*this); }

dummy()

template<class Derived , template< class > class Invalid>

constexpr MInt maia::container::Container< Derived, Invalid >::dummy ( ) const

inlineconstexpr

Definition at line 172 of file container.h.

{ return m_capacity; }

erase() [1/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::erase	(	const MInt	begin,
		const MInt	end
	)

Definition at line 335 of file container.h.

                                                                        {
  ENSURE_VALID_ID(begin);
  ENSURE_VALID_ID(end - 1);
 
  // Exit early if there is nothing to do
  if(end <= begin) {
    return;
  }
 
  derived().deleteConnectivity(begin, end);
  derived().invalidate(begin, end);
}

erase() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::erase ( const MInt  id )

inline

Definition at line 111 of file container.h.

{ erase(id, id + 1); }

fill_invalid()

template<class Derived , template< class > class Invalid>

template<typename Container_ , typename T = typename Container_::value_type>

void maia::container::Container< Derived, Invalid >::fill_invalid ( Container_ &  c, const MInt  begin, const MInt  end, const MInt  solverSize = 1, const T  value = Invalid<T>::value()  )

inlineprotected

Definition at line 131 of file container.h.

                                                       {
    std::fill(c.data() + begin * solverSize, c.data() + end * solverSize, value);
  }

insert() [1/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::insert	(	const MInt	id,
		const MInt	count
	)

Insert 'count' nodes and push back existing nodes while updating parent/child/neighbor information.

Definition at line 318 of file container.h.

                                                                        {
  ENSURE_CONDITION(isValidId(id) || id == size(), "Id must refer to a valid node or be equal to size()");
  ENSURE_CONDITION(count >= 0, "Count must be non-negative");
  ENSURE_CONDITION(count + size() <= capacity(), "New size exceeds capacity");
 
  // Exit early if there is nothing to do
  if(count == 0) {
    return;
  }
 
  m_size += count;
  move(id, size() - count, id + count);
}

insert() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::insert ( const MInt  id )

inline

Definition at line 109 of file container.h.

{ insert(id, 1); }

isValidId()

template<class Derived , template< class > class Invalid>

MBool maia::container::Container< Derived, Invalid >::isValidId ( const MInt  id ) const

protected

Definition at line 443 of file container.h.

                                                                {
  // @memSplitGrid Note: allow second last position to be used as a dummy id (needed for FV solver to
  // work atm, changing to the last position requires changing the allocation of solver variables to
  // be of size maxNoCells+1)
  if(!((id >= 0 && id < size()) || id == capacity() - 1)) {
    std::cerr << "id = " << id << std::endl
              << "size() = " << size() << std::endl
              << "capacity() = " << capacity() << std::endl;
  }
  return ((id >= 0 && id < size()) || id == capacity() - 1);
}

move() [1/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::move	(	const MInt	begin,
		const MInt	end,
		const MInt	to
	)

Definition at line 270 of file container.h.

                                                                                      {
  ENSURE_VALID_ID(begin);
  ENSURE_VALID_ID(end - 1);
  ENSURE_VALID_ID(to);
  ENSURE_CONDITION(to + (end - begin) - 1 < size(), "Target range outside valid size");
 
  // Exit early if there is nothing to do
  if(end <= begin || begin == to) {
    return;
  }
 
  rawCopy(derived(), begin, end, to);
  derived().moveConnectivity(begin, end, to);
  derived().invalidate(begin, end);
}

move() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::move ( const MInt  from, const MInt  to  )

inline

Definition at line 106 of file container.h.

{ move(from, from + 1, to); }

moveConnectivity() [1/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::moveConnectivity ( const MInt  from, const MInt  to  )

inline

Definition at line 171 of file container.h.

{ moveConnectivity(from, from + 1, to); }

moveConnectivity() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::moveConnectivity ( const MInt   NotUsedbegin, const MInt   NotUsedend, const MInt   NotUsedto  )

inline

Definition at line 170 of file container.h.

{}

rawCopy() [1/2]

template<class Derived , template< class > class Invalid>

template<class T >

void maia::container::Container< Derived, Invalid >::rawCopy	(	const T &	source,
		const MInt	begin,
		const MInt	end,
		const MInt	to
	)

Definition at line 404 of file container.h.

                                                                                                          {
  // Use different methods for overlapping and non-overlapping ranges, depending on overlap type
  if(to < begin || to >= end) {
    // Non-overlapping ranges or overlap while copying left can be handled by std::copy
    derived().rawCopyGeneric(Copy<true>{}, source, begin, end, to);
  } else {
    // Overlap while copying right can be handled by std::copy_backward
    const MInt count = end - begin;
    derived().rawCopyGeneric(Copy<false>{}, source, begin, end, to + count);
  }
}

rawCopy() [2/2]

template<class Derived , template< class > class Invalid>

template<class T >

void maia::container::Container< Derived, Invalid >::rawCopy ( const T &  source, const MInt  from, const MInt  to  )

inline

Definition at line 166 of file container.h.

                                                                {
    rawCopy(source, from, from + 1, to);
  }

removeAndFill() [1/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::removeAndFill	(	const MInt	begin,
		const MInt	end
	)

Remove nodes in range [begin, end) and fill gap with nodes from end while updating parent/child/neighbor information.

Definition at line 374 of file container.h.

                                                                                {
  ENSURE_VALID_ID(begin);
  ENSURE_VALID_ID(end - 1);
 
  // Exit early if there is nothing to do
  if(end <= begin) {
    return;
  }
 
  derived().deleteConnectivity(begin, end);
  derived().invalidate(begin, end);
  const MInt count = end - begin;
  if(end < size()) {
    move(std::max(end, size() - count), size(), begin);
  }
  m_size -= count;
}

removeAndFill() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::removeAndFill ( const MInt  id )

inline

Definition at line 115 of file container.h.

{ removeAndFill(id, id + 1); }

removeAndShift() [1/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::removeAndShift	(	const MInt	begin,
		const MInt	end
	)

Remove nodes in range [begin, end) and pull forward existing nodes while updating parent/child/neighbor information.

Definition at line 352 of file container.h.

                                                                                 {
  ENSURE_VALID_ID(begin);
  ENSURE_VALID_ID(end - 1);
 
  // Exit early if there is nothing to do
  if(end <= begin) {
    return;
  }
 
  derived().deleteConnectivity(begin, end);
  derived().invalidate(begin, end);
  if(end < size()) {
    move(end, size(), begin);
  }
  const MInt count = end - begin;
  m_size -= count;
}

removeAndShift() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::removeAndShift ( const MInt  id )

inline

Definition at line 113 of file container.h.

{ removeAndShift(id, id + 1); }

reset()

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::reset

(

const MInt

capacity

)

Definition at line 187 of file container.h.

                                                            {
  ENSURE_CONDITION(capacity_ >= 0, "Capacity must be non-negative");
 
  m_capacity = capacity_;
  m_size = 0;
 
  derived().reset();
}

resetStorage()

template<class Derived , template< class > class Invalid>

template<class T >

void maia::container::Container< Derived, Invalid >::resetStorage ( const MInt  n, Storage< T > &  c  )

protected

Definition at line 420 of file container.h.

                                                                          {
  // Note: Containers are always initialized with an invalid value as for, e.g., std::vector, all
  // entries are default initialized anyways and not providing an invalid value would zero all int's
  // and probably all float's as well.
  Storage<T>(std::max((m_capacity + 1) * n, 1), Invalid<T>::value()).swap(c);
  // TODO: This step is critical for OpenMP parallelization. In most numa
  // architecture data is placed by a 'first touch'-policy.
  // Storage(==std::vector) does a sequential initialization, i.e., it touches
  // all memory from the core associated with the main thread. That might
  // introduce memory access penalty in OpenMP usage.
}

resize() [1/2]

template<class Derived , template< class > class Invalid>

virtual void maia::container::Container< Derived, Invalid >::resize ( )

inlineprotectedvirtual

Reimplemented in maia::acoustic_analogy::collector::SurfaceDataCollector< nDim >, maia::fv::collector::FvCellCollector< nDim >, and maia::fv::surface_collector::FvSurfaceCollector< nDim >.

Definition at line 127 of file container.h.

{ TERMM(1, "not implemented"); };

resize() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::resize

(

const MInt

capacity

)

Definition at line 199 of file container.h.

                                                             {
  ENSURE_CONDITION(capacity_ >= 0, "Capacity must be non-negative");
  ENSURE_CONDITION(capacity_ >= m_capacity, "So far only resize to a larger size is tested.");
 
  if(capacity_ == m_capacity) return;
 
  m_capacity = capacity_;
 
  derived().resize();
}

resizeStorage()

template<class Derived , template< class > class Invalid>

template<class T >

void maia::container::Container< Derived, Invalid >::resizeStorage ( const MInt  n, Storage< T > &  c  )

protected

Definition at line 436 of file container.h.

                                                                           {
  c.resize(std::max((m_capacity + 1) * n, 1), Invalid<T>::value());
}

shrink() [1/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::shrink ( )

inline

Definition at line 96 of file container.h.

{ shrink(1); }

shrink() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::shrink

(

const MInt

count

)

Definition at line 242 of file container.h.

                                                         {
  ENSURE_CONDITION(count >= 0, "Count must be non-negative");
  ENSURE_CONDITION(size() - count >= 0, "New size below zero");
 
  removeAndShift(size() - count, size());
}

size() [1/2]

template<class Derived , template< class > class Invalid>

constexpr MInt maia::container::Container< Derived, Invalid >::size ( ) const

inlineconstexpr

Definition at line 89 of file container.h.

{ return m_size; }

size() [2/2]

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::size

(

const MInt

size_

)

Definition at line 213 of file container.h.

                                                       {
  ENSURE_CONDITION(size_ >= 0, "Size must be non-negative");
  ENSURE_CONDITION(size_ <= capacity(), "Size must not exceed capacity");
 
  m_size = size_;
}

swap()

template<class Derived , template< class > class Invalid>

void maia::container::Container< Derived, Invalid >::swap	(	const MInt	a,
		const MInt	b
	)

Definition at line 289 of file container.h.

                                                                 {
  ENSURE_VALID_ID(a);
  ENSURE_VALID_ID(b);
 
  // Exit early if a and b are the same node
  if(a == b) {
    return;
  }
 
  // Move a to dummy position
  rawCopy(derived(), a, dummy());
  derived().moveConnectivity(a, dummy());
 
  // Move b to a
  rawCopy(derived(), b, a);
  derived().moveConnectivity(b, a);
 
  // Move from dummy position to b
  rawCopy(derived(), dummy(), b);
  derived().moveConnectivity(dummy(), b);
 
  // Invalidate dummy to be sure
  derived().invalidate(dummy(), dummy() + 1);
}

Member Data Documentation

m_capacity

template<class Derived , template< class > class Invalid>

MInt maia::container::Container< Derived, Invalid >::m_capacity = 0

private

Definition at line 180 of file container.h.

m_size

template<class Derived , template< class > class Invalid>

MInt maia::container::Container< Derived, Invalid >::m_size = 0

private

Definition at line 181 of file container.h.

---

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

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/MEMORY/container.h