From patchwork Wed Nov 17 16:03:12 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Frederik Harwath X-Patchwork-Id: 47816 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 5BB46385842C for ; Wed, 17 Nov 2021 16:10:37 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from esa2.mentor.iphmx.com (esa2.mentor.iphmx.com [68.232.141.98]) by sourceware.org (Postfix) with ESMTPS id 584443858432 for ; Wed, 17 Nov 2021 16:03:51 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 584443858432 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: tPVRjRHXFJRsgg8hiWZMtGYuirBfppmIDBZ1Du2T6klHAFwuyqOD1H3OdC8UVzo3gULLcrr4v3 Z3HjD/PLehRn1C68/CkHYeGq5z1pI6P/4jTB53dNqGdV/iB3c/83Pz4FcX4lK4eCjUCxLkb3Yf SOqMxTU6Upku94CLANuaGGzngjI9YfDvL+z/OJnBOT8ASNYkZdYdMezJ5fhZhScuwItlYv4476 OkrwZJhvAnmvDjCAvmJg26Vn22jJAxDrvMDnzOzGKsfm8apz2E5D0yhdL0rcwPXVAsEV27pr4v X3VswKJ3Gq9B11MadFGUBtHy X-IronPort-AV: E=Sophos;i="5.87,241,1631606400"; d="scan'208";a="68604022" Received: from orw-gwy-01-in.mentorg.com ([192.94.38.165]) by esa2.mentor.iphmx.com with ESMTP; 17 Nov 2021 08:03:49 -0800 IronPort-SDR: DKmovncmpAHFVj71A5S2iRUG9TTZnQ9eIMdsFz3/UCa7jaLUdCmYzC8815PbkwrPZtXIvlFTRD dY8m8dT/vnkg6wOhmkzuO1BUYvv2uDDj1tTe9pjNrE4wJJvr4wm63OoPI4oJFVZ/NuL5+C3U2y DRlfN3KxRXNcc965hxD88CiMKYWBiZGzvtn6bmatODnjoJu85ehKewuJ4+4VAwnyToou4HNHGk 74ZIzz+10s1wL9rV1XdUGkCYu56qiFm4nyRQkRj7YLUwc2UakDMSid8ktz0OLzZI36Y1w9J0ef tAQ= From: Frederik Harwath To: Subject: [OG11][committed][PATCH 03/22] graphite: Extend SCoP detection dump output Date: Wed, 17 Nov 2021 17:03:12 +0100 Message-ID: <20211117160330.20029-4-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-04.mgc.mentorg.com (139.181.222.4) To SVR-IES-MBX-04.mgc.mentorg.com (139.181.222.4) X-Spam-Status: No, score=-12.2 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+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" Extend dump output to make understanding why Graphite rejects to include a loop in a SCoP easier (for GCC developers). ChangeLog: * graphite-scop-detection.c (scop_detection::can_represent_loop): Output reason for failure to dump file. (scop_detection::harmful_loop_in_region): Likewise. (scop_detection::graphite_can_represent_expr): Likewise. (scop_detection::stmt_has_simple_data_refs_p): Likewise. (scop_detection::stmt_simple_for_scop_p): Likewise. (print_sese_loop_numbers): New function. (scop_detection::add_scop): Use from here to print loops in rejected SCoP. --- gcc/graphite-scop-detection.c | 188 +++++++++++++++++++++++++++++----- 1 file changed, 165 insertions(+), 23 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/graphite-scop-detection.c b/gcc/graphite-scop-detection.c index 3e729b159b09..46c470210d05 100644 --- a/gcc/graphite-scop-detection.c +++ b/gcc/graphite-scop-detection.c @@ -69,12 +69,27 @@ public: fprintf (output.dump_file, "%d", i); return output; } + friend debug_printer & operator<< (debug_printer &output, const char *s) { fprintf (output.dump_file, "%s", s); return output; } + + friend debug_printer & + operator<< (debug_printer &output, gimple* stmt) + { + print_gimple_stmt (output.dump_file, stmt, 0, TDF_VOPS | TDF_MEMSYMS); + return output; + } + + friend debug_printer & + operator<< (debug_printer &output, tree t) + { + print_generic_expr (output.dump_file, t, TDF_SLIM); + return output; + } } dp; #define DEBUG_PRINT(args) do \ @@ -506,6 +521,24 @@ scop_detection::merge_sese (sese_l first, sese_l second) const return combined; } +/* Print the loop numbers of the loops contained + in SESE to FILE. */ + +static void +print_sese_loop_numbers (FILE *file, sese_l sese) +{ + loop_p loop; + bool printed = false; + FOR_EACH_LOOP (loop, 0) + { + if (loop_in_sese_p (loop, sese)) + fprintf (file, "%d, ", loop->num); + printed = true; + } + if (printed) + fprintf (file, "\b\b"); +} + /* Build scop outer->inner if possible. */ void @@ -519,8 +552,13 @@ scop_detection::build_scop_depth (loop_p loop) if (! next || harmful_loop_in_region (next)) { - if (s) - add_scop (s); + if (next) + DEBUG_PRINT ( + dp << "[scop-detection] Discarding SCoP on loops "; + print_sese_loop_numbers (dump_file, next); + dp << " because of harmful loops\n";); + if (s) + add_scop (s); build_scop_depth (loop); s = invalid_sese; } @@ -560,14 +598,62 @@ scop_detection::can_represent_loop (loop_p loop, sese_l scop) || !single_pred_p (loop->latch) || exit->src != single_pred (loop->latch) || !empty_block_p (loop->latch)) - return false; + { + DEBUG_PRINT (dp << "[can_represent_loop-fail] Loop shape unsupported.\n"); + return false; + } + + bool edge_irreducible + = loop_preheader_edge (loop)->flags & EDGE_IRREDUCIBLE_LOOP; + if (edge_irreducible) + { + DEBUG_PRINT ( + dp << "[can_represent_loop-fail] Loop is not a natural loop.\n"); + return false; + } + + bool niter_is_unconditional = number_of_iterations_exit (loop, + single_exit (loop), + &niter_desc, false); - return !(loop_preheader_edge (loop)->flags & EDGE_IRREDUCIBLE_LOOP) - && number_of_iterations_exit (loop, single_exit (loop), &niter_desc, false) - && niter_desc.control.no_overflow - && (niter = number_of_latch_executions (loop)) - && !chrec_contains_undetermined (niter) - && graphite_can_represent_expr (scop, loop, niter); + if (!niter_is_unconditional) + { + DEBUG_PRINT ( + dp << "[can_represent_loop-fail] Loop niter not unconditional.\n" + << "Condition: " << niter_desc.assumptions << "\n"); + return false; + } + + niter = number_of_latch_executions (loop); + if (!niter) + { + DEBUG_PRINT (dp << "[can_represent_loop-fail] Loop niter unknown.\n"); + return false; + } + if (!niter_desc.control.no_overflow) + { + DEBUG_PRINT (dp << "[can_represent_loop-fail] Loop niter can overflow.\n"); + return false; + } + + bool undetermined_coefficients = chrec_contains_undetermined (niter); + if (undetermined_coefficients) + { + DEBUG_PRINT (dp << "[can_represent_loop-fail] " + << "Loop niter chrec contains undetermined coefficients.\n"); + return false; + } + + bool can_represent_expr = graphite_can_represent_expr (scop, loop, niter); + if (!can_represent_expr) + { + DEBUG_PRINT (dp << "[can_represent_loop-fail] " + << "Loop niter expression cannot be represented: " + << niter << "\n"); + return false; + } + + return true; } /* Return true when BEGIN is the preheader edge of a loop with a single exit @@ -640,6 +726,16 @@ scop_detection::add_scop (sese_l s) scops.safe_push (s); DEBUG_PRINT (dp << "[scop-detection] Adding SCoP: "; print_sese (dump_file, s)); + + if (dump_file && dump_flags & TDF_DETAILS) + { + loop_p loop; + fprintf (dump_file, "Loops in SCoP: "); + FOR_EACH_LOOP (loop, 0) + if (loop_in_sese_p (loop, s)) + fprintf (dump_file, "%d ", loop->num); + fprintf (dump_file, "\n"); + } } /* Return true when a statement in SCOP cannot be represented by Graphite. */ @@ -665,7 +761,11 @@ scop_detection::harmful_loop_in_region (sese_l scop) const /* The basic block should not be part of an irreducible loop. */ if (bb->flags & BB_IRREDUCIBLE_LOOP) - return true; + { + DEBUG_PRINT (dp << "[scop-detection-fail] Found bb in irreducible " + "loop.\n"); + return true; + } /* Check for unstructured control flow: CFG not generated by structured if-then-else. */ @@ -676,7 +776,11 @@ scop_detection::harmful_loop_in_region (sese_l scop) const FOR_EACH_EDGE (e, ei, bb->succs) if (!dominated_by_p (CDI_POST_DOMINATORS, bb, e->dest) && !dominated_by_p (CDI_DOMINATORS, e->dest, bb)) - return true; + { + DEBUG_PRINT (dp << "[scop-detection-fail] Found unstructured " + "control flow.\n"); + return true; + } } /* Collect all loops in the current region. */ @@ -688,7 +792,10 @@ scop_detection::harmful_loop_in_region (sese_l scop) const for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) if (!stmt_simple_for_scop_p (scop, gsi_stmt (gsi), bb)) - return true; + { + DEBUG_PRINT (dp << "[scop-detection-fail] Found harmful statement.\n"); + return true; + } for (basic_block dom = first_dom_son (CDI_DOMINATORS, bb); dom; @@ -731,9 +838,11 @@ scop_detection::harmful_loop_in_region (sese_l scop) const && ! loop_nest_has_data_refs (loop)) { DEBUG_PRINT (dp << "[scop-detection-fail] loop_" << loop->num - << "does not have any data reference.\n"); + << " does not have any data reference.\n"); return true; } + + DEBUG_PRINT (dp << "[scop-detection] loop_" << loop->num << " is harmless.\n"); } return false; @@ -922,7 +1031,21 @@ scop_detection::graphite_can_represent_expr (sese_l scop, loop_p loop, tree expr) { tree scev = cached_scalar_evolution_in_region (scop, loop, expr); - return graphite_can_represent_scev (scop, scev); + bool can_represent = graphite_can_represent_scev (scop, scev); + + if (!can_represent) + { + if (dump_file) + { + fprintf (dump_file, "[graphite_can_represent_expr] Cannot represent " + "scev \""); + print_generic_expr (dump_file, scev, TDF_SLIM); + fprintf (dump_file, "\" of expression "); + print_generic_expr (dump_file, expr, TDF_SLIM); + fprintf (dump_file, " in loop %d\n", loop->num); + } + } + return can_represent; } /* Return true if the data references of STMT can be represented by Graphite. @@ -938,7 +1061,11 @@ scop_detection::stmt_has_simple_data_refs_p (sese_l scop, gimple *stmt) auto_vec drs; if (! graphite_find_data_references_in_stmt (nest, loop, stmt, &drs)) - return false; + { + DEBUG_PRINT (dp << + "[stmt_has_simple_data_refs_p] Unanalyzable statement.\n"); + return false; + } int j; data_reference_p dr; @@ -946,7 +1073,12 @@ scop_detection::stmt_has_simple_data_refs_p (sese_l scop, gimple *stmt) { for (unsigned i = 0; i < DR_NUM_DIMENSIONS (dr); ++i) if (! graphite_can_represent_scev (scop, DR_ACCESS_FN (dr, i))) - return false; + { + DEBUG_PRINT (dp << "[stmt_has_simple_data_refs_p] Cannot " + "represent access function SCEV: " + << DR_ACCESS_FN (dr, i) << "\n"); + return false; + } } return true; @@ -1027,14 +1159,24 @@ scop_detection::stmt_simple_for_scop_p (sese_l scop, gimple *stmt, for (unsigned i = 0; i < 2; ++i) { tree op = gimple_op (stmt, i); - if (!graphite_can_represent_expr (scop, loop, op) - /* We can only constrain on integer type. */ - || ! INTEGRAL_TYPE_P (TREE_TYPE (op))) + if (!graphite_can_represent_expr (scop, loop, op)) + { + DEBUG_PRINT (dump_printf_loc (MSG_MISSED_OPTIMIZATION, stmt, + "[scop-detection-fail] " + "Graphite cannot represent cond " + "stmt operator expression.\n")); + DEBUG_PRINT (dp << op << "\n"); + + return false; + } + + if (! INTEGRAL_TYPE_P (TREE_TYPE (op))) { - DEBUG_PRINT (dp << "[scop-detection-fail] " - << "Graphite cannot represent stmt:\n"; - print_gimple_stmt (dump_file, stmt, 0, - TDF_VOPS | TDF_MEMSYMS)); + DEBUG_PRINT (dump_printf_loc (MSG_MISSED_OPTIMIZATION, stmt, + "[scop-detection-fail] " + "Graphite cannot represent cond " + "statement operator. " + "Type must be integral.\n")); return false; } }