generate-util.c File Reference

#include "defines-local.h"

Include dependency graph for generate-util.c:

Go to the source code of this file.

Functions
static expression	pvm_encoding_option (int n)
	HPFC module by Fabien COELHO. More...
statement	define_node_processor_id (entity proc, entity(*creation)(int))
	builds a statement VAR_i = MYPOS(i, proc_number) // i=1 to proc dimension More...
statement	generate_deducables (list le)
	statement generate_deducables(list le) More...
list	hpfc_gen_n_vars_expr (entity(*creation)(), int number)
	of expression More...
expression	make_reference_expression (entity e, entity(*creation)())
statement	hpfc_add_n (entity var, int n)
	returns statement VAR = VAR + N More...
statement	hpfc_add_2 (expression exp)
	expr = expr + 2 More...
statement	hpfc_message (expression tid, expression channel, bool send)
statement	hpfc_lazy_guard (bool snd, statement then)
	returns if (LAZY_{SEND,RECV}) then More...
static statement	hpfc_lazy_message (expression tid, expression channel, bool snd)
	IF (LAZY_snd) THEN PVMFsnd() LAZY_snd = false // if receive ENDIF. More...
statement	hpfc_generate_message (entity ld, bool send, bool lazy)
statement	hpfc_initsend (bool lazy)
static entity	hpfc_buffer_entity (entity array, string suffix)
	returns the buffer entity for array More...
expression	hpfc_buffer_reference (entity array, entity index)
	returns a reference to the typed common hpfc_buffer buffer, that suits array basic type and with index as an index. More...
static expression	buffer_full_condition (entity array, bool is_send, bool is_full)
	generates the condition for testing the buffer state: returns (BUFFER_INDEX. More...
statement	hpfc_buffer_packing (entity array, entity(*creation)(), bool pack)
	array(creation) = buffer(current++) or reverse assignment... More...
static entity	hpfc_ith_broadcast_function (int dim, bool special)
	whether to use the special version More...
static statement	hpfc_broadcast_buffers (entity src, entity trg, entity lid, entity proc)
	send the buffer, possibly a broadcast. More...
statement	hpfc_packing_of_current__buffer (entity array, bool pack)
	CALL (pvmtype) HPFC {,UN}PACK. More...
statement	hpfc_broadcast_if_necessary (entity array, entity trg, entity lid, entity proc, bool is_lazy)
	lazy or not... More...
statement	hpfc_lazy_buffer_packing (entity src, entity trg, entity lid, entity proc, entity(*array_dim)(), bool is_send, bool is_lazy)
	lazy in actually sending or not the packed buffer immediatly... More...
statement	hpfc_buffer_initialization (bool is_send, _UNUSED_ bool is_lazy, bool job_was_done)
statement	hpfc_lazy_packing (entity array, entity lid, entity(*creation)(), bool pack, bool lazy)
	the lazy issues. More...
statement	hpfc_compute_lid (entity lid, entity proc, entity(*creation)(), entity array)
	statement st_compute_lid(proc) More...

Function Documentation

buffer_full_condition()

static expression buffer_full_condition ( entity  array, bool  is_send, bool  is_full  )

static

generates the condition for testing the buffer state: returns (BUFFER_INDEX.

[eq|ne].BUFFER_[|RCV]SIZE) depending on swtiches. TRUE: is full, FALSE: is not empty

Parameters

is_send	array for the typed buffer size
is_full	while sending or receiving

Definition at line 281 of file generate-util.c.

{
    entity opera, bsize, index;
 
    index = hpfc_name_to_entity(BUFFER_INDEX);
    opera = is_full ? 
        entity_intrinsic(EQUAL_OPERATOR_NAME) :
        entity_intrinsic(NON_EQUAL_OPERATOR_NAME) ;
    bsize = is_send ? is_full ?
        hpfc_buffer_entity(array, BUFSZ) :
        MakeConstant("0", is_basic_int) :
        hpfc_name_to_entity(BUFFER_RCV_SIZE);
 
    return MakeBinaryCall(opera,
                          entity_to_expression(index),
                          entity_to_expression(bsize));
}

References array, BUFFER_INDEX, BUFFER_RCV_SIZE, BUFSZ, entity_intrinsic(), entity_to_expression(), EQUAL_OPERATOR_NAME, hpfc_buffer_entity(), hpfc_name_to_entity(), is_basic_int, MakeBinaryCall(), MakeConstant(), and NON_EQUAL_OPERATOR_NAME.

Referenced by hpfc_broadcast_if_necessary(), and hpfc_lazy_buffer_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

define_node_processor_id()

statement define_node_processor_id	(	entity	proc,
		entity(*)(int)	creation
	)

builds a statement VAR_i = MYPOS(i, proc_number) // i=1 to proc dimension

generate-util.c

of expression

of statement

Parameters

proc

roc

Definition at line 49 of file generate-util.c.

{
    int i, procn = load_hpf_number(proc);
    list /* of expression */ mypos_indices,
         /* of statement */  ls = NIL;
    reference mypos;
    entity dummy;
 
    for(i=NumberOfDimension(proc); i>0; i--)
    {
        dummy = creation(i);
        mypos_indices = CONS(EXPRESSION, int_to_expression(i),
                        CONS(EXPRESSION, int_to_expression(procn), 
                             NIL));
        mypos = make_reference(hpfc_name_to_entity(MYPOS), mypos_indices);
        ls = CONS(STATEMENT,
                  make_assign_statement(entity_to_expression(dummy),
                                        reference_to_expression(mypos)),
                  ls);
    }
                                       
    return make_block_statement(ls);
}

References CONS, entity_to_expression(), EXPRESSION, hpfc_name_to_entity(), int_to_expression(), load_hpf_number(), make_assign_statement(), make_block_statement(), make_reference(), MYPOS, NIL, NumberOfDimension(), reference_to_expression(), and STATEMENT.

Referenced by GENERATION(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_deducables()

statement generate_deducables

(

list

le

)

statement generate_deducables(list le)

the le list of expression is used to generate the deducables. The fields of interest are the variable which is referenced and the normalized field which is the expression that is going to be used to define the variable.

Parameters

le	of expression

Definition at line 83 of file generate-util.c.

{
    list rev = gen_nreverse(gen_copy_seq(le)), ls = NIL;
 
    MAP(EXPRESSION, e,
    {
        entity var = reference_variable(expression_reference(e));
        Pvecteur v = normalized_linear(expression_normalized(e));
 
        ls = CONS(STATEMENT, Pvecteur_to_assign_statement(var, v), ls);
    },
        rev);
 
    gen_free_list(rev);
    return make_block_statement(ls);
}

References CONS, EXPRESSION, expression_normalized, expression_reference(), gen_copy_seq(), gen_free_list(), gen_nreverse(), make_block_statement(), MAP, NIL, normalized_linear, Pvecteur_to_assign_statement(), reference_variable, and STATEMENT.

Referenced by elements_loop(), generate_io_statements_for_shared_arrays(), and GENERATION().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_add_2()

statement hpfc_add_2

(

expression

exp

)

expr = expr + 2

Parameters

exp

xp

Definition at line 141 of file generate-util.c.

{
    entity plus = entity_intrinsic(PLUS_OPERATOR_NAME);
    return(make_assign_statement
           (copy_expression(exp), 
            MakeBinaryCall(plus, exp, int_to_expression(2))));
 
}

References copy_expression(), entity_intrinsic(), exp, int_to_expression(), make_assign_statement(), MakeBinaryCall(), and PLUS_OPERATOR_NAME.

Referenced by hpfc_message().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_add_n()

statement hpfc_add_n	(	entity	var,
		int	n
	)

returns statement VAR = VAR + N

added value

Parameters

var	ar
n	integer scalar variable

Definition at line 128 of file generate-util.c.

{
    return make_assign_statement
        (entity_to_expression(var),
         MakeBinaryCall(entity_intrinsic(PLUS_OPERATOR_NAME),
                        entity_to_expression(var), int_to_expression(n)));
}

References entity_intrinsic(), entity_to_expression(), int_to_expression(), make_assign_statement(), MakeBinaryCall(), and PLUS_OPERATOR_NAME.

Referenced by hpfc_buffer_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_broadcast_buffers()

static statement hpfc_broadcast_buffers ( entity  src, entity  trg, entity  lid, entity  proc  )

static

send the buffer, possibly a broadcast.

unconditional ? if non empty ? generates hpfc_broadcast_x as required. ??? hardwired for remappings... processor related to the array... (redundant!?)

of expression

??? possible replication on sections overlooked here

an argument needed by the special function

Parameters

trg	source array
lid	should be the target array
proc	broadcast base, maybe partial?!

Definition at line 344 of file generate-util.c.

{
    Pcontrainte c;
    int size, npdim, nreplicated;
    list /* of expression */ args = NIL;
    bool avoid_twins = 
        get_bool_property("HPFC_GUARDED_TWINS") && replicated_p(src);
 
    c = full_linearization(proc, (entity) NULL, &size, 
                           get_ith_temporary_dummy, false, 0);
 
    npdim = NumberOfDimension(proc);
    
    for (nreplicated=0; npdim; npdim--)
    {
        if (processors_dim_replicated_p(proc, trg, npdim))
        {
            /* ??? possible replication on sections overlooked here */
            entity v;
            Value step;
            int number;
            
            nreplicated++;
            v = get_ith_temporary_dummy(npdim);
            step = vect_coeff((Variable) v, contrainte_vecteur(c));
            number = SizeOfIthDimension(proc, npdim);
 
            args = CONS(EXPRESSION, int_to_expression(number),
                   CONS(EXPRESSION, Value_to_expression(step),
                        args));
        }
    }
 
    args = CONS(EXPRESSION, entity_to_expression(lid), args);
 
    /* an argument needed by the special function */
    if (avoid_twins) 
        args = CONS(EXPRESSION, int_to_expression(load_hpf_number(src)), args);
    contraintes_free(c);
 
    return call_to_statement
      (make_call(hpfc_ith_broadcast_function(nreplicated, avoid_twins), args));
}

References call_to_statement, CONS, contrainte_vecteur, contraintes_free(), entity_to_expression(), EXPRESSION, full_linearization(), get_bool_property(), get_ith_temporary_dummy(), hpfc_ith_broadcast_function(), int_to_expression(), load_hpf_number(), make_call(), NIL, NumberOfDimension(), processors_dim_replicated_p(), replicated_p(), SizeOfIthDimension(), src, Value_to_expression(), and vect_coeff().

Referenced by hpfc_broadcast_if_necessary(), and hpfc_lazy_buffer_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_broadcast_if_necessary()

statement hpfc_broadcast_if_necessary	(	entity	array,
		entity	trg,
		entity	lid,
		entity	proc,
		bool	is_lazy
	)

lazy or not...

Parameters

array	rray
trg	remapped source array
lid	remapped target array
proc	lid for target processor(s)
is_lazy	target processor

Definition at line 404 of file generate-util.c.

{
    expression not_empty;
    statement send, pack;
 
    not_empty = buffer_full_condition(array, true, false);
    send = hpfc_broadcast_buffers(array, trg, lid, proc);
    pack = hpfc_packing_of_current__buffer(array, true);
 
    if (is_lazy)
        return test_to_statement
            (make_test(not_empty,
             make_block_statement(CONS(STATEMENT, pack,
                                  CONS(STATEMENT, send, NIL))),
             make_continue_statement(entity_undefined)));
    else
        return make_block_statement
            (CONS(STATEMENT, test_to_statement(make_test(not_empty, pack,
                             make_continue_statement(entity_undefined))),
             CONS(STATEMENT, test_to_statement(make_test(not_expression
                (entity_to_expression(hpfc_name_to_entity(SND_NOT_INIT))),send,
                             make_continue_statement(entity_undefined))),
                  NIL)));
}

References array, buffer_full_condition(), CONS, entity_to_expression(), entity_undefined, hpfc_broadcast_buffers(), hpfc_name_to_entity(), hpfc_packing_of_current__buffer(), make_block_statement(), make_continue_statement(), make_test(), NIL, not_expression, SND_NOT_INIT, STATEMENT, and test_to_statement.

Referenced by gen().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_buffer_entity()

static entity hpfc_buffer_entity ( entity  array, string  suffix  )

static

returns the buffer entity for array

Definition at line 254 of file generate-util.c.

{
    return hpfc_name_to_entity(concatenate
                               (pvm_what_options(entity_basic(array)),
                                suffix, NULL));
}

References array, concatenate(), entity_basic(), hpfc_name_to_entity(), and pvm_what_options().

Referenced by buffer_full_condition(), hpfc_buffer_reference(), hpfc_lazy_buffer_packing(), and hpfc_packing_of_current__buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_buffer_initialization()

statement hpfc_buffer_initialization	(	bool	is_send,
		_UNUSED_ bool	is_lazy,
		bool	job_was_done
	)

of statement

set_expression(hpfc_name_to_entity(BUFFER_ENCODING), pvm_encoding_option(2))

Definition at line 492 of file generate-util.c.

{
    statement buffindex, msgstate, other;
    list /* of statement */ l;
 
    buffindex = set_integer(hpfc_name_to_entity(BUFFER_INDEX), 0);
    msgstate = set_logical(hpfc_name_to_entity
        (is_send ? SND_NOT_INIT : RCV_NOT_PRF), job_was_done);
    if (is_send)
        other = make_continue_statement(entity_undefined);
    /* set_expression(hpfc_name_to_entity(BUFFER_ENCODING),
       pvm_encoding_option(2)) */
    else
        other = set_expression
            (hpfc_name_to_entity(BUFFER_RCV_SIZE), int_to_expression(0)); 
 
    l = CONS(STATEMENT, buffindex,
        CONS(STATEMENT, msgstate, 
        CONS(STATEMENT, other,
             NIL)));
 
    return make_block_statement(l);
}

References BUFFER_INDEX, BUFFER_RCV_SIZE, CONS, entity_undefined, hpfc_name_to_entity(), int_to_expression(), make_block_statement(), make_continue_statement(), NIL, RCV_NOT_PRF, set_expression, set_integer, set_logical, SND_NOT_INIT, and STATEMENT.

Referenced by gen(), generate_io_statements_for_shared_arrays(), hpfc_hmessage(), and hpfc_nrecv().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_buffer_packing()

statement hpfc_buffer_packing	(	entity	array,
		entity(*)()	creation,
		bool	pack
	)

array(creation) = buffer(current++) or reverse assignment...

Definition at line 305 of file generate-util.c.

{
    entity index;
    expression array_ref, buffer_ref;
    statement increment, assignment;
 
    index = hpfc_name_to_entity(BUFFER_INDEX);
    array_ref = make_reference_expression(array, creation);
    buffer_ref = hpfc_buffer_reference(array, index);
    increment = hpfc_add_n(index, 1);
    assignment = make_assign_statement(pack ? buffer_ref : array_ref,
                                       pack ? array_ref : buffer_ref);
    
    return make_block_statement(CONS(STATEMENT, increment,
                                CONS(STATEMENT, assignment,
                                     NIL)));
}

References array, BUFFER_INDEX, CONS, hpfc_add_n(), hpfc_buffer_reference(), hpfc_name_to_entity(), make_assign_statement(), make_block_statement(), make_reference_expression(), NIL, and STATEMENT.

Referenced by generate_io_statements_for_shared_arrays(), hpfc_lazy_buffer_packing(), and hpfc_lazy_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_buffer_reference()

expression hpfc_buffer_reference	(	entity	array,
		entity	index
	)

returns a reference to the typed common hpfc_buffer buffer, that suits array basic type and with index as an index.

index variable

Parameters

array	rray
index	array to select the right typed buffer

Definition at line 267 of file generate-util.c.

{
    return reference_to_expression
        (make_reference(hpfc_buffer_entity(array, BUFFER),
         CONS(EXPRESSION, entity_to_expression(index), 
              NIL)));
}

References array, BUFFER, CONS, entity_to_expression(), EXPRESSION, hpfc_buffer_entity(), make_reference(), NIL, and reference_to_expression().

Referenced by hpfc_buffer_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_compute_lid()

statement hpfc_compute_lid	(	entity	lid,
		entity	proc,
		entity(*)()	creation,
		entity	array
	)

statement st_compute_lid(proc)

  T_LID=CMP_LID(pn, pi...)

if array is not NULL, partial according to array. the offset is shifted as if proc dimensions were normalized, in order to match the runtime library hpfc_broadcast_* expectations. to be used for partial (broadcasts...)

remove distributed dimensions from the constraint and normalize the partial system so that dims are 0:...

Parameters

proc	variable to be assigned to
creation	processor arrangement
array	individual variables

Definition at line 553 of file generate-util.c.

{
    if (!get_bool_property("HPFC_EXPAND_CMPLID"))
    {
        int ndim = NumberOfDimension(proc);
        entity cmp_lid = hpfc_name_to_entity(CMP_LID);
 
        pips_assert("implemented", !array);
        
        return make_assign_statement(entity_to_expression(lid),
          make_call_expression
            (cmp_lid, CONS(EXPRESSION,int_to_expression(load_hpf_number(proc)),
                           gen_nconc(hpfc_gen_n_vars_expr(creation, ndim),
                                     make_list_of_constant(0, 7-ndim)))));
    }
    else
    {
        int size;
        Pcontrainte c;
        Pvecteur v;
        statement result;
 
        c = full_linearization(proc, lid, &size, creation, false, 1);
        v = contrainte_vecteur(c);
 
        if (array)
        {
            /* remove distributed dimensions from the constraint
             * and normalize the partial system so that dims are 0:...
             */
            int npdim;
            pips_assert("defined", array && !entity_undefined_p(array));
            
            for(npdim = NumberOfDimension(proc); npdim; npdim--)
                if (processors_dim_replicated_p(proc, array, npdim))
                {
                    Variable var = (Variable) creation(npdim);
                    int low, up;
                    Value cf, vlow;
 
                    get_entity_dimensions(proc, npdim, &low, &up);
                    cf = vect_coeff(var, v);
                    vlow = int_to_value(low);
                    vect_add_elem(&contrainte_vecteur(c), var, 
                                  value_uminus(cf));
                    vect_add_elem(&contrainte_vecteur(c), TCST, 
                                  value_mult(cf,vlow));
                }
        }
 
        result = Pvecteur_to_assign_statement(lid, contrainte_vecteur(c));
        contraintes_free(c);
        
        return result;
    }
}

References array, CMP_LID, CONS, contrainte_vecteur, contraintes_free(), entity_to_expression(), entity_undefined_p, EXPRESSION, full_linearization(), gen_nconc(), get_bool_property(), get_entity_dimensions(), hpfc_gen_n_vars_expr(), hpfc_name_to_entity(), int_to_expression(), int_to_value, load_hpf_number(), make_assign_statement(), make_call_expression(), make_list_of_constant(), NumberOfDimension(), pips_assert, processors_dim_replicated_p(), Pvecteur_to_assign_statement(), TCST, value_mult, value_uminus, vect_add_elem(), and vect_coeff().

Referenced by broadcast(), hpfc_hmessage(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_gen_n_vars_expr()

list hpfc_gen_n_vars_expr	(	entity(*)()	creation,
		int	number
	)

of expression

Definition at line 102 of file generate-util.c.

{
    list result = NIL;
    pips_assert("valid dimension number", number>=0 && number<=7);
 
    for(; number>0; number--)
        result = CONS(EXPRESSION, entity_to_expression(creation(number)),
                      result);
 
    return result;
}

References CONS, entity_to_expression(), EXPRESSION, NIL, and pips_assert.

Referenced by hpfc_compute_lid(), and make_reference_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_generate_message()

statement hpfc_generate_message	(	entity	ld,
		bool	send,
		bool	lazy
	)

Parameters

ld	d
send	end
lazy	azy

Definition at line 208 of file generate-util.c.

{
    entity nc, nt;
    expression lid, tid, chn;
 
    nc = hpfc_name_to_entity(send ? SEND_CHANNELS : RECV_CHANNELS);
    nt = hpfc_name_to_entity(NODETIDS);
    lid = entity_to_expression(ld);
    tid = reference_to_expression
        (make_reference(nt, CONS(EXPRESSION, lid, NIL)));
    chn = reference_to_expression
        (make_reference(nc, CONS(EXPRESSION, copy_expression(lid), NIL)));
 
    return lazy ? hpfc_lazy_message(tid, chn, send) : 
                  hpfc_message(tid, chn, send);
}

References CONS, copy_expression(), entity_to_expression(), EXPRESSION, hpfc_lazy_message(), hpfc_message(), hpfc_name_to_entity(), make_reference(), NIL, NODETIDS, RECV_CHANNELS, reference_to_expression(), and SEND_CHANNELS.

Referenced by broadcast(), gen(), and hpfc_lazy_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_initsend()

statement hpfc_initsend

(

bool

lazy

)

2 args to pvmfinitsend

Parameters

lazy

azy

Definition at line 229 of file generate-util.c.

{
    statement init;
 
    /* 2 args to pvmfinitsend
     */
    init = hpfc_make_call_statement
             (hpfc_name_to_entity(PVM_INITSEND), 
              CONS(EXPRESSION, pvm_encoding_option(1),
              CONS(EXPRESSION, entity_to_expression(hpfc_name_to_entity(BUFID)),
                   NIL)));
 
    return lazy ? make_block_statement
        (CONS(STATEMENT, init,
         CONS(STATEMENT, set_logical(hpfc_name_to_entity(LAZY_SEND), false),
              NIL))) :
                  init ;
}

References BUFID, CONS, entity_to_expression(), EXPRESSION, hpfc_make_call_statement(), hpfc_name_to_entity(), init, LAZY_SEND, make_block_statement(), NIL, pvm_encoding_option(), PVM_INITSEND, set_logical, and STATEMENT.

Referenced by gen().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_ith_broadcast_function()

static entity hpfc_ith_broadcast_function ( int  dim, bool  special  )

static

whether to use the special version

??? static buffer size

Parameters

special

number of dimensions of the broadcast

Definition at line 327 of file generate-util.c.

{
    char *buffer; /* ??? static buffer size */
    asprintf(&buffer, "%s%d", special? GUARDED_BRD: BROADCAST, dim);
    entity e= MakeRunTimeSupportSubroutine(buffer, 2*dim+1);
    free(buffer);
    return e;
}

References asprintf, BROADCAST, buffer, free(), GUARDED_BRD, and MakeRunTimeSupportSubroutine().

Referenced by hpfc_broadcast_buffers().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_lazy_buffer_packing()

statement hpfc_lazy_buffer_packing	(	entity	src,
		entity	trg,
		entity	lid,
		entity	proc,
		entity(*)()	array_dim,
		bool	is_send,
		bool	is_lazy
	)

lazy in actually sending or not the packed buffer immediatly...

means you send the buffer directly, without packing...

of statement

array being manipulated

CALL HPFC PACK/UNPACK

BUF INDEX=0

Parameters

trg	source array
lid	target array
proc	local id for base target
array_dim	the processors, needed for broadcasts
is_send	variables for array dimensions
is_lazy	send or receive ?

Definition at line 437 of file generate-util.c.

{
    statement packing, realpack, indexeq0, ifcond, optional;
    expression condition;
    list /* of statement */ l;
    entity array; /* array being manipulated */
 
    array = is_send ? src : trg;
    packing = hpfc_buffer_packing(array, array_dim, is_send);
    condition = buffer_full_condition(array, is_send, true);
 
    /* CALL HPFC PACK/UNPACK
     */
    realpack = call_to_statement
        (make_call(hpfc_buffer_entity(array, is_send ? BUFPCK : BUFUPK), 
           is_send ? NIL : CONS(EXPRESSION, entity_to_expression(lid), NIL)));
 
    /* BUF INDEX=0
     */
    indexeq0 = set_integer(hpfc_name_to_entity(BUFFER_INDEX), 0);
    optional = is_lazy ? 
        is_send ? hpfc_broadcast_buffers(array, trg, lid, proc) :
                  set_logical(hpfc_name_to_entity(RCV_NOT_PRF), true) :
        make_continue_statement(entity_undefined);
                           
    if (is_send)
        l = CONS(STATEMENT, realpack,
            CONS(STATEMENT, optional,
            CONS(STATEMENT, indexeq0,
                 is_lazy? 
                 CONS(STATEMENT, set_logical(hpfc_name_to_entity(SND_NOT_INIT),
                                             true), NIL): NIL)));
    else
        l = CONS(STATEMENT, optional,
            CONS(STATEMENT, realpack,
            CONS(STATEMENT, indexeq0, NIL)));
    
    ifcond = test_to_statement
        (make_test(condition, 
                   make_block_statement(l),
                   make_continue_statement(entity_undefined)));
 
    return make_block_statement
        (is_send ? CONS(STATEMENT, packing, CONS(STATEMENT, ifcond, NIL)) :
                   CONS(STATEMENT, ifcond, CONS(STATEMENT, packing, NIL)));
}

References array, buffer_full_condition(), BUFFER_INDEX, BUFPCK, BUFUPK, call_to_statement, CONS, entity_to_expression(), entity_undefined, EXPRESSION, hpfc_broadcast_buffers(), hpfc_buffer_entity(), hpfc_buffer_packing(), hpfc_name_to_entity(), make_block_statement(), make_call(), make_continue_statement(), make_test(), NIL, RCV_NOT_PRF, set_integer, set_logical, SND_NOT_INIT, src, STATEMENT, and test_to_statement.

Referenced by gen().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_lazy_guard()

statement hpfc_lazy_guard	(	bool	snd,
		statement	then
	)

returns if (LAZY_{SEND,RECV}) then

Parameters

snd	nd
then	hen

Definition at line 176 of file generate-util.c.

{
    entity decision = hpfc_name_to_entity(snd ? LAZY_SEND : LAZY_RECV);
    return test_to_statement
     (make_test(entity_to_expression(decision), then, make_empty_statement()));
}

References entity_to_expression(), hpfc_name_to_entity(), LAZY_RECV, LAZY_SEND, make_empty_statement, make_test(), and test_to_statement.

Referenced by broadcast(), and hpfc_lazy_message().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_lazy_message()

static statement hpfc_lazy_message ( expression  tid, expression  channel, bool  snd  )

static

IF (LAZY_snd) THEN PVMFsnd() LAZY_snd = false // if receive ENDIF.

Definition at line 191 of file generate-util.c.

{
    entity decision = hpfc_name_to_entity(snd ? LAZY_SEND : LAZY_RECV);
    statement 
        comm = hpfc_message(tid, channel, snd),
        then = snd ? comm : 
            make_block_statement(CONS(STATEMENT, comm,
                                 CONS(STATEMENT, set_logical(decision, false),
                                      NIL))) ;
    
    return hpfc_lazy_guard(snd, then);
}

References CONS, hpfc_lazy_guard(), hpfc_message(), hpfc_name_to_entity(), LAZY_RECV, LAZY_SEND, make_block_statement(), NIL, set_logical, and STATEMENT.

Referenced by hpfc_generate_message().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_lazy_packing()

statement hpfc_lazy_packing	(	entity	array,
		entity	lid,
		entity(*)()	creation,
		bool	pack,
		bool	lazy
	)

the lazy issues.

note that target processors should be known to generate the appropriate broadcast?

Definition at line 524 of file generate-util.c.

{
    statement pack_stmt = hpfc_buffer_packing(array, creation, pack);
 
    return lazy ? (pack ? make_block_statement
       (CONS(STATEMENT, pack_stmt,
        CONS(STATEMENT, set_logical(hpfc_name_to_entity(LAZY_SEND), true),
             NIL))) :
                   make_block_statement
       (CONS(STATEMENT, hpfc_generate_message(lid, false, true),
        CONS(STATEMENT, pack_stmt,
             NIL)))) : pack_stmt ;
}

References array, CONS, hpfc_buffer_packing(), hpfc_generate_message(), hpfc_name_to_entity(), LAZY_SEND, make_block_statement(), NIL, set_logical, and STATEMENT.

Referenced by gen().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_message()

statement hpfc_message	(	expression	tid,
		expression	channel,
		bool	send
	)

Parameters

tid	id
channel	hannel
send	end

Definition at line 152 of file generate-util.c.

{
    expression third;
    entity pvmf;
 
    third = entity_to_expression(hpfc_name_to_entity(send ? INFO : BUFID));
    pvmf = hpfc_name_to_entity(send ? PVM_SEND : PVM_RECV);
 
    return make_block_statement
           (CONS(STATEMENT, hpfc_make_call_statement(pvmf,
                                   CONS(EXPRESSION, tid,
                                   CONS(EXPRESSION, channel,
                                   CONS(EXPRESSION, third,
                                        NIL)))),
            CONS(STATEMENT, hpfc_add_2(copy_expression(channel)),
                 NIL)));
}

References BUFID, CONS, copy_expression(), entity_to_expression(), EXPRESSION, hpfc_add_2(), hpfc_make_call_statement(), hpfc_name_to_entity(), INFO, make_block_statement(), NIL, PVM_RECV, PVM_SEND, and STATEMENT.

Referenced by hpfc_generate_message(), and hpfc_lazy_message().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_packing_of_current__buffer()

statement hpfc_packing_of_current__buffer	(	entity	array,
		bool	pack
	)

CALL (pvmtype) HPFC {,UN}PACK.

Parameters

array	rray
pack	ack

Definition at line 395 of file generate-util.c.

{
    return hpfc_make_call_statement
        (hpfc_buffer_entity(array, pack? BUFPCK: BUFUPK), NIL);
}

References array, BUFPCK, BUFUPK, hpfc_buffer_entity(), hpfc_make_call_statement(), and NIL.

Referenced by hpfc_broadcast_if_necessary(), hpfc_hcast(), hpfc_hmessage(), hpfc_nrecv(), and hpfc_nsend().

Here is the call graph for this function:

Here is the caller graph for this function:

make_reference_expression()

expression make_reference_expression	(	entity	e,
		entity(*)()	creation
	)

Definition at line 117 of file generate-util.c.

{
    return reference_to_expression(make_reference(e,
           hpfc_gen_n_vars_expr(creation, NumberOfDimension(e))));
}

References hpfc_gen_n_vars_expr(), make_reference(), NumberOfDimension(), and reference_to_expression().

Referenced by gen(), and hpfc_buffer_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

pvm_encoding_option()

static expression pvm_encoding_option ( int  n )

static

HPFC module by Fabien COELHO.

Definition at line 33 of file generate-util.c.

{
    static const string option[] = 
    {
        "PvmDataDefault",
        "PvmDataRaw",
        "PvmDataInPlace"
    };
 
    return MakeCharacterConstantExpression(option[n]);
}

References MakeCharacterConstantExpression().

Referenced by hpfc_initsend().

Here is the call graph for this function:

Here is the caller graph for this function: