io-util.c File Reference

#include "defines-local.h"
#include "conversion.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"

Include dependency graph for io-util.c:

Go to the source code of this file.

Macros
#define	Load(stat)    ((bool)(intptr_t) (hash_get(stat_bool_map, stat)))
#define	Store(stat, val)    (hash_put(stat_bool_map, (void*)stat, (void*) (val)))
#define	GENERATION(NAME, COLLECT, UPDATE)

Functions
static bool	host_section_p (list ls)
	true if the first statement of a block is a host section marker. More...
void	hpfc_io_util_error_handler ()
	??? neglect expression side effects... More...
static void	only_io_sequence (sequence q)
static void	only_io_test (test t)
static void	only_io_loop (loop l)
static void	only_io_call (call c)
static void	only_io_unstructured (unstructured u)
static statement_mapping	only_io_mapping (statement program, statement_mapping map)
void	only_io_mapping_initialize (statement program)
static statement	hpfc_hmessage (entity array, entity proc, bool send)
	T_LID=CMP_LID(pn, pi...) ? init buffer... More...
static statement	hpfc_nrecv (entity array, bool cast)
	! init buffer CALL HPFC {RCV FROM HOST, NCAST} CALL (type) BUFFER UNPACK More...
static statement	hpfc_nsend (entity array)
	PVM_SEND(HOST_TID, HOST SND CHANNEL, INFO) HOST SND CHANNEL += 2. More...
static statement	hpfc_hcast (entity array)
	static statement hpfc_hcast() More...
	GENERATION (node_pre_io, hpfc_buffer_initialization(true, false, true), hpfc_nrecv(array, false))
void	generate_io_statements_for_shared_arrays (entity array, tag move, Psysteme condition, Psysteme echelon, _UNUSED_ list parameters, list scanners, list rebuild, statement *psh, statement *psn)
	generate_io_statements_for_shared_arrays More...

Variables
static statement_mapping	stat_bool_map = hash_table_undefined
	HPFC module by Fabien COELHO. More...

Macro Definition Documentation

GENERATION

#define GENERATION	(		NAME,
			COLLECT,
			UPDATE
	)

Value:

static statement NAME(array, move) entity array; tag move;\
{pips_assert("valid move", \
  move==is_movement_collect || move==is_movement_update);\
 return((move==is_movement_collect) ? (COLLECT) : (UPDATE));}

Definition at line 256 of file io-util.c.

Load

#define Load

(

stat

)

((bool)(intptr_t) (hash_get(stat_bool_map, stat)))

Definition at line 53 of file io-util.c.

Store

#define Store	(		stat,
			val
	)		(hash_put(stat_bool_map, (void*)stat, (void*) (val)))

Definition at line 56 of file io-util.c.

Function Documentation

generate_io_statements_for_shared_arrays()

void generate_io_statements_for_shared_arrays	(	entity	array,
		tag	move,
		Psysteme	condition,
		Psysteme	echelon,
		_UNUSED_ list	parameters,
		list	scanners,
		list	rebuild,
		statement *	psh,
		statement *	psn
	)

generate_io_statements_for_shared_arrays

code to be generated:

Host:

[ IF condition then ] init_send DO scanners rebuild pack ENDDO host_cast [ ENDIF ]

Node:

[ IF condition then ] receive_hcast DO scanners rebuild unpack ENDDO [ ENDIF ]

some comments are generated to help understand the code

Definition at line 438 of file io-util.c.

{
    entity divide = hpfc_name_to_entity(IDIVIDE);
    string comment;
    statement
        h_cont = make_empty_statement(),
        n_cont = make_empty_statement(),
        h_pre = hpfc_buffer_initialization(true, false, true),
        h_rebuild = generate_deducables(rebuild),
        h_pack = hpfc_buffer_packing(array, (entity (*)())get_ith_array_dummy, true),
        h_cast = hpfc_hcast(array),
        n_rcv = hpfc_nrecv(array, true),
        n_rebuild = generate_deducables(rebuild),
        n_unpack = hpfc_buffer_packing(array, (entity (*)())get_ith_local_dummy, false),
        h_scan = systeme_to_loop_nest
                     (echelon, 
                      scanners,
                      make_block_statement(CONS(STATEMENT, h_rebuild,
                                           CONS(STATEMENT, h_pack,
                                                NIL))),
                      divide),
        n_scan = systeme_to_loop_nest
                     (echelon, 
                      scanners,
                      make_block_statement(CONS(STATEMENT, n_rebuild,
                                           CONS(STATEMENT, n_unpack,
                                                NIL))),
                      divide);
 
    pips_assert("update", movement_update_p(move));
 
    *psh = make_block_statement(
        CONS(STATEMENT, generate_optional_if
             (condition, make_block_statement(CONS(STATEMENT, h_pre,
                                              CONS(STATEMENT, h_scan,
                                              CONS(STATEMENT, h_cast,
                                                   NIL))))),
        CONS(STATEMENT, h_cont, NIL)));
 
    *psn = make_block_statement(
        CONS(STATEMENT, generate_optional_if
             (condition, make_block_statement(CONS(STATEMENT, n_rcv,
                                              CONS(STATEMENT, n_scan,
                                                   NIL)))),
        CONS(STATEMENT, n_cont, NIL)));
 
    /*   some comments are generated to help understand the code
     */
    comment = strdup(concatenate("! updating shared variable ",
                                 entity_local_name(array), "\n", NULL));
    insert_comments_to_statement(*psh, comment);
    insert_comments_to_statement(*psn, comment);
    free(comment);
    insert_comments_to_statement(h_cont, "! end of update\n");
    insert_comments_to_statement(n_cont, "! end of update\n");
}

References array, comment(), concatenate(), CONS, divide, entity_local_name(), free(), generate_deducables(), generate_optional_if(), get_ith_array_dummy(), get_ith_local_dummy(), hpfc_buffer_initialization(), hpfc_buffer_packing(), hpfc_hcast(), hpfc_name_to_entity(), hpfc_nrecv(), IDIVIDE, insert_comments_to_statement(), make_block_statement(), make_empty_statement, movement_update_p, NIL, pips_assert, STATEMENT, strdup(), and systeme_to_loop_nest().

Here is the call graph for this function:

GENERATION()

GENERATION	(	node_pre_io	,
		hpfc_buffer_initialization(true, false, true)	,
		hpfc_nrecv(array, false)
	)

proc_cond computation: well, it may have been kept before the new loop bound computation?

Do not forget to move forbidden information associated with block:

Definition at line 262 of file io-util.c.

{
    string comment;
    entity
        proc = array_to_processors(array),
        divide = hpfc_name_to_entity(IDIVIDE);
    Psysteme
        /* proc_cond computation:
         * well, it may have been kept before the new loop bound computation?
         */
        proc_decl = entity_to_declaration_constraints(proc, 2),
        proc_cond_tmp = sc_dup(proc_echelon),
        proc_cond = (sc_nredund(&proc_cond_tmp),
                     extract_nredund_subsystem(proc_cond_tmp, proc_decl));
    statement
        h_cont = make_empty_statement(),
        n_cont = make_empty_statement(),
        node_tmp = statement_undefined,
        node_defproc = define_node_processor_id(proc, get_ith_processor_dummy),
        node_deduce = generate_deducables(rebuild),
        host_deduce = generate_deducables(rebuild),
        h_pre = host_pre_io(array, move),
        h_in = host_in_io(array, move),
        h_post = host_post_io(array, move),
        n_pre = node_pre_io(array, move),
        n_in = node_in_io(array, move),
        n_post = node_post_io(array, move),
        host_scan_loop = 
            systeme_to_loop_nest
                (tile_echelon, 
                 scanners, 
                 make_block_statement(CONS(STATEMENT, host_deduce,
                                      CONS(STATEMENT, h_in,
                                           NIL))),
                 divide),
        host_proc_loop = 
            systeme_to_loop_nest
                (proc_echelon, 
                 processors, 
                 make_block_statement(CONS(STATEMENT, h_pre,
                                      CONS(STATEMENT, host_scan_loop,
                                      CONS(STATEMENT, h_post,
                                           NIL)))),
                 divide),
        node_scan_loop = 
            systeme_to_loop_nest
                (tile_echelon, 
                 scanners,      
                 make_block_statement(CONS(STATEMENT, node_deduce,
                                      CONS(STATEMENT, n_in,
                                           NIL))),
                 divide);
 
    *psh = make_block_statement(
        CONS(STATEMENT, generate_optional_if(condition, host_proc_loop),
        CONS(STATEMENT, h_cont, NIL)));
 
    node_tmp = 
        make_block_statement(CONS(STATEMENT, n_pre,
                             CONS(STATEMENT, node_scan_loop,
                             CONS(STATEMENT, n_post,
                                  NIL))));
    *psn = make_block_statement(
        CONS(STATEMENT, generate_optional_if
             (condition, make_block_statement(CONS(STATEMENT, node_defproc,
                                              CONS(STATEMENT, 
                         generate_optional_if(proc_cond, node_tmp), NIL)))),
        CONS(STATEMENT, n_cont, NIL)));
 
    sc_rm(proc_cond_tmp), sc_rm(proc_cond);
 
    comment = strdup(concatenate("! ", 
                                 movement_update_p(move) ? "updating" : "collecting",
                                 " distributed variable ",
                                 entity_local_name(array), "\n", NULL));
 
    insert_comments_to_statement(*psh, comment);
    insert_comments_to_statement(*psn, comment);
    free(comment);
    
    comment = strdup(concatenate("! end of ",
                                 movement_update_p(move) ? "update" : "collect",
                                 "\n", NULL));
    insert_comments_to_statement(h_cont, comment);
    /* Do not forget to move forbidden information associated with
       block: */
    insert_comments_to_statement(n_cont, comment);
    free(comment);
    
    DEBUG_STAT(5, "Host", *psh);
    DEBUG_STAT(5, "Node", *psn);
}

References array, array_to_processors, comment(), concatenate(), CONS, DEBUG_STAT, define_node_processor_id(), divide, entity_local_name(), entity_to_declaration_constraints(), extract_nredund_subsystem(), free(), generate_deducables(), generate_optional_if(), get_ith_processor_dummy(), hpfc_name_to_entity(), IDIVIDE, insert_comments_to_statement(), make_block_statement(), make_empty_statement, movement_update_p, NIL, sc_dup(), sc_rm(), STATEMENT, statement_undefined, strdup(), and systeme_to_loop_nest().

Here is the call graph for this function:

host_section_p()

static bool host_section_p ( list  ls )

static

true if the first statement of a block is a host section marker.

looks like a hack. should be managed in directives.c...

Parameters

ls	of statement

Definition at line 63 of file io-util.c.

{
    if (gen_length(ls)>=1)
    {
        instruction one = statement_instruction(STATEMENT(CAR(ls)));
        if (instruction_call_p(one))
            return same_string_p
                (entity_local_name(call_function(instruction_call(one))), 
                 HPF_PREFIX HOSTSECTION_SUFFIX);
    }
 
    return false;
}

References call_function, CAR, entity_local_name(), gen_length(), HOSTSECTION_SUFFIX, HPF_PREFIX, instruction_call, instruction_call_p, same_string_p, STATEMENT, and statement_instruction.

Referenced by only_io_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_hcast()

static statement hpfc_hcast ( entity  array )

static

static statement hpfc_hcast()

  PVM_CAST(NBTASKS, NODETIDS, MCASTHOST, INFO)
  MCASTHOST = MCASTHOST + 2

Definition at line 247 of file io-util.c.

{
    return make_block_statement(
        CONS(STATEMENT, hpfc_packing_of_current__buffer(array, true),
        CONS(STATEMENT, 
             hpfc_make_call_statement(hpfc_name_to_entity(HPFC_HCAST), NIL),
             NIL)));
}

References array, CONS, HPFC_HCAST, hpfc_make_call_statement(), hpfc_name_to_entity(), hpfc_packing_of_current__buffer(), make_block_statement(), NIL, and STATEMENT.

Referenced by generate_io_statements_for_shared_arrays().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_hmessage()

static statement hpfc_hmessage ( entity  array, entity  proc, bool  send  )

static

T_LID=CMP_LID(pn, pi...) ? init buffer...

/ CALL (type) PACK... CALL HPFC {SND TO,RCV FROM} NODE(T_LID) / CALL (type) UPCK...

statement

Definition at line 181 of file io-util.c.

{
    entity ld;
    expression lid;
    statement cmp_lid, comm, pack;
    list /* statement */ lp, ls;
 
    ld = hpfc_name_to_entity(T_LID);
    lid = entity_to_expression(ld);
    cmp_lid = hpfc_compute_lid(ld, proc, (entity (*)())get_ith_processor_dummy, NULL);
 
    lp = CONS(STATEMENT, cmp_lid, NIL);
 
    if (!send)
        lp = CONS(STATEMENT, hpfc_buffer_initialization(false, false, false), 
                  lp);
 
    comm = hpfc_make_call_statement(hpfc_name_to_entity(
        send? HPFC_sH2N: HPFC_rN2H), CONS(EXPRESSION, lid, NIL));
 
    pack = hpfc_packing_of_current__buffer(array, send);
 
    if (send)
        ls = CONS(STATEMENT, pack, CONS(STATEMENT, comm, NIL));
    else
        ls = CONS(STATEMENT, comm, CONS(STATEMENT, pack, NIL));
 
    return make_block_statement(gen_nconc(lp, ls));
}

References array, CONS, entity_to_expression(), EXPRESSION, gen_nconc(), get_ith_processor_dummy(), hpfc_buffer_initialization(), hpfc_compute_lid(), hpfc_make_call_statement(), hpfc_name_to_entity(), hpfc_packing_of_current__buffer(), HPFC_rN2H, HPFC_sH2N, make_block_statement(), NIL, STATEMENT, and T_LID.

Here is the call graph for this function:

hpfc_io_util_error_handler()

void hpfc_io_util_error_handler

(

void

)

??? neglect expression side effects...

Definition at line 82 of file io-util.c.

{
    error_reset_current_statement_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

hpfc_nrecv()

static statement hpfc_nrecv ( entity  array, bool  cast  )

static

! init buffer CALL HPFC {RCV FROM HOST, NCAST} CALL (type) BUFFER UNPACK

from host

Definition at line 218 of file io-util.c.

{
    return make_block_statement(
        CONS(STATEMENT, hpfc_buffer_initialization(false, false, false),
        CONS(STATEMENT, hpfc_make_call_statement
             (hpfc_name_to_entity(cast? HPFC_NCAST: HPFC_rH2N), NIL),
        CONS(STATEMENT, hpfc_packing_of_current__buffer(array, false),
             NIL))));
}

References array, CONS, hpfc_buffer_initialization(), hpfc_make_call_statement(), hpfc_name_to_entity(), HPFC_NCAST, hpfc_packing_of_current__buffer(), HPFC_rH2N, make_block_statement(), NIL, and STATEMENT.

Referenced by generate_io_statements_for_shared_arrays().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_nsend()

static statement hpfc_nsend ( entity  array )

static

PVM_SEND(HOST_TID, HOST SND CHANNEL, INFO) HOST SND CHANNEL += 2.

Definition at line 233 of file io-util.c.

{
    return make_block_statement(
        CONS(STATEMENT, hpfc_packing_of_current__buffer(array, true),
        CONS(STATEMENT, hpfc_make_call_statement
             (hpfc_name_to_entity(HPFC_sN2H), NIL),
             NIL)));
}

References array, CONS, hpfc_make_call_statement(), hpfc_name_to_entity(), hpfc_packing_of_current__buffer(), HPFC_sN2H, make_block_statement(), NIL, and STATEMENT.

Here is the call graph for this function:

only_io_call()

static void only_io_call ( call  c )

static

Fortran IO intrinsics

declared with FCD

runtime managed

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

{
    entity f = call_function(c);
    intptr_t is_io = entity_continue_p(f)? 3:
                io_intrinsic_p(f) ||     /* Fortran IO intrinsics */
                    hpfc_special_io(f) ||    /* declared with FCD */
                        hpfc_io_like_function(f);/* runtime managed */
 
    pips_debug(5, "call %p (%s): %"PRIdPTR"\n", c, entity_name(f), is_io);
    Store(current_statement_head(), is_io);
}

References call_function, entity_continue_p(), entity_name, f(), hpfc_io_like_function(), hpfc_special_io(), intptr_t, io_intrinsic_p(), pips_debug, and Store.

Referenced by only_io_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

only_io_loop()

static void only_io_loop ( loop  l )

static

Definition at line 110 of file io-util.c.

{
    intptr_t is_io = Load(loop_body(l));
    pips_debug(5, "loop %p: %"PRIdPTR"\n", l, is_io);
    Store(current_statement_head(), is_io);
}

References intptr_t, Load, loop_body, pips_debug, and Store.

Referenced by only_io_mapping().

Here is the caller graph for this function:

only_io_mapping()

static statement_mapping only_io_mapping ( statement  program, statement_mapping  map  )

static

Definition at line 142 of file io-util.c.

{
    stat_bool_map = map;
 
    make_current_statement_stack();
    gen_multi_recurse(program, 
       statement_domain, current_statement_filter, current_statement_rewrite,
       loop_domain, gen_true, only_io_loop,
       test_domain, gen_true, only_io_test,
       sequence_domain, gen_true, only_io_sequence,
       call_domain, gen_true, only_io_call,
       unstructured_domain, gen_true, only_io_unstructured,
       expression_domain, gen_false, gen_null,
       NULL);
    free_current_statement_stack();
    return stat_bool_map;
}

References call_domain, expression_domain, gen_false(), gen_multi_recurse(), gen_null(), gen_true(), loop_domain, only_io_call(), only_io_loop(), only_io_sequence(), only_io_test(), only_io_unstructured(), sequence_domain, stat_bool_map, statement_domain, test_domain, and unstructured_domain.

Referenced by only_io_mapping_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

only_io_mapping_initialize()

void only_io_mapping_initialize

(

statement

program

)

Parameters

program

rogram

Definition at line 163 of file io-util.c.

{
    debug_on("HPFC_IO_DEBUG_LEVEL");
    set_only_io_map(only_io_mapping(program, MAKE_STATEMENT_MAPPING()));
    debug_off();
}

References debug_off, debug_on, MAKE_STATEMENT_MAPPING, only_io_mapping(), and set_only_io_map().

Referenced by set_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

only_io_sequence()

static void only_io_sequence ( sequence  q )

static

Definition at line 87 of file io-util.c.

{
    intptr_t is_io;
    if (host_section_p(sequence_statements(q)))
        is_io=1;
    else
    {
        is_io=3;
        MAP(STATEMENT, s, is_io = (is_io & Load(s)), sequence_statements(q));
    }
 
    pips_debug(5, "block %p: %"PRIdPTR"\n", q, is_io);
    Store(current_statement_head(), is_io);
}

References host_section_p(), intptr_t, Load, MAP, pips_debug, sequence_statements, STATEMENT, and Store.

Referenced by only_io_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

only_io_test()

static void only_io_test ( test  t )

static

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

{
    intptr_t is_io=3;
    is_io = (Load(test_true(t)) & Load(test_false(t)));
    pips_debug(5, "test %p: %"PRIdPTR"\n", t, is_io);
    Store(current_statement_head(), is_io);
}

References intptr_t, Load, pips_debug, Store, test_false, and test_true.

Referenced by only_io_mapping().

Here is the caller graph for this function:

only_io_unstructured()

static void only_io_unstructured ( unstructured  u )

static

Definition at line 129 of file io-util.c.

{
    intptr_t is_io = 3;
    control c = unstructured_control(u);
    list blocks = NIL;
 
    CONTROL_MAP(ct, is_io = is_io & Load(control_statement(ct)), c, blocks);
    gen_free_list(blocks);
    pips_debug(5, "unstructured %p: %"PRIdPTR"\n", u, is_io);
    Store(current_statement_head(), (void*)is_io);
}

References blocks, CONTROL_MAP, control_statement, gen_free_list(), intptr_t, Load, NIL, pips_debug, Store, and unstructured_control.

Referenced by only_io_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

stat_bool_map

statement_mapping stat_bool_map = hash_table_undefined

static

HPFC module by Fabien COELHO.

this is enough for the distribution purpose, because more clever analysis would be as checking for the distributablity of the enclosed code. A distribution code dedicated to IO will be implemented later on. only io encoding: 0 - not an IO 1 - is an IO 3 - may be considered as an IO along real IO functions...

Definition at line 51 of file io-util.c.

Referenced by only_io_mapping().