From patchwork Fri Oct 1 17:09:06 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Julian Brown X-Patchwork-Id: 45703 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 03CA7385AC1D for ; Fri, 1 Oct 2021 17:12:18 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from esa4.mentor.iphmx.com (esa4.mentor.iphmx.com [68.232.137.252]) by sourceware.org (Postfix) with ESMTPS id 9D43C3857408 for ; Fri, 1 Oct 2021 17:09:26 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 9D43C3857408 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: ClBA5XTsN6CWroV6PF2DFn/RKnHkp5k3WFePVMNFWFvHvqubTofaS9QrBqJebGh2Ymm5VToUDM bzRaqAK1Gr7+fyj0ldQQZphVOKbStKheKnKk0XEL6mcc1JRHoyphQxXaKQ7/Arjklw5O9ECUmq uRqdQdzIlw/FzTuh8oF7+TOqf7HFcAUCFZNkecGXZSUckI47H1XgRU+Vtl+DTg0Fgx8BfMVVdI zo0u4eZDlQt/bvsCOhRcJwROLmcc38WJf2frtyPLHzC1W9BiS3AwRYAFfvec1VvAzuPmmJ1Fq8 GiNj91dSF+8tDbZzUrWWQVjB X-IronPort-AV: E=Sophos;i="5.85,339,1624348800"; d="scan'208";a="66726636" Received: from orw-gwy-01-in.mentorg.com ([192.94.38.165]) by esa4.mentor.iphmx.com with ESMTP; 01 Oct 2021 09:09:25 -0800 IronPort-SDR: OfwZiT0joizbfVkw3torQ+O/fXPhZeAACMWH/UFAvjuQ1hBjH5pTYjLm/edfatTQHo2O+2ZMwx a5DZ56ivatKogg9teEba25AfsyZtQ87NYSVDwt4fHIpYASuiyZKykE+ZBq8kJ/qHcKFQS6O20L XHZh04Ixb78LUTcb4TGWYwVC7lVP2K1VD/lwRUY9w+/WSKgp51B5gegqpXBeqNNq6DSui+aeKq ViQVkyYCv0vVg2OOaPcFu+t2TN7xQ7GA48GKCPJepUyL+DMHwZ9L790wIGUt5cVIVvc1XqRwLq Wjo= From: Julian Brown To: Subject: [PATCH 08/11] Not for committing: noisy topological sorting output Date: Fri, 1 Oct 2021 10:09:06 -0700 Message-ID: <2967aebbb316ed80326774f915b82134f0545f43.1633106213.git.julian@codesourcery.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: References: MIME-Version: 1.0 X-Originating-IP: [137.202.0.90] X-ClientProxiedBy: svr-ies-mbx-06.mgc.mentorg.com (139.181.222.6) To SVR-IES-MBX-04.mgc.mentorg.com (139.181.222.4) X-Spam-Status: No, score=-11.8 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: , Cc: Jakub Jelinek , Thomas Schwinge Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" As a possible aid to review, this is my "printf-style" debugging cruft for the topological sorting implementation. We might want to rework this into something that emits scannable output into the gimple dump in order to write tests to make sure base pointer dependencies are being found properly, but that hasn't been done yet. This is not for committing. --- gcc/gimplify.c | 169 ++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 161 insertions(+), 8 deletions(-) diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 31e2e4d9fe7..2ec83bf273b 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -70,6 +70,8 @@ along with GCC; see the file COPYING3. If not see #include "context.h" #include "tree-nested.h" +//#define NOISY_TOPOSORT + /* Hash set of poisoned variables in a bind expr. */ static hash_set *asan_poisoned_variables = NULL; @@ -8957,6 +8959,10 @@ omp_gather_mapping_groups (tree *list_p) { vec *groups = new vec (); +#ifdef NOISY_TOPOSORT + fprintf (stderr, "GATHER MAPPING GROUPS\n"); +#endif + for (tree *cp = list_p; *cp; cp = &OMP_CLAUSE_CHAIN (*cp)) { if (OMP_CLAUSE_CODE (*cp) != OMP_CLAUSE_MAP) @@ -8965,6 +8971,25 @@ omp_gather_mapping_groups (tree *list_p) tree *grp_last_p = omp_group_last (cp); omp_mapping_group grp; +#ifdef NOISY_TOPOSORT + if (cp == grp_last_p) + { + tree tmp = OMP_CLAUSE_CHAIN (*cp); + OMP_CLAUSE_CHAIN (*cp) = NULL_TREE; + fprintf (stderr, "found singleton clause:\n"); + debug_generic_expr (*cp); + OMP_CLAUSE_CHAIN (*cp) = tmp; + } + else + { + tree tmp = OMP_CLAUSE_CHAIN (*grp_last_p); + OMP_CLAUSE_CHAIN (*grp_last_p) = NULL_TREE; + fprintf (stderr, "found group:\n"); + debug_generic_expr (*cp); + OMP_CLAUSE_CHAIN (*grp_last_p) = tmp; + } +#endif + grp.grp_start = cp; grp.grp_end = *grp_last_p; grp.mark = UNVISITED; @@ -9129,14 +9154,44 @@ omp_index_mapping_groups (vec *groups) omp_mapping_group *grp; unsigned int i; +#ifdef NOISY_TOPOSORT + fprintf (stderr, "INDEX MAPPING GROUPS\n"); +#endif + FOR_EACH_VEC_ELT (*groups, i, grp) { +#ifdef NOISY_TOPOSORT + debug_mapping_group (grp); +#endif + tree fpp; unsigned int chained; tree node = omp_group_base (grp, &chained, &fpp); if (node == error_mark_node || (!node && !fpp)) - continue; + { +#ifdef NOISY_TOPOSORT + fprintf (stderr, " -- NULL base, not indexing.\n"); +#endif + continue; + } + +#ifdef NOISY_TOPOSORT + if (node) + { + fprintf (stderr, "base%s: ", chained > 1 ? " list" : ""); + + tree walk = node; + for (unsigned j = 0; j < chained; walk = OMP_CLAUSE_CHAIN (walk), j++) + debug_generic_expr (OMP_CLAUSE_DECL (walk)); + } + + if (fpp) + { + fprintf (stderr, "firstprivate pointer/reference: "); + debug_generic_expr (fpp); + } +#endif for (unsigned j = 0; node && j < chained; @@ -9156,7 +9211,11 @@ omp_index_mapping_groups (vec *groups) omp_mapping_group **prev = grpmap->get (decl); if (prev && *prev == grp) - /* Empty. */; + { +#ifdef NOISY_TOPOSORT + fprintf (stderr, " -- same node\n"); +#endif + } else if (prev) { /* Mapping the same thing twice is normally diagnosed as an error, @@ -9171,9 +9230,17 @@ omp_index_mapping_groups (vec *groups) grp->sibling = (*prev)->sibling; (*prev)->sibling = grp; +#ifdef NOISY_TOPOSORT + fprintf (stderr, " -- index as sibling\n"); +#endif } else - grpmap->put (decl, grp); + { +#ifdef NOISY_TOPOSORT + fprintf (stderr, " -- index as new decl\n"); +#endif + grpmap->put (decl, grp); + } } if (!fpp) @@ -9184,9 +9251,17 @@ omp_index_mapping_groups (vec *groups) { grp->sibling = (*prev)->sibling; (*prev)->sibling = grp; +#ifdef NOISY_TOPOSORT + fprintf (stderr, " -- index fpp as sibling\n"); +#endif } else - grpmap->put (fpp, grp); + { +#ifdef NOISY_TOPOSORT + fprintf (stderr, " -- index fpp as new decl\n"); +#endif + grpmap->put (fpp, grp); + } } return grpmap; } @@ -9233,6 +9308,11 @@ omp_tsort_mapping_groups_1 (omp_mapping_group ***outlist, *grpmap, omp_mapping_group *grp) { +#ifdef NOISY_TOPOSORT + fprintf (stderr, "processing node/group:\n"); + debug_mapping_group (grp); +#endif + if (grp->mark == PERMANENT) return true; if (grp->mark == TEMPORARY) @@ -9253,11 +9333,26 @@ omp_tsort_mapping_groups_1 (omp_mapping_group ***outlist, if (basep) { gcc_assert (*basep != grp); +#ifdef NOISY_TOPOSORT + fprintf (stderr, "has attachment to:\n"); + debug_mapping_group (*basep); +#endif for (omp_mapping_group *w = *basep; w; w = w->sibling) if (!omp_tsort_mapping_groups_1 (outlist, groups, grpmap, w)) return false; } +#ifdef NOISY_TOPOSORT + else + { + fprintf (stderr, "can't find base for attachment, tried:\n"); + debug_generic_expr (attaches_to); + } +#endif } +#ifdef NOISY_TOPOSORT + else + fprintf (stderr, "doesn't attach to anything\n"); +#endif tree decl = OMP_CLAUSE_DECL (*grp->grp_start); @@ -9266,7 +9361,13 @@ omp_tsort_mapping_groups_1 (omp_mapping_group ***outlist, tree base = omp_get_base_pointer (decl); if (!base) - break; + { +#ifdef NOISY_TOPOSORT + fprintf (stderr, "no base pointer for decl:\n"); + debug_generic_expr (decl); +#endif + break; + } omp_mapping_group **innerp = grpmap->get (base); @@ -9283,6 +9384,9 @@ omp_tsort_mapping_groups_1 (omp_mapping_group ***outlist, && TREE_CODE (base) == MEM_REF && integer_zerop (TREE_OPERAND (base, 1))) { +#ifdef NOISY_TOPOSORT + fprintf (stderr, "we have a mem_ref, retry as indirect_ref\n"); +#endif tree ind = TREE_OPERAND (base, 0); ind = build1 (INDIRECT_REF, TREE_TYPE (base), ind); innerp = grpmap->get (ind); @@ -9291,12 +9395,22 @@ omp_tsort_mapping_groups_1 (omp_mapping_group ***outlist, if (innerp && *innerp != grp) { +#ifdef NOISY_TOPOSORT + fprintf (stderr, "base pointer of node is mapped too:\n"); + debug_generic_expr (base); +#endif for (omp_mapping_group *w = *innerp; w; w = w->sibling) if (!omp_tsort_mapping_groups_1 (outlist, groups, grpmap, w)) return false; break; } - +#ifdef NOISY_TOPOSORT + else + { + fprintf (stderr, "base pointer of node is not mapped:\n"); + debug_generic_expr (base); + } +#endif decl = base; } @@ -9307,6 +9421,16 @@ omp_tsort_mapping_groups_1 (omp_mapping_group ***outlist, **outlist = grp; *outlist = &grp->next; +#ifdef NOISY_TOPOSORT + fprintf (stderr, "+++ EMIT NODE/GROUP:\n"); + { + tree tmp = OMP_CLAUSE_CHAIN (grp->grp_end); + OMP_CLAUSE_CHAIN (grp->grp_end) = NULL_TREE; + debug_generic_expr (*grp->grp_start); + OMP_CLAUSE_CHAIN (grp->grp_end) = tmp; + } +#endif + return true; } @@ -9327,6 +9451,10 @@ omp_tsort_mapping_groups (vec *groups, cursor = &outlist; +#ifdef NOISY_TOPOSORT + fprintf (stderr, "TOPOLOGICALLY SORT MAPPING GROUPS\n"); +#endif + FOR_EACH_VEC_ELT (*groups, i, grp) { if (grp->mark != PERMANENT) @@ -9348,6 +9476,10 @@ omp_segregate_mapping_groups (omp_mapping_group *inlist) omp_mapping_group *ard_groups = NULL, *tf_groups = NULL; omp_mapping_group **ard_tail = &ard_groups, **tf_tail = &tf_groups; +#ifdef NOISY_TOPOSORT + fprintf (stderr, "SEGREGATE MAPPING GROUPS\n"); +#endif + for (omp_mapping_group *w = inlist; w;) { tree c = *w->grp_start; @@ -9452,7 +9584,7 @@ omp_reorder_mapping_groups (vec *groups, --> a {l m n} e {o p q} h i j (chain last group to old successor) ^new_grp_tail - */ + */ *new_grp_tail = old_succs[i - 1]; } else @@ -10285,9 +10417,30 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p, grpmap = omp_index_mapping_groups (groups); outlist = omp_tsort_mapping_groups (groups, grpmap); +#ifdef NOISY_TOPOSORT + if (!outlist) + goto failure; + fprintf (stderr, "TOPO-SORTED ORDER:\n"); + for (omp_mapping_group *w = outlist; w; w = w->next) + debug_mapping_group (w); +#endif outlist = omp_segregate_mapping_groups (outlist); +#ifdef NOISY_TOPOSORT + fprintf (stderr, "FINAL ORDER:\n"); + for (omp_mapping_group *w = outlist; w; w = w->next) + debug_mapping_group (w); +#endif list_p = omp_reorder_mapping_groups (groups, outlist, list_p); - +#ifdef NOISY_TOPOSORT + fprintf (stderr, "REORDERED CLAUSES:\n"); + for (tree *w = list_p; *w; w = &OMP_CLAUSE_CHAIN (*w)) + { + tree tmp = OMP_CLAUSE_CHAIN (*w); + OMP_CLAUSE_CHAIN (*w) = NULL_TREE; + debug_generic_expr (*w); + OMP_CLAUSE_CHAIN (*w) = tmp; + } +#endif failure: delete grpmap; delete groups;