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: 8150k
    Peak memory use before GGC: 1102k
    Peak memory use after GGC: 1001k
    Maximum of released memory in single GGC run: 129k
    Garbage: 235k
    Leak: 959k
    Overhead: 80k
    GGC runs: 2
Testing has produced no results
Testing has produced no results

comparing empty function compilation at -O0 -g level:
    Overall memory needed: 8166k
    Peak memory use before GGC: 1129k
    Peak memory use after GGC: 1034k
    Maximum of released memory in single GGC run: 126k
    Garbage: 237k
    Leak: 990k
    Overhead: 84k
    GGC runs: 4
Testing has produced no results
Testing has produced no results

comparing empty function compilation at -O1 level:
    Overall memory needed: 8206k
    Peak memory use before GGC: 1102k
    Peak memory use after GGC: 1001k
    Maximum of released memory in single GGC run: 131k
    Garbage: 237k
    Leak: 959k
    Overhead: 81k
    GGC runs: 2
    Pre-IPA-Garbage: 225k
    Pre-IPA-Leak: 962k
    Pre-IPA-Overhead: 79k
    Post-IPA-Garbage: 225k
    Post-IPA-Leak: 962k
    Post-IPA-Overhead: 79k

comparing empty function compilation at -O2 level:
    Overall memory needed: 8226k
    Peak memory use before GGC: 1102k
    Peak memory use after GGC: 1002k
    Maximum of released memory in single GGC run: 134k
    Garbage: 241k
    Leak: 960k
    Overhead: 81k
    GGC runs: 2
    Pre-IPA-Garbage: 225k
    Pre-IPA-Leak: 963k
    Pre-IPA-Overhead: 79k
    Post-IPA-Garbage: 225k
    Post-IPA-Leak: 963k
    Post-IPA-Overhead: 79k

comparing empty function compilation at -O3 level:
    Overall memory needed: 8226k
    Peak memory use before GGC: 1102k
    Peak memory use after GGC: 1002k
    Maximum of released memory in single GGC run: 134k
    Garbage: 241k
    Leak: 960k
    Overhead: 81k
    GGC runs: 2
    Pre-IPA-Garbage: 225k
    Pre-IPA-Leak: 963k
    Pre-IPA-Overhead: 79k
    Post-IPA-Garbage: 225k
    Post-IPA-Leak: 963k
    Post-IPA-Overhead: 79k

comparing combine.c compilation at -O0 level:
    Overall memory needed: 22634k
    Peak memory use before GGC: 7799k
    Peak memory use after GGC: 7175k
    Maximum of released memory in single GGC run: 1546k
    Garbage: 37767k
    Leak: 5509k
    Overhead: 4605k
    GGC runs: 372
Testing has produced no results
Testing has produced no results

comparing combine.c compilation at -O0 -g level:
    Overall memory needed: 24510k
    Peak memory use before GGC: 9499k
    Peak memory use after GGC: 8762k
    Maximum of released memory in single GGC run: 1831k
    Garbage: 38122k
    Leak: 7914k
    Overhead: 4997k
    GGC runs: 346
Testing has produced no results
Testing has produced no results

comparing combine.c compilation at -O1 level:
    Overall memory needed: 32870k -> 32866k
    Peak memory use before GGC: 16267k
    Peak memory use after GGC: 16084k
    Maximum of released memory in single GGC run: 1375k
    Garbage: 51557k
    Leak: 5657k
    Overhead: 5802k
    GGC runs: 440
    Pre-IPA-Garbage: 13924k
    Pre-IPA-Leak: 17105k
    Pre-IPA-Overhead: 2131k
    Post-IPA-Garbage: 13924k
    Post-IPA-Leak: 17105k
    Post-IPA-Overhead: 2131k

comparing combine.c compilation at -O2 level:
  Amount of produced GGC garbage increased from 70951k to 71481k, overall 0.75%
    Overall memory needed: 34670k -> 34674k
    Peak memory use before GGC: 16367k -> 16364k
    Peak memory use after GGC: 16201k
    Maximum of released memory in single GGC run: 1305k
    Garbage: 70951k -> 71481k
    Leak: 5987k
    Overhead: 8055k -> 8156k
    GGC runs: 510 -> 512
    Pre-IPA-Garbage: 14078k
    Pre-IPA-Leak: 17166k
    Pre-IPA-Overhead: 2145k
    Post-IPA-Garbage: 14078k
    Post-IPA-Leak: 17166k
    Post-IPA-Overhead: 2145k

comparing combine.c compilation at -O3 level:
  Amount of produced GGC garbage increased from 87983k to 88531k, overall 0.62%
    Overall memory needed: 37390k -> 37570k
    Peak memory use before GGC: 16499k
    Peak memory use after GGC: 16206k
    Maximum of released memory in single GGC run: 2006k
    Garbage: 87983k -> 88531k
    Leak: 6050k -> 6042k
    Overhead: 9993k -> 10096k
    GGC runs: 545 -> 547
    Pre-IPA-Garbage: 14080k
    Pre-IPA-Leak: 17178k
    Pre-IPA-Overhead: 2146k
    Post-IPA-Garbage: 14080k
    Post-IPA-Leak: 17178k
    Post-IPA-Overhead: 2146k

comparing insn-attrtab.c compilation at -O0 level:
    Overall memory needed: 137442k -> 137438k
    Peak memory use before GGC: 56968k
    Peak memory use after GGC: 31393k
    Maximum of released memory in single GGC run: 32968k
    Garbage: 128704k
    Leak: 8125k
    Overhead: 14274k
    GGC runs: 293
Testing has produced no results
Testing has produced no results

comparing insn-attrtab.c compilation at -O0 -g level:
    Overall memory needed: 138594k
    Peak memory use before GGC: 58027k
    Peak memory use after GGC: 32452k
    Maximum of released memory in single GGC run: 32968k
    Garbage: 128694k
    Leak: 9812k
    Overhead: 14512k
    GGC runs: 289
Testing has produced no results
Testing has produced no results

comparing insn-attrtab.c compilation at -O1 level:
    Overall memory needed: 142870k -> 142866k
    Peak memory use before GGC: 56190k
    Peak memory use after GGC: 49970k
    Maximum of released memory in single GGC run: 23960k
    Garbage: 205125k
    Leak: 9262k
    Overhead: 24695k
    GGC runs: 315
    Pre-IPA-Garbage: 50369k
    Pre-IPA-Leak: 49664k
    Pre-IPA-Overhead: 7545k
    Post-IPA-Garbage: 50369k
    Post-IPA-Leak: 49664k
    Post-IPA-Overhead: 7545k

comparing insn-attrtab.c compilation at -O2 level:
  Amount of produced GGC garbage increased from 245673k to 246848k, overall 0.48%
    Overall memory needed: 184170k -> 184358k
    Peak memory use before GGC: 56811k
    Peak memory use after GGC: 51536k
    Maximum of released memory in single GGC run: 22857k -> 22858k
    Garbage: 245673k -> 246848k
    Leak: 10341k
    Overhead: 30329k -> 30605k
    GGC runs: 347
    Pre-IPA-Garbage: 50441k
    Pre-IPA-Leak: 49667k
    Pre-IPA-Overhead: 7553k
    Post-IPA-Garbage: 50441k
    Post-IPA-Leak: 49667k
    Post-IPA-Overhead: 7553k

comparing insn-attrtab.c compilation at -O3 level:
  Amount of produced GGC garbage increased from 269382k to 270550k, overall 0.43%
    Overall memory needed: 190058k -> 189778k
    Peak memory use before GGC: 66353k
    Peak memory use after GGC: 62274k
    Maximum of released memory in single GGC run: 23354k -> 23355k
    Garbage: 269382k -> 270550k
    Leak: 10379k
    Overhead: 32117k -> 32391k
    GGC runs: 346 -> 347
    Pre-IPA-Garbage: 50441k
    Pre-IPA-Leak: 49667k
    Pre-IPA-Overhead: 7553k
    Post-IPA-Garbage: 50441k
    Post-IPA-Leak: 49667k
    Post-IPA-Overhead: 7553k

comparing Gerald's testcase PR8361 compilation at -O0 level:
    Overall memory needed: 147667k -> 147635k
    Peak memory use before GGC: 83441k
    Peak memory use after GGC: 82614k
    Maximum of released memory in single GGC run: 16522k
    Garbage: 198620k
    Leak: 47798k
    Overhead: 23753k
    GGC runs: 417
    Pre-IPA-Garbage: 109267k
    Pre-IPA-Leak: 70553k
    Pre-IPA-Overhead: 12198k
    Post-IPA-Garbage: 109267k
    Post-IPA-Leak: 70553k
    Post-IPA-Overhead: 12198k

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
    Overall memory needed: 166695k
    Peak memory use before GGC: 93664k
    Peak memory use after GGC: 92737k
    Maximum of released memory in single GGC run: 16605k
    Garbage: 204260k
    Leak: 65692k
    Overhead: 26796k
    GGC runs: 393
    Pre-IPA-Garbage: 109911k
    Pre-IPA-Leak: 81801k
    Pre-IPA-Overhead: 13755k
    Post-IPA-Garbage: 109911k
    Post-IPA-Leak: 81801k
    Post-IPA-Overhead: 13755k

comparing Gerald's testcase PR8361 compilation at -O1 level:
    Overall memory needed: 122092k -> 122085k
    Peak memory use before GGC: 83693k
    Peak memory use after GGC: 82863k
    Maximum of released memory in single GGC run: 15729k
    Garbage: 287811k
    Leak: 47081k
    Overhead: 29690k
    GGC runs: 514
    Pre-IPA-Garbage: 154418k
    Pre-IPA-Leak: 87525k
    Pre-IPA-Overhead: 17990k
    Post-IPA-Garbage: 154418k
    Post-IPA-Leak: 87525k
    Post-IPA-Overhead: 17990k

comparing Gerald's testcase PR8361 compilation at -O2 level:
  Amount of produced GGC garbage increased from 353950k to 354927k, overall 0.28%
    Overall memory needed: 124588k -> 124589k
    Peak memory use before GGC: 83899k -> 83912k
    Peak memory use after GGC: 83032k
    Maximum of released memory in single GGC run: 15732k
    Garbage: 353950k -> 354927k
    Leak: 48192k
    Overhead: 36760k -> 36951k
    GGC runs: 587 -> 589
    Pre-IPA-Garbage: 156969k
    Pre-IPA-Leak: 87662k
    Pre-IPA-Overhead: 18269k
    Post-IPA-Garbage: 156969k
    Post-IPA-Leak: 87662k
    Post-IPA-Overhead: 18269k

comparing Gerald's testcase PR8361 compilation at -O3 level:
  Amount of produced GGC garbage increased from 377247k to 378284k, overall 0.27%
    Overall memory needed: 127412k -> 127417k
    Peak memory use before GGC: 85163k -> 85171k
    Peak memory use after GGC: 84296k
    Maximum of released memory in single GGC run: 16125k
    Garbage: 377247k -> 378284k
    Leak: 48766k
    Overhead: 38883k -> 39087k
    GGC runs: 609 -> 611
    Pre-IPA-Garbage: 159684k
    Pre-IPA-Leak: 87944k
    Pre-IPA-Overhead: 18525k
    Post-IPA-Garbage: 159684k
    Post-IPA-Leak: 87944k
    Post-IPA-Overhead: 18525k

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
    Overall memory needed: 380356k
    Peak memory use before GGC: 100958k
    Peak memory use after GGC: 56611k
    Maximum of released memory in single GGC run: 50583k
    Garbage: 175620k
    Leak: 8934k
    Overhead: 30537k
    GGC runs: 107
Testing has produced no results
Testing has produced no results

comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
    Overall memory needed: 381056k
    Peak memory use before GGC: 101501k
    Peak memory use after GGC: 57155k
    Maximum of released memory in single GGC run: 50582k
    Garbage: 175735k
    Leak: 10245k
    Overhead: 30757k
    GGC runs: 110
Testing has produced no results
Testing has produced no results

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
    Overall memory needed: 428198k -> 427926k
    Peak memory use before GGC: 78563k
    Peak memory use after GGC: 70443k
    Maximum of released memory in single GGC run: 37595k
    Garbage: 231505k
    Leak: 16425k
    Overhead: 33115k
    GGC runs: 106
    Pre-IPA-Garbage: 52922k
    Pre-IPA-Leak: 49243k
    Pre-IPA-Overhead: 7123k
    Post-IPA-Garbage: 52922k
    Post-IPA-Leak: 49243k
    Post-IPA-Overhead: 7123k

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
  Amount of produced GGC garbage increased from 242300k to 246014k, overall 1.53%
    Overall memory needed: 353802k -> 353654k
    Peak memory use before GGC: 75430k
    Peak memory use after GGC: 70444k
    Maximum of released memory in single GGC run: 31528k
    Garbage: 242300k -> 246014k
    Leak: 16598k
    Overhead: 35527k -> 36251k
    GGC runs: 117
    Pre-IPA-Garbage: 91834k
    Pre-IPA-Leak: 77300k
    Pre-IPA-Overhead: 11796k
    Post-IPA-Garbage: 91834k
    Post-IPA-Leak: 77300k
    Post-IPA-Overhead: 11796k

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
  Amount of produced GGC garbage increased from 368322k to 368798k, overall 0.13%
    Overall memory needed: 1197190k -> 1199094k
    Peak memory use before GGC: 136591k
    Peak memory use after GGC: 127949k
    Maximum of released memory in single GGC run: 59897k -> 59981k
    Garbage: 368322k -> 368798k
    Leak: 25797k
    Overhead: 49768k -> 49863k
    GGC runs: 104
    Pre-IPA-Garbage: 91834k
    Pre-IPA-Leak: 77300k
    Pre-IPA-Overhead: 11796k
    Post-IPA-Garbage: 91834k
    Post-IPA-Leak: 77300k
    Post-IPA-Overhead: 11796k

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog	2008-04-02 08:13:21.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog	2008-04-02 12:02:10.000000000 +0000
@@ -1,3 +1,45 @@
+2008-04-02  Paolo Bonzini  <bonzini@gnu.org>
+
+	PR bootstrap/35752
+	* Makefile.in (objdir): Set it here.
+	* configure.ac: Not here.  Find dynamic linker characteristics.
+	* exec-tool.in: Use them.
+	* aclocal.m4: Regenerate.
+	* configure: Regenerate.
+
+2008-04-02  Paolo Bonzini  <bonzini@gnu.org>
+
+	* expr.c (expand_var): Delete it.
+	* expr.h (expand_var): Delete prototype.
+	* function.c (expand_function_start): Use expand_decl instead.
+	* cfgexpand.c (expand_one_static_var, expand_one_var): Don't call
+	langhook.
+
+2008-04-02  Andy Hutchinson <hutchinsonamdy@aim.com>
+
+	PR rtl-optimization/35542
+	* fwprop.c (forward_propagate_and_simplify): Replace
+	loc_reg_mentioned_in_p with reg_mentioned_p.
+
+2008-04-02  Paolo Bonzini  <bonzini@gnu.org>
+
+	PR rtl-optimization/35281
+	* fwprop.c (PR_CAN_APPEAR, PR_HANDLE_MEM): New.
+	(propagate_rtx_1): Handle PR_HANDLE_MEM.
+	(propagate_rtx): Pass PR_HANDLE_MEM if appropriate.
+	(varying_mem_p): Move above propagate_rtx.
+	(all_uses_available_at): Do not check MEMs.
+
+2008-04-02  Rafael Espindola  <espindola@google.com>
+
+	* tree-vrp.c (extract_code_and_val_from_cond): Remove.
+	(register_edge_assert_for_2): Split the cond argument.
+	(register_edge_assert_for_1): Adjust for the change in
+	register_edge_assert_for_2.
+	(register_edge_assert_for): Split the cond argument.
+	(find_switch_asserts): Adjust for the change in
+	register_edge_assert_for.
+
 2008-04-02  Kai Tietz  <kai.tietz@onevision.com>
 
 	* config.gcc: Add for x86_64-*-mingw* the t-crtfm to tbuild.


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]