task_parallelization.h File Reference

#include "task_private.h"
#include "dg.h"
#include "graph.h"

Include dependency graph for task_parallelization.h:

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

Go to the source code of this file.

Data Structures
struct	annotation
struct	cluster

Macros
#define	MPI_COMM_WORLD_STRING   "MPI_COMM_WORLD"
#define	MPI_GENERATION_NBR_CLUSTER   "MPI_NBR_CLUSTER"
#define	MPI_GENERATION_PREFIX   "MPI_DUPLICATE_VARIABLE_PREFIX"
#define	MPI_GENERATION_PRIVATE_VARIABLES_LIST   "MPI_PRIVATE_VARIABLES_LIST"
#define	MPI_GENERATION_PRIVATE_PARAMETER   "MPI_PRIVATE_PARAMETER"
#define	COMMENT_VARIABLE_REPLICATION   " Generated by Pass VARIABLE_REPLICATION\n"
#define	COMMENT_COPY_VARIABLE   " Generated by Pass COPY_VARIABLE\n"
#define	COMMENT_MPI_CONVERSION   " Generated by Pass MPI_CONVERSION\n"

Typedefs
typedef dg_arc_label	arc_label
	Warning! Do not modify this file that is automatically generated! More...
typedef dg_vertex_label	vertex_label

Functions
_Bool	statement_equal_p (statement, statement)
vertex	statement_to_vertex (statement, graph)
graph	partitioning_sdg (statement)
void	print_SDGs (statement, graph, FILE *, gen_array_t)
_Bool	sequence_dependence_graph (char *)
_Bool	costly_task (statement)
	cost_model.c More...
double	polynomial_to_numerical (Ppolynome)
double	size_of_regions (list)
double	edge_cost (statement, statement)
double	t_level (vertex, graph, gen_array_t)
	First parameter is the top level (earliest start time) for each node. More...
void	top_level (graph, gen_array_t)
void	bottom_level (graph, gen_array_t)
	Second parameter is the bottom level (latest start time) for each node. More...
void	priorities (gen_array_t)
void	initialization (graph, gen_array_t)
void	parse_instrumented_file (char *, graph, gen_array_t)
void	allocate_task_to_cluster (statement, int, int)
	BDSC.c. More...
int	BDSC (sequence, int, int, int)
int	DSC (sequence, int)
list	topological_sort (statement)
int	hierarchical_schedule (statement, int, int, int, _Bool)
_Bool	hbdsc_parallelization (char *)
	he main function for performing the hierarchical scheduling (scheduled SDG) using BDSC and generating the graph (unstructured) BDSC-based top-down hierarchical scheduling More...
_Bool	dsc_code_parallelization (char *)
	he main function for performing the hierarchical scheduling (scheduled SDG) using DSC and generating SPIRE More...
_Bool	bdsc_code_instrumentation (char *)
	instrumentation.c More...
void	cluster_stage_spire_generation (persistant_statement_to_cluster, graph, statement, int)
	he main function More...
_Bool	spire_shared_unstructured_to_structured (char *)
_Bool	spire_distributed_unstructured_to_structured (char *)
statement	make_com_loopbody (entity, _Bool, list, int)
	communication_generation.c More...
statement	region_to_com_nest (effect, _Bool, int)
void	communications_construction (graph, statement, persistant_statement_to_cluster, int)
_Bool	openmp_task_generation (char *)
	openmp_generation.c More...
_Bool	mpi_task_generation (char *)
	mpi_generation.c More...
bool	parallel_task_mapping_undefined_p (void)
	task_mapping.c More...
void	reset_parallel_task_mapping (void)
void	error_reset_parallel_task_mapping (void)
void	set_parallel_task_mapping (statement_task)
statement_task	get_parallel_task_mapping (void)
void	init_parallel_task_mapping (void)
void	close_parallel_task_mapping (void)
void	store_parallel_task_mapping (statement, task)
void	update_parallel_task_mapping (statement, task)
task	load_parallel_task_mapping (statement)
task	delete_parallel_task_mapping (statement)
bool	bound_parallel_task_mapping_p (statement)
void	store_or_update_parallel_task_mapping (statement, task)
void	print_task (task)
	Pass: TASK_MAPPING Debug mode: MPI_GENERATION_DEBUG_LEVEL Resource generated: More...
string	task_to_string (task, bool)
bool	task_mapping (const char *)
	PIPS pass. More...
bool	copy_value_of_write (const char *)
	copy_value_of_write.c More...
bool	copy_value_of_write_with_cumulated_regions (const char *)
	PIPS pass. More...
bool	variable_replication (const char *)
	variable_replication.c More...
bool	eliminate_original_variables (const char *)
	eliminate_original_variables.c More...
bool	mpi_conversion (const char *)
	mpi_conversion.c More...

Variables
int	NBCLUSTERS
	cproto-generated files More...
int	MEMORY_SIZE
string	INSTRUMENTED_FILE
gen_array_t	annotations
	Global variables. More...
gen_array_t	clusters
graph	kdg
	HBDSC.c. More...
graph	ddg
statement	return_st
persistant_statement_to_cluster	stmt_to_cluster
list	com_declarations_to_add
	spire_generation.c More...

Macro Definition Documentation

COMMENT_COPY_VARIABLE

#define COMMENT_COPY_VARIABLE   " Generated by Pass COPY_VARIABLE\n"

Definition at line 47 of file task_parallelization.h.

COMMENT_MPI_CONVERSION

#define COMMENT_MPI_CONVERSION   " Generated by Pass MPI_CONVERSION\n"

Definition at line 48 of file task_parallelization.h.

COMMENT_VARIABLE_REPLICATION

#define COMMENT_VARIABLE_REPLICATION   " Generated by Pass VARIABLE_REPLICATION\n"

Definition at line 46 of file task_parallelization.h.

MPI_COMM_WORLD_STRING

#define MPI_COMM_WORLD_STRING   "MPI_COMM_WORLD"

Definition at line 38 of file task_parallelization.h.

MPI_GENERATION_NBR_CLUSTER

#define MPI_GENERATION_NBR_CLUSTER   "MPI_NBR_CLUSTER"

Definition at line 40 of file task_parallelization.h.

MPI_GENERATION_PREFIX

#define MPI_GENERATION_PREFIX   "MPI_DUPLICATE_VARIABLE_PREFIX"

Definition at line 41 of file task_parallelization.h.

MPI_GENERATION_PRIVATE_PARAMETER

#define MPI_GENERATION_PRIVATE_PARAMETER   "MPI_PRIVATE_PARAMETER"

Definition at line 44 of file task_parallelization.h.

MPI_GENERATION_PRIVATE_VARIABLES_LIST

#define MPI_GENERATION_PRIVATE_VARIABLES_LIST   "MPI_PRIVATE_VARIABLES_LIST"

Definition at line 43 of file task_parallelization.h.

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

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

Modify src/Libs/task_parallelization/task_parallelization-local.h instead, to add your own modifications. header file built by cproto task_parallelization-local.h Instantiation of the dependence graph:

Definition at line 15 of file task_parallelization.h.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 16 of file task_parallelization.h.

Function Documentation

allocate_task_to_cluster()

void allocate_task_to_cluster	(	statement	ready_st,
		int	cl_p,
		int	order
	)

BDSC.c.

Parameters

ready_st	eady_st
cl_p	l_p
order	rder

Definition at line 100 of file BDSC.c.

                                                                      {
  annotation *an = gen_array_item(annotations, (int)statement_ordering(ready_st));
  list vertices = graph_vertices(kdg);
  an->scheduled = true;
  an->order_sched = order;
  an->cluster = cl_p;
  if(!bound_persistant_statement_to_cluster_p(stmt_to_cluster, statement_ordering(ready_st)))
    extend_persistant_statement_to_cluster(stmt_to_cluster, statement_ordering(ready_st), cl_p);
  else
    update_persistant_statement_to_cluster(stmt_to_cluster, statement_ordering(ready_st), cl_p);
  //delete ready_st from successors(tasks(cl_p))
  FOREACH(VERTEX, pre, vertices) {
    statement parent = vertex_to_statement(pre);
    annotation *anp = gen_array_item(annotations, (int)statement_ordering(parent));
    if(anp->cluster == cl_p)
      { 
        FOREACH(SUCCESSOR, su, (vertex_successors(pre))) {
          vertex v = successor_vertex(su);
          statement child = vertex_to_statement(v);
          if(statement_equal_p(child, ready_st)){
            double *ec = (double *)malloc(sizeof(double));
            *ec = 0;
            gen_array_addto(anp->edge_cost,(int)statement_ordering(ready_st), ec);
            gen_array_addto(annotations, (int)statement_ordering(parent), anp); 
          }
        }
      }
  }
 
  cluster *cl = gen_array_item(clusters, cl_p);
  double time = cl->time;
  double time1 = (time > an->tlevel) ? (time + an->task_time) : (an->tlevel + an->task_time);
  cl->time = time1;
  if(gen_length(vertex_successors(statement_to_vertex(ready_st,kdg)))> 0){
    list l_data = RegionsMustUnion(regions_dup(an->data), regions_dup(cl->data), r_w_combinable_p);
    cl->data = l_data;
  }
  gen_array_addto(clusters, cl_p, cl); 
  update_priority_values(ready_st);
  return;
}

References annotations, bound_persistant_statement_to_cluster_p(), annotation::cluster, clusters, annotation::data, cluster::data, annotation::edge_cost, extend_persistant_statement_to_cluster(), FOREACH, gen_array_addto(), gen_array_item(), gen_length(), graph_vertices, kdg, malloc(), annotation::order_sched, r_w_combinable_p(), regions_dup(), RegionsMustUnion(), annotation::scheduled, statement_equal_p(), statement_ordering, statement_to_vertex(), stmt_to_cluster, SUCCESSOR, successor_vertex, annotation::task_time, cluster::time, annotation::tlevel, update_persistant_statement_to_cluster(), update_priority_values(), VERTEX, vertex_successors, and vertex_to_statement().

Referenced by BDSC(), DSC(), DSRW(), find_cluster(), hierarchical_schedule(), and zeroing_multiple_edges().

Here is the call graph for this function:

Here is the caller graph for this function:

BDSC()

int BDSC	(	sequence	seq,
		int	P,
		int	M,
		int	ordering
	)

canf instruction should be scheduled in the master cluster (by convention 0)

f(get_bool_property("BDSC_DISTRIBUTED_MEMORY")) zeroing_p = zeroing_multiple_edges(ready_task, order,M); function Not validated else

Parameters

seq	eq
ordering	rdering

Definition at line 535 of file BDSC.c.

                                                   {
  if(P <= 0)
    return 0;
  int nbclusters = 0;
  int order = 0, cl_p = -1;
  list unscheduled_tasks = NIL;
  list ready_tasks = NIL, unready_tasks = NIL;
  list stmts = sequence_statements(seq);
  statement ready_task = statement_undefined, unready_task = statement_undefined;
  gen_array_t annotations_s = schedule_failsafe();
  bool other_rules_p = false, scanf_p = false; 
  initialization_clusters(false);
  top_level(kdg, annotations);
  bottom_level(kdg, annotations);
  priorities(annotations);
  FOREACH(statement, st, stmts){
    if(!declaration_statement_p(st)) {
      unscheduled_tasks = CONS(STATEMENT, st, unscheduled_tasks);
      if(ready_node(st))
        ready_tasks = CONS(STATEMENT, st, ready_tasks);
      else
        unready_tasks = CONS(STATEMENT, st, unready_tasks);
    }
  }
  while(gen_length(unscheduled_tasks) > 0 ){
    ready_task = select_task_with_highest_priority(ready_tasks, statement_undefined);
    unready_task = select_task_with_highest_priority(unready_tasks, ready_task);
    other_rules_p = false, scanf_p = false; 
    if(statement_call_p(ready_task)){
      entity f = call_function(statement_call(ready_task));
      if(ENTITY_SCANF_P(f) || ENTITY_FSCANF_P(f) || ENTITY_SSCANF_P(f) 
         || ENTITY_ISOC99_FSCANF_P(f)|| ENTITY_ISOC99_SSCANF_P(f) || ENTITY_ISOC99_SCANF_P(f)) 
        scanf_p = true;
    }
    if(scanf_p){
      /*scanf instruction should be scheduled in the master cluster
        (by convention 0)*/
    allocate_task_to_cluster(ready_task, 0, order);
      if(nbclusters == 0) 
        nbclusters ++;
    }
    else{
      if(statement_undefined_p(unready_task)){
        cl_p = -1;
        statement min_pred = ready_task;
        bool zeroing_p = true;
        /*if(get_bool_property("BDSC_DISTRIBUTED_MEMORY")) 
          zeroing_p = zeroing_multiple_edges(ready_task, order,M);
          //function Not validated
          else*/
        {
          min_start_time min_pred_s =  tlevel_decrease(ready_task,M);
          min_pred =  min_pred_s.min_tau; 
          if(min_pred != statement_undefined)
            {
              annotation *anp = gen_array_item(annotations, (int)statement_ordering(min_pred));
              cl_p = anp->cluster;
              allocate_task_to_cluster(ready_task,cl_p, order);
            }
        }
        if(min_pred == statement_undefined || !zeroing_p)
          other_rules_p = true;
      }
      else {
        other_rules_p = DSRW(ready_task, unready_task,order,M);
      }
      if(other_rules_p)
        nbclusters = find_cluster(ready_task, nbclusters, P, M, order, stmts, annotations_s);
      if(nbclusters == -1)//not enough memorry
        return -1;
    }
    gen_remove_once(&unscheduled_tasks, ready_task);
    FOREACH(statement, st, unready_tasks){
      if(ready_node(st))
        gen_remove_once(&unready_tasks, st);
    }
    ready_tasks = NIL; 
    FOREACH(statement, st, unscheduled_tasks) {
      if(ready_node(st))
        ready_tasks = CONS(STATEMENT, st, ready_tasks);
    }
    order ++;
  }
  gen_array_free(annotations_s);
  update_parallel_task(ordering, nbclusters);
  return nbclusters;
}

References allocate_task_to_cluster(), annotations, bottom_level(), call_function, annotation::cluster, CONS, declaration_statement_p(), DSRW(), ENTITY_FSCANF_P, ENTITY_ISOC99_FSCANF_P, ENTITY_ISOC99_SCANF_P, ENTITY_ISOC99_SSCANF_P, ENTITY_SCANF_P, ENTITY_SSCANF_P, f(), find_cluster(), FOREACH, gen_array_free(), gen_array_item(), gen_length(), gen_remove_once(), initialization_clusters(), kdg, min_start_time::min_tau, NIL, priorities(), ready_node(), schedule_failsafe(), select_task_with_highest_priority(), sequence_statements, STATEMENT, statement_call(), statement_call_p(), statement_ordering, statement_undefined, statement_undefined_p, tlevel_decrease(), top_level(), and update_parallel_task().

Referenced by hierarchical_schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

bdsc_code_instrumentation()

_Bool bdsc_code_instrumentation

(

char *

module_name

)

instrumentation.c

The proper effect to detect the I/O operations:

omplexities (task processing time)

irst step is to cumulate dependences hierarchically (between sequences) on granularities : loop, test and simple instruction

Reorder the module, because new statements have been generated.

Parameters

module_name

odule_name

Definition at line 141 of file instrumentation.c.

{ 
  statement module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
  set_ordering_to_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement(module_stat);
  set_precondition_map((statement_mapping)db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
  set_transformer_map((statement_mapping)
                      db_get_memory_resource(DBR_TRANSFORMERS, module_name, true));
  /* The proper effect to detect the I/O operations: */
  set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
   set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  module_to_value_mappings(get_current_module_entity());
  set_rw_effects((statement_effects) 
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_methods_for_convex_effects();
  init_convex_rw_prettyprint(module_name);
 
  kdg = (graph) db_get_memory_resource (DBR_SDG, module_name, true );
  
  /*Complexities (task processing time)*/
  set_complexity_map( (statement_mapping) db_get_memory_resource(DBR_COMPLEXITIES, module_name, true));
 
  /*first step is to cumulate dependences hierarchically (between
    sequences) on granularities : loop, test and simple instruction*/
  list vertices = graph_vertices(kdg);
  FOREACH(VERTEX, v, vertices){
    statement stmt = vertex_to_statement(v);
    if(!declaration_statement_p(stmt)) {
      task_time_polynome(stmt);
      FOREACH(SUCCESSOR, su, (vertex_successors(statement_to_vertex(stmt, kdg)))) {
        vertex s = successor_vertex(su);
        statement child = vertex_to_statement(s);
        edge_cost_polynome(stmt,child);
      }
    }
  }
  /* Reorder the module, because new statements have been generated. */
  module_reorder(module_stat);
  gen_consistent_p((gen_chunk*)module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_stat);
  reset_proper_rw_effects();
  reset_cumulated_rw_effects();
  reset_rw_effects();
  reset_precondition_map();
  reset_transformer_map();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_ordering_to_statement();
  reset_complexity_map();
  free_value_mappings();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, declaration_statement_p(), edge_cost_polynome(), FOREACH, free_value_mappings(), gen_consistent_p(), get_current_module_entity(), graph_vertices, init_convex_rw_prettyprint(), kdg, module_name(), module_name_to_entity(), module_reorder(), module_to_value_mappings(), reset_complexity_map(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_precondition_map(), reset_proper_rw_effects(), reset_rw_effects(), reset_transformer_map(), set_complexity_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_methods_for_convex_effects(), set_ordering_to_statement(), set_precondition_map(), set_proper_rw_effects(), set_rw_effects(), set_transformer_map(), statement_to_vertex(), strdup(), SUCCESSOR, successor_vertex, task_time_polynome(), VERTEX, vertex_successors, and vertex_to_statement().

Here is the call graph for this function:

bottom_level()

void bottom_level	(	graph	dg,
		gen_array_t	annotations
	)

Second parameter is the bottom level (latest start time) for each node.

Parameters

dg	g
annotations	nnotations

Definition at line 223 of file cost_model.c.

{
  double max, level;
  list vertices = (graph_vertices(dg));
  annotation *an, *anp;
  FOREACH(VERTEX, v, vertices) {
    max = 0;
    statement sv = vertex_to_statement(v);
    FOREACH(VERTEX, pre, (graph_vertices(dg))) {
      statement parent = vertex_to_statement(pre);
      anp = gen_array_item(annotations, (int)statement_ordering(parent));
      FOREACH(SUCCESSOR, su, (vertex_successors(pre))) {
        vertex s = successor_vertex(su);
        statement child = vertex_to_statement(s);
        if(statement_equal_p(child, sv) && gen_array_item(annotations, (int)statement_ordering(parent)) )
          {
            double edge_c = *(double *)(gen_array_item(anp->edge_cost,statement_ordering(sv)));
            level = anp->blevel + edge_c;
            if(level > max)
              max = level;
          }
      }
    }
    an = gen_array_item(annotations, statement_ordering(sv));
    an->blevel = an->task_time + max;
    gen_array_addto(annotations, (int)statement_ordering(sv), an);
  }
  return;
}

References annotations, annotation::blevel, dg, annotation::edge_cost, FOREACH, gen_array_addto(), gen_array_item(), graph_vertices, level, max, statement_equal_p(), statement_ordering, SUCCESSOR, successor_vertex, annotation::task_time, VERTEX, vertex_successors, and vertex_to_statement().

Referenced by BDSC(), and DSC().

Here is the call graph for this function:

Here is the caller graph for this function:

bound_parallel_task_mapping_p()

bool bound_parallel_task_mapping_p

(

statement

)

close_parallel_task_mapping()

void close_parallel_task_mapping

(

void

)

cluster_stage_spire_generation()

void cluster_stage_spire_generation	(	persistant_statement_to_cluster	stmt_to_cluster,
		graph	tg,
		statement	stmt,
		int	P
	)

he main function

Parameters

stmt_to_cluster	tmt_to_cluster
tg	g
stmt	tmt

Definition at line 120 of file spire_generation.c.

{
  gen_consistent_p((gen_chunk*)stmt);
  if(!get_bool_property("COSTLY_TASKS_ONLY") | costly_task(stmt)){ 
    statement st_finish = statement_undefined;
    instruction inst = statement_instruction(stmt);
    switch(instruction_tag(inst)){
    case is_instruction_block:{
      list cluster_stages = topological_sort(stmt);
      list list_cl = NIL;
      FOREACH(LIST, cluster_stage, cluster_stages) {
        st_finish = cluster_stage_spire(stmt_to_cluster, tg, cluster_stage, P);
        gen_consistent_p((gen_chunk*)st_finish);
        list_cl = CONS(STATEMENT, st_finish, list_cl);
      }
      instruction ins_seq = make_instruction_sequence(make_sequence(gen_nreverse(list_cl)));
      statement_instruction(stmt) = ins_seq;
      FOREACH(ENTITY, decl, gen_nreverse(statement_declarations(stmt))) 
        add_declaration_statement_at_beginning(stmt, decl);
      gen_free_list(cluster_stages);
      break;
    }
    case is_instruction_test:{
      test t = instruction_test(inst);
      cluster_stage_spire_generation(stmt_to_cluster, tg, test_true(t), P);
      cluster_stage_spire_generation(stmt_to_cluster, tg, test_false(t), P);
      break;
    }
    case is_instruction_loop :{
      loop l = statement_loop(stmt);
      statement body = loop_body(l);
      cluster_stage_spire_generation(stmt_to_cluster, tg, body, P);
      break;
    }
    default:
      break;
    }
  }
  gen_consistent_p((gen_chunk*)stmt);
  return;
}

References add_declaration_statement_at_beginning(), cluster_stage_spire(), CONS, costly_task(), ENTITY, FOREACH, gen_consistent_p(), gen_free_list(), gen_nreverse(), get_bool_property(), instruction_tag, instruction_test, is_instruction_block, is_instruction_loop, is_instruction_test, LIST, loop_body, make_instruction_sequence(), make_sequence(), NIL, STATEMENT, statement_declarations, statement_instruction, statement_loop(), statement_undefined, stmt_to_cluster, test_false, test_true, and topological_sort().

Referenced by cluster_stage_spire(), spire_distributed_unstructured_to_structured(), and spire_shared_unstructured_to_structured().

Here is the call graph for this function:

Here is the caller graph for this function:

communications_construction()

void communications_construction	(	graph	tg,
		statement	stmt,
		persistant_statement_to_cluster	st_to_cluster,
		int	kp
	)

Parameters

tg	g
stmt	tmt
st_to_cluster	t_to_cluster
kp	p

Definition at line 337 of file communication_generation.c.

{
  if(bound_persistant_statement_to_cluster_p(st_to_cluster, statement_ordering(stmt))) {
    gen_consistent_p((gen_chunk*)stmt);
    instruction inst = statement_instruction(stmt);
    switch(instruction_tag(inst)){
    case is_instruction_block:{
      list vertices = graph_vertices(tg), coms_send = NIL, coms_recv = NIL, coms_st = NIL; 
      list barrier = NIL;
      MAPL(stmt_ptr,
           {
             statement ss = STATEMENT(CAR(stmt_ptr ));
             if(statement_block_p(ss)){
               instruction sinst = statement_instruction(ss);
               MAPL(sb_ptr,
                    {
                      statement sb = STATEMENT(CAR(sb_ptr ));
                      if(statement_block_p(sb)){
                        instruction sbinst = statement_instruction(sb);
                        MAPL(ss_ptr,
                             {
                               statement s = STATEMENT(CAR(ss_ptr ));
                               barrier = CONS(STATEMENT,s,barrier);
                             },
                             instruction_block(sbinst));
                      }
                    else
                      barrier = CONS(STATEMENT,sb,barrier);
                    },
                    instruction_block(sinst));
             }
             else
               barrier = CONS(STATEMENT,ss,barrier);
           },
         instruction_block(inst));
      FOREACH(STATEMENT, s, barrier)
        {
          bool found_p = false;
          FOREACH(VERTEX, pre, vertices) {
            statement this = vertex_to_statement(pre);
            if(statement_equal_p(this,s) && bound_persistant_statement_to_cluster_p(st_to_cluster, statement_ordering(s))) {
              found_p = true;
              break;
            }
          }
          if(found_p){
            int ki = apply_persistant_statement_to_cluster(st_to_cluster, statement_ordering(s));
          list args_send =  gen_recv_communications(s, st_to_cluster, tg, kp);
          list args_recv =  gen_send_communications(s, statement_to_vertex(s,tg), st_to_cluster, kp);
          if(gen_length(args_recv) > 0 && (kp != ki) )
            coms_recv = CONS(STATEMENT, com_call(PREDECESSORS, args_recv, ki), coms_recv);
          if(gen_length(args_send) > 0 && (kp != ki) )
            coms_send = CONS(STATEMENT, com_call(SUCCESSORS, args_send, ki), coms_send);
          communications_construction(tg, s, st_to_cluster,  ki);
          }
          else
            communications_construction(tg, s, st_to_cluster, kp);
        }
    if((gen_length(coms_send) > 0 || gen_length(coms_recv) > 0) && (kp != -1)){
      statement new_s = make_statement(
                                       statement_label(stmt),
                                       STATEMENT_NUMBER_UNDEFINED,
                                       STATEMENT_ORDERING_UNDEFINED,
                                       statement_comments(stmt),
                                       statement_instruction(stmt),
                                       NIL, NULL, statement_extensions(stmt), statement_synchronization(stmt));
      if(gen_length(coms_recv) > 0){
        FOREACH(STATEMENT, st, coms_recv){
          coms_st = CONS(STATEMENT, st, coms_st);
        }
      }
      coms_st = CONS(STATEMENT, new_s, coms_st);
      if(gen_length(coms_send) > 0){
        FOREACH(STATEMENT, st, coms_send){
          coms_st = CONS(STATEMENT, st, coms_st);
        }
      }
      instruction seq = make_instruction_sequence(make_sequence((coms_st)));
      statement_instruction(stmt) = seq;
      statement_extensions(stmt) = empty_extensions();
      statement_synchronization(stmt) = make_synchronization_none();
      statement_comments(stmt) = empty_comments;
    }
    break;
    }
    case is_instruction_test:{
      test t = instruction_test(inst);
      communications_construction(tg, test_true(t), st_to_cluster, kp);
      communications_construction(tg, test_false(t), st_to_cluster, kp);
    break;
    }
  case is_instruction_loop :{
    loop l = statement_loop(stmt);
    statement body = loop_body(l);
    communications_construction(tg, body, st_to_cluster, kp);
    break;
  }
    default:
    break;
    }
  }
  return;
}

References apply_persistant_statement_to_cluster(), bound_persistant_statement_to_cluster_p(), CAR, com_call(), CONS, empty_comments, empty_extensions(), FOREACH, gen_consistent_p(), gen_length(), gen_recv_communications(), gen_send_communications(), graph_vertices, instruction_block, instruction_tag, instruction_test, is_instruction_block, is_instruction_loop, is_instruction_test, loop_body, make_instruction_sequence(), make_sequence(), make_statement(), make_synchronization_none(), MAPL, NIL, PREDECESSORS, STATEMENT, statement_block_p, statement_comments, statement_equal_p(), statement_extensions, statement_instruction, statement_label, statement_loop(), STATEMENT_NUMBER_UNDEFINED, statement_ordering, STATEMENT_ORDERING_UNDEFINED, statement_synchronization, statement_to_vertex(), SUCCESSORS, test_false, test_true, VERTEX, and vertex_to_statement().

Referenced by spire_distributed_unstructured_to_structured().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_value_of_write()

bool copy_value_of_write

(

const char *

module_name

)

copy_value_of_write.c

copy_value_of_write.c

Reorder the module, because some statements have been added. Well, the order on the remaining statements should be the same, but by reordering the statements, the number are consecutive. Just for pretty print... :-)

Parameters

module_name

odule_name

Definition at line 542 of file copy_value_of_write.c.

                                                  {
  statement module_statement;
  bool good_result_p = true;
 
  debug_on("MPI_GENERATION_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  //-- configure environment --//
  set_current_module_entity(module_name_to_entity(module_name));
 
  set_current_module_statement( (statement)
      db_get_memory_resource(DBR_CODE, module_name, true) );
  module_statement = get_current_module_statement();
 
  pips_assert("Statement should be OK before...",
      statement_consistent_p(module_statement));
 
  set_ordering_to_statement(module_statement);
 
  //-- get dependencies --//
//  if(use_points_to) {
//    set_pointer_info_kind(with_points_to); //enough?
//  }
  set_proper_rw_effects((statement_effects)
      db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  set_cumulated_rw_effects((statement_effects)
      db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  set_parallel_task_mapping((statement_task)
      db_get_memory_resource(DBR_TASK, module_name, true));
 
 
  //-- Make the job -- //
  gen_recurse(module_statement, statement_domain, gen_true, copy_write_statement);
//  gen_recurse(module_statement, statement_domain, copy_write_statement, gen_true);
//  if(use_points_to) {
//    //TODO
//    //gen_recurse(module_statement, statement_domain, gen_true, identity_statement_remove_with_points_to);
//  }
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  // Removed useless block created by the insert_statement
  unspaghettify_statement(module_statement);
 
  /* Reorder the module, because some statements have been added.
     Well, the order on the remaining statements should be the same,
     but by reordering the statements, the number are consecutive. Just
     for pretty print... :-) */
  module_reorder(module_statement);
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  //-- Save modified code to database --//
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
  DB_PUT_MEMORY_RESOURCE(DBR_TASK, module_name, get_parallel_task_mapping());
 
  reset_ordering_to_statement();
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_parallel_task_mapping();
 
  pips_debug(1, "end\n");
  debug_off();
 
  return (good_result_p);
}

References copy_write_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), get_current_module_statement(), get_parallel_task_mapping(), module_name(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, pips_debug, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_parallel_task_mapping(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_parallel_task_mapping(), set_proper_rw_effects(), statement_consistent_p(), statement_domain, strdup(), and unspaghettify_statement().

Here is the call graph for this function:

copy_value_of_write_with_cumulated_regions()

bool copy_value_of_write_with_cumulated_regions

(

const char *

module_name

)

PIPS pass.

Reorder the module, because some statements have been added. Well, the order on the remaining statements should be the same, but by reordering the statements, the number are consecutive. Just for pretty print... :-)

Parameters

module_name

odule_name

Definition at line 806 of file copy_value_of_write.c.

                                                                         {
  statement module_statement;
  bool good_result_p = true;
 
  debug_on("MPI_GENERATION_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  //-- configure environment --//
  set_current_module_entity(module_name_to_entity(module_name));
 
  set_current_module_statement( (statement)
      db_get_memory_resource(DBR_CODE, module_name, true) );
  module_statement = get_current_module_statement();
 
  pips_assert("Statement should be OK before...",
      statement_consistent_p(module_statement));
 
  set_ordering_to_statement(module_statement);
 
  //-- get dependencies --//
//  if(use_points_to) {
//    set_pointer_info_kind(with_points_to); //enough?
//  }
  set_proper_rw_effects((statement_effects)
      db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  set_cumulated_rw_effects((statement_effects)
      db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  set_live_out_regions((statement_effects)
  //set_out_effects((statement_effects)
      db_get_memory_resource(DBR_LIVE_OUT_REGIONS, module_name, true));
  set_parallel_task_mapping((statement_task)
      db_get_memory_resource(DBR_TASK, module_name, true));
 
 
  //-- Make the job -- //
  //No gen_recurse, only want to work on statement on the first level of the function
  copy_write_statement_with_cumulated_regions(module_statement);
//  gen_recurse(module_statement, statement_domain, gen_true, copy_write_statement_with_cumulated_regions);
//  if(use_points_to) {
//    //TODO
//    //gen_recurse(module_statement, statement_domain, gen_true, copy_write_statement_with_cumulated_regions);
//  }
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  // Removed useless block created by the insert_statement
  unspaghettify_statement(module_statement);
 
  /* Reorder the module, because some statements have been added.
     Well, the order on the remaining statements should be the same,
     but by reordering the statements, the number are consecutive. Just
     for pretty print... :-) */
  module_reorder(module_statement);
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  //-- Save modified code to database --//
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
 
  reset_ordering_to_statement();
  reset_proper_rw_effects();
  reset_cumulated_rw_effects();
  reset_live_out_regions();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_parallel_task_mapping();
 
  pips_debug(1, "end\n");
  debug_off();
 
  return (good_result_p);
}

References copy_write_statement_with_cumulated_regions(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, pips_debug, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_live_out_regions(), reset_ordering_to_statement(), reset_parallel_task_mapping(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_live_out_regions(), set_ordering_to_statement(), set_parallel_task_mapping(), set_proper_rw_effects(), statement_consistent_p(), strdup(), and unspaghettify_statement().

Here is the call graph for this function:

costly_task()

_Bool costly_task

(

statement

st

)

cost_model.c

Parameters

st

t

Definition at line 52 of file cost_model.c.

                              {
  bool costly_p = false;
  instruction inst = statement_instruction(st);
  if (statement_contains_user_call_p(st))
    return true;
  else{
    switch(instruction_tag(inst)){
    case is_instruction_block:{
      MAPL( stmt_ptr,
            {
              statement local_stmt = STATEMENT(CAR(stmt_ptr ));
              costly_p = costly_p || costly_task(local_stmt);
            },
            instruction_block(inst));
      return costly_p;
      break;
    }
    case is_instruction_test :{
      test t = instruction_test(inst);
      return costly_task(test_true(t)) ||
        costly_task(test_false(t));
      break;
    }
    case is_instruction_loop :{
      return true;
    }
    case is_instruction_forloop :{
      return true;
    }
    case is_instruction_whileloop :{
      return true;
    }
    case is_instruction_call:{
      return user_call_p(statement_call(st));
    }
    default:
      return false;
    }
  }
}

References CAR, instruction_block, instruction_tag, instruction_test, is_instruction_block, is_instruction_call, is_instruction_forloop, is_instruction_loop, is_instruction_test, is_instruction_whileloop, MAPL, STATEMENT, statement_call(), statement_contains_user_call_p(), statement_instruction, test_false, test_true, and user_call_p().

Referenced by cluster_stage_spire(), cluster_stage_spire_generation(), hierarchical_schedule(), and hierarchical_schedule_step().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_parallel_task_mapping()

task delete_parallel_task_mapping

(

statement

)

DSC()

int DSC	(	sequence	seq,
		int	ordering
	)

Parameters

seq	eq
ordering	rdering

Definition at line 623 of file BDSC.c.

                                    {
  int M = -1;
  int nbclusters = 0;
  int order = 0, cl_p = -1;
  list unscheduled_tasks = NIL;
  list ready_tasks = NIL, unready_tasks = NIL;
  list stmts = sequence_statements(seq);
  statement ready_task = statement_undefined, unready_task = statement_undefined;
  gen_array_t annotations_s = schedule_failsafe();
  bool other_rules_p = false; 
  top_level(kdg, annotations);
  bottom_level(kdg, annotations);
  priorities(annotations);
  FOREACH(statement, st, stmts){
    unscheduled_tasks = CONS(STATEMENT, st, unscheduled_tasks);
    if(ready_node(st))
      ready_tasks = CONS(STATEMENT, st, ready_tasks);
    else
      unready_tasks = CONS(STATEMENT, st, unready_tasks);
  }
  while(gen_length(unscheduled_tasks) > 0 ){
    ready_task = select_task_with_highest_priority(ready_tasks, statement_undefined);
    unready_task = select_task_with_highest_priority(unready_tasks, ready_task);
    other_rules_p = false; 
    if(statement_undefined_p(unready_task)){
      cl_p = -1;
      statement min_pred = ready_task;
      bool zeroing_p = true;
      if(get_bool_property("BDSC_DISTRIBUTED_MEMORY")) 
        zeroing_p = zeroing_multiple_edges(ready_task, order,M);
      else
        {
          min_start_time min_pred_s =  tlevel_decrease(ready_task,M);
          min_pred =  min_pred_s.min_tau; 
          if(min_pred != statement_undefined)
            {
              annotation *anp = gen_array_item(annotations, (int)statement_ordering(min_pred));
              cl_p = anp->cluster;
                allocate_task_to_cluster(ready_task,cl_p, order);
            }
        }
      if(min_pred == statement_undefined || !zeroing_p)
        other_rules_p = true;
    }
    else {
      other_rules_p = DSRW(ready_task, unready_task,order,M);
    }
    if(other_rules_p){
      cluster *cl_s = (cluster *)malloc(sizeof(cluster));
      cl_s->time = 0;
      cl_s->data = NIL;
      int i = nbclusters++;
      gen_array_addto(clusters, i, cl_s);
      allocate_task_to_cluster(ready_task, i, order);
    }
    gen_remove_once(&unscheduled_tasks, ready_task);
    FOREACH(statement, st, unready_tasks){
      if(ready_node(st))
        gen_remove_once(&unready_tasks, st);
    }
    ready_tasks = NIL; 
    FOREACH(statement, st, unscheduled_tasks) {
      if(ready_node(st))
        ready_tasks = CONS(STATEMENT, st, ready_tasks);
    }
    order ++;
  }
  gen_array_free(annotations_s);
  update_parallel_task(ordering, nbclusters);
  return nbclusters;
}

References allocate_task_to_cluster(), annotations, bottom_level(), annotation::cluster, clusters, CONS, cluster::data, DSRW(), FOREACH, gen_array_addto(), gen_array_free(), gen_array_item(), gen_length(), gen_remove_once(), get_bool_property(), kdg, malloc(), min_start_time::min_tau, NIL, priorities(), ready_node(), schedule_failsafe(), select_task_with_highest_priority(), sequence_statements, STATEMENT, statement_ordering, statement_undefined, statement_undefined_p, cluster::time, tlevel_decrease(), top_level(), update_parallel_task(), and zeroing_multiple_edges().

Referenced by hierarchical_schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

dsc_code_parallelization()

_Bool dsc_code_parallelization

(

char *

module_name

)

he main function for performing the hierarchical scheduling (scheduled SDG) using DSC and generating SPIRE

The proper effect to detect the I/O operations:

omplexities (task processing time)

roperties to set the parameters of BDSC

ost model generation

SC-based top-down hierarchical scheduling

Reorder the module, because new statements have been generated.

Parameters

module_name

odule_name

Definition at line 473 of file HBDSC.c.

{ 
  statement     module_stat;
  if (!get_bool_property("COMPLEXITY_EARLY_EVALUATION")) 
    set_bool_property("COMPLEXITY_EARLY_EVALUATION", true);
  module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
  set_ordering_to_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement(module_stat);
  set_precondition_map((statement_mapping)db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
  set_transformer_map((statement_mapping)
                      db_get_memory_resource(DBR_TRANSFORMERS, module_name, true));
  /* The proper effect to detect the I/O operations: */
  set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
   set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  module_to_value_mappings(get_current_module_entity());
  set_rw_effects((statement_effects) 
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_in_effects((statement_effects) db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
  set_out_effects((statement_effects) db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
  set_methods_for_convex_effects();
  init_convex_rw_prettyprint(module_name);
 
  kdg = (graph) db_get_memory_resource (DBR_DG, module_name, true );
  
  /*Complexities (task processing time)*/
  set_complexity_map( (statement_mapping) db_get_memory_resource(DBR_COMPLEXITIES, module_name, true));
 
  /*Properties to set the parameters of BDSC*/
  NBCLUSTERS = 1;//INT_MAX;
  MEMORY_SIZE = -1;
  INSTRUMENTED_FILE = strdup(get_string_property("BDSC_INSTRUMENTED_FILE"));
  /*cost model generation */
  annotations = gen_array_make(0);
  clusters = gen_array_make(0);
  if(sizeof(INSTRUMENTED_FILE) == 8)
    initialization(kdg, annotations);
  else
    parse_instrumented_file(INSTRUMENTED_FILE, kdg, annotations);
 
  stmt_to_cluster = make_persistant_statement_to_cluster();
  /*DSC-based top-down hierarchical scheduling*/
  hierarchical_schedule(module_stat, 0, NBCLUSTERS, MEMORY_SIZE, true);
  /* Reorder the module, because new statements have been generated. */
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
  reset_ordering_to_statement();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_proper_rw_effects();
  reset_cumulated_rw_effects();
  reset_rw_effects();
  reset_in_effects();
  reset_out_effects();
  reset_precondition_map();
  reset_complexity_map();
  reset_transformer_map();
  gen_array_free(annotations);
  gen_array_free(clusters);
  generic_effects_reset_all_methods();
  free_value_mappings();
  return true;
}

References annotations, clusters, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, free_value_mappings(), gen_array_free(), gen_array_make(), generic_effects_reset_all_methods(), get_bool_property(), get_current_module_entity(), get_string_property(), hierarchical_schedule(), init_convex_rw_prettyprint(), initialization(), INSTRUMENTED_FILE, kdg, make_persistant_statement_to_cluster(), MEMORY_SIZE, module_name(), module_name_to_entity(), module_reorder(), module_to_value_mappings(), NBCLUSTERS, parse_instrumented_file(), reset_complexity_map(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_ordering_to_statement(), reset_out_effects(), reset_precondition_map(), reset_proper_rw_effects(), reset_rw_effects(), reset_transformer_map(), set_bool_property(), set_complexity_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_methods_for_convex_effects(), set_ordering_to_statement(), set_out_effects(), set_precondition_map(), set_proper_rw_effects(), set_rw_effects(), set_transformer_map(), stmt_to_cluster, and strdup().

Here is the call graph for this function:

edge_cost()

double edge_cost	(	statement	s1,
		statement	s2
	)

Parameters

s1	1
s2	2

Definition at line 147 of file cost_model.c.

{
  Ppolynome transfer_time = POLYNOME_NUL;
  list l_write = regions_dup(regions_write_regions(load_statement_local_regions(s1)));
  list l_read = regions_dup(regions_read_regions(load_statement_local_regions(s2)));  
  list l_communications = RegionsIntersection(regions_dup(l_write), regions_dup(l_read), w_r_combinable_p);
  FOREACH(REGION,reg,l_communications){
    Ppolynome reg_footprint = region_enumerate(reg); 
    //reg_footprint =  polynome_mult(reg_footprint, expression_to_polynome(int_to_expression(SizeOfElements(variable_basic(type_variable(entity_type(region_entity(reg))))))));
    //reg_footprint =
    //polynome_mult(reg_footprint,expression_to_polynome(int_to_expression(2.5)));//\beta= 2.5 on Cmmcluster
    polynome_add(&transfer_time, reg_footprint);
  }
  //polynome_add(&transfer_time, latency);// the latency \alpha = 15000 on Cmmcluster
  //polynome_fprint(stderr,transfer_time,entity_local_name,default_is_inferior_var);
  return polynomial_to_numerical(transfer_time);
}

References FOREACH, load_statement_local_regions(), polynome_add(), POLYNOME_NUL, polynomial_to_numerical(), REGION, region_enumerate(), regions_dup(), regions_read_regions(), regions_write_regions(), RegionsIntersection(), s1, and w_r_combinable_p().

Referenced by initialization().

Here is the call graph for this function:

Here is the caller graph for this function:

eliminate_original_variables()

bool eliminate_original_variables

(

const char *

module_name

)

eliminate_original_variables.c

eliminate_original_variables.c

Reorder the module, because some statements have been added. Well, the order on the remaining statements should be the same, but by reordering the statements, the number are consecutive. Just for pretty print... :-)

Parameters

module_name

odule_name

Definition at line 474 of file eliminate_original_variables.c.

                                                           {
  entity module;
  statement module_statement;
  bool good_result_p = true;
 
  debug_on("MPI_GENERATION_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  //-- configure environment --//
  set_current_module_entity(module_name_to_entity(module_name));
  module = get_current_module_entity();
 
  set_current_module_statement( (statement)
      db_get_memory_resource(DBR_CODE, module_name, true) );
  module_statement = get_current_module_statement();
 
  pips_assert("Statement should be OK before...",
      statement_consistent_p(module_statement));
 
  set_ordering_to_statement(module_statement);
 
  //-- get dependencies --//
  set_parallel_task_mapping((statement_task)
      db_get_memory_resource(DBR_TASK, module_name, true));
 
 
  //-- Make the job -- //
  good_result_p = make_eliminate_original_variables(module, module_statement);
//  gen_recurse(module_statement, statement_domain, gen_true, eliminate_in_statement);
 
 
  /* Reorder the module, because some statements have been added.
     Well, the order on the remaining statements should be the same,
     but by reordering the statements, the number are consecutive. Just
     for pretty print... :-) */
  module_reorder(module_statement);
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  //-- Save modified code to database --//
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
 
  reset_ordering_to_statement();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_parallel_task_mapping();
 
  pips_debug(1, "end\n");
  debug_off();
 
  return (good_result_p);
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, get_current_module_entity(), get_current_module_statement(), make_eliminate_original_variables(), module, module_name(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_parallel_task_mapping(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_parallel_task_mapping(), statement_consistent_p(), and strdup().

Here is the call graph for this function:

error_reset_parallel_task_mapping()

void error_reset_parallel_task_mapping

(

void

)

get_parallel_task_mapping()

statement_task get_parallel_task_mapping

(

void

)

Referenced by copy_value_of_write(), and task_mapping().

Here is the caller graph for this function:

hbdsc_parallelization()

_Bool hbdsc_parallelization

(

char *

module_name

)

he main function for performing the hierarchical scheduling (scheduled SDG) using BDSC and generating the graph (unstructured) BDSC-based top-down hierarchical scheduling

The proper effect to detect the I/O operations:

omplexities (task processing time)

roperties to set the parameters of BDSC

ost model generation

Parameters

module_name

odule_name

Definition at line 396 of file HBDSC.c.

{ 
  statement     module_stat;
  string tg_name = NULL;
  FILE *ftg;
  if (!get_bool_property("COMPLEXITY_EARLY_EVALUATION")) 
    set_bool_property("COMPLEXITY_EARLY_EVALUATION", true);
  module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
  set_ordering_to_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement(module_stat);
  set_precondition_map((statement_mapping)db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
  set_transformer_map((statement_mapping)
                      db_get_memory_resource(DBR_TRANSFORMERS, module_name, true));
  /* The proper effect to detect the I/O operations: */
  set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  module_to_value_mappings(get_current_module_entity());
  set_rw_effects((statement_effects) 
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_in_effects((statement_effects) db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
  set_out_effects((statement_effects) db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
  set_methods_for_convex_effects();
  init_convex_rw_prettyprint(module_name);
  kdg = (graph) db_get_memory_resource (DBR_SDG, module_name, true );
  /*Complexities (task processing time)*/
  set_complexity_map( (statement_mapping) db_get_memory_resource(DBR_COMPLEXITIES, module_name, true));
  /*Properties to set the parameters of BDSC*/
  NBCLUSTERS = get_int_property("BDSC_NB_CLUSTERS");
  MEMORY_SIZE = get_int_property("BDSC_MEMORY_SIZE");
  INSTRUMENTED_FILE = strdup(get_string_property("BDSC_INSTRUMENTED_FILE"));
 
  /*cost model generation */
  annotations = gen_array_make(0);
  clusters = gen_array_make(0);
  initialization_clusters(true);
  if(strlen(INSTRUMENTED_FILE) == 0)
    initialization(kdg, annotations);
  else
    parse_instrumented_file(INSTRUMENTED_FILE, kdg, annotations);
  stmt_to_cluster = make_persistant_statement_to_cluster();
  hierarchical_schedule(module_stat, 0, NBCLUSTERS, MEMORY_SIZE, false);
  tg_name = strdup(concatenate(db_get_current_workspace_directory(),
                               "/",module_name,"/",module_name, "_scheduled_sdg.dot", NULL));
  ftg = safe_fopen(tg_name, "w");
  fprintf( ftg, "digraph {\n compound=true;ratio=fill; node[fontsize=24,fontname=\"Courier\",labelloc=\"t\"];nodesep=.05;\n" );
  print_SDGs(module_stat, kdg, ftg, annotations);
  fprintf( ftg, "\n}\n" );
  safe_fclose(ftg, tg_name);
  free(tg_name);
  
  DB_PUT_MEMORY_RESOURCE(DBR_SDG, module_name, (char*) kdg);
  gen_consistent_p((gen_chunk*)stmt_to_cluster);
  DB_PUT_MEMORY_RESOURCE(DBR_SCHEDULE, module_name, (char*) stmt_to_cluster);
  reset_proper_rw_effects();
  reset_cumulated_rw_effects();
  reset_ordering_to_statement();
  reset_rw_effects();
  reset_in_effects();
  reset_out_effects();
  reset_precondition_map();
  reset_complexity_map();
  reset_transformer_map();
  reset_current_module_statement();
  reset_current_module_entity();
  gen_array_full_free(annotations);
  gen_array_full_free(clusters);
  generic_effects_reset_all_methods();
  free_value_mappings();
  return true;
}

References annotations, clusters, concatenate(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, fprintf(), free(), free_value_mappings(), gen_array_full_free(), gen_array_make(), gen_consistent_p(), generic_effects_reset_all_methods(), get_bool_property(), get_current_module_entity(), get_int_property(), get_string_property(), hierarchical_schedule(), init_convex_rw_prettyprint(), initialization(), initialization_clusters(), INSTRUMENTED_FILE, kdg, make_persistant_statement_to_cluster(), MEMORY_SIZE, module_name(), module_name_to_entity(), module_to_value_mappings(), NBCLUSTERS, parse_instrumented_file(), print_SDGs(), reset_complexity_map(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_ordering_to_statement(), reset_out_effects(), reset_precondition_map(), reset_proper_rw_effects(), reset_rw_effects(), reset_transformer_map(), safe_fclose(), safe_fopen(), set_bool_property(), set_complexity_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_methods_for_convex_effects(), set_ordering_to_statement(), set_out_effects(), set_precondition_map(), set_proper_rw_effects(), set_rw_effects(), set_transformer_map(), stmt_to_cluster, and strdup().

hierarchical_schedule()

int hierarchical_schedule	(	statement	,
		int	,
		int	,
		int	,
		_Bool
	)

init_parallel_task_mapping()

void init_parallel_task_mapping

(

void

)

Referenced by task_mapping().

Here is the caller graph for this function:

initialization()

void initialization	(	graph	dg,
		gen_array_t	annotations
	)

Parameters

dg	g
annotations	nnotations

Definition at line 267 of file cost_model.c.

{
  list vertices = graph_vertices(dg);
  int sigma =  get_int_property("BDSC_SENSITIVITY");
  float clock = 1, overhead = 0;
  srand(time(NULL));
  FOREACH(VERTEX, v, vertices){
    statement stmt = vertex_to_statement(v);
    annotation *item = (annotation *)malloc(sizeof(annotation));
    float x = (float)((float)rand()/((float)RAND_MAX) * (float)sigma/100);
    item->task_time = clock * task_time(stmt) * (1 + x ) + overhead;
    item->edge_cost = gen_array_make(gen_length(vertex_successors(v)));//0
    FOREACH(SUCCESSOR, su, (vertex_successors(v))){//statement_to_vertex(stmt, dg)))) {
      vertex s = successor_vertex(su);
      statement child = vertex_to_statement(s);
      double *ec = (double *)malloc(sizeof(double));
      *ec = clock * edge_cost(stmt, child) * (1+((float)rand()/(float)RAND_MAX * sigma/100)) + overhead;
      gen_array_addto(item->edge_cost, statement_ordering(child), ec);
    }
    item->scheduled = false;
    item->order_sched = -1;
    item->cluster = -1;
    item->nbclusters = 0;
    item->data =  used_data(stmt);
    gen_array_addto(annotations, (int)statement_ordering(stmt), item); 
  }
  return;
}

References annotations, annotation::cluster, annotation::data, dg, edge_cost(), annotation::edge_cost, FOREACH, gen_array_addto(), gen_array_make(), gen_length(), get_int_property(), graph_vertices, malloc(), annotation::nbclusters, annotation::order_sched, annotation::scheduled, statement_ordering, SUCCESSOR, successor_vertex, task_time(), annotation::task_time, used_data(), VERTEX, vertex_successors, vertex_to_statement(), and x.

Referenced by dsc_code_parallelization(), hbdsc_parallelization(), and make_unstructured_from_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

load_parallel_task_mapping()

task load_parallel_task_mapping

(

statement

)

Referenced by assign_statement_task_mapping(), copy_n_reference(), copy_n_statement(), copy_write_statement(), copy_write_statement_with_cumulated_regions(), ctx_set_statement_work_on(), make_declaration_replication(), and prepare_context().

Here is the caller graph for this function:

make_com_loopbody()

statement make_com_loopbody	(	entity	,
		_Bool	,
		list	,
		int
	)

communication_generation.c

mpi_conversion()

bool mpi_conversion

(

const char *

module_name

)

mpi_conversion.c

mpi_conversion.c

Reorder the module, because some statements have been added. Well, the order on the remaining statements should be the same, but by reordering the statements, the number are consecutive. Just for pretty print... :-)

Parameters

module_name

odule_name

Definition at line 1989 of file mpi_conversion.c.

                                             {
  entity module;
  statement module_statement;
  bool good_result_p = true;
 
  debug_on("MPI_GENERATION_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  //-- configure environment --//
  set_current_module_entity(module_name_to_entity(module_name));
  module = get_current_module_entity();
 
  set_current_module_statement( (statement)
      db_get_memory_resource(DBR_CODE, module_name, true) );
  module_statement = get_current_module_statement();
 
  pips_assert("Statement should be OK before...",
      statement_consistent_p(module_statement));
 
  set_ordering_to_statement(module_statement);
 
  //-- get dependencies --//
//  if(use_points_to) {
//    set_pointer_info_kind(with_points_to); //enough?
//  }
  set_parallel_task_mapping((statement_task)
      db_get_memory_resource(DBR_TASK, module_name, true));
 
  //-- Make the job -- //
  module_statement = make_mpi_conversion(module, module_statement);
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  // Removed useless block created by the insert_statement
  unspaghettify_statement(module_statement);
 
  /* Reorder the module, because some statements have been added.
     Well, the order on the remaining statements should be the same,
     but by reordering the statements, the number are consecutive. Just
     for pretty print... :-) */
  module_reorder(module_statement);
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  //-- Save modified code to database --//
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
 
  reset_ordering_to_statement();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_parallel_task_mapping();
 
  pips_debug(1, "end\n");
  debug_off();
 
  return (good_result_p);
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, get_current_module_entity(), get_current_module_statement(), make_mpi_conversion(), module, module_name(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_parallel_task_mapping(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_parallel_task_mapping(), statement_consistent_p(), strdup(), and unspaghettify_statement().

Here is the call graph for this function:

mpi_task_generation()

_Bool mpi_task_generation

(

char *

module_name

)

mpi_generation.c

Parameters

module_name

odule_name

Definition at line 348 of file mpi_generation.c.

{ 
  entity    module = local_name_to_top_level_entity(module_name);
  statement module_stat_i = (statement)db_get_memory_resource(DBR_DISTRIBUTED_SPIRE_CODE, module_name, true);
  statement module_stat = copy_statement(module_stat_i);
  set_ordering_to_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement(module_stat);
  init_stmt = mpi_initialize(module_stat, module);
  gen_flat_mpi(module_stat, 0);
  mpi_finalize(module_stat);
  module_reorder(module_stat);
  gen_consistent_p((gen_chunk*)module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_PARALLELIZED_CODE, module_name, module_stat);
  reset_current_module_statement();
  reset_current_module_entity();
  reset_ordering_to_statement();
  return true;
}

References copy_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, gen_consistent_p(), gen_flat_mpi(), init_stmt, local_name_to_top_level_entity(), module, module_name(), module_name_to_entity(), module_reorder(), mpi_finalize(), mpi_initialize(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), set_current_module_entity(), set_current_module_statement(), and set_ordering_to_statement().

Here is the call graph for this function:

openmp_task_generation()

_Bool openmp_task_generation

(

char *

module_name

)

openmp_generation.c

openmp_generation.c

Parameters

module_name

odule_name

Definition at line 160 of file openmp_generation.c.

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

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

Here is the call graph for this function:

parallel_task_mapping_undefined_p()

bool parallel_task_mapping_undefined_p

(

void

)

task_mapping.c

parse_instrumented_file()

void parse_instrumented_file	(	char *	file_name,
		graph	dg,
		gen_array_t	annotations
	)

Parameters

file_name	ile_name
dg	g
annotations	nnotations

Definition at line 296 of file cost_model.c.

{
  FILE *finstrumented;
  double cost;
  int ordering, ordering2;
  finstrumented = fopen(file_name,"r");
  list vertices = graph_vertices(dg);
  annotation *item;
  FOREACH(VERTEX, v, vertices){
    statement stmt = vertex_to_statement(v);
    item = (annotation *)malloc(sizeof(annotation));
    item->edge_cost = gen_array_make(0);
    FOREACH(SUCCESSOR, su, (vertex_successors(statement_to_vertex(stmt, dg)))) {
      vertex s = successor_vertex(su);
      statement child = vertex_to_statement(s);
      double *ec = (double *)malloc(sizeof(double));
      *ec = 0;
      gen_array_addto(item->edge_cost, statement_ordering(child), ec);
    }
    gen_array_addto(annotations, (int)statement_ordering(stmt), item);
  }
  while (!feof(finstrumented) && (fscanf(finstrumented,"%d->%d = %lf \n", &ordering,&ordering2, &cost)))
    {
      if(ordering2 == -1){
        item = gen_array_item(annotations, ordering);
        item->task_time = (double)cost;
        if(item->edge_cost == NULL)
          item->edge_cost = gen_array_make(0);
        gen_array_addto(annotations, ordering, item); 
      }
      else { 
        item = gen_array_item(annotations, ordering);
        if(item->edge_cost == NULL)
          item->edge_cost = gen_array_make(0);
        double *ec = (double *)malloc(sizeof(double));
        *ec = cost;
        gen_array_addto(item->edge_cost, ordering2, ec);
        gen_array_addto(annotations, ordering, item);
      }
     
    }    
  fclose(finstrumented);  
  return;
}

References annotations, dg, annotation::edge_cost, file_name, FOREACH, gen_array_addto(), gen_array_item(), gen_array_make(), graph_vertices, malloc(), statement_ordering, statement_to_vertex(), SUCCESSOR, successor_vertex, annotation::task_time, VERTEX, vertex_successors, and vertex_to_statement().

Referenced by dsc_code_parallelization(), and hbdsc_parallelization().

Here is the call graph for this function:

Here is the caller graph for this function:

partitioning_sdg()

graph partitioning_sdg

(

statement

module_stmt

)

Parameters

module_stmt

odule_stmt

Definition at line 455 of file SDG.c.

{
  gen_recurse(module_stmt, statement_domain, sequence_dg, gen_null);
  return clean_sdg(module_stmt, sdg);
}

References clean_sdg(), gen_null(), gen_recurse, sdg, sequence_dg(), and statement_domain.

Referenced by sequence_dependence_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

polynomial_to_numerical()

double polynomial_to_numerical

(

Ppolynome

poly_amount

)

if polynomial is not a constant monomial, we use
an heuristic to map it into a numerical constant take the higher degree monomial and decide upon its coefficient

Parameters

poly_amount

oly_amount

Definition at line 93 of file cost_model.c.

{
   double size = 0.f;
   /* if polynomial is not a constant monomial, we use    
    * an heuristic to map it into a numerical constant 
    * take the higher degree monomial
    * and decide upon its coefficient
    */
   if(!POLYNOME_UNDEFINED_P(poly_amount))
     {
       int max_degree = polynome_max_degree(poly_amount);
       for(Ppolynome p = poly_amount; !POLYNOME_NUL_P(p); p = polynome_succ(p)) {
         int curr_degree =  (int)vect_sum(monome_term(polynome_monome(p)));
         if(curr_degree == max_degree) {
           size = monome_coeff(polynome_monome(p));
           break;
         }
       }
     }
   return size;
}

References int, monome_coeff, monome_term, polynome_max_degree(), polynome_monome, POLYNOME_NUL_P, polynome_succ, POLYNOME_UNDEFINED_P, and vect_sum().

Referenced by edge_cost(), size_of_regions(), and task_time().

Here is the call graph for this function:

Here is the caller graph for this function:

print_SDGs()

void print_SDGs	(	statement	stmt,
		graph	tg,
		FILE *	ftg,
		gen_array_t	annotations
	)

Parameters

stmt	tmt
tg	g
ftg	tg
annotations	nnotations

Definition at line 520 of file SDG.c.

                                                                              {
  instruction inst = statement_instruction(stmt);
  switch(instruction_tag(inst))
    {
    case is_instruction_block :
      {
      sequence seq = statement_sequence(stmt);
      list stmts = sequence_statements(seq);
      fprintf( ftg, "subgraph cluster%d { color = blue; \n ",count );
      FOREACH(STATEMENT, s, stmts) {
        list vertices = graph_vertices(tg);
        annotation *anp = NULL;
        FOREACH(VERTEX, pre, vertices) {
          statement parent = vertex_to_statement(pre);
          if(statement_equal_p(parent, s)){
            if(gen_array_nitems(annotations)>0)
              anp = gen_array_item(annotations, (int)statement_ordering(parent));
            print_sdg_task(ftg, annotations, parent);
            FOREACH(SUCCESSOR, su, (vertex_successors(pre))) {
              vertex s = successor_vertex(su);
              statement child = vertex_to_statement(s);
              print_sdg_task(ftg, annotations, child);
              if(gen_array_nitems(annotations)>0){
                annotation *an=gen_array_item(annotations, (int)statement_ordering(child));
                if(an->cluster!=-1)
                  {//FFT
                    double edge_c = (intptr_t)(gen_array_item(anp->edge_cost,statement_ordering(child)));
                    fprintf( ftg,"%d -> %d [style=filled,color=blue,fontsize=16,label=\"%ld\",color=black];\n", (int)statement_ordering(parent),(int)statement_ordering(child),(long)(edge_c));
                  }
              }
              else
                fprintf( ftg,"%d -> %d [style=filled,color=blue,fontsize=16,color=black];\n", (int)statement_ordering(parent),(int)statement_ordering(child));
            }
          }
        }
      }
      fprintf( ftg, "} \n " );
      count ++;
      stmts = sequence_statements(seq);
      FOREACH(STATEMENT, s, stmts) 
        print_SDGs(s,tg, ftg, annotations);
      break;
      }
    case is_instruction_test:
      {
        test t = instruction_test(inst);
        print_SDGs(test_true(t),tg, ftg, annotations); 
        print_SDGs(test_false(t),tg, ftg, annotations); 
        break;
      }
    case is_instruction_loop :
      {
        loop l = statement_loop(stmt);
        print_SDGs(loop_body(l),tg, ftg, annotations);
        break;
      }
    case is_instruction_forloop :
      {
        forloop l = statement_forloop(stmt);
        print_SDGs(forloop_body(l),tg, ftg, annotations);
        break;
      }
    case is_instruction_whileloop :
      {
        whileloop l = statement_whileloop(stmt);
        print_SDGs(whileloop_body(l),tg, ftg, annotations);
        break;
      }
    default:
      break;
    }
  return; 
}

References annotations, annotation::cluster, count, annotation::edge_cost, FOREACH, forloop_body, fprintf(), gen_array_item(), gen_array_nitems(), graph_vertices, instruction_tag, instruction_test, intptr_t, is_instruction_block, is_instruction_forloop, is_instruction_loop, is_instruction_test, is_instruction_whileloop, loop_body, print_sdg_task(), sequence_statements, STATEMENT, statement_equal_p(), statement_forloop(), statement_instruction, statement_loop(), statement_ordering, statement_sequence(), statement_whileloop(), SUCCESSOR, successor_vertex, test_false, test_true, VERTEX, vertex_successors, vertex_to_statement(), and whileloop_body.

Referenced by hbdsc_parallelization(), and sequence_dependence_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

print_task()

void print_task

(

task

t

)

Pass: TASK_MAPPING Debug mode: MPI_GENERATION_DEBUG_LEVEL Resource generated:

• DBR_TASK

Definition at line 73 of file task_mapping.c.

                        {
  if(task_undefined_p(t))
    fprintf(stderr, "Undefined task\n");
  // For debugging with gdb, dynamic type checking
  else if(task_domain_number(t)!=task_domain)
    (void) fprintf(stderr,"Arg. \"t\"is not a task.\n");
  else {
    fprintf(stderr, "%s", task_to_string(t, false));
  }
}

References fprintf(), task_domain, task_domain_number, task_to_string(), and task_undefined_p.

Referenced by assign_statement_task_mapping(), and print_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

priorities()

void priorities

(

gen_array_t

annotations

)

Parameters

annotations

nnotations

Definition at line 253 of file cost_model.c.

{
  size_t i;
  for(i = 0; i< gen_array_nitems(annotations); i++){
    if(gen_array_item(annotations, i) != NULL){
      annotation *item = gen_array_item(annotations, i);
      item->prio = item->tlevel + item->blevel;
      gen_array_addto(annotations, i, item);
    }
  }
  return;
}

References annotations, annotation::blevel, gen_array_addto(), gen_array_item(), gen_array_nitems(), annotation::prio, and annotation::tlevel.

Referenced by BDSC(), and DSC().

Here is the call graph for this function:

Here is the caller graph for this function:

region_to_com_nest()

statement region_to_com_nest	(	effect	,
		_Bool	,
		int
	)

reset_parallel_task_mapping()

void reset_parallel_task_mapping

(

void

)

Referenced by copy_value_of_write(), copy_value_of_write_with_cumulated_regions(), eliminate_original_variables(), mpi_conversion(), task_mapping(), and variable_replication().

Here is the caller graph for this function:

sequence_dependence_graph()

_Bool sequence_dependence_graph

(

char *

module_name

)

The proper effect to detect the I/O operations:

dg contains the original dependences before clustering and scheduling, it is saved to not make a side effect on the original dg when constructing the SDG

Parameters

module_name

odule_name

Definition at line 593 of file SDG.c.

{ 
  //entity      module;
  statement     module_stat;
  string tg_name = NULL;
  FILE *ftg;
  //module = local_name_to_top_level_entity(module_name);
  module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
  set_ordering_to_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement(module_stat);
  set_precondition_map((statement_mapping)db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
  set_transformer_map((statement_mapping)
                      db_get_memory_resource(DBR_TRANSFORMERS, module_name, true));
  /* The proper effect to detect the I/O operations: */
  set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  module_to_value_mappings(get_current_module_entity());
  set_rw_effects((statement_effects) 
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_in_effects((statement_effects) db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
  set_out_effects((statement_effects) db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
  set_methods_for_convex_effects();
  init_convex_rw_prettyprint(module_name);
 
  ddg = (graph) db_get_memory_resource (DBR_DG, module_name, true );
  /*ddg contains the original dependences before clustering and  scheduling, it
    is saved to not make a side effect on the original dg when
    constructing the SDG*/
  sdg = copy_graph(ddg);
  sdg = partitioning_sdg(module_stat);
  tg_name = strdup(concatenate(db_get_current_workspace_directory(),
                               "/",module_name,"/",module_name, "_sdg.dot", NULL));
  ftg = safe_fopen(tg_name, "w");
  fprintf( ftg, "digraph {\n compound=true;ratio=fill; node[fontsize=24,fontname=\"Courier\",labelloc=\"t\"];nodesep=.05;\n" );
  print_SDGs(module_stat, sdg, ftg, gen_array_make(0));
  fprintf( ftg, "\n}\n" );
  safe_fclose(ftg, tg_name);
  free(tg_name);
  
  reset_ordering_to_statement();
  DB_PUT_MEMORY_RESOURCE(DBR_SDG, module_name, (char*) sdg);
  
  reset_proper_rw_effects();
  reset_cumulated_rw_effects();
  reset_rw_effects();
  reset_in_effects();
  reset_out_effects();
  reset_precondition_map();
  reset_transformer_map();
  reset_current_module_statement();
  reset_current_module_entity();
  generic_effects_reset_all_methods();
  free_value_mappings();
  return true;
}

References concatenate(), copy_graph(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, ddg, fprintf(), free(), free_value_mappings(), gen_array_make(), generic_effects_reset_all_methods(), get_current_module_entity(), init_convex_rw_prettyprint(), module_name(), module_name_to_entity(), module_to_value_mappings(), partitioning_sdg(), print_SDGs(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_ordering_to_statement(), reset_out_effects(), reset_precondition_map(), reset_proper_rw_effects(), reset_rw_effects(), reset_transformer_map(), safe_fclose(), safe_fopen(), sdg, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_methods_for_convex_effects(), set_ordering_to_statement(), set_out_effects(), set_precondition_map(), set_proper_rw_effects(), set_rw_effects(), set_transformer_map(), and strdup().

Here is the call graph for this function:

set_parallel_task_mapping()

void set_parallel_task_mapping

(

statement_task

)

Referenced by copy_value_of_write(), copy_value_of_write_with_cumulated_regions(), eliminate_original_variables(), mpi_conversion(), and variable_replication().

Here is the caller graph for this function:

size_of_regions()

double size_of_regions

(

list

l_data

)

Parameters

l_data

_data

Definition at line 115 of file cost_model.c.

{
  Ppolynome transfer_time = POLYNOME_NUL;
  FOREACH(REGION,reg,l_data){
    Ppolynome reg_footprint= region_enumerate(reg); 
    reg_footprint = polynome_mult(reg_footprint, expression_to_polynome(int_to_expression(SizeOfElements(variable_basic(type_variable(entity_type(region_entity(reg))))))));
    polynome_add(&transfer_time, reg_footprint);
  }   
  return polynomial_to_numerical(transfer_time); 
}

References entity_type, expression_to_polynome(), FOREACH, int_to_expression(), polynome_add(), polynome_mult(), POLYNOME_NUL, polynomial_to_numerical(), REGION, region_entity, region_enumerate(), SizeOfElements(), type_variable, and variable_basic.

Referenced by MCW(), and transfer_cost().

Here is the call graph for this function:

Here is the caller graph for this function:

spire_distributed_unstructured_to_structured()

_Bool spire_distributed_unstructured_to_structured

(

char *

module_name

)

The proper effect to detect the I/O operations:

Reorder the module, because new statements have been generated.

Parameters

module_name

odule_name

Definition at line 192 of file spire_generation.c.

{ 
  statement module_stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  statement module_stat_i = copy_statement(module_stat);
  set_ordering_to_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement(module_stat);
  set_precondition_map((statement_mapping)db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
  set_transformer_map((statement_mapping)
                      db_get_memory_resource(DBR_TRANSFORMERS, module_name, true));
  /* The proper effect to detect the I/O operations: */
  set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  module_to_value_mappings(get_current_module_entity());
  set_rw_effects((statement_effects) 
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_in_effects((statement_effects) 
                 db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
  set_out_effects((statement_effects) 
                  db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
  set_methods_for_convex_effects();
  init_convex_rw_prettyprint(module_name);
 
  kdg = (graph) db_get_memory_resource (DBR_SDG, module_name, true );
  persistant_statement_to_cluster 
  stmt_to_cluster_i = (persistant_statement_to_cluster)db_get_memory_resource(DBR_SCHEDULE, module_name, true);
  stmt_to_cluster =  copy_persistant_statement_to_cluster(stmt_to_cluster_i);
 
  NBCLUSTERS = get_int_property("BDSC_NB_CLUSTERS");
  MEMORY_SIZE = get_int_property("BDSC_MEMORY_SIZE");
  list entities = gen_filter_tabulated(gen_true, entity_domain);
  char *rtl_prefix = "_rtl";
  FOREACH(entity, e, entities) {
    if (strncmp(entity_local_name(e), rtl_prefix, strlen(rtl_prefix)) == 0){
      gen_clear_tabulated_element((gen_chunkp)e);
    }
  }
  com_declarations_to_add = NIL;
  cluster_stage_spire_generation(stmt_to_cluster, kdg, module_stat, NBCLUSTERS);
  communications_construction(kdg, module_stat, stmt_to_cluster, -1);
  FOREACH(entity, e, com_declarations_to_add) 
    module_stat = add_declaration_statement(module_stat, e);
  if(!statement_undefined_p(return_st))
    insert_statement(module_stat, return_st, false);
  /* Reorder the module, because new statements have been generated. */
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_DISTRIBUTED_SPIRE_CODE, strdup(module_name), module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_stat_i);
  reset_ordering_to_statement();
  reset_proper_rw_effects();
  reset_cumulated_rw_effects();
  reset_rw_effects();
  reset_in_effects();
  reset_out_effects();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_precondition_map();
  reset_transformer_map();
  generic_effects_reset_all_methods();
  free_value_mappings();
  return true;
}

References add_declaration_statement(), cluster_stage_spire_generation(), com_declarations_to_add, communications_construction(), copy_persistant_statement_to_cluster(), copy_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, entity_domain, entity_local_name(), FOREACH, free_value_mappings(), gen_clear_tabulated_element(), gen_filter_tabulated(), gen_true(), generic_effects_reset_all_methods(), get_current_module_entity(), get_int_property(), init_convex_rw_prettyprint(), insert_statement(), kdg, MEMORY_SIZE, module_name(), module_name_to_entity(), module_reorder(), module_to_value_mappings(), NBCLUSTERS, NIL, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_ordering_to_statement(), reset_out_effects(), reset_precondition_map(), reset_proper_rw_effects(), reset_rw_effects(), reset_transformer_map(), return_st, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_methods_for_convex_effects(), set_ordering_to_statement(), set_out_effects(), set_precondition_map(), set_proper_rw_effects(), set_rw_effects(), set_transformer_map(), statement_undefined_p, stmt_to_cluster, and strdup().

Here is the call graph for this function:

spire_shared_unstructured_to_structured()

_Bool spire_shared_unstructured_to_structured

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 163 of file spire_generation.c.

{ 
  statement module_stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  statement module_stat_i = copy_statement(module_stat);
  set_ordering_to_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement(module_stat);
 
  kdg = (graph) db_get_memory_resource (DBR_SDG, module_name, true );
  persistant_statement_to_cluster  stmt_to_cluster_i = (persistant_statement_to_cluster)db_get_memory_resource(DBR_SCHEDULE, module_name, true);
  gen_consistent_p((gen_chunk*)stmt_to_cluster_i);
  stmt_to_cluster = copy_persistant_statement_to_cluster(stmt_to_cluster_i);
  NBCLUSTERS = get_int_property("BDSC_NB_CLUSTERS");
  MEMORY_SIZE = get_int_property("BDSC_MEMORY_SIZE");
  cluster_stage_spire_generation(stmt_to_cluster, kdg, module_stat, NBCLUSTERS);
  if(!statement_undefined_p(return_st))
    insert_statement(module_stat, return_st, false);
  module_reorder(module_stat);
  gen_consistent_p((gen_chunk*)module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_SHARED_SPIRE_CODE, strdup(module_name), module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_stat_i);
 
  reset_ordering_to_statement();
  gen_consistent_p((gen_chunk*)stmt_to_cluster);
  reset_current_module_statement();
  reset_current_module_entity();
  return true;
}

References cluster_stage_spire_generation(), copy_persistant_statement_to_cluster(), copy_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, gen_consistent_p(), get_int_property(), insert_statement(), kdg, MEMORY_SIZE, module_name(), module_name_to_entity(), module_reorder(), NBCLUSTERS, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), return_st, set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), statement_undefined_p, stmt_to_cluster, and strdup().

Here is the call graph for this function:

statement_equal_p()

_Bool statement_equal_p	(	statement	s1,
		statement	s2
	)

Parameters

s1	1
s2	2

Definition at line 123 of file SDG.c.

{
    return (statement_number(s1) == statement_number(s2) && statement_ordering(s1) == statement_ordering(s2) );
}

References s1, statement_number, and statement_ordering.

Referenced by print_SDGs(), same_level_p(), sequence_dg(), statement_in_sequence_p(), and statement_to_vertex().

Here is the caller graph for this function:

statement_to_vertex()

vertex statement_to_vertex	(	statement	s,
		graph	g
	)

Definition at line 131 of file SDG.c.

{
    MAP(VERTEX, v, {
        statement sv = vertex_to_statement(v);
        if (statement_equal_p(s, sv))
          return v;
    }, graph_vertices(g));
    return vertex_undefined;
}

References graph_vertices, MAP, statement_equal_p(), VERTEX, vertex_to_statement(), and vertex_undefined.

Referenced by sequence_dg().

Here is the call graph for this function:

Here is the caller graph for this function:

store_or_update_parallel_task_mapping()

void store_or_update_parallel_task_mapping	(	statement	,
		task
	)

Referenced by assign_statement_task_mapping(), copy_n_reference(), copy_n_statement(), and copy_write_statement_with_cumulated_regions().

Here is the caller graph for this function:

store_parallel_task_mapping()

void store_parallel_task_mapping	(	statement	,
		task
	)

t_level()

double t_level	(	vertex	v,
		graph	dg,
		gen_array_t	annotations
	)

First parameter is the top level (earliest start time) for each node.

intptr_t)

Parameters

dg	g
annotations	nnotations

Definition at line 168 of file cost_model.c.

{
  double max = 0, level;
  list vertices = (graph_vertices(dg));
  annotation *an,*anp;
  statement sv = vertex_to_statement(v);
  FOREACH(VERTEX, pre, vertices) {
    statement parent = vertex_to_statement(pre);
      FOREACH(SUCCESSOR, su, (vertex_successors(pre))) {
        vertex s = successor_vertex(su);
        statement child = vertex_to_statement(s);
        if(statement_equal_p(child, sv) && !statement_equal_p(child,parent) && gen_array_item(annotations, (int)statement_ordering(parent))){       
          double tl_p;
          anp = gen_array_item(annotations, (int)statement_ordering(parent));
          double edge_c = *(double *)/*(intptr_t)*/(gen_array_item(anp->edge_cost, statement_ordering(sv)));
          if(anp->tlevel != -1)
            tl_p = anp->tlevel;
          else
            tl_p =  t_level(pre, dg, annotations);
          level = tl_p + anp->task_time + edge_c ;
          if(level > max)
            max = level;
        }
        else {
          if(statement_equal_p(child, sv) && !statement_equal_p(child,parent) && gen_array_item(annotations, (int)statement_ordering(parent))==NULL )
            {
              anp = gen_array_item(annotations, (int)statement_ordering(parent));
              double edge_c = *(double *)(gen_array_item(anp->edge_cost,statement_ordering(sv)));
              level = t_level(pre, dg, annotations) + anp->task_time + edge_c;
              if(level > max)
                max = level;
            }
        }
      }
  }
  if((int)statement_ordering(sv) < (int) gen_array_size(annotations) && gen_array_item(annotations, (int)statement_ordering(sv))!=NULL)
    an = gen_array_item(annotations, statement_ordering(sv));
  else
    an = (annotation *)malloc(sizeof(annotation));
  an->tlevel = max;
  gen_array_addto(annotations, (int)statement_ordering(sv), an);
  return max; 
}

References annotations, dg, annotation::edge_cost, FOREACH, gen_array_addto(), gen_array_item(), gen_array_size(), graph_vertices, level, malloc(), max, statement_equal_p(), statement_ordering, SUCCESSOR, successor_vertex, annotation::task_time, annotation::tlevel, VERTEX, vertex_successors, and vertex_to_statement().

Referenced by top_level(), and update_priority_values().

Here is the call graph for this function:

Here is the caller graph for this function:

task_mapping()

bool task_mapping

(

const char *

module_name

)

PIPS pass.

Parameters

module_name

odule_name

Definition at line 430 of file task_mapping.c.

                                           {
  entity module;
  statement module_statement;
  bool good_result_p = true;
 
  debug_on("MPI_GENERATION_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  //-- configure environment --//
  set_current_module_entity(module_name_to_entity(module_name));
  module = get_current_module_entity();
 
  set_current_module_statement( (statement)
      db_get_memory_resource(DBR_CODE, module_name, true) );
  module_statement = get_current_module_statement();
 
  pips_assert("Statement should be OK before...",
      statement_consistent_p(module_statement));
 
  init_parallel_task_mapping();
 
  //-- get dependencies --//
  // nothing except code and entity done before.
 
  //TODO look to add parameter in private list?
  //     look module is type functionnal -> list parameter convert to list entitty
 
  //-- Make the job -- //
  make_task_mapping(module, module_statement);
  //  gen_recurse(module_statement, statement_domain, gen_true, print_pragma);
 
  //useless, normally we don't modify the code
  //pips_assert("Statement should be OK after...",
  //    statement_consistent_p(module_statement));
 
  //-- Save modified code to database --//
  //  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
  DB_PUT_MEMORY_RESOURCE(DBR_TASK, module_name, get_parallel_task_mapping());
  //  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name,
  //       compute_callees(module_statement));
 
  reset_current_module_statement();
  reset_current_module_entity();
  reset_parallel_task_mapping();
 
  pips_debug(1, "end\n");
  debug_off();
 
  return (good_result_p);
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, get_current_module_entity(), get_current_module_statement(), get_parallel_task_mapping(), init_parallel_task_mapping(), make_task_mapping(), module, module_name(), module_name_to_entity(), module_statement, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_parallel_task_mapping(), set_current_module_entity(), set_current_module_statement(), and statement_consistent_p().

Here is the call graph for this function:

task_to_string()

string task_to_string	(	task	t,
		bool	pretty_print
	)

Parameters

pretty_print

retty_print

Definition at line 84 of file task_mapping.c.

                                                 {
  char tid[10+4];
  string tprivate = "";
  char tcluster[18+4];
  char tsync[23+5];
  snprintf(tid, 10+4, "task_id=%"_intFMT"\n", task_id(t));
  snprintf(tcluster, 18+4, "task_on_cluster=%"_intFMT"\n", task_on_cluster(t));
  snprintf(tsync, 23+5, "task_synchronization=%s\n", task_synchronization(t)?"true":"false");
  tprivate = "task_private_data={";
  FOREACH(ENTITY, ep, task_private_data(t)) {
    pips_debug(8, "%s", entity_name(ep));
    tprivate = concatenate(tprivate, pretty_print?entity_user_name(ep):entity_name(ep), "; ", (char *) NULL);
  }
  tprivate = strdup(concatenate(tprivate, "}\n", (char *) NULL));
  return concatenate(tid, tprivate, tcluster, tsync, (char *) NULL);
}

References _intFMT, concatenate(), ENTITY, entity_name, entity_user_name(), FOREACH, pips_debug, strdup(), task_id, task_on_cluster, task_private_data, and task_synchronization.

Referenced by prepare_context(), and print_task().

Here is the call graph for this function:

Here is the caller graph for this function:

top_level()

void top_level	(	graph	dg,
		gen_array_t	annotations
	)

Parameters

dg	g
annotations	nnotations

Definition at line 211 of file cost_model.c.

{
  list vertices = graph_vertices(dg);
  FOREACH(VERTEX, v, vertices){ 
    t_level(v, dg, annotations);
  }
  return; 
}

References annotations, dg, FOREACH, graph_vertices, t_level(), and VERTEX.

Referenced by BDSC(), and DSC().

Here is the call graph for this function:

Here is the caller graph for this function:

topological_sort()

list topological_sort

(

statement

stmt

)

Parameters

stmt

tmt

Definition at line 192 of file HBDSC.c.

{
  list K = NIL; uint i;
  list cluster_stages = NIL;
  list vertices = graph_vertices(kdg);
  gen_array_t I = gen_array_make(0);
  for(i = 0;i<gen_length(vertices);i++){
      gen_array_addto(I, i, 0);
  }
  FOREACH(statement, st, sequence_statements(statement_sequence(stmt))){ 
    FOREACH(VERTEX, v, vertices) {
      statement parent = vertex_to_statement(v);
      if(statement_equal_p(st,parent)){
        FOREACH(SUCCESSOR, su, (vertex_successors(v))) {
          vertex w = successor_vertex(su);
          statement child = vertex_to_statement(w);
          gen_array_addto(I, (int)statement_ordering(child), gen_array_item(I, (int)statement_ordering(child)) + 1);
        }
      }
    }
  }
  FOREACH(statement, st, sequence_statements(statement_sequence(stmt))){
    if(gen_array_item(I, statement_ordering(st)) == 0)
      K = CONS(STATEMENT, st, K);
  }
  list L =  gen_copy_seq(K);
  cluster_stages = CONS(LIST, L, cluster_stages);
  bool insert_p = false;
  while(K != NIL){
    statement st = STATEMENT(CAR(gen_last(K)));
    gen_remove_once(&K, st);
    FOREACH(VERTEX, pre, vertices) { 
      statement parent = vertex_to_statement(pre);
      if(statement_equal_p(parent, st)){
          FOREACH(SUCCESSOR, su, (vertex_successors(pre))) {
            vertex v = successor_vertex(su);
            statement child = vertex_to_statement(v);
            gen_array_addto(I, (int)statement_ordering(child), gen_array_item(I, (int)statement_ordering(child)) - 1);
            if(gen_array_item(I, statement_ordering(child)) == 0 && gen_occurences(child, K) == 0) {
              K = CONS(STATEMENT, child, K);
              insert_p = true;
            }
          }
          break;
      }
    }
    list M = NIL;
    bool ins_p = true,found_p=false;
    FOREACH(STATEMENT, stmt, K){
      found_p = false;
      FOREACH(STATEMENT, stmtl, L){
        if(statement_equal_p(stmt,stmtl))
          found_p = true;
      }
      if(!found_p)
        M = CONS(STATEMENT,stmt,M);
      else{
        ins_p = false;
        found_p = false;
      }
    }
    if( ins_p && gen_length(M) > 0 && insert_p){
      cluster_stages = CONS(LIST, M, cluster_stages);
      insert_p = false;
      L =  gen_copy_seq(K);
    }
  }
  gen_array_free(I);
  return rebuild_topological_sort(cluster_stages);
}

References CAR, CONS, FOREACH, gen_array_addto(), gen_array_free(), gen_array_item(), gen_array_make(), gen_copy_seq(), gen_last(), gen_length(), gen_occurences(), gen_remove_once(), graph_vertices, kdg, LIST, NIL, rebuild_topological_sort(), sequence_statements, STATEMENT, statement_equal_p(), statement_ordering, statement_sequence(), SUCCESSOR, successor_vertex, VERTEX, vertex_successors, and vertex_to_statement().

Referenced by cluster_stage_spire_generation(), and hierarchical_schedule_step().

Here is the call graph for this function:

Here is the caller graph for this function:

update_parallel_task_mapping()

void update_parallel_task_mapping	(	statement	,
		task
	)

variable_replication()

bool variable_replication

(

const char *

module_name

)

variable_replication.c

variable_replication.c

Reorder the module, because some statements have been added. Well, the order on the remaining statements should be the same, but by reordering the statements, the number are consecutive. Just for pretty print... :-)

Parameters

module_name

odule_name

Definition at line 148 of file variable_replication.c.

                                                   {
  //entity module;
  statement module_statement;
  bool good_result_p = true;
 
  debug_on("MPI_GENERATION_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  //-- configure environment --//
  set_current_module_entity(module_name_to_entity(module_name));
  //module = get_current_module_entity();
 
  set_current_module_statement( (statement)
      db_get_memory_resource(DBR_CODE, module_name, true) );
  module_statement = get_current_module_statement();
 
  pips_assert("Statement should be OK before...",
      statement_consistent_p(module_statement));
 
  set_ordering_to_statement(module_statement);
 
  //-- get dependencies --//
  set_parallel_task_mapping((statement_task)
      db_get_memory_resource(DBR_TASK, module_name, true));
 
  //-- Make the job -- //
  good_result_p = make_declaration_replication(module_statement);
  good_result_p &= make_global_variable_declaration_replication();
 
  /* Reorder the module, because some statements have been added.
     Well, the order on the remaining statements should be the same,
     but by reordering the statements, the number are consecutive. Just
     for pretty print... :-) */
  module_reorder(module_statement);
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  //-- Save modified code to database --//
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
 
  reset_ordering_to_statement();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_parallel_task_mapping();
 
  pips_debug(1, "end\n");
  debug_off();
 
  return (good_result_p);
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, get_current_module_statement(), make_declaration_replication(), make_global_variable_declaration_replication(), module_name(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_parallel_task_mapping(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_parallel_task_mapping(), statement_consistent_p(), and strdup().

Here is the call graph for this function:

Variable Documentation

annotations

gen_array_t annotations

extern

Global variables.

Definition at line 62 of file SDG.c.

Referenced by allocate_task_to_cluster(), BDSC(), bottom_level(), cancel_schedule(), DSC(), dsc_code_parallelization(), DSRW(), end_idle_clusters(), hbdsc_parallelization(), hierarchical_schedule(), hierarchical_schedule_step(), initialization(), MCW(), move_task_to_cluster(), parse_instrumented_file(), print_sdg_task(), print_SDGs(), priorities(), ready_node(), schedule_failsafe(), select_task_with_highest_priority(), t_level(), tlevel_decrease(), top_level(), update_parallel_task(), update_priority_values(), and zeroing_multiple_edges().

clusters

gen_array_t clusters

extern

Definition at line 63 of file SDG.c.

Referenced by allocate_task_to_cluster(), critical_path_length(), DSC(), dsc_code_parallelization(), end_idle_clusters(), hbdsc_parallelization(), initialization_clusters(), max_start_time_cluster(), MCW(), min_start_time_cluster(), move_task_to_cluster(), tlevel_decrease(), and zeroing_multiple_edges().

com_declarations_to_add

list com_declarations_to_add

extern

spire_generation.c

Definition at line 49 of file spire_generation.c.

Referenced by com_call(), and spire_distributed_unstructured_to_structured().

ddg

graph ddg

extern

Definition at line 52 of file HBDSC.c.

Referenced by sequence_dependence_graph().

INSTRUMENTED_FILE

string INSTRUMENTED_FILE

extern

Definition at line 59 of file SDG.c.

Referenced by dsc_code_parallelization(), and hbdsc_parallelization().

kdg

graph kdg

extern

HBDSC.c.

HBDSC.c.

Definition at line 52 of file HBDSC.c.

Referenced by allocate_task_to_cluster(), BDSC(), bdsc_code_instrumentation(), DSC(), dsc_code_parallelization(), end_idle_clusters(), hbdsc_parallelization(), MCW(), move_task_to_cluster(), ready_node(), schedule_failsafe(), spire_distributed_unstructured_to_structured(), spire_shared_unstructured_to_structured(), tlevel_decrease(), topological_sort(), update_priority_values(), and zeroing_multiple_edges().

MEMORY_SIZE

int MEMORY_SIZE

extern

Definition at line 58 of file SDG.c.

Referenced by dsc_code_parallelization(), find_cluster(), hbdsc_parallelization(), spire_distributed_unstructured_to_structured(), spire_shared_unstructured_to_structured(), tlevel_decrease(), and zeroing_multiple_edges().

NBCLUSTERS

int NBCLUSTERS

extern

cproto-generated files

SDG.c

cproto-generated files

Definition at line 57 of file SDG.c.

Referenced by cluster_stage_spire(), dsc_code_parallelization(), gen_recv_communications(), gen_send_communications(), hbdsc_parallelization(), hierarchical_schedule(), initialization_clusters(), rebuild_topological_sort(), spire_distributed_unstructured_to_structured(), and spire_shared_unstructured_to_structured().

return_st

statement return_st

extern

Definition at line 53 of file HBDSC.c.

Referenced by gen_omp_parallel(), mpi_finalize(), mpi_initialize(), openmp_task_generation(), rebuild_topological_sort(), spire_distributed_unstructured_to_structured(), and spire_shared_unstructured_to_structured().

stmt_to_cluster

persistant_statement_to_cluster stmt_to_cluster

extern

Definition at line 56 of file HBDSC.c.

Referenced by allocate_task_to_cluster(), cancel_schedule(), cluster_stage_spire(), cluster_stage_spire_generation(), dsc_code_parallelization(), hbdsc_parallelization(), move_task_to_cluster(), rebuild_topological_sort(), spire_distributed_unstructured_to_structured(), and spire_shared_unstructured_to_structured().