compile.c File Reference

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

Include dependency graph for compile.c:

Go to the source code of this file.

Macros
#define	STEP_GENERATED_SUFFIX_F   ".step_generated.f"
	Copyright 2007-2012 Alain Muller, Frederique Silber-Chaussumier. More...
#define	STEP_GENERATED_SUFFIX_C   ".step_generated.c"

Functions
statement	compile_mpi (statement stmt, string new_module_name, step_directive drt, int transformation)
statement	compile_omp (statement stmt, step_directive d)
	compile.c More...
void	add_omp_guard (statement *block)
static statement	remove_STEP_pragma (statement stmt)
static void	get_module_name_directive_suffix (step_directive drt, string *directive_txt)
static int	get_directive_transformation_type (step_directive drt)
static int	get_directive_transformation (step_directive drt, string *transformation_txt)
static entity	create_new_module_entity (list *last_module_name, string directive_txt, string transformation_txt)
static bool	compile_filter (statement stmt, list *last_module_name)
static void	compile_rewrite (statement stmt, list *last_module_name)
void	step_compile_analysed_module (const char *module_name, string finit_name)
void	step_compile_generated_module (const char *module_name, string finit_name)
	generated source: no analyse and no compilation necessary. More...
bool	step_compile (const char *module_name)

Macro Definition Documentation

STEP_GENERATED_SUFFIX_C

#define STEP_GENERATED_SUFFIX_C   ".step_generated.c"

Definition at line 21 of file compile.c.

STEP_GENERATED_SUFFIX_F

#define STEP_GENERATED_SUFFIX_F   ".step_generated.f"

Copyright 2007-2012 Alain Muller, Frederique Silber-Chaussumier.

This file is part of STEP.

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

Definition at line 20 of file compile.c.

Function Documentation

add_omp_guard()

void add_omp_guard

(

statement *

block

)

Parameters

block

lock

Definition at line 62 of file compile.c.

{
  pips_assert("block", block && !statement_undefined_p(*block) && statement_block_p(*block));
  pips_debug(1, "begin\n");
 
  if (!empty_statement_or_continue_p(*block))
    {
      statement barrier_stmt = make_empty_block_statement();
      step_directive barrier_guard = make_step_directive(STEP_BARRIER, statement_undefined, NIL);
      step_directive master_guard = make_step_directive(STEP_MASTER, statement_undefined, NIL);
      compile_omp(barrier_stmt, barrier_guard);
      compile_omp(*block, master_guard);
      free_step_directive(barrier_guard);
      free_step_directive(master_guard);
 
      *block = make_block_statement(CONS(STATEMENT, *block, CONS(STATEMENT, barrier_stmt, NIL)));
    }
 
  pips_debug(1, "end\n");
}

References compile_omp(), CONS, empty_statement_or_continue_p(), free_step_directive(), make_block_statement(), make_empty_block_statement(), make_step_directive(), NIL, pips_assert, pips_debug, STATEMENT, statement_block_p, statement_undefined, statement_undefined_p, STEP_BARRIER, and STEP_MASTER.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_filter()

static bool compile_filter ( statement  stmt, list *  last_module_name  )

static

Definition at line 215 of file compile.c.

{
  string directive_txt = NULL, transformation_txt = NULL;
  step_directive drt;
  int transformation_type;
 
  if(!step_directives_bound_p(stmt))
    return true;
 
  pips_debug(1, "begin\n");
 
  drt = step_directives_load(stmt);
  get_module_name_directive_suffix(drt, &directive_txt);
  transformation_type = get_directive_transformation(drt, &transformation_txt);
 
  if (transformation_type == STEP_TRANSFORMATION_MPI || transformation_type == STEP_TRANSFORMATION_HYBRID)
    {
      entity new_module = create_new_module_entity(last_module_name, directive_txt, transformation_txt);
      pips_debug(1, "New entity module created : %s\n", entity_name(new_module));
    }
 
 
  free(directive_txt);
  free(transformation_txt);
 
  pips_debug(1, "end\n");
  return true;
}

References create_new_module_entity(), directive_txt, entity_name, free(), get_directive_transformation(), get_module_name_directive_suffix(), pips_debug, step_directives_bound_p(), step_directives_load(), STEP_TRANSFORMATION_HYBRID, and STEP_TRANSFORMATION_MPI.

Referenced by step_compile_analysed_module().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_mpi()

statement compile_mpi	(	statement	stmt,
		string	new_module_name,
		step_directive	drt,
		int	transformation
	)

Definition at line 517 of file compile_mpi.c.

{
  pips_debug(1, "begin current module %p : %s\n", get_current_module_entity(), get_current_module_name());
 
  list statements_to_outline = make_statement_list(directive_stmt);
  entity new_module = gen_find_tabulated(concatenate(TOP_LEVEL_MODULE_NAME, MODULE_SEP_STRING, new_module_name, NULL), entity_domain);
  pips_assert("new_module", !entity_undefined_p(new_module));
 
  // Init hash table
  hash_table entity_to_effective_parameter = outliner_init(new_module, statements_to_outline);
 
  // Find referenced entities in statements_to_outline
  statement new_body = make_empty_block_statement();
  list referenced_entities = outliner_scan(new_module, statements_to_outline, new_body);
 
  // Generate the body of the new module
  statement work_stmt = make_block_statement(gen_copy_seq(statements_to_outline));
  statement mpi_begin_stmt = make_empty_block_statement();
  statement mpi_end_stmt = make_empty_block_statement();
  compile_body(directive_stmt, new_module, drt, transformation, referenced_entities, new_body, mpi_begin_stmt, work_stmt, mpi_end_stmt);
 
  // Some entities may be added by region_to_statement. Ensure they will be passed as parameters
  update_referenced_entities(new_body, &referenced_entities);
 
  // Update hash table and build parameters
  list effective_parameters = NIL, formal_parameters = NIL;
  outliner_parameters(new_module, new_body, referenced_entities, entity_to_effective_parameter, &effective_parameters, &formal_parameters);
 
  // Patch parameters for side effects
  if(c_module_p(get_current_module_entity()))
    outliner_patch_parameters(statements_to_outline, referenced_entities, effective_parameters, formal_parameters, new_body, mpi_begin_stmt, mpi_end_stmt);
 
  step_RT_set_local_declarations(new_module, new_body);
 
  // Source file generation
  set_prettyprinter_head_hook(step_head_hook);
  outliner_file(new_module, formal_parameters, &new_body);
  reset_prettyprinter_head_hook();
 
  step_RT_clean_local();
 
  statement call_stmt = outliner_call(new_module, statements_to_outline, effective_parameters);
 
  pips_debug(1, "end\n");
  return call_stmt;
}

References c_module_p(), compile_body(), concatenate(), entity_domain, entity_undefined_p, gen_copy_seq(), gen_find_tabulated(), get_current_module_entity(), get_current_module_name(), make_block_statement(), make_empty_block_statement(), make_statement_list, MODULE_SEP_STRING, NIL, outliner_call(), outliner_file(), outliner_init(), outliner_parameters(), outliner_patch_parameters(), outliner_scan(), pips_assert, pips_debug, reset_prettyprinter_head_hook(), set_prettyprinter_head_hook(), step_head_hook(), step_RT_clean_local(), step_RT_set_local_declarations(), TOP_LEVEL_MODULE_NAME, and update_referenced_entities().

Referenced by compile_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_omp()

statement compile_omp	(	statement	stmt,
		step_directive	d
	)

compile.c

Parameters

stmt

tmt

Definition at line 32 of file compile.c.

{
  pips_debug(1, "begin\n");
 
  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);
 
  if(!string_undefined_p(begin_txt))
    {
      if(!is_block_construct)
        {
          if(ENDP(statement_block(stmt)))
            insert_statement(stmt, make_plain_continue_statement(), false);
          stmt = STATEMENT(CAR(statement_block(stmt)));
        }
      add_pragma_str_to_statement(stmt, begin_txt, false);
    }
 
  if(!string_undefined_p(end_txt))
    {
      insert_statement(stmt, make_plain_continue_statement(), false);
      stmt = last_statement(stmt);
      add_pragma_str_to_statement(stmt, end_txt, false);
    }
 
  pips_debug(1, "end\n");
  return stmt;
}

References add_pragma_str_to_statement(), CAR, ENDP, fortran_module_p(), get_current_module_entity(), insert_statement(), last_statement(), make_plain_continue_statement(), pips_debug, STATEMENT, statement_block(), step_directive_to_strings(), and string_undefined_p.

Referenced by add_omp_guard(), compile_body(), and compile_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_rewrite()

static void compile_rewrite ( statement  stmt, list *  last_module_name  )

static

Definition at line 245 of file compile.c.

{
 
  int transformation;
  string new_module_name;
  step_directive drt;
 
  pips_debug(1, "begin\n");
  
  if(!step_directives_bound_p(stmt))
    return;
  
  new_module_name = STRING(CAR(*last_module_name));
  pips_debug(1, "stack_name current name = %s\n", new_module_name);
 
  drt = step_directives_load(stmt);
  ifdebug(3)
    step_directive_print(drt);
  
  remove_STEP_pragma(stmt);
 
  transformation = get_directive_transformation_type(drt);
 
  switch( transformation )
    {
    case STEP_TRANSFORMATION_SEQ:
      break;
    case STEP_TRANSFORMATION_OMP:
      compile_omp(stmt, drt);
      break;
    case STEP_TRANSFORMATION_MPI:
    case STEP_TRANSFORMATION_HYBRID:
      compile_mpi(stmt, new_module_name, drt, transformation);
      POP(*last_module_name);
      break;
    default:
      assert(0);
    }
 
  pips_debug(1, "end\n");
}

References assert, CAR, compile_mpi(), compile_omp(), get_directive_transformation_type(), ifdebug, pips_debug, POP, remove_STEP_pragma(), step_directive_print(), step_directives_bound_p(), step_directives_load(), STEP_TRANSFORMATION_HYBRID, STEP_TRANSFORMATION_MPI, STEP_TRANSFORMATION_OMP, STEP_TRANSFORMATION_SEQ, and STRING.

Referenced by step_compile_analysed_module().

Here is the call graph for this function:

Here is the caller graph for this function:

create_new_module_entity()

static entity create_new_module_entity ( list *  last_module_name, string  directive_txt, string  transformation_txt  )

static

Definition at line 196 of file compile.c.

{
  string previous_name, new_module_name;
  string prefix;
  entity new_module;
 
  previous_name = STRING(CAR(*last_module_name));
 
  assert(asprintf(&prefix,"%s_%s_%s", previous_name, directive_txt, transformation_txt)>=0);
  new_module_name = build_new_top_level_module_name(prefix, true);
  new_module = make_empty_subroutine(new_module_name, copy_language(module_language(get_current_module_entity())));
 
  free(prefix);
 
  *last_module_name = CONS(STRING, new_module_name, *last_module_name);
  pips_debug(1, "new_module %p : %s\n", new_module, new_module_name);
  return new_module;
}

References asprintf, assert, build_new_top_level_module_name(), CAR, CONS, copy_language(), directive_txt, free(), get_current_module_entity(), make_empty_subroutine(), module_language, pips_debug, prefix, and STRING.

Referenced by compile_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

get_directive_transformation()

static int get_directive_transformation ( step_directive  drt, string *  transformation_txt  )

static

Definition at line 169 of file compile.c.

{
  int transformation = -1;
  pips_debug(1, "begin\n");
 
  transformation = get_directive_transformation_type(drt);
  
   switch (transformation)
    {
    case STEP_TRANSFORMATION_MPI:
      *transformation_txt = strdup("MPI");
      break;
    case STEP_TRANSFORMATION_HYBRID:
      *transformation_txt = strdup("HYBRID");
      break;
    case STEP_TRANSFORMATION_SEQ:
    case STEP_TRANSFORMATION_OMP:
      *transformation_txt = strdup("");
      break;
    default:
      assert(0);
    }
 
   pips_debug(1, "end transformation = %d\n", transformation);
   return transformation;
}

References assert, get_directive_transformation_type(), pips_debug, STEP_TRANSFORMATION_HYBRID, STEP_TRANSFORMATION_MPI, STEP_TRANSFORMATION_OMP, STEP_TRANSFORMATION_SEQ, and strdup().

Referenced by compile_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

get_directive_transformation_type()

static int get_directive_transformation_type ( step_directive  drt )

static

que se passe t-il si plusieurs clauses de transformation ?

Definition at line 151 of file compile.c.

{
  int transformation_type = -1;
  pips_debug(2, "begin\n");
 
  FOREACH(STEP_CLAUSE, c, step_directive_clauses(drt))
    {
      /* que se passe t-il si plusieurs clauses de transformation ?*/
 
      if(step_clause_transformation_p(c))
        transformation_type = step_clause_transformation(c);
    }
  
  pips_debug(2,"end transformation_type : %d\n", transformation_type);
  
  return transformation_type;
}

References FOREACH, pips_debug, STEP_CLAUSE, step_clause_transformation, step_clause_transformation_p, and step_directive_clauses.

Referenced by compile_rewrite(), and get_directive_transformation().

Here is the caller graph for this function:

get_module_name_directive_suffix()

static void get_module_name_directive_suffix ( step_directive  drt, string *  directive_txt  )

static

Definition at line 119 of file compile.c.

{
 
  pips_debug(1, "begin\n");
  bool is_fortran = fortran_module_p(get_current_module_entity());
 
  switch(step_directive_type(drt))
    {
    case STEP_PARALLEL:
      *directive_txt = strdup("PAR");
      break;
    case STEP_DO:
      *directive_txt = strdup(is_fortran?"DO":"FOR");
      break;
    case STEP_PARALLEL_DO:
      *directive_txt = strdup(is_fortran?"PARDO":"PARFOR");
      break;
    case STEP_MASTER:
      *directive_txt = strdup("MASTER");
      break;
    case STEP_SINGLE:
      *directive_txt = strdup("SINGLE");
      break;
    case STEP_BARRIER:
      *directive_txt = strdup("BARRIER");
      break;
    default: assert(0);
    }
 
  pips_debug(1, "end *directive_txt = %s\n", *directive_txt);
}

References assert, directive_txt, fortran_module_p(), get_current_module_entity(), pips_debug, STEP_BARRIER, step_directive_type, STEP_DO, STEP_MASTER, STEP_PARALLEL, STEP_PARALLEL_DO, STEP_SINGLE, and strdup().

Referenced by compile_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_STEP_pragma()

static statement remove_STEP_pragma ( statement  stmt )

static

Definition at line 87 of file compile.c.

{
  list ext_l = NIL;
 
  pips_debug(1, "begin\n");
 
  FOREACH(EXTENSION, ext, extensions_extension(statement_extensions(stmt)))
    {
      pragma p = extension_pragma(ext);
      if(pragma_string_p(p) && strncmp(pragma_string(p), STEP_SENTINELLE, strlen(STEP_SENTINELLE))==0)
        {
          pips_debug(2,"drop pragma : %s\n", pragma_string(p));
          free_extension(ext);
        }
      else
        ext_l = CONS(EXTENSION, ext, ext_l);
    }
  gen_free_list(extensions_extension(statement_extensions(stmt)));
  extensions_extension(statement_extensions(stmt)) = gen_nreverse(ext_l);
 
  pips_debug(1, "end\n");
  return stmt;
}

References CONS, EXTENSION, extension_pragma, extensions_extension, FOREACH, free_extension(), gen_free_list(), gen_nreverse(), NIL, pips_debug, pragma_string, pragma_string_p, statement_extensions, and STEP_SENTINELLE.

Referenced by compile_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

step_compile()

bool step_compile

(

const char *

module_name

)

analysed source : let's do the transformations

generated module: nothing to do but copy the generated source

Parameters

module_name

odule_name

Definition at line 393 of file compile.c.

{
  debug_on("STEP_COMPILE_DEBUG_LEVEL");
  pips_debug(1, "Begin considering module_name = %s\n", module_name);
 
  entity module = local_name_to_top_level_entity(module_name);
 
  bool is_fortran = fortran_module_p(module);
  string init_name, finit_name;
  
  init_name = db_build_file_resource_name(DBR_STEP_FILE, module_name, is_fortran?  STEP_GENERATED_SUFFIX_F :  STEP_GENERATED_SUFFIX_C);
  assert(asprintf(&finit_name,"%s/%s" , db_get_current_workspace_directory(), init_name)>=0);
 
  if(step_analysed_module_p(module_name))
    {
      /* analysed source : let's do the transformations */
      step_compile_analysed_module(module_name, finit_name);
    }
  else
    {
      /* generated module: nothing to do but copy the generated source */
      step_compile_generated_module(module_name, finit_name);
    }
 
  DB_PUT_FILE_RESOURCE(DBR_STEP_FILE, module_name, finit_name);
 
  pips_debug(1, "End\n");
  debug_off();
  return true;
}

References asprintf, assert, db_build_file_resource_name(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, fortran_module_p(), local_name_to_top_level_entity(), module, module_name(), pips_debug, step_analysed_module_p(), step_compile_analysed_module(), step_compile_generated_module(), STEP_GENERATED_SUFFIX_C, and STEP_GENERATED_SUFFIX_F.

Here is the call graph for this function:

step_compile_analysed_module()

void step_compile_analysed_module	(	const char *	module_name,
		string	finit_name
	)

Code transformation

File generation

Parameters

module_name	odule_name
finit_name	init_name

Definition at line 288 of file compile.c.

{
  pips_debug(1, "begin\n");
 
  entity module = local_name_to_top_level_entity(module_name);
  statement stmt = (statement)db_get_memory_resource(DBR_CODE, module_name, false);
 
  set_current_module_entity(module);
  set_current_module_statement(stmt);
 
  step_directives_init(0);
  load_step_comm();
 
  statement_effects rw_effects = (statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, false);
  statement_effects cummulated_rw_effects = (statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, false);
  set_rw_effects(rw_effects);
  set_cumulated_rw_effects(cummulated_rw_effects);
 
  /* Code transformation */
  list last_module_name = CONS(STRING, (string)module_name, NIL);
 
  gen_context_recurse(stmt, &last_module_name, statement_domain, compile_filter, compile_rewrite);
 
  if (entity_main_module_p(module))
    {
      string init_subroutine_name;
      init_subroutine_name = fortran_module_p(get_current_module_entity())?
        RT_STEP_init_fortran_order:
        RT_STEP_init_c_order;
      statement init_stmt = call_STEP_subroutine2(init_subroutine_name, NULL);
      statement finalize_stmt = call_STEP_subroutine2(RT_STEP_finalize, NULL);
 
      insert_statement(stmt, init_stmt, true);
      insert_statement(last_statement(stmt), finalize_stmt, true);
    }
 
  reset_cumulated_rw_effects();
  reset_rw_effects();
  free_statement_effects(cummulated_rw_effects);
  free_statement_effects(rw_effects);
  
  reset_step_comm();
  step_directives_reset();
  reset_current_module_statement();
  reset_current_module_entity();
  
  /* File generation */
  text code_txt = text_named_module(module, module, stmt);
  bool saved_b1 = get_bool_property("PRETTYPRINT_ALL_DECLARATIONS");
  bool saved_b2 = get_bool_property("PRETTYPRINT_STATEMENT_NUMBER");
  set_bool_property("PRETTYPRINT_ALL_DECLARATIONS", true);
  set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", false);
  
  FILE *f = safe_fopen(finit_name, "w");
  print_text(f, code_txt);
  safe_fclose(f, finit_name);
  
  set_bool_property("PRETTYPRINT_ALL_DECLARATIONS", saved_b1);
  set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", saved_b2);
  free_text(code_txt);
  free_statement(stmt);
  pips_debug(1, "end\n");
}

References call_STEP_subroutine2(), compile_filter(), compile_rewrite(), CONS, db_get_memory_resource(), entity_main_module_p(), f(), fortran_module_p(), free_statement(), free_statement_effects(), free_text(), gen_context_recurse, get_bool_property(), get_current_module_entity(), init_stmt, insert_statement(), last_statement(), load_step_comm(), local_name_to_top_level_entity(), module, module_name(), NIL, pips_debug, print_text(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_rw_effects(), reset_step_comm(), RT_STEP_finalize, RT_STEP_init_c_order, RT_STEP_init_fortran_order, safe_fclose(), safe_fopen(), set_bool_property(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_rw_effects(), statement_domain, step_directives_init(), step_directives_reset(), STRING, and text_named_module().

Referenced by step_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

step_compile_generated_module()

void step_compile_generated_module	(	const char *	module_name,
		string	finit_name
	)

generated source: no analyse and no compilation necessary.

Keep the source as it is.

Parameters

module_name	odule_name
finit_name	init_name

Definition at line 354 of file compile.c.

{
  pips_debug(1, "begin\n");
  
  string source_file, fsource_file;
  entity module = local_name_to_top_level_entity(module_name);
  bool is_fortran = fortran_module_p(module);
 
  source_file = db_get_memory_resource(is_fortran?DBR_INITIAL_FILE:DBR_C_SOURCE_FILE, module_name, true);
 
  assert(asprintf(&fsource_file,"%s/%s" , db_get_current_workspace_directory(), source_file)>=0);
  pips_debug(1, "Copie from: %s\n", fsource_file);
  safe_copy(fsource_file, finit_name);
  
  if(compilation_unit_p(module_name))
    {
      safe_system(concatenate("echo '#include \"step_api.h\"' >>",finit_name,  NULL));
      pips_debug(1, "\tAdd prototype for STEP generated modules\n");
      gen_array_t modules = db_get_module_list_initial_order();
      int n = gen_array_nitems(modules), i;
      FILE *out = safe_fopen(finit_name, "a");
      for (i=0; i<n; i++)
        {
          string name = gen_array_item(modules, i);
          if (same_string_p((const char*)module_name, (const char*)compilation_unit_of_module(name)) &&
              !same_string_p(module_name, name) &&
              !step_analysed_module_p(name))
            {
              statement stmt = make_plain_continue_statement();
              statement_declarations(stmt) = CONS(ENTITY, module_name_to_entity(name), NIL);
              fprint_statement(out, stmt);
              free_statement(stmt);
            }
        }
      safe_fclose(out, finit_name);
    }
  pips_debug(1, "end\n");
}

References asprintf, assert, compilation_unit_of_module(), compilation_unit_p(), concatenate(), CONS, db_get_current_workspace_directory(), db_get_memory_resource(), db_get_module_list_initial_order(), ENTITY, fortran_module_p(), fprint_statement(), free_statement(), gen_array_item(), gen_array_nitems(), local_name_to_top_level_entity(), make_plain_continue_statement(), module, module_name(), module_name_to_entity(), NIL, out, pips_debug, safe_copy(), safe_fclose(), safe_fopen(), safe_system(), same_string_p, statement_declarations, and step_analysed_module_p().

Referenced by step_compile().

Here is the call graph for this function:

Here is the caller graph for this function: