wp65.h File Reference

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

Go to the source code of this file.

Macros
#define	WP65_INCLUDED
	Warning! Do not modify this file that is automatically generated! More...
#define	EMULATED_SHARED_MEMORY_PREFIX   "ES_"
#define	LOCAL_MEMORY_PREFIX   "L_"
#define	LOCAL_MEMORY_SEPARATOR   "_"
#define	COMPUTE_ENGINE_NAME   "WP65"
#define	BANK_NAME   "BANK"
	#define WP65_SUFFIX "_WP65" More...
#define	PROCESSOR_IDENTIFIER   "PROC_ID"
	#define MEMORY_EMULATOR_SUFFIX "_BANK" More...
#define	BANK_IDENTIFIER   "BANK_ID"
#define	BANK_LINE_IDENTIFIER   "L"
#define	BANK_OFFSET_IDENTIFIER   "O"
#define	SUFFIX_FOR_INDEX_TILE_IN_INITIAL_BASIS   "_1"
#define	SUFFIX_FOR_INDEX_TILE_IN_TILE_BASIS   "_0"
#define	PREFIX_FOR_LOCAL_TILE_BASIS   "L_"
#define	PIPELINE_DEPTH   1
	These values should be read in model.rc (FI, 20/11/91) #define PROCESSOR_NUMBER 4 #define BANK_NUMBER 4 #define LINE_SIZE 25 More...
#define	MAXIMUM_LOCAL_VARIABLE_NAME_SIZE   256

Functions
void	eval_variable_in_statement (entity, statement, Variable, int)
void	tile_change_of_basis (Psysteme, Pbase, Pbase, Pbase, tiling)
statement	make_scanning_over_tiles (entity, list, entity, int, tiling, Pbase, Pbase, Pbase, Psysteme, int, int)
	make_scanning_over_tiles() More...
statement	make_scanning_over_one_tile (entity, statement, tiling, Pbase, Pbase, Pbase, Pbase, Psysteme, int, int)
	make_scanning_over_one_tile(): More...
list	make_compute_block (entity, statement, Pvecteur, hash_table, tiling, Pbase, Pbase, Pbase, Pbase, Psysteme, int, int)
list	reference_conversion_statement (entity, statement, list *, hash_table, Pvecteur, Pbase, Pbase, Pbase, tiling)
	void reference_conversion_statement(body, r_to_llv, offsets, initial_basis, local_basis): More...
list	reference_conversion_computation (entity, list *, expression, Pbase, Pbase, Pbase, tiling)
entity	reference_translation (reference, Pbase, Pbase)
void	reference_conversion_expression (expression, hash_table, Pvecteur, Pbase, Pbase)
bool	uniform_dependence_p (reference, reference)
	This function checks if two references have a uniform dependence. More...
list	classify_reference (list, reference)
	This function classifies the references in lists. More...
Psysteme	build_sc_with_several_uniform_ref (entity, cons *, Psysteme, Pbase *)
	build_sc_with_several_uniform_ref(): More...
void	make_store_blocks (entity, entity, entity, entity, entity, entity, list, hash_table, Psysteme, Pbase, Pbase, Pbase, Pbase, entity, int, int, int, statement *, statement *, int, int)
void	make_load_blocks (entity, entity, entity, entity, entity, entity, list, hash_table, Psysteme, Pbase, Pbase, Pbase, Pbase, entity, int, int, int, statement *, statement *, int, int)
Psysteme	tile_membership (matrice, Pbase, Pbase)
	Psysteme tile_membership(P, origin, member): More...
tiling	loop_nest_to_tile (Psysteme, int, Pbase, int, int, int)
	tiling.c More...
void	loop_nest_to_local_variables (entity, entity, entity, hash_table, hash_table, hash_table, hash_table, hash_table, hash_table, list, statement, Pbase, graph, int, int, int, tiling)
	variable.c More...
entity	make_emulated_shared_variable (entity, entity, int, int)
entity	find_or_create_emulated_shared_variable (entity, entity, hash_table, int, int)
list	make_new_local_variables (entity, entity, int, int, hash_table)
bool	reference_conflicting_test_and_update (reference, graph, hash_table, hash_table, hash_table, hash_table)
	reference_conflicting_test_and_update(): More...
bool	reference_conflicting_p (reference, reference, graph)
Psysteme	make_tile_constraints (matrice, Pbase)
	Psysteme make_tile_constraints(P, b): More...
void	set_dimensions_of_local_variables (hash_table, Pbase, tiling, hash_table)
void	set_dimensions_of_local_variable_family (list, Psysteme, list, tiling, int)
	void set_dimensions_of_local_variable_family(llv, tc, lr): More...
bool	list_of_calls_p (list)
	instruction_to_wp65_code.c More...
entity	ith_index_of_ref (reference, int)
loop	ith_loop_in_loop_nest (statement, int)
void	instruction_to_wp65_code (entity, list, graph, int, int, int, int, entity, entity, Pbase, hash_table, hash_table, entity, statement, entity, statement, statement_mapping, statement_mapping)
void	call_to_wp65_code (statement, entity, entity, entity, entity, statement, statement, statement_mapping, statement_mapping, hash_table)
expression	ref_in_implied_do (expression)
	This function extracts from an implied_do expression the reference having to be computed or printed. More...
reference	translate_IO_ref (call, hash_table, bool)
	This function translates a reference in I/O statement into its corresponding emulated shared memory reference. More...
statement	generate_io_wp65_code (statement, statement, hash_table, bool)
bool	io_loop_nest_p (statement)
	Test if the statement resulting from the perfectly_loop_nest_to_body function contains at first call an io. More...
void	loop_nest_movement_generation (entity, statement, int, int, int, int, entity, entity, Pbase, hash_table, hash_table, entity, statement, entity, statement, statement_mapping, statement_mapping, statement, bool, Psysteme, Pbase, Pbase, Pbase, Pbase, Pbase, Pbase, list, list *, list *, list *, list *, int, int, hash_table, hash_table, hash_table, hash_table)
void	loop_nest_to_wp65_code (entity, statement, graph, int, int, int, int, entity, entity, Pbase, hash_table, hash_table, entity, statement, entity, statement, statement_mapping, statement_mapping, statement)
void	make_all_movement_blocks (entity, entity, entity, entity, list, hash_table, hash_table, hash_table, hash_table, int, int, int, Psysteme, Pbase, Pbase, entity, Pbase, Pbase, list *, list *, tag, int, int)
	generates all data movements related to entity v, loads or stores depending on use_def More...
void	search_parallel_loops (statement, statement, graph, bool[11])
bool	full_parallel_loop_nest_p (statement, statement, int, graph, bool *)
bool	fetch_map_undefined_p (void)
	wp65.c More...
void	set_fetch_map (statement_mapping)
statement_mapping	get_fetch_map (void)
void	reset_fetch_map (void)
void	free_fetch_map (void)
void	make_fetch_map (void)
list	load_statement_fetch (statement)
void	delete_statement_fetch (statement)
bool	statement_fetch_undefined_p (statement)
void	store_statement_fetch (statement, list)
void	update_statement_fetch (statement, list)
bool	store_map_undefined_p (void)
void	set_store_map (statement_mapping)
statement_mapping	get_store_map (void)
void	reset_store_map (void)
void	free_store_map (void)
void	make_store_map (void)
list	load_statement_store (statement)
void	delete_statement_store (statement)
bool	statement_store_undefined_p (statement)
void	store_statement_store (statement, list)
void	update_statement_store (statement, list)
entity	MakeEntityFunction (string)
bool	wp65 (const string)
void	module_to_wp65_modules (entity, statement, graph, int, int, int, int, entity *, statement *, entity *, statement *)
void	fprint_wp65_hash_tables (FILE *, hash_table, hash_table, hash_table, hash_table, hash_table)
	Ignore this function: debugging purposes only. More...
bool	wp65_conform_p (statement)
entity	create_local_index (entity, Pvecteur, string)
	basis.c More...
entity	create_local_index2 (entity, Pvecteur, string)
void	create_tile_basis (entity, entity, entity, Pbase, Pbase *, Pbase *, Pbase *, Pbase *, Pbase *)
void	find_iteration_domain (statement, Psysteme *, Pbase *, int *, list *, instruction *)
	find_iteration_domain.c More...
void	compute_iteration_domain (list, Psysteme *, Pbase *)
void	iteration_domain_from_statement (list *, statement, int *, list *, instruction *)
void	model_fprint (FILE *, int, int, int)
	model.c More...
void	model_fscan (FILE *, int *, int *, int *)
void	get_model (int *, int *, int *)
bool	ref_in_list_p (list, reference)
	references.c More...
void	update_map (statement_mapping, statement, reference)
list	expression_to_operand_list (expression, list)
	This function gives the list of operands belonging to Expression e. More...
bool	reference_in_list_p (reference, list)
	This function tests whether at least one array indice of Reference r belongs to List lwr or not. More...
bool	array_indice_in_list_p (reference, list)
void	reference_list_update (list *, reference)
	This function add Reference r to List l, if r doesn't belong to l. More...
void	reference_list_add (list *, list *)
	This function adds all the references of l2 to l1 if they don't appear in l1. More...
void	reference_list_print (list)
	This function prints the references belonging to l. More...
void	reference_scalar_defined_p (reference)
void	variable_list_update (list *, reference)
	This function adds the reference r to List l, if the reference_variable(r) doesn't belong to l. More...
void	variable_list_add (list *, list *)
	This function adds all the references of l2 to l1 if they don't appear in l1. More...
void	concat_data_list (list *, list *, statement, statement_mapping, bool)
void	call_instruction_to_communications (statement, statement, statement, list *, list *, statement_mapping *, statement_mapping *, hash_table, list *)
	communications.c More...
void	loop_instruction_to_communications (statement, statement, statement, list *, list *, statement_mapping *, statement_mapping *, hash_table, list *)
	This function associates to each variable in the loop the statement where it should be communicated (this statement may be external to the loop). More...
void	statement_to_communications (statement, statement, statement, list *, list *, statement_mapping *, statement_mapping *, hash_table, list *)
	This function associates to each variable in stmt the statement where it should be communicated. More...
void	compute_communications (list, statement_mapping *, statement_mapping *)
	This function associates to each variable the statement in l where it should be communicated Fecth_map contains for each statement the list of variables having to be communicated before its execution. More...
void	include_constant_symbolic_communication (entity, list, bool, statement, entity)
list	array_scalar_access_to_bank_communication (entity, Pbase, int, int, list, bool, entity, entity, bool)
void	insert_run_time_communications (entity, entity, Pbase, int, int, entity, list, statement_mapping, statement_mapping, list *, list *, hash_table, bool, Pbase, tiling, Pvecteur, Pvecteur, Pvecteur)
bool	test_run_time_communications (list, statement_mapping, statement_mapping)

Variables
Value	offset_dim1
	WP65_INCLUDED. More...
Value	offset_dim2

Macro Definition Documentation

BANK_IDENTIFIER

#define BANK_IDENTIFIER   "BANK_ID"

Definition at line 50 of file wp65.h.

BANK_LINE_IDENTIFIER

#define BANK_LINE_IDENTIFIER   "L"

Definition at line 51 of file wp65.h.

BANK_NAME

#define BANK_NAME   "BANK"

#define WP65_SUFFIX "_WP65"

Definition at line 47 of file wp65.h.

BANK_OFFSET_IDENTIFIER

#define BANK_OFFSET_IDENTIFIER   "O"

Definition at line 52 of file wp65.h.

COMPUTE_ENGINE_NAME

#define COMPUTE_ENGINE_NAME   "WP65"

Definition at line 45 of file wp65.h.

EMULATED_SHARED_MEMORY_PREFIX

#define EMULATED_SHARED_MEMORY_PREFIX   "ES_"

Definition at line 42 of file wp65.h.

LOCAL_MEMORY_PREFIX

#define LOCAL_MEMORY_PREFIX   "L_"

Definition at line 43 of file wp65.h.

LOCAL_MEMORY_SEPARATOR

#define LOCAL_MEMORY_SEPARATOR   "_"

Definition at line 44 of file wp65.h.

MAXIMUM_LOCAL_VARIABLE_NAME_SIZE

#define MAXIMUM_LOCAL_VARIABLE_NAME_SIZE   256

Definition at line 68 of file wp65.h.

PIPELINE_DEPTH

#define PIPELINE_DEPTH   1

These values should be read in model.rc (FI, 20/11/91) #define PROCESSOR_NUMBER 4 #define BANK_NUMBER 4 #define LINE_SIZE 25

FI: PIPELINE_DEPTH should be set to 3

Definition at line 66 of file wp65.h.

PREFIX_FOR_LOCAL_TILE_BASIS

#define PREFIX_FOR_LOCAL_TILE_BASIS   "L_"

Definition at line 56 of file wp65.h.

PROCESSOR_IDENTIFIER

#define PROCESSOR_IDENTIFIER   "PROC_ID"

#define MEMORY_EMULATOR_SUFFIX "_BANK"

Definition at line 49 of file wp65.h.

SUFFIX_FOR_INDEX_TILE_IN_INITIAL_BASIS

#define SUFFIX_FOR_INDEX_TILE_IN_INITIAL_BASIS   "_1"

Definition at line 54 of file wp65.h.

SUFFIX_FOR_INDEX_TILE_IN_TILE_BASIS

#define SUFFIX_FOR_INDEX_TILE_IN_TILE_BASIS   "_0"

Definition at line 55 of file wp65.h.

WP65_INCLUDED

#define WP65_INCLUDED

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

Modify src/Libs/wp65/wp65-local.h instead, to add your own modifications. header file built by cproto wp65-local.h Header File for WP65

Francois Irigoin, Corinne Ancourt, Lei Zhou

September 1991

Definition at line 40 of file wp65.h.

Function Documentation

array_indice_in_list_p()

bool array_indice_in_list_p	(	reference	r,
		list	lwr
	)

Parameters

lwr

wr

Definition at line 140 of file references.c.

{ 
 
    list lr = NIL;
    bool result = false;
    list lref1;
    MAPL(ce,{    expression e = EXPRESSION(CAR(ce));
                 lr = expression_to_reference_list(e, lr);
             },
         reference_indices(r));
    for (lref1 = lr; 
         lref1 != NIL && !result;
         result = result || reference_in_list_p(REFERENCE(CAR(lref1)),
                                                lwr),
         lref1 = CDR(lref1));
   
    return result;
}

References CAR, CDR, EXPRESSION, expression_to_reference_list(), MAPL, NIL, REFERENCE, reference_in_list_p(), and reference_indices.

Referenced by call_instruction_to_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

array_scalar_access_to_bank_communication()

list array_scalar_access_to_bank_communication	(	entity	memory_module,
		Pbase	bank_indices,
		int	bn,
		int	ls,
		list	lt,
		bool	load_code,
		entity	proc_id,
		entity	var_id,
		bool	fully_sequential
	)

Generation of the emulated shared memory code corresponding to the transfer of a scalar array element :

CALL BANK_RECEIVE_4(PROC_ID, X1, 1) CALL BANK_RECEIVE_4(PROC_ID, L, 1) CALL BANK_RECEIVE_4(PROC_ID, O, 1) IF (BANK_ID = X1) THEN CALL BANK_SEND_4(PROC_ID, ES_B(O,L), 1) ENDIF

Parameters

memory_module	emory_module
bank_indices	ank_indices
bn	n
ls	s
lt	t
load_code	oad_code
proc_id	roc_id
var_id	ar_id
fully_sequential	ully_sequential

Definition at line 527 of file communications.c.

{   
  pips_assert("true", ls==ls);
  
    reference ref1 = make_reference((entity) bank_indices->succ->var,NIL);
    reference ref2 =  make_reference((entity) bank_indices->succ->succ->var,NIL);
    list lst = CONS(REFERENCE,make_reference(var_id,NIL),
                    CONS(REFERENCE,ref1, CONS(REFERENCE,ref2,NIL)));
    if (!fully_sequential) {
        /* 
           Generation of the emulated shared memory code corresponding to 
           the transfer of a scalar array element :
           
           CALL BANK_RECEIVE_4(PROC_ID, X1, 1)
           CALL BANK_RECEIVE_4(PROC_ID, L, 1)
           CALL BANK_RECEIVE_4(PROC_ID, O, 1)
           IF (BANK_ID = X1) THEN
           CALL BANK_SEND_4(PROC_ID, ES_B(O,L), 1)
           ENDIF
           */
        list ccode= constant_symbolic_communication(memory_module,
                                                    lst,!load_code,proc_id); 
        list tcode = constant_symbolic_communication(memory_module,
                                                     lt,load_code,proc_id);
        expression exp1 =make_vecteur_expression(vect_new(bank_indices->var,
                                                          VALUE_ONE));
        expression exp2 = make_vecteur_expression(vect_new((Variable) var_id,
                                                           VALUE_ONE));
        expression test_bound = MakeBinaryCall(entity_intrinsic(EQUAL_OPERATOR_NAME),exp1,exp2);
        statement testbody = make_block_statement(tcode);
        statement stat = make_test_statement(test_bound,testbody,
            make_empty_block_statement());
        return (gen_nconc(ccode,CONS(STATEMENT,stat,NIL)));
    } 
    else { 
        entity  ent1 = make_new_module_variable(memory_module,100);
        list ccode= constant_symbolic_communication(memory_module,lst,
                                                    !load_code,(entity) bank_indices->var); 
        list icode= constant_symbolic_communication(memory_module,lt,
                                                    load_code,ent1);
        range looprange = make_range(int_to_expression(0),
                                     int_to_expression(bn-1),
                                     int_to_expression(1));
        statement loopbody = make_block_statement(icode);
        entity looplabel = make_loop_label(9000, memory_module);
        
        loop newloop = make_loop(ent1,looprange, loopbody, looplabel, 
                                 make_execution(is_execution_parallel,UU), NIL);
 
        statement  stat = loop_to_statement(newloop);
        AddEntityToDeclarations(ent1,memory_module);
        icode = gen_nconc(ccode,CONS(STATEMENT,stat,NIL));
        return icode;
    }
}

References AddEntityToDeclarations(), CONS, constant_symbolic_communication(), entity_intrinsic(), EQUAL_OPERATOR_NAME, gen_nconc(), int_to_expression(), is_execution_parallel, loop_to_statement, make_block_statement(), make_empty_block_statement(), make_execution(), make_loop(), make_loop_label(), make_new_module_variable(), make_range(), make_reference(), make_test_statement(), make_vecteur_expression(), MakeBinaryCall(), NIL, pips_assert, REFERENCE, STATEMENT, Svecteur::succ, UU, VALUE_ONE, Svecteur::var, and vect_new().

Referenced by insert_array_scalar_access_movement().

Here is the call graph for this function:

Here is the caller graph for this function:

build_sc_with_several_uniform_ref()

Psysteme build_sc_with_several_uniform_ref	(	entity	module,
		cons *	lr,
		Psysteme	sc_domain,
		Pbase *	new_index_base
	)

build_sc_with_several_uniform_ref():

Build the set of constraints describing the array function for the set of uniform references to the array and update the system describing the domain with constraints on new variables

build the system of constraints describing the array function. One constraint for each dimension of the array is built. This constraint is put in the system of inequalities of sc_array_function

update the system describing the image function with the others array functions having a uniform dependence with the first one for example, assume we have A(i,j) and A(i+2,j+3)
then the final system will be : i + 2 X1 <= 0 j - 3 X1 <= 0 X1 is new variable

add to the system of constraints describing the domain the set of constraints on the new variables. If X1,X2,...Xn are these new variables the set of constraints added is: 0 <= X1 <= 1 0 <= X2 <= 1 - X1 0 <= X3 <= 1 - X1 -X2 0<= Xn <= 1 - X1 - X2 ... -Xn-1

Parameters

module	odule
lr	r
sc_domain	c_domain
new_index_base	ew_index_base

Definition at line 1011 of file code.c.

{
    cons * expr;
 
    Psysteme sc_array_function = sc_new();
    Psysteme sc2;
    Pcontrainte pc,pc3=NULL;
    Pvecteur pv,pv1,pv2,pv3;
    Pvecteur pv_sup = VECTEUR_NUL;
    normalized norm;
    reference r;
    cons * ind; 
    Variable var=VARIABLE_UNDEFINED;
    Value cst = VALUE_ZERO;
    Pcontrainte pc1,pc2;
    expression expr1;
 
    debug(8,"build_sc_with_several_uniform_ref", "begin\n");
    ifdebug(8) {
        list crefs;
        (void) fprintf(stderr, "Associated reference list:");
        for(crefs=lr; !ENDP(crefs); POP(crefs)) {
            reference r1 = REFERENCE(CAR(crefs));
            print_reference(r1);
            if(ENDP(CDR(crefs)))
                (void) putc('\n', stderr);
            else
                (void) putc(',', stderr);
        }
    }
 
 
    r= REFERENCE(CAR(lr));
    ind = reference_indices(r);
    
    /* build the system of constraints describing the array function. 
       One constraint for each dimension of the array is built. 
       This constraint is put in the system of inequalities of 
       sc_array_function */
 
    for (expr = ind;expr!= NULL; expr = CDR(expr)) {
        expr1 = EXPRESSION(CAR(expr));
        norm = (normalized) NORMALIZE_EXPRESSION(expr1);
        if (normalized_linear_p(norm)) {
            pv1 = (Pvecteur) normalized_linear(norm);
            pc =  contrainte_make(vect_dup(pv1));
            if (sc_array_function->inegalites == NULL) {
                sc_array_function->inegalites = pc;
            }
            else pc3->succ = pc;
            pc3=pc;
            sc_array_function->nb_ineq ++;
        }
        else {
            pips_internal_error("Non-linear subscript expression");
        }
    }
    sc_creer_base(sc_array_function);
 
    /* update the system describing the image function with the others array 
       functions having a uniform dependence with the first one 
       for example, assume we have  A(i,j) and A(i+2,j+3)  
       then the final system will be :
       i + 2 X1 <= 0
       j - 3 X1 <= 0
       X1 is new variable
       */
    sc2 =sc_dup(sc_dup(sc_array_function));
    for (lr = CDR(lr); lr != NIL;lr = CDR(lr)) {
        bool new_variable = false;
        r= REFERENCE(CAR(lr));
        ind = reference_indices(r);
        for (expr = ind,pc = sc_array_function->inegalites,
             pc2 = sc2->inegalites;
             expr!= NULL; expr = CDR(expr), pc=pc->succ,pc2 = pc2->succ) {
 
            norm = (normalized)  NORMALIZE_EXPRESSION(EXPRESSION(CAR(expr)));
            pv1 = (Pvecteur) normalized_linear(norm);
            pv3 = vect_substract(pv1,pc2->vecteur);
            if (vect_size(pv3) == 1) {
                if (value_notzero_p(cst=vecteur_val(pv3))) {
                    if (!new_variable) {
                        new_variable = true;
                        var = sc_add_new_variable_name(module,
                                                    sc_array_function);
                    
                        vect_chg_coeff(&pv_sup,var,VALUE_ONE);
                    }
                    vect_chg_coeff(&pc->vecteur,var,cst);
                }
            }
            else if (vect_size(pv3) >1) 
                pips_internal_error("Non uniform dependent references");
        }
    }
 
    /* add to the system of constraints describing the domain the 
       set of constraints on the new variables. If X1,X2,...Xn are these
       new variables the set of constraints added is:
       0 <= X1 <= 1
       0 <= X2 <= 1 - X1
       0 <= X3 <= 1 - X1 -X2
       0<= Xn <= 1 - X1 - X2 ... -Xn-1
       */
    for (pv = pv_sup; !VECTEUR_NUL_P(pv); pv = pv->succ) {
        sc_domain->base = vect_add_variable(sc_domain->base,pv->var);
        sc_domain->dimension++;
        *new_index_base = vect_add_variable(*new_index_base,pv->var);
        pv1 = vect_dup(pv);
        vect_chg_coeff(&pv1,TCST,VALUE_MONE);
        pc1= contrainte_make(pv1);
        sc_add_ineg(sc_domain,pc1);
        pv2 = vect_dup(pv);
        vect_chg_sgn(pv2);
        pc2 = contrainte_make(pv2);
        sc_add_ineg(sc_domain,pc2);
    }
 
    ifdebug(8) { 
        (void) fprintf(stderr," The array function :\n");
        (void) sc_fprint(stderr,sc_array_function,(string(*)(Variable))entity_local_name);
    }
 
    debug(8,"build_sc_with_several_uniform_ref", "end\n");
 
 
    return(sc_array_function);
}

References Ssysteme::base, CAR, CDR, contrainte_make(), debug(), Ssysteme::dimension, ENDP, entity_local_name(), EXPRESSION, fprintf(), ifdebug, Ssysteme::inegalites, module, Ssysteme::nb_ineq, new_variable, NIL, norm(), NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_internal_error, POP, print_reference(), REFERENCE, reference_indices, sc_add_new_variable_name(), sc_creer_base(), sc_dup(), sc_fprint(), sc_new(), Scontrainte::succ, Svecteur::succ, TCST, VALUE_MONE, value_notzero_p, VALUE_ONE, VALUE_ZERO, Svecteur::var, VARIABLE_UNDEFINED, vect_add_variable(), vect_chg_coeff(), vect_chg_sgn(), vect_dup(), vect_size(), vect_substract(), Scontrainte::vecteur, VECTEUR_NUL, VECTEUR_NUL_P, and vecteur_val.

Referenced by make_load_blocks(), and make_store_blocks().

Here is the call graph for this function:

Here is the caller graph for this function:

call_instruction_to_communications()

void call_instruction_to_communications	(	statement	s,
		statement	st_level1,
		statement	st_level2,
		list *	lwr,
		list *	lwr_local,
		statement_mapping *	fetch_map,
		statement_mapping *	store_map,
		hash_table	r_to_ud,
		list *	lpv
	)

communications.c

communications.c

first reference in statement s

Parameters

st_level1	t_level1
st_level2	t_level2
lwr	wr
lwr_local	wr_local
fetch_map	etch_map
store_map	tore_map
r_to_ud	_to_ud
lpv	pv

Definition at line 67 of file communications.c.

{
  pips_assert("true", r_to_ud==r_to_ud);
 
    if(assignment_statement_p(s)) {
        reference r;
        entity rv;
        list lexpr =
            call_arguments(instruction_call(statement_instruction(s)));
        /* first reference in statement s */
        bool first_reference = true;
 
        for(; !ENDP(lexpr); POP(lexpr)) {
            expression e = EXPRESSION(CAR(lexpr));
            list lr = expression_to_operand_list(e, NIL);
            if (lr != NIL) {
                list consr = lr;
                ifdebug(2) {
                    (void) fprintf(stderr, "reference list:");
                    print_reference_list(lr);
                    (void) fprintf(stderr, "first_reference=%s\n",
                                   bool_to_string(first_reference));
                }
                for(consr = lr; !ENDP(consr) ; POP(consr)) {
                    r = REFERENCE(CAR(consr));
                    rv = reference_variable(r);
                    if (first_reference) {
                        ifdebug(2) {
                            (void) fprintf(stderr,"list lwr_local:");
                            reference_list_print(*lwr_local);}
                        reference_list_update(lwr_local,r);
                        update_map(*store_map,st_level2,r);
                        first_reference = false;
                    }
                    else {
                         if(!entity_is_argument_p(rv, *lpv)) {
                           debug(8,"loop_nest_to_local_variables",
                           "Variable %s is not private\n",  
                                 entity_local_name(rv));
                        ifdebug(2) { 
                            (void) fprintf(stderr,"list lwr_local:");
                            reference_list_print(*lwr_local);
                            (void) fprintf(stderr,"list lwr : ");
                            reference_list_print(*lwr);} 
 
                        if (reference_scalar_p(r)) {
                            if (!reference_in_list_p(r,*lwr_local))
                            update_map(*fetch_map,st_level1,r); 
                        }
                        else {
                            if (array_indice_in_list_p(r,*lwr_local))
                                update_map(*fetch_map,s,r);
                            else if (array_indice_in_list_p(r,*lwr))
                                update_map(*fetch_map,st_level2,r);
                            else update_map(*fetch_map,st_level1,r);
                        }
                       }
                    }
                }
            }
        }
    }
    else { 
        ifdebug(9) 
            (void) fprintf(stderr, 
                           "call-communications - not assignment\n");
    }
}

References array_indice_in_list_p(), assignment_statement_p(), bool_to_string(), call_arguments, CAR, debug(), ENDP, entity_is_argument_p(), entity_local_name(), EXPRESSION, expression_to_operand_list(), fprintf(), ifdebug, instruction_call, NIL, pips_assert, POP, print_reference_list(), REFERENCE, reference_in_list_p(), reference_list_print(), reference_list_update(), reference_scalar_p(), reference_variable, statement_instruction, and update_map().

Referenced by statement_to_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

call_to_wp65_code()

void call_to_wp65_code	(	statement	s,
		entity	compute_module,
		entity	memory_module,
		entity	bank_id,
		entity	proc_id,
		statement	computational,
		statement	emulator,
		statement_mapping	fetch_map,
		statement_mapping	store_map,
		hash_table	v_to_esv
	)

To deal with implied_do and I/Os

communications for variables having to be loaded in local memories for assignments

communications for variables having to be stored in global memory for assignments

Parameters

compute_module	ompute_module
memory_module	emory_module
bank_id	ank_id
proc_id	roc_id
computational	omputational
emulator	mulator
fetch_map	etch_map
store_map	tore_map
v_to_esv	_to_esv

Definition at line 267 of file instruction_to_wp65_code.c.

{ 
    list lrefs;
    bool load_code = true;
    instruction i; 
    call c = instruction_call(statement_instruction(s));
    /* To deal with implied_do and I/Os */
 
 
    if (strcmp(entity_local_name(call_function(c)), "WRITE") == 0) {
        generate_io_wp65_code(s,s,v_to_esv,false);
        i = statement_instruction(emulator);
        instruction_block(i) = gen_nconc(instruction_block(i), 
                                         CONS(STATEMENT, 
                                              copy_statement(s), NIL));
    }
     else { /* communications for variables having to be 
              loaded in local memories  for assignments */
        if ((lrefs = (list) GET_STATEMENT_MAPPING(fetch_map,s))
            != (list) HASH_UNDEFINED_VALUE) { 
            ifdebug(9) { 
                (void) fprintf(stderr,
                               "Vars having to be loaded for stat %"PRIdPTR":\n",
                               statement_number(s));
                reference_list_print(lrefs); }    
            include_constant_symbolic_communication(compute_module,lrefs,
                                                    load_code,computational,
                                                    proc_id);
            include_constant_symbolic_communication(memory_module,lrefs,
                                                    !load_code,emulator,
                                                    bank_id);
        } 
        i = statement_instruction(computational);
        instruction_block(i) = gen_nconc(instruction_block(i), 
                                         CONS(STATEMENT, copy_statement(s), NIL));
         /* communications for variables having to be 
              stored in global memory  for assignments */
        if ((lrefs = (list) GET_STATEMENT_MAPPING(store_map,s))
            != (list) HASH_UNDEFINED_VALUE) {
            load_code = false;
            ifdebug(9) {
                (void) fprintf(stderr,
                               "Vars having to be stored for stat %"PRIdPTR":\n",
                               statement_number(s));
                reference_list_print(lrefs); }
            include_constant_symbolic_communication(compute_module,lrefs,
                                                    load_code,computational,proc_id);
            include_constant_symbolic_communication(memory_module,lrefs,
                                                    !load_code,emulator,bank_id);
        } 
     }
}

References call_function, CONS, copy_statement(), entity_local_name(), fprintf(), gen_nconc(), generate_io_wp65_code(), GET_STATEMENT_MAPPING, HASH_UNDEFINED_VALUE, ifdebug, include_constant_symbolic_communication(), instruction_block, instruction_call, NIL, reference_list_print(), STATEMENT, statement_instruction, and statement_number.

Referenced by instruction_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

classify_reference()

list classify_reference	(	list	llr,
		reference	r
	)

This function classifies the references in lists.

All the references belonging to the same list are uniform dependent references

Parameters

llr

lr

Definition at line 975 of file code.c.

{
    list plr,lr,bllr,lr2;
    list blr = NIL;
    bool trouve = false;
    reference r2;
 
    debug(8,"classify_reference", "begin\n");
    for (plr = llr,bllr = NIL; plr != NIL && !trouve; plr = CDR(plr)) {
        for (lr = LIST(CAR(plr)), blr=NIL; lr!= NIL && !trouve;
             lr = CDR(lr)) {
            r2 = REFERENCE(CAR(lr));
            if (uniform_dependence_p(r2,r)) 
                trouve = true;
        }
        blr = (trouve) ? CONS(REFERENCE,r,LIST(CAR(plr))) :
            LIST(CAR(plr));
        bllr = CONS(LIST,blr,bllr);  
    }
    if (!trouve) {
        lr2 = CONS(REFERENCE,r,NIL);
        bllr = CONS(LIST,lr2,bllr);
    }
    debug(8,"classify_reference", "end\n");
    return(bllr);
 
}

References CAR, CDR, CONS, debug(), LIST, NIL, REFERENCE, and uniform_dependence_p().

Referenced by make_load_blocks(), and make_store_blocks().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_communications()

void compute_communications	(	list	l,
		statement_mapping *	fetch_map,
		statement_mapping *	store_map
	)

This function associates to each variable the statement in l where it should be communicated Fecth_map contains for each statement the list of variables having to be communicated before its execution.

Store_map contains for each statement the list of variables having to be communicated after its execution.

list of written variables

list of variables written in a local instruction block

list of privates variables

Parameters

fetch_map	etch_map
store_map	tore_map

Definition at line 267 of file communications.c.

{
    list lwr=NIL;                       /* list of written variables */
    list lwr_local= NIL;                /* list of variables written in a local
                                           instruction block */
    list lpv = NIL;                     /* list of privates variables */
    hash_table r_to_ud1 = hash_table_make(hash_pointer,0);
    statement first_stmt = STATEMENT(CAR(l));
    MAPL(pm,{
        statement s1 = STATEMENT(CAR(pm));  
        statement_to_communications(s1,first_stmt,s1,&lwr, &lwr_local,
                                    fetch_map,store_map, r_to_ud1,&lpv);
    },l);
 
}

References CAR, hash_pointer, hash_table_make(), MAPL, NIL, s1, STATEMENT, and statement_to_communications().

Referenced by module_to_wp65_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_iteration_domain()

void compute_iteration_domain	(	list	list_loop_statement,
		Psysteme *	sc,
		Pbase *	basis
	)

computation of the list of loop indices base_index and of the iteration domain sci

Parameters

list_loop_statement	ist_loop_statement
sc	c
basis	asis

Definition at line 92 of file find_iteration_domain.c.

{
 
    Psysteme sci;
    Pbase base_index = BASE_NULLE;
 
    /* computation of the list of loop indices base_index 
       and of the iteration domain sci*/
       
    debug(8,"compute_iteration_domain","begin\n");
 
    sci = loop_iteration_domaine_to_sc(list_loop_statement, &base_index);
    sci->base = base_reversal(sci->base);
    ifdebug(8) { (void) fprintf(stderr,"compute_iteration_domain\n");
                 vect_fprint(stderr,base_index,(string(*)(void*))entity_local_name);
             }
    *sc = sci;
    *basis = base_index;
    debug(8,"compute_iteration_domain","end\n");
}

References Ssysteme::base, BASE_NULLE, base_reversal(), debug(), entity_local_name(), fprintf(), ifdebug, loop_iteration_domaine_to_sc(), and vect_fprint().

Referenced by find_iteration_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

concat_data_list()

void concat_data_list	(	list *	l,
		list *	lr,
		statement	st,
		statement_mapping	map,
		bool	perfect_nested_loop
	)

Parameters

lr	r
st	t
map	ap
perfect_nested_loop	erfect_nested_loop

Definition at line 236 of file references.c.

{
    instruction inst; 
    list  lt = (list) GET_STATEMENT_MAPPING(map,st);
 
    if (lt != (list) HASH_UNDEFINED_VALUE)  {
        variable_list_add(l, &lt);
        reference_list_add(lr,&lt);
    }
    inst = statement_instruction(st);
    switch(instruction_tag(inst)) {
    case is_instruction_block:{
        cons * b;
        b = instruction_block(inst);
        if (list_of_calls_p(b))
            concat_data_list(l,lr,STATEMENT(CAR(b)),map,perfect_nested_loop);
        else
            MAPL(st, { 
                concat_data_list(l,lr,STATEMENT(CAR(st)), map,
                                 perfect_nested_loop);
                   } , b);
        break;
    }
   
    case is_instruction_loop: {
        concat_data_list(l,lr,loop_body(instruction_loop(inst)),map,
                         perfect_nested_loop);
        break;} 
    default:  return;
    }
}

References CAR, GET_STATEMENT_MAPPING, HASH_UNDEFINED_VALUE, instruction_block, instruction_loop, instruction_tag, is_instruction_block, is_instruction_loop, list_of_calls_p(), loop_body, MAPL, reference_list_add(), STATEMENT, statement_instruction, and variable_list_add().

Referenced by loop_nest_movement_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

create_local_index()

entity create_local_index	(	entity	module,
		Pvecteur	pv,
		string	st
	)

basis.c

Parameters

module	odule
pv	v
st	t

Definition at line 61 of file basis.c.

{
    entity new_ind; 
    string name = strdup(concatenate(entity_local_name((entity) 
                                                        vecteur_var(pv)),
                                     st,NULL));
    if ((new_ind = 
         gen_find_tabulated(concatenate(module_local_name(module), 
                                        MODULE_SEP_STRING,name,NULL),
                                       entity_domain)) == entity_undefined)
    {
        new_ind=make_scalar_integer_entity(name, 
                                            module_local_name(module));
    AddEntityToDeclarations( new_ind,module); 
    }
    free(name);
    return(new_ind);
}

References AddEntityToDeclarations(), concatenate(), entity_domain, entity_local_name(), entity_undefined, free(), gen_find_tabulated(), make_scalar_integer_entity(), module, module_local_name(), MODULE_SEP_STRING, strdup(), and vecteur_var.

Referenced by create_tile_basis().

Here is the call graph for this function:

Here is the caller graph for this function:

create_local_index2()

entity create_local_index2	(	entity	module,
		Pvecteur	pv,
		string	st
	)

Parameters

module	odule
pv	v
st	t

Definition at line 80 of file basis.c.

{ 
    entity new_ind;
    string   name = strdup(concatenate(st,
                              entity_local_name((entity) vecteur_var(pv)),
                              NULL));
        if ((new_ind=gen_find_tabulated(concatenate
                                        (module_local_name(module), 
                                         MODULE_SEP_STRING,name,NULL),
                                        entity_domain))== entity_undefined) {
            new_ind=make_scalar_integer_entity(name, 
                                               entity_local_name(
                                                                 module));
            AddEntityToDeclarations( new_ind,module);
        }
        free(name);
    return(new_ind);
}

References AddEntityToDeclarations(), concatenate(), entity_domain, entity_local_name(), entity_undefined, free(), gen_find_tabulated(), make_scalar_integer_entity(), module, module_local_name(), MODULE_SEP_STRING, strdup(), and vecteur_var.

Referenced by create_tile_basis().

Here is the call graph for this function:

Here is the caller graph for this function:

create_tile_basis()

void create_tile_basis	(	entity	initial_module,
		entity	compute_module,
		entity	memory_module,
		Pbase	initial_basis,
		Pbase *	tile_basis_in_initial_basis,
		Pbase *	tile_basis_in_tile_basis,
		Pbase *	local_tile_basis,
		Pbase *	tile_basis_in_tile_basis2,
		Pbase *	local_tile_basis2
	)

Parameters

initial_module	nitial_module
compute_module	ompute_module
memory_module	emory_module
initial_basis	nitial_basis
tile_basis_in_initial_basis	ile_basis_in_initial_basis
tile_basis_in_tile_basis	ile_basis_in_tile_basis
local_tile_basis	ocal_tile_basis
tile_basis_in_tile_basis2	ile_basis_in_tile_basis2
local_tile_basis2	ocal_tile_basis2

Definition at line 100 of file basis.c.

{
    string name;
    entity new_ind;
    Pvecteur pv;
    Pbase tbib = BASE_NULLE;
    Pbase tbtb = BASE_NULLE;
    Pbase tbtbc = BASE_NULLE;
    Pbase ltb = BASE_NULLE;
    Pbase ltbc = BASE_NULLE;
 
    debug(8, "create_tile_basis", "begin initial_module_name=%s\n",
          module_local_name(initial_module));
    ifdebug(8) {
        (void) fprintf(stderr, "initial_basis:\n");
        vect_fprint(stderr, initial_basis, (string(*)(void*))entity_local_name);
    }
 
    for (pv = initial_basis; !VECTEUR_NUL_P(pv); pv=pv->succ) {
        
        name = strdup(concatenate(entity_local_name((entity) 
                                                    vecteur_var(pv)),
                                  SUFFIX_FOR_INDEX_TILE_IN_INITIAL_BASIS,
                                  NULL));
        if ((new_ind = 
             gen_find_tabulated(concatenate(module_local_name(initial_module), 
                                            MODULE_SEP_STRING,name,NULL),
                                entity_domain)) == entity_undefined)
            new_ind=make_scalar_integer_entity(name, 
                                               module_local_name(initial_module));
        
        free(name);
        tbib = vect_add_variable (tbib,(char *)new_ind);
        
        new_ind = create_local_index(compute_module,
                                      pv,
                                      SUFFIX_FOR_INDEX_TILE_IN_TILE_BASIS);
        tbtbc = vect_add_variable (tbtbc,(char *) new_ind);
 
        new_ind= create_local_index(memory_module,
                                      pv,
                                      SUFFIX_FOR_INDEX_TILE_IN_TILE_BASIS);
        tbtb = vect_add_variable (tbtb,(char *) new_ind);
 
        new_ind = create_local_index2(compute_module,  pv,
                                     PREFIX_FOR_LOCAL_TILE_BASIS);
        ltbc = vect_add_variable (ltbc,(char *) new_ind);
 
        new_ind = create_local_index2(memory_module,  pv,
                                     PREFIX_FOR_LOCAL_TILE_BASIS);
        ltb = vect_add_variable (ltb,(char *) new_ind);
    }
 
 
    *tile_basis_in_initial_basis = base_reversal(tbib);
    *tile_basis_in_tile_basis = base_reversal(tbtb);
    *local_tile_basis = base_reversal(ltb);
    *tile_basis_in_tile_basis2 = base_reversal(tbtbc);
    *local_tile_basis2 = base_reversal(ltbc);
 
    ifdebug(8) {
        (void) fprintf(stderr,"\nInitial basis:");
        base_fprint(stderr, initial_basis, (string(*)(void*))entity_local_name);
        (void) fprintf(stderr,"\nTile basis in initial basis:");
        base_fprint(stderr, *tile_basis_in_initial_basis, (string(*)(void*))entity_local_name);
        (void) fprintf(stderr,"\nTile basis in tile basis:");
        base_fprint(stderr, *tile_basis_in_tile_basis, (string(*)(void*))entity_local_name);
        (void) fprintf(stderr,"\nLocal basis:");
        base_fprint(stderr, *local_tile_basis, (string(*)(void*))entity_local_name);
        (void) fprintf(stderr,
                       "\nTile basis in tile basis for compute module:");
        base_fprint(stderr, *tile_basis_in_tile_basis2, (string(*)(void*))entity_local_name);
        (void) fprintf(stderr,"\nLocal basis for compute module:");
        base_fprint(stderr, *local_tile_basis2, (string(*)(void*))entity_local_name);
    }
    
    debug(8, "create_tile_basis", "end\n");
}

References base_fprint(), BASE_NULLE, base_reversal(), concatenate(), create_local_index(), create_local_index2(), debug(), entity_domain, entity_local_name(), entity_undefined, fprintf(), free(), gen_find_tabulated(), ifdebug, make_scalar_integer_entity(), module_local_name(), MODULE_SEP_STRING, PREFIX_FOR_LOCAL_TILE_BASIS, strdup(), Svecteur::succ, SUFFIX_FOR_INDEX_TILE_IN_INITIAL_BASIS, SUFFIX_FOR_INDEX_TILE_IN_TILE_BASIS, vect_add_variable(), vect_fprint(), VECTEUR_NUL_P, and vecteur_var.

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_statement_fetch()

void delete_statement_fetch

(

statement

)

delete_statement_store()

void delete_statement_store

(

statement

)

eval_variable_in_statement()

void eval_variable_in_statement	(	entity	module,
		statement	s,
		Variable	v,
		int	min
	)

Parameters

module	odule
min	in

Definition at line 141 of file code.c.

{
    var_to_evaluate = v;
    var_minmax = min;
    ifdebug(8) {
        (void) fprintf(stderr, "Loop body :\n");
        wp65_debug_print_text(module, s);
    }
    gen_recurse(s,
                reference_domain,
                gen_true,
                eval_var);
    ifdebug(8) {
        (void) fprintf(stderr, "New loop body :\n");
        wp65_debug_print_text(module, s);
    }
 
}

References eval_var(), fprintf(), gen_recurse, gen_true(), ifdebug, min, module, reference_domain, var_minmax, var_to_evaluate, and wp65_debug_print_text().

Here is the call graph for this function:

expression_to_operand_list()

list expression_to_operand_list	(	expression	e,
		list	lr
	)

This function gives the list of operands belonging to Expression e.

Parameters

lr

r

Definition at line 96 of file references.c.

{
    syntax s = expression_syntax(e);
    switch(syntax_tag(s)) {
    case is_syntax_reference:
        lr = gen_nconc(lr, CONS(REFERENCE, syntax_reference(s), NIL));
                break;
    case is_syntax_range:
        lr = expression_to_operand_list(range_lower(syntax_range(s)), lr);
        lr = expression_to_operand_list(range_upper(syntax_range(s)), lr);
        lr = expression_to_operand_list(range_increment(syntax_range(s)),
                                          lr);
        break;
    case is_syntax_call:
        MAPL(ce, {
            expression e = EXPRESSION(CAR(ce));
            lr = expression_to_operand_list(e, lr);
            },
             call_arguments(syntax_call(s)));
        break;
    default:
        (void) fprintf(stderr, 
                       "expression_to_operand_list - unexpected syntax\n");
    }
 
    return lr;
}

References call_arguments, CAR, CONS, EXPRESSION, expression_syntax, fprintf(), gen_nconc(), is_syntax_call, is_syntax_range, is_syntax_reference, MAPL, NIL, range_increment, range_lower, range_upper, REFERENCE, syntax_call, syntax_range, syntax_reference, and syntax_tag.

Referenced by call_instruction_to_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_map_undefined_p()

bool fetch_map_undefined_p

(

void

)

wp65.c

find_iteration_domain()

void find_iteration_domain	(	statement	,
		Psysteme *	,
		Pbase *	,
		int *	,
		list *	,
		instruction *
	)

find_iteration_domain.c

find_or_create_emulated_shared_variable()

entity find_or_create_emulated_shared_variable	(	entity	v,
		entity	memory_module,
		hash_table	v_to_esv,
		int	bn,
		int	ls
	)

nothing to do

Parameters

memory_module	emory_module
v_to_esv	_to_esv
bn	n
ls	s

Definition at line 284 of file variable.c.

{
    entity esv = entity_undefined;
 
    if ( (esv = gen_find_tabulated(concatenate(entity_local_name(memory_module),
                                             MODULE_SEP_STRING,
                                             EMULATED_SHARED_MEMORY_PREFIX,
                                             entity_local_name(v),
                                             NULL),
                                 entity_domain)) != entity_undefined )
        /* nothing to do */
        ;
    else {
        esv = make_emulated_shared_variable(v, memory_module, bn, ls);
        hash_put(v_to_esv, (char *) v, (char *) esv);
    }
    return (esv);
}

References concatenate(), EMULATED_SHARED_MEMORY_PREFIX, entity_domain, entity_local_name(), entity_undefined, gen_find_tabulated(), hash_put(), make_emulated_shared_variable(), and MODULE_SEP_STRING.

Referenced by loop_nest_to_local_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_wp65_hash_tables()

void fprint_wp65_hash_tables	(	FILE *	fd,
		hash_table	llv_to_lcr,
		hash_table	r_to_llv,
		hash_table	v_to_lllv,
		hash_table	r_to_ud,
		hash_table	v_to_esv
	)

Ignore this function: debugging purposes only.

Parameters

fd	d
llv_to_lcr	lv_to_lcr
r_to_llv	_to_llv
v_to_lllv	_to_lllv
r_to_ud	_to_ud
v_to_esv	_to_esv

Definition at line 406 of file wp65.c.

{
    fputs("\nKey mappings for WP65:\n\n", fd);
 
    fputs("Mapping llv_to_lcr from list of local variables to conflicting references:\n", 
          fd);
    HASH_MAP(llv, lcr,
         {
             list llvl=(list) llv;
          list lcrl= (list) lcr;
           for(; !ENDP(llvl); POP(llvl)) {
               entity lv = ENTITY(CAR(llvl));
               fputs(entity_local_name(lv), fd);
               if(ENDP(CDR(llvl)))
                   (void) putc(' ', fd);
               else
                   (void) putc(',', fd);
           }
          fputs("\t->\t",fd);
          for(; !ENDP(lcrl); POP(lcrl)) {
              reference r = REFERENCE(CAR(lcrl));
              fprint_reference(fd, r);
              if(ENDP(CDR(lcrl)))
                  (void) putc('\n', fd);
              else
                  (void) putc(',', fd);
          }
      },
             llv_to_lcr);
 
    fputs("\nMapping r_to_llv from a reference to a list of local variables:\n", 
          fd);
    HASH_MAP(r, llv,
         {  list llvl=(list) llv;
           fprint_reference(fd, (reference) r);
             fputs("\t->\t",fd);
             for(; !ENDP(llvl); POP(llvl)) {
                 entity lv = ENTITY(CAR(llvl));
                 fputs(entity_local_name(lv), fd);
                 if(ENDP(CDR(llvl)))
                     (void) putc(' ', fd);
                 else
                     (void) putc(',', fd);
             }
             (void) putc('\n', fd);
         },
             r_to_llv);
 
    fputs("\nMapping v_to_lllv from variables to lists of lists of local variables:\n",
          fd);
    HASH_MAP(v, lllv,
         {  list lllvl=(list)lllv;
           (void) fprintf(fd,"%s\t->\t", entity_name((entity) v));
           for(; !ENDP(lllvl); POP(lllvl)) {
               list llv = LIST(CAR(lllvl));
               (void) putc('(',fd);
               for(; !ENDP(llv); POP(llv)) {
                   fputs(entity_local_name(ENTITY(CAR(llv))), fd);
                   if(ENDP(CDR(llv)))
                       (void) putc(')', fd);
                   else
                       (void) putc(',', fd);
               }
               if(ENDP(CDR(lllvl)))
                   (void) putc('\n', fd);
               else
                   (void) putc(',',fd);
           }
       },
             v_to_lllv);
 
 
    fputs("\nMapping r_to_ud from references to use-def:\n", fd);
    HASH_MAP(r, use_def,
         {
           fprint_reference(fd, (reference) r);
           fputs("\t->\t",fd);
             fputs(((intptr_t) use_def == (intptr_t)is_action_read) ? "use\n" : "def\n", fd);
       },
             r_to_ud);
 
 
    fputs("\nMapping v_to_esv from variables to emulated shared variables:\n",
          fd);
    HASH_MAP(v, esv,
         {
           (void) fprintf(fd,"%s\t->\t", entity_name((entity) v));
           (void) fprintf(fd,"%s\n", entity_name((entity) esv));
       },
             v_to_esv);
 
    (void) putc('\n', fd);
}

References CAR, CDR, ENDP, ENTITY, entity_local_name(), entity_name, fprint_reference(), fprintf(), HASH_MAP, intptr_t, is_action_read, LIST, POP, and REFERENCE.

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

free_fetch_map()

void free_fetch_map

(

void

)

free_store_map()

void free_store_map

(

void

)

full_parallel_loop_nest_p()

bool full_parallel_loop_nest_p	(	statement	mod_stat,
		statement	loop_stmt,
		int	nest_dim,
		graph	dg,
		bool *	loop_carried_dep
	)

Parameters

mod_stat	od_stat
loop_stmt	oop_stmt
nest_dim	est_dim
dg	g
loop_carried_dep	oop_carried_dep

Definition at line 1119 of file instruction_to_wp65_code.c.

{
    int i; 
    search_parallel_loops(mod_stat,loop_stmt, dg,loop_carried_dep);
    for (i=1; i<= nest_dim && loop_carried_dep[i]== false; i++);
    return( (i>nest_dim) ? true : false);
}

References dg, mod_stat, and search_parallel_loops().

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_io_wp65_code()

statement generate_io_wp65_code	(	statement	s1,
		statement	body,
		hash_table	v_to_esv,
		bool	loop_or_call_print
	)

we know that it is a loop nest containing a PRINT function The loop body contains block statement in case of CONTINUE loop nest style

loop nest belonging IO statement

implied_do case

Parameters

s1	1
body	ody
v_to_esv	_to_esv
loop_or_call_print	oop_or_call_print

Definition at line 406 of file instruction_to_wp65_code.c.

{
    
    list rvld,pl;
    statement result = s1;
    instruction inst = statement_instruction(body);
    call c;
    reference r;
 
    entity  rv,esv_ref;
    type rvt;
    int nb_dim,i;
    
    /* we know that it is a loop nest containing a PRINT function 
     The loop body contains block statement in case of CONTINUE 
     loop nest style*/
    statement_ordering(s1)=STATEMENT_ORDERING_UNDEFINED;
    if (instruction_block_p(inst)) {
        list b = instruction_block(inst);
        c = instruction_call(statement_instruction(STATEMENT(CAR(b))));
    }
    else 
        c= instruction_call(inst);
     r = translate_IO_ref(c,v_to_esv,loop_or_call_print);
    rv = reference_variable(r);
    esv_ref = (entity) hash_get(v_to_esv,(char *) rv); 
    rvt = entity_type(esv_ref);
    rvld = variable_dimensions(type_variable(rvt));
    nb_dim = gen_length((list) rvld);
    
    if (loop_or_call_print) /* loop nest belonging IO statement */
        for (i=1; i<=nb_dim; i++) {
            list ldim = gen_nthcdr(i-1,rvld);
            expression low = dimension_lower(DIMENSION(CAR(ldim)));
            expression up = dimension_upper(DIMENSION(CAR(ldim)));
            range looprange = make_range(low, up,
                                   int_to_expression(1));
            loop loopi = ith_loop_in_loop_nest(result,i);
            loop_range(loopi) = looprange;
        }
    else { /* implied_do case */
        implied_do_range_list = NIL;
        implied_do_ranges(result);
        implied_do_range_list = gen_nreverse(implied_do_range_list);
         for (i=1,pl = implied_do_range_list; !ENDP(pl); POP(pl),i++) {
            range r1 = RANGE(CAR(pl));
            list ldim = gen_nthcdr(i-1,rvld); 
            expression low = copy_expression(
                dimension_lower(DIMENSION(CAR(ldim))));
            expression up = copy_expression(
                dimension_upper(DIMENSION(CAR(ldim))));
            range_lower(r1)=low; 
            range_upper(r1)=up; 
        } 
    }
    return(result);
}

References CAR, copy_expression(), DIMENSION, dimension_lower, dimension_upper, ENDP, entity_type, gen_length(), gen_nreverse(), gen_nthcdr(), hash_get(), implied_do_range_list, implied_do_ranges(), instruction_block, instruction_block_p, instruction_call, int_to_expression(), ith_loop_in_loop_nest(), loop_range, make_range(), NIL, pl, POP, RANGE, range_lower, range_upper, reference_variable, s1, STATEMENT, statement_instruction, statement_ordering, STATEMENT_ORDERING_UNDEFINED, translate_IO_ref(), type_variable, and variable_dimensions.

Referenced by call_to_wp65_code(), and loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

get_fetch_map()

statement_mapping get_fetch_map

(

void

)

get_model()

void get_model	(	int *	ppn,
		int *	pbn,
		int *	pls
	)

Parameters

ppn	pn
pbn	bn
pls	ls

Definition at line 71 of file model.c.

{
    FILE * fd;
    const char* model_rc = get_string_property("WP65_MODEL_FILE");
    if ((fd = fopen(model_rc, "r")) == NULL) {
        fd = fopen_config(model_rc, NULL,NULL);
    }
 
    model_fscan(fd, ppn, pbn, pls);
}

References fopen_config(), get_string_property(), and model_fscan().

Referenced by wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

get_store_map()

statement_mapping get_store_map

(

void

)

include_constant_symbolic_communication()

void include_constant_symbolic_communication	(	entity	compute_or_memory_module,
		list	lrefs,
		bool	load_code,
		statement	computational_or_emulator,
		entity	var_id
	)

Add data movements to the appropriated module

Parameters

compute_or_memory_module	ompute_or_memory_module
lrefs	refs
load_code	oad_code
computational_or_emulator	omputational_or_emulator
var_id	ar_id

Definition at line 305 of file communications.c.

{ 
    instruction i;
    list ccode = constant_symbolic_communication(compute_or_memory_module,lrefs, 
                                                   load_code,var_id); 
    /* Add data movements to the appropriated module */
    i = statement_instruction(computational_or_emulator);
    instruction_block(i) = gen_nconc(instruction_block(i), ccode);
}

References constant_symbolic_communication(), gen_nconc(), instruction_block, and statement_instruction.

Referenced by call_to_wp65_code(), and loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_run_time_communications()

void insert_run_time_communications	(	entity	compute_module,
		entity	memory_module,
		Pbase	bank_indices,
		int	bn,
		int	ls,
		entity	proc_id,
		list	list_statement_block,
		statement_mapping	fetch_map,
		statement_mapping	store_map,
		list *	new_slst,
		list *	new_blist,
		hash_table	v_to_esv,
		bool	fully_sequential,
		Pbase	loop_indices,
		tiling	tile,
		Pvecteur	tile_delay,
		Pvecteur	tile_indices,
		Pvecteur	tile_local_indices
	)

Parameters

compute_module	ompute_module
memory_module	emory_module
bank_indices	ank_indices
bn	n
ls	s
proc_id	roc_id
list_statement_block	ist_statement_block
fetch_map	etch_map
store_map	tore_map
new_slst	ew_slst
new_blist	ew_blist
v_to_esv	_to_esv
fully_sequential	ully_sequential
loop_indices	oop_indices
tile	ile
tile_delay	ile_delay
tile_indices	ile_indices
tile_local_indices	ile_local_indices

Definition at line 639 of file communications.c.

{
    int nbcall=0; 
    entity ent1=entity_undefined; 
    
    MAPL(st1, 
     { instruction inst = statement_instruction(STATEMENT(CAR(st1)));
       switch(instruction_tag(inst)) {
       case is_instruction_block: {
          
           list new_slst1 = NIL; 
           nbcall = 0; 
           MAPL(st2, {
               insert_run_time_communications(compute_module,memory_module, 
                                              bank_indices,bn,ls,proc_id,
                                              CONS(STATEMENT,
                                                   STATEMENT(CAR(st2)),NIL),
                                              fetch_map,store_map,
                                              &new_slst1,new_blist,
                                              v_to_esv,fully_sequential,
                                              loop_indices,tile, tile_delay,
                                              tile_indices,tile_local_indices);
           
 
},
                instruction_block(inst));  
           instruction_block(inst)= new_slst1;  
           break; }
       case is_instruction_loop: {
           statement lbody = loop_body(instruction_loop(inst));
           statement sbody = make_block_statement(CONS(STATEMENT,
                                                       lbody,NIL));
           cons *nbody=(instruction_call_p(statement_instruction(lbody))) ? 
               CONS(STATEMENT,sbody,NIL) : 
                   CONS(STATEMENT,lbody,NIL);
           insert_run_time_communications(compute_module,memory_module, 
                                          bank_indices,bn,ls,proc_id,
                                          nbody,fetch_map,store_map,new_slst,
                                          new_blist,
                                          v_to_esv,fully_sequential,
                                          loop_indices,tile, tile_delay,
                                          tile_indices,tile_local_indices);
            *new_slst = gen_nconc(*new_slst,
                                  CONS(STATEMENT,STATEMENT(CAR(st1)),NIL)); 
           break;
       }
       case is_instruction_call: {
           list  lt;
         
           if ((lt= (list) 
                GET_STATEMENT_MAPPING(fetch_map,STATEMENT(CAR(st1))))
               != (list) HASH_UNDEFINED_VALUE && nbcall ) { 
 
               ent1 = make_new_module_variable(compute_module,100);
               AddEntityToDeclarations(ent1,compute_module);
               
               insert_array_scalar_access_movement(compute_module,memory_module,bank_indices,
                                                   bn,ls,proc_id,ent1,lt,STATEMENT(CAR(st1)),true,
                                                   v_to_esv,new_slst,new_blist,fully_sequential,
                                                   loop_indices,tile, tile_delay,tile_indices,
                                                   tile_local_indices
                                                   );
           }
           if ((lt=(list) GET_STATEMENT_MAPPING(store_map,
                                                STATEMENT(CAR(st1))))
               != (list) HASH_UNDEFINED_VALUE && nbcall )
           { 
               ent1 = make_new_module_variable(compute_module,100);
               AddEntityToDeclarations(ent1,compute_module);
           
               insert_array_scalar_access_movement(compute_module,memory_module,bank_indices,
                                                   bn,ls,proc_id,ent1,lt,STATEMENT(CAR(st1)),false,
                                                   v_to_esv,new_slst,new_blist,fully_sequential,
                                                   loop_indices,tile, tile_delay,tile_indices,
                                                   tile_local_indices);
           }
           *new_slst = gen_nconc(*new_slst,CONS(STATEMENT,STATEMENT(CAR(st1)),NIL));
           nbcall ++;
           break;
       }
       default:
           break;
       }
   }, list_statement_block);
}

References AddEntityToDeclarations(), CAR, CONS, entity_undefined, gen_nconc(), GET_STATEMENT_MAPPING, HASH_UNDEFINED_VALUE, insert_array_scalar_access_movement(), instruction_block, instruction_call_p, instruction_loop, instruction_tag, is_instruction_block, is_instruction_call, is_instruction_loop, loop_body, make_block_statement(), make_new_module_variable(), MAPL, NIL, STATEMENT, and statement_instruction.

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

instruction_to_wp65_code()

void instruction_to_wp65_code	(	entity	module,
		list	l,
		graph	dg,
		int	pn,
		int	bn,
		int	ls,
		int	pd,
		entity	proc_id,
		entity	proc_id_mm,
		Pbase	bank_indices,
		hash_table	v_to_esv,
		hash_table	v_to_nlv,
		entity	compute_module,
		statement	computational,
		entity	memory_module,
		statement	emulator,
		statement_mapping	fetch_map,
		statement_mapping	store_map
	)

cms

FI: the semantics has been changed: the next two get_xxx() cannot/should not return something undefined.

if ((cme = get_current_module_entity()) == entity_undefined)

FI: already done somewhere else

set_current_module_entity(local_name_to_top_level_entity(module_local_name(module)));

if ((cms = get_current_module_statement()) == statement_undefined)

FI: shouldn't the current statement be retrieved at the same time as the current module?

reset_current_module_entity();

Parameters

module	odule
dg	g
pn	n
bn	n
ls	s
pd	d
proc_id	roc_id
proc_id_mm	roc_id_mm
bank_indices	ank_indices
v_to_esv	_to_esv
v_to_nlv	_to_nlv
compute_module	ompute_module
computational	omputational
memory_module	emory_module
emulator	mulator
fetch_map	etch_map
store_map	tore_map

Definition at line 175 of file instruction_to_wp65_code.c.

{
 
    statement mod_stat/*,cms*/;
    //entity cme;
    debug_on("WP65_DEBUG_LEVEL");
 
    /* FI: the semantics has been changed: the next two get_xxx() cannot/should not return
     * something undefined.
     */
    /* if ((cme = get_current_module_entity()) == entity_undefined)  */
    /* FI: already done somewhere else */
    /* set_current_module_entity(local_name_to_top_level_entity(module_local_name(module)));  */
    /* if ((cms = get_current_module_statement()) == statement_undefined) */
    /* FI: shouldn't the current statement be retrieved at the same time as the current module? */
    set_current_module_statement( (statement)
                                  db_get_memory_resource(DBR_CODE, 
                                                         module_local_name(module),
                                                         true) ); 
    mod_stat = get_current_module_statement();
    MAPL(pm,{
        statement s1 = STATEMENT(CAR(pm));  
        instruction inst = statement_instruction(s1);
        ifdebug(9) 
            (void) fprintf(stderr,
                           "instruction_to_wp65_code-instruction- begin\n");
        switch(instruction_tag(inst)) {
            
        case is_instruction_block:{
            instruction_to_wp65_code(module,instruction_block(inst), 
                                     dg, pn, bn, ls, pd,
                                     proc_id, proc_id_mm, bank_indices,
                                     v_to_esv, v_to_nlv,
                                     compute_module, computational,
                                     memory_module, emulator, 
                                     fetch_map,store_map);
            
            break;}
            case is_instruction_test: {
                (void) fprintf(stderr,
                            "instruction_to_wp65_code-Sorry:test not implemented\n");
                break;}
            case is_instruction_goto: {
                (void) fprintf(stderr,
                               "instruction_to_wp65_cod -Sorry:goto implemented\n");
                break;}
            case is_instruction_loop: {
                loop_nest_to_wp65_code(module, s1, dg, pn, bn, ls, pd,
                                       proc_id, proc_id_mm, bank_indices,
                                       v_to_esv, v_to_nlv,
                                       compute_module, computational,
                                       memory_module, emulator,
                                       fetch_map,store_map,mod_stat);
                break;}
            case is_instruction_call:  {     
                if (!return_statement_p(s1)) {
  
                     call_to_wp65_code(s1,compute_module,
                                      memory_module,
                                      (entity) bank_indices->var,proc_id,
                                      computational,emulator, fetch_map,
                                      store_map,v_to_esv);
                }
                break;
            } 
            case is_instruction_unstructured: {
                pips_internal_error("Sorry: unstructured not implemented");
                break;}
            default: 
                (void) fprintf(stderr, 
                               " instruction_to_wp65_code- bad instruction tag \n");
                break;
            }
        ifdebug(9) 
            (void) fprintf(stderr,
                           "instruction_to_wp65_code-instruction_end \n");
    },l);
    /* reset_current_module_entity(); */
    reset_current_module_statement(); 
    debug_off();
}

References call_to_wp65_code(), CAR, db_get_memory_resource(), debug_off, debug_on, dg, fprintf(), get_current_module_statement(), ifdebug, instruction_block, instruction_tag, is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, loop_nest_to_wp65_code(), MAPL, mod_stat, module, module_local_name(), pips_internal_error, reset_current_module_statement(), return_statement_p(), s1, set_current_module_statement(), STATEMENT, statement_instruction, and Svecteur::var.

Referenced by module_to_wp65_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

io_loop_nest_p()

bool io_loop_nest_p

(

statement

st

)

Test if the statement resulting from the perfectly_loop_nest_to_body function contains at first call an io.

Parameters

st

t

Definition at line 467 of file instruction_to_wp65_code.c.

{
    instruction inst = statement_instruction(st);
    call c;
    if (instruction_block_p(inst)) {
        list b = instruction_block(inst);
        c = instruction_call(statement_instruction(STATEMENT(CAR(b))));
    }
    else 
        c= instruction_call(inst);
    return (strcmp(entity_local_name(call_function(c)), "WRITE") == 0) ;
}

References call_function, CAR, entity_local_name(), instruction_block, instruction_block_p, instruction_call, STATEMENT, and statement_instruction.

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

iteration_domain_from_statement()

void iteration_domain_from_statement	(	list *	list_loop_statement,
		statement	s,
		int *	nested_level,
		list *	blocks,
		instruction *	inst
	)

case where there is a unique assignment in do-enddo loop nest

Parameters

list_loop_statement	ist_loop_statement
nested_level	ested_level
blocks	locks
inst	nst

Definition at line 116 of file find_iteration_domain.c.

{
    instruction i;
    cons *b;
    loop l;
   debug(8, "iteration_domain_from_statement", "begin\n");
        
    i = statement_instruction(s);
    switch (instruction_tag(i)) {
 
    case is_instruction_loop:
        l = instruction_loop(i);
        *list_loop_statement = CONS (STATEMENT,s,*list_loop_statement);
        iteration_domain_from_statement(list_loop_statement,loop_body(l),
                                        nested_level, 
                                        blocks,inst);
        break;
 
    case is_instruction_block: {
        int nbl = 0;
        bool simple_block = false;
        b= instruction_block(i);
        nbl = gen_length((list) b);
        simple_block = (nbl==1 
                        || (nbl ==2 && continue_statement_p(STATEMENT(CAR(CDR(b)))))) 
            ? true : false;
        
        if (simple_block && instruction_loop_p(statement_instruction(STATEMENT(CAR(b)))))
                iteration_domain_from_statement(list_loop_statement,
                                                STATEMENT(CAR(b))
                                                ,nested_level, blocks,inst);
        else { 
            *nested_level = gen_length(*list_loop_statement);
            *inst = i;
            *blocks = b;
            }
      
        break;
    }
    case is_instruction_call: {
        /* case where there is a unique assignment in do-enddo loop nest*/
         *nested_level = gen_length(*list_loop_statement);
         *inst =make_instruction_block(CONS(STATEMENT,s,NIL));  
         *blocks =CONS(STATEMENT,s,NIL);
        return;
           }
 
    case is_instruction_test:
         return;
        
    case is_instruction_unstructured:
         return;
        
    case is_instruction_goto:
        pips_internal_error("unexpected goto in code");
    default:
        pips_internal_error("unexpected tag");
    }
    
    debug(8, "search_array_from_statement", "end\n");
}

References blocks, CAR, CDR, CONS, continue_statement_p(), debug(), gen_length(), instruction_block, instruction_loop, instruction_loop_p, instruction_tag, is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, loop_body, make_instruction_block(), NIL, pips_internal_error, STATEMENT, statement_instruction, and true.

Referenced by find_iteration_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

ith_index_of_ref()

entity ith_index_of_ref	(	reference	r,
		int	level
	)

Parameters

level

evel

Definition at line 146 of file instruction_to_wp65_code.c.

{
    entity result = entity_undefined;
    list  ith_index=reference_indices(r);
    expression exp_ind = EXPRESSION(gen_nth(level,ith_index));
    syntax sy = expression_syntax(exp_ind);
    if (syntax_reference_p(sy)) 
        result = reference_variable(syntax_reference(sy));
    return (result);
} 

References entity_undefined, EXPRESSION, expression_syntax, gen_nth(), level, reference_indices, reference_variable, syntax_reference, and syntax_reference_p.

Here is the call graph for this function:

ith_loop_in_loop_nest()

loop ith_loop_in_loop_nest	(	statement	s1,
		int	level
	)

Parameters

s1	1
level	evel

Definition at line 158 of file instruction_to_wp65_code.c.

{
    instruction inst = statement_instruction(s1);
    loop loop1;
    if (instruction_block_p(inst)) { 
        statement st1 = STATEMENT(CAR(instruction_block(inst)));
        inst = statement_instruction(st1);
    }
    loop1 = instruction_loop(inst);
    return((level ==1) ? loop1 :
                ith_loop_in_loop_nest(loop_body(loop1),level -1));
 
}

References CAR, instruction_block, instruction_block_p, instruction_loop, level, loop1, loop_body, s1, STATEMENT, and statement_instruction.

Referenced by generate_io_wp65_code().

Here is the caller graph for this function:

list_of_calls_p()

bool list_of_calls_p

(

list

lsb

)

instruction_to_wp65_code.c

Parameters

lsb

sb

Definition at line 136 of file instruction_to_wp65_code.c.

{
    list pl;
    for(pl=lsb; 
        pl!=NIL &&  statement_call_p(STATEMENT(CAR(pl))); 
        pl = CDR(pl));
    return(pl==NIL);
}

References CAR, CDR, NIL, pl, STATEMENT, and statement_call_p().

Referenced by concat_data_list(), and loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

load_statement_fetch()

list load_statement_fetch

(

statement

)

load_statement_store()

list load_statement_store

(

statement

)

loop_instruction_to_communications()

void loop_instruction_to_communications	(	statement	stmt,
		statement	st_level1,
		statement	st_level2,
		list *	lwr,
		list *	lwr_local,
		statement_mapping *	fetch_map,
		statement_mapping *	store_map,
		hash_table	r_to_ud,
		list *	lpv
	)

This function associates to each variable in the loop the statement where it should be communicated (this statement may be external to the loop).

Parameters

stmt	tmt
st_level1	t_level1
st_level2	t_level2
lwr	wr
lwr_local	wr_local
fetch_map	etch_map
store_map	tore_map
r_to_ud	_to_ud
lpv	pv

Definition at line 150 of file communications.c.

{
    instruction inst = statement_instruction(stmt);
    statement b = loop_body(instruction_loop(inst));
    instruction inst2=  (instruction) statement_instruction(b);
    reference_list_add(lwr, lwr_local);
    reference_list_update(lwr,
                          make_reference(loop_index(instruction_loop(inst)),
                                         NIL));
    *lwr_local = NIL; 
    *lpv=loop_locals(instruction_loop(inst));
 
    switch(instruction_tag(inst2)) {
    case is_instruction_block: 
        st_level2 = STATEMENT(CAR(instruction_block(inst)));
        break;
    case is_instruction_call: 
        st_level2 =b;
        break;
    default:
        (void) fprintf(stderr,
                       "loop_instruction_to_communications: non implemented case \n");
        break;
    }
    statement_to_communications(b,st_level1, st_level2,
                             lwr,lwr_local,
                             fetch_map,store_map,r_to_ud,lpv);
 
}

References CAR, fprintf(), instruction_block, instruction_loop, instruction_tag, is_instruction_block, is_instruction_call, loop_body, loop_index, loop_locals, make_reference(), NIL, reference_list_add(), reference_list_update(), STATEMENT, statement_instruction, and statement_to_communications().

Referenced by statement_to_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_nest_movement_generation()

void loop_nest_movement_generation	(	entity	module,
		statement	loop_nest,
		int	pn,
		int	bn,
		int	ls,
		int	pd,
		entity	proc_id,
		entity	proc_id_mm,
		Pbase	bank_indices,
		hash_table	v_to_esv,
		hash_table	v_to_nlv,
		entity	compute_module,
		statement	computational,
		entity	memory_module,
		statement	emulator,
		statement_mapping	fetch_map,
		statement_mapping	store_map,
		statement	mod_stat,
		bool	fully_parallel,
		Psysteme	sc_tile,
		Pbase	initial_basis,
		Pbase	local_basis,
		Pbase	local_basis2,
		Pbase	tile_basis_in_tile_basis,
		Pbase	tile_basis_in_tile_basis2,
		Pbase	loop_body_indices,
		list	lpv,
		list *	lb,
		list *	blb,
		list *	sb,
		list *	bsb,
		int	first_parallel_level,
		int	last_parallel_level,
		hash_table	llv_to_lcr,
		hash_table	r_to_llv,
		hash_table	v_to_lllv,
		hash_table	r_to_ud
	)

the list of data having to be store into the global memory is the concatenation of store_map sets of the internal loops

update of variable names according to the module of appartenance

Parameters

module	odule
loop_nest	oop_nest
pn	n
bn	n
ls	s
pd	d
proc_id	roc_id
proc_id_mm	roc_id_mm
bank_indices	ank_indices
v_to_esv	_to_esv
v_to_nlv	_to_nlv
compute_module	ompute_module
computational	omputational
memory_module	emory_module
emulator	mulator
fetch_map	etch_map
store_map	tore_map
mod_stat	od_stat
fully_parallel	ully_parallel
sc_tile	c_tile
initial_basis	nitial_basis
local_basis	ocal_basis
local_basis2	ocal_basis2
tile_basis_in_tile_basis	ile_basis_in_tile_basis
tile_basis_in_tile_basis2	ile_basis_in_tile_basis2
loop_body_indices	oop_body_indices
lpv	pv
lb	b
blb	lb
sb	b
bsb	sb
first_parallel_level	irst_parallel_level
last_parallel_level	ast_parallel_level
llv_to_lcr	lv_to_lcr
r_to_llv	_to_llv
v_to_lllv	_to_lllv
r_to_ud	_to_ud

Definition at line 483 of file instruction_to_wp65_code.c.

{ 
  pips_assert("true", pd==pd
              && proc_id_mm==proc_id_mm
              &&v_to_nlv==v_to_nlv
              && emulator==emulator
              && mod_stat==mod_stat
              && r_to_llv==r_to_llv
              && computational==computational);
    
    list fetch_data_list =NIL; 
    list store_data_list = NIL; 
    list fetch_reference_list = NIL; 
    list store_reference_list = NIL;
    debug_on("WP65_DEBUG_LEVEL");
    /* the list of data having to be store into the global memory 
       is the concatenation  of store_map sets of the internal loops */
     
    concat_data_list(&fetch_data_list,&fetch_reference_list,
                     loop_nest,fetch_map,fully_parallel); 
    concat_data_list(&store_data_list , &store_reference_list ,
                     loop_nest,store_map,fully_parallel);   
    MAPL(r1,{  entity rv = (entity) reference_variable(REFERENCE(CAR(r1)));
               if(!entity_is_argument_p(rv, lpv))
                   make_all_movement_blocks(
                       module,compute_module,memory_module,
                       rv,fetch_reference_list,
                       llv_to_lcr, v_to_lllv,r_to_ud, v_to_esv,
                       pn,bn, ls,
                       sc_tile, initial_basis, local_basis,
                       proc_id, bank_indices,loop_body_indices,
                       lb, blb,is_action_read,first_parallel_level,
                                            last_parallel_level);
           },
         fetch_data_list);
    /* update of variable names according to the module of appartenance */
    sc_variables_rename(sc_tile,local_basis2,local_basis, (string(*)(void*))entity_local_name);
    sc_variables_rename(sc_tile, tile_basis_in_tile_basis2, 
                        tile_basis_in_tile_basis,(string(*)(void*))entity_local_name);
    MAPL(r1,{ 
        reference rf = REFERENCE(CAR(r1));
        entity rv = (entity) reference_variable(rf);
        if (!reference_scalar_p(rf)  && !entity_is_argument_p(rv, lpv)) 
            make_all_movement_blocks(module,compute_module,memory_module,
                                     rv,store_reference_list ,
                                     llv_to_lcr, v_to_lllv, r_to_ud, v_to_esv,
                                     pn,bn, ls,
                                     sc_tile, initial_basis, local_basis,
                                     proc_id, bank_indices, loop_body_indices,
                                     sb, bsb, is_action_write, 
                                     first_parallel_level,
                                     last_parallel_level);
    },
         store_data_list);
    debug_off();
}

References CAR, concat_data_list(), debug_off, debug_on, entity_is_argument_p(), entity_local_name(), is_action_read, is_action_write, make_all_movement_blocks(), MAPL, mod_stat, module, NIL, pips_assert, REFERENCE, reference_scalar_p(), reference_variable, and sc_variables_rename().

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_nest_to_local_variables()

void loop_nest_to_local_variables	(	entity	initial_module,
		entity	compute_module,
		entity	memory_module,
		hash_table	llv_to_lcr,
		hash_table	r_to_llv,
		hash_table	v_to_lllv,
		hash_table	r_to_ud,
		hash_table	v_to_esv,
		hash_table	v_to_nlv,
		list	lpv,
		statement	body,
		Pbase	indices,
		graph	dg,
		int	bn,
		int	ls,
		int	pd,
		tiling	tile
	)

variable.c

variable.c

loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references.

pips_assert("loop_nest_to_local_variables", instruction_block_p(instr));

first reference in statement s

there are only two expressions to loop over: the lhs and the rhs

FI: local variable dimensions should be set later by the caller so as to use the clustering performed here to compute space complexity, to use space complexity to define the tiling and to use the tiling to define the dimensions

Parameters

initial_module	nitial_module
compute_module	loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. initial module: achtung, this arg. is not used!?!

Parameters

memory_module

loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. compute module

Parameters

llv_to_lcr

loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. memory module

Parameters

r_to_llv

loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. local variable to list of conflicting references

Parameters

v_to_lllv

loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. reference to list of local variables

Parameters

r_to_ud

loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. variable to list of lists of local variables

Parameters

v_to_esv

loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. reference to use def

Parameters

v_to_nlv

loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. variable to emulated shared variable

Parameters

lpv	loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. variable to number of associated local variables (local to this procedure)

Parameters

body	loop_nest_to_local_variables():

Key function allocating local copies according to interferences between references. It also gather information about references (which is also indirectly available in the effect information), allocate emulated shared variables, and create different mappings between local variables and references. private variables

Parameters

indices	ndices
dg	g
bn	n
ls	s
pd	d
tile	ile

Definition at line 80 of file variable.c.

{
  pips_assert("true", initial_module==initial_module);
    list block;
    instruction instr = statement_instruction(body);
 
    debug(6,"loop_nest_to_local_variables","begin\n");
 
    ifdebug(5) { 
        (void) fprintf(stderr,"Private variables:");
        print_entities(lpv);
    } 
 
/*    pips_assert("loop_nest_to_local_variables", 
      instruction_block_p(instr));*/ 
 
    if (instruction_call_p(instr)) 
        block = CONS(STATEMENT,body,NIL);
    else block = instruction_block(instr);
 
    for( ;!ENDP(block); POP(block)) {
        statement s = STATEMENT(CAR(block));
 
        if(assignment_statement_p(s)) {
            list lexpr =call_arguments(instruction_call(statement_instruction(s)));
            /* first reference in statement s */
            bool first_reference = true;
            /* there are only two expressions to loop over: the lhs and the 
               rhs */
            for(; !ENDP(lexpr); POP(lexpr)) {
                expression e = EXPRESSION(CAR(lexpr));
                list lr = expression_to_reference_list(e, NIL);
                list consr;
 
                ifdebug(7) {
                    (void) fprintf(stderr, "reference list:");
                    print_reference_list(lr);
                    (void) fprintf(stderr, "first_reference=%s\n",
                                   bool_to_string(first_reference));
                }
 
                for(consr = lr; !ENDP(consr) ; POP(consr)) {
                    reference r = REFERENCE(CAR(consr));
                    entity rv = reference_variable(r);
 
                    if(entity_is_argument_p(rv, lpv) || reference_indices(r) ==NIL) {
                        debug(7,"loop_nest_to_local_variables",
                              "Variable %s is private\n", 
                              entity_local_name(rv));
                        
                        first_reference = false;
                    }
                    else {
                        hash_put(r_to_ud,  r,
                                 (void*)(intptr_t)(first_reference? 
                                           is_action_write : is_action_read));
                        first_reference = false;
                        if(!reference_conflicting_test_and_update(r, dg, 
                                                                  v_to_lllv, 
                                                                  llv_to_lcr,
                                                                  r_to_llv,
                                                                  r_to_ud)) {
                            entity v = reference_variable(r);
                            intptr_t n;
                            list llv;
                            (void) find_or_create_emulated_shared_variable(v, memory_module, 
                                                                           v_to_esv,
                                                                           bn, ls);
                            if((n = (intptr_t) hash_get(v_to_nlv, (char *) v))
                               == (intptr_t) HASH_UNDEFINED_VALUE)
                                n = 0;
                            llv = make_new_local_variables(v, compute_module, n, pd, 
                                                           v_to_lllv);
                            hash_put(llv_to_lcr,  llv, 
                                      CONS(REFERENCE, r, NIL));
                            hash_put(r_to_llv,  r,  llv);
                            hash_put(v_to_nlv,  v,  (void*)(n+1));
                        }
                    }
                }
                gen_free_list(lr);
            }
        }
    }
    /* FI: local variable dimensions should be set later by the caller
       so as to use the clustering performed here to compute space
       complexity, to use space complexity to define the tiling and
       to use the tiling to define the dimensions */
    set_dimensions_of_local_variables(v_to_lllv, indices, tile, llv_to_lcr);
 
    debug(6,"loop_nest_to_local_variables","end\n");
}

References assignment_statement_p(), bool_to_string(), call_arguments, CAR, CONS, debug(), dg, ENDP, entity_is_argument_p(), entity_local_name(), EXPRESSION, expression_to_reference_list(), find_or_create_emulated_shared_variable(), fprintf(), gen_free_list(), hash_get(), hash_put(), HASH_UNDEFINED_VALUE, ifdebug, indices, instruction_block, instruction_call, instruction_call_p, intptr_t, is_action_read, is_action_write, make_new_local_variables(), NIL, pips_assert, POP, print_entities(), print_reference_list(), REFERENCE, reference_conflicting_test_and_update(), reference_indices, reference_variable, set_dimensions_of_local_variables(), STATEMENT, and statement_instruction.

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_nest_to_tile()

tiling loop_nest_to_tile	(	Psysteme	sc,
		int	ls,
		Pbase	base_index,
		int	first_parallel_level,
		int	last_parallel_level,
		int	perfect_nested_level
	)

tiling.c

tiling.c

Functions to decide a specific tiling for a loop nest

File: tiling.c

PUMA, ESPRIT contract 2701

Francois Irigoin, Corinne Ancourt, Lei Zhou 1991 loop_nest_to_tile():

Because the number of elements per bank ligne is usefull to optimize the tiling, parameter ls is used temporarily to build it. Because ls is the number of bytes of each bank ligne, it is divided by the assumed number of bytes needed for the
location of one element (4 for int and real)

build the diagonal matrix: ls x I

build origin tile vector as the first iteration to minimize the number of partial tiles (heuristics)

vect_chg_coeff(&porigin,var,min);

Parameters

sc	c
ls	s
base_index	ase_index
first_parallel_level	irst_parallel_level
last_parallel_level	ast_parallel_level
perfect_nested_level	erfect_nested_level

Definition at line 58 of file tiling.c.

{
 
    tiling tile;
    matrice M;
    Pvecteur porigin = VECTEUR_NUL;
    Pvecteur pv;
    int vs = vect_size((Pvecteur)(base_index));
    Psysteme sc_proj;
    Value min,max;
    bool faisable;
    int i;
 
    /* Because the number of elements per bank ligne is usefull to
       optimize the tiling,  parameter ls is used temporarily to build it.
       Because ls is the number of bytes of each bank ligne, it is 
       divided by the assumed number of bytes needed for the  
       location of one element (4 for int and real) */
 
    int lsd = ls/4;
 
    /* build the diagonal matrix: ls x I */
 
    M = matrice_new(vs,vs);
    matrice_nulle(M,vs,vs); 
    for (i =1; i<= vs && i < first_parallel_level; i++)
        ACCESS(M,vs,i,i) = VALUE_ONE;
    for (; i<= vs && i <= last_parallel_level; i++)
        ACCESS(M,vs,i,i) = int_to_value(lsd);
    for (i = MIN(perfect_nested_level+1,last_parallel_level+1); i<= vs; i++)
        ACCESS(M,vs,i,i) = VALUE_CONST(999);
 
  
    /* build origin tile vector as the first iteration to minimize
       the number of partial tiles (heuristics) */
 
    for (pv = base_index; !VECTEUR_NUL_P(pv); pv = pv->succ) {
        Variable var = vecteur_var(pv);
        sc_proj = sc_dup(sc);
        faisable =  sc_minmax_of_variable(sc_proj,var, &min, &max);
        if (faisable) 
            /*      vect_chg_coeff(&porigin,var,min);*/
            vect_chg_coeff(&porigin,var,VALUE_ONE);
        else
            pips_internal_error("illegal empty iteration domain");
 
    }
  
    tile = make_tiling(M, porigin);
    return tile;
}

References ACCESS, int_to_value, make_tiling(), matrice_new, matrice_nulle(), max, min, MIN, pips_internal_error, sc_dup(), sc_minmax_of_variable(), Svecteur::succ, VALUE_CONST, VALUE_ONE, vect_chg_coeff(), vect_size(), VECTEUR_NUL, VECTEUR_NUL_P, and vecteur_var.

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_nest_to_wp65_code()

void loop_nest_to_wp65_code	(	entity	module,
		statement	loop_nest,
		graph	dg,
		int	pn,
		int	bn,
		int	ls,
		int	pd,
		entity	proc_id,
		entity	proc_id_mm,
		Pbase	bank_indices,
		hash_table	v_to_esv,
		hash_table	v_to_nlv,
		entity	compute_module,
		statement	computational,
		entity	memory_module,
		statement	emulator,
		statement_mapping	fetch_map,
		statement_mapping	store_map,
		statement	mod_stat
	)

load block

bank load block

store block

bank store block

compute block

list of local variables to list of conflicting references

inverse table: list of local variables to use for a given reference

variable to list of list of local variables: the main list is an image of connected components of the dependence graph filtered for a given variable, v; the low-level list is a function of the number of pipeline stages

reference to use-def usage ; use and def are encoded as action_is_read and action_is_write

pipelining offset; no pipelining is implemented yet

private variables for the loop nest

local variables

pour eviter tous les problemes de tiling sur les nids de boucles internes a des nids de boucles mal imbriques on execute les boucles internes en sequentiel. Il faudrait autrement s'assurer que l'on a les meme indices de boucles en interne pour le tiling et que les bornes sont identiques (meme restrictions que pour du loop fusion)

creation of new indices

a modifie pour tenir compte des dimensions reelles des domaines

normalement full_initila_basis == initial_basis2

a modifie pour tenir compte des dimensions reelles des domaines

put together the different pieces of code as two lists of statements

add the scanning over the tiles around them to build a proper stmt

update computational and emulator with cs and ems

Parameters

module	odule
loop_nest	oop_nest
dg	g
pn	n
bn	n
ls	s
pd	d
proc_id	roc_id
proc_id_mm	roc_id_mm
bank_indices	ank_indices
v_to_esv	_to_esv
v_to_nlv	_to_nlv
compute_module	ompute_module
computational	omputational
memory_module	emory_module
emulator	mulator
fetch_map	etch_map
store_map	tore_map
mod_stat	od_stat

Definition at line 579 of file instruction_to_wp65_code.c.

{
 
    Psysteme iteration_domain = sc_new();  
    Psysteme  iteration_domain2 = sc_new();
    Psysteme sc_tile = SC_UNDEFINED;
    tiling tile;
    Pvecteur tile_delay = VECTEUR_NUL;
    Pvecteur pv;
    int it;
    list lb = NIL;                      /* load block */
    list blb = NIL;                     /* bank load block */
    list sb = NIL;                      /* store block */
    list bsb = NIL;                     /* bank store block */
    list cb = NIL;                      /* compute block */
    /* list of local variables to list of conflicting references */
    hash_table llv_to_lcr = hash_table_make(hash_pointer, 0);
    /* inverse table: list of local variables to use for a given reference */
    hash_table r_to_llv = hash_table_make(hash_pointer, 0);
    /* variable to list of list of local variables: the main list
       is an image of connected components of the dependence graph filtered
       for a given variable, v; the low-level list is a function of
       the number of pipeline stages */
    hash_table v_to_lllv = hash_table_make(hash_pointer,0);
    /* reference to use-def usage ; use and def are encoded as action_is_read
       and action_is_write */
    hash_table r_to_ud = hash_table_make(hash_pointer,0);
 
    /* pipelining offset; no pipelining is implemented yet */
    Pbase offsets = VECTEUR_NUL;
    statement body;
 
    /* private variables for the loop nest */
    list lpv = loop_locals(instruction_loop(statement_instruction(loop_nest)));
 
    /* local variables */
    list cbl, embl = NIL;
    statement cs, ems,bs;
    statement io_st=statement_undefined;
    instruction i;
    list store_data_list = NIL; 
    list store_reference_list = NIL;
    Pbase initial_basis = BASE_NULLE;
    Pbase full_initial_basis = BASE_NULLE;
    Pbase local_basis = BASE_NULLE;
    Pbase tile_basis_in_initial_basis = BASE_NULLE;
    Pbase tile_basis_in_tile_basis = BASE_NULLE;
    Pbase local_basis2 = BASE_NULLE; 
    Pbase initial_basis2= BASE_NULLE; 
    Pbase tile_basis_in_tile_basis2 = BASE_NULLE; 
    Pbase loop_body_indices = BASE_NULLE;
    int i1,lpl, loop_nest_dimt;
    int first_parallel_level=1;
    int last_parallel_level, perfect_nested_loop_size; 
    bool loop_carried_dep[11];  
    bool fully_parallel;
    bool fully_sequential=true;
    int   nested_level2,nested_level=0;
    list list_statement_block=NIL;
    list list_statement_block2=NIL;
    list new_compute_lst = NIL;
    list new_bank_lst = NIL;
    instruction binst,binst2;
    bool io_statementp=false;
 
    debug_on("WP65_DEBUG_LEVEL");
    debug(5,"loop_nest_to_wp65_code", "begin\n");
 
    for (i1=1;i1<=10;i1++)  loop_carried_dep[i1] = false;
    compute_loop_nest_dim(loop_nest); 
    loop_nest_dimt = loop_nest_dim;
   
 
    fully_parallel =  full_parallel_loop_nest_p(mod_stat,loop_nest,
                                              loop_nest_dimt,dg,
                                                loop_carried_dep);
    find_iteration_domain(loop_nest,&iteration_domain, &initial_basis,
                          &nested_level,&list_statement_block, &binst);
    full_initial_basis = base_dup(initial_basis); 
    perfect_nested_loop_size= vect_size(initial_basis);
 
    /* pour eviter tous les problemes de tiling sur les nids de boucles
       internes a des nids de boucles mal imbriques on execute les boucles
       internes en sequentiel. Il faudrait autrement s'assurer que l'on a
       les meme indices de boucles en interne pour le tiling et que les
       bornes sont identiques (meme restrictions que pour du loop fusion) */
  
    for (i1=perfect_nested_loop_size+1;i1<=10;i1++)  
        loop_carried_dep[i1] = true;
    assert(perfect_nested_loop_size <=10);
 
    last_parallel_level =perfect_nested_loop_size+1; 
    if (!fully_parallel) {  
        for (i1=1; i1<=loop_nest_dimt && (loop_carried_dep[i1] == true);
             i1++);
        first_parallel_level = i1; 
        for (i1=first_parallel_level; 
             i1<=loop_nest_dimt && (loop_carried_dep[i1] == false);i1++);
        last_parallel_level = i1-1; 
        for (it=1, pv=initial_basis;
             it <perfect_nested_loop_size &&  it<last_parallel_level;
             it++, pv=pv->succ);
        loop_body_indices = base_dup(pv->succ);
        ifdebug(4) {
            (void) fprintf(stderr,"first_parallel_level :%d, last_parallel_level %d\n",
                           first_parallel_level,last_parallel_level);
            (void) fprintf(stderr,"\nLoop body basis - loop_nest:");
            base_fprint(stderr, loop_body_indices, (string(*)(void*))entity_local_name);
            (void) fprintf(stderr,"\nInitial basis - loop_nest:");
            base_fprint(stderr, initial_basis, (string(*)(void*))entity_local_name);
        }
    }
 
    /* creation of new indices */
    create_tile_basis(module,compute_module,memory_module, initial_basis,
                      &tile_basis_in_initial_basis,
                      &tile_basis_in_tile_basis,
                      &local_basis, 
                      &tile_basis_in_tile_basis2,
                      &local_basis2);
    lpl = (fully_parallel) ? last_parallel_level-1:last_parallel_level;
    tile = loop_nest_to_tile(iteration_domain, ls, 
                             initial_basis, first_parallel_level,lpl,
                             perfect_nested_loop_size); 
      
    sc_tile = loop_bounds_to_tile_bounds(iteration_domain,initial_basis, 
                                         tile, tile_delay, 
                                         tile_basis_in_tile_basis, 
                                         local_basis);
  
    ifdebug(8) { 
        fprintf(stderr,"loop body \n");
        MAP(STATEMENT, s, wp65_debug_print_text(module, s), 
            list_statement_block); 
             }
    if (list_of_calls_p(list_statement_block)) {
        body = perfectly_nested_loop_to_body(loop_nest);
 
     if (io_loop_nest_p(body)) {
         io_st = generate_io_wp65_code(loop_nest,body,v_to_esv,true);
     io_statementp = true;}
     else {
 
        /* a modifie pour tenir compte des dimensions reelles des domaines */
 
        loop_nest_to_local_variables(module, compute_module, memory_module, 
                                     llv_to_lcr, r_to_llv, v_to_lllv, 
                                     r_to_ud, v_to_esv, v_to_nlv,
                                     lpv, body, initial_basis, dg, 
                                     bn, ls, pd, 
                                     tile);
        ifdebug(4) fprint_wp65_hash_tables(stderr, llv_to_lcr, r_to_llv, v_to_lllv, 
                                           r_to_ud, v_to_esv);
  
        loop_nest_movement_generation(module,loop_nest,pn,bn, ls, pd,proc_id,proc_id_mm,
                                      bank_indices,v_to_esv,v_to_nlv,compute_module,
                                      computational, memory_module,emulator,fetch_map,
                                      store_map,mod_stat,fully_parallel,sc_tile, 
                                      full_initial_basis,local_basis, local_basis2,
                                      tile_basis_in_tile_basis, tile_basis_in_tile_basis2, 
                                      loop_body_indices,lpv,&lb,&blb,&sb,
                                      &bsb,first_parallel_level, last_parallel_level, 
                                      llv_to_lcr, r_to_llv, v_to_lllv,r_to_ud ); 
}    
    }
    else {
        Pbase tbib2 = BASE_NULLE;
        Pbase tbtl3 = BASE_NULLE;
        Pbase tbtl4 = BASE_NULLE;
        Pbase lba3 = BASE_NULLE; 
        Pbase lba4 = BASE_NULLE; 
        Pbase lba5 = BASE_NULLE; 
        Pbase lba6 = BASE_NULLE; 
        Pbase tbtl5 = BASE_NULLE;
        Pbase tbtl6 = BASE_NULLE;
        Psysteme sc_tile2 = SC_UNDEFINED;
        tiling tile2;
 
        MAPL(lsb,
         {
             statement stmp =  STATEMENT(CAR(lsb)); 
             if (!continue_statement_p(stmp)) {
                 instruction_block(binst) = CONS(STATEMENT,stmp,NIL);
                 ifdebug(8) 
                 {
                     fprintf(stderr,"generation des transferts pour \n");
                     wp65_debug_print_text(module, loop_nest);
                 }
                 body =  perfectly_nested_loop_to_body(loop_nest);
                 find_iteration_domain(loop_nest,&iteration_domain2,
                                       &initial_basis2,&nested_level2,
                                       &list_statement_block2,&binst2);
                 if (loop_nest_dimt > perfect_nested_loop_size) {
                     loop_body_indices = vect_dup(initial_basis2);
                     for ( pv=initial_basis; pv!= NULL;
                        vect_chg_coeff(&loop_body_indices,pv->var,VALUE_ZERO),
                          pv =pv->succ);
                     full_initial_basis=base_reversal(vect_add(initial_basis,
                                                               loop_body_indices));
                     /* normalement full_initila_basis == initial_basis2*/
                }
                 ifdebug(2) {
                     (void) fprintf(stderr,"full basis\n");
                     base_fprint(stderr, initial_basis2, 
                                 (string(*)(void*))entity_local_name);
                     (void)  fprintf(stderr,"full iteration domain\n");
                     sc_fprint(stderr,iteration_domain2, 
                               (string(*)(void*))entity_local_name);
                 }
                 create_tile_basis(module,compute_module,memory_module, loop_body_indices,
                                   &tbib2, &tbtl3, &lba3, &tbtl4, &lba4);
                 tbtl5= base_reversal(vect_add(tile_basis_in_tile_basis, tbtl3));
                 tbtl6= base_reversal(vect_add(tile_basis_in_tile_basis2, tbtl4));
                 //Pbase tbib3=base_reversal(vect_add(tile_basis_in_initial_basis, tbib2));
                 lba5= base_reversal(vect_add( local_basis, lba3));
                 lba6= base_reversal(vect_add( local_basis2, lba4));
                 /* a modifie pour tenir compte des dimensions reelles des domaines */
                 tile2 = loop_nest_to_tile(iteration_domain2, ls, initial_basis2, 
                                           first_parallel_level,lpl,
                                           perfect_nested_loop_size); 
                 sc_tile2=loop_bounds_to_tile_bounds(iteration_domain2,initial_basis2, 
                                                     tile2, tile_delay,tbtl5,lba5);
 
                 loop_nest_to_local_variables(module, compute_module, memory_module, 
                                              llv_to_lcr, r_to_llv, v_to_lllv, 
                                              r_to_ud, v_to_esv, v_to_nlv,
                                              lpv, body, initial_basis2, dg, 
                                              bn, ls, pd,tile2);
                 ifdebug(4) fprint_wp65_hash_tables(stderr, llv_to_lcr, 
                                                    r_to_llv, v_to_lllv, 
                                                    r_to_ud, v_to_esv);
                 loop_nest_movement_generation(
                     module,stmp,pn,bn, ls, pd,proc_id,
                     proc_id_mm, bank_indices,v_to_esv,
                     v_to_nlv,compute_module, computational,
                     memory_module,emulator,fetch_map,
                     store_map, mod_stat,fully_parallel,
                     sc_tile2,initial_basis2,lba5,lba6,tbtl5,
                     tbtl6,loop_body_indices,lpv,&lb,&blb,&sb,
                     &bsb,first_parallel_level, 
                     last_parallel_level, llv_to_lcr, 
                     r_to_llv, v_to_lllv,r_to_ud ); 
                 reduce_loop_bound_for_st(stmp);
             } 
                
         },
             list_statement_block); 
    }    
    fully_sequential = (first_parallel_level >last_parallel_level); 
 
    if (io_statementp)  {
        cs = statement_undefined;
        ems =io_st;
    }
    else {
        insert_run_time_communications(compute_module, memory_module,
                                       bank_indices,bn,ls,proc_id,
                                       list_statement_block,fetch_map,
                                       store_map,&new_compute_lst,
                                       &new_bank_lst,v_to_esv,
                                       fully_sequential,
                                       initial_basis,tile, tile_delay, 
                                       tile_basis_in_tile_basis, 
                                       local_basis);
 
        instruction_block(binst)= new_compute_lst;
        body = instruction_to_statement(binst);
        ifdebug(8) {
            fprintf(stderr,"loop body \n");
            wp65_debug_print_text(module, body); 
            fprintf(stderr,"base_initiale 1\n");
            vect_fprint(stderr,initial_basis,(string(*)(void*))entity_local_name);
        }
        
    sc_variables_rename(sc_tile,local_basis,local_basis2, (string(*)(void*))entity_local_name);
    sc_variables_rename(sc_tile, tile_basis_in_tile_basis, 
                        tile_basis_in_tile_basis2,(string(*)(void*))entity_local_name);  
 
    cb = make_compute_block(compute_module, body, offsets, r_to_llv,tile, 
                            initial_basis, local_basis2,
                            tile_basis_in_tile_basis2,
                            tile_basis_in_initial_basis,
                            iteration_domain,first_parallel_level,
                            last_parallel_level);
      
 
    if (new_bank_lst != NIL) {
        bs = make_scanning_over_one_tile(module, 
                                         make_block_statement(new_bank_lst),
                                         tile, initial_basis, local_basis,
                                         tile_basis_in_tile_basis,
                                         tile_basis_in_initial_basis,
                                         iteration_domain,
                                         first_parallel_level,
                                         last_parallel_level);
        new_bank_lst = CONS(STATEMENT,bs,NIL);
    }
        /* put together the different pieces of code as two lists of
           statements */
        cbl = gen_nconc(lb, gen_nconc(cb ,sb));
        bsb = gen_nconc(new_bank_lst, bsb);
        embl =gen_nconc(blb, bsb);
        
        /* add the scanning over the tiles around them to build a proper stmt */
        cs = make_scanning_over_tiles(compute_module, cbl, proc_id, pn,tile, 
                                      initial_basis, 
                                      tile_basis_in_tile_basis2,
                                      tile_basis_in_initial_basis,
                                      iteration_domain,first_parallel_level,
                                      last_parallel_level);
        ems = make_scanning_over_tiles(memory_module, embl, proc_id_mm, 
                                       pn, tile, initial_basis, 
                                       tile_basis_in_tile_basis, 
                                       tile_basis_in_initial_basis,
                                       iteration_domain,first_parallel_level,
                                       last_parallel_level);
        
        if (fully_sequential) {
            range looprange = make_range(int_to_expression(0),
                                         int_to_expression(pn-1),
                                         int_to_expression(1));
            entity looplabel = make_loop_label(9000, 
                                               compute_module);
            loop newloop = make_loop(proc_id, 
                                     looprange,
                                     ems,
                                     looplabel, 
                                     make_execution(is_execution_parallel,
                                                    UU),
                                     NIL);
            
            ems = loop_to_statement(newloop);
        }
        /* update computational and emulator with cs and ems */
    }
    i = statement_instruction(computational);
    if (cs != statement_undefined) 
        instruction_block(i) = gen_nconc(instruction_block(i),CONS(STATEMENT, cs, NIL));
    i = statement_instruction(emulator);
    instruction_block(i) = gen_nconc(instruction_block(i),CONS(STATEMENT, ems, NIL));
    
    ifdebug(5) {
        (void) fprintf(stderr,
                       "Vars having to be stored into global memory:\n");
        reference_list_print(store_data_list);
        reference_list_print(store_reference_list);
    }
    gen_map((gen_iter_func_t)reference_scalar_defined_p, store_data_list);
    
      MAPL(r1,{ 
        reference rf = REFERENCE(CAR(r1));
        if (reference_scalar_p(rf)) {
            include_constant_symbolic_communication(compute_module,CONS(REFERENCE,rf,NIL),
                                                    false,computational,proc_id);
            include_constant_symbolic_communication(memory_module,CONS(REFERENCE,rf,NIL),
                                                    true,emulator,(entity)bank_indices->var);
        }
    },
         store_data_list); 
    hash_table_free(llv_to_lcr);
    hash_table_free(r_to_llv);
    hash_table_free(v_to_lllv);
    hash_table_free(r_to_ud);
    
    debug(5,"loop_nest_to_wp65_code", "end\n");
    debug_off();
}

References assert, base_dup(), base_fprint(), BASE_NULLE, base_reversal(), CAR, compute_loop_nest_dim(), CONS, continue_statement_p(), create_tile_basis(), debug(), debug_off, debug_on, dg, entity_local_name(), find_iteration_domain(), fprint_wp65_hash_tables(), fprintf(), full_parallel_loop_nest_p(), gen_map(), gen_nconc(), generate_io_wp65_code(), hash_pointer, hash_table_free(), hash_table_make(), ifdebug, include_constant_symbolic_communication(), insert_run_time_communications(), instruction_block, instruction_loop, instruction_to_statement(), int_to_expression(), io_loop_nest_p(), is_execution_parallel, list_of_calls_p(), loop_bounds_to_tile_bounds(), loop_locals, loop_nest_dim, loop_nest_movement_generation(), loop_nest_to_local_variables(), loop_nest_to_tile(), loop_to_statement, make_block_statement(), make_compute_block(), make_execution(), make_loop(), make_loop_label(), make_range(), make_scanning_over_one_tile(), make_scanning_over_tiles(), MAP, MAPL, mod_stat, module, NIL, perfectly_nested_loop_to_body(), reduce_loop_bound_for_st(), REFERENCE, reference_list_print(), reference_scalar_defined_p(), reference_scalar_p(), sc_fprint(), sc_new(), sc_variables_rename(), STATEMENT, statement_instruction, statement_undefined, Svecteur::succ, UU, VALUE_ZERO, Svecteur::var, vect_add(), vect_chg_coeff(), vect_dup(), vect_fprint(), vect_size(), VECTEUR_NUL, and wp65_debug_print_text().

Referenced by instruction_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

make_all_movement_blocks()

void make_all_movement_blocks	(	entity	initial_module,
		entity	compute_module,
		entity	memory_module,
		entity	v,
		list	map,
		hash_table	llv_to_lcr,
		hash_table	v_to_lllv,
		hash_table	r_to_ud,
		hash_table	v_to_esv,
		int	pn,
		int	bn,
		int	ls,
		Psysteme	iteration_domain,
		Pbase	initial_basis,
		Pbase	local_basis,
		entity	proc_id,
		Pbase	bank_indices,
		Pbase	loop_body_indices,
		list *	pmb,
		list *	pbmb,
		tag	use_def,
		int	first_parallel_level,
		int	last_parallel_level
	)

generates all data movements related to entity v, loads or stores depending on use_def

FI: depending on the pipeline stage, a specific lv should be chosen; by default, let's take the first one

statement for one movement block

statement for one bank movement block

Parameters

initial_module	nitial_module
compute_module	ompute_module
memory_module	emory_module
map	ap
llv_to_lcr	lv_to_lcr
v_to_lllv	_to_lllv
r_to_ud	_to_ud
v_to_esv	_to_esv
pn	n
bn	n
ls	s
iteration_domain	teration_domain
initial_basis	nitial_basis
local_basis	ocal_basis
proc_id	roc_id
bank_indices	ank_indices
loop_body_indices	oop_body_indices
pmb	mb
pbmb	bmb
use_def	se_def
first_parallel_level	irst_parallel_level
last_parallel_level	ast_parallel_level

Definition at line 972 of file instruction_to_wp65_code.c.

{
    list lllv = (list) hash_get(v_to_lllv, (char *) v);
    entity esv = (entity) hash_get(v_to_esv, (char *) v);
 
    debug(8,"make_all_movement_blocks", "begin\n");
    for(; !ENDP(lllv); POP(lllv)) {
        /* FI: depending on the pipeline stage, a specific lv should be 
           chosen; by default, let's take the first one */
        list llv = LIST(CAR(lllv));
        entity lv = ENTITY(CAR(llv));
        list lr = (list) hash_get(llv_to_lcr, (char *) llv);
        bool proper_tag = false;
 
        for(; !ENDP(lr) && !proper_tag ; POP(lr)) {
            reference r = REFERENCE(CAR(lr));
            if( reference_in_list_p(r,map) && 
               (intptr_t) hash_get(r_to_ud, r) == (intptr_t)use_def) {
                statement mbs = NULL;   /* statement for one movement block */
                statement bmbs = NULL;   /* statement for one bank movement block */
 
                proper_tag = true;
                switch(use_def) {
                case is_action_read:
                    make_load_blocks(initial_module,compute_module,
                                     memory_module, v, esv, lv,
                                     lr, r_to_ud, iteration_domain,
                                     initial_basis, bank_indices,
                                     local_basis, loop_body_indices,
                                     proc_id, pn,bn, ls, 
                                     &mbs, &bmbs,first_parallel_level,
                                     last_parallel_level);
 
                    break;
                case is_action_write:
                    make_store_blocks(initial_module,compute_module,
                                      memory_module, v, esv, lv,
                                      lr, r_to_ud, iteration_domain,
                                      initial_basis, 
                                      bank_indices,local_basis,
                                      loop_body_indices,
                                      proc_id, pn,bn, ls, 
                                      &mbs, &bmbs,first_parallel_level,
                                      last_parallel_level);
                    break;
                default:
                    pips_internal_error("unexpected use-def = %d", use_def);
                }
 
                ifdebug(9) {
                    pips_debug(9, "mbs=\n");
                    wp65_debug_print_text(compute_module, mbs);
                    pips_debug(9, "bmbs=\n");
                    wp65_debug_print_text(compute_module, mbs);
                }
 
                *pmb = gen_nconc(*pmb, CONS(STATEMENT, mbs, NIL));
                *pbmb = gen_nconc(*pbmb, CONS(STATEMENT, bmbs, NIL));
            }
        }
    }
 
    debug(8,"make_all_movement_blocks", "end\n");
}

References CAR, CONS, debug(), ENDP, ENTITY, gen_nconc(), hash_get(), ifdebug, intptr_t, is_action_read, is_action_write, LIST, make_load_blocks(), make_store_blocks(), NIL, pips_debug, pips_internal_error, POP, REFERENCE, reference_in_list_p(), STATEMENT, and wp65_debug_print_text().

Referenced by loop_nest_movement_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

make_compute_block()

list make_compute_block	(	entity	module,
		statement	body,
		Pvecteur	offsets,
		hash_table	r_to_llv,
		tiling	tile,
		Pbase	initial_basis,
		Pbase	local_basis,
		Pbase	tile_basis_in_tile_basis,
		Pbase	tile_basis_in_initial_basis,
		Psysteme	iteration_domain,
		int	first_parallel_level,
		int	last_parallel_level
	)

Parameters

module	odule
body	ody
offsets	ffsets
r_to_llv	_to_llv
tile	ile
initial_basis	nitial_basis
local_basis	ocal_basis
tile_basis_in_tile_basis	ile_basis_in_tile_basis
tile_basis_in_initial_basis	ile_basis_in_initial_basis
iteration_domain	teration_domain
first_parallel_level	irst_parallel_level
last_parallel_level	ast_parallel_level

Definition at line 679 of file code.c.

{
    statement s;
 
    list lt = NIL;
    lt = reference_conversion_statement(module,body, &lt, r_to_llv, offsets, initial_basis,
                                   tile_basis_in_tile_basis,local_basis,tile);
    body = make_block_statement(gen_nconc(lt,instruction_block(statement_instruction(body))));
    s = make_scanning_over_one_tile(module, body,
                                    tile, initial_basis, local_basis,
                                    tile_basis_in_tile_basis,
                                    tile_basis_in_initial_basis,
                                    iteration_domain,first_parallel_level,last_parallel_level);
 
    return CONS(STATEMENT, s, NIL);
}

References CONS, gen_nconc(), instruction_block, make_block_statement(), make_scanning_over_one_tile(), module, NIL, reference_conversion_statement(), STATEMENT, and statement_instruction.

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

make_emulated_shared_variable()

entity make_emulated_shared_variable	(	entity	v,
		entity	memory_module,
		int	bn,
		int	ls
	)

filled in the following

filled in the following

generate the proper type; basic is preserved but the array is made two dimensional

In two sprintf , -1 is added once seperately by LZ make_expression_1 takes the place of the make_expression_1 12/11/91

FI->CA, LZ: what should we do with scalar variables? Put a copy on each memory bank? Take into account memory bank conflicts shown in thresholding (PUMA WP 6.1 and 6.7)

Parameters

memory_module	emory_module
bn	n
ls	s

Definition at line 195 of file variable.c.

{
    string esv_name = strdup(concatenate(entity_local_name(memory_module),
                                         MODULE_SEP_STRING,
                                         EMULATED_SHARED_MEMORY_PREFIX,
                                         entity_local_name(v),
                                         NULL));
    entity esv = gen_find_tabulated(esv_name, entity_domain);
    type tv = entity_type(v);
    basic bv = variable_basic(type_variable(tv));
    list ldv = variable_dimensions(type_variable(tv));
    entity a;
    int number_of_elements = 1;
 
    dimension esvd1 = dimension_undefined;
    dimension esvd2 = dimension_undefined;
    debug(8,"make_emulated_shared_variable", "begin\n");
 
    pips_assert("make_emulated_shared_variable", esv == entity_undefined );
    pips_assert("make_emulated_shared_variable", type_variable_p(tv));
 
    
 
    esv = make_entity(esv_name,
                      type_undefined,   /* filled in the following */
                      storage_undefined,        
                      value_undefined ); /* filled in the following */
 
    /* generate the proper type; basic is preserved but the array is made
       two dimensional */
 
    for( ; !ENDP(ldv); POP(ldv)) {
        dimension d = DIMENSION(CAR(ldv));
        int size = dimension_size(d);
        number_of_elements *= size;
    }
 
    ifdebug(8) {
        (void) fprintf(stderr,"number of elements for %s: %d\n", 
                       entity_name(esv), number_of_elements);
    }
 
     /* In two sprintf , -1 is added once seperately  by LZ
      * make_expression_1 takes the place of the make_expression_1
      * 12/11/91
      */
    if(number_of_elements > 1) {
        esvd1 = make_dimension(int_to_expression(0),
                               int_to_expression(ls-1),
                               NIL);
        esvd2 = make_dimension(int_to_expression(0),
                               int_to_expression((number_of_elements+ls*bn-1)/(ls*bn)),
                               NIL);
 
        entity_type(esv) = MakeTypeVariable(copy_basic(bv), 
                                            CONS(DIMENSION, esvd1,
                                                 CONS(DIMENSION, esvd2, NIL)));
    }
    else {
        /* FI->CA, LZ: what should we do with scalar variables? Put a copy
           on each memory bank? Take into account memory bank conflicts
           shown in thresholding (PUMA WP 6.1 and 6.7) */
        entity_type(esv) = MakeTypeVariable( copy_basic(bv), NIL);
    }
 
    entity_initial(esv) = make_value_unknown();
 
    a = FindEntity(module_local_name(memory_module), 
                              DYNAMIC_AREA_LOCAL_NAME);
    entity_storage(esv)=make_storage(is_storage_ram,
                                     (make_ram(memory_module, 
                                               a,
                                               add_variable_to_area(a,
                                                                    esv),
                                               NIL)));
    
    AddEntityToDeclarations(esv,memory_module);
 
    debug(8,"make_emulated_shared_variable", "esv_name=%s\n", entity_name(esv));
    ifdebug(8) print_sentence(stderr,Sentence_Variable(esv));
    debug(8,"make_emulated_shared_variable", "end\n");
 
    return(esv);
}

References add_variable_to_area(), AddEntityToDeclarations(), CAR, concatenate(), CONS, copy_basic(), debug(), DIMENSION, dimension_size(), dimension_undefined, DYNAMIC_AREA_LOCAL_NAME, EMULATED_SHARED_MEMORY_PREFIX, ENDP, entity_domain, entity_initial, entity_local_name(), entity_name, entity_storage, entity_type, entity_undefined, FindEntity(), fprintf(), gen_find_tabulated(), ifdebug, int_to_expression(), is_storage_ram, make_dimension(), make_entity, make_ram(), make_storage(), make_value_unknown(), MakeTypeVariable(), module_local_name(), MODULE_SEP_STRING, NIL, number_of_elements(), pips_assert, POP, print_sentence(), Sentence_Variable(), storage_undefined, strdup(), type_undefined, type_variable, type_variable_p, value_undefined, variable_basic, and variable_dimensions.

Referenced by find_or_create_emulated_shared_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

make_fetch_map()

void make_fetch_map

(

void

)

make_load_blocks()

void make_load_blocks	(	entity	initial_module,
		entity	compute_module,
		entity	memory_module,
		entity	var,
		entity	shared_variable,
		entity	local_variable,
		list	lrefs,
		hash_table	r_to_ud,
		Psysteme	sc_domain,
		Pbase	index_base,
		Pbase	bank_indices,
		Pbase	tile_indices,
		Pbase	loop_body_indices,
		entity	Proc_id,
		int	pn,
		int	bn,
		int	ls,
		statement *	load_block,
		statement *	bank_load_block,
		int	first_parallel_level,
		int	last_parallel_level
	)

is true if it is the generation of code for bank false if it is for engine

is true if the generated code must be a RECEIVE, false if it must be a SEND

Cases where the references are scalar variables

In the other cases the references must be classified in lists of uniform dependent references

For each list of uniform dependent references, "load_block" and "bank_load_block" are computed

Parameters

initial_module	nitial_module
compute_module	ompute_module
memory_module	emory_module
var	ar
shared_variable	hared_variable
local_variable	ocal_variable
lrefs	refs
r_to_ud	_to_ud
sc_domain	c_domain
index_base	ndex_base
bank_indices	ank_indices
tile_indices	ile_indices
loop_body_indices	oop_body_indices
Proc_id	roc_id
pn	n
bn	n
ls	s
load_block	oad_block
bank_load_block	ank_load_block
first_parallel_level	irst_parallel_level
last_parallel_level	ast_parallel_level

Definition at line 1312 of file code.c.

{
  pips_assert("true", last_parallel_level==last_parallel_level &&
              first_parallel_level==first_parallel_level);
    list lur;
    list llur = NIL;
    list lrs = lrefs;
    Psysteme sc_image,sc_array_function;
    int n,dim_h;
    Pbase const_base;
    Pbase new_index_base = BASE_NULLE;
    Pbase new_tile_indices = BASE_NULLE;
    bool bank_code;                     /* is true if it is the generation 
                                           of code for bank false if it is 
                                           for engine */
    bool receive_code;          /* is true if the generated code 
                                           must be a RECEIVE, false if it 
                                           must be a SEND*/
    reference r;
    statement stat1,stat2,lb,blb;
    cons * bst_lb= NIL;
    cons * bst_blb= NIL;
    Pbase var_id;
    Pvecteur ppid = vect_new((char *) Proc_id, VALUE_ONE);
    Psysteme sc_image2= SC_UNDEFINED;
    debug(8,"make_load_blocks",
          "begin variable=%s, shared_variable=%s, local_variable=%s\n",
          entity_local_name(var), entity_local_name(shared_variable),
          entity_local_name(local_variable));
 
    ifdebug(8) {
        list crefs;
        (void) fprintf(stderr, "Associated reference list:");
        for(crefs=lrefs; !ENDP(crefs); POP(crefs)) {
            reference r1 = REFERENCE(CAR(crefs));
            print_reference(r1);
            if(ENDP(CDR(crefs)))
                (void) putc('\n', stderr);
            else
                (void) putc(',', stderr);
        }
    }
 
 
    /* Cases where the references are scalar variables */
 
    for (lrs =lrefs ; !ENDP(lrs) ; POP(lrs)) {
        r = REFERENCE(CAR(lrs));
        if (reference_indices(r) ==NIL) {
 
            receive_code = true;
            *load_block =make_movement_scalar_wp65(compute_module,receive_code,
                                                   r,Proc_id);
            receive_code = false;
            *bank_load_block=
                make_movement_scalar_wp65(memory_module,receive_code,
                                          r,(entity) bank_indices->var);
            return;
        }
    }
    /* In the other cases the references must be classified in lists of 
       uniform dependent references */
 
    for (lrs =lrefs ; !ENDP(lrs) ; POP(lrs)) {
        r = REFERENCE(CAR(lrs));
        if ( (intptr_t) hash_get(r_to_ud, r) == (intptr_t)is_action_read) 
            llur = classify_reference(llur,r);
    }
 
    /* For each list of uniform dependent references, "load_block" and 
       "bank_load_block" are computed */
 
    for (lur=llur; lur != NIL; lur = CDR(lur)) {
        sc_array_function=
            build_sc_with_several_uniform_ref(initial_module,
                                              LIST(CAR(lur)),
                                              sc_domain,&new_index_base);
        new_index_base = vect_add(new_index_base,
                                  vect_dup(index_base));
 
        sc_image =  sc_image_computation(initial_module,var,sc_domain,
                                         sc_array_function,new_index_base,
                                         &const_base,Proc_id,bank_indices,
                                         tile_indices,&new_tile_indices,
                                         pn,bn,ls,
                                         &n,&dim_h);
        nullify_offsets();
        sc_image2= sc_dup(sc_image);
        bank_code = true ;
        receive_code = false;
        var_id = (Pbase) vect_new(vecteur_var(ppid),
                                  vecteur_val(ppid));
        stat1 = movement_computation(memory_module,
                                     true,
                                     bank_code,
                                     receive_code,
                                     shared_variable,sc_image,
                                     const_base,bank_indices,new_tile_indices,
                                     var_id, loop_body_indices,n,dim_h);
        initialize_offsets(lur);
        bank_code = false ;
        receive_code = true;
        var_id = (Pbase) vect_new(vecteur_var(bank_indices),
                                  vecteur_val(bank_indices));
        stat2 = movement_computation(compute_module,
                                     true,
                                     bank_code,
                                     receive_code,
                                     local_variable,sc_image2,
                                     const_base,bank_indices,new_tile_indices,
                                     var_id, loop_body_indices,n,dim_h);
 
        bst_lb = CONS(STATEMENT,stat2,bst_lb);  
        bst_blb = CONS(STATEMENT,stat1,bst_blb);        
    }
 
    lb = make_block_statement(bst_lb);
    blb = make_block_statement(bst_blb);
    *load_block =lb;
    *bank_load_block=blb;
 
    debug(8,"make_load_blocks", "end\n");
}

References BASE_NULLE, build_sc_with_several_uniform_ref(), CAR, CDR, classify_reference(), CONS, debug(), ENDP, entity_local_name(), false, fprintf(), hash_get(), ifdebug, initialize_offsets(), intptr_t, is_action_read, LIST, make_block_statement(), make_movement_scalar_wp65(), movement_computation(), NIL, nullify_offsets(), pips_assert, POP, print_reference(), REFERENCE, reference_indices, sc_dup(), sc_image_computation(), STATEMENT, true, VALUE_ONE, Svecteur::var, vect_add(), vect_dup(), vect_new(), vecteur_val, and vecteur_var.

Referenced by make_all_movement_blocks().

Here is the call graph for this function:

Here is the caller graph for this function:

make_new_local_variables()

list make_new_local_variables	(	entity	v,
		entity	compute_module,
		int	number,
		int	pd,
		hash_table	v_to_lllv
	)

Local variables cannot be immediately dimensionned because this will depend on all associated references.

To avoid a possible "fusion" between references connected in the dg, local variable declarations should be delayed to that point.

concatenate cannot be used (directly) because of n and s conversions

a new btv is necessary for each variable because CONS cannot be shared under NewGen rules

FI->LZ: the type should be v's type, except for the dimensions, the storage should be RAM and allocated in the dynamic area of module_name, and the value is undefined; the actual dimensions will be updated later

update v_to_lllv by side effect

Parameters

compute_module	ompute_module
number	umber
pd	d
v_to_lllv	_to_lllv

Definition at line 310 of file variable.c.

{
    /* Local variables cannot be immediately dimensionned because this
       will depend on *all* associated references.
       
       To avoid a possible "fusion" between references connected in the dg,
       local variable declarations should be delayed to that point. */
 
    /* concatenate cannot be used (directly) because of n and s conversions */
    char *local_variable_name;
    int s;
    list llv = NIL;
    list lllv = NIL;
    const char* computational_name = entity_local_name(compute_module);
 
    type tv = entity_type(v);
    entity a; 
 
    debug(7,"make_new_local_variables","begin v=%s, number=%d, pd=%d\n",
          entity_name(v), number, pd);
 
    for(s=0; s<pd; s++) {
        entity lv;
        /* a new btv is necessary for each variable because CONS cannot
           be shared under NewGen rules */
        basic btv =  copy_basic(variable_basic(type_variable(tv)));
 
        (void) asprintf(&local_variable_name,"%s%s%s%s%s%d%s%d",
                       computational_name,
                       MODULE_SEP_STRING,
                       LOCAL_MEMORY_PREFIX,
                       entity_local_name(v),
                       LOCAL_MEMORY_SEPARATOR,
                       number,
                       LOCAL_MEMORY_SEPARATOR,
                       s);
                
        /* FI->LZ: the type should be v's type, except for the dimensions,
           the storage should be RAM and allocated in the dynamic
           area of module_name, and the value is undefined;
           the actual dimensions will be updated later */
        lv = make_entity(local_variable_name,
                         MakeTypeVariable(btv, NIL),
                         storage_undefined,
                         value_undefined);
 
        a = FindEntity(module_local_name(compute_module), 
                                  DYNAMIC_AREA_LOCAL_NAME);
        pips_assert("make_new_local_variables",!entity_undefined_p(a));
 
        entity_storage(lv) = make_storage(is_storage_ram,
                                          (make_ram(compute_module, a,
                                                    add_variable_to_area(a, lv),
                                                    NIL)));
 
 
        AddEntityToDeclarations( lv,compute_module);
        llv = gen_nconc(llv, CONS(ENTITY, lv, NIL));
    }
 
    if((lllv = (list) hash_get(v_to_lllv, (char *) v)) 
       == (list) HASH_UNDEFINED_VALUE) {
        lllv = CONS(LIST, llv, NIL);
        hash_put(v_to_lllv, (char *) v, (char *) lllv);
    }
    else {
        /* update v_to_lllv by side effect */
        lllv = gen_nconc(lllv, CONS(LIST, llv, NIL));
    }
 
 
    debug(7,"make_new_local_variables","end\n");
    
    return llv;
}

References add_variable_to_area(), AddEntityToDeclarations(), asprintf, CONS, copy_basic(), debug(), DYNAMIC_AREA_LOCAL_NAME, ENTITY, entity_local_name(), entity_name, entity_storage, entity_type, entity_undefined_p, FindEntity(), gen_nconc(), hash_get(), hash_put(), HASH_UNDEFINED_VALUE, is_storage_ram, LIST, LOCAL_MEMORY_PREFIX, LOCAL_MEMORY_SEPARATOR, make_entity, make_ram(), make_storage(), MakeTypeVariable(), module_local_name(), MODULE_SEP_STRING, NIL, pips_assert, storage_undefined, type_variable, value_undefined, and variable_basic.

Referenced by loop_nest_to_local_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

make_scanning_over_one_tile()

statement make_scanning_over_one_tile	(	entity	module,
		statement	body,
		tiling	tile,
		Pbase	initial_basis,
		Pbase	local_basis,
		Pbase	tile_basis_in_tile_basis,
		Pbase	tile_basis_in_initial_basis,
		Psysteme	iteration_domain,
		int	first_parallel_level,
		int	last_parallel_level
	)

make_scanning_over_one_tile():

generates a nest of loops to enumerate all iterations contained in one tile; the loop bounds are such that empty tiles execute no iteration at all;

The following system is built:

-> -> B i <= b

-> --> -> t1 = P t0 + o

-> --> -> i = t1 + l

-> -1 -> --> -—> 0 <= k P ( i - t1 ) <= (k-1)

where (B,b) defines the iteration domain, t1 is the tile origin in the initial basis, t0 is the tile origin in the tile basis, P is the partitioning matrix, o is the partitioning origin, i is an iteration, and k is the denominator of the inverse of P. l is an iteration in the local (to the current tile) basis.

Because the loops over the tiles are built with t1 and because we need to access the copy with local coordinates, i and t0 are eliminated.

A few changes would make this function generate loops for a shared memory machine. The local_basis would be useless and the initial basis should be chosen as indices for the loops so as not to have to update the loop body. So l would not be introduced and i would not be projected.

Algorithm described in PPoPP'91.

only fully-dimensional partitioning for the time being

add change of basis equations to iteration domain: tile_basis_in_tile_basis to tile_basis_in_initial_basis

add translation equations from initial basis to local basis using tile_basis_in_initial_basis: i == t1 + l

add the tile membership inequalities

update the basis for system tile_domain

get rid of tile_basis_in_initial_basis; we might as well (?) keep them and get rid of tile_basis_in_tile_basis

get rid of initial indices

TEMPTATIVE

compute general information on loop bound origins this is done to take into account information carried by the outer loops, scanning the tile set

get rid of local indices

inject this redundant information

END OF TEMPTATIVE SECTION

apply a row echelon transformation

transform these constraints into a loop nest with the right body, starting with the innermost loop

test pour optimiser le nid de boucles genere

I need new labels and new continues for my loops! make_loop_label() needs (at least) a module name

Parameters

module	odule
body	ody
tile	ile
initial_basis	nitial_basis
local_basis	ocal_basis
tile_basis_in_tile_basis	ile_basis_in_tile_basis
tile_basis_in_initial_basis	ile_basis_in_initial_basis
iteration_domain	teration_domain
first_parallel_level	irst_parallel_level
last_parallel_level	ast_parallel_level

Definition at line 475 of file code.c.

{
  pips_assert("true", first_parallel_level==first_parallel_level);
    Psysteme tile_domain = sc_dup(iteration_domain);
    Psysteme ordered_tile_domain = SC_UNDEFINED;
    Psysteme origin_domain = SC_UNDEFINED;
    int id = base_dimension(initial_basis);
    int td = base_dimension(tile_basis_in_tile_basis);
    int l,t,i;
    statement s = statement_undefined;
    Pvecteur pv;
 
    debug(8,"make_scanning_over_one_tile", "begin for module %s\n",
          module_local_name(module));
 
    /* only fully-dimensional partitioning for the time being */
    pips_assert("make_scanning_over_one_tile",id==td); 
 
    /* add change of basis equations to iteration domain:
       tile_basis_in_tile_basis to tile_basis_in_initial_basis */
  
 
     tile_change_of_basis(tile_domain,initial_basis,
                        tile_basis_in_tile_basis,
                        tile_basis_in_initial_basis,tile);
 
    /* add translation equations from initial basis to local basis
       using tile_basis_in_initial_basis: i == t1 + l */
 
    for(l=1; l <= id; l++) {
        Pcontrainte eq;
        Pvecteur v = VECTEUR_NUL;
        vect_add_elem(&v, variable_of_rank(initial_basis, l), VALUE_ONE);
        vect_add_elem(&v, variable_of_rank(tile_basis_in_initial_basis, l),
                      VALUE_MONE);
        vect_add_elem(&v, variable_of_rank(local_basis, l), VALUE_MONE);
        eq = contrainte_make(v);
        sc_add_egalite(tile_domain, eq);
    }
 
 
    /* add the tile membership inequalities */
    tile_domain = sc_append(tile_domain, 
                            tile_membership((matrice) tiling_tile(tile),
                                            tile_basis_in_initial_basis,
                                            initial_basis));
 
    /* update the basis for system tile_domain */
    base_rm(sc_base(tile_domain));
    sc_base(tile_domain) = BASE_NULLE;
    sc_creer_base(tile_domain);
 
    ifdebug(8) {
        (void) fprintf(stderr, "Full system before projections:\n");
        sc_fprint(stderr, tile_domain,(string(*)(Variable)) entity_local_name);
    }
 
    /* get rid of tile_basis_in_initial_basis; we might as well (?) keep
       them and get rid of tile_basis_in_tile_basis */
    for(l=1; l <= td; l++) {
        entity ind = (entity) variable_of_rank(tile_basis_in_initial_basis, l);
        tile_domain = sc_projection_pure(tile_domain, (Variable) ind);
    }
 
    ifdebug(8) {
        (void) fprintf(stderr, 
                       "Constraints on local tile indices parametrized by tile origin and initial indices:\n");
        sc_fprint(stderr, tile_domain,(string(*)(Variable)) entity_local_name);
    }
 
    /* get rid of initial indices */
    for(l=1; l <= id; l++) {
        entity ind = (entity) variable_of_rank(initial_basis, l);
        tile_domain = sc_projection_pure(tile_domain, (Variable) ind);
    }
 
    ifdebug(8) {
        (void) fprintf(stderr, 
                       "Constraints on local tile indices parametrized by tile origin:\n");
        sc_fprint(stderr, tile_domain, (string(*)(Variable))entity_local_name);
    }
 
    /* TEMPTATIVE */
 
    /* compute general information on loop bound origins
       this is done to take into account information carried by the
       outer loops, scanning the tile set */
    origin_domain = sc_dup(tile_domain);
 
    /* get rid of local indices */
    for(l=1; l <= id; l++) {
        entity ind = (entity) variable_of_rank(local_basis, l);
        origin_domain = sc_projection_pure(origin_domain, (Variable) ind);
    }
 
    ifdebug(8) {
        (void) fprintf(stderr, 
                       "Absolute constraints on tile origins:\n");
        sc_fprint(stderr, origin_domain,(string(*)(Variable)) entity_local_name);
    }
 
    /* inject this redundant information */
    tile_domain = sc_append(origin_domain, tile_domain);
 
    ifdebug(8) {
        (void) fprintf(stderr, 
                       "Constraints on local tile indices parametrized by tile origin, with redundant information:\n");
        sc_fprint(stderr, tile_domain,(string(*)(Variable)) entity_local_name);
    }
 
    pv =tile_basis_in_tile_basis;
    for (i=1; i<= last_parallel_level &&  !VECTEUR_NUL_P(pv); i++, pv = pv->succ);
    
    for ( ;  !VECTEUR_NUL_P(pv); pv = pv->succ) {
        sc_force_variable_to_zero(tile_domain,vecteur_var(pv));
    }
 
 
    /* END OF TEMPTATIVE SECTION */
 
    /* apply a row echelon transformation */
    ordered_tile_domain = new_loop_bound(tile_domain, local_basis);
    sc_transform_eg_in_ineg(ordered_tile_domain);
    
    ifdebug(8) {
        (void) fprintf(stderr, "Ordered constraints on local indices:\n");
        sc_fprint(stderr, ordered_tile_domain,(string(*)(Variable)) entity_local_name);
    }
 
    /* transform these constraints into a loop nest with the right body,
       starting with the innermost loop */
  
    s = body;
 
    /* test pour optimiser le nid de boucles genere */
    for (t =id; t >= 1; t--) {
        Value min,max; 
        Variable var = variable_of_rank(local_basis, t);
        
        Psysteme sctmp = sc_dup(ordered_tile_domain);
        sc_minmax_of_variable(sctmp,var,&min,&max); 
    }
 
 
    for(t = id; t >= 1; t--) {
        expression lower;
        expression upper;
        range r;
        loop new_l;
        entity ind;
        entity new_label;
        statement cs;
 
        ind = (entity) variable_of_rank(local_basis, t);
        make_bound_expression((Variable) ind,
                              local_basis,
                              ordered_tile_domain,
                              &lower, &upper);
        r = make_range(lower, upper, int_to_expression(1));
        /* I need new labels and new continues for my loops!
           make_loop_label() needs (at least) a module name */
        new_label = make_loop_label(9000, module);
        cs = make_continue_statement(new_label);
        if(instruction_block_p(statement_instruction(s)))
            (void) gen_nconc(instruction_block(statement_instruction(s)),
                             CONS(STATEMENT, cs, NIL));
        else 
            s = make_block_statement(CONS(STATEMENT, s,
                                          CONS(STATEMENT, cs, NIL)));
        
        new_l = make_loop(ind, r, s, 
                          new_label,
                          make_execution(is_execution_sequential,UU), NIL);
        s = loop_to_statement( new_l);
    }
    statement_comments(s) = 
        strdup("C           To scan each iteration of the current tile\n");
    ifdebug(8) {
        (void) fprintf(stderr, "Loop nest over tiles:\n");
        wp65_debug_print_text(module, s);
    }
 
    debug(8,"make_scanning_over_one_tile", "end\n");
 
    return s;
}

References base_dimension, BASE_NULLE, base_rm, CONS, contrainte_make(), debug(), entity_local_name(), eq, fprintf(), gen_nconc(), ifdebug, instruction_block, instruction_block_p, int_to_expression(), is_execution_sequential, loop_to_statement, make_block_statement(), make_bound_expression(), make_continue_statement(), make_execution(), make_loop(), make_loop_label(), make_range(), max, min, module, module_local_name(), new_loop_bound(), NIL, pips_assert, sc_add_egalite(), sc_append(), sc_creer_base(), sc_dup(), sc_force_variable_to_zero(), sc_fprint(), sc_minmax_of_variable(), sc_transform_eg_in_ineg(), STATEMENT, statement_comments, statement_instruction, statement_undefined, strdup(), Svecteur::succ, tile_change_of_basis(), tile_membership(), tiling_tile, UU, VALUE_MONE, VALUE_ONE, variable_of_rank(), vect_add_elem(), VECTEUR_NUL, VECTEUR_NUL_P, vecteur_var, and wp65_debug_print_text().

Referenced by loop_nest_to_wp65_code(), and make_compute_block().

Here is the call graph for this function:

Here is the caller graph for this function:

make_scanning_over_tiles()

statement make_scanning_over_tiles	(	entity	module,
		list	body,
		entity	proc_id,
		int	pn,
		tiling	tile,
		Pbase	initial_basis,
		Pbase	tile_basis_in_tile_basis,
		Pbase	tile_basis_in_initial_basis,
		Psysteme	iteration_domain,
		int	first_parallel_level,
		int	last_parallel_level
	)

make_scanning_over_tiles()

generates a nest of loops to enumerate all tiles containing at least one iteration in iteration_domain, and even sometimes zero because a rational projection is used; empty tiles are taken care of at a lower level to make sure that no iterations are performed.

The following system is built:

-> -> B i <= b

-> --> -> t1 = P t0 + o

-> -1 -> --> -—> 0 <= k P ( i - t1 ) <= (k-1)

where (B,b) defines the iteration domain, t1 is the tile origin in the initial basis, t0 is the tile origin in the tile basis, P is the partitioning matrix, o is the partitioning origin, i is an iteration, and k is the denominator of the inverse of P.

i and t1 are eliminated to obtain constraints on t0 only. These constraints are used to derive the loop bounds.

This piece of code could also be used to generate tiled code for a shared memory machine without any change.

Notes:

• the outermost loop is assumed parallel;
• the outermost loop is statically distributed over the processors if proc_id is defined as a formal parameter (compute code)
• proc_id has to be derived from the outermost loop index for the memory code, when it is a local variable

Algorithm described in PPoPP'91

only fully-dimensional partitioning for the time being

add change of basis equations to iteration domain: tile_basis_in_tile_basis to tile_basis_in_initial_basis; they would be of no use for a shared memory machine

add the tile membership inequalities

update the basis for system tile_domain

get rid of initial indices; they would be preserved to generate shared memory code

get rid of tile_basis_in_initial_basis; we might as well (?) keep them and get rid of tile_basis_in_tile_basis

apply a row echelon transformation

transform these constraints into a loop nest with the right body, starting with the innermost loop

optimization : Loop indices that are constant and don't appear in the program body are not generated

distribute work statically on processors using the outermost loop (assumed parallel!) if proc_id is properly defined; this should not be the case for bank tiles

I may need a definition for PROC_ID = MOD(I_0, PROCESSOR_NUMBER)

I need new labels and new continues for my loops! make_loop_label() needs (at least) a module name

Now, s is certainly a block; prefix it with proc_id def

Parameters

module	odule
body	ody
proc_id	roc_id
pn	n
tile	ile
initial_basis	nitial_basis
tile_basis_in_tile_basis	ile_basis_in_tile_basis
tile_basis_in_initial_basis	ile_basis_in_initial_basis
iteration_domain	teration_domain
first_parallel_level	irst_parallel_level
last_parallel_level	ast_parallel_level

Definition at line 227 of file code.c.

{
  pips_assert("true", last_parallel_level==last_parallel_level);
    statement s = statement_undefined;
    entity ind;
    Psysteme tile_domain = sc_dup(iteration_domain);
    Psysteme ordered_tile_domain = SC_UNDEFINED;
    Psysteme sctmp;
    int id = base_dimension(initial_basis);
    int td = base_dimension(tile_basis_in_tile_basis);
    int l,t;
    int keep_indice[11]; 
    Value min,max;
    int first_indice;  
    debug(8,"make_scanning_over_tiles", "begin for module %s\n",
          module_local_name(module));
 
    /* only fully-dimensional partitioning for the time being */
    pips_assert("make_scanning_over_tiles",id==td); 
 
    /* add change of basis equations to iteration domain:
       tile_basis_in_tile_basis to tile_basis_in_initial_basis;
       they would be of no use for a shared memory machine */
 
   tile_change_of_basis(tile_domain,initial_basis,
                        tile_basis_in_tile_basis,
                        tile_basis_in_initial_basis,tile);
 
    /* add the tile membership inequalities */
    tile_domain = sc_append(tile_domain, 
                            tile_membership((matrice) tiling_tile(tile),
                                            tile_basis_in_initial_basis,
                                            initial_basis));
 
    /* update the basis for system tile_domain */
    base_rm(sc_base(tile_domain));
    sc_base(tile_domain) = BASE_NULLE;
    sc_creer_base(tile_domain);
 
    tile_domain=sc_normalize(tile_domain);
 
    ifdebug(8) {
        (void) fprintf(stderr, "Tile basis -> initial basis:\n");
        sc_fprint(stderr, tile_domain,(string(*)(Variable)) entity_local_name);
    }
 
    /* get rid of initial indices; they would be preserved to generate
       shared memory code */
    for(l=1; l <= id; l++) {
        entity ind = (entity) variable_of_rank(initial_basis, l);
        tile_domain = sc_projection_pure(tile_domain, (Variable) ind);
    }
 
    /* get rid of tile_basis_in_initial_basis; we might as well (?) keep
       them and get rid of tile_basis_in_tile_basis */
    for(l=1; l <= td; l++) {
        entity ind = (entity) variable_of_rank(tile_basis_in_initial_basis, l);
        tile_domain = sc_projection_pure(tile_domain, (Variable) ind);
    }
 
    ifdebug(8) {
        (void) fprintf(stderr, "Constraints on tile indices:\n");
        sc_fprint(stderr, tile_domain, (string(*)(Variable))entity_local_name);
    }
 
    /* apply a row echelon transformation */
    ordered_tile_domain = 
        new_loop_bound(tile_domain, tile_basis_in_tile_basis);
    sc_transform_eg_in_ineg(ordered_tile_domain);
 
    ifdebug(8) {
        (void) fprintf(stderr, "Ordered constraints on tile indices:\n");
        sc_fprint(stderr, ordered_tile_domain, (string(*)(Variable))entity_local_name);
    }
 
 
 
    /* transform these constraints into a loop nest with the right body,
       starting with the innermost loop */
    s = make_block_statement(body);
    
    pips_debug(9, "body statement:");
    ifdebug(9) wp65_debug_print_text(module, s);
 
    for(t = td; t >= 1; t--) { 
        keep_indice[t]=true;
        sctmp = sc_dup(ordered_tile_domain);
        sc_minmax_of_variable(sctmp,
                              variable_of_rank(tile_basis_in_tile_basis, t),
                              &min,
                              &max); 
        ind = (entity) variable_of_rank(tile_basis_in_tile_basis, t);
        if ( value_eq(min,max) && !reference_in_statement_p(s,ind)) { 
            fprintf(stderr,"indice de tuile inutile %d, %s\n",t,
                    entity_local_name(ind));
            keep_indice[t] = false;
        }
    }
   
    for (t=1;t<=td && keep_indice[t]== false;t++);
    first_indice = (t==td+1) ? td:t;
    ifdebug(7) 
        fprintf(stderr,"first tile index %d, %s\n",first_indice,
                entity_local_name
                ((entity) variable_of_rank(tile_basis_in_tile_basis, t)));
 
    for(t = td; t >= 1; t--)
    {
        expression lower;
        expression upper;
        range r;
        loop new_l;
        entity new_label;
        statement cs = statement_undefined;
        statement ps = statement_undefined;
 
        ind = (entity) variable_of_rank(tile_basis_in_tile_basis, t);
 
        /* optimization : Loop indices that are constant and 
           don't appear in the program body are not generated */
 
        if (keep_indice[t]){ 
 
            make_bound_expression((Variable) ind,
                                  tile_basis_in_tile_basis,
                                  ordered_tile_domain,
                                  &lower, &upper);
 
            /* distribute work statically on processors using the outermost
               loop (assumed parallel!) if proc_id is properly defined;
               this should not be the case for bank tiles */
            if(t !=first_parallel_level || 
               !storage_formal_p(entity_storage(proc_id))) 
                r = make_range(lower, upper, int_to_expression(1));
            else {
                normalized n = NORMALIZE_EXPRESSION(lower);
                if(normalized_linear_p(n) 
                   && VECTEUR_NUL_P((Pvecteur) normalized_linear(n)))
                    lower = entity_to_expression(proc_id);
                else
                    lower = MakeBinaryCall
                        (local_name_to_top_level_entity(PLUS_OPERATOR_NAME), 
                         lower,
                         entity_to_expression(proc_id));
                r = make_range(lower, upper, int_to_expression(pn));
            }
 
            /* I may need a definition for PROC_ID = MOD(I_0, PROCESSOR_NUMBER) */
            if(t==first_parallel_level && 
               !storage_formal_p(entity_storage(proc_id))) {
                ps = make_assign_statement
                    (entity_to_expression(proc_id),
                     MakeBinaryCall
                     (local_name_to_top_level_entity(MOD_INTRINSIC_NAME),
                      entity_to_expression(ind),
                      int_to_expression(pn)));
            }
            else ps = statement_undefined;
         
            /* I need new labels and new continues for my loops!
               make_loop_label() needs (at least) a module name */
            new_label = make_loop_label(9000, module);
            cs = make_continue_statement(new_label);
 
            if(instruction_block_p(statement_instruction(s))) 
                (void) gen_nconc(instruction_block(statement_instruction(s)),
                                 CONS(STATEMENT, cs, NIL));
            else 
                s = make_block_statement(CONS(STATEMENT, s,
                                         CONS(STATEMENT, cs,
                                              NIL)));
            
            /* Now, s is certainly a block; prefix it with proc_id def */
            if(ps != statement_undefined)
                instruction_block(statement_instruction(s)) = 
                    CONS(STATEMENT, ps,
                         instruction_block(statement_instruction(s)));
 
            new_l = make_loop(ind, r, s, 
                              new_label,
                              make_execution(is_execution_sequential,UU), 
                              NIL);
            s = loop_to_statement(new_l);
        }
    }
 
    statement_comments(s) = 
        strdup(concatenate("\nC     To scan the tile set for ",
                           module_local_name(module), "\n", NULL));
    
    ifdebug(8) {
        (void) fprintf(stderr, "Loop nest over tiles:\n");
        wp65_debug_print_text(module, s);
    }
 
    pips_debug(8,"end\n");
 
    return s;
}

References base_dimension, BASE_NULLE, base_rm, concatenate(), CONS, debug(), entity_local_name(), entity_storage, entity_to_expression(), fprintf(), gen_nconc(), ifdebug, instruction_block, instruction_block_p, int_to_expression(), is_execution_sequential, local_name_to_top_level_entity(), loop_to_statement, make_assign_statement(), make_block_statement(), make_bound_expression(), make_continue_statement(), make_execution(), make_loop(), make_loop_label(), make_range(), MakeBinaryCall(), max, min, MOD_INTRINSIC_NAME, module, module_local_name(), new_loop_bound(), NIL, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_assert, pips_debug, PLUS_OPERATOR_NAME, reference_in_statement_p(), sc_append(), sc_creer_base(), sc_dup(), sc_fprint(), sc_minmax_of_variable(), sc_normalize(), sc_transform_eg_in_ineg(), STATEMENT, statement_comments, statement_instruction, statement_undefined, storage_formal_p, strdup(), tile_change_of_basis(), tile_membership(), tiling_tile, UU, value_eq, variable_of_rank(), VECTEUR_NUL_P, and wp65_debug_print_text().

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

make_store_blocks()

void make_store_blocks	(	entity	initial_module,
		entity	compute_module,
		entity	memory_module,
		entity	var,
		entity	shared_variable,
		entity	local_variable,
		list	lrefs,
		hash_table	r_to_ud,
		Psysteme	sc_domain,
		Pbase	index_base,
		Pbase	bank_indices,
		Pbase	tile_indices,
		Pbase	loop_body_indices,
		entity	Proc_id,
		int	pn,
		int	bn,
		int	ls,
		statement *	store_block,
		statement *	bank_store_block,
		int	first_parallel_level,
		int	last_parallel_level
	)

is true if it is the generation of code for bank false if it is for engine

is true if the generated code must be a RECEIVE, false if it must be a SEND

Cases where the references are scalar variables

In the other cases the references must be classified in lists of uniform dependent references

For each list of uniform dependent references, "store_block" and "bank_store_block" are computed

Parameters

initial_module	nitial_module
compute_module	ompute_module
memory_module	emory_module
var	ar
shared_variable	hared_variable
local_variable	ocal_variable
lrefs	refs
r_to_ud	_to_ud
sc_domain	c_domain
index_base	ndex_base
bank_indices	ank_indices
tile_indices	ile_indices
loop_body_indices	oop_body_indices
Proc_id	roc_id
pn	n
bn	n
ls	s
store_block	tore_block
bank_store_block	ank_store_block
first_parallel_level	irst_parallel_level
last_parallel_level	ast_parallel_level

Definition at line 1166 of file code.c.

{
  pips_assert("true", last_parallel_level==last_parallel_level
              && first_parallel_level==first_parallel_level);
    list ldr;
    list lldr = NIL;
    list lrs;
    Psysteme sc_image,sc_array_function;
    int n,dim_h;
    Pbase const_base;
    Pbase new_index_base= BASE_NULLE;
    Pbase new_tile_indices = BASE_NULLE;
    reference r;
    bool bank_code;                     /* is true if it is the generation 
                                           of code for bank false if it is 
                                           for engine */
    bool receive_code;          /* is true if the generated code 
                                           must be a RECEIVE, false if it 
                                           must be a SEND*/
    statement stat1,stat2,sb,bsb;
    cons * bst_sb = NIL;
    cons * bst_bsb = NIL;
    Pbase var_id;
    Pvecteur ppid = vect_new((char *) Proc_id, VALUE_ONE);
    Psysteme sc_image2= SC_UNDEFINED;
    debug(8,"make_store_blocks",
          "begin variable=%s, shared_variable=%s, local_variable=%s\n",
          entity_local_name(var), entity_local_name(shared_variable),
          entity_local_name(local_variable));
 
    ifdebug(8) {
        list crefs;
        (void) fprintf(stderr, "Associated reference list:");
        for(crefs=lrefs; !ENDP(crefs); POP(crefs)) {
            reference r1 = REFERENCE(CAR(crefs));
            print_reference(r1);
            if(ENDP(CDR(crefs)))
                (void) putc('\n', stderr);
            else
                (void) putc(',', stderr);
        }
    }
 
 
    /* Cases where the references are scalar variables */
 
    for (lrs =lrefs ; !ENDP(lrs) ; POP(lrs)) {
        r = REFERENCE(CAR(lrs));
        if (reference_indices(r) ==NIL) {
            receive_code = false;
            *store_block=make_movement_scalar_wp65(compute_module,
                                                   receive_code,
                                                   r,Proc_id);
            receive_code = true;
            *bank_store_block=
                make_movement_scalar_wp65(memory_module,receive_code,
                                          r,(entity) bank_indices->var);
            return;
        }
    }
 
    /* In the other cases the references must be classified in lists of 
       uniform dependent references */
 
    for ( lrs = lrefs; lrs != NIL ; lrs = CDR(lrs) ) {
        r = REFERENCE(CAR(lrefs));
        if (  (intptr_t)hash_get(r_to_ud, r) == (intptr_t)is_action_write) 
            lldr = classify_reference(lldr,r);
    }
 
    /* For each list of uniform dependent references, "store_block" and 
       "bank_store_block" are computed */
 
    for (ldr = lldr;ldr != NIL;ldr = CDR(ldr)) {
        
        sc_array_function=
            build_sc_with_several_uniform_ref(initial_module,
                                              LIST(CAR(ldr)),
                                              sc_domain,&new_index_base);
        new_index_base = vect_add(new_index_base,
                                  vect_dup(index_base));
 
        sc_image =  sc_image_computation(initial_module,
                                         var,sc_domain,
                                         sc_array_function,new_index_base,
                                         &const_base,Proc_id,bank_indices,
                                         tile_indices,&new_tile_indices,
                                         pn,bn,ls,
                                         &n,&dim_h);
        nullify_offsets();
        sc_image2 = sc_dup(sc_image);
        bank_code = true ;
        receive_code = true;
        var_id = (Pbase) vect_new(vecteur_var(ppid),
                                  vecteur_val(ppid));
        stat1 = movement_computation(memory_module,false,bank_code,
                                     receive_code,
                                     shared_variable,sc_image,
                                     const_base,bank_indices,
                                     new_tile_indices,
                                     var_id,loop_body_indices,n,dim_h);
        initialize_offsets(ldr);
        bank_code = false ;
        receive_code = false;
        var_id = (Pbase) vect_new(vecteur_var(bank_indices),
                                  vecteur_val(bank_indices));
        stat2 = movement_computation(compute_module,false,bank_code,
                                     receive_code,
                                     local_variable,sc_image2,
                                     const_base,bank_indices,
                                     new_tile_indices,
                                     var_id,loop_body_indices,n,dim_h);
 
        bst_sb = CONS(STATEMENT,stat2,bst_sb);
        bst_bsb =CONS(STATEMENT,stat1,bst_bsb);
    }
    sb = make_block_statement(bst_sb);
    bsb=make_block_statement(bst_bsb);
    *store_block = sb;
    *bank_store_block = bsb;
 
    debug(8,"make_store_blocks", "end\n");
}

References BASE_NULLE, build_sc_with_several_uniform_ref(), CAR, CDR, classify_reference(), CONS, debug(), ENDP, entity_local_name(), false, fprintf(), hash_get(), ifdebug, initialize_offsets(), intptr_t, is_action_write, LIST, make_block_statement(), make_movement_scalar_wp65(), movement_computation(), NIL, nullify_offsets(), pips_assert, POP, print_reference(), REFERENCE, reference_indices, sc_dup(), sc_image_computation(), STATEMENT, true, VALUE_ONE, Svecteur::var, vect_add(), vect_dup(), vect_new(), vecteur_val, and vecteur_var.

Referenced by make_all_movement_blocks().

Here is the call graph for this function:

Here is the caller graph for this function:

make_store_map()

void make_store_map

(

void

)

make_tile_constraints()

Psysteme make_tile_constraints	(	matrice	P,
		Pbase	b
	)

Psysteme make_tile_constraints(P, b):

convert a partitioning matrice into a system of linear constraints for a tile whose origin is 0, i.e. generate constraints over local indices:

-> -1 -> -—> 0 <= k P b <= (k-1)

where k is the denominator of P inverse.

FI: such functions should be put together in a file, linear.c

pips_assert("make_tile_constraints", k > 1);

Definition at line 591 of file variable.c.

{
    Psysteme tc = sc_new();
 
    int d = base_dimension(b);
    Value k = DENOMINATOR(P);
    int i,j;
 
    matrice IP = matrice_new(d,d);
    Pcontrainte c1;
 
    debug(8,"make_tile_constraints", "begin\n");
 
    pips_assert("make_tile_constraints", value_one_p(k));
 
    ifdebug(8) {
        (void) fprintf(stderr,"Partitioning matrix P:\n");
        matrice_fprint(stderr, P, d, d);
    }
 
    matrice_general_inversion(P, IP, d);
    matrice_normalize(IP, d, d);
    k = DENOMINATOR(IP);
 
  /*  pips_assert("make_tile_constraints", k > 1); */
 
    ifdebug(8) {
        (void) fprintf(stderr,"Inverse of partitioning matrix, IP:\n");
        matrice_fprint(stderr, IP, d, d);
    }
 
    for ( i=1; i<=d; i++) {
        Pcontrainte c = contrainte_new();
 
        for ( j=1; j<=d; j++) {
            vect_add_elem(&contrainte_vecteur(c), 
                          variable_of_rank(b,i),
                          value_uminus(ACCESS(IP, d, j, i)));
 
        }
        sc_add_inegalite(tc, c);
        c1 = contrainte_dup(c);
        contrainte_chg_sgn(c1);
        vect_add_elem(&contrainte_vecteur(c1), TCST, value_minus(VALUE_ONE,k));
        sc_add_inegalite(tc, c1);
    }
 
    sc_creer_base(tc);
    matrice_free(IP);
 
    ifdebug(8) {
        sc_fprint(stderr, tc, (string(*)(Variable))entity_local_name);
    }
 
    debug(8,"make_tile_constraints", "end\n");
 
    return (tc);
}

References ACCESS, base_dimension, contrainte_chg_sgn(), contrainte_dup(), contrainte_new(), contrainte_vecteur, debug(), DENOMINATOR, entity_local_name(), fprintf(), ifdebug, matrice_fprint(), matrice_free, matrice_general_inversion(), matrice_new, matrice_normalize(), pips_assert, sc_add_inegalite(), sc_creer_base(), sc_fprint(), sc_new(), tc, TCST, value_minus, VALUE_ONE, value_one_p, value_uminus, variable_of_rank(), and vect_add_elem().

Referenced by set_dimensions_of_local_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeEntityFunction()

entity MakeEntityFunction

(

string

sname

)

Parameters

sname

name

Definition at line 101 of file wp65.c.

{
    entity f = make_empty_function(sname, MakeIntegerResult(), make_language_unknown());
    return f;
}

References f(), make_empty_function(), make_language_unknown(), and MakeIntegerResult().

Referenced by module_to_wp65_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

model_fprint()

void model_fprint	(	FILE *	fd,
		int	pn,
		int	bn,
		int	ls
	)

model.c

model.c

Reads and prints the target machine description (compatible formats) Temporary version. A more general machine model should be defined by Lei for complexity evaluation.

File: model.c

PUMA, ESPRIT contract 2701

Francois Irigoin 1991 ???

Parameters

fd	d
pn	n
bn	n
ls	s

Definition at line 50 of file model.c.

{
    fprintf(fd, 
            "Target Machine:\n"
            "Processor number: %d\n"
            "Memory bank number: %d\n"
            "Bank width (i.e. line size): %d\n\n", pn, bn, ls);
}

References fprintf().

Referenced by wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

model_fscan()

void model_fscan	(	FILE *	fd,
		int *	ppn,
		int *	pbn,
		int *	pls
	)

Parameters

fd	d
ppn	pn
pbn	bn
pls	ls

Definition at line 59 of file model.c.

{
    int i1, i2, i3, i4;
    i1 = fscanf(fd, "Target Machine:\n");
    i2 = fscanf(fd, "Processor number: %d\n", ppn);
    i3 = fscanf(fd, "Memory bank number: %d\n", pbn);
    i4 = fscanf(fd, "Bank width (i.e. line size): %d\n\n", pls);
    if(i1!=0 && i2!=1 && i3!=1 && i4!=1) {
        user_error("model_fscan", "Bad format for machine model\n");
    }
}

References user_error.

Referenced by get_model().

Here is the caller graph for this function:

module_to_wp65_modules()

void module_to_wp65_modules	(	entity	module,
		statement	module_code,
		graph	dg,
		int	pn,
		int	bn,
		int	ls,
		int	pd,
		entity *	pcompute_module,
		statement *	pcomputational,
		entity *	pmemory_module,
		statement *	pemulator
	)

variable to emulated shared variable

To establish an occurence numbering accross loop nests

Generate two new modules, compute module and memory module

Generate scalar variables that are going to be used all over the compute and memory module

variables related to bank emulation are put together in one basis to decrease the number of parameters; they are used as such when liner systems of constraints are built

skip a potential useless unstructured

generate code for each loop nest in the module and append it to computational and emulator

kill_statement_number_and_ordering(computational); kill_statement_number_and_ordering(emulator);

return results

Parameters

module	odule
module_code	odule_code
dg	g
pn	n
bn	n
ls	s
pd	d
pcompute_module	compute_module
pcomputational	computational
pmemory_module	memory_module
pemulator	emulator

Definition at line 202 of file wp65.c.

{
    string compute_module_name;
    string memory_module_name;
    instruction i = instruction_undefined;
    list l = list_undefined;
    entity proc_id = entity_undefined;
    entity proc_id_mm = entity_undefined;
    entity bank_id = entity_undefined;
    entity bank_line = entity_undefined;
    entity bank_offset = entity_undefined;
    Pbase bank_indices = BASE_NULLE;
    statement fs = statement_undefined;
 
    /* variable to emulated shared variable */
    hash_table v_to_esv = hash_table_make(hash_pointer,0);
    /* To establish an occurence numbering accross loop nests */
    hash_table v_to_nlv = hash_table_make(hash_pointer, 0);
 
    entity compute_module;
    statement computational;
    entity memory_module;
    statement emulator;
    statement_mapping fetch_map= MAKE_STATEMENT_MAPPING();
    statement_mapping store_map= MAKE_STATEMENT_MAPPING();
    entity div;
 
    debug(6,"module_to_wp65_modules","begin\n");
 
    /*       Generate two new modules, compute module and memory module
     */
    compute_module_name = strdup(COMPUTE_ENGINE_NAME);
    compute_module = make_empty_subroutine(compute_module_name,copy_language(module_language(module)));
 
    module_functional_parameters(compute_module)
        = CONS(PARAMETER, make_parameter(MakeTypeVariable(make_basic_int(4), NIL),
                                         make_mode(is_mode_reference, UU),
                                         make_dummy_unknown()),
               NIL);
 
    memory_module_name = strdup(BANK_NAME);
    memory_module = make_empty_subroutine(memory_module_name,copy_language(module_language(module)));
 
    module_functional_parameters(memory_module)
        = CONS(PARAMETER, 
               make_parameter(MakeTypeVariable(make_basic_int(
                                                          4), NIL),
                              make_mode(is_mode_reference, UU),
                              make_dummy_unknown()),
               NIL);
    computational = make_block_statement(NIL);
    emulator = make_block_statement(NIL);
 
    div =MakeEntityFunction("idiv");
    AddEntityToDeclarations(div,compute_module);
    AddEntityToDeclarations(div,memory_module);
 
  
    /* Generate scalar variables that are going to be used all over
       the compute and memory module
       */
    proc_id_mm = make_scalar_integer_entity(PROCESSOR_IDENTIFIER,
                                            entity_local_name(memory_module));
    AddEntityToDeclarations( proc_id_mm,memory_module);
 
    proc_id = make_scalar_integer_entity(PROCESSOR_IDENTIFIER,
                                         entity_local_name(compute_module));
    entity_storage(proc_id) = make_storage(is_storage_formal, 
                                           make_formal(compute_module, 1));
    AddEntityToDeclarations( proc_id,compute_module);
 
    bank_id = make_scalar_integer_entity(BANK_IDENTIFIER,
                                         entity_local_name(compute_module));
    AddEntityToDeclarations( bank_id,compute_module);
 
    bank_id = make_scalar_integer_entity(BANK_IDENTIFIER,
                                         entity_local_name(memory_module));
    entity_storage(bank_id) = make_storage(is_storage_formal, 
                                           make_formal(memory_module, 1)); 
    AddEntityToDeclarations( bank_id,memory_module);
 
    bank_line = make_scalar_integer_entity(BANK_LINE_IDENTIFIER,
                                           entity_local_name(compute_module)); 
    AddEntityToDeclarations( bank_line,compute_module); 
 
    bank_line = make_scalar_integer_entity(BANK_LINE_IDENTIFIER,
                                           entity_local_name(memory_module));
    AddEntityToDeclarations( bank_line,memory_module);
 
    bank_offset = make_scalar_integer_entity(BANK_OFFSET_IDENTIFIER,
                                             entity_local_name(memory_module));
    AddEntityToDeclarations( bank_offset,memory_module);
    bank_offset = make_scalar_integer_entity(BANK_OFFSET_IDENTIFIER,
                                             entity_local_name(compute_module));
    AddEntityToDeclarations( bank_offset,compute_module);
    /* variables related to bank emulation are put together in one basis
       to decrease the number of parameters; they are used as such when
       liner systems of constraints are built */
    bank_indices = 
        vect_add_variable(vect_add_variable(vect_add_variable(BASE_NULLE,
                                                              (char*) 
                                                              bank_offset),
                                            (char *) bank_line),
                          (char *) bank_id);
 
    ifdebug(6) {
        (void) fprintf(stderr,"Bank indices:\n");
        vect_fprint(stderr, bank_indices, (string(*)(void*))entity_local_name);
        (void) fprintf(stderr,"Code for the computational module:\n");
        wp65_debug_print_module(compute_module,computational);
        (void) fprintf(stderr,"Code for the memory module:\n");
        wp65_debug_print_module(memory_module,emulator);
    }
 
 
    /* skip a potential useless unstructured */
    i = statement_instruction(module_code);
    if (instruction_unstructured_p(i)) {
        unstructured u = instruction_unstructured(i);
        control c = unstructured_control(u);
        i = statement_instruction(control_statement(c));
    }
 
    /* generate code for each loop nest in the module and append it
       to computational and emulator */
    l = instruction_block(i); 
 
    compute_communications(l,&fetch_map,&store_map);
  
    instruction_to_wp65_code(module,l, dg, 
                             pn, bn, ls, pd,
                             proc_id, proc_id_mm, bank_indices,
                             v_to_esv, v_to_nlv,
                             compute_module, computational,
                             memory_module, emulator, fetch_map,store_map);
 
    i = statement_instruction(computational);
    instruction_block(i) = gen_nconc(instruction_block(i), 
                                     CONS(STATEMENT, 
                                          make_return_statement(compute_module), 
                                          NIL));
    i = statement_instruction(emulator);
    instruction_block(i) = gen_nconc(instruction_block(i), 
                                     CONS(STATEMENT, 
                                          make_return_statement(memory_module),
                                          NIL));
 
  
    fs = STATEMENT(CAR(instruction_block(statement_instruction(computational))));
    statement_comments(fs) = 
        strdup(concatenate("\nC     WP65 DISTRIBUTED CODE FOR ",
                           module_local_name(module), "\n",
                           (string_undefined_p(statement_comments(fs)) 
                            ? NULL :statement_comments(fs)),
                           NULL));
    module_reorder(fs);
    fs = STATEMENT(CAR(instruction_block(statement_instruction(emulator))));
    statement_comments(fs) =
        strdup(concatenate("\nC     BANK DISTRIBUTED CODE FOR ",
                           module_local_name(module), "\n",
                           (string_undefined_p(statement_comments(fs)) 
                            ? NULL :statement_comments(fs)),
                           NULL));
    module_reorder(fs);
    /* kill_statement_number_and_ordering(computational);
    kill_statement_number_and_ordering(emulator);*/
    
 
    ifdebug(1) {
        (void) fprintf(stderr,"Final code for the computational module:\n");
        wp65_debug_print_module(compute_module,computational);
        (void) fprintf(stderr,"Final code for the memory module:\n");
        wp65_debug_print_module(memory_module,emulator);
    }
 
    hash_table_free(v_to_esv);
    hash_table_free(v_to_nlv);
   
    /* return results */
    * pcompute_module = compute_module;
    * pcomputational = computational;
    * pmemory_module = memory_module;
    * pemulator = emulator;
 
    debug(6,"module_to_wp65_modules","end\n");
 
}

References AddEntityToDeclarations(), BANK_IDENTIFIER, BANK_LINE_IDENTIFIER, BANK_NAME, BANK_OFFSET_IDENTIFIER, BASE_NULLE, CAR, compute_communications(), COMPUTE_ENGINE_NAME, concatenate(), CONS, control_statement, copy_language(), debug(), dg, entity_local_name(), entity_storage, entity_undefined, fprintf(), gen_nconc(), hash_pointer, hash_table_free(), hash_table_make(), ifdebug, instruction_block, instruction_to_wp65_code(), instruction_undefined, instruction_unstructured, instruction_unstructured_p, is_mode_reference, is_storage_formal, list_undefined, make_basic_int(), make_block_statement(), make_dummy_unknown(), make_empty_subroutine(), make_formal(), make_mode(), make_parameter(), make_return_statement(), make_scalar_integer_entity(), MAKE_STATEMENT_MAPPING, make_storage(), MakeEntityFunction(), MakeTypeVariable(), module, module_functional_parameters, module_language, module_local_name(), module_reorder(), NIL, PARAMETER, PROCESSOR_IDENTIFIER, STATEMENT, statement_comments, statement_instruction, statement_undefined, strdup(), string_undefined_p, unstructured_control, UU, vect_add_variable(), vect_fprint(), and wp65_debug_print_module().

Referenced by wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

ref_in_implied_do()

expression ref_in_implied_do

(

expression

exp

)

This function extracts from an implied_do expression the reference having to be computed or printed.

Parameters

exp

xp

Definition at line 328 of file instruction_to_wp65_code.c.

{
    call c2 = syntax_call(expression_syntax(exp));
    list  call_args = call_arguments(c2); 
    expression last_call = EXPRESSION(CAR(gen_last(call_args)));
    syntax s = expression_syntax(last_call);
    
    return((syntax_call_p(s)
            && (strcmp(entity_local_name(call_function(syntax_call(s))),
                       "IMPLIED-DO") == 0)) ? 
           ref_in_implied_do(last_call):
           last_call );
}

References call_arguments, call_function, CAR, entity_local_name(), exp, EXPRESSION, expression_syntax, gen_last(), syntax_call, and syntax_call_p.

Referenced by translate_IO_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

ref_in_list_p()

bool ref_in_list_p	(	list	lt,
		reference	r
	)

references.c

Parameters

lt

t

Definition at line 62 of file references.c.

{
  pips_assert("true", lt==lt && r==r);
    return (false);
}

References pips_assert.

Referenced by update_map().

Here is the caller graph for this function:

reference_conflicting_p()

bool reference_conflicting_p	(	reference	r1,
		reference	r2,
		graph	dg
	)

Parameters

r1	1
r2	2
dg	g

Definition at line 513 of file variable.c.

{
    /*
      graph = vertices:vertex* ;
      successor = arc_label x vertex ;
      vertex = vertex_label x successors:successor* ;
      */
    list ver1 = graph_vertices(dg);
 
    debug(8,"reference_conflicting_p","begin\n");
    ifdebug(8) {
        (void) fprintf(stderr,"Reference 1 %p: ", r1);
        print_reference(r1);
        (void) fprintf(stderr,"\nReference 2 %p: ", r2);
        print_reference(r2);
        (void) fputc('\n',stderr);
    }
 
    MAPL(pm1,{
        vertex v1 = VERTEX(CAR(pm1));
        list ver2 = vertex_successors(v1);
        MAPL(pm2,{
            successor su = SUCCESSOR(CAR(pm2));
 
            dg_arc_label dal = (dg_arc_label) successor_arc_label(su);
            list conf_list = dg_arc_label_conflicts(dal);
 
            MAPL(pm3,{
                conflict conf2 = CONFLICT(CAR(pm3));
 
                effect e_source = conflict_source(conf2);
                effect e_sink = conflict_sink(conf2);
 
                reference r11 = effect_any_reference(e_source);
                reference r21 = effect_any_reference(e_sink);
 
                ifdebug(8) {
                    (void) fprintf(stderr,"Test with reference 1 %p: ", r1);
                    print_reference(r1);
                    (void) fprintf(stderr," and reference 2 %p: ", r2);
                    print_reference(r2);
                    (void) fputc('\n',stderr);
                    (void) fprintf(stderr,"Test with reference 11 %p: ", r11);
                    print_reference(r11);
                    (void) fprintf(stderr," and reference 21 %p: ", r21);
                    print_reference(r21);
                    (void) fputc('\n',stderr);
                    (void) fputc('\n',stderr);
                }
 
                if( (reference_equal_p(r11,r1) &&  reference_equal_p(r21,r2))
                   || (reference_equal_p(r11,r2) && reference_equal_p(r21,r1)) ) {
                    debug(8,"reference_conflicting_p","return TRUE\n");
                    return true;
                }
            },conf_list);
        },ver2);
    },ver1);
 
    debug(8,"reference_conflicting_p","return FALSE\n");
    return false;
}

References CAR, CONFLICT, conflict_sink, conflict_source, debug(), dg, dg_arc_label_conflicts, effect_any_reference, fprintf(), graph_vertices, ifdebug, MAPL, print_reference(), reference_equal_p(), SUCCESSOR, successor_arc_label, VERTEX, and vertex_successors.

Referenced by reference_conflicting_test_and_update().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_conflicting_test_and_update()

bool reference_conflicting_test_and_update	(	reference	r,
		graph	dg,
		hash_table	v_to_lllv,
		hash_table	llv_to_lcr,
		hash_table	r_to_llv,
		hash_table	r_to_ud
	)

reference_conflicting_test_and_update():

Build, incrementally, connected component in the dependence graph. Input dependences should be used to save local memory space. Mappings are updated.

Too many local variables might be created if two connected components had to be fused. This is not likely to happen with real code. In that case, the function would stop with pips_error().

referenced variable

short cut for identical references; not necessarily a good idea for the body translation process; design to save time in transfer code generation

should go one step forwards and take care of use-def, easier by introducing a "use and def" value or by adding the new reference directly

we need to remember there is a use and a def

this is very clumsy as we may keep a large number of identical def after one use and vice-versa; we need a use-and-def value or we have to keep all references and filter them for data movements

update llv_to_lcr by side-effect

should not happen too often: the regions associated with two references do not intersect together but each of them intersect a third one on which we bump afterwards; the two initial llv's should be merged...

update llv_to_lcr by side-effect

save current_llv for a future (?) merge

no need to study conflicts with other references in the same connected component

Parameters

dg	g
v_to_lllv	_to_lllv
llv_to_lcr	lv_to_lcr
r_to_llv	_to_llv
r_to_ud	_to_ud

Definition at line 401 of file variable.c.

{
    list current_llv = list_undefined;
    entity rv;                          /* referenced variable */
    list lllv;
    list cllv;
    bool conflicting = false;
 
    debug(8,"reference_conflicting_test_and_update", "begin\n");
 
    rv = reference_variable(r);
 
    ifdebug(8) {
        (void) fprintf(stderr, "reference %p to %s:", 
                       r, entity_local_name(rv));
        print_reference(r);
        (void) putc('\n', stderr);
    }
 
    if((lllv = (list) hash_get(v_to_lllv, (char *) rv)) 
       == (list) HASH_UNDEFINED_VALUE) {
        debug(8, "reference_conflicting_test_and_update", 
              "no local variables for reference %p to %s\n",
              r, entity_local_name(rv));
 
        debug(8,"reference_conflicting_test_and_update", "return FALSE\n");
        return false;
    }
 
    for(cllv = lllv; !ENDP(cllv); POP(cllv)) {
        list llv = LIST(CAR(cllv));
        list lcr = (list) hash_get(llv_to_lcr, (char *) llv);
        list ccr;
 
        for(ccr = lcr; !ENDP(ccr); POP(ccr)) {
            reference r2 = REFERENCE(CAR(ccr));
            entity rv2 = reference_variable(r2);
 
            ifdebug(8) {
                (void) fprintf(stderr, "conflict_p with reference %p to %s:",
                               r2, entity_local_name(rv2));
                print_reference(r2);
                (void) putc('\n', stderr);
            }
 
            if(reference_equal_p(r, r2)) {
                if(hash_get(r_to_ud,(char*) r)==hash_get(r_to_ud,(char*) r2)){
                /* short cut for identical references; not necessarily a good
                   idea for the body translation process; design to save
                   time in transfer code generation */
                /* should go one step forwards and take care of use-def,
                   easier by introducing a "use and def" value or by adding
                   the new reference directly */
 
                    debug(8,"reference_conflicting_test_and_update", 
                          "reference equality and same use, return TRUE\n");
                }
                else {
                    /* we need to remember there is a use and a def */
                    /* this is very clumsy as we may keep a large number
                       of identical def after one use and vice-versa;
                       we need a use-and-def value or we have to keep
                       all references and filter them for data movements */
                    /* update llv_to_lcr by side-effect */
                    lcr = gen_nconc(lcr, CONS(REFERENCE, r, NIL));
                    debug(8,"reference_conflicting_test_and_update", 
                          "reference equality and same use, return TRUE\n");
                }
                hash_put(r_to_llv, (char *) r, (char *) llv);
                return true;
            }
            else if(reference_conflicting_p(r, r2, dg)) {
                if(conflicting) {
                    /* should not happen too often: the regions associated 
                       with two references do not intersect together but
                       each of them intersect a third one on which we bump
                       afterwards; the two initial llv's should be merged...
                       */
                    pips_assert("reference_conflicting_test_and_update",
                                current_llv != llv);
                    pips_internal_error("local variable merge not implemented");
                }
                else {
                    conflicting = true;
                    /* update llv_to_lcr by side-effect */
                    lcr = gen_nconc(lcr, CONS(REFERENCE, r, NIL));
                    hash_put(r_to_llv, (char *) r, (char *) llv);
                    /* save current_llv for a future (?) merge */
                    current_llv = llv;
                    /* no need to study conflicts with other references
                       in the *same* connected component */
                debug(8,"reference_conflicting_test_and_update", 
                      "Conflict! Look for conflicts with other components\n");
                    break;
                }
            }
        }
    }
 
    debug(8,"reference_conflicting_test_and_update", "return %d\n",
          conflicting);
    return conflicting;
}

References CAR, CONS, debug(), dg, ENDP, entity_local_name(), fprintf(), gen_nconc(), hash_get(), hash_put(), HASH_UNDEFINED_VALUE, ifdebug, LIST, list_undefined, NIL, pips_assert, pips_internal_error, POP, print_reference(), REFERENCE, reference_conflicting_p(), reference_equal_p(), and reference_variable.

Referenced by loop_nest_to_local_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_conversion_computation()

list reference_conversion_computation	(	entity	compute_module,
		list *	lt,
		expression	expr,
		Pbase	initial_basis,
		Pbase	tile_indices,
		Pbase	tile_local_indices,
		tiling	tile
	)

the called function is assumed to be unchanged

Parameters

compute_module	ompute_module
lt	t
expr	xpr
initial_basis	nitial_basis
tile_indices	ile_indices
tile_local_indices	ile_local_indices
tile	ile

Definition at line 799 of file code.c.

{
    syntax s = expression_syntax(expr);
   
    switch(syntax_tag(s)) {
    case is_syntax_reference: {
        reference r = syntax_reference(s);
        entity rv = reference_variable(r);
        int i;
        
        if((i=rank_of_variable(initial_basis, (Variable) rv)) > 0) {
            
            entity ent1 = make_new_module_variable(compute_module,200);
            Pvecteur pv2 = vect_new((Variable) ent1, VALUE_ONE);
            Pvecteur pvt = VECTEUR_NUL;
            expression exp1,exp2;
            statement stat= statement_undefined;
            Pvecteur pv = make_loop_indice_equation(initial_basis,tile, pvt,
                                                    tile_indices,
                                                    tile_local_indices,i);
            AddEntityToDeclarations(ent1,compute_module);   
            reference_variable(r) = ent1 ;
            exp1= make_vecteur_expression(pv);
            exp2 = make_vecteur_expression(pv2);
            stat = make_assign_statement(exp2,exp1);
            *lt = gen_nconc(*lt,CONS(STATEMENT,stat,NIL));
        } 
        return (*lt);
        break;
    }
    case is_syntax_call:
        /* the called function is assumed to be unchanged */
        MAPL(ce, {
            *lt = reference_conversion_computation(compute_module,lt,
                                                   EXPRESSION(CAR(ce)),initial_basis,
                                             tile_indices, tile_local_indices,tile);
        }, 
             call_arguments(syntax_call(s)));
             return (*lt);
        break;
    default:
        pips_internal_error("Unexpected syntax tag %d", syntax_tag(s));
        break;
    }
    return(*lt);
}

References AddEntityToDeclarations(), call_arguments, CAR, CONS, EXPRESSION, expression_syntax, gen_nconc(), is_syntax_call, is_syntax_reference, make_assign_statement(), make_loop_indice_equation(), make_new_module_variable(), make_vecteur_expression(), MAPL, NIL, pips_internal_error, rank_of_variable(), reference_variable, STATEMENT, statement_undefined, syntax_call, syntax_reference, syntax_tag, VALUE_ONE, vect_new(), and VECTEUR_NUL.

Referenced by reference_conversion_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_conversion_expression()

void reference_conversion_expression	(	expression	e,
		hash_table	r_to_llv,
		Pvecteur	offsets,
		Pbase	initial_basis,
		Pbase	local_basis
	)

no pipeline, select the first entity by default

the called function is assumed to be unchanged

Parameters

r_to_llv	_to_llv
offsets	ffsets
initial_basis	nitial_basis
local_basis	ocal_basis

Definition at line 864 of file code.c.

{
    syntax s = expression_syntax(e);
    int i;
    debug(8,"reference_conversion_expression", "begin expression:");
    ifdebug(8) {
      print_words(stderr, Words_Expression(e));
        (void) fputc('\n', stderr);
    }
 
    switch(syntax_tag(s)) {
    case is_syntax_reference: {
        reference r = syntax_reference(s);
        entity rv = reference_variable(r);
        list llv;
 
        if((llv = (list) hash_get(r_to_llv, (char *) r))
           != (list) HASH_UNDEFINED_VALUE) {
            /* no pipeline, select the first entity by default */
            entity new_v = ENTITY(CAR(llv));
            reference_variable(r) = new_v;
        }
        else 
            if ((i=rank_of_variable(initial_basis, 
                                    (Variable) rv)) > 0)
        
                reference_variable(r)=
                    (entity) variable_of_rank(local_basis, i);
        
        MAPL(ce, {
            reference_conversion_expression(EXPRESSION(CAR(ce)), 
                                            r_to_llv, offsets,
                                            initial_basis, local_basis);
        }, 
             reference_indices(r));
        break;
    }
    case is_syntax_range:
        pips_internal_error("Ranges are not (yet) handled");
        break;
    case is_syntax_call:
        /* the called function is assumed to be unchanged */
        MAPL(ce, {
            reference_conversion_expression(EXPRESSION(CAR(ce)), 
                                            r_to_llv, offsets,
                                            initial_basis, local_basis);
        }, 
             call_arguments(syntax_call(s)));
        break;
    default:
        pips_internal_error("Unexpected syntax tag %d", syntax_tag(s));
        break;
    }
 
    debug(8,"reference_conversion_expression", "end expression:\n");
    ifdebug(8) {
      print_words(stderr, Words_Expression(e));
        (void) fputc('\n', stderr);
    }
}

References call_arguments, CAR, debug(), ENTITY, EXPRESSION, expression_syntax, hash_get(), HASH_UNDEFINED_VALUE, ifdebug, is_syntax_call, is_syntax_range, is_syntax_reference, MAPL, pips_internal_error, print_words(), rank_of_variable(), reference_indices, reference_variable, syntax_call, syntax_reference, syntax_tag, variable_of_rank(), and Words_Expression().

Referenced by reference_conversion_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_conversion_statement()

list reference_conversion_statement	(	entity	module,
		statement	body,
		list *	lt,
		hash_table	r_to_llv,
		Pvecteur	offsets,
		Pbase	initial_basis,
		Pbase	tile_indices,
		Pbase	local_basis,
		tiling	tile
	)

void reference_conversion_statement(body, r_to_llv, offsets, initial_basis, local_basis):

All references in body which appear in r_to_llv are replaced by references to one of the local variables associated via the r_to_llv hash_table; the choice of one specific local variable is a function of offsets, which is used to generate pipelined code (not implemented).

Statement numbers are set to STATEMENT_NUMBER_UNDEFINED.

the function is assumed to be unchanged

Parameters

module	odule
body	ody
lt	t
r_to_llv	_to_llv
offsets	ffsets
initial_basis	nitial_basis
tile_indices	ile_indices
local_basis	ocal_basis
tile	ile

Definition at line 723 of file code.c.

{
    instruction i = statement_instruction(body);
 
    pips_debug(8, "begin statement: \n");
    ifdebug(8) {
        wp65_debug_print_text(entity_undefined, body);
    }
 
    statement_number(body) = STATEMENT_NUMBER_UNDEFINED;
 
    switch(instruction_tag(i)) {
    case is_instruction_block:
        MAPL(cs, {
            *lt = reference_conversion_statement(module,STATEMENT(CAR(cs)),lt,
                                           r_to_llv, offsets,
                                           initial_basis,tile_indices, local_basis,tile);
        }, 
             instruction_block(i)); 
        return(*lt);
        break;
    case is_instruction_test:
        pips_internal_error("Reference conversion not implemented for tests");
        break;
    case is_instruction_loop: 
 
        
        *lt = reference_conversion_statement(module,
                                             loop_body(instruction_loop(i)),
                                             lt, r_to_llv, offsets,
                                             initial_basis, 
                                             tile_indices,local_basis,tile); 
         return(*lt);
        break;
    case is_instruction_goto:
        pips_internal_error("Unexpected goto (in restructured code)");
        break;
    case is_instruction_call:
        /* the function is assumed to be unchanged */
        MAP(EXPRESSION, argument,
        {  
            *lt = reference_conversion_computation(module,lt,argument,
                                                   initial_basis,
                                                   tile_indices,
                                                   local_basis, tile);
            reference_conversion_expression(argument, 
                                            r_to_llv, offsets,
                                            initial_basis, local_basis);
        }, 
             call_arguments(instruction_call(i)));
         return(*lt);
        break;
    case is_instruction_unstructured:
        pips_internal_error("Reference conversion not implemented for unstructureds");
        break;
    default:
        break;
    }
 
    debug(8,"reference_conversion_statement", "return statement: \n");
    ifdebug(8) {
        wp65_debug_print_text(entity_undefined, body);
    } 
    return(*lt);
} 

References call_arguments, CAR, debug(), entity_undefined, EXPRESSION, ifdebug, instruction_block, instruction_call, instruction_loop, instruction_tag, is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, loop_body, MAP, MAPL, module, pips_debug, pips_internal_error, reference_conversion_computation(), reference_conversion_expression(), STATEMENT, statement_instruction, statement_number, STATEMENT_NUMBER_UNDEFINED, and wp65_debug_print_text().

Referenced by make_compute_block().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_in_list_p()

bool reference_in_list_p	(	reference	r,
		list	lwr
	)

This function tests whether at least one array indice of Reference r belongs to List lwr or not.

Parameters

lwr

wr

Definition at line 130 of file references.c.

{ 
    list lref2;
    bool result = false;
    for (lref2 = lwr; 
         lref2 != NULL && !result; 
         result = result || reference_equal_p(r,REFERENCE(CAR(lref2))),
         lref2 = CDR(lref2)) ;
    return(result);
}

References CAR, CDR, REFERENCE, and reference_equal_p().

Referenced by array_indice_in_list_p(), call_instruction_to_communications(), and make_all_movement_blocks().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_list_add()

void reference_list_add	(	list *	l1,
		list *	l2
	)

This function adds all the references of l2 to l1 if they don't appear in l1.

Parameters

l1	1
l2	2

Definition at line 175 of file references.c.

{
    list lref2 =*l2 ;
    for(; lref2!= NIL; 
        reference_list_update(l1, REFERENCE(CAR(lref2))),
        lref2 = CDR(lref2));
}

References CAR, CDR, NIL, REFERENCE, and reference_list_update().

Referenced by concat_data_list(), loop_instruction_to_communications(), and statement_to_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_list_print()

void reference_list_print

(

list

l

)

This function prints the references belonging to l.

Definition at line 186 of file references.c.

{
    list lref;
    for (lref = l; 
         lref != NIL;
         (void) fprintf(stderr, 
                       "%s,",
                       entity_local_name(reference_variable(REFERENCE(CAR(lref))))), 
         lref = CDR(lref));
    (void) fprintf(stderr,"\n");
}

References CAR, CDR, entity_local_name(), fprintf(), NIL, REFERENCE, and reference_variable.

Referenced by call_instruction_to_communications(), call_to_wp65_code(), insert_array_scalar_access_movement(), and loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_list_update()

void reference_list_update	(	list *	l,
		reference	r
	)

This function add Reference r to List l, if r doesn't belong to l.

Definition at line 161 of file references.c.

{
    list lref1 =*l ;
    if (*l != NIL)  {
        for(; lref1!= NIL && !(reference_equal_p(REFERENCE(CAR(lref1)),r)) ; 
            lref1 = CDR(lref1));
        if (lref1 == NIL) 
            *l= gen_nconc(*l, CONS(REFERENCE,r,NIL));
    }
    else *l =  CONS(REFERENCE,r,NIL);
}

References CAR, CDR, CONS, gen_nconc(), NIL, REFERENCE, and reference_equal_p().

Referenced by call_instruction_to_communications(), loop_instruction_to_communications(), and reference_list_add().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_scalar_defined_p()

void reference_scalar_defined_p

(

reference

r

)

Definition at line 199 of file references.c.

{
    assert(!reference_undefined_p(r) 
           && r!=NULL && reference_variable(r)!=NULL 
           && reference_indices(r) == NIL);
}

References assert, NIL, reference_indices, reference_undefined_p, and reference_variable.

Referenced by loop_nest_to_wp65_code().

Here is the caller graph for this function:

reference_translation()

entity reference_translation	(	reference	r,
		Pbase	initial_basis,
		Pbase	local_basis
	)

Parameters

initial_basis	nitial_basis
local_basis	ocal_basis

Definition at line 855 of file code.c.

{
    int i;
    entity rv = reference_variable(r);
    if((i=rank_of_variable(initial_basis, (Variable) rv)) > 0)
        return((entity) variable_of_rank(local_basis, i));
    else return(entity_undefined);
}

References entity_undefined, rank_of_variable(), reference_variable, and variable_of_rank().

Here is the call graph for this function:

reset_fetch_map()

void reset_fetch_map

(

void

)

reset_store_map()

void reset_store_map

(

void

)

search_parallel_loops()

void search_parallel_loops	(	statement	,
		statement	,
		graph	,
		bool	[11]
	)

set_dimensions_of_local_variable_family()

void set_dimensions_of_local_variable_family	(	list	llv,
		Psysteme	tc,
		list	lr,
		tiling	tile,
		int	dimn
	)

void set_dimensions_of_local_variable_family(llv, tc, lr):

The algorithm used is not general; references are assumed equal up to a translation;

A general algorithm, as would be necessary for instance if a dependence was detected in the transposition algorithm between M(I,J) and M(J,I), would preserve some translation information for each reference in lr so as to generate proper new references to the local variable.

let's use the first reference to find out the number of dimensions

referenced variable

referenced variable type

referenced variable dimension list

dimension number

dimensions for the local variables

computation of the initial bounds of Entity rv

pips_assert("set_dimensions_of_local_variable_family",

pour tenir compte des offsets numeriques dans les fonctions d'acces

parameter ==> min = max = 1

ips_internal_error("unbounded domain for phi, %s", "check tile bounds and subscript expressions");

update types

sharing is not legal under NewGen rules; to avoid it lvd is duplicated at the CONS level, except the first time

Parameters

llv	lv
tc	The algorithm used is not general; references are assumed equal up to a translation;

A general algorithm, as would be necessary for instance if a dependence was detected in the transposition algorithm between M(I,J) and M(J,I), would preserve some translation information for each reference in lr so as to generate proper new references to the local variable. list of local variables with same dimensions used at different pipeline stages

Parameters

lr	r
tile	The algorithm used is not general; references are assumed equal up to a translation;

A general algorithm, as would be necessary for instance if a dependence was detected in the transposition algorithm between M(I,J) and M(J,I), would preserve some translation information for each reference in lr so as to generate proper new references to the local variable. non-empty list of associated references

Parameters

dimn

imn

Definition at line 689 of file variable.c.

{
    /* let's use the first reference to find out the number of dimensions */
    reference r;
    entity rv;                  /* referenced variable */
    type rvt;                   /* referenced variable type */
    list rvld;                  /* referenced variable dimension list */
    int d = -1;                 /* dimension number */
    list lvd = NIL;             /* dimensions for the local variables */
    bool first_ref;
    matrice P = (matrice) tiling_tile(tile);
    debug(8,"set_dimensions_of_local_variable_family","begin\n");
 
    r = REFERENCE(CAR(lr));
    rv = reference_variable(r);
    rvt = entity_type(rv);
    rvld = variable_dimensions(type_variable(rvt));
 
    debug(8,"set_dimensions_of_local_variable_family","entity=%s\n",
          entity_name(rv));
 
    for( d = 1; !ENDP(rvld); POP(rvld), d++) {
        Value imax = VALUE_MIN;
        Value gmin = VALUE_MAX;
        Value gmax = VALUE_MIN;
        list cr = list_undefined;
        dimension dimd = dimension_undefined;
        
 
        /* computation of the initial bounds of Entity rv */
        dimension dim1 = DIMENSION(CAR(rvld));
        expression lower= dimension_lower(dim1);
        normalized norm1 = NORMALIZE_EXPRESSION(lower);
        expression upper= dimension_upper(dim1);
        normalized norm2 = NORMALIZE_EXPRESSION(upper);
        if (normalized_linear_p(norm1) && normalized_linear_p(norm2)) {
            gmin = vect_coeff(TCST,(Pvecteur) normalized_linear(norm1));
            value_decrement(gmin);
            gmax = vect_coeff(TCST,(Pvecteur) normalized_linear(norm2));
            value_decrement(gmax);
            imax = gmax;
        }
        first_ref = true;
        for(cr = lr; !ENDP(cr); POP(cr)) {
            entity phi = make_phi_entity(d);
            expression e;
            normalized n;
            Pvecteur vec;
            Pcontrainte eg;
            Psysteme s;
            Value min, max, coef;
            r = REFERENCE(CAR(cr));
            e = find_ith_expression(reference_indices(r), d);
            n = NORMALIZE_EXPRESSION(e);
 
            /* pips_assert("set_dimensions_of_local_variable_family", */
            if (normalized_linear_p(n)) {
                vec = vect_dup((Pvecteur) normalized_linear(n));
                vect_add_elem(&vec, (Variable) phi, VALUE_MONE);
                eg = contrainte_make(vec);
 
                /* pour tenir compte des offsets numeriques dans les 
                   fonctions d'acces */
                coef =vect_coeff(TCST,vec);
                if (value_pos_p(coef)) value_addto(gmax,coef);
                else value_addto(gmin,coef);
 
                s = sc_dup(tc);
                sc_add_egalite(s, eg);
                vect_add_variable(sc_base(s), (Variable) phi);
 
                s = sc_normalize(s);
                ifdebug(8) {
                    (void) fprintf(stderr,
                                   "System on phi for dimension %d:\n", d);
                    sc_fprint(stderr, s, (string(*)(Variable))entity_local_name);
                }
 
 
                if(!sc_minmax_of_variable(s, (Variable) phi, 
                                          &min, &max))
                    pips_internal_error("empty domain for phi");
 
                if(value_min_p(min) || value_max_p(max)) {
                    Value divis= ACCESS(P,dimn,d,d);
                    /* parameter ==> min = max = 1 */
                    /*pips_internal_error("unbounded domain for phi, %s",
                      "check tile bounds and subscript expressions"); */
                    min= VALUE_ZERO;
                    max= value_lt(divis,VALUE_CONST(999)) && 
                        value_gt(divis,VALUE_ONE)? value_div(imax,divis): imax;
                }
 
                debug(8,"set_dimensions_of_local_variable_family",
                      "bounds for dimension %d: [%d:%d]\n", d, min, max);
 
                gmin = first_ref? value_max(gmin, min): value_min(gmin, min);
                gmax = first_ref? value_min(gmax, max): value_max(gmax, max);
                
                if (value_gt(gmin,gmax)) gmax = gmin;
                first_ref=false;                
            }
        }
        dimd = make_dimension(int_to_expression(VALUE_TO_INT(gmin)),
                              int_to_expression(VALUE_TO_INT(gmax)),
                              NIL);
 
        debug(8,"set_dimensions_of_local_variable_family",
              "bounds for dimension %d: [%d:%d]\n", d, gmin, gmax);
 
        lvd = gen_nconc(lvd, CONS(DIMENSION, dimd, NIL));
    }
 
    /* update types */
    MAPL(clv, 
     {
         entity lv = ENTITY(CAR(clv));
         type tlv = entity_type(lv);
         variable tv = type_variable(tlv);
 
         /* sharing is not legal under NewGen rules; to avoid
            it lvd is duplicated at the CONS level, except the first time */
         if(clv!=llv)
             lvd = gen_copy_seq(lvd);
         variable_dimensions(tv) = lvd;
     },
         llv);
 
    ifdebug(8) {
        MAPL(clv, 
         {
             entity lv = ENTITY(CAR(clv));
             print_sentence(stderr,Sentence_Variable(lv));
         },
             llv);
    }
 
    pips_debug(8,"end\n");
}

References ACCESS, CAR, CONS, contrainte_make(), debug(), DIMENSION, dimension_lower, dimension_undefined, dimension_upper, ENDP, ENTITY, entity_local_name(), entity_name, entity_type, find_ith_expression(), fprintf(), gen_copy_seq(), gen_nconc(), ifdebug, int_to_expression(), list_undefined, make_dimension(), make_phi_entity(), MAPL, max, min, NIL, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_debug, pips_internal_error, POP, print_sentence(), REFERENCE, reference_indices, reference_variable, sc_add_egalite(), sc_dup(), sc_fprint(), sc_minmax_of_variable(), sc_normalize(), Sentence_Variable(), tc, TCST, tiling_tile, type_variable, value_addto, VALUE_CONST, value_decrement, value_div, value_gt, value_lt, VALUE_MAX, value_max, value_max_p, VALUE_MIN, value_min, value_min_p, VALUE_MONE, VALUE_ONE, value_pos_p, VALUE_TO_INT, VALUE_ZERO, variable_dimensions, vect_add_elem(), vect_add_variable(), vect_coeff(), and vect_dup().

Referenced by set_dimensions_of_local_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

set_dimensions_of_local_variables()

void set_dimensions_of_local_variables	(	hash_table	v_to_lllv,
		Pbase	basis,
		tiling	tile,
		hash_table	llv_to_lcr
	)

Parameters

v_to_lllv	_to_lllv
basis	asis
tile	ile
llv_to_lcr	lv_to_lcr

Definition at line 652 of file variable.c.

{
    Psysteme tc = SC_UNDEFINED;
    matrice P = (matrice) tiling_tile(tile);
 
    debug(8,"set_dimensions_of_local_variables","begin\n");
 
    tc = make_tile_constraints(P, basis);
 
    HASH_MAP(v, clllv, {
        list cllv;
        for(cllv = (list) clllv; !ENDP(cllv); POP(cllv)) {
            list llv = LIST(CAR(cllv));
            list lr = (list) hash_get(llv_to_lcr, (char *) llv);
            set_dimensions_of_local_variable_family(llv, tc, lr,tile,vect_size(basis));
        }
    }, v_to_lllv);
 
    sc_rm(tc);
 
    debug(8,"set_dimensions_of_local_variables","end\n");
}

References CAR, debug(), ENDP, hash_get(), HASH_MAP, LIST, make_tile_constraints(), POP, sc_rm(), set_dimensions_of_local_variable_family(), tc, tiling_tile, and vect_size().

Referenced by loop_nest_to_local_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

set_fetch_map()

void set_fetch_map

(

statement_mapping

)

set_store_map()

void set_store_map

(

statement_mapping

)

statement_fetch_undefined_p()

bool statement_fetch_undefined_p

(

statement

)

statement_store_undefined_p()

bool statement_store_undefined_p

(

statement

)

statement_to_communications()

void statement_to_communications	(	statement	stmt,
		statement	st_level1,
		statement	st_level2,
		list *	lwr,
		list *	lwr_local,
		statement_mapping *	fetch_map,
		statement_mapping *	store_map,
		hash_table	r_to_ud,
		list *	lpv
	)

This function associates to each variable in stmt the statement where it should be communicated.

The lwr list corresponds to the list of variables that have been updated before the current statement bloc. The lwr_local list corresponds to the list of variables that are updated in the current statement bloc.

Parameters

stmt	tmt
st_level1	t_level1
st_level2	t_level2
lwr	wr
lwr_local	wr_local
fetch_map	etch_map
store_map	tore_map
r_to_ud	_to_ud
lpv	pv

Definition at line 191 of file communications.c.

{
    instruction inst = statement_instruction(stmt);
    
    debug(8, "statement_to_communications", "begin with tag %d\n", 
          instruction_tag(inst));
 
    switch(instruction_tag(inst)) {
    case is_instruction_block: {
        ifdebug(7) 
            (void) fprintf(stderr,
                           "statement_to_communications-instruction block- begin\n");
        st_level2 = STATEMENT(CAR(instruction_block(inst)));
        MAPL( sts, {
            statement s = STATEMENT(CAR(sts));
            statement_to_communications(s,st_level1, st_level2,
                                        lwr,lwr_local,
                                        fetch_map,store_map, 
                                        r_to_ud,lpv);
        }, instruction_block(inst));
        ifdebug(7) 
            (void) fprintf(stderr,
                           "statement_to_communications-instruction block- end\n");
        break;
    }
    case is_instruction_test:
        (void) fprintf(stderr,"not implemented\n");
        break;
    case is_instruction_loop: {
        ifdebug(7)
            (void) fprintf(stderr,
                           "statement_to_communications-instruction loop- begin\n");
        loop_instruction_to_communications(stmt, stmt, stmt, 
                                           lwr, lwr_local,
                                           fetch_map,store_map,
                                           r_to_ud,lpv);
        reference_list_add(lwr, lwr_local);
        ifdebug(7)
            (void) fprintf(stderr,
                           "statement_to_communications-instruction loop- end\n");
        break;
    }
    case is_instruction_call: {
        ifdebug(7)
            (void) fprintf(stderr,"statement_to_communications-instruction call- begin\n");
        call_instruction_to_communications(stmt, st_level1, st_level2, 
                                           lwr, lwr_local,
                                           fetch_map,store_map,r_to_ud,lpv);
        ifdebug(7)
            (void) fprintf(stderr,"statement_to_communications-instruction call- end\n");
        break; 
    }
    case is_instruction_goto: {
        pips_internal_error("Unexpected goto");
        break;}
    case is_instruction_unstructured: {
        pips_internal_error("Sorry: unstructured not implemented");
        break;}
    default: 
        pips_internal_error("Bad instruction tag");
    }
}

References call_instruction_to_communications(), CAR, debug(), fprintf(), ifdebug, instruction_block, instruction_tag, is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, loop_instruction_to_communications(), MAPL, pips_internal_error, reference_list_add(), STATEMENT, and statement_instruction.

Referenced by compute_communications(), and loop_instruction_to_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

store_map_undefined_p()

bool store_map_undefined_p

(

void

)

store_statement_fetch()

void store_statement_fetch	(	statement	,
		list
	)

store_statement_store()

void store_statement_store	(	statement	,
		list
	)

test_run_time_communications()

bool test_run_time_communications	(	list	list_statement_block,
		statement_mapping	fetch_map,
		statement_mapping	store_map
	)

just to avoid warning

Parameters

list_statement_block	ist_statement_block
fetch_map	etch_map
store_map	tore_map

Definition at line 733 of file communications.c.

{
    bool ok ;
    int nbcall =0;
    MAPL(st1, 
     { instruction inst = statement_instruction(STATEMENT(CAR(st1)));
       switch(instruction_tag(inst)) {
       case is_instruction_block: { 
           ok = false;
           MAPL(st2, {
               ok = (ok) ? ok : 
                   test_run_time_communications(CONS(STATEMENT,
                                                     STATEMENT(CAR(st2)),
                                                     NIL),
                                                fetch_map,store_map);
           }, 
               instruction_block(inst));
           return ok;
           break; }
       case is_instruction_loop: {
           return(test_run_time_communications(CONS(STATEMENT,
                                                    loop_body(instruction_loop(inst)),
                                                    NIL),
                                               fetch_map,store_map));
           break;}
       case is_instruction_call: {
           list  lt = (list) GET_STATEMENT_MAPPING(fetch_map,STATEMENT(CAR(st1))); 
           if (lt != (list) HASH_UNDEFINED_VALUE) {
               nbcall ++;
           return (true);  
               } else
                   return(false);
           break;
       }
       default:
           break;
       }
   }, 
       list_statement_block);
 /* just to avoid warning */
 return (true);
}

References CAR, CONS, GET_STATEMENT_MAPPING, HASH_UNDEFINED_VALUE, instruction_block, instruction_loop, instruction_tag, is_instruction_block, is_instruction_call, is_instruction_loop, loop_body, MAPL, NIL, ok, STATEMENT, and statement_instruction.

tile_change_of_basis()

void tile_change_of_basis	(	Psysteme	tile_domain,
		Pbase	initial_basis,
		Pbase	tile_basis,
		Pbase	tile_init_basis,
		tiling	tile
	)

Parameters

tile_domain	ile_domain
initial_basis	nitial_basis
tile_basis	ile_basis
tile_init_basis	ile_init_basis
tile	ile

Definition at line 161 of file code.c.

{ 
    int dim = base_dimension(initial_basis);
    int l,c;
    for(l=1; l <= dim; l++) {
        Pcontrainte eq;
        Pvecteur v = VECTEUR_NUL;
        int td = base_dimension(tile_basis);
        for(c=1; c<=td; c++)
            vect_add_elem(&v, variable_of_rank(tile_basis, c), 
                          (Value) ACCESS((matrice) tiling_tile(tile), dim, l, c));
        
        vect_add_elem(&v, variable_of_rank(tile_init_basis, l), VALUE_MONE);
        vect_add_elem(&v, TCST,
                      vect_coeff(variable_of_rank(initial_basis, l),
                                 (Pvecteur) tiling_origin(tile)));
        eq = contrainte_make(v);
        sc_add_egalite(tile_domain, eq);
    }
}

References ACCESS, base_dimension, contrainte_make(), eq, sc_add_egalite(), TCST, tiling_origin, tiling_tile, VALUE_MONE, variable_of_rank(), vect_add_elem(), vect_coeff(), and VECTEUR_NUL.

Referenced by make_scanning_over_one_tile(), and make_scanning_over_tiles().

Here is the call graph for this function:

Here is the caller graph for this function:

tile_membership()

Psysteme tile_membership	(	matrice	P,
		Pbase	origin,
		Pbase	member
	)

Psysteme tile_membership(P, origin, member):

builds a linear constraint system to express the fact that iteration "member" belongs to a P tile with origin "origin". "origin" and "member" are expressed in the initial basis.

pips_assert("tile_membership", k > 1);

Parameters

origin	rigin
member	ember

Definition at line 1469 of file code.c.

{
    Psysteme m = sc_new();
    int d = base_dimension(origin);
    matrice IP = matrice_new(d,d);
    Pcontrainte c1;
    int i, j;
    Value k;
 
    debug(8,"tile_membership", "begin\n");
 
    pips_assert("tile_membership", d == base_dimension(member)); 
    pips_assert("tile_membership", value_one_p(DENOMINATOR(P)));
 
    ifdebug(8) {
        (void) fprintf(stderr,"Partitioning matrix P:\n");
        matrice_fprint(stderr, P, d, d);
    }
 
    matrice_general_inversion(P, IP, d);
    matrice_normalize(IP, d, d);
    k = DENOMINATOR(IP);
 
/*   pips_assert("tile_membership", k > 1); */
 
    ifdebug(8) {
        (void) fprintf(stderr,"Inverse of partitioning matrix, IP:\n");
        matrice_fprint(stderr, IP, d, d);
    }
 
    for ( i=1; i<=d; i++) {
        Pcontrainte c = contrainte_new();
 
        for ( j=1; j<=d; j++) {
            vect_add_elem(&contrainte_vecteur(c), 
                          variable_of_rank(member,i),
                          value_uminus(ACCESS(IP, d, j, i)));
            vect_add_elem(&contrainte_vecteur(c), 
                          variable_of_rank(origin,i),
                          ACCESS(IP, d, j, i));
        }
        sc_add_inegalite(m, c);
        c1 = contrainte_dup(c);
        contrainte_chg_sgn(c1);
        vect_add_elem(&contrainte_vecteur(c1), TCST, value_minus(VALUE_ONE,k));
        sc_add_inegalite(m, c1);
    }
 
    sc_creer_base(m);
    matrice_free(IP);
 
    ifdebug(8) {
        (void) fprintf(stderr,"Tile membership conditions:\n");
        sc_fprint(stderr, m, (string(*)(Variable))entity_local_name);
    }
 
    debug(8,"tile_membership", "end\n");
 
    return m;
}

References ACCESS, base_dimension, contrainte_chg_sgn(), contrainte_dup(), contrainte_new(), contrainte_vecteur, debug(), DENOMINATOR, entity_local_name(), fprintf(), ifdebug, matrice_fprint(), matrice_free, matrice_general_inversion(), matrice_new, matrice_normalize(), member(), origin, pips_assert, sc_add_inegalite(), sc_creer_base(), sc_fprint(), sc_new(), TCST, value_minus, VALUE_ONE, value_one_p, value_uminus, variable_of_rank(), and vect_add_elem().

Referenced by make_scanning_over_one_tile(), and make_scanning_over_tiles().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_IO_ref()

reference translate_IO_ref	(	call	c,
		hash_table	v_to_esv,
		bool	loop_or_call_print
	)

This function translates a reference in I/O statement into its corresponding emulated shared memory reference.

scan the argument list till IOLIST' arguments

implied-do case: the array reference is the first argument in the last argument list of the implied do call

Parameters

v_to_esv	_to_esv
loop_or_call_print	oop_or_call_print

Definition at line 346 of file instruction_to_wp65_code.c.

{
  pips_assert("true", loop_or_call_print==loop_or_call_print);
    list pio,pc = NIL;
    bool iolist_reached = false;
    expression exp; 
    syntax s;
    reference  result=reference_undefined;
    if (same_string_p(entity_local_name(call_function(c)), "WRITE")) {
        pio = pc = call_arguments(c);  
        /* scan the argument list till IOLIST' arguments*/
        while (!ENDP(pio) && (!iolist_reached)) {
            call c1;
            expression arg;
            s = expression_syntax(EXPRESSION(CAR(pio)));
            c1=syntax_call(s);
            arg = EXPRESSION(CAR(CDR(pio)));
            
            if (((strcmp(entity_local_name(call_function(c1)),"FMT=")==0) &&
                 (strcmp(expression_to_string(arg),"*")==0))
                ||((strcmp(entity_local_name(call_function(c1)),"UNIT=")==0) 
                   &&
                   (strcmp(expression_to_string(arg),"*")==0)))
                pio = CDR(CDR(pio));
            else
                if (strcmp(entity_local_name(call_function(c1)),
                           "IOLIST=")==0) {
                    iolist_reached = true;
                    pio = CDR(pio);
                }
        }
        exp = EXPRESSION(CAR(pio));
        /* implied-do case: the array reference is the first argument 
         in the last argument list of the implied do call */
        s=expression_syntax(exp);
        if (syntax_call_p(s) && 
            (strcmp(entity_local_name(call_function(syntax_call(s))),
               "IMPLIED-DO") == 0)) {
            exp = ref_in_implied_do(exp);
            s=expression_syntax(exp);
        }
        if (syntax_reference_p(s)) {
            syntax sy1 = expression_syntax(exp);
            reference ref1 = syntax_reference(sy1);
            list indic = gen_full_copy_list(reference_indices(ref1));
            entity ent1=(entity)hash_get(v_to_esv,
                                         (char *) reference_variable(ref1));
            reference newr = make_reference(ent1,indic);
            expression_syntax(exp)= make_syntax(is_syntax_reference,newr);
            result = ref1;
        }
    }  
    else
        pips_user_error("function calls are not handled in this version\n");
    return result;
}

References call_arguments, call_function, CAR, CDR, ENDP, entity_local_name(), exp, EXPRESSION, expression_syntax, expression_to_string(), gen_full_copy_list(), hash_get(), is_syntax_reference, make_reference(), make_syntax(), NIL, pips_assert, pips_user_error, ref_in_implied_do(), reference_indices, reference_undefined, reference_variable, same_string_p, syntax_call, syntax_call_p, syntax_reference, and syntax_reference_p.

Referenced by generate_io_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

uniform_dependence_p()

bool uniform_dependence_p	(	reference	r1,
		reference	r2
	)

This function checks if two references have a uniform dependence.

It assumes that some verifications have been made before. The two references r1 and r2 must reference the same array with the same dimension.

FI: could/should be moved in ri-util/expression.c

Parameters

r1	1
r2	2

Definition at line 939 of file code.c.

{
 
    bool uniform = true;
    cons * ind1, *ind2;
 
    debug(8,"uniform_dependence_p", "begin\n");
 
    ind1 = reference_indices(r1);
    ind2 = reference_indices(r2); 
    for (; uniform && ind1 != NULL && ind2!= NULL;
         ind1 = CDR(ind1), ind2=CDR(ind2)) 
    { 
    expression expr1= EXPRESSION(CAR(ind1));
    expression expr2= EXPRESSION(CAR(ind2));
        normalized norm1 = (normalized) NORMALIZE_EXPRESSION(expr1);
        normalized norm2 = (normalized) NORMALIZE_EXPRESSION(expr2);
        if (normalized_linear_p(norm1) && normalized_linear_p(norm2)) {
            Pvecteur pv1 = (Pvecteur) normalized_linear(norm1);
            Pvecteur pv2 = (Pvecteur) normalized_linear(norm2);
            Pvecteur pv3 = vect_substract(pv1,pv2);
            if (vect_size(pv3) >1 || 
                ((vect_size (pv3)==1) && (vecteur_var(pv3) != TCST)))
                uniform = false;
            vect_rm(pv3);
        }
    }
    debug(8,"uniform_dependence_p", "end\n");
    return(uniform);
}

References CAR, CDR, debug(), EXPRESSION, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, reference_indices, TCST, vect_rm(), vect_size(), vect_substract(), and vecteur_var.

Referenced by classify_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

update_map()

void update_map	(	statement_mapping	m,
		statement	st,
		reference	r
	)

Parameters

st

t

Definition at line 68 of file references.c.

{
    list lt;
 
    lt = (list) GET_STATEMENT_MAPPING(m,st);
    if (lt != (list) HASH_UNDEFINED_VALUE) { 
        if (!ref_in_list_p(lt,r)) {
            lt =  gen_nconc(lt, CONS(REFERENCE,r, NIL));
            ifdebug(9) 
                (void) fprintf(stderr,
                               "ajout de la ref: %s au statement %"PRIdPTR"\n",
                               entity_local_name(reference_variable(r)), 
                               statement_number(st));    
        }
    }
    else {
        lt= CONS(REFERENCE,r, NIL);
        ifdebug(9) 
            (void) fprintf (stderr,
                "ajout de la ref: %s au statement %"PRIdPTR"\n",
                entity_local_name(reference_variable(r)), 
                statement_number(st));   
    }
    SET_STATEMENT_MAPPING(m,st,lt);
}

References CONS, entity_local_name(), fprintf(), gen_nconc(), GET_STATEMENT_MAPPING, HASH_UNDEFINED_VALUE, ifdebug, NIL, ref_in_list_p(), REFERENCE, reference_variable, SET_STATEMENT_MAPPING, and statement_number.

Referenced by call_instruction_to_communications().

Here is the call graph for this function:

Here is the caller graph for this function:

update_statement_fetch()

void update_statement_fetch	(	statement	,
		list
	)

update_statement_store()

void update_statement_store	(	statement	,
		list
	)

variable_list_add()

void variable_list_add	(	list *	l1,
		list *	l2
	)

This function adds all the references of l2 to l1 if they don't appear in l1.

Parameters

l1	1
l2	2

Definition at line 225 of file references.c.

{
    list lvar2 =*l2 ;
    for(; lvar2!= NIL; 
        variable_list_update(l1,REFERENCE(CAR(lvar2))),
        lvar2 = CDR(lvar2));
}

References CAR, CDR, NIL, REFERENCE, and variable_list_update().

Referenced by concat_data_list().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_list_update()

void variable_list_update	(	list *	l,
		reference	r
	)

This function adds the reference r to List l, if the reference_variable(r) doesn't belong to l.

Definition at line 208 of file references.c.

{
    list lvar1 =*l ;
    if (*l != NIL)  {
        for(; 
            lvar1!= NIL 
            && strcmp(entity_local_name(reference_variable(REFERENCE(CAR(lvar1)))),
                      entity_local_name(reference_variable(r))); 
            lvar1 = CDR(lvar1));
        if (lvar1 == NIL) 
            *l= gen_nconc(*l, CONS(REFERENCE,r,NIL));
    }
    else *l =  CONS(REFERENCE,r,NIL);
}

References CAR, CDR, CONS, entity_local_name(), gen_nconc(), NIL, REFERENCE, and reference_variable.

Referenced by variable_list_add().

Here is the call graph for this function:

Here is the caller graph for this function:

wp65()

bool wp65

(

const

string

)

Let's modify the old code instead of copy it but do not tell pipsdbm; else we would get a copy of the code, not consistent with the dependence graph

fprintf(stderr,"refs du code\n"); debug_refs(s); fprintf(stderr,"refs du dg\n"); debug_refs(dg);

fprintf(stderr,"refs du code\n"); debug_refs(s); fprintf(stderr,"refs du dg\n"); debug_refs(dg);

Put final code for the computational module in a text resource of the database

Put final code for the memory module in a text resource of the database

reset_current_module_statement();

Parameters

string

nput_module_name

Definition at line 128 of file wp65.c.

{
    entity module = module_name_to_entity(input_module_name);
    /* Let's modify the old code instead of copy it but do not tell
       pipsdbm; else we would get a *copy* of the code, not consistent
       with the dependence graph */
    statement s;
    entity compute_module = entity_undefined;
    statement computational = statement_undefined;
    entity memory_module = entity_undefined;
    statement emulator = statement_undefined;
    int pn, bn, ls, pd = PIPELINE_DEPTH;
    graph dg;
    string ppp;
 
    s = (statement) db_get_memory_resource(DBR_CODE, input_module_name,true);
    dg = (graph) db_get_memory_resource(DBR_DG, input_module_name, true);
    set_ordering_to_statement(s);
    debug_on("WP65_DEBUG_LEVEL");
    debug(8, "wp65", "begin\n");
 
    get_model(&pn, &bn, &ls);
    ifdebug(1) model_fprint(stderr, pn, bn ,ls);
 
    regions_init();
    set_current_module_entity(module);
    ppp = strdup(get_string_property(PRETTYPRINT_PARALLEL));
    set_string_property(PRETTYPRINT_PARALLEL, "doall");
 
    /*    fprintf(stderr,"refs du code\n"); debug_refs(s);
          fprintf(stderr,"refs du dg\n"); debug_refs(dg); */
 
    translate_unary_into_binary_ref(s);      
 
    /* fprintf(stderr,"refs du code\n"); debug_refs(s); 
       fprintf(stderr,"refs du dg\n"); debug_refs(dg); */
 
    module_to_wp65_modules(module, s, dg,
                           pn, bn, ls, pd, 
                           &compute_module, &computational, 
                           &memory_module, &emulator);
    
    (void) variable_declaration_coherency_p(compute_module,computational);
    (void) variable_declaration_coherency_p(memory_module,emulator);
 
  
    /* Put final code for the computational module in a text resource 
       of the database */
    init_prettyprint(empty_text);
    make_text_resource(input_module_name,
                       DBR_WP65_COMPUTE_FILE, 
                       WP65_COMPUTE_EXT,
                       text_module(compute_module,computational));
    close_prettyprint();
 
    /* Put final code for the memory module in a text resource 
       of the database */
    make_text_resource(input_module_name,
                       DBR_WP65_BANK_FILE, 
                       WP65_BANK_EXT,
                       text_module(memory_module,emulator));
 
    debug(8, "wp65", "end\n");
 
    /* reset_current_module_statement(); */
    reset_ordering_to_statement();
    reset_current_module_entity();
    set_string_property(PRETTYPRINT_PARALLEL, ppp); free(ppp);
    debug_off();
 
return true;
 
}

References close_prettyprint(), db_get_memory_resource(), debug(), debug_off, debug_on, dg, empty_text(), entity_undefined, free(), get_model(), get_string_property(), ifdebug, init_prettyprint(), make_text_resource(), model_fprint(), module, module_name_to_entity(), module_to_wp65_modules(), PIPELINE_DEPTH, PRETTYPRINT_PARALLEL, regions_init(), reset_current_module_entity(), reset_ordering_to_statement(), set_current_module_entity(), set_ordering_to_statement(), set_string_property(), statement_undefined, strdup(), text_module(), translate_unary_into_binary_ref(), and variable_declaration_coherency_p().

Here is the call graph for this function:

wp65_conform_p()

bool wp65_conform_p

(

statement

s

)

there should be only one instruction: do not put a STOP in the source file

Definition at line 508 of file wp65.c.

{
    instruction i = statement_instruction(s);
 
    if (instruction_unstructured_p(i)) {
        /* there should be only one instruction: do not put a STOP in the
           source file */
        unstructured u = instruction_unstructured(i);
        control c = unstructured_control(u);
        if(control_predecessors(c) == NIL && control_successors(c) == NIL) {
            i = statement_instruction(control_statement(c));
        }
        else {
            debug(1,"wp65_conform_p",
                  "program body is an unstructured with at least two nodes\n");
            return false;
        }
    }
 
    if(!instruction_block_p(i)) {
        debug(1,"wp65_conform_p","program body is not a block\n");
        return false;
    }
    else {
        list ls = instruction_block(i);
        MAPL(pm,{
            statement s1 = STATEMENT(CAR(pm));
            if(!assignment_statement_p(s1) && !perfectly_nested_loop_p(s1)) {
                if(!stop_statement_p(s1) && !return_statement_p(s1)) {
                    debug(1,"wp65_conform_p",
                          "program body contains a non-perfectly nested loop\n");
                    return false;
                }
            }
        },ls);
    }
    return true;
}

References assignment_statement_p(), CAR, control_predecessors, control_statement, control_successors, debug(), instruction_block, instruction_block_p, instruction_unstructured, instruction_unstructured_p, MAPL, NIL, perfectly_nested_loop_p(), return_statement_p(), s1, STATEMENT, statement_instruction, stop_statement_p(), and unstructured_control.

Here is the call graph for this function:

Variable Documentation

offset_dim1

Value offset_dim1

extern

WP65_INCLUDED.

cproto-generated files code.c

WP65_INCLUDED.

Definition at line 67 of file code.c.

Referenced by initialize_offsets(), and nullify_offsets().

offset_dim2

Value offset_dim2

extern

Definition at line 68 of file code.c.

Referenced by initialize_offsets(), and nullify_offsets().