CbC/CbC_gcc: gcc/mem-stats.h comparison

comparison gcc/mem-stats.h @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* A memory statistics tracking infrastructure.
-Copyright (C) 2015-2018 Free Software Foundation, Inc.
+Copyright (C) 2015-2020 Free Software Foundation, Inc.
 Contributed by Martin Liska  <mliska@suse.cz>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #define LOCATION_LINE_EXTRA_SPACE 30
 #define LOCATION_LINE_WIDTH	  48
 /* Memory allocation location.  */
-struct mem_location
+class mem_location
 {
+public:
 /* Default constructor.  */
 inline
 mem_location () {}
 /* Constructor.  */
 /* Flag if used by GGC allocation.  */
 bool m_ggc;
 };
 /* Memory usage register to a memory location.  */
-struct mem_usage
+class mem_usage
 {
+public:
 /* Default constructor.  */
 mem_usage (): m_allocated (0), m_times (0), m_peak (0), m_instances (1) {}
 /* Constructor.  */
 mem_usage (size_t allocated, size_t times, size_t peak, size_t instances = 0):
 inline void
 dump (mem_location *loc, mem_usage &total) const
 {
 char *location_string = loc->to_string ();
-fprintf (stderr, "%-48s %10" PRIu64 ":%5.1f%%"
+fprintf (stderr, "%-48s " PRsa (9) ":%5.1f%%"
-	     "%10" PRIu64 "%10" PRIu64 ":%5.1f%%%10s\n",
+	     PRsa (9) PRsa (9) ":%5.1f%%%10s\n",
-	     location_string, (uint64_t)m_allocated,
+	     location_string, SIZE_AMOUNT (m_allocated),
 	     get_percent (m_allocated, total.m_allocated),
-	     (uint64_t)m_peak, (uint64_t)m_times,
+	     SIZE_AMOUNT (m_peak), SIZE_AMOUNT (m_times),
 	     get_percent (m_times, total.m_times), loc->m_ggc ? "ggc" : "heap");
 free (location_string);
 }
 /* Dump footer.  */
 inline void
 dump_footer () const
 {
-print_dash_line ();
+fprintf (stderr, "%s" PRsa (53) PRsa (26) "\n", "Total",
-fprintf (stderr, "%s%54" PRIu64 "%27" PRIu64 "\n", "Total",
+	     SIZE_AMOUNT (m_allocated), SIZE_AMOUNT (m_times));
-	     (uint64_t)m_allocated, (uint64_t)m_times);
-print_dash_line ();
 }
 /* Return fraction of NOMINATOR and DENOMINATOR in percent.  */
 static inline float
 get_percent (size_t nominator, size_t denominator)
 static inline void
 dump_header (const char *name)
 {
 fprintf (stderr, "%-48s %11s%16s%10s%17s\n", name, "Leak", "Peak",
 	     "Times", "Type");
-print_dash_line ();
 }
 /* Current number of allocated bytes.  */
 size_t m_allocated;
 /* Number of allocations.  */
 };
 /* Memory usage pair that connectes memory usage and number
 of allocated bytes.  */
 template <class T>
-struct mem_usage_pair
+class mem_usage_pair
 {
+public:
 mem_usage_pair (T *usage_, size_t allocated_): usage (usage_),
 allocated (allocated_) {}
 T *usage;
 size_t allocated;
 struct mem_location_hash : nofree_ptr_hash <mem_location>
 {
 static hashval_t
 hash (value_type l)
 {
-	inchash::hash hstate;
+inchash::hash hstate;
-	hstate.add_ptr ((const void *)l->m_filename);
+hstate.add_ptr ((const void *)l->m_filename);
-	hstate.add_ptr (l->m_function);
+hstate.add_ptr (l->m_function);
-	hstate.add_int (l->m_line);
+hstate.add_int (l->m_line);
-	return hstate.end ();
+return hstate.end ();
 }
 static bool
 equal (value_type l1, value_type l2)
 {
-return l1->m_filename == l2->m_filename
+return (l1->m_filename == l2->m_filename
-	&& l1->m_function == l2->m_function
+	      && l1->m_function == l2->m_function
-	&& l1->m_line == l2->m_line;
+	      && l1->m_line == l2->m_line);
 }
 };
 /* Internal class type definitions.  */
 typedef hash_map <mem_location_hash, T *> mem_map_t;
 /* Default destructor.  */
 ~mem_alloc_description ();
 /* Returns true if instance PTR is registered by the memory description.  */
-bool
+bool contains_descriptor_for_instance (const void *ptr);
-contains_descriptor_for_instance (const void *ptr);
 /* Return descriptor for instance PTR.  */
-T *
+T *get_descriptor_for_instance (const void *ptr);
-get_descriptor_for_instance (const void *ptr);
 /* Register memory allocation descriptor for container PTR which is
 described by a memory LOCATION.  */
-T *
+T *register_descriptor (const void *ptr, mem_location *location);
-register_descriptor (const void *ptr, mem_location *location);
 /* Register memory allocation descriptor for container PTR.  ORIGIN identifies
 type of container and GGC identifes if the allocation is handled in GGC
 memory.  Each location is identified by file NAME, LINE in source code and
 FUNCTION name.  */
-T *
+T *register_descriptor (const void *ptr, mem_alloc_origin origin,
-register_descriptor (const void *ptr, mem_alloc_origin origin,
 			  bool ggc, const char *name, int line,
 			  const char *function);
 /* Register instance overhead identified by PTR pointer. Allocation takes
 SIZE bytes.  */
-T *
+T *register_instance_overhead (size_t size, const void *ptr);
-register_instance_overhead (size_t size, const void *ptr);
 /* For containers (and GGC) where we want to track every instance object,
 we register allocation of SIZE bytes, identified by PTR pointer, belonging
 to USAGE descriptor.  */
-void
+void register_object_overhead (T *usage, size_t size, const void *ptr);
-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.  */
+remove the instance from reverse map.  Return memory usage that belongs
-void
+to this memory description.  */
-release_instance_overhead (void *ptr, size_t size,
+T *release_instance_overhead (void *ptr, size_t size,
-				  bool remove_from_map = false);
+				bool remove_from_map = false);
-/* Release intance object identified by PTR pointer.  */
+/* Release instance object identified by PTR pointer.  */
-void
+void release_object_overhead (void *ptr);
-release_object_overhead (void *ptr);
+/* Unregister a memory allocation descriptor registered with
+register_descriptor (remove from reverse map), unless it is
+unregistered through release_instance_overhead with
+REMOVE_FROM_MAP = true.  */
+void unregister_descriptor (void *ptr);
 /* Get sum value for ORIGIN type of allocation for the descriptor.  */
-T
+T get_sum (mem_alloc_origin origin);
-get_sum (mem_alloc_origin origin);
 /* Get all tracked instances registered by the description. Items
 are filtered by ORIGIN type, LENGTH is return value where we register
 the number of elements in the list. If we want to process custom order,
 CMP comparator can be provided.  */
-mem_list_t *
+mem_list_t *get_list (mem_alloc_origin origin, unsigned *length);
-get_list (mem_alloc_origin origin, unsigned *length,
-	    int (*cmp) (const void *first, const void *second) = NULL);
 /* Dump all tracked instances of type ORIGIN. If we want to process custom
 order, CMP comparator can be provided.  */
-void dump (mem_alloc_origin origin,
+void dump (mem_alloc_origin origin);
-	     int (*cmp) (const void *first, const void *second) = NULL);
 /* Reverse object map used for every object allocation mapping.  */
 reverse_object_map_t *m_reverse_object_map;
 private:
 /* Reverse pointer to usage mapping.  */
 reverse_mem_map_t *m_reverse_map;
 };
 /* Returns true if instance PTR is registered by the memory description.  */
 template <class T>
 inline bool
 mem_alloc_description<T>::contains_descriptor_for_instance (const void *ptr)
 mem_alloc_description<T>::get_descriptor_for_instance (const void *ptr)
 {
 return m_reverse_map->get (ptr) ? (*m_reverse_map->get (ptr)).usage : NULL;
 }
+/* Register memory allocation descriptor for container PTR which is
-/* Register memory allocation descriptor for container PTR which is
+described by a memory LOCATION.  */
-described by a memory LOCATION.  */
 template <class T>
 inline T*
 mem_alloc_description<T>::register_descriptor (const void *ptr,
 					       mem_location *location)
 {
 }
 /* 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)
 {
 mem_usage_pair<T> *slot = m_reverse_map->get (ptr);
 if (!slot)
 {
 /* Due to PCH, it can really happen.  */
-return;
+return NULL;
 }
-mem_usage_pair<T> usage_pair = *slot;
+T *usage = (*slot).usage;
-usage_pair.usage->release_overhead (size);
+usage->release_overhead (size);
 if (remove_from_map)
 m_reverse_map->remove (ptr);
-}
+return usage;
-/* Release intance object identified by PTR pointer.  */
+}
+/* Release instance object identified by PTR pointer.  */
 template <class T>
 inline void
 mem_alloc_description<T>::release_object_overhead (void *ptr)
 {
 std::pair <T *, size_t> *entry = m_reverse_object_map->get (ptr);
-if (entry)
+entry->first->release_overhead (entry->second);
-{
+m_reverse_object_map->remove (ptr);
-entry->first->release_overhead (entry->second);
+}
-m_reverse_object_map->remove (ptr);
-}
+/* Unregister a memory allocation descriptor registered with
+register_descriptor (remove from reverse map), unless it is
+unregistered through release_instance_overhead with
+REMOVE_FROM_MAP = true.  */
+template <class T>
+inline void
+mem_alloc_description<T>::unregister_descriptor (void *ptr)
+{
+m_reverse_map->remove (ptr);
 }
 /* Default contructor.  */
 template <class T>
 inline
 mem_alloc_description<T>::mem_alloc_description ()
 {
-m_map = new mem_map_t (13, false, false);
+m_map = new mem_map_t (13, false, false, false);
-m_reverse_map = new reverse_mem_map_t (13, false, false);
+m_reverse_map = new reverse_mem_map_t (13, false, false, false);
-m_reverse_object_map = new reverse_object_map_t (13, false, false);
+m_reverse_object_map = new reverse_object_map_t (13, false, false, false);
 }
 /* Default destructor.  */
 template <class T>
 can be provided.  */
 template <class T>
 inline
 typename mem_alloc_description<T>::mem_list_t *
-mem_alloc_description<T>::get_list (mem_alloc_origin origin, unsigned *length,
+mem_alloc_description<T>::get_list (mem_alloc_origin origin, unsigned *length)
-			int (*cmp) (const void *first, const void *second))
 {
 /* vec data structure is not used because all vectors generate memory
 allocation info a it would create a cycle.  */
 size_t element_size = sizeof (mem_list_t);
 mem_list_t *list = XCNEWVEC (mem_list_t, m_map->elements ());
 for (typename mem_map_t::iterator it = m_map->begin (); it != m_map->end ();
 ++it)
 if ((*it).first->m_origin == origin)
 list[i++] = std::pair<mem_location*, T*> (*it);
-qsort (list, i, element_size, cmp == NULL ? T::compare : cmp);
+qsort (list, i, element_size, T::compare);
 *length = i;
 return list;
 }
 /* Dump all tracked instances of type ORIGIN. If we want to process custom
 order, CMP comparator can be provided.  */
 template <class T>
 inline void
-mem_alloc_description<T>::dump (mem_alloc_origin origin,
+mem_alloc_description<T>::dump (mem_alloc_origin origin)
-				int (*cmp) (const void *first,
-					    const void *second))
 {
 unsigned length;
 fprintf (stderr, "\n");
-mem_list_t *list = get_list (origin, &length, cmp);
+mem_list_t *list = get_list (origin, &length);
 T total = get_sum (origin);
+T::print_dash_line ();
 T::dump_header (mem_location::get_origin_name (origin));
+T::print_dash_line ();
 for (int i = length - 1; i >= 0; i--)
 list[i].second->dump (list[i].first, total);
+T::print_dash_line ();
+T::dump_header (mem_location::get_origin_name (origin));
+T::print_dash_line ();
 total.dump_footer ();
+T::print_dash_line ();
 XDELETEVEC (list);
 fprintf (stderr, "\n");
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/mem-stats.h @ 145:1830386684a0