remapping.c File Reference

#include "defines-local.h"
#include "prettyprint.h"
#include "conversion.h"
#include "resources.h"
#include "pipsdbm.h"

Include dependency graph for remapping.c:

Go to the source code of this file.

Macros
#define	CPY   0
	in the following functions tag t controls the code generation, depending of what is to be generated (send, receive, copy, broadcast)... More...
#define	SND   1
#define	RCV   2
#define	BRD   3
#define	PRE   0
#define	INL   4
#define	PST   8
#define	NLZ   0
#define	LZY   16
#define	NBF   0
#define	BUF   32
#define	ret(name)   result = name; break
	I have to deal with a 4D space to generate some code: More...

Functions
static Pcontrainte	partial_linearization (entity array, bool distributed, entity var, int *psize, entity(*create_var)(int))
	HPFC module by Fabien COELHO. More...
Pcontrainte	full_linearization (entity obj, entity var, int *psize, entity(*create_var)(int), bool fortran_way, int initial_offset)
	builds a linarization equation of the dimensions of obj. More...
static Psysteme	generate_work_sharing_system (entity src, entity trg)
	load-balancing equation as suggested in the A-274 report. More...
static Psysteme	generate_remapping_system (entity src, entity trg)
	returns the full remapping system, including the source and target mappings systems, the link and the work sharing system More...
static void	remapping_variables (Psysteme s, entity a1, entity a2, list *pl, list *plp, list *pll, list *plrm, list *pld, list *plo)
	??? assumes that there are no parameters. More...
static statement	processor_loop (Psysteme s, _UNUSED_ list l_psi, list l_oth, entity psi, entity oth, entity lid, entity array, entity(*create_psi)(), entity(*create_oth)(), statement body, bool sh)
	to be generated: ??? the Proc cycle should be deduce directly in some case... More...
static statement	elements_loop (Psysteme s, list ll, list ld, statement body)
	to be generated: More...
static expression	mylid_ne_lid (entity lid)
static statement	if_different_pe_and_not_twin (entity src, entity lid, statement strue, statement sfalse)
	to be generated: IF (MYLID.NE.LID[.AND.NOT.HPFC_TWIN_P(an, LID)]) THEN true ELSE false ENDIF More...
static statement	broadcast (entity src, entity lid, entity proc, Psysteme sr, list ldiff, bool lazy)
	builds the diffusion loop. More...
static statement	gen (int what, entity src, entity trg, entity lid, entity proc, entity(*create_src)(), entity(*create_trg)(), Psysteme sr, list ldiff)
	arguments: all that may be useful to generate some code More...
static statement	remapping_stats (int t, Psysteme s, Psysteme sr, list ll, list ldiff, list ld, entity lid, entity src, entity trg)
	generates a remapping loop nest (copy/send/receive/broadcast) basically a loop on elements with pre/in/post statements... More...
static statement	generate_remapping_code (entity src, entity trg, Psysteme procs, Psysteme locals, list l, list lp, list ll, list ldiff, list ld, bool dist_p)
	generates a full remapping code, given the systems and indexes to be used in the different loops. More...
static expression	live_mapping_expression (int index)
	returns LIVEMAPPING(index) More...
static statement	set_array_status_to_target (entity trg)
static statement	set_live_status (entity trg, _UNUSED_ bool val)
static statement	update_runtime_for_remapping (entity trg)
static statement	generate_remapping_guard (entity src, entity trg, statement the_code)
	Runtime descriptors management around the remapping code. More...
static statement	generate_all_liveness_but (entity primary, bool val, entity butthisone)
statement	generate_all_liveness (entity primary, bool val)
static statement	generate_dynamic_liveness_for_primary (entity primary, list tokeep)
static statement	generate_dynamic_liveness_management (statement s)
static statement	hpf_remapping (entity src, entity trg)
	remaps src to trg. More...
static string	remapping_file_name (renaming remap)
	file name for storing the remapping code. More...
static void	loop_rwt (loop l)
static void	reference_rwt (reference r)
static list	list_of_referenced_entities (statement s)
static text	protected_text_statement (statement s)
static void	generate_hpf_remapping_file (renaming r)
static statement	generate_remapping_include (renaming r)
	just a hack because pips does not have 'include' More...
statement	root_statement_remapping_inits (statement root)
	returns the initialization statement: must initialize the status and liveness of arrays More...
void	remapping_compile (statement s, statement *hsp, statement *nsp)
	void remapping_compile(s, hsp, nsp) statement s, *hsp, *nsp; More...

Variables
static list	l_found
	quick recursion to find the entities referenced in a statement. More...

Macro Definition Documentation

BRD

#define BRD   3

Definition at line 473 of file remapping.c.

BUF

#define BUF   32

Definition at line 483 of file remapping.c.

CPY

#define CPY   0

in the following functions tag t controls the code generation, depending of what is to be generated (send, receive, copy, broadcast)...

tag t may have the following values:

Definition at line 470 of file remapping.c.

INL

#define INL   4

Definition at line 476 of file remapping.c.

LZY

#define LZY   16

Definition at line 480 of file remapping.c.

NBF

#define NBF   0

Definition at line 482 of file remapping.c.

NLZ

#define NLZ   0

Definition at line 479 of file remapping.c.

PRE

#define PRE   0

Definition at line 475 of file remapping.c.

PST

#define PST   8

Definition at line 477 of file remapping.c.

RCV

#define RCV   2

Definition at line 472 of file remapping.c.

ret

#define ret

(

name

)

result = name; break

I have to deal with a 4D space to generate some code:

buffer/nobuf lazy/nolazy

pre/in/post cpy/snd/rcv/brd

Definition at line 494 of file remapping.c.

SND

#define SND   1

Definition at line 471 of file remapping.c.

Function Documentation

broadcast()

static statement broadcast ( entity  src, entity  lid, entity  proc, Psysteme  sr, list  ldiff, bool  lazy  )

static

builds the diffusion loop.

[ IF (LAZY_SEND) THEN ] DO ldiff in sr LID computation(...) IF (MYLID.NE.LID) send to LID ENDDO [ ENDIF ] whether to send empty messages

Parameters

lid	source array
proc	variable to store the target local id
sr	target processors for the broadcast
ldiff	broadcast polyhedron of entity
lazy	dimension variables for the broadcast

Definition at line 442 of file remapping.c.

{
    statement cmp_lid, body, nest;
 
    cmp_lid = hpfc_compute_lid(lid, proc, (entity(*)())get_ith_processor_prime, NULL);
    body = make_block_statement
        (CONS(STATEMENT, cmp_lid,
         CONS(STATEMENT, if_different_pe_and_not_twin
              (src, lid, hpfc_generate_message(lid, true, false),
               make_empty_statement()),
              NIL)));
 
    nest = systeme_to_loop_nest(sr, ldiff, body, hpfc_name_to_entity(IDIVIDE));
 
    return lazy ? hpfc_lazy_guard(true, nest) : nest ;
}

References CONS, get_ith_processor_prime(), hpfc_compute_lid(), hpfc_generate_message(), hpfc_lazy_guard(), hpfc_name_to_entity(), IDIVIDE, if_different_pe_and_not_twin(), make_block_statement(), make_empty_statement, NIL, src, STATEMENT, and systeme_to_loop_nest().

Referenced by gen().

Here is the call graph for this function:

Here is the caller graph for this function:

elements_loop()

static statement elements_loop ( Psysteme  s, list  ll, list  ld, statement  body  )

static

to be generated:

DO ll's in S(ll)[...] DEDUCABLES(ld) body ENDDO loop body

Parameters

ll	triangular bounds on ll of entities
ld	loop indexes of expressions
body	deduced scalars

Definition at line 381 of file remapping.c.

{
    return systeme_to_loop_nest(s, ll,
           make_block_statement(CONS(STATEMENT, generate_deducables(ld),
                                CONS(STATEMENT, body,
                                     NIL))), 
                                hpfc_name_to_entity(IDIVIDE));
}

References CONS, generate_deducables(), hpfc_name_to_entity(), IDIVIDE, make_block_statement(), NIL, STATEMENT, and systeme_to_loop_nest().

Referenced by remapping_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

full_linearization()

Pcontrainte full_linearization	(	entity	obj,
		entity	var,
		int *	psize,
		entity(*)(int)	create_var,
		bool	fortran_way,
		int	initial_offset
	)

builds a linarization equation of the dimensions of obj.

remapping.c

var is set to the result. *psize returns the size of obj. Done the Fortran way, or the other way around... initial offset if desired

Parameters

obj	bj
var	array being lin.
psize	assigned variable if desired
create_var	returned array extent
fortran_way	dimension variable builder
initial_offset	Fortran/C linearization way

Definition at line 80 of file remapping.c.

{
    int dim = NumberOfDimension(obj), low, up, size, i;
    Pvecteur v = VECTEUR_NUL;
 
    for(*psize=1, i=fortran_way ? dim : 1 ;
        fortran_way ? i>0 : i<=dim; 
        i+= fortran_way ? -1 : 1)
    {
        get_entity_dimensions(obj, i, &low, &up);
        size = up - low + 1;
        *psize *= size;
        v = vect_multiply(v, int_to_value(size));
        vect_add_elem(&v, (Variable) create_var(i), VALUE_ONE);
        vect_add_elem(&v, TCST, int_to_value(-low));
    }
 
    if (var) vect_add_elem(&v, (Variable) var, VALUE_MONE);
    if (initial_offset) 
        vect_add_elem(&v, TCST, 
                      int_to_value(initial_offset));
 
    return contrainte_make(v);
}

References contrainte_make(), get_entity_dimensions(), int_to_value, NumberOfDimension(), TCST, VALUE_MONE, VALUE_ONE, vect_add_elem(), vect_multiply(), and VECTEUR_NUL.

Referenced by hpfc_broadcast_buffers(), and hpfc_compute_lid().

Here is the call graph for this function:

Here is the caller graph for this function:

gen()

static statement gen ( int  what, entity  src, entity  trg, entity  lid, entity  proc, entity(*)()  create_src, entity(*)()  create_trg, Psysteme  sr, list  ldiff  )

static

arguments: all that may be useful to generate some code

cpy pre/post rcv post nbuf

snd.brd pre nbuf

cpy inl

snd/brd inl nbf

send!

receive!

snd/rcv pre buf

send!

receive!

default is a forgotten case, I guess

to avoid a gcc warning

Parameters

ldiff

of entity

Definition at line 498 of file remapping.c.

{
    statement result;
    bool is_lazy = what & LZY, 
         is_buff = what & BUF;
 
    switch (what)
    {
        /* cpy pre/post
         * rcv post nbuf
         */
    case CPY+PRE: 
    case CPY+PST:
    case CPY+PRE+LZY: 
    case CPY+PST+LZY:
    case CPY+PRE+BUF:
    case CPY+PST+BUF:
    case CPY+PRE+LZY+BUF: 
    case CPY+PST+LZY+BUF:
    case RCV+PST: 
    case RCV+PST+LZY:
    case RCV+PST+BUF:
    case RCV+PST+LZY+BUF:
        ret(make_empty_statement());
 
        /* snd.brd pre nbuf
         */
    case SND+PRE: 
    case BRD+PRE:
    case SND+PRE+LZY: 
    case BRD+PRE+LZY: 
        ret(hpfc_initsend(is_lazy));
 
    case RCV+PRE+LZY:
        ret(set_logical(hpfc_name_to_entity(LAZY_RECV), true));
 
    case RCV+PRE:
        ret(hpfc_generate_message(lid, false, false));
 
        /* cpy inl 
         */
    case CPY+INL: 
    case CPY+INL+LZY:
    case CPY+INL+BUF:
    case CPY+INL+LZY+BUF:
        ret(make_assign_statement(make_reference_expression(trg, create_trg),
                                  make_reference_expression(src, create_src)));
 
        /* snd/brd inl nbf
         */
    case SND+INL:
    case BRD+INL:
    case SND+INL+LZY:
    case BRD+INL+LZY:
        ret(hpfc_lazy_packing(src, lid, create_src, true, is_lazy));
 
    case SND+INL+BUF:
    case SND+INL+LZY+BUF:
    case BRD+INL+BUF:
    case BRD+INL+LZY+BUF:
        ret(hpfc_lazy_buffer_packing(src, trg, lid, proc, create_src,
                                     true /* send! */, is_lazy));
    case RCV+INL+BUF:
    case RCV+INL+LZY+BUF:
        ret(hpfc_lazy_buffer_packing(src, trg, lid, proc, create_trg,
                                     false /* receive! */, is_lazy));
    case RCV+INL:
    case RCV+INL+LZY:
        ret(hpfc_lazy_packing(trg, lid, create_trg, false, is_lazy));
 
    case SND+PST:
    case SND+PST+LZY:
        ret(hpfc_generate_message(lid, true, is_lazy));
 
    case BRD+PST:
    case BRD+PST+LZY:
        ret(broadcast(src, lid, proc, sr, ldiff, is_lazy));
 
    case SND+PST+BUF:
    case SND+PST+LZY+BUF:
    case BRD+PST+BUF:
    case BRD+PST+LZY+BUF:
        ret(hpfc_broadcast_if_necessary(src, trg, lid, proc, is_lazy));
 
        /* snd/rcv pre buf
         */
    case SND+PRE+BUF:
    case SND+PRE+LZY+BUF:
    case BRD+PRE+BUF:
    case BRD+PRE+LZY+BUF:
        ret(hpfc_buffer_initialization(true /* send! */, is_lazy, true));
    case RCV+PRE+BUF:
    case RCV+PRE+LZY+BUF:
        ret(hpfc_buffer_initialization(false /* receive! */, is_lazy, true));
        
        /* default is a forgotten case, I guess
         */
    default:
        pips_internal_error("invalid tag %d", what);
        ret(statement_undefined); /* to avoid a gcc warning */
    }
 
    pips_debug(7, "tag is %d (%s, %s)\n", what, 
               is_lazy ? "lazy" : "not lazy",
               is_buff ? "bufferized" : "not bufferized");
    DEBUG_STAT(7, "returning", result);
 
    return result;
}

References BRD, broadcast(), BUF, CPY, DEBUG_STAT, hpfc_broadcast_if_necessary(), hpfc_buffer_initialization(), hpfc_generate_message(), hpfc_initsend(), hpfc_lazy_buffer_packing(), hpfc_lazy_packing(), hpfc_name_to_entity(), INL, LAZY_RECV, LZY, make_assign_statement(), make_empty_statement, make_reference_expression(), pips_debug, pips_internal_error, PRE, PST, RCV, ret, set_logical, SND, src, and statement_undefined.

Referenced by compute_points_to_gen_set(), genref_any_loop(), genref_one_statement(), kill_effects(), list_assignment_to_points_to(), points_to_anywhere(), points_to_anywhere_typed(), points_to_nowhere(), and remapping_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_all_liveness()

statement generate_all_liveness	(	entity	primary,
		bool	val
	)

Parameters

primary	rimary
val	al

Definition at line 940 of file remapping.c.

{
    return generate_all_liveness_but(primary, val, entity_undefined);
}

References entity_undefined, and generate_all_liveness_but().

Referenced by hpf_compile_call(), and root_statement_remapping_inits().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_all_liveness_but()

static statement generate_all_liveness_but ( entity  primary, bool  val, entity  butthisone  )

static

of statement

LIVEMAPPING(array) = val (.TRUE. or .FALSE.)

commented result

Definition at line 906 of file remapping.c.

{
    statement result;
    list /* of statement */ ls = NIL;
 
    MAP(ENTITY, array,
    {
        /* LIVEMAPPING(array) = val (.TRUE. or .FALSE.)
         */
        if (array != butthisone)
            ls = CONS(STATEMENT, 
                      make_assign_statement
                      (live_mapping_expression(load_hpf_number(array)),
                       bool_to_expression(val)), ls);
    },
        entities_list(load_dynamic_hpf(primary)));
 
    /* commented result
     */
    result = make_block_statement(ls);
    {
        string comment =
            strdup(concatenate("! all livenesss for ", 
                               entity_local_name(primary), "\n", NULL));
        insert_comments_to_statement(result, comment);
        free(comment);
    }
    return result;
}

References array, bool_to_expression(), comment(), concatenate(), CONS, entities_list, ENTITY, entity_local_name(), free(), insert_comments_to_statement(), live_mapping_expression(), load_dynamic_hpf(), load_hpf_number(), make_assign_statement(), make_block_statement(), MAP, NIL, STATEMENT, and strdup().

Referenced by generate_all_liveness().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_dynamic_liveness_for_primary()

static statement generate_dynamic_liveness_for_primary ( entity  primary, list  tokeep  )

static

of statement

clean not maybeuseful instances of the primary

LIVEMAPPING(array) = .FALSE.

commented result

Parameters

tokeep

of entity

Definition at line 948 of file remapping.c.

{
    statement result;
    list /* of statement */ ls = NIL;
 
    /* clean not maybeuseful instances of the primary
     */
    MAP(ENTITY, array,
    {
        if (!gen_in_list_p(array, tokeep))
        {
            /* LIVEMAPPING(array) = .FALSE.
             */
            ls = CONS(STATEMENT, 
              make_assign_statement
                  (live_mapping_expression(load_hpf_number(array)),
                   bool_to_expression(false)), ls);
        }           
    },
        entities_list(load_dynamic_hpf(primary)));
 
    /* commented result
     */
    result = make_block_statement(ls);
    if (ls) {
        string comment =
            strdup(concatenate("! clean live set for ", 
                               entity_local_name(primary), "\n", NULL));
        insert_comments_to_statement(result, comment);
        free(comment);
    }
    return result;
}

References array, bool_to_expression(), comment(), concatenate(), CONS, entities_list, ENTITY, entity_local_name(), free(), gen_in_list_p(), insert_comments_to_statement(), live_mapping_expression(), load_dynamic_hpf(), load_hpf_number(), make_assign_statement(), make_block_statement(), MAP, NIL, STATEMENT, and strdup().

Referenced by generate_dynamic_liveness_management().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_dynamic_liveness_management()

static statement generate_dynamic_liveness_management ( statement  s )

static

of entity

of statement

for each primary remapped at s, generate the management code.

commented result

Definition at line 985 of file remapping.c.

{
    statement result;
    list /* of entity */ already_seen = NIL,
                         tokeep = entities_list(load_maybeuseful_mappings(s)),
         /* of statement */ ls;
    
    result = make_empty_statement();
    {
        string comment =
            strdup(concatenate("! end of liveness management\n", NULL));
        insert_comments_to_statement(result, comment);
        free(comment);
    }
    ls = CONS(STATEMENT, result, NIL);
 
    /* for each primary remapped at s, generate the management code.
     */
    MAP(ENTITY, array,
    {
        entity primary = load_primary_entity(array);
 
        if (!gen_in_list_p(primary, already_seen))
        {
            ls = CONS(STATEMENT, 
                      generate_dynamic_liveness_for_primary(primary, tokeep),
                      ls);
            already_seen = CONS(ENTITY, primary, already_seen);
        }
    },
        tokeep);
 
    /* commented result 
     */
    result = make_block_statement(ls);
    {
        string comment =
            strdup(concatenate("! liveness management\n", NULL));
        insert_comments_to_statement(result, comment);
        free(comment);
    }
    return result;
}

References array, comment(), concatenate(), CONS, entities_list, ENTITY, free(), gen_in_list_p(), generate_dynamic_liveness_for_primary(), insert_comments_to_statement(), load_maybeuseful_mappings(), load_primary_entity(), make_block_statement(), make_empty_statement, MAP, NIL, STATEMENT, and strdup().

Referenced by remapping_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_hpf_remapping_file()

static void generate_hpf_remapping_file ( renaming  r )

static

of entity

generates the remapping code and text !!! generated between similar arrays...

stores the remapping as computed

put it in a file

Definition at line 1200 of file remapping.c.

{
    string file_name, dir;
    FILE * f;
    statement remap;
    text t;
    list /* of entity */ l;
    entity src = renaming_old(r), trg = renaming_new(r);
 
    pips_debug(1, "%s -> %s\n",
               entity_name(src), entity_name(trg));
 
    /* generates the remapping code and text
     * !!! generated between similar arrays...
     */
    remap = hpf_remapping(load_similar_mapping(src),
                          load_similar_mapping(trg));
    update_object_for_module(remap, node_module);
    t = protected_text_statement(remap);
 
    /* stores the remapping as computed
     */
    l = list_of_referenced_entities(remap);
    add_remapping_as_computed(r, l);
 
    /* put it in a file
     */
    dir = db_get_directory_name_for_module(WORKSPACE_SRC_SPACE);
    string rfn = remapping_file_name(r);
    asprintf(&file_name,"%s/%s",dir,rfn);
    free(rfn);
    free(dir);
 
    f = hpfc_fopen(file_name);
    print_text(f, t);
    hpfc_fclose(f, file_name);
 
    free_text(t);
    free(file_name);
    free_statement(remap);
    gen_free_list(l);
}

References add_remapping_as_computed(), asprintf, db_get_directory_name_for_module(), entity_name, f(), file_name, free(), free_statement(), free_text(), gen_free_list(), hpf_remapping(), hpfc_fclose(), hpfc_fopen(), list_of_referenced_entities(), load_similar_mapping(), node_module, pips_debug, print_text(), protected_text_statement(), remapping_file_name(), renaming_new, renaming_old, src, update_object_for_module(), and WORKSPACE_SRC_SPACE.

Referenced by remapping_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_remapping_code()

static statement generate_remapping_code ( entity  src, entity  trg, Psysteme  procs, Psysteme  locals, list  l, list  lp, list  ll, list  ldiff, list  ld, bool  dist_p  )

static

generates a full remapping code, given the systems and indexes to be used in the different loops.

that is complementary send/broadcast and receive/copy. The distribution of target onto source processors may require special care if lambda.

output: AS a source DO target DO element PACK SEND/BROADCAST to target(s) AS a target DO source DO element RECEIVE/UNPACK OR DO element COPY true if must take care of lambda

the send is different for diffusions

distributed

replicated

polyhedron separation to extract the diffusions.

??? to be deduced

some comments to help understand the generated code

Parameters

trg	source array
procs	target array
locals	communicating processors polyhedron
l	elements polyhedron of entity
lp	source processor indexes
ll	target processor indexes
ldiff	element indexes
ld	broadcast target processor indexes of expression
dist_p	deducable elements

Definition at line 679 of file remapping.c.

{
    entity lid = hpfc_name_to_entity(T_LID),
           p_src = array_to_processors(src),
           p_trg = array_to_processors(trg),
           lambda = get_ith_temporary_dummy(3),
           primary = load_primary_entity(src);
    statement copy, recv, send, receive, cont, result;
    bool is_buffer = get_bool_property(USE_BUFFERS);
 
    pips_debug(3, "%s taking care of processor cyclic distribution\n", 
               dist_p ? "actually" : "not");
 
    copy = remapping_stats(CPY, locals, SC_EMPTY, ll, NIL, ld, lid, src, trg);
    recv = remapping_stats(RCV, locals, SC_EMPTY, ll, NIL, ld, lid, src, trg);
 
    if (dist_p) lp = CONS(ENTITY, lambda, lp);
 
    /* the send is different for diffusions
     */
    if (ENDP(ldiff))
    {
        statement rp_send;
 
        rp_send =
            remapping_stats(SND, locals, SC_EMPTY, ll, NIL, ld, lid, src, trg);
    
        send = processor_loop
            (procs, l, lp, p_src, p_trg, lid, NULL,
             get_ith_processor_dummy, get_ith_processor_prime,
             if_different_pe_and_not_twin(src, lid, rp_send, 
                                          make_empty_statement()), false);
    }
    else
    {
        Pbase b = entity_list_to_base(ldiff);
        list lpproc = gen_copy_seq(lp);
        statement diff;
        Psysteme 
            sd /* distributed */, 
            sr /* replicated */;
 
        MAP(ENTITY, e, gen_remove(&lpproc, e), ldiff);
 
        /* polyhedron separation to extract the diffusions.
         */
        sc_separate_on_vars(procs, b, &sr, &sd);
        base_rm(b);
 
        diff = remapping_stats(BRD, locals, sr, ll, ldiff, ld, lid, src, trg);
 
        send = processor_loop
            (sd, l, lpproc, p_src, p_trg, lid, is_buffer ? trg : NULL,
             get_ith_processor_dummy, get_ith_processor_prime,
             diff, false);
 
        gen_free_list(lpproc); sc_rm(sd); sc_rm(sr);
    }
 
    if (dist_p) 
    {
        gen_remove(&lp, lambda);
        l = gen_nconc(l, CONS(ENTITY, lambda, NIL)); /* ??? to be deduced */
    }
 
    receive = processor_loop
        (procs, lp, l, p_trg, p_src, lid, NULL,
         get_ith_processor_prime, get_ith_processor_dummy,
         if_different_pe_and_not_twin(src, lid, recv, copy), true);
 
    if (dist_p) gen_remove(&l, lambda);
 
    cont = make_empty_statement();
 
    result = make_block_statement(CONS(STATEMENT, send,
                                  CONS(STATEMENT, receive,
                                  CONS(STATEMENT, cont,
                                       NIL))));
 
    /*   some comments to help understand the generated code
     */
    {
        char *buffer;
        
        asprintf(&buffer, "! remapping %s[%"PRIdPTR"]: %s[%"PRIdPTR"] -> %s[%"PRIdPTR"]\n",
                entity_local_name(primary), load_hpf_number(primary),
                entity_local_name(src), load_hpf_number(src),
                entity_local_name(trg), load_hpf_number(trg));
        
        insert_comments_to_statement(result, buffer);
    free(buffer);
        insert_comments_to_statement(send, "! send part\n");
        insert_comments_to_statement(receive, "! receive part\n");
        insert_comments_to_statement(cont, "! end of remapping\n");
    }
    
    DEBUG_STAT(3, "result", result);
    
    return result;
}

References array_to_processors, asprintf, base_rm, BRD, buffer, CONS, CPY, DEBUG_STAT, ENDP, ENTITY, entity_list_to_base(), entity_local_name(), free(), gen_copy_seq(), gen_free_list(), gen_nconc(), gen_remove(), get_bool_property(), get_ith_processor_dummy(), get_ith_processor_prime(), get_ith_temporary_dummy(), hpfc_name_to_entity(), if_different_pe_and_not_twin(), insert_comments_to_statement(), load_hpf_number(), load_primary_entity(), make_block_statement(), make_empty_statement, MAP, NIL, pips_debug, processor_loop(), RCV, remapping_stats(), sc_rm(), sc_separate_on_vars(), SND, src, STATEMENT, T_LID, and USE_BUFFERS.

Referenced by hpf_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_remapping_guard()

static statement generate_remapping_guard ( entity  src, entity  trg, statement  the_code  )

static

Runtime descriptors management around the remapping code.

performs the remapping if reaching mapping is ok, and update the mapping status.

IF (MSTATUS(primary_number).eq.src_number) THEN [ IF (.not.LIVEMAPPING(target_number)]) THEN ] the_code [ ENDIF ] [ LIVEMAPPING(target_number) = .TRUE. ] MSTATUS(primary_number) = trg_number ENDDIF remapping code

source, target and primary numbers

mapping status

of statement

MSTATUS(primary_n)

MSTATUS(primary_number) = trg_number

MSTATUS(primary_number).eq.src_number

checks whether alive or not

Parameters

trg	source array
the_code	target array

Definition at line 859 of file remapping.c.

{
    int src_n = load_hpf_number(src), /* source, target and primary numbers */
        trg_n = load_hpf_number(trg),
        prm_n = load_hpf_number(load_primary_entity(src));
    entity m_status = hpfc_name_to_entity(MSTATUS); /* mapping status */
    expression m_stat_ref, cond;
    statement result;
    list /* of statement */ l = NIL;
    
    /* MSTATUS(primary_n) */
    m_stat_ref =
        reference_to_expression
            (make_reference(m_status, 
                            CONS(EXPRESSION, int_to_expression(prm_n), NIL)));
    
    /* MSTATUS(primary_number) = trg_number */
    l = CONS(STATEMENT, set_array_status_to_target(trg), l);
 
    /* MSTATUS(primary_number).eq.src_number */
    cond = eq_expression(m_stat_ref, int_to_expression(src_n));
 
    /* checks whether alive or not */
    if (get_bool_property("HPFC_DYNAMIC_LIVENESS"))
    {
        expression live_cond =
            not_expression(live_mapping_expression(trg_n));
 
        the_code =  test_to_statement(make_test
            (live_cond, the_code, make_empty_statement()));
 
        l = CONS(STATEMENT,
                 make_assign_statement(live_mapping_expression(trg_n),
                                   bool_to_expression(true)), l);
    }
 
    result = test_to_statement(make_test(cond, 
      make_block_statement(CONS(STATEMENT, the_code, l)),
      make_empty_statement()));
 
    return result;
}

References bool_to_expression(), CONS, eq_expression, EXPRESSION, get_bool_property(), hpfc_name_to_entity(), int_to_expression(), live_mapping_expression(), load_hpf_number(), load_primary_entity(), make_assign_statement(), make_block_statement(), make_empty_statement, make_reference(), make_test(), MSTATUS, NIL, not_expression, reference_to_expression(), set_array_status_to_target(), src, STATEMENT, and test_to_statement.

Referenced by hpf_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_remapping_include()

static statement generate_remapping_include ( renaming  r )

static

just a hack because pips does not have 'include'

Definition at line 1246 of file remapping.c.

{
    statement result;
 
    result = make_empty_statement();
    {
        string comment =
            strdup(concatenate("      include '",
                               remapping_file_name(r), "'\n", NULL));
        insert_comments_to_statement(result, comment);
        free(comment);
    }
    return result;
}

References comment(), concatenate(), free(), insert_comments_to_statement(), make_empty_statement, remapping_file_name(), and strdup().

Referenced by remapping_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_remapping_system()

static Psysteme generate_remapping_system ( entity  src, entity  trg  )

static

returns the full remapping system, including the source and target mappings systems, the link and the work sharing system

target array

Parameters

trg	source array for the remapping

Definition at line 175 of file remapping.c.

{
    int ndim = variable_entity_dimension(src);
    Psysteme 
        result,
        s_src = generate_system_for_distributed_variable(src),
        s_trg = shift_system_to_prime_variables
            (generate_system_for_distributed_variable(trg)),
        s_equ = generate_system_for_equal_variables
            (ndim, get_ith_array_dummy, get_ith_array_prime),
        s_shr = generate_work_sharing_system(src, trg);
    
    DEBUG_SYST(6, concatenate("source ", entity_name(src), NULL), s_src);
    DEBUG_SYST(6, concatenate("target ", entity_name(trg), NULL), s_trg);
    DEBUG_SYST(6, "link", s_equ);
    DEBUG_SYST(6, "sharing", s_shr);
 
    result = s_src;
    result = sc_append(result, s_trg), sc_rm(s_trg);
    result = sc_append(result, s_equ), sc_rm(s_equ);
    result = sc_append(result, s_shr), sc_rm(s_shr);
 
    return result;
}

References concatenate(), DEBUG_SYST, entity_name, generate_system_for_distributed_variable(), generate_system_for_equal_variables(), generate_work_sharing_system(), get_ith_array_dummy(), get_ith_array_prime(), sc_append(), sc_rm(), shift_system_to_prime_variables(), src, and variable_entity_dimension().

Referenced by hpf_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_work_sharing_system()

static Psysteme generate_work_sharing_system ( entity  src, entity  trg  )

static

load-balancing equation as suggested in the A-274 report.

here some choices are quite arbitrary:

• the dimension order linearization of both source and target procs.
• the initial offset some clever choice could be suggested so as to minimize the required communications by maximizing the local copies, knowing the actual hpf processors to real processors affectation...

should allow a stupid system with some property? target array

psi_d = psi_r + |psi_r| delta

0 <= delta (there are cycles)

delta <= -((size_d-1)/size_r) // not really necessary, but may help.

delta == 0

Parameters

trg	source array

Definition at line 122 of file remapping.c.

{
    entity psi_r = get_ith_temporary_dummy(1),
           psi_d = get_ith_temporary_dummy(2),
           delta = get_ith_temporary_dummy(3);
    int size_r, size_d;
    Psysteme sharing = sc_new();
 
    sc_add_egalite(sharing, partial_linearization(src, false, psi_r, &size_r, 
                                                  get_ith_processor_dummy));
    sc_add_egalite(sharing, partial_linearization(trg, true, psi_d, &size_d,
                                                  get_ith_processor_prime));
    
    /* psi_d = psi_r + |psi_r| delta
     */
    sc_add_egalite(sharing, contrainte_make(vect_make
        (VECTEUR_NUL, psi_d, VALUE_MONE, 
                      psi_r, VALUE_ONE, 
                      delta, int_to_value(size_r), 
                      TCST, VALUE_ZERO)));
 
    if (size_d > size_r)
    {
        /* 0 <= delta (there are cycles)
         */
        sc_add_inegalite(sharing, contrainte_make
           (vect_make(VECTEUR_NUL, delta, VALUE_MONE, TCST, VALUE_ZERO)));
 
        /* delta <= -((size_d-1)/size_r) // not really necessary, but may help.
         */
        sc_add_inegalite(sharing, contrainte_make
           (vect_make(VECTEUR_NUL, delta, VALUE_ONE, 
                      TCST, int_to_value(-((size_d-1)/size_r)))));
    }
    else
    {
        /* delta == 0
         */
        sc_add_egalite(sharing, 
           contrainte_make(vect_new((Variable) delta, VALUE_ONE)));
    }
 
    sc_creer_base(sharing);
 
    return sharing;
}

References contrainte_make(), get_ith_processor_dummy(), get_ith_processor_prime(), get_ith_temporary_dummy(), int_to_value, partial_linearization(), sc_add_egalite(), sc_add_inegalite(), sc_creer_base(), sc_new(), src, TCST, VALUE_MONE, VALUE_ONE, VALUE_ZERO, vect_make(), vect_new(), and VECTEUR_NUL.

Referenced by generate_remapping_system().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_remapping()

static statement hpf_remapping ( entity  src, entity  trg  )

static

remaps src to trg.

first builds the equation and needed lists of indexes, then call the actual code generation phase.

P cycle

of entities

of expressions

(optimization:-)

builds and simplifies the systems.

it is not obvious to decide where to place the cleaning, the equalities detection and the deducables...

the P cycle ?

processors/array elements separation.

??? why row echelon? why not... it is not too bad a projection! actually, what I want is to separate processors and elements. Then I would like to perform some manipulations on the systems to improve them, extracting deducables and lattices... but the conservation of the optimized order is not obvious... May/should I give it up in some cases? Well, I guess so.

What's missing:

• extraction of the lattice if equalities remain in a system. 1 Hermite transformation + variable list update...
• also some deducables could be extracted once the code is transformed.
• Q: what about variables which were kept althought not desired?

{ list ns = NIL; extract_lattice(proc, lp, &ns, &lp..

generates the code.

clean.

???

Definition at line 1034 of file remapping.c.

{
    Psysteme p, proc, enume;
    statement s;
    entity lambda = get_ith_temporary_dummy(3) ; /* P cycle */
    bool proc_distribution_p;
    list /* of entities */ l, lp, ll, lrm, ld, lo, left, scanners,
         /* of expressions */ lddc;
    bool time_remapping = get_bool_property("HPFC_TIME_REMAPPINGS");
 
    pips_debug(1, "%s -> %s\n", entity_name(src), entity_name(trg));
 
    if (src==trg) /* (optimization:-) */
        return make_empty_statement();
 
    if (time_remapping) push_performance_spy();
 
    /*   builds and simplifies the systems.
     */
    p = generate_remapping_system(src, trg);
    set_information_for_code_optimizations(p);
 
    remapping_variables(p, src, trg, &l, &lp, &ll, &lrm, &ld, &lo);
 
    /* it is not obvious to decide where to place
     * the cleaning, the equalities detection and the deducables...
     */
 
    clean_the_system(&p, &lrm, &lo);
    DEBUG_SYST(4, "cleaned system", p);
 
    if (get_bool_property("HPFC_EXTRACT_EQUALITIES"))
    {
        sc_find_equalities(&p);
        DEBUG_SYST(4, "more equalities", p);
    }
 
    lddc = simplify_deducable_variables(p, ll, &left);
    gen_free_list(ll);
    DEBUG_SYST(4, "without deducables system", p);
    
    /* the P cycle ?
     */
    proc_distribution_p = gen_in_list_p(lambda, lo);
    if (proc_distribution_p) gen_remove(&lo, lambda);
    scanners = gen_nconc(lo, left);
 
    DEBUG_ELST(4, "scanners", scanners);
 
    /* processors/array elements separation.
     *
     * ??? why row echelon? why not... it is not too bad a projection!
     * actually, what I want is to separate processors and elements. 
     * Then I would like to perform some manipulations on the systems
     * to improve them, extracting deducables and lattices... 
     * but the conservation of the optimized order is not obvious... 
     * May/should I give it up in some cases? Well, I guess so.
     *
     * What's missing:
     *  - extraction of the lattice if equalities remain in a system.
     *    1 Hermite transformation + variable list update...
     *  - also some deducables could be extracted once the code is transformed.
     *  - Q: what about variables which were kept althought not desired?
     */
    hpfc_algorithm_row_echelon(p, scanners, &proc, &enume);
    sc_rm(p);
 
    sc_transform_ineg_in_eg(proc);
    sc_transform_ineg_in_eg(enume);
 
    if (sc_egalites(proc))
        hpfc_warning("lattice extraction not implemented (proc)\n");
    /* {
        list ns = NIL;
        extract_lattice(proc, lp, &ns, &lp.. */
 
 
    if (sc_egalites(enume))
    {
        list ns = NIL;
        extract_lattice(enume, scanners, &ns, &lddc);
        gen_free_list(scanners), scanners=ns;
    }
 
    DEBUG_SYST(3, "proc", proc);
    DEBUG_SYST(3, "enum", enume);
 
    /*   generates the code.
     */
    s = generate_remapping_guard(src, trg, generate_remapping_code
      (src, trg, proc, enume, l, lp, scanners, ld, lddc, proc_distribution_p));
 
    /*   clean.
     */
    sc_rm(proc), sc_rm(enume);
    gen_free_list(scanners);
    gen_free_list(l), gen_free_list(lp), gen_free_list(ld);
    gen_map((gen_iter_func_t)gen_free, lddc), gen_free_list(lddc);  /* ??? */
 
    reset_information_for_code_optimizations();
    
    if (time_remapping) 
        pop_performance_spy(stderr, 
        concatenate("remapping ", 
                    entity_name(src), " -> ",
                    entity_name(trg), NULL));
 
    DEBUG_STAT(6, "result", s);
 
    return s;
}

References clean_the_system(), concatenate(), DEBUG_ELST, DEBUG_STAT, DEBUG_SYST, entity_name, extract_lattice(), gen_free(), gen_free_list(), gen_in_list_p(), gen_map(), gen_nconc(), gen_remove(), generate_remapping_code(), generate_remapping_guard(), generate_remapping_system(), get_bool_property(), get_ith_temporary_dummy(), hpfc_algorithm_row_echelon(), hpfc_warning, make_empty_statement, NIL, pips_debug, pop_performance_spy(), push_performance_spy(), remapping_variables(), reset_information_for_code_optimizations(), sc_find_equalities(), sc_rm(), sc_transform_ineg_in_eg(), set_information_for_code_optimizations(), simplify_deducable_variables(), and src.

Referenced by generate_hpf_remapping_file().

Here is the call graph for this function:

Here is the caller graph for this function:

if_different_pe_and_not_twin()

static statement if_different_pe_and_not_twin ( entity  src, entity  lid, statement  strue, statement  sfalse  )

static

to be generated: IF (MYLID.NE.LID[.AND.NOT.HPFC_TWIN_P(an, LID)]) THEN true ELSE false ENDIF

else statement

of expression

Parameters

lid	source array processor
strue	process local id variable
sfalse	then statement

Definition at line 408 of file remapping.c.

{
    expression cond = mylid_ne_lid(lid);
 
    if (get_bool_property("HPFC_GUARDED_TWINS") && replicated_p(src))
    {
        list /* of expression */ largs;
        expression not_twin;
 
        largs = CONS(EXPRESSION, int_to_expression(load_hpf_number(src)),
                CONS(EXPRESSION, entity_to_expression(lid), NIL));
        not_twin = not_expression(call_to_expression
            (make_call(hpfc_name_to_entity(TWIN_P), largs)));
 
        cond = and_expression(cond, not_twin);
    }
 
    return test_to_statement(make_test(cond, strue, sfalse));
}

References and_expression, call_to_expression(), CONS, entity_to_expression(), EXPRESSION, get_bool_property(), hpfc_name_to_entity(), int_to_expression(), load_hpf_number(), make_call(), make_test(), mylid_ne_lid(), NIL, not_expression, replicated_p(), src, test_to_statement, and TWIN_P.

Referenced by broadcast(), and generate_remapping_code().

Here is the call graph for this function:

Here is the caller graph for this function:

list_of_referenced_entities()

static list list_of_referenced_entities ( statement  s )

static

Definition at line 1181 of file remapping.c.

{
    l_found = NIL;
    gen_multi_recurse(s, loop_domain, gen_true, loop_rwt,
                         reference_domain, gen_true, reference_rwt, NULL);
    return l_found;
}

References gen_multi_recurse(), gen_true(), l_found, loop_domain, loop_rwt(), NIL, reference_domain, and reference_rwt().

Referenced by generate_hpf_remapping_file().

Here is the call graph for this function:

Here is the caller graph for this function:

live_mapping_expression()

static expression live_mapping_expression ( int  index )

static

returns LIVEMAPPING(index)

Definition at line 793 of file remapping.c.

{
    entity live_status = hpfc_name_to_entity(LIVEMAPPING);
    return reference_to_expression(make_reference
        (live_status, CONS(EXPRESSION, int_to_expression(index), NIL)));
}

References CONS, EXPRESSION, hpfc_name_to_entity(), int_to_expression(), LIVEMAPPING, make_reference(), NIL, and reference_to_expression().

Referenced by generate_all_liveness_but(), generate_dynamic_liveness_for_primary(), generate_remapping_guard(), and set_live_status().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_rwt()

static void loop_rwt ( loop  l )

static

Definition at line 1175 of file remapping.c.

{ l_found = gen_once(loop_index(l), l_found);}

References gen_once(), l_found, and loop_index.

Referenced by list_of_referenced_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

mylid_ne_lid()

static expression mylid_ne_lid ( entity  lid )

static

Definition at line 395 of file remapping.c.

{
    return ne_expression(entity_to_expression(hpfc_name_to_entity(MYLID)),
                         entity_to_expression(lid));
}

References entity_to_expression(), hpfc_name_to_entity(), MYLID, and ne_expression.

Referenced by if_different_pe_and_not_twin().

Here is the call graph for this function:

Here is the caller graph for this function:

partial_linearization()

static Pcontrainte partial_linearization ( entity  array, bool  distributed, entity  var, int *  psize, entity(*)(int)  create_var  )

static

HPFC module by Fabien COELHO.

generates a remapping code. debug controlled with HPFC_REMAPPING_DEBUG_LEVEL. ??? should drop the renaming domain? linearize the processor arrangement on which array is distributed or replicated (driven by distributed). The variables are those created or returned by the create_var function. var is set as the linearization result, if not NULL. *psize the the extent of the returned array. Special care is taken about the declaration shifts. dimension variable builder

Parameters

distributed	array variable
var	distributed or replicated dimensions lin.
psize	assigned variable if desired
create_var	returned array extent

Definition at line 48 of file remapping.c.

{
    entity proc = array_to_processors(array);
    int dim = NumberOfDimension(proc), low, up, size;
    Pvecteur v = VECTEUR_NUL;
 
    for(*psize=1; dim>0; dim--)
        if (distributed ^ processors_dim_replicated_p(proc, array, dim))
        {
            get_entity_dimensions(proc, dim, &low, &up);
            size = up - low + 1;
            *psize *= size;
            v = vect_multiply(v, int_to_value(size));
            vect_add_elem(&v, (Variable) create_var(dim), VALUE_ONE);
            vect_add_elem(&v, TCST, int_to_value(-low));
        }
 
    if (var) vect_add_elem(&v, (Variable) var, VALUE_MONE);
 
    return contrainte_make(v);
}

References array, array_to_processors, contrainte_make(), get_entity_dimensions(), int_to_value, NumberOfDimension(), processors_dim_replicated_p(), TCST, VALUE_MONE, VALUE_ONE, vect_add_elem(), vect_multiply(), and VECTEUR_NUL.

Referenced by generate_work_sharing_system().

Here is the call graph for this function:

Here is the caller graph for this function:

processor_loop()

static statement processor_loop ( Psysteme  s, _UNUSED_ list  l_psi, list  l_oth, entity  psi, entity  oth, entity  lid, entity  array, entity(*)()  create_psi, entity(*)()  create_oth, statement  body, bool  sh  )

static

to be generated: ??? the Proc cycle should be deduce directly in some case...

PSI_i's definitions [ IF (I AM IN S(PSI_i)) THEN ] DO OTH_i's in S(OTH_i's)[PSI_i's] LID computation(OTH_i's) // if LID is not NULL! body ENDDO [ ENDIF ] whether to shift the psi's

the lid computation is delayed in the body for broadcasts.

simplifies the processor arrangement for the condition

the processor must be in the psi processor arrangement

target processors enumeration loop

Parameters

l_psi	system of comm. couples of processors of entities
l_oth	processor local dimensions of entities
psi	communicating proc. dimensions
oth	local processor arrangement
lid	communicating processor arrangement
array	variable for the comm. proc local id
create_psi	array being remapped
create_oth	to create a local proc. dim.
body	to create a comm. proc. dim.
sh	loop body

Definition at line 304 of file remapping.c.

{
    entity divide = hpfc_name_to_entity(IDIVIDE);
    Psysteme condition, enumeration, known, simpler;
    statement define_psis, compute_lid, oth_loop, if_guard;
    
    define_psis = define_node_processor_id(psi, create_psi);
 
    /* the lid computation is delayed in the body for broadcasts.
     */
    compute_lid = (lid) ?
        hpfc_compute_lid(lid, oth, create_oth, array) : 
        make_empty_statement(); 
 
    /* simplifies the processor arrangement for the condition
     */
    known = sc_dup(entity_to_declaration_constraints(psi, 2));
    if (sh) known = shift_system_to_prime_variables(known);
 
    DEBUG_SYST(7, "initial system", s);
    DEBUG_ELST(7, "loop indexes", l_oth);
 
    hpfc_algorithm_row_echelon(s, l_oth, &condition, &enumeration);
 
    DEBUG_SYST(7, "P condition", condition);
 
    simpler = extract_nredund_subsystem(condition, known);
    sc_rm(condition), sc_rm(known);
 
    /*  the processor must be in the psi processor arrangement
     */
    sc_add_inegalite(simpler, 
                     contrainte_make
                     (vect_make(VECTEUR_NUL,
                                hpfc_name_to_entity(MYLID), VALUE_ONE, 
                                TCST, int_to_value(- element_number
      (variable_basic(type_variable(entity_type(psi))),
       variable_dimensions(type_variable(entity_type(psi))))))));
 
    DEBUG_SYST(5, "P simpler", simpler);
    DEBUG_SYST(5, "P enumeration", enumeration);
 
    /* target processors enumeration loop
     */
    oth_loop = systeme_to_loop_nest(enumeration, l_oth, 
               make_block_statement(CONS(STATEMENT, compute_lid,
                                    CONS(STATEMENT, body,
                                         NIL))), divide);
 
    if_guard = generate_optional_if(simpler, oth_loop);
 
    sc_rm(simpler); sc_rm(enumeration);
 
    return make_block_statement(CONS(STATEMENT, define_psis,
                                CONS(STATEMENT, if_guard,
                                     NIL)));
}

References array, CONS, contrainte_make(), DEBUG_ELST, DEBUG_SYST, define_node_processor_id(), divide, element_number(), entity_to_declaration_constraints(), entity_type, extract_nredund_subsystem(), generate_optional_if(), hpfc_algorithm_row_echelon(), hpfc_compute_lid(), hpfc_name_to_entity(), IDIVIDE, int_to_value, make_block_statement(), make_empty_statement, MYLID, NIL, sc_add_inegalite(), sc_dup(), sc_rm(), shift_system_to_prime_variables(), STATEMENT, systeme_to_loop_nest(), TCST, type_variable, VALUE_ONE, variable_basic, variable_dimensions, vect_make(), and VECTEUR_NUL.

Referenced by generate_remapping_code().

Here is the call graph for this function:

Here is the caller graph for this function:

protected_text_statement()

static text protected_text_statement ( statement  s )

static

Definition at line 1190 of file remapping.c.

{
    text t;
    debug_on("PRETTYPRINT_DEBUG_LEVEL");
    t = Text_Statement(entity_undefined, 0, s);
    debug_off();
    return t;
}

References debug_off, debug_on, entity_undefined, and Text_Statement().

Referenced by generate_hpf_remapping_file().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_rwt()

static void reference_rwt ( reference  r )

static

Definition at line 1177 of file remapping.c.

{ l_found = gen_once(reference_variable(r), l_found);}

References gen_once(), l_found, and reference_variable.

Referenced by list_of_referenced_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

remapping_compile()

void remapping_compile	(	statement	s,
		statement *	hsp,
		statement *	nsp
	)

void remapping_compile(s, hsp, nsp) statement s, *hsp, *nsp;

what: generates the remapping code for s. how: polyhedron technique. input: s, the statement. output: statements *hsp and *nsp, the host and SPMD node code. side effects: (none?) bugs or features: idem Node

of statements

nothing for host

comment at the end

dynamic liveness management if required

remapping codes (indirect thru include)

KILL => status update

comment at the beginning

block of remaps for the nodes

Parameters

hsp	initial statement in the source code
nsp	Host Statement Pointer

Definition at line 1302 of file remapping.c.

{
    statement tmp;
    list /* of statements */ l = NIL;
    
    debug_on("HPFC_REMAPPING_DEBUG_LEVEL");
    what_stat_debug(1, s);
 
    *hsp = make_empty_statement(); /* nothing for host */
 
    /* comment at the end
     */
    tmp = make_empty_statement();
    {
        string comment = strdup(concatenate("! end remappings\n", NULL));
        insert_comments_to_statement(tmp, comment);
        free(comment);
    }
    l = CONS(STATEMENT, tmp, l);
 
    /* dynamic liveness management if required
     */
    if (get_bool_property("HPFC_DYNAMIC_LIVENESS"))
    {
        l = CONS(STATEMENT, generate_dynamic_liveness_management(s), l);
    }
 
    /* remapping codes (indirect thru include)
     */
    MAP(RENAMING, r,
    {
        pips_debug(7, "remapping %s -> %s\n", entity_name(renaming_old(r)),
                   entity_name(renaming_new(r)));
        if (renaming_old(r)==renaming_new(r)) /* KILL => status update */
            l = CONS(STATEMENT, set_array_status_to_target(renaming_new(r)),
                     l);
        else 
        {
            if (!remapping_already_computed_p(r))
                generate_hpf_remapping_file(r);
            
            add_remapping_as_used(r);
            l = CONS(STATEMENT, generate_remapping_include(r), l);
        }
    },
        load_renamings(s));
 
    /* comment at the beginning
     */
    tmp = make_empty_statement();
    {
        string comment = strdup(concatenate("! begin remappings\n", NULL));
        insert_comments_to_statement(tmp, comment);
        free(comment);
    }
    l = CONS(STATEMENT, tmp, l);
 
    *nsp = make_block_statement(l); /* block of remaps for the nodes */
    DEBUG_STAT(8, "result", *nsp);
 
    debug_off();
}

References add_remapping_as_used(), comment(), concatenate(), CONS, debug_off, debug_on, DEBUG_STAT, entity_name, free(), generate_dynamic_liveness_management(), generate_hpf_remapping_file(), generate_remapping_include(), get_bool_property(), insert_comments_to_statement(), load_renamings(), make_block_statement(), make_empty_statement, MAP, NIL, pips_debug, remapping_already_computed_p(), RENAMING, renaming_new, renaming_old, set_array_status_to_target(), STATEMENT, strdup(), and what_stat_debug.

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

remapping_file_name()

static string remapping_file_name ( renaming  remap )

static

file name for storing the remapping code.

{module}_{array}_{src}_{trg}_node.h

Definition at line 1152 of file remapping.c.

{
    char *buffer;
    entity src = renaming_old(remap), trg = renaming_new(remap);
    string module, array;
 
    module = strdup(entity_module_name(src));
    array  = strdup(entity_local_name(load_primary_entity(src)));
 
    asprintf(&buffer, "%s_%s_%"PRIdPTR"_%"PRIdPTR"_node.h", module, array,
            load_hpf_number(src), load_hpf_number(trg));
 
    free(module);
    free(array);
 
    return buffer;
}

References array, asprintf, buffer, entity_local_name(), entity_module_name(), free(), load_hpf_number(), load_primary_entity(), module, renaming_new, renaming_old, src, and strdup().

Referenced by generate_hpf_remapping_file(), and generate_remapping_include().

Here is the call graph for this function:

Here is the caller graph for this function:

remapping_stats()

static statement remapping_stats ( int  t, Psysteme  s, Psysteme  sr, list  ll, list  ldiff, list  ld, entity  lid, entity  src, entity  trg  )

static

generates a remapping loop nest (copy/send/receive/broadcast) basically a loop on elements with pre/in/post statements...

target array

comments are added to help understand the generated code

Parameters

s	tag: CPY/SND/RCV/BRD
sr	elements polyhedron
ll	broadcast polyhedron of entity
ldiff	indexes for element loops of entity
ld	indexes for broadcasts of expressions
lid	deducable elements
src	lid variable to be used
trg	source array

Definition at line 615 of file remapping.c.

{
    entity proc = array_to_processors(trg);
    statement inner, prel, postl, result;
    bool is_buffer, is_lazy;
    int what;
 
    is_lazy = get_bool_property(LAZY_MESSAGES);
    is_buffer = get_bool_property(USE_BUFFERS);
    what = (is_lazy ? LZY : NLZ) + (is_buffer ? BUF : NBF) + t;
    
    prel  = gen(what+PRE, src, trg, lid, proc, 
                get_ith_local_dummy, get_ith_local_prime, sr, ldiff);
    inner = gen(what+INL, src, trg, lid, proc, 
                get_ith_local_dummy, get_ith_local_prime, sr, ldiff);
    postl = gen(what+PST, src, trg, lid, proc, 
                get_ith_local_dummy, get_ith_local_prime, sr, ldiff);
 
    result = make_block_statement
            (CONS(STATEMENT, prel,
             CONS(STATEMENT, elements_loop(s, ll, ld, inner),
             CONS(STATEMENT, postl,
                  NIL))));
 
    {
        /* comments are added to help understand the generated code
         */
        string comment = strdup(concatenate("! - ", (what & LZY) ? "lazy " : "",
               t==CPY ? "copy" : t==SND ? "send" : t==RCV ? "receiv" :
               t==BRD ? "broadcast" : "?",  "ing\n", NULL));
        insert_comments_to_statement(result, comment);
        free(comment);
    }
    return result;
}

References array_to_processors, BRD, BUF, comment(), concatenate(), CONS, CPY, elements_loop(), free(), gen(), get_bool_property(), get_ith_local_dummy(), get_ith_local_prime(), INL, insert_comments_to_statement(), LAZY_MESSAGES, LZY, make_block_statement(), NBF, NIL, NLZ, PRE, PST, RCV, SND, src, STATEMENT, strdup(), and USE_BUFFERS.

Referenced by generate_remapping_code().

Here is the call graph for this function:

Here is the caller graph for this function:

remapping_variables()

static void remapping_variables ( Psysteme  s, entity  a1, entity  a2, list *  pl, list *  plp, list *  pll, list *  plrm, list *  pld, list *  plo  )

static

??? assumes that there are no parameters.

what should be the case... generates the list of variables needed by the code generation. others

processors.

to be removed.

corresponding equations generated in the sharing system

Replicated dimensions associated variables must be removed. A nicer approach would have been not to generate them, but it's not so hard to remove them, and the equation generation is kept simpler this way. At least in my own opinion:-)

locals.

others.

Parameters

a1	full remapping system
a2	source array
pl	target array
plp	P
pll	P'
plrm	locals
pld	to remove
plo	diffusion processor variables

Definition at line 206 of file remapping.c.

{
    entity
        t1 = array_to_template(a1),
        p1 = template_to_processors(t1),
        t2 = array_to_template(a2),
        p2 = template_to_processors(t2);
    int
        a1dim = variable_entity_dimension(a1),
        a2dim = variable_entity_dimension(a2),
        t1dim = variable_entity_dimension(t1),
        t2dim = variable_entity_dimension(t2),
        p1dim = variable_entity_dimension(p1),
        p2dim = variable_entity_dimension(p2), i;
 
    /*   processors.
     */
    *pl  = NIL; add_to_list_of_vars(*pl, get_ith_processor_dummy, p1dim);
    *plp = NIL; add_to_list_of_vars(*plp, get_ith_processor_prime, p2dim);
 
    *pld = NIL; 
    for (i=p2dim; i>0; i--)
        if (processors_dim_replicated_p(p2, a2, i))
            *pld = CONS(ENTITY, get_ith_processor_prime(i), *pld);
 
    /*   to be removed.
     */
    *plrm = NIL;
    add_to_list_of_vars(*plrm, get_ith_template_dummy, t1dim);
    add_to_list_of_vars(*plrm, get_ith_template_prime, t2dim);
    add_to_list_of_vars(*plrm, get_ith_array_dummy, a1dim);
    add_to_list_of_vars(*plrm, get_ith_array_prime, a2dim);
 
    /*    corresponding equations generated in the sharing system
     */
    add_to_list_of_vars(*plrm, get_ith_temporary_dummy, 2);
    
 
    /*    Replicated dimensions associated variables must be removed.
     *    A nicer approach would have been not to generate them, but
     * it's not so hard to remove them, and the equation generation is
     * kept simpler this way. At least in my own opinion:-)
     */
    for (i=p1dim; i>0; i--)
        if (processors_dim_replicated_p(p1, a1, i))
            *plrm = CONS(ENTITY, get_ith_block_dummy(i), 
                    CONS(ENTITY, get_ith_cycle_dummy(i), *plrm));
 
    for (i=p2dim; i>0; i--)
        if (processors_dim_replicated_p(p2, a2, i))
            *plrm = CONS(ENTITY, get_ith_block_prime(i), 
                    CONS(ENTITY, get_ith_cycle_prime(i), *plrm));
 
    /*   locals.
     */
    *pll = NIL;
    add_to_list_of_vars(*pll, get_ith_local_dummy, a1dim);
    add_to_list_of_vars(*pll, get_ith_local_prime, a2dim);
 
    /*   others.
     */
    *plo = base_to_list(sc_base(s)); 
    gen_remove(plo, (entity) TCST);
 
    MAP(ENTITY, e, gen_remove(plo, e), *pl);
    MAP(ENTITY, e, gen_remove(plo, e), *plp);
    MAP(ENTITY, e, gen_remove(plo, e), *plrm);
    MAP(ENTITY, e, gen_remove(plo, e), *pll);
 
    DEBUG_ELST(7, "P", *pl);
    DEBUG_ELST(7, "P'", *plp);
    DEBUG_ELST(7, "RM", *plrm);
    DEBUG_ELST(7, "LOCALS", *pll);
    DEBUG_ELST(7, "DIFFUSION", *pld);
    DEBUG_ELST(7, "OTHERS", *plo);
}

References add_to_list_of_vars, array_to_template, base_to_list(), CONS, DEBUG_ELST, ENTITY, gen_remove(), get_ith_array_dummy(), get_ith_array_prime(), get_ith_block_dummy(), get_ith_block_prime(), get_ith_cycle_dummy(), get_ith_cycle_prime(), get_ith_local_dummy(), get_ith_local_prime(), get_ith_processor_dummy(), get_ith_processor_prime(), get_ith_template_dummy(), get_ith_template_prime(), get_ith_temporary_dummy(), MAP, NIL, pl, processors_dim_replicated_p(), TCST, template_to_processors, and variable_entity_dimension().

Referenced by hpf_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

root_statement_remapping_inits()

statement root_statement_remapping_inits

(

statement

root

)

returns the initialization statement: must initialize the status and liveness of arrays

of statement

of entity

LIVENESS(...) = .TRUE. STATUS(...) = ...

LIVENESS(...) = .FALSE.

Parameters

root

oot

Definition at line 1265 of file remapping.c.

{
    list /* of statement */ ls = NIL;
    list /* of entity */ le =
        list_of_distributed_arrays_for_module(get_current_module_entity());
 
    /* LIVENESS(...) = .TRUE.
     * STATUS(...) = ...
     */
    MAP(RENAMING, r,
        ls = CONS(STATEMENT, update_runtime_for_remapping(renaming_new(r)),ls),
        load_renamings(root));
 
    /* LIVENESS(...) = .FALSE.
     */
    MAP(ENTITY, array,
        if (bound_dynamic_hpf_p(array) && primary_entity_p(array))
            ls = CONS(STATEMENT, generate_all_liveness(array, false), ls),
        le);
 
    gen_free_list(le), le = NIL;
    
    return make_block_statement(ls);
}

References array, bound_dynamic_hpf_p(), CONS, ENTITY, gen_free_list(), generate_all_liveness(), get_current_module_entity(), list_of_distributed_arrays_for_module(), load_renamings(), make_block_statement(), MAP, NIL, primary_entity_p, RENAMING, renaming_new, STATEMENT, and update_runtime_for_remapping().

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

set_array_status_to_target()

static statement set_array_status_to_target ( entity  trg )

static

mapping status

MSTATUS(primary_n)

Definition at line 801 of file remapping.c.

{
    int trg_n = load_hpf_number(trg),
        prm_n = load_hpf_number(load_primary_entity(trg));
    entity m_status = hpfc_name_to_entity(MSTATUS); /* mapping status */
    expression m_stat_ref;
 
    /* MSTATUS(primary_n) */
    m_stat_ref =
        reference_to_expression
            (make_reference(m_status, 
                            CONS(EXPRESSION, int_to_expression(prm_n), NIL)));
 
    return make_assign_statement(m_stat_ref, int_to_expression(trg_n));
}

References CONS, EXPRESSION, hpfc_name_to_entity(), int_to_expression(), load_hpf_number(), load_primary_entity(), make_assign_statement(), make_reference(), MSTATUS, NIL, and reference_to_expression().

Referenced by generate_remapping_guard(), remapping_compile(), and update_runtime_for_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

set_live_status()

static statement set_live_status ( entity  trg, _UNUSED_ bool  val  )

static

Definition at line 818 of file remapping.c.

{
    int trg_n = load_hpf_number(load_similar_mapping(trg));
 
    return make_assign_statement(live_mapping_expression(trg_n),
                                 bool_to_expression(true));
}

References bool_to_expression(), live_mapping_expression(), load_hpf_number(), load_similar_mapping(), and make_assign_statement().

Referenced by update_runtime_for_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

update_runtime_for_remapping()

static statement update_runtime_for_remapping ( entity  trg )

static

Definition at line 829 of file remapping.c.

{
    statement s = set_live_status(trg, true);
 
    {
        string comment =
            strdup(concatenate("! direct remapping for ", 
                               entity_local_name(load_primary_entity(trg)), "\n", NULL));
        insert_comments_to_statement(s, comment);
        free(comment);
    }
 
    return make_block_statement
        (CONS(STATEMENT, s,
         CONS(STATEMENT, set_array_status_to_target(trg), NIL)));
}

References comment(), concatenate(), CONS, entity_local_name(), free(), insert_comments_to_statement(), load_primary_entity(), make_block_statement(), NIL, set_array_status_to_target(), set_live_status(), STATEMENT, and strdup().

Referenced by root_statement_remapping_inits().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

l_found

list l_found

static

quick recursion to find the entities referenced in a statement.

the list is allocated and returned. of entity

Definition at line 1174 of file remapping.c.

Referenced by list_of_referenced_entities(), loop_rwt(), and reference_rwt().