1 /* A memory statistics tracking infrastructure.
2 Copyright (C) 2015-2023 Free Software Foundation, Inc.
3 Contributed by Martin Liska <mliska@suse.cz>
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21 #ifndef GCC_MEM_STATS_H
22 #define GCC_MEM_STATS_H
23
24 /* Forward declaration. */
25 template<typename Key, typename Value,
26 typename Traits = simple_hashmap_traits<default_hash_traits<Key>,
27 Value> >
28 class hash_map;
29
30 #define LOCATION_LINE_EXTRA_SPACE 30
31 #define LOCATION_LINE_WIDTH 48
32
33 /* Memory allocation location. */
34 class mem_location
35 {
36 public:
37 /* Default constructor. */
38 inline
39 mem_location () {}
40
41 /* Constructor. */
42 inline
43 mem_location (mem_alloc_origin origin, bool ggc,
44 const char *filename = NULL, int line = 0,
45 const char *function = NULL):
46 m_filename (filename), m_function (function), m_line (line), m_origin
47 (origin), m_ggc (ggc) {}
48
49 /* Copy constructor. */
50 inline
51 mem_location (mem_location &other): m_filename (other.m_filename),
52 m_function (other.m_function), m_line (other.m_line),
53 m_origin (other.m_origin), m_ggc (other.m_ggc) {}
54
55 /* Compute hash value based on file name, function name and line in
56 source code. As there is just a single pointer registered for every
57 constant that points to e.g. the same file name, we can use hash
58 of the pointer. */
59 hashval_t
60 hash ()
61 {
62 inchash::hash hash;
63
64 hash.add_ptr (m_filename);
65 hash.add_ptr (m_function);
66 hash.add_int (m_line);
67
68 return hash.end ();
69 }
70
71 /* Return true if the memory location is equal to OTHER. */
72 int
73 equal (const mem_location &other)
74 {
75 return m_filename == other.m_filename && m_function == other.m_function
76 && m_line == other.m_line;
77 }
78
79 /* Return trimmed filename for the location. */
80 inline const char *
81 get_trimmed_filename ()
82 {
83 const char *s1 = m_filename;
84 const char *s2;
85
86 while ((s2 = strstr (s1, "gcc/")))
87 s1 = s2 + 4;
88
89 return s1;
90 }
91
92 inline char *
93 to_string ()
94 {
95 unsigned l = strlen (get_trimmed_filename ()) + strlen (m_function)
96 + LOCATION_LINE_EXTRA_SPACE;
97
98 char *s = XNEWVEC (char, l);
99 sprintf (s, "%s:%i (%s)", get_trimmed_filename (),
100 m_line, m_function);
101
102 s[MIN (LOCATION_LINE_WIDTH, l - 1)] = '\0';
103
104 return s;
105 }
106
107 /* Return display name associated to ORIGIN type. */
108 static const char *
109 get_origin_name (mem_alloc_origin origin)
110 {
111 return mem_alloc_origin_names[(unsigned) origin];
112 }
113
114 /* File name of source code. */
115 const char *m_filename;
116 /* Funcation name. */
117 const char *m_function;
118 /* Line number in source code. */
119 int m_line;
120 /* Origin type. */
121 mem_alloc_origin m_origin;
122 /* Flag if used by GGC allocation. */
123 bool m_ggc;
124 };
125
126 /* Memory usage register to a memory location. */
127 class mem_usage
128 {
129 public:
130 /* Default constructor. */
131 mem_usage (): m_allocated (0), m_times (0), m_peak (0), m_instances (1) {}
132
133 /* Constructor. */
134 mem_usage (size_t allocated, size_t times, size_t peak, size_t instances = 0):
135 m_allocated (allocated), m_times (times), m_peak (peak),
136 m_instances (instances) {}
137
138 /* Register overhead of SIZE bytes. */
139 inline void
140 register_overhead (size_t size)
141 {
142 m_allocated += size;
143 m_times++;
144
145 if (m_peak < m_allocated)
146 m_peak = m_allocated;
147 }
148
149 /* Release overhead of SIZE bytes. */
150 inline void
151 release_overhead (size_t size)
152 {
153 gcc_assert (size <= m_allocated);
154
155 m_allocated -= size;
156 }
157
158 /* Sum the usage with SECOND usage. */
159 mem_usage
160 operator+ (const mem_usage &second)
161 {
162 return mem_usage (m_allocated + second.m_allocated,
163 m_times + second.m_times,
164 m_peak + second.m_peak,
165 m_instances + second.m_instances);
166 }
167
168 /* Equality operator. */
169 inline bool
170 operator== (const mem_usage &second) const
171 {
172 return (m_allocated == second.m_allocated
173 && m_peak == second.m_peak
174 && m_times == second.m_times);
175 }
176
177 /* Comparison operator. */
178 inline bool
179 operator< (const mem_usage &second) const
180 {
181 if (*this == second)
182 return false;
183
184 return (m_allocated == second.m_allocated ?
185 (m_peak == second.m_peak ? m_times < second.m_times
186 : m_peak < second.m_peak) : m_allocated < second.m_allocated);
187 }
188
189 /* Compare wrapper used by qsort method. */
190 static int
191 compare (const void *first, const void *second)
192 {
193 typedef std::pair<mem_location *, mem_usage *> mem_pair_t;
194
195 const mem_pair_t f = *(const mem_pair_t *)first;
196 const mem_pair_t s = *(const mem_pair_t *)second;
197
198 if (*f.second == *s.second)
199 return 0;
200
201 return *f.second < *s.second ? 1 : -1;
202 }
203
204 /* Dump usage coupled to LOC location, where TOTAL is sum of all rows. */
205 inline void
206 dump (mem_location *loc, const mem_usage &total) const
207 {
208 char *location_string = loc->to_string ();
209
210 fprintf (stderr, "%-48s " PRsa (9) ":%5.1f%%"
211 PRsa (9) PRsa (9) ":%5.1f%%%10s\n",
212 location_string, SIZE_AMOUNT (m_allocated),
213 get_percent (m_allocated, total.m_allocated),
214 SIZE_AMOUNT (m_peak), SIZE_AMOUNT (m_times),
215 get_percent (m_times, total.m_times), loc->m_ggc ? "ggc" : "heap");
216
217 free (location_string);
218 }
219
220 /* Dump footer. */
221 inline void
222 dump_footer () const
223 {
224 fprintf (stderr, "%s" PRsa (53) PRsa (26) "\n", "Total",
225 SIZE_AMOUNT (m_allocated), SIZE_AMOUNT (m_times));
226 }
227
228 /* Return fraction of NOMINATOR and DENOMINATOR in percent. */
229 static inline float
230 get_percent (size_t nominator, size_t denominator)
231 {
232 return denominator == 0 ? 0.0f : nominator * 100.0 / denominator;
233 }
234
235 /* Print line made of dashes. */
236 static inline void
237 print_dash_line (size_t count = 140)
238 {
239 while (count--)
240 fputc ('-', stderr);
241 fputc ('\n', stderr);
242 }
243
244 /* Dump header with NAME. */
245 static inline void
246 dump_header (const char *name)
247 {
248 fprintf (stderr, "%-48s %11s%16s%10s%17s\n", name, "Leak", "Peak",
249 "Times", "Type");
250 }
251
252 /* Current number of allocated bytes. */
253 size_t m_allocated;
254 /* Number of allocations. */
255 size_t m_times;
256 /* Peak allocation in bytes. */
257 size_t m_peak;
258 /* Number of container instances. */
259 size_t m_instances;
260 };
261
262 /* Memory usage pair that connectes memory usage and number
263 of allocated bytes. */
264 template <class T>
265 class mem_usage_pair
266 {
267 public:
268 mem_usage_pair (T *usage_, size_t allocated_): usage (usage_),
269 allocated (allocated_) {}
270
271 T *usage;
272 size_t allocated;
273 };
274
275 /* Memory allocation description. */
276 template <class T>
277 class mem_alloc_description
278 {
279 public:
280 struct mem_location_hash : nofree_ptr_hash <mem_location>
281 {
282 static hashval_t
283 hash (value_type l)
284 {
285 inchash::hash hstate;
286
287 hstate.add_ptr ((const void *)l->m_filename);
288 hstate.add_ptr (l->m_function);
289 hstate.add_int (l->m_line);
290
291 return hstate.end ();
292 }
293
294 static bool
295 equal (value_type l1, value_type l2)
296 {
297 return (l1->m_filename == l2->m_filename
298 && l1->m_function == l2->m_function
299 && l1->m_line == l2->m_line);
300 }
301 };
302
303 /* Internal class type definitions. */
304 typedef hash_map <mem_location_hash, T *> mem_map_t;
305 typedef hash_map <const void *, mem_usage_pair<T> > reverse_mem_map_t;
306 typedef hash_map <const void *, std::pair<T *, size_t> > reverse_object_map_t;
307 typedef std::pair <mem_location *, T *> mem_list_t;
308
309 /* Default contructor. */
310 mem_alloc_description ();
311
312 /* Default destructor. */
313 ~mem_alloc_description ();
314
315 /* Returns true if instance PTR is registered by the memory description. */
316 bool contains_descriptor_for_instance (const void *ptr);
317
318 /* Return descriptor for instance PTR. */
319 T *get_descriptor_for_instance (const void *ptr);
320
321 /* Register memory allocation descriptor for container PTR which is
322 described by a memory LOCATION. */
323 T *register_descriptor (const void *ptr, mem_location *location);
324
325 /* Register memory allocation descriptor for container PTR. ORIGIN identifies
326 type of container and GGC identifes if the allocation is handled in GGC
327 memory. Each location is identified by file NAME, LINE in source code and
328 FUNCTION name. */
329 T *register_descriptor (const void *ptr, mem_alloc_origin origin,
330 bool ggc, const char *name, int line,
331 const char *function);
332
333 /* Register instance overhead identified by PTR pointer. Allocation takes
334 SIZE bytes. */
335 T *register_instance_overhead (size_t size, const void *ptr);
336
337 /* For containers (and GGC) where we want to track every instance object,
338 we register allocation of SIZE bytes, identified by PTR pointer, belonging
339 to USAGE descriptor. */
340 void register_object_overhead (T *usage, size_t size, const void *ptr);
341
342 /* Release PTR pointer of SIZE bytes. If REMOVE_FROM_MAP is set to true,
343 remove the instance from reverse map. Return memory usage that belongs
344 to this memory description. */
345 T *release_instance_overhead (void *ptr, size_t size,
346 bool remove_from_map = false);
347
348 /* Release instance object identified by PTR pointer. */
349 void release_object_overhead (void *ptr);
350
351 /* Unregister a memory allocation descriptor registered with
352 register_descriptor (remove from reverse map), unless it is
353 unregistered through release_instance_overhead with
354 REMOVE_FROM_MAP = true. */
355 void unregister_descriptor (void *ptr);
356
357 /* Get sum value for ORIGIN type of allocation for the descriptor. */
358 T get_sum (mem_alloc_origin origin);
359
360 /* Get all tracked instances registered by the description. Items
361 are filtered by ORIGIN type, LENGTH is return value where we register
362 the number of elements in the list. If we want to process custom order,
363 CMP comparator can be provided. */
364 mem_list_t *get_list (mem_alloc_origin origin, unsigned *length);
365
366 /* Dump all tracked instances of type ORIGIN. If we want to process custom
367 order, CMP comparator can be provided. */
368 void dump (mem_alloc_origin origin);
369
370 /* Reverse object map used for every object allocation mapping. */
371 reverse_object_map_t *m_reverse_object_map;
372
373 private:
374 /* Register overhead of SIZE bytes of ORIGIN type. PTR pointer is allocated
375 in NAME source file, at LINE in source code, in FUNCTION. */
376 T *register_overhead (size_t size, mem_alloc_origin origin, const char *name,
377 int line, const char *function, const void *ptr);
378
379 /* Allocation location coupled to the description. */
380 mem_location m_location;
381
382 /* Location to usage mapping. */
383 mem_map_t *m_map;
384
385 /* Reverse pointer to usage mapping. */
386 reverse_mem_map_t *m_reverse_map;
387 };
388
389 /* Returns true if instance PTR is registered by the memory description. */
390
391 template <class T>
392 inline bool
393 mem_alloc_description<T>::contains_descriptor_for_instance (const void *ptr)
394 {
395 return m_reverse_map->get (ptr);
396 }
397
398 /* Return descriptor for instance PTR. */
399
400 template <class T>
401 inline T*
402 mem_alloc_description<T>::get_descriptor_for_instance (const void *ptr)
403 {
404 return m_reverse_map->get (ptr) ? (*m_reverse_map->get (ptr)).usage : NULL;
405 }
406
407 /* Register memory allocation descriptor for container PTR which is
408 described by a memory LOCATION. */
409
410 template <class T>
411 inline T*
412 mem_alloc_description<T>::register_descriptor (const void *ptr,
413 mem_location *location)
414 {
415 T *usage = NULL;
416
417 T **slot = m_map->get (location);
418 if (slot)
419 {
420 delete location;
421 usage = *slot;
422 usage->m_instances++;
423 }
424 else
425 {
426 usage = new T ();
427 m_map->put (location, usage);
428 }
429
430 if (!m_reverse_map->get (ptr))
431 m_reverse_map->put (ptr, mem_usage_pair<T> (usage, 0));
432
433 return usage;
434 }
435
436 /* Register memory allocation descriptor for container PTR. ORIGIN identifies
437 type of container and GGC identifes if the allocation is handled in GGC
438 memory. Each location is identified by file NAME, LINE in source code and
439 FUNCTION name. */
440
441 template <class T>
442 inline T*
443 mem_alloc_description<T>::register_descriptor (const void *ptr,
444 mem_alloc_origin origin,
445 bool ggc,
446 const char *filename,
447 int line,
448 const char *function)
449 {
450 mem_location *l = new mem_location (origin, ggc, filename, line, function);
451 return register_descriptor (ptr, l);
452 }
453
454 /* Register instance overhead identified by PTR pointer. Allocation takes
455 SIZE bytes. */
456
457 template <class T>
458 inline T*
459 mem_alloc_description<T>::register_instance_overhead (size_t size,
460 const void *ptr)
461 {
462 mem_usage_pair <T> *slot = m_reverse_map->get (ptr);
463 if (!slot)
464 {
465 /* Due to PCH, it can really happen. */
466 return NULL;
467 }
468
469 T *usage = (*slot).usage;
470 usage->register_overhead (size);
471
472 return usage;
473 }
474
475 /* For containers (and GGC) where we want to track every instance object,
476 we register allocation of SIZE bytes, identified by PTR pointer, belonging
477 to USAGE descriptor. */
478
479 template <class T>
480 void
481 mem_alloc_description<T>::register_object_overhead (T *usage, size_t size,
482 const void *ptr)
483 {
484 /* In case of GGC, it is possible to have already occupied the memory
485 location. */
486 m_reverse_object_map->put (ptr, std::pair<T *, size_t> (usage, size));
487 }
488
489 /* Register overhead of SIZE bytes of ORIGIN type. PTR pointer is allocated
490 in NAME source file, at LINE in source code, in FUNCTION. */
491
492 template <class T>
493 inline T*
494 mem_alloc_description<T>::register_overhead (size_t size,
495 mem_alloc_origin origin,
496 const char *filename,
497 int line,
498 const char *function,
499 const void *ptr)
500 {
501 T *usage = register_descriptor (ptr, origin, filename, line, function);
502 usage->register_overhead (size);
503
504 return usage;
505 }
506
507 /* Release PTR pointer of SIZE bytes. */
508
509 template <class T>
510 inline T *
511 mem_alloc_description<T>::release_instance_overhead (void *ptr, size_t size,
512 bool remove_from_map)
513 {
514 mem_usage_pair<T> *slot = m_reverse_map->get (ptr);
515
516 if (!slot)
517 {
518 /* Due to PCH, it can really happen. */
519 return NULL;
520 }
521
522 T *usage = (*slot).usage;
523 usage->release_overhead (size);
524
525 if (remove_from_map)
526 m_reverse_map->remove (ptr);
527
528 return usage;
529 }
530
531 /* Release instance object identified by PTR pointer. */
532
533 template <class T>
534 inline void
535 mem_alloc_description<T>::release_object_overhead (void *ptr)
536 {
537 std::pair <T *, size_t> *entry = m_reverse_object_map->get (ptr);
538 entry->first->release_overhead (entry->second);
539 m_reverse_object_map->remove (ptr);
540 }
541
542 /* Unregister a memory allocation descriptor registered with
543 register_descriptor (remove from reverse map), unless it is
544 unregistered through release_instance_overhead with
545 REMOVE_FROM_MAP = true. */
546 template <class T>
547 inline void
548 mem_alloc_description<T>::unregister_descriptor (void *ptr)
549 {
550 m_reverse_map->remove (ptr);
551 }
552
553 /* Default contructor. */
554
555 template <class T>
556 inline
557 mem_alloc_description<T>::mem_alloc_description ()
558 {
559 m_map = new mem_map_t (13, false, false, false);
560 m_reverse_map = new reverse_mem_map_t (13, false, false, false);
561 m_reverse_object_map = new reverse_object_map_t (13, false, false, false);
562 }
563
564 /* Default destructor. */
565
566 template <class T>
567 inline
568 mem_alloc_description<T>::~mem_alloc_description ()
569 {
570 for (typename mem_map_t::iterator it = m_map->begin (); it != m_map->end ();
571 ++it)
572 {
573 delete (*it).first;
574 delete (*it).second;
575 }
576
577 delete m_map;
578 delete m_reverse_map;
579 delete m_reverse_object_map;
580 }
581
582 /* Get all tracked instances registered by the description. Items are filtered
583 by ORIGIN type, LENGTH is return value where we register the number of
584 elements in the list. If we want to process custom order, CMP comparator
585 can be provided. */
586
587 template <class T>
588 inline
589 typename mem_alloc_description<T>::mem_list_t *
590 mem_alloc_description<T>::get_list (mem_alloc_origin origin, unsigned *length)
591 {
592 /* vec data structure is not used because all vectors generate memory
593 allocation info a it would create a cycle. */
594 size_t element_size = sizeof (mem_list_t);
595 mem_list_t *list = XCNEWVEC (mem_list_t, m_map->elements ());
596 unsigned i = 0;
597
598 for (typename mem_map_t::iterator it = m_map->begin (); it != m_map->end ();
599 ++it)
600 if ((*it).first->m_origin == origin)
601 list[i++] = std::pair<mem_location*, T*> (*it);
602
603 qsort (list, i, element_size, T::compare);
604 *length = i;
605
606 return list;
607 }
608
609 /* Get sum value for ORIGIN type of allocation for the descriptor. */
610
611 template <class T>
612 inline T
613 mem_alloc_description<T>::get_sum (mem_alloc_origin origin)
614 {
615 unsigned length;
616 mem_list_t *list = get_list (origin, &length);
617 T sum;
618
619 for (unsigned i = 0; i < length; i++)
620 sum = sum + *list[i].second;
621
622 XDELETEVEC (list);
623
624 return sum;
625 }
626
627 /* Dump all tracked instances of type ORIGIN. If we want to process custom
628 order, CMP comparator can be provided. */
629
630 template <class T>
631 inline void
632 mem_alloc_description<T>::dump (mem_alloc_origin origin)
633 {
634 unsigned length;
635
636 fprintf (stderr, "\n");
637
638 mem_list_t *list = get_list (origin, &length);
639 T total = get_sum (origin);
640
641 T::print_dash_line ();
642 T::dump_header (mem_location::get_origin_name (origin));
643 T::print_dash_line ();
644 for (int i = length - 1; i >= 0; i--)
645 list[i].second->dump (list[i].first, total);
646 T::print_dash_line ();
647
648 T::dump_header (mem_location::get_origin_name (origin));
649 T::print_dash_line ();
650 total.dump_footer ();
651 T::print_dash_line ();
652
653 XDELETEVEC (list);
654
655 fprintf (stderr, "\n");
656 }
657
658 #endif // GCC_MEM_STATS_H