Reference documentation for deal.II version 8.4.1

Functions  
template<typename T >  
std_cxx11::enable_if< std_cxx11::is_fundamental< T >::value, std::size_t >::type  memory_consumption (const T &t) 
template<typename T >  
std_cxx11::enable_if<!(std_cxx11::is_fundamental< T >::valuestd_cxx11::is_pointer< T >::value), std::size_t >::type  memory_consumption (const T &t) 
std::size_t  memory_consumption (const char *string) 
template<typename T >  
std::size_t  memory_consumption (const std::complex< T > &) 
template<typename T >  
std::size_t  memory_consumption (const VectorizedArray< T > &) 
std::size_t  memory_consumption (const std::string &s) 
template<typename T >  
std::size_t  memory_consumption (const std::vector< T > &v) 
template<typename T , int N>  
std::size_t  memory_consumption (const T(&v)[N]) 
std::size_t  memory_consumption (const std::vector< bool > &v) 
template<typename A , typename B >  
std::size_t  memory_consumption (const std::pair< A, B > &p) 
template<typename T >  
std::size_t  memory_consumption (const T *const) 
template<typename T >  
std::size_t  memory_consumption (const std_cxx11::shared_ptr< T > &) 
template<typename T >  
std::size_t  memory_consumption (const std_cxx11::unique_ptr< T > &) 
This namespace provides functions helping to determine the amount of memory used by objects. The goal is not necessarily to give the amount of memory used up to the last bit (what is the memory used by a std::map
object?), but rather to aid in the search for memory bottlenecks.
This namespace has a single member function memory_consumption() and a lot of specializations. Depending on the argument type of the function, there are several modes of operation:
If the argument is a fundamental C++ data type (such as bool
, float
, double
or any of the integer types), then memory_consumption() just returns sizeof
of its argument. The library also provides an estimate for the amount of memory occupied by a std::string
.
For objects, which are neither standard types, nor vectors, memory_consumption() will simply call the member function of same name. It is up to the implementation of the data type to provide a good estimate of the amount of memory used. Inside this function, the use of MemoryConsumption::memory_consumption() for compounds of the class helps to obtain this estimate. Most classes in the deal.II library have such a member function.
For vectors and C++ arrays of objects, memory_consumption() recursively calls itself for all entries and adds the results to the size of the object itself. Some optimized specializations for standard data types exist.
For vectors of regular pointers, memory_consumption(T*) returns the size of the vector of pointers, ignoring the size of the objects.
The function in this namespace and the functionality provided by it relies on the assumption that there is either a function memory_consumption(T)
in this namespace determining the amount of memory used by objects of type T
or that the class T
has a member function of that name. While the latter is true for almost all classes in deal.II, we have only implemented the first kind of functions for the most common data types, such as fundamental types, strings, C++ vectors, Cstyle arrays, and C++ pairs. These functions therefore do not cover, for example, C++ maps, lists, etc. If you need such functions feel free to implement them and send them to us for inclusion.

inline 
Calculate the memory consumption of a fundamental type. See EnableIfScalar for a discussion on how this restriction (SFINAE) is implemented.
Definition at line 249 of file memory_consumption.h.

inline 
Estimate the memory consumption of an object. If no further template specialization (past this one) is available for the type T
, then this function returns the member function t.memory_consumption()
's value.
Definition at line 381 of file memory_consumption.h.

inline 
Determine the amount of memory consumed by a Cstyle string. The returned value does not include the size of the pointer. This function only measures up to (and including) the NUL byte; the underlying buffer may be larger.
Definition at line 257 of file memory_consumption.h.

inline 
Determine the amount of memory in bytes consumed by a std::complex
variable.
Definition at line 273 of file memory_consumption.h.

inline 
Determine the amount of memory in bytes consumed by a VectorizedArray
variable.
Definition at line 282 of file memory_consumption.h.

inline 
Determine an estimate of the amount of memory in bytes consumed by a std::string
variable.
Definition at line 290 of file memory_consumption.h.

inline 
Determine the amount of memory in bytes consumed by a std::vector
of elements of type T
by recursively calling memory_consumption() for each entry.
This function loops over all entries of the vector and determines their sizes using memory_consumption() for each v[i]
. If the entries are of constant size, there might be another global function memory_consumption() for this data type or if there is a member function of that class of that names that returns a constant value and the compiler will unroll this loop so that the operation is fast. If the size of the data elements is variable, for example if they do memory allocation themselves, then the operation will necessarily be more expensive.
Using the algorithm, in particular the loop over all elements, it is possible to also compute the memory consumption of vectors of vectors, vectors of strings, etc, where the individual elements may have vastly different sizes.
Note that this algorithm also takes into account the size of elements that are allocated by this vector but not currently used.
For the most commonly used vectors, there are special functions that compute the size without a loop. This also applies for the special case of vectors of bools.
Definition at line 298 of file memory_consumption.h.

inline 
Estimate the amount of memory (in bytes) occupied by a Cstyle array. Since in this library we do not usually store simple data elements like double
s in such arrays (but rather use std::vector
s or deal.II Vector
objects), we do not provide specializations like for the std::vector
arrays, but always use the loop over all elements.
Definition at line 320 of file memory_consumption.h.

inline 
Specialization of the determination of the memory consumption of a vector, here for a vector of bool
s.
This is a special case, as the bools are not stored onebyone, but as a bit field.
Definition at line 331 of file memory_consumption.h.

inline 
Determine an estimate of the amount of memory in bytes consumed by a pair of values.
Definition at line 340 of file memory_consumption.h.

inline 
Calculate the memory consumption of a pointer.
Definition at line 351 of file memory_consumption.h.

inline 
Return the amount of memory used by a shared pointer.
Definition at line 361 of file memory_consumption.h.

inline 
Return the amount of memory used by a std_cxx11::unique_ptr object.
Definition at line 371 of file memory_consumption.h.