/* Functions to support a pool of allocatable objects.
- Copyright (C) 1987, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007
- Free Software Foundation, Inc.
+ Copyright (C) 1987-2014 Free Software Foundation, Inc.
Contributed by Daniel Berlin <dan@cgsoftware.com>
This file is part of GCC.
#include "config.h"
#include "system.h"
+#include "coretypes.h"
#include "alloc-pool.h"
-#include "hashtab.h"
+#include "hash-table.h"
+#include "hash-map.h"
#define align_eight(x) (((x+7) >> 3) << 3)
/* Because we want any type of data to be well aligned after the ID,
the following elements are here. They are never accessed so
- the allocated object may be even smaller than this structure. */
+ the allocated object may be even smaller than this structure.
+ We do not care about alignment for floating-point types. */
char *align_p;
- HOST_WIDEST_INT align_i;
- long double align_ld;
+ int64_t align_i;
} u;
} allocation_object;
static ALLOC_POOL_ID_TYPE last_id;
#endif
-#ifdef GATHER_STATISTICS
-
-/* Store information about each particular alloc_pool. */
+/* Store information about each particular alloc_pool. Note that this
+ will underestimate the amount the amount of storage used by a small amount:
+ 1) The overhead in a pool is not accounted for.
+ 2) The unallocated elements in a block are not accounted for. Note
+ that this can at worst case be one element smaller that the block
+ size for that pool. */
struct alloc_pool_descriptor
{
- const char *name;
- int allocated;
- int created;
- int peak;
- int current;
+ /* Number of pools allocated. */
+ unsigned long created;
+ /* Gross allocated storage. */
+ unsigned long allocated;
+ /* Amount of currently active storage. */
+ unsigned long current;
+ /* Peak amount of storage used. */
+ unsigned long peak;
+ /* Size of element in the pool. */
+ int elt_size;
};
/* Hashtable mapping alloc_pool names to descriptors. */
-static htab_t alloc_pool_hash;
-
-/* Hashtable helpers. */
-static hashval_t
-hash_descriptor (const void *p)
-{
- const struct alloc_pool_descriptor *d = p;
- return htab_hash_pointer (d->name);
-}
-static int
-eq_descriptor (const void *p1, const void *p2)
-{
- const struct alloc_pool_descriptor *d = p1;
- return d->name == p2;
-}
+static hash_map<const char *, alloc_pool_descriptor> *alloc_pool_hash;
/* For given name, return descriptor, create new if needed. */
static struct alloc_pool_descriptor *
-alloc_pool_descriptor (const char *name)
+allocate_pool_descriptor (const char *name)
{
- struct alloc_pool_descriptor **slot;
-
if (!alloc_pool_hash)
- alloc_pool_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
-
- slot = (struct alloc_pool_descriptor **)
- htab_find_slot_with_hash (alloc_pool_hash, name,
- htab_hash_pointer (name),
- 1);
- if (*slot)
- return *slot;
- *slot = xcalloc (sizeof (**slot), 1);
- (*slot)->name = name;
- return *slot;
+ alloc_pool_hash = new hash_map<const char *, alloc_pool_descriptor> (10);
+
+ return &alloc_pool_hash->get_or_insert (name);
}
-#endif
/* Create a pool of things of size SIZE, with NUM in each block we
allocate. */
{
alloc_pool pool;
size_t header_size;
-#ifdef GATHER_STATISTICS
- struct alloc_pool_descriptor *desc;
-#endif
- gcc_assert (name);
+ gcc_checking_assert (name);
/* Make size large enough to store the list header. */
if (size < sizeof (alloc_pool_list))
#endif
/* Um, we can't really allocate 0 elements per block. */
- gcc_assert (num);
+ gcc_checking_assert (num);
/* Allocate memory for the pool structure. */
pool = XNEW (struct alloc_pool_def);
/* Now init the various pieces of our pool structure. */
pool->name = /*xstrdup (name)*/name;
-#ifdef GATHER_STATISTICS
- desc = alloc_pool_descriptor (name);
- desc->created++;
-#endif
pool->elt_size = size;
pool->elts_per_block = num;
+ if (GATHER_STATISTICS)
+ {
+ struct alloc_pool_descriptor *desc = allocate_pool_descriptor (name);
+ desc->elt_size = size;
+ desc->created++;
+ }
+
/* List header size should be a multiple of 8. */
header_size = align_eight (sizeof (struct alloc_pool_list_def));
empty_alloc_pool (alloc_pool pool)
{
alloc_pool_list block, next_block;
-#ifdef GATHER_STATISTICS
- struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
-#endif
- gcc_assert (pool);
+ gcc_checking_assert (pool);
/* Free each block allocated to the pool. */
for (block = pool->block_list; block != NULL; block = next_block)
{
next_block = block->next;
free (block);
-#ifdef GATHER_STATISTICS
- desc->current -= pool->block_size;
-#endif
+ }
+
+ if (GATHER_STATISTICS)
+ {
+ struct alloc_pool_descriptor *desc = allocate_pool_descriptor (pool->name);
+ desc->current -= (pool->elts_allocated - pool->elts_free) * pool->elt_size;
}
pool->returned_free_list = NULL;
pool_alloc (alloc_pool pool)
{
alloc_pool_list header;
-#ifdef GATHER_STATISTICS
- struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
-
- desc->allocated+=pool->elt_size;
+#ifdef ENABLE_VALGRIND_ANNOTATIONS
+ int size;
#endif
- gcc_assert (pool);
+ if (GATHER_STATISTICS)
+ {
+ struct alloc_pool_descriptor *desc = allocate_pool_descriptor (pool->name);
+
+ desc->allocated += pool->elt_size;
+ desc->current += pool->elt_size;
+ if (desc->peak < desc->current)
+ desc->peak = desc->current;
+ }
+
+ gcc_checking_assert (pool);
+#ifdef ENABLE_VALGRIND_ANNOTATIONS
+ size = pool->elt_size - offsetof (allocation_object, u.data);
+#endif
/* If there are no more free elements, make some more!. */
if (!pool->returned_free_list)
block = XNEWVEC (char, pool->block_size);
block_header = (alloc_pool_list) block;
block += align_eight (sizeof (struct alloc_pool_list_def));
-#ifdef GATHER_STATISTICS
- desc->current += pool->block_size;
- if (desc->peak < desc->current)
- desc->peak = desc->current;
-#endif
-
+
/* Throw it on the block list. */
block_header->next = pool->block_list;
pool->block_list = block_header;
pool->blocks_allocated += 1;
}
-
+
/* We now know that we can take the first elt off the virgin list and
put it on the returned list. */
block = pool->virgin_free_list;
/* Mark the element to be free. */
((allocation_object *) block)->id = 0;
#endif
+ VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (header,size));
pool->returned_free_list = header;
pool->virgin_free_list += pool->elt_size;
pool->virgin_elts_remaining--;
/* Pull the first free element from the free list, and return it. */
header = pool->returned_free_list;
+ VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (header, sizeof (*header)));
pool->returned_free_list = header->next;
pool->elts_free--;
/* Set the ID for element. */
ALLOCATION_OBJECT_PTR_FROM_USER_PTR (header)->id = pool->id;
#endif
+ VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (header, size));
return ((void *) header);
}
pool_free (alloc_pool pool, void *ptr)
{
alloc_pool_list header;
-
- gcc_assert (ptr);
+#if defined(ENABLE_VALGRIND_ANNOTATIONS) || defined(ENABLE_CHECKING)
+ int size;
+ size = pool->elt_size - offsetof (allocation_object, u.data);
+#endif
#ifdef ENABLE_CHECKING
- /* Check whether the PTR was allocated from POOL. */
- gcc_assert (pool->id == ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id);
+ gcc_assert (ptr
+ /* Check if we free more than we allocated, which is Bad (TM). */
+ && pool->elts_free < pool->elts_allocated
+ /* Check whether the PTR was allocated from POOL. */
+ && pool->id == ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id);
- memset (ptr, 0xaf, pool->elt_size - offsetof (allocation_object, u.data));
+ memset (ptr, 0xaf, size);
/* Mark the element to be free. */
ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id = 0;
-#else
- /* Check if we free more than we allocated, which is Bad (TM). */
- gcc_assert (pool->elts_free < pool->elts_allocated);
#endif
header = (alloc_pool_list) ptr;
header->next = pool->returned_free_list;
pool->returned_free_list = header;
+ VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (ptr, size));
pool->elts_free++;
+
+ if (GATHER_STATISTICS)
+ {
+ struct alloc_pool_descriptor *desc = allocate_pool_descriptor (pool->name);
+ desc->current -= pool->elt_size;
+ }
}
+
/* Output per-alloc_pool statistics. */
-#ifdef GATHER_STATISTICS
/* Used to accumulate statistics about alloc_pool sizes. */
-struct output_info
+struct pool_output_info
{
- int count;
- int size;
+ unsigned long total_created;
+ unsigned long total_allocated;
};
-/* Called via htab_traverse. Output alloc_pool descriptor pointed out by SLOT
- and update statistics. */
-static int
-print_statistics (void **slot, void *b)
+/* Called via hash_map.traverse. Output alloc_pool descriptor pointed out by
+ SLOT and update statistics. */
+bool
+print_alloc_pool_statistics (const char *const &name,
+ const alloc_pool_descriptor &d,
+ struct pool_output_info *i)
{
- struct alloc_pool_descriptor *d = (struct alloc_pool_descriptor *) *slot;
- struct output_info *i = (struct output_info *) b;
-
- if (d->allocated)
+ if (d.allocated)
{
- fprintf (stderr, "%-21s %6d %10d %10d %10d\n", d->name,
- d->created, d->allocated, d->peak, d->current);
- i->size += d->allocated;
- i->count += d->created;
+ fprintf (stderr,
+ "%-22s %6d %10lu %10lu(%10lu) %10lu(%10lu) %10lu(%10lu)\n",
+ name, d.elt_size, d.created, d.allocated,
+ d.allocated / d.elt_size, d.peak, d.peak / d.elt_size,
+ d.current, d.current / d.elt_size);
+ i->total_allocated += d.allocated;
+ i->total_created += d.created;
}
return 1;
}
-#endif
/* Output per-alloc_pool memory usage statistics. */
void
dump_alloc_pool_statistics (void)
{
-#ifdef GATHER_STATISTICS
- struct output_info info;
+ struct pool_output_info info;
+
+ if (! GATHER_STATISTICS)
+ return;
if (!alloc_pool_hash)
return;
- fprintf (stderr, "\nAlloc-pool Kind Pools Allocated Peak Leak\n");
- fprintf (stderr, "-------------------------------------------------------------\n");
- info.count = 0;
- info.size = 0;
- htab_traverse (alloc_pool_hash, print_statistics, &info);
- fprintf (stderr, "-------------------------------------------------------------\n");
- fprintf (stderr, "%-20s %7d %10d\n",
- "Total", info.count, info.size);
- fprintf (stderr, "-------------------------------------------------------------\n");
-#endif
+ fprintf (stderr, "\nAlloc-pool Kind Elt size Pools Allocated (elts) Peak (elts) Leak (elts)\n");
+ fprintf (stderr, "--------------------------------------------------------------------------------------------------------------\n");
+ info.total_created = 0;
+ info.total_allocated = 0;
+ alloc_pool_hash->traverse <struct pool_output_info *,
+ print_alloc_pool_statistics> (&info);
+ fprintf (stderr, "--------------------------------------------------------------------------------------------------------------\n");
+ fprintf (stderr, "%-22s %7lu %10lu\n",
+ "Total", info.total_created, info.total_allocated);
+ fprintf (stderr, "--------------------------------------------------------------------------------------------------------------\n");
}
projects / gcc.git / blobdiff