gpu.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
string	build_outline_name (const char *, const char *)
	Warning! Do not modify this file that is automatically generated! More...
bool	gpu_ify (const string)
	Transform all the parallel loop nests of a module into smaller independent functions suitable for GPU-style accelerators. More...
void	xml_print_entity_full (entity)
	xml_output.c More...
void	gather_grid_dim (statement, void *)
bool	gpu_xml_dump (string)
	PIPSMAKE INTERFACE. More...
bool	gpu_loop_nest_annotate_on_statement (statement)
	loop_nest_annotate.c More...
bool	gpu_loop_nest_annotate (const char *)
bool	gpu_parallelize_annotated_loop_nest (const string)
	Parallelize the launcher based on loop nest annotate sentinels. More...
bool	clear_annotated_loop_nest (statement)
	Callback for gen_recurse Remove annotation on a loop nest. More...
bool	gpu_clear_annotations_on_loop_nest (const string)
	Remove all annotations on a loop nest. More...
bool	one_thread_parallelize (string)
	one_thread_kernel.c More...
void	do_gpu_qualify_pointers (entity, statement code, callees, bool)
	gpu_qualify_pointers.c More...
bool	gpu_qualify_pointers (const string)

Function Documentation

build_outline_name()

string build_outline_name	(	const char *	base_prefix,
		const char *	mod_name
	)

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

Modify src/Libs/gpu/gpu-local.h instead, to add your own modifications. header file built by cproto gpu-local.h Nothing yet... cproto-generated files gpu-ify.c

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

Parameters

base_prefix	ase_prefix
mod_name	od_name

Definition at line 78 of file gpu-ify.c.

                                                            {
  bool name_suffix_p = get_bool_property("GPU_OUTLINE_SUFFIX_WITH_OWNER_NAME");
 
  char *prefix;
  if(name_suffix_p) {
    // strdup because concatenate is used during build_new_top_level_module_name
    prefix = strdup(concatenate(base_prefix,"_",mod_name,NULL));
  } else {
    prefix = strdup(base_prefix);
  }
 
  string outline_name = build_new_top_level_module_name(prefix,true);
 
  free(prefix);
 
  return outline_name;
}

References build_new_top_level_module_name(), concatenate(), free(), get_bool_property(), prefix, and strdup().

Referenced by get_next_task_name(), and gpu_ify_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_annotated_loop_nest()

bool clear_annotated_loop_nest

(

statement

s

)

Callback for gen_recurse Remove annotation on a loop nest.

Definition at line 465 of file loop_nest_annotate.c.

                                            {
  string comment = statement_comments(s);
  if(comment  && !empty_comments_p(comment)
      && (NULL != strstr(comment, "Loop nest P4A end")|| NULL != strstr(comment, "Loop nest P4A begin"))) {
    // clear the comment
    // We may instead filter out only the annotation inside the comment
    statement_comments(s) = string_undefined;
  }
  return true;
}

References comment(), empty_comments_p(), statement_comments, and string_undefined.

Referenced by gpu_clear_annotations_on_loop_nest().

Here is the call graph for this function:

Here is the caller graph for this function:

do_gpu_qualify_pointers()

void do_gpu_qualify_pointers	(	entity	module,
		statement	code,
		callees	funcs,
		bool	do_casts
	)

gpu_qualify_pointers.c

Parameters

module	odule
funcs	uncs
do_casts	o_casts

Definition at line 378 of file gpu_qualify_pointers.c.

{
  pips_debug(2, "qualifying pointers in module %s\n", entity_name(module));
 
  // check for module parameters, mark them if needed
  // note: there are declarations in the code and in the function signature
  // should it be set on both?
  pips_assert(entity_function_p(module), "module must be a function");
  value val = entity_initial(module);
  pips_assert(value_code_p(val), "function must have code");
 
  // set formal parameters as private or global, in doubt set as global
  list params = functional_parameters(type_functional(entity_type(module)));
  FOREACH(entity, var, code_declarations(value_code(val)))
  {
    if (formal_parameter_p(var))
    {
      if (entity_pointer_p(var) || entity_array_p(var))
      {
        int number = formal_offset(storage_formal(entity_storage(var)));
        type tn = parameter_type(PARAMETER(gen_nth(number-1, params)));
        pips_assert(type_variable_p(tn), "formal parameter is a variable");
        variable fp = type_variable(tn);
 
        if (variable_is_glopriv(fp, true))
          set_global(var);
        else if (variable_is_glopriv(fp, false))
          set_as_private(var);
        else  // in doubt, assume it is a global pointer
        {
          pips_user_warning("no clue, set formal parameter %s as global\n",
                            entity_name(var));
          set_variable_qualifier(fp, true);
          set_global(var);
        }
      }
    }
    else if (entity_array_p(var))
      // just a private array declaration
      set_as_private(var);
  }
 
  // pass through the code
  glopriv_context_t * glc = new_glopriv();
  glc->do_casts = do_casts;
  bool try_again = true;
  int iteration = 0;
 
  while (try_again)
  {
    iteration++;
    pips_debug(3, "propagating privates & globals iteration %d\n", iteration);
 
    // update global/private information
    glc->changed = false;
    collect_glopriv_data(module, code, glc);
 
    // if something is needed and it is not converging?
    if (iteration > 1 && !glc->changed)
      // this may happen if some pointers are not used,
      // or point to unqualified scalars
      break;
 
    // if changed, more expr may be qualified even if no entity is concerned
    // this iteration is needed for ensuring that calls are well qualified.
    try_again = glc->changed;
 
    // qualify pointers if possible
    FOREACH(entity, var, code_declarations(value_code(val)))
    {
      if (entity_variable_p(var))
      {
        pips_debug(8, "considering variable %s (global=%d, private=%d)\n",
                   entity_name(var), is_global(var), is_private(var));
        if (!formal_parameter_p(var) &&
            (entity_pointer_p(var) || entity_array_p(var)) &&
            !is_private(var) && !is_global(var))
        {
          bool
            var_is_global = set_belong_p(glc->globals, var),
            var_is_private = set_belong_p(glc->privates, var);
 
          // no "else", so as to trigger user errors if need be
          if (var_is_global)
            set_global(var);
          if (var_is_private)
            set_as_private(var);
          if (!var_is_global && !var_is_private) // in doubt? set_as_private(var);
          {
            pips_debug(5, "in doubt about %s, retrying...\n", entity_name(var));
            try_again = true;
          }
        }
      }
    }
  }
 
  // unmarked remaining pointers are expected to be private only
  // see x/z w/v in "validation/Gpu/glopriv04.c"
  FOREACH(entity, var, code_declarations(value_code(val)))
  {
    if (entity_variable_p(var) && !formal_parameter_p(var) &&
        (entity_pointer_p(var) || entity_array_p(var)) &&
        !is_private(var) && !is_global(var))
      set_as_private(var);
  }
 
  // now mark/check callee parameters
  FOREACH(string, f, callees_callees(funcs))
  {
    pips_debug(3, "updating call to %s\n", f);
    entity callee = module_name_to_entity(f);
    list params = functional_parameters(type_functional(entity_type(callee)));
 
    if (hash_defined_p(glc->call_sites, callee))
    {
      FOREACH(call, c, (list) hash_get(glc->call_sites, callee))
      {
        pips_assert(call_function(c) == callee, "good function called");
        pips_assert(gen_length(params) == gen_length(call_arguments(c)),
                    "matching #arguments & #parameters");
        list lp = params;
        int nparam = 0;
        FOREACH(expression, e, call_arguments(c))
        {
          parameter p = PARAMETER(CAR(lp));
          dummy d = parameter_dummy(p);
          const string sp = dummy_unknown_p(d)?
            "?": (const string) entity_local_name(dummy_identifier(d));
          type te = parameter_type(p);
          lp = CDR(lp);
          nparam += 1;
 
          if (!pointer_type_p(te) && !array_type_p(te))
          {
            pips_debug(5, "skipping non pointer parameter %s:%d (%s)\n",
                       entity_name(callee), nparam, sp);
            continue;
          }
 
          pips_assert(type_variable_p(te), "type is a variable");
          variable var = type_variable(te);
          bool global_expr = set_belong_p(glc->globals, e),
            private_expr = set_belong_p(glc->privates, e),
            var_is_global = variable_is_glopriv(var, true),
            var_is_private = variable_is_glopriv(var, false);
 
          if (global_expr && private_expr)
            // is it possible, or would it be an internal error?
            pips_user_error("formal parameter \"%s\" (#%d of \"%s\") is both "
                            "private & global\n",
                            sp, nparam, entity_name(callee));
          if (global_expr && var_is_private)
            pips_user_error("formal parameter \"%s\" (#%d of \"%s\") is "
                            "already private, cannot switch it to global\n",
                            sp, nparam, entity_name(callee));
          if (private_expr && var_is_global)
            pips_user_error("formal parameter \"%s\" (#%d of \"%s\") is "
                            "already global, cannot switch it to private\n",
                            sp, nparam, entity_name(callee));
 
          // no else so as to possibly trigger some errors...
          if (global_expr)
            set_variable_qualifier(var, true);
          if (private_expr)
            set_variable_qualifier(var, false);
          if (!global_expr && !private_expr) // in doubt, set as private...
          {
            pips_debug(5, "setting %s:%d (%s) as private by default\n",
                       entity_name(callee), nparam, sp);
            set_variable_qualifier(var, false);
          }
        }
      }
    }
    // else the callee is not called? unlikely:-)
  }
 
  // cleanup
  free_glopriv(&glc);
}

References array_type_p(), call_arguments, call_function, glopriv_context_t::call_sites, callee, callees_callees, CAR, CDR, glopriv_context_t::changed, code_declarations, collect_glopriv_data(), glopriv_context_t::do_casts, dummy_identifier, dummy_unknown_p, entity_array_p(), entity_function_p(), entity_initial, entity_local_name(), entity_name, entity_pointer_p(), entity_storage, entity_type, entity_variable_p, f(), FOREACH, formal_offset, formal_parameter_p(), free_glopriv(), functional_parameters, gen_length(), gen_nth(), glopriv_context_t::globals, hash_defined_p(), hash_get(), is_global(), is_private(), module, module_name_to_entity(), new_glopriv(), PARAMETER, parameter_dummy, parameter_type, params, pips_assert, pips_debug, pips_user_error, pips_user_warning, pointer_type_p(), glopriv_context_t::privates, set_as_private(), set_belong_p(), set_global(), set_variable_qualifier(), storage_formal, type_functional, type_variable, type_variable_p, value_code, value_code_p, and variable_is_glopriv().

Referenced by gpu_qualify_pointers().

Here is the call graph for this function:

Here is the caller graph for this function:

gather_grid_dim()

void gather_grid_dim	(	statement	s,
		void *	ctx
	)

Parameters

ctx

tx

Definition at line 165 of file xml_output.c.

                                             {
  // ctx is a pointer to a list of variable
  list *dims = (list *)ctx;
 
  string comment = statement_comments(s);
  pips_debug(3,"Statement %p, Compare comment '%s'\n",s,comment);
  if(!string_undefined_p(comment)) {
    size_t sentinel_len = strlen("// To be assigned to a call to P4A_vp_X: ");
    string sentinel;
    while((sentinel=strstr(comment,"// To be assigned to a call to P4A_vp_"))!=NULL) {
      string varname_ptr = sentinel+sentinel_len;
      string varname_end = strchr(varname_ptr,'\n');
      int varname_len = varname_end-varname_ptr;
      string varname = strndup(varname_ptr,varname_len); // to be freed
      pips_debug(2,"Catch dimension %s\n",varname);
      *dims = CONS(string,varname,*dims);
      comment = varname_end;
    }
  }
}

References comment(), CONS, pips_debug, statement_comments, string_undefined_p, and strndup().

Referenced by gpu_xml_dump().

Here is the call graph for this function:

Here is the caller graph for this function:

gpu_clear_annotations_on_loop_nest()

bool gpu_clear_annotations_on_loop_nest

(

const

string

)

Remove all annotations on a loop nest.

Parameters

string

od_name

Definition at line 477 of file loop_nest_annotate.c.

                                                               {
  // Use this module name and this environment variable to set
  statement module_statement = PIPS_PHASE_PRELUDE(mod_name,
      "GPU_IFY_DEBUG_LEVEL");
 
  // Parallelize loops
  gen_recurse(module_statement,
      statement_domain, clear_annotated_loop_nest, gen_null);
 
  // Put back the new statement module
  PIPS_PHASE_POSTLUDE(module_statement)
  ;
  // The macro above does a "return TRUE" indeed.
}

References clear_annotated_loop_nest(), gen_null(), gen_recurse, module_statement, PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, and statement_domain.

Here is the call graph for this function:

gpu_ify()

bool gpu_ify

(

const string

mod_name

)

Transform all the parallel loop nests of a module into smaller independent functions suitable for GPU-style accelerators.

What can be done is more detailed in gpu_ify_statement(). The various functions are generated or not according to different properties.

Parameters

module_name

is the name of the module to work on.

Returns

true since it should succeed...

Outline the previous marked loop nests. First put the statements to outline in the good order:

Clean module name from prefix

Parameters

mod_name

od_name

Definition at line 347 of file gpu-ify.c.

                                    {
  // Use this module name and this environment variable to set
  statement module_statement = PIPS_PHASE_PRELUDE(mod_name,
                                                  "GPU_IFY_DEBUG_LEVEL");
 
  // Get the effects and use them:
  set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS,mod_name,true));
 
  // Initialize the loop nest set to outline to the empty set yet:
  loop_nests_to_outline = NIL;
 
  // Mark interesting loops:
  gen_recurse(module_statement,
              statement_domain, mark_loop_to_outline, gen_null);
 
  /* Outline the previous marked loop nests.
     First put the statements to outline in the good order: */
  loop_nests_to_outline = gen_nreverse(loop_nests_to_outline);
 
  /* Clean module name from prefix */
  const char* clean_mod_name=get_clean_mod_name(global_name_to_user_name(entity_name(get_current_module_entity())));
 
  FOREACH(STATEMENT, s, loop_nests_to_outline) {
    // We could have stored the depth, but it complexifies the code...
    gpu_ify_statement(s, depth_of_parallel_perfect_loop_nest(s),clean_mod_name);
  }
 
  gen_free_list(loop_nests_to_outline);
 
  // No longer use effects:
  reset_cumulated_rw_effects();
 
  // We may have outline some code, so recompute the callees:
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, mod_name,
                         compute_callees(get_current_module_statement()));
 
  // Put back the new statement module
  PIPS_PHASE_POSTLUDE(module_statement);
  // The macro above does a "return TRUE" indeed.
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, depth_of_parallel_perfect_loop_nest(), entity_name, FOREACH, gen_free_list(), gen_nreverse(), gen_null(), gen_recurse, get_clean_mod_name(), get_current_module_entity(), get_current_module_statement(), global_name_to_user_name(), gpu_ify_statement(), loop_nests_to_outline, mark_loop_to_outline(), module_statement, NIL, PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, reset_cumulated_rw_effects(), set_cumulated_rw_effects(), STATEMENT, and statement_domain.

Here is the call graph for this function:

gpu_loop_nest_annotate()

bool gpu_loop_nest_annotate

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 406 of file loop_nest_annotate.c.

                                                     {
  // Use this module name and this environment variable to set
  statement module_statement =
      PIPS_PHASE_PRELUDE(module_name, "P4A_LOOP_NEST_ANOTATE_DEBUG_LEVEL");
 
  gpu_loop_nest_annotate_on_statement(module_statement);
 
  // Put back the new statement module
  PIPS_PHASE_POSTLUDE(module_statement)
  ;
  // The macro above does a "return TRUE" indeed.
}

References gpu_loop_nest_annotate_on_statement(), module_name(), module_statement, PIPS_PHASE_POSTLUDE, and PIPS_PHASE_PRELUDE.

Here is the call graph for this function:

gpu_loop_nest_annotate_on_statement()

bool gpu_loop_nest_annotate_on_statement

(

statement

s

)

loop_nest_annotate.c

loop_nest_annotate.c

for(i=0; i<=100; i++) for(j=0; j<=200; j++) foo();

==>

// Loop nest P4A begin,2D(200, 100) for(i=0; i<=100; i++) for(j=0; j<=200; j++) // Loop nest P4A end if (i<=100&&j<=200) foo();

for loops must have been transformed into loops.

Parameters

mod_name

name of the module

Returns

true

Initialize context

Annotate the loop nests of the module.

Clean up things: (hasn't it been done previously in loop_annotate?)

Definition at line 383 of file loop_nest_annotate.c.

                                                      {
  /* Initialize context */
  gpu_lna_context c;
  c.l_enclosing_loops = NIL;
  c.l_number_iter_exp = NIL;
  c.max_loop_nest_depth = -1;
  c.loop_nest_depth = 0;
  c.inner_reached = false;
  c.gpu_loop_nest_annotate_parallel_p
      = get_bool_property("GPU_LOOP_NEST_ANNOTATE_PARALLEL");
  c.fail_p = false;
  c.inner_loop = loop_undefined;
  c.guard_expression = expression_undefined;
 
  /* Annotate the loop nests of the module. */
  gen_context_recurse(s, &c, loop_domain, loop_push, loop_annotate);
 
  /* Clean up things: (hasn't it been done previously in loop_annotate?) */
  gen_free_list(c.l_number_iter_exp);
 
  return true;
}

References expression_undefined, gpu_lna_context::fail_p, gen_context_recurse, gen_free_list(), get_bool_property(), gpu_lna_context::gpu_loop_nest_annotate_parallel_p, gpu_lna_context::guard_expression, gpu_lna_context::inner_loop, gpu_lna_context::inner_reached, gpu_lna_context::l_enclosing_loops, gpu_lna_context::l_number_iter_exp, loop_annotate(), loop_domain, gpu_lna_context::loop_nest_depth, loop_push(), loop_undefined, gpu_lna_context::max_loop_nest_depth, and NIL.

Referenced by gpu_ify_statement(), and gpu_loop_nest_annotate().

Here is the call graph for this function:

Here is the caller graph for this function:

gpu_parallelize_annotated_loop_nest()

bool gpu_parallelize_annotated_loop_nest

(

const

string

)

Parallelize the launcher based on loop nest annotate sentinels.

Parameters

string

od_name

Definition at line 445 of file loop_nest_annotate.c.

                                                                {
  // Use this module name and this environment variable to set
  statement module_statement = PIPS_PHASE_PRELUDE(mod_name,
      "GPU_IFY_DEBUG_LEVEL");
 
  // Parallelize loops
  gen_recurse(module_statement,
      statement_domain, parallelize_annotated_loop_nest, gen_null);
 
  // Put back the new statement module
  PIPS_PHASE_POSTLUDE(module_statement)
  ;
  // The macro above does a "return TRUE" indeed.
}

References gen_null(), gen_recurse, module_statement, parallelize_annotated_loop_nest(), PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, and statement_domain.

Here is the call graph for this function:

gpu_qualify_pointers()

bool gpu_qualify_pointers

(

const

string

)

Parameters

string

odule_name

Definition at line 575 of file gpu_qualify_pointers.c.

{
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement((statement)
    db_get_memory_resource(DBR_CODE, module_name, true));
  callees funcs = (callees)
    db_get_memory_resource(DBR_CALLEES, module_name, true);
 
  debug_on("GPU_QUALIFY_POINTERS_DEBUG_LEVEL");
  pips_debug(1, "running on %s", module_name);
 
  do_gpu_qualify_pointers(get_current_module_entity(),
                          get_current_module_statement(),
                          funcs,
                          get_bool_property("GPU_QUALIFY_POINTERS_DO_CASTS"));
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,
                         get_current_module_statement());
 
  debug_off();
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, do_gpu_qualify_pointers(), get_bool_property(), get_current_module_entity(), get_current_module_statement(), module_name(), module_name_to_entity(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), and set_current_module_statement().

Here is the call graph for this function:

gpu_xml_dump()

bool gpu_xml_dump

(

string

mod_name

)

PIPSMAKE INTERFACE.

Set the current module entity required to have many things working in PIPS:

First find grid dimension by looking for magic comments

of const strings

Print current module

Parameters

mod_name

od_name

Definition at line 187 of file xml_output.c.

                                   {
 
  statement module_statement = (statement) db_get_memory_resource(DBR_CODE,
                                                                  mod_name,
                                                                  true);
 
  set_current_module_statement(module_statement);
 
  /* Set the current module entity required to have many things
   working in PIPS: */
  set_current_module_entity(module_name_to_entity(mod_name));
 
  debug_on("GPU_XML_DUMP_DEBUG_LEVEL");
  pips_assert("Statement should be OK at entry...",
              statement_consistent_p(module_statement));
 
  // Prepare the output file
  string xml_file_name = db_build_file_resource_name("RI",
                                                     mod_name,
                                                     ".out.xml");
  string output_file = strdup(concatenate(db_get_current_workspace_directory(),
                                          "/",
                                          xml_file_name,
                                          NULL));
  pips_debug(2, "Output in %s\n", output_file);
  FILE *fp = safe_fopen(output_file, "w");
  xml_set_output(fp);
 
  /* First find grid dimension by looking for magic comments */
  list /* of const strings */ dims = NIL;
  gen_context_recurse(module_statement, &dims,
     statement_domain, gen_true2, gather_grid_dim);
 
  /* Print current module */
  entity module = get_current_module_entity();
  type module_type = entity_type(module);
  pips_assert("Functional module", type_functional_p(module_type));
 
  // Remove wrapper prefix FIXME: bad hack...
  string original_name = mod_name + strlen("p4a_wrapper_");
 
  // Print Task
  xml_print("<Task name=\"%s\" kernel=\"%s\" nbParallelLoops=\"%zu\">" NL,
            original_name, mod_name, gen_length(dims));
 
  // Params
  int nparams = gen_length(functional_parameters(type_functional(module_type)));
  for(int i = 1; i <= nparams; i++) {
    entity param = find_ith_parameter(module, i);
    bool is_a_dim = false;
    FOREACH(string, dim, dims) {
      if(same_string_p(entity_user_name(param),dim)) {
        is_a_dim=true;
        break;
      }
    }
    xml_print_parameter(param, is_a_dim );
  }
 
  //xml_print_statement(module_statement);
  xml_print("</Task>" NL);
 
  // Reset output file
  xml_set_output(0);
  safe_fclose(fp, output_file);
 
  DB_PUT_FILE_RESOURCE( DBR_GPU_XML_FILE, strdup( mod_name ), xml_file_name );
 
  debug_off();
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
}

References concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, entity_type, entity_user_name(), find_ith_parameter(), FOREACH, functional_parameters, gather_grid_dim(), gen_context_recurse, gen_length(), gen_true2(), get_current_module_entity(), module, module_name_to_entity(), module_statement, NIL, NL, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), safe_fclose(), safe_fopen(), same_string_p, set_current_module_entity(), set_current_module_statement(), statement_consistent_p(), statement_domain, strdup(), type_functional, type_functional_p, xml_print, xml_print_parameter(), and xml_set_output().

Here is the call graph for this function:

one_thread_parallelize()

bool one_thread_parallelize

(

string

mod_name

)

one_thread_kernel.c

Set the current module entity required to have many things working in PIPS:

Parameters

mod_name

od_name

Definition at line 77 of file one_thread_kernel.c.

                                             {
  statement module_statement = (statement) db_get_memory_resource(DBR_CODE,
                                                                  mod_name,
                                                                  true);
 
  set_current_module_statement(module_statement);
 
  /* Set the current module entity required to have many things
   working in PIPS: */
  set_current_module_entity(module_name_to_entity(mod_name));
 
  debug_on("ONE_THREAD_PARALLELIZE_DEBUG_LEVEL");
  pips_assert("Statement should be OK at entry...",
              statement_consistent_p(module_statement));
 
  module_statement = enclose_in_a_parallel_loop(module_statement);
  module_reorder(module_statement);
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, (char*) module_statement);
 
  debug_off();
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, enclose_in_a_parallel_loop(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_consistent_p().

Here is the call graph for this function:

xml_print_entity_full()

void xml_print_entity_full

(

entity

e

)

xml_output.c

Definition at line 132 of file xml_output.c.

                                     {
  xml_output(entity_name( e ));
  xml_print_type(entity_type( e ));
  //xml_print_storage(entity_storage( e ));
  //xml_print_value(entity_initial( e ));
}

References entity_name, entity_type, xml_output(), and xml_print_type().

Here is the call graph for this function: