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!

From: gcctest at suse dot de
To: jh at suse dot cz, gcc-regression at gcc dot gnu dot org
Date: Mon, 06 Apr 2009 02:14:54 +0000
Subject: 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: 8419k
    Peak memory use before GGC: 1487k
    Peak memory use after GGC: 1436k
    Maximum of released memory in single GGC run: 87k
    Garbage: 219k
    Leak: 1536k
    Overhead: 187k
    GGC runs: 4
    Pre-IPA-Garbage: 210k
    Pre-IPA-Leak: 1539k
    Pre-IPA-Overhead: 185k
    Post-IPA-Garbage: 210k
    Post-IPA-Leak: 1539k
    Post-IPA-Overhead: 185k

comparing empty function compilation at -O0 -g level:
    Overall memory needed: 8443k
    Peak memory use before GGC: 1515k
    Peak memory use after GGC: 1464k
    Maximum of released memory in single GGC run: 88k
    Garbage: 220k
    Leak: 1568k
    Overhead: 191k
    GGC runs: 4
    Pre-IPA-Garbage: 210k
    Pre-IPA-Leak: 1539k
    Pre-IPA-Overhead: 185k
    Post-IPA-Garbage: 210k
    Post-IPA-Leak: 1539k
    Post-IPA-Overhead: 185k

comparing empty function compilation at -O1 level:
    Overall memory needed: 8447k
    Peak memory use before GGC: 1487k
    Peak memory use after GGC: 1436k
    Maximum of released memory in single GGC run: 89k
    Garbage: 221k
    Leak: 1536k
    Overhead: 188k
    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 -O2 level:
    Overall memory needed: 8455k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1436k
    Maximum of released memory in single GGC run: 89k
    Garbage: 226k
    Leak: 1536k
    Overhead: 188k
    GGC runs: 5
    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 -O3 level:
    Overall memory needed: 8455k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1436k
    Maximum of released memory in single GGC run: 89k
    Garbage: 226k
    Leak: 1536k
    Overhead: 189k
    GGC runs: 5
    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 combine.c compilation at -O0 level:
    Overall memory needed: 31479k
    Peak memory use before GGC: 17917k
    Peak memory use after GGC: 17669k
    Maximum of released memory in single GGC run: 1796k
    Garbage: 38393k
    Leak: 7143k
    Overhead: 5623k
    GGC runs: 332
    Pre-IPA-Garbage: 12652k
    Pre-IPA-Leak: 19306k
    Pre-IPA-Overhead: 2675k
    Post-IPA-Garbage: 12652k
    Post-IPA-Leak: 19306k
    Post-IPA-Overhead: 2675k

comparing combine.c compilation at -O0 -g level:
    Overall memory needed: 33439k
    Peak memory use before GGC: 19916k
    Peak memory use after GGC: 19507k
    Maximum of released memory in single GGC run: 1805k
    Garbage: 38609k
    Leak: 10413k
    Overhead: 6434k
    GGC runs: 317
    Pre-IPA-Garbage: 12671k
    Pre-IPA-Leak: 21553k
    Pre-IPA-Overhead: 3156k
    Post-IPA-Garbage: 12671k
    Post-IPA-Leak: 21553k
    Post-IPA-Overhead: 3156k

comparing combine.c compilation at -O1 level:
    Overall memory needed: 31627k
    Peak memory use before GGC: 17009k
    Peak memory use after GGC: 16837k
    Maximum of released memory in single GGC run: 1379k
    Garbage: 45468k
    Leak: 7104k
    Overhead: 6160k
    GGC runs: 388
    Pre-IPA-Garbage: 13168k
    Pre-IPA-Leak: 18342k
    Pre-IPA-Overhead: 2653k
    Post-IPA-Garbage: 13168k
    Post-IPA-Leak: 18342k
    Post-IPA-Overhead: 2653k

comparing combine.c compilation at -O2 level:
    Overall memory needed: 32195k
    Peak memory use before GGC: 17103k
    Peak memory use after GGC: 16926k
    Maximum of released memory in single GGC run: 1407k
    Garbage: 57010k
    Leak: 7130k
    Overhead: 7921k
    GGC runs: 439
    Pre-IPA-Garbage: 13311k
    Pre-IPA-Leak: 18434k
    Pre-IPA-Overhead: 2674k
    Post-IPA-Garbage: 13311k
    Post-IPA-Leak: 18434k
    Post-IPA-Overhead: 2674k

comparing combine.c compilation at -O3 level:
    Overall memory needed: 32511k
    Peak memory use before GGC: 17116k
    Peak memory use after GGC: 16946k
    Maximum of released memory in single GGC run: 1411k
    Garbage: 67631k
    Leak: 7149k
    Overhead: 9191k
    GGC runs: 467
    Pre-IPA-Garbage: 13311k
    Pre-IPA-Leak: 18434k
    Pre-IPA-Overhead: 2674k
    Post-IPA-Garbage: 13311k
    Post-IPA-Leak: 18434k
    Post-IPA-Overhead: 2674k

comparing insn-attrtab.c compilation at -O0 level:
    Overall memory needed: 150775k
    Peak memory use before GGC: 64251k
    Peak memory use after GGC: 52910k
    Maximum of released memory in single GGC run: 26647k
    Garbage: 129469k
    Leak: 9532k
    Overhead: 16924k
    GGC runs: 260
    Pre-IPA-Garbage: 40951k
    Pre-IPA-Leak: 54624k
    Pre-IPA-Overhead: 8308k
    Post-IPA-Garbage: 40951k
    Post-IPA-Leak: 54624k
    Post-IPA-Overhead: 8308k

comparing insn-attrtab.c compilation at -O0 -g level:
    Overall memory needed: 152123k
    Peak memory use before GGC: 65516k
    Peak memory use after GGC: 54172k
    Maximum of released memory in single GGC run: 26647k
    Garbage: 129805k
    Leak: 11163k
    Overhead: 17376k
    GGC runs: 253
    Pre-IPA-Garbage: 40959k
    Pre-IPA-Leak: 56148k
    Pre-IPA-Overhead: 8637k
    Post-IPA-Garbage: 40959k
    Post-IPA-Leak: 56148k
    Post-IPA-Overhead: 8637k

comparing insn-attrtab.c compilation at -O1 level:
    Overall memory needed: 127795k
    Peak memory use before GGC: 51722k
    Peak memory use after GGC: 45119k
    Maximum of released memory in single GGC run: 20927k
    Garbage: 180283k
    Leak: 8899k
    Overhead: 25107k
    GGC runs: 296
    Pre-IPA-Garbage: 46033k
    Pre-IPA-Leak: 47873k
    Pre-IPA-Overhead: 8106k
    Post-IPA-Garbage: 46033k
    Post-IPA-Leak: 47873k
    Post-IPA-Overhead: 8106k

comparing insn-attrtab.c compilation at -O2 level:
    Overall memory needed: 141139k
    Peak memory use before GGC: 51508k
    Peak memory use after GGC: 45126k
    Maximum of released memory in single GGC run: 18495k
    Garbage: 206579k
    Leak: 8910k
    Overhead: 30132k
    GGC runs: 321
    Pre-IPA-Garbage: 46099k
    Pre-IPA-Leak: 47883k
    Pre-IPA-Overhead: 8113k
    Post-IPA-Garbage: 46099k
    Post-IPA-Leak: 47883k
    Post-IPA-Overhead: 8113k

comparing insn-attrtab.c compilation at -O3 level:
    Overall memory needed: 141163k
    Peak memory use before GGC: 51512k
    Peak memory use after GGC: 45126k
    Maximum of released memory in single GGC run: 18440k
    Garbage: 207733k
    Leak: 8916k
    Overhead: 30405k
    GGC runs: 327
    Pre-IPA-Garbage: 46099k
    Pre-IPA-Leak: 47883k
    Pre-IPA-Overhead: 8113k
    Post-IPA-Garbage: 46099k
    Post-IPA-Leak: 47883k
    Post-IPA-Overhead: 8113k

comparing Gerald's testcase PR8361 compilation at -O0 level:
  Amount of produced GGC garbage increased from 198896k to 200620k, overall 0.87%
    Overall memory needed: 146893k -> 146892k
    Peak memory use before GGC: 82002k -> 81955k
    Peak memory use after GGC: 81185k -> 81142k
    Maximum of released memory in single GGC run: 13832k -> 13857k
    Garbage: 198896k -> 200620k
    Leak: 55285k -> 55286k
    Overhead: 27858k -> 27859k
    GGC runs: 447 -> 449
    Pre-IPA-Garbage: 109726k -> 109726k
    Pre-IPA-Leak: 86117k
    Pre-IPA-Overhead: 14954k -> 14954k
    Post-IPA-Garbage: 109726k -> 109726k
    Post-IPA-Leak: 86117k
    Post-IPA-Overhead: 14954k -> 14954k

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
  Amount of produced GGC garbage increased from 203309k to 205911k, overall 1.28%
    Overall memory needed: 165261k -> 164884k
    Peak memory use before GGC: 96109k -> 96054k
    Peak memory use after GGC: 95156k -> 95100k
    Maximum of released memory in single GGC run: 14240k -> 14112k
    Garbage: 203309k -> 205911k
    Leak: 83313k -> 82335k
    Overhead: 34659k -> 34382k
    GGC runs: 415 -> 421
  Amount of produced pre-ipa-GGC garbage increased from 110091k to 110294k, overall 0.18%
    Pre-IPA-Garbage: 110091k -> 110294k
    Pre-IPA-Leak: 102974k -> 102577k
    Pre-IPA-Overhead: 18531k -> 18420k
  Amount of produced post-ipa-GGC garbage increased from 110091k to 110294k, overall 0.18%
    Post-IPA-Garbage: 110091k -> 110294k
    Post-IPA-Leak: 102974k -> 102577k
    Post-IPA-Overhead: 18531k -> 18420k

comparing Gerald's testcase PR8361 compilation at -O1 level:
  Amount of produced GGC garbage increased from 259964k to 261216k, overall 0.48%
    Overall memory needed: 107224k
    Peak memory use before GGC: 84474k
    Peak memory use after GGC: 83554k -> 83555k
    Maximum of released memory in single GGC run: 13657k -> 13809k
    Garbage: 259964k -> 261216k
    Leak: 52067k -> 52060k
    Overhead: 30202k -> 30203k
    GGC runs: 513 -> 514
    Pre-IPA-Garbage: 151846k -> 151846k
    Pre-IPA-Leak: 89209k
    Pre-IPA-Overhead: 19165k -> 19165k
    Post-IPA-Garbage: 151846k -> 151846k
    Post-IPA-Leak: 89209k
    Post-IPA-Overhead: 19165k -> 19165k

comparing Gerald's testcase PR8361 compilation at -O2 level:
  Amount of produced GGC garbage increased from 300580k to 301795k, overall 0.40%
    Overall memory needed: 107520k -> 107524k
    Peak memory use before GGC: 85028k -> 85030k
    Peak memory use after GGC: 84182k
    Maximum of released memory in single GGC run: 13689k -> 13660k
    Garbage: 300580k -> 301795k
    Leak: 52110k -> 52103k
    Overhead: 35438k -> 35439k
    GGC runs: 563 -> 565
    Pre-IPA-Garbage: 156565k -> 156566k
    Pre-IPA-Leak: 88442k
    Pre-IPA-Overhead: 19586k -> 19586k
    Post-IPA-Garbage: 156565k -> 156566k
    Post-IPA-Leak: 88442k
    Post-IPA-Overhead: 19586k -> 19586k

comparing Gerald's testcase PR8361 compilation at -O3 level:
  Amount of produced GGC garbage increased from 319186k to 320401k, overall 0.38%
    Overall memory needed: 107692k -> 107696k
    Peak memory use before GGC: 85455k -> 85456k
    Peak memory use after GGC: 84607k -> 84608k
    Maximum of released memory in single GGC run: 13689k -> 13660k
    Garbage: 319186k -> 320401k
    Leak: 52107k -> 52114k
    Overhead: 37397k -> 37398k
    GGC runs: 582 -> 584
    Pre-IPA-Garbage: 156627k -> 156627k
    Pre-IPA-Leak: 88893k
    Pre-IPA-Overhead: 19619k -> 19619k
    Post-IPA-Garbage: 156627k -> 156627k
    Post-IPA-Leak: 88893k
    Post-IPA-Overhead: 19619k -> 19619k

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
    Overall memory needed: 358116k
    Peak memory use before GGC: 76531k
    Peak memory use after GGC: 48910k
    Maximum of released memory in single GGC run: 36352k
    Garbage: 138734k
    Leak: 8222k
    Overhead: 24340k
    GGC runs: 86
    Pre-IPA-Garbage: 13104k
    Pre-IPA-Leak: 19428k
    Pre-IPA-Overhead: 2307k
    Post-IPA-Garbage: 13104k
    Post-IPA-Leak: 19428k
    Post-IPA-Overhead: 2307k

comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
    Overall memory needed: 358940k
    Peak memory use before GGC: 77215k
    Peak memory use after GGC: 49594k
    Maximum of released memory in single GGC run: 36337k
    Garbage: 138867k
    Leak: 10219k
    Overhead: 24922k
    GGC runs: 94
    Pre-IPA-Garbage: 13106k
    Pre-IPA-Leak: 19674k
    Pre-IPA-Overhead: 2360k
    Post-IPA-Garbage: 13106k
    Post-IPA-Leak: 19674k
    Post-IPA-Overhead: 2360k

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
    Overall memory needed: 201591k
    Peak memory use before GGC: 76365k
    Peak memory use after GGC: 71649k
    Maximum of released memory in single GGC run: 36514k
    Garbage: 210705k
    Leak: 8172k
    Overhead: 31296k
    GGC runs: 94
    Pre-IPA-Garbage: 42461k
    Pre-IPA-Leak: 69560k
    Pre-IPA-Overhead: 9062k
    Post-IPA-Garbage: 42461k
    Post-IPA-Leak: 69560k
    Post-IPA-Overhead: 9062k

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
    Overall memory needed: 497595k
    Peak memory use before GGC: 76366k
    Peak memory use after GGC: 71650k
    Maximum of released memory in single GGC run: 33187k
    Garbage: 260554k
    Leak: 8164k
    Overhead: 39932k
    GGC runs: 102
    Pre-IPA-Garbage: 95611k
    Pre-IPA-Leak: 84901k
    Pre-IPA-Overhead: 14813k
    Post-IPA-Garbage: 95611k
    Post-IPA-Leak: 84901k
    Post-IPA-Overhead: 14813k

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
    Overall memory needed: 1025539k
    Peak memory use before GGC: 140763k
    Peak memory use after GGC: 133076k
    Maximum of released memory in single GGC run: 56562k
    Garbage: 347339k
    Leak: 9720k
    Overhead: 45326k
    GGC runs: 98
    Pre-IPA-Garbage: 95611k
    Pre-IPA-Leak: 84901k
    Pre-IPA-Overhead: 14813k
    Post-IPA-Garbage: 95611k
    Post-IPA-Leak: 84901k
    Post-IPA-Overhead: 14813k

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog	2009-04-05 07:41:49.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog	2009-04-05 22:54:19.000000000 +0000
@@ -1,3 +1,21 @@
+2009-04-05  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/39648
+	* tree-ssa-sccvn.c (vn_reference_fold_indirect): Work around
+	our &A vs. &A[0] IL deficiencies.
+
+2009-04-04  Jan Hubicka  <jh@suse.cz>
+
+	* except.c (sjlj_find_directly_reachable_regions): Be ready for
+	removed toplevel regions.
+	(sjlj_mark_call_sites): Likewise.
+
+2009-04-04  Dave Korn  <dave.korn.cygwin@gmail.com>
+
+	* config.gcc (cygwin tm_file):  Add cygwin-stdint.h.
+	(cygwin tm clause use_gcc_stdint):  Set to wrap.
+	* config/i386/cygwin-stdint.h:  New file.
+
 2009-04-04  Richard Guenther  <rguenther@suse.de>
 
 	* Makefile.in (tree-ssa-copy.o): Add $(CFGLOOP_H) dependency.
--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog.cp	2009-04-05 07:41:48.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/cp/ChangeLog	2009-04-05 22:54:18.000000000 +0000
@@ -1,3 +1,14 @@
+2009-04-05  Giovanni Bajo <giovannibajo@libero.it>
+	    Jason Merrill  <jason@redhat.com>
+
+	PR c++/14912
+	* error.c (count_non_default_template_args): New fn.
+	(dump_template_parms): Call it.
+	(dump_template_argument_list): Call it.  Add parms parm.
+	(dump_template_argument): Adjust call to dump_template_argument_list.
+	(dump_type, dump_decl): Likewise.
+	(dump_template_bindings): Refactor logic.
+
 2009-04-03  Jason Merrill  <jason@redhat.com>
 
 	PR c++/25185


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]