openmp_generation.c File Reference

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "boolean.h"
#include <stdbool.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "database.h"
#include "misc.h"
#include "text.h"
#include "text-util.h"
#include "ri-util.h"
#include "effects-util.h"
#include "accel-util.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "pipsdbm.h"
#include "resources.h"
#include "control.h"
#include "conversion.h"
#include "properties.h"
#include "transformations.h"
#include "effects-convex.h"
#include "complexity_ri.h"
#include "dg.h"
#include "graph.h"
#include "ricedg.h"
#include "chains.h"
#include "task_parallelization.h"

Include dependency graph for openmp_generation.c:

Go to the source code of this file.

Typedefs
typedef dg_arc_label	arc_label
	Instantiation of the dependence graph: More...
typedef dg_vertex_label	vertex_label

Functions
static void	gen_omp_taskwait (statement stmt)
static void	gen_omp_parallel (statement stmt)
static bool	gen_synchronization (statement stmt, bool nested_p, int length)
static bool	gen_openmp (statement stmt, bool nested_p)
bool	openmp_task_generation (char *module_name)
	OpenMP generation pass. More...

Variables
static bool	omp_parallel = false

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

Instantiation of the dependence graph:

Definition at line 41 of file openmp_generation.c.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 42 of file openmp_generation.c.

Function Documentation

gen_omp_parallel()

static void gen_omp_parallel ( statement  stmt )

static

Definition at line 61 of file openmp_generation.c.

                                            {
  string data = strdup(concatenate( "omp parallel default(shared) ",NULL));
  if(statement_sequence_p(stmt)){
    list stmts = sequence_statements(statement_sequence(stmt)), body = NIL, decls = NIL;
    statement st_body = statement_undefined;
    FOREACH(STATEMENT, st, stmts){
      if(declaration_statement_p(st))
        decls =  CONS(STATEMENT, st, decls);
      else
        if(!return_statement_p(st))
          body = CONS(STATEMENT, st, body);
        else
          return_st = st;
    }
    if(gen_length(body)>0){
      st_body = make_block_statement(gen_nreverse(body));
      add_pragma_str_to_statement (st_body, data, true);
      decls =  CONS(STATEMENT, st_body, decls);
    }
    if(gen_length(decls)>0){
      statement_instruction(stmt) = make_instruction_sequence(make_sequence(gen_nreverse(decls)));
    }
  }      
  else
    add_pragma_str_to_statement (stmt, data, true);
  return;
}

References add_pragma_str_to_statement(), concatenate(), CONS, declaration_statement_p(), FOREACH, gen_length(), gen_nreverse(), make_block_statement(), make_instruction_sequence(), make_sequence(), NIL, return_st, return_statement_p(), sequence_statements, STATEMENT, statement_instruction, statement_sequence(), statement_sequence_p(), statement_undefined, and strdup().

Referenced by openmp_task_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_omp_taskwait()

static void gen_omp_taskwait ( statement  stmt )

static

Definition at line 51 of file openmp_generation.c.

{
  statement st = make_continue_statement(entity_empty_label());
  string data = strdup(concatenate( "omp taskwait ",NULL));
  add_pragma_str_to_statement (st, data, true);
  statement_synchronization(stmt) =  make_synchronization_none();
  list list_stmts = CONS(STATEMENT, st, CONS(STATEMENT, copy_statement(stmt), NIL));
  statement_instruction(stmt) = make_instruction_sequence(make_sequence(gen_nreverse(list_stmts)));  
  return;
}

References add_pragma_str_to_statement(), concatenate(), CONS, copy_statement(), entity_empty_label(), gen_nreverse(), make_continue_statement(), make_instruction_sequence(), make_sequence(), make_synchronization_none(), NIL, STATEMENT, statement_instruction, statement_synchronization, and strdup().

Referenced by gen_synchronization().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_openmp()

static bool gen_openmp ( statement  stmt, bool  nested_p  )

static

Definition at line 119 of file openmp_generation.c.

                                                     {
  instruction inst = statement_instruction(stmt);
  switch(instruction_tag(inst))
    {
    case is_instruction_block:
      {
        MAPL(stmt_ptr,
              {
                statement st = STATEMENT(CAR( stmt_ptr));
                bool nested_p_local = gen_synchronization(st,nested_p, gen_length(sequence_statements(statement_sequence(stmt))));
                gen_openmp(st, nested_p_local);
              },
              instruction_block(inst));
        break;
      }
    case is_instruction_test :
      {
        test t = instruction_test(inst);
        bool nested_p_t = gen_synchronization(test_true(t),nested_p,1);
        bool nested_p_f = gen_synchronization(test_false(t),nested_p,1);
        gen_openmp(test_true(t), nested_p_t);
        gen_openmp(test_false(t), nested_p_f);
        break;
      }
    case is_instruction_loop :
      {
        loop l = statement_loop(stmt);
        statement body = loop_body(l);
        nested_p = gen_synchronization(body,nested_p,1);
        gen_openmp(body, nested_p);
        break;
      }
    default:
      break;
    }
  return true;
}

References CAR, gen_length(), gen_synchronization(), instruction_block, instruction_tag, instruction_test, is_instruction_block, is_instruction_loop, is_instruction_test, loop_body, MAPL, sequence_statements, STATEMENT, statement_instruction, statement_loop(), statement_sequence(), test_false, and test_true.

Referenced by openmp_task_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_synchronization()

static bool gen_synchronization ( statement  stmt, bool  nested_p, int  length  )

static

Definition at line 89 of file openmp_generation.c.

{
 synchronization sync  = statement_synchronization(stmt);
  switch(synchronization_tag(sync)){
  case is_synchronization_spawn:
    if(length>1){
      add_pragma_str_to_statement(stmt, "omp task", true);
      if(!omp_parallel)
        omp_parallel = true;
    }
    break;
  case is_synchronization_barrier:
    if(!nested_p){
      add_pragma_str_to_statement(stmt, "omp single", true);
      nested_p = true;
    }
    else
      {
        if(gen_length(sequence_statements(statement_sequence(stmt)))>1)
          gen_omp_taskwait(stmt);
      }
    if(!omp_parallel)
      omp_parallel = true;
    break;
  default:
    break;
  }
  return nested_p;
}

References add_pragma_str_to_statement(), gen_length(), gen_omp_taskwait(), is_synchronization_barrier, is_synchronization_spawn, omp_parallel, sequence_statements, statement_sequence(), statement_synchronization, and synchronization_tag.

Referenced by gen_openmp().

Here is the call graph for this function:

Here is the caller graph for this function:

openmp_task_generation()

bool openmp_task_generation

(

char *

module_name

)

OpenMP generation pass.

openmp_generation.c

Parameters

module_name

odule_name

Definition at line 160 of file openmp_generation.c.

{ 
  statement module_stat_i = (statement)db_get_memory_resource(DBR_SHARED_SPIRE_CODE, module_name, true);
  statement module_stat = copy_statement(module_stat_i);
  set_ordering_to_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement(module_stat);
  gen_openmp(module_stat, false);
  if(omp_parallel)
    gen_omp_parallel(module_stat);
  if(!statement_undefined_p(return_st)) 
    insert_statement(module_stat, return_st, false);
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_PARALLELIZED_CODE, module_name, module_stat);
  reset_current_module_statement();
  reset_current_module_entity();
  reset_ordering_to_statement();
  return true;
}

References copy_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, gen_omp_parallel(), gen_openmp(), insert_statement(), module_name(), module_name_to_entity(), module_reorder(), omp_parallel, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), return_st, set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), and statement_undefined_p.

Here is the call graph for this function:

Variable Documentation

omp_parallel

bool omp_parallel = false

static

Definition at line 48 of file openmp_generation.c.

Referenced by gen_synchronization(), and openmp_task_generation().