pragma.c File Reference

This file holds the generation of omp pragma for reductions. More...

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

Include dependency graph for pragma.c:

Go to the source code of this file.

Functions
static void	reset_all_reduction (void)
	reset the all_reduction flag More...
static bool	statement_is_reduction (statement stmt)
static void	compute_all_reduction (statement stmt)
	remenber if all the statement analazed are reduction since the last reset More...
static bool	reductions_on_scalar (reductions reds)
static entity	omp_operator_entity (reduction_operator o)
static expression	reduction_as_expr (reduction r)
static string	omp_operator_str (reduction_operator o)
static string	reduction_as_str (reduction r)
	allocates and returns a string for reduction r More...
list	reductions_get_omp_pragma_expr (loop l, statement stmt, bool strict)
	pragma.c More...
string	reductions_get_omp_pragma_str (loop l, statement stmt)
static list	omp_append_private_clause (loop l, list exprs)
static void	statement_remove_omp_clauses (statement stmt)
bool	omp_pragma_expr_for_reduction (loop l, statement stmt, bool strict)
	generate pragma for a reduction as a list of expressions More...
bool	omp_pragma_expr_for (loop l, statement stmt)
	generate "pragma omp for" as a list of expressions More...

Variables
static const string	OMP_PRAGMA_FOR_HEADER_C = "omp parallel for"
static const string	OMP_PRAGMA_FOR_HEADER_F = "omp parallel do"
static const string	REDUCTION_KEYWORD = "reduction"
static bool	all_reduction = false

Detailed Description

This file holds the generation of omp pragma for reductions.

Author

pierre villalon pierr.nosp@m.e.vi.nosp@m.llalo.nosp@m.n@hp.nosp@m.c-pro.nosp@m.ject.nosp@m..com

Date

2009-05-24

Definition in file pragma.c.

Function Documentation

compute_all_reduction()

static void compute_all_reduction ( statement  stmt )

static

remenber if all the statement analazed are reduction since the last reset

Returns

void

Parameters

stmt,the

statement to test for reduction

Definition at line 43 of file pragma.c.

                                                   {
  all_reduction = all_reduction && statement_is_reduction (stmt);
}

References all_reduction, and statement_is_reduction().

Referenced by reductions_get_omp_pragma_expr(), and reductions_get_omp_pragma_str().

Here is the call graph for this function:

Here is the caller graph for this function:

omp_append_private_clause()

static list omp_append_private_clause ( loop  l, list  exprs  )

static

Returns

the new pragma

Parameters

l,the	loop to analyze for omp reduction
exprs,the	pragma as a list of expression

Definition at line 293 of file pragma.c.

                                                           {
  // the private variables as a list of entites
  list private = loop_private_variables_as_entites (l, true, true);
  // add private clause if needed
  if (gen_length (private) != 0) {
    expression expr_private  = pragma_private_as_expr (private);
    exprs = gen_expression_cons (expr_private, exprs);
  }
  return exprs;
}

References gen_expression_cons(), gen_length(), loop_private_variables_as_entites(), and pragma_private_as_expr().

Referenced by omp_pragma_expr_for(), and omp_pragma_expr_for_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

omp_operator_entity()

static entity omp_operator_entity ( reduction_operator  o )

static

Returns

an entiy describing the reduction operator

Parameters

o	the reduction operator to analyze

Definition at line 61 of file pragma.c.

                                                         {
 
  entity result = entity_undefined;
  tag t = reduction_operator_tag(o);
 
  switch(t) {
  case is_reduction_operator_none:
    pips_internal_error("unexpected none reduction operator tag!");
    break;
  case is_reduction_operator_sum:
    result = CreateIntrinsic(PLUS_OPERATOR_NAME);
    break;
  case is_reduction_operator_csum:
    result = CreateIntrinsic(PLUS_C_OPERATOR_NAME);
    break;
  case is_reduction_operator_prod:
    result = CreateIntrinsic(MULTIPLY_OPERATOR_NAME);
    break;
  case is_reduction_operator_min:
    result = CreateIntrinsic(MIN_OPERATOR_NAME);
    break;
  case is_reduction_operator_max:
    result = CreateIntrinsic(MAX_OPERATOR_NAME);
    break;
  case is_reduction_operator_and:
    result = (prettyprint_language_is_fortran_p () == true ?
              CreateIntrinsic(AND_OPERATOR_NAME) :
              CreateIntrinsic(C_AND_OPERATOR_NAME));
    break;
  case is_reduction_operator_or:
    result = (prettyprint_language_is_fortran_p () == true ?
              CreateIntrinsic(OR_OPERATOR_NAME) :
              CreateIntrinsic(C_OR_OPERATOR_NAME));
    break;
  case is_reduction_operator_bitwise_or:
    result = CreateIntrinsic(BITWISE_OR_OPERATOR_NAME);
    break;
  case is_reduction_operator_bitwise_xor:
    result = CreateIntrinsic(BITWISE_XOR_OPERATOR_NAME);
    break;
  case is_reduction_operator_bitwise_and:
    result = CreateIntrinsic(BITWISE_AND_OPERATOR_NAME);
    break;
  case is_reduction_operator_eqv:
    pips_assert ("not a C reduction operator", prettyprint_language_is_fortran_p () == true);
    result = CreateIntrinsic(EQUIV_OPERATOR_NAME);
    break;
  case is_reduction_operator_neqv:
    pips_assert ("not a C reduction operator", prettyprint_language_is_fortran_p () == true);
    result = CreateIntrinsic(NON_EQUIV_OPERATOR_NAME);
    break;
  default:
    pips_internal_error("unexpected reduction operator tag!");
    break;
  }
  return result;
}

References AND_OPERATOR_NAME, BITWISE_AND_OPERATOR_NAME, BITWISE_OR_OPERATOR_NAME, BITWISE_XOR_OPERATOR_NAME, C_AND_OPERATOR_NAME, C_OR_OPERATOR_NAME, CreateIntrinsic(), entity_undefined, EQUIV_OPERATOR_NAME, is_reduction_operator_and, is_reduction_operator_bitwise_and, is_reduction_operator_bitwise_or, is_reduction_operator_bitwise_xor, is_reduction_operator_csum, is_reduction_operator_eqv, is_reduction_operator_max, is_reduction_operator_min, is_reduction_operator_neqv, is_reduction_operator_none, is_reduction_operator_or, is_reduction_operator_prod, is_reduction_operator_sum, MAX_OPERATOR_NAME, MIN_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, NON_EQUIV_OPERATOR_NAME, OR_OPERATOR_NAME, pips_assert, pips_internal_error, PLUS_C_OPERATOR_NAME, PLUS_OPERATOR_NAME, prettyprint_language_is_fortran_p(), and reduction_operator_tag.

Referenced by reduction_as_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

omp_operator_str()

static string omp_operator_str ( reduction_operator  o )

static

Returns

a (static) string describing the reduction operator for open mp

Parameters

o	the reduction operator to analyze

Definition at line 151 of file pragma.c.

                                                      {
 
  tag t = reduction_operator_tag(o);
  string result = string_undefined;
 
  switch(t) {
  case is_reduction_operator_none:
    result = "none";
    break;
  case is_reduction_operator_sum:
    result = "+";
    break;
  case is_reduction_operator_csum:
    result = "+";
    break;
  case is_reduction_operator_prod:
    result = "*";
    break;
  case is_reduction_operator_min:
    result = "MIN";
    break;
  case is_reduction_operator_max:
    result = "MAX";
    break;
  case is_reduction_operator_and:
    result = (prettyprint_language_is_fortran_p () == true) ? ".AND." : "&&";
    break;
  case is_reduction_operator_or:
    result = (prettyprint_language_is_fortran_p () == true) ? ".OR." :"||";
    break;
  case is_reduction_operator_bitwise_or:
    result = "|";
    break;
  case is_reduction_operator_bitwise_xor:
    result = "^";
    break;
  case is_reduction_operator_bitwise_and:
    result = "&";
    break;
  case is_reduction_operator_eqv:
    pips_assert ("not a C reduction operator", prettyprint_language_is_fortran_p () == true);
    result = ".EQV.";
    break;
  case is_reduction_operator_neqv:
    pips_assert ("not a C reduction operator", prettyprint_language_is_fortran_p () == true);
    result = ".NEQV.";
    break;
  default:
    pips_internal_error("unexpected reduction operator tag!");
    break;
  }
  return result;
}

References is_reduction_operator_and, is_reduction_operator_bitwise_and, is_reduction_operator_bitwise_or, is_reduction_operator_bitwise_xor, is_reduction_operator_csum, is_reduction_operator_eqv, is_reduction_operator_max, is_reduction_operator_min, is_reduction_operator_neqv, is_reduction_operator_none, is_reduction_operator_or, is_reduction_operator_prod, is_reduction_operator_sum, pips_assert, pips_internal_error, prettyprint_language_is_fortran_p(), reduction_operator_tag, and string_undefined.

Referenced by reduction_as_str().

Here is the call graph for this function:

Here is the caller graph for this function:

omp_pragma_expr_for()

bool omp_pragma_expr_for	(	loop	l,
		statement	stmt
	)

generate "pragma omp for" as a list of expressions

Returns

true if a pragma has been generated

Parameters

l,the	loop to analyze for omp for
stmt,the	statament where the pragma should be attached

Parameters

stmt

tmt

Definition at line 366 of file pragma.c.

                                                  {
  list exprs = NULL;
  if (execution_parallel_p(loop_execution(l))) {
    // the list of expression to generate initialized with
    // pragma "omp parallel for"
    list exprs = pragma_omp_parallel_for_as_exprs ();
    exprs = omp_append_private_clause (l, exprs);
    // insert the pragma as an expression to the current statement
    add_pragma_expr_to_statement (stmt, exprs);
    pips_debug (5, "new for pragma as an extension added\n");
  }
  return (exprs != NULL);
}

References add_pragma_expr_to_statement(), execution_parallel_p, loop_execution, omp_append_private_clause(), pips_debug, and pragma_omp_parallel_for_as_exprs().

Referenced by process_reductions_in_openmp_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

omp_pragma_expr_for_reduction()

bool omp_pragma_expr_for_reduction	(	loop	l,
		statement	stmt,
		bool	strict
	)

generate pragma for a reduction as a list of expressions

Returns

true if a pragma has been generated

Parameters

l,the	loop to analyze for omp reduction
stmt,the	statament where the pragma should be attached
strict,if	set to true, only one-liner statements with reductions are handled

Parameters

stmt	tmt
strict	trict

Definition at line 346 of file pragma.c.

                                                                         {
  // the list of expression to generate
  list exprs = NULL;
  exprs = reductions_get_omp_pragma_expr(l, stmt, strict);
  // insert the pragma (if any) as an expression to the current statement
  if (exprs != NULL) {
    // remove any previous openmp expression to make sure we do not introduce inconsistency
    statement_remove_omp_clauses(stmt);
    // check if a private clause is needed on top of the reduction clause
    exprs = omp_append_private_clause (l, exprs);
    add_pragma_expr_to_statement (stmt, exprs);
    pips_debug (5, "new reduction pragma as an extension added\n");
  }
  return (exprs != NULL);
}

References add_pragma_expr_to_statement(), omp_append_private_clause(), pips_debug, reductions_get_omp_pragma_expr(), and statement_remove_omp_clauses().

Referenced by process_reductions_in_openmp_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_as_expr()

static expression reduction_as_expr ( reduction  r )

static

Returns

a list of expression for reduction r

Parameters

r	the reduction to process

Definition at line 121 of file pragma.c.

{
  // prepare the expressions list that specifies the variable
  // and the operator
  reference ref = copy_reference (reduction_reference(r));
  syntax s = make_syntax_reference (ref);
  expression expr = make_expression (s, normalized_undefined);
  list args = NIL;
  args = gen_expression_cons (expr, args);
  // and now the operator
  reduction_operator op = reduction_op (r);
  ref = make_reference (omp_operator_entity (op), NIL);
  s = make_syntax_reference (ref);
  expr = make_expression (s, normalized_undefined);
  args = gen_expression_cons (expr, args);
 
  // first prepare "reduction" as an expression
  entity e = CreateIntrinsic(OMP_REDUCTION_FUNCTION_NAME);
  call c = make_call (e, args);
  s = make_syntax_call (c);
  expression result = make_expression (s, normalized_undefined);
 
  pips_debug(5, "finish\n");
  return result;
}

References copy_reference(), CreateIntrinsic(), gen_expression_cons(), make_call(), make_expression(), make_reference(), make_syntax_call(), make_syntax_reference(), NIL, normalized_undefined, omp_operator_entity(), OMP_REDUCTION_FUNCTION_NAME, pips_debug, reduction_op, reduction_reference, and ref.

Referenced by reductions_get_omp_pragma_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_as_str()

static string reduction_as_str ( reduction  r )

static

allocates and returns a string for reduction r

Definition at line 207 of file pragma.c.

{
  string str;
  str = concatenate (REDUCTION_KEYWORD,
                     "(", omp_operator_str (reduction_op(r)), ":",
                     reference_to_string(reduction_reference(r)),
                     ")", NULL);
  pips_debug(5, "finish with string: %s\n", str);
  return strdup (str);
}

References concatenate(), omp_operator_str(), pips_debug, REDUCTION_KEYWORD, reduction_op, reduction_reference, reference_to_string(), and strdup().

Referenced by reductions_get_omp_pragma_str().

Here is the call graph for this function:

Here is the caller graph for this function:

reductions_get_omp_pragma_expr()

list reductions_get_omp_pragma_expr	(	loop	l,
		statement	stmt,
		bool	strict
	)

pragma.c

Parameters

stmt	tmt
strict	trict

Definition at line 227 of file pragma.c.

                                                                          {
  list exprs = NIL;
  // check that reduction as been detected at loop level
  if  (statement_is_reduction (stmt) == true) {
    reductions rs = load_printed_reductions(stmt);
    // check that the reductions are done on scalars and not arrays
    if (reductions_on_scalar (rs) == true) {
      // reset the all reduction flag
      reset_all_reduction ();
      // check that all the statements of the loop are reductions otherwise, do
      // not generate omp reduction pragma
      // the test is too restrictive so need to be improved
      if(strict)
          gen_recurse(l, statement_domain, gen_true, compute_all_reduction);
      if (all_reduction) {
                                reductions rs = load_printed_reductions(stmt);
                                FOREACH (REDUCTION, red, reductions_list(rs)) {
                                  exprs = gen_expression_cons (reduction_as_expr (red), exprs);
                                }
                                //secondly get "omp parallel for" as an expr and concatenate
                                list parallel_for = pragma_omp_parallel_for_as_exprs ();
                                exprs = gen_nconc (exprs, parallel_for);
      }
    }
  }
  pips_debug(5, "finish with pragma\n");
  return exprs;
}

References all_reduction, compute_all_reduction(), FOREACH, gen_expression_cons(), gen_nconc(), gen_recurse, gen_true(), load_printed_reductions(), NIL, pips_debug, pragma_omp_parallel_for_as_exprs(), REDUCTION, reduction_as_expr(), reductions_list, reductions_on_scalar(), reset_all_reduction(), statement_domain, and statement_is_reduction().

Referenced by omp_pragma_expr_for_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

reductions_get_omp_pragma_str()

string reductions_get_omp_pragma_str	(	loop	l,
		statement	stmt
	)

Returns

a string with omp pragma for reductions

Parameters

l,the	loop associated with the statement
stmt,the	statement to analyzed for reductions, must be a loop

Parameters

stmt

tmt

Definition at line 259 of file pragma.c.

                                                              {
  string_buffer buf  = string_buffer_make (false);
  // check that reduction as been detected at loop level
  if  (statement_is_reduction (stmt) == true) {
    reductions rs = load_printed_reductions(stmt);
    // check that the reductions are done on scalars and not arrays
    if (reductions_on_scalar (rs) == true) {
      // reset the all reduction flag
      reset_all_reduction ();
      // check that all the statements of the loop are reductions otherwise, do
      // not generate omp reduction pragma
      // the test is too restrictive so need to be improved
      gen_recurse(l, statement_domain, gen_true, compute_all_reduction);
      if (all_reduction == true) {
        string header = (prettyprint_language_is_fortran_p ()
                         ? OMP_PRAGMA_FOR_HEADER_F :
                         OMP_PRAGMA_FOR_HEADER_C);
        string_buffer_append (buf, strdup (header));
        string_buffer_append (buf, strdup (" "));
        FOREACH (REDUCTION, red, reductions_list(rs)) {
          string_buffer_append (buf, reduction_as_str (red));
        }
      }
    }
  }
  string result = string_buffer_to_string (buf);
  pips_debug(5, "finish with pragma: %s\n", result);
  string_buffer_free_all (&buf);
  return result;
}

References all_reduction, buf, compute_all_reduction(), FOREACH, gen_recurse, gen_true(), load_printed_reductions(), OMP_PRAGMA_FOR_HEADER_C, OMP_PRAGMA_FOR_HEADER_F, pips_debug, prettyprint_language_is_fortran_p(), REDUCTION, reduction_as_str(), reductions_list, reductions_on_scalar(), reset_all_reduction(), statement_domain, statement_is_reduction(), strdup(), string_buffer_append(), string_buffer_free_all(), string_buffer_make(), and string_buffer_to_string().

Here is the call graph for this function:

reductions_on_scalar()

static bool reductions_on_scalar ( reductions  reds )

static

Returns

true if the reductions are applied on scalars only

Parameters

reds,the

reductions to analyze

Definition at line 49 of file pragma.c.

                                                   {
  FOREACH (REDUCTION, red, reductions_list(reds)) {
    reference ref = reduction_reference (red);
    if (reference_indices (ref) != NIL) return false;
  }
  return true;
}

References FOREACH, NIL, REDUCTION, reduction_reference, reductions_list, ref, and reference_indices.

Referenced by reductions_get_omp_pragma_expr(), and reductions_get_omp_pragma_str().

Here is the caller graph for this function:

reset_all_reduction()

static void reset_all_reduction ( void  )

static

reset the all_reduction flag

Definition at line 26 of file pragma.c.

                                       {
  all_reduction = true;
}

References all_reduction.

Referenced by reductions_get_omp_pragma_expr(), and reductions_get_omp_pragma_str().

Here is the caller graph for this function:

statement_is_reduction()

static bool statement_is_reduction ( statement  stmt )

static

Returns

true if the statement is a reduction

Parameters

stmt,the

statement to test for reduction

Definition at line 32 of file pragma.c.

                                                    {
  // test that we have a reachable statement
  if (bound_printed_reductions_p (stmt) == false) return false;
  int size = gen_length (reductions_list (load_printed_reductions(stmt)));
  return (size != 0);
}

References bound_printed_reductions_p(), gen_length(), load_printed_reductions(), and reductions_list.

Referenced by compute_all_reduction(), reductions_get_omp_pragma_expr(), and reductions_get_omp_pragma_str().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_remove_omp_clauses()

static void statement_remove_omp_clauses ( statement  stmt )

static

Definition at line 304 of file pragma.c.

                                                         {
    list exts = gen_copy_seq(extensions_extension(statement_extensions(stmt)));
    FOREACH(EXTENSION, ext, exts) {
        if(extension_pragma(ext)) {
            pragma p = extension_pragma(ext);
            bool remove=false;
            if(pragma_string_p(p)) {
                remove = (strncasecmp("omp", pragma_string(p), 3) == 0);
            }
            else if(pragma_expression_p(p)) {
                list exps = pragma_expression(p);
                FOREACH(EXPRESSION,exp, exps) {
                    if(expression_call_p(exp)) {
                        call c = expression_call(exp);
                        entity op = call_function(c);
                        const char* omp_entities[] = {
                            OMP_OMP_FUNCTION_NAME,
                            OMP_REDUCTION_FUNCTION_NAME,
                            OMP_PRIVATE_FUNCTION_NAME,
                            NULL
                        };
                        const char *lname = entity_local_name(op);
                        for(const char **iter=omp_entities;*iter;++iter) {
                            if((remove=same_string_p(lname, *iter))) {
                                break;
                            }
                        }
                    }
                    if(remove) break;
                }
            }
            if(remove)
                gen_remove_once(&extensions_extension(statement_extensions(stmt)),ext);
        }
    }
}

References call_function, entity_local_name(), exp, EXPRESSION, expression_call(), expression_call_p(), EXTENSION, extension_pragma, extensions_extension, FOREACH, gen_copy_seq(), gen_remove_once(), lname(), OMP_OMP_FUNCTION_NAME, OMP_PRIVATE_FUNCTION_NAME, OMP_REDUCTION_FUNCTION_NAME, pragma_expression, pragma_expression_p, pragma_string, pragma_string_p, same_string_p, and statement_extensions.

Referenced by omp_pragma_expr_for_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

all_reduction

bool all_reduction = false

static

Definition at line 20 of file pragma.c.

Referenced by compute_all_reduction(), reductions_get_omp_pragma_expr(), reductions_get_omp_pragma_str(), and reset_all_reduction().

OMP_PRAGMA_FOR_HEADER_C

const string OMP_PRAGMA_FOR_HEADER_C = "omp parallel for"

static

Definition at line 15 of file pragma.c.

Referenced by reductions_get_omp_pragma_str().

OMP_PRAGMA_FOR_HEADER_F

const string OMP_PRAGMA_FOR_HEADER_F = "omp parallel do"

static

Definition at line 16 of file pragma.c.

Referenced by reductions_get_omp_pragma_str().

REDUCTION_KEYWORD

const string REDUCTION_KEYWORD = "reduction"

static

Definition at line 17 of file pragma.c.

Referenced by reduction_as_str().