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!


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:
    Overall memory needed: 8801k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1437k
    Maximum of released memory in single GGC run: 85k
    Garbage: 218k
    Leak: 1537k
    Overhead: 187k
    GGC runs: 4
    Pre-IPA-Garbage: 210k
    Pre-IPA-Leak: 1539k
    Pre-IPA-Overhead: 186k
    Post-IPA-Garbage: 210k
    Post-IPA-Leak: 1539k
    Post-IPA-Overhead: 186k

comparing empty function compilation at -O0 -g level:
    Overall memory needed: 8825k
    Peak memory use before GGC: 1516k
    Peak memory use after GGC: 1464k
    Maximum of released memory in single GGC run: 87k
    Garbage: 219k
    Leak: 1570k
    Overhead: 192k
    GGC runs: 4
    Pre-IPA-Garbage: 210k
    Pre-IPA-Leak: 1539k
    Pre-IPA-Overhead: 186k
    Post-IPA-Garbage: 210k
    Post-IPA-Leak: 1539k
    Post-IPA-Overhead: 186k

comparing empty function compilation at -O1 level:
  Amount of produced GGC garbage increased from 220k to 223k, overall 1.09%
    Overall memory needed: 8909k -> 8929k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1437k
    Maximum of released memory in single GGC run: 87k -> 90k
    Garbage: 220k -> 223k
    Leak: 1537k
    Overhead: 188k -> 188k
    GGC runs: 4
  Amount of produced pre-ipa-GGC garbage increased from 210k to 212k, overall 1.12%
    Pre-IPA-Garbage: 210k -> 212k
    Pre-IPA-Leak: 1540k -> 1540k
    Pre-IPA-Overhead: 186k -> 186k
  Amount of produced post-ipa-GGC garbage increased from 210k to 212k, overall 1.12%
    Post-IPA-Garbage: 210k -> 212k
    Post-IPA-Leak: 1540k -> 1540k
    Post-IPA-Overhead: 186k -> 186k

comparing empty function compilation at -O2 level:
  Amount of produced GGC garbage increased from 226k to 228k, overall 1.06%
    Overall memory needed: 8925k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1437k
    Maximum of released memory in single GGC run: 92k -> 90k
    Garbage: 226k -> 228k
    Leak: 1537k
    Overhead: 189k -> 189k
    GGC runs: 4 -> 5
  Amount of produced pre-ipa-GGC garbage increased from 210k to 212k, overall 1.12%
    Pre-IPA-Garbage: 210k -> 212k
    Pre-IPA-Leak: 1540k -> 1540k
    Pre-IPA-Overhead: 186k -> 186k
  Amount of produced post-ipa-GGC garbage increased from 210k to 212k, overall 1.12%
    Post-IPA-Garbage: 210k -> 212k
    Post-IPA-Leak: 1540k -> 1540k
    Post-IPA-Overhead: 186k -> 186k

comparing empty function compilation at -O3 level:
  Amount of produced GGC garbage increased from 226k to 228k, overall 1.06%
    Overall memory needed: 8933k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1437k
    Maximum of released memory in single GGC run: 92k -> 90k
    Garbage: 226k -> 228k
    Leak: 1537k
    Overhead: 189k -> 189k
    GGC runs: 4 -> 5
  Amount of produced pre-ipa-GGC garbage increased from 210k to 212k, overall 1.12%
    Pre-IPA-Garbage: 210k -> 212k
    Pre-IPA-Leak: 1540k -> 1540k
    Pre-IPA-Overhead: 186k -> 186k
  Amount of produced post-ipa-GGC garbage increased from 210k to 212k, overall 1.12%
    Post-IPA-Garbage: 210k -> 212k
    Post-IPA-Leak: 1540k -> 1540k
    Post-IPA-Overhead: 186k -> 186k

comparing combine.c compilation at -O0 level:
    Overall memory needed: 31445k
    Peak memory use before GGC: 17469k
    Peak memory use after GGC: 17020k
    Maximum of released memory in single GGC run: 1910k
    Garbage: 37903k
    Leak: 7157k
    Overhead: 5493k -> 5493k
    GGC runs: 330
    Pre-IPA-Garbage: 12540k
    Pre-IPA-Leak: 18404k
    Pre-IPA-Overhead: 2506k
    Post-IPA-Garbage: 12540k
    Post-IPA-Leak: 18404k
    Post-IPA-Overhead: 2506k

comparing combine.c compilation at -O0 -g level:
    Overall memory needed: 33369k -> 33401k
    Peak memory use before GGC: 19377k
    Peak memory use after GGC: 18859k
    Maximum of released memory in single GGC run: 1920k
    Garbage: 38119k
    Leak: 10443k
    Overhead: 6305k
    GGC runs: 315
    Pre-IPA-Garbage: 12559k
    Pre-IPA-Leak: 20652k
    Pre-IPA-Overhead: 2988k
    Post-IPA-Garbage: 12559k
    Post-IPA-Leak: 20652k
    Post-IPA-Overhead: 2988k

comparing combine.c compilation at -O1 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 16476k to 16555k, overall 0.48%
  Peak amount of GGC memory still allocated after garbage collecting increased from 16310k to 16383k, overall 0.45%
  Amount of produced GGC garbage increased from 45345k to 45806k, overall 1.02%
    Overall memory needed: 31985k -> 31913k
    Peak memory use before GGC: 16476k -> 16555k
    Peak memory use after GGC: 16310k -> 16383k
    Maximum of released memory in single GGC run: 1378k
    Garbage: 45345k -> 45806k
    Leak: 7158k
    Overhead: 6391k -> 6443k
    GGC runs: 387 -> 388
  Amount of produced pre-ipa-GGC garbage increased from 12959k to 13405k, overall 3.44%
  Amount of memory referenced pre-ipa increased from 17622k to 17704k, overall 0.46%
    Pre-IPA-Garbage: 12959k -> 13405k
    Pre-IPA-Leak: 17622k -> 17704k
    Pre-IPA-Overhead: 2502k -> 2554k
  Amount of produced post-ipa-GGC garbage increased from 12959k to 13405k, overall 3.44%
  Amount of memory referenced post-ipa increased from 17622k to 17704k, overall 0.46%
    Post-IPA-Garbage: 12959k -> 13405k
    Post-IPA-Leak: 17622k -> 17704k
    Post-IPA-Overhead: 2502k -> 2554k

comparing combine.c compilation at -O2 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 16539k to 16628k, overall 0.54%
  Peak amount of GGC memory still allocated after garbage collecting increased from 16375k to 16454k, overall 0.48%
  Amount of produced GGC garbage increased from 56220k to 56648k, overall 0.76%
    Overall memory needed: 32977k -> 32973k
    Peak memory use before GGC: 16539k -> 16628k
    Peak memory use after GGC: 16375k -> 16454k
    Maximum of released memory in single GGC run: 1488k
    Garbage: 56220k -> 56648k
    Leak: 7191k
    Overhead: 8012k -> 8059k
    GGC runs: 441
  Amount of produced pre-ipa-GGC garbage increased from 13012k to 13435k, overall 3.25%
  Amount of memory referenced pre-ipa increased from 17645k to 17726k, overall 0.46%
    Pre-IPA-Garbage: 13012k -> 13435k
    Pre-IPA-Leak: 17645k -> 17726k
    Pre-IPA-Overhead: 2508k -> 2557k
  Amount of produced post-ipa-GGC garbage increased from 13012k to 13435k, overall 3.25%
  Amount of memory referenced post-ipa increased from 17645k to 17726k, overall 0.46%
    Post-IPA-Garbage: 13012k -> 13435k
    Post-IPA-Leak: 17645k -> 17726k
    Post-IPA-Overhead: 2508k -> 2557k

comparing combine.c compilation at -O3 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 16535k to 16574k, overall 0.24%
  Peak amount of GGC memory still allocated after garbage collecting increased from 16341k to 16409k, overall 0.42%
  Amount of produced GGC garbage increased from 72063k to 72503k, overall 0.61%
    Overall memory needed: 35133k -> 35053k
    Peak memory use before GGC: 16535k -> 16574k
    Peak memory use after GGC: 16341k -> 16409k
    Maximum of released memory in single GGC run: 1672k
    Garbage: 72063k -> 72503k
    Leak: 7221k
    Overhead: 9905k -> 9955k
    GGC runs: 493
  Amount of produced pre-ipa-GGC garbage increased from 13012k to 13435k, overall 3.25%
  Amount of memory referenced pre-ipa increased from 17645k to 17726k, overall 0.46%
    Pre-IPA-Garbage: 13012k -> 13435k
    Pre-IPA-Leak: 17645k -> 17726k
    Pre-IPA-Overhead: 2508k -> 2557k
  Amount of produced post-ipa-GGC garbage increased from 13012k to 13435k, overall 3.25%
  Amount of memory referenced post-ipa increased from 17645k to 17726k, overall 0.46%
    Post-IPA-Garbage: 13012k -> 13435k
    Post-IPA-Leak: 17645k -> 17726k
    Post-IPA-Overhead: 2508k -> 2557k

comparing insn-attrtab.c compilation at -O0 level:
    Overall memory needed: 152501k -> 152505k
    Peak memory use before GGC: 65254k
    Peak memory use after GGC: 52818k
    Maximum of released memory in single GGC run: 26250k
    Garbage: 128569k
    Leak: 9588k
    Overhead: 16692k
    GGC runs: 258
    Pre-IPA-Garbage: 40782k
    Pre-IPA-Leak: 51015k
    Pre-IPA-Overhead: 7761k
    Post-IPA-Garbage: 40782k
    Post-IPA-Leak: 51015k
    Post-IPA-Overhead: 7761k

comparing insn-attrtab.c compilation at -O0 -g level:
    Overall memory needed: 153817k -> 153849k
    Peak memory use before GGC: 66520k
    Peak memory use after GGC: 54081k
    Maximum of released memory in single GGC run: 26251k
    Garbage: 128907k
    Leak: 11220k
    Overhead: 17145k
    GGC runs: 252
    Pre-IPA-Garbage: 40791k
    Pre-IPA-Leak: 52540k
    Pre-IPA-Overhead: 8092k
    Post-IPA-Garbage: 40791k
    Post-IPA-Leak: 52540k
    Post-IPA-Overhead: 8092k

comparing insn-attrtab.c compilation at -O1 level:
  Amount of produced GGC garbage increased from 180928k to 181123k, overall 0.11%
    Overall memory needed: 154685k -> 154545k
    Peak memory use before GGC: 54960k -> 54973k
    Peak memory use after GGC: 44890k -> 44903k
    Maximum of released memory in single GGC run: 17233k
    Garbage: 180928k -> 181123k
    Leak: 9179k
    Overhead: 23407k -> 23428k
    GGC runs: 297 -> 298
  Amount of produced pre-ipa-GGC garbage increased from 45067k to 45260k, overall 0.43%
    Pre-IPA-Garbage: 45067k -> 45260k
    Pre-IPA-Leak: 45086k -> 45117k
    Pre-IPA-Overhead: 7587k -> 7608k
  Amount of produced post-ipa-GGC garbage increased from 45067k to 45260k, overall 0.43%
    Post-IPA-Garbage: 45067k -> 45260k
    Post-IPA-Leak: 45086k -> 45117k
    Post-IPA-Overhead: 7587k -> 7608k

comparing insn-attrtab.c compilation at -O2 level:
    Overall memory needed: 202257k -> 202485k
    Peak memory use before GGC: 54409k -> 54422k
    Peak memory use after GGC: 44641k -> 44653k
    Maximum of released memory in single GGC run: 18696k
    Garbage: 211478k -> 211672k
    Leak: 9193k
    Overhead: 29279k -> 29300k
    GGC runs: 330 -> 331
  Amount of produced pre-ipa-GGC garbage increased from 45129k to 45322k, overall 0.43%
    Pre-IPA-Garbage: 45129k -> 45322k
    Pre-IPA-Leak: 45093k -> 45124k
    Pre-IPA-Overhead: 7592k -> 7613k
  Amount of produced post-ipa-GGC garbage increased from 45129k to 45322k, overall 0.43%
    Post-IPA-Garbage: 45129k -> 45322k
    Post-IPA-Leak: 45093k -> 45124k
    Post-IPA-Overhead: 7592k -> 7613k

comparing insn-attrtab.c compilation at -O3 level:
    Overall memory needed: 205885k -> 205461k
    Peak memory use before GGC: 54422k -> 54434k
    Peak memory use after GGC: 44649k -> 44662k
    Maximum of released memory in single GGC run: 18680k
    Garbage: 229759k -> 229954k
    Leak: 9211k
    Overhead: 31179k -> 31200k
    GGC runs: 351 -> 352
  Amount of produced pre-ipa-GGC garbage increased from 45129k to 45322k, overall 0.43%
    Pre-IPA-Garbage: 45129k -> 45322k
    Pre-IPA-Leak: 45093k -> 45124k
    Pre-IPA-Overhead: 7592k -> 7613k
  Amount of produced post-ipa-GGC garbage increased from 45129k to 45322k, overall 0.43%
    Post-IPA-Garbage: 45129k -> 45322k
    Post-IPA-Leak: 45093k -> 45124k
    Post-IPA-Overhead: 7592k -> 7613k

comparing Gerald's testcase PR8361 compilation at -O0 level:
    Overall memory needed: 146201k -> 146341k
    Peak memory use before GGC: 81786k
    Peak memory use after GGC: 80976k
    Maximum of released memory in single GGC run: 13629k
    Garbage: 193642k -> 193642k
    Leak: 55468k
    Overhead: 28789k
    GGC runs: 439
    Pre-IPA-Garbage: 105771k
    Pre-IPA-Leak: 84581k
    Pre-IPA-Overhead: 15541k
    Post-IPA-Garbage: 105771k
    Post-IPA-Leak: 84581k
    Post-IPA-Overhead: 15541k

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
    Overall memory needed: 164069k -> 164021k
    Peak memory use before GGC: 95912k
    Peak memory use after GGC: 94960k
    Maximum of released memory in single GGC run: 13880k
    Garbage: 198964k
    Leak: 82559k
    Overhead: 35351k -> 35352k
    GGC runs: 410
    Pre-IPA-Garbage: 106356k
    Pre-IPA-Leak: 101101k
    Pre-IPA-Overhead: 19047k
    Post-IPA-Garbage: 106356k
    Post-IPA-Leak: 101101k
    Post-IPA-Overhead: 19047k

comparing Gerald's testcase PR8361 compilation at -O1 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 81741k to 81962k, overall 0.27%
  Peak amount of GGC memory still allocated after garbage collecting increased from 80929k to 81128k, overall 0.25%
  Amount of produced GGC garbage increased from 255383k to 263586k, overall 3.21%
    Overall memory needed: 107441k -> 107789k
    Peak memory use before GGC: 81741k -> 81962k
    Peak memory use after GGC: 80929k -> 81128k
    Maximum of released memory in single GGC run: 13498k -> 13770k
    Garbage: 255383k -> 263586k
    Leak: 52267k -> 52259k
    Overhead: 30243k -> 30809k
    GGC runs: 510 -> 522
  Amount of produced pre-ipa-GGC garbage increased from 145188k to 153342k, overall 5.62%
  Amount of memory referenced pre-ipa increased from 85972k to 86146k, overall 0.20%
    Pre-IPA-Garbage: 145188k -> 153342k
    Pre-IPA-Leak: 85972k -> 86146k
    Pre-IPA-Overhead: 18513k -> 19079k
  Amount of produced post-ipa-GGC garbage increased from 145188k to 153342k, overall 5.62%
  Amount of memory referenced post-ipa increased from 85972k to 86146k, overall 0.20%
    Post-IPA-Garbage: 145188k -> 153342k
    Post-IPA-Leak: 85972k -> 86146k
    Post-IPA-Overhead: 18513k -> 19079k

comparing Gerald's testcase PR8361 compilation at -O2 level:
  Peak amount of GGC memory still allocated after garbage collecting increased from 80084k to 80227k, overall 0.18%
  Amount of produced GGC garbage increased from 293517k to 301890k, overall 2.85%
    Overall memory needed: 106849k -> 107057k
    Peak memory use before GGC: 81660k -> 81213k
    Peak memory use after GGC: 80084k -> 80227k
    Maximum of released memory in single GGC run: 13522k -> 13774k
    Garbage: 293517k -> 301890k
    Leak: 52335k -> 52342k
    Overhead: 35245k -> 35832k
    GGC runs: 557 -> 569
  Amount of produced pre-ipa-GGC garbage increased from 148349k to 156623k, overall 5.58%
  Amount of memory referenced pre-ipa increased from 85063k to 85230k, overall 0.20%
    Pre-IPA-Garbage: 148349k -> 156623k
    Pre-IPA-Leak: 85063k -> 85230k
    Pre-IPA-Overhead: 18724k -> 19306k
  Amount of produced post-ipa-GGC garbage increased from 148349k to 156623k, overall 5.58%
  Amount of memory referenced post-ipa increased from 85063k to 85230k, overall 0.20%
    Post-IPA-Garbage: 148349k -> 156623k
    Post-IPA-Leak: 85063k -> 85230k
    Post-IPA-Overhead: 18724k -> 19306k

comparing Gerald's testcase PR8361 compilation at -O3 level:
  Peak amount of GGC memory still allocated after garbage collecting increased from 80200k to 80352k, overall 0.19%
  Amount of produced GGC garbage increased from 325935k to 334304k, overall 2.57%
    Overall memory needed: 111401k -> 111817k
    Peak memory use before GGC: 82121k -> 81673k
    Peak memory use after GGC: 80200k -> 80352k
    Maximum of released memory in single GGC run: 13522k -> 13774k
    Garbage: 325935k -> 334304k
    Leak: 52370k -> 52370k
    Overhead: 39050k -> 39637k
    GGC runs: 596 -> 607
  Amount of produced pre-ipa-GGC garbage increased from 148349k to 156623k, overall 5.58%
  Amount of memory referenced pre-ipa increased from 85068k to 85234k, overall 0.20%
    Pre-IPA-Garbage: 148349k -> 156623k
    Pre-IPA-Leak: 85068k -> 85234k
    Pre-IPA-Overhead: 18725k -> 19306k
  Amount of produced post-ipa-GGC garbage increased from 148349k to 156623k, overall 5.58%
  Amount of memory referenced post-ipa increased from 85068k to 85234k, overall 0.20%
    Post-IPA-Garbage: 148349k -> 156623k
    Post-IPA-Leak: 85068k -> 85234k
    Post-IPA-Overhead: 18725k -> 19306k

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
    Overall memory needed: 358785k -> 358781k
    Peak memory use before GGC: 78173k
    Peak memory use after GGC: 49107k
    Maximum of released memory in single GGC run: 37057k
    Garbage: 140190k
    Leak: 7711k
    Overhead: 24961k
    GGC runs: 86
    Pre-IPA-Garbage: 12171k
    Pre-IPA-Leak: 18627k
    Pre-IPA-Overhead: 2403k
    Post-IPA-Garbage: 12171k
    Post-IPA-Leak: 18627k
    Post-IPA-Overhead: 2403k

comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
    Overall memory needed: 359557k -> 359441k
    Peak memory use before GGC: 78856k
    Peak memory use after GGC: 49791k
    Maximum of released memory in single GGC run: 37041k
    Garbage: 140255k
    Leak: 9707k
    Overhead: 25529k
    GGC runs: 94
    Pre-IPA-Garbage: 12173k
    Pre-IPA-Leak: 18873k
    Pre-IPA-Overhead: 2457k
    Post-IPA-Garbage: 12173k
    Post-IPA-Leak: 18873k
    Post-IPA-Overhead: 2457k

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 74131k to 75811k, overall 2.27%
  Amount of produced GGC garbage increased from 216024k to 217894k, overall 0.87%
    Overall memory needed: 208393k -> 210297k
    Peak memory use before GGC: 74131k -> 75811k
    Peak memory use after GGC: 69415k -> 69462k
    Maximum of released memory in single GGC run: 35390k
    Garbage: 216024k -> 217894k
    Leak: 9295k
    Overhead: 32789k -> 32942k
    GGC runs: 95
  Amount of produced pre-ipa-GGC garbage increased from 39335k to 41119k, overall 4.53%
  Amount of memory referenced pre-ipa increased from 63718k to 63805k, overall 0.14%
    Pre-IPA-Garbage: 39335k -> 41119k
    Pre-IPA-Leak: 63718k -> 63805k
    Pre-IPA-Overhead: 6988k -> 7142k
  Amount of produced post-ipa-GGC garbage increased from 39335k to 41119k, overall 4.53%
  Amount of memory referenced post-ipa increased from 63718k to 63805k, overall 0.14%
    Post-IPA-Garbage: 39335k -> 41119k
    Post-IPA-Leak: 63718k -> 63805k
    Post-IPA-Overhead: 6988k -> 7142k

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 74132k to 75811k, overall 2.26%
  Amount of produced GGC garbage increased from 255773k to 257643k, overall 0.73%
    Overall memory needed: 528025k -> 535237k
    Peak memory use before GGC: 74132k -> 75811k
    Peak memory use after GGC: 69415k -> 69463k
    Maximum of released memory in single GGC run: 37541k
    Garbage: 255773k -> 257643k
    Leak: 9045k
    Overhead: 38347k -> 38501k
    GGC runs: 106
  Amount of produced pre-ipa-GGC garbage increased from 89677k to 90152k, overall 0.53%
    Pre-IPA-Garbage: 89677k -> 90152k
    Pre-IPA-Leak: 80311k -> 80313k
    Pre-IPA-Overhead: 11128k -> 11168k
  Amount of produced post-ipa-GGC garbage increased from 89677k to 90152k, overall 0.53%
    Post-IPA-Garbage: 89677k -> 90152k
    Post-IPA-Leak: 80311k -> 80313k
    Post-IPA-Overhead: 11128k -> 11168k

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
  Peak amount of GGC memory allocated before garbage collecting increased from 134702k to 135102k, overall 0.30%
  Amount of produced GGC garbage increased from 340296k to 340773k, overall 0.14%
    Overall memory needed: 1235241k -> 1235213k
    Peak memory use before GGC: 134702k -> 135102k
    Peak memory use after GGC: 126430k -> 126444k
    Maximum of released memory in single GGC run: 54316k -> 54329k
    Garbage: 340296k -> 340773k
    Leak: 10362k
    Overhead: 43454k -> 43494k
    GGC runs: 106
  Amount of produced pre-ipa-GGC garbage increased from 89677k to 90152k, overall 0.53%
    Pre-IPA-Garbage: 89677k -> 90152k
    Pre-IPA-Leak: 80311k -> 80313k
    Pre-IPA-Overhead: 11128k -> 11168k
  Amount of produced post-ipa-GGC garbage increased from 89677k to 90152k, overall 0.53%
    Post-IPA-Garbage: 89677k -> 90152k
    Post-IPA-Leak: 80311k -> 80313k
    Post-IPA-Overhead: 11128k -> 11168k

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-haydn-memory/x86_64/mem-result/ChangeLog	2009-05-25 00:04:45.000000000 +0000
+++ /usr/src/SpecTests/sandbox-haydn-memory/gcc/gcc/ChangeLog	2009-05-25 14:20:03.000000000 +0000
@@ -1,3 +1,33 @@
+2009-05-25  Richard Guenther  <rguenther@suse.de>
+
+	* tree-ssa-alias.h (dump_points_to_solution): Declare.
+	* tree-inline.c (expand_call_inline): Reset the escaped and
+	callused solutions.
+	* tree-ssa-structalias.c (pass_build_ealias): New.
+	* tree-pass.h (pass_build_ealias): Declare.
+	* passes.c (init_optimization_passes): Add PTA during 
+	early optimizations.
+	* tree-ssa-alias.c (dump_alias_info): Dump the ESCAPED
+	and CALLUSED solutions.
+	(dump_points_to_solution): New function, split out from ...
+	(dump_points_to_info_for): ... here.
+	* tree-parloops.c (parallelize_loops): Reset the escaped and
+	callused solutions.
+
+2009-05-25  Rainer Orth  <ro@TechFak.Uni-Bielefeld.DE>
+
+	PR bootstrap/40027
+	* config/i386/i386.c (USE_HIDDEN_LINKONCE): Only define if missing.
+	* config/i386/sol2.h [!TARGET_GNU_LD] (USE_HIDDEN_LINKONCE): Define.
+
+2009-05-25  Ira Rosen  <irar@il.ibm.com>
+
+	PR tree-optimization/40238
+	* tree-vect-stmts.c (vect_init_vector): Insert initialization
+	statements after basic block's labels.
+	* tree-vect-slp.c (vect_slp_transform_bb): Call destroy_bb_vec_info() 
+	to free the allocated memory.
+
 2009-05-24  Kaz Kojima  <kkojima@gcc.gnu.org>
 
 	* gcc/config/sh/sh.c (sh_set_return_address): Mark store of


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]