Fix vector memory statistics.

2018-11-05  Martin Liska  <mliska@suse.cz>

	* mem-stats.h (mem_alloc_description::release_instance_overhead):
	Return T *.
	* vec.c (struct vec_usage): Register m_element_size.
	(vec_prefix::register_overhead): New arguments: elements and
	element_size.
	(vec_prefix::release_overhead): Subtract elements.
	* vec.h (struct vec_prefix): Change signature.
	(va_heap::reserve): Pass proper arguments.
	(va_heap::release): Likewise.

From-SVN: r265799

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 45f2e904f3b62c3e4b45bef7ee3efd4ead75e7c8..fd48d8fda965f998c0d3017129326b5cda31b234 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,15 @@
+2018-11-05  Martin Liska  <mliska@suse.cz>
+
+       * mem-stats.h (mem_alloc_description::release_instance_overhead):
+       Return T *.
+       * vec.c (struct vec_usage): Register m_element_size.
+       (vec_prefix::register_overhead): New arguments: elements and
+       element_size.
+       (vec_prefix::release_overhead): Subtract elements.
+       * vec.h (struct vec_prefix): Change signature.
+       (va_heap::reserve): Pass proper arguments.
+       (va_heap::release): Likewise.
+
 2018-11-05  Martin Liska  <mliska@suse.cz>
 
        * mem-stats.h (mem_alloc_description::get_list): Fix GNU coding

diff --git a/gcc/mem-stats.h b/gcc/mem-stats.h
index 3ef6d53dfa625e235d47dcddefcf042fdf4a3758..b7f7e06a1c7069332d8cea5bebbefb3a0a75be10 100644 (file)
--- a/gcc/mem-stats.h
+++ b/gcc/mem-stats.h
@@ -340,9 +340,10 @@ public:
   void register_object_overhead (T *usage, size_t size, const void *ptr);
 
   /* Release PTR pointer of SIZE bytes. If REMOVE_FROM_MAP is set to true,
-     remove the instance from reverse map.  */
-  void release_instance_overhead (void *ptr, size_t size,
-                                 bool remove_from_map = false);
+     remove the instance from reverse map.  Return memory usage that belongs
+     to this memory description.  */
+  T * release_instance_overhead (void *ptr, size_t size,
+                                bool remove_from_map = false);
 
   /* Release intance object identified by PTR pointer.  */
   void release_object_overhead (void *ptr);
@@ -503,7 +504,7 @@ mem_alloc_description<T>::register_overhead (size_t size,
 /* Release PTR pointer of SIZE bytes.  */
 
 template <class T>
-inline void
+inline T *
 mem_alloc_description<T>::release_instance_overhead (void *ptr, size_t size,
                                                     bool remove_from_map)
 {
@@ -512,14 +513,16 @@ mem_alloc_description<T>::release_instance_overhead (void *ptr, size_t size,
   if (!slot)
     {
       /* Due to PCH, it can really happen.  */
-      return;
+      return NULL;
     }
 
-  mem_usage_pair<T> usage_pair = *slot;
-  usage_pair.usage->release_overhead (size);
+  T *usage = (*slot).usage;
+  usage->release_overhead (size);
 
   if (remove_from_map)
     m_reverse_map->remove (ptr);
+
+  return usage;
 }
 
 /* Release intance object identified by PTR pointer.  */

diff --git a/gcc/vec.c b/gcc/vec.c
index ff2456aead9ea67e738ee7c72aedb3e51c0dd48c..bfd52856e4686ae7a8d4b0d2d2f71acf7b2930b2 100644 (file)
--- a/gcc/vec.c
+++ b/gcc/vec.c
@@ -52,13 +52,14 @@ vnull vNULL;
 struct vec_usage: public mem_usage
 {
   /* Default constructor.  */
-  vec_usage (): m_items (0), m_items_peak (0) {}
+  vec_usage (): m_items (0), m_items_peak (0), m_element_size (0) {}
 
   /* Constructor.  */
   vec_usage (size_t allocated, size_t times, size_t peak,
-            size_t items, size_t items_peak)
+            size_t items, size_t items_peak, size_t element_size)
     : mem_usage (allocated, times, peak),
-    m_items (items), m_items_peak (items_peak) {}
+    m_items (items), m_items_peak (items_peak),
+    m_element_size (element_size) {}
 
   /* Sum the usage with SECOND usage.  */
   vec_usage
@@ -68,7 +69,7 @@ struct vec_usage: public mem_usage
                      m_times + second.m_times,
                      m_peak + second.m_peak,
                      m_items + second.m_items,
-                     m_items_peak + second.m_items_peak);
+                     m_items_peak + second.m_items_peak, 0);
   }
 
   /* Dump usage coupled to LOC location, where TOTAL is sum of all rows.  */
@@ -81,7 +82,8 @@ struct vec_usage: public mem_usage
 
     s[48] = '\0';
 
-    fprintf (stderr, "%-48s %10li:%4.1f%%%10li%10li:%4.1f%%%11li%11li\n", s,
+    fprintf (stderr, "%-48s %10li%11li:%4.1f%%%10li%10li:%4.1f%%%11li%11li\n", s,
+            (long)m_element_size,
             (long)m_allocated, m_allocated * 100.0 / total.m_allocated,
             (long)m_peak, (long)m_times, m_times * 100.0 / total.m_times,
             (long)m_items, (long)m_items_peak);
@@ -101,8 +103,8 @@ struct vec_usage: public mem_usage
   static inline void
   dump_header (const char *name)
   {
-    fprintf (stderr, "%-48s %11s%15s%10s%17s%11s\n", name, "Leak", "Peak",
-            "Times", "Leak items", "Peak items");
+    fprintf (stderr, "%-48s %10s%11s%16s%10s%17s%11s\n", name, "sizeof(T)",
+            "Leak", "Peak", "Times", "Leak items", "Peak items");
     print_dash_line ();
   }
 
@@ -110,6 +112,8 @@ struct vec_usage: public mem_usage
   size_t m_items;
   /* Peak value of number of allocated items.  */
   size_t m_items_peak;
+  /* Size of element of the vector.  */
+  size_t m_element_size;
 };
 
 /* Vector memory description.  */
@@ -118,12 +122,14 @@ static mem_alloc_description <vec_usage> vec_mem_desc;
 /* Account the overhead.  */
 
 void
-vec_prefix::register_overhead (void *ptr, size_t size, size_t elements
-                              MEM_STAT_DECL)
+vec_prefix::register_overhead (void *ptr, size_t elements,
+                              size_t element_size MEM_STAT_DECL)
 {
   vec_mem_desc.register_descriptor (ptr, VEC_ORIGIN, false
                                    FINAL_PASS_MEM_STAT);
-  vec_usage *usage = vec_mem_desc.register_instance_overhead (size, ptr);
+  vec_usage *usage
+    = vec_mem_desc.register_instance_overhead (elements * element_size, ptr);
+  usage->m_element_size = element_size;
   usage->m_items += elements;
   if (usage->m_items_peak < usage->m_items)
     usage->m_items_peak = usage->m_items;
@@ -132,13 +138,15 @@ vec_prefix::register_overhead (void *ptr, size_t size, size_t elements
 /* Notice that the memory allocated for the vector has been freed.  */
 
 void
-vec_prefix::release_overhead (void *ptr, size_t size, bool in_dtor
-                             MEM_STAT_DECL)
+vec_prefix::release_overhead (void *ptr, size_t size, size_t elements,
+                             bool in_dtor MEM_STAT_DECL)
 {
   if (!vec_mem_desc.contains_descriptor_for_instance (ptr))
     vec_mem_desc.register_descriptor (ptr, VEC_ORIGIN,
                                      false FINAL_PASS_MEM_STAT);
-  vec_mem_desc.release_instance_overhead (ptr, size, in_dtor);
+  vec_usage *usage = vec_mem_desc.release_instance_overhead (ptr, size,
+                                                            in_dtor);
+  usage->m_items -= elements;
 }
 
 /* Calculate the number of slots to reserve a vector, making sure that

diff --git a/gcc/vec.h b/gcc/vec.h
index 0af5187782e0b31c83e000d0409fd79f31fcbf00..f8c039754d2d105ff3d85805f0ea91d64940d9a1 100644 (file)
--- a/gcc/vec.h
+++ b/gcc/vec.h
@@ -195,7 +195,7 @@ struct vec_prefix
 
   /* Memory allocation support routines in vec.c.  */
   void register_overhead (void *, size_t, size_t CXX_MEM_STAT_INFO);
-  void release_overhead (void *, size_t, bool CXX_MEM_STAT_INFO);
+  void release_overhead (void *, size_t, size_t, bool CXX_MEM_STAT_INFO);
   static unsigned calculate_allocation (vec_prefix *, unsigned, bool);
   static unsigned calculate_allocation_1 (unsigned, unsigned);
 
@@ -276,12 +276,14 @@ inline void
 va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact
                  MEM_STAT_DECL)
 {
+  size_t elt_size = sizeof (T);
   unsigned alloc
     = vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
   gcc_checking_assert (alloc);
 
   if (GATHER_STATISTICS && v)
-    v->m_vecpfx.release_overhead (v, v->allocated (), false);
+    v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
+                                 v->allocated (), false);
 
   size_t size = vec<T, va_heap, vl_embed>::embedded_size (alloc);
   unsigned nelem = v ? v->length () : 0;
@@ -289,7 +291,7 @@ va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact
   v->embedded_init (alloc, nelem);
 
   if (GATHER_STATISTICS)
-    v->m_vecpfx.register_overhead (v, alloc, nelem PASS_MEM_STAT);
+    v->m_vecpfx.register_overhead (v, alloc, elt_size PASS_MEM_STAT);
 }
 
 
@@ -299,11 +301,13 @@ template<typename T>
 void
 va_heap::release (vec<T, va_heap, vl_embed> *&v)
 {
+  size_t elt_size = sizeof (T);
   if (v == NULL)
     return;
 
   if (GATHER_STATISTICS)
-    v->m_vecpfx.release_overhead (v, v->allocated (), true);
+    v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
+                                 v->allocated (), true);
   ::free (v);
   v = NULL;
 }