wp65.c File Reference

#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "dg.h"
#include "graph.h"
#include "matrice.h"
#include "tiling.h"
#include "database.h"
#include "text.h"
#include "misc.h"
#include "properties.h"
#include "text-util.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "resources.h"
#include "pipsdbm.h"
#include "movements.h"
#include "effects-generic.h"
#include "effects-convex.h"
#include "top-level.h"
#include "control.h"
#include "wp65.h"

Include dependency graph for wp65.c:

Go to the source code of this file.

Typedefs
typedef dg_arc_label	arc_label
	Code Generation for Distributed Memory Machines. More...
typedef dg_vertex_label	vertex_label

Functions
static void	unary_into_binary_ref (reference ref)
static void	translate_unary_into_binary_ref (statement stat)
entity	MakeEntityFunction (string sname)
bool	wp65 (const string input_module_name)
void	module_to_wp65_modules (entity module, statement module_code, graph dg, int pn, int bn, int ls, int pd, entity *pcompute_module, statement *pcomputational, entity *pmemory_module, statement *pemulator)
void	fprint_wp65_hash_tables (FILE *fd, hash_table llv_to_lcr, hash_table r_to_llv, hash_table v_to_lllv, hash_table r_to_ud, hash_table v_to_esv)
	Ignore this function: debugging purposes only. More...
bool	wp65_conform_p (statement s)

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

Code Generation for Distributed Memory Machines.

Higher level functions

File: wp65.c

PUMA, ESPRIT contract 2701

Francois Irigoin, Corinne Ancourt, Lei Zhou 1991

Definition at line 49 of file wp65.c.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 50 of file wp65.c.

Function Documentation

fprint_wp65_hash_tables()

void fprint_wp65_hash_tables	(	FILE *	fd,
		hash_table	llv_to_lcr,
		hash_table	r_to_llv,
		hash_table	v_to_lllv,
		hash_table	r_to_ud,
		hash_table	v_to_esv
	)

Ignore this function: debugging purposes only.

Parameters

fd	d
llv_to_lcr	lv_to_lcr
r_to_llv	_to_llv
v_to_lllv	_to_lllv
r_to_ud	_to_ud
v_to_esv	_to_esv

Definition at line 406 of file wp65.c.

{
    fputs("\nKey mappings for WP65:\n\n", fd);
 
    fputs("Mapping llv_to_lcr from list of local variables to conflicting references:\n", 
          fd);
    HASH_MAP(llv, lcr,
         {
             list llvl=(list) llv;
          list lcrl= (list) lcr;
           for(; !ENDP(llvl); POP(llvl)) {
               entity lv = ENTITY(CAR(llvl));
               fputs(entity_local_name(lv), fd);
               if(ENDP(CDR(llvl)))
                   (void) putc(' ', fd);
               else
                   (void) putc(',', fd);
           }
          fputs("\t->\t",fd);
          for(; !ENDP(lcrl); POP(lcrl)) {
              reference r = REFERENCE(CAR(lcrl));
              fprint_reference(fd, r);
              if(ENDP(CDR(lcrl)))
                  (void) putc('\n', fd);
              else
                  (void) putc(',', fd);
          }
      },
             llv_to_lcr);
 
    fputs("\nMapping r_to_llv from a reference to a list of local variables:\n", 
          fd);
    HASH_MAP(r, llv,
         {  list llvl=(list) llv;
           fprint_reference(fd, (reference) r);
             fputs("\t->\t",fd);
             for(; !ENDP(llvl); POP(llvl)) {
                 entity lv = ENTITY(CAR(llvl));
                 fputs(entity_local_name(lv), fd);
                 if(ENDP(CDR(llvl)))
                     (void) putc(' ', fd);
                 else
                     (void) putc(',', fd);
             }
             (void) putc('\n', fd);
         },
             r_to_llv);
 
    fputs("\nMapping v_to_lllv from variables to lists of lists of local variables:\n",
          fd);
    HASH_MAP(v, lllv,
         {  list lllvl=(list)lllv;
           (void) fprintf(fd,"%s\t->\t", entity_name((entity) v));
           for(; !ENDP(lllvl); POP(lllvl)) {
               list llv = LIST(CAR(lllvl));
               (void) putc('(',fd);
               for(; !ENDP(llv); POP(llv)) {
                   fputs(entity_local_name(ENTITY(CAR(llv))), fd);
                   if(ENDP(CDR(llv)))
                       (void) putc(')', fd);
                   else
                       (void) putc(',', fd);
               }
               if(ENDP(CDR(lllvl)))
                   (void) putc('\n', fd);
               else
                   (void) putc(',',fd);
           }
       },
             v_to_lllv);
 
 
    fputs("\nMapping r_to_ud from references to use-def:\n", fd);
    HASH_MAP(r, use_def,
         {
           fprint_reference(fd, (reference) r);
           fputs("\t->\t",fd);
             fputs(((intptr_t) use_def == (intptr_t)is_action_read) ? "use\n" : "def\n", fd);
       },
             r_to_ud);
 
 
    fputs("\nMapping v_to_esv from variables to emulated shared variables:\n",
          fd);
    HASH_MAP(v, esv,
         {
           (void) fprintf(fd,"%s\t->\t", entity_name((entity) v));
           (void) fprintf(fd,"%s\n", entity_name((entity) esv));
       },
             v_to_esv);
 
    (void) putc('\n', fd);
}

References CAR, CDR, ENDP, ENTITY, entity_local_name(), entity_name, fprint_reference(), fprintf(), HASH_MAP, intptr_t, is_action_read, LIST, POP, and REFERENCE.

Referenced by loop_nest_to_wp65_code().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeEntityFunction()

entity MakeEntityFunction

(

string

sname

)

Parameters

sname

name

Definition at line 101 of file wp65.c.

{
    entity f = make_empty_function(sname, MakeIntegerResult(), make_language_unknown());
    return f;
}

References f(), make_empty_function(), make_language_unknown(), and MakeIntegerResult().

Referenced by module_to_wp65_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

module_to_wp65_modules()

void module_to_wp65_modules	(	entity	module,
		statement	module_code,
		graph	dg,
		int	pn,
		int	bn,
		int	ls,
		int	pd,
		entity *	pcompute_module,
		statement *	pcomputational,
		entity *	pmemory_module,
		statement *	pemulator
	)

variable to emulated shared variable

To establish an occurence numbering accross loop nests

Generate two new modules, compute module and memory module

Generate scalar variables that are going to be used all over the compute and memory module

variables related to bank emulation are put together in one basis to decrease the number of parameters; they are used as such when liner systems of constraints are built

skip a potential useless unstructured

generate code for each loop nest in the module and append it to computational and emulator

kill_statement_number_and_ordering(computational); kill_statement_number_and_ordering(emulator);

return results

Parameters

module	odule
module_code	odule_code
dg	g
pn	dependence graph
bn	processor_number
ls	bank number
pd	line size
pcompute_module	pipeline depth
pcomputational	computational
pmemory_module	memory_module
pemulator	emulator

Definition at line 202 of file wp65.c.

{
    string compute_module_name;
    string memory_module_name;
    instruction i = instruction_undefined;
    list l = list_undefined;
    entity proc_id = entity_undefined;
    entity proc_id_mm = entity_undefined;
    entity bank_id = entity_undefined;
    entity bank_line = entity_undefined;
    entity bank_offset = entity_undefined;
    Pbase bank_indices = BASE_NULLE;
    statement fs = statement_undefined;
 
    /* variable to emulated shared variable */
    hash_table v_to_esv = hash_table_make(hash_pointer,0);
    /* To establish an occurence numbering accross loop nests */
    hash_table v_to_nlv = hash_table_make(hash_pointer, 0);
 
    entity compute_module;
    statement computational;
    entity memory_module;
    statement emulator;
    statement_mapping fetch_map= MAKE_STATEMENT_MAPPING();
    statement_mapping store_map= MAKE_STATEMENT_MAPPING();
    entity div;
 
    debug(6,"module_to_wp65_modules","begin\n");
 
    /*       Generate two new modules, compute module and memory module
     */
    compute_module_name = strdup(COMPUTE_ENGINE_NAME);
    compute_module = make_empty_subroutine(compute_module_name,copy_language(module_language(module)));
 
    module_functional_parameters(compute_module)
        = CONS(PARAMETER, make_parameter(MakeTypeVariable(make_basic_int(4), NIL),
                                         make_mode(is_mode_reference, UU),
                                         make_dummy_unknown()),
               NIL);
 
    memory_module_name = strdup(BANK_NAME);
    memory_module = make_empty_subroutine(memory_module_name,copy_language(module_language(module)));
 
    module_functional_parameters(memory_module)
        = CONS(PARAMETER, 
               make_parameter(MakeTypeVariable(make_basic_int(
                                                          4), NIL),
                              make_mode(is_mode_reference, UU),
                              make_dummy_unknown()),
               NIL);
    computational = make_block_statement(NIL);
    emulator = make_block_statement(NIL);
 
    div =MakeEntityFunction("idiv");
    AddEntityToDeclarations(div,compute_module);
    AddEntityToDeclarations(div,memory_module);
 
  
    /* Generate scalar variables that are going to be used all over
       the compute and memory module
       */
    proc_id_mm = make_scalar_integer_entity(PROCESSOR_IDENTIFIER,
                                            entity_local_name(memory_module));
    AddEntityToDeclarations( proc_id_mm,memory_module);
 
    proc_id = make_scalar_integer_entity(PROCESSOR_IDENTIFIER,
                                         entity_local_name(compute_module));
    entity_storage(proc_id) = make_storage(is_storage_formal, 
                                           make_formal(compute_module, 1));
    AddEntityToDeclarations( proc_id,compute_module);
 
    bank_id = make_scalar_integer_entity(BANK_IDENTIFIER,
                                         entity_local_name(compute_module));
    AddEntityToDeclarations( bank_id,compute_module);
 
    bank_id = make_scalar_integer_entity(BANK_IDENTIFIER,
                                         entity_local_name(memory_module));
    entity_storage(bank_id) = make_storage(is_storage_formal, 
                                           make_formal(memory_module, 1)); 
    AddEntityToDeclarations( bank_id,memory_module);
 
    bank_line = make_scalar_integer_entity(BANK_LINE_IDENTIFIER,
                                           entity_local_name(compute_module)); 
    AddEntityToDeclarations( bank_line,compute_module); 
 
    bank_line = make_scalar_integer_entity(BANK_LINE_IDENTIFIER,
                                           entity_local_name(memory_module));
    AddEntityToDeclarations( bank_line,memory_module);
 
    bank_offset = make_scalar_integer_entity(BANK_OFFSET_IDENTIFIER,
                                             entity_local_name(memory_module));
    AddEntityToDeclarations( bank_offset,memory_module);
    bank_offset = make_scalar_integer_entity(BANK_OFFSET_IDENTIFIER,
                                             entity_local_name(compute_module));
    AddEntityToDeclarations( bank_offset,compute_module);
    /* variables related to bank emulation are put together in one basis
       to decrease the number of parameters; they are used as such when
       liner systems of constraints are built */
    bank_indices = 
        vect_add_variable(vect_add_variable(vect_add_variable(BASE_NULLE,
                                                              (char*) 
                                                              bank_offset),
                                            (char *) bank_line),
                          (char *) bank_id);
 
    ifdebug(6) {
        (void) fprintf(stderr,"Bank indices:\n");
        vect_fprint(stderr, bank_indices, (string(*)(void*))entity_local_name);
        (void) fprintf(stderr,"Code for the computational module:\n");
        wp65_debug_print_module(compute_module,computational);
        (void) fprintf(stderr,"Code for the memory module:\n");
        wp65_debug_print_module(memory_module,emulator);
    }
 
 
    /* skip a potential useless unstructured */
    i = statement_instruction(module_code);
    if (instruction_unstructured_p(i)) {
        unstructured u = instruction_unstructured(i);
        control c = unstructured_control(u);
        i = statement_instruction(control_statement(c));
    }
 
    /* generate code for each loop nest in the module and append it
       to computational and emulator */
    l = instruction_block(i); 
 
    compute_communications(l,&fetch_map,&store_map);
  
    instruction_to_wp65_code(module,l, dg, 
                             pn, bn, ls, pd,
                             proc_id, proc_id_mm, bank_indices,
                             v_to_esv, v_to_nlv,
                             compute_module, computational,
                             memory_module, emulator, fetch_map,store_map);
 
    i = statement_instruction(computational);
    instruction_block(i) = gen_nconc(instruction_block(i), 
                                     CONS(STATEMENT, 
                                          make_return_statement(compute_module), 
                                          NIL));
    i = statement_instruction(emulator);
    instruction_block(i) = gen_nconc(instruction_block(i), 
                                     CONS(STATEMENT, 
                                          make_return_statement(memory_module),
                                          NIL));
 
  
    fs = STATEMENT(CAR(instruction_block(statement_instruction(computational))));
    statement_comments(fs) = 
        strdup(concatenate("\nC     WP65 DISTRIBUTED CODE FOR ",
                           module_local_name(module), "\n",
                           (string_undefined_p(statement_comments(fs)) 
                            ? NULL :statement_comments(fs)),
                           NULL));
    module_reorder(fs);
    fs = STATEMENT(CAR(instruction_block(statement_instruction(emulator))));
    statement_comments(fs) =
        strdup(concatenate("\nC     BANK DISTRIBUTED CODE FOR ",
                           module_local_name(module), "\n",
                           (string_undefined_p(statement_comments(fs)) 
                            ? NULL :statement_comments(fs)),
                           NULL));
    module_reorder(fs);
    /* kill_statement_number_and_ordering(computational);
    kill_statement_number_and_ordering(emulator);*/
    
 
    ifdebug(1) {
        (void) fprintf(stderr,"Final code for the computational module:\n");
        wp65_debug_print_module(compute_module,computational);
        (void) fprintf(stderr,"Final code for the memory module:\n");
        wp65_debug_print_module(memory_module,emulator);
    }
 
    hash_table_free(v_to_esv);
    hash_table_free(v_to_nlv);
   
    /* return results */
    * pcompute_module = compute_module;
    * pcomputational = computational;
    * pmemory_module = memory_module;
    * pemulator = emulator;
 
    debug(6,"module_to_wp65_modules","end\n");
 
}

References AddEntityToDeclarations(), BANK_IDENTIFIER, BANK_LINE_IDENTIFIER, BANK_NAME, BANK_OFFSET_IDENTIFIER, BASE_NULLE, CAR, compute_communications(), COMPUTE_ENGINE_NAME, concatenate(), CONS, control_statement, copy_language(), debug(), dg, entity_local_name(), entity_storage, entity_undefined, fprintf(), gen_nconc(), hash_pointer, hash_table_free(), hash_table_make(), ifdebug, instruction_block, instruction_to_wp65_code(), instruction_undefined, instruction_unstructured, instruction_unstructured_p, is_mode_reference, is_storage_formal, list_undefined, make_basic_int(), make_block_statement(), make_dummy_unknown(), make_empty_subroutine(), make_formal(), make_mode(), make_parameter(), make_return_statement(), make_scalar_integer_entity(), MAKE_STATEMENT_MAPPING, make_storage(), MakeEntityFunction(), MakeTypeVariable(), module, module_functional_parameters, module_language, module_local_name(), module_reorder(), NIL, PARAMETER, PROCESSOR_IDENTIFIER, STATEMENT, statement_comments, statement_instruction, statement_undefined, strdup(), string_undefined_p, unstructured_control, UU, vect_add_variable(), vect_fprint(), and wp65_debug_print_module().

Referenced by wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_unary_into_binary_ref()

static void translate_unary_into_binary_ref ( statement  stat )

static

Definition at line 88 of file wp65.c.

{
    gen_recurse(stat, reference_domain, gen_true, unary_into_binary_ref);
    ifdebug(8) {  
        entity module =get_current_module_entity();
        fprintf(stderr,"statement without unary references \n");
        wp65_debug_print_text(module,stat);
    }
 
} 

References fprintf(), gen_recurse, gen_true(), get_current_module_entity(), ifdebug, module, reference_domain, unary_into_binary_ref(), and wp65_debug_print_text().

Referenced by wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

unary_into_binary_ref()

static void unary_into_binary_ref ( reference  ref )

static

Definition at line 78 of file wp65.c.

{
    list lt; 
    if (gen_length((lt = reference_indices(ref))) ==1) {
        expression expr = int_to_expression(1);
        reference_indices(ref)= CONS(EXPRESSION, EXPRESSION(CAR(lt)),
                                     CONS(EXPRESSION,expr,NIL));
    }
}

References CAR, CONS, EXPRESSION, gen_length(), int_to_expression(), NIL, ref, and reference_indices.

Referenced by translate_unary_into_binary_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

wp65()

bool wp65

(

const string

input_module_name

)

Let's modify the old code instead of copy it but do not tell pipsdbm; else we would get a copy of the code, not consistent with the dependence graph

fprintf(stderr,"refs du code\n"); debug_refs(s); fprintf(stderr,"refs du dg\n"); debug_refs(dg);

fprintf(stderr,"refs du code\n"); debug_refs(s); fprintf(stderr,"refs du dg\n"); debug_refs(dg);

Put final code for the computational module in a text resource of the database

Put final code for the memory module in a text resource of the database

reset_current_module_statement();

Parameters

input_module_name

nput_module_name

Definition at line 128 of file wp65.c.

{
    entity module = module_name_to_entity(input_module_name);
    /* Let's modify the old code instead of copy it but do not tell
       pipsdbm; else we would get a *copy* of the code, not consistent
       with the dependence graph */
    statement s;
    entity compute_module = entity_undefined;
    statement computational = statement_undefined;
    entity memory_module = entity_undefined;
    statement emulator = statement_undefined;
    int pn, bn, ls, pd = PIPELINE_DEPTH;
    graph dg;
    string ppp;
 
    s = (statement) db_get_memory_resource(DBR_CODE, input_module_name,true);
    dg = (graph) db_get_memory_resource(DBR_DG, input_module_name, true);
    set_ordering_to_statement(s);
    debug_on("WP65_DEBUG_LEVEL");
    debug(8, "wp65", "begin\n");
 
    get_model(&pn, &bn, &ls);
    ifdebug(1) model_fprint(stderr, pn, bn ,ls);
 
    regions_init();
    set_current_module_entity(module);
    ppp = strdup(get_string_property(PRETTYPRINT_PARALLEL));
    set_string_property(PRETTYPRINT_PARALLEL, "doall");
 
    /*    fprintf(stderr,"refs du code\n"); debug_refs(s);
          fprintf(stderr,"refs du dg\n"); debug_refs(dg); */
 
    translate_unary_into_binary_ref(s);      
 
    /* fprintf(stderr,"refs du code\n"); debug_refs(s); 
       fprintf(stderr,"refs du dg\n"); debug_refs(dg); */
 
    module_to_wp65_modules(module, s, dg,
                           pn, bn, ls, pd, 
                           &compute_module, &computational, 
                           &memory_module, &emulator);
    
    (void) variable_declaration_coherency_p(compute_module,computational);
    (void) variable_declaration_coherency_p(memory_module,emulator);
 
  
    /* Put final code for the computational module in a text resource 
       of the database */
    init_prettyprint(empty_text);
    make_text_resource(input_module_name,
                       DBR_WP65_COMPUTE_FILE, 
                       WP65_COMPUTE_EXT,
                       text_module(compute_module,computational));
    close_prettyprint();
 
    /* Put final code for the memory module in a text resource 
       of the database */
    make_text_resource(input_module_name,
                       DBR_WP65_BANK_FILE, 
                       WP65_BANK_EXT,
                       text_module(memory_module,emulator));
 
    debug(8, "wp65", "end\n");
 
    /* reset_current_module_statement(); */
    reset_ordering_to_statement();
    reset_current_module_entity();
    set_string_property(PRETTYPRINT_PARALLEL, ppp); free(ppp);
    debug_off();
 
return true;
 
}

References close_prettyprint(), db_get_memory_resource(), debug(), debug_off, debug_on, dg, empty_text(), entity_undefined, free(), get_model(), get_string_property(), ifdebug, init_prettyprint(), make_text_resource(), model_fprint(), module, module_name_to_entity(), module_to_wp65_modules(), PIPELINE_DEPTH, PRETTYPRINT_PARALLEL, regions_init(), reset_current_module_entity(), reset_ordering_to_statement(), set_current_module_entity(), set_ordering_to_statement(), set_string_property(), statement_undefined, strdup(), text_module(), translate_unary_into_binary_ref(), and variable_declaration_coherency_p().

Here is the call graph for this function:

wp65_conform_p()

bool wp65_conform_p

(

statement

s

)

there should be only one instruction: do not put a STOP in the source file

Definition at line 508 of file wp65.c.

{
    instruction i = statement_instruction(s);
 
    if (instruction_unstructured_p(i)) {
        /* there should be only one instruction: do not put a STOP in the
           source file */
        unstructured u = instruction_unstructured(i);
        control c = unstructured_control(u);
        if(control_predecessors(c) == NIL && control_successors(c) == NIL) {
            i = statement_instruction(control_statement(c));
        }
        else {
            debug(1,"wp65_conform_p",
                  "program body is an unstructured with at least two nodes\n");
            return false;
        }
    }
 
    if(!instruction_block_p(i)) {
        debug(1,"wp65_conform_p","program body is not a block\n");
        return false;
    }
    else {
        list ls = instruction_block(i);
        MAPL(pm,{
            statement s1 = STATEMENT(CAR(pm));
            if(!assignment_statement_p(s1) && !perfectly_nested_loop_p(s1)) {
                if(!stop_statement_p(s1) && !return_statement_p(s1)) {
                    debug(1,"wp65_conform_p",
                          "program body contains a non-perfectly nested loop\n");
                    return false;
                }
            }
        },ls);
    }
    return true;
}

References assignment_statement_p(), CAR, control_predecessors, control_statement, control_successors, debug(), instruction_block, instruction_block_p, instruction_unstructured, instruction_unstructured_p, MAPL, NIL, perfectly_nested_loop_p(), return_statement_p(), s1, STATEMENT, statement_instruction, stop_statement_p(), and unstructured_control.

Here is the call graph for this function: