+2015-09-16 Mikhail Maltsev <maltsevm@gmail.com>
+
+ * Makefile.in: Add memory-block.cc
+ (pool_allocator::initialize): Use fixed block size.
+ (pool_allocator::release): Use memory_block_pool.
+ (pool_allocator::allocate): Likewise.
+ * asan.c (asan_mem_ref_pool): Adjust to use common block size in all
+ object pools.
+ * cfg.c (initialize_original_copy_tables): Likewise.
+ * cselib.c (elt_list_pool, elt_loc_list_pool,
+ cselib_val_pool): Likewise.
+ * df-problems.c (df_chain_alloc): Likewise.
+ * df-scan.c (df_scan_alloc): Likewise.
+ * dse.c (cse_store_info_pool, rtx_store_info_pool,
+ read_info_type_pool, insn_info_type_pool, bb_info_pool,
+ group_info_pool, deferred_change_pool): Likewise.
+ * et-forest.c (et_nodes, et_occurrences): Likewise.
+ * ipa-cp.c (ipcp_cst_values_pool, ipcp_sources_pool,
+ ipcp_agg_lattice_pool): Likewise.
+ * ipa-inline-analysis.c (edge_predicate_pool): Likewise.
+ * ipa-profile.c (histogram_pool): Likewise.
+ * ipa-prop.c (ipa_refdesc_pool): Likewise.
+ * ira-build.c (live_range_pool, allocno_pool, object_pool,
+ initiate_cost_vectors, pref_pool, copy_pool): Likewise.
+ * ira-color.c (update_cost_record_pool): Likewise.
+ * lra-lives.c (lra_live_range_pool): Likewise.
+ * lra.c (lra_insn_reg_pool, lra_copy_pool): Likewise.
+ * memory-block.cc: New file.
+ * memory-block.h: New file.
+ * regcprop.c (queued_debug_insn_change_pool): Use common block size.
+ * sched-deps.c (sched_deps_init): Likewise.
+ * sel-sched-ir.c (sched_lists_pool): Likewise.
+ * stmt.c (expand_case, expand_sjlj_dispatch_table): Likewise.
+ * tree-sra.c (access_pool): Likewise.
+ * tree-ssa-math-opts.c (pass_cse_reciprocals::execute): Likewise.
+ * tree-ssa-pre.c (pre_expr_pool, bitmap_set_pool): Likewise.
+ * tree-ssa-reassoc.c (operand_entry_pool): Likewise.
+ * tree-ssa-sccvn.c (allocate_vn_table): Likewise.
+ * tree-ssa-strlen.c (strinfo_pool): Likewise.
+ * tree-ssa-structalias.c (variable_info_pool): Likewise.
+ * var-tracking.c (attrs_def_pool, var_pool, valvar_pool,
+ location_chain_pool, shared_hash_pool, loc_exp_dep_pool): Likewise.
+
2015-09-15 Max Filippov <jcmvbkbc@gmail.com>
* config/xtensa/xtensa.h (DWARF_ALT_FRAME_RETURN_COLUMN): New
# Objects in libcommon.a, potentially used by all host binaries and with
# no target dependencies.
OBJS-libcommon = diagnostic.o diagnostic-color.o pretty-print.o intl.o \
- vec.o input.o version.o hash-table.o ggc-none.o
+ vec.o input.o version.o hash-table.o ggc-none.o memory-block.o
# Objects in libcommon-target.a, used by drivers and by the core
# compiler and containing target-dependent code.
#ifndef ALLOC_POOL_H
#define ALLOC_POOL_H
+#include "memory-block.h"
extern void dump_alloc_pool_statistics (void);
extern mem_alloc_description<pool_usage> pool_allocator_usage;
+#if 0
+/* If a pool with custom block size is needed, one might use the following
+ template. An instance of this template can be used as a parameter for
+ instantiating base_pool_allocator template:
+
+ typedef custom_block_allocator <128*1024> huge_block_allocator;
+ ...
+ static base_pool_allocator <huge_block_allocator>
+ value_pool ("value", 16384);
+
+ Right now it's not used anywhere in the code, and is given here as an
+ example). */
+
+template <size_t BlockSize>
+class custom_block_allocator
+{
+public:
+ static const size_t block_size = BlockSize;
+
+ static inline void *
+ allocate () ATTRIBUTE_MALLOC
+ {
+ return XNEWVEC (char, BlockSize);
+ }
+
+ static inline void
+ release (void *block)
+ {
+ XDELETEVEC (block);
+ }
+};
+#endif
+
/* Generic pool allocator. */
-class pool_allocator
+
+template <typename TBlockAllocator>
+class base_pool_allocator
{
public:
- /* Default constructor for pool allocator called NAME. Each block
- has NUM elements. */
- pool_allocator (const char *name, size_t num, size_t size CXX_MEM_STAT_INFO);
- ~pool_allocator ();
+ /* Default constructor for pool allocator called NAME. */
+ base_pool_allocator (const char *name, size_t size CXX_MEM_STAT_INFO);
+ ~base_pool_allocator ();
void release ();
void release_if_empty ();
void *allocate () ATTRIBUTE_MALLOC;
void remove (void *object);
+ size_t num_elts_current ();
private:
struct allocation_pool_list
};
/* Align X to 8. */
- size_t
+ static inline size_t
align_eight (size_t x)
{
return (((x+7) >> 3) << 3);
size_t m_blocks_allocated;
/* List of blocks that are used to allocate new objects. */
allocation_pool_list *m_block_list;
- /* The number of elements in a block. */
- size_t m_block_size;
/* Size of a pool elements in bytes. */
size_t m_elt_size;
/* Size in bytes that should be allocated for each element. */
mem_location m_location;
};
+template <typename TBlockAllocator>
inline
-pool_allocator::pool_allocator (const char *name, size_t num,
- size_t size MEM_STAT_DECL):
- m_name (name), m_id (0), m_elts_per_block (num), m_returned_free_list (NULL),
+base_pool_allocator <TBlockAllocator>::base_pool_allocator (
+ const char *name, size_t size MEM_STAT_DECL):
+ m_name (name), m_id (0), m_elts_per_block (0), m_returned_free_list (NULL),
m_virgin_free_list (NULL), m_virgin_elts_remaining (0), m_elts_allocated (0),
- m_elts_free (0), m_blocks_allocated (0), m_block_list (NULL),
- m_block_size (0), m_size (size), m_initialized (false),
- m_location (ALLOC_POOL_ORIGIN, false PASS_MEM_STAT) {}
+ m_elts_free (0), m_blocks_allocated (0), m_block_list (NULL), m_size (size),
+ m_initialized (false), m_location (ALLOC_POOL_ORIGIN, false PASS_MEM_STAT) {}
/* Initialize a pool allocator. */
+template <typename TBlockAllocator>
inline void
-pool_allocator::initialize ()
+base_pool_allocator <TBlockAllocator>::initialize ()
{
gcc_checking_assert (!m_initialized);
m_initialized = true;
- size_t header_size;
size_t size = m_size;
gcc_checking_assert (m_name);
if (size < sizeof (allocation_pool_list*))
size = sizeof (allocation_pool_list*);
- /* Now align the size to a multiple of 4. */
+ /* Now align the size to a multiple of 8. */
size = align_eight (size);
/* Add the aligned size of ID. */
size += offsetof (allocation_object, u.data);
- /* Um, we can't really allocate 0 elements per block. */
- gcc_checking_assert (m_elts_per_block);
-
m_elt_size = size;
if (GATHER_STATISTICS)
}
/* List header size should be a multiple of 8. */
- header_size = align_eight (sizeof (allocation_pool_list));
+ size_t header_size = align_eight (sizeof (allocation_pool_list));
- m_block_size = (size * m_elts_per_block) + header_size;
+ m_elts_per_block = (TBlockAllocator::block_size - header_size) / size;
+ gcc_checking_assert (m_elts_per_block != 0);
#ifdef ENABLE_CHECKING
/* Increase the last used ID and use it for this pool.
}
/* Free all memory allocated for the given memory pool. */
+template <typename TBlockAllocator>
inline void
-pool_allocator::release ()
+base_pool_allocator <TBlockAllocator>::release ()
{
if (!m_initialized)
return;
for (block = m_block_list; block != NULL; block = next_block)
{
next_block = block->next;
- free (block);
+ TBlockAllocator::release (block);
}
if (GATHER_STATISTICS)
m_block_list = NULL;
}
-void
-inline pool_allocator::release_if_empty ()
+template <typename TBlockAllocator>
+inline void
+base_pool_allocator <TBlockAllocator>::release_if_empty ()
{
if (m_elts_free == m_elts_allocated)
release ();
}
-inline pool_allocator::~pool_allocator ()
+template <typename TBlockAllocator>
+inline base_pool_allocator <TBlockAllocator>::~base_pool_allocator ()
{
release ();
}
/* Allocates one element from the pool specified. */
+template <typename TBlockAllocator>
inline void*
-pool_allocator::allocate ()
+base_pool_allocator <TBlockAllocator>::allocate ()
{
if (!m_initialized)
initialize ();
allocation_pool_list *block_header;
/* Make the block. */
- block = XNEWVEC (char, m_block_size);
+ block = reinterpret_cast<char *> (TBlockAllocator::allocate ());
block_header = (allocation_pool_list*) block;
block += align_eight (sizeof (allocation_pool_list));
}
/* Puts PTR back on POOL's free list. */
+template <typename TBlockAllocator>
inline void
-pool_allocator::remove (void *object)
+base_pool_allocator <TBlockAllocator>::remove (void *object)
{
gcc_checking_assert (m_initialized);
}
}
+/* Number of elements currently active (not returned to pool). Used for cheap
+ consistency checks. */
+template <typename TBlockAllocator>
+inline size_t
+base_pool_allocator <TBlockAllocator>::num_elts_current ()
+{
+ return m_elts_allocated - m_elts_free;
+}
+
+/* Specialization of base_pool_allocator which should be used in most cases.
+ Another specialization may be needed, if object size is greater than
+ memory_block_pool::block_size (64 KB). */
+typedef base_pool_allocator <memory_block_pool> pool_allocator;
+
/* Type based memory pool allocator. */
template <typename T>
class object_allocator
{
public:
- /* Default constructor for pool allocator called NAME. Each block
- has NUM elements. */
- object_allocator (const char *name, size_t num CXX_MEM_STAT_INFO):
- m_allocator (name, num, sizeof (T) PASS_MEM_STAT) {}
+ /* Default constructor for pool allocator called NAME. */
+ object_allocator (const char *name CXX_MEM_STAT_INFO):
+ m_allocator (name, sizeof (T) PASS_MEM_STAT) {}
inline void
release ()
m_allocator.remove (object);
}
+ inline size_t
+ num_elts_current ()
+ {
+ return m_allocator.num_elts_current ();
+ }
+
private:
pool_allocator m_allocator;
};
HOST_WIDE_INT access_size;
};
-object_allocator <asan_mem_ref> asan_mem_ref_pool ("asan_mem_ref", 10);
+object_allocator <asan_mem_ref> asan_mem_ref_pool ("asan_mem_ref");
/* Initializes an instance of asan_mem_ref. */
+2015-09-16 Mikhail Maltsev <maltsevm@gmail.com>
+
+ * c-format.c (check_format_arg): Adjust to use common block size in all
+ object pools.
+
2015-09-15 David Malcolm <dmalcolm@redhat.com>
* c-format.c (location_from_offset): Update for change in
will decrement it if it finds there are extra arguments, but this way
need not adjust it for every return. */
res->number_other++;
- object_allocator <format_wanted_type> fwt_pool ("format_wanted_type pool",
- 10);
+ object_allocator <format_wanted_type> fwt_pool ("format_wanted_type pool");
check_format_info_main (res, info, format_chars, format_length,
params, arg_num, fwt_pool);
}
initialize_original_copy_tables (void)
{
original_copy_bb_pool = new object_allocator<htab_bb_copy_original_entry>
- ("original_copy", 10);
+ ("original_copy");
bb_original = new hash_table<bb_copy_hasher> (10);
bb_copy = new hash_table<bb_copy_hasher> (10);
loop_copy = new hash_table<bb_copy_hasher> (10);
typedef struct basic_block_def *basic_block;
typedef const struct basic_block_def *const_basic_block;
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-#define OBSTACK_CHUNK_SIZE 0
+#if !defined (GENERATOR_FILE)
+# define OBSTACK_CHUNK_SIZE memory_block_pool::block_size
+# define obstack_chunk_alloc mempool_obstack_chunk_alloc
+# define obstack_chunk_free mempool_obstack_chunk_free
+#else
+# define OBSTACK_CHUNK_SIZE 0
+# define obstack_chunk_alloc xmalloc
+# define obstack_chunk_free free
+#endif
+
#define gcc_obstack_init(OBSTACK) \
obstack_specify_allocation ((OBSTACK), OBSTACK_CHUNK_SIZE, 0, \
obstack_chunk_alloc, \
#include "hash-set.h"
#include "input.h"
#include "is-a.h"
+#include "memory-block.h"
#endif /* GENERATOR_FILE && !USED_FOR_TARGET */
#endif /* coretypes.h */
each time memory is invalidated. */
static cselib_val *first_containing_mem = &dummy_val;
-static object_allocator<elt_list> elt_list_pool ("elt_list", 10);
-static object_allocator<elt_loc_list> elt_loc_list_pool ("elt_loc_list", 10);
-static object_allocator<cselib_val> cselib_val_pool ("cselib_val_list", 10);
+static object_allocator<elt_list> elt_list_pool ("elt_list");
+static object_allocator<elt_loc_list> elt_loc_list_pool ("elt_loc_list");
+static object_allocator<cselib_val> cselib_val_pool ("cselib_val_list");
-static pool_allocator value_pool ("value", 100, RTX_CODE_SIZE (VALUE));
+static pool_allocator value_pool ("value", RTX_CODE_SIZE (VALUE));
/* If nonnull, cselib will call this function before freeing useless
VALUEs. A VALUE is deemed useless if its "locs" field is null. */
df_chain_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
{
df_chain_remove_problem ();
- df_chain->block_pool = new object_allocator<df_link> ("df_chain_block pool",
- 50);
+ df_chain->block_pool = new object_allocator<df_link> ("df_chain_block pool");
df_chain->optional_p = true;
}
it gets run. It also has no need for the iterative solver.
----------------------------------------------------------------------------*/
-#define SCAN_PROBLEM_DATA_BLOCK_SIZE 512
-
/* Problem data for the scanning dataflow function. */
struct df_scan_problem_data
{
df_scan->computed = true;
problem_data->ref_base_pool = new object_allocator<df_base_ref>
- ("df_scan ref base", SCAN_PROBLEM_DATA_BLOCK_SIZE);
+ ("df_scan ref base");
problem_data->ref_artificial_pool = new object_allocator<df_artificial_ref>
- ("df_scan ref artificial", SCAN_PROBLEM_DATA_BLOCK_SIZE);
+ ("df_scan ref artificial");
problem_data->ref_regular_pool = new object_allocator<df_regular_ref>
- ("df_scan ref regular", SCAN_PROBLEM_DATA_BLOCK_SIZE);
+ ("df_scan ref regular");
problem_data->insn_pool = new object_allocator<df_insn_info>
- ("df_scan insn", SCAN_PROBLEM_DATA_BLOCK_SIZE);
+ ("df_scan insn");
problem_data->reg_pool = new object_allocator<df_reg_info>
- ("df_scan reg", SCAN_PROBLEM_DATA_BLOCK_SIZE);
+ ("df_scan reg");
problem_data->mw_reg_pool = new object_allocator<df_mw_hardreg>
- ("df_scan mw_reg", SCAN_PROBLEM_DATA_BLOCK_SIZE / 16);
+ ("df_scan mw_reg");
bitmap_obstack_initialize (&problem_data->reg_bitmaps);
bitmap_obstack_initialize (&problem_data->insn_bitmaps);
return mask >> (HOST_BITS_PER_WIDE_INT - n);
}
-static object_allocator<store_info> cse_store_info_pool ("cse_store_info_pool",
- 100);
+static object_allocator<store_info> cse_store_info_pool ("cse_store_info_pool");
-static object_allocator<store_info> rtx_store_info_pool ("rtx_store_info_pool",
- 100);
+static object_allocator<store_info> rtx_store_info_pool ("rtx_store_info_pool");
/* This structure holds information about a load. These are only
built for rtx bases. */
};
typedef struct read_info_type *read_info_t;
-static object_allocator<read_info_type> read_info_type_pool
- ("read_info_pool", 100);
+static object_allocator<read_info_type> read_info_type_pool ("read_info_pool");
/* One of these records is created for each insn. */
};
typedef struct insn_info_type *insn_info_t;
-static object_allocator<insn_info_type> insn_info_type_pool
- ("insn_info_pool", 100);
+static object_allocator<insn_info_type> insn_info_type_pool ("insn_info_pool");
/* The linked list of stores that are under consideration in this
basic block. */
typedef struct dse_bb_info_type *bb_info_t;
static object_allocator<dse_bb_info_type> dse_bb_info_type_pool
- ("bb_info_pool", 100);
+ ("bb_info_pool");
/* Table to hold all bb_infos. */
static bb_info_t *bb_table;
int offset_map_size_n, offset_map_size_p;
};
-static object_allocator<group_info> group_info_pool
- ("rtx_group_info_pool", 100);
+static object_allocator<group_info> group_info_pool ("rtx_group_info_pool");
/* Index into the rtx_group_vec. */
static int rtx_group_next_id;
};
static object_allocator<deferred_change> deferred_change_pool
- ("deferred_change_pool", 10);
+ ("deferred_change_pool");
static deferred_change *deferred_change_list = NULL;
depth. */
};
-static object_allocator<et_node> et_nodes ("et_nodes pool", 300);
-static object_allocator<et_occ> et_occurrences ("et_occ pool", 300);
+static object_allocator<et_node> et_nodes ("et_nodes pool");
+static object_allocator<et_occ> et_occurrences ("et_occ pool");
/* Changes depth of OCC to D. */
/* Allocation pools for values and their sources in ipa-cp. */
object_allocator<ipcp_value<tree> > ipcp_cst_values_pool
- ("IPA-CP constant values", 32);
+ ("IPA-CP constant values");
object_allocator<ipcp_value<ipa_polymorphic_call_context> >
- ipcp_poly_ctx_values_pool ("IPA-CP polymorphic contexts", 32);
+ ipcp_poly_ctx_values_pool ("IPA-CP polymorphic contexts");
object_allocator<ipcp_value_source<tree> > ipcp_sources_pool
- ("IPA-CP value sources", 64);
+ ("IPA-CP value sources");
object_allocator<ipcp_agg_lattice> ipcp_agg_lattice_pool
- ("IPA_CP aggregate lattices", 32);
+ ("IPA_CP aggregate lattices");
/* Maximal count found in program. */
vec<edge_growth_cache_entry> edge_growth_cache;
/* Edge predicates goes here. */
-static object_allocator<predicate> edge_predicate_pool ("edge predicates", 10);
+static object_allocator<predicate> edge_predicate_pool ("edge predicates");
/* Return true predicate (tautology).
We represent it by empty list of clauses. */
duplicate entries. */
vec<histogram_entry *> histogram;
-static object_allocator<histogram_entry> histogram_pool
- ("IPA histogram", 10);
+static object_allocator<histogram_entry> histogram_pool ("IPA histogram");
/* Hashtable support for storing SSA names hashed by their SSA_NAME_VAR. */
/* Allocation pool for reference descriptions. */
static object_allocator<ipa_cst_ref_desc> ipa_refdesc_pool
- ("IPA-PROP ref descriptions", 32);
+ ("IPA-PROP ref descriptions");
/* Return true if DECL_FUNCTION_SPECIFIC_OPTIMIZATION of the decl associated
with NODE should prevent us from analyzing it for the purposes of IPA-CP. */
\f
/* Pools for allocnos, allocno live ranges and objects. */
-static object_allocator<live_range> live_range_pool ("live ranges", 100);
-static object_allocator<ira_allocno> allocno_pool ("allocnos", 100);
-static object_allocator<ira_object> object_pool ("objects", 100);
+static object_allocator<live_range> live_range_pool ("live ranges");
+static object_allocator<ira_allocno> allocno_pool ("allocnos");
+static object_allocator<ira_object> object_pool ("objects");
/* Vec containing references to all created allocnos. It is a
container of array allocnos. */
\f
/* Pools for allocno preferences. */
-static object_allocator <ira_allocno_pref> pref_pool ("prefs", 100);
+static object_allocator <ira_allocno_pref> pref_pool ("prefs");
/* Vec containing references to all created preferences. It is a
container of array ira_prefs. */
\f
/* Pools for copies. */
-static object_allocator<ira_allocno_copy> copy_pool ("copies", 100);
+static object_allocator<ira_allocno_copy> copy_pool ("copies");
/* Vec containing references to all created copies. It is a
container of array ira_copies. */
{
aclass = ira_allocno_classes[i];
cost_vector_pool[aclass] = new pool_allocator
- ("cost vectors", 100,
- sizeof (int) * (ira_class_hard_regs_num[aclass]));
+ ("cost vectors", sizeof (int) * (ira_class_hard_regs_num[aclass]));
}
}
/* Pool for update cost records. */
static object_allocator<update_cost_record> update_cost_record_pool
- ("update cost records", 100);
+ ("update cost records");
/* Return new update cost record with given params. */
static struct update_cost_record *
static bitmap_head temp_bitmap;
/* Pool for pseudo live ranges. */
-static object_allocator<lra_live_range> lra_live_range_pool
- ("live ranges", 100);
+static object_allocator<lra_live_range> lra_live_range_pool ("live ranges");
/* Free live range list LR. */
static void
insns. */
/* Pools for insn reg info. */
-object_allocator<lra_insn_reg> lra_insn_reg_pool ("insn regs", 100);
+object_allocator<lra_insn_reg> lra_insn_reg_pool ("insn regs");
/* Create LRA insn related info about a reference to REGNO in INSN with
TYPE (in/out/inout), biggest reference mode MODE, flag that it is
}
/* Pools for copies. */
-static object_allocator<lra_copy> lra_copy_pool ("lra copies", 100);
+static object_allocator<lra_copy> lra_copy_pool ("lra copies");
/* Finish LRA data about all insns. */
static void
--- /dev/null
+/* Shared pool of memory blocks for pool allocators.
+ Copyright (C) 2015 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
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "memory-block.h"
+#include "obstack.h"
+
+/* Global singleton-like instance. */
+memory_block_pool memory_block_pool::instance;
+
+memory_block_pool::memory_block_pool () : m_blocks (NULL) {}
+
+/* Return all blocks from free list to the OS. */
+void
+memory_block_pool::clear_free_list ()
+{
+ while (m_blocks)
+ {
+ block_list *next = m_blocks->m_next;
+ XDELETEVEC (m_blocks);
+ m_blocks = next;
+ }
+}
+
+/* Allocate a chunk for obstack. Use the pool if requested chunk size matches
+ the size of blocks in the pool. */
+void *
+mempool_obstack_chunk_alloc (size_t size)
+{
+ if (size == memory_block_pool::block_size)
+ return memory_block_pool::allocate ();
+ else
+ return XNEWVEC (char, size);
+}
+
+/* Free previously allocated obstack chunk. */
+void
+mempool_obstack_chunk_free (void *chunk)
+{
+ size_t size = (reinterpret_cast<_obstack_chunk *> (chunk)->limit
+ - reinterpret_cast<char *> (chunk));
+ if (size == memory_block_pool::block_size)
+ memory_block_pool::release (chunk);
+ else
+ XDELETEVEC (chunk);
+}
--- /dev/null
+/* Shared pool of memory blocks for pool allocators.
+ Copyright (C) 2015 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 Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+
+#ifndef MEMORY_BLOCK_H
+#define MEMORY_BLOCK_H
+
+/* Shared pool which allows other memory pools to reuse each others' allocated
+ memory blocks instead of calling free/malloc again. */
+class memory_block_pool
+{
+public:
+ /* Blocks have fixed size. This is necessary for sharing. */
+ static const size_t block_size = 64 * 1024;
+
+ memory_block_pool ();
+
+ static inline void *allocate () ATTRIBUTE_MALLOC;
+ static inline void release (void *);
+ void clear_free_list ();
+
+private:
+ /* memory_block_pool singleton instance, defined in memory-block.cc. */
+ static memory_block_pool instance;
+
+ struct block_list
+ {
+ block_list *m_next;
+ };
+
+ /* Free list. */
+ block_list *m_blocks;
+};
+
+/* Allocate a single block. Reuse a previously returned block, if possible. */
+inline void *
+memory_block_pool::allocate ()
+{
+ if (instance.m_blocks == NULL)
+ return XNEWVEC (char, block_size);
+
+ void *result = instance.m_blocks;
+ instance.m_blocks = instance.m_blocks->m_next;
+ return result;
+}
+
+/* Return UNCAST_BLOCK to the pool. */
+inline void
+memory_block_pool::release (void *uncast_block)
+{
+ block_list *block = new (uncast_block) block_list;
+ block->m_next = instance.m_blocks;
+ instance.m_blocks = block;
+}
+
+extern void *mempool_obstack_chunk_alloc (size_t) ATTRIBUTE_MALLOC;
+extern void mempool_obstack_chunk_free (void *);
+
+#endif /* MEMORY_BLOCK_H */
};
static object_allocator<queued_debug_insn_change> queued_debug_insn_change_pool
- ("debug insn changes pool", 256);
+ ("debug insn changes pool");
static bool skip_debug_insn_p;
if (global_p)
{
- dl_pool = new object_allocator<_deps_list> ("deps_list",
- /* Allocate lists for one block at a time. */
- insns_in_block);
- dn_pool = new object_allocator<_dep_node> ("dep_node",
- /* Allocate nodes for one block at a time.
- We assume that average insn has
- 5 producers. */
- 5 * insns_in_block);
+ dl_pool = new object_allocator<_deps_list> ("deps_list");
+ /* Allocate lists for one block at a time. */
+ dn_pool = new object_allocator<_dep_node> ("dep_node");
+ /* Allocate nodes for one block at a time. */
}
}
sel_region_bb_info = vNULL;
/* A pool for allocating all lists. */
-object_allocator<_list_node> sched_lists_pool ("sel-sched-lists", 500);
+object_allocator<_list_node> sched_lists_pool ("sel-sched-lists");
/* This contains information about successors for compute_av_set. */
struct succs_info current_succs;
struct case_node *case_list = 0;
/* A pool for case nodes. */
- object_allocator<case_node> case_node_pool ("struct case_node pool", 100);
+ object_allocator<case_node> case_node_pool ("struct case_node pool");
/* An ERROR_MARK occurs for various reasons including invalid data type.
??? Can this still happen, with GIMPLE and all? */
{
/* Similar to expand_case, but much simpler. */
struct case_node *case_list = 0;
- object_allocator<case_node> case_node_pool ("struct sjlj_case pool",
- ncases);
+ object_allocator<case_node> case_node_pool ("struct sjlj_case pool");
tree index_expr = make_tree (index_type, dispatch_index);
tree minval = build_int_cst (index_type, 0);
tree maxval = CASE_LOW (dispatch_table.last ());
/* Alloc pool for allocating access structures. */
-static object_allocator<struct access> access_pool ("SRA accesses", 16);
+static object_allocator<struct access> access_pool ("SRA accesses");
/* A structure linking lhs and rhs accesses from an aggregate assignment. They
are used to propagate subaccesses from rhs to lhs as long as they don't
};
/* Alloc pool for allocating assign link structures. */
-static object_allocator<assign_link> assign_link_pool ("SRA links", 16);
+static object_allocator<assign_link> assign_link_pool ("SRA links");
/* Base (tree) -> Vector (vec<access_p> *) map. */
static hash_map<tree, auto_vec<access_p> > *base_access_vec;
basic_block bb;
tree arg;
- occ_pool = new object_allocator<occurrence>
- ("dominators for recip", n_basic_blocks_for_fn (fun) / 3 + 1);
+ occ_pool = new object_allocator<occurrence> ("dominators for recip");
memset (&reciprocal_stats, 0, sizeof (reciprocal_stats));
calculate_dominance_info (CDI_DOMINATORS);
expressions.release ();
}
-static object_allocator<pre_expr_d> pre_expr_pool ("pre_expr nodes", 30);
+static object_allocator<pre_expr_d> pre_expr_pool ("pre_expr nodes");
/* Given an SSA_NAME NAME, get or create a pre_expr to represent it. */
/* We can add and remove elements and entries to and from sets
and hash tables, so we use alloc pools for them. */
-static object_allocator<bitmap_set> bitmap_set_pool ("Bitmap sets", 30);
+static object_allocator<bitmap_set> bitmap_set_pool ("Bitmap sets");
static bitmap_obstack grand_bitmap_obstack;
/* Set of blocks with statements that have had their EH properties changed. */
unsigned int count;
} *operand_entry_t;
-static object_allocator<operand_entry> operand_entry_pool ("operand entry pool",
- 30);
+static object_allocator<operand_entry> operand_entry_pool
+ ("operand entry pool");
/* This is used to assign a unique ID to each struct operand_entry
so that qsort results are identical on different hosts. */
table->references = new vn_reference_table_type (23);
gcc_obstack_init (&table->nary_obstack);
- table->phis_pool = new object_allocator<vn_phi_s> ("VN phis", 30);
+ table->phis_pool = new object_allocator<vn_phi_s> ("VN phis");
table->references_pool = new object_allocator<vn_reference_s>
- ("VN references", 30);
+ ("VN references");
}
/* Free a value number table. */
} *strinfo;
/* Pool for allocating strinfo_struct entries. */
-static object_allocator<strinfo_struct> strinfo_pool ("strinfo_struct pool",
- 64);
+static object_allocator<strinfo_struct> strinfo_pool ("strinfo_struct pool");
/* Vector mapping positive string indexes to strinfo, for the
current basic block. The first pointer in the vector is special,
/* Pool of variable info structures. */
static object_allocator<variable_info> variable_info_pool
- ("Variable info pool", 30);
+ ("Variable info pool");
/* Map varinfo to final pt_solution. */
static hash_map<varinfo_t, pt_solution *> *final_solutions;
/* List of constraints that we use to build the constraint graph from. */
static vec<constraint_t> constraints;
-static object_allocator<constraint> constraint_pool ("Constraint pool", 30);
+static object_allocator<constraint> constraint_pool ("Constraint pool");
/* The constraint graph is represented as an array of bitmaps
containing successor nodes. */
} *variable_tracking_info;
/* Alloc pool for struct attrs_def. */
-object_allocator<attrs_def> attrs_def_pool ("attrs_def pool", 1024);
+object_allocator<attrs_def> attrs_def_pool ("attrs_def pool");
/* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
static pool_allocator var_pool
- ("variable_def pool", 64, sizeof (variable_def) +
+ ("variable_def pool", sizeof (variable_def) +
(MAX_VAR_PARTS - 1) * sizeof (((variable)NULL)->var_part[0]));
/* Alloc pool for struct variable_def with a single var_part entry. */
static pool_allocator valvar_pool
- ("small variable_def pool", 256, sizeof (variable_def));
+ ("small variable_def pool", sizeof (variable_def));
-/* Alloc pool for struct location_chain_def. */
+/* Alloc pool for struct location_chain. */
static object_allocator<location_chain> location_chain_pool
- ("location_chain pool", 1024);
+ ("location_chain pool");
-/* Alloc pool for struct shared_hash_def. */
-static object_allocator<shared_hash> shared_hash_pool
- ("shared_hash pool", 256);
+/* Alloc pool for struct shared_hash. */
+static object_allocator<shared_hash> shared_hash_pool ("shared_hash pool");
/* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */
-object_allocator<loc_exp_dep> loc_exp_dep_pool ("loc_exp_dep pool", 64);
+object_allocator<loc_exp_dep> loc_exp_dep_pool ("loc_exp_dep pool");
/* Changed variables, notes will be emitted for them. */
static variable_table_type *changed_variables;
projects / gcc.git / commitdiff