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

Include dependency graph for spire_generation.c:

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

typedef dg_vertex_label	vertex_label

Functions
static statement	cluster_stage_spire (persistant_statement_to_cluster stmt_to_cluster, graph tg, list cluster_stage, int p)
	return SPIRE for a cluster stage More...

void	cluster_stage_spire_generation (persistant_statement_to_cluster stmt_to_cluster, graph tg, statement stmt, int P)
	he main function More...

bool	spire_shared_unstructured_to_structured (char *module_name)

bool	spire_distributed_unstructured_to_structured (char *module_name)

Variables
list	com_declarations_to_add
	spire_generation.c More...

Typedef Documentation

◆ arc_label

typedef dg_arc_label arc_label

Instantiation of the dependence graph:

Definition at line 42 of file spire_generation.c.

◆ vertex_label

typedef dg_vertex_label vertex_label

Definition at line 43 of file spire_generation.c.

Function Documentation

◆ cluster_stage_spire()

static statement cluster_stage_spire	(	persistant_statement_to_cluster	stmt_to_cluster,
		graph	tg,
		list	cluster_stage,
		int	p
	)

static

return SPIRE for a cluster stage

Definition at line 54 of file spire_generation.c.

                                                                                                                            {
   int i = -1;
   list list_cl = NIL;
   statement stmt_spawn = statement_undefined, stmt_finish = statement_undefined; 
   int stage_mod = gen_length(cluster_stage);
   // int minus; FI: minus is not really used...
   int Ps = p - stage_mod;// + 1;  // plus one if we use the current cluster
   bool costly_p = false;
   FOREACH(LIST, list_stmts, cluster_stage){
     FOREACH(statement, st, list_stmts){
       if(!get_bool_property("COSTLY_TASKS_ONLY") | costly_task(st)){ 
         costly_p = true;
         i = apply_persistant_statement_to_cluster(stmt_to_cluster, statement_ordering(st));
         if(Ps > 0){
           cluster_stage_spire_generation(stmt_to_cluster, tg, st, Ps);
         }
      }
     }
     int physical_cluster = i;
     instruction ins_spawn = make_instruction_sequence(make_sequence(list_stmts));
     if(costly_p){
       // FI: minus is not used
       // minus = (NBCLUSTERS==p)?0:1;
       physical_cluster = NBCLUSTERS - p + i;// + 1 ;
       FOREACH(statement, st, list_stmts){
         update_persistant_statement_to_cluster(stmt_to_cluster, statement_ordering(st), physical_cluster);
       }
       entity k_ent = make_constant_entity(i2a(physical_cluster), is_basic_int, 4);
       stmt_spawn = make_statement(
                                   entity_empty_label(),
                                   STATEMENT_NUMBER_UNDEFINED,
                                   STATEMENT_ORDERING_UNDEFINED,
                                   empty_comments,
                                   ins_spawn,
                                   NIL, NULL, empty_extensions(), 
                                   make_synchronization_spawn(k_ent));
     }
     else
       stmt_spawn = make_statement(
                                   entity_empty_label(),
                                   STATEMENT_NUMBER_UNDEFINED,
                                   STATEMENT_ORDERING_UNDEFINED,
                                   empty_comments,
                                   ins_spawn,
                                   NIL, NULL, empty_extensions(), 
                                   make_synchronization_none());
     gen_consistent_p((gen_chunk*)stmt_spawn);
     gen_consistent_p((gen_chunk*) stmt_spawn);
     list_cl = CONS(STATEMENT, stmt_spawn, list_cl);
   }
   instruction ins_finish = make_instruction_sequence(make_sequence(gen_nreverse(list_cl)));
   synchronization sync = make_synchronization_none();
   (costly_p)? sync = make_synchronization_barrier() : make_synchronization_none();
   stmt_finish = make_statement(
                                  entity_empty_label(),
                                  STATEMENT_NUMBER_UNDEFINED,
                                  STATEMENT_ORDERING_UNDEFINED,
                                  empty_comments,
                                  ins_finish,
                                  NIL, NULL, empty_extensions(), 
                                  sync);
   gen_consistent_p((gen_chunk*)stmt_finish);
   return stmt_finish; 
 }

References apply_persistant_statement_to_cluster(), cluster_stage_spire_generation(), CONS, costly_task(), empty_comments, empty_extensions(), entity_empty_label(), FOREACH, gen_consistent_p(), gen_length(), gen_nreverse(), get_bool_property(), i2a(), is_basic_int, LIST, make_constant_entity(), make_instruction_sequence(), make_sequence(), make_statement(), make_synchronization_barrier(), make_synchronization_none(), make_synchronization_spawn(), NBCLUSTERS, NIL, STATEMENT, STATEMENT_NUMBER_UNDEFINED, statement_ordering, STATEMENT_ORDERING_UNDEFINED, statement_undefined, stmt_to_cluster, and update_persistant_statement_to_cluster().

Referenced by cluster_stage_spire_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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:

◆ 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;
 }