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:
The argument is a standard C++ data type, namely,
double or any of the integer types. In that case, memory_consumption() simple returns
sizeof of its argument. The library also provides an estimate for the amount of memory occupied by a
std::string this way.
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.
Extending this namespace
The function in this namespace and the functionality provided by it relies on the assumption that there is either a specialized 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 atomic types, strings, C++ vectors, C-style 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.
- Wolfgang Bangerth, documentation updated by Guido Kanschat
template<typename T >
||const std::vector< T > &
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 506 of file memory_consumption.h.
template<typename T , int N>
Estimate the amount of memory (in bytes) occupied by a C-style array. Since in this library we do not usually store simple data elements like
doubles in such arrays (but rather use
std::vectors 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 519 of file memory_consumption.h.