From patchwork Mon Aug 3 08:40:58 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mikhail Maltsev X-Patchwork-Id: 503061 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 418A41402D5 for ; Mon, 3 Aug 2015 18:41:24 +1000 (AEST) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b=fmzkpJ2Z; dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:date:from:mime-version:to:cc:subject:references :in-reply-to:content-type; q=dns; s=default; b=qFTMBIvSudcaLhujg 9J2Rp10vl9lIOdhCF5pM8r3lbgDlFWN29VVNmvpBjhLDC4kJeCaQye1rOUQ+z69X Nkj8w9zQ4BIV7nZ8I2vFY24/94mNZGUpkt5eI7+V1eYIavoPRUgKFKH1/qVH7ph/ y3j02GYabo07WxHPafRTTZw4KE= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:date:from:mime-version:to:cc:subject:references :in-reply-to:content-type; s=default; bh=XzabMbwIi3r+Bc2QRvu47fS wI1o=; b=fmzkpJ2Zz2Erxi1v+8adZcu1u3bka0I2HYSdSbYr4y0hKRO1grF9I8q Mf8hMxIC07otCLZyMvGOcW7AsC6/KKK8o/sJmgTuxBVa+HAXLfUkun7VVH3ee3YW D0EJUZ7gmRXH8gjMVOCi6ZET0UutC9y+oji2IvgBNlGU0up88l38= Received: (qmail 128748 invoked by alias); 3 Aug 2015 08:41:15 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 128730 invoked by uid 89); 3 Aug 2015 08:41:15 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.6 required=5.0 tests=AWL, BAYES_50, FREEMAIL_FROM, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-la0-f48.google.com Received: from mail-la0-f48.google.com (HELO mail-la0-f48.google.com) (209.85.215.48) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Mon, 03 Aug 2015 08:41:04 +0000 Received: by labow3 with SMTP id ow3so11657311lab.1 for ; Mon, 03 Aug 2015 01:41:00 -0700 (PDT) X-Received: by 10.112.218.67 with SMTP id pe3mr15400898lbc.111.1438591260524; Mon, 03 Aug 2015 01:41:00 -0700 (PDT) Received: from [192.168.123.200] ([77.41.78.126]) by smtp.googlemail.com with ESMTPSA id jl4sm2828566lbc.14.2015.08.03.01.40.59 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 03 Aug 2015 01:40:59 -0700 (PDT) Message-ID: <55BF291A.2010405@gmail.com> Date: Mon, 03 Aug 2015 11:40:58 +0300 From: Mikhail Maltsev User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Icedove/31.7.0 MIME-Version: 1.0 To: Richard Biener , Andrew Pinski CC: Andi Kleen , gcc-patches mailing list , mliska , Jeff Law Subject: Re: [PATCH] Use single shared memory block pool for all pool allocators References: <55B51674.4080203@gmail.com> <87y4i2rbxj.fsf@tassilo.jf.intel.com> <2378E38A-ACE5-47BB-8A45-BEE3F8486E49@gmail.com> In-Reply-To: X-IsSubscribed: yes On Jul 26, 2015, at 11:50 AM, Andi Kleen wrote: > I've been compiling gcc with tcmalloc to do a similar speedup. It would be > interesting to compare that to your patch. I repeated the test with TCMalloc and jemalloc. TCMalloc shows nice results, though it required some tweaks: this allocator has a threshold block size equal to 32 KB, larger blocks are allocated from global heap, rather than thread cache (and this operation is expensive), so the original patch shows worse performance when used with TCMalloc. In order to fix this, I reduced the block size to 8 KB. Here there are 5 columns for each value: pristine version, pristine version + TCMalloc (and the difference in parenthesis), and patched version with TCMalloc (difference is relative to pristine version). Likewise, for memory usage. 400.perlbench 26.86 26.17 ( -2.57%) 26.17 ( -2.57%) user 0.56 0.64 ( +14.29%) 0.61 ( +8.93%) sys 27.45 26.84 ( -2.22%) 26.81 ( -2.33%) real 401.bzip2 2.53 2.5 ( -1.19%) 2.48 ( -1.98%) user 0.07 0.09 ( +28.57%) 0.1 ( +42.86%) sys 2.61 2.6 ( -0.38%) 2.59 ( -0.77%) real 403.gcc 73.59 72.62 ( -1.32%) 71.72 ( -2.54%) user 1.59 1.88 ( +18.24%) 1.88 ( +18.24%) sys 75.27 74.58 ( -0.92%) 73.67 ( -2.13%) real 429.mcf 0.4 0.41 ( +2.50%) 0.4 ( +0.00%) user 0.03 0.05 ( +66.67%) 0.05 ( +66.67%) sys 0.44 0.47 ( +6.82%) 0.47 ( +6.82%) real 433.milc 3.22 3.24 ( +0.62%) 3.25 ( +0.93%) user 0.22 0.32 ( +45.45%) 0.3 ( +36.36%) sys 3.48 3.59 ( +3.16%) 3.59 ( +3.16%) real 444.namd 7.54 7.41 ( -1.72%) 7.37 ( -2.25%) user 0.1 0.15 ( +50.00%) 0.15 ( +50.00%) sys 7.66 7.58 ( -1.04%) 7.54 ( -1.57%) real 445.gobmk 20.24 19.59 ( -3.21%) 19.6 ( -3.16%) user 0.52 0.67 ( +28.85%) 0.59 ( +13.46%) sys 20.8 20.29 ( -2.45%) 20.23 ( -2.74%) real 450.soplex 19.08 18.47 ( -3.20%) 18.51 ( -2.99%) user 0.87 1.11 ( +27.59%) 1.06 ( +21.84%) sys 19.99 19.62 ( -1.85%) 19.6 ( -1.95%) real 453.povray 42.27 41.42 ( -2.01%) 41.32 ( -2.25%) user 2.71 3.11 ( +14.76%) 3.09 ( +14.02%) sys 45.04 44.58 ( -1.02%) 44.47 ( -1.27%) real 456.hmmer 7.27 7.22 ( -0.69%) 7.15 ( -1.65%) user 0.31 0.36 ( +16.13%) 0.39 ( +25.81%) sys 7.61 7.61 ( +0.00%) 7.57 ( -0.53%) real 458.sjeng 3.22 3.14 ( -2.48%) 3.15 ( -2.17%) user 0.09 0.16 ( +77.78%) 0.14 ( +55.56%) sys 3.32 3.32 ( +0.00%) 3.3 ( -0.60%) real 462.libquantum 0.86 0.87 ( +1.16%) 0.85 ( -1.16%) user 0.05 0.08 ( +60.00%) 0.08 ( +60.00%) sys 0.92 0.96 ( +4.35%) 0.94 ( +2.17%) real 464.h264ref 27.62 27.27 ( -1.27%) 27.16 ( -1.67%) user 0.63 0.73 ( +15.87%) 0.75 ( +19.05%) sys 28.28 28.03 ( -0.88%) 27.95 ( -1.17%) real 470.lbm 0.27 0.27 ( +0.00%) 0.27 ( +0.00%) user 0.01 0.01 ( +0.00%) 0.01 ( +0.00%) sys 0.29 0.29 ( +0.00%) 0.29 ( +0.00%) real 471.omnetpp 28.29 27.63 ( -2.33%) 27.54 ( -2.65%) user 1.5 1.57 ( +4.67%) 1.62 ( +8.00%) sys 29.84 29.25 ( -1.98%) 29.21 ( -2.11%) real 473.astar 1.14 1.12 ( -1.75%) 1.11 ( -2.63%) user 0.05 0.07 ( +40.00%) 0.09 ( +80.00%) sys 1.21 1.21 ( +0.00%) 1.2 ( -0.83%) real 482.sphinx3 4.65 4.57 ( -1.72%) 4.59 ( -1.29%) user 0.2 0.3 ( +50.00%) 0.26 ( +30.00%) sys 4.88 4.89 ( +0.20%) 4.88 ( +0.00%) real 483.xalancbmk 284.5 276.4 ( -2.85%) 276.48 ( -2.82%) user 20.29 23.03 ( +13.50%) 22.82 ( +12.47%) sys 305.19 299.79 ( -1.77%) 299.67 ( -1.81%) real 400.perlbench 102308kB 123004kB ( +20696kB) 116104kB ( +13796kB) 401.bzip2 74628kB 86936kB ( +12308kB) 84316kB ( +9688kB) 403.gcc 190284kB 218180kB ( +27896kB) 212480kB ( +22196kB) 429.mcf 19804kB 24464kB ( +4660kB) 24320kB ( +4516kB) 433.milc 36940kB 45308kB ( +8368kB) 44652kB ( +7712kB) 444.namd 183548kB 193856kB ( +10308kB) 192632kB ( +9084kB) 445.gobmk 73724kB 78792kB ( +5068kB) 79192kB ( +5468kB) 450.soplex 62076kB 67596kB ( +5520kB) 66856kB ( +4780kB) 453.povray 180620kB 208480kB ( +27860kB) 207576kB ( +26956kB) 456.hmmer 39544kB 47380kB ( +7836kB) 46776kB ( +7232kB) 458.sjeng 40144kB 48652kB ( +8508kB) 47608kB ( +7464kB) 462.libquantum 23464kB 28576kB ( +5112kB) 28260kB ( +4796kB) 464.h264ref 708760kB 738400kB ( +29640kB) 734224kB ( +25464kB) 470.lbm 26552kB 31684kB ( +5132kB) 31348kB ( +4796kB) 471.omnetpp 152000kB 172924kB ( +20924kB) 167204kB ( +15204kB) 473.astar 27036kB 31472kB ( +4436kB) 31380kB ( +4344kB) 482.sphinx3 33100kB 40812kB ( +7712kB) 39496kB ( +6396kB) 483.xalancbmk 368844kB 393292kB ( +24448kB) 393032kB ( +24188kB) jemalloc causes regression (and that is rather surprising, because my previous tests showed the opposite result, but those tests had very small workload - in fact, a single file). On 07/27/2015 12:13 PM, Richard Biener wrote: >>> On Jul 26, 2015, at 11:50 AM, Andi Kleen wrote: >>> Another useful optimization is to adjust the allocation size to be >= >>> 2MB. Then modern Linux kernels often can give you a large page, >>> which cuts down TLB overhead. I did similar changes some time >>> ago for the garbage collector. >> >> Unless you are running with 64k pages which I do all the time on my armv8 system. > > This can be a host configurable value of course. Yes, I actually mentioned that among possible enhancements. I think that code from ggc-page.c can be reused (it already implements querying page size from OS). > But first of all (without looking at the patch but just reading the > description) this > sounds like a good idea. Maybe still allow pools to use their own backing if > the object size is larger than the block size of the caching pool? Yes, I though about it, but I hesitated, whether this should be implemented in advance. I attached the updated patch. diff --git a/gcc/alloc-pool.c b/gcc/alloc-pool.c index 7e25915..f8c1351 100644 --- a/gcc/alloc-pool.c +++ b/gcc/alloc-pool.c @@ -35,3 +35,25 @@ dump_alloc_pool_statistics (void) pool_allocator_usage.dump (ALLOC_POOL_ORIGIN); } + +/* Global singleton-like instance. */ +memory_block_pool memory_block_pool::instance; + +memory_block_pool::memory_block_pool () : m_blocks (NULL) {} + +memory_block_pool::~memory_block_pool () +{ + release (); +} + +/* Free all memory allocated by memory_block_pool. */ +void +memory_block_pool::release () +{ + while (m_blocks) + { + block_list *next = m_blocks->m_next; + XDELETEVEC (m_blocks); + m_blocks = next; + } +} diff --git a/gcc/alloc-pool.h b/gcc/alloc-pool.h index 03bde63..dccc41a 100644 --- a/gcc/alloc-pool.h +++ b/gcc/alloc-pool.h @@ -95,18 +95,102 @@ struct pool_usage: public mem_usage extern mem_alloc_description pool_allocator_usage; +/* 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 (); + ~memory_block_pool (); + + static inline void *allocate () ATTRIBUTE_MALLOC; + static inline void remove (void *); + void release (); + +private: + /* memory_block_pool singleton instance, defined in alloc-pool.c. */ + static memory_block_pool instance; + + struct block_list + { + block_list *m_next; + }; + + /* Free list. */ + block_list *m_blocks; +}; + +/* Allocate single block. Reuse 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 pool. */ +inline void +memory_block_pool::remove (void *uncast_block) +{ + block_list *block = reinterpret_cast (uncast_block); + block->m_next = instance.m_blocks; + instance.m_blocks = block; +} + +#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 + value_pool ("value", 16384); + + Right now it's not used anywhere in the code, and is given here as an + example). */ + +template +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 + remove (void *block) + { + XDELETEVEC (block); + } +}; +#endif + /* Generic pool allocator. */ -class pool_allocator + +template +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 @@ -151,7 +235,7 @@ private: }; /* Align X to 8. */ - size_t + static inline size_t align_eight (size_t x) { return (((x+7) >> 3) << 3); @@ -180,8 +264,6 @@ private: 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. */ @@ -192,24 +274,24 @@ private: mem_location m_location; }; +template 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 ::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 inline void -pool_allocator::initialize () +base_pool_allocator ::initialize () { gcc_checking_assert (!m_initialized); m_initialized = true; - size_t header_size; size_t size = m_size; gcc_checking_assert (m_name); @@ -218,15 +300,12 @@ pool_allocator::initialize () 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) @@ -239,9 +318,10 @@ pool_allocator::initialize () } /* 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. @@ -255,8 +335,9 @@ pool_allocator::initialize () } /* Free all memory allocated for the given memory pool. */ +template inline void -pool_allocator::release () +base_pool_allocator ::release () { if (!m_initialized) return; @@ -267,7 +348,7 @@ pool_allocator::release () for (block = m_block_list; block != NULL; block = next_block) { next_block = block->next; - free (block); + TBlockAllocator::remove (block); } if (GATHER_STATISTICS) @@ -285,21 +366,24 @@ pool_allocator::release () m_block_list = NULL; } -void -inline pool_allocator::release_if_empty () +template +inline void +base_pool_allocator ::release_if_empty () { if (m_elts_free == m_elts_allocated) release (); } -inline pool_allocator::~pool_allocator () +template +inline base_pool_allocator ::~base_pool_allocator () { release (); } /* Allocates one element from the pool specified. */ +template inline void* -pool_allocator::allocate () +base_pool_allocator ::allocate () { if (!m_initialized) initialize (); @@ -327,7 +411,7 @@ pool_allocator::allocate () allocation_pool_list *block_header; /* Make the block. */ - block = XNEWVEC (char, m_block_size); + block = reinterpret_cast (TBlockAllocator::allocate ()); block_header = (allocation_pool_list*) block; block += align_eight (sizeof (allocation_pool_list)); @@ -378,8 +462,9 @@ pool_allocator::allocate () } /* Puts PTR back on POOL's free list. */ +template inline void -pool_allocator::remove (void *object) +base_pool_allocator ::remove (void *object) { gcc_checking_assert (m_initialized); @@ -412,15 +497,28 @@ pool_allocator::remove (void *object) } } +/* Number of elements currently active (not returned to pool). Used for cheap + consistency checks. */ +template +inline size_t +base_pool_allocator ::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 pool_allocator; + /* Type based memory pool allocator. */ template 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 () @@ -448,6 +546,12 @@ public: m_allocator.remove (object); } + inline size_t + num_elts_current () + { + return m_allocator.num_elts_current (); + } + private: pool_allocator m_allocator; }; diff --git a/gcc/asan.c b/gcc/asan.c index 4f5adaa..7c243cd 100644 --- a/gcc/asan.c +++ b/gcc/asan.c @@ -350,7 +350,7 @@ struct asan_mem_ref HOST_WIDE_INT access_size; }; -object_allocator asan_mem_ref_pool ("asan_mem_ref", 10); +object_allocator asan_mem_ref_pool ("asan_mem_ref"); /* Initializes an instance of asan_mem_ref. */ diff --git a/gcc/c-family/c-format.c b/gcc/c-family/c-format.c index 4bc3147..d92a4fd 100644 --- a/gcc/c-family/c-format.c +++ b/gcc/c-family/c-format.c @@ -1687,8 +1687,7 @@ check_format_arg (void *ctx, tree format_tree, 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 fwt_pool ("format_wanted_type pool", - 10); + object_allocator fwt_pool ("format_wanted_type pool"); check_format_info_main (res, info, format_chars, format_length, params, arg_num, fwt_pool); } diff --git a/gcc/cfg.c b/gcc/cfg.c index c998492..2bc7857 100644 --- a/gcc/cfg.c +++ b/gcc/cfg.c @@ -1052,7 +1052,7 @@ void initialize_original_copy_tables (void) { original_copy_bb_pool = new object_allocator - ("original_copy", 10); + ("original_copy"); bb_original = new hash_table (10); bb_copy = new hash_table (10); loop_copy = new hash_table (10); diff --git a/gcc/cselib.c b/gcc/cselib.c index 2149959..4264394 100644 --- a/gcc/cselib.c +++ b/gcc/cselib.c @@ -246,11 +246,11 @@ static unsigned int cfa_base_preserved_regno = INVALID_REGNUM; each time memory is invalidated. */ static cselib_val *first_containing_mem = &dummy_val; -static object_allocator elt_list_pool ("elt_list", 10); -static object_allocator elt_loc_list_pool ("elt_loc_list", 10); -static object_allocator cselib_val_pool ("cselib_val_list", 10); +static object_allocator elt_list_pool ("elt_list"); +static object_allocator elt_loc_list_pool ("elt_loc_list"); +static object_allocator 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. */ diff --git a/gcc/df-problems.c b/gcc/df-problems.c index d4b5d76..0ab533f 100644 --- a/gcc/df-problems.c +++ b/gcc/df-problems.c @@ -1997,8 +1997,7 @@ static void df_chain_alloc (bitmap all_blocks ATTRIBUTE_UNUSED) { df_chain_remove_problem (); - df_chain->block_pool = new object_allocator ("df_chain_block pool", - 50); + df_chain->block_pool = new object_allocator ("df_chain_block pool"); df_chain->optional_p = true; } diff --git a/gcc/df-scan.c b/gcc/df-scan.c index 93c2eae..7f6bf6f 100644 --- a/gcc/df-scan.c +++ b/gcc/df-scan.c @@ -133,8 +133,6 @@ static const unsigned int copy_all = copy_defs | copy_uses | copy_eq_uses 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 { @@ -253,17 +251,17 @@ df_scan_alloc (bitmap all_blocks ATTRIBUTE_UNUSED) df_scan->computed = true; problem_data->ref_base_pool = new object_allocator - ("df_scan ref base", SCAN_PROBLEM_DATA_BLOCK_SIZE); + ("df_scan ref base"); problem_data->ref_artificial_pool = new object_allocator - ("df_scan ref artificial", SCAN_PROBLEM_DATA_BLOCK_SIZE); + ("df_scan ref artificial"); problem_data->ref_regular_pool = new object_allocator - ("df_scan ref regular", SCAN_PROBLEM_DATA_BLOCK_SIZE); + ("df_scan ref regular"); problem_data->insn_pool = new object_allocator - ("df_scan insn", SCAN_PROBLEM_DATA_BLOCK_SIZE); + ("df_scan insn"); problem_data->reg_pool = new object_allocator - ("df_scan reg", SCAN_PROBLEM_DATA_BLOCK_SIZE); + ("df_scan reg"); problem_data->mw_reg_pool = new object_allocator - ("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); diff --git a/gcc/dse.c b/gcc/dse.c index ff26fc0..d34cb48 100644 --- a/gcc/dse.c +++ b/gcc/dse.c @@ -308,11 +308,9 @@ lowpart_bitmask (int n) } typedef struct store_info *store_info_t; -static object_allocator cse_store_info_pool ("cse_store_info_pool", - 100); +static object_allocator cse_store_info_pool ("cse_store_info_pool"); -static object_allocator rtx_store_info_pool ("rtx_store_info_pool", - 100); +static object_allocator rtx_store_info_pool ("rtx_store_info_pool"); /* This structure holds information about a load. These are only built for rtx bases. */ @@ -337,8 +335,7 @@ struct read_info_type }; typedef struct read_info_type *read_info_t; -static object_allocator read_info_type_pool - ("read_info_pool", 100); +static object_allocator read_info_type_pool ("read_info_pool"); /* One of these records is created for each insn. */ @@ -427,8 +424,7 @@ struct insn_info_type }; typedef struct insn_info_type *insn_info_t; -static object_allocator insn_info_type_pool - ("insn_info_pool", 100); +static object_allocator insn_info_type_pool ("insn_info_pool"); /* The linked list of stores that are under consideration in this basic block. */ @@ -495,7 +491,7 @@ struct dse_bb_info_type typedef struct dse_bb_info_type *bb_info_t; static object_allocator dse_bb_info_type_pool - ("bb_info_pool", 100); + ("bb_info_pool"); /* Table to hold all bb_infos. */ static bb_info_t *bb_table; @@ -567,8 +563,7 @@ struct group_info typedef struct group_info *group_info_t; typedef const struct group_info *const_group_info_t; -static object_allocator group_info_pool - ("rtx_group_info_pool", 100); +static object_allocator group_info_pool ("rtx_group_info_pool"); /* Index into the rtx_group_vec. */ static int rtx_group_next_id; @@ -594,7 +589,7 @@ struct deferred_change typedef struct deferred_change *deferred_change_t; static object_allocator deferred_change_pool - ("deferred_change_pool", 10); + ("deferred_change_pool"); static deferred_change_t deferred_change_list = NULL; diff --git a/gcc/et-forest.c b/gcc/et-forest.c index 1931285..4f919d4 100644 --- a/gcc/et-forest.c +++ b/gcc/et-forest.c @@ -54,8 +54,8 @@ struct et_occ depth. */ }; -static object_allocator et_nodes ("et_nodes pool", 300); -static object_allocator et_occurrences ("et_occ pool", 300); +static object_allocator et_nodes ("et_nodes pool"); +static object_allocator et_occurrences ("et_occ pool"); /* Changes depth of OCC to D. */ diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index 8de7e56..69a181d 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -276,16 +276,16 @@ public: /* Allocation pools for values and their sources in ipa-cp. */ object_allocator > ipcp_cst_values_pool - ("IPA-CP constant values", 32); + ("IPA-CP constant values"); object_allocator > - ipcp_poly_ctx_values_pool ("IPA-CP polymorphic contexts", 32); + ipcp_poly_ctx_values_pool ("IPA-CP polymorphic contexts"); object_allocator > ipcp_sources_pool - ("IPA-CP value sources", 64); + ("IPA-CP value sources"); object_allocator ipcp_agg_lattice_pool - ("IPA_CP aggregate lattices", 32); + ("IPA_CP aggregate lattices"); /* Maximal count found in program. */ diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c index 3a8f0ec..4822329 100644 --- a/gcc/ipa-inline-analysis.c +++ b/gcc/ipa-inline-analysis.c @@ -143,7 +143,7 @@ vec inline_edge_summary_vec; vec edge_growth_cache; /* Edge predicates goes here. */ -static object_allocator edge_predicate_pool ("edge predicates", 10); +static object_allocator edge_predicate_pool ("edge predicates"); /* Return true predicate (tautology). We represent it by empty list of clauses. */ diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c index 1b929c6..382897c 100644 --- a/gcc/ipa-profile.c +++ b/gcc/ipa-profile.c @@ -87,8 +87,7 @@ struct histogram_entry duplicate entries. */ vec histogram; -static object_allocator histogram_pool - ("IPA histogram", 10); +static object_allocator histogram_pool ("IPA histogram"); /* Hashtable support for storing SSA names hashed by their SSA_NAME_VAR. */ diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c index c862cff..8e0f182 100644 --- a/gcc/ipa-prop.c +++ b/gcc/ipa-prop.c @@ -95,7 +95,7 @@ struct ipa_cst_ref_desc /* Allocation pool for reference descriptions. */ static object_allocator 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. */ diff --git a/gcc/ira-build.c b/gcc/ira-build.c index 333dfb7..067a608 100644 --- a/gcc/ira-build.c +++ b/gcc/ira-build.c @@ -421,9 +421,9 @@ rebuild_regno_allocno_maps (void) /* Pools for allocnos, allocno live ranges and objects. */ -static object_allocator live_range_pool ("live ranges", 100); -static object_allocator allocno_pool ("allocnos", 100); -static object_allocator object_pool ("objects", 100); +static object_allocator live_range_pool ("live ranges"); +static object_allocator allocno_pool ("allocnos"); +static object_allocator object_pool ("objects"); /* Vec containing references to all created allocnos. It is a container of array allocnos. */ @@ -1171,7 +1171,7 @@ finish_allocnos (void) /* Pools for allocno preferences. */ -static object_allocator pref_pool ("prefs", 100); +static object_allocator pref_pool ("prefs"); /* Vec containing references to all created preferences. It is a container of array ira_prefs. */ @@ -1358,7 +1358,7 @@ finish_prefs (void) /* Pools for copies. */ -static object_allocator copy_pool ("copies", 100); +static object_allocator copy_pool ("copies"); /* Vec containing references to all created copies. It is a container of array ira_copies. */ @@ -1631,8 +1631,7 @@ initiate_cost_vectors (void) { 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])); } } diff --git a/gcc/ira-color.c b/gcc/ira-color.c index 74d2c2e..e6533c6 100644 --- a/gcc/ira-color.c +++ b/gcc/ira-color.c @@ -1157,7 +1157,7 @@ setup_profitable_hard_regs (void) /* Pool for update cost records. */ static object_allocator update_cost_record_pool - ("update cost records", 100); + ("update cost records"); /* Return new update cost record with given params. */ static struct update_cost_record * diff --git a/gcc/lra-lives.c b/gcc/lra-lives.c index e139846..bf25740 100644 --- a/gcc/lra-lives.c +++ b/gcc/lra-lives.c @@ -107,8 +107,7 @@ static sparseset unused_set, dead_set; static bitmap_head temp_bitmap; /* Pool for pseudo live ranges. */ -static object_allocator lra_live_range_pool - ("live ranges", 100); +static object_allocator lra_live_range_pool ("live ranges"); /* Free live range list LR. */ static void diff --git a/gcc/lra.c b/gcc/lra.c index 8ced164..895483c 100644 --- a/gcc/lra.c +++ b/gcc/lra.c @@ -533,7 +533,7 @@ lra_update_dups (lra_insn_recog_data_t id, signed char *nops) insns. */ /* Pools for insn reg info. */ -object_allocator lra_insn_reg_pool ("insn regs", 100); +object_allocator 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 @@ -746,7 +746,7 @@ free_insn_recog_data (lra_insn_recog_data_t data) } /* Pools for copies. */ -static object_allocator lra_copy_pool ("lra copies", 100); +static object_allocator lra_copy_pool ("lra copies"); /* Finish LRA data about all insns. */ static void diff --git a/gcc/regcprop.c b/gcc/regcprop.c index 97433f0..6f7d01e 100644 --- a/gcc/regcprop.c +++ b/gcc/regcprop.c @@ -75,7 +75,7 @@ struct value_data }; static object_allocator queued_debug_insn_change_pool - ("debug insn changes pool", 256); + ("debug insn changes pool"); static bool skip_debug_insn_p; diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c index 3ac66e8..57ff1ef 100644 --- a/gcc/sched-deps.c +++ b/gcc/sched-deps.c @@ -4058,14 +4058,10 @@ sched_deps_init (bool global_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. */ } } diff --git a/gcc/sel-sched-ir.c b/gcc/sel-sched-ir.c index 9988285..8ea4dce 100644 --- a/gcc/sel-sched-ir.c +++ b/gcc/sel-sched-ir.c @@ -59,7 +59,7 @@ vec 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; diff --git a/gcc/stmt.c b/gcc/stmt.c index 391686c..61a986d 100644 --- a/gcc/stmt.c +++ b/gcc/stmt.c @@ -1139,7 +1139,7 @@ expand_case (gswitch *stmt) struct case_node *case_list = 0; /* A pool for case nodes. */ - object_allocator case_node_pool ("struct case_node pool", 100); + object_allocator 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? */ @@ -1315,8 +1315,7 @@ expand_sjlj_dispatch_table (rtx dispatch_index, { /* Similar to expand_case, but much simpler. */ struct case_node *case_list = 0; - object_allocator case_node_pool ("struct sjlj_case pool", - ncases); + object_allocator 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 ()); diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 818c290..6638bc1 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -277,7 +277,7 @@ typedef struct access *access_p; /* Alloc pool for allocating access structures. */ -static object_allocator access_pool ("SRA accesses", 16); +static object_allocator 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 @@ -289,7 +289,7 @@ struct assign_link }; /* Alloc pool for allocating assign link structures. */ -static object_allocator assign_link_pool ("SRA links", 16); +static object_allocator assign_link_pool ("SRA links"); /* Base (tree) -> Vector (vec *) map. */ static hash_map > *base_access_vec; diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c index eae5358..c8d0d33 100644 --- a/gcc/tree-ssa-math-opts.c +++ b/gcc/tree-ssa-math-opts.c @@ -547,8 +547,7 @@ pass_cse_reciprocals::execute (function *fun) basic_block bb; tree arg; - occ_pool = new object_allocator - ("dominators for recip", n_basic_blocks_for_fn (fun) / 3 + 1); + occ_pool = new object_allocator ("dominators for recip"); memset (&reciprocal_stats, 0, sizeof (reciprocal_stats)); calculate_dominance_info (CDI_DOMINATORS); diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index 041cb78..05c2d9c 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -349,7 +349,7 @@ clear_expression_ids (void) expressions.release (); } -static object_allocator pre_expr_pool ("pre_expr nodes", 30); +static object_allocator pre_expr_pool ("pre_expr nodes"); /* Given an SSA_NAME NAME, get or create a pre_expr to represent it. */ @@ -488,7 +488,7 @@ static unsigned int get_expr_value_id (pre_expr); /* 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_pool ("Bitmap sets", 30); +static object_allocator bitmap_set_pool ("Bitmap sets"); static bitmap_obstack grand_bitmap_obstack; /* Set of blocks with statements that have had their EH properties changed. */ diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index efb813c..51934c0 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -209,8 +209,8 @@ typedef struct operand_entry unsigned int count; } *operand_entry_t; -static object_allocator operand_entry_pool ("operand entry pool", - 30); +static object_allocator 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. */ diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index ab4b110..ba55f28 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -4125,9 +4125,9 @@ allocate_vn_table (vn_tables_t table) table->references = new vn_reference_table_type (23); gcc_obstack_init (&table->nary_obstack); - table->phis_pool = new object_allocator ("VN phis", 30); + table->phis_pool = new object_allocator ("VN phis"); table->references_pool = new object_allocator - ("VN references", 30); + ("VN references"); } /* Free a value number table. */ diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c index cfe4dd9..87f48bc 100644 --- a/gcc/tree-ssa-strlen.c +++ b/gcc/tree-ssa-strlen.c @@ -113,8 +113,7 @@ typedef struct strinfo_struct } *strinfo; /* Pool for allocating strinfo_struct entries. */ -static object_allocator strinfo_pool ("strinfo_struct pool", - 64); +static object_allocator 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, diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index c1f3c32..f585e3c 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -323,7 +323,7 @@ static inline bool type_can_have_subvars (const_tree); /* Pool of variable info structures. */ static object_allocator variable_info_pool - ("Variable info pool", 30); + ("Variable info pool"); /* Map varinfo to final pt_solution. */ static hash_map *final_solutions; @@ -523,7 +523,7 @@ struct constraint /* List of constraints that we use to build the constraint graph from. */ static vec constraints; -static object_allocator constraint_pool ("Constraint pool", 30); +static object_allocator constraint_pool ("Constraint pool"); /* The constraint graph is represented as an array of bitmaps containing successor nodes. */ diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c index da9de28..f1a02f9 100644 --- a/gcc/var-tracking.c +++ b/gcc/var-tracking.c @@ -576,28 +576,28 @@ typedef struct variable_tracking_info_def } *variable_tracking_info; /* Alloc pool for struct attrs_def. */ -object_allocator attrs_def_pool ("attrs_def pool", 1024); +object_allocator 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. */ static object_allocator location_chain_def_pool - ("location_chain_def pool", 1024); + ("location_chain_def pool"); /* Alloc pool for struct shared_hash_def. */ static object_allocator shared_hash_def_pool - ("shared_hash_def pool", 256); + ("shared_hash_def pool"); /* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */ -object_allocator loc_exp_dep_pool ("loc_exp_dep pool", 64); +object_allocator loc_exp_dep_pool ("loc_exp_dep pool"); /* Changed variables, notes will be emitted for them. */ static variable_table_type *changed_variables;