SMS: Revisit order of insns within a row

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@132615 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f924395..5b2f80f 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2008-02-25  Ayal Zaks  <zaks@il.ibm.com>
+       Revital Eres  <eres@il.ibm.com>
+
+       * modulo-sched.c (calculate_must_precede_follow): Address TODO
+       regarding the order of two dependent insns in the same row.
+
 2008-02-25  Eric Botcazou  <ebotcazou@adacore.com>
 
        * stor-layout.c (layout_decl): Do not bump the alignment of a

diff --git a/gcc/modulo-sched.c b/gcc/modulo-sched.c
index 0fe180f..3d710ad 100644 (file)
--- a/gcc/modulo-sched.c
+++ b/gcc/modulo-sched.c
@@ -1587,18 +1587,17 @@ get_sched_window (partial_schedule_ptr ps, int *nodes_order, int i,
 
 /* Calculate MUST_PRECEDE/MUST_FOLLOW bitmaps of U_NODE; which is the
    node currently been scheduled.  At the end of the calculation
-   MUST_PRECEDE/MUST_FOLLOW contains all predecessors/successors of U_NODE
-   which are in SCHED_NODES (already scheduled nodes) and scheduled at
-   the same row as the first/last row of U_NODE's scheduling window.
+   MUST_PRECEDE/MUST_FOLLOW contains all predecessors/successors of
+   U_NODE which are (1) already scheduled in the first/last row of
+   U_NODE's scheduling window, (2) whose dependence inequality with U
+   becomes an equality when U is scheduled in this same row, and (3)
+   whose dependence latency is zero.
+
    The first and last rows are calculated using the following parameters:
    START/END rows - The cycles that begins/ends the traversal on the window;
    searching for an empty cycle to schedule U_NODE.
    STEP - The direction in which we traverse the window.
-   II - The initiation interval.
-   TODO: We can add an insn to the must_precede/must_follow bitmap only
-   if it has tight dependence to U and they are both scheduled in the
-   same row.  The current check is more conservative and content with
-   the fact that both U and the insn are scheduled in the same row.  */
+   II - The initiation interval.  */
 
 static void
 calculate_must_precede_follow (ddg_node_ptr u_node, int start, int end,
@@ -1607,7 +1606,6 @@ calculate_must_precede_follow (ddg_node_ptr u_node, int start, int end,
 {
   ddg_edge_ptr e;
   int first_cycle_in_window, last_cycle_in_window;
-  int first_row_in_window, last_row_in_window;
 
   gcc_assert (must_precede && must_follow);
 
@@ -1621,18 +1619,27 @@ calculate_must_precede_follow (ddg_node_ptr u_node, int start, int end,
   first_cycle_in_window = (step == 1) ? start : end - step;
   last_cycle_in_window = (step == 1) ? end - step : start;
 
-  first_row_in_window = SMODULO (first_cycle_in_window, ii);
-  last_row_in_window = SMODULO (last_cycle_in_window, ii);
-
   sbitmap_zero (must_precede);
   sbitmap_zero (must_follow);
 
   if (dump_file)
     fprintf (dump_file, "\nmust_precede: ");
 
+  /* Instead of checking if:
+      (SMODULO (SCHED_TIME (e->src), ii) == first_row_in_window)
+      && ((SCHED_TIME (e->src) + e->latency - (e->distance * ii)) ==
+             first_cycle_in_window)
+      && e->latency == 0
+     we use the fact that latency is non-negative:
+      SCHED_TIME (e->src) - (e->distance * ii) <=
+      SCHED_TIME (e->src) + e->latency - (e->distance * ii)) <=
+      first_cycle_in_window
+     and check only if
+      SCHED_TIME (e->src) - (e->distance * ii) == first_cycle_in_window  */
   for (e = u_node->in; e != 0; e = e->next_in)
     if (TEST_BIT (sched_nodes, e->src->cuid)
-       && (SMODULO (SCHED_TIME (e->src), ii) == first_row_in_window))
+       && ((SCHED_TIME (e->src) - (e->distance * ii)) ==
+             first_cycle_in_window))
       {
        if (dump_file)
          fprintf (dump_file, "%d ", e->src->cuid);
@@ -1643,9 +1650,21 @@ calculate_must_precede_follow (ddg_node_ptr u_node, int start, int end,
   if (dump_file)
     fprintf (dump_file, "\nmust_follow: ");
 
+  /* Instead of checking if:
+      (SMODULO (SCHED_TIME (e->dest), ii) == last_row_in_window)
+      && ((SCHED_TIME (e->dest) - e->latency + (e->distance * ii)) ==
+             last_cycle_in_window)
+      && e->latency == 0
+     we use the fact that latency is non-negative:
+      SCHED_TIME (e->dest) + (e->distance * ii) >=
+      SCHED_TIME (e->dest) - e->latency + (e->distance * ii)) >= 
+      last_cycle_in_window
+     and check only if
+      SCHED_TIME (e->dest) + (e->distance * ii) == last_cycle_in_window  */
   for (e = u_node->out; e != 0; e = e->next_out)
     if (TEST_BIT (sched_nodes, e->dest->cuid)
-       && (SMODULO (SCHED_TIME (e->dest), ii) == last_row_in_window))
+       && ((SCHED_TIME (e->dest) + (e->distance * ii)) ==
+             last_cycle_in_window))
       {
        if (dump_file)
          fprintf (dump_file, "%d ", e->dest->cuid);