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

gcctest@suse.de gcctest@suse.de
Fri May 9 03:56:00 GMT 2008


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: 8151k -> 8153k
    Peak memory use before GGC: 1104k
    Peak memory use after GGC: 1001k
    Maximum of released memory in single GGC run: 129k
    Garbage: 238k
    Leak: 958k
    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: 8167k -> 8169k
    Peak memory use before GGC: 1132k
    Peak memory use after GGC: 1035k
    Maximum of released memory in single GGC run: 128k
    Garbage: 240k
    Leak: 991k
    Overhead: 85k
    GGC runs: 4
Testing has produced no results
Testing has produced no results

comparing empty function compilation at -O1 level:
    Overall memory needed: 8203k -> 8205k
    Peak memory use before GGC: 1104k
    Peak memory use after GGC: 1001k
    Maximum of released memory in single GGC run: 130k
    Garbage: 240k
    Leak: 959k
    Overhead: 81k
    GGC runs: 2
    Pre-IPA-Garbage: 228k
    Pre-IPA-Leak: 961k
    Pre-IPA-Overhead: 79k
    Post-IPA-Garbage: 228k
    Post-IPA-Leak: 961k
    Post-IPA-Overhead: 79k

comparing empty function compilation at -O2 level:
    Overall memory needed: 8223k -> 8225k
    Peak memory use before GGC: 1105k
    Peak memory use after GGC: 1001k
    Maximum of released memory in single GGC run: 135k
    Garbage: 244k
    Leak: 960k
    Overhead: 82k
    GGC runs: 2
    Pre-IPA-Garbage: 228k
    Pre-IPA-Leak: 962k
    Pre-IPA-Overhead: 79k
    Post-IPA-Garbage: 228k
    Post-IPA-Leak: 962k
    Post-IPA-Overhead: 79k

comparing empty function compilation at -O3 level:
    Overall memory needed: 8223k -> 8225k
    Peak memory use before GGC: 1105k
    Peak memory use after GGC: 1001k
    Maximum of released memory in single GGC run: 135k
    Garbage: 244k
    Leak: 960k
    Overhead: 82k
    GGC runs: 2
    Pre-IPA-Garbage: 228k
    Pre-IPA-Leak: 962k
    Pre-IPA-Overhead: 79k
    Post-IPA-Garbage: 228k
    Post-IPA-Leak: 962k
    Post-IPA-Overhead: 79k

comparing combine.c compilation at -O0 level:
    Overall memory needed: 22619k -> 22617k
    Peak memory use before GGC: 7774k
    Peak memory use after GGC: 7150k
    Maximum of released memory in single GGC run: 1545k
    Garbage: 37789k
    Leak: 5479k
    Overhead: 4616k
    GGC runs: 371
Testing has produced no results
Testing has produced no results

comparing combine.c compilation at -O0 -g level:
    Overall memory needed: 24695k -> 24697k
    Peak memory use before GGC: 9689k
    Peak memory use after GGC: 9046k
    Maximum of released memory in single GGC run: 1831k
    Garbage: 38140k
    Leak: 8673k
    Overhead: 5412k
    GGC runs: 341
Testing has produced no results
Testing has produced no results

comparing combine.c compilation at -O1 level:
    Overall memory needed: 32719k -> 32721k
    Peak memory use before GGC: 16184k
    Peak memory use after GGC: 16019k
    Maximum of released memory in single GGC run: 1375k
    Garbage: 51456k
    Leak: 5647k
    Overhead: 5731k
    GGC runs: 439
    Pre-IPA-Garbage: 13897k
    Pre-IPA-Leak: 16976k
    Pre-IPA-Overhead: 2087k
    Post-IPA-Garbage: 13897k
    Post-IPA-Leak: 16976k
    Post-IPA-Overhead: 2087k

comparing combine.c compilation at -O2 level:
    Overall memory needed: 34483k -> 34481k
    Peak memory use before GGC: 16273k
    Peak memory use after GGC: 16112k
    Maximum of released memory in single GGC run: 1304k
    Garbage: 71652k
    Leak: 5984k
    Overhead: 8073k
    GGC runs: 509
    Pre-IPA-Garbage: 14049k
    Pre-IPA-Leak: 17039k
    Pre-IPA-Overhead: 2100k
    Post-IPA-Garbage: 14049k
    Post-IPA-Leak: 17039k
    Post-IPA-Overhead: 2100k

comparing combine.c compilation at -O3 level:
    Overall memory needed: 38647k -> 38645k
    Peak memory use before GGC: 16367k
    Peak memory use after GGC: 16127k
    Maximum of released memory in single GGC run: 2440k
    Garbage: 91500k
    Leak: 6035k
    Overhead: 10604k
    GGC runs: 544
    Pre-IPA-Garbage: 14051k
    Pre-IPA-Leak: 17051k
    Pre-IPA-Overhead: 2101k
    Post-IPA-Garbage: 14051k
    Post-IPA-Leak: 17051k
    Post-IPA-Overhead: 2101k

comparing insn-attrtab.c compilation at -O0 level:
    Overall memory needed: 137427k -> 137425k
    Peak memory use before GGC: 56958k
    Peak memory use after GGC: 31384k
    Maximum of released memory in single GGC run: 33223k
    Garbage: 128389k
    Leak: 8355k
    Overhead: 14291k
    GGC runs: 291
Testing has produced no results
Testing has produced no results

comparing insn-attrtab.c compilation at -O0 -g level:
    Overall memory needed: 138715k -> 138717k
    Peak memory use before GGC: 58160k
    Peak memory use after GGC: 32585k
    Maximum of released memory in single GGC run: 33224k
    Garbage: 128896k
    Leak: 9933k
    Overhead: 14731k
    GGC runs: 289
Testing has produced no results
Testing has produced no results

comparing insn-attrtab.c compilation at -O1 level:
    Overall memory needed: 142319k -> 142341k
    Peak memory use before GGC: 56075k
    Peak memory use after GGC: 49744k
    Maximum of released memory in single GGC run: 23959k
    Garbage: 205079k
    Leak: 9261k
    Overhead: 24464k
    GGC runs: 315
    Pre-IPA-Garbage: 50364k
    Pre-IPA-Leak: 49269k
    Pre-IPA-Overhead: 7416k
    Post-IPA-Garbage: 50364k
    Post-IPA-Leak: 49269k
    Post-IPA-Overhead: 7416k

comparing insn-attrtab.c compilation at -O2 level:
    Overall memory needed: 184395k -> 184405k
    Peak memory use before GGC: 56658k
    Peak memory use after GGC: 51345k
    Maximum of released memory in single GGC run: 22853k
    Garbage: 246616k
    Leak: 10338k
    Overhead: 30364k
    GGC runs: 346
    Pre-IPA-Garbage: 50436k
    Pre-IPA-Leak: 49273k
    Pre-IPA-Overhead: 7423k
    Post-IPA-Garbage: 50436k
    Post-IPA-Leak: 49273k
    Post-IPA-Overhead: 7423k

comparing insn-attrtab.c compilation at -O3 level:
    Overall memory needed: 190411k -> 190413k
    Peak memory use before GGC: 68990k
    Peak memory use after GGC: 64798k
    Maximum of released memory in single GGC run: 24862k
    Garbage: 273836k
    Leak: 10373k
    Overhead: 32276k
    GGC runs: 345
    Pre-IPA-Garbage: 50436k
    Pre-IPA-Leak: 49273k
    Pre-IPA-Overhead: 7423k
    Post-IPA-Garbage: 50436k
    Post-IPA-Leak: 49273k
    Post-IPA-Overhead: 7423k

comparing Gerald's testcase PR8361 compilation at -O0 level:
    Overall memory needed: 144126k -> 144101k
    Peak memory use before GGC: 80333k
    Peak memory use after GGC: 79537k
    Maximum of released memory in single GGC run: 14817k
    Garbage: 197259k
    Leak: 47150k
    Overhead: 24089k
    GGC runs: 418
    Pre-IPA-Garbage: 107899k
    Pre-IPA-Leak: 69071k
    Pre-IPA-Overhead: 12027k
    Post-IPA-Garbage: 107899k
    Post-IPA-Leak: 69071k
    Post-IPA-Overhead: 12027k

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
    Overall memory needed: 166174k -> 166173k
    Peak memory use before GGC: 92916k
    Peak memory use after GGC: 91996k
    Maximum of released memory in single GGC run: 15518k
    Garbage: 202906k
    Leak: 71539k
    Overhead: 30448k
    GGC runs: 389
    Pre-IPA-Garbage: 108542k
    Pre-IPA-Leak: 83804k
    Pre-IPA-Overhead: 15331k
    Post-IPA-Garbage: 108542k
    Post-IPA-Leak: 83804k
    Post-IPA-Overhead: 15331k

comparing Gerald's testcase PR8361 compilation at -O1 level:
    Overall memory needed: 119019k -> 119013k
    Peak memory use before GGC: 79610k
    Peak memory use after GGC: 78821k
    Maximum of released memory in single GGC run: 14455k
    Garbage: 287473k
    Leak: 46302k
    Overhead: 28537k
    GGC runs: 520
    Pre-IPA-Garbage: 151011k
    Pre-IPA-Leak: 83180k
    Pre-IPA-Overhead: 16678k
    Post-IPA-Garbage: 151011k
    Post-IPA-Leak: 83180k
    Post-IPA-Overhead: 16678k

comparing Gerald's testcase PR8361 compilation at -O2 level:
    Overall memory needed: 121235k -> 121237k
    Peak memory use before GGC: 79532k
    Peak memory use after GGC: 78720k
    Maximum of released memory in single GGC run: 14458k
    Garbage: 356264k
    Leak: 47708k
    Overhead: 35693k
    GGC runs: 597
    Pre-IPA-Garbage: 152632k
    Pre-IPA-Leak: 83057k
    Pre-IPA-Overhead: 16818k
    Post-IPA-Garbage: 152632k
    Post-IPA-Leak: 83057k
    Post-IPA-Overhead: 16818k

comparing Gerald's testcase PR8361 compilation at -O3 level:
    Overall memory needed: 124263k -> 124261k
    Peak memory use before GGC: 80999k
    Peak memory use after GGC: 80197k
    Maximum of released memory in single GGC run: 14780k
    Garbage: 383207k
    Leak: 48125k
    Overhead: 37990k
    GGC runs: 622
    Pre-IPA-Garbage: 155259k
    Pre-IPA-Leak: 83340k
    Pre-IPA-Overhead: 17059k
    Post-IPA-Garbage: 155259k
    Post-IPA-Leak: 83340k
    Post-IPA-Overhead: 17059k

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
    Overall memory needed: 380351k -> 380346k
    Peak memory use before GGC: 100958k
    Peak memory use after GGC: 56611k
    Maximum of released memory in single GGC run: 50583k
    Garbage: 178452k -> 178453k
    Leak: 6103k
    Overhead: 30540k -> 30541k
    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: 381191k -> 381186k
    Peak memory use before GGC: 101651k
    Peak memory use after GGC: 57304k
    Maximum of released memory in single GGC run: 50583k
    Garbage: 178616k -> 178568k
    Leak: 8132k
    Overhead: 31123k -> 31124k
    GGC runs: 110 -> 111
Testing has produced no results
Testing has produced no results

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
    Overall memory needed: 396719k -> 399601k
    Peak memory use before GGC: 75052k
    Peak memory use after GGC: 68954k -> 68956k
    Maximum of released memory in single GGC run: 35019k -> 34951k
    Garbage: 238003k -> 237663k
    Leak: 13677k -> 13678k
    Overhead: 30751k -> 30716k
    GGC runs: 106
    Pre-IPA-Garbage: 47276k -> 47276k
    Pre-IPA-Leak: 65128k -> 65129k
    Pre-IPA-Overhead: 6423k -> 6423k
    Post-IPA-Garbage: 47276k -> 47276k
    Post-IPA-Leak: 65128k -> 65129k
    Post-IPA-Overhead: 6423k -> 6423k

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
    Overall memory needed: 303027k -> 303617k
    Peak memory use before GGC: 74965k -> 74966k
    Peak memory use after GGC: 68955k -> 68956k
    Maximum of released memory in single GGC run: 31602k -> 31581k
    Garbage: 252445k -> 252153k
    Leak: 13851k -> 13851k
    Overhead: 33865k -> 33834k
    GGC runs: 118
  Amount of memory referenced pre-ipa increased from 76606k to 82247k, overall 7.36%
    Pre-IPA-Garbage: 99865k -> 99280k
    Pre-IPA-Leak: 76606k -> 82247k
    Pre-IPA-Overhead: 10318k -> 10465k
  Amount of memory referenced post-ipa increased from 76606k to 82247k, overall 7.36%
    Post-IPA-Garbage: 99865k -> 99280k
    Post-IPA-Leak: 76606k -> 82247k
    Post-IPA-Overhead: 10318k -> 10465k

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
  Ovarall memory allocated via mmap and sbrk decreased from 1201687k to 1079393k, overall -11.33%
  Peak amount of GGC memory allocated before garbage collecting increased from 136395k to 141304k, overall 3.60%
  Peak amount of GGC memory still allocated after garbage collecting increased from 125705k to 131199k, overall 4.37%
  Amount of produced GGC garbage decreased from 374979k to 343000k, overall -9.32%
  Amount of memory still referenced at the end of compilation decreased from 24124k to 22001k, overall -9.65%
    Overall memory needed: 1201687k -> 1079393k
    Peak memory use before GGC: 136395k -> 141304k
    Peak memory use after GGC: 125705k -> 131199k
    Maximum of released memory in single GGC run: 55504k -> 55803k
    Garbage: 374979k -> 343000k
    Leak: 24124k -> 22001k
    Overhead: 47476k -> 37524k
    GGC runs: 106 -> 102
  Amount of memory referenced pre-ipa increased from 76606k to 82247k, overall 7.36%
    Pre-IPA-Garbage: 99865k -> 99280k
    Pre-IPA-Leak: 76606k -> 82247k
    Pre-IPA-Overhead: 10318k -> 10465k
  Amount of memory referenced post-ipa increased from 76606k to 82247k, overall 7.36%
    Post-IPA-Garbage: 99865k -> 99280k
    Post-IPA-Leak: 76606k -> 82247k
    Post-IPA-Overhead: 10318k -> 10465k

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog	2008-05-08 20:39:17.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog	2008-05-09 00:18:09.000000000 +0000
@@ -1,3 +1,35 @@
+2008-05-08  Seongbae Park  <seongbae.park@gmail.com>
+	* common.opt (Wframe-larger-than=): Shorten the help message
+	to one line.
+	* doc/invoke.texi (Wframe-larger-than=): Add more description.
+
+2008-05-08  Rafael Espindola  <espindola@google.com>
+
+	* tree-complex.c (expand_complex_div_wide): Don't create CONDs that
+	trap.
+	* tree-gimple.c (is_gimple_condexpr): Check that the expression doesn't
+	trap and that both operands are gimple values.
+	(canonicalize_cond_expr_cond): Use is_gimple_condexpr.
+	* gcc/tree-eh.c (tree_could_trap_p): Correctly detect if a comparison
+	is a fp operation.
+
+2008-05-08  Richard Sandiford  <rsandifo@nildram.co.uk>
+
+	* read-rtl.c (join_c_conditions): Return the first string if the
+	two strings are equal.
+
+2008-05-08  Richard Sandiford  <rsandifo@nildram.co.uk>
+
+	* gensupport.h (pred_data): Add a "num_codes" field.
+	(add_predicate_code): Declare.
+	* gensupport.c (add_predicate_code): New function.
+	(std_pred_table): Add an "allows_const_p" field.
+	(std_preds): Set this field for predicates that allow RTX_CONST_OBJs.
+	Remove the (incomplete) list of such codes from the codes field.
+	(init_predicate_table): Use add_predicate_code.  Add all
+	RTX_CONST_OBJs if allows_const_p is true.
+	* genrecog.c (process_define_predicate): Use add_predicate_code.
+
 2008-05-08  David Daney  <ddaney@avtrex.com>
 	    Richard Sandiford  <rsandifo@nildram.co.uk>
 	


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.



More information about the Gcc-regression mailing list