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

Functions
bool	scalopify (char *)
	Warning! Do not modify this file that is automatically generated! More...

bool	sesamify (char *)

bool	scalopragma (char *)

bool	sesam_buffers_processing (const char *)
	sesam_tasks_processing.c More...

bool	sesam_servers_processing (const char *)

Variables
hash_table	shared_mem
	sesamify.c More...

hash_table	entity_action

list	statement_to_outline
	scalopragma.c More...

Function Documentation

◆ scalopify()

bool scalopify ( char * module_name )

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

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

wo cases: vector or scalar

Parameters

module_name odule_name

Definition at line 94 of file scalopify.c.

                                    {
  
   // Use this module name and this environment variable to set
   statement module_statement = PIPS_PHASE_PRELUDE(module_name,
                                                   "SCALOPIFY_DEBUG_LEVEL");
   set entities_to_wrap=set_make(set_pointer);
   list call_to_wrap=NIL;
  
   expression exp;
   type t;
  
   entity get_call_entity = local_name_to_top_level_entity("P4A_scmp_flow");
  
   set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  
   gen_context_recurse(module_statement,&entities_to_wrap,
     call_domain, find_entities_to_wrap, gen_null2);
  
   gen_context_recurse(module_statement, &call_to_wrap,
     call_domain, find_call_to_wrap, gen_null2);
  
   FOREACH(CALL, c , call_to_wrap){
  
     if(!call_load_store_p(c)){
  
       SET_FOREACH(entity, e, entities_to_wrap){
  
         /*Two cases: vector or scalar*/
         if(entity_array_p(e)) { 
  
          exp =  MakeUnaryCall(get_call_entity, entity_to_expression(e));
  
           if(!pointer_to_array_p(e)){
             t = convert_local_to_pointer_array(entity_type(e));
           }
           else{
             t= entity_type(e);
           }
  
           exp = make_expression( make_syntax_cast(make_cast(t,exp)) ,normalized_undefined);
         }
         else{
  
           basic b   = make_basic_pointer(copy_type(entity_type(e)));
           t   = make_type_variable(make_variable(b,NIL,NIL));
  
           exp = MakeUnaryCall(entity_intrinsic(ADDRESS_OF_OPERATOR_NAME), entity_to_expression(e));
           exp = MakeUnaryCall(get_call_entity, exp);
           exp = make_expression(make_syntax_cast(make_cast(t, exp)),normalized_undefined);
           exp = MakeUnaryCall(entity_intrinsic(DEREFERENCING_OPERATOR_NAME), exp);
         }
         replace_entity_by_expression(c, e, exp);
       }    
     }
   }
  
  
  
   gen_free_list(call_to_wrap);
   set_free(entities_to_wrap);
  
   // We may have outline some code, so recompute the callees:
   DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name,
                          compute_callees(get_current_module_statement()));
  
   reset_cumulated_rw_effects();
   // Put back the new statement module
   PIPS_PHASE_POSTLUDE(module_statement);
  
   return true;
 }

References ADDRESS_OF_OPERATOR_NAME, CALL, call_domain, call_load_store_p(), compute_callees(), convert_local_to_pointer_array(), copy_type(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, DEREFERENCING_OPERATOR_NAME, entity_array_p(), entity_intrinsic(), entity_to_expression(), entity_type, exp, find_call_to_wrap(), find_entities_to_wrap(), FOREACH, gen_context_recurse, gen_free_list(), gen_null2(), get_current_module_statement(), local_name_to_top_level_entity(), make_basic_pointer(), make_cast(), make_expression(), make_syntax_cast(), make_type_variable(), make_variable(), MakeUnaryCall(), module_name(), module_statement, NIL, normalized_undefined, PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, pointer_to_array_p(), replace_entity_by_expression(), reset_cumulated_rw_effects(), set_cumulated_rw_effects(), SET_FOREACH, set_free(), set_make(), and set_pointer.

Here is the call graph for this function:

◆ scalopragma()

bool scalopragma ( char * module_name )

ook for statement with SCMP pragma

elete statement pragma

Parameters

module_name odule_name

Definition at line 59 of file scalopragma.c.

                                      {
   
   // Use this module name and this environment variable to set
   statement module_statement = PIPS_PHASE_PRELUDE(module_name,
                                                   "SCALOPRAGMA_DEBUG_LEVEL");
   
   set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
   
   statement_to_outline=NIL;
   
   /*look for statement with SCMP pragma*/
   gen_recurse(module_statement, statement_domain, find_pragma, gen_null);
  
   statement_to_outline = gen_nreverse(statement_to_outline);
  
   FOREACH(STATEMENT, stmt, statement_to_outline){
  
     /*delete statement pragma*/
     extensions_extension(statement_extensions(stmt))=NIL;
  
     outliner(build_new_top_level_module_name(get_string_property("GPU_LAUNCHER_PREFIX"), false ), CONS(STATEMENT,stmt,NIL));
   }
  
   gen_free_list(statement_to_outline);
   
   // We may have outline some code, so recompute the callees:
   DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name,
                          compute_callees(get_current_module_statement()));
   
   reset_cumulated_rw_effects();
   // Put back the new statement module
   PIPS_PHASE_POSTLUDE(module_statement);
   
   return true;
 }

References build_new_top_level_module_name(), compute_callees(), CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, extensions_extension, find_pragma(), FOREACH, gen_free_list(), gen_nreverse(), gen_null(), gen_recurse, get_current_module_statement(), get_string_property(), module_name(), module_statement, NIL, outliner(), PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, reset_cumulated_rw_effects(), set_cumulated_rw_effects(), STATEMENT, statement_domain, statement_extensions, and statement_to_outline.

Here is the call graph for this function:

◆ sesam_buffers_processing()

bool sesam_buffers_processing ( const char * module_name )

sesam_tasks_processing.c

Parameters

module_name is the current module name

Parameters

module_name odule_name

Definition at line 420 of file sesam_tasks_processing.c.

 {
   // Use this module name and this environment variable to set
   statement module_statement = PIPS_PHASE_PRELUDE(module_name,
                                                   "SCALOPES_DEBUG_LEVEL");
   sesam_buffers_processing_context sbp_context
     = sesam_buffers_processing_context_undefined;
  
   sbp_context_init(&sbp_context);
  
   // use cumulated effects for the moment, regions can be used later if need be
   set_cumulated_rw_effects((statement_effects)
                            db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  
   set_methods_for_rw_effects_prettyprint(module_name);
   gen_context_recurse(module_statement, &sbp_context,
                       statement_domain, update_sesam_tasks_buffers, gen_null2);
   reset_methods_for_effects_prettyprint(module_name);
   print_sesam_tasks_buffers_header(module_name, sbp_context);
  
   reset_cumulated_rw_effects();
  
   free_sesam_buffers_processing_context(sbp_context);
   // Put back the new statement module
   PIPS_PHASE_POSTLUDE(module_statement);
  
   return (true);
 }

References db_get_memory_resource(), free_sesam_buffers_processing_context(), gen_context_recurse, gen_null2(), module_name(), module_statement, PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, print_sesam_tasks_buffers_header(), reset_cumulated_rw_effects(), reset_methods_for_effects_prettyprint(), sbp_context_init(), sesam_buffers_processing_context_undefined, set_cumulated_rw_effects(), set_methods_for_rw_effects_prettyprint(), statement_domain, and update_sesam_tasks_buffers().

Here is the call graph for this function:

◆ sesam_servers_processing()

bool sesam_servers_processing ( const char * module_name )

Parameters

module_name odule_name

Definition at line 449 of file sesam_tasks_processing.c.

 {
   // Use this module name and this environment variable to set
   statement module_statement = PIPS_PHASE_PRELUDE(module_name,
                                                   "SCALOPES_DEBUG_LEVEL");
  
   // Put back the new statement module
   PIPS_PHASE_POSTLUDE(module_statement);
  
   return (true);
 }

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

Here is the call graph for this function:

◆ sesamify()

bool sesamify ( char * module_name )

ist effects in the task

heck if the entities has already been processed with the same action to avoid doublons

f the entity is not stored yet

validate

ostlude

Parameters

module_name odule_name

Definition at line 52 of file sesamify.c.

                                   {
   debug_on("SESAMIFY_DEBUG_LEVEL");
   
   list args,args2,args3, args4, args5, malloc_statements, map_statements, unmap_statements, wait_statements, send_statements,  rw_effects, entity_declaration;
   callees callees_list = (callees) db_get_memory_resource(DBR_CALLEES, module_name, true);
   intptr_t id;
   entity reserve_data     = local_name_to_top_level_entity("sesam_reserve_data");
   entity get_page_size    = local_name_to_top_level_entity("sesam_get_page_size");
   entity data_assignation = local_name_to_top_level_entity("sesam_data_assignation");
   entity map_data         = local_name_to_top_level_entity("sesam_map_data");
   entity unmap_data       = local_name_to_top_level_entity("sesam_unmap_data");
   entity wait_dispo       = local_name_to_top_level_entity("sesam_wait_dispo");
   entity send_dispo       = local_name_to_top_level_entity("sesam_send_dispo");
   entity chown_data       = local_name_to_top_level_entity("sesam_chown_data");
   entity new, re;
   struct dma_action * val;
  
   shared_mem      = hash_table_make(hash_pointer,HASH_DEFAULT_SIZE);
   entity_action   = hash_table_make(hash_pointer,HASH_DEFAULT_SIZE);
  
   intptr_t counter = 1;
   int nb_task_total = gen_length(callees_callees(callees_list));
   int num_task=1;
  
   FOREACH(STRING,callee_name,gen_nreverse(callees_callees(callees_list))) {
  
     pips_debug(1,"%s\n", callee_name);
     //Change context
     set_current_module_entity(module_name_to_entity( callee_name ));
     set_current_module_statement((statement) db_get_memory_resource(DBR_CODE,
                                                                     callee_name,
                                                                     true));
     set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS,
                                                                        callee_name,
                                                                        true));
  
     //reset tables
     hash_table_clear(entity_action);
  
     rw_effects = load_cumulated_rw_effects_list(get_current_module_statement());
     map_statements     = NIL;
     malloc_statements  = NIL;
     unmap_statements   = NIL;
     wait_statements    = NIL;
     send_statements    = NIL;
     entity_declaration = NIL;
  
     /*list effects in the task*/
     FOREACH(EFFECT,e,rw_effects) {
  
       re = reference_variable(effect_any_reference(e));
  
        val = (struct dma_action *) hash_get(entity_action, re);
        /*check if the entities has already been processed with the same action to avoid doublons*/
       if(val==HASH_UNDEFINED_VALUE|| (action_read_p(effect_action(e)) && val->read==0) || (action_write_p(effect_action(e)) && val->write==0)){
  
         /*if the entity is not stored yet*/
         if(val==HASH_UNDEFINED_VALUE)
           val = (struct dma_action *) malloc(sizeof(struct dma_action));
         //flags entity effects
         if(action_read_p(effect_action(e)))
           val->read=1;
         else
           val->write=1;
  
         //MEMORY ALLOCATION
         if(hash_get(shared_mem,re)==HASH_UNDEFINED_VALUE){
           //shared memory ID
           id=counter-1;
           hash_put(shared_mem, re, (void*)counter);
           //compute table memory size
           range the_range = make_range(int_to_expression(0),
                                      make_op_exp(MINUS_OPERATOR_NAME,
                                                  make_expression(make_syntax_sizeofexpression(make_sizeofexpression_type(entity_type(re))),
                                                                  normalized_undefined),
                                                  int_to_expression(1)),
                                      int_to_expression(1));
  
           expression memory_size  = range_to_expression(the_range,range_to_distance);
           expression size = MakeBinaryCall(entity_intrinsic(DIVIDE_OPERATOR_NAME),
                                            memory_size,
                                            call_to_expression(make_call(get_page_size,NIL)));
  
           size = MakeBinaryCall(entity_intrinsic(PLUS_OPERATOR_NAME),
                                 size,
                                 int_to_expression(1));
           args  = make_expression_list(size);
  
           args2 = CONS(EXPRESSION, int_to_expression(1), NIL);
           args2 = CONS(EXPRESSION, size,args2);
           args2 = CONS(EXPRESSION, int_to_expression(counter-1),args2);
  
           malloc_statements=CONS(STATEMENT,
                                  instruction_to_statement(make_instruction_call(make_call(reserve_data,args))),
                                  malloc_statements);
           malloc_statements=CONS(STATEMENT,
                                  instruction_to_statement(make_instruction_call(make_call(data_assignation,args2))),
                                  malloc_statements);
           counter++;
         }
         else{
           id = (intptr_t) hash_get(shared_mem, re)-1;
         }
  
         //MAP_DATA + pointer creation +UNMAP + CHMOD
         type t = convert_local_to_pointer_array(entity_type(re));
         new = make_new_scalar_variable(get_current_module_entity(),
                                               make_basic_pointer(t));
         entity_declaration = CONS(ENTITY,new, entity_declaration);
         args3 =  make_expression_list(int_to_expression(id));
         expression map_data_exp = call_to_expression(make_call(map_data,args3));
         expression new_exp = entity_to_expression(new);
         replace_entity_by_expression(get_current_module_statement(), re, new_exp);
         args4 = CONS(EXPRESSION,map_data_exp, NIL);
         args4 = CONS(EXPRESSION,new_exp,args4);
  
         map_statements=CONS(STATEMENT,
                             instruction_to_statement(make_instruction_call(make_call(entity_intrinsic(ASSIGN_OPERATOR_NAME),args4))),
                             map_statements);
         unmap_statements=CONS(STATEMENT,
                               instruction_to_statement(make_instruction_call(make_call(unmap_data,make_expression_list(new_exp)))),
                               unmap_statements);
  
         //change data owner
         if(num_task < nb_task_total){
           args5 =  make_expression_list(int_to_expression(id),int_to_expression(num_task));
           unmap_statements=CONS(STATEMENT,
                                 instruction_to_statement(make_instruction_call(make_call(chown_data,args5))),
                                 unmap_statements);
         }
  
         //SEND + WAIT dispo
         print_effect(e);
         if(action_read_p(effect_action(e))){
           print_entities(CONS(ENTITY,re,NIL));
           pips_debug(1,"READ\n");
           wait_statements=CONS(STATEMENT,
                                instruction_to_statement(make_instruction_call(make_call(wait_dispo,
                                                                                         make_expression_list(int_to_expression(id),
                                                                                                              int_to_expression(0),
                                                                                                              int_to_expression(0),
                                                                                                              int_to_expression(0))))),
                                wait_statements);
           send_statements=CONS(STATEMENT,
                                instruction_to_statement(make_instruction_call(make_call(send_dispo,
                                                                                         make_expression_list(int_to_expression(id),
                                                                                                              int_to_expression(0),
                                                                                                              int_to_expression(1))))),
                                send_statements);
         }
         else{
           print_entities(CONS(ENTITY,re,NIL));
           pips_debug(1,"WRITE\n");
           wait_statements=CONS(STATEMENT,
                                instruction_to_statement(make_instruction_call(make_call(wait_dispo,
                                                                                         make_expression_list(int_to_expression(id),
                                                                                                              int_to_expression(0),
                                                                                                              int_to_expression(1),
                                                                                                              int_to_expression(0))))),
                                wait_statements);
            send_statements=CONS(STATEMENT,
                                 instruction_to_statement(make_instruction_call(make_call(send_dispo,
                                                                                          make_expression_list(int_to_expression(id),
                                                                                                               int_to_expression(0),
                                                                                                               int_to_expression(0))))),
                                 send_statements);
         }
       }
     }
  
     //insert all statements
     insert_statement(get_current_module_statement(),
                        make_block_statement(gen_nreverse(wait_statements)),true);
     insert_statement(get_current_module_statement(),
                        make_block_statement(gen_nreverse(map_statements)),true);
     insert_statement(get_current_module_statement(),
                        make_block_statement(gen_nreverse(malloc_statements)),true);
     insert_statement(get_current_module_statement(),
                        make_block_statement(gen_nreverse(send_statements)),false);
     insert_statement(get_current_module_statement(),
                        make_block_statement(gen_nreverse(unmap_statements)),false);
  
     //add declaration
     FOREACH(ENTITY,ent,entity_declaration){
       AddEntityToCurrentModule(ent);
     }
  
     /* validate */
     module_reorder(get_current_module_statement());
     DB_PUT_MEMORY_RESOURCE(DBR_CODE, callee_name,
                            get_current_module_statement());
     DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, callee_name,
                            compute_callees(get_current_module_statement()));
  
     /*postlude*/
     reset_cumulated_rw_effects();
     reset_current_module_entity();
     reset_current_module_statement();
     num_task++;
   }
  
   debug_off();
   return true;
 }