CbC/CbC_gcc: gcc/profile.c comparison

comparison gcc/profile.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Calculate branch probabilities, and basic block execution counts.
-Copyright (C) 1990-2017 Free Software Foundation, Inc.
+Copyright (C) 1990-2018 Free Software Foundation, Inc.
 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
 based on some ideas from Dain Samples of UC Berkeley.
 Further mangling by Bob Manson, Cygnus Support.
 This file is part of GCC.
 #define BB_INFO(b)  ((struct bb_profile_info *) (b)->aux)
 /* Counter summary from the last set of coverage counts read.  */
-const struct gcov_ctr_summary *profile_info;
+gcov_summary *profile_info;
-/* Counter working set information computed from the current counter
-summary. Not initialized unless profile_info summary is non-NULL.  */
-static gcov_working_set_t gcov_working_sets[NUM_GCOV_WORKING_SETS];
 /* Collect statistics on the performance of this pass for the entire source
 file.  */
 static int total_num_blocks;
 static int total_num_passes;
 static int total_num_times_called;
 static int total_hist_br_prob[20];
 static int total_num_branches;
-/* Helper function to update gcov_working_sets.  */
-void add_working_set (gcov_working_set_t *set) {
-int i = 0;
-for (; i < NUM_GCOV_WORKING_SETS; i++)
-gcov_working_sets[i] = set[i];
-}
 /* Forward declarations.  */
 static void find_spanning_tree (struct edge_list *);
 /* Add edge instrumentation code to the entire insn chain.
 	}
 }
 }
-/* Fill the working set information into the profile_info structure.  */
-void
-get_working_sets (void)
-{
-unsigned ws_ix, pctinc, pct;
-gcov_working_set_t *ws_info;
-if (!profile_info)
-return;
-compute_working_sets (profile_info, gcov_working_sets);
-if (dump_file)
-{
-fprintf (dump_file, "Counter working sets:\n");
-/* Multiply the percentage by 100 to avoid float.  */
-pctinc = 100 * 100 / NUM_GCOV_WORKING_SETS;
-for (ws_ix = 0, pct = pctinc; ws_ix < NUM_GCOV_WORKING_SETS;
-ws_ix++, pct += pctinc)
-{
-if (ws_ix == NUM_GCOV_WORKING_SETS - 1)
-pct = 9990;
-ws_info = &gcov_working_sets[ws_ix];
-/* Print out the percentage using int arithmatic to avoid float.  */
-fprintf (dump_file, "\t\t%u.%02u%%: num counts=%u, min counter="
-"%" PRId64 "\n",
-pct / 100, pct - (pct / 100 * 100),
-ws_info->num_counters,
-(int64_t)ws_info->min_counter);
-}
-}
-}
-/* Given a the desired percentage of the full profile (sum_all from the
-summary), multiplied by 10 to avoid float in PCT_TIMES_10, returns
-the corresponding working set information. If an exact match for
-the percentage isn't found, the closest value is used.  */
-gcov_working_set_t *
-find_working_set (unsigned pct_times_10)
-{
-unsigned i;
-if (!profile_info)
-return NULL;
-gcc_assert (pct_times_10 <= 1000);
-if (pct_times_10 >= 999)
-return &gcov_working_sets[NUM_GCOV_WORKING_SETS - 1];
-i = pct_times_10 * NUM_GCOV_WORKING_SETS / 1000;
-if (!i)
-return &gcov_working_sets[0];
-return &gcov_working_sets[i - 1];
-}
 /* Computes hybrid profile for all matching entries in da_file.
 CFG_CHECKSUM is the precomputed checksum for the CFG.  */
 static gcov_type *
 FOR_EACH_EDGE (e, ei, bb->succs)
 	if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
 	  num_edges++;
 }
-counts = get_coverage_counts (GCOV_COUNTER_ARCS, num_edges, cfg_checksum,
+counts = get_coverage_counts (GCOV_COUNTER_ARCS, cfg_checksum,
-				lineno_checksum, &profile_info);
+				lineno_checksum);
 if (!counts)
 return NULL;
-get_working_sets ();
-if (dump_file && profile_info)
-fprintf (dump_file, "Merged %u profiles with maximal count %u.\n",
-	     profile_info->runs, (unsigned) profile_info->sum_max);
 return counts;
 }
 static bool
 is_edge_inconsistent (vec<edge, va_gc> *edges)
 {
 edge e;
 FOR_EACH_EDGE (e, ei, bb->succs)
 	if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
 	  {
 	    num_edges++;
 	    if (exec_counts)
-	      {
+	      edge_gcov_count (e) = exec_counts[exec_counts_pos++];
-		edge_gcov_count (e) = exec_counts[exec_counts_pos++];
-		if (edge_gcov_count (e) > profile_info->sum_max)
-		  {
-		    if (flag_profile_correction)
-		      {
-			static bool informed = 0;
-			if (dump_enabled_p () && !informed)
-		          dump_printf_loc (MSG_NOTE, input_location,
-"corrupted profile info: edge count"
-" exceeds maximal count\n");
-			informed = 1;
-		      }
-		    else
-		      error ("corrupted profile info: edge from %i to %i exceeds maximal count",
-			     bb->index, e->dest->index);
-		  }
-	      }
 	    else
 	      edge_gcov_count (e) = 0;
 	    EDGE_INFO (e)->count_valid = 1;
 	    BB_INFO (bb)->succ_count--;
 }
 return num_edges;
 }
-#define OVERLAP_BASE 10000
-/* Compare the static estimated profile to the actual profile, and
-return the "degree of overlap" measure between them.
-Degree of overlap is a number between 0 and OVERLAP_BASE. It is
-the sum of each basic block's minimum relative weights between
-two profiles. And overlap of OVERLAP_BASE means two profiles are
-identical.  */
-static int
-compute_frequency_overlap (void)
-{
-gcov_type count_total = 0, freq_total = 0;
-int overlap = 0;
-basic_block bb;
-FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
-{
-count_total += bb_gcov_count (bb);
-freq_total += bb->frequency;
-}
-if (count_total == 0 || freq_total == 0)
-return 0;
-FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
-overlap += MIN (bb_gcov_count (bb) * OVERLAP_BASE / count_total,
-		    bb->frequency * OVERLAP_BASE / freq_total);
-return overlap;
-}
 /* Compute the branch probabilities for the various branches.
 Annotate them accordingly.
 CFG_CHECKSUM is the precomputed checksum for the CFG.  */
 gcov_type *exec_counts = get_exec_counts (cfg_checksum, lineno_checksum);
 int inconsistent = 0;
 /* Very simple sanity checks so we catch bugs in our profiling code.  */
 if (!profile_info)
-return;
+{
+if (dump_file)
+	fprintf (dump_file, "Profile info is missing; giving up\n");
+return;
+}
 bb_gcov_counts.safe_grow_cleared (last_basic_block_for_fn (cfun));
 edge_gcov_counts = new hash_map<edge,gcov_type>;
-if (profile_info->sum_all < profile_info->sum_max)
-{
-error ("corrupted profile info: sum_all is smaller than sum_max");
-exec_counts = NULL;
-}
 /* Attach extra info block to each bb.  */
 alloc_aux_for_blocks (sizeof (struct bb_profile_info));
 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
 {
 		  changes = 1;
 		}
 	    }
 	}
 }
-if (dump_file)
-{
-int overlap = compute_frequency_overlap ();
-gimple_dump_cfg (dump_file, dump_flags);
-fprintf (dump_file, "Static profile overlap: %d.%d%%\n",
-	       overlap / (OVERLAP_BASE / 100),
-	       overlap % (OVERLAP_BASE / 100));
-}
 total_num_passes += passes;
 if (dump_file)
 fprintf (dump_file, "Graph solving took %d passes.\n\n", passes);
 /* Inconsistency detected. Make it flow-consistent. */
 static int informed = 0;
 if (dump_enabled_p () && informed == 0)
 {
 informed = 1;
-dump_printf_loc (MSG_NOTE, input_location,
+dump_printf_loc (MSG_NOTE,
+			      dump_location_t::from_location_t (input_location),
 "correcting inconsistent profile data\n");
 }
 correct_negative_edge_counts ();
 /* Set bb counts to the sum of the outgoing edge counts */
 set_bb_counts ();
 	      && EDGE_COUNT (bb->succs) >= 2)
 	    num_branches++;
 	}
 }
-FOR_ALL_BB_FN (bb, cfun)
+/* If we have real data, use them!  */
-{
+if (bb_gcov_count (ENTRY_BLOCK_PTR_FOR_FN (cfun))
+|| !flag_guess_branch_prob)
+FOR_ALL_BB_FN (bb, cfun)
 bb->count = profile_count::from_gcov_type (bb_gcov_count (bb));
-}
+/* If function was not trained, preserve local estimates including statically
+determined zero counts.  */
+else
+FOR_ALL_BB_FN (bb, cfun)
+if (!(bb->count == profile_count::zero ()))
+bb->count = bb->count.global0 ();
 bb_gcov_counts.release ();
 delete edge_gcov_counts;
 edge_gcov_counts = NULL;
-counts_to_freqs ();
+update_max_bb_count ();
 if (dump_file)
 {
 fprintf (dump_file, "%d branches\n", num_branches);
 if (num_branches)
 	{
 	  histogram_counts[t] = NULL;
 	  continue;
 	}
-histogram_counts[t] =
+histogram_counts[t] = get_coverage_counts (COUNTER_FOR_HIST_TYPE (t),
-	get_coverage_counts (COUNTER_FOR_HIST_TYPE (t),
+						 cfg_checksum,
-			     n_histogram_counters[t], cfg_checksum,
+						 lineno_checksum);
-			     lineno_checksum, NULL);
 if (histogram_counts[t])
 	any = 1;
 act_count[t] = histogram_counts[t];
 }
 if (!any)
 for (t = 0; t < GCOV_N_VALUE_COUNTERS; t++)
 free (histogram_counts[t]);
 }
+/* Location triplet which records a location.  */
+struct location_triplet
+{
+const char *filename;
+int lineno;
+int bb_index;
+};
+/* Traits class for streamed_locations hash set below.  */
+struct location_triplet_hash : typed_noop_remove <location_triplet>
+{
+typedef location_triplet value_type;
+typedef location_triplet compare_type;
+static hashval_t
+hash (const location_triplet &ref)
+{
+inchash::hash hstate (0);
+if (ref.filename)
+hstate.add_int (strlen (ref.filename));
+hstate.add_int (ref.lineno);
+hstate.add_int (ref.bb_index);
+return hstate.end ();
+}
+static bool
+equal (const location_triplet &ref1, const location_triplet &ref2)
+{
+return ref1.lineno == ref2.lineno
+&& ref1.bb_index == ref2.bb_index
+&& ref1.filename != NULL
+&& ref2.filename != NULL
+&& strcmp (ref1.filename, ref2.filename) == 0;
+}
+static void
+mark_deleted (location_triplet &ref)
+{
+ref.lineno = -1;
+}
+static void
+mark_empty (location_triplet &ref)
+{
+ref.lineno = -2;
+}
+static bool
+is_deleted (const location_triplet &ref)
+{
+return ref.lineno == -1;
+}
+static bool
+is_empty (const location_triplet &ref)
+{
+return ref.lineno == -2;
+}
+};
 /* When passed NULL as file_name, initialize.
 When passed something else, output the necessary commands to change
 line to LINE and offset to FILE_NAME.  */
 static void
-output_location (char const *file_name, int line,
+output_location (hash_set<location_triplet_hash> *streamed_locations,
+		 char const *file_name, int line,
 		 gcov_position_t *offset, basic_block bb)
 {
 static char const *prev_file_name;
 static int prev_line;
 bool name_differs, line_differs;
+location_triplet triplet;
+triplet.filename = file_name;
+triplet.lineno = line;
+triplet.bb_index = bb ? bb->index : 0;
+if (streamed_locations->add (triplet))
+return;
 if (!file_name)
 {
 prev_file_name = NULL;
 prev_line = -1;
 total_num_times_called++;
 flow_call_edges_add (NULL);
 add_noreturn_fake_exit_edges ();
+hash_set <location_triplet_hash> streamed_locations;
 /* We can't handle cyclic regions constructed using abnormal edges.
 To avoid these we replace every source of abnormal edge by a fake
 edge from entry node and every destination by fake edge to exit.
 This keeps graph acyclic and our calculation exact for all normal
 	  gcov_write_length (offset);
 	}
 /* Line numbers.  */
 /* Initialize the output.  */
-output_location (NULL, 0, NULL, NULL);
+output_location (&streamed_locations, NULL, 0, NULL, NULL);
+hash_set<int_hash <location_t, 0, 2> > seen_locations;
 FOR_EACH_BB_FN (bb, cfun)
 	{
 	  gimple_stmt_iterator gsi;
 	  gcov_position_t offset = 0;
 	  if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb)
 	    {
-	      expanded_location curr_location =
+	      location_t loc = DECL_SOURCE_LOCATION (current_function_decl);
-		expand_location (DECL_SOURCE_LOCATION (current_function_decl));
+	      seen_locations.add (loc);
-	      output_location (curr_location.file, curr_location.line,
+	      expanded_location curr_location = expand_location (loc);
-			       &offset, bb);
+	      output_location (&streamed_locations, curr_location.file,
+			       curr_location.line, &offset, bb);
 	    }
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
 	      gimple *stmt = gsi_stmt (gsi);
-	      if (!RESERVED_LOCATION_P (gimple_location (stmt)))
+	      location_t loc = gimple_location (stmt);
-		output_location (gimple_filename (stmt), gimple_lineno (stmt),
+	      if (!RESERVED_LOCATION_P (loc))
-				 &offset, bb);
+		{
-	    }
+		  seen_locations.add (loc);
+		  output_location (&streamed_locations, gimple_filename (stmt),
-	  /* Notice GOTO expressions eliminated while constructing the CFG.  */
+				   gimple_lineno (stmt), &offset, bb);
+		}
+	    }
+	  /* Notice GOTO expressions eliminated while constructing the CFG.
+	     It's hard to distinguish such expression, but goto_locus should
+	     not be any of already seen location.  */
+	  location_t loc;
 	  if (single_succ_p (bb)
-	      && !RESERVED_LOCATION_P (single_succ_edge (bb)->goto_locus))
+	      && (loc = single_succ_edge (bb)->goto_locus)
-	    {
+	      && !RESERVED_LOCATION_P (loc)
-	      expanded_location curr_location
+	      && !seen_locations.contains (loc))
-		= expand_location (single_succ_edge (bb)->goto_locus);
+	    {
-	      output_location (curr_location.file, curr_location.line,
+	      expanded_location curr_location = expand_location (loc);
-			       &offset, bb);
+	      output_location (&streamed_locations, curr_location.file,
+			       curr_location.line, &offset, bb);
 	    }
 	  if (offset)
 	    {
 	      /* A file of NULL indicates the end of run.  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/profile.c @ 131:84e7813d76e9