Compilation performance comparison of 3.5.0 and TreeSSA trees on MICO sources as requested in: [tree-ssa] Merge status 2004-05-03

[Daniel Berlin]

On May 5, 2004, at 3:14 PM, Karel Gardas wrote:

>
> Folks,
>
> as you have requested log files of various builds with -ftime-report
> option used are here: http://mico.org/~karel/logs.tar.bz2. I have also
> added one build for -O2 -foptions, where -foptions are options 
> suggested
> by Steven Bosscher and Jeff Law. What surprised me a bit is that there 
> is
> so big difference between build w/ and w/o -ftime-report option from
> compilation performance point of view. As such I have also included
> original logs (w/o -ftime-report) from which I have provided summary 
> table
> yesterday.
>

Note that in almost all of his cases, the parser takes at least 15%, 
and usually 30%+ of the time of compilation.
>
This is true even for both the small, medium, and the  large cases.
parser                :   0.14 (15%) usr   0.01 (14%) sys   0.18 (17%) 
wall
  parser                :   0.15 (10%) usr   0.02 (25%) sys   0.17 (11%) 
wall
  parser                :   0.15 (23%) usr   0.02 (33%) sys   0.15 (20%) 
wall
  parser                :   0.15 (26%) usr   0.02 (33%) sys   0.17 (25%) 
wall
  parser                :   0.16 (16%) usr   0.01 (10%) sys   0.23 (20%) 
wall
  parser                :   0.17 (11%) usr   0.03 (38%) sys   0.21 (12%) 
wall
  parser                :   0.18 (14%) usr   0.03 (30%) sys   0.17 (12%) 
wall
...

  parser                :   3.54 (46%) usr   0.51 (42%) sys   4.35 (48%) 
wall
  parser                :   3.57 (51%) usr   0.45 (37%) sys   3.87 (46%) 
wall
  parser                :   3.57 (57%) usr   0.55 (48%) sys   3.70 (49%) 
wall
  parser                :   3.60 (33%) usr   0.51 (40%) sys   4.35 (35%) 
wall
  parser                :   3.62 (54%) usr   0.45 (37%) sys   4.28 (53%) 
wall
  parser                :   3.67 (54%) usr   0.47 (39%) sys   3.73 (45%) 
wall
  parser                :   3.69 (30%) usr   0.56 (43%) sys   4.34 (32%) 
wall
  parser                :   3.70 (32%) usr   0.44 (33%) sys   4.34 (33%) 
wall
  parser                :   3.73 (28%) usr   0.52 (40%) sys   4.41 (29%) 
wall
  ...

  parser                :  11.08 (37%) usr   1.06 (42%) sys  12.11 (36%) 
wall
  parser                :  11.19 (45%) usr   1.05 (44%) sys  12.40 (45%) 
wall
  parser                :  11.28 (44%) usr   1.01 (43%) sys  12.76 (44%) 
wall
  parser                :  17.78 (14%) usr   1.14 (28%) sys  20.27 (15%) 
wall
  parser                :  18.52 (14%) usr   1.37 (33%) sys  20.19 (14%) 
wall
  parser                :  20.95 (30%) usr   1.15 (36%) sys  22.77 (31%) 
wall
  parser                :  21.01 (22%) usr   1.06 (28%) sys  21.68 (21%) 
wall

Name lookup is another 5-20% of the time in his cases, for both small, 
medium, and large again

  name lookup           :   0.69 (13%) usr   0.42 (40%) sys   1.33 (20%) 
wall
  name lookup           :   0.80 (18%) usr   0.50 (54%) sys   1.16 (21%) 
wall
  name lookup           :   0.80 (19%) usr   0.39 (42%) sys   1.35 (25%) 
wall
  name lookup           :   0.81 (18%) usr   0.38 (43%) sys   1.27 (23%) 
wall
  name lookup           :   0.81 (20%) usr   0.41 (41%) sys   1.32 (25%) 
wall
...
  name lookup           :   2.68 (12%) usr   0.92 (39%) sys   3.45 (13%) 
wall
  name lookup           :   2.81 ( 9%) usr   0.99 (38%) sys   3.44 (10%) 
wall
  name lookup           :   4.98 ( 7%) usr   1.31 (45%) sys   6.54 ( 9%) 
wall
  name lookup           :   4.99 ( 7%) usr   1.25 (39%) sys   6.21 ( 8%) 
wall
  name lookup           :   5.23 ( 6%) usr   1.49 (39%) sys   6.86 ( 7%) 
wall
  name lookup           :   5.32 ( 4%) usr   1.24 (31%) sys   6.24 ( 5%) 
wall


Gimplification takes 3-7% on all of his cases.

  tree gimplify         :   1.60 ( 5%) usr   0.01 ( 0%) sys   1.74 ( 5%) 
wall
  tree gimplify         :   1.61 ( 5%) usr   0.04 ( 2%) sys   1.75 ( 5%) 
wall
  tree gimplify         :   1.65 ( 5%) usr   0.03 ( 1%) sys   1.70 ( 4%) 
wall
  tree gimplify         :   4.46 ( 5%) usr   0.04 ( 1%) sys   5.41 ( 5%) 
wall
  tree gimplify         :   4.68 ( 3%) usr   0.06 ( 1%) sys   5.08 ( 4%) 
wall
  tree gimplify         :   4.96 ( 7%) usr   0.06 ( 2%) sys   4.76 ( 6%) 
wall
  tree gimplify         :   5.14 ( 4%) usr   0.08 ( 2%) sys   4.81 ( 4%) 
wall

Most of the optimizations are 1% or less, if they are even measurable.

Note that the parser times are significantly slower with tree-ssa than 
they are for mainline (be it because of memory locality, bad time 
accounting, or whatever)
.
The largest parser times for 3.5 are
...
  parser                :   9.90 (41%) usr   0.96 (42%) sys  10.97 (41%) 
wall
  parser                :   9.93 (39%) usr   0.96 (42%) sys  10.99 (39%) 
wall
  parser                :  10.17 (47%) usr   0.91 (44%) sys  11.21 (46%) 
wall
  parser                :  13.60 (14%) usr   1.10 (34%) sys  15.08 (14%) 
wall
  parser                :  15.19 (22%) usr   1.06 (36%) sys  16.57 (22%) 
wall
  parser                :  15.57 (32%) usr   0.98 (37%) sys  16.20 (31%) 
wall

which is 6-7 seconds *less* than the largest parser times for tree-ssa

I only mention this because i'm pretty sure that right now, even if we 
made gimplification take no time on these testcases, we'd still have a 
large percent regression just from the parser times.

In fact, on these testcases, to avoid regression, you'd be better off 
concentrating speed on the parser and the name lookup, than you would 
on anything actually specific to tree-ssa (IE any optimization or 
gimplification).