predict.c (probably_never_executed): Compare frequency-based count to number of training runs.

2013-10-18  Teresa Johnson  <tejohnson@google.com>

	* predict.c (probably_never_executed): Compare frequency-based
	count to number of training runs.
	* params.def (UNLIKELY_BB_COUNT_FRACTION): New parameter.

From-SVN: r203830

gcc/ChangeLog

+2013-10-18  Teresa Johnson  <tejohnson@google.com>
+
+	* predict.c (probably_never_executed): Compare frequency-based
+	count to number of training runs.
+	* params.def (UNLIKELY_BB_COUNT_FRACTION): New parameter.
+
 2013-10-18  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
 
 	* config/arm/arm.c (cortexa9_extra_costs): New table.

gcc/params.def

@@ -373,6 +373,11 @@ DEFPARAM(HOT_BB_FREQUENCY_FRACTION,
 	 "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot",
 	 1000, 0, 0)
 
+DEFPARAM(UNLIKELY_BB_COUNT_FRACTION,
+	 "unlikely-bb-count-fraction",
+         "The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely",
+	 20, 1, 10000)
+
 DEFPARAM (PARAM_ALIGN_THRESHOLD,
 	  "align-threshold",
 	  "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment",

gcc/predict.c

@@ -237,17 +237,33 @@ probably_never_executed (struct function *fun,
   gcc_checking_assert (fun);
   if (profile_status_for_function (fun) == PROFILE_READ)
     {
-      if ((count * 4 + profile_info->runs / 2) / profile_info->runs > 0)
+      int unlikely_count_fraction = PARAM_VALUE (UNLIKELY_BB_COUNT_FRACTION);
+      if (count * unlikely_count_fraction >= profile_info->runs)
 	return false;
       if (!frequency)
 	return true;
       if (!ENTRY_BLOCK_PTR->frequency)
 	return false;
-      if (ENTRY_BLOCK_PTR->count && ENTRY_BLOCK_PTR->count < REG_BR_PROB_BASE)
+      if (ENTRY_BLOCK_PTR->count)
 	{
-	  return (RDIV (frequency * ENTRY_BLOCK_PTR->count,
-		        ENTRY_BLOCK_PTR->frequency)
-		  < REG_BR_PROB_BASE / 4);
+          gcov_type computed_count;
+          /* Check for possibility of overflow, in which case entry bb count
+             is large enough to do the division first without losing much
+             precision.  */
+          if (ENTRY_BLOCK_PTR->count < REG_BR_PROB_BASE * REG_BR_PROB_BASE)
+            {
+              gcov_type scaled_count
+                  = frequency * ENTRY_BLOCK_PTR->count * unlikely_count_fraction;
+              computed_count = RDIV (scaled_count, ENTRY_BLOCK_PTR->frequency);
+            }
+          else
+            {
+              computed_count = RDIV (ENTRY_BLOCK_PTR->count,
+                                     ENTRY_BLOCK_PTR->frequency);
+              computed_count *= frequency * unlikely_count_fraction;
+            }
+          if (computed_count >= profile_info->runs)
+            return false;
 	}
       return true;
     }