From patchwork Tue Nov 23 17:02:22 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Andrew MacLeod X-Patchwork-Id: 48030 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 18EE53858D28 for ; Tue, 23 Nov 2021 17:03:08 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 18EE53858D28 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1637686988; bh=59L4+9CDVYg7dANInIL3JrlJIyRMNli+IgUlIWFXIdg=; h=Date:To:Subject:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=u1K35WhyY53YcU6B4v58QAxhO8hDZSC7jPnOmSE4zWbtzqQMKmzMfDBstGhSXiBZy msv9tDCAgkiOtdSUkvvsY0fVXZaDbc3gcnvX8R1/yA89B/SPWOm/7sgmXYrq18wz/V kXXcd4QbHNGaPJhQ04sNe6uJk1N7WowoYD1tsj68= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 195A43858D28 for ; Tue, 23 Nov 2021 17:02:33 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 195A43858D28 Received: from mail-qv1-f69.google.com (mail-qv1-f69.google.com [209.85.219.69]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-468-j6_WWuOaMQ6fBJP9d_g6rA-1; Tue, 23 Nov 2021 12:02:26 -0500 X-MC-Unique: j6_WWuOaMQ6fBJP9d_g6rA-1 Received: by mail-qv1-f69.google.com with SMTP id kj12-20020a056214528c00b003bde2e1df71so19585564qvb.18 for ; Tue, 23 Nov 2021 09:02:26 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent :content-language:to:from:subject:cc; bh=c6ct8faqMcFM2hcYUOrTibJLg3/2I8LUtcEsfoipSAs=; b=hUGDagAf2lGIccibKEN+xeOZYUegqeGTnt7xQbEbtLv4hjWkWgrkPCi3BMoNFjFXmT FQv8y/Ng3EGqiwT1nXGs5DZNC8toWZf29tlOlDNXknzU91NyymgFwzJgWiTvl2bBm44B tk1mJoehs154wYJSaFpTiRRk2NA5CBty4ZGVsRj5yktfNSQPUqgSR9y6h9Q1K917EETE XATcLUdaqhDgsIrykrZ21S066y0k3J2ZamgDkt0fI4YuDceaWjWSeYJZQ+SSv78MBZV/ 54312IhFxMD/8Whca/wWSAUxWyFONpaVWzCk51WB5UduUnEaF5I4ahKTvs3eLbneLU+8 VNQQ== X-Gm-Message-State: AOAM530l5nXLZKxHZNHsrR0PE+KNOFmVyowZ6TonJVRoukyBQEOWqVL1 eGeovLgVQ7AXyTzl9WaRv/cDSRkmo+5HyF1n3AviAQODTUMjx6DxD6VI6UdYlrsW3XkjHe3tG9s gcPUsabIKeUuJOLir2DaSPov1Dc0pwsenEpm5ktHxoXzfs3XTpMCkS9ZSC01gUAGa8tydQA== X-Received: by 2002:a05:6214:240c:: with SMTP id fv12mr8195399qvb.58.1637686945032; Tue, 23 Nov 2021 09:02:25 -0800 (PST) X-Google-Smtp-Source: ABdhPJwPy2xvUcnd25mN8ecespXX2JXjlaITYcWowerTfEKKFYtzh4u3aZXKMpDXuWeJxQl+E1asLg== X-Received: by 2002:a05:6214:240c:: with SMTP id fv12mr8195358qvb.58.1637686944736; Tue, 23 Nov 2021 09:02:24 -0800 (PST) Received: from ?IPV6:2607:fea8:a262:5f00::38cf? ([2607:fea8:a262:5f00::38cf]) by smtp.gmail.com with ESMTPSA id bq43sm6889493qkb.32.2021.11.23.09.02.23 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 23 Nov 2021 09:02:23 -0800 (PST) Message-ID: Date: Tue, 23 Nov 2021 12:02:22 -0500 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Thunderbird/91.3.2 To: gcc-patches Subject: [PATCH 1/2] Split return functionality of get_non_stale_global_range. X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-CA X-Spam-Status: No, score=-12.6 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, 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: , X-Patchwork-Original-From: Andrew MacLeod via Gcc-patches From: Andrew MacLeod Reply-To: Andrew MacLeod Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" This is the first of 2 patches which will reduce the depth of the call chain in ranger. This patch simply splits the functionality of the routine get_non_stale_global_range() from a single boolean return to a boolean return and a bool reference. This routine queries the global cache for a value.  If  there is no value, it queries the legacy global range and sets it to that value.  If there was a value, it checks the temporal cache to see if its current, and if it is, returns TRUe plus the range. If the value is not currrent, or it was set to the legacy global value, then the timestamp is marked as "always current" as it indicates a calculation is ongoing, and we dont want to trigger any additional temporal faults until the calculation is done. And finallt FALSE is returned for all these cases. The second patch in the series wants to disambiguate at the call site whether this was a failure due to not being in the global cache, or whether it was due to the timestamp being out of date and take different actions for each case.   Details in the following note. This has been Bootstrapped on x86_64-pc-linux-gnu with no regressions.  OK? Andrew From 310719594aa20e8d012f478ab3208f889b558bac Mon Sep 17 00:00:00 2001 From: Andrew MacLeod Date: Fri, 19 Nov 2021 12:59:12 -0500 Subject: [PATCH 2/3] Split return functionality of get_non_stale_global_range. Get_non_stale_global_range returns true only when there is a cache entry that is not out of date. Change it so that it returns true if there was a cache value, but return the temporal comparison result in an auxiallary flag. * gimple-range-cache.cc (ranger_cache::get_global_range): Always return a range, return if it came from the cache or not. (get_non_stale_global_range): Rename to get_global_range, and return the temporal state in a flag. * gimple-range-cache.h (get_non_stale_global_range): Rename and adjust. * gimple-range.cc (gimple_ranger::range_of_expr): No need to query get_global_range. (gimple_ranger::range_of_stmt): Adjust for global cache temporal state returned in a flag. --- gcc/gimple-range-cache.cc | 55 ++++++++++++++++++++------------------- gcc/gimple-range-cache.h | 2 +- gcc/gimple-range.cc | 21 ++++++++------- 3 files changed, 41 insertions(+), 37 deletions(-) diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc index b347edeb474..fe31e9462aa 100644 --- a/gcc/gimple-range-cache.cc +++ b/gcc/gimple-range-cache.cc @@ -923,44 +923,45 @@ ranger_cache::dump_bb (FILE *f, basic_block bb) } // Get the global range for NAME, and return in R. Return false if the -// global range is not set. +// global range is not set, and return the legacy global value in R. bool ranger_cache::get_global_range (irange &r, tree name) const { - return m_globals.get_global_range (r, name); + if (m_globals.get_global_range (r, name)) + return true; + r = gimple_range_global (name); + return false; } -// Get the global range for NAME, and return in R if the value is not stale. -// If the range is set, but is stale, mark it current and return false. -// If it is not set pick up the legacy global value, mark it current, and -// return false. -// Note there is always a value returned in R. The return value indicates -// whether that value is an up-to-date calculated value or not.. +// Get the global range for NAME, and return in R. Return false if the +// global range is not set, and R will contain the legacy global value. +// CURRENT_P is set to true if the value was in cache and not stale. +// Otherwise, set CURRENT_P to false and mark as it always current. +// If the global cache did not have a value, initialize it as well. +// After this call, the global cache will have a value. bool -ranger_cache::get_non_stale_global_range (irange &r, tree name) +ranger_cache::get_global_range (irange &r, tree name, bool ¤t_p) { - if (m_globals.get_global_range (r, name)) - { - // Use this value if the range is constant or current. - if (r.singleton_p () - || m_temporal->current_p (name, m_gori.depend1 (name), - m_gori.depend2 (name))) - return true; - } + bool had_global = get_global_range (r, name); + + // If there was a global value, set current flag, otherwise set a value. + current_p = false; + if (had_global) + current_p = r.singleton_p () + || m_temporal->current_p (name, m_gori.depend1 (name), + m_gori.depend2 (name)); else - { - // Global has never been accessed, so pickup the legacy global value. - r = gimple_range_global (name); - m_globals.set_global_range (name, r); - } - // After a stale check failure, mark the value as always current until a - // new one is set. - m_temporal->set_always_current (name); - return false; + m_globals.set_global_range (name, r); + + // If the existing value was not current, mark it as always current. + if (!current_p) + m_temporal->set_always_current (name); + return current_p; } -// Set the global range of NAME to R. + +// Set the global range of NAME to R and give it a timestamp. void ranger_cache::set_global_range (tree name, const irange &r) diff --git a/gcc/gimple-range-cache.h b/gcc/gimple-range-cache.h index 49c13d1e85f..eb7a875c46b 100644 --- a/gcc/gimple-range-cache.h +++ b/gcc/gimple-range-cache.h @@ -100,7 +100,7 @@ public: bool block_range (irange &r, basic_block bb, tree name, bool calc = true); bool get_global_range (irange &r, tree name) const; - bool get_non_stale_global_range (irange &r, tree name); + bool get_global_range (irange &r, tree name, bool ¤t_p); void set_global_range (tree name, const irange &r); void propagate_updated_value (tree name, basic_block bb); diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc index 9ca568ce55d..e3ab3a8bb48 100644 --- a/gcc/gimple-range.cc +++ b/gcc/gimple-range.cc @@ -85,8 +85,7 @@ gimple_ranger::range_of_expr (irange &r, tree expr, gimple *stmt) if (!stmt) { int_range_max tmp; - if (!m_cache.get_global_range (r, expr)) - r = gimple_range_global (expr); + m_cache.get_global_range (r, expr); // Pick up implied context information from the on-entry cache // if current_bb is set. Do not attempt any new calculations. if (current_bb && m_cache.block_range (tmp, current_bb, expr, false)) @@ -282,15 +281,19 @@ gimple_ranger::range_of_stmt (irange &r, gimple *s, tree name) } else if (!gimple_range_ssa_p (name)) res = get_tree_range (r, name, NULL); - // Check if the stmt has already been processed, and is not stale. - else if (m_cache.get_non_stale_global_range (r, name)) - { - if (idx) - tracer.trailer (idx, " cached", true, name, r); - return true; - } else { + bool current; + // Check if the stmt has already been processed, and is not stale. + if (m_cache.get_global_range (r, name, current)) + { + if (current) + { + if (idx) + tracer.trailer (idx, " cached", true, name, r); + return true; + } + } // Otherwise calculate a new value. int_range_max tmp; fold_range_internal (tmp, s, name); -- 2.17.2