Skip to content

R
riscv-gcc-1
Commit 40ce7fa6 by Martin Liska Committed by Martin Liska
Options

Come up with SIZE_AMOUNT and use it in memory statistics and sort stats. 

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

	* alloc-pool.h (struct pool_usage): Use SIZE_AMOUNT.
	* bitmap.h (struct bitmap_usage): Likewise.
	* ggc-common.c (SCALE): Remove.
	(LABEL): Likewise.
	(struct ggc_usage): Use SIZE_AMOUNT. And update
	compare method.
	* ggc-page.c (SCALE): Remove.
	(STAT_LABEL): Remove.
	(ggc_print_statistics): Use SIZE_AMOUNT.
	* gimple.h (SCALE): Remove.
	(LABEL): Likewise.
	* input.c (ONE_K): Remove.
	(ONE_M): Likewise.
	(SCALE): Likewise.
	(STAT_LABEL): Likewise.
	(FORMAT_AMOUNT): Likewise.
	(dump_line_table_statistics): Use SIZE_AMOUNT.
	* mem-stats.h (struct mem_usage): Likewise.
	* rtl.c (dump_rtx_statistics): Likewise.
	(rtx_alloc_counts): Change type to size_t.
	(rtx_alloc_sizes): Likewise.
	(rtx_count_cmp): New.
	(dump_rtx_statistics): Sort first based on counts.
	* tree.c (tree_nodes_cmp): New.
	(tree_codes_cmp): New.
	(dump_tree_statistics): Sort first based on counts.
	* system.h (ONE_K): New.
	(ONE_M): Likewise.
	(SIZE_SCALE): Likewise.
	(SIZE_LABEL): Likewise.
	(SIZE_AMOUNT): Likewise.
	* tree-cfg.c (dump_cfg_stats): Use SIZE_AMOUNT.
	* tree-dfa.c (dump_dfa_stats): Likewise.
	* tree-phinodes.c (phinodes_print_statistics): Likewise.
	* tree-ssanames.c (ssanames_print_statistics): Likewise.
	* tree.c (dump_tree_statistics): Likewise.
	* vec.c (struct vec_usage): Likewise.
	* trans-mem.c (tm_mangle): Enlarge buffer in order to not
	trigger a -Werror=format-overflow with
	--enable-gather-detailed-stats.

From-SVN: r265800
parent 00e6775a
Showing with 315 additions and 223 deletions
gcc/ChangeLog
2018-11-05 Martin Liska <mliska@suse.cz>
* alloc-pool.h (struct pool_usage): Use SIZE_AMOUNT.
* bitmap.h (struct bitmap_usage): Likewise.
* ggc-common.c (SCALE): Remove.
(LABEL): Likewise.
(struct ggc_usage): Use SIZE_AMOUNT. And update
compare method.
* ggc-page.c (SCALE): Remove.
(STAT_LABEL): Remove.
(ggc_print_statistics): Use SIZE_AMOUNT.
* gimple.h (SCALE): Remove.
(LABEL): Likewise.
* input.c (ONE_K): Remove.
(ONE_M): Likewise.
(SCALE): Likewise.
(STAT_LABEL): Likewise.
(FORMAT_AMOUNT): Likewise.
(dump_line_table_statistics): Use SIZE_AMOUNT.
* mem-stats.h (struct mem_usage): Likewise.
* rtl.c (dump_rtx_statistics): Likewise.
(rtx_alloc_counts): Change type to size_t.
(rtx_alloc_sizes): Likewise.
(rtx_count_cmp): New.
(dump_rtx_statistics): Sort first based on counts.
* tree.c (tree_nodes_cmp): New.
(tree_codes_cmp): New.
(dump_tree_statistics): Sort first based on counts.
* system.h (ONE_K): New.
(ONE_M): Likewise.
(SIZE_SCALE): Likewise.
(SIZE_LABEL): Likewise.
(SIZE_AMOUNT): Likewise.
* tree-cfg.c (dump_cfg_stats): Use SIZE_AMOUNT.
* tree-dfa.c (dump_dfa_stats): Likewise.
* tree-phinodes.c (phinodes_print_statistics): Likewise.
* tree-ssanames.c (ssanames_print_statistics): Likewise.
* tree.c (dump_tree_statistics): Likewise.
* vec.c (struct vec_usage): Likewise.
* trans-mem.c (tm_mangle): Enlarge buffer in order to not
trigger a -Werror=format-overflow with
--enable-gather-detailed-stats.
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.
gcc/alloc-pool.h
......@@ -63,12 +63,16 @@ struct pool_usage: public mem_usage
{
char *location_string = loc->to_string ();
fprintf (stderr, "%-32s%-48s %6li%10li:%5.1f%%%10li%10li:%5.1f%%%12li\n",
m_pool_name, location_string, (long)m_instances,
(long)m_allocated, get_percent (m_allocated, total.m_allocated),
(long)m_peak, (long)m_times,
fprintf (stderr, "%-32s%-48s %5zu%c%9zu%c:%5.1f%%%9zu"
"%c%9zu%c:%5.1f%%%12zu\n",
m_pool_name, location_string,
SIZE_AMOUNT (m_instances),
SIZE_AMOUNT (m_allocated),
get_percent (m_allocated, total.m_allocated),
SIZE_AMOUNT (m_peak),
SIZE_AMOUNT (m_times),
get_percent (m_times, total.m_times),
(long)m_element_size);
m_element_size);
free (location_string);
}
......@@ -87,8 +91,8 @@ struct pool_usage: public mem_usage
dump_footer ()
{
print_dash_line ();
fprintf (stderr, "%s%82li%10li\n", "Total", (long)m_instances,
(long)m_allocated);
fprintf (stderr, "%s%82zu%c%10zu%c\n", "Total",
SIZE_AMOUNT (m_instances), SIZE_AMOUNT (m_allocated));
print_dash_line ();
}
......
gcc/bitmap.h
......@@ -239,14 +239,14 @@ struct bitmap_usage: public mem_usage
{
char *location_string = loc->to_string ();
fprintf (stderr, "%-48s %10" PRIu64 ":%5.1f%%"
"%10" PRIu64 "%10" PRIu64 ":%5.1f%%"
"%12" PRIu64 "%12" PRIu64 "%10s\n",
location_string, (uint64_t)m_allocated,
fprintf (stderr, "%-48s %9zu%c:%5.1f%%"
"%9zu%c%9zu%c:%5.1f%%"
"%11" PRIu64 "%c%11" PRIu64 "%c%10s\n",
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),
m_nsearches, m_search_iter,
SIZE_AMOUNT (m_nsearches), SIZE_AMOUNT (m_search_iter),
loc->m_ggc ? "ggc" : "heap");
free (location_string);
......
gcc/ggc-common.c
......@@ -195,14 +195,6 @@ ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
gcc_assert (!nl);
}
/* Print statistics that are independent of the collector in use. */
#define SCALE(x) ((unsigned long) ((x) < 1024*10 \
? (x) \
: ((x) < 1024*1024*10 \
? (x) / 1024 \
: (x) / (1024*1024))))
#define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
void
ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED,
ggc_statistics *stats)
......@@ -890,16 +882,17 @@ struct ggc_usage: public mem_usage
inline void
dump (const char *prefix, ggc_usage &total) const
{
long balance = get_balance ();
size_t balance = get_balance ();
fprintf (stderr,
"%-48s %10li:%5.1f%%%10li:%5.1f%%"
"%10li:%5.1f%%%10li:%5.1f%%%10li\n",
prefix, (long)m_collected,
"%-48s %9zu%c:%5.1f%%%9zu%c:%5.1f%%"
"%9zu%c:%5.1f%%%9zu%c:%5.1f%%%9zu%c\n",
prefix, SIZE_AMOUNT (m_collected),
get_percent (m_collected, total.m_collected),
(long)m_freed, get_percent (m_freed, total.m_freed),
(long)balance, get_percent (balance, total.get_balance ()),
(long)m_overhead, get_percent (m_overhead, total.m_overhead),
(long)m_times);
SIZE_AMOUNT (m_freed), get_percent (m_freed, total.m_freed),
SIZE_AMOUNT (balance), get_percent (balance, total.get_balance ()),
SIZE_AMOUNT (m_overhead),
get_percent (m_overhead, total.m_overhead),
SIZE_AMOUNT (m_times));
}
/* Dump usage coupled to LOC location, where TOTAL is sum of all rows. */
......@@ -923,7 +916,7 @@ struct ggc_usage: public mem_usage
}
/* Get balance which is GGC allocation leak. */
inline long
inline size_t
get_balance () const
{
return m_allocated + m_overhead - m_collected - m_freed;
......@@ -938,10 +931,7 @@ struct ggc_usage: public mem_usage
const mem_pair_t f = *(const mem_pair_t *)first;
const mem_pair_t s = *(const mem_pair_t *)second;
if (*f.second == *s.second)
return 0;
return *f.second < *s.second ? 1 : -1;
return s.second->get_balance () - f.second->get_balance ();
}
/* Compare rows in final GGC summary dump. */
......
gcc/ggc-page.c
......@@ -2237,14 +2237,6 @@ ggc_grow (void)
fprintf (stderr, " {GC start %luk} ", (unsigned long) G.allocated / 1024);
}
/* Print allocation statistics. */
#define SCALE(x) ((unsigned long) ((x) < 1024*10 \
? (x) \
: ((x) < 1024*1024*10 \
? (x) / 1024 \
: (x) / (1024*1024))))
#define STAT_LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
void
ggc_print_statistics (void)
{
......@@ -2296,53 +2288,61 @@ ggc_print_statistics (void)
overhead += (sizeof (page_entry) - sizeof (long)
+ BITMAP_SIZE (OBJECTS_IN_PAGE (p) + 1));
}
fprintf (stderr, "%-8lu %10lu%c %10lu%c %10lu%c\n",
(unsigned long) OBJECT_SIZE (i),
SCALE (allocated), STAT_LABEL (allocated),
SCALE (in_use), STAT_LABEL (in_use),
SCALE (overhead), STAT_LABEL (overhead));
fprintf (stderr, "%-8zu %10zu%c %10zu%c %10zu%c\n",
OBJECT_SIZE (i),
SIZE_AMOUNT (allocated),
SIZE_AMOUNT (in_use),
SIZE_AMOUNT (overhead));
total_overhead += overhead;
}
fprintf (stderr, "%-8s %10lu%c %10lu%c %10lu%c\n", "Total",
SCALE (G.bytes_mapped), STAT_LABEL (G.bytes_mapped),
SCALE (G.allocated), STAT_LABEL (G.allocated),
SCALE (total_overhead), STAT_LABEL (total_overhead));
fprintf (stderr, "%-8s %10zu%c %10zu%c %10zu%c\n",
"Total",
SIZE_AMOUNT (G.bytes_mapped),
SIZE_AMOUNT (G.allocated),
SIZE_AMOUNT (total_overhead));
if (GATHER_STATISTICS)
{
fprintf (stderr, "\nTotal allocations and overheads during "
"the compilation process\n");
fprintf (stderr, "Total Overhead: %10"
HOST_LONG_LONG_FORMAT "d\n", G.stats.total_overhead);
fprintf (stderr, "Total Allocated: %10"
HOST_LONG_LONG_FORMAT "d\n",
G.stats.total_allocated);
fprintf (stderr, "Total Overhead under 32B: %10"
HOST_LONG_LONG_FORMAT "d\n", G.stats.total_overhead_under32);
fprintf (stderr, "Total Allocated under 32B: %10"
HOST_LONG_LONG_FORMAT "d\n", G.stats.total_allocated_under32);
fprintf (stderr, "Total Overhead under 64B: %10"
HOST_LONG_LONG_FORMAT "d\n", G.stats.total_overhead_under64);
fprintf (stderr, "Total Allocated under 64B: %10"
HOST_LONG_LONG_FORMAT "d\n", G.stats.total_allocated_under64);
fprintf (stderr, "Total Overhead under 128B: %10"
HOST_LONG_LONG_FORMAT "d\n", G.stats.total_overhead_under128);
fprintf (stderr, "Total Allocated under 128B: %10"
HOST_LONG_LONG_FORMAT "d\n", G.stats.total_allocated_under128);
fprintf (stderr, "Total Overhead: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
SIZE_AMOUNT (G.stats.total_overhead));
fprintf (stderr, "Total Allocated: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
SIZE_AMOUNT (G.stats.total_allocated));
fprintf (stderr, "Total Overhead under 32B: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
SIZE_AMOUNT (G.stats.total_overhead_under32));
fprintf (stderr, "Total Allocated under 32B: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
SIZE_AMOUNT (G.stats.total_allocated_under32));
fprintf (stderr, "Total Overhead under 64B: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
SIZE_AMOUNT (G.stats.total_overhead_under64));
fprintf (stderr, "Total Allocated under 64B: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
SIZE_AMOUNT (G.stats.total_allocated_under64));
fprintf (stderr, "Total Overhead under 128B: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
SIZE_AMOUNT (G.stats.total_overhead_under128));
fprintf (stderr, "Total Allocated under 128B: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
SIZE_AMOUNT (G.stats.total_allocated_under128));
for (i = 0; i < NUM_ORDERS; i++)
if (G.stats.total_allocated_per_order[i])
{
fprintf (stderr, "Total Overhead page size %9lu: %10"
HOST_LONG_LONG_FORMAT "d\n",
(unsigned long) OBJECT_SIZE (i),
G.stats.total_overhead_per_order[i]);
fprintf (stderr, "Total Allocated page size %9lu: %10"
HOST_LONG_LONG_FORMAT "d\n",
(unsigned long) OBJECT_SIZE (i),
G.stats.total_allocated_per_order[i]);
fprintf (stderr, "Total Overhead page size %9zu: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
OBJECT_SIZE (i),
SIZE_AMOUNT (G.stats.total_overhead_per_order[i]));
fprintf (stderr, "Total Allocated page size %9zu: %9"
HOST_LONG_LONG_FORMAT "d%c\n",
OBJECT_SIZE (i),
SIZE_AMOUNT (G.stats.total_allocated_per_order[i]));
}
}
}
......
gcc/gimple.c
......@@ -2149,15 +2149,16 @@ dump_gimple_statistics (void)
fprintf (stderr, "---------------------------------------\n");
for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
{
fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n",
gimple_alloc_kind_names[i], gimple_alloc_counts[i],
gimple_alloc_sizes[i]);
fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n",
gimple_alloc_kind_names[i],
SIZE_AMOUNT (gimple_alloc_counts[i]),
SIZE_AMOUNT (gimple_alloc_sizes[i]));
total_tuples += gimple_alloc_counts[i];
total_bytes += gimple_alloc_sizes[i];
}
fprintf (stderr, "---------------------------------------\n");
fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n", "Total",
total_tuples, total_bytes);
fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n", "Total",
SIZE_AMOUNT (total_tuples), SIZE_AMOUNT (total_bytes));
fprintf (stderr, "---------------------------------------\n");
}
......
gcc/gimple.h
......@@ -6404,14 +6404,4 @@ gimple_set_do_not_emit_location (gimple *g)
gimple_set_plf (g, GF_PLF_1, true);
}
/* Macros for showing usage statistics. */
#define SCALE(x) ((unsigned long) ((x) < 1024*10 \
? (x) \
: ((x) < 1024*1024*10 \
? (x) / 1024 \
: (x) / (1024*1024))))
#define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M'))
#endif /* GCC_GIMPLE_H */
gcc/input.c
......@@ -905,31 +905,6 @@ make_location (location_t caret, source_range src_range)
return COMBINE_LOCATION_DATA (line_table, pure_loc, src_range, NULL);
}
#define ONE_K 1024
#define ONE_M (ONE_K * ONE_K)
/* Display a number as an integer multiple of either:
- 1024, if said integer is >= to 10 K (in base 2)
- 1024 * 1024, if said integer is >= 10 M in (base 2)
*/
#define SCALE(x) ((unsigned long) ((x) < 10 * ONE_K \
? (x) \
: ((x) < 10 * ONE_M \
? (x) / ONE_K \
: (x) / ONE_M)))
/* For a given integer, display either:
- the character 'k', if the number is higher than 10 K (in base 2)
but strictly lower than 10 M (in base 2)
- the character 'M' if the number is higher than 10 M (in base2)
- the charcter ' ' if the number is strictly lower than 10 K */
#define STAT_LABEL(x) ((x) < 10 * ONE_K ? ' ' : ((x) < 10 * ONE_M ? 'k' : 'M'))
/* Display an integer amount as multiple of 1K or 1M (in base 2).
Display the correct unit (either k, M, or ' ') after the amount, as
well. */
#define FORMAT_AMOUNT(size) SCALE (size), STAT_LABEL (size)
/* Dump statistics to stderr about the memory usage of the line_table
set of line maps. This also displays some statistics about macro
expansion. */
......@@ -964,49 +939,37 @@ dump_line_table_statistics (void)
s.num_macro_tokens / s.num_expanded_macros);
fprintf (stderr,
"\nLine Table allocations during the "
"compilation process\n");
"compilation process\n");
fprintf (stderr, "Number of ordinary maps used: %5ld%c\n",
SCALE (s.num_ordinary_maps_used),
STAT_LABEL (s.num_ordinary_maps_used));
SIZE_AMOUNT (s.num_ordinary_maps_used));
fprintf (stderr, "Ordinary map used size: %5ld%c\n",
SCALE (s.ordinary_maps_used_size),
STAT_LABEL (s.ordinary_maps_used_size));
SIZE_AMOUNT (s.ordinary_maps_used_size));
fprintf (stderr, "Number of ordinary maps allocated: %5ld%c\n",
SCALE (s.num_ordinary_maps_allocated),
STAT_LABEL (s.num_ordinary_maps_allocated));
SIZE_AMOUNT (s.num_ordinary_maps_allocated));
fprintf (stderr, "Ordinary maps allocated size: %5ld%c\n",
SCALE (s.ordinary_maps_allocated_size),
STAT_LABEL (s.ordinary_maps_allocated_size));
SIZE_AMOUNT (s.ordinary_maps_allocated_size));
fprintf (stderr, "Number of macro maps used: %5ld%c\n",
SCALE (s.num_macro_maps_used),
STAT_LABEL (s.num_macro_maps_used));
SIZE_AMOUNT (s.num_macro_maps_used));
fprintf (stderr, "Macro maps used size: %5ld%c\n",
SCALE (s.macro_maps_used_size),
STAT_LABEL (s.macro_maps_used_size));
SIZE_AMOUNT (s.macro_maps_used_size));
fprintf (stderr, "Macro maps locations size: %5ld%c\n",
SCALE (s.macro_maps_locations_size),
STAT_LABEL (s.macro_maps_locations_size));
SIZE_AMOUNT (s.macro_maps_locations_size));
fprintf (stderr, "Macro maps size: %5ld%c\n",
SCALE (macro_maps_size),
STAT_LABEL (macro_maps_size));
SIZE_AMOUNT (macro_maps_size));
fprintf (stderr, "Duplicated maps locations size: %5ld%c\n",
SCALE (s.duplicated_macro_maps_locations_size),
STAT_LABEL (s.duplicated_macro_maps_locations_size));
SIZE_AMOUNT (s.duplicated_macro_maps_locations_size));
fprintf (stderr, "Total allocated maps size: %5ld%c\n",
SCALE (total_allocated_map_size),
STAT_LABEL (total_allocated_map_size));
SIZE_AMOUNT (total_allocated_map_size));
fprintf (stderr, "Total used maps size: %5ld%c\n",
SCALE (total_used_map_size),
STAT_LABEL (total_used_map_size));
SIZE_AMOUNT (total_used_map_size));
fprintf (stderr, "Ad-hoc table size: %5ld%c\n",
SCALE (s.adhoc_table_size),
STAT_LABEL (s.adhoc_table_size));
fprintf (stderr, "Ad-hoc table entries used: %5ld\n",
s.adhoc_table_entries_used);
fprintf (stderr, "optimized_ranges: %i\n",
line_table->num_optimized_ranges);
fprintf (stderr, "unoptimized_ranges: %i\n",
line_table->num_unoptimized_ranges);
SIZE_AMOUNT (s.adhoc_table_size));
fprintf (stderr, "Ad-hoc table entries used: %5ld%c\n",
SIZE_AMOUNT (s.adhoc_table_entries_used));
fprintf (stderr, "optimized_ranges: %5xu%c\n",
SIZE_AMOUNT (line_table->num_optimized_ranges));
fprintf (stderr, "unoptimized_ranges: %5xu%c\n",
SIZE_AMOUNT (line_table->num_unoptimized_ranges));
fprintf (stderr, "\n");
}
......
gcc/mem-stats.h
......@@ -205,11 +205,11 @@ struct mem_usage
{
char *location_string = loc->to_string ();
fprintf (stderr, "%-48s %10" PRIu64 ":%5.1f%%"
"%10" PRIu64 "%10" PRIu64 ":%5.1f%%%10s\n",
location_string, (uint64_t)m_allocated,
fprintf (stderr, "%-48s %9zu%c:%5.1f%%"
"%9zu%c%9zu%c:%5.1f%%%10s\n",
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);
......@@ -220,8 +220,8 @@ struct mem_usage
dump_footer () const
{
print_dash_line ();
fprintf (stderr, "%s%54" PRIu64 "%27" PRIu64 "\n", "Total",
(uint64_t)m_allocated, (uint64_t)m_times);
fprintf (stderr, "%s%53zu%c%26zu%c\n", "Total",
SIZE_AMOUNT (m_allocated), SIZE_AMOUNT (m_times));
print_dash_line ();
}
......
gcc/rtl.c
......@@ -148,10 +148,10 @@ const char * const reg_note_name[REG_NOTE_MAX] =
#undef DEF_REG_NOTE
};
static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
static int rtvec_alloc_counts;
static int rtvec_alloc_sizes;
static size_t rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
static size_t rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
static size_t rtvec_alloc_counts;
static size_t rtvec_alloc_sizes;
/* Allocate an rtx vector of N elements.
......@@ -785,10 +785,20 @@ classify_insn (rtx x)
return INSN;
}
/* Comparator of indices based on rtx_alloc_counts. */
static int
rtx_count_cmp (const void *p1, const void *p2)
{
const unsigned *n1 = (const unsigned *)p1;
const unsigned *n2 = (const unsigned *)p2;
return rtx_alloc_counts[*n1] - rtx_alloc_counts[*n2];
}
void
dump_rtx_statistics (void)
{
int i;
int total_counts = 0;
int total_sizes = 0;
......@@ -798,27 +808,41 @@ dump_rtx_statistics (void)
return;
}
fprintf (stderr, "\nRTX Kind Count Bytes\n");
fprintf (stderr, "---------------------------------------\n");
for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
if (rtx_alloc_counts[i])
{
fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
rtx_alloc_counts[i], rtx_alloc_sizes[i]);
total_counts += rtx_alloc_counts[i];
total_sizes += rtx_alloc_sizes[i];
}
fprintf (stderr, "\nRTX Kind Count Bytes\n");
fprintf (stderr, "-------------------------------------------\n");
auto_vec<unsigned> indices (LAST_AND_UNUSED_RTX_CODE);
for (unsigned i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
indices.quick_push (i);
indices.qsort (rtx_count_cmp);
for (unsigned i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
{
unsigned j = indices[i];
if (rtx_alloc_counts[j])
{
fprintf (stderr, "%-24s %6zu%c %9zu%c\n",
GET_RTX_NAME (j),
SIZE_AMOUNT (rtx_alloc_counts[j]),
SIZE_AMOUNT (rtx_alloc_sizes[j]));
total_counts += rtx_alloc_counts[j];
total_sizes += rtx_alloc_sizes[j];
}
}
if (rtvec_alloc_counts)
{
fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
rtvec_alloc_counts, rtvec_alloc_sizes);
fprintf (stderr, "%-24s %6zu%c %9zu%c\n", "rtvec",
SIZE_AMOUNT (rtvec_alloc_counts),
SIZE_AMOUNT (rtvec_alloc_sizes));
total_counts += rtvec_alloc_counts;
total_sizes += rtvec_alloc_sizes;
}
fprintf (stderr, "---------------------------------------\n");
fprintf (stderr, "%-20s %7d %10d\n",
"Total", total_counts, total_sizes);
fprintf (stderr, "---------------------------------------\n");
fprintf (stderr, "-----------------------------------------------\n");
fprintf (stderr, "%-24s %6d%c %9d%c\n",
"Total", SIZE_AMOUNT (total_counts),
SIZE_AMOUNT (total_sizes));
fprintf (stderr, "-----------------------------------------------\n");
}
#if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
......
gcc/system.h
......@@ -1208,4 +1208,29 @@ void gcc_stablesort (void *, size_t, size_t,
#undef qsort
#define qsort(...) PP_5th (__VA_ARGS__, gcc_qsort, 3, 2, qsort, 0) (__VA_ARGS__)
#define ONE_K 1024
#define ONE_M (ONE_K * ONE_K)
/* Display a number as an integer multiple of either:
- 1024, if said integer is >= to 10 K (in base 2)
- 1024 * 1024, if said integer is >= 10 M in (base 2)
*/
#define SIZE_SCALE(x) (((x) < 10 * ONE_K \
? (x) \
: ((x) < 10 * ONE_M \
? (x) / ONE_K \
: (x) / ONE_M)))
/* For a given integer, display either:
- the character 'k', if the number is higher than 10 K (in base 2)
but strictly lower than 10 M (in base 2)
- the character 'M' if the number is higher than 10 M (in base2)
- the charcter ' ' if the number is strictly lower than 10 K */
#define SIZE_LABEL(x) ((x) < 10 * ONE_K ? ' ' : ((x) < 10 * ONE_M ? 'k' : 'M'))
/* Display an integer amount as multiple of 1K or 1M (in base 2).
Display the correct unit (either k, M, or ' ') after the amount, as
well. */
#define SIZE_AMOUNT(size) SIZE_SCALE (size), SIZE_LABEL (size)
#endif /* ! GCC_SYSTEM_H */
gcc/trans-mem.c
......@@ -4859,7 +4859,7 @@ tm_mangle (tree old_asm_id)
if (dc == NULL)
{
char length[8];
char length[12];
do_unencoded:
sprintf (length, "%u", IDENTIFIER_LENGTH (old_asm_id));
......
gcc/tree-cfg.c
......@@ -2584,18 +2584,18 @@ dump_cfg_stats (FILE *file)
size = n_basic_blocks_for_fn (cfun) * sizeof (struct basic_block_def);
total += size;
fprintf (file, fmt_str_1, "Basic blocks", n_basic_blocks_for_fn (cfun),
SCALE (size), LABEL (size));
SIZE_AMOUNT (size));
num_edges = 0;
FOR_EACH_BB_FN (bb, cfun)
num_edges += EDGE_COUNT (bb->succs);
size = num_edges * sizeof (struct edge_def);
total += size;
fprintf (file, fmt_str_2, "Edges", num_edges, SCALE (size), LABEL (size));
fprintf (file, fmt_str_2, "Edges", num_edges, SIZE_AMOUNT (size));
fprintf (file, "---------------------------------------------------------\n");
fprintf (file, fmt_str_3, "Total memory used by CFG data", SCALE (total),
LABEL (total));
fprintf (file, fmt_str_3, "Total memory used by CFG data",
SIZE_AMOUNT (total));
fprintf (file, "---------------------------------------------------------\n");
fprintf (file, "\n");
......
gcc/tree-dfa.c
......@@ -201,36 +201,36 @@ dump_dfa_stats (FILE *file)
size = dfa_stats.num_uses * sizeof (tree *);
total += size;
fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
SCALE (size), LABEL (size));
SIZE_AMOUNT (size));
size = dfa_stats.num_defs * sizeof (tree *);
total += size;
fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
SCALE (size), LABEL (size));
SIZE_AMOUNT (size));
size = dfa_stats.num_vuses * sizeof (tree *);
total += size;
fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
SCALE (size), LABEL (size));
SIZE_AMOUNT (size));
size = dfa_stats.num_vdefs * sizeof (tree *);
total += size;
fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
SCALE (size), LABEL (size));
SIZE_AMOUNT (size));
size = dfa_stats.num_phis * sizeof (struct gphi);
total += size;
fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
SCALE (size), LABEL (size));
SIZE_AMOUNT (size));
size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
total += size;
fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
SCALE (size), LABEL (size));
SIZE_AMOUNT (size));
fprintf (file, "---------------------------------------------------------\n");
fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
LABEL (total));
fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data",
SIZE_AMOUNT (total));
fprintf (file, "---------------------------------------------------------\n");
fprintf (file, "\n");
......
gcc/tree-phinodes.c
......@@ -80,8 +80,9 @@ unsigned int phi_nodes_created;
void
phinodes_print_statistics (void)
{
fprintf (stderr, "PHI nodes allocated: %u\n", phi_nodes_created);
fprintf (stderr, "PHI nodes reused: %u\n", phi_nodes_reused);
fprintf (stderr, "PHI nodes allocated: %u%c\n",
SIZE_AMOUNT (phi_nodes_created));
fprintf (stderr, "PHI nodes reused: %u%c\n", SIZE_AMOUNT (phi_nodes_reused));
}
/* Allocate a PHI node with at least LEN arguments. If the free list
......
gcc/tree-ssanames.c
......@@ -112,8 +112,10 @@ fini_ssanames (struct function *fn)
void
ssanames_print_statistics (void)
{
fprintf (stderr, "SSA_NAME nodes allocated: %u\n", ssa_name_nodes_created);
fprintf (stderr, "SSA_NAME nodes reused: %u\n", ssa_name_nodes_reused);
fprintf (stderr, "SSA_NAME nodes allocated: %u%c\n",
SIZE_AMOUNT (ssa_name_nodes_created));
fprintf (stderr, "SSA_NAME nodes reused: %u%c\n",
SIZE_AMOUNT (ssa_name_nodes_reused));
}
/* Verify the state of the SSA_NAME lists.
......
gcc/tree.c
......@@ -9226,6 +9226,28 @@ get_call_combined_fn (const_tree call)
return CFN_LAST;
}
/* Comparator of indices based on tree_node_counts. */
static int
tree_nodes_cmp (const void *p1, const void *p2)
{
const unsigned *n1 = (const unsigned *)p1;
const unsigned *n2 = (const unsigned *)p2;
return tree_node_counts[*n1] - tree_node_counts[*n2];
}
/* Comparator of indices based on tree_code_counts. */
static int
tree_codes_cmp (const void *p1, const void *p2)
{
const unsigned *n1 = (const unsigned *)p1;
const unsigned *n2 = (const unsigned *)p2;
return tree_code_counts[*n1] - tree_code_counts[*n2];
}
#define TREE_MEM_USAGE_SPACES 40
/* Print debugging information about tree nodes generated during the compile,
......@@ -9236,34 +9258,55 @@ dump_tree_statistics (void)
{
if (GATHER_STATISTICS)
{
int i;
uint64_t total_nodes, total_bytes;
fprintf (stderr, "\nKind Nodes Bytes\n");
mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
total_nodes = total_bytes = 0;
for (i = 0; i < (int) all_kinds; i++)
{
fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n",
tree_node_kind_names[i], tree_node_counts[i],
tree_node_sizes[i]);
total_nodes += tree_node_counts[i];
total_bytes += tree_node_sizes[i];
}
mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n", "Total",
total_nodes, total_bytes);
mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
fprintf (stderr, "Code Nodes\n");
mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
for (i = 0; i < (int) MAX_TREE_CODES; i++)
fprintf (stderr, "%-32s %7" PRIu64 "\n",
get_tree_code_name ((enum tree_code) i), tree_code_counts[i]);
mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
fprintf (stderr, "\n");
ssanames_print_statistics ();
fprintf (stderr, "\n");
phinodes_print_statistics ();
fprintf (stderr, "\n");
{
auto_vec<unsigned> indices (all_kinds);
for (unsigned i = 0; i < all_kinds; i++)
indices.quick_push (i);
indices.qsort (tree_nodes_cmp);
for (unsigned i = 0; i < (int) all_kinds; i++)
{
unsigned j = indices[i];
fprintf (stderr, "%-20s %6" PRIu64 "%c %9" PRIu64 "%c\n",
tree_node_kind_names[i], SIZE_AMOUNT (tree_node_counts[j]),
SIZE_AMOUNT (tree_node_sizes[j]));
total_nodes += tree_node_counts[j];
total_bytes += tree_node_sizes[j];
}
mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
fprintf (stderr, "%-20s %6" PRIu64 "%c %9" PRIu64 "%c\n", "Total",
SIZE_AMOUNT (total_nodes), SIZE_AMOUNT (total_bytes));
mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
}
{
fprintf (stderr, "Code Nodes\n");
mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
auto_vec<unsigned> indices (MAX_TREE_CODES);
for (unsigned i = 0; i < MAX_TREE_CODES; i++)
indices.quick_push (i);
indices.qsort (tree_codes_cmp);
for (unsigned i = 0; i < MAX_TREE_CODES; i++)
{
unsigned j = indices[i];
fprintf (stderr, "%-32s %6" PRIu64 "%c\n",
get_tree_code_name ((enum tree_code) j),
SIZE_AMOUNT (tree_code_counts[j]));
}
mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
fprintf (stderr, "\n");
ssanames_print_statistics ();
fprintf (stderr, "\n");
phinodes_print_statistics ();
fprintf (stderr, "\n");
}
}
else
fprintf (stderr, "(No per-node statistics)\n");
......
gcc/vec.c
......@@ -82,11 +82,16 @@ struct vec_usage: public mem_usage
s[48] = '\0';
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);
fprintf (stderr,
"%-48s %10zu%10zu%c:%4.1f%%%9zu%c%10zu"
":%4.1f%%%10zu%c%10zu%c\n",
s,
m_element_size,
SIZE_AMOUNT (m_allocated),
m_allocated * 100.0 / total.m_allocated,
SIZE_AMOUNT (m_peak), m_times,
m_times * 100.0 / total.m_times,
SIZE_AMOUNT (m_items), SIZE_AMOUNT (m_items_peak));
}
/* Dump footer. */
......@@ -94,8 +99,9 @@ struct vec_usage: public mem_usage
dump_footer ()
{
print_dash_line ();
fprintf (stderr, "%s%55li%25li%17li\n", "Total", (long)m_allocated,
(long)m_times, (long)m_items);
fprintf (stderr, "%s%64zu%c%25zu%c%16zu%c\n",
"Total", SIZE_AMOUNT (m_allocated),
SIZE_AMOUNT (m_times), SIZE_AMOUNT (m_items));
print_dash_line ();
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment