quick_privatize.c File Reference

#include "local.h"

Include dependency graph for quick_privatize.c:

Go to the source code of this file.

Functions
static bool	quick_privatize_loop (statement, list)
	QUICK PRIVATIZATION More...
static bool	quick_privatize_statement_pair (statement, statement, list)
void	quick_privatize_graph (graph dep_graph)
	quick_privatize.c More...

Function Documentation

quick_privatize_graph()

void quick_privatize_graph

(

graph

dep_graph

)

quick_privatize.c

we analyze arcs exiting from loop statements

Parameters

dep_graph

ep_graph

Definition at line 38 of file quick_privatize.c.

                                            {
  /* we analyze arcs exiting from loop statements */
  FOREACH (VERTEX, v1, graph_vertices(dep_graph)) {
    statement s1 = vertex_to_statement(v1);
    list successors = vertex_successors(v1);
    if(statement_loop_p(s1)) {
      loop l = statement_loop(s1);
      list locals = loop_locals(l);
      entity ind = loop_index(l);
 
      if(gen_find_eq(ind, locals) == entity_undefined) {
        if(// entity_privatizable_in_loop_p(ind, l) && /* to be restored when global variables are uniformly treated everywhere. BC.*/
           quick_privatize_loop(s1, successors)) {
          pips_debug(1, "Index for loop %" PRIdPTR " privatized\n",
              statement_number(s1));
          loop_locals(l) = CONS(ENTITY, ind, locals);
        } else {
          pips_debug(1, "could not privatize loop %" PRIdPTR "\n",
              statement_number(s1));
        }
      }
    }
  }
}

References CONS, dep_graph, ENTITY, entity_undefined, FOREACH, gen_find_eq(), graph_vertices, loop_index, loop_locals, pips_debug, quick_privatize_loop(), s1, statement_loop(), statement_loop_p(), statement_number, successors(), VERTEX, vertex_successors, and vertex_to_statement().

Referenced by compute_dg_on_statement_from_chains_in_place(), and rice_dependence_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

quick_privatize_loop()

static bool quick_privatize_loop ( statement  stat, list  successors  )

static

QUICK PRIVATIZATION

Parameters

stat	tat
successors	uccessors

Definition at line 63 of file quick_privatize.c.

                                                                  {
  pips_debug(3, "arcs from %" PRIdPTR "\n", statement_number(stat));
  FOREACH(SUCCESSOR, su, successors) {
    dg_arc_label dal = (dg_arc_label)successor_arc_label(su);
    statement st = vertex_to_statement(successor_vertex(su));
 
    pips_debug(3, "arcs to %" PRIdPTR "\n", statement_number(st));
 
    if(!quick_privatize_statement_pair(stat, st, dg_arc_label_conflicts(dal)))
      return (false);
  }
 
  return (true);
}

References dg_arc_label_conflicts, FOREACH, pips_debug, quick_privatize_statement_pair(), statement_number, SUCCESSOR, successor_arc_label, successor_vertex, successors(), and vertex_to_statement().

Referenced by quick_privatize_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

quick_privatize_statement_pair()

static bool quick_privatize_statement_pair ( statement  s1, statement  s2, list  conflicts  )

static

equivalence or conflict not created by loop index. I give up !

we must know where this read effect come from. if it comes from the loop body, the arc may be ignored.

s2 is a loop. if there are no read effet in the range part, ignore this conflict.

Parameters

s1	1
s2	2
conflicts	onflicts

Definition at line 80 of file quick_privatize.c.

                                   {
  loop l1 = statement_loop(s1);
  entity ind1 = loop_index(l1);
  FOREACH(CONFLICT, c, conflicts) {
    effect f1 = conflict_source(c);
    reference r1 = effect_any_reference(f1);
    entity e1 = reference_variable(r1);
 
    effect f2 = conflict_sink(c);
    reference r2 = effect_any_reference(f2);
    entity e2 = reference_variable(r2);
 
    pips_debug(2, "conflict between %s & %s\n",
        entity_name(e1), entity_name(e2));
 
    /* equivalence or conflict not created by loop index. I give up ! */
    if(e1 != ind1)
      continue;
 
    if(action_write_p(effect_action(f1)) && action_read_p(effect_action(f2))) {
      /* we must know where this read effect come from. if it
       comes from the loop body, the arc may be ignored. */
 
      list loops = load_statement_enclosing_loops(s2);
 
      if(gen_find_eq(s1, loops) == entity_undefined) {
        loop l2;
        entity ind2;
        list range_effects;
 
        pips_debug(3, "the arc goes outside the loop body.\n");
 
        if(is_implied_do_index(e1, statement_instruction(s2))) {
          pips_debug(3, "s2 is an implied loop\n");
          return (true);
        }
        if(!statement_loop_p(s2)) {
          pips_debug(3, "s2 not a loop\n");
          return (false);
        }
 
        /* s2 is a loop. if there are no read effet in the range
         part, ignore this conflict. */
        l2 = statement_loop(s2);
        ind2 = loop_index(l2);
        range_effects = proper_effects_of_range(loop_range(l2));
        FOREACH(EFFECT, e, range_effects) {
          if(reference_variable(effect_any_reference(e)) == ind2
              && action_read_p(effect_action(e))) {
 
            pips_debug(3, "index read in range expressions\n");
 
            free_effects(make_effects(range_effects));
            return (false);
          }
        }
        free_effects(make_effects(range_effects));
      }
    }
  }
 
  return (true);
}

References action_read_p, action_write_p, CONFLICT, conflict_sink, conflict_source, EFFECT, effect_action, effect_any_reference, entity_name, entity_undefined, f2(), FOREACH, free_effects(), gen_find_eq(), is_implied_do_index(), load_statement_enclosing_loops(), loop_index, loop_range, loops, make_effects(), pips_debug, proper_effects_of_range(), reference_variable, s1, statement_instruction, statement_loop(), and statement_loop_p().

Referenced by quick_privatize_loop().

Here is the call graph for this function:

Here is the caller graph for this function: