compiler.c File Reference

#include "defines-local.h"

Include dependency graph for compiler.c:

Go to the source code of this file.

Macros
#define	debug_print_control(c, w)

Functions
static void	hpf_compile_block (statement stat, statement *hoststatp, statement *nodestatp)
static void	hpf_compile_test (statement s, statement *hoststatp, statement *nodestatp)
static list	caller_list_of_bounds (_UNUSED_ entity fun, list le)
	return the list of bounds More...
static void	hpf_compile_call (statement stat, statement *hoststatp, statement *nodestatp)
	returned node version More...
static void	compile_control (control c, statement_mapping maph, statement_mapping mapn)
static void	hpf_compile_unstructured (statement stat, statement *hoststatp, statement *nodestatp)
static void	hpf_compile_sequential_loop (statement stat, statement *hoststatp, statement *nodestatp)
static void	hpf_compile_parallel_body (statement body, statement *hoststatp, statement *nodestatp)
static void	hpf_compile_parallel_loop (statement stat, statement *hoststatp, statement *nodestatp)
static bool	loop_flt (loop l)
static bool	parallel_loop_in_stat_p (statement s)
static void	hpf_compile_loop (statement stat, statement *hoststatp, statement *nodestatp)
void	hpf_compiler (statement stat, statement *hoststatp, statement *nodestatp)
	what: compile a statement into a host and SPMD node code. More...

Variables
entity	host_module
	HPFC - Fabien Coelho, May 1993 and later... More...
entity	node_module
static bool	parallel_loop_found
	is there a parallel loop down s? More...

Macro Definition Documentation

debug_print_control

#define debug_print_control	(		c,
			w
	)

Value:

  fprintf(stderr, \
          "%s: ctr %p (stat %p) , %zd preds, %zd succs\n", w, \
          c, control_statement(c), \
          gen_length(control_predecessors(c)), \
          gen_length(control_successors(c))); \
  print_statement(control_statement(c));

Definition at line 49 of file compiler.c.

Function Documentation

caller_list_of_bounds()

static list caller_list_of_bounds ( _UNUSED_ entity  fun, list  le  )

static

return the list of bounds

of expression

of expression

Parameters

le	of expression

Definition at line 133 of file compiler.c.

{
    list /* of expression */ lneeded = NIL;
    int len = gen_length(le);
 
    for (; len>=1; len--)
    {
        expression e = EXPRESSION(gen_nth(len-1, le));
        syntax s = expression_syntax(e);
 
        if (syntax_reference_p(s)) 
        {
            entity var, old;
 
            old = reference_variable(syntax_reference(s));
            var = load_new_node(old);
            pips_debug(8, "considering %s\n", entity_name(var));
 
            if (array_distributed_p(old))
            {
                int dim = NumberOfDimension(var);
 
                for (; dim>=1; dim--)
                {
                    if (ith_dim_overlapable_p(old, dim))
                    {
                        lneeded = 
                            CONS(EXPRESSION, hpfc_array_bound(var, false, dim),
                            CONS(EXPRESSION, hpfc_array_bound(var, true, dim),
                                 lneeded));
                    }
                }
            }
        }
    }
 
    return lneeded;
}

References array_distributed_p(), CONS, entity_name, EXPRESSION, expression_syntax, gen_length(), gen_nth(), hpfc_array_bound(), ith_dim_overlapable_p(), load_new_node(), NIL, NumberOfDimension(), pips_debug, reference_variable, syntax_reference, and syntax_reference_p.

Referenced by hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_control()

static void compile_control ( control  c, statement_mapping  maph, statement_mapping  mapn  )

static

Definition at line 326 of file compiler.c.

{
    control hostc, nodec;
    statement stath, statn, statc = control_statement(c);
    
    hpf_compiler(statc, &stath, &statn);
    
    DEBUG_STAT(7, "statc", statc);
    DEBUG_STAT(7, "host stat", stath);
    DEBUG_STAT(7, "node stat", statn);
    
    hostc = make_control(stath, NIL, NIL);
    SET_CONTROL_MAPPING(maph, c, hostc);
    
    nodec = make_control(statn, NIL, NIL);
    SET_CONTROL_MAPPING(mapn, c, nodec);
}

References control_statement, DEBUG_STAT, hpf_compiler(), make_control(), NIL, and SET_CONTROL_MAPPING.

Referenced by hpf_compile_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_compile_block()

static void hpf_compile_block ( statement  stat, statement *  hoststatp, statement*  nodestatp  )

static

of statements

Definition at line 58 of file compiler.c.

{
    list /* of statements */ lhost=NIL, lnode=NIL;
    statement hostcd, nodecd;
 
    pips_assert("block", instruction_block_p(statement_instruction(stat)));
 
    (*hoststatp) = MakeStatementLike(stat, is_instruction_block);
    (*nodestatp) = MakeStatementLike(stat, is_instruction_block);
 
    MAP(STATEMENT, s,
     {
         hpf_compiler(s,&hostcd,&nodecd);
         
         lhost = CONS(STATEMENT, hostcd, lhost);
         lnode = CONS(STATEMENT, nodecd, lnode);
     },
         instruction_block(statement_instruction(stat)));
 
    instruction_block(statement_instruction(*hoststatp)) = gen_nreverse(lhost);
    instruction_block(statement_instruction(*nodestatp)) = gen_nreverse(lnode);
 
    DEBUG_STAT(9, entity_name(host_module), *hoststatp);
    DEBUG_STAT(9, entity_name(node_module), *nodestatp);
}

References CONS, DEBUG_STAT, entity_name, gen_nreverse(), host_module, hpf_compiler(), instruction_block, instruction_block_p, is_instruction_block, MakeStatementLike(), MAP, NIL, node_module, pips_assert, STATEMENT, and statement_instruction.

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_compile_call()

static void hpf_compile_call ( statement  stat, statement *  hoststatp, statement *  nodestatp  )

static

returned node version

IO functions should be detected earlier, in hpf_compiler

"kill" FC directive. tells that the array is dead, hence all copies are live...

of statement

no reference to distributed arrays... the call is just translated into local objects.

should consider read and written variables

of expressions

C1-ALPHA

reductions are detected here. They are not handled otherwise

C1-BETA

call to something with distributed variables, which is not an assignment. Since I do not use the effects as I should, nothing is done...

temporary (?:-) hack

of expressions

Parameters

hoststatp	compiled statement
nodestatp	returned host version

Definition at line 175 of file compiler.c.

{
    call c = instruction_call(statement_instruction(stat));
 
    /* IO functions should be detected earlier, in hpf_compiler
     */
    pips_assert("not an io call", !IO_CALL_P(c));
    pips_assert("call", instruction_call_p(statement_instruction(stat)));
    pips_debug(7, "function %s\n", entity_name(call_function(c)));
 
    DEBUG_STAT(9, "statement", stat);
 
    /* "kill" FC directive.
     * tells that the array is dead, hence all copies are live...
     */
    if (dead_fcd_directive_p(call_function(c)))
    {
        list /* of statement */ ls = NIL;
 
        MAP(EXPRESSION, e,
        {
            entity primary = expression_to_entity(e);
            pips_debug(5, "dealing with array %s\n", entity_name(primary));
            if (array_distributed_p(primary))
                ls = CONS(STATEMENT, generate_all_liveness(primary, true), ls);
        },
            call_arguments(c));
        
        (*hoststatp) = MakeStatementLike(stat, is_instruction_block);
        (*nodestatp) = MakeStatementLike(stat, is_instruction_block);
        
        instruction_block(statement_instruction(*hoststatp)) = NIL;
        instruction_block(statement_instruction(*nodestatp)) = ls;
 
        return;
    }
 
    /* no reference to distributed arrays...
     * the call is just translated into local objects.
     */
    if (!ref_to_dist_array_p(c))
    {
        pips_debug(7, "no reference to distributed variable\n");
 
        (*hoststatp)=MakeStatementLike(stat, is_instruction_call);
        (*nodestatp)=MakeStatementLike(stat, is_instruction_call);
        
        instruction_call(statement_instruction((*hoststatp))) = copy_call(c);
        update_object_for_module(*hoststatp, host_module);
 
        instruction_call(statement_instruction((*nodestatp))) = copy_call(c);
        update_object_for_module(*nodestatp, node_module);
 
        DEBUG_STAT(8, entity_name(host_module), *hoststatp);
        DEBUG_STAT(8, entity_name(node_module), *nodestatp);
 
        return;
    }
 
    /* should consider read and written variables
     */    
    if (ENTITY_ASSIGN_P(call_function(c)))
    {
        list /* of expressions */
            lh = NIL, ln = NIL, args = call_arguments(c) ;
        expression 
            w = EXPRESSION(CAR(args)),
            r = EXPRESSION(CAR(CDR(args)));
 
        pips_assert("reference", syntax_reference_p(expression_syntax(w)));
 
        if (array_distributed_p
            (reference_variable(syntax_reference(expression_syntax(w)))))
        {
            pips_debug(8, "c1-alpha\n");
            
            generate_c1_alpha(stat, &lh, &ln); /* C1-ALPHA */
        }
        else
        {
            syntax s = expression_syntax(r);
 
            /* reductions are detected here. They are not handled otherwise
             */
            if (syntax_call_p(s) && call_reduction_p(syntax_call(s)))
            {
                statement sh, sn;
 
                if (!compile_reduction(stat, &sh, &sn))
                    pips_internal_error("reduction compilation failed");
 
                lh = CONS(STATEMENT, sh, NIL);
                ln = CONS(STATEMENT, sn, NIL);
            }
            else
            {
                pips_debug(8, "c1-beta\n");
                
                generate_c1_beta(stat, &lh, &ln); /* C1-BETA */
            }
        }
 
        (*hoststatp) = MakeStatementLike(stat, is_instruction_block);
        (*nodestatp) = MakeStatementLike(stat, is_instruction_block);
        
        instruction_block(statement_instruction(*hoststatp)) = lh;
        instruction_block(statement_instruction(*nodestatp)) = ln;
        
        DEBUG_STAT(8, entity_name(host_module), *hoststatp);
        DEBUG_STAT(8, entity_name(node_module), *nodestatp);
 
        return;
    }
 
    /* call to something with distributed variables, which is not an
     * assignment. Since I do not use the effects as I should, nothing is
     * done...
     */
 
    /* temporary (?:-) hack 
     */
    {
        entity fun = call_function(c);
        list /* of expressions */
            args = call_arguments(c),
            leh=lUpdateExpr_but_distributed(host_module, args),
            len=lUpdateExpr(node_module, args);
        
        update_overlaps_in_caller(fun, args);
 
        pips_debug(7, "some references to distributed variable\n");
 
        (*hoststatp)=MakeStatementLike(stat, is_instruction_call);
        (*nodestatp)=MakeStatementLike(stat, is_instruction_call);
        
        instruction_call(statement_instruction((*hoststatp)))=
            make_call(fun, leh);
 
        instruction_call(statement_instruction((*nodestatp)))=
            make_call(fun, gen_nconc(len, caller_list_of_bounds(fun, args)));
 
        DEBUG_STAT(8, entity_name(host_module), *hoststatp);
        DEBUG_STAT(8, entity_name(node_module), *nodestatp);
 
        return;
    }
}

References array_distributed_p(), call_arguments, call_function, call_reduction_p(), caller_list_of_bounds(), CAR, CDR, compile_reduction(), CONS, copy_call(), dead_fcd_directive_p(), DEBUG_STAT, ENTITY_ASSIGN_P, entity_name, EXPRESSION, expression_syntax, expression_to_entity(), gen_nconc(), generate_all_liveness(), generate_c1_alpha(), generate_c1_beta(), host_module, instruction_block, instruction_call, instruction_call_p, IO_CALL_P, is_instruction_block, is_instruction_call, lUpdateExpr(), lUpdateExpr_but_distributed(), make_call(), MakeStatementLike(), MAP, NIL, node_module, pips_assert, pips_debug, pips_internal_error, ref_to_dist_array_p(), reference_variable, STATEMENT, statement_instruction, syntax_call, syntax_call_p, syntax_reference, syntax_reference_p, update_object_for_module(), and update_overlaps_in_caller().

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_compile_loop()

static void hpf_compile_loop ( statement  stat, statement *  hoststatp, statement *  nodestatp  )

static

should verify that only listed in labels and distributed entities are defined inside the body of the loop

Definition at line 623 of file compiler.c.

{
    loop the_loop = instruction_loop(statement_instruction(stat));
    list l = NIL;
    entity var;
    bool is_shift = subarray_shift_p(stat, &var, &l);
 
    pips_assert("stat is a loop", statement_loop_p(stat));
 
    if (is_shift)
    {
        pips_debug(4, "shift detected\n");
        
        *nodestatp = generate_subarray_shift(stat, var, l);
        *hoststatp = make_empty_statement();
    }
    else if (execution_parallel_p(loop_execution(the_loop)))
    {
        reference left, right;
        bool /* should verify that only listed in labels and distributed
              * entities are defined inside the body of the loop
              */
            at_ac = atomic_accesses_only_p(stat),
            in_in = indirections_inside_statement_p(stat),
            is_full_copy = full_copy_p(stat, &left, &right);
        
        pips_debug(5, "condition results: aa %d, in %d\n", at_ac, in_in);
 
        
        if (is_full_copy)
        {
            pips_debug(4, "full copy detected\n");
            
            *nodestatp = generate_full_copy(left, right);
            *hoststatp = make_empty_statement();
        }
        else if (at_ac && !in_in)
        {
            statement overlapstat;
 
            pips_debug(7, "compiling a parallel loop\n");
 
            if (Overlap_Analysis(stat, &overlapstat))
            {
                string c = statement_comments(stat);
                pips_debug(7, "overlap analysis succeeded\n");
 
                *hoststatp = make_continue_statement(entity_empty_label());
                *nodestatp = overlapstat;
                if (!string_undefined_p(c))
                    insert_comments_to_statement(*nodestatp, c);
            }
            else
            {
                pips_debug(7, "overlap analysis is not ok...\n");
 
                if (parallel_loop_in_stat_p(loop_body(the_loop)))
                    hpf_compile_sequential_loop(stat, hoststatp, nodestatp);
                else
                    hpf_compile_parallel_loop(stat, hoststatp, nodestatp);
            }
        }
        else
        {
            pips_debug(7, "compiling a parallel loop sequential...\n");
            hpf_compile_sequential_loop(stat, hoststatp, nodestatp);
        }
    }
    else
    {
        pips_debug(7,"compiling a sequential loop\n");
    
        hpf_compile_sequential_loop(stat, hoststatp, nodestatp);
    }
}

References atomic_accesses_only_p(), entity_empty_label(), execution_parallel_p, full_copy_p(), generate_full_copy(), generate_subarray_shift(), hpf_compile_parallel_loop(), hpf_compile_sequential_loop(), indirections_inside_statement_p(), insert_comments_to_statement(), instruction_loop, loop_body, loop_execution, make_continue_statement(), make_empty_statement, NIL, Overlap_Analysis(), parallel_loop_in_stat_p(), pips_assert, pips_debug, statement_comments, statement_instruction, statement_loop_p(), string_undefined_p, and subarray_shift_p().

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_compile_parallel_body()

static void hpf_compile_parallel_body ( statement  body, statement *  hoststatp, statement *  nodestatp  )

static

??? dependances are not surely respected in the definitions list... should check that only locals variables, that are not replicated, may be defined during the body of the loop...

very partial

Definition at line 518 of file compiler.c.

{
    list lw = NIL, lr = NIL, li = NIL, ls = NIL, lbs = NIL;
 
    /* ???
     * dependances are not surely respected in the definitions list...
     * should check that only locals variables, that are not replicated,
     * may be defined during the body of the loop...
     */
    FindRefToDistArrayInStatement(body, &lw, &lr);
    li = AddOnceToIndicesList(lIndicesOfRef(lw), lIndicesOfRef(lr));
    ls = FindDefinitionsOf(body, li);
    gen_free_list(li), li=NIL;
 
    if (gen_length(lw)==0 && gen_length(lr)==0) /* very partial */
    {
        (*hoststatp) = copy_statement(body);
        (*nodestatp) = copy_statement(body);
    }
    else
    {
        generate_parallel_body(body, &lbs, lw, lr);
        
        (*hoststatp) = NULL;
        (*nodestatp) = make_block_statement(gen_nconc(ls, lbs));
    }
 
    gen_free_list(lw), lw=NIL;
    gen_free_list(lr), lr=NIL;
}

References AddOnceToIndicesList(), copy_statement(), FindDefinitionsOf(), FindRefToDistArrayInStatement(), gen_free_list(), gen_length(), gen_nconc(), generate_parallel_body(), lIndicesOfRef(), make_block_statement(), and NIL.

Referenced by hpf_compile_parallel_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_compile_parallel_loop()

static void hpf_compile_parallel_loop ( statement  stat, statement *  hoststatp, statement *  nodestatp  )

static

Definition at line 551 of file compiler.c.

{
    loop the_loop = statement_loop(stat);
    statement s, nodebody, body = loop_body(the_loop);
    instruction bodyinst = statement_instruction(body);
    entity
        label = loop_label(the_loop),
        index = loop_index(the_loop),
        nindex = NewVariableForModule(node_module,index);
    range r = loop_range(the_loop);
    expression
        lower = range_lower(r),
        upper = range_upper(r),
        increment = range_increment(r);
    list lw=NIL, lr=NIL;
 
    FindRefToDistArrayInStatement(stat, &lw, &lr);
    
    if (lw||lr) 
    {
        pips_assert("parallel loop",
                    execution_parallel_p(loop_execution(the_loop)));
        
        if ((instruction_loop_p(bodyinst)) &&
            (execution_parallel_p(loop_execution(instruction_loop(bodyinst)))))
            hpf_compile_parallel_loop(body, &s, &nodebody);
        else
            hpf_compile_parallel_body(body, &s, &nodebody);
    
        (*hoststatp) = make_continue_statement(entity_undefined);
        (*nodestatp) = MakeStatementLike(stat, is_instruction_loop);
        
        instruction_loop(statement_instruction(*nodestatp))=
            make_loop(nindex,
                      make_range(UpdateExpressionForModule(node_module,lower),
                                 UpdateExpressionForModule(node_module,upper),
                           UpdateExpressionForModule(node_module,increment)),
                      nodebody,
                      label,
                      make_execution(is_execution_sequential,UU),
                      NULL);
    } else {
        (*hoststatp) = copy_statement(stat);
        (*nodestatp) = copy_statement(stat);
    }
 
    gen_free_list(lw), gen_free_list(lr);
 
}

References copy_statement(), entity_undefined, execution_parallel_p, FindRefToDistArrayInStatement(), gen_free_list(), hpf_compile_parallel_body(), instruction_loop, instruction_loop_p, is_execution_sequential, is_instruction_loop, loop_body, loop_execution, loop_index, loop_label, loop_range, make_continue_statement(), make_execution(), make_loop(), make_range(), MakeStatementLike(), NewVariableForModule(), NIL, node_module, pips_assert, range_increment, range_lower, range_upper, statement_instruction, statement_loop(), UpdateExpressionForModule(), and UU.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_compile_sequential_loop()

static void hpf_compile_sequential_loop ( statement  stat, statement *  hoststatp, statement *  nodestatp  )

static

of entities

??? memory leak, hostbody is lost whatever it was.

Definition at line 460 of file compiler.c.

{
    loop the_loop=statement_loop(stat);
    statement body = loop_body(the_loop), hostbody, nodebody;
    range r=loop_range(the_loop);
    list /* of entities */ locals=loop_locals(the_loop);
    entity
        label = loop_label(the_loop),
        index = loop_index(the_loop),
        nindex = NewVariableForModule(node_module, index),
        hindex = NewVariableForModule(host_module, index);
    expression
        lower = range_lower(r),
        upper = range_upper(r),
        increment = range_increment(r);
    
    hpf_compiler(body, &hostbody, &nodebody);
    
    if (empty_code_p(hostbody))
    {
        /* ??? memory leak, hostbody is lost whatever it was.
         */
        (*hoststatp)=make_continue_statement(entity_undefined);
    }
    else
    {
        (*hoststatp)=MakeStatementLike(stat, is_instruction_loop);
 
        instruction_loop(statement_instruction(*hoststatp))=
          make_loop(hindex,
                    make_range(UpdateExpressionForModule(host_module,lower),
                               UpdateExpressionForModule(host_module,upper),
                            UpdateExpressionForModule(host_module,increment)),
                    hostbody,
                    label,
                    make_execution(is_execution_sequential,UU),
                    lNewVariableForModule(host_module,locals));
    }
 
    DEBUG_STAT(8, "host stat", *hoststatp);
 
    (*nodestatp)=MakeStatementLike(stat, is_instruction_loop);
 
    instruction_loop(statement_instruction(*nodestatp))=
        make_loop(nindex,
                  make_range(UpdateExpressionForModule(node_module,lower),
                             UpdateExpressionForModule(node_module,upper),
                             UpdateExpressionForModule(node_module,increment)),
                  nodebody,
                  label,
                  make_execution(is_execution_sequential,UU),
                  lNewVariableForModule(node_module,locals));
 
    DEBUG_STAT(8, "node stat", *nodestatp);
}

References DEBUG_STAT, empty_code_p(), entity_undefined, host_module, hpf_compiler(), instruction_loop, is_execution_sequential, is_instruction_loop, lNewVariableForModule(), loop_body, loop_index, loop_label, loop_locals, loop_range, make_continue_statement(), make_execution(), make_loop(), make_range(), MakeStatementLike(), NewVariableForModule(), node_module, range_increment, range_lower, range_upper, statement_instruction, statement_loop(), UpdateExpressionForModule(), and UU.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_compile_test()

static void hpf_compile_test ( statement  s, statement *  hoststatp, statement*  nodestatp  )

static

if it may happen that a condition modifies the value of a distributed variable, this condition is to be put out of the statement, for separate compilation.

Definition at line 87 of file compiler.c.

{
    statement
        s_true, s_hosttrue, s_nodetrue,
        s_false, s_hostfalse, s_nodefalse;
    test the_test;
    expression condition;
    
    pips_assert("test", instruction_test_p(statement_instruction(s)));
 
    the_test = instruction_test(statement_instruction(s));
    condition = test_condition(the_test);
    
    (*hoststatp) = MakeStatementLike(s, is_instruction_test);
    (*nodestatp) = MakeStatementLike(s, is_instruction_test);
 
    /* if it may happen that a condition modifies the value
     * of a distributed variable, this condition is to be
     * put out of the statement, for separate compilation.
     */
 
    s_true = test_true(the_test);
    s_false = test_false(the_test);
 
    hpf_compiler(s_true, &s_hosttrue, &s_nodetrue);
    hpf_compiler(s_false, &s_hostfalse, &s_nodefalse);
 
    instruction_test(statement_instruction(*hoststatp)) =
        make_test(UpdateExpressionForModule(host_module, condition),
                  s_hosttrue,
                  s_hostfalse);
 
    instruction_test(statement_instruction(*nodestatp))=
        make_test(UpdateExpressionForModule(node_module, condition),
                  s_nodetrue,
                  s_nodefalse);
 
    DEBUG_STAT(9, entity_name(host_module), *hoststatp);
    DEBUG_STAT(9, entity_name(node_module), *nodestatp);
}

References DEBUG_STAT, entity_name, host_module, hpf_compiler(), instruction_test, instruction_test_p, is_instruction_test, make_test(), MakeStatementLike(), node_module, pips_assert, statement_instruction, test_condition, test_false, test_true, and UpdateExpressionForModule().

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_compile_unstructured()

static void hpf_compile_unstructured ( statement  stat, statement *  hoststatp, statement *  nodestatp  )

static

nothing spacial is done! ??? there may be a problem with the label of the statement, if any.

HOST statement

NODE statement

Definition at line 348 of file compiler.c.

{
    instruction inst=statement_instruction(stat);
 
    pips_assert("unstructured", instruction_unstructured_p(inst));
 
    if (one_statement_unstructured(instruction_unstructured(inst)))
    {
        pips_debug(7, "one statement recognize\n");
 
        /* nothing spacial is done! 
         * ??? there may be a problem with the label of the statement, if any.
         */
        hpf_compiler(control_statement
             (unstructured_control(instruction_unstructured(inst))),
             hoststatp, nodestatp);
    }
    else
    {
        control_mapping 
            hostmap = MAKE_CONTROL_MAPPING(),
            nodemap = MAKE_CONTROL_MAPPING();
        unstructured  u = instruction_unstructured(inst);
        control ct = unstructured_control(u),
                ce = unstructured_exit(u), new_ct, new_ce;
        list blocks = NIL;
 
        pips_debug(6, "beginning\n");
 
        CONTROL_MAP(c, compile_control(c, hostmap, nodemap), ct, blocks);
 
        if (!gen_in_list_p(ce, blocks))
        {
            pips_debug(5, "exit not in blocks\n");
            blocks = CONS(CONTROL, ce, blocks);
            compile_control(ce, hostmap, nodemap);
        }
        
        MAP(CONTROL, c,
         {
             update_control_lists(c, hostmap);
             update_control_lists(c, nodemap);
         },
            blocks);
 
        ifdebug(9)
        {
            control h_tmp, n_tmp;
 
            pips_debug(9, "controls:\n");
            
            MAP(CONTROL, c_tmp,
             {
                 h_tmp = (control) GET_CONTROL_MAPPING(hostmap, c_tmp);
                 n_tmp = (control) GET_CONTROL_MAPPING(nodemap, c_tmp);
                 
                 debug_print_control(c_tmp, "initial");
                 debug_print_control(h_tmp, "host");
                 debug_print_control(n_tmp, "node");
             },
                 blocks);
        }
 
        /*    HOST statement
         */
        (*hoststatp) = MakeStatementLike(stat, is_instruction_unstructured);
 
        new_ct = (control) GET_CONTROL_MAPPING(hostmap, ct);
        new_ce = (control) GET_CONTROL_MAPPING(hostmap, ce);
 
        pips_assert("defined control", !control_undefined_p(new_ct) &&
                    !control_undefined_p(new_ce));
 
        ifdebug(9)
        {
            pips_debug(9, "host controls for [%p,%p]:\n", ct, ce);
            
            debug_print_control(new_ct, "main");
            debug_print_control(new_ce, "exit");
        }
 
        instruction_unstructured(statement_instruction(*hoststatp)) =
            make_unstructured(new_ct, new_ce);
 
        DEBUG_STAT(7, "host new stat", *hoststatp);
 
        /*    NODE statement
         */
        (*nodestatp) = MakeStatementLike(stat, is_instruction_unstructured);
 
        new_ct = (control) GET_CONTROL_MAPPING(nodemap, ct);
        new_ce = (control) GET_CONTROL_MAPPING(nodemap, ce);
 
        pips_assert("defined control",
                    !control_undefined_p(new_ct) && 
                    !control_undefined_p(new_ce));
 
        instruction_unstructured(statement_instruction(*nodestatp)) =
            make_unstructured(new_ct, new_ce);
 
        DEBUG_STAT(7, "host new stat (again)", *hoststatp);
        
        gen_free_list(blocks);
        FREE_CONTROL_MAPPING(hostmap);
        FREE_CONTROL_MAPPING(nodemap);
    }
}

References blocks, compile_control(), CONS, CONTROL, CONTROL_MAP, control_statement, control_undefined_p, debug_print_control, DEBUG_STAT, FREE_CONTROL_MAPPING, gen_free_list(), gen_in_list_p(), GET_CONTROL_MAPPING, hpf_compiler(), ifdebug, instruction_unstructured, instruction_unstructured_p, is_instruction_unstructured, MAKE_CONTROL_MAPPING, make_unstructured(), MakeStatementLike(), MAP, NIL, one_statement_unstructured, pips_assert, pips_debug, statement_instruction, unstructured_control, unstructured_exit, and update_control_lists().

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_compiler()

void hpf_compiler	(	statement	stat,
		statement *	hoststatp,
		statement *	nodestatp
	)

what: compile a statement into a host and SPMD node code.

how: double code rewriting in a recursive traversal of stat. input: statement stat. output: statements *hoststatp and *nodestatp side effects: ? bugs or features:

• special care is made here of I/O and remappings.

of hpfc_reduction

necessary

remapping

HPF REDUCTION

else usual stuff

of statement

Parameters

stat	tat
hoststatp	oststatp
nodestatp	odestatp

Definition at line 710 of file compiler.c.

{
    list /* of hpfc_reduction */ lr = NIL;
    bool root_statement_p = stat==get_current_module_statement();
 
    DEBUG_STAT(9, "stat is", stat);
    pips_debug(9, "only io %d, remapping %d, reduction %d\n",
               load_statement_only_io(stat),
               bound_renamings_p(stat),
               bound_hpf_reductions_p(stat));
 
    if (load_statement_only_io(stat)==1) /* necessary */
    {
        io_efficient_compile(stat, hoststatp, nodestatp);
        return;
    }
    else if (bound_renamings_p(stat) && !root_statement_p) /* remapping */
    {
        remapping_compile(stat, hoststatp, nodestatp);
        return;
    }
    
    if (bound_hpf_reductions_p(stat)) /* HPF REDUCTION */
        lr = handle_hpf_reduction(stat);
    
    /* else usual stuff 
     */
    switch(instruction_tag(statement_instruction(stat)))
    {
    case is_instruction_block:
        hpf_compile_block(stat, hoststatp, nodestatp);
        break;
    case is_instruction_test:
        hpf_compile_test(stat, hoststatp, nodestatp);
        break;
    case is_instruction_loop:
        hpf_compile_loop(stat, hoststatp, nodestatp);
        break;
    case is_instruction_call:
        hpf_compile_call(stat, hoststatp, nodestatp);
        break;
    case is_instruction_unstructured:
        hpf_compile_unstructured(stat, hoststatp, nodestatp);
        break;
    case is_instruction_goto:
    default:
        pips_internal_error("unexpected instruction tag");
        break;
    }
 
    if (lr)
    {
        list /* of statement */ lh, ln;
        lh = gen_nconc(compile_hpf_reduction(lr, true, true),
         CONS(STATEMENT, *hoststatp,
                       compile_hpf_reduction(lr, false, true)));
        ln = gen_nconc(compile_hpf_reduction(lr, true, false),
         CONS(STATEMENT, *nodestatp,
                       compile_hpf_reduction(lr, false, false)));
 
        *hoststatp = make_block_statement(lh);
        *nodestatp = make_block_statement(ln);
    }
 
    if (root_statement_p && bound_renamings_p(stat))
    {
        *nodestatp = make_block_statement(
            CONS(STATEMENT, root_statement_remapping_inits(stat),
            CONS(STATEMENT, *nodestatp, NIL)));
    }
}

References bound_hpf_reductions_p(), bound_renamings_p(), compile_hpf_reduction(), CONS, DEBUG_STAT, gen_nconc(), get_current_module_statement(), handle_hpf_reduction(), hpf_compile_block(), hpf_compile_call(), hpf_compile_loop(), hpf_compile_test(), hpf_compile_unstructured(), instruction_tag, io_efficient_compile(), is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, load_statement_only_io(), make_block_statement(), NIL, pips_debug, pips_internal_error, remapping_compile(), root_statement_remapping_inits(), STATEMENT, and statement_instruction.

Referenced by compile_control(), compile_module(), hpf_compile_block(), hpf_compile_sequential_loop(), hpf_compile_test(), and hpf_compile_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_flt()

static bool loop_flt ( loop  l )

static

Definition at line 607 of file compiler.c.

{
    if (execution_parallel_p(loop_execution(l))) {
        parallel_loop_found = true;
        gen_recurse_stop(NULL);
    }
    return !parallel_loop_found;
} 

References execution_parallel_p, gen_recurse_stop(), loop_execution, and parallel_loop_found.

Referenced by parallel_loop_in_stat_p().

Here is the call graph for this function:

Here is the caller graph for this function:

parallel_loop_in_stat_p()

static bool parallel_loop_in_stat_p ( statement  s )

static

Definition at line 615 of file compiler.c.

{
    parallel_loop_found = false;
    gen_recurse(s, loop_domain, loop_flt, gen_null);
    return parallel_loop_found;
}

References gen_null(), gen_recurse, loop_domain, loop_flt(), and parallel_loop_found.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

host_module

entity host_module

HPFC - Fabien Coelho, May 1993 and later...

compiler.c

Compiler

stat is the current statement to be compiled, and there are pointers to the current statement building of the node and host codes. the module of these are also kept in order to add the needed declarations generated by the compilation.

however, every entities of the compiled program, and of both generated programs will be mixed, due to the tabulated nature of these objects. some objects will be shared. I don't think this is a problem. global variables

Definition at line 47 of file compiler.c.

Referenced by add_declaration_to_host_and_link(), AddCommonToHostAndNodeModules(), AddEntityToHostAndNodeModules(), compile_module(), generate_c1_beta(), generate_read_of_ref_for_all(), hpf_compile_block(), hpf_compile_call(), hpf_compile_sequential_loop(), hpf_compile_test(), hpfc_common_hook(), hpfc_module_suffix(), init_host_and_node_entities(), NewVariableForModule(), old_name(), put_generated_resources_for_common(), put_generated_resources_for_module(), and update_object_for_module().

node_module

entity node_module

Definition at line 47 of file compiler.c.

Referenced by AddCommonToHostAndNodeModules(), AddEntityToHostAndNodeModules(), compile_module(), extract_lattice(), generate_c1_alpha(), generate_c1_beta(), generate_compute_local_indices(), generate_get_value_locally(), generate_hpf_remapping_file(), generate_optimized_code_for_loop_nest(), generate_parallel_body(), generate_read_of_ref_for_all(), generate_receive_from_computer(), generate_send_to_computer(), hpf_compile_block(), hpf_compile_call(), hpf_compile_parallel_loop(), hpf_compile_sequential_loop(), hpf_compile_test(), hpfc_module_suffix(), init_host_and_node_entities(), Overlap_Analysis(), put_generated_resources_for_common(), put_generated_resources_for_module(), st_compute_current_computer(), st_compute_current_owners(), and st_compute_ith_local_index().

parallel_loop_found

bool parallel_loop_found

static

is there a parallel loop down s?

Definition at line 606 of file compiler.c.

Referenced by loop_flt(), and parallel_loop_in_stat_p().