generate.c File Reference

#include "defines-local.h"

Include dependency graph for generate.c:

Go to the source code of this file.

Functions
void	generate_c1_beta (statement stat, list *lhp, list *lnp)
	??? this should work (but that is not the case yet), with every call with no write to distributed arrays. More...
void	generate_c1_alpha (statement stat, list *lhp, list *lnp)
	generate_c1_alpha More...
void	generate_update_values_on_nodes (reference ref, reference newref, list *lscompp, list *lsnotcompp)
	generate_update_values_on_nodes More...
void	generate_read_of_ref_for_computer (syntax s, list *lcompp, list *lnotcompp)
	generate_read_of_ref_for_computer More...
void	generate_read_of_ref_for_all (syntax s, list *lhp, list *lnp)
	generate_read_of_ref_for_all More...
void	generate_compute_local_indices (reference ref, list *lsp, list *lindsp)
	generate_compute_local_indices More...
void	generate_get_value_locally (reference ref, reference goal, list *lstatp)
	generate_get_value_locally More...
void	generate_send_to_computer (reference ref, list *lstatp)
	generate_send_to_computer More...
void	generate_receive_from_computer (reference ref, list *lstatp)
void	generate_parallel_body (statement body, list *lstatp, list lw, list lr)
void	generate_update_values_on_computer_and_nodes (reference ref, reference val, list *lscompp, list *lsnotcompp)
	generate_update_values_on_computer_and_nodes More...
void	generate_update_distributed_value_from_host (syntax s, list *lhstatp, list *lnstatp)
	generate_update_distributed_value_from_host More...
void	generate_update_private_value_from_host (syntax s, list *lhstatp, list *lnstatp)
	generate_update_private_value_from_host More...
statement	st_get_value_locally_and_send (reference ref, reference goal)
statement	st_compute_ith_local_index (entity array, int i, expression expr, syntax *sp)
	the returned expression is translated into variables of the node module. More...
statement	st_send_to_host_and_nodes (reference ref, reference val)
statement	st_send_to_computer_if_necessary (reference ref)
statement	st_get_value_for_all (reference ref, reference goal)
statement	st_get_value_for_computer (reference ref, reference goal)
statement	st_receive_from (reference ref, reference goal)
	if ref is replicated: goal = Receive_From_Sender() More...

Function Documentation

generate_c1_alpha()

void generate_c1_alpha	(	statement	stat,
		list *	lhp,
		list *	lnp
	)

generate_c1_alpha

a distributed array variable is defined

read references to distributed arrays.

generation of the code to get the necessary values...

then the updated statement is to be added to node:

Update the values of the defined distributed variable if necessary...

the overall statements are generated.

Parameters

stat	tat
lhp	hp
lnp	np

Definition at line 121 of file generate.c.

{
    statement statcomputation, statcomputecomputer, statifcomputer;
    expression writtenexpr, newreadexpr;
    call the_call;
    list
        lupdatecomp = NIL,
        lupdatenotcomp = NIL,
        lreadreftodistarray = NIL,
        lstatcomp = NIL,
        lstatnotcomp = NIL,
        lstat = NIL,
        linds = NIL;
    reference ref, newref;
    entity newarray;
 
    (*lhp) = NIL;
    (*lnp) = NIL;
 
    pips_assert("call", statement_call_p(stat));
 
    the_call = instruction_call(statement_instruction(stat));
    pips_assert("assignment", ENTITY_ASSIGN_P(call_function(the_call)));
 
    writtenexpr = EXPRESSION(CAR(call_arguments(the_call)));
    pips_assert("reference",
                syntax_reference_p(expression_syntax(writtenexpr)) &&
           (array_distributed_p
            (reference_variable
             (syntax_reference(expression_syntax(writtenexpr))))));
 
    /* read references to distributed arrays.
     */
    lreadreftodistarray =
        FindRefToDistArray(EXPRESSION(CAR(CDR(call_arguments(the_call)))));
 
    /* generation of the code to get the necessary values...
     */
    MAP(SYNTAX, s,
    {
        list lnotcomp;
        list lcomp;
 
        pips_debug(8, "considering reference to %s\n",
              entity_name(reference_variable(syntax_reference(s))));
 
        generate_read_of_ref_for_computer(s, &lcomp, &lnotcomp);
 
        lstatcomp = gen_nconc(lstatcomp, lcomp);
        lstatnotcomp = gen_nconc(lstatnotcomp, lnotcomp);
    },
        lreadreftodistarray);
 
    gen_free_list(lreadreftodistarray);
 
    /* then the updated statement is to be added to node:
     */
    ref = syntax_reference(expression_syntax(writtenexpr));
    newarray  =  load_new_node(reference_variable(ref));
    generate_compute_local_indices(ref, &lstat, &linds);
    newref = make_reference(newarray, linds);
    newreadexpr = UpdateExpressionForModule
        (node_module, EXPRESSION(CAR(CDR(call_arguments(the_call)))));
 
    statcomputation =
        make_assign_statement(reference_to_expression(newref),
                              newreadexpr);
 
    lstatcomp = gen_nconc(lstatcomp, lstat);
    lstatcomp = gen_nconc(lstatcomp, CONS(STATEMENT, statcomputation, NIL));
 
    /* Update the values of the defined distributed variable
     * if necessary...
     */
    generate_update_values_on_nodes(ref, newref, &lupdatecomp, &lupdatenotcomp);
 
    lstatcomp = gen_nconc(lstatcomp, lupdatecomp);
    lstatnotcomp = gen_nconc(lstatnotcomp, lupdatenotcomp);
 
    /* the overall statements are generated.
     */
    statcomputecomputer = st_compute_current_computer(ref);
    statifcomputer = st_make_nice_test(condition_computerp(),
                                       lstatcomp,
                                       lstatnotcomp);
 
    DEBUG_STAT(8, entity_name(node_module), statifcomputer);
 
    (*lnp) = CONS(STATEMENT, statcomputecomputer,
             CONS(STATEMENT, statifcomputer,
                  NIL));
    (*lhp) = NIL;
 
    return;
 }

References array_distributed_p(), call_arguments, call_function, CAR, CDR, condition_computerp, CONS, DEBUG_STAT, ENTITY_ASSIGN_P, entity_name, EXPRESSION, expression_syntax, FindRefToDistArray(), gen_free_list(), gen_nconc(), generate_compute_local_indices(), generate_read_of_ref_for_computer(), generate_update_values_on_nodes(), instruction_call, load_new_node(), make_assign_statement(), make_reference(), MAP, NIL, node_module, pips_assert, pips_debug, ref, reference_to_expression(), reference_variable, st_compute_current_computer(), st_make_nice_test(), STATEMENT, statement_call_p(), statement_instruction, SYNTAX, syntax_reference, syntax_reference_p, and UpdateExpressionForModule().

Referenced by hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_c1_beta()

void generate_c1_beta	(	statement	stat,
		list *	lhp,
		list *	lnp
	)

??? this should work (but that is not the case yet), with every call with no write to distributed arrays.

generate.c

these conditions are to be verifyed, by calculating the proper effects of the statement.

to be corrected later on.

this shouldn't be necessary

references to distributed arrays: w(A(I)) = B(I) so the whole list is to be considered.

generation of the code

Parameters

stat	tat
lhp	hp
lnp	np

Definition at line 41 of file generate.c.

{
    statement staths, statns;
    expression w;
    call the_call;
    list lreftodistarray = NIL;
 
    (*lhp) = NIL;
    (*lnp) = NIL;
 
    pips_assert("call", statement_call_p(stat));
 
    the_call = instruction_call(statement_instruction(stat));
 
    /* this shouldn't be necessary
     */
    pips_assert("assignment", ENTITY_ASSIGN_P(call_function(the_call)));
 
    w = EXPRESSION(CAR(call_arguments(the_call)));
 
    pips_assert("reference",
                syntax_reference_p(expression_syntax(w)) &&
            (!array_distributed_p
             (reference_variable(syntax_reference(expression_syntax(w))))));
 
    /* references to distributed arrays:
     * w(A(I)) = B(I)
     * so the whole list is to be considered.
     */
    lreftodistarray = FindRefToDistArrayFromList(call_arguments(the_call));
 
    /* generation of the code
     */
    MAP(SYNTAX, s,
     {
         list lhost;
         list lnode;
 
         pips_debug(8, "considering reference to %s\n",
               entity_name(reference_variable(syntax_reference(s))));
 
         generate_read_of_ref_for_all(s, &lhost, &lnode);
 
         (*lhp) = gen_nconc((*lhp), lhost);
         (*lnp) = gen_nconc((*lnp), lnode);
     },
         lreftodistarray);
 
    /*
     * then updated statements are to be added to both host and nodes:
     */
 
    staths = instruction_to_statement(make_instruction
                          (is_instruction_call,
                           make_call(call_function(the_call),
                                     lUpdateExpr(host_module,
                                                 call_arguments(the_call)))));
 
    statns = instruction_to_statement(make_instruction
                          (is_instruction_call,
                           make_call(call_function(the_call),
                                     lUpdateExpr(node_module,
                                                 call_arguments(the_call)))));
 
    DEBUG_STAT(9, entity_name(host_module), staths);
    DEBUG_STAT(9, entity_name(node_module), statns);
 
    (*lhp) = gen_nconc((*lhp), CONS(STATEMENT, staths, NIL));
    (*lnp) = gen_nconc((*lnp), CONS(STATEMENT, statns, NIL));
 
    gen_free_list(lreftodistarray);
}

References array_distributed_p(), call_arguments, call_function, CAR, CONS, DEBUG_STAT, ENTITY_ASSIGN_P, entity_name, EXPRESSION, expression_syntax, FindRefToDistArrayFromList(), gen_free_list(), gen_nconc(), generate_read_of_ref_for_all(), host_module, instruction_call, instruction_to_statement(), is_instruction_call, lUpdateExpr(), make_call(), make_instruction(), MAP, NIL, node_module, pips_assert, pips_debug, reference_variable, STATEMENT, statement_call_p(), statement_instruction, SYNTAX, 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:

generate_compute_local_indices()

void generate_compute_local_indices	(	reference	ref,
		list *	lsp,
		list *	lindsp
	)

generate_compute_local_indices

this function generate the list of statement necessary to compute the local indices of the given reference. It gives back the new list of indices for the reference.

Parameters

ref	ef
lsp	sp
lindsp	indsp

Definition at line 388 of file generate.c.

{
    int i;
    entity array = reference_variable(ref);
    list inds = reference_indices(ref);
 
    pips_assert("distributed array", array_distributed_p(array));
 
    (*lsp) = NIL, (*lindsp) = NIL;
 
    pips_debug(9, "number of dimensions of %s to compute: %d\n",
          entity_name(array), NumberOfDimension(array));
 
    for(i=1; i<=NumberOfDimension(array); i++, inds = CDR(inds))
    {
        if (local_index_is_different_p(array, i))
        {
            syntax s;
            statement stat = st_compute_ith_local_index(array, i,
                                              EXPRESSION(CAR(inds)), &s);
 
            DEBUG_STAT(9, entity_name(node_module), stat);
 
            (*lsp) = gen_nconc((*lsp), CONS(STATEMENT, stat, NIL));
            (*lindsp) =
                gen_nconc((*lindsp), CONS(EXPRESSION,
                           make_expression(s, normalized_undefined), NIL));
        }
        else
        {
            expression expr =
                UpdateExpressionForModule(node_module, EXPRESSION(CAR(inds)));
 
            (*lindsp) =
                gen_nconc((*lindsp),
                          CONS(EXPRESSION, expr, NIL));
        }
    }
 
    pips_debug(8, "result:\n");
    ifdebug(8)
        MAP(STATEMENT, s, DEBUG_STAT(8, entity_name(node_module), s), (*lsp));
}

References array, array_distributed_p(), CAR, CDR, CONS, DEBUG_STAT, entity_name, EXPRESSION, gen_nconc(), ifdebug, local_index_is_different_p, make_expression(), MAP, NIL, node_module, normalized_undefined, NumberOfDimension(), pips_assert, pips_debug, ref, reference_indices, reference_variable, st_compute_ith_local_index(), STATEMENT, and UpdateExpressionForModule().

Referenced by generate_c1_alpha(), generate_get_value_locally(), generate_parallel_body(), generate_receive_from_computer(), generate_send_to_computer(), generate_update_distributed_value_from_host(), generate_update_values_on_computer_and_nodes(), generate_update_values_on_nodes(), and st_send_to_computer_if_necessary().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_get_value_locally()

void generate_get_value_locally	(	reference	ref,
		reference	goal,
		list *	lstatp
	)

generate_get_value_locally

put the local value of ref in the variable local.

for every indexes, if necessary, compute the local value of the indices, by calling RTR support function LOCAL_INDEX(array_number, dimension) then the assignment is performed.

tempi = LOCAL_INDEX(array_number, dimension, indexi) ... goal = ref_local(tempi...)

Parameters

ref	ef
goal	oal
lstatp	statp

Definition at line 446 of file generate.c.

{
    statement stat;
    expression expr;
    entity array = reference_variable(ref),
           newarray = load_new_node(array);
    list ls = NIL, newinds = NIL;
 
    pips_assert("distributed array", array_distributed_p(array));
 
    generate_compute_local_indices(ref, &ls, &newinds);
    expr = reference_to_expression(make_reference(newarray, newinds));
    stat = make_assign_statement(reference_to_expression(goal), expr);
 
    DEBUG_STAT(9, entity_name(node_module), stat);
 
    (*lstatp) = gen_nconc(ls, CONS(STATEMENT, stat, NIL));
}

References array, array_distributed_p(), CONS, DEBUG_STAT, entity_name, gen_nconc(), generate_compute_local_indices(), load_new_node(), make_assign_statement(), make_reference(), NIL, node_module, pips_assert, ref, reference_to_expression(), reference_variable, and STATEMENT.

Referenced by st_get_value_for_computer(), and st_get_value_locally_and_send().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_parallel_body()

void generate_parallel_body	(	statement	body,
		list *	lstatp,
		list	lw,
		list	lr
	)

the first written or read distributed ref is chosen as the computer

we are sure that computer is one of the owners

Parameters

body	ody
lstatp	statp
lw	w
lr	r

Definition at line 511 of file generate.c.

{
    statement statcc, statbody;
    list lcomp = NIL, lcompr = NIL, lcompw = NIL,
        lnotcomp = NIL, lnotcompr = NIL, lnotcompw = NIL;
    syntax comp;
 
    pips_assert("at leat one written or read",
                (gen_length(lw)+gen_length(lr))>0);
 
    /* the first written or read distributed ref is chosen as the computer
     */
    comp = lw? SYNTAX(CAR(lw)): SYNTAX(CAR(lr));
    statcc = st_compute_current_computer(syntax_reference(comp));
 
    MAP(SYNTAX, s,
     {
         list lco = NIL;
         list lnotco = NIL;
 
         generate_read_of_ref_for_computer(s, &lco, &lnotco);
 
         lcompr = gen_nconc(lcompr, lco);
         lnotcompr = gen_nconc(lnotcompr, lnotco);
     },
         lr);
 
    MAP(SYNTAX, s,
     {
         list lco = NIL;
         list lnotco = NIL;
         reference r = syntax_reference(s);
         entity var = reference_variable(r);
         entity temp = make_new_scalar_variable(get_current_module_entity(),
                                         entity_basic(var));
         entity tempn ;
 
         AddEntityToHostAndNodeModules(temp);
         tempn = load_new_node( temp);
 
         if (comp == s)
         {
             /* we are sure that computer is one of the owners
              */
             list lstat = NIL;
             list linds = NIL;
             entity newarray = load_new_node(var);
 
             generate_compute_local_indices(r, &lstat, &linds);
             lstat =
                 gen_nconc
                     (lstat,
                      CONS(STATEMENT,
                           make_assign_statement
                             (reference_to_expression(make_reference(newarray,
                                                                     linds)),
                              entity_to_expression(tempn)),
                           NIL));
 
             generate_update_values_on_nodes
                 (r, make_reference(tempn, NIL), &lco, &lnotco);
 
             lco = gen_nconc(lstat, lco);
         }
         else
         {
             generate_update_values_on_computer_and_nodes
                 (r, make_reference(tempn, NIL), &lco, &lnotco);
         }
 
         lcompw = gen_nconc(lcompw, lco);
         lnotcompw = gen_nconc(lnotcompw, lnotco);
 
         syntax_reference(s) = make_reference(temp, NIL);
     },
         lw);
 
 
    pips_debug(6, "%zd statements for computer write:\n", gen_length(lcompw));
 
    ifdebug(8)
    {
        MAP(STATEMENT, s, DEBUG_STAT(8, entity_name(node_module), s), lcompw);
    }
 
    pips_debug(6, "%zd statements for not computer write:\n",
               gen_length(lnotcompw));
 
    ifdebug(8)
    {
        MAP(STATEMENT, s, DEBUG_STAT(8, entity_name(node_module), s),
            lnotcompw);
    }
 
    statbody = UpdateStatementForModule(node_module, body);
    DEBUG_STAT(7, entity_name(node_module), statbody);
 
    lcomp = gen_nconc(lcompr, CONS(STATEMENT, statbody, lcompw));
    lnotcomp = gen_nconc(lnotcompr, lnotcompw);
 
    (*lstatp) = CONS(STATEMENT, statcc,
                CONS(STATEMENT, st_make_nice_test(condition_computerp(),
                                                  lcomp,
                                                  lnotcomp),
                     NIL));
 
    ifdebug(6)
    {
        pips_debug(6, "final statement:\n");
        MAP(STATEMENT, s, DEBUG_STAT(6, entity_name(node_module),s), (*lstatp));
    }
}

References AddEntityToHostAndNodeModules(), CAR, condition_computerp, CONS, DEBUG_STAT, entity_basic(), entity_name, entity_to_expression(), gen_length(), gen_nconc(), generate_compute_local_indices(), generate_read_of_ref_for_computer(), generate_update_values_on_computer_and_nodes(), generate_update_values_on_nodes(), get_current_module_entity(), ifdebug, load_new_node(), make_assign_statement(), make_new_scalar_variable(), make_reference(), MAP, NIL, node_module, pips_assert, pips_debug, reference_to_expression(), reference_variable, st_compute_current_computer(), st_make_nice_test(), STATEMENT, SYNTAX, syntax_reference, and UpdateStatementForModule().

Referenced by hpf_compile_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_read_of_ref_for_all()

void generate_read_of_ref_for_all	(	syntax	s,
		list *	lhp,
		list *	lnp
	)

generate_read_of_ref_for_all

this function organise the read of the given reference for all the nodes, and for host.

the receive statement is built for host:

COMPUTE_CURRENT_OWNERS(ref) temp = RECEIVEFROMSENDER(...)

a receive from sender is generated, however replicated the variable is FC 930623 (before was a call to st_receive_from(ref, ...))

the code for node is built, in order that temp has the wanted value.

COMPUTE_CURRENT_OWNERS(ref) IF OWNERP(ME) THEN local_ref = COMPUTE_LOCAL(ref) temp = (local_ref) IF SENDERP(ME) // this protection in case of replicated arrays. THEN SENDTOHOST(temp) SENDTONODE(ALL-OWNERS,temp) ENDIF ELSE temp = RECEIVEFROM(SENDER(...)) ENDIF

the new variable is inserted in the expression...

Parameters

lhp	hp
lnp	np

Definition at line 316 of file generate.c.

{
    statement stathco, stathrcv, statnco, statngv;
    reference ref = syntax_reference(s);
    entity temph, tempn,
        var = reference_variable(ref),
        temp = make_new_scalar_variable(get_current_module_entity(),
                                    entity_basic(var));
 
    pips_assert("distributed array", array_distributed_p(var));
 
    AddEntityToHostAndNodeModules(temp);
    temph = load_new_host(temp);
    tempn = load_new_node(temp);
 
    /* the receive statement is built for host:
     *
     * COMPUTE_CURRENT_OWNERS(ref)
     * temp = RECEIVEFROMSENDER(...)
     */
    stathco = st_compute_current_owners(ref);
 
    /* a receive from sender is generated, however replicated the variable is
     * FC 930623 (before was a call to st_receive_from(ref, ...))
     */
    stathrcv = st_receive_from(ref, make_reference(temph, NIL));
 
    (*lhp) = CONS(STATEMENT, stathco,
             CONS(STATEMENT, stathrcv,
                  NIL));
 
    DEBUG_STAT(9, entity_name(host_module), stathco);
    DEBUG_STAT(9, entity_name(host_module), stathrcv);
 
    /* the code for node is built, in order that temp has the
     * wanted value.
     *
     * COMPUTE_CURRENT_OWNERS(ref)
     * IF OWNERP(ME)
     * THEN
     *   local_ref = COMPUTE_LOCAL(ref)
     *   temp = (local_ref)
     *   IF SENDERP(ME) // this protection in case of replicated arrays.
     *   THEN
     *       SENDTOHOST(temp)
     *   SENDTONODE(ALL-OWNERS,temp)
     *   ENDIF
     * ELSE
     *   temp = RECEIVEFROM(SENDER(...))
     * ENDIF
     */
    statnco = st_compute_current_owners(ref);
    statngv = st_get_value_for_all(ref, make_reference(tempn, NIL));
 
    (*lnp) = CONS(STATEMENT, statnco, CONS(STATEMENT, statngv, NIL));
 
    DEBUG_STAT(9, entity_name(node_module), statnco);
    DEBUG_STAT(9, entity_name(node_module), statngv);
 
    /* the new variable is inserted in the expression...
     */
    syntax_reference(s) = make_reference(temp, NIL);
}

References AddEntityToHostAndNodeModules(), array_distributed_p(), CONS, DEBUG_STAT, entity_basic(), entity_name, get_current_module_entity(), host_module, load_new_host(), load_new_node(), make_new_scalar_variable(), make_reference(), NIL, node_module, pips_assert, ref, reference_variable, st_compute_current_owners(), st_get_value_for_all(), st_receive_from(), STATEMENT, and syntax_reference.

Referenced by generate_c1_beta().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_read_of_ref_for_computer()

void generate_read_of_ref_for_computer	(	syntax	s,
		list *	lcompp,
		list *	lnotcompp
	)

generate_read_of_ref_for_computer

en cours d'adaptation...

the new variable is inserted in the expression...

Parameters

lcompp	compp
lnotcompp	notcompp

Definition at line 275 of file generate.c.

{
    statement statcompco, statcompgv, statnotcompco, statnotcompmaysend;
    reference ref = syntax_reference(s);
    entity tempn,
        var = reference_variable(ref),
        temp = make_new_scalar_variable(get_current_module_entity(),
                                    entity_basic(var));
 
    pips_assert("distributed array", array_distributed_p(var));
 
    AddEntityToHostAndNodeModules(temp);
    tempn = load_new_node(temp);
 
    statcompco = st_compute_current_owners(ref);
    statcompgv = st_get_value_for_computer(ref, make_reference(tempn, NIL));
 
    (*lcompp) = CONS(STATEMENT, statcompco,
                CONS(STATEMENT, statcompgv, NIL));
 
    statnotcompco = st_compute_current_owners(ref);
    statnotcompmaysend = st_send_to_computer_if_necessary(ref);
 
 
    (*lnotcompp) =
        CONS(STATEMENT, statnotcompco,
        CONS(STATEMENT, statnotcompmaysend,
             NIL));
 
    /* the new variable is inserted in the expression...
     */
    syntax_reference(s) = make_reference(temp, NIL);
}

References AddEntityToHostAndNodeModules(), array_distributed_p(), CONS, entity_basic(), get_current_module_entity(), load_new_node(), make_new_scalar_variable(), make_reference(), NIL, pips_assert, ref, reference_variable, st_compute_current_owners(), st_get_value_for_computer(), st_send_to_computer_if_necessary(), STATEMENT, and syntax_reference.

Referenced by generate_c1_alpha(), and generate_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_receive_from_computer()

void generate_receive_from_computer	(	reference	ref,
		list *	lstatp
	)

Parameters

ref	ef
lstatp	statp

Definition at line 491 of file generate.c.

{
    statement statrcv;
    entity
        array = reference_variable(ref),
        newarray = load_new_node(array);
    list ls = NIL, newinds = NIL;
 
    pips_assert("distributed array", array_distributed_p(array));
 
    generate_compute_local_indices(ref, &ls, &newinds);
    statrcv = st_receive_from_computer(make_reference(newarray, newinds));
 
    DEBUG_STAT(9, entity_name(node_module), statrcv);
 
    (*lstatp) = gen_nconc(ls, CONS(STATEMENT, statrcv, NIL));
}

References array, array_distributed_p(), CONS, DEBUG_STAT, entity_name, gen_nconc(), generate_compute_local_indices(), load_new_node(), make_reference(), NIL, node_module, pips_assert, ref, reference_variable, st_receive_from_computer, and STATEMENT.

Here is the call graph for this function:

generate_send_to_computer()

void generate_send_to_computer	(	reference	ref,
		list *	lstatp
	)

generate_send_to_computer

sends the local value of ref to the current computer

Parameters

ref	ef
lstatp	statp

Definition at line 471 of file generate.c.

{
    statement statsnd;
    entity
        array = reference_variable(ref),
        newarray = load_new_node(array);
    list ls = NIL, newinds = NIL;
 
    pips_assert("distributed array", array_distributed_p(array));
 
    generate_compute_local_indices(ref, &ls, &newinds);
    statsnd = st_send_to_computer(make_reference(newarray, newinds));
 
    DEBUG_STAT(9, entity_name(node_module), statsnd);
 
    (*lstatp) = gen_nconc(ls, CONS(STATEMENT, statsnd, NIL));
}

References array, array_distributed_p(), CONS, DEBUG_STAT, entity_name, gen_nconc(), generate_compute_local_indices(), load_new_node(), make_reference(), NIL, node_module, pips_assert, ref, reference_variable, st_send_to_computer, and STATEMENT.

Here is the call graph for this function:

generate_update_distributed_value_from_host()

void generate_update_distributed_value_from_host	(	syntax	s,
		list *	lhstatp,
		list *	lnstatp
	)

generate_update_distributed_value_from_host

call the necessary communication function

Parameters

lhstatp	hstatp
lnstatp	nstatp

Definition at line 691 of file generate.c.

{
    reference r = syntax_reference(s);
    entity array, newarray, temp, temph;
    statement statnco, stathco, stnrcv, stnif, sthsnd;
    list linds = NIL, lnstat = NIL;
 
    pips_assert("distrivuted reference",
                array_distributed_p(reference_variable(syntax_reference(s))));
 
    array    = reference_variable(r);
    newarray = load_new_node(array);
 
    temp     = make_new_scalar_variable(get_current_module_entity(),
                                    entity_basic(array));
 
    AddEntityToHostAndNodeModules(temp);
    temph = load_new_host(temp);
 
    generate_compute_local_indices(r, &lnstat, &linds);
    stnrcv = st_receive_from_host(make_reference(newarray, linds));
    stnif = st_make_nice_test(condition_ownerp(),
                              gen_nconc(lnstat,
                                        CONS(STATEMENT, stnrcv, NIL)),
                              NIL);
 
    /* call the necessary communication function
     */
 
    sthsnd = (replicated_p(array) ?
              st_send_to_owners(make_reference(temph, NIL)) :
              st_send_to_owner(make_reference(temph, NIL))) ;
 
    syntax_reference(s) = make_reference(temp, NIL);
 
    statnco = st_compute_current_owners(r);
    stathco = st_compute_current_owners(r);
 
    (*lhstatp) = CONS(STATEMENT, stathco, CONS(STATEMENT, sthsnd, NIL));
    (*lnstatp) = CONS(STATEMENT, statnco, CONS(STATEMENT, stnif, NIL));
 
}

References AddEntityToHostAndNodeModules(), array, array_distributed_p(), condition_ownerp, CONS, entity_basic(), gen_nconc(), generate_compute_local_indices(), get_current_module_entity(), load_new_host(), load_new_node(), make_new_scalar_variable(), make_reference(), NIL, pips_assert, reference_variable, replicated_p(), st_compute_current_owners(), st_make_nice_test(), st_receive_from_host, st_send_to_owner, st_send_to_owners, STATEMENT, and syntax_reference.

Here is the call graph for this function:

generate_update_private_value_from_host()

void generate_update_private_value_from_host	(	syntax	s,
		list *	lhstatp,
		list *	lnstatp
	)

generate_update_private_value_from_host

Parameters

lhstatp	hstatp
lnstatp	nstatp

Definition at line 738 of file generate.c.

{
  entity
    var  = reference_variable(syntax_reference(s)),
    varn = load_new_node(var),
    varh = load_new_host(var);
 
  pips_assert("not distributed reference",
              !array_distributed_p(reference_variable(syntax_reference(s))));
 
  (*lhstatp) = CONS(STATEMENT,
                    st_host_send_to_all_nodes(make_reference(varh, NIL)),
                    NIL);
 
  (*lnstatp) = CONS(STATEMENT,
                    st_receive_mcast_from_host(make_reference(varn, NIL)),
                    NIL);
}

References array_distributed_p(), CONS, load_new_host(), load_new_node(), make_reference(), NIL, pips_assert, reference_variable, st_host_send_to_all_nodes, st_receive_mcast_from_host, STATEMENT, and syntax_reference.

Here is the call graph for this function:

generate_update_values_on_computer_and_nodes()

void generate_update_values_on_computer_and_nodes	(	reference	ref,
		reference	val,
		list *	lscompp,
		list *	lsnotcompp
	)

generate_update_values_on_computer_and_nodes

inside a loop, a variable is defined, and the values have to be updated on the computer node itself, and on the other owners of the given variable.

computer is doing the job

all values have to be updated...

Parameters

ref	ef
val	al
lscompp	scompp
lsnotcompp	snotcompp

Definition at line 634 of file generate.c.

{
    entity
        array = reference_variable(ref),
        newarray = load_new_node(array);
    statement
        statif, statcompif, statco, statcompco, statcompassign,
        statsndtoO, statsndtoOO, statrcvfromcomp;
    list lstat, lstatcomp, linds, lindscomp;
 
    /* all values have to be updated...
     */
    statcompco = st_compute_current_owners(ref);
    generate_compute_local_indices(ref, &lstatcomp, &lindscomp);
 
    statcompassign =
        make_assign_statement
            (reference_to_expression(make_reference(newarray, lindscomp)),
             reference_to_expression(val));
 
    if (replicated_p(array))
    {
        statsndtoOO = st_send_to_other_owners(val);
        statsndtoO  = st_send_to_owners(val);
    }
    else
    {
        statsndtoOO = make_continue_statement(entity_undefined);
        statsndtoO  = st_send_to_owner(val);
    }
    statcompif = st_make_nice_test
        (condition_ownerp(),
         gen_nconc(lstatcomp, CONS(STATEMENT, statcompassign,
                              CONS(STATEMENT, statsndtoOO,
                                   NIL))),
         CONS(STATEMENT, statsndtoO,
              NIL));
 
    statco = st_compute_current_owners(ref);
    generate_compute_local_indices(ref, &lstat, &linds);
    statrcvfromcomp =
        st_receive_from_computer(make_reference(newarray,linds));
    statif = st_make_nice_test(condition_ownerp(),
                               gen_nconc(lstat, CONS(STATEMENT, statrcvfromcomp,
                                                     NIL)),
                               NIL);
 
    (*lscompp) = CONS(STATEMENT, statcompco,
                 CONS(STATEMENT, statcompif, NIL));
    (*lsnotcompp) = CONS(STATEMENT, statco,
                    CONS(STATEMENT, statif, NIL));
}

References array, condition_ownerp, CONS, entity_undefined, gen_nconc(), generate_compute_local_indices(), load_new_node(), make_assign_statement(), make_continue_statement(), make_reference(), NIL, ref, reference_to_expression(), reference_variable, replicated_p(), st_compute_current_owners(), st_make_nice_test(), st_receive_from_computer, st_send_to_other_owners, st_send_to_owner, st_send_to_owners, and STATEMENT.

Referenced by generate_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_update_values_on_nodes()

void generate_update_values_on_nodes	(	reference	ref,
		reference	newref,
		list *	lscompp,
		list *	lsnotcompp
	)

generate_update_values_on_nodes

computer is doing the job

remote values have to be updated

the computer has to compute the owners in order to call the send to other owners function, because the owners are used to define the owners set, which was quite obvious:-)

bug fixed by FC, 930629

Parameters

ref	ef
newref	ewref
lscompp	scompp
lsnotcompp	snotcompp

Definition at line 223 of file generate.c.

{
    entity array = reference_variable(ref);
 
    if (replicated_p(array))
    {
        statement statif, statco, statco2, statsndtoon, statrcvfromcomp;
        list lstat, linds;
 
        /* remote values have to be updated
         */
        statco = st_compute_current_owners(ref);
 
        /* the computer has to compute the owners in order to call
         * the send to other owners function, because the owners
         * are used to define the owners set, which was quite obvious:-)
         *
         * bug fixed by FC, 930629
         */
        statco2 = st_compute_current_owners(ref);
        statsndtoon = st_send_to_other_owners(newref);
        generate_compute_local_indices(ref, &lstat, &linds);
        statrcvfromcomp =
            st_receive_from_computer(make_reference(reference_variable(newref),
                                                    linds));
        statif = st_make_nice_test(condition_ownerp(),
                                   gen_nconc(lstat,
                                             CONS(STATEMENT,
                                                  statrcvfromcomp,
                                                  NIL)),
                                   NIL);
 
        (*lscompp) = CONS(STATEMENT, statco2,
                     CONS(STATEMENT, statsndtoon,
                          NIL));
        (*lsnotcompp) = CONS(STATEMENT, statco,
                        CONS(STATEMENT, statif,
                             NIL));
    }
    else
    {
        (*lscompp) = NIL;
        (*lsnotcompp) = NIL;
    }
}

References array, condition_ownerp, CONS, gen_nconc(), generate_compute_local_indices(), make_reference(), NIL, ref, reference_variable, replicated_p(), st_compute_current_owners(), st_make_nice_test(), st_receive_from_computer, st_send_to_other_owners, and STATEMENT.

Referenced by generate_c1_alpha(), and generate_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

st_compute_ith_local_index()

statement st_compute_ith_local_index	(	entity	array,
		int	i,
		expression	expr,
		syntax *	sp
	)

the returned expression is translated into variables of the node module.

the necessity is not checked, but it could be done, looking that the new declaration of the given array is smaller or not on the given dimension...

Parameters

array	rray
expr	xpr
sp	p

Definition at line 775 of file generate.c.

{
    /* the necessity is not checked, but it could be done,
     * looking that the new declaration of the given array
     * is smaller or not on the given dimension...
     */
 
    entity temp = make_new_scalar_variable(node_module,
                                           MakeBasic(is_basic_int));
    statement stat;
    AddEntityToCurrentModule(temp);
 
    (*sp)=make_syntax(is_syntax_reference, make_reference(temp, NIL));
 
    stat=instruction_to_statement
        (make_assign_instruction
         (reference_to_expression(make_reference(temp, NIL)),
          expr_compute_local_index(array,
                                   i,
                                   UpdateExpressionForModule(node_module,
                                                             expr))));
 
    return(stat);
}

References AddEntityToCurrentModule(), array, expr_compute_local_index(), instruction_to_statement(), is_basic_int, is_syntax_reference, make_assign_instruction(), make_new_scalar_variable(), make_reference(), make_syntax(), MakeBasic(), NIL, node_module, reference_to_expression(), and UpdateExpressionForModule().

Referenced by generate_compute_local_indices().

Here is the call graph for this function:

Here is the caller graph for this function:

st_get_value_for_all()

statement st_get_value_for_all	(	reference	ref,
		reference	goal
	)

Parameters

ref	ef
goal	oal

Definition at line 842 of file generate.c.

{
    return
        st_make_nice_test(condition_ownerp(),
         CONS(STATEMENT, st_get_value_locally_and_send(ref,goal), NIL),
         CONS(STATEMENT, st_receive_from(ref,goal), NIL));
}

References condition_ownerp, CONS, NIL, ref, st_get_value_locally_and_send(), st_make_nice_test(), st_receive_from(), and STATEMENT.

Referenced by generate_read_of_ref_for_all().

Here is the call graph for this function:

Here is the caller graph for this function:

st_get_value_for_computer()

statement st_get_value_for_computer	(	reference	ref,
		reference	goal
	)

Parameters

ref	ef
goal	oal

Definition at line 850 of file generate.c.

{
    list ltrue=NIL, lfalse=NIL;
    generate_get_value_locally(ref,goal,&ltrue);
    lfalse=CONS(STATEMENT,st_receive_from_sender(goal),NIL);
    return st_make_nice_test(condition_ownerp(),ltrue,lfalse);
}

References condition_ownerp, CONS, generate_get_value_locally(), NIL, ref, st_make_nice_test(), st_receive_from_sender, and STATEMENT.

Referenced by generate_read_of_ref_for_computer().

Here is the call graph for this function:

Here is the caller graph for this function:

st_get_value_locally_and_send()

statement st_get_value_locally_and_send	(	reference	ref,
		reference	goal
	)

Parameters

ref	ef
goal	oal

Definition at line 760 of file generate.c.

{
    list ls=NIL;
 
    generate_get_value_locally(ref,goal,&ls);
    ls=gen_nconc(ls, CONS(STATEMENT, st_send_to_host_and_nodes(ref, goal),
                          NIL));
 
    return(make_block_statement(ls));
}

References CONS, gen_nconc(), generate_get_value_locally(), make_block_statement(), NIL, ref, st_send_to_host_and_nodes(), and STATEMENT.

Referenced by st_get_value_for_all().

Here is the call graph for this function:

Here is the caller graph for this function:

st_receive_from()

statement st_receive_from	(	reference	ref,
		reference	goal
	)

if ref is replicated: goal = Receive_From_Sender()

if ref is not replicated goal = Receive_Multi_Cast_From_Sender()

Parameters

ref	ef
goal	oal

Definition at line 865 of file generate.c.

{
    if (replicated_p(reference_variable(ref)))
        return st_receive_from_sender(goal);
    else
        return st_receive_mcast_from_sender(goal);
}

References ref, reference_variable, replicated_p(), st_receive_from_sender, and st_receive_mcast_from_sender.

Referenced by generate_read_of_ref_for_all(), and st_get_value_for_all().

Here is the call graph for this function:

Here is the caller graph for this function:

st_send_to_computer_if_necessary()

statement st_send_to_computer_if_necessary

(

reference

ref

)

Parameters

ref

ef

Definition at line 817 of file generate.c.

{
    entity
        array = reference_variable(ref),
        newarray = load_new_node(array);
    expression
        condition=((replicated_p(array))?
                   (MakeBinaryCall
                    (entity_intrinsic(AND_OPERATOR_NAME),
                     condition_senderp(),
                     condition_not_computer_in_owners())):
                   (condition_senderp()));
    list lstat = NIL, lnewinds = NIL;
 
    generate_compute_local_indices(ref, &lstat, &lnewinds);
 
    return
      st_make_nice_test(condition,
        gen_nconc(lstat,
          CONS(STATEMENT,
               st_send_to_computer(make_reference(newarray, lnewinds)),
               NIL)),
                        NIL);
}

References AND_OPERATOR_NAME, array, condition_not_computer_in_owners, condition_senderp, CONS, entity_intrinsic(), gen_nconc(), generate_compute_local_indices(), load_new_node(), make_reference(), MakeBinaryCall(), NIL, ref, reference_variable, replicated_p(), st_make_nice_test(), st_send_to_computer, and STATEMENT.

Referenced by generate_read_of_ref_for_computer().

Here is the call graph for this function:

Here is the caller graph for this function:

st_send_to_host_and_nodes()

statement st_send_to_host_and_nodes	(	reference	ref,
		reference	val
	)

Parameters

ref	ef
val	al

Definition at line 804 of file generate.c.

{
    if(replicated_p(reference_variable(ref)))
        return(st_make_nice_test(condition_senderp(),
                                 CONS(STATEMENT,
                                      st_send_to_host_and_not_owners(val),
                                      NIL),
                                 NIL));
    else
        return st_send_to_host_and_all_nodes(val);
}

References condition_senderp, CONS, NIL, ref, reference_variable, replicated_p(), st_make_nice_test(), st_send_to_host_and_all_nodes, st_send_to_host_and_not_owners, and STATEMENT.

Referenced by st_get_value_locally_and_send().

Here is the call graph for this function:

Here is the caller graph for this function: