movements.h File Reference

#include "matrice.h"

Include dependency graph for movements.h:

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

Go to the source code of this file.

Macros
#define	COLUMN_MAJOR   true
	Warning! Do not modify this file that is automatically generated! More...
#define	SUFFIX_FOR_TEMP_VAR1_IN_INNER_LOOP   "_1"
#define	SUFFIX_FOR_TEMP_VAR2_IN_INNER_LOOP   "_2"

Functions
Pbase	build_image_base (bool, Pbase, Pbase, Pbase)
	cproto-generated files More...
void	print_fullname_base (Pbase)
void	update_basis (Pbase, Pbase *, Pbase *, Pbase *, Pbase, Pbase, Pbase *, Pbase *, Pbase *, Pbase *, Pbase *, bool, Pbase)
	Update all the basis needed for data movement generation. More...
void	sort_tile_indices (Pbase, Pbase *, matrice, int)
	Sort the tile indices base, such that the indices correspond to the tile indices of the array elements accessed by the local entity. More...
Psysteme	elim_redund_sc_with_sc (Psysteme, Psysteme, Pbase, int)
	Build the system of inequations of sc1 no-redundant with system sc2. More...
Pbase	variables_in_declaration_list (entity, code)
statement	movement_computation (entity, bool, bool, bool, entity, Psysteme, Pbase, Pbase, Pbase, Pbase, Pbase, int, int)
	Calcul des nouvelles bornes des boucles et de la nouvelle fonction d'acces a une reference d'un tableau permettant d'exprimer l'ensemble des elements references dans une base. More...
Psysteme	sc_image_computation (entity, entity, Psysteme, Psysteme, Pbase, Pbase *, entity, Pbase, Pbase, Pbase *, int, int, int, int *, int *)
	This function computes the system of constraints characterizing the image by the array function of the iteration domain. More...
expression	lower_bound_generation (Psysteme, Pbase, int, int)
	bound_generation.c More...
expression	upper_bound_generation (Psysteme, Pbase, int, int)
	This fonction generates the upper bounds of the "loop_rank"-th loop. More...
expression	test_bound_generation (Psysteme, Pbase)
	This function generates the expressions of the guard if it exists. More...
statement	bound_generation (entity, bool, bool, entity, Pbase, Pbase, Psysteme *, Pbase, int, int[][4])
	Generation of the new loop nest characterizing the new domain. More...
expression	make_div_expression (expression, cons *)
	operation.c More...
expression	make_op_expression (entity, cons *)
expression	complex_bound_generation (Value, Value, Value, Pvecteur, Variable, Pvecteur, Variable)
	complex_bound_generation.c More...
expression	complex_bound_computation (Psysteme, Pbase, Pcontrainte, Pcontrainte, int)
void	bound_distribution (Psysteme *, Pbase, int[][4], int, Psysteme *, Psysteme *, Psysteme)
	constraint_distribution.c More...
void	constraint_distribution (Psysteme, Psysteme *, Pbase, int[][4])
	Distribution of the constraints of the system sc into several systems. More...
void	egalite_distribution (Psysteme, Psysteme *, Pbase)
void	wp65_debug_print_text (entity, statement)
	make_loop_body.c More...
void	wp65_debug_print_module (entity, statement)
bool	variable_in_declaration_module_p (entity, entity)
entity	find_operator (entity, string, string)
statement	make_statement_operator (entity, cons *)
statement	make_movements_loop_body_wp65 (entity, bool, entity, Pbase, Pbase, Psysteme, Psysteme, Pbase, int, int, int)
	statement make_movements_loop_body_wp65(module,receive_code, ent,local_indices,var_id, sc_neg,sc_pos,index_base,rank, number_of_lower_bounds, number_of_upper_bounds) More...
statement	make_datum_movement (entity, bool, entity, Pbase, Pbase)
	statement make_datum_movement(module,receive_code,ent, local_indices,var_id) More...
statement	make_movement_scalar_wp65 (entity, bool, reference, entity)
	statement make_movement_scalar_wp65(receive_code,r) More...
Psysteme	build_sc_machine (int, int, int, Psysteme, entity, Pbase, entity)
	build_sc_machine.c More...
Pvecteur	make_loop_indice_equation (Pbase, tiling, Pvecteur, Pvecteur, Pvecteur, int)
	build_sc_tile.c More...
Psysteme	loop_bounds_to_tile_bounds (Psysteme, Pbase, tiling, Pvecteur, Pvecteur, Pvecteur)
	this function returns the system of constraints More...
Variable	sc_add_new_variable_name (entity, Psysteme)
	sc_add_variable.c More...

Macro Definition Documentation

COLUMN_MAJOR

#define COLUMN_MAJOR   true

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

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

Definition at line 36 of file movements.h.

SUFFIX_FOR_TEMP_VAR1_IN_INNER_LOOP

#define SUFFIX_FOR_TEMP_VAR1_IN_INNER_LOOP   "_1"

Definition at line 38 of file movements.h.

SUFFIX_FOR_TEMP_VAR2_IN_INNER_LOOP

#define SUFFIX_FOR_TEMP_VAR2_IN_INNER_LOOP   "_2"

Definition at line 39 of file movements.h.

Function Documentation

bound_distribution()

void bound_distribution	(	Psysteme *	,
		Pbase	,
		int	[][4],
		int	,
		Psysteme *	,
		Psysteme *	,
		Psysteme
	)

constraint_distribution.c

bound_generation()

statement bound_generation	(	entity	module,
		bool	bank_code,
		bool	receive_code,
		entity	ent,
		Pbase	loop_body_indices,
		Pbase	var_id,
		Psysteme *	lsystem,
		Pbase	index_base,
		int	n,
		int	sc_info[][4]
	)

Generation of the new loop nest characterizing the new domain.

The set of systems lsystem describes the set of constraints of each loop index. New loop bounds are deduced from these sytems.

Initialisation des systemes

make new bound expression and new range loop

looplabel = make_new_label(initial_module_name);

new code by FI to add continue statements starts here

end of new code by FI

Parameters

module	odule
bank_code	ank_code
receive_code	eceive_code
ent	nt
loop_body_indices	oop_body_indices
var_id	ar_id
lsystem	system
index_base	ndex_base
sc_info	c_info

Definition at line 328 of file bound_generation.c.

{
 
    Psysteme ps,*sc_pos,*sc_neg,sc_test;
    Pvecteur pv;
    Variable var;
    int n0_loop,i,first_loop;
    int number_of_lower_bounds = 0;
    int number_of_upper_bounds =0;      
    expression lower_bound;
    expression upper_bound;
    expression test_bound;
    range looprange;
    statement stat, cs;
    statement loopbody =statement_undefined;
    test tst;
    entity looplabel;
    loop newloop;
    int space = (n+1) * sizeof(Ssysteme);
    bool debut = true;
    int j;
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"bound_generation","begin\n");
 
    /* Initialisation des systemes */
 
    sc_neg = (Psysteme *) malloc((unsigned)(space));
    sc_pos = (Psysteme *) malloc((unsigned)(space));
    ps = lsystem[1];
    sc_test =  sc_init_with_sc(ps);
 
    bound_distribution(lsystem,index_base,sc_info,n,
                       sc_neg,sc_pos,sc_test);
 
 
    if (!CONTRAINTE_UNDEFINED_P(sc_test->inegalites))  {
        test_bound = test_bound_generation(sc_test,index_base);
        loopbody = make_datum_movement(module,receive_code,ent,
                                       loop_body_indices,
                                       var_id);
        tst =  make_test(test_bound,loopbody,
                         make_continue_statement(entity_empty_label()));
        stat = test_to_statement(tst);
        loopbody=make_block_statement(CONS(STATEMENT,stat,NIL));
        debut=false;
    }
  
    ifdebug(8) {
        (void) fprintf(stderr, "base des indices \n");
        for (pv = index_base; pv!=NULL; pv=pv->succ)
            fprintf (stderr,"%s,",entity_local_name((entity) pv->var));
 
        for (i=1;i<=n;i++) {
            for (j=1; j<=3;j++) {
                printf ("%d,",sc_info[i][j]); }
            printf ("\n");
        }
    }
 
    first_loop = (bank_code) ?  2 : 1;
 
    for (n0_loop = vect_size(index_base); n0_loop >= first_loop; n0_loop --) {
        var = variable_of_rank(index_base,n0_loop);
 
        if (sc_info[rank_of_variable(index_base,var)][1]) {
            ps = lsystem[n0_loop];
            ifdebug(8) {
                (void) fprintf(stderr,"LE SYSTEME  est :\n");
                (void) sc_fprint(stderr, ps, (get_variable_name_t) entity_local_name);
            }
            number_of_lower_bounds = 0;
            number_of_upper_bounds = 0;
            if (debut) {
                loopbody = make_movements_loop_body_wp65(module,
                                                         receive_code,ent,
                                                         loop_body_indices,
                                                         var_id,
                                                         sc_neg[n0_loop],
                                                         sc_pos[n0_loop],
                                                         index_base,n0_loop,
                                                         sc_info[n0_loop][3],
                                                         sc_info[n0_loop][2]);
                debut = false;
            }
            else {
                /* make new bound expression and new range loop */
 
                number_of_upper_bounds=sc_info[n0_loop][2];
                number_of_lower_bounds=sc_info[n0_loop][3];
                lower_bound = lower_bound_generation(sc_neg[n0_loop],
                                                     index_base,
                                                     number_of_lower_bounds,
                                                     n0_loop);
 
                upper_bound = upper_bound_generation(sc_pos[n0_loop],
                                                     index_base,
                                                     number_of_upper_bounds,
                                                     n0_loop);
 
                looprange = make_range(lower_bound,upper_bound,
                                       int_to_expression(1));
 
                /* looplabel = make_new_label(initial_module_name); */
                /* new code by FI to add continue statements starts here */
                looplabel = make_loop_label(9000, module);
                cs = make_continue_statement(looplabel);
                if(instruction_block_p(statement_instruction(loopbody)))
                    (void) gen_nconc(instruction_block(statement_instruction(loopbody)),
                                     CONS(STATEMENT, cs, NIL));
                else {
                    loopbody = make_block_statement(CONS(STATEMENT, loopbody,
                                                         CONS(STATEMENT, cs, NIL)));
                }
                /* end of new code by FI */
 
                if (n0_loop ==1)
                    newloop = make_loop((entity) var, 
                                        looprange,
                                        loopbody,
                                        looplabel, 
                                        make_execution(is_execution_parallel,
                                                       UU),
                                        NIL);
                else newloop = make_loop((entity) var, 
                                         looprange,
                                         loopbody,
                                         looplabel, 
                                 make_execution(is_execution_sequential,UU),
                                         NIL);
 
                stat = loop_to_statement(newloop);
        
                loopbody = make_block_statement(CONS(STATEMENT,stat,NIL));
                ifdebug(8) {
                    wp65_debug_print_text(entity_undefined, loopbody);
                    pips_debug(8,"systeme pour la %d boucle \n",n0_loop);
                    (void) sc_fprint(stderr, sc_neg[n0_loop],
                                     (get_variable_name_t) entity_local_name);
                    (void) sc_fprint(stderr, sc_pos[n0_loop],
                                     (get_variable_name_t) entity_local_name);
                    (void) sc_fprint(stderr, sc_test,
                                     (get_variable_name_t) entity_local_name);
                }
            }
        }
    }
   
    free((Psysteme) sc_neg);
    free((Psysteme) sc_pos);
 
    debug(8,"bound_generation","end\n");
    debug_off();
    return(loopbody);
 
}

References bound_distribution(), CONS, CONTRAINTE_UNDEFINED_P, debug(), debug_off, debug_on, entity_empty_label(), entity_local_name(), entity_undefined, fprintf(), free(), gen_nconc(), ifdebug, Ssysteme::inegalites, instruction_block, instruction_block_p, int_to_expression(), is_execution_parallel, is_execution_sequential, loop_to_statement, lower_bound_generation(), make_block_statement(), make_continue_statement(), make_datum_movement(), make_execution(), make_loop(), make_loop_label(), make_movements_loop_body_wp65(), make_range(), make_test(), malloc(), module, NIL, pips_debug, printf(), rank_of_variable(), sc_fprint(), sc_init_with_sc(), space, STATEMENT, statement_instruction, statement_undefined, Svecteur::succ, test_bound_generation(), test_to_statement, upper_bound_generation(), UU, Svecteur::var, variable_of_rank(), vect_size(), and wp65_debug_print_text().

Referenced by movement_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

build_image_base()

Pbase build_image_base	(	bool	bank_code,
		Pbase	proc_id,
		Pbase	bank_indices,
		Pbase	tile_indices
	)

cproto-generated files

movement_computation.c

Parameters

bank_code	ank_code
proc_id	roc_id
bank_indices	ank_indices
tile_indices	ile_indices

Definition at line 76 of file movement_computation.c.

{
    Pvecteur pb,ti;
    Pbase invt = base_reversal(tile_indices);
    Pbase dupt = base_dup(tile_indices);
 
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"build_image_base","begin\n");
 
    ti = (COLUMN_MAJOR) ? dupt:invt ;
    
    if (bank_code)
        pb = vect_new(vecteur_var(bank_indices->succ->succ),VALUE_ONE); 
    else 
        pb = vect_new(ti->var,VALUE_ONE);
    vect_add_elem(&pb,vecteur_var(bank_indices->succ),VALUE_ONE);
    
    if (!VECTEUR_NUL_P(ti->succ))
        vect_add_elem(&pb,vecteur_var(ti->succ),VALUE_ONE);
    
    if (bank_code) 
        vect_add_elem(&pb,vecteur_var(proc_id),VALUE_ONE);
    else 
        vect_add_elem(&pb,vecteur_var(bank_indices),VALUE_ONE);
    
    vect_rm(dupt);
    vect_rm(invt);
    debug(8,"build_image_base","end\n");
    debug_off();
    return ((Pbase) pb);
}

References base_dup(), base_reversal(), COLUMN_MAJOR, debug(), debug_off, debug_on, Svecteur::succ, VALUE_ONE, Svecteur::var, vect_add_elem(), vect_new(), vect_rm(), VECTEUR_NUL_P, and vecteur_var.

Referenced by update_basis().

Here is the call graph for this function:

Here is the caller graph for this function:

build_sc_machine()

Psysteme build_sc_machine	(	int	pn,
		int	bn,
		int	ls,
		Psysteme	sc_array_function,
		entity	proc_id,
		Pbase	bank_indices,
		entity	entity_var
	)

build_sc_machine.c

build_sc_machine.c

Corinne Ancourt - septembre 1991 this function builds the following system of constraints depending on the machine. It describes the implementation of array elements in the memory in function of bank, ligne size, ligne bank,...

bn is the number of banks, ls the ligne size, ms the first array dimension bank is a variable giving the bank id., ligne a variable corresponding to a ligne in the bank, ofs a variable corresponding to an offset in a ligne of the bank.

if COLUMN_MAJOR is true the system is the following one

 (VAR1-1) + (VAR2-1) *ms == bn*ls* ligne +ls*bank+ofs,
   1 <= bank <= bn ,
   1 <= proc <= pn ,
   0 <= ofs <= ls-1

else it is

  (VAR1-1) * ms + (VAR2-1) == bn*ls*ligne +ls*bank+ofs,
    1 <= bank <= bn ,
    1 <= proc <= pn ,
    0 <= ofs <= ls-1

Si l'on veut utiliser le nombre d'octets il faut remplacer l'equation par deux inequations du type

if COLUMN_MAJOR is true the system is the following one

(VAR1-1) + (VAR2-1) ms <= bn*ls (ligne-1) +ls*(bank-1)+ofs, bn*ls* (ligne-1) +ls*(bank-1)+ofs <= (VAR1) + (VAR2-1) *ms

else it is

(VAR1-1) * ms + (VAR2-1) <= bn*ls*(ligne-1) +ls*(bank-1)+ofs, bn*ls*(ligne-1) +ls*(bank-1)+ofs <= (VAR1-1) * ms + (VAR2)

nb_bytes = SizeOfElements(bas);

bank_indices is assumed to belong the three variables bank_id, L and O (see documentation for more details)

if COLUMN_MAJOR is true then build the constraint
(VAR1-1) + (VAR2-1) *ms == bn*ls*L +ls*bank_id+O, else build the constraint (VAR1-1) * ms + (VAR2-1) == bn*ls*L +ls*bank_id+O, VAR1 and VAR2 correspond to the image array function indices

to deal with MONO dimensional array

to deal with MONO dimensional array

build the constraints 0 <= bank_id <= bn-1

build the constraints 0 <= proc_id <= pn-1

build the constraints 0 <= O <= ls -1

build the constraints 0 <= L

Parameters

pn	n
bn	n
ls	s
sc_array_function	c_array_function
proc_id	roc_id
bank_indices	ank_indices
entity_var	ntity_var

Definition at line 70 of file build_sc_machine.c.

{
 
    type t = entity_type(entity_var);
    Value ms=0;
    Variable vbank,vligne,vofs;
    Psysteme sc = sc_init_with_sc(sc_array_function);
    Pcontrainte pc;
    Pvecteur pv1,pv2;
    int nb_bytes=1;
 
    debug(8,"build_sc_machine","begin\n");
    if (type_variable_p(t)) {
        variable var = type_variable(t);
        cons * dims = variable_dimensions(var);
        dimension dim1 = DIMENSION(CAR(dims));
        expression lower= dimension_lower(dim1);
        normalized norm1 = NORMALIZE_EXPRESSION(lower);
        expression upper= dimension_upper(dim1);
        normalized norm2 = NORMALIZE_EXPRESSION(upper);
        Value min_ms =VALUE_ZERO, max_ms=VALUE_ZERO;
        if (normalized_linear_p(norm1) && normalized_linear_p(norm2)) {
            min_ms = vect_coeff(TCST,(Pvecteur) normalized_linear(norm1));
            max_ms = vect_coeff(TCST,(Pvecteur) normalized_linear(norm2));
        }
        ms = value_plus(value_minus(max_ms,min_ms), VALUE_ONE);
 
        /* Si l'on veut utiliser le nombre d'octets il faut remplacer l'equation 
           par deux inequations du type 
           
           if COLUMN_MAJOR is true the system is the following one
           
           (VAR1-1) + (VAR2-1) *ms <= bn*ls* (ligne-1) +ls*(bank-1)+ofs,
           bn*ls* (ligne-1) +ls*(bank-1)+ofs <=  (VAR1) + (VAR2-1) *ms
 
           else it is
           
           (VAR1-1) * ms + (VAR2-1) <= bn*ls*(ligne-1) +ls*(bank-1)+ofs,
           bn*ls*(ligne-1) +ls*(bank-1)+ofs <=  (VAR1-1) * ms + (VAR2)
 
           */
 
        /*        nb_bytes = SizeOfElements(bas);*/
        
    }
 
    ifdebug(8) {  
        fprint_string_Value(stderr," MS = ",ms);
        fprintf(stderr, " \n"); 
    }
 
    vbank = vecteur_var(bank_indices);
    vligne = vecteur_var(bank_indices->succ);
    vofs = vecteur_var(bank_indices->succ->succ);
    sc->base = vect_add_variable(sc->base,vbank);
    sc->base = vect_add_variable(sc->base,vligne);
    sc->base = vect_add_variable(sc->base,vofs);
 
    sc->dimension +=3;
 
    /* bank_indices is assumed to belong the three variables
       bank_id, L and O (see documentation for more details) */
 
    /* if COLUMN_MAJOR is true then build the constraint   
       (VAR1-1) + (VAR2-1) *ms == bn*ls*L +ls*bank_id+O,
       else build the constraint
       (VAR1-1) * ms + (VAR2-1) == bn*ls*L +ls*bank_id+O,
       VAR1 and VAR2 correspond to the image array function indices */
    pv1 = vect_new(vbank,int_to_value(-ls));
    vect_add_elem(&pv1,vligne,int_to_value((-bn*ls)));
    vect_add_elem(&pv1,vofs,VALUE_MONE);
    if (COLUMN_MAJOR)
        pc = sc_array_function->inegalites;
    else pc = sc_array_function->inegalites->succ;
    /* to deal with MONO dimensional array */
    if (pc==NULL) pc= contrainte_make(vect_new(TCST,VALUE_ONE));
    pv2 = vect_dup(pc->vecteur);
    vect_add_elem(&pv2,TCST,VALUE_MONE);
    pv2 = vect_multiply(pv2,int_to_value(nb_bytes));
    pv1 = vect_add(pv1,pv2);
    if (COLUMN_MAJOR)
        pc = pc->succ;
    else pc =  sc_array_function->inegalites;    
    /* to deal with MONO dimensional array */
    if (pc==NULL) pc=  contrainte_make(vect_new(TCST,VALUE_ONE));
    pv2 = vect_dup(pc->vecteur);
    vect_add_elem(&pv2,TCST,VALUE_MONE);
    Value nbv = int_to_value(nb_bytes);
    pv2 = vect_multiply(pv2,value_mult(ms, nbv));
    pv1 = vect_add(pv1,pv2);
    pc = contrainte_make(pv1);
    sc_add_eg(sc,pc);
 
    /* build the constraints 0 <= bank_id <= bn-1 */
 
    pv2 = vect_new(vbank, VALUE_MONE);
    pc = contrainte_make(pv2);
    sc_add_ineg(sc,pc);
    pv2 = vect_new(vbank, VALUE_ONE);
    vect_add_elem(&pv2,TCST,int_to_value(- bn+1));
    pc = contrainte_make(pv2);
    sc_add_ineg(sc,pc);
 
    /* build the constraints 0 <= proc_id <= pn-1 */
    sc->base = vect_add_variable(sc->base,(char *) proc_id);
    sc->dimension++;
    pv2 = vect_new((char *) proc_id, VALUE_MONE);
    pc = contrainte_make(pv2);
    sc_add_ineg(sc,pc);
    pv2 = vect_new((char *) proc_id, VALUE_ONE);
    vect_add_elem(&pv2,TCST,int_to_value(- pn+1));
    pc = contrainte_make(pv2);
    sc_add_ineg(sc,pc);
 
 
    /* build the constraints 0 <= O <= ls -1 */
 
    pv2 = vect_new(vofs, VALUE_MONE);
    pc = contrainte_make(pv2);
    sc_add_ineg(sc,pc);
    pv2 = vect_new(vofs, VALUE_ONE);
    vect_add_elem(&pv2,TCST,int_to_value(- ls +1));
    pc = contrainte_make(pv2);
    sc_add_ineg(sc,pc);
 
 
    /* build the constraints 0 <= L   */
 
    pc = contrainte_make(vect_new(vligne,VALUE_MONE));
    sc_add_ineg(sc,pc);
    ifdebug(8)  {
        (void) fprintf(stderr,"Domain Machine :\n");
        sc_fprint(stderr, sc, (get_variable_name_t) entity_local_name);
    }
    debug(8,"build_sc_machine","end\n");
 
    return(sc);
 
}

References Ssysteme::base, CAR, COLUMN_MAJOR, contrainte_make(), debug(), Ssysteme::dimension, DIMENSION, dimension_lower, dimension_upper, entity_local_name(), entity_type, fprint_string_Value(), fprintf(), ifdebug, Ssysteme::inegalites, int_to_value, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, sc_fprint(), sc_init_with_sc(), Scontrainte::succ, Svecteur::succ, TCST, type_variable, type_variable_p, value_minus, VALUE_MONE, value_mult, VALUE_ONE, value_plus, VALUE_ZERO, variable_dimensions, vect_add(), vect_add_elem(), vect_add_variable(), vect_coeff(), vect_dup(), vect_multiply(), vect_new(), Scontrainte::vecteur, and vecteur_var.

Referenced by sc_image_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

complex_bound_computation()

expression complex_bound_computation	(	Psysteme	,
		Pbase	,
		Pcontrainte	,
		Pcontrainte	,
		int
	)

complex_bound_generation()

expression complex_bound_generation	(	Value	,
		Value	,
		Value	,
		Pvecteur	,
		Variable	,
		Pvecteur	,
		Variable
	)

complex_bound_generation.c

constraint_distribution()

void constraint_distribution	(	Psysteme	sc,
		Psysteme *	bound_systems,
		Pbase	index_base,
		int	sc_info[][4]
	)

Distribution of the constraints of the system sc into several systems.

System sc contains all the contraints having to be used to generate bound expressions for all loop indices.

A new system is defined for each system variable. Each new system defines the set of constraints needed for the generation of loop bound expressions for one variable.

The constraint constraining directly a variable of rank "rank_hr" is added to the system corresponding to the variable "var_hr" except if this variable must not be kept (var_hr is not a loop index). In this last case, the constraint must be combined with another constraint in order to eliminate the variable "var_hr" and to deduce a constraint constrainnig another variable of rank "rank". In that case, the two constraints are added to the system corresponding to the variable "var = variable_of_rank(rank)"

This condition is true if the variable must be kept like loop index. All the constraints constraining directly the variable of rank "rank_hr" are kept in the system bound_systems[rank_hr]

this condition is true if the combination of the two constraints pc1 and pc2 is not redundant for the
system. Then the two constraints are added to the system of the variable of higher rank

Parameters

sc	c
bound_systems	ound_systems
index_base	ndex_base
sc_info	c_info

Definition at line 164 of file constraint_distribution.c.

{
    Pcontrainte pc1,pc2;
    int rank,rank_hr,rank_pc1,rank_pc2;
    Value coeff1,coeff2;
    int sign1,sign2,i;
    Variable var_hr;
    Psysteme sc2 = sc_init_with_sc(sc);
 
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"constraint_distribution","begin\n");
 
 
    for (pc1=sc->inegalites; !CONTRAINTE_UNDEFINED_P(pc1); pc1 = pc1->succ) {
        if ((rank_hr = search_higher_rank(pc1->vecteur,index_base))>0) {
            if (sc_info[rank_hr][1]) {
                /* This condition is true if the variable must be kept like 
                   loop index. All the constraints constraining directly the 
                   variable of rank "rank_hr" are kept in the system 
                   bound_systems[rank_hr] */
 
                insert_ineq_end_sc(bound_systems[rank_hr],pc1);
                insert_ineq_end_sc(sc2,pc1);
            }
            else {
                var_hr = variable_of_rank(index_base,rank_hr);
                rank_pc1 = rank_of_variable
                    (index_base,
                     search_var_of_higher_rank(pc1->vecteur,
                                               index_base,
                                               var_hr));
                
                coeff1 = vect_coeff(var_hr,pc1->vecteur);
                sign1 = value_sign(coeff1);
                for (pc2 = pc1; !CONTRAINTE_UNDEFINED_P(pc2); 
                     pc2= pc2->succ) {
                    coeff2 = vect_coeff(var_hr,pc2->vecteur);
                    sign2 = value_sign(coeff2); 
                    if (value_notzero_p(coeff2) && sign1 == -sign2 
                        && !bound_redund_with_sc_p(sc2,pc1,pc2,var_hr)) {
                        /* this condition is true if the combination of the 
                           two constraints pc1 and pc2 is not redundant for the  
                           system. Then the two constraints are added to the 
                           system of the variable of higher rank */
 
                        Variable var2 = search_var_of_higher_rank(pc2->vecteur,
                                                                  index_base,
                                                                  var_hr);
                        rank_pc2 = rank_of_variable(index_base,var2);
 
                        if (rank_pc1 !=rank_pc2)
                            rank=(rank_pc1 >rank_pc2) ? rank_pc1:rank_pc2;
                        else rank = rank_hr;
                        insert_ineq_end_sc(bound_systems[rank],pc1);
                        insert_ineq_end_sc(bound_systems[rank],pc2);
                        insert_ineq_end_sc(sc2,pc1);
                        insert_ineq_end_sc(sc2,pc2);
                    }   
                }
            }
        }
    }
    ifdebug(8) {
        for (i=1;i<=vect_size(index_base);i++) {
            (void) fprintf(stderr,"Le systeme sur la var. %d est:\n",i);
            sc_fprint(stderr, bound_systems[i], (get_variable_name_t) entity_local_name);
        }
    }
 
    debug(8,"constraint_distribution","end\n");
    debug_off();
}

References bound_redund_with_sc_p(), CONTRAINTE_UNDEFINED_P, debug(), debug_off, debug_on, entity_local_name(), fprintf(), ifdebug, Ssysteme::inegalites, insert_ineq_end_sc(), rank, rank_of_variable(), sc_fprint(), sc_init_with_sc(), search_higher_rank(), search_var_of_higher_rank(), Scontrainte::succ, value_notzero_p, value_sign, variable_of_rank(), vect_coeff(), vect_size(), and Scontrainte::vecteur.

Referenced by movement_computation(), and parallel_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

egalite_distribution()

void egalite_distribution	(	Psysteme	sc,
		Psysteme *	bound_systems,
		Pbase	index_base
	)

Parameters

sc	c
bound_systems	ound_systems
index_base	ndex_base

Definition at line 241 of file constraint_distribution.c.

{
    Pcontrainte pc1;
    int rank;
 
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"egalite_distribution","begin\n");
 
    for (pc1=sc->egalites; !CONTRAINTE_UNDEFINED_P(pc1); pc1 = pc1->succ) {
        if ((rank = search_higher_rank(pc1->vecteur,index_base))>0) {
            sc_add_eg(bound_systems[rank],pc1);
        }
    }
    debug(8,"egalite_distribution","end\n");
    debug_off();
}

References CONTRAINTE_UNDEFINED_P, debug(), debug_off, debug_on, Ssysteme::egalites, rank, search_higher_rank(), Scontrainte::succ, and Scontrainte::vecteur.

Here is the call graph for this function:

elim_redund_sc_with_sc()

Psysteme elim_redund_sc_with_sc	(	Psysteme	sc1,
		Psysteme	sc2,
		Pbase	index_base,
		int	dim
	)

Build the system of inequations of sc1 no-redundant with system sc2.

Parameters

sc1	c1
sc2	c2
index_base	ndex_base
dim	im

Definition at line 262 of file movement_computation.c.

{
    Pcontrainte pc,pc2;
    Psysteme ps1 = sc_init_with_sc(sc1);
    Psysteme ps2 = sc_dup(sc2);
        
    for (pc =sc1->inegalites; pc != NULL;pc = pc->succ) {
 
        pc2 = contrainte_dup(pc);
        if (search_higher_rank(pc2->vecteur,index_base) > dim || 
            !ineq_redund_with_sc_p(ps2,pc2)) {
            pc2 = contrainte_dup(pc);
            sc_add_ineg(ps1,pc2);
            pc2 = contrainte_dup(pc);
            sc_add_ineg(ps2,pc2);
        } 
    }
    ps2 = sc_dup(sc2);
 
    for (pc = ps1->inegalites; pc != NULL;pc = pc->succ) {
        pc2 = contrainte_dup(pc);
        if (search_higher_rank(pc2->vecteur,index_base) > dim || 
            !ineq_redund_with_sc_p(ps2,pc2)) {
            pc2 = contrainte_dup(pc);
            sc_add_ineg(ps2,pc2);
        } 
        else   eq_set_vect_nul(pc);    
    }   
 
    sc_rm_empty_constraints(ps1, false);
    return (ps1);
}

References contrainte_dup(), eq_set_vect_nul(), Ssysteme::inegalites, ineq_redund_with_sc_p(), sc_dup(), sc_init_with_sc(), sc_rm_empty_constraints(), search_higher_rank(), Scontrainte::succ, and Scontrainte::vecteur.

Referenced by movement_computation(), and parallel_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

find_operator()

entity find_operator	(	entity	module,
		string	oper,
		string	str
	)

Parameters

module	odule
oper	per
str	tr

Definition at line 117 of file make_loop_body.c.

{
    entity operator;
    string name =  concatenate(TOP_LEVEL_MODULE_NAME,
                               MODULE_SEP_STRING, 
                               module_local_name(module),
                               "_",oper, "_",str,NULL);
 
    if ((operator = gen_find_tabulated(name, entity_domain))
        == entity_undefined)
        operator=make_entity(strdup(name),
                             make_type(is_type_functional,
                                       make_functional(NIL,
                                                       make_type(is_type_void,
                                                                 UU))),
                             make_storage_rom(),
                             make_value(is_value_unknown,NIL));
    return(operator);
}

References concatenate(), entity_domain, entity_undefined, gen_find_tabulated(), is_type_functional, is_type_void, is_value_unknown, make_entity, make_functional(), make_storage_rom(), make_type(), make_value(), module, module_local_name(), MODULE_SEP_STRING, NIL, strdup(), TOP_LEVEL_MODULE_NAME, and UU.

Referenced by make_datum_movement(), make_movement_scalar_wp65(), and make_movements_loop_body_wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_bounds_to_tile_bounds()

Psysteme loop_bounds_to_tile_bounds	(	Psysteme	loop_bounds,
		Pbase	loop_indices,
		tiling	t,
		Pvecteur	tile_delay,
		Pvecteur	tile_indices,
		Pvecteur	tile_local_indices
	)

this function returns the system of constraints

-------—> --------—> ------—> ---—> --------------—> loop_indices = P (tile_indices - tile_delay) + origin + tile_local_indices

P is the matrice describing the tiling. Its determinant is 1.

mise a jour de la base du systeme de contraintes

build the constraints min (=0) <= lti <= max (=ls-1)

build the constraints 0 <= ti

Parameters

loop_bounds	oop_bounds
loop_indices	oop_indices
tile_delay	ile_delay
tile_indices	ile_indices
tile_local_indices	ile_local_indices

Definition at line 97 of file build_sc_tile.c.

{
    Psysteme sc = sc_dup(loop_bounds);
    matrice P = (matrice) tiling_tile(t);
    Pcontrainte pc;
    Pvecteur li,to,lti,ti,td,pv;
    int n,m,i,j;
    Value min,max,val;
 
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"loop_bounds_to_tile_bounds","begin\n");
 
    /* mise a jour de la base du systeme de contraintes */
    for (li=loop_indices,n=0;!VECTEUR_NUL_P(li);n++,li = li->succ);
    for (ti=tile_indices,m=0;
         !VECTEUR_NUL_P(ti);
         sc->base = vect_add_variable(sc->base,(char *) ti->var),
         sc->dimension++,m++,ti = ti->succ);
    to = (Pvecteur)tiling_origin(t);
    td = tile_delay;
 
    for (i=1,lti =tile_local_indices, li = loop_indices;
         i<=n; 
         i++,
         sc->base = vect_add_variable(sc->base,(Variable) lti->var),
         sc->dimension++,lti = lti->succ,li=li->succ) {
        j=1;
        ti = tile_indices;
        pv = vect_new(vecteur_var(lti),VALUE_ONE);
        vect_add_elem(&pv,vecteur_var(li),VALUE_MONE);
        for (j=1;j<=m; j++,ti = ti->succ) {
            if (value_ne(ACCESS(P,n,i,j),VALUE_CONST(999))) { 
                vect_add_elem(&pv,vecteur_var(ti), ACCESS(P,n,i,j));
                if (value_notzero_p(val = vect_coeff(li->var,td)))
                    vect_add_elem(&pv,TCST,
                        value_uminus(value_mult(val,ACCESS(P,n,i,j))));
            }   else {
                sc_force_variable_to_zero(sc,vecteur_var(ti));
                sc_add_egalite(sc,
                               contrainte_make(vect_new(vecteur_var(ti),
                                                        VALUE_ONE)));
            }
        }
        if (value_notzero_p(val = vect_coeff(li->var,to))) 
            vect_add_elem(&pv,TCST,val);
        pc= contrainte_make(pv);
        sc_add_egalite(sc,pc);
    }
 
    /* build the constraints min (=0) <= lti <= max (=ls-1) */
    for ( j=1,lti= tile_local_indices;
         !VECTEUR_NUL_P(lti) ;
         lti = lti->succ,j++) {
        min = ACCESS(P,n,1,j);
        max = ACCESS(P,n,1,j);
        for (i=1;i<=n;i++) {
            Value a = ACCESS(P,n,i,j);
            value_minimum(min, a);
            value_maximum(max, a);
        }
        pv = vect_new(vecteur_var(lti), VALUE_MONE);
        vect_add_elem(&pv,TCST,VALUE_ZERO);
        pc = contrainte_make(pv);
        sc_add_ineg(sc,pc);
        pv = vect_new(vecteur_var(lti), VALUE_ONE);
        vect_add_elem(&pv,TCST,value_minus(VALUE_ONE, max));
        pc = contrainte_make(pv);
        sc_add_ineg(sc,pc);
    }
 
    /* build the constraints    0 <= ti  */
    for (ti =tile_indices; !VECTEUR_NUL_P(ti); ti = ti->succ) {
        pv = vect_new(vecteur_var(ti), VALUE_MONE);
        pc = contrainte_make(pv);
        sc_add_ineg(sc,pc);
    }
    ifdebug(8) { fprintf(stderr,"TILE SYSTEM:\n");
                 sc_fprint(stderr, sc, (get_variable_name_t) entity_local_name);
    }
    debug(8,"loop_bounds_to_tile_bounds","end\n");
    debug_off();
    return(sc);
}

References ACCESS, Ssysteme::base, contrainte_make(), debug(), debug_off, debug_on, Ssysteme::dimension, entity_local_name(), fprintf(), ifdebug, max, min, sc_add_egalite(), sc_dup(), sc_force_variable_to_zero(), sc_fprint(), Svecteur::succ, TCST, tiling_origin, tiling_tile, VALUE_CONST, value_maximum, value_minimum, value_minus, VALUE_MONE, value_mult, value_ne, value_notzero_p, VALUE_ONE, value_uminus, VALUE_ZERO, Svecteur::var, vect_add_elem(), vect_add_variable(), vect_coeff(), vect_new(), 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:

lower_bound_generation()

expression lower_bound_generation	(	Psysteme	sc_neg,
		Pbase	index_base,
		int	number_of_lower_bounds,
		int	loop_rank
	)

bound_generation.c

bound_generation.c

this condition is true if the constraint constrains directly the variable

In that case the bound expression results from the combination of two constraints. The variable of rank "higher_rank" will be eliminated from these two constraints in order to give only one bound for the "loop_rank" index.

Parameters

sc_neg	c_neg
index_base	ndex_base
number_of_lower_bounds	umber_of_lower_bounds
loop_rank	oop_rank

Definition at line 56 of file bound_generation.c.

{
    Pcontrainte ineq;
    Variable var = variable_of_rank(index_base,loop_rank); 
    Pvecteur pv2 = VECTEUR_NUL; 
    expression expr,ex1,ex2, lower=expression_undefined ;
    cons * lex2,* lexpr = NIL;
    entity max = local_name_to_top_level_entity("MAX");
    int higher_rank,nlb = 0; 
    Value coeff;
    bool reductible = false;
 
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"lower_bound_generation","begin\n");
 
    if (number_of_lower_bounds>=1) {
        for (ineq = sc_neg->inegalites; 
             !CONTRAINTE_UNDEFINED_P(ineq); 
             ineq=ineq->succ) {
            Variable var2;
            Value coeff2,coeff3;
            reductible = false;
            higher_rank=search_higher_rank(ineq->vecteur,index_base);
            if (higher_rank > loop_rank ) {
                Pcontrainte pc2 = ineq->succ;
                var2 = variable_of_rank(index_base,higher_rank);
                coeff2 = vect_coeff(var2,ineq->vecteur);
                coeff3 = vect_coeff(var2,pc2->vecteur);
                
                if (value_one_p(value_abs(coeff2)) || 
                    value_one_p(value_abs(coeff3))) {
                    reductible = true;
                    pv2 = vect_cl2(value_abs(coeff2),pc2->vecteur,
                                   value_abs(coeff3),ineq->vecteur);
                    ineq= ineq->succ;
                }
            }
            else pv2 = vect_dup(ineq->vecteur);
            if (higher_rank <= loop_rank || reductible ) {  
                /* this condition is true if the constraint constrains 
                   directly the variable */
                if (value_notmone_p(coeff= vect_coeff(var,pv2)))
                    vect_add_elem(&pv2, TCST,
                                  value_uminus(value_plus(coeff, VALUE_ONE)));
                vect_chg_coeff(&pv2,var,VALUE_ZERO);
                expr = ex1 = make_vecteur_expression(pv2);
                if (value_notmone_p(coeff)) {
                    ex2 = int_to_expression(
                        VALUE_TO_INT(value_abs(coeff)));
                    lex2 =CONS(EXPRESSION,ex2,NIL);
                    expr=make_div_expression(ex1,lex2);
                    vect_add_elem(&pv2,TCST,value_plus(coeff,VALUE_ONE));
                }
            }
            else {                              
                /* In that case the bound expression results from 
                   the  combination of two constraints. The variable of 
                   rank "higher_rank" will be eliminated from these two 
                   constraints in order to give only one bound for 
                   the "loop_rank" index. */
                expr = complex_bound_computation(sc_neg,index_base,
                                                 ineq,ineq->succ,
                                                 higher_rank);
                ineq = ineq->succ;
 
            }
            lexpr = CONS(EXPRESSION, expr,lexpr);
            nlb ++;
        }
        if (nlb > 1)
            lower = make_op_expression(max,lexpr);
        else lower = EXPRESSION(CAR(lexpr));
    }
    debug(8,"lower_bound_generation","end\n");
    debug_off();
 
    return(lower);
}

References CAR, complex_bound_computation(), CONS, CONTRAINTE_UNDEFINED_P, debug(), debug_off, debug_on, EXPRESSION, expression_undefined, Ssysteme::inegalites, int_to_expression(), local_name_to_top_level_entity(), make_div_expression(), make_op_expression(), make_vecteur_expression(), max, NIL, search_higher_rank(), Scontrainte::succ, TCST, value_abs, value_notmone_p, VALUE_ONE, value_one_p, value_plus, VALUE_TO_INT, value_uminus, VALUE_ZERO, variable_of_rank(), vect_add_elem(), vect_chg_coeff(), vect_cl2(), vect_coeff(), vect_dup(), Scontrainte::vecteur, and VECTEUR_NUL.

Referenced by bound_generation(), and make_movements_loop_body_wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

make_datum_movement()

statement make_datum_movement	(	entity	module,
		bool	receive_code,
		entity	ent,
		Pbase	local_indices,
		Pbase	var_id
	)

statement make_datum_movement(module,receive_code,ent, local_indices,var_id)

This function generates the loop body of the movement code. In the case of bank code generation the loop body must be :

BANK_/WP65_ send/receive_nb_bytes(ES_A,O,1,L,Prod_id) ES_A is the emulated shared variable given as entity ent. Prod_id is the Processeur id. given as a Pvecteur in var_id. O and L are the local indices for the bank passed like Pbase in local_indices.

In the case of engine code generation the loop body must be :

BANK_/WP65_send/receive_nb_bytes(L_A,LI,1,LJ,Bank_id)

L_A is the local variable given as entity in ent. Bank_id is the bank id, given as Pvecteur in var_id. LJ, and LI are the local indices passed like Pbase in local_indices corresponds to the Pvecteur belonging Prod_id if bank_code and Bank_id otherwise

build the list of expressions : Prod_id,ES_A(L,O),1 for bank case and Bank_id,L_A(LJ,LI),1 for engine case

generate the send or the receive call

Parameters

module	odule
receive_code	eceive_code
ent	This function generates the loop body of the movement code. In the case of bank code generation the loop body must be :

BANK_/WP65_ send/receive_nb_bytes(ES_A,O,1,L,Prod_id) ES_A is the emulated shared variable given as entity ent. Prod_id is the Processeur id. given as a Pvecteur in var_id. O and L are the local indices for the bank passed like Pbase in local_indices.

In the case of engine code generation the loop body must be :

BANK_/WP65_send/receive_nb_bytes(L_A,LI,1,LJ,Bank_id)

L_A is the local variable given as entity in ent. Bank_id is the bank id, given as Pvecteur in var_id. LJ, and LI are the local indices passed like Pbase in local_indices is true if the code is generated for receive

Parameters

local_indices

This function generates the loop body of the movement code. In the case of bank code generation the loop body must be :

BANK_/WP65_ send/receive_nb_bytes(ES_A,O,1,L,Prod_id) ES_A is the emulated shared variable given as entity ent. Prod_id is the Processeur id. given as a Pvecteur in var_id. O and L are the local indices for the bank passed like Pbase in local_indices.

In the case of engine code generation the loop body must be :

BANK_/WP65_send/receive_nb_bytes(L_A,LI,1,LJ,Bank_id)

L_A is the local variable given as entity in ent. Bank_id is the bank id, given as Pvecteur in var_id. LJ, and LI are the local indices passed like Pbase in local_indices corresponds to the shared entiy if bank_code and to the local entity otherwise

Parameters

var_id

This function generates the loop body of the movement code. In the case of bank code generation the loop body must be :

BANK_/WP65_ send/receive_nb_bytes(ES_A,O,1,L,Prod_id) ES_A is the emulated shared variable given as entity ent. Prod_id is the Processeur id. given as a Pvecteur in var_id. O and L are the local indices for the bank passed like Pbase in local_indices.

In the case of engine code generation the loop body must be :

BANK_/WP65_send/receive_nb_bytes(L_A,LI,1,LJ,Bank_id)

L_A is the local variable given as entity in ent. Bank_id is the bank id, given as Pvecteur in var_id. LJ, and LI are the local indices passed like Pbase in local_indices correspond to O,L if bank_code and to LJ,LI otherwise

Definition at line 401 of file make_loop_body.c.

{
 
    expression exp_ent;
    statement lbody;
    Pvecteur ofs = local_indices;
    Pvecteur pvt =VECTEUR_NUL;
    entity operator_receive,operator_send; 
    cons * args, * args2;
    type tp = entity_type(ent);
    int nb_bytes = 0;
    char *str1;
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"make_datum_movement","begin\n");
 
    if (type_variable_p(tp)) {
        variable var = type_variable(tp);
        basic b = variable_basic(var);
        nb_bytes = SizeOfElements(b);
    }
 
    str1=int2a(nb_bytes);
    operator_receive = find_operator(module, "RECEIVE",str1);
    operator_send = find_operator(module,"SEND",str1);
    free(str1);
  
    /* build the list of expressions :
       Prod_id,ES_A(L,O),1  for bank case and
       Bank_id,L_A(LJ,LI),1 for engine case
       */
 
    args = CONS(EXPRESSION,int_to_expression(1),NIL);
    pvt =(!VECTEUR_NUL_P(ofs->succ))  ?
        vect_add(vect_new(vecteur_var(ofs->succ),VALUE_ONE),
                 vect_new(TCST,offset_dim2)):
                     vect_new(TCST,offset_dim2);
 
   args2 = CONS(EXPRESSION,make_vecteur_expression(pvt),NIL);
    pvt =vect_new(vecteur_var(ofs),VALUE_ONE);
    vect_add_elem(&pvt,TCST,offset_dim1);
    args2 = CONS(EXPRESSION,make_vecteur_expression(pvt),
                 args2);
 
    exp_ent = make_expression(make_syntax(is_syntax_reference,
                                          make_reference(ent,
                                                         args2
                                                         )),
                              normalized_undefined);    
 
    args = CONS(EXPRESSION,exp_ent,args);
    args = CONS(EXPRESSION,make_vecteur_expression(vect_dup(var_id)),args);
    /* generate the send or the receive call */
 
    lbody = (receive_code) ?
        make_statement_operator(operator_receive,args):
            make_statement_operator(operator_send,args);
        
    debug(8,"make_datum_movement","end\n");
    debug_off();
    return (lbody);
 
}

References CONS, debug(), debug_off, debug_on, entity_type, EXPRESSION, find_operator(), free(), int2a(), int_to_expression(), is_syntax_reference, make_expression(), make_reference(), make_statement_operator(), make_syntax(), make_vecteur_expression(), module, NIL, normalized_undefined, offset_dim1, offset_dim2, SizeOfElements(), Svecteur::succ, TCST, type_variable, type_variable_p, VALUE_ONE, variable_basic, vect_add(), vect_add_elem(), vect_dup(), vect_new(), VECTEUR_NUL, VECTEUR_NUL_P, and vecteur_var.

Referenced by bound_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

make_div_expression()

expression make_div_expression	(	expression	ex1,
		cons *	ex2
	)

operation.c

Parameters

ex1	x1
ex2	x2

Definition at line 42 of file operation.c.

{ 
    entity div = local_name_to_top_level_entity("idiv");
 
    return(make_expression(
                           make_syntax(is_syntax_call,
                                       make_call(div,
                                                 CONS(EXPRESSION,
                                                      ex1,ex2))
                                       ),normalized_undefined));
}

References CONS, EXPRESSION, is_syntax_call, local_name_to_top_level_entity(), make_call(), make_expression(), make_syntax(), and normalized_undefined.

Referenced by array_indices_communication(), complex_bound_generation(), lower_bound_generation(), test_bound_generation(), and upper_bound_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

make_loop_indice_equation()

Pvecteur make_loop_indice_equation	(	Pbase	loop_indices,
		tiling	tile,
		Pvecteur	tile_delay,
		Pvecteur	tile_indices,
		Pvecteur	tile_local_indices,
		int	rank
	)

build_sc_tile.c

build_sc_tile.c

Corinne Ancourt - septembre 1991

Parameters

loop_indices	oop_indices
tile	ile
tile_delay	ile_delay
tile_indices	ile_indices
tile_local_indices	ile_local_indices
rank	ank

Definition at line 51 of file build_sc_tile.c.

{ 
    matrice P= (matrice) tiling_tile(tile);
     Pvecteur to = (Pvecteur)tiling_origin(tile);
    Pvecteur pv; 
    Pvecteur lti,li,ti= tile_indices;
    int m = vect_size(loop_indices); 
    int n= m;
    int i,j;
    Value val;
    for (i=1,lti =tile_local_indices, li = loop_indices; i<rank;
         lti =lti->succ,li= li->succ, i++);
    pv = vect_make(NULL,vecteur_var(lti),VALUE_ONE,TCST,VALUE_ZERO);
 
    for (j=1;j<=m; j++,ti = ti->succ) {
        if (value_ne(ACCESS(P,n,i,j),VALUE_CONST(999))) { 
            vect_add_elem(&pv,vecteur_var(ti), ACCESS(P,n,i,j));
            if (value_notzero_p(val = vect_coeff(li->var, tile_delay)))
                vect_add_elem(&pv,TCST,
                              value_uminus(value_mult(val,ACCESS(P,n,i,j))));
        } 
    }
    if (value_notzero_p(val = vect_coeff(li->var,to)))
        vect_add_elem(&pv,TCST,val);
    ifdebug(8) {
        fprintf(stderr, "Equation defining the tiling\n");
        vect_dump(pv);
    }
    return(pv);
}

References ACCESS, fprintf(), ifdebug, rank, Svecteur::succ, TCST, tiling_origin, tiling_tile, VALUE_CONST, value_mult, value_ne, value_notzero_p, VALUE_ONE, value_uminus, VALUE_ZERO, Svecteur::var, vect_add_elem(), vect_coeff(), vect_dump(), vect_make(), vect_size(), and vecteur_var.

Referenced by array_indices_communication(), and reference_conversion_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

make_movement_scalar_wp65()

statement make_movement_scalar_wp65	(	entity	module,
		bool	receive_code,
		reference	r,
		entity	var_id
	)

statement make_movement_scalar_wp65(receive_code,r)

This function generates the loop body of the movement code. In the case of bank code generation the loop body must be :

call BANK_/WP65_send/receive_nb_bytes(S)

In the case of engine code generation the loop body must be :

call BANK_/WP65_send/receive_nb_bytes(S)

where nb_bytes is the number of bytes needed for the variable location

nb_bytes is the number of bytes needed for the variable location

build the expression : S

args = CONS(EXPRESSION,int_expr(nb_bytes),NIL);

generate the send or the receive call

Parameters

module	odule
receive_code	eceive_code
r	This function generates the loop body of the movement code. In the case of bank code generation the loop body must be : call BANK_/WP65_send/receive_nb_bytes(S) In the case of engine code generation the loop body must be : call BANK_/WP65_send/receive_nb_bytes(S) where nb_bytes is the number of bytes needed for the variable location is true if the code is generated for receive
var_id	This function generates the loop body of the movement code. In the case of bank code generation the loop body must be : call BANK_/WP65_send/receive_nb_bytes(S) In the case of engine code generation the loop body must be : call BANK_/WP65_send/receive_nb_bytes(S) where nb_bytes is the number of bytes needed for the variable location corresponds to scalaire entity

Definition at line 485 of file make_loop_body.c.

{
 
    statement lbody;
    cons * args;
    expression expr;
    list lexp1;
    entity
        operator_receive, operator_send,
        var = reference_variable(r); 
    type t;
    int nb_bytes=4;             /* nb_bytes is the number of bytes
                                   needed for the variable location  */
    basic bas;
    char *str1;
 
    debug_on("MOVEMENT_DEBUG_LEVEL");
    pips_debug(8, "begin\n");
    pips_debug(8, "considering %s\n", entity_local_name(var));
 
    t = entity_type(var);
 
    if (type_variable_p(t)) {
        variable var = type_variable(t);
        bas = variable_basic(var);
        nb_bytes = SizeOfElements(bas);
    }
    str1=int2a(nb_bytes);
    operator_receive = find_operator(module, "RECEIVE",str1);
    operator_send = find_operator(module,"SEND",str1);
    free(str1);
  
    /* build the  expression :     S    */
    /*    args = CONS(EXPRESSION,int_expr(nb_bytes),NIL);*/
 
    lexp1= CONS(EXPRESSION,int_to_expression(1),NIL);
    expr = make_expression(make_syntax(is_syntax_reference,r
                                       ),normalized_undefined);
    args = CONS(EXPRESSION,expr,lexp1);
    args = CONS(EXPRESSION,
                make_vecteur_expression(vect_new((Variable)var_id,
                                                 VALUE_ONE)),args);
    /* generate the send or the receive call */
 
    lbody =  (receive_code) ?
        make_statement_operator(operator_receive,args):
            make_statement_operator(operator_send,args);
    ifdebug(9) {
        pips_debug(9, "returning :\n");
        wp65_debug_print_text(entity_undefined, lbody);
    }
 
    pips_debug(8,"end\n");
    debug_off();
    return (lbody);
 
}

References CONS, debug_off, debug_on, entity_local_name(), entity_type, entity_undefined, EXPRESSION, find_operator(), free(), ifdebug, int2a(), int_to_expression(), is_syntax_reference, make_expression(), make_statement_operator(), make_syntax(), make_vecteur_expression(), module, NIL, normalized_undefined, pips_debug, reference_variable, SizeOfElements(), type_variable, type_variable_p, VALUE_ONE, variable_basic, vect_new(), and wp65_debug_print_text().

Referenced by constant_symbolic_communication(), make_load_blocks(), and make_store_blocks().

Here is the call graph for this function:

Here is the caller graph for this function:

make_movements_loop_body_wp65()

statement make_movements_loop_body_wp65	(	entity	module,
		bool	receive_code,
		entity	ent,
		Pbase	local_indices,
		Pbase	var_id,
		Psysteme	sc_neg,
		Psysteme	sc_pos,
		Pbase	index_base,
		int	rank,
		int	number_of_lower_bounds,
		int	number_of_upper_bounds
	)

statement make_movements_loop_body_wp65(module,receive_code, ent,local_indices,var_id, sc_neg,sc_pos,index_base,rank, number_of_lower_bounds, number_of_upper_bounds)

This function generates the loop body of the movement code. In the case of bank code generation the loop body must be :

O1 = .....
O2 = .....
IF (O1.LE.O2) THEN
BANK_/WP65_send/receive_nb_bytes(Prod_id,ES_A(L,O1),O2-O1+1)

ES_A is the emulated shared variable given as entity ent. Prod_id is the Processeur id. given as a Pvecteur in var_id. O and L are the local indices for the bank passed like Pbase in local_indices.

In the case of engine code generation the loop body must be :

LI1 = .... LI2 = .... IF (LI1.LE.LI2) THEN BANK_/WP65_send/receive_nb_bytes(Bank_id,L_A(LJ,LI1),LI2-LI1+1) L_A is the local variable given as entity in ent. Bank_id is the bank id, given as Pvecteur in var_id. LJ, and LI are the local indices passed like Pbase in local_indices

create the new indices new_ind1 et new_ind2 corresponding to LI1 et LI2 when the code is generated for engines and O1 et O2 when code is generated for banks vecteur_var(ofs) is respectivly LI or O

build the expression new_ind2 - new_ind1+1

build the list of expressions : Prod_id,ES_A(L,O1),O2-O1+1 for bank case and Bank_id,L_A(LJ,LI1),LI2-LI1+1 for engine case

generate the send or the receive call

build the test around stat

if (pmin == INT_MIN || pmax == INT_MAX || pmax > pmin) {

}

build the whole code:

O1 = ..... O2 = ..... IF (O1.LE.O2) THEN BANK_/WP65_send/receive(Prod_id,ES_A(L,O1),O2-O1+1) for bank case or: LI1 = .... LI2 = .... IF (LI1.LE.LI2) THEN BANK_/WP65_send/receive(Bank_id,L_A(LJ,LI1),LI2-LI1+1) for engine case

Parameters

module	odule
receive_code	eceive_code
ent	This function generates the loop body of the movement code. In the case of bank code generation the loop body must be : O1 = ..... O2 = ..... IF (O1.LE.O2) THEN BANK_/WP65_send/receive_nb_bytes(Prod_id,ES_A(L,O1),O2-O1+1) ES_A is the emulated shared variable given as entity ent. Prod_id is the Processeur id. given as a Pvecteur in var_id. O and L are the local indices for the bank passed like Pbase in local_indices.

In the case of engine code generation the loop body must be :

LI1 = .... LI2 = .... IF (LI1.LE.LI2) THEN BANK_/WP65_send/receive_nb_bytes(Bank_id,L_A(LJ,LI1),LI2-LI1+1) L_A is the local variable given as entity in ent. Bank_id is the bank id, given as Pvecteur in var_id. LJ, and LI are the local indices passed like Pbase in local_indices is true if the code is generated for receive

Parameters

local_indices

This function generates the loop body of the movement code. In the case of bank code generation the loop body must be : O1 = ..... O2 = ..... IF (O1.LE.O2) THEN BANK_/WP65_send/receive_nb_bytes(Prod_id,ES_A(L,O1),O2-O1+1) ES_A is the emulated shared variable given as entity ent. Prod_id is the Processeur id. given as a Pvecteur in var_id. O and L are the local indices for the bank passed like Pbase in local_indices.

In the case of engine code generation the loop body must be :

LI1 = .... LI2 = .... IF (LI1.LE.LI2) THEN BANK_/WP65_send/receive_nb_bytes(Bank_id,L_A(LJ,LI1),LI2-LI1+1) L_A is the local variable given as entity in ent. Bank_id is the bank id, given as Pvecteur in var_id. LJ, and LI are the local indices passed like Pbase in local_indices corresponds to the shared entiy if bank_code and to the local entity otherwise

Parameters

var_id

This function generates the loop body of the movement code. In the case of bank code generation the loop body must be : O1 = ..... O2 = ..... IF (O1.LE.O2) THEN BANK_/WP65_send/receive_nb_bytes(Prod_id,ES_A(L,O1),O2-O1+1) ES_A is the emulated shared variable given as entity ent. Prod_id is the Processeur id. given as a Pvecteur in var_id. O and L are the local indices for the bank passed like Pbase in local_indices.

In the case of engine code generation the loop body must be :

LI1 = .... LI2 = .... IF (LI1.LE.LI2) THEN BANK_/WP65_send/receive_nb_bytes(Bank_id,L_A(LJ,LI1),LI2-LI1+1) L_A is the local variable given as entity in ent. Bank_id is the bank id, given as Pvecteur in var_id. LJ, and LI are the local indices passed like Pbase in local_indices correspond to O,L if bank_code and to LI,LJ otherwise

Parameters

sc_neg

This function generates the loop body of the movement code. In the case of bank code generation the loop body must be : O1 = ..... O2 = ..... IF (O1.LE.O2) THEN BANK_/WP65_send/receive_nb_bytes(Prod_id,ES_A(L,O1),O2-O1+1) ES_A is the emulated shared variable given as entity ent. Prod_id is the Processeur id. given as a Pvecteur in var_id. O and L are the local indices for the bank passed like Pbase in local_indices.

In the case of engine code generation the loop body must be :

LI1 = .... LI2 = .... IF (LI1.LE.LI2) THEN BANK_/WP65_send/receive_nb_bytes(Bank_id,L_A(LJ,LI1),LI2-LI1+1) L_A is the local variable given as entity in ent. Bank_id is the bank id, given as Pvecteur in var_id. LJ, and LI are the local indices passed like Pbase in local_indices corresponds to the Pvecteur belonging Prod_id if bank_code and Bank_id otherwise

Parameters

sc_pos	c_pos
index_base	ndex_base
rank	ank
number_of_lower_bounds	umber_of_lower_bounds
number_of_upper_bounds	umber_of_upper_bounds

Definition at line 182 of file make_loop_body.c.

{
    expression lower_bound,upper_bound;
    expression expr_ind1,expr_ind2,expr,expr2,exp_ent,expr_cond;
    entity new_ind1,new_ind2, mod;
    entity operator_assign,operator_minus,operator_plus,operator_le,
    operator_receive,operator_send;
    string lower_or_equal;
    statement stat,stat1,stat2,lbody;
    Pvecteur  pvt,ofs = local_indices;
    type tp = entity_type(ent);
    Value  pmin,pmax;
    int nb_bytes = 0;
    text t; 
    test test1;
     cons * args, * args2, * lex2, * lex3;
    char *str1;
    Psysteme sctmp=NULL;
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"make_movements_loop_body_wp65","begin\n");
 
    operator_assign=
        gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                                                ASSIGN_OPERATOR_NAME ),
                           entity_domain);
 
    operator_minus=
        gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                                                MINUS_OPERATOR_NAME ),
                           entity_domain);
    operator_plus=
        gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                                                PLUS_OPERATOR_NAME ),
                           entity_domain);
 
    if (type_variable_p(tp)) {
        variable var = type_variable(tp);
        basic b = variable_basic(var);
        nb_bytes = SizeOfElements(b);
    }
 
    str1=int2a(nb_bytes);
    operator_receive = find_operator(module, "RECEIVE",str1);
    operator_send = find_operator(module,"SEND",str1);
    free(str1);
  
    ofs = local_indices;
 
    /* create the new indices new_ind1 et new_ind2 corresponding to
       LI1 et LI2 when the code is generated for engines
       and O1 et O2 when code is generated for banks
       vecteur_var(ofs) is respectivly LI or O  */
 
 
 
    new_ind1 = find_entity(module, ofs,SUFFIX_FOR_TEMP_VAR1_IN_INNER_LOOP);
    expr_ind1 = make_vecteur_expression(vect_new((char *) new_ind1,
                                                 vecteur_val(ofs)));
 
    new_ind2=  find_entity(module, ofs,SUFFIX_FOR_TEMP_VAR2_IN_INNER_LOOP);
    expr_ind2 = make_vecteur_expression(vect_new((char *) new_ind2,
                                                 vecteur_val(ofs)));
 
    /* build the expression     new_ind2 - new_ind1+1 */
 
    lex2 = CONS(EXPRESSION,expr_ind1,NIL);
    expr = make_op_expression(operator_minus,
                              CONS(EXPRESSION,expr_ind2,lex2));
 
    lex2 = CONS(EXPRESSION,int_to_expression(1),NIL);
    expr2 = make_op_expression(operator_plus,
                               CONS(EXPRESSION,expr,lex2));
 
    /* build the list of expressions :
       Prod_id,ES_A(L,O1),O2-O1+1  for bank case and
       Bank_id,L_A(LJ,LI1),LI2-LI1+1 for engine case
      
       */
 
    args = CONS(EXPRESSION,expr2,NIL);;
    pvt =vect_new((char *) new_ind1, vecteur_val(ofs));
    vect_add_elem(&pvt,TCST,offset_dim1);
 
    expr_ind1 = make_vecteur_expression(pvt);   
 
    pvt =(!VECTEUR_NUL_P(ofs->succ))  ?
        vect_add(vect_new(vecteur_var(ofs->succ), VALUE_ONE),
                 vect_new(TCST,offset_dim2)):
                     vect_new(TCST,offset_dim2);
    args2 = CONS(EXPRESSION,
                 make_vecteur_expression(pvt),
                 NIL);
    args2 = CONS(EXPRESSION,expr_ind1,args2);
    exp_ent = make_expression(make_syntax(is_syntax_reference,
                                          make_reference(ent,
                                                         args2
                                                         )),
                              normalized_undefined);
    args = CONS(EXPRESSION,exp_ent,args);
    args = CONS(EXPRESSION,make_vecteur_expression(vect_dup(var_id)),args);
 
    /* generate the send or the receive call */
 
    stat =(receive_code) ? make_statement_operator(operator_receive,args)
        : make_statement_operator(operator_send,args);
 
    /* build the test around stat */
 
    sctmp = sc_dup(sc_pos);
    sctmp = sc_append(sctmp,sc_neg);
 
 
    (void)sc_minmax_of_variable(sctmp, vecteur_var(ofs), &pmin, &pmax);
    ifdebug(4) {
        fprint_string_Value(stderr, "borne min ", pmin);
        fprint_string_Value(stderr, ", borne sup ", pmax);
        fprintf(stderr,"\n");
    }
    /* if (pmin == INT_MIN || pmax == INT_MAX || pmax > pmin) { */
        new_ind1=find_entity(module, ofs,SUFFIX_FOR_TEMP_VAR1_IN_INNER_LOOP);
 
        expr_ind1 = make_vecteur_expression(vect_new((char *) new_ind1,
                                                     vecteur_val(ofs)));
 
        new_ind2= find_entity(module,ofs,SUFFIX_FOR_TEMP_VAR2_IN_INNER_LOOP);
        expr_ind2 = make_vecteur_expression(vect_new((char *) new_ind2,
                                                     vecteur_val(ofs)));
 
 
        lower_or_equal = concatenate(TOP_LEVEL_MODULE_NAME,
                                     MODULE_SEP_STRING,".LE.", NULL);
 
        if ((operator_le =
             gen_find_tabulated(lower_or_equal, entity_domain))
            == entity_undefined)
            operator_le = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,
                                             lower_or_equal);
        expr_cond = MakeBinaryCall(operator_le,expr_ind1,expr_ind2);
 
        test1 =  make_test(expr_cond,stat,make_continue_statement(entity_empty_label()));
        stat = test_to_statement(test1);
    /*    }*/
    /* build the whole code:
 
       O1 = .....
       O2 = .....
       IF (O1.LE.O2) THEN
       BANK_/WP65_send/receive(Prod_id,ES_A(L,O1),O2-O1+1)  for bank case
       or:
       LI1 = ....
       LI2 = ....
       IF (LI1.LE.LI2) THEN
       BANK_/WP65_send/receive(Bank_id,L_A(LJ,LI1),LI2-LI1+1) for engine case        */
    expr_ind1 = make_vecteur_expression(vect_new((char *) new_ind1,
                                                 vecteur_val(ofs)));
    expr_ind2 = make_vecteur_expression(vect_new((char *) new_ind2,
                                                 vecteur_val(ofs)));
    lower_bound = lower_bound_generation(sc_neg,index_base,
                                         number_of_lower_bounds,
                                         rank);
    lex2 = CONS(EXPRESSION,lower_bound,NIL);
    stat1 = make_statement_operator(operator_assign,
                                    CONS(EXPRESSION,expr_ind1,lex2));
 
    upper_bound = upper_bound_generation(sc_pos,index_base,
                                         number_of_upper_bounds,
                                         rank);
 
    lex2 =  CONS(EXPRESSION,upper_bound,NIL);
    stat2 = make_statement_operator(operator_assign,
                                    CONS(EXPRESSION,expr_ind2,lex2));
    lex2 = CONS(STATEMENT,stat,NIL);
    lex3 = CONS(STATEMENT,stat2,lex2);
 
    lbody = make_block_statement(CONS(STATEMENT,stat1,lex3));
    ifdebug(8) {
        mod = local_name_to_top_level_entity(entity_local_name(module));
        t = Text_Statement(mod, 2, lbody);
        print_text(stderr,t);
    }
    debug(8,"make_movements_loop_body_wp65","end\n");
    debug_off();
 
 
    return (lbody);
 
}

References ASSIGN_OPERATOR_NAME, concatenate(), CONS, debug(), debug_off, debug_on, entity_domain, entity_empty_label(), entity_local_name(), entity_type, entity_undefined, EXPRESSION, find_entity(), find_operator(), FindOrCreateEntity(), fprint_string_Value(), fprintf(), free(), gen_find_tabulated(), ifdebug, int2a(), int_to_expression(), is_syntax_reference, local_name_to_top_level_entity(), lower_bound_generation(), make_block_statement(), make_continue_statement(), make_entity_fullname(), make_expression(), make_op_expression(), make_reference(), make_statement_operator(), make_syntax(), make_test(), make_vecteur_expression(), MakeBinaryCall(), MINUS_OPERATOR_NAME, module, MODULE_SEP_STRING, NIL, normalized_undefined, offset_dim1, offset_dim2, PLUS_OPERATOR_NAME, print_text(), rank, sc_append(), sc_dup(), sc_minmax_of_variable(), SizeOfElements(), STATEMENT, Svecteur::succ, SUFFIX_FOR_TEMP_VAR1_IN_INNER_LOOP, SUFFIX_FOR_TEMP_VAR2_IN_INNER_LOOP, TCST, test_to_statement, Text_Statement(), TOP_LEVEL_MODULE_NAME, type_variable, type_variable_p, upper_bound_generation(), VALUE_ONE, variable_basic, vect_add(), vect_add_elem(), vect_dup(), vect_new(), VECTEUR_NUL_P, vecteur_val, and vecteur_var.

Referenced by bound_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

make_op_expression()

expression make_op_expression	(	entity	op,
		cons *	ex2
	)

Parameters

op	p
ex2	x2

Definition at line 55 of file operation.c.

{
 return(make_expression(make_syntax(is_syntax_call,
                                    make_call(op,ex2)), 
                        normalized_undefined));
}

References is_syntax_call, make_call(), make_expression(), make_syntax(), and normalized_undefined.

Referenced by complex_bound_generation(), lower_bound_generation(), make_movements_loop_body_wp65(), test_bound_generation(), and upper_bound_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

make_statement_operator()

statement make_statement_operator	(	entity	oper,
		cons *	args
	)

Parameters

oper	per
args	rgs

Definition at line 138 of file make_loop_body.c.

{
  return  make_statement (entity_empty_label(),
                          STATEMENT_NUMBER_UNDEFINED,
                          STATEMENT_ORDERING_UNDEFINED,
                          string_undefined,
                          make_instruction(is_instruction_call,
                                           make_call (oper, args)),
                          NIL,
                          NULL,
                          empty_extensions (), make_synchronization_none());
}

References empty_extensions(), entity_empty_label(), is_instruction_call, make_call(), make_instruction(), make_statement(), make_synchronization_none(), NIL, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, and string_undefined.

Referenced by make_datum_movement(), make_movement_scalar_wp65(), and make_movements_loop_body_wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

movement_computation()

statement movement_computation	(	entity	module,
		bool	used_def,
		bool	bank_code,
		bool	receive_code,
		entity	private_entity,
		Psysteme	sc_image,
		Pbase	const_base,
		Pbase	bank_indices,
		Pbase	tile_indices,
		Pbase	ppid,
		Pbase	loop_body_indices,
		int	n,
		int	dim_h
	)

Calcul des nouvelles bornes des boucles et de la nouvelle fonction d'acces a une reference d'un tableau permettant d'exprimer l'ensemble des elements references dans une base.

Cette base est pour le moment la base de Hermite associee a la fonction d'acces au tableau

constains the list of variables for which integer projection might be necessary

constains the variables remaining in the system after all the projections i.e. constants, index loops. It is usefull to project (FM) on these variables at the end for collecting more informations on variables and to eliminate redundant constraints

corresponds to the loop indices of the generated code. Then it is Bank_id, LJ,L,LI in case of engine code and Bank_id, LJ,L,O in case of bank code

contains the local indices O and L if it is the generation of bank code and LI, LJ if it is for engine code

int sc_info[sc_image->dimension+1][3]; // this is NOT ANSI C

added

Translate each entity in its appropriated entity full name for generating module code

allocation d'un tableau de systemes et d'une table contenant des infos sur ces systemes

update the different basis

Projection on each variable having unity coefficients in the system

Projection on the others variables having to be eliminated from the system. In case of Copy-in local memory code generation, the FM projection algorithm is used. For Copy-back code generation interger projection algorithm is used.

vect_chg_coeff(&lvar_coeff_nunit,vecteur_var(pv1),0);

Computation of sample constraints contraining only index variables

why 11?

ore restrictive system

Elimination of redundant constraints for integer systems

Constraints distribution. Lsc[i] will contain all constraints contraining the i-th index variable

Computation of constraints contraining symbolic constants

Elimination of constraints redundant in list_of_systems[i] with the "symbolic constant system"

if you get through this pp, it core dumps much later on:-)

Parameters

module	odule
used_def	sed_def
bank_code	ank_code
receive_code	is true if it is the generation of code for bank false if it is for engine
private_entity	is true if the generated code must be a RECEIVE, false if it must be a SEND
sc_image	local entity
const_base	domain of image
bank_indices	ank_indices
tile_indices	contains the index describing the bank: bank_id, L (ligne of bank) and O (offset in the ligne)
ppid	contains the local indices LI, LJ,.. of tile
loop_body_indices	oop_body_indices
n	contains the loop indices situated in the tile
dim_h	im_h

Definition at line 321 of file movement_computation.c.

{
    Psysteme    sc_proj,*list_of_systems,sc_proj2,sc_image2,sc_on_constants;
    statement  stat = statement_undefined;
    Pvecteur lvar_coeff_nunit = VECTEUR_NUL; 
    /* constains the list of variables for which integer projection 
       might be necessary */
    Pvecteur lvar_coeff_unit= VECTEUR_NUL;
 
    Pbase lindex = BASE_NULLE;          
    /* constains the variables remaining in the system after all the 
       projections i.e. constants, index loops. It is usefull to project (FM)
       on  these variables at the end for collecting more  informations on 
       variables and to eliminate redundant constraints */
  
    Pbase image_base=BASE_NULLE;        
    /* corresponds to the loop indices of the generated code. Then it is 
       Bank_id, LJ,L,LI in case of engine code 
       and Bank_id, LJ,L,O in case of bank code */
  
 
    Pbase loop_body_offsets;            
    /* contains the local indices O and L if it is the generation of bank 
       code and LI, LJ if it is for engine code */
 
    Pbase index_base=BASE_NULLE;
    Pbase const_base2;
    Pbase var_id;
    int dim_h2= dim_h;
    unsigned    space;
#define maxscinfosize 100
    /* int sc_info[sc_image->dimension+1][3]; // this is NOT ANSI C */
    int sc_info[maxscinfosize][4];
    int i;
    Pvecteur pv1= NULL;
    Pbase btmp = BASE_NULLE;
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(3,"movement_computation","begin\n");
 
    assert(sc_image->dimension<maxscinfosize); /* added */
 
    /* Translate each entity in its appropriated entity full name 
       for generating module code */
 
    btmp =  variables_in_declaration_list(module,entity_code(module));
    sc_image = sc_variables_rename(sc_image, bank_indices, btmp,
                                   (get_variable_name_t) entity_local_name);
    sc_image = sc_variables_rename(sc_image, const_base, btmp,
                                   (get_variable_name_t) entity_local_name);
    sc_image = sc_variables_rename(sc_image,tile_indices, btmp,
                                   (get_variable_name_t) entity_local_name);
    bank_indices= vect_rename(bank_indices, btmp,
                              (get_variable_name_t) entity_local_name);
    tile_indices= vect_rename(tile_indices, btmp,
                              (get_variable_name_t) entity_local_name);
    const_base= vect_rename(const_base, btmp,
                            (get_variable_name_t) entity_local_name);
    ppid = vect_rename(ppid, btmp,
                       (get_variable_name_t) entity_local_name);
 
    const_base2 =base_dup(const_base);
    sc_image2 = sc_dup(sc_image);
    sc_proj = sc_dup(sc_image2);
    n = sc_image2->dimension;
 
    /* allocation d'un tableau de systemes et d'une table 
       contenant des infos sur ces systemes*/
 
    space = (n+1) * sizeof(Ssysteme);
    list_of_systems = (Psysteme *) malloc((unsigned) space);
    /* update the different basis */
 
    update_basis(sc_image2->base,&index_base,&const_base2,&image_base,
                 bank_indices,tile_indices,&lindex,&lvar_coeff_nunit,
                 &lvar_coeff_unit,&loop_body_offsets,&loop_body_indices,
                 bank_code,ppid);
 
 
    dim_h2 = vect_size(image_base);
 
    sys_debug(2, "Domain before Projection :\n",sc_proj);
 
    /* Projection on each variable having unity coefficients in the system */
 
    for (pv1 = lvar_coeff_unit;!VECTEUR_UNDEFINED_P(pv1);pv1=pv1->succ) {
        if (var_with_unity_coeff_p(sc_proj,vecteur_var(pv1))) {
            sc_proj = sc_projection(sc_proj,vecteur_var(pv1));
            sc_proj= sc_normalize(sc_proj);
            vect_chg_coeff(&lvar_coeff_nunit,vecteur_var(pv1),0);
        }
    } 
 
    sys_debug(2, " After FM projection :\n", sc_proj);
 
    sc_proj->inegalites = contrainte_sort(sc_proj->inegalites, 
                                          sc_proj->base,  index_base,
                                          true,false);
    ifdebug(2) {
        pips_debug(2," After FM projection  and sort:\n");
        sc_fprint(stderr, sc_proj, (get_variable_name_t) entity_local_name);
    }
 
    /* Projection on the others variables having to be eliminated from 
       the system. In case of Copy-in local memory code generation, the 
       FM projection algorithm is used. For Copy-back code generation
       interger projection algorithm is used.*/
 
    if (!used_def)      
        sc_proj = sc_integer_projection_along_variables(
            sc_image2,sc_proj, index_base, lvar_coeff_nunit, sc_info,dim_h2,n);
    else { 
        for (pv1 = lvar_coeff_nunit;!VECTEUR_UNDEFINED_P(pv1);pv1=pv1->succ) {
            sc_proj = sc_projection(sc_proj,vecteur_var(pv1));
            sc_proj= sc_normalize(sc_proj);
        }           
        /* vect_chg_coeff(&lvar_coeff_nunit,vecteur_var(pv1),0);*/
 
    }
    
    ifdebug(2) {
        sys_debug(2," Before contrainte sort :\n",sc_proj);
        pips_debug(2," Base index :\n");
        vect_fprint(stderr, index_base, (get_variable_name_t) entity_local_name);
    }
    sc_proj->inegalites = contrainte_sort(sc_proj->inegalites, 
                                          sc_proj->base,  index_base,
                                          true,false); 
 
    sys_debug(5," After  contrainte sort:\n",sc_proj);
 
    build_sc_nredund_1pass(&sc_proj);
 
    sys_debug(5,"After Integer Projection :\n",sc_proj);
 
    /* Computation of sample constraints contraining only index variables 
     */
    sc_proj2 = sc_dup(sc_proj);
 
    sys_debug(4, "sc_proj2 [dup] = \n", sc_proj2);
 
    if (vect_size(sc_image2->base) <= 11)  /* why 11? */
    {
        for (pv1 = const_base2; pv1 != NULL; pv1 = pv1->succ)
            vect_erase_var(&lindex, vecteur_var(pv1));
 
        sc_proj = sc_projection_on_list_of_variables
            (sc_image2, image_base, lindex);
        sys_debug(9, "sc_proj = \n", sc_proj);
 
        sc_proj2 = sc_intersection(sc_proj2,sc_proj2,sc_proj);
        sys_debug(4, "sc_proj2 [inter] = \n", sc_proj2);
 
        sc_proj2 = sc_normalize(sc_proj2); 
        sys_debug(4, "sc_proj2 [norm] = \n", sc_proj2);
 
        sys_debug(9, "sc_image2 [minmax] = \n", sc_image2);
        sc_minmax_of_variables(sc_image2,sc_proj2,const_base2);
        sys_debug(4, "sc_proj2 [minmax] = \n", sc_proj2);
    }
    else                                /*more restrictive system */
        sc_minmax_of_variables(sc_image2,sc_proj2,image_base);
 
    sys_debug(2, "Iterat. Domain Before redundancy elimin.:\n",sc_proj2);
    
    /* Elimination of redundant constraints for integer systems*/
 
    sc_proj2->inegalites = 
        contrainte_sort(sc_proj2->inegalites, 
                        sc_proj2->base,  index_base, 
                        false,false);
 
    sys_debug(2,"Iterat. Domain After 1rst sort:\n",sc_proj2);
 
    sc_integer_projection_information(sc_proj2,index_base, sc_info,dim_h2,n);
    sc_proj2=build_integer_sc_nredund(sc_proj2,index_base,sc_info,1,dim_h2,n);  
    sys_debug(2," After redundancy elimination :\n",sc_proj2);
 
    for (i=1;i<=n;i++) 
        list_of_systems[i] = sc_init_with_sc(sc_proj2);
        
    /* Constraints distribution. Lsc[i] will contain all constraints
       contraining the i-th index variable */
 
    constraint_distribution(sc_proj2,list_of_systems,index_base,sc_info);
 
    /* Computation of constraints contraining symbolic constants */
    sc_on_constants= sc_init_with_sc(sc_proj2);
    for (pv1 = tile_indices; pv1!=NULL; pv1=pv1->succ)
        vect_erase_var(&const_base2, vecteur_var(pv1));
    for (pv1 = bank_indices; pv1!=NULL; pv1=pv1->succ)
        vect_erase_var(&const_base2, vecteur_var(pv1));
    for (pv1 = ppid; pv1!=NULL; pv1=pv1->succ)
        vect_erase_var(&const_base2, vecteur_var(pv1));
 
    /* Elimination of constraints redundant in list_of_systems[i] with the 
       "symbolic constant system" */
 
    sc_minmax_of_variables(sc_image2,sc_on_constants,const_base2);
    for (i = 1; sc_on_constants != NULL && i <=vect_size(image_base);i++) {
        list_of_systems[i] = elim_redund_sc_with_sc(list_of_systems[i],
                                                    sc_on_constants,
                                                    index_base,
                                                    dim_h2);
        ifdebug(8) {
            pips_debug(8,"Constraints on the %d-th var.:\n",i);
            sc_fprint(stderr, list_of_systems[i], (get_variable_name_t) entity_local_name);
        }
    }
 
    var_id = (bank_code) ? vect_dup(ppid) : 
    vect_new(vecteur_var(bank_indices), VALUE_ONE);
    stat = bound_generation(module,bank_code,receive_code,
                            private_entity,
                            loop_body_offsets,var_id,
                            list_of_systems,index_base,n,sc_info);
 
    ifdebug(4) {
        /* if you get through this pp, it core dumps much later on:-) */
        pips_debug(3, "returning:\n");
        wp65_debug_print_text(entity_undefined, stat);
    }
    debug(3,"movement_computation","end\n");
    debug_off();
 
    return (stat);
}

References assert, Ssysteme::base, base_dup(), BASE_NULLE, bound_generation(), build_integer_sc_nredund(), build_sc_nredund_1pass(), constraint_distribution(), contrainte_sort(), debug(), debug_off, debug_on, Ssysteme::dimension, elim_redund_sc_with_sc(), entity_code(), entity_local_name(), entity_undefined, ifdebug, Ssysteme::inegalites, malloc(), maxscinfosize, module, pips_debug, sc_dup(), sc_fprint(), sc_init_with_sc(), sc_integer_projection_information(), sc_intersection(), sc_minmax_of_variables(), sc_normalize(), sc_variables_rename(), space, statement_undefined, Svecteur::succ, sys_debug, update_basis(), VALUE_ONE, var_with_unity_coeff_p(), variables_in_declaration_list(), vect_chg_coeff(), vect_dup(), vect_erase_var(), vect_fprint(), vect_new(), vect_rename(), vect_size(), VECTEUR_NUL, VECTEUR_UNDEFINED_P, vecteur_var, and wp65_debug_print_text().

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:

print_fullname_base()

void print_fullname_base

(

Pbase

sb

)

Parameters

sb

b

Definition at line 114 of file movement_computation.c.

{
    Pvecteur pv;
    for (pv = sb; pv !=NULL;
         (void) fprintf(stderr,"%s_%s,",
                        entity_module_name((entity)(pv->var)),
                        entity_local_name((entity)(pv->var))),
         pv=pv->succ);
    (void) fprintf(stderr,"\n");
}

References entity_local_name(), entity_module_name(), fprintf(), Svecteur::succ, and Svecteur::var.

Referenced by update_basis().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_add_new_variable_name()

Variable sc_add_new_variable_name	(	entity	module,
		Psysteme	ps
	)

sc_add_variable.c

sc_add_variable.c

Corinne Ancourt - juin 1990 This function adds a new variable to the system of constraints ps.

Parameters

module	odule
ps	s

Definition at line 48 of file sc_add_variable.c.

{
     static char name[ 64 ];
    string name1;
    int d;
    entity ent1;
    string full_name;
    d = ps->dimension++;
    name[0] = 'X';
    (void) sprintf(&name[1],"%d",d);
    name1 = strdup(name);
 
    full_name=strdup(concatenate(module_local_name(module), 
                                 MODULE_SEP_STRING,
                                 name1,
                                 NULL));
    if ((ent1 = gen_find_tabulated(full_name,entity_domain)) == entity_undefined) {
        ent1 = make_scalar_integer_entity(name1,module_local_name(module));
        free(full_name);
    }
    ps->base = vect_add_variable (ps->base,(char *)ent1);
 
    return((char *)  ent1);
 
}

References Ssysteme::base, concatenate(), Ssysteme::dimension, entity_domain, entity_undefined, free(), full_name, gen_find_tabulated(), make_scalar_integer_entity(), module, module_local_name(), MODULE_SEP_STRING, strdup(), and vect_add_variable().

Referenced by build_sc_with_several_uniform_ref(), and sc_image_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_image_computation()

Psysteme sc_image_computation	(	entity	module,
		entity	entity_var,
		Psysteme	sc_domain,
		Psysteme	sc_array_function,
		Pbase	index_base,
		Pbase *	const_base,
		entity	proc_id,
		Pbase	bank_indices,
		Pbase	tile_indices,
		Pbase *	new_tile_indices,
		int	pn,
		int	bn,
		int	ls,
		int *	n,
		int *	dim_h
	)

This function computes the system of constraints characterizing the image by the array function of the iteration domain.

Computation of the system depending on the machine

conversion des egalites en deux inegalites

pdate the base of constants in the system

initialisation du nombre de constantes symboliques du systeme

allocation et initialisation des matrices utiles

conversion du premier systeme relatif au domaine d'iteration et du deuxieme systeme relatif a la fonction d'acces aux elements du tableau

mise sous forme normale de matrice_hermite

calcul de la dimension reelle de la fonction d'acces

Computation of the new iteration domain

conversion de la matrice en systeme

Computation of the new matrix for array function

conversion from matrix to system

sc_transform_ineg_in_eg(sc_image);

Parameters

module	odule
entity_var	ntity_var
sc_domain	c_domain
sc_array_function	c_array_function
index_base	ndex_base
const_base	onst_base
proc_id	roc_id
bank_indices	ank_indices
tile_indices	ile_indices
new_tile_indices	ew_tile_indices
pn	n
bn	n
ls	s
n	bank number and line size (depends on the machine)
dim_h	im_h

Definition at line 572 of file movement_computation.c.

{
 
    Psysteme sc_image = SC_UNDEFINED;
    Psysteme sc_machine = SC_UNDEFINED;
    Psysteme sc_domain2 = sc_dup(sc_domain);
    Pcontrainte pc = CONTRAINTE_UNDEFINED;
    Pbase new_index_base = BASE_NULLE;
    Pvecteur pv = VECTEUR_NUL;
    Pvecteur pvnew = VECTEUR_NUL;
    Pvecteur pv1= VECTEUR_NUL; 
    Pvecteur pvi=VECTEUR_NUL;
           
    Pbase pbv, list_new_var=BASE_NULLE;
    matrice A,B,F0,P,HERM,HERF,R;
    matrice F = 0;
    matrice Q = NULL;
    int n1,mb,i;
    Value det_p, det_q;
    int n2 = 0;
    int ma =0;
    Variable new_var;
 
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(3,"sc_image_computation","begin\n");
 
    ifdebug(3) {
        pips_debug(3,"ITERATION DOMAIN:\n");
        sc_fprint(stderr, sc_domain2, (get_variable_name_t) entity_local_name);
        pips_debug(3,"ARRAY FUNCTION :\n");
        sc_fprint(stderr, sc_array_function, (get_variable_name_t) entity_local_name);
    }
    if (!sc_faisabilite(sc_domain2))
        (void) fprintf(stderr,"systeme non faisable en  reels  \n");
    else {
 
        /* Computation of the system depending on the machine */        
        sc_machine = build_sc_machine(pn,bn,ls,sc_array_function,proc_id,
                                      bank_indices,entity_var);
        sc_domain2 = sc_append(sc_domain2,sc_machine);
 
        /* conversion des egalites en deux inegalites */
        sc_transform_eg_in_ineg(sc_domain2);
 
        /*update the base of constants in the system */
 
        pv1 =vect_dup(sc_domain2->base);
        for (pv = index_base; 
             !VECTEUR_NUL_P(pv); 
             vect_chg_coeff(&pv1,vecteur_var(pv),0),pv=pv->succ);
        *const_base = pv1;
        ifdebug(8) {
            pips_debug(8,"\n constant basis - sc_image_computation:");
            base_fprint(stderr, *const_base,
                        (get_variable_name_t) entity_local_name);
        }
 
        /* initialisation du nombre de constantes symboliques du systeme */
 
        for (pv1 = index_base, ma=0; 
             !VECTEUR_NUL_P(pv1);
             ma ++, pv1 = pv1->succ);
        for (pv1 = *const_base, mb=1; 
             !VECTEUR_NUL_P(pv1);
             mb ++, pv1 = pv1->succ);
        
        sc_image = sc_new();
        n1 = sc_domain2->nb_ineq;
        n2 = sc_array_function->nb_ineq;
 
        /* allocation et initialisation des matrices utiles */
        A = matrice_new(n1,ma);
        B = matrice_new(n1,mb);
        F = matrice_new(n2,ma);
        F0 = matrice_new(n2,mb);
        R = matrice_new(n1,ma);
        P = matrice_new(n2,n2);
        Q = matrice_new(ma,ma);
        HERM = matrice_new(n2,ma);
        HERF= matrice_new(n2,ma);
 
        matrice_nulle(R,n1,ma);
        matrice_nulle(HERF,n2,ma);
        matrice_identite(P,n2,0);
 
        *n= ma;
 
        /* conversion du premier systeme relatif au domaine d'iteration 
           et du deuxieme systeme relatif a la fonction d'acces
           aux elements du tableau  */
        loop_sc_to_matrices(sc_domain2,index_base,*const_base,A,B,n1,ma,mb);
 
        loop_sc_to_matrices(sc_array_function,index_base,
                            *const_base,F,F0,n2,ma,mb);
 
        /* mise sous forme normale de matrice_hermite */
        matrice_hermite(F,n2,ma,P,HERM,Q,&det_p,&det_q);
        ifdebug(8) {
            sc_fprint(stderr, sc_array_function, (get_variable_name_t) entity_local_name);
            (void) fprintf(stderr," matrice F\n");
            matrice_fprint(stderr,F,n2,ma);
          }
 
        ifdebug(8) { 
            (void) fprintf(stderr," matrice P\n");
            matrice_fprint(stderr,P,n2,n2);
            (void) fprintf(stderr," matrice Q\n");
            matrice_fprint(stderr,Q,ma,ma);
        }
 
        /* calcul de la dimension reelle de la fonction d'acces */
        *dim_h = dim_H(HERM,n2,ma);
 
        /** Computation of the new iteration domain **/
        matrice_multiply(A,Q,R,n1,ma,ma);
        ifdebug(8) { 
            (void) fprintf(stderr," matrix of new iteration domain \n");
            matrice_fprint(stderr,R,n1,ma);
        }
        /* conversion de la matrice en systeme */
        for (i = 1; i<= ma;i++) { 
            new_var = sc_add_new_variable_name(module,sc_image); 
            if (i==1) {
                new_index_base= vect_new(new_var,VALUE_ONE);
                pvi = new_index_base;
            }
            else { pvi->succ = vect_new(new_var,VALUE_ONE);
                   pvi=pvi->succ;
               }
        }
        matrices_to_loop_sc(sc_image,new_index_base,
                            *const_base,R,B,n1,ma,mb);
        list_new_var = new_index_base;
        for (i = 1,pc=sc_array_function->inegalites,pbv = list_new_var; 
             i<= ma && !CONTRAINTE_UNDEFINED_P(pc) && !VECTEUR_NUL_P(pbv);
             i++,pc =pc->succ,pbv=pbv->succ) { 
            if (vect_size(pc->vecteur) == 1 && pc->vecteur->var == TCST) {
                pvnew = vect_make(NULL,
                                  pbv->var,VALUE_ONE,
                                  TCST,value_uminus(pc->vecteur->val));
                sc_add_inegalite(sc_image,contrainte_make(pvnew));
                pvnew = vect_make(NULL,
                                  pbv->var,VALUE_MONE,
                                  TCST,pc->vecteur->val);
                sc_add_inegalite(sc_image,contrainte_make(pvnew));
            }
        }
        ifdebug(3) {
            pips_debug(3,"NEW ITERATION DOMAIN:\n");
            sc_fprint(stderr, sc_image, (get_variable_name_t) entity_local_name);
        }
 
        /** Computation of the new matrix for array function **/
        matrice_multiply(P,HERM,HERF,n2,n2,ma);
        ifdebug(3) { 
            pips_debug(3," New Matrix for Array Function \n");
            matrice_fprint(stderr,HERF,n2,ma);
            matrice_fprint(stderr,F0,n2,mb);
        }
        /* conversion from matrix to system */
        matrices_to_loop_sc(sc_array_function,
                            new_index_base,*const_base,
                            HERF,
                            F0,
                            n2,
                            ma,mb);
        ifdebug(3) { 
            pips_debug(3,"New Array Function :\n");
            sc_fprint(stderr, sc_array_function, (get_variable_name_t) entity_local_name);
        }
    }
   
    /*    sc_transform_ineg_in_eg(sc_image);*/
    *new_tile_indices = BASE_NULLE;
    sort_tile_indices(tile_indices,new_tile_indices,F,n2);
 
 
    ifdebug(3) {
        pips_debug(3,"New Iteration Domain :\n");
        sc_fprint(stderr, sc_image, (get_variable_name_t) entity_local_name);
    }
    debug(3,"sc_image_computation","end\n");
    debug_off();
 
    return(sc_image);
}

References A, B, Ssysteme::base, base_fprint(), BASE_NULLE, build_sc_machine(), contrainte_make(), CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED_P, debug(), debug_off, debug_on, dim_H(), entity_local_name(), F, fprintf(), ifdebug, Ssysteme::inegalites, loop_sc_to_matrices(), matrice_fprint(), matrice_hermite(), matrice_identite(), matrice_multiply(), matrice_new, matrice_nulle(), matrices_to_loop_sc(), module, Ssysteme::nb_ineq, pips_debug, Q, sc_add_inegalite(), sc_add_new_variable_name(), sc_append(), sc_dup(), sc_fprint(), sc_new(), sc_transform_eg_in_ineg(), sort_tile_indices(), Scontrainte::succ, Svecteur::succ, TCST, VALUE_MONE, VALUE_ONE, value_uminus, Svecteur::var, vect_chg_coeff(), vect_dup(), vect_make(), vect_new(), vect_size(), VECTEUR_NUL, VECTEUR_NUL_P, and vecteur_var.

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:

sort_tile_indices()

void sort_tile_indices	(	Pbase	tile_indices,
		Pbase *	new_tile_indices,
		matrice	Q,
		int	m
	)

Sort the tile indices base, such that the indices correspond to the tile indices of the array elements accessed by the local entity.

Example: If A[I,K] is referenced. the tile indices base sould be L_I,L_K...

Parameters

tile_indices	ile_indices
new_tile_indices	ew_tile_indices

Definition at line 236 of file movement_computation.c.

{
    register int i,j; 
    Pvecteur pv,pv2;
    Pvecteur pv3=VECTEUR_UNDEFINED;
 
    for (i=1;i<=m;i++) {
        for (j=1,pv=tile_indices; pv!=NULL;j++,pv=pv->succ) {
            if (ACCESS(Q,m,i,j) &&  vect_coeff(pv->var,pv3)==0 ) {
                pv2 = vect_new(pv->var,ACCESS(Q,m,i,j)); 
                if (*new_tile_indices ==BASE_NULLE) 
                    *new_tile_indices =pv2 ;
                else pv3->succ= pv2;
                pv3 = pv2;
            }
        }
    }
}

References ACCESS, BASE_NULLE, Q, Svecteur::succ, vect_coeff(), vect_new(), and VECTEUR_UNDEFINED.

Referenced by sc_image_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

test_bound_generation()

expression test_bound_generation	(	Psysteme	sc_test,
		Pbase	index_base
	)

This function generates the expressions of the guard if it exists.

All the expressions of the guards are computed from the combination of two constraints where the variable of higher_rank is eliminated.

generation of the left hand side of the guard

generation of the right hand side of the guard

generation of the inequality

Parameters

sc_test	c_test
index_base	ndex_base

Definition at line 234 of file bound_generation.c.

{
 
    Pcontrainte ineq,right_ineq,left_ineq;
    int rank;
    Value coeff;
    Variable var;
    bool debut;
    expression expr,ex1,ex2,ex3,ex4;
    expression exl= expression_undefined;
    expression exr= expression_undefined;
    expression lexpr= expression_undefined;
  
    cons * lex2;
    entity inf =local_name_to_top_level_entity(LESS_OR_EQUAL_OPERATOR_NAME);
    entity an =local_name_to_top_level_entity(AND_OPERATOR_NAME);
   
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"test_bound_generation","begin\n");
 
 
    debut = true;
    for (ineq = sc_test->inegalites; 
         !CONTRAINTE_UNDEFINED_P(ineq); 
         ineq=ineq->succ) {
        rank = search_higher_rank(ineq->vecteur,index_base);
        var = variable_of_rank(index_base,rank);
 
        if (value_pos_p(coeff= vect_coeff(var,ineq->vecteur))) {
            right_ineq = contrainte_dup(ineq);
            left_ineq = contrainte_dup(ineq->succ);
        } 
        else {
            right_ineq = contrainte_dup(ineq->succ);
            left_ineq= contrainte_dup(ineq);
        }
 
        /* generation of the left hand side of the guard */         
        if (value_notmone_p(coeff= vect_coeff(var,left_ineq->vecteur)))
            vect_add_elem(&(left_ineq->vecteur),TCST,
                          value_uminus(value_plus(coeff,VALUE_ONE)));
        
        vect_chg_coeff(&(left_ineq->vecteur),var,VALUE_ZERO);
        ex1 = make_vecteur_expression(left_ineq->vecteur);
        if (value_notmone_p(coeff)) {
            ex2 = int_to_expression(
                VALUE_TO_INT(value_abs(coeff)));
            lex2 = CONS(EXPRESSION,ex2,NIL);
            exl = make_div_expression(ex1,lex2);        
            vect_add_elem(&(left_ineq->vecteur),TCST,
                          value_plus(coeff,VALUE_ONE));
        }
 
        /* generation of the right hand side of the guard */        
 
        coeff= vect_coeff(var,right_ineq->vecteur);
        vect_chg_sgn(right_ineq->vecteur);
        vect_chg_coeff(&(right_ineq->vecteur),var,VALUE_ZERO);
        ex3= make_vecteur_expression(right_ineq->vecteur);
        vect_chg_sgn(right_ineq->vecteur);
    
        if (value_notone_p(coeff)) {
            ex4 = int_to_expression(
                VALUE_TO_INT(value_abs(coeff)));
            lex2 =CONS(EXPRESSION,ex4,NIL);
            exr = make_div_expression(ex3,lex2);        
        }
        lex2 = CONS(EXPRESSION,exr,NIL);
 
        /* generation of the inequality */
        expr =  make_op_expression(inf,CONS(EXPRESSION,exl,lex2));      
 
        if (debut) lexpr =expr;
        else {
            lex2 = CONS(EXPRESSION,expr,NIL);
            lexpr=make_op_expression(an,CONS(EXPRESSION,lexpr,lex2));
        }
        ineq = ineq->succ;
        debut = false;
    }
    
    debug(8,"test_bound_generation","end\n");
    debug_off();        
    return(lexpr); 
}

References AND_OPERATOR_NAME, CONS, contrainte_dup(), CONTRAINTE_UNDEFINED_P, debug(), debug_off, debug_on, EXPRESSION, expression_undefined, Ssysteme::inegalites, int_to_expression(), LESS_OR_EQUAL_OPERATOR_NAME, local_name_to_top_level_entity(), make_div_expression(), make_op_expression(), make_vecteur_expression(), NIL, rank, search_higher_rank(), Scontrainte::succ, TCST, value_abs, value_notmone_p, value_notone_p, VALUE_ONE, value_plus, value_pos_p, VALUE_TO_INT, value_uminus, VALUE_ZERO, variable_of_rank(), vect_add_elem(), vect_chg_coeff(), vect_chg_sgn(), vect_coeff(), and Scontrainte::vecteur.

Referenced by bound_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

update_basis()

void update_basis	(	Pbase	scbase,
		Pbase *	index_base,
		Pbase *	const_base,
		Pbase *	image_base,
		Pbase	bank_indices,
		Pbase	tile_indices,
		Pbase *	lindex,
		Pbase *	lvar_coeff_nunit,
		Pbase *	lvar_coeff_unit,
		Pbase *	loop_body_offsets,
		Pbase *	loop_body_indices,
		bool	bank_code,
		Pbase	ppid
	)

Update all the basis needed for data movement generation.

-loop_body_offsets: indices such as O or LI or LJ used to describe the range of contiguous values accessed on line (of tile or bank).

-loop_body_indices: list of the loop indices that are not parameters of the tiling transformation and are situated in the loop body of the tile

Parameters

scbase	cbase
index_base	ndex_base
const_base	onst_base
image_base	mage_base
bank_indices	ank_indices
tile_indices	ile_indices
lindex	index
lvar_coeff_nunit	var_coeff_nunit
lvar_coeff_unit	var_coeff_unit
loop_body_offsets	oop_body_offsets
loop_body_indices	oop_body_indices
bank_code	ank_code
ppid	pid

Definition at line 136 of file movement_computation.c.

{
 
    Pvecteur pv,pv1;
 
    debug(8,"update_basis","begin\n");
    ifdebug(8) {
        (void) fprintf(stderr,"BASIS PRINTING: \n");  
        (void) fprintf(stderr,"     sc_base :");
        print_fullname_base(scbase);
        (void) fprintf(stderr,"     const_base :");
        print_fullname_base(*const_base);
        (void) fprintf(stderr,"     bank_indices ");
        print_fullname_base(bank_indices);
        (void) fprintf(stderr,"     index_base");
        print_fullname_base(*index_base);
        (void) fprintf(stderr,"     tile_indices");
        print_fullname_base(tile_indices);  
        (void) fprintf(stderr,"     loop_body_indices");
        print_fullname_base(*loop_body_indices); }
 
    for (pv = bank_indices; !VECTEUR_NUL_P(pv); pv = pv->succ)
        vect_chg_coeff(const_base,pv->var, VALUE_ZERO);
 
    vect_chg_coeff(const_base,ppid->var, VALUE_ZERO);
 
    if (bank_code) 
        vect_chg_coeff(const_base,vecteur_var(bank_indices), VALUE_ONE);
    else 
        vect_chg_coeff(const_base,vecteur_var(ppid), VALUE_ONE);
 
    for (pv = tile_indices; !VECTEUR_NUL_P(pv); pv = pv->succ)
        vect_chg_coeff(const_base,pv->var, VALUE_ZERO);
 
    for (pv = *loop_body_indices;  !VECTEUR_NUL_P(pv); pv = pv->succ)
        vect_erase_var(const_base,pv->var);
 
    *index_base = vect_dup(scbase);
    *lindex = vect_dup(scbase);
    *lvar_coeff_nunit = base_dup(scbase);
 
    for (pv = *const_base; !BASE_NULLE_P(pv);
         vect_erase_var(lvar_coeff_nunit, vecteur_var(pv)),
         vect_erase_var(index_base, vecteur_var(pv)), 
         vect_erase_var(lindex, vecteur_var(pv)), 
         pv= pv->succ);
 
    *image_base = build_image_base(bank_code,ppid,bank_indices,tile_indices);
 
    for (pv1 = *image_base; 
         !BASE_NULLE_P(pv1);
         vect_erase_var(lvar_coeff_nunit,vecteur_var(pv1)),
         vect_erase_var(index_base,vecteur_var(pv1)),
         vect_erase_var(lindex,vecteur_var(pv1)),
         pv1=pv1->succ);
 
    *lvar_coeff_unit = base_dup(*lvar_coeff_nunit);
    *index_base = vect_add(vect_dup(*index_base),vect_dup(*image_base));
    *lindex = vect_add(*image_base,vect_dup(*lindex));
    *lindex = vect_add(vect_dup(*lindex),vect_dup(*const_base));
    
     if (bank_code)
         *loop_body_offsets = vect_dup(bank_indices->succ);
    else 
        *loop_body_offsets = base_dup(tile_indices);
    ifdebug(8) {
        (void) fprintf(stderr,"New BASIS:");
        print_fullname_base(*image_base);    
        (void) fprintf(stderr,"    base lindex:");
        print_fullname_base(*lindex);    
        (void) fprintf(stderr,"   base index:");
        print_fullname_base(*index_base);       
        (void) fprintf(stderr,"    lvar_coeff_nunit:");
        print_fullname_base(*lvar_coeff_nunit);    
        (void) fprintf(stderr,"    lvar_coeff_unit:");
        print_fullname_base(*lvar_coeff_unit);    
    }
    debug(8,"update_basis","end\n");
}

References base_dup(), BASE_NULLE_P, build_image_base(), debug(), fprintf(), ifdebug, print_fullname_base(), Svecteur::succ, VALUE_ONE, VALUE_ZERO, Svecteur::var, vect_add(), vect_chg_coeff(), vect_dup(), vect_erase_var(), VECTEUR_NUL_P, and vecteur_var.

Referenced by movement_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

upper_bound_generation()

expression upper_bound_generation	(	Psysteme	sc_pos,
		Pbase	index_base,
		int	number_of_upper_bounds,
		int	loop_rank
	)

This fonction generates the upper bounds of the "loop_rank"-th loop.

this condition is true if the constraint constrains directly the variable

In that case the bound expression results from the combination of two constraints. The variable of rank "higher_rank" will be eliminated from these two constraints in order to give only one bound for the "loop_rank" index.

Parameters

sc_pos	c_pos
index_base	ndex_base
number_of_upper_bounds	umber_of_upper_bounds
loop_rank	oop_rank

Definition at line 145 of file bound_generation.c.

{
    Pcontrainte ineq; 
    Pvecteur pv2=VECTEUR_NUL;
    int higher_rank, nub = 0;
    Value coeff;
    Variable var = variable_of_rank(index_base,loop_rank);
    expression expr, ex2, ex1, upper = expression_undefined;
    cons * lex2,* lexpr = NIL;
    entity min=local_name_to_top_level_entity("MIN");
    bool reductible = false;
  
    debug_on("MOVEMENT_DEBUG_LEVEL");
    debug(8,"upper_bound_generation","begin\n");
 
 
    if (number_of_upper_bounds) {  
        for (ineq = sc_pos->inegalites;
             !CONTRAINTE_UNDEFINED_P(ineq); 
             ineq=ineq->succ) {
            Variable var2;
            Value coeff2,coeff3;
            reductible = false;
            higher_rank=search_higher_rank(ineq->vecteur,index_base);
            if (higher_rank > loop_rank ) {
                var2 = variable_of_rank(index_base,higher_rank);
                coeff2 = vect_coeff(var2,ineq->vecteur);
                coeff3 = vect_coeff(var2,(ineq->succ)->vecteur);
                if (value_one_p(value_abs(coeff2)) || 
                    value_one_p(value_abs(coeff3))) {
                    reductible = true;
                    pv2 = vect_cl2(value_abs(coeff2),(ineq->succ)->vecteur,
                                   value_abs(coeff3),ineq->vecteur);
 
                    ineq= ineq->succ;
                }
            }
            else pv2 = vect_dup(ineq->vecteur);
 
            if (higher_rank <=loop_rank || reductible) {
                /* this condition is true if the constraint constrains 
                   directly the variable */
                coeff= vect_coeff(var,pv2);
                vect_chg_sgn(pv2);
                vect_chg_coeff(&pv2,var,VALUE_ZERO);
                expr = ex1 =make_vecteur_expression(pv2);
                vect_chg_sgn(pv2);
              
                if (value_notone_p(coeff)) {
                    ex2 = int_to_expression(
                        VALUE_TO_INT(value_abs(coeff)));
                    lex2 = CONS(EXPRESSION,ex2,NIL);
                    expr= make_div_expression(ex1,lex2);
                }
            }
            else {  
                /* In that case the bound expression results from 
                   the  combination of two constraints. The variable of 
                   rank "higher_rank" will be eliminated from these two 
                   constraints in order to give only one bound for 
                   the "loop_rank" index. */
                expr = complex_bound_computation(sc_pos,index_base,
                                                 ineq,ineq->succ,
                                                 higher_rank);
                ineq = ineq->succ;
            }
            lexpr = CONS(EXPRESSION, expr,lexpr);
            nub ++;
        }
        if (nub > 1)    
            upper = make_op_expression(min,lexpr);
        else upper = EXPRESSION(CAR(lexpr));
    }
    debug(8,"upper_bound_generation","end\n");
    debug_off();
    return (upper);
 
}

References CAR, complex_bound_computation(), CONS, CONTRAINTE_UNDEFINED_P, debug(), debug_off, debug_on, EXPRESSION, expression_undefined, Ssysteme::inegalites, int_to_expression(), local_name_to_top_level_entity(), make_div_expression(), make_op_expression(), make_vecteur_expression(), min, NIL, search_higher_rank(), Scontrainte::succ, value_abs, value_notone_p, value_one_p, VALUE_TO_INT, VALUE_ZERO, variable_of_rank(), vect_chg_coeff(), vect_chg_sgn(), vect_cl2(), vect_coeff(), vect_dup(), Scontrainte::vecteur, and VECTEUR_NUL.

Referenced by bound_generation(), and make_movements_loop_body_wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_in_declaration_module_p()

bool variable_in_declaration_module_p	(	entity	m,
		entity	v
	)

Definition at line 74 of file make_loop_body.c.

{
    value val = entity_initial(m);
    code c = value_code(val);
    cons *d, *cp1;
    d = code_declarations(c);
 
    if (d == NIL) return(false) ;
    for (cp1 = d ; !ENDP(cp1) ; cp1 = CDR( cp1 ))  {
        if (strcmp(entity_local_name(ENTITY(CAR(cp1))),
                   entity_local_name(v)) == 0)
            return(true);
    }
    return (false);
}

References CAR, CDR, code_declarations, ENDP, ENTITY, entity_initial, entity_local_name(), NIL, and value_code.

Here is the call graph for this function:

variables_in_declaration_list()

Pbase variables_in_declaration_list	(	entity	,
		code
	)

wp65_debug_print_module()

void wp65_debug_print_module	(	entity	m,
		statement	s
	)

Definition at line 61 of file make_loop_body.c.

{
    debug_on("PRETTYPRINT_DEBUG_LEVEL");
    text t = text_module(m, s);
    print_text(stderr, t);
    free_text(t);
    debug_off();
}

References debug_off, debug_on, free_text(), print_text(), and text_module().

Referenced by module_to_wp65_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

wp65_debug_print_text()

void wp65_debug_print_text	(	entity	m,
		statement	s
	)

make_loop_body.c

make_loop_body.c

Definition at line 53 of file make_loop_body.c.

{
    debug(1, "For module %s:\n", entity_name(m));
    debug_on("PRETTYPRINT_DEBUG_LEVEL");
    print_statement(s);
    debug_off();
}

References debug(), debug_off, debug_on, entity_name, and print_statement().

Referenced by bound_generation(), eval_variable_in_statement(), loop_nest_to_wp65_code(), make_all_movement_blocks(), make_movement_scalar_wp65(), make_scanning_over_one_tile(), make_scanning_over_tiles(), movement_computation(), reference_conversion_statement(), and translate_unary_into_binary_ref().

Here is the call graph for this function:

Here is the caller graph for this function: