From 746447567a82ce2987f579770fd296ace60f87b1 Mon Sep 17 00:00:00 2001 From: Martin Liska Date: Fri, 8 Jun 2018 14:26:57 +0200 Subject: [PATCH] Remove cgraph_node::summary_uid and make cgraph_node::uid really unique. 2018-06-08 Martin Liska * cgraph.c (cgraph_node::remove): Do not recycle uid. * cgraph.h (symbol_table::release_symbol): Do not pass uid. (symbol_table::allocate_cgraph_symbol): Do not set uid. * passes.c (uid_hash_t): Record removed_nodes by their uids. (remove_cgraph_node_from_order): Use the removed_nodes set. (do_per_function_toporder): Likwise. * symbol-summary.h (symtab_insertion): Use cgraph_node::uid instead of summary_uid. (symtab_removal): Likewise. (symtab_duplication): Likewise. 2018-06-08 Martin Liska * lto-partition.c (lto_balanced_map): Use cgraph_node::uid instead of summary_uid. From-SVN: r261315 --- gcc/ChangeLog | 13 +++++++++++++ gcc/cgraph.c | 3 +-- gcc/cgraph.h | 20 ++++++-------------- gcc/lto/ChangeLog | 5 +++++ gcc/lto/lto-partition.c | 26 +++++++++++--------------- gcc/passes.c | 37 ++++++++++++------------------------- gcc/symbol-summary.h | 18 +++++++++--------- 7 files changed, 57 insertions(+), 65 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index c13f246..b6c6a6a 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,18 @@ 2018-06-08 Martin Liska + * cgraph.c (cgraph_node::remove): Do not recycle uid. + * cgraph.h (symbol_table::release_symbol): Do not pass uid. + (symbol_table::allocate_cgraph_symbol): Do not set uid. + * passes.c (uid_hash_t): Record removed_nodes by their uids. + (remove_cgraph_node_from_order): Use the removed_nodes set. + (do_per_function_toporder): Likwise. + * symbol-summary.h (symtab_insertion): Use cgraph_node::uid + instead of summary_uid. + (symtab_removal): Likewise. + (symtab_duplication): Likewise. + +2018-06-08 Martin Liska + * ipa-cp.c (ipcp_store_bits_results): Use ipcp_transformation_sum. (ipcp_store_vr_results): Likewise. diff --git a/gcc/cgraph.c b/gcc/cgraph.c index f922b70..6c6ecd8 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -1779,7 +1779,6 @@ void cgraph_node::remove (void) { cgraph_node *n; - int uid = this->uid; if (symtab->ipa_clones_dump_file && symtab->cloned_nodes.contains (this)) fprintf (symtab->ipa_clones_dump_file, @@ -1875,7 +1874,7 @@ cgraph_node::remove (void) call_site_hash = NULL; } - symtab->release_symbol (this, uid); + symtab->release_symbol (this); } /* Likewise indicate that a node is having address taken. */ diff --git a/gcc/cgraph.h b/gcc/cgraph.h index f0f9961..9a05867 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -1392,8 +1392,6 @@ public: int count_materialization_scale; /* Unique id of the node. */ int uid; - /* Summary unique id of the node. */ - int summary_uid; /* ID assigned by the profiling. */ unsigned int profile_id; /* Time profiler: first run of function. */ @@ -2013,7 +2011,7 @@ public: friend class cgraph_node; friend class cgraph_edge; - symbol_table (): cgraph_max_summary_uid (1) + symbol_table (): cgraph_max_uid (1) { } @@ -2073,9 +2071,8 @@ public: /* Allocate new callgraph node and insert it into basic data structures. */ cgraph_node *create_empty (void); - /* Release a callgraph NODE with UID and put in to the list - of free nodes. */ - void release_symbol (cgraph_node *node, int uid); + /* Release a callgraph NODE. */ + void release_symbol (cgraph_node *node); /* Output all variables enqueued to be assembled. */ bool output_variables (void); @@ -2223,7 +2220,6 @@ public: int cgraph_count; int cgraph_max_uid; - int cgraph_max_summary_uid; int edges_count; int edges_max_uid; @@ -2586,7 +2582,7 @@ symbol_table::unregister (symtab_node *node) /* Release a callgraph NODE with UID and put in to the list of free nodes. */ inline void -symbol_table::release_symbol (cgraph_node *node, int uid) +symbol_table::release_symbol (cgraph_node *node) { cgraph_count--; @@ -2594,7 +2590,6 @@ symbol_table::release_symbol (cgraph_node *node, int uid) list. */ memset (node, 0, sizeof (*node)); node->type = SYMTAB_FUNCTION; - node->uid = uid; SET_NEXT_FREE_NODE (node, free_nodes); free_nodes = node; } @@ -2612,12 +2607,9 @@ symbol_table::allocate_cgraph_symbol (void) free_nodes = NEXT_FREE_NODE (node); } else - { - node = ggc_cleared_alloc (); - node->uid = cgraph_max_uid++; - } + node = ggc_cleared_alloc (); - node->summary_uid = cgraph_max_summary_uid++; + node->uid = cgraph_max_uid++; return node; } diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index 5004a30..aaf375b 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,5 +1,10 @@ 2018-06-08 Martin Liska + * lto-partition.c (lto_balanced_map): Use cgraph_node::uid + instead of summary_uid. + +2018-06-08 Martin Liska + * lto-partition.c (add_symbol_to_partition_1): Use get_create instead of get. (undo_partition): Likewise. diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c index 1cca082..006eec7 100644 --- a/gcc/lto/lto-partition.c +++ b/gcc/lto/lto-partition.c @@ -500,12 +500,10 @@ account_reference_p (symtab_node *n1, symtab_node *n2) void lto_balanced_map (int n_lto_partitions, int max_partition_size) { - int n_nodes = 0; int n_varpool_nodes = 0, varpool_pos = 0, best_varpool_pos = 0; - struct cgraph_node **order = XNEWVEC (cgraph_node *, symtab->cgraph_max_uid); + auto_vec order (symtab->cgraph_count); auto_vec noreorder; auto_vec varpool_order; - int i; struct cgraph_node *node; int64_t original_total_size, total_size = 0; int64_t partition_size; @@ -513,7 +511,7 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size) int last_visited_node = 0; varpool_node *vnode; int64_t cost = 0, internal = 0; - int best_n_nodes = 0, best_i = 0; + unsigned int best_n_nodes = 0, best_i = 0; int64_t best_cost = -1, best_internal = 0, best_size = 0; int npartitions; int current_order = -1; @@ -521,14 +519,14 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size) FOR_EACH_VARIABLE (vnode) gcc_assert (!vnode->aux); - + FOR_EACH_DEFINED_FUNCTION (node) if (node->get_partitioning_class () == SYMBOL_PARTITION) { if (node->no_reorder) noreorder.safe_push (node); else - order[n_nodes++] = node; + order.safe_push (node); if (!node->alias) total_size += ipa_fn_summaries->get_create (node)->size; } @@ -540,15 +538,15 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size) unit tends to import a lot of global trees defined there. We should get better about minimizing the function bounday, but until that things works smoother if we order in source order. */ - qsort (order, n_nodes, sizeof (struct cgraph_node *), node_cmp); + order.qsort (node_cmp); noreorder.qsort (node_cmp); if (symtab->dump_file) { - for(i = 0; i < n_nodes; i++) + for (unsigned i = 0; i < order.length (); i++) fprintf (symtab->dump_file, "Balanced map symbol order:%s:%u\n", order[i]->name (), order[i]->tp_first_run); - for(i = 0; i < (int)noreorder.length(); i++) + for (unsigned i = 0; i < noreorder.length (); i++) fprintf (symtab->dump_file, "Balanced map symbol no_reorder:%s:%u\n", noreorder[i]->name (), noreorder[i]->tp_first_run); } @@ -577,7 +575,7 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size) auto_vec next_nodes; - for (i = 0; i < n_nodes; i++) + for (unsigned i = 0; i < order.length (); i++) { if (symbol_partitioned_p (order[i])) continue; @@ -792,9 +790,9 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size) "Partition insns: %i (want %" PRId64 ")\n", partition->insns, partition_size); /* When we are finished, avoid creating empty partition. */ - while (i < n_nodes - 1 && symbol_partitioned_p (order[i + 1])) + while (i < order.length () - 1 && symbol_partitioned_p (order[i + 1])) i++; - if (i == n_nodes - 1) + if (i == order.length () - 1) break; total_size -= partition->insns; partition = new_partition (""); @@ -842,8 +840,6 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size) gcc_assert (next_nodes.length () || npartitions != 1 || !best_cost || best_cost == -1); add_sorted_nodes (next_nodes, partition); - free (order); - if (symtab->dump_file) { fprintf (symtab->dump_file, "\nPartition sizes:\n"); @@ -854,7 +850,7 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size) ltrans_partition p = ltrans_partitions[i]; fprintf (symtab->dump_file, "partition %d contains %d (%2.2f%%)" " symbols and %d (%2.2f%%) insns\n", i, p->symbols, - 100.0 * p->symbols / n_nodes, p->insns, + 100.0 * p->symbols / order.length (), p->insns, 100.0 * p->insns / original_total_size); } diff --git a/gcc/passes.c b/gcc/passes.c index ee42009..537e95a 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -1635,22 +1635,16 @@ do_per_function (void (*callback) (function *, void *data), void *data) static int nnodes; static GTY ((length ("nnodes"))) cgraph_node **order; +#define uid_hash_t hash_set> + /* Hook called when NODE is removed and therefore should be - excluded from order vector. DATA is an array of integers. - DATA[0] holds max index it may be accessed by. For cgraph - node DATA[node->uid + 1] holds index of this node in order - vector. */ + excluded from order vector. DATA is a hash set with removed nodes. */ + static void remove_cgraph_node_from_order (cgraph_node *node, void *data) { - int *order_idx = (int *)data; - - if (node->uid >= order_idx[0]) - return; - - int idx = order_idx[node->uid + 1]; - if (idx >= 0 && idx < nnodes && order[idx] == node) - order[idx] = NULL; + uid_hash_t *removed_nodes = (uid_hash_t *)data; + removed_nodes->add (node->uid); } /* If we are in IPA mode (i.e., current_function_decl is NULL), call @@ -1667,30 +1661,23 @@ do_per_function_toporder (void (*callback) (function *, void *data), void *data) else { cgraph_node_hook_list *hook; - int *order_idx; + uid_hash_t removed_nodes; gcc_assert (!order); order = ggc_vec_alloc (symtab->cgraph_count); - order_idx = XALLOCAVEC (int, symtab->cgraph_max_uid + 1); - memset (order_idx + 1, -1, sizeof (int) * symtab->cgraph_max_uid); - order_idx[0] = symtab->cgraph_max_uid; - nnodes = ipa_reverse_postorder (order); for (i = nnodes - 1; i >= 0; i--) - { - order[i]->process = 1; - order_idx[order[i]->uid + 1] = i; - } + order[i]->process = 1; hook = symtab->add_cgraph_removal_hook (remove_cgraph_node_from_order, - order_idx); + &removed_nodes); for (i = nnodes - 1; i >= 0; i--) { + cgraph_node *node = order[i]; + /* Function could be inlined and removed as unreachable. */ - if (!order[i]) + if (node == NULL || removed_nodes.contains (node->uid)) continue; - struct cgraph_node *node = order[i]; - /* Allow possibly removed nodes to be garbage collected. */ order[i] = NULL; node->process = 0; diff --git a/gcc/symbol-summary.h b/gcc/symbol-summary.h index 8227abb..dda3ae5 100644 --- a/gcc/symbol-summary.h +++ b/gcc/symbol-summary.h @@ -90,13 +90,13 @@ public: does not exist it will be created. */ T* get_create (cgraph_node *node) { - return get (node->summary_uid, true); + return get (node->uid, true); } /* Getter for summary callgraph node pointer. */ T* get (cgraph_node *node) { - return get (node->summary_uid, false); + return get (node->uid, false); } /* Return number of elements handled by data structure. */ @@ -108,7 +108,7 @@ public: /* Return true if a summary for the given NODE already exists. */ bool exists (cgraph_node *node) { - return m_map.get (node->summary_uid) != NULL; + return m_map.get (node->uid) != NULL; } /* Enable insertion hook invocation. */ @@ -216,7 +216,7 @@ template void function_summary::symtab_insertion (cgraph_node *node, void *data) { - gcc_checking_assert (node->summary_uid); + gcc_checking_assert (node->uid); function_summary *summary = (function_summary *) (data); if (summary->m_insertion_enabled) @@ -227,11 +227,11 @@ template void function_summary::symtab_removal (cgraph_node *node, void *data) { - gcc_checking_assert (node->summary_uid); + gcc_checking_assert (node->uid); function_summary *summary = (function_summary *) (data); - int summary_uid = node->summary_uid; - T **v = summary->m_map.get (summary_uid); + int uid = node->uid; + T **v = summary->m_map.get (uid); if (v) { @@ -240,7 +240,7 @@ function_summary::symtab_removal (cgraph_node *node, void *data) if (!summary->m_ggc) delete (*v); - summary->m_map.remove (summary_uid); + summary->m_map.remove (uid); } } @@ -256,7 +256,7 @@ function_summary::symtab_duplication (cgraph_node *node, { /* This load is necessary, because we insert a new value! */ T *duplicate = summary->allocate_new (); - summary->m_map.put (node2->summary_uid, duplicate); + summary->m_map.put (node2->uid, duplicate); summary->duplicate (node, node2, v, duplicate); } } -- 2.7.4