gcc/profile-count.c

   1 /* Profile counter container type.
   2    Copyright (C) 2017-2018 Free Software Foundation, Inc.
   3    Contributed by Jan Hubicka
   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 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "profile-count.h"
  25 #include "options.h"
  26 #include "tree.h"
  27 #include "basic-block.h"
  28 #include "cfg.h"
  29 #include "function.h"
  30 #include "gimple.h"
  31 #include "data-streamer.h"
  32 #include "cgraph.h"
  33 #include "wide-int.h"
  34 #include "sreal.h"
  35
  36 /* Get a string describing QUALITY.  */
  37
  38 const char *
  39 profile_quality_as_string (enum profile_quality quality)
  40 {
  41   switch (quality)
  42     {
  43     default:
  44       gcc_unreachable ();
  45     case profile_uninitialized:
  46       return "uninitialized";
  47     case profile_guessed_local:
  48       return "guessed_local";
  49     case profile_guessed_global0:
  50       return "guessed_global0";
  51     case profile_guessed_global0adjusted:
  52       return "guessed_global0adjusted";
  53     case profile_guessed:
  54       return "guessed";
  55     case profile_afdo:
  56       return "afdo";
  57     case profile_adjusted:
  58       return "adjusted";
  59     case profile_precise:
  60       return "precise";
  61     }
  62 }
  63
  64 /* Dump THIS to F.  */
  65
  66 void
  67 profile_count::dump (FILE *f) const
  68 {
  69   if (!initialized_p ())
  70     fprintf (f, "uninitialized");
  71   else
  72     {
  73       fprintf (f, "%" PRId64, m_val);
  74       if (m_quality == profile_guessed_local)
  75         fprintf (f, " (estimated locally)");
  76       else if (m_quality == profile_guessed_global0)
  77         fprintf (f, " (estimated locally, globally 0)");
  78       else if (m_quality == profile_guessed_global0adjusted)
  79         fprintf (f, " (estimated locally, globally 0 adjusted)");
  80       else if (m_quality == profile_adjusted)
  81         fprintf (f, " (adjusted)");
  82       else if (m_quality == profile_afdo)
  83         fprintf (f, " (auto FDO)");
  84       else if (m_quality == profile_guessed)
  85         fprintf (f, " (guessed)");
  86     }
  87 }
  88
  89 /* Dump THIS to stderr.  */
  90
  91 void
  92 profile_count::debug () const
  93 {
  94   dump (stderr);
  95   fprintf (stderr, "\n");
  96 }
  97
  98 /* Return true if THIS differs from OTHER; tolerate small diferences.  */
  99
 100 bool
 101 profile_count::differs_from_p (profile_count other) const
 102 {
 103   gcc_checking_assert (compatible_p (other));
 104   if (!initialized_p () || !other.initialized_p ())
 105     return false;
 106   if ((uint64_t)m_val - (uint64_t)other.m_val < 100
 107       || (uint64_t)other.m_val - (uint64_t)m_val < 100)
 108     return false;
 109   if (!other.m_val)
 110     return true;
 111   int64_t ratio = (int64_t)m_val * 100 / other.m_val;
 112   return ratio < 99 || ratio > 101;
 113 }
 114
 115 /* Stream THIS from IB.  */
 116
 117 profile_count
 118 profile_count::stream_in (struct lto_input_block *ib)
 119 {
 120   profile_count ret;
 121   ret.m_val = streamer_read_gcov_count (ib);
 122   ret.m_quality = (profile_quality) streamer_read_uhwi (ib);
 123   return ret;
 124 }
 125
 126 /* Stream THIS to OB.  */
 127
 128 void
 129 profile_count::stream_out (struct output_block *ob)
 130 {
 131   streamer_write_gcov_count (ob, m_val);
 132   streamer_write_uhwi (ob, m_quality);
 133 }
 134
 135 /* Stream THIS to OB.  */
 136
 137 void
 138 profile_count::stream_out (struct lto_output_stream *ob)
 139 {
 140   streamer_write_gcov_count_stream (ob, m_val);
 141   streamer_write_uhwi_stream (ob, m_quality);
 142 }
 143
 144 /* Dump THIS to F.  */
 145
 146 void
 147 profile_probability::dump (FILE *f) const
 148 {
 149   if (!initialized_p ())
 150     fprintf (f, "uninitialized");
 151   else
 152     {
 153       /* Make difference between 0.00 as a roundoff error and actual 0.
 154          Similarly for 1.  */
 155       if (m_val == 0)
 156         fprintf (f, "never");
 157       else if (m_val == max_probability)
 158         fprintf (f, "always");
 159       else
 160         fprintf (f, "%3.1f%%", (double)m_val * 100 / max_probability);
 161       if (m_quality == profile_adjusted)
 162         fprintf (f, " (adjusted)");
 163       else if (m_quality == profile_afdo)
 164         fprintf (f, " (auto FDO)");
 165       else if (m_quality == profile_guessed)
 166         fprintf (f, " (guessed)");
 167     }
 168 }
 169
 170 /* Dump THIS to stderr.  */
 171
 172 void
 173 profile_probability::debug () const
 174 {
 175   dump (stderr);
 176   fprintf (stderr, "\n");
 177 }
 178
 179 /* Return true if THIS differs from OTHER; tolerate small diferences.  */
 180
 181 bool
 182 profile_probability::differs_from_p (profile_probability other) const
 183 {
 184   if (!initialized_p () || !other.initialized_p ())
 185     return false;
 186   if ((uint64_t)m_val - (uint64_t)other.m_val < max_probability / 1000
 187       || (uint64_t)other.m_val - (uint64_t)max_probability < 1000)
 188     return false;
 189   if (!other.m_val)
 190     return true;
 191   int64_t ratio = (int64_t)m_val * 100 / other.m_val;
 192   return ratio < 99 || ratio > 101;
 193 }
 194
 195 /* Return true if THIS differs significantly from OTHER.  */
 196
 197 bool
 198 profile_probability::differs_lot_from_p (profile_probability other) const
 199 {
 200   if (!initialized_p () || !other.initialized_p ())
 201     return false;
 202   uint32_t d = m_val > other.m_val ? m_val - other.m_val : other.m_val - m_val;
 203   return d > max_probability / 2;
 204 }
 205
 206 /* Stream THIS from IB.  */
 207
 208 profile_probability
 209 profile_probability::stream_in (struct lto_input_block *ib)
 210 {
 211   profile_probability ret;
 212   ret.m_val = streamer_read_uhwi (ib);
 213   ret.m_quality = (profile_quality) streamer_read_uhwi (ib);
 214   return ret;
 215 }
 216
 217 /* Stream THIS to OB.  */
 218
 219 void
 220 profile_probability::stream_out (struct output_block *ob)
 221 {
 222   streamer_write_uhwi (ob, m_val);
 223   streamer_write_uhwi (ob, m_quality);
 224 }
 225
 226 /* Stream THIS to OB.  */
 227
 228 void
 229 profile_probability::stream_out (struct lto_output_stream *ob)
 230 {
 231   streamer_write_uhwi_stream (ob, m_val);
 232   streamer_write_uhwi_stream (ob, m_quality);
 233 }
 234
 235 /* Compute RES=(a*b + c/2)/c capping and return false if overflow happened.  */
 236
 237 bool
 238 slow_safe_scale_64bit (uint64_t a, uint64_t b, uint64_t c, uint64_t *res)
 239 {
 240   FIXED_WIDE_INT (128) tmp = a;
 241   wi::overflow_type overflow;
 242   tmp = wi::udiv_floor (wi::umul (tmp, b, &overflow) + (c / 2), c);
 243   gcc_checking_assert (!overflow);
 244   if (wi::fits_uhwi_p (tmp))
 245     {
 246       *res = tmp.to_uhwi ();
 247       return true;
 248     }
 249   *res = (uint64_t) -1;
 250   return false;
 251 }
 252
 253 /* Return count as frequency within FUN scaled in range 0 to REG_FREQ_MAX
 254    Used for legacy code and should not be used anymore.  */
 255
 256 int
 257 profile_count::to_frequency (struct function *fun) const
 258 {
 259   if (!initialized_p ())
 260     return BB_FREQ_MAX;
 261   if (*this == profile_count::zero ())
 262     return 0;
 263   gcc_assert (REG_BR_PROB_BASE == BB_FREQ_MAX
 264               && fun->cfg->count_max.initialized_p ());
 265   profile_probability prob = probability_in (fun->cfg->count_max);
 266   if (!prob.initialized_p ())
 267     return REG_BR_PROB_BASE;
 268   return prob.to_reg_br_prob_base ();
 269 }
 270
 271 /* Return count as frequency within FUN scaled in range 0 to CGRAPH_FREQ_MAX
 272    where CGRAPH_FREQ_BASE means that count equals to entry block count.
 273    Used for legacy code and should not be used anymore.  */
 274
 275 int
 276 profile_count::to_cgraph_frequency (profile_count entry_bb_count) const
 277 {
 278   if (!initialized_p () || !entry_bb_count.initialized_p ())
 279     return CGRAPH_FREQ_BASE;
 280   if (*this == profile_count::zero ())
 281     return 0;
 282   gcc_checking_assert (entry_bb_count.initialized_p ());
 283   uint64_t scale;
 284   if (!safe_scale_64bit (!entry_bb_count.m_val ? m_val + 1 : m_val,
 285                          CGRAPH_FREQ_BASE, MAX (1, entry_bb_count.m_val), &scale))
 286     return CGRAPH_FREQ_MAX;
 287   return MIN (scale, CGRAPH_FREQ_MAX);
 288 }
 289
 290 /* Return THIS/IN as sreal value.  */
 291
 292 sreal
 293 profile_count::to_sreal_scale (profile_count in, bool *known) const
 294 {
 295   if (!initialized_p () || !in.initialized_p ())
 296     {
 297       if (known)
 298         *known = false;
 299       return 1;
 300     }
 301   if (known)
 302     *known = true;
 303   if (*this == profile_count::zero ())
 304     return 0;
 305
 306   if (!in.m_val)
 307     {
 308       if (!m_val)
 309         return 1;
 310       return m_val * 4;
 311     }
 312   return (sreal)m_val / (sreal)in.m_val;
 313 }
 314
 315 /* We want to scale profile across function boundary from NUM to DEN.
 316    Take care of the side case when DEN is zeros.  We still want to behave
 317    sanely here which means
 318      - scale to profile_count::zero () if NUM is profile_count::zero
 319      - do not affect anything if NUM == DEN
 320      - preserve counter value but adjust quality in other cases.  */
 321
 322 void
 323 profile_count::adjust_for_ipa_scaling (profile_count *num,
 324                                        profile_count *den)
 325 {
 326   /* Scaling is no-op if NUM and DEN are the same.  */
 327   if (*num == *den)
 328     return;
 329   /* Scaling to zero is always zero.  */
 330   if (*num == profile_count::zero ())
 331     return;
 332   /* If den is non-zero we are safe.  */
 333   if (den->force_nonzero () == *den)
 334     return;
 335   /* Force both to non-zero so we do not push profiles to 0 when
 336      both num == 0 and den == 0.  */
 337   *den = den->force_nonzero ();
 338   *num = num->force_nonzero ();
 339 }
 340
 341 /* THIS is a count of bb which is known to be executed IPA times.
 342    Combine this information into bb counter.  This means returning IPA
 343    if it is nonzero, not changing anything if IPA is uninitialized
 344    and if IPA is zero, turning THIS into corresponding local profile with
 345    global0.  */
 346 profile_count
 347 profile_count::combine_with_ipa_count (profile_count ipa)
 348 {
 349   ipa = ipa.ipa ();
 350   if (ipa.nonzero_p ())
 351     return ipa;
 352   if (!ipa.initialized_p () || *this == profile_count::zero ())
 353     return *this;
 354   if (ipa == profile_count::zero ())
 355     return this->global0 ();
 356   return this->global0adjusted ();
 357 }
 358
 359 /* The profiling runtime uses gcov_type, which is usually 64bit integer.
 360    Conversions back and forth are used to read the coverage and get it
 361    into internal representation.  */
 362 profile_count
 363 profile_count::from_gcov_type (gcov_type v)
 364   {
 365     profile_count ret;
 366     gcc_checking_assert (v >= 0);
 367     if (dump_file && v >= (gcov_type)max_count)
 368       fprintf (dump_file,
 369                "Capping gcov count %" PRId64 " to max_count %" PRId64 "\n",
 370                (int64_t) v, (int64_t) max_count);
 371     ret.m_val = MIN (v, (gcov_type)max_count);
 372     ret.m_quality = profile_precise;
 373     return ret;
 374   }
 375
 376
 377 /* COUNT1 times event happens with *THIS probability, COUNT2 times OTHER
 378    happens with COUNT2 probablity. Return probablity that either *THIS or
 379    OTHER happens.  */
 380
 381 profile_probability
 382 profile_probability::combine_with_count (profile_count count1,
 383                                          profile_probability other,
 384                                          profile_count count2) const
 385 {
 386   /* If probabilities are same, we are done.
 387      If counts are nonzero we can distribute accordingly. In remaining
 388      cases just avreage the values and hope for the best.  */
 389   if (*this == other || count1 == count2
 390       || (count2 == profile_count::zero ()
 391           && !(count1 == profile_count::zero ())))
 392     return *this;
 393   if (count1 == profile_count::zero () && !(count2 == profile_count::zero ()))
 394     return other;
 395   else if (count1.nonzero_p () || count2.nonzero_p ())
 396     return *this * count1.probability_in (count1 + count2)
 397            + other * count2.probability_in (count1 + count2);
 398   else
 399     return *this * profile_probability::even ()
 400            + other * profile_probability::even ();
 401 }