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