Share memory blocks between pool allocators

gcc/
	* 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.

gcc/c-family/
	* c-format.c (check_format_arg): Adjust to use common block size in all
	object pools.

From-SVN: r227817

1 files changed, 75 insertions, 0 deletions

diff --git a/gcc/memory-block.h b/gcc/memory-block.h
new file mode 100644
index 00000000000..1a495eaea0e
--- /dev/null
+++ b/gcc/memory-block.h
@@ -0,0 +1,75 @@
+/* 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 */