public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Do not account single-lane SLP graphs against discovery limit
@ 2023-10-19 13:29 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-10-19 13:29 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:b2107f70d7d729fd5b1c573f2eecaac0a3f9e6f5
commit b2107f70d7d729fd5b1c573f2eecaac0a3f9e6f5
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 15:12:54 2023 +0200
Do not account single-lane SLP graphs against discovery limit
The following avoids accounting single-lane SLP to the discovery
limit. Even when raising it the attempt of forming multi-lane SLP
can exhaust the limit before we fall back to single-lane.
* tree-vect-slp.cc (vect_build_slp_tree): Only account
multi-lane SLP to limit.
Diff:
---
gcc/tree-vect-slp.cc | 31 ++++++++++++++++++-------------
1 file changed, 18 insertions(+), 13 deletions(-)
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 98170bef47ba..9e693f578c0c 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -1691,21 +1691,26 @@ vect_build_slp_tree (vec_info *vinfo,
SLP_TREE_SCALAR_STMTS (res) = stmts;
bst_map->put (stmts.copy (), res);
- if (*limit == 0)
+ /* Single-lane SLP doesn't have the chance of run-away, do not account
+ it to the limit. */
+ if (stmts.length () > 1)
{
- if (dump_enabled_p ())
- dump_printf_loc (MSG_NOTE, vect_location,
- "SLP discovery limit exceeded\n");
- /* Mark the node invalid so we can detect those when still in use
- as backedge destinations. */
- SLP_TREE_SCALAR_STMTS (res) = vNULL;
- SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
- res->failed = XNEWVEC (bool, group_size);
- memset (res->failed, 0, sizeof (bool) * group_size);
- memset (matches, 0, sizeof (bool) * group_size);
- return NULL;
+ if (*limit == 0)
+ {
+ if (dump_enabled_p ())
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "SLP discovery limit exceeded\n");
+ /* Mark the node invalid so we can detect those when still in use
+ as backedge destinations. */
+ SLP_TREE_SCALAR_STMTS (res) = vNULL;
+ SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
+ res->failed = XNEWVEC (bool, group_size);
+ memset (res->failed, 0, sizeof (bool) * group_size);
+ memset (matches, 0, sizeof (bool) * group_size);
+ return NULL;
+ }
+ --*limit;
}
- --*limit;
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Do not account single-lane SLP graphs against discovery limit
@ 2024-02-23 7:31 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2024-02-23 7:31 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:9db05737e95c245145155a2f1744d2c5cc2c7d33
commit 9db05737e95c245145155a2f1744d2c5cc2c7d33
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 15:12:54 2023 +0200
Do not account single-lane SLP graphs against discovery limit
The following avoids accounting single-lane SLP to the discovery
limit. Even when raising it the attempt of forming multi-lane SLP
can exhaust the limit before we fall back to single-lane.
* tree-vect-slp.cc (vect_build_slp_tree): Only account
multi-lane SLP to limit.
Diff:
---
gcc/tree-vect-slp.cc | 31 ++++++++++++++++++-------------
1 file changed, 18 insertions(+), 13 deletions(-)
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index e5a5045f4f5f..47149df6cd71 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -1719,21 +1719,26 @@ vect_build_slp_tree (vec_info *vinfo,
SLP_TREE_SCALAR_STMTS (res) = stmts;
bst_map->put (stmts.copy (), res);
- if (*limit == 0)
+ /* Single-lane SLP doesn't have the chance of run-away, do not account
+ it to the limit. */
+ if (stmts.length () > 1)
{
- if (dump_enabled_p ())
- dump_printf_loc (MSG_NOTE, vect_location,
- "SLP discovery limit exceeded\n");
- /* Mark the node invalid so we can detect those when still in use
- as backedge destinations. */
- SLP_TREE_SCALAR_STMTS (res) = vNULL;
- SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
- res->failed = XNEWVEC (bool, group_size);
- memset (res->failed, 0, sizeof (bool) * group_size);
- memset (matches, 0, sizeof (bool) * group_size);
- return NULL;
+ if (*limit == 0)
+ {
+ if (dump_enabled_p ())
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "SLP discovery limit exceeded\n");
+ /* Mark the node invalid so we can detect those when still in use
+ as backedge destinations. */
+ SLP_TREE_SCALAR_STMTS (res) = vNULL;
+ SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
+ res->failed = XNEWVEC (bool, group_size);
+ memset (res->failed, 0, sizeof (bool) * group_size);
+ memset (matches, 0, sizeof (bool) * group_size);
+ return NULL;
+ }
+ --*limit;
}
- --*limit;
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Do not account single-lane SLP graphs against discovery limit
@ 2023-11-09 13:03 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-11-09 13:03 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:2885097eaf348a562d5abbfdc6d006a08bba18db
commit 2885097eaf348a562d5abbfdc6d006a08bba18db
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 15:12:54 2023 +0200
Do not account single-lane SLP graphs against discovery limit
The following avoids accounting single-lane SLP to the discovery
limit. Even when raising it the attempt of forming multi-lane SLP
can exhaust the limit before we fall back to single-lane.
* tree-vect-slp.cc (vect_build_slp_tree): Only account
multi-lane SLP to limit.
Diff:
---
gcc/tree-vect-slp.cc | 31 ++++++++++++++++++-------------
1 file changed, 18 insertions(+), 13 deletions(-)
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 4c7ad976963..b3a2ec0ab87 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -1726,21 +1726,26 @@ vect_build_slp_tree (vec_info *vinfo,
SLP_TREE_SCALAR_STMTS (res) = stmts;
bst_map->put (stmts.copy (), res);
- if (*limit == 0)
+ /* Single-lane SLP doesn't have the chance of run-away, do not account
+ it to the limit. */
+ if (stmts.length () > 1)
{
- if (dump_enabled_p ())
- dump_printf_loc (MSG_NOTE, vect_location,
- "SLP discovery limit exceeded\n");
- /* Mark the node invalid so we can detect those when still in use
- as backedge destinations. */
- SLP_TREE_SCALAR_STMTS (res) = vNULL;
- SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
- res->failed = XNEWVEC (bool, group_size);
- memset (res->failed, 0, sizeof (bool) * group_size);
- memset (matches, 0, sizeof (bool) * group_size);
- return NULL;
+ if (*limit == 0)
+ {
+ if (dump_enabled_p ())
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "SLP discovery limit exceeded\n");
+ /* Mark the node invalid so we can detect those when still in use
+ as backedge destinations. */
+ SLP_TREE_SCALAR_STMTS (res) = vNULL;
+ SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
+ res->failed = XNEWVEC (bool, group_size);
+ memset (res->failed, 0, sizeof (bool) * group_size);
+ memset (matches, 0, sizeof (bool) * group_size);
+ return NULL;
+ }
+ --*limit;
}
- --*limit;
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Do not account single-lane SLP graphs against discovery limit
@ 2023-11-02 13:59 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-11-02 13:59 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:4b676ef953b3560ecc6909a664522dbd013345a6
commit 4b676ef953b3560ecc6909a664522dbd013345a6
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 15:12:54 2023 +0200
Do not account single-lane SLP graphs against discovery limit
The following avoids accounting single-lane SLP to the discovery
limit. Even when raising it the attempt of forming multi-lane SLP
can exhaust the limit before we fall back to single-lane.
* tree-vect-slp.cc (vect_build_slp_tree): Only account
multi-lane SLP to limit.
Diff:
---
gcc/tree-vect-slp.cc | 31 ++++++++++++++++++-------------
1 file changed, 18 insertions(+), 13 deletions(-)
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 473d606a3359..acc5c3865f9d 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -1725,21 +1725,26 @@ vect_build_slp_tree (vec_info *vinfo,
SLP_TREE_SCALAR_STMTS (res) = stmts;
bst_map->put (stmts.copy (), res);
- if (*limit == 0)
+ /* Single-lane SLP doesn't have the chance of run-away, do not account
+ it to the limit. */
+ if (stmts.length () > 1)
{
- if (dump_enabled_p ())
- dump_printf_loc (MSG_NOTE, vect_location,
- "SLP discovery limit exceeded\n");
- /* Mark the node invalid so we can detect those when still in use
- as backedge destinations. */
- SLP_TREE_SCALAR_STMTS (res) = vNULL;
- SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
- res->failed = XNEWVEC (bool, group_size);
- memset (res->failed, 0, sizeof (bool) * group_size);
- memset (matches, 0, sizeof (bool) * group_size);
- return NULL;
+ if (*limit == 0)
+ {
+ if (dump_enabled_p ())
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "SLP discovery limit exceeded\n");
+ /* Mark the node invalid so we can detect those when still in use
+ as backedge destinations. */
+ SLP_TREE_SCALAR_STMTS (res) = vNULL;
+ SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
+ res->failed = XNEWVEC (bool, group_size);
+ memset (res->failed, 0, sizeof (bool) * group_size);
+ memset (matches, 0, sizeof (bool) * group_size);
+ return NULL;
+ }
+ --*limit;
}
- --*limit;
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Do not account single-lane SLP graphs against discovery limit
@ 2023-10-16 12:49 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-10-16 12:49 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:5515521aa666f94a430974be7b0f8dcb5c5dc583
commit 5515521aa666f94a430974be7b0f8dcb5c5dc583
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 15:12:54 2023 +0200
Do not account single-lane SLP graphs against discovery limit
The following avoids accounting single-lane SLP to the discovery
limit. Even when raising it the attempt of forming multi-lane SLP
can exhaust the limit before we fall back to single-lane.
* tree-vect-slp.cc (vect_build_slp_tree): Only account
multi-lane SLP to limit.
Diff:
---
gcc/tree-vect-slp.cc | 31 ++++++++++++++++++-------------
1 file changed, 18 insertions(+), 13 deletions(-)
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 9741d2ee2163..ef3a105cfaf4 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -1652,21 +1652,26 @@ vect_build_slp_tree (vec_info *vinfo,
SLP_TREE_SCALAR_STMTS (res) = stmts;
bst_map->put (stmts.copy (), res);
- if (*limit == 0)
+ /* Single-lane SLP doesn't have the chance of run-away, do not account
+ it to the limit. */
+ if (stmts.length () > 1)
{
- if (dump_enabled_p ())
- dump_printf_loc (MSG_NOTE, vect_location,
- "SLP discovery limit exceeded\n");
- /* Mark the node invalid so we can detect those when still in use
- as backedge destinations. */
- SLP_TREE_SCALAR_STMTS (res) = vNULL;
- SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
- res->failed = XNEWVEC (bool, group_size);
- memset (res->failed, 0, sizeof (bool) * group_size);
- memset (matches, 0, sizeof (bool) * group_size);
- return NULL;
+ if (*limit == 0)
+ {
+ if (dump_enabled_p ())
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "SLP discovery limit exceeded\n");
+ /* Mark the node invalid so we can detect those when still in use
+ as backedge destinations. */
+ SLP_TREE_SCALAR_STMTS (res) = vNULL;
+ SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
+ res->failed = XNEWVEC (bool, group_size);
+ memset (res->failed, 0, sizeof (bool) * group_size);
+ memset (matches, 0, sizeof (bool) * group_size);
+ return NULL;
+ }
+ --*limit;
}
- --*limit;
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Do not account single-lane SLP graphs against discovery limit
@ 2023-10-06 7:07 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-10-06 7:07 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:d2799c4ffdb8b99ce8dd1502b2a5dfd2d7f33933
commit d2799c4ffdb8b99ce8dd1502b2a5dfd2d7f33933
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 15:12:54 2023 +0200
Do not account single-lane SLP graphs against discovery limit
The following avoids accounting single-lane SLP to the discovery
limit. Even when raising it the attempt of forming multi-lane SLP
can exhaust the limit before we fall back to single-lane.
* tree-vect-slp.cc (vect_build_slp_tree): Only account
multi-lane SLP to limit.
Diff:
---
gcc/tree-vect-slp.cc | 31 ++++++++++++++++++-------------
1 file changed, 18 insertions(+), 13 deletions(-)
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 4646380232f..41b5626cbe5 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -1634,21 +1634,26 @@ vect_build_slp_tree (vec_info *vinfo,
SLP_TREE_SCALAR_STMTS (res) = stmts;
bst_map->put (stmts.copy (), res);
- if (*limit == 0)
+ /* Single-lane SLP doesn't have the chance of run-away, do not account
+ it to the limit. */
+ if (stmts.length () > 1)
{
- if (dump_enabled_p ())
- dump_printf_loc (MSG_NOTE, vect_location,
- "SLP discovery limit exceeded\n");
- /* Mark the node invalid so we can detect those when still in use
- as backedge destinations. */
- SLP_TREE_SCALAR_STMTS (res) = vNULL;
- SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
- res->failed = XNEWVEC (bool, group_size);
- memset (res->failed, 0, sizeof (bool) * group_size);
- memset (matches, 0, sizeof (bool) * group_size);
- return NULL;
+ if (*limit == 0)
+ {
+ if (dump_enabled_p ())
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "SLP discovery limit exceeded\n");
+ /* Mark the node invalid so we can detect those when still in use
+ as backedge destinations. */
+ SLP_TREE_SCALAR_STMTS (res) = vNULL;
+ SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def;
+ res->failed = XNEWVEC (bool, group_size);
+ memset (res->failed, 0, sizeof (bool) * group_size);
+ memset (matches, 0, sizeof (bool) * group_size);
+ return NULL;
+ }
+ --*limit;
}
- --*limit;
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2024-02-23 7:31 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-10-19 13:29 [gcc(refs/users/rguenth/heads/vect-force-slp)] Do not account single-lane SLP graphs against discovery limit Richard Biener
-- strict thread matches above, loose matches on Subject: below --
2024-02-23 7:31 Richard Biener
2023-11-09 13:03 Richard Biener
2023-11-02 13:59 Richard Biener
2023-10-16 12:49 Richard Biener
2023-10-06 7:07 Richard Biener
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).