CbC/CbC_gcc: gcc/ggc-page.c comparison

comparison gcc/ggc-page.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* "Bag-of-pages" garbage collector for the GNU compiler.
-Copyright (C) 1999-2018 Free Software Foundation, Inc.
+Copyright (C) 1999-2020 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 #include "tm_p.h"
 #include "diagnostic-core.h"
 #include "flags.h"
 #include "ggc-internal.h"
 #include "timevar.h"
-#include "params.h"
 #include "cgraph.h"
 #include "cfgloop.h"
 #include "plugin.h"
 /* Prefer MAP_ANON(YMOUS) to /dev/zero, since we don't need to keep a
 sizeof (struct tree_var_decl),
 sizeof (struct tree_type_non_common),
 sizeof (struct function),
 sizeof (struct basic_block_def),
 sizeof (struct cgraph_node),
-sizeof (struct loop),
+sizeof (class loop),
 };
 /* The total number of orders.  */
 #define NUM_ORDERS (HOST_BITS_PER_PTR + NUM_EXTRA_ORDERS)
 static void set_page_group_in_use (page_group *, char *);
 static void clear_page_group_in_use (page_group *, char *);
 #endif
 static struct page_entry * alloc_page (unsigned);
 static void free_page (struct page_entry *);
-static void release_pages (void);
 static void clear_marks (void);
 static void sweep_pages (void);
 static void ggc_recalculate_in_use_p (page_entry *);
 static void compute_inverse (unsigned);
 static inline void adjust_depth (void);
 set_page_table_entry (page, entry);
 if (GGC_DEBUG_LEVEL >= 2)
 fprintf (G.debug_file,
 	     "Allocating page at %p, object size=%lu, data %p-%p\n",
-	     (void *) entry, (unsigned long) OBJECT_SIZE (order), page,
+	     (void *) entry, (unsigned long) OBJECT_SIZE (order),
-	     page + entry_size - 1);
+	     (void *) page, (void *) (page + entry_size - 1));
 return entry;
 }
 /* Adjust the size of G.depth so that no index greater than the one
 free_page (page_entry *entry)
 {
 if (GGC_DEBUG_LEVEL >= 2)
 fprintf (G.debug_file,
 	     "Deallocating page at %p, data %p-%p\n", (void *) entry,
-	     entry->page, entry->page + entry->bytes - 1);
+	     (void *) entry->page, (void *) (entry->page + entry->bytes - 1));
 /* Mark the page as inaccessible.  Discard the handle to avoid handle
 leak.  */
 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (entry->page, entry->bytes));
 /* Release the free page cache to the system.  */
 static void
 release_pages (void)
 {
+size_t n1 = 0;
+size_t n2 = 0;
 #ifdef USING_MADVISE
 page_entry *p, *start_p;
 char *start;
 size_t len;
 size_t mapped_len;
 	  if (prev)
 	    prev->next = p;
 else
 G.free_pages = p;
 G.bytes_mapped -= mapped_len;
+	  n1 += len;
 	  continue;
 }
 prev = newprev;
 }
 	 process. Next time we can reuse it by just touching it. */
 madvise (start, len, MADV_DONTNEED);
 /* Don't count those pages as mapped to not touch the garbage collector
 unnecessarily. */
 G.bytes_mapped -= len;
+n2 += len;
 while (start_p != p)
 {
 start_p->discarded = true;
 start_p = start_p->next;
 }
 	  free (p);
 	  p = next;
 	}
 munmap (start, len);
+n1 += len;
 G.bytes_mapped -= len;
 }
 G.free_pages = NULL;
 #endif
 while ((g = *gp) != NULL)
 if (g->in_use == 0)
 {
 	*gp = g->next;
 	G.bytes_mapped -= g->alloc_size;
+	n1 += g->alloc_size;
 	free (g->allocation);
 }
 else
 gp = &g->next;
 #endif
+if (!quiet_flag && (n1 || n2))
+{
+fprintf (stderr, " {GC");
+if (n1)
+	fprintf (stderr, " released %luk", (unsigned long)(n1 / 1024));
+if (n2)
+	fprintf (stderr, " madv_dontneed %luk", (unsigned long)(n2 / 1024));
+fprintf (stderr, "}");
+}
 }
 /* This table provides a fast way to determine ceil(log_2(size)) for
 allocation requests.  The minimum allocation size is eight bytes.  */
 #define NUM_SIZE_LOOKUP 512
 {
 /* Avoid frequent unnecessary work by skipping collection if the
 total allocations haven't expanded much since the last
 collection.  */
 float allocated_last_gc =
-MAX (G.allocated_last_gc, (size_t)PARAM_VALUE (GGC_MIN_HEAPSIZE) * 1024);
+MAX (G.allocated_last_gc, (size_t)param_ggc_min_heapsize * 1024);
-float min_expand = allocated_last_gc * PARAM_VALUE (GGC_MIN_EXPAND) / 100;
+/* It is also good time to get memory block pool into limits.  */
+memory_block_pool::trim ();
+float min_expand = allocated_last_gc * param_ggc_min_expand / 100;
 if (G.allocated < allocated_last_gc + min_expand && !ggc_force_collect)
 return;
 timevar_push (TV_GC);
-if (!quiet_flag)
-fprintf (stderr, " {GC %luk -> ", (unsigned long) G.allocated / 1024);
 if (GGC_DEBUG_LEVEL >= 2)
 fprintf (G.debug_file, "BEGIN COLLECTING\n");
 /* Zero the total allocated bytes.  This will be recalculated in the
 sweep phase.  */
+size_t allocated = G.allocated;
 G.allocated = 0;
 /* Release the pages we freed the last time we collected, but didn't
 reuse in the interim.  */
 release_pages ();
+/* Output this later so we do not interfere with release_pages.  */
+if (!quiet_flag)
+fprintf (stderr, " {GC %luk -> ", (unsigned long) allocated / 1024);
 /* Indicate that we've seen collections at this context depth.  */
 G.context_depth_collections = ((unsigned long)1 << (G.context_depth + 1)) - 1;
 invoke_plugin_callbacks (PLUGIN_GGC_START, NULL);
 fprintf (stderr, "%luk}", (unsigned long) G.allocated / 1024);
 if (GGC_DEBUG_LEVEL >= 2)
 fprintf (G.debug_file, "END COLLECTING\n");
 }
-/* Assume that all GGC memory is reachable and grow the limits for next collection.
+/* Return free pages to the system.  */
-With checking, trigger GGC so -Q compilation outputs how much of memory really is
-reachable.  */
+void
+ggc_trim ()
+{
+timevar_push (TV_GC);
+G.allocated = 0;
+sweep_pages ();
+release_pages ();
+if (!quiet_flag)
+fprintf (stderr, " {GC trimmed to %luk, %luk mapped}",
+	     (unsigned long) G.allocated / 1024,
+	     (unsigned long) G.bytes_mapped / 1024);
+timevar_pop (TV_GC);
+}
+/* Assume that all GGC memory is reachable and grow the limits for next
+collection.  With checking, trigger GGC so -Q compilation outputs how much
+of memory really is reachable.  */
 void
 ggc_grow (void)
 {
 if (!flag_checking)
 G.allocated_last_gc = MAX (G.allocated_last_gc,
 			       G.allocated);
 else
 ggc_collect ();
 if (!quiet_flag)
-fprintf (stderr, " {GC start %luk} ", (unsigned long) G.allocated / 1024);
+fprintf (stderr, " {GC %luk} ", (unsigned long) G.allocated / 1024);
 }
-/* Print allocation statistics.  */
-#define SCALE(x) ((unsigned long) ((x) < 1024*10 \
-		  ? (x) \
-		  : ((x) < 1024*1024*10 \
-		     ? (x) / 1024 \
-		     : (x) / (1024*1024))))
-#define STAT_LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
 void
 ggc_print_statistics (void)
 {
 struct ggc_statistics stats;
 	    (OBJECTS_IN_PAGE (p) - p->num_free_objects) * OBJECT_SIZE (i);
 	  overhead += (sizeof (page_entry) - sizeof (long)
 		       + BITMAP_SIZE (OBJECTS_IN_PAGE (p) + 1));
 	}
-fprintf (stderr, "%-8lu %10lu%c %10lu%c %10lu%c\n",
+fprintf (stderr, "%-8" PRIu64 " " PRsa (10) " " PRsa (10) " "
-	       (unsigned long) OBJECT_SIZE (i),
+	       PRsa (10) "\n",
-	       SCALE (allocated), STAT_LABEL (allocated),
+	       (uint64_t)OBJECT_SIZE (i),
-	       SCALE (in_use), STAT_LABEL (in_use),
+	       SIZE_AMOUNT (allocated),
-	       SCALE (overhead), STAT_LABEL (overhead));
+	       SIZE_AMOUNT (in_use),
+	       SIZE_AMOUNT (overhead));
 total_overhead += overhead;
 }
-fprintf (stderr, "%-8s %10lu%c %10lu%c %10lu%c\n", "Total",
+fprintf (stderr, "%-8s " PRsa (10) " " PRsa (10) " " PRsa (10) "\n",
-	   SCALE (G.bytes_mapped), STAT_LABEL (G.bytes_mapped),
+	   "Total",
-	   SCALE (G.allocated), STAT_LABEL (G.allocated),
+	   SIZE_AMOUNT (G.bytes_mapped),
-	   SCALE (total_overhead), STAT_LABEL (total_overhead));
+	   SIZE_AMOUNT (G.allocated),
+	   SIZE_AMOUNT (total_overhead));
 if (GATHER_STATISTICS)
 {
 fprintf (stderr, "\nTotal allocations and overheads during "
 	       "the compilation process\n");
-fprintf (stderr, "Total Overhead:                          %10"
+fprintf (stderr, "Total Overhead:                          "
-	       HOST_LONG_LONG_FORMAT "d\n", G.stats.total_overhead);
+	       PRsa (9) "\n",
-fprintf (stderr, "Total Allocated:                         %10"
+	       SIZE_AMOUNT (G.stats.total_overhead));
-	       HOST_LONG_LONG_FORMAT "d\n",
+fprintf (stderr, "Total Allocated:                         "
-	       G.stats.total_allocated);
+	       PRsa (9) "\n",
+	       SIZE_AMOUNT (G.stats.total_allocated));
-fprintf (stderr, "Total Overhead  under  32B:              %10"
-	       HOST_LONG_LONG_FORMAT "d\n", G.stats.total_overhead_under32);
+fprintf (stderr, "Total Overhead  under  32B:              "
-fprintf (stderr, "Total Allocated under  32B:              %10"
+	       PRsa (9) "\n",
-	       HOST_LONG_LONG_FORMAT "d\n", G.stats.total_allocated_under32);
+	       SIZE_AMOUNT (G.stats.total_overhead_under32));
-fprintf (stderr, "Total Overhead  under  64B:              %10"
+fprintf (stderr, "Total Allocated under  32B:              "
-	       HOST_LONG_LONG_FORMAT "d\n", G.stats.total_overhead_under64);
+	       PRsa (9) "\n",
-fprintf (stderr, "Total Allocated under  64B:              %10"
+	       SIZE_AMOUNT (G.stats.total_allocated_under32));
-	       HOST_LONG_LONG_FORMAT "d\n", G.stats.total_allocated_under64);
+fprintf (stderr, "Total Overhead  under  64B:              "
-fprintf (stderr, "Total Overhead  under 128B:              %10"
+	       PRsa (9) "\n",
-	       HOST_LONG_LONG_FORMAT "d\n", G.stats.total_overhead_under128);
+	       SIZE_AMOUNT (G.stats.total_overhead_under64));
-fprintf (stderr, "Total Allocated under 128B:              %10"
+fprintf (stderr, "Total Allocated under  64B:              "
-	       HOST_LONG_LONG_FORMAT "d\n", G.stats.total_allocated_under128);
+	       PRsa (9) "\n",
+	       SIZE_AMOUNT (G.stats.total_allocated_under64));
+fprintf (stderr, "Total Overhead  under 128B:              "
+	       PRsa (9) "\n",
+	       SIZE_AMOUNT (G.stats.total_overhead_under128));
+fprintf (stderr, "Total Allocated under 128B:              "
+	       PRsa (9) "\n",
+	       SIZE_AMOUNT (G.stats.total_allocated_under128));
 for (i = 0; i < NUM_ORDERS; i++)
 	if (G.stats.total_allocated_per_order[i])
 	  {
-	    fprintf (stderr, "Total Overhead  page size %9lu:     %10"
+	    fprintf (stderr, "Total Overhead  page size %9" PRIu64 ":     "
-		     HOST_LONG_LONG_FORMAT "d\n",
+		     PRsa (9) "\n",
-		     (unsigned long) OBJECT_SIZE (i),
+		     (uint64_t)OBJECT_SIZE (i),
-		     G.stats.total_overhead_per_order[i]);
+		     SIZE_AMOUNT (G.stats.total_overhead_per_order[i]));
-	    fprintf (stderr, "Total Allocated page size %9lu:     %10"
+	    fprintf (stderr, "Total Allocated page size %9" PRIu64 ":     "
-		     HOST_LONG_LONG_FORMAT "d\n",
+		     PRsa (9) "\n",
-		     (unsigned long) OBJECT_SIZE (i),
+		     (uint64_t)OBJECT_SIZE (i),
-		     G.stats.total_allocated_per_order[i]);
+		     SIZE_AMOUNT (G.stats.total_allocated_per_order[i]));
 	  }
 }
 }
 struct ggc_pch_ondisk
 while (size > OBJECT_SIZE (order))
 	order++;
 }
 if (fwrite (x, size, 1, f) != 1)
-fatal_error (input_location, "can%'t write PCH file: %m");
+fatal_error (input_location, "cannot write PCH file: %m");
 /* If SIZE is not the same as OBJECT_SIZE(order), then we need to pad the
 object out to OBJECT_SIZE(order).  This happens for strings.  */
 if (size != OBJECT_SIZE (order))
 permits us to do the padding with fwrite() rather than fseek(), and
 limits the chance the OS may try to flush any outstanding writes.  */
 if (padding <= sizeof (emptyBytes))
 {
 if (fwrite (emptyBytes, 1, padding, f) != padding)
-fatal_error (input_location, "can%'t write PCH file");
+	    fatal_error (input_location, "cannot write PCH file");
 }
 else
 {
 /* Larger than our buffer?  Just default to fseek.  */
 if (fseek (f, padding, SEEK_CUR) != 0)
-fatal_error (input_location, "can%'t write PCH file");
+	    fatal_error (input_location, "cannot write PCH file");
 }
 }
 d->written[order]++;
 if (d->written[order] == d->d.totals[order]
 && fseek (f, ROUND_UP_VALUE (d->d.totals[order] * OBJECT_SIZE (order),
 				   G.pagesize),
 		SEEK_CUR) != 0)
-fatal_error (input_location, "can%'t write PCH file: %m");
+fatal_error (input_location, "cannot write PCH file: %m");
 }
 void
 ggc_pch_finish (struct ggc_pch_data *d, FILE *f)
 {
 if (fwrite (&d->d, sizeof (d->d), 1, f) != 1)
-fatal_error (input_location, "can%'t write PCH file: %m");
+fatal_error (input_location, "cannot write PCH file: %m");
 free (d);
 }
 /* Move the PCH PTE entries just added to the end of by_depth, to the
 front.  */
 unsigned long count_old_page_tables;
 unsigned long count_new_page_tables;
 count_old_page_tables = G.by_depth_in_use;
+if (fread (&d, sizeof (d), 1, f) != 1)
+fatal_error (input_location, "cannot read PCH file: %m");
 /* We've just read in a PCH file.  So, every object that used to be
 allocated is now free.  */
 clear_marks ();
 #ifdef ENABLE_GC_CHECKING
 poison_pages ();
 	p->context_depth = G.context_depth;
 }
 /* Allocate the appropriate page-table entries for the pages read from
 the PCH file.  */
-if (fread (&d, sizeof (d), 1, f) != 1)
-fatal_error (input_location, "can%'t read PCH file: %m");
 for (i = 0; i < NUM_ORDERS; i++)
 {
 struct page_entry *entry;
 char *pte;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ggc-page.c @ 145:1830386684a0