Remove old pool allocator.
* alloc-pool.c (create_alloc_pool): Remove. (empty_alloc_pool): Likewise. (free_alloc_pool): Likewise. (free_alloc_pool_if_empty): Likewise. (pool_alloc): Likewise. (pool_free): Likewise. * alloc-pool.h: Remove old declarations. From-SVN: r223973
This commit is contained in:
Martin Liska
Martin Liska
parent
0b470bae0c
commit
fdc5c392fe
@ -1,3 +1,13 @@
|
||||
2015-06-01 Martin Liska <mliska@suse.cz>
|
||||
|
||||
* alloc-pool.c (create_alloc_pool): Remove.
|
||||
(empty_alloc_pool): Likewise.
|
||||
(free_alloc_pool): Likewise.
|
||||
(free_alloc_pool_if_empty): Likewise.
|
||||
(pool_alloc): Likewise.
|
||||
(pool_free): Likewise.
|
||||
* alloc-pool.h: Remove old declarations.
|
||||
|
||||
2015-06-01 Martin Liska <mliska@suse.cz>
|
||||
|
||||
* ira-build.c (initiate_allocnos): Use new type-based pool allocator.
|
||||
|
||||
274
gcc/alloc-pool.c
274
gcc/alloc-pool.c
@ -27,39 +27,6 @@ along with GCC; see the file COPYING3. If not see
|
||||
|
||||
ALLOC_POOL_ID_TYPE last_id;
|
||||
|
||||
#define align_eight(x) (((x+7) >> 3) << 3)
|
||||
|
||||
/* The internal allocation object. */
|
||||
typedef struct allocation_object_def
|
||||
{
|
||||
#ifdef ENABLE_CHECKING
|
||||
/* The ID of alloc pool which the object was allocated from. */
|
||||
ALLOC_POOL_ID_TYPE id;
|
||||
#endif
|
||||
|
||||
union
|
||||
{
|
||||
/* The data of the object. */
|
||||
char data[1];
|
||||
|
||||
/* 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.
|
||||
We do not care about alignment for floating-point types. */
|
||||
char *align_p;
|
||||
int64_t align_i;
|
||||
} u;
|
||||
} allocation_object;
|
||||
|
||||
/* Convert a pointer to allocation_object from a pointer to user data. */
|
||||
#define ALLOCATION_OBJECT_PTR_FROM_USER_PTR(X) \
|
||||
((allocation_object *) (((char *) (X)) \
|
||||
- offsetof (allocation_object, u.data)))
|
||||
|
||||
/* Convert a pointer to user data from a pointer to allocation_object. */
|
||||
#define USER_PTR_FROM_ALLOCATION_OBJECT_PTR(X) \
|
||||
((void *) (((allocation_object *) (X))->u.data))
|
||||
|
||||
/* Hashtable mapping alloc_pool names to descriptors. */
|
||||
hash_map<const char *, alloc_pool_descriptor> *alloc_pool_hash;
|
||||
|
||||
@ -74,247 +41,6 @@ allocate_pool_descriptor (const char *name)
|
||||
return &alloc_pool_hash->get_or_insert (name);
|
||||
}
|
||||
|
||||
|
||||
/* Create a pool of things of size SIZE, with NUM in each block we
|
||||
allocate. */
|
||||
|
||||
alloc_pool
|
||||
create_alloc_pool (const char *name, size_t size, size_t num)
|
||||
{
|
||||
alloc_pool pool;
|
||||
size_t header_size;
|
||||
|
||||
gcc_checking_assert (name);
|
||||
|
||||
/* Make size large enough to store the list header. */
|
||||
if (size < sizeof (alloc_pool_list))
|
||||
size = sizeof (alloc_pool_list);
|
||||
|
||||
/* Now align the size to a multiple of 4. */
|
||||
size = align_eight (size);
|
||||
|
||||
#ifdef ENABLE_CHECKING
|
||||
/* Add the aligned size of ID. */
|
||||
size += offsetof (allocation_object, u.data);
|
||||
#endif
|
||||
|
||||
/* Um, we can't really allocate 0 elements per block. */
|
||||
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;
|
||||
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));
|
||||
|
||||
pool->block_size = (size * num) + header_size;
|
||||
pool->returned_free_list = NULL;
|
||||
pool->virgin_free_list = NULL;
|
||||
pool->virgin_elts_remaining = 0;
|
||||
pool->elts_allocated = 0;
|
||||
pool->elts_free = 0;
|
||||
pool->blocks_allocated = 0;
|
||||
pool->block_list = NULL;
|
||||
|
||||
#ifdef ENABLE_CHECKING
|
||||
/* Increase the last used ID and use it for this pool.
|
||||
ID == 0 is used for free elements of pool so skip it. */
|
||||
last_id++;
|
||||
if (last_id == 0)
|
||||
last_id++;
|
||||
|
||||
pool->id = last_id;
|
||||
#endif
|
||||
|
||||
return (pool);
|
||||
}
|
||||
|
||||
/* Free all memory allocated for the given memory pool. */
|
||||
void
|
||||
empty_alloc_pool (alloc_pool pool)
|
||||
{
|
||||
alloc_pool_list block, next_block;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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->virgin_free_list = NULL;
|
||||
pool->virgin_elts_remaining = 0;
|
||||
pool->elts_allocated = 0;
|
||||
pool->elts_free = 0;
|
||||
pool->blocks_allocated = 0;
|
||||
pool->block_list = NULL;
|
||||
}
|
||||
|
||||
/* Free all memory allocated for the given memory pool and the pool itself. */
|
||||
void
|
||||
free_alloc_pool (alloc_pool pool)
|
||||
{
|
||||
/* First empty the pool. */
|
||||
empty_alloc_pool (pool);
|
||||
#ifdef ENABLE_CHECKING
|
||||
memset (pool, 0xaf, sizeof (*pool));
|
||||
#endif
|
||||
/* Lastly, free the pool. */
|
||||
free (pool);
|
||||
}
|
||||
|
||||
/* Frees the alloc_pool, if it is empty and zero *POOL in this case. */
|
||||
void
|
||||
free_alloc_pool_if_empty (alloc_pool *pool)
|
||||
{
|
||||
if ((*pool)->elts_free == (*pool)->elts_allocated)
|
||||
{
|
||||
free_alloc_pool (*pool);
|
||||
*pool = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* Allocates one element from the pool specified. */
|
||||
void *
|
||||
pool_alloc (alloc_pool pool)
|
||||
{
|
||||
alloc_pool_list header;
|
||||
#ifdef ENABLE_VALGRIND_ANNOTATIONS
|
||||
int size;
|
||||
#endif
|
||||
|
||||
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)
|
||||
{
|
||||
char *block;
|
||||
if (!pool->virgin_elts_remaining)
|
||||
{
|
||||
alloc_pool_list block_header;
|
||||
|
||||
/* Make the block. */
|
||||
block = XNEWVEC (char, pool->block_size);
|
||||
block_header = (alloc_pool_list) block;
|
||||
block += align_eight (sizeof (struct alloc_pool_list_def));
|
||||
|
||||
/* Throw it on the block list. */
|
||||
block_header->next = pool->block_list;
|
||||
pool->block_list = block_header;
|
||||
|
||||
/* Make the block available for allocation. */
|
||||
pool->virgin_free_list = block;
|
||||
pool->virgin_elts_remaining = pool->elts_per_block;
|
||||
|
||||
/* Also update the number of elements we have free/allocated, and
|
||||
increment the allocated block count. */
|
||||
pool->elts_allocated += pool->elts_per_block;
|
||||
pool->elts_free += pool->elts_per_block;
|
||||
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;
|
||||
header = (alloc_pool_list) USER_PTR_FROM_ALLOCATION_OBJECT_PTR (block);
|
||||
header->next = NULL;
|
||||
#ifdef ENABLE_CHECKING
|
||||
/* 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--;
|
||||
|
||||
#ifdef ENABLE_CHECKING
|
||||
/* 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);
|
||||
}
|
||||
|
||||
/* Puts PTR back on POOL's free list. */
|
||||
void
|
||||
pool_free (alloc_pool pool, void *ptr)
|
||||
{
|
||||
alloc_pool_list header;
|
||||
#if defined(ENABLE_VALGRIND_ANNOTATIONS) || defined(ENABLE_CHECKING)
|
||||
int size;
|
||||
size = pool->elt_size - offsetof (allocation_object, u.data);
|
||||
#endif
|
||||
|
||||
#ifdef ENABLE_CHECKING
|
||||
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, size);
|
||||
|
||||
/* Mark the element to be free. */
|
||||
ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id = 0;
|
||||
#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. */
|
||||
|
||||
/* Used to accumulate statistics about alloc_pool sizes. */
|
||||
|
||||
@ -22,46 +22,6 @@ along with GCC; see the file COPYING3. If not see
|
||||
|
||||
#include "hash-map.h"
|
||||
|
||||
typedef unsigned long ALLOC_POOL_ID_TYPE;
|
||||
|
||||
typedef struct alloc_pool_list_def
|
||||
{
|
||||
struct alloc_pool_list_def *next;
|
||||
}
|
||||
*alloc_pool_list;
|
||||
|
||||
typedef struct alloc_pool_def
|
||||
{
|
||||
const char *name;
|
||||
ALLOC_POOL_ID_TYPE id;
|
||||
size_t elts_per_block;
|
||||
|
||||
/* These are the elements that have been allocated at least once and freed. */
|
||||
alloc_pool_list returned_free_list;
|
||||
|
||||
/* These are the elements that have not yet been allocated out of
|
||||
the last block obtained from XNEWVEC. */
|
||||
char* virgin_free_list;
|
||||
|
||||
/* The number of elements in the virgin_free_list that can be
|
||||
allocated before needing another block. */
|
||||
size_t virgin_elts_remaining;
|
||||
|
||||
size_t elts_allocated;
|
||||
size_t elts_free;
|
||||
size_t blocks_allocated;
|
||||
alloc_pool_list block_list;
|
||||
size_t block_size;
|
||||
size_t elt_size;
|
||||
}
|
||||
*alloc_pool;
|
||||
|
||||
extern alloc_pool create_alloc_pool (const char *, size_t, size_t);
|
||||
extern void free_alloc_pool (alloc_pool);
|
||||
extern void empty_alloc_pool (alloc_pool);
|
||||
extern void free_alloc_pool_if_empty (alloc_pool *);
|
||||
extern void *pool_alloc (alloc_pool) ATTRIBUTE_MALLOC;
|
||||
extern void pool_free (alloc_pool, void *);
|
||||
extern void dump_alloc_pool_statistics (void);
|
||||
|
||||
typedef unsigned long ALLOC_POOL_ID_TYPE;
|
||||
@ -76,21 +36,10 @@ public:
|
||||
potentially IGNORE_TYPE_SIZE. */
|
||||
pool_allocator (const char *name, size_t num, size_t extra_size = 0,
|
||||
bool ignore_type_size = false);
|
||||
|
||||
/* Default destuctor. */
|
||||
~pool_allocator ();
|
||||
|
||||
/* Release internal data structures. */
|
||||
void release ();
|
||||
|
||||
/* Release internal data structures if the pool has not allocated
|
||||
an object. */
|
||||
void release_if_empty ();
|
||||
|
||||
/* Allocate a new object. */
|
||||
T *allocate () ATTRIBUTE_MALLOC;
|
||||
|
||||
/* Release OBJECT that must come from the pool. */
|
||||
void remove (T *object);
|
||||
|
||||
private:
|
||||
|
||||
Loading…
Reference in New Issue
Block a user