This is the mail archive of the gcc-regression@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

A recent patch increased GCC's memory consumption in some cases!


Hi,

I am a friendly script caring about memory consumption in GCC.  Please
contact jh@suse.cz if something is going wrong.

Comparing memory consumption on compilation of combine.i, insn-attrtab.i,
and generate-3.4.ii I got:


comparing empty function compilation at -O0 level:
  Amount of produced GGC garbage increased from 245k to 246k, overall 0.65%
    Overall memory needed: 8136k -> 8139k
    Peak memory use before GGC: 1165k
    Peak memory use after GGC: 1063k
    Maximum of released memory in single GGC run: 131k -> 132k
    Garbage: 245k -> 246k
    Leak: 1024k
    Overhead: 92k -> 92k
    GGC runs: 3
  Amount of memory referenced pre-ipa increased from 1024k to 1026k, overall 0.21%
    Pre-IPA-Garbage: 235k
    Pre-IPA-Leak: 1024k -> 1026k
    Pre-IPA-Overhead: 90k -> 90k
  Amount of memory referenced post-ipa increased from 1024k to 1026k, overall 0.21%
    Post-IPA-Garbage: 235k
    Post-IPA-Leak: 1024k -> 1026k
    Post-IPA-Overhead: 90k -> 90k

comparing empty function compilation at -O0 -g level:
  Amount of produced GGC garbage increased from 247k to 249k, overall 0.64%
    Overall memory needed: 8152k -> 8155k
    Peak memory use before GGC: 1193k
    Peak memory use after GGC: 1091k
    Maximum of released memory in single GGC run: 131k
    Garbage: 247k -> 249k
    Leak: 1057k
    Overhead: 96k -> 97k
    GGC runs: 3
  Amount of memory referenced pre-ipa increased from 1024k to 1026k, overall 0.21%
    Pre-IPA-Garbage: 235k
    Pre-IPA-Leak: 1024k -> 1026k
    Pre-IPA-Overhead: 90k -> 90k
  Amount of memory referenced post-ipa increased from 1024k to 1026k, overall 0.21%
    Post-IPA-Garbage: 235k
    Post-IPA-Leak: 1024k -> 1026k
    Post-IPA-Overhead: 90k -> 90k

comparing empty function compilation at -O1 level:
    Overall memory needed: 8220k -> 8223k
    Peak memory use before GGC: 1165k
    Peak memory use after GGC: 1063k
    Maximum of released memory in single GGC run: 131k
    Garbage: 249k
    Leak: 1024k
    Overhead: 93k
    GGC runs: 3
    Pre-IPA-Garbage: 235k
    Pre-IPA-Leak: 1026k
    Pre-IPA-Overhead: 91k
    Post-IPA-Garbage: 235k
    Post-IPA-Leak: 1026k
    Post-IPA-Overhead: 91k

comparing empty function compilation at -O2 level:
    Overall memory needed: 8236k -> 8231k
    Peak memory use before GGC: 1165k
    Peak memory use after GGC: 1064k
    Maximum of released memory in single GGC run: 130k
    Garbage: 254k
    Leak: 1024k
    Overhead: 94k
    GGC runs: 3
    Pre-IPA-Garbage: 235k
    Pre-IPA-Leak: 1027k
    Pre-IPA-Overhead: 91k
    Post-IPA-Garbage: 235k
    Post-IPA-Leak: 1027k
    Post-IPA-Overhead: 91k

comparing empty function compilation at -O3 level:
    Overall memory needed: 8240k -> 8239k
    Peak memory use before GGC: 1165k
    Peak memory use after GGC: 1064k
    Maximum of released memory in single GGC run: 130k
    Garbage: 254k
    Leak: 1024k
    Overhead: 94k
    GGC runs: 3
    Pre-IPA-Garbage: 235k
    Pre-IPA-Leak: 1027k
    Pre-IPA-Overhead: 91k
    Post-IPA-Garbage: 235k
    Post-IPA-Leak: 1027k
    Post-IPA-Overhead: 91k

comparing combine.c compilation at -O0 level:
  Overall memory allocated via mmap and sbrk increased from 27396k to 31603k, overall 15.36%
  Peak amount of GGC memory allocated before garbage collecting increased from 15015k to 18544k, overall 23.50%
  Peak amount of GGC memory still allocated after garbage collecting increased from 14752k to 18355k, overall 24.42%
  Amount of produced GGC garbage increased from 38075k to 39791k, overall 4.51%
  Amount of memory still referenced at the end of compilation increased from 5189k to 5195k, overall 0.11%
    Overall memory needed: 27396k -> 31603k
    Peak memory use before GGC: 15015k -> 18544k
    Peak memory use after GGC: 14752k -> 18355k
    Maximum of released memory in single GGC run: 1788k -> 1844k
    Garbage: 38075k -> 39791k
    Leak: 5189k -> 5195k
    Overhead: 4644k -> 4761k
    GGC runs: 354 -> 355
  Amount of produced pre-ipa-GGC garbage increased from 12896k to 13074k, overall 1.38%
  Amount of memory referenced pre-ipa increased from 15352k to 19544k, overall 27.30%
    Pre-IPA-Garbage: 12896k -> 13074k
    Pre-IPA-Leak: 15352k -> 19544k
    Pre-IPA-Overhead: 1978k -> 2164k
  Amount of produced post-ipa-GGC garbage increased from 12896k to 13074k, overall 1.38%
  Amount of memory referenced post-ipa increased from 15352k to 19544k, overall 27.30%
    Post-IPA-Garbage: 12896k -> 13074k
    Post-IPA-Leak: 15352k -> 19544k
    Post-IPA-Overhead: 1978k -> 2164k

comparing combine.c compilation at -O0 -g level:
  Overall memory allocated via mmap and sbrk increased from 29600k to 33551k, overall 13.35%
  Peak amount of GGC memory allocated before garbage collecting increased from 16875k to 20437k, overall 21.11%
  Peak amount of GGC memory still allocated after garbage collecting increased from 16644k to 20224k, overall 21.51%
  Amount of produced GGC garbage increased from 38416k to 40159k, overall 4.54%
    Overall memory needed: 29600k -> 33551k
    Peak memory use before GGC: 16875k -> 20437k
    Peak memory use after GGC: 16644k -> 20224k
    Maximum of released memory in single GGC run: 1812k -> 1853k
    Garbage: 38416k -> 40159k
    Leak: 8504k -> 8493k
    Overhead: 5465k -> 5583k
    GGC runs: 337 -> 341
  Amount of produced pre-ipa-GGC garbage increased from 12996k to 13173k, overall 1.37%
  Amount of memory referenced pre-ipa increased from 17628k to 21819k, overall 23.78%
    Pre-IPA-Garbage: 12996k -> 13173k
    Pre-IPA-Leak: 17628k -> 21819k
    Pre-IPA-Overhead: 2469k -> 2656k
  Amount of produced post-ipa-GGC garbage increased from 12996k to 13173k, overall 1.37%
  Amount of memory referenced post-ipa increased from 17628k to 21819k, overall 23.78%
    Post-IPA-Garbage: 12996k -> 13173k
    Post-IPA-Leak: 17628k -> 21819k
    Post-IPA-Overhead: 2469k -> 2656k

comparing combine.c compilation at -O1 level:
    Overall memory needed: 30320k -> 30319k
    Peak memory use before GGC: 16342k
    Peak memory use after GGC: 16180k
    Maximum of released memory in single GGC run: 1395k
    Garbage: 50530k
    Leak: 5178k
    Overhead: 5602k
    GGC runs: 430
    Pre-IPA-Garbage: 13919k
    Pre-IPA-Leak: 17185k
    Pre-IPA-Overhead: 2114k
    Post-IPA-Garbage: 13919k
    Post-IPA-Leak: 17185k
    Post-IPA-Overhead: 2114k

comparing combine.c compilation at -O2 level:
    Overall memory needed: 31644k -> 31643k
    Peak memory use before GGC: 16439k
    Peak memory use after GGC: 16276k
    Maximum of released memory in single GGC run: 1333k
    Garbage: 66525k
    Leak: 5208k
    Overhead: 7419k
    GGC runs: 505
    Pre-IPA-Garbage: 14068k
    Pre-IPA-Leak: 17247k
    Pre-IPA-Overhead: 2127k
    Post-IPA-Garbage: 14068k
    Post-IPA-Leak: 17247k
    Post-IPA-Overhead: 2127k

comparing combine.c compilation at -O3 level:
    Overall memory needed: 37356k -> 37343k
    Peak memory use before GGC: 16466k
    Peak memory use after GGC: 16293k
    Maximum of released memory in single GGC run: 2126k
    Garbage: 83136k
    Leak: 5231k
    Overhead: 9046k
    GGC runs: 534
    Pre-IPA-Garbage: 14069k
    Pre-IPA-Leak: 17258k
    Pre-IPA-Overhead: 2128k
    Post-IPA-Garbage: 14069k
    Post-IPA-Leak: 17258k
    Post-IPA-Overhead: 2128k

comparing insn-attrtab.c compilation at -O0 level:
  Overall memory allocated via mmap and sbrk increased from 141740k to 147003k, overall 3.71%
  Peak amount of GGC memory allocated before garbage collecting increased from 62365k to 66154k, overall 6.08%
  Peak amount of GGC memory still allocated after garbage collecting increased from 52700k to 59246k, overall 12.42%
  Amount of produced GGC garbage increased from 130179k to 135564k, overall 4.14%
  Amount of memory still referenced at the end of compilation decreased from 7087k to 6844k, overall -3.54%
    Overall memory needed: 141740k -> 147003k
    Peak memory use before GGC: 62365k -> 66154k
    Peak memory use after GGC: 52700k -> 59246k
    Maximum of released memory in single GGC run: 25736k -> 28087k
    Garbage: 130179k -> 135564k
    Leak: 7087k -> 6844k
    Overhead: 14220k -> 14460k
    GGC runs: 272 -> 273
  Amount of produced pre-ipa-GGC garbage increased from 43045k to 43648k, overall 1.40%
  Amount of memory referenced pre-ipa increased from 49873k to 61271k, overall 22.85%
    Pre-IPA-Garbage: 43045k -> 43648k
    Pre-IPA-Leak: 49873k -> 61271k
    Pre-IPA-Overhead: 7105k -> 7606k
  Amount of produced post-ipa-GGC garbage increased from 43045k to 43648k, overall 1.40%
  Amount of memory referenced post-ipa increased from 49873k to 61271k, overall 22.85%
    Post-IPA-Garbage: 43045k -> 43648k
    Post-IPA-Leak: 49873k -> 61271k
    Post-IPA-Overhead: 7105k -> 7606k

comparing insn-attrtab.c compilation at -O0 -g level:
  Overall memory allocated via mmap and sbrk increased from 143040k to 148299k, overall 3.68%
  Peak amount of GGC memory allocated before garbage collecting increased from 63640k to 67429k, overall 5.95%
  Peak amount of GGC memory still allocated after garbage collecting increased from 53973k to 60518k, overall 12.13%
  Amount of produced GGC garbage increased from 130699k to 136084k, overall 4.12%
    Overall memory needed: 143040k -> 148299k
    Peak memory use before GGC: 63640k -> 67429k
    Peak memory use after GGC: 53973k -> 60518k
    Maximum of released memory in single GGC run: 25737k -> 28088k
    Garbage: 130699k -> 136084k
    Leak: 8738k -> 8495k
    Overhead: 14678k -> 14919k
    GGC runs: 263 -> 266
  Amount of produced pre-ipa-GGC garbage increased from 43102k to 43706k, overall 1.40%
  Amount of memory referenced pre-ipa increased from 51416k to 62814k, overall 22.17%
    Pre-IPA-Garbage: 43102k -> 43706k
    Pre-IPA-Leak: 51416k -> 62814k
    Pre-IPA-Overhead: 7441k -> 7942k
  Amount of produced post-ipa-GGC garbage increased from 43102k to 43706k, overall 1.40%
  Amount of memory referenced post-ipa increased from 51416k to 62814k, overall 22.17%
    Post-IPA-Garbage: 43102k -> 43706k
    Post-IPA-Leak: 51416k -> 62814k
    Post-IPA-Overhead: 7441k -> 7942k

comparing insn-attrtab.c compilation at -O1 level:
    Overall memory needed: 133012k -> 133011k
    Peak memory use before GGC: 54287k
    Peak memory use after GGC: 48560k
    Maximum of released memory in single GGC run: 23289k
    Garbage: 203580k
    Leak: 6477k
    Overhead: 24012k
    GGC runs: 313
    Pre-IPA-Garbage: 50236k
    Pre-IPA-Leak: 49387k
    Pre-IPA-Overhead: 7216k
    Post-IPA-Garbage: 50236k
    Post-IPA-Leak: 49387k
    Post-IPA-Overhead: 7216k

comparing insn-attrtab.c compilation at -O2 level:
    Overall memory needed: 179740k -> 179739k
    Peak memory use before GGC: 54969k
    Peak memory use after GGC: 49574k
    Maximum of released memory in single GGC run: 22125k
    Garbage: 240508k
    Leak: 6485k
    Overhead: 29589k
    GGC runs: 346
    Pre-IPA-Garbage: 50305k
    Pre-IPA-Leak: 49392k
    Pre-IPA-Overhead: 7223k
    Post-IPA-Garbage: 50305k
    Post-IPA-Leak: 49392k
    Post-IPA-Overhead: 7223k

comparing insn-attrtab.c compilation at -O3 level:
    Overall memory needed: 188288k -> 188291k
    Peak memory use before GGC: 65890k
    Peak memory use after GGC: 63022k
    Maximum of released memory in single GGC run: 24136k
    Garbage: 267145k
    Leak: 6493k
    Overhead: 31425k
    GGC runs: 349
    Pre-IPA-Garbage: 50305k
    Pre-IPA-Leak: 49392k
    Pre-IPA-Overhead: 7223k
    Post-IPA-Garbage: 50305k
    Post-IPA-Leak: 49392k
    Post-IPA-Overhead: 7223k

comparing Gerald's testcase PR8361 compilation at -O0 level:
  Overall memory allocated via mmap and sbrk increased from 137208k to 147428k, overall 7.45%
  Peak amount of GGC memory allocated before garbage collecting increased from 79974k to 82001k, overall 2.53%
  Peak amount of GGC memory still allocated after garbage collecting increased from 79182k to 81184k, overall 2.53%
  Amount of produced GGC garbage increased from 197831k to 203795k, overall 3.01%
    Overall memory needed: 137208k -> 147428k
    Peak memory use before GGC: 79974k -> 82001k
    Peak memory use after GGC: 79182k -> 81184k
    Maximum of released memory in single GGC run: 14878k -> 14743k
    Garbage: 197831k -> 203795k
    Leak: 47687k -> 47678k
    Overhead: 24133k -> 25126k
    GGC runs: 424 -> 418
  Amount of produced pre-ipa-GGC garbage increased from 107619k to 107843k, overall 0.21%
  Amount of memory referenced pre-ipa increased from 68617k to 86264k, overall 25.72%
    Pre-IPA-Garbage: 107619k -> 107843k
    Pre-IPA-Leak: 68617k -> 86264k
    Pre-IPA-Overhead: 11898k -> 13169k
  Amount of produced post-ipa-GGC garbage increased from 107619k to 107843k, overall 0.21%
  Amount of memory referenced post-ipa increased from 68617k to 86264k, overall 25.72%
    Post-IPA-Garbage: 107619k -> 107843k
    Post-IPA-Leak: 68617k -> 86264k
    Post-IPA-Overhead: 11898k -> 13169k

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
  Overall memory allocated via mmap and sbrk increased from 155448k to 165124k, overall 6.22%
  Peak amount of GGC memory allocated before garbage collecting increased from 94258k to 95760k, overall 1.59%
  Peak amount of GGC memory still allocated after garbage collecting increased from 93325k to 94810k, overall 1.59%
  Amount of produced GGC garbage increased from 203504k to 209503k, overall 2.95%
    Overall memory needed: 155448k -> 165124k
    Peak memory use before GGC: 94258k -> 95760k
    Peak memory use after GGC: 93325k -> 94810k
    Maximum of released memory in single GGC run: 15678k -> 14943k
    Garbage: 203504k -> 209503k
    Leak: 74286k -> 74269k
    Overhead: 30824k -> 31811k
    GGC runs: 391 -> 387
  Amount of produced pre-ipa-GGC garbage increased from 108258k to 108483k, overall 0.21%
  Amount of memory referenced pre-ipa increased from 85186k to 102833k, overall 20.72%
    Pre-IPA-Garbage: 108258k -> 108483k
    Pre-IPA-Leak: 85186k -> 102833k
    Pre-IPA-Overhead: 15436k -> 16708k
  Amount of produced post-ipa-GGC garbage increased from 108258k to 108483k, overall 0.21%
  Amount of memory referenced post-ipa increased from 85186k to 102833k, overall 20.72%
    Post-IPA-Garbage: 108258k -> 108483k
    Post-IPA-Leak: 85186k -> 102833k
    Post-IPA-Overhead: 15436k -> 16708k

comparing Gerald's testcase PR8361 compilation at -O1 level:
    Overall memory needed: 108519k -> 108516k
    Peak memory use before GGC: 79066k
    Peak memory use after GGC: 78223k
    Maximum of released memory in single GGC run: 14459k
    Garbage: 283151k
    Leak: 44476k
    Overhead: 27890k
    GGC runs: 513
    Pre-IPA-Garbage: 149633k
    Pre-IPA-Leak: 82295k
    Pre-IPA-Overhead: 16420k
    Post-IPA-Garbage: 149633k
    Post-IPA-Leak: 82295k
    Post-IPA-Overhead: 16420k

comparing Gerald's testcase PR8361 compilation at -O2 level:
    Overall memory needed: 110151k -> 110112k
    Peak memory use before GGC: 79357k
    Peak memory use after GGC: 78571k
    Maximum of released memory in single GGC run: 14426k
    Garbage: 334915k
    Leak: 44584k
    Overhead: 32756k
    GGC runs: 581
    Pre-IPA-Garbage: 151234k
    Pre-IPA-Leak: 82160k
    Pre-IPA-Overhead: 16555k
    Post-IPA-Garbage: 151234k
    Post-IPA-Leak: 82160k
    Post-IPA-Overhead: 16555k

comparing Gerald's testcase PR8361 compilation at -O3 level:
    Overall memory needed: 117779k -> 117780k
    Peak memory use before GGC: 80352k
    Peak memory use after GGC: 79547k
    Maximum of released memory in single GGC run: 14782k
    Garbage: 363516k
    Leak: 44958k
    Overhead: 34976k
    GGC runs: 602
    Pre-IPA-Garbage: 153862k
    Pre-IPA-Leak: 82425k
    Pre-IPA-Overhead: 16792k
    Post-IPA-Garbage: 153862k
    Post-IPA-Leak: 82425k
    Post-IPA-Overhead: 16792k

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
  Amount of produced GGC garbage increased from 178404k to 181084k, overall 1.50%
    Overall memory needed: 377310k -> 377361k
    Peak memory use before GGC: 100918k -> 100794k
    Peak memory use after GGC: 56571k -> 56447k
    Maximum of released memory in single GGC run: 50583k
    Garbage: 178404k -> 181084k
    Leak: 6287k -> 6163k
    Overhead: 30426k -> 30560k
    GGC runs: 94 -> 97
  Amount of produced pre-ipa-GGC garbage increased from 12065k to 12450k, overall 3.18%
  Amount of memory referenced pre-ipa increased from 16461k to 21670k, overall 31.64%
    Pre-IPA-Garbage: 12065k -> 12450k
    Pre-IPA-Leak: 16461k -> 21670k
    Pre-IPA-Overhead: 1540k -> 1763k
  Amount of produced post-ipa-GGC garbage increased from 12065k to 12450k, overall 3.18%
  Amount of memory referenced post-ipa increased from 16461k to 21670k, overall 31.64%
    Post-IPA-Garbage: 12065k -> 12450k
    Post-IPA-Leak: 16461k -> 21670k
    Post-IPA-Overhead: 1540k -> 1763k

comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
  Amount of produced GGC garbage increased from 178523k to 181202k, overall 1.50%
    Overall memory needed: 378538k -> 378161k
    Peak memory use before GGC: 101617k -> 101493k
    Peak memory use after GGC: 57270k -> 57146k
    Maximum of released memory in single GGC run: 50583k
    Garbage: 178523k -> 181202k
    Leak: 8332k -> 8208k
    Overhead: 31011k -> 31145k
    GGC runs: 103 -> 106
  Amount of produced pre-ipa-GGC garbage increased from 12073k to 12457k, overall 3.18%
  Amount of memory referenced pre-ipa increased from 16710k to 21919k, overall 31.17%
    Pre-IPA-Garbage: 12073k -> 12457k
    Pre-IPA-Leak: 16710k -> 21919k
    Pre-IPA-Overhead: 1594k -> 1818k
  Amount of produced post-ipa-GGC garbage increased from 12073k to 12457k, overall 3.18%
  Amount of memory referenced post-ipa increased from 16710k to 21919k, overall 31.17%
    Post-IPA-Garbage: 12073k -> 12457k
    Post-IPA-Leak: 16710k -> 21919k
    Post-IPA-Overhead: 1594k -> 1818k

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
    Overall memory needed: 383608k -> 383603k
    Peak memory use before GGC: 75664k
    Peak memory use after GGC: 67608k
    Maximum of released memory in single GGC run: 34790k
    Garbage: 243330k
    Leak: 7907k
    Overhead: 30630k
    GGC runs: 103
    Pre-IPA-Garbage: 49523k
    Pre-IPA-Leak: 63645k
    Pre-IPA-Overhead: 6443k
    Post-IPA-Garbage: 49523k
    Post-IPA-Leak: 63645k
    Post-IPA-Overhead: 6443k

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
    Overall memory needed: 320464k -> 322039k
    Peak memory use before GGC: 75664k
    Peak memory use after GGC: 67608k
    Maximum of released memory in single GGC run: 32489k
    Garbage: 254887k
    Leak: 8070k
    Overhead: 33405k
    GGC runs: 115
    Pre-IPA-Garbage: 107518k
    Pre-IPA-Leak: 75534k
    Pre-IPA-Overhead: 10761k
    Post-IPA-Garbage: 107518k
    Post-IPA-Leak: 75534k
    Post-IPA-Overhead: 10761k

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
    Overall memory needed: 1068292k -> 1068291k
    Peak memory use before GGC: 142490k
    Peak memory use after GGC: 129145k
    Maximum of released memory in single GGC run: 59680k
    Garbage: 356335k
    Leak: 11049k
    Overhead: 38047k
    GGC runs: 101
    Pre-IPA-Garbage: 107518k
    Pre-IPA-Leak: 75534k
    Pre-IPA-Overhead: 10761k
    Post-IPA-Garbage: 107518k
    Post-IPA-Leak: 75534k
    Post-IPA-Overhead: 10761k

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog	2008-07-20 11:10:34.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog	2008-07-20 18:40:50.000000000 +0000
@@ -1,3 +1,46 @@
+2008-07-20  Andrew Pinski  <andrew_pinski@playstation.sony.com>
+
+	PR tree-opt/36879
+	* tree-switch-conversion.c (build_one_array): Call
+	varpool_mark_needed_node and varpool_finalize_decl 
+	instead of assemble_variable.
+
+2008-07-19  Jan Hubicka  <jh@suse.cz>
+
+	* cgraph.c (cgraph_add_new_function): Do early local passes.
+	* tree-nrv.c (gate_pass_return_slot): New gate.
+	(pass_nrv): Add the gate.
+	* tree-ssa-coalese.c (hash_ssa_name_by_var, eq_ssa_name_by_var): New
+	functions.
+	(coalesce_ssa_name): Coalesce SSA names.
+	* tree-ssa-live.c (remove_unused_locals): Be more conservative when
+	not optimizing so unused user vars remains visible.
+	* common.opt (flag_tree_ter): Always enable by default.
+	* tree-ssa-ter.c: Include flags.h
+	(is_replaceable_p): Check that locations match; when aliasing is missing
+	be conservative about loads.
+	* tree-optimize.c (gate_init_datastructures): Remove.
+	(pass_init_datastructures): New.
+	* passes.c: Reorder passes so we always go into SSA.
+
+2008-07-19  Jan Hubicka  <jh@suse.cz>
+
+	* doc/extend.texi (flatten attribute): Remove note about unit-at-a-time
+	* doc/invoke.texi (--combine): Likewise.
+	(-finline-functions-called-once): Update levels when enabled.
+	(-funit-at-a-time): Document new behaviour.
+	(-ftoplevel-reorder): Document that it is enabled -O0 and imply
+	-fno-section-anchors when disabled explicitly.
+	(inline params): They are not ignored now.
+	(precompiled headers): Remove unit-at-a-time as being incompatible.
+	* opts.c (decode_options): Handle unit-at-a-time as alias;
+	imply -fno-section-anchors when toplevel reorder is disabled
+	explicitly.
+	* common.opt (ftoplevel-reorder): Set default value to 2.
+	(funit-at-a-time): Set default value to 1.
+	* config/rs6000/rs6000.c (optimization_options): Set section anchors
+	to 2.
+
 2008-07-19  Jan Hubicka  <jh@suse.cz>
 
 	* builtins.c (expand_builtin_int_roundingfn,


The results can be reproduced by building a compiler with

--enable-gather-detailed-mem-stats targetting x86-64

and compiling preprocessed combine.c or testcase from PR8632 with:

-fmem-report --param=ggc-min-heapsize=1024 --param=ggc-min-expand=1 -Ox -Q

The memory consumption summary appears in the dump after detailed listing
of the places they are allocated in.  Peak memory consumption is actually
computed by looking for maximal value in {GC XXXX -> YYYY} report.

Your testing script.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]