hyperplane.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "misc.h"
#include "text.h"
#include "boolean.h"
#include "vecteur.h"
#include "contrainte.h"
#include "sc.h"
#include "matrice.h"
#include "matrix.h"
#include "sparse_sc.h"
#include "ri-util.h"
#include "effects-util.h"
#include "conversion.h"
#include "hyperplane.h"

Include dependency graph for hyperplane.c:

Go to the source code of this file.

Functions
statement	hyperplane (list lls, _UNUSED_ bool(*u)(statement))
	package hyperplane More...

Function Documentation

hyperplane()

statement hyperplane	(	list	lls,
		_UNUSED_ bool(*)(statement)	u
	)

package hyperplane

void hyperplane(cons *lls) Implementation of the hyperplane method "lls" is the list of nested loops

sc initial

sc nouveau

number of index

number of constraints

make the system "sc" of constraints of iteration space

NDEBUG

create the matrix A of coefficients of index in (Psysteme)sci

NDEBUG

NDEBUG

NDEBUG

computation of the hyperplane direction

use the hyperplane direction

computation of the scanning base G

the new matrice of constraints AG = A * G

NDEBUG

create the new system of constraintes (Psysteme scn) with AG and sci

NDEBUG

NDEBUG

NDEBUG

computation of the new iteration space in the new basis G

NDEBUG

(void) fprintf(stderr,"scn after new_loop_bound:\n"); sc_default_dump(scn); has been destroyed

change of basis for index

NDEBUG

NDEBUG

generation of hyperplane code

generation of bounds

loop body generation

Definition at line 61 of file hyperplane.c.

{
    Psysteme sci;                       /* sc initial */
    Psysteme scn;                       /* sc nouveau */
    Psysteme sc_row_echelon;
    Psysteme sc_newbase;
    Pbase base_oldindex = NULL;
    Pbase base_newindex = NULL;
    matrice A;
    matrice G;
    matrice AG;
    int n;                              /* number of index */
    int m ;                             /* number of constraints */
    Value *h;
    int i;
    statement s_lhyp;
    Pvecteur *pvg;
    Pbase pb;
    expression lower, upper;
    Pvecteur pv1;
    loop l;
 
    debug_on("HYPERPLANE_DEBUG_LEVEL");
 
    debug(8," hyperplane","Begin:\n");
 
    /* make the  system "sc" of constraints of iteration space */
    sci = loop_iteration_domaine_to_sc(lls, &base_oldindex);
 
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"base_oldindex 0:\n");
      base_fprint(stderr,base_oldindex,default_variable_to_string);
    }
 
    /* create the  matrix A of coefficients of  index in (Psysteme)sci */
    n = base_dimension(base_oldindex);
    m = sci->nb_ineq;
    A = matrice_new(m,n);
    sys_matrice_index(sci, base_oldindex, A, n, m);
 
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"base_oldindex 1:\n");
      base_fprint(stderr,base_oldindex,default_variable_to_string);
    }
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"Matrice A:\n");
      matrice_fprint(stderr,A,m,n);
    }
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"sci:\n");
      sc_default_dump(sci);
    }
    /* computation of the hyperplane direction */
    /*  use the  hyperplane direction  */
    h = (Value*)(malloc(n*sizeof(Value)));
 
    if(!interactive_hyperplane_direction(h, n)) {
        pips_user_error("A proper hyperplane direction was not provided\n");
    }
 
    ifdebug(8) {
        debug(8," hyperplane","Vector h :");
        for (i = 0; i<n; i++) {
            (void) fprintf(stderr," " VALUE_FMT, *(h+i));
        }
        (void) fprintf(stderr,"\n");
    }
 
    G = matrice_new(n,n);
    /* computation of the  scanning base G */
    scanning_base_hyperplane(h, n, G);
    ifdebug(8) {
        (void) fprintf(stderr,"The scanning base G is:");
        matrice_fprint(stderr, G, n, n);
    }
 
    /* the new matrice of constraints AG = A * G */
    AG = matrice_new(m,n);
    matrice_multiply(A, G, AG, m, n, n);
 
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"Matrice AG:\n");
      matrice_fprint(stderr,AG,m,n);
    }
    /* create the new system of constraintes (Psysteme scn) with
       AG and sci */
    scn = sc_dup(sci);
 
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"base_oldindex 2:\n");
      base_fprint(stderr,base_oldindex,default_variable_to_string);
    }
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"scn before matrice_index_sys :\n");
      sc_default_dump(scn);
    }
    matrice_index_sys(scn, base_oldindex, AG, n,m );
 
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"scn after matrice_index_sys :\n");
      sc_default_dump(scn);
    }
 
    /* computation of the new iteration space in the new basis G */
    sc_row_echelon = new_loop_bound(scn, base_oldindex);
 
    ifdebug(8) {
      /*DNDEBUG*/
      /*      (void) fprintf(stderr,"scn after new_loop_bound:\n");
              sc_default_dump(scn);
              has been destroyed
      */
      (void) fprintf(stderr,"sc_row_echelon:\n");
      sc_default_dump(sc_row_echelon);
    }
 
    /* change of basis for index */
    change_of_base_index(base_oldindex, &base_newindex);
 
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"base_oldindex:\n");
      base_fprint(stderr,base_oldindex,default_variable_to_string);
      (void) fprintf(stderr,"base_newindex:\n");
      base_fprint(stderr,base_newindex,default_variable_to_string);
    }
 
    sc_newbase = sc_change_baseindex(sc_dup(sc_row_echelon), base_oldindex, base_newindex);
 
    ifdebug(8) {
      /*DNDEBUG*/
      (void) fprintf(stderr,"sc_newbase:\n");
      sc_default_dump(sc_newbase);
    }
 
    /* generation of hyperplane  code */
    /*  generation of bounds */
    for (pb=base_newindex; pb!=NULL; pb=pb->succ) {
        make_bound_expression(pb->var, base_newindex, sc_newbase, &lower, &upper);
    }
 
    /* loop body generation */
    pvg = (Pvecteur *)malloc((unsigned)n*sizeof(Svecteur));
    scanning_base_to_vect(G,n,base_newindex,pvg);
    pv1 = sc_row_echelon->inegalites->succ->vecteur;
    (void)vect_change_base(pv1,base_oldindex,pvg);
 
    l = instruction_loop(statement_instruction(STATEMENT(CAR(lls))));
    lower = range_upper(loop_range(l));
    upper= expression_to_expression_newbase(lower, pvg, base_oldindex);
 
 
    s_lhyp = code_generation(lls, pvg, base_oldindex, base_newindex, sc_newbase, true);
 
    debug(8," hyperplane","End\n");
 
    debug_off();
 
    return(s_lhyp);
}

References A, base_dimension, base_fprint(), CAR, change_of_base_index(), code_generation(), debug(), debug_off, debug_on, default_variable_to_string(), expression_to_expression_newbase(), fprintf(), G, ifdebug, Ssysteme::inegalites, instruction_loop, interactive_hyperplane_direction(), loop_iteration_domaine_to_sc(), loop_range, make_bound_expression(), malloc(), matrice_fprint(), matrice_index_sys(), matrice_multiply(), matrice_new, Ssysteme::nb_ineq, new_loop_bound(), pips_user_error, range_upper, sc_change_baseindex(), sc_default_dump(), sc_dup(), sc_newbase, scanning_base_hyperplane(), scanning_base_to_vect(), STATEMENT, statement_instruction, Scontrainte::succ, Svecteur::succ, sys_matrice_index(), VALUE_FMT, Svecteur::var, vect_change_base(), and Scontrainte::vecteur.

Referenced by global_parallelization(), and loop_hyperplane().

Here is the call graph for this function:

Here is the caller graph for this function: