From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 23619 invoked by alias); 10 Jun 2010 11:35:33 -0000 Received: (qmail 23607 invoked by uid 22791); 10 Jun 2010 11:35:32 -0000 X-SWARE-Spam-Status: No, hits=-1.8 required=5.0 tests=AWL,BAYES_00,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from nikam-dmz.ms.mff.cuni.cz (HELO nikam.ms.mff.cuni.cz) (195.113.20.16) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 10 Jun 2010 11:35:23 +0000 Received: from localhost (occam.ms.mff.cuni.cz [195.113.18.121]) by nikam.ms.mff.cuni.cz (Postfix) with ESMTP id 78FEF9AC7C9; Thu, 10 Jun 2010 13:35:21 +0200 (CEST) Received: by localhost (Postfix, from userid 16202) id 72B325641B7; Thu, 10 Jun 2010 13:35:21 +0200 (CEST) Date: Thu, 10 Jun 2010 12:00:00 -0000 From: Jan Hubicka To: gcc-patches@gcc.gnu.org, bonzini@gnu.org Subject: Move df_live and df_md bitmaps to own obstacks Message-ID: <20100610113521.GB562@kam.mff.cuni.cz> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline User-Agent: Mutt/1.5.18 (2008-05-17) Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org X-SW-Source: 2010-06/txt/msg01085.txt.bz2 Hi, this patch moves df_live and df_md bitmaps to own obstacks. I believe those are all important df problems that depends on bitmap performance? Bootstrapped/regtested x86_64-linux (with df checking) OK? Honza * df-problems.c (df_live_problem_data): Add live_bitmaps. (df_live_alloc): Initialize problem data and live_osbtacks. (df_live_finalize): Remove obstack, problem data; do not clear all bitmaps. (df_live_top_dump, df_live_bottom_dump): Do not dump old data when not allocated. (df_live_verify_solution_start): Do not allocate problem data. (df_live_verify_solution_end): Check if out is allocated. (struct df_md_problem_data): New structure. (df_md_alloc): Allocate problem data. (df_md_free): Free problem data; do not clear bitmaps. Index: df-problems.c =================================================================== --- df-problems.c (revision 160501) +++ df-problems.c (working copy) @@ -1361,6 +1361,8 @@ struct df_live_problem_data { bitmap_head *in; bitmap_head *out; + /* An obstack for the bitmaps we need for this problem. */ + bitmap_obstack live_bitmaps; }; /* Scratch var used by transfer functions. This is used to implement @@ -1406,12 +1408,24 @@ df_live_alloc (bitmap all_blocks ATTRIBU { unsigned int bb_index; bitmap_iterator bi; + struct df_live_problem_data *problem_data; if (!df_live->block_pool) df_live->block_pool = create_alloc_pool ("df_live_block pool", sizeof (struct df_live_bb_info), 100); + if (df_live->problem_data) + problem_data = (struct df_live_problem_data *) df_live->problem_data; + else + { + problem_data = XNEW (struct df_live_problem_data); + df_live->problem_data = problem_data; + + problem_data->out = NULL; + problem_data->in = NULL; + bitmap_obstack_initialize (&problem_data->live_bitmaps); + } if (!df_live_scratch) - df_live_scratch = BITMAP_ALLOC (NULL); + df_live_scratch = BITMAP_ALLOC (&problem_data->live_bitmaps); df_grow_bb_info (df_live); @@ -1427,10 +1441,10 @@ df_live_alloc (bitmap all_blocks ATTRIBU { bb_info = (struct df_live_bb_info *) pool_alloc (df_live->block_pool); df_live_set_bb_info (bb_index, bb_info); - bitmap_initialize (&bb_info->kill, &bitmap_default_obstack); - bitmap_initialize (&bb_info->gen, &bitmap_default_obstack); - bitmap_initialize (&bb_info->in, &bitmap_default_obstack); - bitmap_initialize (&bb_info->out, &bitmap_default_obstack); + bitmap_initialize (&bb_info->kill, &problem_data->live_bitmaps); + bitmap_initialize (&bb_info->gen, &problem_data->live_bitmaps); + bitmap_initialize (&bb_info->in, &problem_data->live_bitmaps); + bitmap_initialize (&bb_info->out, &problem_data->live_bitmaps); } } df_live->optional_p = (optimize <= 1); @@ -1622,25 +1636,14 @@ df_live_finalize (bitmap all_blocks) static void df_live_free (void) { + struct df_live_problem_data *problem_data + = (struct df_live_problem_data *) df_live->problem_data; if (df_live->block_info) { - unsigned int i; - - for (i = 0; i < df_live->block_info_size; i++) - { - struct df_live_bb_info *bb_info = df_live_get_bb_info (i); - if (bb_info) - { - bitmap_clear (&bb_info->gen); - bitmap_clear (&bb_info->kill); - bitmap_clear (&bb_info->in); - bitmap_clear (&bb_info->out); - } - } - free_alloc_pool (df_live->block_pool); df_live->block_info_size = 0; free (df_live->block_info); + bitmap_obstack_release (&problem_data->live_bitmaps); if (df_live_scratch) BITMAP_FREE (df_live_scratch); @@ -1666,8 +1669,11 @@ df_live_top_dump (basic_block bb, FILE * if (df_live->problem_data) { problem_data = (struct df_live_problem_data *)df_live->problem_data; - fprintf (file, ";; old in \t"); - df_print_regset (file, &problem_data->in[bb->index]); + if (problem_data->in) + { + fprintf (file, ";; old in \t"); + df_print_regset (file, &problem_data->in[bb->index]); + } } fprintf (file, ";; live gen \t"); df_print_regset (file, &bb_info->gen); @@ -1692,8 +1698,11 @@ df_live_bottom_dump (basic_block bb, FIL if (df_live->problem_data) { problem_data = (struct df_live_problem_data *)df_live->problem_data; - fprintf (file, ";; old out \t"); - df_print_regset (file, &problem_data->out[bb->index]); + if (problem_data->out) + { + fprintf (file, ";; old out \t"); + df_print_regset (file, &problem_data->out[bb->index]); + } } } @@ -1707,23 +1716,19 @@ df_live_verify_solution_start (void) basic_block bb; struct df_live_problem_data *problem_data; if (df_live->solutions_dirty) - { - df_live->problem_data = NULL; - return; - } + return; /* Set it true so that the solution is recomputed. */ df_live->solutions_dirty = true; - problem_data = XNEW (struct df_live_problem_data); - df_live->problem_data = problem_data; + problem_data = (struct df_live_problem_data *)df_live->problem_data; problem_data->in = XNEWVEC (bitmap_head, last_basic_block); problem_data->out = XNEWVEC (bitmap_head, last_basic_block); FOR_ALL_BB (bb) { - bitmap_initialize (&problem_data->in[bb->index], &bitmap_default_obstack); - bitmap_initialize (&problem_data->out[bb->index], &bitmap_default_obstack); + bitmap_initialize (&problem_data->in[bb->index], &problem_data->live_bitmaps); + bitmap_initialize (&problem_data->out[bb->index], &problem_data->live_bitmaps); bitmap_copy (&problem_data->in[bb->index], DF_LIVE_IN (bb)); bitmap_copy (&problem_data->out[bb->index], DF_LIVE_OUT (bb)); } @@ -1739,10 +1744,9 @@ df_live_verify_solution_end (void) struct df_live_problem_data *problem_data; basic_block bb; - if (df_live->problem_data == NULL) - return; - problem_data = (struct df_live_problem_data *)df_live->problem_data; + if (!problem_data->out) + return; FOR_ALL_BB (bb) { @@ -4199,6 +4203,13 @@ df_simulate_one_insn_forwards (basic_blo propagating the information to BB3's successors. ---------------------------------------------------------------------------*/ +/* Private data used to verify the solution for this problem. */ +struct df_md_problem_data +{ + /* An obstack for the bitmaps we need for this problem. */ + bitmap_obstack md_bitmaps; +}; + /* Scratch var used by transfer functions. This is used to do md analysis only for live registers. */ static bitmap_head df_md_scratch; @@ -4240,13 +4251,22 @@ df_md_alloc (bitmap all_blocks) { unsigned int bb_index; bitmap_iterator bi; + struct df_md_problem_data *problem_data; if (!df_md->block_pool) df_md->block_pool = create_alloc_pool ("df_md_block pool", sizeof (struct df_md_bb_info), 50); df_grow_bb_info (df_md); - bitmap_initialize (&df_md_scratch, &bitmap_default_obstack); + if (df_md->problem_data) + problem_data = (struct df_md_problem_data *) df_md->problem_data; + else + { + problem_data = XNEW (struct df_md_problem_data); + df_md->problem_data = problem_data; + bitmap_obstack_initialize (&problem_data->md_bitmaps); + } + bitmap_initialize (&df_md_scratch, &problem_data->md_bitmaps); EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi) { @@ -4263,11 +4283,11 @@ df_md_alloc (bitmap all_blocks) { bb_info = (struct df_md_bb_info *) pool_alloc (df_md->block_pool); df_md_set_bb_info (bb_index, bb_info); - bitmap_initialize (&bb_info->init, &bitmap_default_obstack); - bitmap_initialize (&bb_info->gen, &bitmap_default_obstack); - bitmap_initialize (&bb_info->kill, &bitmap_default_obstack); - bitmap_initialize (&bb_info->in, &bitmap_default_obstack); - bitmap_initialize (&bb_info->out, &bitmap_default_obstack); + bitmap_initialize (&bb_info->init, &problem_data->md_bitmaps); + bitmap_initialize (&bb_info->gen, &problem_data->md_bitmaps); + bitmap_initialize (&bb_info->kill, &problem_data->md_bitmaps); + bitmap_initialize (&bb_info->in, &problem_data->md_bitmaps); + bitmap_initialize (&bb_info->out, &problem_data->md_bitmaps); } } @@ -4520,21 +4540,10 @@ df_md_confluence_n (edge e) static void df_md_free (void) { - unsigned int i; - for (i = 0; i < df_md->block_info_size; i++) - { - struct df_md_bb_info *bb_info = df_md_get_bb_info (i); - if (bb_info) - { - bitmap_clear (&bb_info->kill); - bitmap_clear (&bb_info->gen); - bitmap_clear (&bb_info->init); - bitmap_clear (&bb_info->in); - bitmap_clear (&bb_info->out); - } - } + struct df_md_problem_data *problem_data + = (struct df_md_problem_data *) df_md->problem_data; - bitmap_clear (&df_md_scratch); + bitmap_obstack_release (&problem_data->md_bitmaps); free_alloc_pool (df_md->block_pool); df_md->block_info_size = 0;