From patchwork Wed Nov 17 16:03:15 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Frederik Harwath X-Patchwork-Id: 1556252 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Received: from sourceware.org (server2.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4HvSdL2B9Wz9s1l for ; Thu, 18 Nov 2021 03:12:54 +1100 (AEDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id A15C4385DC01 for ; Wed, 17 Nov 2021 16:12:51 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from esa3.mentor.iphmx.com (esa3.mentor.iphmx.com [68.232.137.180]) by sourceware.org (Postfix) with ESMTPS id 5C232385841C for ; Wed, 17 Nov 2021 16:04:07 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 5C232385841C Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=mentor.com IronPort-SDR: qharzFcyP6MoWQvzoPnW62rf0THNx3gs3gd0p15bQdgvPIzHeu8BU1mDObmcS9sYTZqZpE+RWp AXPDZFFHFxW/BMDLDl369+Hnkd0n+8eKmorafhX1ivZSFu+NGOOZlrL/kqAOExjqhmOjIyBvMB CB/TqgXMbvlB8iRhxswOlTt8HED+v5jf1bRhQULwK3U3kXlSFD0U9qgpnSsKmLjKU3nm4oX78L 5CNLOJeF8B9Eb85XqaPtHvCnli5Lrs28OQeDQTuU//ZUAw3pnIuQtuJVjn5IsHB7+LyvVtuXDL mfe9wBiasMQfakdwdBPAueQ+ X-IronPort-AV: E=Sophos;i="5.87,241,1631606400"; d="scan'208";a="68445333" Received: from orw-gwy-01-in.mentorg.com ([192.94.38.165]) by esa3.mentor.iphmx.com with ESMTP; 17 Nov 2021 08:04:07 -0800 IronPort-SDR: BDkKMMEoTgo9AEcq2K+nWSuzT0SnbZI/yV25ByFe/UoUzdqNE2dxM8Ivxs6Jfji6PTCl79K3iH MYLI1wmQCkCCWLjeyv9Ad+iFzocmN9EbJce333N0bGvo+aigT4CXs1mkDldvBX8GZ49HG7Z0dT CsDOmIojuCZx+1uySFjt9YFxOSpbbE3Jmp0f8jZRccnpmEXHttDfzXhPdl3st27mEj/8O2zhBm oEaUIaKEy2ArpwKAJPY+vuW3EOr/KBZp8NDQFAN7846onXTYtBCjtfMrXpVOlHSiMbuUqYPg6Q 4Sk= From: Frederik Harwath To: Subject: [OG11][committed][PATCH 07/22] Move compute_alias_check_pairs to tree-data-ref.c Date: Wed, 17 Nov 2021 17:03:15 +0100 Message-ID: <20211117160330.20029-7-frederik@codesourcery.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211117160330.20029-1-frederik@codesourcery.com> References: <20211117160330.20029-1-frederik@codesourcery.com> MIME-Version: 1.0 X-Originating-IP: [137.202.0.90] X-ClientProxiedBy: svr-ies-mbx-01.mgc.mentorg.com (139.181.222.1) To SVR-IES-MBX-04.mgc.mentorg.com (139.181.222.4) X-Spam-Status: No, score=-12.4 required=5.0 tests=BAYES_00, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, SPF_HELO_PASS, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Move this function from tree-loop-distribution.c to tree-data-ref.c and make it non-static to enable its use from other parts of GCC. gcc/ChangeLog: * tree-loop-distribution.c (data_ref_segment_size): Remove function. (latch_dominated_by_data_ref): Likewise. (compute_alias_check_pairs): Likewise. * tree-data-ref.c (data_ref_segment_size): New function, copied from tree-loop-distribution.c (compute_alias_check_pairs): Likewise. (latch_dominated_by_data_ref): Likewise. * tree-data-ref.h (compute_alias_check_pairs): New declaration. --- gcc/tree-data-ref.c | 87 ++++++++++++++++++++++++++++++++++++ gcc/tree-data-ref.h | 3 ++ gcc/tree-loop-distribution.c | 87 ------------------------------------ 3 files changed, 90 insertions(+), 87 deletions(-) -- 2.33.0 ----------------- Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstraße 201, 80634 München; Gesellschaft mit beschränkter Haftung; Geschäftsführer: Thomas Heurung, Frank Thürauf; Sitz der Gesellschaft: München; Registergericht München, HRB 106955 diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c index d04e95f7c285..71f8d790e618 100644 --- a/gcc/tree-data-ref.c +++ b/gcc/tree-data-ref.c @@ -2645,6 +2645,93 @@ create_intersect_range_checks (class loop *loop, tree *cond_expr, dump_printf (MSG_NOTE, "using an address-based overlap test\n"); } +/* Compute and return an expression whose value is the segment length which + will be accessed by DR in NITERS iterations. */ + +static tree +data_ref_segment_size (struct data_reference *dr, tree niters) +{ + niters = size_binop (MINUS_EXPR, + fold_convert (sizetype, niters), + size_one_node); + return size_binop (MULT_EXPR, + fold_convert (sizetype, DR_STEP (dr)), + fold_convert (sizetype, niters)); +} + +/* Return true if LOOP's latch is dominated by statement for data reference + DR. */ + +static inline bool +latch_dominated_by_data_ref (class loop *loop, data_reference *dr) +{ + return dominated_by_p (CDI_DOMINATORS, single_exit (loop)->src, + gimple_bb (DR_STMT (dr))); +} + +/* Compute alias check pairs and store them in COMP_ALIAS_PAIRS for LOOP's + data dependence relations ALIAS_DDRS. */ + +void +compute_alias_check_pairs (class loop *loop, vec *alias_ddrs, + vec *comp_alias_pairs) +{ + unsigned int i; + unsigned HOST_WIDE_INT factor = 1; + tree niters_plus_one, niters = number_of_latch_executions (loop); + + gcc_assert (niters != NULL_TREE && niters != chrec_dont_know); + niters = fold_convert (sizetype, niters); + niters_plus_one = size_binop (PLUS_EXPR, niters, size_one_node); + + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "Creating alias check pairs:\n"); + + /* Iterate all data dependence relations and compute alias check pairs. */ + for (i = 0; i < alias_ddrs->length (); i++) + { + ddr_p ddr = (*alias_ddrs)[i]; + struct data_reference *dr_a = DDR_A (ddr); + struct data_reference *dr_b = DDR_B (ddr); + tree seg_length_a, seg_length_b; + + if (latch_dominated_by_data_ref (loop, dr_a)) + seg_length_a = data_ref_segment_size (dr_a, niters_plus_one); + else + seg_length_a = data_ref_segment_size (dr_a, niters); + + if (latch_dominated_by_data_ref (loop, dr_b)) + seg_length_b = data_ref_segment_size (dr_b, niters_plus_one); + else + seg_length_b = data_ref_segment_size (dr_b, niters); + + unsigned HOST_WIDE_INT access_size_a + = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr_a)))); + unsigned HOST_WIDE_INT access_size_b + = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr_b)))); + unsigned int align_a = TYPE_ALIGN_UNIT (TREE_TYPE (DR_REF (dr_a))); + unsigned int align_b = TYPE_ALIGN_UNIT (TREE_TYPE (DR_REF (dr_b))); + + dr_with_seg_len_pair_t dr_with_seg_len_pair + (dr_with_seg_len (dr_a, seg_length_a, access_size_a, align_a), + dr_with_seg_len (dr_b, seg_length_b, access_size_b, align_b), + /* ??? Would WELL_ORDERED be safe? */ + dr_with_seg_len_pair_t::REORDERED); + + comp_alias_pairs->safe_push (dr_with_seg_len_pair); + } + + if (tree_fits_uhwi_p (niters)) + factor = tree_to_uhwi (niters); + + /* Prune alias check pairs. */ + prune_runtime_alias_test_list (comp_alias_pairs, factor); + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, + "Improved number of alias checks from %d to %d\n", + alias_ddrs->length (), comp_alias_pairs->length ()); +} + /* Create a conditional expression that represents the run-time checks for overlapping of address ranges represented by a list of data references pairs passed in ALIAS_PAIRS. Data references are in LOOP. The returned diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h index 8001cc54f518..5016ec926b1d 100644 --- a/gcc/tree-data-ref.h +++ b/gcc/tree-data-ref.h @@ -577,6 +577,9 @@ extern opt_result runtime_alias_check_p (ddr_p, class loop *, bool); extern int data_ref_compare_tree (tree, tree); extern void prune_runtime_alias_test_list (vec *, poly_uint64); + +extern void compute_alias_check_pairs (class loop *, vec *, + vec *); extern void create_runtime_alias_checks (class loop *, vec *, tree*); extern tree dr_direction_indicator (struct data_reference *); diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c index 65aa1df4abae..d987cdb34424 100644 --- a/gcc/tree-loop-distribution.c +++ b/gcc/tree-loop-distribution.c @@ -2559,93 +2559,6 @@ loop_distribution::break_alias_scc_partitions (struct graph *rdg, } } -/* Compute and return an expression whose value is the segment length which - will be accessed by DR in NITERS iterations. */ - -static tree -data_ref_segment_size (struct data_reference *dr, tree niters) -{ - niters = size_binop (MINUS_EXPR, - fold_convert (sizetype, niters), - size_one_node); - return size_binop (MULT_EXPR, - fold_convert (sizetype, DR_STEP (dr)), - fold_convert (sizetype, niters)); -} - -/* Return true if LOOP's latch is dominated by statement for data reference - DR. */ - -static inline bool -latch_dominated_by_data_ref (class loop *loop, data_reference *dr) -{ - return dominated_by_p (CDI_DOMINATORS, single_exit (loop)->src, - gimple_bb (DR_STMT (dr))); -} - -/* Compute alias check pairs and store them in COMP_ALIAS_PAIRS for LOOP's - data dependence relations ALIAS_DDRS. */ - -static void -compute_alias_check_pairs (class loop *loop, vec *alias_ddrs, - vec *comp_alias_pairs) -{ - unsigned int i; - unsigned HOST_WIDE_INT factor = 1; - tree niters_plus_one, niters = number_of_latch_executions (loop); - - gcc_assert (niters != NULL_TREE && niters != chrec_dont_know); - niters = fold_convert (sizetype, niters); - niters_plus_one = size_binop (PLUS_EXPR, niters, size_one_node); - - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, "Creating alias check pairs:\n"); - - /* Iterate all data dependence relations and compute alias check pairs. */ - for (i = 0; i < alias_ddrs->length (); i++) - { - ddr_p ddr = (*alias_ddrs)[i]; - struct data_reference *dr_a = DDR_A (ddr); - struct data_reference *dr_b = DDR_B (ddr); - tree seg_length_a, seg_length_b; - - if (latch_dominated_by_data_ref (loop, dr_a)) - seg_length_a = data_ref_segment_size (dr_a, niters_plus_one); - else - seg_length_a = data_ref_segment_size (dr_a, niters); - - if (latch_dominated_by_data_ref (loop, dr_b)) - seg_length_b = data_ref_segment_size (dr_b, niters_plus_one); - else - seg_length_b = data_ref_segment_size (dr_b, niters); - - unsigned HOST_WIDE_INT access_size_a - = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr_a)))); - unsigned HOST_WIDE_INT access_size_b - = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr_b)))); - unsigned int align_a = TYPE_ALIGN_UNIT (TREE_TYPE (DR_REF (dr_a))); - unsigned int align_b = TYPE_ALIGN_UNIT (TREE_TYPE (DR_REF (dr_b))); - - dr_with_seg_len_pair_t dr_with_seg_len_pair - (dr_with_seg_len (dr_a, seg_length_a, access_size_a, align_a), - dr_with_seg_len (dr_b, seg_length_b, access_size_b, align_b), - /* ??? Would WELL_ORDERED be safe? */ - dr_with_seg_len_pair_t::REORDERED); - - comp_alias_pairs->safe_push (dr_with_seg_len_pair); - } - - if (tree_fits_uhwi_p (niters)) - factor = tree_to_uhwi (niters); - - /* Prune alias check pairs. */ - prune_runtime_alias_test_list (comp_alias_pairs, factor); - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, - "Improved number of alias checks from %d to %d\n", - alias_ddrs->length (), comp_alias_pairs->length ()); -} - /* Given data dependence relations in ALIAS_DDRS, generate runtime alias checks and version LOOP under condition of these runtime alias checks. */