#include "toplev.h"
#include "params.h"
#include "hosthooks.h"
+#include "hosthooks-def.h"
#ifdef HAVE_SYS_RESOURCE_H
# include <sys/resource.h>
char *this_object = NULL;
size_t this_object_size = 0;
struct mmap_info mmi;
- size_t page_size = getpagesize();
+ const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity();
gt_pch_save_stringpool ();
and on the rest it's a lot of work to do better.
(The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and
HOST_HOOKS_GT_PCH_USE_ADDRESS.) */
- mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size);
+ mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f));
-#if HAVE_MMAP_FILE
- if (mmi.preferred_base == NULL)
- {
- mmi.preferred_base = mmap (NULL, mmi.size,
- PROT_READ | PROT_WRITE, MAP_PRIVATE,
- fileno (state.f), 0);
- if (mmi.preferred_base == (void *) MAP_FAILED)
- mmi.preferred_base = NULL;
- else
- munmap (mmi.preferred_base, mmi.size);
- }
-#endif /* HAVE_MMAP_FILE */
-
ggc_pch_this_base (state.d, mmi.preferred_base);
state.ptrs = xmalloc (state.count * sizeof (*state.ptrs));
ggc_pch_prepare_write (state.d, state.f);
- /* Pad the PCH file so that the mmapped area starts on a page boundary. */
+ /* Pad the PCH file so that the mmapped area starts on an allocation
+ granularity (usually page) boundary. */
{
long o;
o = ftell (state.f) + sizeof (mmi);
if (o == -1)
fatal_error ("can't get position in PCH file: %m");
- mmi.offset = page_size - o % page_size;
- if (mmi.offset == page_size)
+ mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
+ if (mmi.offset == mmap_offset_alignment)
mmi.offset = 0;
mmi.offset += o;
}
state.ptrs[i]->note_ptr_cookie,
relocate_ptrs, &state);
ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj,
- state.ptrs[i]->new_addr, state.ptrs[i]->size, state.ptrs[i]->note_ptr_fn == gt_pch_p_S);
+ state.ptrs[i]->new_addr, state.ptrs[i]->size,
+ state.ptrs[i]->note_ptr_fn == gt_pch_p_S);
if (state.ptrs[i]->note_ptr_fn != gt_pch_p_S)
memcpy (state.ptrs[i]->obj, this_object, state.ptrs[i]->size);
}
const struct ggc_root_tab *rti;
size_t i;
struct mmap_info mmi;
- void *addr;
- bool needs_read;
+ int result;
/* Delete any deletable objects. This makes ggc_pch_read much
faster, as it can be sure that no GCable objects remain other
if (fread (&mmi, sizeof (mmi), 1, f) != 1)
fatal_error ("can't read PCH file: %m");
- if (host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size))
+ result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
+ fileno (f), mmi.offset);
+ if (result < 0)
+ fatal_error ("had to relocate PCH");
+ if (result == 0)
{
-#if HAVE_MMAP_FILE
- void *mmap_result;
+ if (fseek (f, mmi.offset, SEEK_SET) != 0
+ || fread (mmi.preferred_base, mmi.size, 1, f) != 1)
+ fatal_error ("can't read PCH file: %m");
+ }
+ else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
+ fatal_error ("can't read PCH file: %m");
- mmap_result = mmap (mmi.preferred_base, mmi.size,
- PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED,
- fileno (f), mmi.offset);
+ ggc_pch_read (f, mmi.preferred_base);
- /* The file might not be mmap-able. */
- needs_read = mmap_result == (void *) MAP_FAILED;
+ gt_pch_restore_stringpool ();
+}
+
+/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present.
+ Select no address whatsoever, and let gt_pch_save choose what it will with
+ malloc, presumably. */
+
+void *
+default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED,
+ int fd ATTRIBUTE_UNUSED)
+{
+ return NULL;
+}
+
+/* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present.
+ Allocate SIZE bytes with malloc. Return 0 if the address we got is the
+ same as base, indicating that the memory has been allocated but needs to
+ be read in from the file. Return -1 if the address differs, to relocation
+ of the PCH file would be required. */
+
+int
+default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED,
+ size_t offset ATTRIBUTE_UNUSED)
+{
+ void *addr = xmalloc (size);
+ return (addr == base) - 1;
+}
+
+/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS. Return the
+ alignment required for allocating virtual memory. Usually this is the
+ same as pagesize. */
+
+size_t
+default_gt_pch_alloc_granularity (void)
+{
+ return getpagesize();
+}
- /* Sanity check for broken MAP_FIXED. */
- if (! needs_read && mmap_result != mmi.preferred_base)
- abort ();
-#else
- needs_read = true;
-#endif
- addr = mmi.preferred_base;
- }
- else
- {
#if HAVE_MMAP_FILE
- addr = mmap (mmi.preferred_base, mmi.size,
- PROT_READ | PROT_WRITE, MAP_PRIVATE,
- fileno (f), mmi.offset);
-
-#if HAVE_MINCORE
- if (addr != mmi.preferred_base)
- {
- size_t page_size = getpagesize();
- char one_byte;
-
- if (addr != (void *) MAP_FAILED)
- munmap (addr, mmi.size);
-
- /* We really want to be mapped at mmi.preferred_base
- so we're going to resort to MAP_FIXED. But before,
- make sure that we can do so without destroying a
- previously mapped area, by looping over all pages
- that would be affected by the fixed mapping. */
- errno = 0;
-
- for (i = 0; i < mmi.size; i+= page_size)
- if (mincore ((char *)mmi.preferred_base + i, page_size,
- (void *)&one_byte) == -1
- && errno == ENOMEM)
- continue; /* The page is not mapped. */
- else
- break;
-
- if (i >= mmi.size)
- addr = mmap (mmi.preferred_base, mmi.size,
- PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED,
- fileno (f), mmi.offset);
- }
-#endif /* HAVE_MINCORE */
-
- needs_read = addr == (void *) MAP_FAILED;
+/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present.
+ We temporarily allocate SIZE bytes, and let the kernel place the data
+ wherever it will. If it worked, that's our spot, if not we're likely
+ to be in trouble. */
-#else /* HAVE_MMAP_FILE */
- needs_read = true;
-#endif /* HAVE_MMAP_FILE */
- if (needs_read)
- addr = xmalloc (mmi.size);
- }
+void *
+mmap_gt_pch_get_address (size_t size, int fd)
+{
+ void *ret;
- if (needs_read)
- {
- if (fseek (f, mmi.offset, SEEK_SET) != 0
- || fread (&mmi, mmi.size, 1, f) != 1)
- fatal_error ("can't read PCH file: %m");
- }
- else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
- fatal_error ("can't read PCH file: %m");
+ ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+ if (ret == (void *) MAP_FAILED)
+ ret = NULL;
+ else
+ munmap (ret, size);
- ggc_pch_read (f, addr);
+ return ret;
+}
- if (addr != mmi.preferred_base)
- {
- for (rt = gt_ggc_rtab; *rt; rt++)
- for (rti = *rt; rti->base != NULL; rti++)
- for (i = 0; i < rti->nelt; i++)
- {
- char **ptr = (char **)((char *)rti->base + rti->stride * i);
- if (*ptr != NULL)
- *ptr += (size_t)addr - (size_t)mmi.preferred_base;
- }
+/* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present.
+ Map SIZE bytes of FD+OFFSET at BASE. Return 1 if we succeeded at
+ mapping the data at BASE, -1 if we couldn't.
- for (rt = gt_pch_cache_rtab; *rt; rt++)
- for (rti = *rt; rti->base != NULL; rti++)
- for (i = 0; i < rti->nelt; i++)
- {
- char **ptr = (char **)((char *)rti->base + rti->stride * i);
- if (*ptr != NULL)
- *ptr += (size_t)addr - (size_t)mmi.preferred_base;
- }
+ This version assumes that the kernel honors the START operand of mmap
+ even without MAP_FIXED if START through START+SIZE are not currently
+ mapped with something. */
- sorry ("had to relocate PCH");
- }
+int
+mmap_gt_pch_use_address (void *base, size_t size, int fd, size_t offset)
+{
+ void *addr;
- gt_pch_restore_stringpool ();
+ /* We're called with size == 0 if we're not planning to load a PCH
+ file at all. This allows the hook to free any static space that
+ we might have allocated at link time. */
+ if (size == 0)
+ return -1;
+
+ addr = mmap (base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
+ fd, offset);
+
+ return addr == base ? 1 : -1;
}
+#endif /* HAVE_MMAP_FILE */
-/* Modify the bound based on rlimits. Keep the smallest number found. */
+/* Modify the bound based on rlimits. */
static double
ggc_rlimit_bound (double limit)
{
#if defined(HAVE_GETRLIMIT)
struct rlimit rlim;
-# ifdef RLIMIT_RSS
- if (getrlimit (RLIMIT_RSS, &rlim) == 0
+# if defined (RLIMIT_AS)
+ /* RLIMIT_AS is what POSIX says is the limit on mmap. Presumably
+ any OS which has RLIMIT_AS also has a working mmap that GCC will use. */
+ if (getrlimit (RLIMIT_AS, &rlim) == 0
&& rlim.rlim_cur != (rlim_t) RLIM_INFINITY
&& rlim.rlim_cur < limit)
limit = rlim.rlim_cur;
-# endif
-# ifdef RLIMIT_DATA
+# elif defined (RLIMIT_DATA)
+ /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
+ might be on an OS that has a broken mmap. (Others don't bound
+ mmap at all, apparently.) */
if (getrlimit (RLIMIT_DATA, &rlim) == 0
&& rlim.rlim_cur != (rlim_t) RLIM_INFINITY
- && rlim.rlim_cur < limit)
+ && rlim.rlim_cur < limit
+ /* Darwin has this horribly bogus default setting of
+ RLIMIT_DATA, to 6144Kb. No-one notices because RLIMIT_DATA
+ appears to be ignored. Ignore such silliness. If a limit
+ this small was actually effective for mmap, GCC wouldn't even
+ start up. */
+ && rlim.rlim_cur >= 8 * 1024 * 1024)
limit = rlim.rlim_cur;
-# endif
-# ifdef RLIMIT_AS
- if (getrlimit (RLIMIT_AS, &rlim) == 0
- && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
- && rlim.rlim_cur < limit)
- limit = rlim.rlim_cur;
-# endif
+# endif /* RLIMIT_AS or RLIMIT_DATA */
#endif /* HAVE_GETRLIMIT */
return limit;
int
ggc_min_heapsize_heuristic (void)
{
- double min_heap_kbytes = physmem_total();
-
- /* Adjust for rlimits. */
- min_heap_kbytes = ggc_rlimit_bound (min_heap_kbytes);
+ double phys_kbytes = physmem_total();
+ double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
- min_heap_kbytes /= 1024; /* Convert to Kbytes. */
+ phys_kbytes /= 1024; /* Convert to Kbytes. */
+ limit_kbytes /= 1024;
/* The heuristic is RAM/8, with a lower bound of 4M and an upper
bound of 128M (when RAM >= 1GB). */
- min_heap_kbytes /= 8;
- min_heap_kbytes = MAX (min_heap_kbytes, 4 * 1024);
- min_heap_kbytes = MIN (min_heap_kbytes, 128 * 1024);
+ phys_kbytes /= 8;
+
+#if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
+ /* Try not to overrun the RSS limit while doing garbage collection.
+ The RSS limit is only advisory, so no margin is subtracted. */
+ {
+ struct rlimit rlim;
+ if (getrlimit (RLIMIT_RSS, &rlim) == 0
+ && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
+ phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024);
+ }
+# endif
+
+ /* Don't blindly run over our data limit; do GC at least when the
+ *next* GC would be within 16Mb of the limit. If GCC does hit the
+ data limit, compilation will fail, so this tries to be
+ conservative. */
+ limit_kbytes = MAX (0, limit_kbytes - 16 * 1024);
+ limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic());
+ phys_kbytes = MIN (phys_kbytes, limit_kbytes);
- return min_heap_kbytes;
+ phys_kbytes = MAX (phys_kbytes, 4 * 1024);
+ phys_kbytes = MIN (phys_kbytes, 128 * 1024);
+
+ return phys_kbytes;
}
void
return *slot;
}
-/* Record ALLOCATED and OVERHEAD bytes to descritor NAME:LINE (FUNCTION). */
-void ggc_record_overhead (size_t allocated, size_t overhead,
- const char *name, int line, const char *function)
+/* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */
+void
+ggc_record_overhead (size_t allocated, size_t overhead,
+ const char *name, int line, const char *function)
{
struct loc_descriptor *loc = loc_descriptor (name, line, function);
OSDN Git Service
