code_generation.c File Reference

#include <stdio.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "conversion.h"
#include "hyperplane.h"

Include dependency graph for code_generation.c:

Go to the source code of this file.

Functions
statement	code_generation (list lls, Pvecteur pvg[], Pbase base_oldindex, Pbase base_newindex, Psysteme sc_newbase, bool preserve_entry_label_p)
	package hyperplane More...

Function Documentation

code_generation()

statement code_generation	(	list	lls,
		Pvecteur	pvg[],
		Pbase	base_oldindex,
		Pbase	base_newindex,
		Psysteme	sc_newbase,
		bool	preserve_entry_label_p
	)

package hyperplane

code_generation.c

include <sys/stdtypes.h> for debug with dbmalloc include "stdlib.h" statement code_generation(cons *lls,Pvecteur pvg[], Pbase base_oldindex, Pbase base_newindex) generation of hyperplane code for the nested loops (cons *lls). the new nested loops will be ; DOSEQ Ip = ... DOALL Jp = ... DOALL Kp = ... ... ENDDO

modification : Keep the code in the sequential version. Let the parallelisation to generate the parallel code. suggested by BB, modified by Yi-Qing. 17/05/92

make the parallel loops from inner loop to outermost loop

handling of current loop

new bounds for new index related to the old index of the old loop

FI: I do not understand how you could keep a go to target (!) or a list of local variables

Parameters

lls	ls
pvg	vg
base_oldindex	ase_oldindex
base_newindex	ase_newindex
sc_newbase	c_newbase
preserve_entry_label_p	reserve_entry_label_p

Definition at line 58 of file code_generation.c.

{
    statement state_lhyp = statement_undefined;
    instruction instr_lhyp = instruction_undefined;
    loop l_hyp = loop_undefined;
    range rl = range_undefined;
    expression lower = expression_undefined;
    expression upper = expression_undefined;
    statement bl = statement_undefined; 
    statement s_loop = statement_undefined;
    Pbase pb = BASE_UNDEFINED;
 
    bl = loop_body(instruction_loop(statement_instruction(STATEMENT(CAR(lls)))));
    statement_newbase(bl,pvg,base_oldindex);
    /* make the parallel loops from inner loop to outermost loop*/
 
    for(pb=base_reversal(base_newindex);lls!=NIL; lls=CDR(lls), pb = pb->succ) {
        /* handling of current loop */
        s_loop = STATEMENT(CAR(lls));
 
        /* new bounds for new index related to the old index of the old loop*/
        make_bound_expression(pb->var, base_newindex,sc_newbase, &lower, &upper);
        rl = make_range(lower, upper, int_to_expression(1));
 
        /*
    loop l_old = loop_undefined;
        l_old = instruction_loop(statement_instruction(s_loop));
        l_hyp = make_loop((entity) pb->var,
                          rl,
                          bl,
                          loop_label(l_old),
                          make_execution(is_execution_sequential,UU),
                          loop_locals(l_old));
        */
 
        /* FI: I do not understand how you could keep a go to target (!)
         * or a list of local variables
         */
        l_hyp = make_loop((entity) pb->var,
                          rl,
                          bl,
                          entity_empty_label(),
                          make_execution(is_execution_sequential,UU),
                          NIL);
 
        bl = makeloopbody(l_hyp, s_loop, true);
    }
    
    instr_lhyp = make_instruction(is_instruction_loop,l_hyp);
    state_lhyp = copy_statement(s_loop);
    if(!preserve_entry_label_p)
      clear_label(state_lhyp);
    free_instruction(statement_instruction(state_lhyp));
    statement_instruction(state_lhyp) = instr_lhyp;
    return(state_lhyp);
}

References base_reversal(), BASE_UNDEFINED, CAR, CDR, clear_label(), copy_statement(), entity_empty_label(), expression_undefined, free_instruction(), instruction_loop, instruction_undefined, int_to_expression(), is_execution_sequential, is_instruction_loop, loop_body, loop_undefined, make_bound_expression(), make_execution(), make_instruction(), make_loop(), make_range(), makeloopbody(), NIL, range_undefined, sc_newbase, STATEMENT, statement_instruction, statement_newbase(), statement_undefined, Svecteur::succ, UU, and Svecteur::var.

Referenced by hyperplane(), parallel_tiling(), tiling_transformation(), and unimodular().

Here is the call graph for this function:

Here is the caller graph for this function: