directives.c File Reference

#include "defines-local.h"
#include "prettyprint.h"

Include dependency graph for directives.c:

Go to the source code of this file.

Macros
#define	SB_LIST_VARIABLE(sb, list_var, txt_begin)

Functions
	GENERIC_LOCAL_FUNCTION (directives, step_directives)
	Copyright 2007, 2008, 2009 Alain Muller, Frederique Silber-Chaussumier. More...
void	get_step_directive_name (step_directive drt, string *directive_txt)
	Warning! Do not modify this file that is automatically generated! More...
void	step_directive_type_print (step_directive drt)
void	step_directives_print ()
void	step_directives_init (bool first_p)
void	step_directives_reset ()
void	step_directives_save ()
step_directive	step_directives_load (statement stmt)
bool	step_directives_bound_p (statement stmt)
void	step_directives_store (statement stmt, step_directive d)
bool	step_directive_to_strings (step_directive d, bool is_fortran, string *begin_txt, string *end_txt)
statement	step_directive_basic_workchunk (step_directive d)
list	step_directive_basic_workchunk_index (step_directive d)
void	step_directive_print (step_directive d)
static list	step_directive_omp_get_private_entities (step_directive directive)
bool	step_private_p (statement stmt, entity e)

Macro Definition Documentation

SB_LIST_VARIABLE

#define SB_LIST_VARIABLE	(		sb,
			list_var,
			txt_begin
	)

Value:

  if(!set_empty_p(list_var))                                            \
    {                                                                   \
      string s = string_undefined;                                      \
      FOREACH(ENTITY, variable, set_to_sorted_list(list_var, (gen_cmp_func_t)compare_entities)) \
        {                                                               \
          if(s == string_undefined)                                     \
            s=strdup(concatenate(txt_begin, entity_user_name(variable), NULL)); \
          else                                                          \
            s=strdup(concatenate(", ", entity_user_name(variable), NULL)); \
          string_buffer_append(sb, s);                                  \
        }                                                               \
      string_buffer_append(sb, strdup(")"));                            \
    }

Definition at line 132 of file directives.c.

Function Documentation

GENERIC_LOCAL_FUNCTION()

GENERIC_LOCAL_FUNCTION	(	directives	,
		step_directives
	)

Copyright 2007, 2008, 2009 Alain Muller, Frederique Silber-Chaussumier.

This file is part of STEP.

The program is distributed under the terms of the GNU General Public License.

get_step_directive_name()

void get_step_directive_name	(	step_directive	drt,
		string *	directive_txt
	)

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/step/step-local.h instead, to add your own modifications. header file built by cproto step-local.h cproto-generated files directives.c

Parameters

drt	rt
directive_txt	irective_txt

Definition at line 18 of file directives.c.

{
  pips_debug(2, "begin\n");
 
  switch(step_directive_type(drt))
    {
    case STEP_PARALLEL:
      *directive_txt = strdup(STEP_PARALLEL_NAME);
      break;
    case STEP_DO:
      *directive_txt = strdup(STEP_DO_NAME);
      break;
    case STEP_PARALLEL_DO:
      *directive_txt = strdup(STEP_PARALLEL_DO_NAME);
      break;
    case STEP_MASTER:
      *directive_txt = strdup(STEP_MASTER_NAME);
      break;
    case STEP_SINGLE:
      *directive_txt = strdup(STEP_SINGLE_NAME);
      break;
    case STEP_BARRIER:
      *directive_txt = string_undefined;
      break;
    case STEP_THREADPRIVATE:
      *directive_txt = string_undefined;
      break;
    default: assert(0);
    }
 
  pips_debug(2, "end\n");
}

References assert, directive_txt, pips_debug, STEP_BARRIER, step_directive_type, STEP_DO, STEP_DO_NAME, STEP_MASTER, STEP_MASTER_NAME, STEP_PARALLEL, STEP_PARALLEL_DO, STEP_PARALLEL_DO_NAME, STEP_PARALLEL_NAME, STEP_SINGLE, STEP_SINGLE_NAME, STEP_THREADPRIVATE, strdup(), and string_undefined.

Referenced by generate_call_construct_begin_construct_end().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_basic_workchunk()

statement step_directive_basic_workchunk

(

step_directive

d

)

Definition at line 286 of file directives.c.

{
  statement stmt = step_directive_block(d);
  pips_debug(3, "begin\n");
 
  switch(step_directive_type(d))
    {
    case STEP_DO:
    case STEP_PARALLEL_DO:
      {
        // on retourne le corps de boucle
        list block = statement_block(stmt);
        pips_assert("1 statement", gen_length(block) == 1);
 
        stmt = STATEMENT(CAR(block));
 
        if(statement_loop_p(stmt))
          stmt = loop_body(statement_loop(stmt));
        else if (statement_forloop_p(stmt))
          stmt = forloop_body(statement_forloop(stmt));
        else
          pips_assert("not a loop", false);
        break;
      }
    default:
      {
        // on retourne le block de la directive
      }
    }
 
  pips_debug(3, "end\n");
  return stmt;
}

References CAR, forloop_body, gen_length(), loop_body, pips_assert, pips_debug, STATEMENT, statement_block(), statement_forloop(), statement_forloop_p(), statement_loop(), statement_loop_p(), step_directive_block, step_directive_type, STEP_DO, and STEP_PARALLEL_DO.

Referenced by compute_directive_regions(), and step_print_directives_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_basic_workchunk_index()

list step_directive_basic_workchunk_index

(

step_directive

d

)

Definition at line 320 of file directives.c.

{
  list index_l = NIL;
  statement stmt = step_directive_block(d);
 
  pips_debug(4, "begin\n");
  switch(step_directive_type(d))
    {
    case STEP_DO:
    case STEP_PARALLEL_DO:
      {
        list block = statement_block(stmt);
        pips_assert("1 statement", gen_length(block) == 1);
 
        stmt = STATEMENT(CAR(block));
 
        if(statement_loop_p(stmt))
          index_l = CONS(ENTITY, loop_index(statement_loop(stmt)), index_l);
        else if (statement_forloop_p(stmt))
          {
            expression init = forloop_initialization(statement_forloop(stmt));
            pips_assert("an assignment", assignment_expression_p(init));
            list assign_params = call_arguments(syntax_call(expression_syntax(init)));
            expression lhs = EXPRESSION(CAR(assign_params));
            entity e = expression_to_entity(lhs);
            pips_assert("an entity", !entity_undefined_p(e));
            index_l = CONS(ENTITY, e, index_l);
          }
        else
          pips_assert("not a loop", false);
        break;
      }
    default:
      {
        // on retourne la liste vide
      }
    }
 
  pips_debug(4, "end\n");
  return gen_nreverse(index_l);
}

References assignment_expression_p(), call_arguments, CAR, CONS, ENTITY, entity_undefined_p, EXPRESSION, expression_syntax, expression_to_entity(), forloop_initialization, gen_length(), gen_nreverse(), init, loop_index, NIL, pips_assert, pips_debug, STATEMENT, statement_block(), statement_forloop(), statement_forloop_p(), statement_loop(), statement_loop_p(), step_directive_block, step_directive_type, STEP_DO, STEP_PARALLEL_DO, and syntax_call.

Referenced by step_compute_step_interlaced().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_omp_get_private_entities()

static list step_directive_omp_get_private_entities ( step_directive  directive )

static

Definition at line 404 of file directives.c.

{
  pips_debug(4, "begin\n");
  list private_l = NIL;
  list clauses = step_directive_clauses(directive);
  FOREACH(STEP_CLAUSE,c,clauses)
    {
      switch (step_clause_tag(c))
        {
        case is_step_clause_private:
          private_l = gen_append(step_clause_private(c), private_l);
          break;
        default:
          break;
        }
    }
  pips_debug(4, "end\n");
  return private_l;
}

References FOREACH, gen_append(), is_step_clause_private, NIL, pips_debug, STEP_CLAUSE, step_clause_private, step_clause_tag, and step_directive_clauses.

Referenced by step_private_p().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_print()

void step_directive_print

(

step_directive

d

)

Definition at line 362 of file directives.c.

{
  int type = step_directive_type(d);
  list clauses = step_directive_clauses(d);
  string begin_txt, end_txt;
  bool is_fortran = fortran_module_p(get_current_module_entity());
  bool is_block_construct = step_directive_to_strings(d, is_fortran, &begin_txt, &end_txt);
 
  pips_debug(1, "begin ====> TYPE %d : \nNB clauses : %d\n\tdirective begin : %s\n",
             type, (int)gen_length(clauses), begin_txt);
  if (is_block_construct && !empty_comments_p(end_txt)) pips_debug(1,"\tdirective end : %s\n", end_txt);
 
  ifdebug(1)
    {
      statement stmt = step_directive_block(d);
      assert(!statement_undefined_p(stmt));
      pips_debug(1, "----> on statement :\n");
      print_statement(stmt);
      pips_debug(1, "\n");
    }
  /*
  ifdebug(2)
    {
      statement stmt = step_directive_basic_workchunk(d);
      assert(!statement_undefined_p(stmt));
 
      string index_str=strdup("");
      FOREACH(ENTITY, e , step_directive_basic_workchunk_index(d))
        {
          string previous = index_str;
          index_str = strdup(concatenate(previous, entity_local_name(e), " ", NULL));
          free(previous);
        }
      pips_debug(2, "\n----> basic workchunk (index : [%s] )\n", index_str);
      print_statement(stmt);
      pips_debug(2, "\n");
      }
  */
  pips_debug(1, "end\n");
}

References assert, empty_comments_p(), fortran_module_p(), gen_length(), get_current_module_entity(), ifdebug, pips_debug, print_statement(), statement_undefined_p, step_directive_block, step_directive_clauses, step_directive_to_strings(), and step_directive_type.

Referenced by compile_rewrite(), compute_directive_regions(), and step_directives_print().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_to_strings()

bool step_directive_to_strings	(	step_directive	d,
		bool	is_fortran,
		string *	begin_txt,
		string *	end_txt
	)

clause

transformation clause is not printed

Parameters

is_fortran	s_fortran
begin_txt	egin_txt
end_txt	nd_txt

Definition at line 147 of file directives.c.

{
  bool block_directive = true;
  bool end_directive = is_fortran;
 
  string directive_txt = string_undefined;
  switch(step_directive_type(d))
    {
    case STEP_PARALLEL:
      directive_txt = strdup("parallel");
      break;
    case STEP_DO:
      directive_txt = strdup(is_fortran?"do":"for");
      block_directive = is_fortran;
      break;
    case STEP_PARALLEL_DO:
      directive_txt = strdup(is_fortran?"parallel do":"parallel for");
      block_directive = is_fortran;
      break;
    case STEP_MASTER:
      directive_txt = strdup("master");
      break;
    case STEP_SINGLE:
      directive_txt = strdup("single");
      break;
    case STEP_BARRIER:
      directive_txt = strdup("barrier");
      block_directive = false;
      end_directive = false;
      break;
    case STEP_THREADPRIVATE:
      directive_txt = strdup("threadprivate");
      block_directive = false;
      end_directive = false;
      break;
    default:
      pips_internal_error("unpexpected step directive type");
    }
 
  /*  clause */
  set copyin_l = set_make(set_pointer);
  set private_l = set_make(set_pointer);
  set shared_l = set_make(set_pointer);
  set threadprivate_l = set_make(set_pointer);
  set firstprivate_l = set_make(set_pointer);
  list schedule_l = list_undefined;
  bool nowait = false;
 
  int op;
  set reductions_l[STEP_UNDEF_REDUCE];
  for(op=0; op<STEP_UNDEF_REDUCE; op++)
    reductions_l[op] = set_make(set_pointer);
 
  FOREACH(STEP_CLAUSE, c, step_directive_clauses(d))
    {
      switch (step_clause_tag(c))
        {
        case is_step_clause_copyin:
          set_append_list(copyin_l, step_clause_copyin(c));
          break;
        case is_step_clause_private:
          set_append_list(private_l, step_clause_private(c));
          break;
        case is_step_clause_shared:
          set_append_list(shared_l, step_clause_shared(c));
          break;
        case is_step_clause_threadprivate:
          set_append_list(threadprivate_l, step_clause_threadprivate(c));
          break;
        case is_step_clause_firstprivate:
          set_append_list(firstprivate_l, step_clause_firstprivate(c));
          break;
        case is_step_clause_nowait:
          nowait = true;
          break;
        case is_step_clause_reduction:
          MAP_ENTITY_INT_MAP(variable, op, {
              set_add_element(reductions_l[op], reductions_l[op], variable);
            }, step_clause_reduction(c));
          break;
        case is_step_clause_schedule:
          schedule_l = step_clause_schedule(c);
          break;
        case is_step_clause_transformation:
          /* transformation clause is not printed */
          break;
        default: assert(0);
        }
    }
 
 
  if(end_directive)
    *end_txt = strdup(concatenate("omp end ",directive_txt, nowait?" nowait":"", NULL));
  else
    *end_txt = string_undefined;
 
  string_buffer sb = string_buffer_make(false);
  string_buffer_cat(sb, strdup("omp "), strdup(directive_txt), NULL);
 
  SB_LIST_VARIABLE(sb, copyin_l, " copyin(");
  SB_LIST_VARIABLE(sb, private_l, " private(");
  SB_LIST_VARIABLE(sb, shared_l, " shared(");
  SB_LIST_VARIABLE(sb, threadprivate_l, "(");
  SB_LIST_VARIABLE(sb, firstprivate_l, " firstprivate(");
 
  if(!list_undefined_p(schedule_l))
    {
      string s = string_undefined;
      FOREACH(STRING, str, schedule_l)
        {
          if(s == string_undefined)
            s=strdup(concatenate(" schedule(", str, NULL));
          else
            s=strdup(concatenate(", ", str, NULL));
          string_buffer_append(sb, s);
        }
      string_buffer_append(sb, strdup(")"));
    }
 
  string op_txt[STEP_UNDEF_REDUCE]={" reduction(*: "," reduction(max: "," reduction(min: "," reduction(+: "};
  for(op=0; op<STEP_UNDEF_REDUCE; op++)
    SB_LIST_VARIABLE(sb, reductions_l[op], op_txt[op]);
 
  if(nowait && !end_directive)
    string_buffer_append(sb, strdup(" nowait"));
 
  *begin_txt = string_buffer_to_string(sb);
  string_buffer_free_all(&sb);
 
  ifdebug(4)
    {
      printf("ÞÞÞÞÞÞÞÞÞ directive begin : %s\n", *begin_txt);
      printf("ÞÞÞÞÞÞÞÞÞ directive end : %s\n", end_directive?*end_txt:"");
    }
 
  return block_directive;
}

References assert, concatenate(), directive_txt, end_directive(), FOREACH, ifdebug, is_step_clause_copyin, is_step_clause_firstprivate, is_step_clause_nowait, is_step_clause_private, is_step_clause_reduction, is_step_clause_schedule, is_step_clause_shared, is_step_clause_threadprivate, is_step_clause_transformation, list_undefined, list_undefined_p, MAP_ENTITY_INT_MAP, pips_internal_error, printf(), SB_LIST_VARIABLE, set_add_element(), set_append_list(), set_make(), set_pointer, STEP_BARRIER, STEP_CLAUSE, step_clause_copyin, step_clause_firstprivate, step_clause_private, step_clause_reduction, step_clause_schedule, step_clause_shared, step_clause_tag, step_clause_threadprivate, step_directive_clauses, step_directive_type, STEP_DO, STEP_MASTER, STEP_PARALLEL, STEP_PARALLEL_DO, STEP_SINGLE, STEP_THREADPRIVATE, STEP_UNDEF_REDUCE, strdup(), STRING, string_buffer_append(), string_buffer_cat(), string_buffer_free_all(), string_buffer_make(), string_buffer_to_string(), and string_undefined.

Referenced by compile_omp(), and step_directive_print().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_type_print()

void step_directive_type_print

(

step_directive

drt

)

Parameters

drt

rt

Definition at line 51 of file directives.c.

{
  switch(step_directive_type(drt))
    {
    case STEP_PARALLEL:
      pips_debug(1, "step_directive_type = STEP_PARALLEL\n");
      break;
    case STEP_PARALLEL_DO:
      pips_debug(1, "step_directive_type = STEP_PARALLEL_DO\n");
      break;
    case STEP_DO:
      pips_debug(1, "step_directive_type = STEP_DO\n");
      break;
    case STEP_MASTER:
      pips_debug(1, "step_directive_type = STEP_MASTER\n");
      break;
    case STEP_BARRIER:
      pips_debug(1, "step_directive_type = STEP_BARRIER\n");
      break;
    case STEP_THREADPRIVATE:
      pips_debug(1, "step_directive_type = STEP_THREADPRIVATE\n");
      break;
    default:
      pips_debug(1, "step_directive_type = UNKNOWN\n");
      break;
    }
}

References pips_debug, STEP_BARRIER, step_directive_type, STEP_DO, STEP_MASTER, STEP_PARALLEL, STEP_PARALLEL_DO, and STEP_THREADPRIVATE.

Referenced by compile_body().

Here is the caller graph for this function:

step_directives_bound_p()

bool step_directives_bound_p

(

statement

stmt

)

Parameters

stmt

tmt

Definition at line 121 of file directives.c.

{
  return bound_directives_p(stmt);
}

Referenced by compile_filter(), compile_rewrite(), compute_SENDRECV_regions(), end_omp_construct(), get_current_step_directive(), sequence_rewrite(), statement_filter(), step_compute_CHAINS_DG_SENDRECV_regions(), and step_statement_path_first_directive_statement().

Here is the caller graph for this function:

step_directives_init()

void step_directives_init

(

bool

first_p

)

Parameters

first_p

irst_p

Definition at line 88 of file directives.c.

{
  pips_debug(4, "begin first_p = %d\n", first_p);
 
  if (first_p)
    init_directives();
  else
    {
      const char *module_name = entity_user_name(get_current_module_entity());
      set_directives((step_directives)db_get_memory_resource(DBR_STEP_DIRECTIVES, module_name, true));
    }
 
  pips_debug(4, "end\n");
}

References db_get_memory_resource(), entity_user_name(), get_current_module_entity(), module_name(), and pips_debug.

Referenced by step_analyse(), step_compile_analysed_module(), and step_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directives_load()

step_directive step_directives_load

(

statement

stmt

)

Parameters

stmt

tmt

Definition at line 116 of file directives.c.

{
  return load_directives(stmt);
}

Referenced by compile_filter(), compile_rewrite(), compute_SENDRECV_regions(), end_omp_construct(), get_current_step_directive(), and step_private_p().

Here is the caller graph for this function:

step_directives_print()

void step_directives_print

(

void

)

Definition at line 79 of file directives.c.

{
  STEP_DIRECTIVES_MAP(block_stmt, d,
                      {
                        assert(!statement_undefined_p(block_stmt));
                        step_directive_print(d);
                      }, get_directives()); 
}

References assert, statement_undefined_p, step_directive_print(), and STEP_DIRECTIVES_MAP.

Referenced by step_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directives_reset()

void step_directives_reset

(

void

)

Definition at line 103 of file directives.c.

{
  reset_directives();
}

Referenced by step_analyse(), and step_compile_analysed_module().

Here is the caller graph for this function:

step_directives_save()

void step_directives_save

(

void

)

Definition at line 108 of file directives.c.

{
  const char *module_name = entity_user_name(get_current_module_entity());
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_DIRECTIVES, module_name, get_directives());
  reset_directives();
}

References DB_PUT_MEMORY_RESOURCE, entity_user_name(), get_current_module_entity(), and module_name().

Referenced by step_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directives_store()

void step_directives_store	(	statement	stmt,
		step_directive	d
	)

Parameters

stmt

tmt

Definition at line 126 of file directives.c.

{
  assert(statement_block_p(stmt));
  store_directives(stmt, d);
}

References assert, and statement_block_p.

Referenced by new_step_directive().

Here is the caller graph for this function:

step_private_p()

bool step_private_p	(	statement	stmt,
		entity	e
	)

Parameters

stmt

tmt

Definition at line 424 of file directives.c.

{
  pips_debug(4, "begin\n");
  step_directive d = step_directives_load(stmt);
  list private_l;
  private_l = step_directive_omp_get_private_entities(d);
  pips_debug(4, "end\n");
  return gen_in_list_p(e, private_l);
}

References gen_in_list_p(), pips_debug, step_directive_omp_get_private_entities(), and step_directives_load().

Referenced by create_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function: