diff mbox series

Move computation of SLP_TREE_NUMBER_OF_VEC_STMTS

Message ID 87mv5wnsxl.fsf@linaro.org
State New
Headers show
Series Move computation of SLP_TREE_NUMBER_OF_VEC_STMTS | expand

Commit Message

Richard Sandiford Sept. 15, 2017, 10:43 a.m. UTC
Previously SLP_TREE_NUMBER_OF_VEC_STMTS was calculated while scheduling
an SLP tree after analysis, but sometimes it can be useful to know the
value during analysis too.  This patch moves the calculation to
vect_slp_analyze_node_operaions instead.

This became more natural after:

2017-06-30  Richard Biener  <rguenther@suse.de>

        * tree-vect-slp.c (vect_slp_analyze_node_operations): Only
        analyze the first scalar stmt.  Move vector type computation
        for the BB case here from ...
        * tree-vect-stmts.c (vect_analyze_stmt): ... here.  Guard
        live operation processing in the SLP case properly.

since the STMT_VINFO_VECTYPE is now always initialised in time.

Tested on aarch64-linux-gnu, x86_64-linux-gnu and powerpc64le-linux-gnu.
OK to install?

Richard


2017-09-15  Richard Sandiford  <richard.sandiford@linaro.org>
	    Alan Hayward  <alan.hayward@arm.com>
	    David Sherwood  <david.sherwood@arm.com>

gcc/
	* tree-vectorizer.h (vect_slp_analyze_operations): Replace parameters
	with a vec_info *.
	* tree-vect-loop.c (vect_analyze_loop_operations): Update call
	accordingly.
	* tree-vect-slp.c (vect_slp_analyze_node_operations): Add vec_info *
	parameter.  Set SLP_TREE_NUMBER_OF_VEC_STMTS here rather than in
	vect_schedule_slp_instance.
	(vect_slp_analyze_operations): Replace parameters with a vec_info *.
	Update call to vect_slp_analyze_node_operations.  Simplify return
	value.
	(vect_slp_analyze_bb_1): Update call accordingly.
	(vect_schedule_slp_instance): Remove vectorization_factor parameter.
	Don't calculate SLP_TREE_NUMBER_OF_VEC_STMTS here.
	(vect_schedule_slp): Update call accordingly.

Comments

Jeff Law Sept. 15, 2017, 3:33 p.m. UTC | #1
On 09/15/2017 04:43 AM, Richard Sandiford wrote:
> Previously SLP_TREE_NUMBER_OF_VEC_STMTS was calculated while scheduling

> an SLP tree after analysis, but sometimes it can be useful to know the

> value during analysis too.  This patch moves the calculation to

> vect_slp_analyze_node_operaions instead.

> 

> This became more natural after:

> 

> 2017-06-30  Richard Biener  <rguenther@suse.de>

> 

>         * tree-vect-slp.c (vect_slp_analyze_node_operations): Only

>         analyze the first scalar stmt.  Move vector type computation

>         for the BB case here from ...

>         * tree-vect-stmts.c (vect_analyze_stmt): ... here.  Guard

>         live operation processing in the SLP case properly.

> 

> since the STMT_VINFO_VECTYPE is now always initialised in time.

> 

> Tested on aarch64-linux-gnu, x86_64-linux-gnu and powerpc64le-linux-gnu.

> OK to install?

> 

> Richard

> 

> 

> 2017-09-15  Richard Sandiford  <richard.sandiford@linaro.org>

> 	    Alan Hayward  <alan.hayward@arm.com>

> 	    David Sherwood  <david.sherwood@arm.com>

> 

> gcc/

> 	* tree-vectorizer.h (vect_slp_analyze_operations): Replace parameters

> 	with a vec_info *.

> 	* tree-vect-loop.c (vect_analyze_loop_operations): Update call

> 	accordingly.

> 	* tree-vect-slp.c (vect_slp_analyze_node_operations): Add vec_info *

> 	parameter.  Set SLP_TREE_NUMBER_OF_VEC_STMTS here rather than in

> 	vect_schedule_slp_instance.

> 	(vect_slp_analyze_operations): Replace parameters with a vec_info *.

> 	Update call to vect_slp_analyze_node_operations.  Simplify return

> 	value.

> 	(vect_slp_analyze_bb_1): Update call accordingly.

> 	(vect_schedule_slp_instance): Remove vectorization_factor parameter.

> 	Don't calculate SLP_TREE_NUMBER_OF_VEC_STMTS here.

> 	(vect_schedule_slp): Update call accordingly.

OK.
jeff
diff mbox series

Patch

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2017-09-14 17:35:26.635276568 +0100
+++ gcc/tree-vectorizer.h	2017-09-15 11:35:46.833592065 +0100
@@ -1246,8 +1246,7 @@  extern void vect_free_slp_instance (slp_
 extern bool vect_transform_slp_perm_load (slp_tree, vec<tree> ,
                                           gimple_stmt_iterator *, int,
                                           slp_instance, bool, unsigned *);
-extern bool vect_slp_analyze_operations (vec<slp_instance> slp_instances,
-					 void *);
+extern bool vect_slp_analyze_operations (vec_info *);
 extern bool vect_schedule_slp (vec_info *);
 extern bool vect_analyze_slp (vec_info *, unsigned);
 extern bool vect_make_slp_decision (loop_vec_info);
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2017-09-14 17:35:26.635276568 +0100
+++ gcc/tree-vect-loop.c	2017-09-15 11:35:46.832592132 +0100
@@ -2031,8 +2031,7 @@  vect_analyze_loop_2 (loop_vec_info loop_
 	 remove unsupported SLP instances which makes the above
 	 SLP kind detection invalid.  */
       unsigned old_size = LOOP_VINFO_SLP_INSTANCES (loop_vinfo).length ();
-      vect_slp_analyze_operations (LOOP_VINFO_SLP_INSTANCES (loop_vinfo),
-				   LOOP_VINFO_TARGET_COST_DATA (loop_vinfo));
+      vect_slp_analyze_operations (loop_vinfo);
       if (LOOP_VINFO_SLP_INSTANCES (loop_vinfo).length () != old_size)
 	goto again;
     }
Index: gcc/tree-vect-slp.c
===================================================================
--- gcc/tree-vect-slp.c	2017-09-14 17:04:19.083694343 +0100
+++ gcc/tree-vect-slp.c	2017-09-15 11:35:46.833592065 +0100
@@ -2501,11 +2501,14 @@  _bb_vec_info::~_bb_vec_info ()
 }
 
 
-/* Analyze statements contained in SLP tree node after recursively analyzing
-   the subtree. Return TRUE if the operations are supported.  */
+/* Analyze statements contained in SLP tree NODE after recursively analyzing
+   the subtree.  NODE_INSTANCE contains NODE and VINFO contains INSTANCE.
+
+   Return true if the operations are supported.  */
 
 static bool
-vect_slp_analyze_node_operations (slp_tree node, slp_instance node_instance)
+vect_slp_analyze_node_operations (vec_info *vinfo, slp_tree node,
+				  slp_instance node_instance)
 {
   bool dummy;
   int i, j;
@@ -2516,7 +2519,7 @@  vect_slp_analyze_node_operations (slp_tr
     return true;
 
   FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child)
-    if (!vect_slp_analyze_node_operations (child, node_instance))
+    if (!vect_slp_analyze_node_operations (vinfo, child, node_instance))
       return false;
 
   stmt = SLP_TREE_SCALAR_STMTS (node)[0];
@@ -2568,6 +2571,29 @@  vect_slp_analyze_node_operations (slp_tr
 	STMT_VINFO_VECTYPE (vinfo_for_stmt (sstmt)) = vectype;
     }
 
+  /* Calculate the number of vector statements to be created for the
+     scalar stmts in this node.  For SLP reductions it is equal to the
+     number of vector statements in the children (which has already been
+     calculated by the recursive call).  Otherwise it is the number of
+     scalar elements in one scalar iteration (GROUP_SIZE) multiplied by
+     VF divided by the number of elements in a vector.  */
+  if (GROUP_FIRST_ELEMENT (stmt_info)
+      && !STMT_VINFO_GROUPED_ACCESS (stmt_info))
+    SLP_TREE_NUMBER_OF_VEC_STMTS (node)
+      = SLP_TREE_NUMBER_OF_VEC_STMTS (SLP_TREE_CHILDREN (node)[0]);
+  else
+    {
+      int vf;
+      if (loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo))
+	vf = loop_vinfo->vectorization_factor;
+      else
+	vf = 1;
+      unsigned int group_size = SLP_INSTANCE_GROUP_SIZE (node_instance);
+      tree vectype = STMT_VINFO_VECTYPE (stmt_info);
+      SLP_TREE_NUMBER_OF_VEC_STMTS (node)
+	= vf * group_size / TYPE_VECTOR_SUBPARTS (vectype);
+    }
+
   /* Push SLP node def-type to stmt operands.  */
   FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), j, child)
     if (SLP_TREE_DEF_TYPE (child) != vect_internal_def)
@@ -2586,11 +2612,11 @@  vect_slp_analyze_node_operations (slp_tr
 }
 
 
-/* Analyze statements in SLP instances of the basic block.  Return TRUE if the
+/* Analyze statements in SLP instances of VINFO.  Return true if the
    operations are supported. */
 
 bool
-vect_slp_analyze_operations (vec<slp_instance> slp_instances, void *data)
+vect_slp_analyze_operations (vec_info *vinfo)
 {
   slp_instance instance;
   int i;
@@ -2599,9 +2625,10 @@  vect_slp_analyze_operations (vec<slp_ins
     dump_printf_loc (MSG_NOTE, vect_location,
 		     "=== vect_slp_analyze_operations ===\n");
 
-  for (i = 0; slp_instances.iterate (i, &instance); )
+  for (i = 0; vinfo->slp_instances.iterate (i, &instance); )
     {
-      if (!vect_slp_analyze_node_operations (SLP_INSTANCE_TREE (instance),
+      if (!vect_slp_analyze_node_operations (vinfo,
+					     SLP_INSTANCE_TREE (instance),
 					     instance))
         {
 	  dump_printf_loc (MSG_NOTE, vect_location,
@@ -2610,20 +2637,17 @@  vect_slp_analyze_operations (vec<slp_ins
 			    SLP_TREE_SCALAR_STMTS
 			      (SLP_INSTANCE_TREE (instance))[0], 0);
 	  vect_free_slp_instance (instance);
-          slp_instances.ordered_remove (i);
+          vinfo->slp_instances.ordered_remove (i);
 	}
       else
 	{
 	  /* Compute the costs of the SLP instance.  */
-	  vect_analyze_slp_cost (instance, data);
+	  vect_analyze_slp_cost (instance, vinfo->target_cost_data);
 	  i++;
 	}
     }
 
-  if (!slp_instances.length ())
-    return false;
-
-  return true;
+  return !vinfo->slp_instances.is_empty ();
 }
 
 
@@ -2897,8 +2921,7 @@  vect_slp_analyze_bb_1 (gimple_stmt_itera
       return NULL;
     }
 
-  if (!vect_slp_analyze_operations (BB_VINFO_SLP_INSTANCES (bb_vinfo),
-				    BB_VINFO_TARGET_COST_DATA (bb_vinfo)))
+  if (!vect_slp_analyze_operations (bb_vinfo))
     {
       if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
@@ -3652,14 +3675,13 @@  vect_transform_slp_perm_load (slp_tree n
 /* Vectorize SLP instance tree in postorder.  */
 
 static bool
-vect_schedule_slp_instance (slp_tree node, slp_instance instance,
-                            unsigned int vectorization_factor)
+vect_schedule_slp_instance (slp_tree node, slp_instance instance)
 {
   gimple *stmt;
   bool grouped_store, is_store;
   gimple_stmt_iterator si;
   stmt_vec_info stmt_info;
-  unsigned int vec_stmts_size, nunits, group_size;
+  unsigned int group_size;
   tree vectype;
   int i, j;
   slp_tree child;
@@ -3668,7 +3690,7 @@  vect_schedule_slp_instance (slp_tree nod
     return false;
 
   FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child)
-    vect_schedule_slp_instance (child, instance, vectorization_factor);
+    vect_schedule_slp_instance (child, instance);
 
   /* Push SLP node def-type to stmts.  */
   FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child)
@@ -3681,27 +3703,10 @@  vect_schedule_slp_instance (slp_tree nod
 
   /* VECTYPE is the type of the destination.  */
   vectype = STMT_VINFO_VECTYPE (stmt_info);
-  nunits = (unsigned int) TYPE_VECTOR_SUBPARTS (vectype);
   group_size = SLP_INSTANCE_GROUP_SIZE (instance);
 
-  /* For each SLP instance calculate number of vector stmts to be created
-     for the scalar stmts in each node of the SLP tree.  Number of vector
-     elements in one vector iteration is the number of scalar elements in
-     one scalar iteration (GROUP_SIZE) multiplied by VF divided by vector
-     size.
-     Unless this is a SLP reduction in which case the number of vector
-     stmts is equal to the number of vector stmts of the children.  */
-  if (GROUP_FIRST_ELEMENT (stmt_info)
-      && !STMT_VINFO_GROUPED_ACCESS (stmt_info))
-    vec_stmts_size = SLP_TREE_NUMBER_OF_VEC_STMTS (SLP_TREE_CHILDREN (node)[0]);
-  else
-    vec_stmts_size = (vectorization_factor * group_size) / nunits;
-
   if (!SLP_TREE_VEC_STMTS (node).exists ())
-    {
-      SLP_TREE_VEC_STMTS (node).create (vec_stmts_size);
-      SLP_TREE_NUMBER_OF_VEC_STMTS (node) = vec_stmts_size;
-    }
+    SLP_TREE_VEC_STMTS (node).create (SLP_TREE_NUMBER_OF_VEC_STMTS (node));
 
   if (dump_enabled_p ())
     {
@@ -3850,20 +3855,15 @@  vect_schedule_slp (vec_info *vinfo)
 {
   vec<slp_instance> slp_instances;
   slp_instance instance;
-  unsigned int i, vf;
+  unsigned int i;
   bool is_store = false;
 
   slp_instances = vinfo->slp_instances;
-  if (is_a <loop_vec_info> (vinfo))
-    vf = as_a <loop_vec_info> (vinfo)->vectorization_factor;
-  else
-    vf = 1;
-
   FOR_EACH_VEC_ELT (slp_instances, i, instance)
     {
       /* Schedule the tree of INSTANCE.  */
       is_store = vect_schedule_slp_instance (SLP_INSTANCE_TREE (instance),
-                                             instance, vf);
+                                             instance);
       if (dump_enabled_p ())
 	dump_printf_loc (MSG_NOTE, vect_location,
                          "vectorizing stmts using SLP.\n");