pipsmake.h File Reference

#include "makefile.h"

Include dependency graph for pipsmake.h:

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

Go to the source code of this file.

Typedefs
typedef bool(*	pipsmake_callback_handler_type) (void)
	Warning! Do not modify this file that is automatically generated! More...

Functions
void	pipsmake_error (const char *)
	symbols exported by lex / yacc More...
int	pipsmake_lex (void)
int	pipsmake_parse (void)
void	yyerror (const char *)
	work around cproto 4.7t issue More...
void	fprint_virtual_resources (FILE *, const char *, list)
void	fprint_makefile (FILE *, makefile)
makefile	parse_makefile (void)
rule	find_rule_by_phase (const char *)
	this function returns the rule that defines builder pname More...
void	add_rule (rule)
makefile	open_makefile (const char *)
void	save_makefile (const char *)
bool	close_makefile (const char *)
int	yywrap (void)
	symbols form lexer.l More...
int	init_lex (void)
void	yyerror_lex_part (const char *)
void	set_current_phase_context (const char *, const char *)
	cproto-generated files More...
void	reset_current_phase_context (void)
void	reset_make_cache (void)
void	init_make_cache (void)
bool	make_cache_p (void)
	Can the make cache be used? More...
void	reinit_make_cache_if_necessary (void)
bool	make_cache_hit_p (void *)
void	add_resource_to_make_cache (void *)
void	remove_resource_from_make_cache (void *)
void	print_make_cache (void)
	Debug function, to be tested... More...
bool	make_cache_consistent_p (void)
	Debug function: make sure that up-to-date resources do exist in the resource database. More...
void	reset_static_phase_variables (void)
	Static variables used by phases must be reset on error although pipsmake does not know which ones are used. More...
rule	find_rule_by_resource (const char *)
	This function returns the active rule to produce resource rname. More...
bool	rmake (const char *, const char *)
	recursive make resource. More...
int	delete_obsolete_resources (void)
void	delete_some_resources (void)
	this is quite ugly, but I wanted to put the enumeration down to pipsdbm. More...
bool	check_resource_up_to_date (const char *, const char *)
	To be used in a rule. More...
void	delete_named_resources (const char *)
	Delete from up_to_date_resources make cache all the resources with a given resource name. More...
void	delete_all_resources (void)
string	get_first_main_module (void)
	Should be able to handle Fortran applications, C applications and mixed Fortran/C applications. More...
void	do_resource_usage_check (const char *, rule)
	check the usage of resources More...
bool	safe_make (const char *, const char *)
bool	safe_apply (const char *, const char *)
bool	safe_concurrent_apply (const char *, gen_array_t)
bool	safe_set_property (const char *, const char *)
gen_array_t	get_callers (string)
	Get all the callers of the specified module. More...
gen_array_t	get_callees (string)
	Get all the callers of the specified module. More...
void	save_active_phases (void)
	activate.c More...
void	retrieve_active_phases (void)
bool	active_phase_p (const char *)
bool	saved_active_phase_p (const char *)
	Debugging function. More...
void	fprint_activated (FILE *)
string	active_phase_for_resource (string)
	return the phase which would be used to build a given resource. More...
const char *	activate_phase (const char *)
const char *	activate (const char *)
bool	activate_phases (void)
	Use property ACTIVE_PHASES to active the phases required by the user. More...
void	activate_language (language)
	Choose the right combination of activate and setproperty for a given language. More...
bool	rule_use_resource_produced (rule)
	Test if a rule uses a resource it produces. More...
string	build_pgm_makefile (const char *)
	openclose.c More...
string	make_open_workspace (const char *)
bool	make_close_workspace (bool)
	FI->GO: could be in top-level, no? More...
void	checkpoint_workspace (void)
	checkpoint the current workspace, i.e. More...
void	set_pipsmake_callback (pipsmake_callback_handler_type)
	callback.c More...
void	reset_pipsmake_callback (void)
bool	run_pipsmake_callback (void)
bool	unsplit (const string)
	unsplit.c More...
bool	unsplit_parsed (const string)
bool	array_dfg (string)
	stubs.c More...
bool	print_array_dfg (string)
bool	scheduling (string)
	================================================================= More...
bool	print_bdt (string)
	================================================================= More...
bool	prgm_mapping (string)
	========================================================================= More...
bool	print_plc (string)
bool	reindexing (string)
	====================================================================== More...
bool	print_parallelizedCMF_code (string)
	====================================================================== More...
bool	print_parallelizedCRAFT_code (string)
	====================================================================== More...
string	build_view_file (const char *)
	view.c More...
string	get_dont_build_view_file (const char *)
void	reset_pips_timeout (void)
	signal.c More...
void	set_pips_timeout (unsigned int)
	set pips timeout on delay setting to 0 removes the current timeout. More...
void	set_pips_timeout_from_env (void)
	set pips timeout using PIPS_TIMEOUT environment variable More...
void	initialize_signal_catcher (void)
void	pipsmake_restart (FILE *)
void	pipsmake_pop_buffer_state (void)
int	pipsmake_get_lineno (void)
FILE *	pipsmake_get_in (void)
FILE *	pipsmake_get_out (void)
int	pipsmake_get_leng (void)
char *	pipsmake_get_text (void)
void	pipsmake_set_lineno (int)
void	pipsmake_set_in (FILE *)
void	pipsmake_set_out (FILE *)
int	pipsmake_get_debug (void)
void	pipsmake_set_debug (int)
int	pipsmake_lex_destroy (void)
void *	pipsmake_alloc (yy_size_t)
void *	pipsmake_realloc (void *, yy_size_t)
void	pipsmake_free (void *)
int	pipsmake_wrap (void)

Variables
FILE *	pipsmake_in
int	pipsmake_char
	readmakefile.c More...
int	pipsmake_nerrs
int	pipsmake_leng
	lexer.c More...
FILE *	pipsmake_out
int	pipsmake_lineno
int	pipsmake__flex_debug
char *	pipsmake_text

Typedef Documentation

pipsmake_callback_handler_type

typedef bool(* pipsmake_callback_handler_type) (void)

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

Modify src/Libs/pipsmake/pipsmake-local.h instead, to add your own modifications. header file built by cproto pipsmake-local.h

Definition at line 33 of file pipsmake.h.

Function Documentation

activate()

const char* activate

(

const char *

phase

)

Parameters

phase

hase

Definition at line 214 of file activate.c.

{
  const char* r = activate_phase(phase);
  if(!r)
    pips_user_error("Phase activation error: check the phase names\n");
  return r;
}

References activate_phase(), and pips_user_error.

Referenced by activate_language(), make_pre_post_transformation(), options_select(), select_rule(), and update_options().

Here is the call graph for this function:

Here is the caller graph for this function:

activate_language()

void activate_language

(

language

l

)

Choose the right combination of activate and setproperty for a given language.

This is not really compatible with the litterate programming of pipsmake-rc.tex, where this information should be encoded.

Usual properties for Fortran

Usual properties for Fortran 90/95

Usual properties for C

The language is unknown

Definition at line 254 of file activate.c.

{
  if(language_fortran_p(l)) {
    /* Usual properties for Fortran */
    set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", true);
    set_bool_property("FOR_TO_WHILE_LOOP_IN_CONTROLIZER", false);
    set_bool_property("FOR_TO_DO_LOOP_IN_CONTROLIZER", false);
 
    if(!active_phase_p("PARSER"))
      activate("PARSER");
  } else if(language_fortran95_p(l)) {
    /* Usual properties for Fortran 90/95 */
    set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", false);
    set_bool_property("FOR_TO_WHILE_LOOP_IN_CONTROLIZER", false);
    set_bool_property("FOR_TO_DO_LOOP_IN_CONTROLIZER", false);
 
    // Temporary fix for autogenerated file
    if(!active_phase_p("PARSER"))
      activate("PARSER");
  } else if(language_c_p(l)) {
    /* Usual properties for C */
    set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", false);
    set_bool_property("FOR_TO_WHILE_LOOP_IN_CONTROLIZER", true);
    set_bool_property("FOR_TO_DO_LOOP_IN_CONTROLIZER", true);
 
    if(!active_phase_p("C_PARSER"))
      activate("C_PARSER");
    // No longer useful
    //if(!active_phase_p("C_SYMBOL_TABLE"))
    //  activate("C_SYMBOL_TABLE");
  }
  else {
    /* The language is unknown*/
    pips_user_warning("Unknown language initialization\n");
  }
}

References activate(), active_phase_p(), language_c_p, language_fortran95_p, language_fortran_p, pips_user_warning, and set_bool_property().

Referenced by add_a_file(), and create_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

activate_phase()

const char* activate_phase

(

const char *

phase

)

find rule that describes phase

Parameters

phase

hase

Definition at line 124 of file activate.c.

{
  makefile current_makefile = parse_makefile();
  bool rule_cyclic_p = true;
  const char * status = phase;
 
  debug_on("PIPSMAKE_DEBUG_LEVEL");
  pips_debug(1, "%s - requested\n", phase);
 
  pips_assert("a current workspace is defined",
              db_get_current_workspace_name());
 
  /* find rule that describes phase */
  rule r = find_rule_by_phase(phase);
 
  if (r == rule_undefined) {
    if (get_bool_property("PIPSMAKE_WARNINGS"))
      pips_user_warning("Rule `%s' undefined.\n"
                        "Check spelling and/or ACTIVE_PHASE property.\n",
                        phase);
    status = NULL;
  }
  else if (active_phase_p(phase)) {
    if (get_bool_property("PIPSMAKE_WARNINGS"))
      pips_user_warning ("Rule `%s' already active\n", phase);
  }
  else if (!gen_length(rule_produced(r))) {
    // if (get_bool_property("PIPSMAKE_WARNINGS"))
    pips_user_warning("Phase %s produces no resource\n", phase);
    status = NULL;
  }
  else {
    // GO: for many produced resources we loop over them
    // with the same 'old' code
    // find resource res that is produced by phase
    FOREACH(VIRTUAL_RESOURCE, res, rule_produced(r)) {
      bool require_produced_rule_p = false;
      string vrn = virtual_resource_name(res);
 
      FOREACH(VIRTUAL_RESOURCE, vr, rule_required(r)) {
        string vrn2 = virtual_resource_name(vr);
        owner vro = virtual_resource_owner(vr);
 
        // We do not check callers and callees
        // I dropped select also, just in case... FC
        if (!(owner_callers_p(vro) || owner_callees_p(vro) ||
              owner_select_p(vro)) && same_string_p(vrn, vrn2))
          require_produced_rule_p = true;
      }
 
      // If the current produced resource is not required by the new rule
      if (!require_produced_rule_p) {
        rule_cyclic_p = false;
        // find current active phase old_phase that produces res
        string old_phase = rule_phase(find_rule_by_resource(vrn));
 
        // replace old_phase by phase in active phase list
        if (old_phase != NULL) {
          pips_debug(5, "replacing %s by %s for %s\n", old_phase, phase, vrn);
          MAPL(pa, {
              string s = STRING(CAR(pa));
 
              if (strcmp(s, old_phase) == 0) {
                free(STRING(CAR(pa)));
                STRING(CAR(pa)) = strdup(phase);
              }
            }, makefile_active_phases(current_makefile));
        }
 
        // this generates many warnings when called from select...
        if (get_bool_property("ACTIVATE_DEL_DERIVED_RES"))
          delete_derived_resources (res);
        else
          if (db_get_current_workspace_name()) {
            // remove resources with the same name as res
            // to maintain consistency in the database
            db_unput_resources(vrn);
          }
      }
    }
 
    if (rule_cyclic_p == true) {
      pips_user_warning("Phase %s is cyclic\n", phase);
      status = NULL;
    }
  }
  debug_off();
  return status;
}

References active_phase_p(), CAR, db_get_current_workspace_name(), db_unput_resources(), debug_off, debug_on, delete_derived_resources(), find_rule_by_phase(), find_rule_by_resource(), FOREACH, free(), gen_length(), get_bool_property(), makefile_active_phases, MAPL, owner_callees_p, owner_callers_p, owner_select_p, parse_makefile(), pips_assert, pips_debug, pips_user_warning, rule_phase, rule_produced, rule_required, rule_undefined, same_string_p, strdup(), STRING, VIRTUAL_RESOURCE, virtual_resource_name, and virtual_resource_owner.

Referenced by activate(), and activate_phases().

Here is the call graph for this function:

Here is the caller graph for this function:

activate_phases()

bool activate_phases

(

void

)

Use property ACTIVE_PHASES to active the phases required by the user.

Definition at line 224 of file activate.c.

{
  string d = " ,\t\n";
  // strtok breaks its first argument string
  string ap = strdup(get_string_property("ACTIVE_PHASES"));
  string cap = strtok(ap, d);
  bool pips_special =
    !same_string_p("full", get_string_property("PIPS_VERSION"));
  bool result = true;
 
  while (cap!=NULL) {
    pips_debug(1, "Phase to activate: %s\n", cap);
    if (!active_phase_p(cap)) {
      const char* r =  activate_phase(cap);
      result = r!=NULL;
    }
    cap = strtok(NULL, d);
  }
  free(ap);
 
  // for a specialized pips, accept invalid phase names
  return pips_special? true: result;
}

References activate_phase(), active_phase_p(), free(), get_string_property(), pips_debug, same_string_p, and strdup().

Referenced by create_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

active_phase_for_resource()

string active_phase_for_resource

(

string

res

)

return the phase which would be used to build a given resource.

Parameters

res

es

Definition at line 119 of file activate.c.

{
  return rule_phase(find_rule_by_resource(res));
}

References find_rule_by_resource(), and rule_phase.

Here is the call graph for this function:

active_phase_p()

bool active_phase_p

(

const char *

phase

)

Parameters

phase

hase

Definition at line 80 of file activate.c.

{
  makefile current_makefile = parse_makefile();
  list apl = makefile_active_phases(current_makefile);
 
  FOREACH(STRING, s, apl)
    if (same_string_p(s, phase))
      return true; // new line for breakpoints
 
  return false;
}

References FOREACH, makefile_active_phases, parse_makefile(), same_string_p, STRING, and STUB_ERROR.

Referenced by activate_language(), activate_phase(), activate_phases(), make_pre_post_transformation(), points_to_unary_operation_to_transformer(), and ProcessEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

add_resource_to_make_cache()

void add_resource_to_make_cache

(

void *

res_id

)

FI: debugging messages cannot be factorized here because of sibling resources, unless an extra parameter is added...

Parameters

res_id

es_id

Definition at line 225 of file pipsmake.c.

{
  /* FI: debugging messages cannot be factorized here because of
     sibling resources, unless an extra parameter is added... */
  //string res_rn = real_resource_resource_name((real_resource) res);
  //string res_on = real_resource_owner_name((real_resource) res);
  //pips_debug(5, "resource %s(%s) added to up_to_date make cache\n",
  //         res_rn, res_on);
  set_add_element (up_to_date_resources,
                   up_to_date_resources,
                   res_id);
}

References set_add_element(), and up_to_date_resources.

Referenced by check_physical_resource_up_to_date(), and rmake().

Here is the call graph for this function:

Here is the caller graph for this function:

add_rule()

void add_rule

(

rule

r

)

Definition at line 1704 of file readmakefile.c.

{
  string pn = rule_phase(r);
  bool   active_phase = false;
 
  // Check resources produced by this rule
  FOREACH(VIRTUAL_RESOURCE, vr, rule_produced(r)) {
    string vrn = virtual_resource_name(vr);
    string phase;
 
    // We activated this rule to produce this resource only if
    // this resource is not already produced
    if ((phase = hash_get(activated, vrn)) == HASH_UNDEFINED_VALUE) {
            pips_debug(1, "Default function for %s is %s\n", vrn, pn);
 
            active_phase = true;
            hash_put(activated, vrn, pn);
 
            makefile_active_phases(pipsmakefile) =
        CONS(STRING, strdup(pn), makefile_active_phases(pipsmakefile));
    }
    else pips_debug(1, "Function %s not activated\n", pn);
  }
 
  // Check resources required for this rule if it is an active one
  if (active_phase) {
    FOREACH(VIRTUAL_RESOURCE, vr, rule_required(r)) {
            string vrn = virtual_resource_name(vr);
            owner vro = virtual_resource_owner(vr);
            string phase;
 
            // We must use a resource already defined
            if ( owner_callers_p(vro) || owner_callees_p(vro) ) {}
            else {
        phase = hash_get(activated, vrn);
        if (phase == HASH_UNDEFINED_VALUE)
        {
          if (get_bool_property("PIPSMAKE_WARNINGS"))
            pips_user_warning(
              "%s: phase %s requires an undefined resource %s\n",
              PIPSMAKE_RC, pn, vrn);
        }
        // If we use a resource, another function should have produced it
        else if (strcmp(phase, pn) == 0) {
          pips_internal_error(
            "%s: phase %s cannot be active for the %s resource\n",
            PIPSMAKE_RC, phase, vrn);
        }
        else
          pips_debug(1, "Required resource %s is checked OK for Function %s\n",
                     vrn, pn);
            }
    }
  }
 
  // FI: no check of rule name unicity; e.g. double declaration of sesamify
  rule or = find_rule_by_phase(rule_phase(r));
  if(rule_undefined_p(or))
    makefile_rules(pipsmakefile) = gen_nconc(makefile_rules(pipsmakefile),
                                             CONS(RULE, r, NIL));
  else
    pips_internal_error("Double declaration of phase \"%s\"\n"
                        "Check pipsmake-rc.tex or pipsmake.rc\n",
                        rule_phase(r));
}

array_dfg()

bool array_dfg

(

char *

mod_name

)

stubs.c

stubs.c

void array_dfg( (char*) module_name ) AL 93/06/29

It computes the array data flow graph using Feautrier's algorithm. This kind of graph detects the real dependances between arrays. It could be computed on a static control program. The original code is prepared by the static_controlize package. See its comments for more details.

summary or not ?

Initialize debugging functions

Initialization of the pass

set current_module_entity to ent ...

If the input program is not a static_control one, return

What will we compute ?

We need the dependance graph for a first source approximation. The graph is first reversed to have the possible source statement. Then we take only the WR dependances. At the end : duplicate nodes "a la Redon" for IF statement.

We reorder the statement number linked to each vertex in order to distinguich duplicated vertices

We compute the core of the pass

End of the program

Parameters

mod_name

odule

Definition at line 501 of file array_dfg.c.

{
  extern int            Gcount_re;
  extern int            Gcount_ie;
  graph                 dg = NULL, rev_dg = NULL, wr_dg = NULL; 
  graph                 dup_dg = NULL, ret_dfg = NULL;
  entity                ent = NULL;
  statement             mod_stat = NULL;
  static_control        stco = NULL;
  string                ss = NULL; /* summary or not ? */
  bool                  SUMMARY = false;
  
  /* Initialize debugging functions */
  debug_on("ARRAY_DFG_DEBUG_LEVEL");
  if (get_debug_level() > 0) 
    user_log("\n\n *** COMPUTE ARRAY DATA FLOW GRAPH for %s\n",mod_name);
 
 
  my_pip_count = 0;
  my_fai_count = 0;
 
  /* Initialization of the pass */
  Gcount_re = 0;
  Gcount_ie = 0;
  ent       = local_name_to_top_level_entity( mod_name );
  set_current_module_entity(ent); /* set current_module_entity to ent ... */
  
  mod_stat  = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
  Gstco_map = (statement_mapping) db_get_memory_resource(DBR_STATIC_CONTROL,
                                                         mod_name, true);
  
  /* If the input program is not a static_control one, return */
  stco   = (static_control) GET_STATEMENT_MAPPING(Gstco_map, mod_stat);
  if ( !static_control_yes( stco )) {
    pips_user_error("\n"
                    " CAN'T APPLY FEAUTRIER'S ALGORITHM:\n"
                    " This is not a static control program !");
  }
  Gstructural_parameters = static_control_params( stco );
  set_proper_rw_effects((statement_effects) 
                       db_get_memory_resource(DBR_PROPER_EFFECTS, mod_name, true));
 
  /* What will we compute ? */
  SUMMARY = ((ss = getenv("SUMMARY")) != NULL)? atoi(ss) : false;
  
  
  /* We need the dependance graph for a first source approximation.
   * The graph is first reversed to have the possible source statement.
   * Then we take only the WR dependances.
   * At the end : duplicate nodes "a la Redon" for IF statement.
   */
  dg      = (graph) db_get_memory_resource( DBR_DG, mod_name, true );
  rev_dg  = adg_reverse_graph( dg );
  wr_dg   = adg_only_call_WR_dependence( rev_dg );
  dup_dg  = adg_dup_disjunctive_nodes( wr_dg, Gstco_map );
  
  /* We reorder the statement number linked to each vertex
   * in order to distinguich duplicated vertices 
   */
  adg_reorder_statement_number( dup_dg );
  
  /* We compute the core of the pass */
  if (!SUMMARY) 
  { ret_dfg = adg_dataflowgraph( mod_stat, Gstco_map, dup_dg );}
  else ret_dfg = adg_dataflowgraph_with_extremities(mod_stat, Gstco_map, dup_dg);
  
  
  /* End of the program */
  if (get_debug_level() > 0) fprint_dfg(stderr, ret_dfg);
  if (get_debug_level() > 8) fprint_dfg(stderr, adg_pure_dfg(ret_dfg));
  
  DB_PUT_MEMORY_RESOURCE( DBR_ADFG, strdup(mod_name), ret_dfg);
  
  if (get_debug_level() > 0)  {
    printf("\n PIP CALLS : %d\n", my_pip_count);
    printf("\n FAI CALLS : %d\n", my_fai_count);
  }
 
  if (get_debug_level() > 0) user_log("\n\n *** ARRAY_DFG done\n");
  debug_off();
 
  reset_proper_rw_effects();
  reset_current_module_entity();
  reset_current_module_statement();
 
  return(true);
}

References adg_dataflowgraph(), adg_dataflowgraph_with_extremities(), adg_dup_disjunctive_nodes(), adg_only_call_WR_dependence(), adg_pure_dfg(), adg_reorder_statement_number(), adg_reverse_graph(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dg, fprint_dfg(), Gcount_ie, Gcount_re, get_debug_level(), GET_STATEMENT_MAPPING, Gstco_map, Gstructural_parameters, local_name_to_top_level_entity(), mod_stat, my_fai_count, my_pip_count, pips_user_error, printf(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), set_current_module_entity(), set_proper_rw_effects(), static_control_params, static_control_yes, strdup(), SUMMARY, and user_log().

Here is the call graph for this function:

build_pgm_makefile()

string build_pgm_makefile

(

const char *

)

openclose.c

build_view_file()

string build_view_file

(

const char *

print_type

)

view.c

Parameters

print_type

rint_type

Definition at line 97 of file view.c.

{
    return get_view_file(print_type, true);
}

References get_view_file(), and print_type().

Referenced by display(), display_a_resource(), gpips_display_graph_file_display(), gpips_display_plain_file(), wpips_display_graph_file_display(), wpips_display_plain_file(), and wpips_display_WP65_file().

Here is the call graph for this function:

Here is the caller graph for this function:

check_resource_up_to_date()

bool check_resource_up_to_date	(	const char *	rname,
		const char *	oname
	)

To be used in a rule.

use and update the up_to_dat list created by makeapply

Parameters

rname	name
oname	name

Definition at line 1468 of file pipsmake.c.

{
  return db_resource_p(rname, oname)?
    check_physical_resource_up_to_date(rname, oname): false;
}

References check_physical_resource_up_to_date(), and db_resource_p().

Referenced by check_physical_resource_up_to_date(), and rmake().

Here is the call graph for this function:

Here is the caller graph for this function:

checkpoint_workspace()

void checkpoint_workspace

(

void

)

checkpoint the current workspace, i.e.

save everything so that it is possible to reopen it in case of failure.

FC 25/06/2003 this seems to break pipsmake internal data... pips_debug(3, "\tdeleting obsolete resources...\n"); delete_obsolete_resources();

Definition at line 129 of file openclose.c.

{
    if (db_get_current_workspace_name())
    {
        user_log("Checkpoint of workspace.\n");
        /* FC 25/06/2003
         * this seems to break pipsmake internal data...
        pips_debug(3, "\tdeleting obsolete resources...\n");
        delete_obsolete_resources();
        */
        pips_debug(3, "\tsaving resources...\n");
        db_checkpoint_workspace();
        pips_debug(3, "\tproperties and makefile...\n");
        save_properties();
        save_makefile(db_get_current_workspace_name());
    }
}

References db_checkpoint_workspace(), db_get_current_workspace_name(), pips_debug, save_makefile(), save_properties(), and user_log().

Referenced by apply_a_rule(), and pips_signal_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

close_makefile()

bool close_makefile

(

const char *

name

)

Parameters

name

ame

Definition at line 1812 of file readmakefile.c.

{
    save_makefile(name);
    free_makefile(pipsmakefile), pipsmakefile = makefile_undefined;
    return true;
}

delete_all_resources()

void delete_all_resources

(

void

)

Definition at line 1513 of file pipsmake.c.

{
  db_delete_all_resources();
  reset_make_cache();
  init_make_cache();
}

References db_delete_all_resources(), init_make_cache(), and reset_make_cache().

Here is the call graph for this function:

delete_named_resources()

void delete_named_resources

(

const char *

rn

)

Delete from up_to_date_resources make cache all the resources with a given resource name.

There is no internal data structure in pipsdbm to access these resources efficiently... The two-level mapping of database.c must be inverted.

FI: FC claims in an e-mail that this could be done more efficiently but does not explain how.

Parameters

rn

n

Definition at line 1482 of file pipsmake.c.

{
  pips_assert("make cache is consistent before deletion",
              make_cache_consistent_p());
 
  // firstly, clean up the up-to-date cache if it exists
  int count = 0;
  if (make_cache_p()) {
    list rl = db_retrieve_resources(rn);
    FOREACH(STRING, r_id, rl) {
      if (make_cache_hit_p(r_id)) {
        remove_resource_from_make_cache(r_id);
        count++;
      }
    }
    gen_free_list(rl);
  }
 
  pips_debug(8, "Number of resources no longer considered up-to-date: %d\n",
             count);
 
  // Then remove the resource
  // GO 29/6/95: many lines ...  db_unput_resources_verbose (rn);
  int count2 = db_unput_resources(rn);
  pips_assert("The number of resources removed from the cache is smaller "
              "than the number of resources removed from te database\n",
              count<=count2);
  pips_assert("make cache is consistent before deletion",
              make_cache_consistent_p());
}

References count, db_retrieve_resources(), db_unput_resources(), FOREACH, gen_free_list(), make_cache_consistent_p(), make_cache_hit_p(), make_cache_p(), pips_assert, pips_debug, remove_resource_from_make_cache(), and STRING.

Referenced by delete_derived_resources().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_obsolete_resources()

int delete_obsolete_resources

(

void

)

Definition at line 1432 of file pipsmake.c.

{
  bool cache_off = !make_cache_p();
  // FI: this test breaks the consistency of init() and reset() for
  // the make cache
  if (cache_off) init_make_cache();
  int ndeleted =
    db_delete_obsolete_resources(check_physical_resource_up_to_date);
  if (cache_off) reset_make_cache();
  return ndeleted;
}

References check_physical_resource_up_to_date(), db_delete_obsolete_resources(), init_make_cache(), make_cache_p(), and reset_make_cache().

Referenced by delete_some_resources().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_some_resources()

void delete_some_resources

(

void

)

this is quite ugly, but I wanted to put the enumeration down to pipsdbm.

Definition at line 1446 of file pipsmake.c.

{
  const char* what = get_string_property("PIPSDBM_RESOURCES_TO_DELETE");
  dont_interrupt_pipsmake_asap();
 
  user_log("Deletion of %s resources:\n", what);
 
  if (same_string_p(what, "obsolete"))
  {
    int ndeleted = delete_obsolete_resources();
    if (ndeleted>0) user_log("%d destroyed.\n", ndeleted);
    else user_log("none destroyed.\n");
  } else if (same_string_p(what, "all")) {
    db_delete_all_resources();
    user_log("done.\n");
  } else
    pips_internal_error("unexpected delete request %s", what);
}

References db_delete_all_resources(), delete_obsolete_resources(), dont_interrupt_pipsmake_asap(), get_string_property(), pips_internal_error, same_string_p, and user_log().

Referenced by close_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

do_resource_usage_check()

void do_resource_usage_check	(	const char *	oname,
		rule	ru
	)

check the usage of resources

es_write

Parameters

oname	name
ru	u

Definition at line 1559 of file pipsmake.c.

{
  list reals;
  set res_read = set_undefined;
  set res_write = set_undefined;
 
  // Get the dbm sets
  get_logged_resources (&res_read, &res_write);
 
  // build the real required resrouces
  reals = build_real_resources(oname, rule_required (ru));
 
  // Delete then from the set of read resources
  FOREACH(real_resource, rr, reals)
  {
    string rron = real_resource_owner_name(rr);
    string rrrn = real_resource_resource_name(rr);
    string elem_name = strdup(concatenate(rron,".", rrrn, NULL));
 
    if (set_belong_p (res_read, elem_name)){
            pips_debug (5, "resource %s.%s has been read: ok\n", rron, rrrn);
            set_del_element(res_read, res_read, elem_name);
    }
    else
            user_log("resource %s.%s has not been read\n", rron, rrrn);
  }
 
  // Try to find an illegally read resource ... */
  SET_MAP(re,   user_log("resource %s has been read\n", re), res_read);
  gen_full_free_list(reals);
 
  // build the real produced resources
  reals = build_real_resources(oname, rule_produced(ru));
 
  // Delete then from the set of written/generated resources
  FOREACH(real_resource, rr, reals /*res_write*/)
  {
    string rron = real_resource_owner_name(rr);
    string rrrn = real_resource_resource_name(rr);
    string elem_name = strdup(concatenate(rron,".", rrrn, NULL));
 
    if (set_belong_p (res_write, (void *) elem_name)){
            pips_debug (5, "resource %s.%s has been written: ok\n", rron, rrrn);
            set_del_element(res_write, res_write, elem_name);
    }
    else
            user_log ("resource %s.%s has not been written\n", rron, rrrn);
  }
 
  // Try to find an illegally written resource ...
  SET_MAP(re, user_log ("resource %s has been written\n", re), res_write);
 
  gen_full_free_list(reals);
 
  // not free!
  set_clear(res_read);
  set_clear(res_write);
}

References build_real_resources(), concatenate(), FOREACH, gen_full_free_list(), get_logged_resources(), pips_debug, real_resource_owner_name, real_resource_resource_name, res_read, res_write, rule_produced, rule_required, set_belong_p(), set_clear(), set_del_element(), SET_MAP, set_undefined, strdup(), and user_log().

Referenced by apply_a_rule().

Here is the call graph for this function:

Here is the caller graph for this function:

find_rule_by_phase()

rule find_rule_by_phase

(

const char *

pname

)

this function returns the rule that defines builder pname

walking thru rules

Parameters

pname

name

Definition at line 1686 of file readmakefile.c.

{
  rule fr = rule_undefined;
  makefile m = parse_makefile();
 
  pips_debug(9, "searching rule for phase %s\n", pname);
 
  /* walking thru rules */
  FOREACH(RULE, r, makefile_rules(m)) {
    if (same_string_p(rule_phase(r), pname)) {
      fr = r;
      break;
    }
  }
 
  return fr;
}

Referenced by add_rule().

Here is the caller graph for this function:

find_rule_by_resource()

rule find_rule_by_resource

(

const char *

rname

)

This function returns the active rule to produce resource rname.

It selects the first active rule in the database which produces the resource but does not use/require it.

walking thru rules

walking thru resources required by this rule to eliminate rules using and producing this resource, e.g. code transformations for the CODE resource.

Parameters

rname

name

Definition at line 694 of file pipsmake.c.

{
  makefile m = parse_makefile();
 
  pips_debug(5, "searching rule for resource %s\n", rname);
 
  /* walking thru rules */
  FOREACH(RULE, r, makefile_rules(m))
  {
    bool resource_required_p = false;
 
    /* walking thru resources required by this rule to eliminate rules
       using and producing this resource, e.g. code transformations
       for the CODE resource. */
    FOREACH(VIRTUAL_RESOURCE, vr, rule_required(r))
    {
      string vrn = virtual_resource_name(vr);
      owner vro = virtual_resource_owner(vr);
 
            // We do not check callers and callees
            if ( owner_callers_p(vro) || owner_callees_p(vro) ) {}
            // Is this resource required ??
            else if (same_string_p(vrn, rname))
        resource_required_p = true;
    }
 
    // If this particular resource is not required by the current rule.
    if (!resource_required_p)
    {
      // walking thru resources made by this particular rule
      FOREACH(VIRTUAL_RESOURCE, vr, rule_produced(r))
      {
        string vrn = virtual_resource_name(vr);
 
        if (same_string_p(vrn, rname)) {
 
          pips_debug(5, "made by phase %s\n", rule_phase(r));
 
          // Is this phase an active one ?
          FOREACH(STRING, pps, makefile_active_phases(m))
          {
            if (same_string_p(pps, rule_phase(r))) {
              pips_debug(5, "active phase\n");
              return r;
            }
          }
 
          pips_debug(5, "inactive phase\n");
        }
      }
    }
  }
 
  return rule_undefined;
}

References FOREACH, makefile_active_phases, makefile_rules, owner_callees_p, owner_callers_p, parse_makefile(), pips_debug, RULE, rule_phase, rule_produced, rule_required, rule_undefined, same_string_p, STRING, VIRTUAL_RESOURCE, virtual_resource_name, and virtual_resource_owner.

Referenced by activate_phase(), active_phase_for_resource(), array_bound_check_top_down(), check_physical_resource_up_to_date(), rice_regions_dependence_graph(), rmake(), safe_find_rule_by_resource(), safe_make(), update_options(), and used_before_set().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_activated()

void fprint_activated

(

FILE *

fd

)

Parameters

fd

d

Definition at line 110 of file activate.c.

{
  makefile m = parse_makefile();
  FOREACH(STRING, s, makefile_active_phases(m))
    fprintf(fd, "%s\n", s);
}

References FOREACH, fprintf(), makefile_active_phases, parse_makefile(), and STRING.

Referenced by retrieve_active_phases(), and select_rule().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_makefile()

void fprint_makefile	(	FILE *	fd,
		makefile	m
	)

Parameters

fd

d

Definition at line 1649 of file readmakefile.c.

{
  FOREACH(RULE, r, makefile_rules(m))
  {
    fprintf(fd, "%s\n", rule_phase(r));
    fprint_virtual_resources(fd, "\t!", rule_pre_transformation(r));
    fprint_virtual_resources(fd, "\t<", rule_required(r));
    fprint_virtual_resources(fd, "\t>", rule_produced(r));
    fprint_virtual_resources(fd, "\t=", rule_preserved(r));
    fprint_virtual_resources(fd, "\t#", rule_modified(r));
  }
}

Referenced by parse_makefile().

Here is the caller graph for this function:

fprint_virtual_resources()

void fprint_virtual_resources	(	FILE *	fd,
		const char *	dir,
		list	lrv
	)

Parameters

fd	d
dir	ir
lrv	rv

Definition at line 1611 of file readmakefile.c.

{
  FOREACH(VIRTUAL_RESOURCE, vr, lrv)
  {
    owner o = virtual_resource_owner(vr);
    string n = virtual_resource_name(vr);
 
    switch (owner_tag(o)) {
    case is_owner_program:
            fprintf(fd, "    %s program.%s\n", dir, n);
            break;
    case is_owner_module:
            fprintf(fd, "    %s module.%s\n", dir, n);
            break;
    case is_owner_main:
            fprintf(fd, "    %s main.%s\n", dir, n);
            break;
    case is_owner_callees:
            fprintf(fd, "    %s callees.%s\n", dir, n);
            break;
    case is_owner_callers:
            fprintf(fd, "    %s callers.%s\n", dir, n);
            break;
    case is_owner_all:
            fprintf(fd, "    %s all.%s\n", dir, n);
            break;
    case is_owner_select:
            fprintf(fd, "    %s select.%s\n", dir, n);
            break;
    case is_owner_compilation_unit:
            fprintf(fd, "    %s compilation_unit.%s\n", dir, n);
            break;
    default:
            pips_internal_error("bad owner tag (%d)\n", owner_tag(o));
    }
  }
}

Referenced by fprint_makefile().

Here is the caller graph for this function:

get_callees()

gen_array_t get_callees

(

string

module

)

Get all the callers of the specified module.

The returned value is allocated dynamically and needs to be freed by the caller of this function

Parameters

module

odule

Definition at line 1816 of file pipsmake.c.

{
  callees callee_modules;
 
  if (!safe_make(DBR_CALLEES, module))
    pips_internal_error("Cannot make callees for %s", module);
 
  callee_modules = (callees)
    db_get_memory_resource(DBR_CALLEES, module,true);
 
  return gen_array_from_list(callees_callees(callee_modules));
}

References callees_callees, db_get_memory_resource(), gen_array_from_list(), module, pips_internal_error, and safe_make().

Referenced by get_callees_of().

Here is the call graph for this function:

Here is the caller graph for this function:

get_callers()

gen_array_t get_callers

(

string

module

)

Get all the callers of the specified module.

The returned value is allocated dynamically and needs to be freed by the caller of this function

Parameters

module

odule

Definition at line 1799 of file pipsmake.c.

{
  callees caller_modules;
 
  if (!safe_make(DBR_CALLERS, module))
    pips_internal_error("Cannot make callers for %s", module);
 
  caller_modules = (callees)
    db_get_memory_resource(DBR_CALLERS, module,true);
 
  return gen_array_from_list(callees_callees(caller_modules));
}

References callees_callees, db_get_memory_resource(), gen_array_from_list(), module, pips_internal_error, and safe_make().

Referenced by get_callers_of().

Here is the call graph for this function:

Here is the caller graph for this function:

get_dont_build_view_file()

string get_dont_build_view_file

(

const char *

print_type

)

Parameters

print_type

rint_type

Definition at line 102 of file view.c.

{
    return get_view_file(print_type, false);
}

References get_view_file(), and print_type().

Referenced by wpips_display_WP65_file().

Here is the call graph for this function:

Here is the caller graph for this function:

get_first_main_module()

string get_first_main_module

(

void

)

Should be able to handle Fortran applications, C applications and mixed Fortran/C applications.

This is a duplicate for pipsdbm function, get_main_entity_name()

Definition at line 1525 of file pipsmake.c.

{
  string dir_name = db_get_current_workspace_directory();
  string main_name;
  string name = string_undefined;
 
  debug_on("PIPSMAKE_DEBUG_LEVEL");
 
  // Let's look for a Fortran main
  main_name = strdup(concatenate(dir_name, "/", MAIN_FILE_NAMES, NULL));
 
  if (file_exists_p(main_name))
  {
    FILE * tmp_file = safe_fopen(main_name, "r");
    name = safe_readline(tmp_file);
    safe_fclose(tmp_file, main_name);
  }
  free(main_name);
 
  if(string_undefined_p(name)) {
    // Let's now look for a C main
    main_name = strdup(concatenate(dir_name, "/", MAIN_FILE_NAMES, NULL));
    if (file_exists_p(main_name))
      name = strdup("main");
    free(main_name);
  }
 
  free(dir_name);
  debug_off();
  return name;
}

References concatenate(), db_get_current_workspace_directory(), debug_off, debug_on, file_exists_p(), free(), MAIN_FILE_NAMES, safe_fclose(), safe_fopen(), safe_readline(), strdup(), string_undefined, and string_undefined_p.

Referenced by get_main(), and select_a_module_by_default().

Here is the call graph for this function:

Here is the caller graph for this function:

init_lex()

int init_lex

(

void

)

init_make_cache()

void init_make_cache

(

void

)

Definition at line 199 of file pipsmake.c.

{
  pips_debug(8, "The up-to-date resource cache is initialized to empty\n");
  pips_assert("not set", set_undefined_p(up_to_date_resources));
  up_to_date_resources = set_make(set_pointer);
}

References pips_assert, pips_debug, set_make(), set_pointer, set_undefined_p, and up_to_date_resources.

Referenced by apply(), concurrent_apply(), delete_all_resources(), delete_obsolete_resources(), make(), make_post_transformation(), make_pre_post_transformation(), and reinit_make_cache_if_necessary().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_signal_catcher()

void initialize_signal_catcher

(

void

)

Definition at line 126 of file signal.c.

{
  // misc signals
  (void) signal(SIGINT,  pips_signal_handler);
  (void) signal(SIGHUP,  pips_signal_handler);
  (void) signal(SIGTERM, pips_signal_handler);
 
  (void) signal(SIGUSR1, pips_signal_handler);
  (void) signal(SIGUSR2, pips_signal_handler);
 
  // timeout handling
  set_pips_timeout_from_env();
}

References pips_signal_handler(), and set_pips_timeout_from_env().

Referenced by pips_main(), and tpips_main().

Here is the call graph for this function:

Here is the caller graph for this function:

make_cache_consistent_p()

bool make_cache_consistent_p

(

void

)

Debug function: make sure that up-to-date resources do exist in the resource database.

If the cache does not exist, it is considered consistent.

FI: the first test should be enough

Definition at line 275 of file pipsmake.c.

{
  if (!set_undefined_p(up_to_date_resources)) {
    SET_FOREACH(void *, res_id, up_to_date_resources) {
      string res_rn = db_resource_name(res_id);
      /* FI: the first test should be enough */
      if(string_undefined_p(res_rn))
        return false;
      string res_on = db_resource_owner_name(res_id);
      if(string_undefined_p(res_on))
        return false;
      if(!db_resource_p(res_rn, res_on))
        return false;
    }
  }
  return true;
}

References db_resource_name(), db_resource_owner_name(), db_resource_p(), SET_FOREACH, set_undefined_p, string_undefined_p, and up_to_date_resources.

Referenced by delete_named_resources().

Here is the call graph for this function:

Here is the caller graph for this function:

make_cache_hit_p()

bool make_cache_hit_p

(

void *

rr_id

)

Parameters

rr_id

r_id

Definition at line 219 of file pipsmake.c.

{
  return set_belong_p(up_to_date_resources, rr_id);
}

References set_belong_p(), and up_to_date_resources.

Referenced by check_physical_resource_up_to_date(), delete_named_resources(), make_required(), rmake(), and update_preserved_resources().

Here is the call graph for this function:

Here is the caller graph for this function:

make_cache_p()

bool make_cache_p

(

void

)

Can the make cache be used?

Definition at line 207 of file pipsmake.c.

{
  return !set_undefined_p(up_to_date_resources);
}

References set_undefined_p, and up_to_date_resources.

Referenced by delete_named_resources(), delete_obsolete_resources(), and make_required().

Here is the caller graph for this function:

make_close_workspace()

bool make_close_workspace

(

bool

is_quit

)

FI->GO: could be in top-level, no?

lazy...

dup because freed in db_close_workspace

Parameters

is_quit

s_quit

Definition at line 102 of file openclose.c.

{
    bool res = true;
    string name;
 
    if (db_get_current_module_name()) /* lazy... */
        db_reset_current_module_name();
 
    /* dup because freed in db_close_workspace */
    name = strdup(db_get_current_workspace_name()); 
 
    res &= close_makefile(name);
    save_properties();
    res &= db_close_workspace(is_quit);
 
    if(res)
        user_log("Workspace %s closed.\n\n", name);
    else
        user_log("Failed to close workspace %s.\n\n", name);
 
    free(name);
    return res;
}

References close_makefile(), db_close_workspace(), db_get_current_module_name(), db_get_current_workspace_name(), db_reset_current_module_name(), free(), save_properties(), strdup(), and user_log().

Referenced by close_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

make_open_workspace()

string make_open_workspace

(

const char *

name

)

should be an error?

Parameters

name

ame

Definition at line 72 of file openclose.c.

{
    if (db_open_workspace(name)) 
    {
        if (open_properties())
        {
            if (open_makefile(name) != makefile_undefined) 
            {
                pips_debug(7, "makefile opened\n");
            }
            else
            {
                /* should be an error? */
                pips_user_warning("No special makefile for this workspace "
                                  "%s/%s.database\n", get_cwd(), name);
            }
        }
        else
        {
            pips_user_warning("Cannot read properties...\n");
            db_close_workspace(true);
        }
    } else
        pips_user_warning("No workspace %s to open\n", name);
 
    return db_get_current_workspace_name();
}

References db_close_workspace(), db_get_current_workspace_name(), db_open_workspace(), get_cwd(), makefile_undefined, open_makefile(), open_properties(), pips_debug, and pips_user_warning.

Referenced by open_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

open_makefile()

makefile open_makefile

(

const char *

name

)

Parameters

name

ame

Definition at line 1770 of file readmakefile.c.

{
    FILE * fd;
    char * mkf_name;
 
    mkf_name = build_pgm_makefile(name);
    fd = fopen(mkf_name, "r");
 
    if (!makefile_undefined_p(pipsmakefile))
    {
      free_makefile(pipsmakefile);
      pipsmakefile = makefile_undefined;
      pips_debug(1, "current makefile erased\n");
    }
 
    if (fd)
    {
      pipsmakefile = read_makefile(fd);
      safe_fclose(fd, mkf_name);
    }
    else
    {
      pips_user_warning("pipsmake file not found in database...\n");
      pipsmakefile = parse_makefile();
    }
 
    free(mkf_name);
    return pipsmakefile;
}

parse_makefile()

makefile parse_makefile

(

void

)

Definition at line 1663 of file readmakefile.c.

{
  // do it only once
  if (pipsmakefile == makefile_undefined)
  {
    debug_on("PIPSMAKE_DEBUG_LEVEL");
 
    pipsmake_in = fopen_config(PIPSMAKE_RC, NULL, "PIPS_PIPSMAKERC");
 
    init_lex();
    yyparse();
    safe_fclose(pipsmake_in, "PIPS_PIPSMAKERC");
 
    ifdebug(8) fprint_makefile(stderr, pipsmakefile);
 
    debug_off();
  }
 
  return pipsmakefile;
}

Referenced by find_rule_by_phase(), and open_makefile().

Here is the caller graph for this function:

pipsmake_alloc()

void* pipsmake_alloc

(

yy_size_t

)

pipsmake_error()

void pipsmake_error

(

const char *

)

symbols exported by lex / yacc

pipsmake_free()

void pipsmake_free

(

void *

)

pipsmake_get_debug()

int pipsmake_get_debug

(

void

)

pipsmake_get_in()

FILE* pipsmake_get_in

(

void

)

pipsmake_get_leng()

int pipsmake_get_leng

(

void

)

pipsmake_get_lineno()

int pipsmake_get_lineno

(

void

)

pipsmake_get_out()

FILE* pipsmake_get_out

(

void

)

pipsmake_get_text()

char* pipsmake_get_text

(

void

)

pipsmake_lex()

int pipsmake_lex

(

void

)

pipsmake_lex_destroy()

int pipsmake_lex_destroy

(

void

)

pipsmake_parse()

int pipsmake_parse

(

void

)

pipsmake_pop_buffer_state()

void pipsmake_pop_buffer_state

(

void

)

pipsmake_realloc()

void* pipsmake_realloc	(	void *	,
		yy_size_t
	)

pipsmake_restart()

void pipsmake_restart

(

FILE *

)

pipsmake_set_debug()

void pipsmake_set_debug

(

int

)

pipsmake_set_in()

void pipsmake_set_in

(

FILE *

)

pipsmake_set_lineno()

void pipsmake_set_lineno

(

int

)

pipsmake_set_out()

void pipsmake_set_out

(

FILE *

)

pipsmake_wrap()

int pipsmake_wrap

(

void

)

prgm_mapping()

bool prgm_mapping

(

string

module_name

)

=========================================================================

The placement function

The timing function

The number of nodes in the DFG

The number of dataflows in the DFG

Mapping from a dataflow to its distance

Mapping from a statement to its prototype

Perf.mesurement

List of the unknowns coefficients

Initialize debugging functions

We get the required data: module entity, code, static_control, dataflow graph, timing function.

The DFG

the BDT

First we count the number of nodes and dataflows

We look for the broadcasts

We sort the nodes of "the_dfg" in decreasing dimension order. The dimension of a node is the dimension of the iteration space of its instruction.

INITIALIZATION

We create a prototype for each statement. Each prototype is mapped to its statement in the hash table "StmtToProto". An other hash table "StmtToProto" associates the unknown coefficients used in the prototype and the statement. The returned value "lambda" gives all the coefficients that have been created.

plc_make_dim() has to initialize the Mu list

We compute the dimension of the placement function of each instruction, and the greatest one (dmax). This is based on the timing function, if it exists.

The number of mapping dimensions can be computed as a minimum, see plc_make_min_dim()

Mapping dimension can be fixed with the environment variable MAPPING_DIMENSION

We initialize the prgm_mapping function.

Computation of the weight of each dataflow of the DFG.

We get all the dataflows of the graph

We sort the dataflows in decreasing weight order

EDGES TREATMENT

BROADCAST CONDITIONS

We take into account the broadcast conditions

OD : we could give "remnants_df_l" as an arg, in order to only compute the useful distances.

DISTANCE COMPUTATION

Computation of the distance of each dataflow.

CUTTING CONDITIONS

We compute the list of equations that are to be nullified in order to zero out all the distances.

We eliminate all the unknowns that are valuated by the substitution computed above "sigma"; and then we cut it in two parts, one containing the indices coefficients, one containing the parameters coefficients, both sorted by decreasing frenquency in the prototypes. Before cutting the list "lambda" into two parts, we take into account the partial broadcast prototypes (contain in "pfunc") to replace some of the "lambda" coeff by the "mu" coeff. The new sigma is returned by this function.

UNELIMINATED COEFF SORTING

COEFF PARTITION

VALUATION

We valuate all the remaining unknowns by building successively each dimension.

Parameters

module_name

odule

Definition at line 2213 of file prgm_mapping.c.

{
  extern plc pfunc;             /* The placement function */
  extern bdt the_bdt;           /* The timing function */
  extern graph the_dfg;
  extern int nb_nodes,          /* The number of nodes in the DFG */
             nb_dfs;            /* The number of dataflows in the DFG */
 
  extern hash_table DtfToDist;  /* Mapping from a dataflow to its distance */
  extern hash_table StmtToProto;/* Mapping from a statement to its prototype */
  extern hash_table DtfToSink;
  extern hash_table DtfToWgh;
 
  extern list prgm_parameter_l;
 
  struct  tms             chrono1, chrono2; /* Perf.mesurement */
  statement_mapping STS;
 
  /* List of the unknowns coefficients */
  list lambda, xmu_lambda, mu_lambda, mu,
       sigma, sigma1, sigma2, sigma_p, *sigma3,
       su_l,
       sorted_df_l, l, remnants_df_l, df_l;
  Psysteme M_ps;
  int dmax, i;
  entity ent;
  static_control          stco;
  statement               mod_stat;
  char *md;
 
  /* Initialize debugging functions */
  debug_on("MAPPING_DEBUG_LEVEL");
  if(get_debug_level() > 0)
    fprintf(stderr, "\n\n *** COMPUTE MAPPING for %s\n", module_name);
 
  if(get_debug_level() > 1) {
    times(&chrono1);
  }
 
  /* We get the required data: module entity, code, static_control, dataflow
   * graph, timing function.
   */
  ent = local_name_to_top_level_entity( module_name );
 
  set_current_module_entity(ent);
 
  mod_stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  STS = (statement_mapping) db_get_memory_resource(DBR_STATIC_CONTROL,
                                                       module_name, true);
  stco     = (static_control) GET_STATEMENT_MAPPING(STS, mod_stat);
  if ( stco == static_control_undefined) {
    pips_internal_error("This is an undefined static control !");
  }
  if ( !static_control_yes( stco )) {
    pips_internal_error("This is not a static control program !");
  }
 
  set_current_stco_map(STS);
 
  prgm_parameter_l = static_control_params(stco);
 
  if(get_debug_level() > 2) {
    fprintf(stderr, "[prgm_mapping] Structure parameters of the program: ");
    fprint_entity_list(stderr, prgm_parameter_l);
    fprintf(stderr, "\n");
  }
 
  /* The DFG */
  the_dfg = adg_pure_dfg((graph) db_get_memory_resource(DBR_ADFG, module_name, true));
 
  /* the BDT */
  the_bdt = bdt_undefined;
  the_bdt = (bdt) db_get_memory_resource(DBR_BDT, module_name, true);
 
  if(get_debug_level() > 2) {
    fprint_dfg(stderr, the_dfg);
  }
  if(get_debug_level() > 0) {
    fprint_bdt(stderr, the_bdt);
  }
  /* First we count the number of nodes and dataflows */
  nb_nodes = 0;
  nb_dfs = 0;
  for(l = graph_vertices(the_dfg); !ENDP(l); POP(l)) {
    nb_nodes++;
    for(su_l = vertex_successors(VERTEX(CAR(l))); !ENDP(su_l); POP(su_l)) {
      for(df_l = SUCC_DATAFLOWS(SUCCESSOR(CAR(su_l))); df_l != NIL; df_l = CDR(df_l)) {
        nb_dfs++;
      }
    }
  }
 
  /* We look for the broadcasts */
  broadcast(the_dfg);
 
  /* We sort the nodes of "the_dfg" in decreasing dimension order. The
   * dimension of a node is the dimension of the iteration space of its
   * instruction.
   */
  graph_vertices(the_dfg) = sort_dfg_node(graph_vertices(the_dfg));
 
  if(get_debug_level() > 2)
{
    fprintf(stderr, "[prgm_mapping] Nodes order:");
    for(l = graph_vertices(the_dfg); ! ENDP(l); POP(l))
      fprintf(stderr, " %d,", vertex_int_stmt(VERTEX(CAR(l))));
    fprintf(stderr, "\n");
  }
 
/* INITIALIZATION */
  /* We create a prototype for each statement. Each prototype is mapped to
   * its statement in the hash table "StmtToProto". An other hash table
   * "StmtToProto" associates the unknown coefficients used in the
   * prototype and the statement. The returned value "lambda" gives all
   * the coefficients that have been created.
   */
  lambda = plc_make_proto();
 
  if(get_debug_level() > 2)
{
    fprintf(stderr, "[prgm_mapping] Nodes prototypes:\n");
    plc_fprint_proto(stderr, the_dfg, StmtToProto);
    fprintf(stderr, "[prgm_mapping] LAMBDAS: ");
    fprint_entity_list(stderr, lambda);
    fprintf(stderr, "\n");
  }
 
  /* plc_make_dim() has to initialize the Mu list*/
 
  /* We compute the dimension of the placement function of each instruction,
   * and the greatest one (dmax). This is based on the timing function, if it
   * exists.
   */
  count_mu_coeff = 1;
  dmax = plc_make_dim();
 
  /* The number of mapping dimensions can be computed as a minimum, see
   * plc_make_min_dim() */
  i = ((md = getenv("MINIMUM_DIMENSION")) != NULL) ? 1 : 0;
  if(i == 1) {
    int dmin;
 
    dmin = plc_make_min_dim();
 
    user_warning("prgm_mapping",
                 "Minimum number of dimensions: %d instead of %d\n",
                 dmin, dmax);
 
    dmax = dmin;
  }
 
  /* Mapping dimension can be fixed with the environment variable
   * MAPPING_DIMENSION */
  i = ((md = getenv("MAPPING_DIMENSION")) != NULL) ? atoi(md) : dmax;
  if(i != dmax) {
    user_warning("prgm_mapping",
                 "environment variable MAPPING_DIMENSION has set the mapping dimension to %d instead of %d\n",
                 i, dmax);
 
    dmax = i;
  }
  
  /* We initialize the prgm_mapping function. */
  pfunc = make_plc(NIL);
  for(l = graph_vertices(the_dfg); l != NIL; l = CDR(l)) {
    placement new_func;
    vertex v = VERTEX(CAR(l));
    int stmt = vertex_int_stmt(v);
 
    new_func = make_placement(stmt, NIL);
    plc_placements(pfunc) = gen_nconc(plc_placements(pfunc),
                                      CONS(PLACEMENT, new_func, NIL));
  }
 
  debug(3, "prgm_mapping", "DIM des fonctions de placement : %d\n", dmax);
  if(dmax == 0) {
    for(l = plc_placements(pfunc); !ENDP(l); POP(l)) {
      placement crt_func = PLACEMENT(CAR(l));
      placement_dims(crt_func) = CONS(EXPRESSION,
                                      int_to_expression(0),
                                      NIL);
    }
 
    DB_PUT_MEMORY_RESOURCE(DBR_PLC, strdup(module_name), pfunc);
    reset_current_stco_map();
    reset_current_module_entity();
    debug_off();
    return(true);
  }
 
  /* Computation of the weight of each dataflow of the DFG. */
  edge_weight();
 
  /* We get all the dataflows of the graph */
  df_l = get_graph_dataflows(the_dfg);
  if(get_debug_level() > 5) {
    fprintf(stderr, "[prgm_mapping] Edges UNorder:\n");
    plc_fprint_dfs(stderr, df_l, DtfToSink, DtfToWgh);
  }
 
  /* We sort the dataflows in decreasing weight order */
  sorted_df_l = general_merge_sort(df_l, compare_dfs_weight);
  if(get_debug_level() > 2)
 {
    fprintf(stderr, "[prgm_mapping] Edges order:\n");
    plc_fprint_dfs(stderr, sorted_df_l, DtfToSink, DtfToWgh);
  }
 
 
/* EDGES TREATMENT */
 
/* BROADCAST CONDITIONS */
  /* We take into account the broadcast conditions */
  sigma = NIL;
  remnants_df_l = broadcast_conditions(lambda, sorted_df_l, &sigma);
  if(get_debug_level() > 2)
  {
    fprintf(stderr, "[prgm_mapping] Dif Red restriction:\n");
    fprint_vvs(stderr, sigma);
    fprintf(stderr, "[prgm_mapping] Remnants :\n");
    plc_fprint_dfs(stderr, remnants_df_l, DtfToSink, DtfToWgh);
  }
 
  for(sigma_p = sigma; !ENDP(sigma_p); POP(sigma_p))
    gen_remove(&lambda, (chunk *) var_val_variable(VAR_VAL(CAR(sigma_p))));
 
  if(get_debug_level() > 2)
  {
    fprintf(stderr, "[prgm_mapping] Prototypes after broadcast conditions:\n");
    plc_fprint_proto(stderr, the_dfg, StmtToProto);
    fprintf(stderr, "\n");
  }
 
  mu = NIL;
  sigma1 = partial_broadcast_coefficients(lambda, &mu);
 
  if(get_debug_level() > 3)
{
fprintf(stderr, "[prgm_mapping] ******* Partial broadcast sub:");
fprint_vvs(stderr, sigma1);
fprintf(stderr, "\n");
}
 
  vvs_on_prototypes(sigma1);
 
  if(get_debug_level() > 2) 
{
    fprintf(stderr, "[prgm_mapping] Prototypes after partial broadcast sub:\n");
    plc_fprint_proto(stderr, the_dfg, StmtToProto);
    fprintf(stderr, "\n");
}
 
  for(sigma_p = sigma1; !ENDP(sigma_p); POP(sigma_p)) {
    entity e = var_val_variable(VAR_VAL(CAR(sigma_p)));
    gen_remove(&lambda, (chunk *) e);
    gen_remove(&mu, (chunk *) e);
  }
 
if(get_debug_level() > 3) {
fprintf(stderr, "[prgm_mapping] ******* Remaining lambdas and Mus:\n");
fprintf(stderr, "\t LAMBDAs:");
fprint_entity_list(stderr, lambda);
fprintf(stderr, "\n");
fprintf(stderr, "\t MUs:");
fprint_entity_list(stderr, mu);
fprintf(stderr, "\n");
}
 
/*MOD : we could give "remnants_df_l" as an arg, in order to only compute the
useful distances. */
 
/* DISTANCE COMPUTATION */
  /* Computation of the distance of each dataflow. */
  plc_make_distance();
  if(get_debug_level() > 2) {
    fprintf(stderr, "[prgm_mapping] Edges distances:\n");
    plc_fprint_distance(stderr, the_dfg, DtfToDist);
  }
 
/* CUTTING CONDITIONS */
  /* We compute the list of equations that are to be nullified in order to zero
   * out all the distances.
   */
  M_ps = cutting_conditions(remnants_df_l);
  if(get_debug_level() > 2)
{
    fprintf(stderr, "[prgm_mapping] Matrix M:\n");
    fprint_psysteme(stderr, M_ps);
  }
 
  sigma2 = NIL;
  (void) solve_system_by_succ_elim(M_ps, &sigma2);
 
  if(get_debug_level() > 2) 
{
    fprintf(stderr, "Crt subs:\n");
    fprint_vvs(stderr, sigma2);
  }
    
if(get_debug_level() > 0) {
    fprintf(stderr, "[prgm_mapping] Prototypes after distance conditions:\n");
    plc_fprint_proto(stderr, the_dfg, StmtToProto);
    fprintf(stderr, "\n");
}
 
  /* We eliminate all the unknowns that are valuated by the substitution
   * computed above "sigma"; and then we cut it in two parts, one
   * containing the indices coefficients, one containing the parameters
   * coefficients, both sorted by decreasing frenquency in the
   * prototypes. Before cutting the list "lambda" into two parts, we take
   * into account the partial broadcast prototypes (contain in "pfunc") to
   * replace some of the "lambda" coeff by the "mu" coeff. The new sigma
   * is returned by this function.  */
 
  for(sigma_p = sigma2; !ENDP(sigma_p); POP(sigma_p)) {
    entity e = var_val_variable(VAR_VAL(CAR(sigma_p)));
    gen_remove(&lambda, (chunk *) e);
    gen_remove(&mu, (chunk *) e);
  }
 
if(get_debug_level() > 3) {
fprintf(stderr, "[prgm_mapping] ******* Remaining lambdas:");
fprint_entity_list(stderr, lambda);
fprintf(stderr, "\n");
fprintf(stderr, "[prgm_mapping] ******* Remaining mus:");
fprint_entity_list(stderr, mu);
fprintf(stderr, "\n");
}
 
  /* UNELIMINATED COEFF SORTING */
  sort_unknowns(&lambda, dmax);
  sort_unknowns(&mu, dmax);
 
if(get_debug_level() > 3) {
fprintf(stderr, "[prgm_mapping] ******* Sorted lambdas:");
fprint_entity_list(stderr, lambda);
fprintf(stderr, "\n");
fprintf(stderr, "[prgm_mapping] ******* Sorted mus:");
fprint_entity_list(stderr, mu);
fprintf(stderr, "\n");
}
 
  /* COEFF PARTITION */
  mu_lambda = gen_nconc(mu, lambda);
  xmu_lambda = partition_unknowns(&mu_lambda, dmax);
 
  if(get_debug_level() > 2) 
  {
    fprintf(stderr, "[prgm_mapping] \nRemaining unknowns\n");
    fprintf(stderr, "\tX COEFF: ");
    for(l = xmu_lambda; !ENDP(l); POP(l)) {
      fprintf(stderr, "(");
      fprint_entity_list(stderr, CONSP(CAR(l)));
      fprintf(stderr, ") ");
    }
    fprintf(stderr, "\tPC COEFF: ");
    fprint_entity_list(stderr, mu_lambda);
    fprintf(stderr, "\n");
 
fprint_plc_pp_dims(stderr, pfunc);
}
 
/* VALUATION */
  /* We valuate all the remaining unknowns by building successively each
   * dimension.
   */
  sigma3 = (list *) malloc(sizeof(list)*dmax);
  for(i = 0; i < dmax; i++) {
    list plcs;
 
    sigma3[i] = valuer(i, xmu_lambda, mu_lambda);
 
    if(get_debug_level() > 2) 
    {
      fprintf(stderr, "[prgm_mapping] Plc dim %d, new subs is\n", i);
      fprint_vvs(stderr, sigma3[i]);
      fprintf(stderr, "\n");
    }
 
    for(l = graph_vertices(the_dfg), plcs = plc_placements(pfunc); l != NIL;
        l = CDR(l), POP(plcs)) {
      placement crt_func = PLACEMENT(CAR(plcs));
      list dims;
      vertex v = VERTEX(CAR(l));
      int stmt = vertex_int_stmt(v);
 
      Ppolynome pp = polynome_dup((Ppolynome) hash_get(StmtToProto,
                                                       (char *) stmt));
      Ppolynome sub_pp = vvs_on_polynome(sigma3[i], pp);
      Pvecteur sub_vect = polynome_to_vecteur(sub_pp);
      expression exp = Pvecteur_to_expression(sub_vect);
 
      if(i == 0)
        dims = NIL;
      else
        dims = placement_dims(crt_func);
 
      if(exp == expression_undefined)
        exp = int_to_expression(0);
 
      placement_dims(crt_func) = gen_nconc(dims, CONS(EXPRESSION, exp, NIL));
    }
  }
 
  if(get_debug_level() > 0) {
    fprintf(stderr, "\n RESULT OF MAPPING:\n**************\n");
    df_l = get_graph_dataflows(the_dfg);
    for(i = 0; i < dmax; i++) {
      fprintf(stderr,
              "Distance for dim %d\n=================================\n", i);
      
      for(l = df_l; !ENDP(l); POP(l)) {
        dataflow df = DATAFLOW(CAR(l));
        int stmt = (int) hash_get(DtfToSink, (char *) df);
        Ppolynome pp_dist = polynome_dup((Ppolynome) hash_get(DtfToDist,
                                                              (char *) df));
 
        pp_dist = vvs_on_polynome(sigma, pp_dist);
        pp_dist = vvs_on_polynome(sigma1, pp_dist);
        pp_dist = vvs_on_polynome(sigma2, pp_dist);
        pp_dist = vvs_on_polynome(sigma3[i], pp_dist);
 
        fprintf(stderr, "Dataflow ");
        fprint_dataflow(stderr, stmt, df);
        fprintf(stderr, "\tDist = ");
        polynome_fprint(stderr, pp_dist, pu_variable_name, pu_is_inferior_var);
        fprintf(stderr, "\n");
      }
    }
  }
 
  if(get_debug_level() > 1) {
    times(&chrono2);
 
    fprintf(stderr,
            "\n*******\nTIMING:\n*******\n\tuser : %ld, system : %ld \n",
            (long) chrono2.tms_utime - chrono1.tms_utime,
            (long) chrono2.tms_stime - chrono1.tms_stime );
  }
 
  if(get_debug_level() > 0) {
    fprintf(stderr, "\n MAPPING:\n**************\n");
    fprint_plc(stderr, pfunc);
    fprintf(stderr, "\n\n *** MAPPING done\n");
  }
 
  DB_PUT_MEMORY_RESOURCE(DBR_PLC, strdup(module_name), pfunc);
 
  reset_current_stco_map();
  reset_current_module_entity();
 
  debug_off();
 
  return(true);
}

References adg_pure_dfg(), bdt_undefined, broadcast(), broadcast_conditions(), CAR, CDR, compare_dfs_weight(), CONS, CONSP, count_mu_coeff, cutting_conditions(), DATAFLOW, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, DtfToDist, DtfToSink, DtfToWgh, edge_weight(), ENDP, exp, EXPRESSION, expression_undefined, fprint_bdt(), fprint_dataflow(), fprint_dfg(), fprint_entity_list(), fprint_plc(), fprint_plc_pp_dims(), fprint_psysteme(), fprint_vvs(), fprintf(), gen_nconc(), gen_remove(), general_merge_sort(), get_debug_level(), get_graph_dataflows(), GET_STATEMENT_MAPPING, graph_vertices, hash_get(), int, int_to_expression(), local_name_to_top_level_entity(), make_placement(), make_plc(), malloc(), mod_stat, module_name(), nb_dfs, nb_nodes, NIL, partial_broadcast_coefficients(), partition_unknowns(), pfunc, pips_internal_error, PLACEMENT, placement_dims, plc_fprint_dfs(), plc_fprint_distance(), plc_fprint_proto(), plc_make_dim(), plc_make_distance(), plc_make_min_dim(), plc_make_proto(), plc_placements, polynome_dup(), polynome_fprint(), polynome_to_vecteur(), POP, prgm_parameter_l, pu_is_inferior_var(), pu_variable_name(), Pvecteur_to_expression(), reset_current_module_entity(), reset_current_stco_map(), set_current_module_entity(), set_current_stco_map(), solve_system_by_succ_elim(), sort_dfg_node(), sort_unknowns(), static_control_params, static_control_undefined, static_control_yes, StmtToProto, strdup(), STS, SUCC_DATAFLOWS, SUCCESSOR, the_bdt, the_dfg, user_warning, valuer(), VAR_VAL, var_val_variable, VERTEX, vertex_int_stmt(), vertex_successors, vvs_on_polynome(), and vvs_on_prototypes().

print_array_dfg()

bool print_array_dfg

(

string

)

print_bdt()

bool print_bdt

(

const string

module_name

)

=================================================================

void print_bdt(module_name): print the bdt of module name

AC 94/03/30

Parameters

module_name

odule

Definition at line 89 of file scheduling.c.

{
  char *localfilename;
  FILE        *fd;
  char        *filename;
  bdt the_bdt;
 
  debug_on( "PRINT_BDT_DEBUG_LEVEL" );
 
  if (get_debug_level() > 1)
    user_log("\n\n *** PRINTING BDT for %s\n", module_name);
 
  the_bdt = (bdt) db_get_memory_resource(DBR_BDT, module_name, true);
 
  localfilename = strdup(concatenate(module_name, BDT_EXT, NULL));
  filename = strdup(concatenate(db_get_current_workspace_directory(),
                                "/", localfilename, NULL));
 
  fd = safe_fopen(filename, "w");
  fprint_bdt(fd, the_bdt);
  safe_fclose(fd, filename);
 
  DB_PUT_FILE_RESOURCE(DBR_BDT_FILE, strdup(module_name), localfilename);
 
  free(filename);
 
  if(get_debug_level() > 0)
    fprintf(stderr, "\n\n *** PRINT_BDT DONE\n");
 
  debug_off();
 
  return(true);
}

References BDT_EXT, concatenate(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, fprint_bdt(), fprintf(), free(), get_debug_level(), module_name(), safe_fclose(), safe_fopen(), strdup(), the_bdt, and user_log().

Here is the call graph for this function:

print_make_cache()

void print_make_cache

(

void

)

Debug function, to be tested...

Definition at line 251 of file pipsmake.c.

{
  if (!set_undefined_p(up_to_date_resources)) {
    int count = 0;
    SET_FOREACH(void *, res_id, up_to_date_resources) {
      string res_rn = db_resource_name(res_id);
      string res_on = db_resource_owner_name(res_id);
      if(string_undefined_p(res_rn) || string_undefined_p(res_on))
        printf("Up-to-date resources/make cache inconsistent with "
               "pipsdbm resources\n");
      else
        printf("Up-to-date resource: \"%s.%s\"\n", res_on, res_rn);
      count++;
    }
    if(count==0)
      printf("No up-to-date resource is cached in make cache\n");
  }
  else
    printf("The up-to-date resource make cache is currently undefined\n");
}

References count, db_resource_name(), db_resource_owner_name(), printf(), SET_FOREACH, set_undefined_p, string_undefined_p, and up_to_date_resources.

Here is the call graph for this function:

print_parallelizedCMF_code()

bool print_parallelizedCMF_code

(

string

mod_name

)

======================================================================

Static controlize code

The DFG, the BDT and the PLC

Parameters

mod_name

odule

Definition at line 401 of file prettyprint.c.

{
  plc the_plc;
 
  text r = make_text(NIL);
  entity module;
  statement mod_stat;
  code c;
  string s, pp;
  static_control stco;
  statement_mapping STS;
  bool success;
 
  debug_on("PRETTYPRINT_DEBUG_LEVEL");
  
  module = local_name_to_top_level_entity(mod_name);
  if (module != get_current_module_entity()) {
    reset_current_module_entity();
    set_current_module_entity(module);
  }
  c = entity_code(module);
  s = code_decls_text(c);
 
  /* Static controlize code */
  mod_stat = (statement) db_get_memory_resource(DBR_CODE, mod_name, true); 
  STS = (statement_mapping) db_get_memory_resource(DBR_STATIC_CONTROL, 
                                            mod_name, true); 
  set_current_stco_map(STS);
  stco = get_stco_from_current_map(mod_stat);
 
  lparams = static_control_params(stco); 
  if (stco == static_control_undefined)  
    pips_internal_error("This is an undefined static control !");  
  if (!static_control_yes(stco))  
    pips_internal_error("This is not a static control program !");  
  
  /* The DFG, the BDT and the PLC */
  current_dfg = adg_pure_dfg((graph) db_get_memory_resource(DBR_ADFG,
                                                        mod_name, true));
  current_bdt = (bdt) db_get_memory_resource(DBR_BDT, mod_name, true);
  the_plc = (plc) db_get_memory_resource(DBR_PLC, mod_name, true);
  if (get_debug_level() > 0) {
    fprint_dfg(stderr, current_dfg);
    fprint_bdt(stderr, current_bdt);
    fprint_plc(stderr, the_plc);
  }
 
  pp = strdup(get_string_property(PRETTYPRINT_PARALLEL));
  set_string_property(PRETTYPRINT_PARALLEL, "cmf");
  set_bool_property("PRETTYPRINT_ALL_DECLARATIONS", true);
 
  init_prettyprint(empty_text);
 
  mod_stat = (statement)
    db_get_memory_resource(DBR_REINDEXED_CODE, mod_name, true);
    
  insure_declaration_coherency_of_module(module, mod_stat);
 
  cmf_layout_align(mod_stat);
 
  MERGE_TEXTS(r, text_module(module, mod_stat));
 
  success = make_text_resource(mod_name,
                               DBR_PARALLELPRINTED_FILE,
                               CM_FORTRAN_EXT,
                               r);
 
  reset_current_stco_map();
  reset_current_module_entity();
  close_prettyprint();
 
  set_string_property(PRETTYPRINT_PARALLEL, pp); free(pp);
 
  debug_off();
 
  return(success);
}

References adg_pure_dfg(), close_prettyprint(), CM_FORTRAN_EXT, cmf_layout_align(), code_decls_text, current_bdt, current_dfg, db_get_memory_resource(), debug_off, debug_on, empty_text(), entity_code(), fprint_bdt(), fprint_dfg(), fprint_plc(), free(), get_current_module_entity(), get_debug_level(), get_stco_from_current_map(), get_string_property(), init_prettyprint(), local_name_to_top_level_entity(), lparams, make_text(), make_text_resource(), MERGE_TEXTS, mod_stat, module, NIL, pips_internal_error, PRETTYPRINT_PARALLEL, reset_current_module_entity(), reset_current_stco_map(), set_bool_property(), set_current_module_entity(), set_current_stco_map(), set_string_property(), static_control_params, static_control_undefined, static_control_yes, strdup(), STS, and text_module().

Here is the call graph for this function:

print_parallelizedCRAFT_code()

bool print_parallelizedCRAFT_code

(

string

mod_name

)

======================================================================

Static controlize code

The DFG, the BDT and the PLC

Parameters

mod_name

odule

Definition at line 482 of file prettyprint.c.

{
  plc the_plc;
 
  text r = make_text(NIL);
  entity module;
  statement mod_stat;
  code c;
  string s, pp;
  static_control stco;
  statement_mapping STS;
  bool success;
 
  debug_on("PRETTYPRINT_DEBUG_LEVEL");
  
  module = local_name_to_top_level_entity(mod_name);
  if (module != get_current_module_entity()) {
    reset_current_module_entity();
    set_current_module_entity(module);
  }
  c = entity_code(module);
  s = code_decls_text(c);
 
  /* Static controlize code */
  mod_stat = (statement) db_get_memory_resource(DBR_CODE, mod_name, true); 
  STS = (statement_mapping)db_get_memory_resource(DBR_STATIC_CONTROL, 
                                           mod_name, true); 
  set_current_stco_map(STS);
  stco = get_stco_from_current_map(mod_stat);
 
  lparams = static_control_params(stco); 
  if (stco == static_control_undefined)  
    pips_internal_error("This is an undefined static control !");  
  if (!static_control_yes(stco))  
    pips_internal_error("This is not a static control program !");  
  
  /* The DFG, the BDT and the PLC */
  current_dfg = adg_pure_dfg((graph) db_get_memory_resource(DBR_ADFG,
                                                            mod_name,
                                                            true));
  current_bdt = (bdt) db_get_memory_resource(DBR_BDT, mod_name, true);
  the_plc = (plc) db_get_memory_resource(DBR_PLC, mod_name, true);
  if (get_debug_level() > 0) {
    fprint_dfg(stderr, current_dfg);
    fprint_bdt(stderr, current_bdt);
    fprint_plc(stderr, the_plc);
  }
 
  pp = strdup(get_string_property(PRETTYPRINT_PARALLEL));
  set_string_property(PRETTYPRINT_PARALLEL, "craft");
  set_bool_property("PRETTYPRINT_ALL_DECLARATIONS", true);
 
  init_prettyprint(empty_text);
 
  mod_stat = (statement) db_get_memory_resource(DBR_REINDEXED_CODE,
                                                mod_name, true);
    
  insure_declaration_coherency_of_module(module, mod_stat);
  craft_layout_align(mod_stat);
  MERGE_TEXTS(r, text_module(module, mod_stat));
 
  success = make_text_resource(mod_name,
                               DBR_PARALLELPRINTED_FILE,
                               CRAFT_FORTRAN_EXT,
                               r);
 
  reset_current_stco_map();
  reset_current_module_entity();
  close_prettyprint();
  set_string_property(PRETTYPRINT_PARALLEL, pp); free(pp);
  debug_off();
 
  return(success);
}

References adg_pure_dfg(), close_prettyprint(), code_decls_text, CRAFT_FORTRAN_EXT, craft_layout_align(), current_bdt, current_dfg, db_get_memory_resource(), debug_off, debug_on, empty_text(), entity_code(), fprint_bdt(), fprint_dfg(), fprint_plc(), free(), get_current_module_entity(), get_debug_level(), get_stco_from_current_map(), get_string_property(), init_prettyprint(), local_name_to_top_level_entity(), lparams, make_text(), make_text_resource(), MERGE_TEXTS, mod_stat, module, NIL, pips_internal_error, PRETTYPRINT_PARALLEL, reset_current_module_entity(), reset_current_stco_map(), set_bool_property(), set_current_module_entity(), set_current_stco_map(), set_string_property(), static_control_params, static_control_undefined, static_control_yes, strdup(), STS, and text_module().

Here is the call graph for this function:

print_plc()

bool print_plc

(

string

)

reindexing()

bool reindexing

(

char *

mod_name

)

======================================================================

void reindexing((char*) mod_name):

Initialize debugging functions

We get the required data: module entity, code, static_control,

dataflow graph.

mod_stat = copy_statement((statement) db_get_memory_resource(DBR_CODE, mod_name, true));

The DFG, the BDT and the PLC

First we count the number of nodes to initialize the hash tables

The temporary variables counter

Remove the old code:

And replace it by the new one:

print the values of the delay

Parameters

mod_name

odule

Definition at line 664 of file reindexing.c.

{
  extern int tc;
 
  graph           the_dfg;
  bdt             the_bdt;
  plc             the_plc;
  entity          ent;
  static_control  stco;
  statement       mod_stat, new_mod_stat;
  int nb_nodes;
  list l;
  statement_mapping STS;
 
  /* Initialize debugging functions */
  debug_on("REINDEXING_DEBUG_LEVEL");
  if (get_debug_level() > 0)
    user_log("\n\n *** COMPUTE REINDEXING for %s\n", mod_name);
 
  /* We get the required data: module entity, code, static_control, */
  /* dataflow graph.  */
  ent = local_name_to_top_level_entity( mod_name );
 
  if (ent != get_current_module_entity())
  {
    reset_current_module_entity();
    set_current_module_entity(ent);
  }
 
  /* mod_stat = copy_statement((statement) db_get_memory_resource(DBR_CODE, mod_name,
     true));*/
  mod_stat = (statement) db_get_memory_resource(DBR_CODE, mod_name, false);
  STS = (statement_mapping)db_get_memory_resource(DBR_STATIC_CONTROL,
                                           mod_name, false);
  set_current_stco_map(STS);
  stco = get_stco_from_current_map(mod_stat);
 
  lparams = static_control_params(stco);
 
  if (stco == static_control_undefined) 
    pips_internal_error("This is an undefined static control !");
  
  if (!static_control_yes(stco)) 
    pips_internal_error("This is not a static control program !");
  
 
  /* The DFG, the BDT and the PLC */
  the_dfg = (graph)db_get_memory_resource(DBR_ADFG, mod_name, true);
  the_bdt = (bdt)db_get_memory_resource(DBR_BDT, mod_name, true);
  the_plc = (plc)db_get_memory_resource(DBR_PLC, mod_name, true);
 
  if (get_debug_level() > 0)  
  {
    fprint_dfg(stderr, the_dfg);
    fprint_bdt(stderr, the_bdt);
    fprint_plc(stderr, the_plc);
  }
 
  /* First we count the number of nodes to initialize the hash tables */
  nb_nodes = 0;
  for(l = graph_vertices(the_dfg); !ENDP(l); POP(l))
    nb_nodes++;
  h_node = hash_table_make(hash_int, nb_nodes+1);
  delay_table = hash_table_make(hash_int, nb_nodes+1);
  ht_ab = hash_table_make(hash_int, nb_nodes+1);
 
  /* The temporary variables counter */
  tc = 0;
 
  new_mod_stat = re_do_it(the_dfg, the_bdt, the_plc);
 
  /* Remove the old code: */
  free_instruction(statement_instruction(mod_stat));
  /* And replace it by the new one: */
  statement_instruction(mod_stat) = make_instruction_block(CONS(STATEMENT,
                                                                new_mod_stat,
                                                                NIL));
  DB_PUT_MEMORY_RESOURCE(DBR_REINDEXED_CODE, strdup(mod_name),
                         (char*) mod_stat);
  reset_current_module_statement(); 
  set_current_module_statement((statement) 
                               db_get_memory_resource(DBR_CODE, 
                                                      mod_name, true) ); 
  mod_stat = get_current_module_statement(); 
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(mod_name), (char*) mod_stat); 
  reset_current_module_statement(); 
 
  /* print the values of the delay */
  if (get_debug_level() > 0)
    fprint_delay(stderr, the_dfg, delay_table);
 
  if(get_debug_level() > 0)
    user_log("\n\n *** REINDEXING done\n");
 
  hash_table_free(h_node);
  hash_table_free(delay_table);
 
  reset_current_stco_map();
  reset_current_module_entity();
 
  debug_off();
 
  return(true);
}

References CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, delay_table, ENDP, fprint_bdt(), fprint_delay(), fprint_dfg(), fprint_plc(), free_instruction(), get_current_module_entity(), get_current_module_statement(), get_debug_level(), get_stco_from_current_map(), graph_vertices, h_node, hash_int, hash_table_free(), hash_table_make(), ht_ab, local_name_to_top_level_entity(), lparams, make_instruction_block(), mod_stat, nb_nodes, NIL, pips_internal_error, POP, re_do_it(), reset_current_module_entity(), reset_current_module_statement(), reset_current_stco_map(), set_current_module_entity(), set_current_module_statement(), set_current_stco_map(), STATEMENT, statement_instruction, static_control_params, static_control_undefined, static_control_yes, strdup(), STS, tc, the_bdt, the_dfg, and user_log().

Here is the call graph for this function:

reinit_make_cache_if_necessary()

void reinit_make_cache_if_necessary

(

void

)

Definition at line 212 of file pipsmake.c.

{
  if (!set_undefined_p(up_to_date_resources))
    reset_make_cache(), init_make_cache();
}

References init_make_cache(), reset_make_cache(), set_undefined_p, and up_to_date_resources.

Here is the call graph for this function:

remove_resource_from_make_cache()

void remove_resource_from_make_cache

(

void *

res_id

)

Parameters

res_id

es_id

Definition at line 239 of file pipsmake.c.

{
  string res_rn = db_resource_name(res_id);
  string res_on = db_resource_owner_name(res_id);
  pips_debug(5, "resource %s(%s) deleted from up_to_date make cache\n",
             res_rn, res_on);
  set_del_element (up_to_date_resources,
                   up_to_date_resources,
                   res_id);
}

References db_resource_name(), db_resource_owner_name(), pips_debug, set_del_element(), and up_to_date_resources.

Referenced by delete_named_resources(), make_required(), and update_preserved_resources().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_current_phase_context()

void reset_current_phase_context

(

void

)

Definition at line 96 of file pipsmake.c.

{
  reset_pips_current_computation();
  entity_basic_concrete_types_reset();
  reset_std_static_entities();
}

References entity_basic_concrete_types_reset(), reset_pips_current_computation(), and reset_std_static_entities().

Referenced by callgraph(), and catch_user_error().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_make_cache()

void reset_make_cache

(

void

)

Definition at line 191 of file pipsmake.c.

{
  pips_debug(8, "The up-to-date resource cache is reset\n");
  pips_assert("set is defined", !set_undefined_p(up_to_date_resources));
  set_free(up_to_date_resources);
  up_to_date_resources = set_undefined;
}

References pips_assert, pips_debug, set_free(), set_undefined, set_undefined_p, and up_to_date_resources.

Referenced by apply(), concurrent_apply(), delete_all_resources(), delete_obsolete_resources(), make(), make_post_transformation(), make_pre_post_transformation(), reinit_make_cache_if_necessary(), safe_concurrent_apply(), and safe_do_something().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_pips_timeout()

void reset_pips_timeout

(

void

)

signal.c

Definition at line 60 of file signal.c.

{
  if (pips_timeout_set)
    POP_TIMEOUT();
  pips_timeout_set = false;
}

References pips_timeout_set, and POP_TIMEOUT.

Referenced by set_pips_timeout(), and set_pips_timeout_from_env().

Here is the caller graph for this function:

reset_pipsmake_callback()

void reset_pipsmake_callback

(

void

)

Definition at line 51 of file callback.c.

{
    message_assert("callback not set", callback_set_p == true);
    
    callback_set_p = false;
    callback = (pipsmake_callback_handler_type) NULL;
}

References callback, callback_set_p, and message_assert.

Referenced by gpips_main(), and wpips_main().

Here is the caller graph for this function:

reset_static_phase_variables()

void reset_static_phase_variables

(

void

)

Static variables used by phases must be reset on error although pipsmake does not know which ones are used.

FI: let us hope this is documented in PIPS developer guide... It is not mentionned in the PIPS tutorial. And rightly so I believe. It should be linked to the exception pips_user_error().

From ri-util/static.c

Macro-generated resets

Definition at line 298 of file pipsmake.c.

{
#define DECLARE_ERROR_HANDLER(name) extern void name(); name()
 
    /* From ri-util/static.c */
    DECLARE_ERROR_HANDLER(error_reset_current_module_entity);
    DECLARE_ERROR_HANDLER(error_reset_current_module_statement);
 
    /* Macro-generated resets */
#ifdef HAVE_PIPS_effects_generic_LIBRARY
    DECLARE_ERROR_HANDLER(error_reset_rw_effects);
    DECLARE_ERROR_HANDLER(error_reset_invariant_rw_effects);
    DECLARE_ERROR_HANDLER(error_reset_proper_rw_effects);
    DECLARE_ERROR_HANDLER(error_reset_cumulated_rw_effects);
    /* Macro-generated resets in effects-generic/utils.c */
    DECLARE_ERROR_HANDLER(proper_effects_error_handler);
#endif // HAVE_PIPS_effects_generic_LIBRARY
 
#ifdef HAVE_PIPS_transformer_LIBRARY
    DECLARE_ERROR_HANDLER(reset_transformer_map);
#endif // HAVE_PIPS_transformer_LIBRARY
 
#ifdef HAVE_PIPS_semantics_LIBRARY
    DECLARE_ERROR_HANDLER(reset_precondition_map);
    DECLARE_ERROR_HANDLER(reset_total_precondition_map);
#endif // HAVE_PIPS_semantics_LIBRARY
 
#undef DECLARE_ERROR_HANDLER
 
    // call registered reset functions
    reset_hooks_call();
}

References DECLARE_ERROR_HANDLER, error_reset_cumulated_rw_effects(), error_reset_current_module_entity(), error_reset_current_module_statement(), error_reset_invariant_rw_effects(), error_reset_proper_rw_effects(), error_reset_rw_effects(), proper_effects_error_handler(), reset_hooks_call(), reset_precondition_map(), reset_total_precondition_map(), and reset_transformer_map().

Referenced by catch_user_error(), and safe_do_something().

Here is the call graph for this function:

Here is the caller graph for this function:

retrieve_active_phases()

void retrieve_active_phases

(

void

)

Definition at line 58 of file activate.c.

{
  makefile current_makefile = parse_makefile();
 
  ifdebug(9) {
    puts("----- BEFORE RETRIEVING -----");
    fprint_activated(stdout);
  }
 
  if (saved_active_phases != NIL)
  {
    gen_free_string_list(makefile_active_phases(current_makefile));
    makefile_active_phases(current_makefile) = saved_active_phases;
    saved_active_phases = NIL;
 
    ifdebug(9) {
            puts("----- AFTER RETREIVING -----");
            fprint_activated(stdout);
    }
  }
}

References fprint_activated(), gen_free_string_list(), ifdebug, makefile_active_phases, NIL, parse_makefile(), and saved_active_phases.

Referenced by apply(), concurrent_apply(), make(), safe_concurrent_apply(), and safe_do_something().

Here is the call graph for this function:

Here is the caller graph for this function:

rmake()

bool rmake	(	const char *	rname,
		const char *	oname
	)

recursive make resource.

Should be static, but FI uses it in callgraph.c

is it up to date ?

YES, IT IS!

this resource exists but may be up-to-date?

NO, IT IS NOT.

the resource is already being required... this is bad

Well, the resource does not exists, we have to build it.

Let's check if the proper options have been selected.

These conditions should not be hardwired here but managed by the tpips script language.

we look for the active rule to produce this resource

we recursively make the pre transformations.

we recursively make required resources.

we build the resource

set up-to-date all the produced resources for that rule

we recursively make the post transformations.

Parameters

rname	name
oname	name

Definition at line 919 of file pipsmake.c.

{
  rule ru;
  char * res_id = NULL;
 
  pips_debug(2, "%s(%s) - requested\n", rname, oname);
 
  /* is it up to date ? */
  if (db_resource_p(rname, oname))
  {
    res_id = db_get_resource_id(rname, oname);
    if(make_cache_hit_p(res_id))
    {
      pips_debug(5, "resource %s(%s) found up_to_date, time stamp %d\n",
                 rname, oname, db_time_of_resource(rname, oname));
      return true; /* YES, IT IS! */
    }
    else
    {
      /* this resource exists but may be up-to-date? */
      res_id = NULL; /* NO, IT IS NOT. */
    }
  }
  else if (db_resource_is_required_p(rname, oname))
  {
    /* the resource is already being required... this is bad */
    db_print_all_required_resources(stderr);
    pips_user_error("recursion on resource %s of %s\n", rname, oname);
  }
  else
  {
    /* Well, the resource does not exists, we have to build it. */
    db_set_resource_as_required(rname, oname);
 
    // FC: YUK, this warning should not be here:-(
    /* Let's check  if the proper options have been selected. */
    /* These conditions should not be hardwired here but managed by
       the tpips script language. */
    if(same_string_p(rname, "IN_REGIONS")
       || same_string_p(rname, "OUT_REGIONS")) {
      if (!same_string_p(rule_phase(find_rule_by_resource("REGIONS")),
                         "MUST_REGIONS"))
        pips_user_warning("\nMUST REGIONS not selected - "
                          "Do not expect interesting results.\n");
    }
  }
 
  /* we look for the active rule to produce this resource */
  if ((ru = find_rule_by_resource(rname)) == rule_undefined)
    pips_internal_error("could not find a rule for %s", rname);
 
  /* we recursively make the pre transformations. */
  if (!make_pre_transformation(oname, ru))
    return false;
 
  /* we recursively make required resources. */
  if (!make_required(oname, ru))
    return false;
 
  if (check_resource_up_to_date (rname, oname))
  {
    pips_debug(8,
               "Resource %s(%s) becomes up-to-date after applying\n"
               "  pre-transformations and building required resources\n",
               rname,oname);
  }
  else
  {
    bool success = false;
    list lr;
 
    /* we build the resource */
    db_set_resource_as_required(rname, oname);
 
    success = apply_a_rule(oname, ru);
    if (!success) return false;
 
    lr = build_real_resources(oname, rule_produced(ru));
 
    /* set up-to-date all the produced resources for that rule */
    FOREACH(REAL_RESOURCE, rr, lr) {
      string rron = real_resource_owner_name(rr);
      string rrrn = real_resource_resource_name(rr);
 
      if (db_resource_p(rrrn, rron))
      {
        res_id = db_get_resource_id(rrrn, rron);
        pips_debug(5, "resource %s(%s) added to up_to_date "
                   "with time stamp %d\n",
                   rrrn, rron, db_time_of_resource(rrrn, rron));
        add_resource_to_make_cache(res_id);
      }
      else {
        pips_internal_error("resource %s[%s] just built not found!",
                            rrrn, rron);
      }
    }
 
    gen_full_free_list(lr);
  }
 
  /* we recursively make the post transformations. */
  if (!make_post_transformation(oname, ru))
    return false;
 
  return true;
}

References add_resource_to_make_cache(), apply_a_rule(), build_real_resources(), check_resource_up_to_date(), db_get_resource_id(), db_print_all_required_resources(), db_resource_is_required_p(), db_resource_p(), db_set_resource_as_required(), db_time_of_resource(), find_rule_by_resource(), FOREACH, gen_full_free_list(), make_cache_hit_p(), make_post_transformation(), make_pre_transformation(), make_required(), pips_debug, pips_internal_error, pips_user_error, pips_user_warning, REAL_RESOURCE, real_resource_owner_name, real_resource_resource_name, rule_phase, rule_produced, rule_undefined, and same_string_p.

Referenced by build_real_resources(), callgraph(), make(), and make_required().

Here is the call graph for this function:

Here is the caller graph for this function:

rule_use_resource_produced()

bool rule_use_resource_produced

(

rule

r

)

Test if a rule uses a resource it produces.

find resource res that is produced by phase

owner vro = virtual_resource_owner(vr);

We DO check callers and callees (DB,08/96)

if ( owner_callers_p(vro) || owner_callees_p(vro) ) {} else

Definition at line 353 of file activate.c.

{
    MAPL(pvrp, {
        /* find resource res that is produced by phase */
        virtual_resource res = VIRTUAL_RESOURCE(CAR(pvrp));
        string vrn = virtual_resource_name(res);
 
        MAPL(pvr, {
            virtual_resource vr = VIRTUAL_RESOURCE(CAR(pvr));
            string vrn2 = virtual_resource_name(vr);
            /* owner vro = virtual_resource_owner(vr); */
 
            /* We DO check callers and callees (DB,08/96) */
            /* if ( owner_callers_p(vro) || owner_callees_p(vro) ) {}
            else
            */ 
            if (same_string_p(vrn, vrn2))
                return true;
        }, (list) rule_required( r ) );
 
    }, (list) rule_produced( r ) );
 
    return false;
}

References CAR, MAPL, rule_produced, rule_required, same_string_p, VIRTUAL_RESOURCE, and virtual_resource_name.

Referenced by get_more_derived_resources().

Here is the caller graph for this function:

run_pipsmake_callback()

bool run_pipsmake_callback

(

void

)

Definition at line 59 of file callback.c.

{
    bool result = true;
 
    if (callback_set_p)
        result = (*callback)();
 
    return result;
}

References callback_set_p.

Referenced by apply_a_rule().

Here is the caller graph for this function:

safe_apply()

bool safe_apply	(	const char *	phase_n,
		const char *	module_n
	)

Parameters

phase_n	hase_n
module_n	odule_n

Definition at line 1723 of file pipsmake.c.

{
  return safe_do_something(phase_n, module_n, "phase/rule",
                           find_rule_by_phase, apply);
}

References apply(), find_rule_by_phase(), and safe_do_something().

Referenced by apply(), execute_safe_apply_outside_the_notifier(), execute_safe_apply_outside_the_notifyer(), hpfc_notify(), and pips_main().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_concurrent_apply()

bool safe_concurrent_apply	(	const char *	phase_n,
		gen_array_t	modules
	)

Parameters

phase_n	hase_n
modules	odules

Definition at line 1729 of file pipsmake.c.

{
  bool ok = true;
  debug_on("PIPSMAKE_DEBUG_LEVEL");
 
  // Get a human being representation of the modules:
  string module_list = strdup(string_array_join(modules, ","));
 
  if (find_rule_by_phase(phase_n)==rule_undefined)
  {
    pips_user_warning("Unknown phase \"%s\"\n", phase_n);
    ok = false;
  }
  else
  {
    CATCH(any_exception_error)
    {
      reset_make_cache();
      retrieve_active_phases();
      pips_user_warning("Request aborted in pipsmake\n");
      ok = false;
 
      if (the_last_just_thrown_exception == timeout_error)
        RETHROW();
    }
    TRY
    {
      logs_on();
      user_log("Request: capply %s for module [%s].\n", phase_n, module_list);
 
      ok = concurrent_apply(phase_n, modules);
 
      if (ok)   {
        user_log("capply %s made for [%s].\n", phase_n, module_list);
        logs_off();
      }
      else {
        pips_user_warning("Request aborted under pipsmake: "
                          "capply %s for module [%s].\n",
                          phase_n, module_list);
      }
      UNCATCH(any_exception_error);
    }
  }
 
  free(module_list);
  debug_off();
  return ok;
}

References any_exception_error, CATCH, concurrent_apply(), debug_off, debug_on, find_rule_by_phase(), free(), logs_off(), logs_on(), ok, pips_user_warning, reset_make_cache(), RETHROW, retrieve_active_phases(), rule_undefined, strdup(), string_array_join(), the_last_just_thrown_exception, timeout_error, TRY, UNCATCH, and user_log().

Referenced by capply().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_make()

bool safe_make	(	const char *	res_n,
		const char *	module_n
	)

Parameters

res_n	es_n
module_n	odule_n

Definition at line 1717 of file pipsmake.c.

{
  return safe_do_something(res_n, module_n, "resource",
                           find_rule_by_resource, make);
}

References find_rule_by_resource(), make(), and safe_do_something().

Referenced by get_callees(), get_callees_of(), get_callers(), get_callers_of(), get_view_file(), loop_pragma(), module_loops(), pips_main(), tp_set_current_module(), and try_to_parse_everything_just_in_case().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_set_property()

bool safe_set_property	(	const char *	propname,
		const char *	value
	)

Parameters

propname	ropname
value	alue

Definition at line 1781 of file pipsmake.c.

{
  size_t len = strlen(propname) + strlen(value) + 2;
  char* line = calloc(len, sizeof(char));
  strcat(line, propname);
  strcat(line, " ");
  strcat(line, value);
  user_log("set %s\n", line);
  parse_properties_string(line, false);
  free(line);
  // parse_properties_string() doesn't return whether it succeeded
  return true;
}

References free(), line, parse_properties_string(), and user_log().

Referenced by set_property().

Here is the call graph for this function:

Here is the caller graph for this function:

save_active_phases()

void save_active_phases

(

void

)

activate.c

Definition at line 49 of file activate.c.

{
  makefile current_makefile = parse_makefile();
 
  if (saved_active_phases == NIL)
    saved_active_phases =
      gen_copy_string_list(makefile_active_phases(current_makefile));
}

References gen_copy_string_list(), makefile_active_phases, NIL, parse_makefile(), and saved_active_phases.

Referenced by apply(), concurrent_apply(), and make().

Here is the call graph for this function:

Here is the caller graph for this function:

save_makefile()

void save_makefile

(

const char *

name

)

Parameters

name

ame

Definition at line 1801 of file readmakefile.c.

{
    char * mkf_name = build_pgm_makefile(name);
    FILE * fd = safe_fopen(mkf_name, "w");
    write_makefile(fd, pipsmakefile);
    safe_fclose(fd, mkf_name);
    pips_debug(1, "makefile written on %s\n", mkf_name);
    free(mkf_name);
}

Referenced by close_makefile().

Here is the caller graph for this function:

saved_active_phase_p()

bool saved_active_phase_p

(

const char *

phase

)

Debugging function.

Parameters

phase

hase

Definition at line 93 of file activate.c.

{
  list sapl = saved_active_phases;
 
  if(ENDP(sapl)) {
    fprintf(stderr, "Active phases have not been saved\n");
  }
  else {
    FOREACH(STRING, s, sapl)
      if (same_string_p(s, phase))
        return true; // new line for breakpoints
  }
 
  return false;
}

References ENDP, FOREACH, fprintf(), same_string_p, saved_active_phases, and STRING.

Here is the call graph for this function:

scheduling()

bool scheduling

(

const string

mod_name

)

=================================================================

void scheduling(mod_name ): this is the main function to calculate the schedules of the node of a dfg. It first reverse the graph to have each node in function of its predecessors, then calculates the strongly connected components by the Trajan algorithm, then calls the function that really find the schedules.

AC 93/10/30

We get the required data: module entity, code, static_control, dataflow graph, timing function.

Read the DFG

Parameters

mod_name

odule

Definition at line 133 of file scheduling.c.

{
  graph           dfg, rdfg;
  sccs            rgraph;
  bdt             bdt_list;
  entity          ent;
  statement       mod_stat;
  static_control  stco;
  statement_mapping STS;
 
  debug_on("SCHEDULING_DEBUG_LEVEL");
  if (get_debug_level() > 0)
  {
    fprintf(stderr,"\n\nBegin scheduling\n");
    fprintf(stderr,"DEBUT DU PROGRAMME\n");
    fprintf(stderr,"==================\n\n");
  }
  
  /* We get the required data: module entity, code, static_control, dataflow
   * graph, timing function.
   */
  ent = local_name_to_top_level_entity(mod_name);
  
  set_current_module_entity(ent);
  
  mod_stat = (statement)db_get_memory_resource(DBR_CODE, mod_name, true);
  STS = (statement_mapping) db_get_memory_resource(DBR_STATIC_CONTROL,
                                            mod_name, true);
  stco = (static_control) GET_STATEMENT_MAPPING(STS, mod_stat);
  
  set_current_stco_map(STS);
 
  if (stco == static_control_undefined) 
    pips_internal_error("This is an undefined static control !");
  
  if (!static_control_yes(stco)) 
    pips_internal_error("This is not a static control program !");
  
  /* Read the DFG */
  dfg = (graph)db_get_memory_resource(DBR_ADFG, mod_name, true);
  dfg = adg_pure_dfg(dfg);
  rdfg = dfg_reverse_graph(dfg);
  if (get_debug_level() > 5) fprint_dfg(stderr, rdfg);
  rgraph = dfg_find_sccs(rdfg);
  
  if (get_debug_level() > 0) fprint_sccs(stderr, rgraph);
  
  bdt_list = search_graph_bdt(rgraph);
  
  if (get_debug_level() > 0)
  {
    fprintf(stderr,"\n==============================================");
    fprintf(stderr,"\nBase de temps trouvee :\n");
    fprint_bdt_with_stat(stderr, bdt_list);
    fprintf(stderr,"\nEnd of scheduling\n");
  }
  
  DB_PUT_MEMORY_RESOURCE(DBR_BDT, strdup(mod_name), bdt_list);
  
  reset_current_stco_map();
  reset_current_module_entity();
 
  debug_off();
 
  return(true);
}

References adg_pure_dfg(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dfg, dfg_find_sccs(), dfg_reverse_graph(), fprint_bdt_with_stat(), fprint_dfg(), fprint_sccs(), fprintf(), get_debug_level(), GET_STATEMENT_MAPPING, local_name_to_top_level_entity(), mod_stat, pips_internal_error, reset_current_module_entity(), reset_current_stco_map(), search_graph_bdt(), set_current_module_entity(), set_current_stco_map(), static_control_undefined, static_control_yes, strdup(), and STS.

Here is the call graph for this function:

set_current_phase_context()

void set_current_phase_context	(	const char *	rname,
		const char *	oname
	)

cproto-generated files

pipsmake.c

Parameters

rname	name
oname	name

Definition at line 89 of file pipsmake.c.

{
  set_pips_current_computation(rname, oname);
  entity_basic_concrete_types_init();
  reset_std_static_entities();
}

References entity_basic_concrete_types_init(), reset_std_static_entities(), and set_pips_current_computation().

Referenced by callgraph(), and catch_user_error().

Here is the call graph for this function:

Here is the caller graph for this function:

set_pips_timeout()

void set_pips_timeout

(

unsigned int

delay

)

set pips timeout on delay setting to 0 removes the current timeout.

Parameters

delay

elay

Definition at line 70 of file signal.c.

{
  reset_pips_timeout();
  set_timeout_callback(pips_timeout_callback);
 
  if (delay > 0)
  {
    pips_timeout_set = true;
    PUSH_TIMEOUT(delay);
  }
}

References pips_timeout_callback(), pips_timeout_set, PUSH_TIMEOUT, reset_pips_timeout(), and set_timeout_callback().

Here is the call graph for this function:

set_pips_timeout_from_env()

void set_pips_timeout_from_env

(

void

)

set pips timeout using PIPS_TIMEOUT environment variable

Definition at line 84 of file signal.c.

{
  reset_pips_timeout();
  set_timeout_callback(pips_timeout_callback);
 
  pips_timeout_set = PUSH_TIMEOUT_ENV("PIPS_TIMEOUT");
}

References pips_timeout_callback(), pips_timeout_set, PUSH_TIMEOUT_ENV, reset_pips_timeout(), and set_timeout_callback().

Referenced by initialize_signal_catcher().

Here is the call graph for this function:

Here is the caller graph for this function:

set_pipsmake_callback()

void set_pipsmake_callback

(

pipsmake_callback_handler_type

p

)

callback.c

Definition at line 43 of file callback.c.

{
    message_assert("callback is already set", callback_set_p == false);
    
    callback_set_p = true;
    callback = p;
}

References callback, callback_set_p, and message_assert.

Referenced by gpips_main(), and wpips_main().

Here is the caller graph for this function:

unsplit()

bool unsplit

(

const string

name

)

unsplit.c

unsplit.c

Parameters

name

ame

Definition at line 185 of file unsplit.c.

{
  return unsplit_internal(name, DBR_PRINTED_FILE);
}

References unsplit_internal().

Here is the call graph for this function:

unsplit_parsed()

bool unsplit_parsed

(

const

string

)

Parameters

string

ame

Definition at line 190 of file unsplit.c.

{
  return unsplit_internal(name, DBR_PARSED_PRINTED_FILE);
}

References unsplit_internal().

Here is the call graph for this function:

yyerror()

void yyerror

(

const char *

s

)

work around cproto 4.7t issue

symbols from readmakefile.y

work around cproto 4.7t issue

symbols from readmakefile.y

work around cproto 4.7t issue

Definition at line 1927 of file genread_yacc.c.

{
  int c, n=40;
  newgen_lexer_position(stderr);
  fprintf(stderr, "%s before ", s);
 
  while (n-->0  && ((c=genread_input()) != EOF))
    putc(c, stderr);
 
  fprintf(stderr, "\n\n");
 
  fatal("Incorrect object written by GEN_WRITE\n", (char *) NULL);
}

yyerror_lex_part()

void yyerror_lex_part

(

const char *

)

yywrap()

int yywrap

(

void

)

symbols form lexer.l

Variable Documentation

pipsmake__flex_debug

int pipsmake__flex_debug

extern

pipsmake_char

int pipsmake_char

extern

readmakefile.c

pipsmake_in

FILE* pipsmake_in

extern

Definition at line 142 of file pipsmake.h.

pipsmake_leng

int pipsmake_leng

extern

lexer.c

pipsmake_lineno

int pipsmake_lineno

extern

pipsmake_nerrs

int pipsmake_nerrs

extern

pipsmake_out

FILE* pipsmake_out

extern

pipsmake_text

char* pipsmake_text

extern