aboutsummaryrefslogtreecommitdiff
path: root/src/memusage.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/memusage.h')
-rw-r--r--src/memusage.h67
1 files changed, 66 insertions, 1 deletions
diff --git a/src/memusage.h b/src/memusage.h
index 9f7de9e2e1..7a831e6d33 100644
--- a/src/memusage.h
+++ b/src/memusage.h
@@ -11,6 +11,7 @@
#include <set>
#include <vector>
+#include <boost/foreach.hpp>
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
@@ -20,12 +21,28 @@ namespace memusage
/** Compute the total memory used by allocating alloc bytes. */
static size_t MallocUsage(size_t alloc);
+/** Dynamic memory usage for built-in types is zero. */
+static inline size_t DynamicUsage(const int8_t& v) { return 0; }
+static inline size_t DynamicUsage(const uint8_t& v) { return 0; }
+static inline size_t DynamicUsage(const int16_t& v) { return 0; }
+static inline size_t DynamicUsage(const uint16_t& v) { return 0; }
+static inline size_t DynamicUsage(const int32_t& v) { return 0; }
+static inline size_t DynamicUsage(const uint32_t& v) { return 0; }
+static inline size_t DynamicUsage(const int64_t& v) { return 0; }
+static inline size_t DynamicUsage(const uint64_t& v) { return 0; }
+static inline size_t DynamicUsage(const float& v) { return 0; }
+static inline size_t DynamicUsage(const double& v) { return 0; }
+template<typename X> static inline size_t DynamicUsage(X * const &v) { return 0; }
+template<typename X> static inline size_t DynamicUsage(const X * const &v) { return 0; }
+template<typename X, typename Y> static inline size_t DynamicUsage(std::pair<X, Y> &p) { return 0; }
+
/** Compute the memory used for dynamically allocated but owned data structures.
* For generic data types, this is *not* recursive. DynamicUsage(vector<vector<int> >)
* will compute the memory used for the vector<int>'s, but not for the ints inside.
* This is for efficiency reasons, as these functions are intended to be fast. If
* application data structures require more accurate inner accounting, they should
- * do the recursion themselves, or use more efficient caching + updating on modification.
+ * use RecursiveDynamicUsage, iterate themselves, or use more efficient caching +
+ * updating on modification.
*/
template<typename X> static size_t DynamicUsage(const std::vector<X>& v);
template<typename X> static size_t DynamicUsage(const std::set<X>& s);
@@ -34,6 +51,12 @@ template<typename X, typename Y> static size_t DynamicUsage(const boost::unorder
template<typename X, typename Y, typename Z> static size_t DynamicUsage(const boost::unordered_map<X, Y, Z>& s);
template<typename X> static size_t DynamicUsage(const X& x);
+template<typename X> static size_t RecursiveDynamicUsage(const std::vector<X>& v);
+template<typename X> static size_t RecursiveDynamicUsage(const std::set<X>& v);
+template<typename X, typename Y> static size_t RecursiveDynamicUsage(const std::map<X, Y>& v);
+template<typename X, typename Y> static size_t RecursiveDynamicUsage(const std::pair<X, Y>& v);
+template<typename X> static size_t RecursiveDynamicUsage(const X& v);
+
static inline size_t MallocUsage(size_t alloc)
{
// Measured on libc6 2.19 on Linux.
@@ -66,17 +89,53 @@ static inline size_t DynamicUsage(const std::vector<X>& v)
}
template<typename X>
+static inline size_t RecursiveDynamicUsage(const std::vector<X>& v)
+{
+ size_t usage = DynamicUsage(v);
+ BOOST_FOREACH(const X& x, v) {
+ usage += RecursiveDynamicUsage(x);
+ }
+ return usage;
+}
+
+template<typename X>
static inline size_t DynamicUsage(const std::set<X>& s)
{
return MallocUsage(sizeof(stl_tree_node<X>)) * s.size();
}
+template<typename X>
+static inline size_t RecursiveDynamicUsage(const std::set<X>& v)
+{
+ size_t usage = DynamicUsage(v);
+ BOOST_FOREACH(const X& x, v) {
+ usage += RecursiveDynamicUsage(x);
+ }
+ return usage;
+}
+
template<typename X, typename Y>
static inline size_t DynamicUsage(const std::map<X, Y>& m)
{
return MallocUsage(sizeof(stl_tree_node<std::pair<const X, Y> >)) * m.size();
}
+template<typename X, typename Y>
+static inline size_t RecursiveDynamicUsage(const std::map<X, Y>& v)
+{
+ size_t usage = DynamicUsage(v);
+ for (typename std::map<X, Y>::const_iterator it = v.begin(); it != v.end(); it++) {
+ usage += RecursiveDynamicUsage(*it);
+ }
+ return usage;
+}
+
+template<typename X, typename Y>
+static inline size_t RecursiveDynamicUsage(const std::pair<X, Y>& v)
+{
+ return RecursiveDynamicUsage(v.first) + RecursiveDynamicUsage(v.second);
+}
+
// Boost data structures
template<typename X>
@@ -106,6 +165,12 @@ static inline size_t DynamicUsage(const X& x)
return x.DynamicMemoryUsage();
}
+template<typename X>
+static inline size_t RecursiveDynamicUsage(const X& x)
+{
+ return DynamicUsage(x);
+}
+
}
#endif