locality.h File Reference

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

Go to the source code of this file.

Data Structures
struct	context_p
	cette structure contient une pile. More...

Typedefs
typedef struct context_p	context_t

Functions
bool	loop_statistics (const string)
	cproto-generated files More...
statement	permutation (statement, Pmatrix)
statement	permutation2 (statement, Pmatrix)
statement	Hierarchical_tiling (void)
int	position_one_element (Pmatrix, int)
statement	Tiling_buffer_allocation (void)
statement	Tiling2_buffer (void)
bool	tiling_sequence (string)
statement	unimodular (statement)
statement	free_guards (statement)
bool	guard_elimination (string)

Variables
loop	loop1
	tiling_sequence.c More...
entity	first_array
	une copie de l'un des nids de la sequence More...
Psysteme	sc_newbase
	guard_elimination.c More...
Ptsg	sg
bool	if1
bool	if2

Typedef Documentation

context_t

typedef struct context_p context_t

Function Documentation

free_guards()

statement free_guards

(

statement

s

)

sg_dump(sg);

fprint_lsom(stderr, vertice,variable_dump_name );

debut cas1

fins cas1

ebut cas2

fin cas2

debut cas3

s1

in cas3

debut cas4

in cas4

Definition at line 544 of file guard_elimination.c.

{
  int isoler =-1,isoler2=-1;
  instruction ins;
  statement body1,body2,loop2=NULL;
  sequence seqi,seqj,seq;
  list lisi,lisj,lisjcopy,lis,lisjcopy2,lisp;
  statement first, last=NULL;
  expression  exp;
  normalized norm;
  Pvecteur pv1,pv2=NULL,pvif1=NULL,pvif2=NULL,pv_i_lower,pv_i_upper;
  Pcontrainte cif1=NULL,cif2=NULL;
  Value sommetg[4];
  loop tab_loop[6], loop1;
  instruction tab_instruction[6];
  statement tab_statement[6];
  int i=0,j;
  Psommet vertice,e;
  int nbr_vertice;
  Variable indice1,indice2;
  range range_i,range1,range2,range3;
  /* sg_dump(sg);  */
  /* fprint_lsom(stderr, vertice,variable_dump_name ); */
  ins =statement_instruction(s);
  loop1=instruction_loop(ins);
  body1=loop_body(instruction_loop(ins));
  indice1=(Variable )loop_index(instruction_loop(ins));
  range_i=loop_range(instruction_loop(ins));
  normalize_all_expressions_of(range_lower(range_i));
  normalize_all_expressions_of(range_upper(range_i));
  pv_i_lower=normalized_linear(expression_normalized(range_lower(range_i)));
  vect_add_elem(&pv_i_lower,indice1,-1);
  pv_i_upper=normalized_linear(expression_normalized(range_upper(range_i)));
  vect_add_elem(&pv_i_upper,indice1,-1);
  ins =statement_instruction(body1);
  seqi=instruction_sequence(ins);
  lisi =sequence_statements(seqi); 
  MAP(STATEMENT,s1,{loop2 =s1; },lisi) ; 
  ins=statement_instruction(loop2);
  indice2=(Variable )loop_index(instruction_loop(ins));
  body2=loop_body(instruction_loop(ins));
  ins =statement_instruction(body2); 
  seqj=instruction_sequence(ins);
  lisj =sequence_statements(seqj); 
  lisjcopy= gen_full_copy_list(lisj);
  first= (statement )CHUNK( CAR(lisj));
  nbr_vertice=sg_nbre_sommets(sg);
  printf(" le nombre de sommet est %d \n",  nbr_vertice);
  vertice= sg_sommets(sg); 
  for (e = vertice; e != NULL; e = e->succ) {
    pv1=e->vecteur;
    sommetg[i]=value_div (vect_coeff(indice1,pv1),e->denominateur);
    i++;
  };
  for(i=0;i<=nbr_vertice-1;i++)  
    { 
      for(j=i+1;j<= nbr_vertice;j++)  
        if( sommetg[j]< sommetg[i] )
          {
            Value permut;
            permut= sommetg[i];
            sommetg[i]= sommetg[j];
            sommetg[j]=permut;
          };
    };
  for(i=0;i<= nbr_vertice-1;i++)  
    {
      if( sommetg[i]== sommetg[i+1] )
        {
          for (j=i;j<=nbr_vertice-1;j++)
            sommetg[j]=sommetg[j+1];
          nbr_vertice--;
        };
    };
  i=0;
  MAP(STATEMENT,s1, { last =s1; },lisjcopy) ; 
  if (if1){ 
    Pcontrainte peq;
    syntax syntax;
    call call;
    list lis;
    CHUNK(CAR(lisjcopy))= (gen_chunk *)
        test_true(instruction_test(statement_instruction(first))); 
    CHUNK(CAR(lisj))= (gen_chunk *) make_block_statement(NIL); 
    exp= test_condition (instruction_test(statement_instruction(first)));
    normalize_all_expressions_of(exp); 
    syntax=expression_syntax(exp);
    call=syntax_call(syntax);
    lis =call_arguments(call);
    exp=(expression )CHUNK(CAR(lis));
    norm=expression_normalized(exp);
    pv1=normalized_linear(norm);
    MAP(EXPRESSION,exp,{
      norm=expression_normalized(exp);
      pv2=normalized_linear(norm); 
    },lis) ; 
    pvif1=vect_substract(pv1,pv2);
    exp=Pvecteur_to_expression(pvif1);
    for (peq = sc_newbase->inegalites;peq!=NULL;peq=peq->succ){
      if(  vect_oppos(pvif1,peq->vecteur))
        pvif1=vect_substract(VECTEUR_NUL,vect_dup(pvif1));
    };  
    cif1=contrainte_make(pvif1);
    exp=Pvecteur_to_expression(pvif1);
    test_condition (instruction_test(statement_instruction(first)))= 
      eq_expression (exp, int_to_expression(0) );
  }
  if(if2){
    Pcontrainte peq;
    syntax syntax;
    call call;
    list lis;
    CHUNK(CAR(gen_last(lisjcopy)))= (gen_chunk *)
      test_true(instruction_test(statement_instruction(last))); 
    CHUNK( CAR(gen_last(lisj)))= (gen_chunk *) make_block_statement(NIL);   
    exp= test_condition (instruction_test(statement_instruction(last)));
    normalize_all_expressions_of(exp); 
    syntax=expression_syntax(exp);
    call=syntax_call(syntax);
    lis =call_arguments(call);
    exp=(expression) CHUNK(CAR(lis));
    norm=expression_normalized(exp);
    pv1=normalized_linear(norm);  
    MAP(EXPRESSION,exp,{
      norm=expression_normalized(exp);
      pv2=normalized_linear(norm); 
    },lis) ; 
    pvif2=vect_substract(pv1,pv2);
    for (peq = sc_newbase->inegalites;peq!=NULL;peq=peq->succ){
      if(  vect_oppos(pvif2,peq->vecteur))
        pvif2= vect_substract(VECTEUR_NUL,vect_dup(pvif2)) ; 
    }
    cif2=contrainte_make(pvif2);
    exp=Pvecteur_to_expression(pvif2);
    test_condition (instruction_test(statement_instruction(last)))= 
      eq_expression 
      (exp, int_to_expression(0) );
  }
  lis=NIL; 
  lisjcopy2= gen_full_copy_list(lisjcopy);
  if(if1) CHUNK( CAR(    (lisjcopy2)))= (gen_chunk *) make_block_statement(NIL);
  if(if2)CHUNK(CAR(gen_last((lisjcopy))))= (gen_chunk *) make_block_statement(NIL);
  for(i=0;i<=2*nbr_vertice-2;i++){ 
    Pcontrainte peq,cinf=NULL,csup=NULL;
    statement body1,body2;
    instruction ins;
    sequence seqi,seqj;
    list lisi,lisj;
    range range; 
    statement loop2=NULL;
    bool condition1=false,condition2=false;
    tab_loop[i]=copy_loop(loop1);
    tab_instruction[i] = make_instruction_loop(tab_loop[i]);
    tab_statement[i]=instruction_to_statement (  tab_instruction[i]);
    lis=CONS(STATEMENT,  tab_statement[i],lis);
    if (i%2==0){
      int indice;
      Value minjp=-100,maxjp=100;
      indice=i/2;
      range_lower(loop_range(tab_loop[i]))=
        int_to_expression( sommetg[indice]);
      range_upper(loop_range(tab_loop[i]))=
        int_to_expression( sommetg[indice]);
      for (peq = sc_newbase->inegalites;peq!=NULL;peq=peq->succ){
        Pvecteur v;
        Value  constante,val1,val2;
        v = contrainte_vecteur(peq);
        constante=vect_coeff(TCST,v);
        val1=vect_coeff(indice1,v);
        val2=vect_coeff(indice2,v);
        if (val2 < 0){
          if (eval2(constante,val1,val2, sommetg[indice])>minjp ){
            minjp=eval2(constante,val1,val2, sommetg[indice]);
            cinf=peq;
          }
          else {
            if (  eval2(constante,val1,val2, sommetg[indice])==minjp ){
              Pvecteur vp;
              Value  constantep,val1p,val2p;
              vp=contrainte_vecteur(cinf);
              constantep=vect_coeff(TCST,vp);
              val1p=vect_coeff(indice1,vp);
              val2p=vect_coeff(indice2,vp);
              if(value_direct_multiply
                 ( value_direct_multiply(val1,sommetg[indice])+ constante ,-val2p)
                 > value_direct_multiply
                 (value_direct_multiply(val1p,sommetg[indice])+constantep,-val2))
                cinf=peq;
              else
                if(value_direct_multiply
                   (value_direct_multiply(val1,sommetg[indice])+ constante,-val2p)
                   ==value_direct_multiply
                   (value_direct_multiply(val1p,sommetg[indice])+constantep,-val2))
                  if(egalite_equal(peq,cif1)||egalite_equal(peq,cif2) )
                    cinf=peq;
            };
          };
        };
        if (val2 > 0){
          if (eval2(constante,val1,val2, sommetg[indice])<maxjp ){
            maxjp=eval2(constante,val1,val2, sommetg[indice]);
            csup=peq;
          }
          else {
            if (eval2(constante,val1,val2, sommetg[indice])==maxjp ){  
              Pvecteur vp;
              Value  constantep,val1p,val2p;
              vp=contrainte_vecteur(csup);
              constantep=vect_coeff(TCST,vp);
              val1p=vect_coeff(indice1,vp);
              val2p=vect_coeff(indice2,vp);;
              if(value_direct_multiply
                 (value_direct_multiply(val1,sommetg[indice])+ constante ,-val2p)
                 < value_direct_multiply
                 (value_direct_multiply (val1p,sommetg[indice])+ constantep,-val2))
                csup=peq; 
              else
                if(value_direct_multiply
                   (value_direct_multiply(val1,sommetg[indice])+ constante ,-val2p)
                   ==value_direct_multiply
                   (value_direct_multiply(val1p,sommetg[indice])+constantep,-val2))
                  if( ( egalite_equal(peq,cif1) )||(egalite_equal(peq,cif2)) )  
                    csup=peq; 
            };
          };
        };
      };
      for (e = vertice; e != NULL; e = e->succ) {
        Value j2;
        Pvecteur pv1;
        pv1=e->vecteur;
        if (sommetg[indice]==vect_coeff(indice1,pv1)){
          j2=vect_coeff(indice2,pv1);
          if ( 
              (value_direct_multiply(vect_coeff(indice1,pvif1),sommetg[indice])+
               value_direct_multiply(vect_coeff(indice2,pvif1),j2)+
               vect_coeff(TCST,pvif1)==0)&&
              (value_direct_multiply(vect_coeff(indice1,pvif2),sommetg[indice])+
               value_direct_multiply(vect_coeff(indice2,pvif2),j2)+
               vect_coeff(TCST,pvif2)==0)){
            if( vect_coeff(indice2,pvif2) < 0 )
              condition1=true;
            else{
              if( vect_coeff(indice2,pvif1) > 0 ){
                condition2=true;
                
              };
            }
          }
        }
      };
      
    }
    else{
      int indice;
      Value minjp1=-100,minjp2=-100,maxjp1=100,maxjp2=100;
      indice=i/2;
      range_lower(loop_range(tab_loop[i]))=
        int_to_expression( sommetg[indice]+1);
      range_upper(loop_range(tab_loop[i]))=
        int_to_expression( sommetg[indice+1]-1);
      for (peq = sc_newbase->inegalites;peq!=NULL;peq=peq->succ){
        Pvecteur v;
        Value constante,val1,val2;
        v = contrainte_vecteur(peq);   
        constante=vect_coeff(TCST,v);
        val1=vect_coeff(indice1,v);
        val2=vect_coeff(indice2,v);
        if (val2 < 0){
          if (  (eval2(constante,val1,val2, sommetg[indice])>=minjp1 )
                &&( eval2(constante,val1,val2, sommetg[indice+1]) >=minjp2)){
            if (  (eval2(constante,val1,val2, sommetg[indice])==minjp1 )
                  &&( eval2(constante,val1,val2, sommetg[indice+1]) ==minjp2))
              {
                Pvecteur vp;
                Value  constantep,val1p,val2p;
                vp=contrainte_vecteur(cinf);
                constantep=vect_coeff(TCST,vp);
                val1p=vect_coeff(indice1,vp);
                val2p=vect_coeff(indice2,vp);
                if((value_direct_multiply
                    (value_direct_multiply(val1,sommetg[indice])+constante,-val2p)
                    > value_direct_multiply
                    (value_direct_multiply(val1p,sommetg[indice])+constantep,-val2))|| 
                   (value_direct_multiply
                    ( value_direct_multiply(val1,sommetg[indice+1])+ constante ,-val2p)
                    > value_direct_multiply
                    ( value_direct_multiply 
                      (val1p,sommetg[indice+1])+ constantep ,-val2)))
                  {
                    minjp1=eval2(constante,val1,val2, sommetg[indice]);
                    minjp2=eval2(constante,val1,val2, sommetg[indice+1]);
                    cinf=peq;
                  }
              }
            else{
              minjp1=eval2(constante,val1,val2, sommetg[indice]);
              minjp2=eval2(constante,val1,val2, sommetg[indice+1]);
              cinf=peq;
            }
          };   
        };
        if (val2 > 0){
          if (  (eval2(constante,val1,val2, sommetg[indice])<=maxjp1 )&&
                ( eval2(constante,val1,val2, sommetg[indice+1]) <=maxjp2)){
            if (  (eval2(constante,val1,val2, sommetg[indice])==maxjp1 )
                  &&( eval2(constante,val1,val2, sommetg[indice+1]) ==maxjp2))
              {
                Pvecteur vp;
                Value  constantep,val1p,val2p;
                vp=contrainte_vecteur(csup);
                constantep=vect_coeff(TCST,vp);
                val1p=vect_coeff(indice1,vp);
                val2p=vect_coeff(indice2,vp);
                if((value_direct_multiply
                    (value_direct_multiply(val1,sommetg[indice])+ constante ,-val2p)
                    < value_direct_multiply
                    (value_direct_multiply(val1p,sommetg[indice])+constantep,-val2)) || 
                   (value_direct_multiply
                    (value_direct_multiply(val1,sommetg[indice+1])+ constante ,-val2p)
                    < value_direct_multiply
                    (value_direct_multiply (val1p,sommetg[indice+1])+constantep,-val2)))
                  {
                    maxjp1=eval2(constante,val1,val2, sommetg[indice]);
                    maxjp2=eval2(constante,val1,val2, sommetg[indice+1]);
                    csup=peq;
                  };
              }
            else{
              maxjp1=eval2(constante,val1,val2, sommetg[indice]);
              maxjp2=eval2(constante,val1,val2, sommetg[indice+1]);
              csup=peq;
            };
          };
        };
      };
    }; 
    body1=loop_body( tab_loop[i]);
    ins =statement_instruction(body1);
    seqi=instruction_sequence(ins);
    lisi =sequence_statements(seqi); 
    MAP(STATEMENT,s,loop2=s,lisi);
    ins=statement_instruction(loop2);
    range =loop_range(instruction_loop(ins));
    range_lower(range)=make_contrainte_expression(cinf,indice2);
    range_upper(range)=make_contrainte_expression(csup,indice2);
    body2= loop_body(instruction_loop(ins));
    seqj=instruction_sequence(statement_instruction(body2));
    lisj=sequence_statements(seqj);
    if (condition1){
      list lisjcopy;
      Pvecteur v;
      Value constante;
      lisjcopy= gen_full_copy_list(lisj);
      CHUNK(CAR(gen_last(lisjcopy)))= (gen_chunk *)
        test_true(instruction_test(statement_instruction(last)));
      CHUNK(CAR(lisjcopy))= (gen_chunk *)
        test_true(instruction_test(statement_instruction(first)));
      lisi= gen_concatenate(lisjcopy,lisi);
      sequence_statements(seqi)=lisi;
      v = vect_dup (contrainte_vecteur(cinf));
      constante=vect_coeff(TCST,v);
      vect_chg_coeff(&v,TCST,value_plus(1,constante)); 
      cinf=contrainte_make(v);
      range_lower(range)=make_contrainte_expression(cinf,indice2); 
      
    }
    if (condition2){
      Pvecteur v;
      Value constante;
      list lisjcopy;
      lisjcopy= gen_full_copy_list(lisj);
      CHUNK(CAR(gen_last(lisjcopy)))= (gen_chunk *)
        test_true(instruction_test(statement_instruction(last)));
      CHUNK(CAR(lisjcopy))= (gen_chunk *)
        test_true(instruction_test(statement_instruction(first)));
      lisi= gen_concatenate(lisi,lisjcopy);
      sequence_statements(seqi)=lisi;
      v=vect_dup( contrainte_vecteur(csup));
      constante=vect_coeff(TCST,v);
      vect_chg_coeff(&v,TCST,value_plus(1,constante)); 
      csup=contrainte_make(v);
      range_upper(range)=make_contrainte_expression(csup,indice2);  
    }
    if (i==0){
      if ( vect_equal(pvif1,pv_i_lower) ||
           vect_oppos(pvif1,pv_i_lower)){
        CHUNK( CAR((lisj)))= (gen_chunk * ) 
          test_true(instruction_test(statement_instruction(first)));
        sequence_statements(seqj)=lisj;   
        isoler2=0;  
      }  
      else{
        if ( vect_equal(pvif2,pv_i_lower) ||
             vect_oppos(pvif2,pv_i_lower)) {
          CHUNK( CAR(gen_last((lisj))))= (gen_chunk * ) 
            test_true(instruction_test(statement_instruction(last)));
          sequence_statements(seqj)=lisj;  
          isoler2=0; 
        };
      };
    };
    if (i==2*nbr_vertice-2){
      if ( vect_equal(pvif1,pv_i_upper) ||
           vect_oppos(pvif1,pv_i_upper)) 
        {
          CHUNK( CAR((lisj)))= (gen_chunk * ) 
          test_true(instruction_test(statement_instruction(first)));
          sequence_statements(seqj)=lisj;   
          isoler=2*nbr_vertice-2;
        }  
      else{
        if ( vect_equal(pvif2,pv_i_upper) ||
             vect_oppos(pvif2,pv_i_upper)) {
          CHUNK( CAR(gen_last((lisj))))= (gen_chunk * ) 
            test_true(instruction_test(statement_instruction(last)));
          sequence_statements(seqj)=lisj;  
          isoler=2*nbr_vertice-2;
        };
      };
    };
    
    if ((condition1==false) && (condition2==false)){
      
      /*  debut  cas1  */
      
      if ( egalite_equal(cinf,cif1)){
        if (value_abs  (vect_coeff(indice2,pvif1))==1){  
          lisi=CONS(STATEMENT,
                    test_true(instruction_test(statement_instruction(first))),lisi);
          sequence_statements(seqi)=lisi;  
        }  
        else{
          list lexp;
          call ca;
          expression exp1,exp2;
          Pvecteur pv;
          statement s;
          pv=vect_dup (pvif1); 
          vect_erase_var( &pv,indice2);
          exp1=Pvecteur_to_expression(pv);
          s= copy_statement (first);
          lexp = CONS(EXPRESSION, int_to_expression
                      (-vect_coeff(indice2,pvif1)), NIL);
          lexp = CONS(EXPRESSION, exp1, lexp);
          ca = make_call(entity_intrinsic(MODULO_OPERATOR_NAME), lexp);
          exp1 = make_expression(make_syntax(is_syntax_call, ca),
                                 normalized_undefined);
          exp2=int_to_expression(0);
          exp1=eq_expression(exp1,exp2);
          test_condition(instruction_test(statement_instruction(s)))=exp1; 
          lisi=CONS(STATEMENT,s,lisi);
          sequence_statements(seqi)=lisi;
        };
      }; 
      
      /* fins cas1 */
      
      
      /*debut cas2 */
      
      if ( egalite_equal(csup,cif2)) {
        list listemp;
        if (value_abs  (vect_coeff(indice2,pvif2))==1){  
          listemp=CONS(STATEMENT,
                       test_true(instruction_test(statement_instruction(last))),NIL);
          lisi= gen_concatenate(lisi,listemp);
          sequence_statements(seqi)=lisi;  
        }  
        else{
          list lexp;
          call ca;
          expression exp1,exp2;
          Pvecteur pv;
          statement s;
          pv=vect_dup (pvif2); 
          vect_erase_var( &pv,indice2);
          exp1=Pvecteur_to_expression(pv);
          s= copy_statement (last);
          lexp = CONS(EXPRESSION, int_to_expression
                      (-vect_coeff(indice2,pvif2)), NIL);
          lexp = CONS(EXPRESSION, exp1, lexp);
          ca = make_call(entity_intrinsic(MODULO_OPERATOR_NAME), lexp);
          exp1 = make_expression(make_syntax(is_syntax_call, ca),
                                 normalized_undefined);
          exp2=int_to_expression(0);
          exp1=eq_expression(exp1,exp2);
          test_condition(instruction_test(statement_instruction(s)))=exp1; 
          listemp=CONS(STATEMENT,s ,NIL);
          lisi= gen_concatenate(lisi,listemp);
          sequence_statements(seqi)=lisi;
        };
      }; 
    
      
      /* fin  cas2  */
      /* debut cas3 */
      
      if ( egalite_equal(cinf,cif2)) {
        statement sif1;
        sequence seqif1;
        instruction insif1;
        Pvecteur v;
        Value  constante;
        seqif1=make_sequence(lisjcopy2);
        insif1=make_instruction_sequence(seqif1);
        sif1=instruction_to_statement(insif1);
        if (value_abs  (vect_coeff(indice2,pvif2))==1){  
          lisi=gen_concatenate(lisjcopy2,lisi);
          sequence_statements(seqi)=lisi;  
        }  
        else{
          list lexp;
          call ca;
          expression exp1,exp2;
          Pvecteur pv;
          Value val;
          statement s/*,s1*/;
          pv=vect_dup (pvif2);
          val=vect_coeff(indice2,pvif2);
          vect_erase_var( &pv,indice2);
          exp1=Pvecteur_to_expression(pv);;
            s= copy_statement (last);
 
            lexp = CONS(EXPRESSION, int_to_expression
                      (-val), NIL);
           lexp = CONS(EXPRESSION, exp1, lexp); 
          ca = make_call(entity_intrinsic(MODULO_OPERATOR_NAME), lexp);
          exp1 = make_expression(make_syntax(is_syntax_call, ca),
                                 normalized_undefined);
            exp2=int_to_expression(0);
            exp1=eq_expression(exp1,exp2); 
              test_condition(instruction_test(statement_instruction(s)))=exp1;    
                test_true(instruction_test(statement_instruction(s)))=copy_statement (sif1);   
            lisi=CONS(STATEMENT,s,lisi);
              sequence_statements(seqi)=lisi; 
        };
        v = vect_dup (contrainte_vecteur(cinf));
        constante=vect_coeff(TCST,v);
        vect_chg_coeff(&v,TCST,value_plus(1,constante)); 
        cinf=contrainte_make(v);
        range_lower(range)=make_contrainte_expression(cinf,indice2);  
        }  
      /*fin cas3 */
      /* debut cas4 */
        
      if ( egalite_equal(csup,cif1)){
        statement sif2;
        sequence seqif2;
        instruction insif2;
        Pvecteur v;
        list listemp;
        Value  constante;
        seqif2=make_sequence(lisjcopy);
        insif2=make_instruction_sequence(seqif2);
        sif2=instruction_to_statement(insif2);
        if (value_abs  (vect_coeff(indice2,pvif1))==1){  
          lisi=gen_concatenate(lisi,lisjcopy);
          sequence_statements(seqi)=lisi;  
        }  
        else{
          list lexp;
          call ca;
          expression exp1,exp2;
          Pvecteur pv;
          statement s;
          pv=vect_dup (pvif1); 
          vect_erase_var( &pv,indice2);
          exp1=Pvecteur_to_expression(pv);
          s= copy_statement (first);
          lexp = CONS(EXPRESSION, int_to_expression
                      (-vect_coeff(indice2,pvif1)), NIL);
          lexp = CONS(EXPRESSION, exp1, lexp);
          ca = make_call(entity_intrinsic(MODULO_OPERATOR_NAME), lexp);
          exp1 = make_expression(make_syntax(is_syntax_call, ca),
                                 normalized_undefined);
          exp2=int_to_expression(0);
          exp1=eq_expression(exp1,exp2);
          test_condition(instruction_test(statement_instruction(s)))=exp1;    
          test_true(instruction_test(statement_instruction(s)))=copy_statement(sif2);
          listemp=CONS(STATEMENT,s ,NIL);
          lisi= gen_concatenate(lisi,listemp);
          sequence_statements(seqi)=lisi;  
        };
        v=vect_dup( contrainte_vecteur(csup));
        constante=vect_coeff(TCST,v);
        vect_chg_coeff(&v,TCST,value_plus(1,constante)); 
        csup=contrainte_make(v);
        range_upper(range)=make_contrainte_expression(csup,indice2);  
        
        }  
      
      /*fin cas4 */
    };
    if (i%2==0){
        if (condition1||condition2) isoler =i; 
    }
 
  };
  lis= gen_nreverse(lis);
  i=-1;
  lisp=lis; 
  FOREACH(STATEMENT,s,lis)
  {
      i++;if((i!=isoler)&&(i%2==0)&&(i!=isoler2)) {
    if(i==0) {
      CHUNK( CAR(lisp))= (gen_chunk *) make_block_statement(NIL); 
      range_lower(loop_range(tab_loop[i+1]))= 
        int_to_expression( sommetg[(i+1)/2]);  
    }
    else{
      if(i==2*nbr_vertice-2){
        CHUNK( CAR(lisp))= (gen_chunk *) make_block_statement(NIL); 
        range_upper(loop_range(tab_loop[i-1]))= 
          int_to_expression(sommetg[(i-1)/2+1]);
      }
      else{   
        body1=loop_body(tab_loop[i]);
        ins =statement_instruction(body1);
        seq=instruction_sequence(ins);
        lisi =sequence_statements(seq); 
        MAP(STATEMENT,s1,{if ( instruction_loop_p(statement_instruction(s1)))
          loop2 =s1; },lisi) ; 
        ins =statement_instruction(loop2);
        range1=loop_range(instruction_loop(ins)); 
        body1=loop_body(tab_loop[i-1]);
        ins =statement_instruction(body1);
        seq=instruction_sequence(ins);
        lisi =sequence_statements(seq); 
        MAP(STATEMENT,s1,{if ( instruction_loop_p(statement_instruction(s1)))
          loop2 =s1; },lisi) ; 
        ins =statement_instruction(loop2);
        range2=loop_range(instruction_loop(ins)); 
        body1=loop_body(tab_loop[i+1]);
        ins =statement_instruction(body1);
        seq=instruction_sequence(ins);
        lisi =sequence_statements(seq); 
        MAP(STATEMENT,s1,{if ( instruction_loop_p(statement_instruction(s1)))
          loop2 =s1; },lisi) ; 
        ins =statement_instruction(loop2);
        range3=loop_range(instruction_loop(ins)); 
        if (range_equal_p(range1,range2)) {
          CHUNK( CAR(lisp))= (gen_chunk *) make_block_statement(NIL); 
          range_upper(loop_range(tab_loop[i-1]))=
            int_to_expression( sommetg[(i-1)/2+1]);
        }
        else {
          CHUNK( CAR(lisp))= (gen_chunk *) make_block_statement(NIL); 
          if (range_equal_p(range1,range3)) 
            range_lower(loop_range(tab_loop[i+1]))= 
              int_to_expression( sommetg[(i+1)/2]);  
        }
      };  
    };
 
  };
  lisp=CDR(lisp); 
   }
    seq=make_sequence (lis);
     ins= make_instruction_sequence(seq);
     return(  instruction_to_statement(ins)); 
}

References call_arguments, CAR, CDR, CHUNK, CONS, contrainte_make(), contrainte_vecteur, copy_loop(), copy_statement(), typ_som::denominateur, egalite_equal(), entity_intrinsic(), eq_expression, eval2(), exp, EXPRESSION, expression_normalized, expression_syntax, FOREACH, gen_concatenate(), gen_full_copy_list(), gen_last(), gen_nreverse(), if1, if2, Ssysteme::inegalites, instruction_loop, instruction_loop_p, instruction_sequence, instruction_test, instruction_to_statement(), int_to_expression(), is_syntax_call, lexp, loop1, loop_body, loop_index, loop_range, make_block_statement(), make_call(), make_contrainte_expression(), make_expression(), make_instruction_loop(), make_instruction_sequence(), make_sequence(), make_syntax(), MAP, MODULO_OPERATOR_NAME, NIL, norm(), normalize_all_expressions_of(), normalized_linear, normalized_undefined, printf(), Pvecteur_to_expression(), range_equal_p(), range_lower, range_upper, s1, sc_newbase, sequence_statements, sg, sg_nbre_sommets, sg_sommets, STATEMENT, statement_instruction, Scontrainte::succ, typ_som::succ, syntax_call, TCST, test_condition, test_true, value_abs, value_direct_multiply, value_div, value_plus, vect_add_elem(), vect_chg_coeff(), vect_coeff(), vect_dup(), vect_equal(), vect_erase_var(), vect_oppos(), vect_substract(), Scontrainte::vecteur, typ_som::vecteur, and VECTEUR_NUL.

Referenced by guard_elimination().

Here is the call graph for this function:

Here is the caller graph for this function:

guard_elimination()

bool guard_elimination

(

string

module

)

set_ordering_to_statement(stat);

MAP(STATEMENT,s,{printf("%d \n",statement_ordering(s));},lis)

gen_recurse(stat, statement_domain, gen_true,);

Parameters

module

odule

Definition at line 1208 of file guard_elimination.c.

{
 
  statement stat,s1;
  string str ;
  int ordering ; 
  instruction ins;
  sequence seq;
  list lis;        
  context_t context;                              
  debug_on("GUARD_ELIMINATION_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", module);
  set_current_module_entity(local_name_to_top_level_entity(module));
  stat = (statement) db_get_memory_resource(DBR_CODE, module, true); 
  set_current_module_statement(stat);
  context.statement_stack = stack_make(statement_domain, 0, 0);
  
  // user_request
  // recherche le statement dans stat
  // appliquer...
  
  /* set_ordering_to_statement(stat); */
  ins=statement_instruction(stat);
  seq=instruction_sequence(ins);
  lis =sequence_statements(seq); 
  /* MAP(STATEMENT,s,{printf("%d \n",statement_ordering(s));},lis) */
  
  str = user_request("Which nid do you want to treat?\n"
                     "(give its ordering): ");
  ordering=atoi(str);  
  
  
  s1=ordering_to_statement(ordering);
  
  gen_context_multi_recurse(s1, &context,
                            statement_domain, stmt_flt, stmt_rwt,
                            loop_domain, loop_flt, gen_null,
                            NULL);  
  str = user_request("for Which nid do you want apply unimodular " 
                      "transformation ?\n" "(give its ordering): ");
  ordering=atoi(str); 
              
  s1=ordering_to_statement(ordering);
  MAP(STATEMENT,s,{if (statement_ordering(s)==ordering){
    s1=unimodular(s1); ; s1= free_guards(s1);  
    CHUNK(CAR(lis))= (gen_chunk *) s1;}
  ;lis=CDR(lis) ;},lis) 
    
    
    
  
    /*  gen_recurse(stat, statement_domain, gen_true,);  */
    module_reorder(stat); 
  
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module, stat);
    reset_current_module_entity();
    reset_current_module_statement();
    debug_off();
    return true;  
}

References CAR, CDR, CHUNK, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, free_guards(), gen_context_multi_recurse(), gen_null(), instruction_sequence, local_name_to_top_level_entity(), loop_domain, loop_flt(), MAP, module, module_reorder(), ordering_to_statement(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), s1, sequence_statements, set_current_module_entity(), set_current_module_statement(), stack_make(), STATEMENT, statement_domain, statement_instruction, statement_ordering, stmt_flt(), stmt_rwt(), unimodular(), and user_request().

Here is the call graph for this function:

Hierarchical_tiling()

statement Hierarchical_tiling

(

void

)

Definition at line 1021 of file tiling_sequence.c.

{
  FILE *infp;
  char *name_file;
  Pmatrix A,P;
  int rw,cl,i,j;
  list lis=NULL;
  instruction ins;
  sequence seq=NULL;
  statement s,s1;
  loop ls=NULL;
  cons *lls=NULL;
  Pbase base_oldindex = NULL;
  Pbase base_newindex = NULL;
  Pbase pb;
  expression upper=NULL,lower=NULL;
  int plus;
  Value elem_mat1,elem_mat2;
  Psysteme  loop_iteration_domaine_to_sc();
  name_file = user_request("nom du fichier pour la matrice A ");
  infp = safe_fopen(name_file,"r");
  matrix_fscan(infp,&A,&rw,&cl);
  name_file = user_request("nom du fichier pour la matrice P ");
  infp = safe_fopen(name_file,"r");
  matrix_fscan(infp,&P,&cl,&cl);
  matrix_print(A);
  matrix_print(P); 
  compute_delay_tiled_nest ();
  compute_bound_tiled_nest();
  ls=loop1;
  for(j=0;j<=depth-1;j++)
    {
      range range1;  
      range1=loop_range(ls); 
      range_lower(range1)=int_to_expression(tiled_nest[j].lower);
      range_upper(range1)= int_to_expression(tiled_nest[j].upper);
      if  (j!=depth-1) ls=instruction_loop(statement_instruction(loop_body(ls)));
    };
  s1=loop_to_statement(loop1);
  while(instruction_loop_p(statement_instruction (s1))) {
    lls = CONS(STATEMENT,s1,lls);
    s1 = loop_body(instruction_loop(statement_instruction(s1)));
  }
  (void)loop_iteration_domaine_to_sc(lls, &base_oldindex);
 
  derive_new_basis_deux(base_oldindex, &base_newindex , make_tile_index_entity_n);
  tiling_indice= ( Pvecteur  *)malloc(depth *sizeof( Pvecteur*));
  plus=depth*3-1;
  for (pb =base_newindex; pb!=NULL; pb=pb->succ) {
    loop tl;
    switch(plus%3)
      {
      case 2: 
        {
          elem_mat1=MATRIX_ELEM(A,plus/3+1,plus);
          elem_mat2=MATRIX_ELEM(A,plus/3+1,plus+1);
          upper= int_to_expression(value_minus(elem_mat1,VALUE_ONE));
          lower= int_to_expression(0);
          tiling_indice[plus/3]=vect_make(VECTEUR_NUL,vecteur_var(pb),elem_mat2,TCST,VALUE_ZERO);
        };
        break;
      case 1: 
        { 
          elem_mat1=MATRIX_ELEM(A,plus/3+1,plus) ;
          elem_mat2=MATRIX_ELEM(A,plus/3+1,plus+1  ) ;
          upper= int_to_expression(value_minus(value_div(elem_mat1,elem_mat2),VALUE_ONE));
          lower= int_to_expression(0);
          tiling_indice[plus/3]=vect_make( tiling_indice[plus/3],pb->var , elem_mat2,TCST,VALUE_ZERO);
        };
        break;   
      case 0:
        { 
          elem_mat1=MATRIX_ELEM(A,plus/3+1,plus+1);
          upper= int_to_expression(value_div(tiled_nest[plus/3].upper,elem_mat1));
          lower= int_to_expression(0);
          tiling_indice[plus/3]=vect_make( tiling_indice[plus/3],pb->var ,elem_mat1,TCST,VALUE_ZERO);
        };
      default: break;
      }  
    tl = make_loop((entity) vecteur_var(pb),
                   make_range(copy_expression(lower), copy_expression(upper),
                              int_to_expression(1)),
                   s1,
                   entity_empty_label(),
                   make_execution(is_execution_sequential, UU),
                   NIL);
    s1 = instruction_to_statement(make_instruction(is_instruction_loop, tl));
    plus--;
  };
  
  printf(" azuuuul lalallalalal \n"); getchar();
 
  /******/
  for (i=k1-1;i>=0;i--)
    {
      expression e1,e2,e,gauche=NULL,droite=NULL,delai_plus;
      test t;
      call c;
      int m;
      Pvecteur pv;
      e1=ge_expression(Pvecteur_to_expression (tiling_indice[0]),
                       Value_to_expression( value_plus(sequen[i].nd[0].lower,
                                                       MATRIX_ELEM( sequen[i].delai,1,1))));
      e2=le_expression(Pvecteur_to_expression (tiling_indice[0]), 
                       Value_to_expression( value_plus(sequen[i].nd[0].upper,
                                                       MATRIX_ELEM( sequen[i].delai,1,1))));
      if (value_eq( value_plus(sequen[i].nd[0].lower,MATRIX_ELEM( sequen[i].delai,1,1)),tiled_nest[0].lower))
        {
          if (value_eq( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)),tiled_nest[0].upper)&&
              value_eq(value_mod( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)), 
                                  MATRIX_ELEM(A,1,1)),VALUE_ZERO))
            e=NULL;
          else
            e=e2;
        }
      else
        {
          if (value_eq( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)),tiled_nest[0].upper)&&
              value_eq(value_mod( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)), 
                                  MATRIX_ELEM(A,1,1)),VALUE_ZERO))
            e=e1;
           
          else
            e=and_expression(e1,e2);
            
        };
    
      for(j=0;j<=depth-1;j++)
        {
         
          if (j>=1) 
            { 
               
             
              print_expression(Pvecteur_to_expression (tiling_indice[j])  );
               
              
              e1=ge_expression( Pvecteur_to_expression (tiling_indice[j]),
                                Value_to_expression(value_plus(sequen[i].nd[j].lower,
                                                               MATRIX_ELEM( sequen[i].delai,j+1,1))));
             
              e2=le_expression(Pvecteur_to_expression (tiling_indice[j]), 
                               Value_to_expression( value_plus(sequen[i].nd[j].upper,
                                                               MATRIX_ELEM( sequen[i].delai,j+1,1))));
              
              if (value_eq( value_plus(sequen[i].nd[j].lower,MATRIX_ELEM( sequen[i].delai,j+1,1)),tiled_nest[j].lower))
                {
                  if (! (value_eq(value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)),tiled_nest[j].upper)&&
                         value_eq(value_mod( value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)), 
                                             MATRIX_ELEM(A,j+1,3*j+1)),VALUE_ZERO)))
                    {
                      if (e==NULL)
                        e=e2;
                      else
                        e=and_expression(e,e2);
                    };
                }
              else
                {
                  if (value_eq(value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)),tiled_nest[j].upper)&&
                      value_eq(value_mod( value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)), 
                                          MATRIX_ELEM(A,j+1,3*j+1)),VALUE_ZERO))
                    {
                      if (e==NULL)
                        e=e1;
                      else
                        e=and_expression(e,e1);
                    }
                  else
                    {
                      e1=and_expression(e1,e2);
                      if(e==NULL)
                        e=e1;
                      else
                        e=and_expression(e,e1);
                    }
                };
 
                
            }; 
          c= instruction_call(statement_instruction((sequen[i].s )));
          m=0;
          MAP(EXPRESSION,exp,{  
            if (m==0)  gauche=exp;
            if (m==1)  droite=exp;
            m++;
          },call_arguments(c)) ;
          pv = vect_make(tiling_indice[j],TCST,value_uminus(MATRIX_ELEM(sequen[i].delai,j+1,1)));
          delai_plus=Pvecteur_to_expression(pv);
      replace_entity_by_expression(gauche,(entity) sequen[i].nd[j].index,delai_plus);
      FOREACH(EXPRESSION,exp,call_arguments( syntax_call(expression_syntax(droite))))
          replace_entity_by_expression(exp,(entity) sequen[i].nd[j].index,delai_plus);
        };
      t= make_test(e,sequen[i].s,make_block_statement(NIL));
      s=test_to_statement(t);
      if(i==k1-1)   lis=CONS(STATEMENT,s,NIL);
      else      lis=CONS(STATEMENT,s,lis);
    };
  seq= make_sequence(lis);
  ins= make_instruction_sequence(seq);
  s= instruction_to_statement(ins);
  ls=instruction_loop(statement_instruction(s1));
  for(j=0;j<=3*depth-1;j++)
    if  (j!=3*depth-1) ls=instruction_loop(statement_instruction(loop_body(ls)));
    else loop_body(ls)=s;
  s1=permutation(s1,P);
  return s1;
}

References A, and_expression, call_arguments, compute_bound_tiled_nest(), compute_delay_tiled_nest(), CONS, copy_expression(), depth, derive_new_basis_deux(), entity_empty_label(), exp, EXPRESSION, expression_syntax, FOREACH, ge_expression, INFO_LOOP::index, instruction_call, instruction_loop, instruction_loop_p, instruction_to_statement(), int_to_expression(), is_execution_sequential, is_instruction_loop, k1, le_expression, loop1, loop_body, loop_iteration_domaine_to_sc(), loop_range, loop_to_statement, INFO_LOOP::lower, make_block_statement(), make_execution(), make_instruction(), make_instruction_sequence(), make_loop(), make_range(), make_sequence(), make_test(), make_tile_index_entity_n(), malloc(), MAP, MATRIX_ELEM, matrix_fscan(), matrix_print(), NIL, permutation(), print_expression(), printf(), Pvecteur_to_expression(), range_lower, range_upper, replace_entity_by_expression(), s1, safe_fopen(), sequen, STATEMENT, statement_instruction, Svecteur::succ, syntax_call, TCST, test_to_statement, tiled_nest, tiling_indice, INFO_LOOP::upper, user_request(), UU, value_div, value_eq, value_minus, value_mod, VALUE_ONE, value_plus, Value_to_expression(), value_uminus, VALUE_ZERO, Svecteur::var, vect_make(), VECTEUR_NUL, and vecteur_var.

Referenced by tiling_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_statistics()

bool loop_statistics

(

const

string

)

cproto-generated files

stats.c

Parameters

string

ame

Definition at line 450 of file stats.c.

{
  statement stat;
  string filename, localfilename; 
  context_t context;
                                  
  debug_on("STATISTICS_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", name);
  set_current_module_entity(local_name_to_top_level_entity(name));
 
  initialize() ;
  
  stat = (statement) db_get_memory_resource(DBR_CODE, name, true); 
 
  context.contenu = hash_table_make(hash_pointer, 0);  
  context.depth   = hash_table_make(hash_pointer, 0);
  context.statement_stack = stack_make(statement_domain, 0, 0); 
   
  
  gen_context_multi_recurse
    (stat, & context, 
     statement_domain, stmt_flt, stmt_rwt,
     sequence_domain, seq_flt, seq_rwt,
     test_domain, test_flt, test_rwt,
     loop_domain, loop_flt, loop_rwt,
     call_domain, call_flt, call_rwt,
     whileloop_domain, gen_true, wl_rwt,
     unstructured_domain, uns_flt, uns_rwt,
     expression_domain, gen_false, gen_null,
     NULL); 
 
 
  hash_table_free(context.contenu);
 
 
  hash_table_free(context.depth);
  stack_free(&context.statement_stack); 
 
  localfilename = db_build_file_resource_name(DBR_STATS_FILE,
                                              name, ".loop_stats");
 
  filename = strdup(concatenate(db_get_current_workspace_directory(), 
                                "/", localfilename, NULL));
 
   put_result(filename);  
   free(nbr_no_perf_nest_loop_of_depth);
   free(nbr_perf_nest_loop_of_depth);
  free(filename);
  DB_PUT_FILE_RESOURCE(DBR_STATS_FILE, name, localfilename);
  reset_current_module_entity();
  
pips_debug(1, "done.\n");
  debug_off();
   
  return true;
}

References call_domain, call_flt(), call_rwt(), concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, expression_domain, free(), gen_context_multi_recurse(), gen_false(), gen_null(), gen_true(), hash_pointer, hash_table_free(), hash_table_make(), initialize(), local_name_to_top_level_entity(), loop_domain, loop_flt(), loop_rwt(), nbr_no_perf_nest_loop_of_depth, nbr_perf_nest_loop_of_depth, pips_debug, put_result(), reset_current_module_entity(), seq_flt(), seq_rwt(), sequence_domain, set_current_module_entity(), stack_free(), stack_make(), statement_domain, stmt_flt(), stmt_rwt(), strdup(), test_domain, test_flt(), test_rwt(), uns_flt(), uns_rwt(), unstructured_domain, whileloop_domain, and wl_rwt().

Here is the call graph for this function:

permutation()

statement permutation	(	statement	s,
		Pmatrix	P
	)

Definition at line 957 of file tiling_sequence.c.

{
  statement scopy;
  int i,j;
  loop ls1,ls2;
  bool found=false;
  scopy=copy_statement(s);
  ls1=instruction_loop(statement_instruction(scopy));
  for(i=1;i<=3*depth;i++)
    {
      j=1;
      found=false;
      ls2=instruction_loop(statement_instruction(s));
      while ((j<=3*depth)&& !found)
        {
          if (value_eq(MATRIX_ELEM(P,i,j),VALUE_ONE))
            {
              found =true;
              loop_index(ls1)=loop_index(ls2);
              loop_range(ls1)=loop_range(ls2);
            };
          ls2=instruction_loop(statement_instruction(loop_body(ls2)));
          j++;
        };
      ls1=instruction_loop(statement_instruction(loop_body(ls1)));
    }
  
  return scopy;
}

References copy_statement(), depth, instruction_loop, loop_body, loop_index, loop_range, MATRIX_ELEM, statement_instruction, value_eq, and VALUE_ONE.

Referenced by Hierarchical_tiling(), and Tiling2_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

permutation2()

statement permutation2	(	statement	s,
		Pmatrix	P
	)

Definition at line 989 of file tiling_sequence.c.

{
  statement scopy;
  int i,j;
  loop ls1,ls2;
  bool found=false;
  scopy=copy_statement(s);
  ls1=instruction_loop(statement_instruction(scopy));
  for(i=1;i<=2*depth;i++)
    {
      j=1;
      found=false;
      ls2=instruction_loop(statement_instruction(s));
      while ((j<=2*depth)&& !found)
        {
          if (value_eq(MATRIX_ELEM(P,i,j),VALUE_ONE))
            {
              found =true;
              loop_index(ls1)=loop_index(ls2);
              loop_range(ls1)=loop_range(ls2);
            };
          ls2=instruction_loop(statement_instruction(loop_body(ls2)));
          j++;
        };
      ls1=instruction_loop(statement_instruction(loop_body(ls1)));
    }
  
  return scopy;
}

References copy_statement(), depth, instruction_loop, loop_body, loop_index, loop_range, MATRIX_ELEM, statement_instruction, value_eq, and VALUE_ONE.

Referenced by Tiling_buffer_allocation().

Here is the call graph for this function:

Here is the caller graph for this function:

position_one_element()

int position_one_element	(	Pmatrix	P,
		int	i
	)

Definition at line 1232 of file tiling_sequence.c.

{
  int j;
  for (j=1;j<=depth;j++)
    if(MATRIX_ELEM(P,i,j)==VALUE_ONE) return j;
  pips_internal_error("asking for a non existing element");
  return -1;
}

References depth, MATRIX_ELEM, pips_internal_error, and VALUE_ONE.

Referenced by Tiling_buffer_allocation().

Here is the caller graph for this function:

Tiling2_buffer()

statement Tiling2_buffer

(

void

)

Definition at line 2265 of file tiling_sequence.c.

{
  FILE *infp;
  char *name_file;
  Pmatrix A,A1,A2,P, P1,P2,P3;
  int rw,cl,i,j;
  list lis=NULL;
  instruction ins;
  sequence seq=NULL;
  statement s,s1,s2;
  loop ls=NULL;
  cons *lls=NULL;
  Pbase base_oldindex = NULL;
  Pbase base_newindex = NULL;
  Pbase pb;
  expression upper=NULL,lower=NULL;
  int plus;
  Value elem_mat1,elem_mat2;
  Psysteme  loop_iteration_domaine_to_sc();
  //  void  full_loop_unroll();
  name_file = user_request("nom du fichier pour la matrice A ");
  infp = safe_fopen(name_file,"r");
  matrix_fscan(infp,&A,&rw,&cl);
  name_file = user_request("nom du fichier pour la matrice P ");
  infp = safe_fopen(name_file,"r");
  matrix_fscan(infp,&P,&cl,&cl);
  matrix_print(A);
  matrix_print(P); 
  P1=matrix_new(depth,depth);
  for(i=1;i<=depth;i++)
    for(j=1;j<=3*depth;j=j+3)
      {
        if ( value_eq(MATRIX_ELEM(P,i,j),VALUE_ONE))
          MATRIX_ELEM(P1,i,j/3+1)=VALUE_ONE;
        else 
          MATRIX_ELEM(P1,i,j/3+1)=VALUE_ZERO;
      };
 
  P2=matrix_new(depth,depth);
  for(i=depth+1;i<=2*depth;i++)
    for(j=2;j<=3*depth;j=j+3)
      {
        if (value_eq(MATRIX_ELEM(P,i,j),VALUE_ONE))
          MATRIX_ELEM(P2,(i-1)%depth+1,j/3+1)=VALUE_ONE;
        else 
          MATRIX_ELEM(P2,(i-1)%depth+1,j/3+1)=VALUE_ZERO;
      };
  
  P3=matrix_new(depth,depth);
  for(i=2*depth+1;i<=3*depth;i++)
    for(j=3;j<=3*depth;j=j+3)
      {
        if (value_eq(MATRIX_ELEM(P,i,j),VALUE_ONE))
          MATRIX_ELEM(P3,(i-1)%depth+1,j/3)=VALUE_ONE;
        else 
          MATRIX_ELEM(P3,(i-1)%depth+1,j/3)=VALUE_ZERO;
      };
 
 
  A1=matrix_new(depth,1);
  for(i=0;i<=depth-1;i++)
    MATRIX_ELEM(A1,i+1,1)=MATRIX_ELEM(A,i+1,3*i+1);
 
  A2=matrix_new(depth,1);
  for(i=0;i<=depth-1;i++)
    MATRIX_ELEM(A2,i+1,1)=MATRIX_ELEM(A,i+1,3*i+2);
 
 
 
 matrix_print(P1);
 matrix_print(P2);
 matrix_print(P3);
 matrix_print(A1);
 matrix_print(A2);
 
 getchar();
 getchar(); 
 
  compute_delay_tiled_nest ();
  compute_bound_tiled_nest();
  ls=loop1;
  for(j=0;j<=depth-1;j++)
    {
      range range1;  
      range1=loop_range(ls); 
      range_lower(range1)=int_to_expression(tiled_nest[j].lower);
      range_upper(range1)= int_to_expression(tiled_nest[j].upper);
      if  (j!=depth-1) ls=instruction_loop(statement_instruction(loop_body(ls)));
    };
  s1=loop_to_statement(loop1);
  while(instruction_loop_p(statement_instruction (s1))) {
    lls = CONS(STATEMENT,s1,lls);
    s1 = loop_body(instruction_loop(statement_instruction(s1)));
  }
  (void)loop_iteration_domaine_to_sc(lls, &base_oldindex);
 
  derive_new_basis_deux(base_oldindex, &base_newindex , make_tile_index_entity_n);
  tiling_indice= ( Pvecteur  *)malloc(depth *sizeof( Pvecteur*));
  plus=depth*3-1;
  for (pb =base_newindex; pb!=NULL; pb=pb->succ) {
    loop tl;
    switch(plus%3)
      {
      case 2: 
        {
          elem_mat1=MATRIX_ELEM(A,plus/3+1,plus);
          elem_mat2=MATRIX_ELEM(A,plus/3+1,plus+1);
          upper= int_to_expression(value_minus(elem_mat1,VALUE_ONE));
          lower= int_to_expression(0);
          tiling_indice[plus/3]=vect_make(VECTEUR_NUL,vecteur_var(pb),elem_mat2,TCST,VALUE_ZERO);
        };
        break;
      case 1: 
        { 
          elem_mat1=MATRIX_ELEM(A,plus/3+1,plus) ;
          elem_mat2=MATRIX_ELEM(A,plus/3+1,plus+1  ) ;
          upper= int_to_expression(value_minus(value_div(elem_mat1,elem_mat2),VALUE_ONE));
          lower= int_to_expression(0);
          tiling_indice[plus/3]=vect_make( tiling_indice[plus/3],pb->var , elem_mat2,TCST,VALUE_ZERO);
        };
        break;   
      case 0:
        { 
          elem_mat1=MATRIX_ELEM(A,plus/3+1,plus+1);
          upper= int_to_expression(value_div(tiled_nest[plus/3].upper,elem_mat1));
          lower= int_to_expression(0);
          tiling_indice[plus/3]=vect_make( tiling_indice[plus/3],pb->var ,elem_mat1,TCST,VALUE_ZERO);
        };
      default: break;
      }  
    tl = make_loop((entity) vecteur_var(pb),
                   make_range(copy_expression(lower), copy_expression(upper),
                              int_to_expression(1)),
                   s1,
                   entity_empty_label(),
                   make_execution(is_execution_sequential, UU),
                   NIL);
    s1 = instruction_to_statement(make_instruction(is_instruction_loop, tl));
    plus--;
  };
  
 
 
  /******/
  for (i=k1-1;i>=0;i--)
    {
      expression e1,e2,e,gauche=NULL,droite=NULL,delai_plus;
      test t;
      call c;
      int m;
      Pvecteur pv;
      e1=ge_expression(Pvecteur_to_expression (tiling_indice[0]),
                       Value_to_expression( value_plus(sequen[i].nd[0].lower,
                                                       MATRIX_ELEM( sequen[i].delai,1,1))));
      e2=le_expression(Pvecteur_to_expression (tiling_indice[0]), 
                       Value_to_expression( value_plus(sequen[i].nd[0].upper,
                                                       MATRIX_ELEM( sequen[i].delai,1,1))));
      if (value_eq( value_plus(sequen[i].nd[0].lower,MATRIX_ELEM( sequen[i].delai,1,1)),tiled_nest[0].lower))
        {
          if (value_eq( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)),tiled_nest[0].upper)&&
              value_eq(value_mod( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)), 
                                  MATRIX_ELEM(A,1,1)),VALUE_ZERO))
            e=NULL;
          else
            e=e2;
        }
      else
        {
          if (value_eq( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)),tiled_nest[0].upper)&&
              value_eq(value_mod( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)), 
                                  MATRIX_ELEM(A,1,1)),VALUE_ZERO))
            e=e1;
           
          else
            e=and_expression(e1,e2);
            
        };
      for(j=0;j<=depth-1;j++)
        {
          if (j>=1) 
            {
              e1=ge_expression( Pvecteur_to_expression (tiling_indice[j]),
                                Value_to_expression(value_plus(sequen[i].nd[j].lower,
                                                               MATRIX_ELEM( sequen[i].delai,j+1,1))));
              e2=le_expression(Pvecteur_to_expression (tiling_indice[j]), 
                               Value_to_expression( value_plus(sequen[i].nd[j].upper,
                                                               MATRIX_ELEM( sequen[i].delai,j+1,1))));
              if (value_eq( value_plus(sequen[i].nd[j].lower,MATRIX_ELEM( sequen[i].delai,j+1,1)),tiled_nest[j].lower))
                {
                  if (! (value_eq(value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)),tiled_nest[j].upper)&&
                         value_eq(value_mod( value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)), 
                                             MATRIX_ELEM(A,j+1,3*j+1)),VALUE_ZERO)))
                    {
                      if (e==NULL)
                        e=e2;
                      else
                        e=and_expression(e,e2);
                    };
                }
              else
                {
                  if (value_eq(value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)),tiled_nest[j].upper)&&
                      value_eq(value_mod( value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)), 
                                          MATRIX_ELEM(A,j+1,3*j+1)),VALUE_ZERO))
                    {
                      if (e==NULL)
                        e=e1;
                      else
                        e=and_expression(e,e1);
                    }
                  else
                    {
                      e1=and_expression(e1,e2);
                      if(e==NULL)
                        e=e1;
                      else
                        e=and_expression(e,e1);
                    }
                };
            }; 
          c= instruction_call(statement_instruction((sequen[i].s )));
          m=0;
          MAP(EXPRESSION,exp,{  
            if (m==0)  gauche=exp;
            if (m==1)  droite=exp;
            m++;
          },call_arguments(c)) ;
          pv = vect_make(tiling_indice[j],TCST,value_uminus(MATRIX_ELEM(sequen[i].delai,j+1,1)));
          delai_plus=Pvecteur_to_expression(pv);
      replace_entity_by_expression(gauche,(entity) sequen[i].nd[j].index,delai_plus);
      FOREACH(EXPRESSION,exp,call_arguments( syntax_call(expression_syntax(droite))))
        replace_entity_by_expression(exp,(entity) sequen[i].nd[j].index,delai_plus);
        };
      t= make_test(e,sequen[i].s,make_block_statement(NIL));
      s=test_to_statement(t);
      if(i==k1-1)   lis=CONS(STATEMENT,s,NIL);
      else      lis=CONS(STATEMENT,s,lis);
    };
  seq= make_sequence(lis);
  ins= make_instruction_sequence(seq);
  s= instruction_to_statement(ins);
  ls=instruction_loop(statement_instruction(s1));
  for(j=0;j<=3*depth-1;j++)
    if  (j!=3*depth-1) ls=instruction_loop(statement_instruction(loop_body(ls)));
    else loop_body(ls)=s;
  s1=permutation(s1,P);
  
  i=1;
  s2=s1;
  while (i <=2*depth)
    {
      printf(" %d \n", i);
      s2= loop_body(instruction_loop(statement_instruction(s2)));
      i++;
    }
  print_statement(s2);
  printf(" tptpto \n");
  unroll_recursive(s2,depth);
 
  
  return s1;
}

References A, and_expression, call_arguments, compute_bound_tiled_nest(), compute_delay_tiled_nest(), CONS, copy_expression(), depth, derive_new_basis_deux(), entity_empty_label(), exp, EXPRESSION, expression_syntax, FOREACH, ge_expression, INFO_LOOP::index, instruction_call, instruction_loop, instruction_loop_p, instruction_to_statement(), int_to_expression(), is_execution_sequential, is_instruction_loop, k1, le_expression, loop1, loop_body, loop_iteration_domaine_to_sc(), loop_range, loop_to_statement, INFO_LOOP::lower, make_block_statement(), make_execution(), make_instruction(), make_instruction_sequence(), make_loop(), make_range(), make_sequence(), make_test(), make_tile_index_entity_n(), malloc(), MAP, MATRIX_ELEM, matrix_fscan(), matrix_new(), matrix_print(), NIL, permutation(), print_statement(), printf(), Pvecteur_to_expression(), range_lower, range_upper, replace_entity_by_expression(), s1, safe_fopen(), sequen, STATEMENT, statement_instruction, Svecteur::succ, syntax_call, TCST, test_to_statement, tiled_nest, tiling_indice, unroll_recursive(), INFO_LOOP::upper, user_request(), UU, value_div, value_eq, value_minus, value_mod, VALUE_ONE, value_plus, Value_to_expression(), value_uminus, VALUE_ZERO, Svecteur::var, vect_make(), VECTEUR_NUL, and vecteur_var.

Referenced by tiling_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

Tiling_buffer_allocation()

statement Tiling_buffer_allocation

(

void

)

---

gauche=NULL,droite=NULL

Definition at line 1242 of file tiling_sequence.c.

{
  FILE *infp;
  char *name_file;
  Pmatrix A,P,ATE,ATEP,ATEPP,P1,P2,N[nid_nbr],NP[nid_nbr],G_PRO[nid_nbr], G_PROP[nid_nbr],G_PROPP[nid_nbr];
  int rw,cl,i,j,k,pos;
  list lis=NULL,lis1=NULL,lis2=NULL;
  instruction ins;
  sequence seq=NULL;
  statement s, s1, sequenp[nid_nbr],
    ps1 = statement_undefined, ps2 = statement_undefined /*,*pst1*/;
  loop ls=NULL;
  cons *lls=NULL;
  Pbase base_oldindex = NULL;
  Pbase base_newindex = NULL;
  Pbase pb;
  expression upper=NULL,lower=NULL,exp=NULL;
  int plus;
  Value elem_mat1,elem_mat2;
  entity *ref[nid_nbr],name;
  reference *buf_ref[nid_nbr];
  statement *scopy[nid_nbr];
  Psysteme  loop_iteration_domaine_to_sc();
  Variable *iter, *itert;
  name_file = user_request("nom du fichier pour la matrice A ");
  infp = safe_fopen(name_file,"r");
  matrix_fscan(infp,&A,&rw,&cl);
  name_file = user_request("nom du fichier pour la matrice P ");
  infp = safe_fopen(name_file,"r");
  matrix_fscan(infp,&P,&cl,&cl);
  compute_delay_tiled_nest ();
  compute_bound_tiled_nest();
  P1=matrix_new(depth,depth);
  
  for(i=1;i<=depth;i++)
    for(j=1;j<=2*depth;j=j+2)
      {
        if ( value_eq(MATRIX_ELEM(P,i,j),VALUE_ONE))
          MATRIX_ELEM(P1,i,j/2+1)=VALUE_ONE;
        else 
          MATRIX_ELEM(P1,i,j/2+1)=VALUE_ZERO;
      };
  
  
  P2=matrix_new(depth,depth);
  for(i=depth+1;i<=2*depth;i++)
    for(j=2;j<=2*depth;j=j+2)
      {
        if (value_eq(MATRIX_ELEM(P,i,j),VALUE_ONE))
          MATRIX_ELEM(P2,(i-1)%depth+1,j/2)=VALUE_ONE;
        else 
          MATRIX_ELEM(P2,(i-1)%depth+1,j/2)=VALUE_ZERO;
      };
  
  ATE=matrix_new(depth,1);
  for(i=0;i<=depth-1;i++)
    MATRIX_ELEM(ATE,i+1,1)=MATRIX_ELEM(A,i+1,2*i+1);
 
  ATEP=matrix_new(depth,1);
  matrix_multiply(P1,ATE,ATEP);
  ATEPP=matrix_new(depth,1);
  matrix_multiply(P2,ATE,ATEPP);
 
 
 
 
  s1=loop_to_statement(loop1);
  while(instruction_loop_p(statement_instruction (s1))) {
    lls = CONS(STATEMENT,s1,lls);
    s1 = loop_body(instruction_loop(statement_instruction(s1)));
  }
 
  (void)loop_iteration_domaine_to_sc(lls, &base_oldindex);
  derive_new_basis_une(base_oldindex, &base_newindex , make_tile_index_entity_n);
 
  iter= ( Variable  *)malloc(depth *sizeof( Variable));
  itert=( Variable  *)malloc(depth *sizeof( Variable));
  i=2*depth-1;
  for (pb =base_newindex; pb!=NULL; pb=pb->succ) {
    if (i%2==1) iter[i/2]=(pb->var);
    else itert[i/2]=(pb->var);
    i--;
  };
  
    
  for(i=0;i<=k1-1;i++)
    {
      //statement s1;
      sequence seq;
      instruction ins;
 
      Pvecteur pv;
      Value con;
      expression e,gauche=expression_undefined,cavite=expression_undefined;
      test t;
      statement s;
      call c;
      int m;
      
      N[i]=matrix_new(depth,1);
      for (j=1;j<=depth;j++)
        MATRIX_ELEM(N[i],j,1)= value_plus(value_minus(sequen[i].nd[j-1].upper,sequen[i].nd[j-1].lower),VALUE_ONE);
      NP[i]=matrix_new(depth,1);
      matrix_multiply(P1,N[i],NP[i]);
   
      if (i<=k1-2)
        { 
          
          
          lis2=NULL;
          G_PRO[i]=matrix_new(depth,1);
          for(j=1;j<=depth;j++)
            {
              
              Value temp;
         
              temp=value_minus(MATRIX_ELEM(sequen[i+1].delai,j,1),MATRIX_ELEM(sequen[i].delai,j,1));
              MATRIX_ELEM( G_PRO[i],j,1)=value_minus(temp, MATRIX_ELEM(sequen[i+1].st[0],j,1));
              for(k=1;k<=sequen[i].nbr_stencil-1;k++)
                {   
                  if (MATRIX_ELEM( G_PRO[i],j,1)< value_minus(temp, MATRIX_ELEM(sequen[i].st[k],j,1)))
                    MATRIX_ELEM( G_PRO[i],j,1)=value_minus(temp, MATRIX_ELEM(sequen[i].st[k],j,1));
                };
            };
             
          G_PROP[i]=matrix_new(depth,1);
          matrix_multiply(P1,G_PRO[i],G_PROP[i]);
          G_PROPP[i]=matrix_new(depth,1);
          matrix_multiply(P2,G_PRO[i],G_PROPP[i]);
          ref[i]= ( entity  *)malloc((depth+1) *sizeof( entity));
          buf_ref[i]=( reference  *)malloc((depth+1) *sizeof( reference));
          scopy[i]=( statement   *)malloc((depth+1) *sizeof( statement));
         
          for(j=1;j<=depth;j++)
            {         
 
              lis= NULL;
              lis1=NULL;
             
              lis=CONS(DIMENSION, make_dimension(int_to_expression(0),
                                                 int_to_expression(1),
                                                 NIL),
                       lis);
              pos=position_one_element(P1,j);
              pv= vect_make(VECTEUR_NUL ,itert[pos-1], VALUE_ONE,TCST,VALUE_ZERO);
              exp= binary_intrinsic_expression ("MOD",Pvecteur_to_expression(pv ),Value_to_expression(2));
              lis1 =CONS(EXPRESSION, exp,lis1);
         
              for (k=1;k<=j-1;k++)
                {
                 
                  lis=CONS(DIMENSION,
                           make_dimension(int_to_expression(0),
                                          Value_to_expression(value_minus 
                                                              (MATRIX_ELEM(ATEP,k,1),VALUE_ONE)),
                                          NIL),
                           lis);
                  pos=position_one_element(P1,k);
                  pv= vect_make(VECTEUR_NUL ,iter[pos-1], VALUE_ONE,TCST,VALUE_ZERO);
                  exp=Pvecteur_to_expression(pv);
                 
                  lis1 =CONS(EXPRESSION, exp,lis1);
                }
 
              if (value_minus (MATRIX_ELEM(G_PROP[i],j,1),VALUE_ONE)==VALUE_MONE)
                {
 
                  cavite=int_to_expression(0);
                }
              
              else 
                { 
 
                  cavite =Value_to_expression(value_minus (MATRIX_ELEM(G_PROP[i],j,1),VALUE_ONE));
                };
              lis=CONS(DIMENSION,
                       make_dimension(int_to_expression(0),
                                      cavite,
                                      NIL), 
                       lis);
              pos=position_one_element(P1,k);
              con=value_minus(MATRIX_ELEM(G_PRO[i],pos,1), MATRIX_ELEM(ATE,pos,1));    
              pv= vect_make(VECTEUR_NUL ,iter[pos-1], VALUE_ONE,TCST,con);
              
              exp=Pvecteur_to_expression(pv);
             
              lis1 =CONS(EXPRESSION, exp,lis1);
              for (k=j+1;k<=depth;k++)
                {
                  Value v1;
                  lis=CONS(DIMENSION,
                           make_dimension(int_to_expression(0),
                                          Value_to_expression(value_minus 
                                                              (MATRIX_ELEM(NP[i],k,1), VALUE_ONE)),
                                          NIL),
                           lis);
                  pos=position_one_element(P1,k);
                 v1=sequen[i].nd[pos-1].lower+MATRIX_ELEM( sequen[i].delai,pos,1 );
                 
                 
                 pv= vect_make(VECTEUR_NUL ,iter[pos-1], VALUE_ONE,itert[pos-1], MATRIX_ELEM(ATE,pos,1) ,TCST,
                                value_uminus(v1)  );
                 
                  vect_dump(pv);
                  exp=Pvecteur_to_expression(pv);
                  print_expression(exp);
                 
                  lis1 =CONS(EXPRESSION, exp,lis1);
                }
              
           
              name= internal_make_new_array_variable(i+1,j,get_current_module_entity() , make_basic(is_basic_int, (void *) 4), lis);
              buf_ref[i][j-1]=make_reference(name,lis1);
              ref[i][j-1]=name;
              scopy[i][j-1]=copy_statement(sequen[i].s);
 
              pos=position_one_element(P1,j);
              con=value_minus(MATRIX_ELEM(G_PRO[i],pos,1), MATRIX_ELEM(ATE,pos,1));  
              pv= vect_make(VECTEUR_NUL ,iter[pos-1], VALUE_ONE,TCST,con);
              e=ge_expression( Pvecteur_to_expression (pv), Value_to_expression( VALUE_ZERO));
              t= make_test(e,scopy[i][j-1],make_block_statement(NIL));
              s=test_to_statement(t);
              lis2=CONS(STATEMENT,s,lis2);
              c= instruction_call(statement_instruction((   scopy[i][j-1] )));
              m=0;
              FOREACH(EXPRESSION, exp, call_arguments(c)) {  
                if (m==0)
                  gauche = exp;
                m++;
              }
              syntax_reference(expression_syntax(gauche))= buf_ref[i][j-1];
              
 
            }
         
          lis=CONS(DIMENSION,
                   make_dimension(int_to_expression(0),
                                  Value_to_expression(MATRIX_ELEM(G_PROPP[i],1,1)),
                                  NIL),
                   NIL);
          pos=position_one_element(P2,1);
          pv= vect_make(VECTEUR_NUL ,iter[pos-1], VALUE_ONE,TCST,VALUE_ZERO);
         
 
          exp= binary_intrinsic_expression ("MOD",Pvecteur_to_expression(pv ),
                                            Value_to_expression(value_plus(MATRIX_ELEM(G_PROPP[i],1,1),VALUE_ONE)));
 
          
          lis1 =CONS(EXPRESSION, exp,NIL);
          for (k=2;k<=depth;k++)
            {
              lis=CONS(DIMENSION,
                       make_dimension(int_to_expression(0),
                                      Value_to_expression(value_minus 
                                                          (MATRIX_ELEM(ATEPP,k,1),VALUE_ONE)),
                                      NIL),
                       lis);
              pos=position_one_element(P2,k);
              pv= vect_make(VECTEUR_NUL ,iter[pos-1], VALUE_ONE,TCST,VALUE_ZERO);
              exp=Pvecteur_to_expression(pv);
              
              lis1 =CONS(EXPRESSION, exp,lis1);
            }
          name= internal_make_new_array_variable(i+1,depth+1,get_current_module_entity() , make_basic(is_basic_int, (void *) 4), lis);
          buf_ref[i][depth]=make_reference(name,lis1);
          ref[i][depth]=name;
          scopy[i][depth]=copy_statement(sequen[i].s);
          c= instruction_call(statement_instruction((   scopy[i][depth] )));
          m=0;
          MAP(EXPRESSION,exp,{  
            if (m==0)  gauche=exp;
            m++;
          },call_arguments(c)) ;
          syntax_reference(expression_syntax(gauche))= buf_ref[i][depth];
          lis2=CONS(STATEMENT, scopy[i][depth],lis2);
          seq= make_sequence(lis2);
          ins= make_instruction_sequence(seq);
          sequenp[i]= instruction_to_statement(ins);
         
        };
    };
   
  for(i=1;i<=k1-2;i++)
    { 
      expression e=NULL;
      Pvecteur pv;
      Pmatrix *temp;
      reference *regi[nid_nbr];
      int m1;
     
      for(j=1;j<=depth;j++)
        {
          Value v2;
          v2=value_uminus(MATRIX_ELEM(G_PRO[i-1],j,1));
          pv= vect_make(VECTEUR_NUL,iter[j-1], VALUE_ONE,TCST ,v2);
          if (j==1)  e=ge_expression(Pvecteur_to_expression(pv),Value_to_expression(VALUE_ZERO));  
          else
            e=and_expression(e,ge_expression(Pvecteur_to_expression(pv),Value_to_expression(VALUE_ZERO)));
        }
      temp=( Pmatrix *)malloc( sequen[i].nbr_stencil *sizeof(Pmatrix));
      regi[i]=( reference *)malloc( sequen[i].nbr_stencil *sizeof(reference));;
      for(k=0;k<=sequen[i].nbr_stencil-1;k++)
        {
          entity name;
          char buffer[20];  
          //expression exp;
          //reference ref;
          temp[k]=matrix_new(depth,1);
          matrix_substract(temp[k],sequen[i].delai, sequen[i-1].delai);
          matrix_substract(temp[k], temp[k],sequen[i].st[k]);
          sprintf(buffer,"%s%d_%d", "R",i+1,k);
          name= make_scalar_entity(buffer,  module_local_name(get_current_module_entity()),
                                   make_basic(is_basic_int, (void *) 4) );
          regi[i][k]=make_reference(name,NIL);
        }
      for(j=0;j<=depth;j++) 
        {
          expression droite = expression_undefined, expt;
          statement s1,s2,s3;
          sequence seq;
          instruction ins;
          call c;
          test t;
          int m,l;
          list lis,lisp;
          reference ref;
          s1=copy_statement(scopy[i][j]);
          c= instruction_call(statement_instruction(( s1)));
          m=0;
          MAP(EXPRESSION,exp,{  
            if (m==1)  droite=exp;
            m++;
          },call_arguments(c)) ;
          lis=call_arguments( syntax_call(expression_syntax(droite)));
          for(k=0;k<=sequen[i].nbr_stencil-1;k++)
            {
              expression exp;
              ref=copy_reference (buf_ref[i-1][depth]);  /**** ?????? ****/
              exp=reference_to_expression(ref);
              for(l=0;l<=depth-1;l++)
                {
                  Pvecteur pv;
                  expression delai_plus;
                  pv = vect_make(VECTEUR_NUL,iter[l], VALUE_ONE, TCST,-MATRIX_ELEM(temp[k],l+1,1));
                  delai_plus=Pvecteur_to_expression(pv);
          replace_entity_by_expression(exp,(entity)iter[l],delai_plus);
                }
              expt=EXPRESSION( CAR(lis));
              lis=CDR(lis);
              syntax_reference(expression_syntax(expt))=ref;
            }
          lis=NIL;
          for(k=0;k<=sequen[i].nbr_stencil-1;k++)
            {
              statement s,*stemp;
              stemp=( statement  *)malloc( (depth+1) *sizeof(statement));
              for(l=0;l<=depth;l++)
                { 
                  int r;
                  expression exp;
                  reference ref;
                   
                  ref=copy_reference (buf_ref[i-1][l]);
                  exp=reference_to_expression(ref);
                  for (r=0;r<=depth-1;r++)
                    {
                      Pvecteur pv;
                      expression delai_plus;
                      
                      if(r==l)
                        {
                          Value t;
                          int pos;
                          pos=position_one_element(P1,r+1);
                          t=value_minus(MATRIX_ELEM(ATEP,r+1,1),MATRIX_ELEM(temp[k],pos,1));
                          pv = vect_make(VECTEUR_NUL,iter[pos-1], VALUE_ONE, TCST,t);
                          delai_plus=Pvecteur_to_expression(pv);
              replace_entity_by_expression(exp,(entity)iter[pos-1],delai_plus);
                        }                  
                      
                      else           
                        {
                          int pos;
                          pos=position_one_element(P1,r+1);
                          pv = vect_make(VECTEUR_NUL,iter[pos-1], VALUE_ONE, TCST,-MATRIX_ELEM(temp[k],pos,1));
                          delai_plus=Pvecteur_to_expression(pv);
              replace_entity_by_expression(exp,(entity)iter[pos-1],delai_plus);
                        }
                    }
 
                  
                  r=0;
                  MAP(EXPRESSION,exp,{  
                   
                    if (r==depth)
                      {
                         
                        int pos;
                        expression delai_plus;
                        pos=position_one_element(P1,l+1);
                        pv= vect_make(VECTEUR_NUL ,itert[pos-1], VALUE_ONE,TCST,-VALUE_ONE);
                        delai_plus=Pvecteur_to_expression(pv);
            replace_entity_by_expression(exp,(entity)itert[pos-1],delai_plus);
 
                      };
                    r++;
                  },reference_indices(ref)) 
 
                  stemp[l]=make_assign_statement(reference_to_expression(regi[i][k]),reference_to_expression(ref));
                };
              s=  stemp[depth];
              for(l=depth-1;l>=0;l--)
                {
                  int pos;
                  Pvecteur pv2;
                  //statement s1/*,s2*/;
                  test t;
                  expression exp;
                  pos=position_one_element(P1,l+1);
                  pv2= vect_make(VECTEUR_NUL,iter[pos-1], VALUE_ONE,TCST , -MATRIX_ELEM(temp[k],pos,1));
                  exp=lt_expression(Pvecteur_to_expression(pv2 ),Value_to_expression(VALUE_ZERO));
                  t= make_test(exp,stemp[l],s);
                  s=test_to_statement(t);
                }
              lis=CONS(STATEMENT,s,lis);
 
            }
          s3=copy_statement(s1);
         
          c= instruction_call(statement_instruction(( s3)));
          m=0;
          MAP(EXPRESSION,exp,{  
            if (m==1)  droite=exp;
            m++;
          },call_arguments(c)) ;
          lisp=call_arguments( syntax_call(expression_syntax(droite)));
          for(k=0;k<=sequen[i].nbr_stencil-1;k++)
            {
             
              expression expt;
             
           
               
              expt=EXPRESSION( CAR(lisp));
               
              lisp=CDR(lisp);
           
              syntax_reference(expression_syntax(expt))=regi[i][k];
             
            }
 
 
 
          lis=CONS(STATEMENT,s3,lis);
          lis=gen_nreverse(lis);
          
          seq= make_sequence(lis);
          ins= make_instruction_sequence(seq);
          s2= instruction_to_statement(ins);
          t= make_test(e,s1,s2);
          scopy[i][j]=test_to_statement(t);
          
          
        };
 
      m1=0; 
 
        CHUNK(CAR( sequence_statements(instruction_sequence(statement_instruction(sequenp[i])))))=   (gen_chunk *) scopy[i][depth];  
      MAP(STATEMENT,s,{  
        if (m1!=0)   
          {
            test_true(instruction_test(statement_instruction(s)) )=  scopy[i][depth-m1];
    
          }
        m1++;
        }, sequence_statements(instruction_sequence(statement_instruction(sequenp[i]))) ) ; 
 
 
 
 
      
    };
  /*   **********************************   */
 
  for(i= k1-1 ;i<=k1-1;i++)
    { 
      expression e=NULL;
      Pvecteur pv;
      Pmatrix *temp;
      reference *regi[nid_nbr];
      //int m1;
      /* */
 
      expression droite = expression_undefined, expt;
      statement s1,s2,s3;
      sequence seq;
      instruction ins;
      call c;
      test t;
      int m,l;
      list lis,lisp;
      reference ref;
      
     
      for(j=1;j<=depth;j++)
        {
          
          Value v2;
          
          
          
          v2=value_uminus(MATRIX_ELEM(G_PRO[i-1],j,1));
          
          pv= vect_make(VECTEUR_NUL,iter[j-1], VALUE_ONE,TCST ,v2);
          
          if (j==1)  e=ge_expression(Pvecteur_to_expression(pv),Value_to_expression(VALUE_ZERO));  
          else
            e=and_expression(e,ge_expression(Pvecteur_to_expression(pv),Value_to_expression(VALUE_ZERO)));
          
        }
      
      temp=( Pmatrix *)malloc( sequen[i].nbr_stencil *sizeof(Pmatrix));
      regi[i]=( reference *)malloc( sequen[i].nbr_stencil *sizeof(reference));;
      for(k=0;k<=sequen[i].nbr_stencil-1;k++)
        {
          entity name;
          char buffer[20];  
          //expression exp;
          //reference ref;
          temp[k]=matrix_new(depth,1);
          
          matrix_substract(temp[k],sequen[i].delai, sequen[i-1].delai);
          matrix_substract(temp[k], temp[k],sequen[i].st[k]);
          
          
          
          sprintf(buffer,"%s%d_%d", "R",i+1,k);
          name= make_scalar_entity(buffer,  module_local_name(get_current_module_entity()),
                                   make_basic(is_basic_int, (void *) 4) );
          
          regi[i][k]=make_reference(name,NIL);
          
          
              
        }
      
      s1=copy_statement( sequen[i].s);
      ps1=s1;
      c= instruction_call(statement_instruction(( s1)));
      m=0;
      MAP(EXPRESSION,exp,{  
        if (m==1)  droite=exp;
        m++;
      },call_arguments(c)) ;
      lis=call_arguments( syntax_call(expression_syntax(droite)));
      for(k=0;k<=sequen[i].nbr_stencil-1;k++)
        {
          expression exp;
          ref=copy_reference (buf_ref[i-1][depth]);
          exp=reference_to_expression(ref);
          for(l=0;l<=depth-1;l++)
            {
              Pvecteur pv;
              expression delai_plus;
              pv = vect_make(VECTEUR_NUL,iter[l], VALUE_ONE, TCST,-MATRIX_ELEM(temp[k],l+1,1));
              delai_plus=Pvecteur_to_expression(pv);
          replace_entity_by_expression(exp,(entity)iter[l],delai_plus);
            }
          expt=EXPRESSION( CAR(lis));
          lis=CDR(lis);
          syntax_reference(expression_syntax(expt))=ref;
        } 
      lis=NIL;
      for(k=0;k<=sequen[i].nbr_stencil-1;k++)
        {
          statement s,*stemp;
          stemp=( statement  *)malloc( (depth+1) *sizeof(statement));
          for(l=0;l<=depth;l++)
            { 
              int r;
              expression exp;
              reference ref;
              
              ref=copy_reference (buf_ref[i-1][l]);
              
              
              exp=reference_to_expression(ref);
              for (r=0;r<=depth-1;r++)
                {
                  Pvecteur pv;
                  expression delai_plus;
                  
                     if(r==l)
                        {
                          Value t;
                          int pos;
                          pos=position_one_element(P1,r+1);
                          t=value_minus(MATRIX_ELEM(ATEP,r+1,1),MATRIX_ELEM(temp[k],pos,1));
                          pv = vect_make(VECTEUR_NUL,iter[pos-1], VALUE_ONE, TCST,t);
                          delai_plus=Pvecteur_to_expression(pv);
              replace_entity_by_expression(exp,(entity) iter[pos-1], delai_plus);
                        }                  
                      
                      else           
                        {
                          int pos;
                          pos=position_one_element(P1,r+1);
                          pv = vect_make(VECTEUR_NUL,iter[pos-1], VALUE_ONE, TCST,-MATRIX_ELEM(temp[k],pos,1));
                          delai_plus=Pvecteur_to_expression(pv);
              replace_entity_by_expression(exp,(entity) iter[pos-1], delai_plus);
                        }
                    
                }
              r=0;
              MAP(EXPRESSION,exp,{  
                
                if (r==depth)
                  {
                    int pos;
                    expression delai_plus;
                    pos=position_one_element(P1,l+1);
                    
                 
                    pv= vect_make(VECTEUR_NUL ,itert[pos-1], VALUE_ONE,TCST,-VALUE_ONE);
                 
                    delai_plus=Pvecteur_to_expression(pv);
            replace_entity_by_expression(exp,(entity) itert[pos-1], delai_plus);
                    
 
                  
                  };
                r++;
              },reference_indices(ref));
              
              stemp[l]=make_assign_statement(reference_to_expression(regi[i][k]),reference_to_expression(ref));
            };
          s=  stemp[depth];
          for(l=depth-1;l>=0;l--)
            {
              int pos;
              Pvecteur pv2;
              //statement s1,s2;
              test t;
              expression exp;
              pos=position_one_element(P1,l+1);
              pv2= vect_make(VECTEUR_NUL,iter[pos-1], VALUE_ONE,TCST , -MATRIX_ELEM(temp[k],pos,1));
              exp=lt_expression( Pvecteur_to_expression(pv2 ) ,Value_to_expression(VALUE_ZERO) );
              t= make_test(exp,stemp[l],s);
              s=test_to_statement(t);
            }
          lis=CONS(STATEMENT,s,lis);
          
        }
      s3=copy_statement(s1);
      ps2=s3;
      c= instruction_call(statement_instruction(( s3)));
      m=0;
      MAP(EXPRESSION,exp,{  
        if (m==1)  droite=exp;
        m++;
      },call_arguments(c)) ;
      lisp=call_arguments( syntax_call(expression_syntax(droite)));
      for(k=0;k<=sequen[i].nbr_stencil-1;k++)
        {
          expression expt;
          expt=EXPRESSION( CAR(lisp));
          lisp=CDR(lisp);
          syntax_reference(expression_syntax(expt))=regi[i][k];
        }
      lis=CONS(STATEMENT,s3,lis);
      lis=gen_nreverse(lis);
      seq= make_sequence(lis);
      ins= make_instruction_sequence(seq);
      s2= instruction_to_statement(ins);
      t= make_test(e,s1,s2);
      sequen[i].s=test_to_statement(t);
 
 
      
    }; 
 
 
 
 
      
 
/* ************************** */
 
 
 
 
 
 
 
  ls=loop1;
  for(j=0;j<=depth-1;j++)
    {
      range range1;  
      range1=loop_range(ls); 
      range_lower(range1)=int_to_expression(tiled_nest[j].lower);
      range_upper(range1)= int_to_expression(tiled_nest[j].upper);
      if  (j!=depth-1) ls=instruction_loop(statement_instruction(loop_body(ls)));
    };
  tiling_indice= ( Pvecteur  *)malloc(depth *sizeof( Pvecteur*));
  plus=depth*2-1;
  
  for (pb =base_newindex; pb!=NULL; pb=pb->succ) {
    loop tl;
    switch(plus%2)
      {
      case 1: 
        { 
          
          elem_mat2=MATRIX_ELEM(A,plus/2+1,plus  ) ;
          
          upper= int_to_expression(value_minus(elem_mat2,VALUE_ONE));
          
          lower= int_to_expression(0);
          
          tiling_indice[plus/2]=vect_make(VECTEUR_NUL ,pb->var , VALUE_ONE,TCST,VALUE_ZERO);
                
          vect_dump( tiling_indice[plus/2]);
          
         
          break;
        }
        
      case 0:
        { 
          elem_mat1=MATRIX_ELEM(A,plus/2+1,plus+1);
          upper= int_to_expression(value_div(tiled_nest[plus/2].upper,elem_mat1));
          lower= int_to_expression(0);
         
          tiling_indice[plus/2]=vect_make( tiling_indice[plus/2],pb->var ,elem_mat1,TCST,VALUE_ZERO);
          vect_dup( tiling_indice[plus/2]);
         
          break;
        };
        
      default: break;
      }  
    
    tl = make_loop((entity) vecteur_var(pb),
                   make_range(copy_expression(lower), copy_expression(upper),
                              int_to_expression(1)),
                   s1,
                   entity_empty_label(),
                   make_execution(is_execution_sequential, UU),
                   NIL);
    s1 = instruction_to_statement(make_instruction(is_instruction_loop, tl));
    
    
    plus--;
  };
  
  
 
  /******/
  for (i=k1-1;i>=0;i--)
    {
      expression e1,e2,e/*,gauche=NULL,droite=NULL*/,delai_plus;
      test t;
      //call c;
      //int m;
      //Pvecteur pv;
      e1=ge_expression(Pvecteur_to_expression (tiling_indice[0]),
                       Value_to_expression( value_plus(sequen[i].nd[0].lower,
                                                       MATRIX_ELEM( sequen[i].delai,1,1))));
      e2=le_expression(Pvecteur_to_expression (tiling_indice[0]), 
                       Value_to_expression( value_plus(sequen[i].nd[0].upper,
                                                       MATRIX_ELEM( sequen[i].delai,1,1))));
      if (value_eq( value_plus(sequen[i].nd[0].lower,MATRIX_ELEM( sequen[i].delai,1,1)),tiled_nest[0].lower))
        {
          if (value_eq( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)),tiled_nest[0].upper)&&
              value_eq(value_mod( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)), 
                                  MATRIX_ELEM(A,1,1)),VALUE_ZERO))
            e=NULL;
          else
            e=e2;
        }
      else
        {
          if (value_eq( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)),tiled_nest[0].upper)&&
              value_eq(value_mod( value_plus(sequen[i].nd[0].upper,MATRIX_ELEM( sequen[i].delai,1,1)), 
                                  MATRIX_ELEM(A,1,1)),VALUE_ZERO))
            e=e1;
          
          else
            e=and_expression(e1,e2);
          
        };
     
      for(j=0;j<=depth-1;j++)
        {
          if (j>=1) 
            {
              e1=ge_expression( Pvecteur_to_expression (tiling_indice[j]),
                                Value_to_expression(value_plus(sequen[i].nd[j].lower,
                                                               MATRIX_ELEM( sequen[i].delai,j+1,1))));
              e2=le_expression(Pvecteur_to_expression (tiling_indice[j]), 
                               Value_to_expression( value_plus(sequen[i].nd[j].upper,
                                                               MATRIX_ELEM( sequen[i].delai,j+1,1))));
              if (value_eq( value_plus(sequen[i].nd[j].lower,MATRIX_ELEM( sequen[i].delai,j+1,1)),tiled_nest[j].lower))
                {
                  if (! (value_eq(value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)),tiled_nest[j].upper)&&
                         value_eq(value_mod( value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)), 
                                             MATRIX_ELEM(A,j+1,2*j+1)),VALUE_ZERO)))
                    {
                      if (e==NULL)
                        e=e2;
                      else
                        e=and_expression(e,e2);
                    };
                }
              else
                {
                  if (value_eq(value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)),tiled_nest[j].upper)&&
                      value_eq(value_mod( value_plus(sequen[i].nd[j].upper,MATRIX_ELEM( sequen[i].delai,j+1,1)), 
                                          MATRIX_ELEM(A,j+1,2*j+1)),VALUE_ZERO))
                    {
                      if (e==NULL)
                        e=e1;
                      else
                        e=and_expression(e,e1);
                    }
                  else
                    {
                      e1=and_expression(e1,e2);
                      if(e==NULL)
                        e=e1;
                      else
                        e=and_expression(e,e1);
                    }
                };
            };
        };
      if(i<= k1-2) 
        {
          if(i==0)
            {
              call c;
              int m ,j,l;
              expression droite = expression_undefined;
              Pvecteur pv;
 
              for(j=0;j<depth+1;j++)
                {
                  c= instruction_call(statement_instruction(( scopy[i][j])));
                  m=0;
                  MAP(EXPRESSION,exp,{  
                    if (m==1)  droite=exp;
                    m++;
                  },call_arguments(c)) ;
                  for(l=0;l<=depth-1;l++)
                    {
                      pv = vect_make(tiling_indice[l],TCST,value_uminus(MATRIX_ELEM(sequen[i].delai,l+1,1)));
                      delai_plus=Pvecteur_to_expression(pv);
                   
                      FOREACH(EXPRESSION,exp,call_arguments( syntax_call(expression_syntax(droite))))
                  replace_entity_by_expression(exp,(entity)  sequen[i].nd[l].index, delai_plus);
                    }
                }
            }         
          
          t= make_test(e,sequenp[i],make_block_statement(NIL));
        }
      else 
        {
          call c;
          int m ,j;
          expression gauche = expression_undefined;
          Pvecteur pv;
          c= instruction_call(statement_instruction(( ps1 )));
          m=0;
          MAP(EXPRESSION,exp,{  
            if (m==0)  gauche=exp;
            m++;
          },call_arguments(c)) ;
          for(j=0;j<=depth-1;j++)
            {  
              pv = vect_make(tiling_indice[j],TCST,value_uminus(MATRIX_ELEM(sequen[i].delai,j+1,1)));
              delai_plus=Pvecteur_to_expression(pv);
          replace_entity_by_expression(gauche,(entity)  sequen[i].nd[j].index, delai_plus);
            }
          c= instruction_call(statement_instruction(( ps2 )));
          m=0;
          MAP(EXPRESSION,exp,{  
            if (m==0)  gauche=exp;
            m++;
          },call_arguments(c)) ;
          for(j=0;j<=depth-1;j++)
            {  
              pv = vect_make(tiling_indice[j],TCST,value_uminus(MATRIX_ELEM(sequen[i].delai,j+1,1)));
              delai_plus=Pvecteur_to_expression(pv);
          replace_entity_by_expression(gauche,(entity)  sequen[i].nd[j].index, delai_plus);
            }
 
 
          
          t= make_test(e,sequen[i].s,make_block_statement(NIL));
        };
      s=test_to_statement(t);
 
      if(i==k1-1)   lis=CONS(STATEMENT,s,NIL);
      else      lis=CONS(STATEMENT,s,lis);
      
    };
 
  seq= make_sequence(lis);
  ins= make_instruction_sequence(seq);
  s= instruction_to_statement(ins);
  ls=instruction_loop(statement_instruction(s1));
  for(j=0;j<=2*depth-1;j++)
    if  (j!=2*depth-1) ls=instruction_loop(statement_instruction(loop_body(ls)));
    else loop_body(ls)=s;
 
   
  s1=permutation2(s1,P);
  
  return s1;
}

References A, and_expression, binary_intrinsic_expression, buffer, call_arguments, CAR, CDR, CHUNK, compute_bound_tiled_nest(), compute_delay_tiled_nest(), CONS, copy_expression(), copy_reference(), copy_statement(), depth, derive_new_basis_une(), DIMENSION, entity_empty_label(), exp, EXPRESSION, expression_syntax, expression_undefined, FOREACH, ge_expression, gen_nreverse(), get_current_module_entity(), INFO_LOOP::index, instruction_call, instruction_loop, instruction_loop_p, instruction_sequence, instruction_test, instruction_to_statement(), int_to_expression(), internal_make_new_array_variable(), is_basic_int, is_execution_sequential, is_instruction_loop, k1, le_expression, loop1, loop_body, loop_iteration_domaine_to_sc(), loop_range, loop_to_statement, INFO_LOOP::lower, lt_expression, make_assign_statement(), make_basic(), make_block_statement(), make_dimension(), make_execution(), make_instruction(), make_instruction_sequence(), make_loop(), make_range(), make_reference(), make_scalar_entity(), make_sequence(), make_test(), make_tile_index_entity_n(), malloc(), MAP, MATRIX_ELEM, matrix_fscan(), matrix_multiply(), matrix_new(), matrix_substract(), module_local_name(), NID::nbr_stencil, NID::nd, nid_nbr, NIL, NP, permutation2(), position_one_element(), print_expression(), Pvecteur_to_expression(), range_lower, range_upper, ref, reference_indices, reference_to_expression(), replace_entity_by_expression(), NID::s, s1, safe_fopen(), sequen, sequence_statements, STATEMENT, statement_instruction, statement_undefined, Svecteur::succ, syntax_call, syntax_reference, TCST, test_to_statement, test_true, tiled_nest, tiling_indice, INFO_LOOP::upper, user_request(), UU, value_div, value_eq, value_minus, value_mod, VALUE_MONE, VALUE_ONE, value_plus, Value_to_expression(), value_uminus, VALUE_ZERO, Svecteur::var, vect_dump(), vect_dup(), vect_make(), VECTEUR_NUL, and vecteur_var.

Referenced by tiling_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

tiling_sequence()

bool tiling_sequence

(

string

module

)

Parameters

module

odule

Definition at line 2534 of file tiling_sequence.c.

{
  statement stat,s1=NULL;
  context_t context;
  contenu_t contenu;
 
  debug_on("STATISTICS_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", module);
  set_current_module_entity(local_name_to_top_level_entity(module));
 
  stat = (statement) db_get_memory_resource(DBR_CODE, module, true);
 
  context.contenu = hash_table_make(hash_pointer, 0);
  context.depth   = hash_table_make(hash_pointer, 0);
  context.statement_stack = stack_make(statement_domain, 0, 0);
 
  gen_context_multi_recurse
    (stat, & context,
     statement_domain, stmt_flt, stmt_rwt,
     sequence_domain, seq_flt, seq_rwt,
     test_domain, test_flt, test_rwt,
     loop_domain, loop_flt, loop_rwt,
     call_domain, call_flt, call_rwt,
     whileloop_domain, gen_true, wl_rwt,
     unstructured_domain, uns_flt, uns_rwt,
     expression_domain, gen_false, gen_null,
     NULL);
  contenu = (contenu_t) hash_get(context.contenu, stat);
  depth = (intptr_t ) hash_get(context.depth, stat);
 
  if (contenu!=is_a_stencil)
    {
      printf(" Le programme ne repond pas aux hypotheses  \n");
      array_overflow();
    }
  else
    {
      if(!array_overflow())
        {
          int choix ;
          printf("--------------Choix de la transformation-------\n");
          printf(" 1: Fusion  \n");
          printf(" 2: Fusion avec allocation des tampons  \n");
          printf(" 3: Tiling \n");
          printf(" 4: Tiling a seul niveau avec  allocation des tampons \n");
          printf(" 5: Tiling a deux niveaux avec  allocation des tampons \n");
          printf(" Choix: ");
          if(scanf("%d", &choix)!=1)
            pips_user_error("Undefined variable \"choix\".\n");
          switch(choix)
            {
            case 1: s1=fusion();
              break;
            case 2:  s1= fusion_buffer();
              break;
            case 3: s1=Hierarchical_tiling();
              break;
            case 4: s1=Tiling_buffer_allocation();
              break;
            case 5: s1=Tiling2_buffer();
              break;
            default: break;
            }
          module_reorder(s1);
          DB_PUT_MEMORY_RESOURCE(DBR_CODE, module, s1);
        }
    }
  reset_current_module_entity();
  //  reset_current_module_statement();
 
  pips_debug(1, "done.\n");
  debug_off();
  return true;
}

References array_overflow(), call_domain, call_flt(), call_rwt(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, depth, expression_domain, fusion(), fusion_buffer(), gen_context_multi_recurse(), gen_false(), gen_null(), gen_true(), hash_get(), hash_pointer, hash_table_make(), Hierarchical_tiling(), intptr_t, is_a_stencil, local_name_to_top_level_entity(), loop_domain, loop_flt(), loop_rwt(), module, module_reorder(), pips_debug, pips_user_error, printf(), reset_current_module_entity(), s1, seq_flt(), seq_rwt(), sequence_domain, set_current_module_entity(), stack_make(), statement_domain, stmt_flt(), stmt_rwt(), test_domain, test_flt(), test_rwt(), Tiling2_buffer(), Tiling_buffer_allocation(), uns_flt(), uns_rwt(), unstructured_domain, whileloop_domain, and wl_rwt().

Here is the call graph for this function:

unimodular()

statement unimodular

(

statement

)

Variable Documentation

first_array

entity first_array

extern

une copie de l'un des nids de la sequence

Definition at line 83 of file tiling_sequence.c.

Referenced by array_overflow(), call_rwt(), and top_down_abc_flt().

if1

bool if1

extern

Definition at line 49 of file guard_elimination.c.

Referenced by free_guards(), and loop_flt().

if2

bool if2

extern

Definition at line 49 of file guard_elimination.c.

Referenced by free_guards(), and loop_flt().

loop1

loop loop1

extern

tiling_sequence.c

tiling_sequence.c

Definition at line 81 of file tiling_sequence.c.

Referenced by free_guards(), fusion(), fusion_buffer(), Hierarchical_tiling(), ith_loop_in_loop_nest(), loop_flt(), matrice_fprint(), matrice_multiply(), matrice_normalize(), matrice_swap_columns(), matrice_swap_rows(), matrice_transpose(), Tiling2_buffer(), and Tiling_buffer_allocation().

sc_newbase

Psysteme sc_newbase

extern

guard_elimination.c

guard_elimination.c

Definition at line 47 of file guard_elimination.c.

Referenced by code_generation(), free_guards(), hyperplane(), and unimodular().

sg

Ptsg sg

extern

Definition at line 48 of file guard_elimination.c.

Referenced by ajout_dte(), constrs_of_sg(), dte_in_sg_p(), free_guards(), is_good_direction_p(), main(), mk_rn(), ray_in_sg_p(), rays_of_sg(), sc_of_sg(), sc_to_sg_chernikova(), sg_add_ray(), sg_dump(), sg_fprint(), sg_fprint_as_ddv(), sg_fprint_as_dense(), sg_new(), sg_of_constrs(), sg_of_rays(), sg_of_sc(), sg_print(), sg_rm(), sg_rm_droites(), sg_rm_rayons(), sg_rm_sommets(), sg_to_sc_chernikova(), sg_to_sc_chernikova_fixprec(), sg_union(), sommet_in_sg_p(), and unimodular().