From patchwork Wed Jun 18 06:42:02 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Zhenqiang Chen X-Patchwork-Id: 361275 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 EB9C6140077 for ; Wed, 18 Jun 2014 16:42:14 +1000 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:in-reply-to:references:date:message-id:subject :from:to:cc:content-type; q=dns; s=default; b=TfNzqU4JAAPTZACQBR eLPYdYgAoT9L6DcNwtIxNdVFOVIbs2ZvQLoOKXen7YUGq0nylozyCUBl+mz6/tqI o61bfmBEuep9oxPsyAt4lQRQjLyZc/IDNG329639bZ7O36dMJVGYrE3xixTKNyXj JG+SvAOkFmPlGhm/klKl6Kkd0= 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 :mime-version:in-reply-to:references:date:message-id:subject :from:to:cc:content-type; s=default; bh=WBXtGHYhr4Ww2bco3/jO6xgI kyI=; b=W44qwd4OIZd74eLxDTzbQTPbN1KuiHcmwFkjdVGudchAg0b4SiZ+/QGv hWPzS01FojGZES4qo47uBTMqA+4wo3aq3LW+1f8TOK86LqNHEByV9WyDN6t0Ch1o OFBjMnlAVSqZtI1fwd/5WBIMTOavbcoUnqp/J3iTDcJ2sDB6O10= Received: (qmail 19851 invoked by alias); 18 Jun 2014 06:42:07 -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 19838 invoked by uid 89); 18 Jun 2014 06:42:07 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.5 required=5.0 tests=AWL, BAYES_00, 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-SHA encrypted) ESMTPS; Wed, 18 Jun 2014 06:42:05 +0000 Received: by mail-la0-f48.google.com with SMTP id el20so183088lab.7 for ; Tue, 17 Jun 2014 23:42:02 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:in-reply-to:references:date :message-id:subject:from:to:cc:content-type; bh=h4xhpNNiYuIgvbe/6PRdsdDQYEuy8Lkc7L+fzANUXHw=; b=SS0K7Xf7BIygpkLCqxhlpjU8sg94xyyzzZ4QHod2szbugfOp64Hsfzx3NTH5+6Yyuc bY66fxKRNw7SJuZ6xe5koY26pqdTZAt4S6DsJ5yitFK2vYc/SYx2Q73O4YMAvYE87GPU xegxz6vPFX/TCAZu500a9hh4kyHlEddFZQjEBZ4WBio8BIWx6XI5Uuhx2Nybbf/YSnqu XxsdAu3peYp2Y1gPGKcbDoyCstSlgmy40UIvbP1sCbQJILCP76d3NAyU1NJ6OUJ4gLvp G1BIBTKqhVUjOd+GSL79/UM2qDQp6oktTEs8jJrmE0XKDxUX/MqkAqyaJfEaWYc3HQEt 828Q== X-Gm-Message-State: ALoCoQnL6Wt8gSTt7ZYgw5u520gCggEATOICX7JBIBJ9d2zEP+iP5SSWldIBd/q1Tsx3WYfe9Bo+ MIME-Version: 1.0 X-Received: by 10.112.12.103 with SMTP id x7mr62796lbb.36.1403073722121; Tue, 17 Jun 2014 23:42:02 -0700 (PDT) Received: by 10.112.13.36 with HTTP; Tue, 17 Jun 2014 23:42:02 -0700 (PDT) In-Reply-To: References: Date: Wed, 18 Jun 2014 14:42:02 +0800 Message-ID: Subject: Re: [PATCH, loop2_invariant, 2/2] Change heuristics for identical invariants From: Zhenqiang Chen To: Steven Bosscher Cc: "gcc-patches@gcc.gnu.org" , Jeff Law X-IsSubscribed: yes On 10 June 2014 19:16, Steven Bosscher wrote: > On Tue, Jun 10, 2014 at 11:23 AM, Zhenqiang Chen wrote: >> * loop-invariant.c (struct invariant): Add a new member: eqno; >> (find_identical_invariants): Update eqno; >> (create_new_invariant): Init eqno; >> (get_inv_cost): Compute comp_cost wiht eqno; >> (gain_for_invariant): Take spill cost into account. > > Look OK except ... > >> @@ -1243,7 +1256,13 @@ gain_for_invariant (struct invariant *inv, >> unsigned *regs_needed, >> + IRA_LOOP_RESERVED_REGS >> - ira_class_hard_regs_num[cl]; >> if (size_cost > 0) >> - return -1; >> + { >> + int spill_cost = target_spill_cost [speed] * (int) regs_needed[cl]; >> + if (comp_cost <= spill_cost) >> + return -1; >> + >> + return 2; >> + } >> else >> size_cost = 0; >> } > > ... why "return 2", instead of just falling through to "return > comp_cost - size_cost;"? Thanks for the comments. Updated. As your comments for the previous patch, I should also check the overlap between reg classes. So I change the logic to check spill cost. return; @@ -513,7 +517,12 @@ find_identical_invariants (invariant_htab_type eq, struct invariant *inv) mode = GET_MODE (expr); if (mode == VOIDmode) mode = GET_MODE (SET_DEST (set)); - inv->eqto = find_or_insert_inv (eq, expr, mode, inv)->invno; + + tmp = find_or_insert_inv (eq, expr, mode, inv); + inv->eqto = tmp->invno; + + if (tmp->invno != inv->invno && inv->always_executed) + tmp->eqno++; if (dump_file && inv->eqto != inv->invno) fprintf (dump_file, @@ -725,6 +734,10 @@ create_new_invariant (struct def *def, rtx insn, bitmap depends_on, inv->invno = invariants.length (); inv->eqto = ~0u; + + /* Itself. */ + inv->eqno = 1; + if (def) def->invno = inv->invno; invariants.safe_push (inv); @@ -1141,7 +1154,7 @@ get_inv_cost (struct invariant *inv, int *comp_cost, unsigned *regs_needed, if (!inv->cheap_address || inv->def->n_addr_uses < inv->def->n_uses) - (*comp_cost) += inv->cost; + (*comp_cost) += inv->cost * inv->eqno; #ifdef STACK_REGS { @@ -1249,7 +1262,7 @@ gain_for_invariant (struct invariant *inv, unsigned *regs_needed, unsigned *new_regs, unsigned regs_used, bool speed, bool call_p) { - int comp_cost, size_cost; + int comp_cost, size_cost = 0; enum reg_class cl; int ret; @@ -1273,6 +1286,8 @@ gain_for_invariant (struct invariant *inv, unsigned *regs_needed, { int i; enum reg_class pressure_class; + int spill_cost = 0; + int base_cost = target_spill_cost [speed]; for (i = 0; i < ira_pressure_classes_num; i++) { @@ -1286,30 +1301,13 @@ gain_for_invariant (struct invariant *inv, unsigned *regs_needed, + LOOP_DATA (curr_loop)->max_reg_pressure[pressure_class] + IRA_LOOP_RESERVED_REGS > ira_class_hard_regs_num[pressure_class]) - break; + { + spill_cost += base_cost * (int) regs_needed[pressure_class]; + size_cost = -1; + } } - if (i < ira_pressure_classes_num) - /* There will be register pressure excess and we want not to - make this loop invariant motion. All loop invariants with - non-positive gains will be rejected in function - find_invariants_to_move. Therefore we return the negative - number here. - - One could think that this rejects also expensive loop - invariant motions and this will hurt code performance. - However numerous experiments with different heuristics - taking invariant cost into account did not confirm this - assumption. There are possible explanations for this - result: - o probably all expensive invariants were already moved out - of the loop by PRE and gimple invariant motion pass. - o expensive invariant execution will be hidden by insn - scheduling or OOO processor hardware because usually such - invariants have a lot of freedom to be executed - out-of-order. - Another reason for ignoring invariant cost vs spilling cost - heuristics is also in difficulties to evaluate accurately - spill cost at this stage. */ + if ((size_cost == -1) + && (comp_cost <= spill_cost)) return -1; else size_cost = 0; diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c index 6e43b49..af0c95b 100644 --- a/gcc/loop-invariant.c +++ b/gcc/loop-invariant.c @@ -104,6 +104,9 @@ struct invariant /* The number of the invariant with the same value. */ unsigned eqto; + /* The number of invariants which eqto this. */ + unsigned eqno; + /* If we moved the invariant out of the loop, the register that contains its value. */ rtx reg; @@ -498,6 +501,7 @@ find_identical_invariants (invariant_htab_type eq, struct invariant *inv) struct invariant *dep; rtx expr, set; enum machine_mode mode; + struct invariant *tmp; if (inv->eqto != ~0u)