inits.c File Reference

#include "defines-local.h"

Include dependency graph for inits.c:

Go to the source code of this file.

Functions
void	create_common_parameters_h (FILE *file)
	Fabien Coelho, June 1993. More...
void	create_parameters_h (FILE *file, entity module)
	create_parameters_h More...
int	max_size_of_processors ()
static int	code_number (tag t)
	translation from an hpf_newdecl tag to the runtime code expected More...
void	create_init_common_param_for_arrays (FILE *file, entity module)
void	create_init_common_param_for_templates (FILE *file)
void	create_init_common_param_for_processors (FILE *file)
void	create_init_common_param (FILE *file)
	create_init_common_param (templates and modules) More...

Function Documentation

code_number()

static int code_number ( tag  t )

static

translation from an hpf_newdecl tag to the runtime code expected

just to avoid a gcc warning

Definition at line 141 of file inits.c.

{
    switch(t)
    {
    case is_hpf_newdecl_none: return 0;
    case is_hpf_newdecl_alpha: return 1;
    case is_hpf_newdecl_beta: return 2;
    case is_hpf_newdecl_gamma: return 3;
    case is_hpf_newdecl_delta: return 4;
    default: 
        pips_internal_error("unexpected hpf_newdecl tag %d", t);
    }
    
    return -1; /* just to avoid a gcc warning */
}

References is_hpf_newdecl_alpha, is_hpf_newdecl_beta, is_hpf_newdecl_delta, is_hpf_newdecl_gamma, is_hpf_newdecl_none, and pips_internal_error.

Referenced by create_init_common_param_for_arrays().

Here is the caller graph for this function:

create_common_parameters_h()

void create_common_parameters_h

(

FILE *

file

)

Fabien Coelho, June 1993.

inits.c

in this file there are functions to generate the run-time resolution parameters.

Parameters

file

ile

Definition at line 36 of file inits.c.

{
    fprintf(file,
            "      integer\n"
            "     $     REALNBOFARRAYS,\n"
            "     $     REALNBOFTEMPLATES,\n"
            "     $     REALNBOFPROCESSORS,\n"
            "     $     REALMAXSIZEOFPROCS,\n"
            "     $     REALMAXSIZEOFBUFFER\n\n"
            "!\n! parameters\n!\n"
            "      parameter(REALNBOFARRAYS = %d)\n"
            "      parameter(REALNBOFTEMPLATES = %d)\n"
            "      parameter(REALNBOFPROCESSORS = %d)\n"
            "      parameter(REALMAXSIZEOFPROCS = %d)\n"
            "      parameter(REALMAXSIZEOFBUFFER = %d)\n",
            number_of_distributed_arrays(),
            number_of_templates(),
            number_of_processors(),
            max_size_of_processors(),
            get_int_property("HPFC_BUFFER_SIZE"));
}

References fprintf(), get_int_property(), max_size_of_processors(), number_of_distributed_arrays(), number_of_processors(), and number_of_templates().

Referenced by put_generated_resources_for_program().

Here is the call graph for this function:

Here is the caller graph for this function:

create_init_common_param()

void create_init_common_param

(

FILE*

file

)

create_init_common_param (templates and modules)

Parameters

file

ile

Definition at line 511 of file inits.c.

{
    create_init_common_param_for_templates(file);
    create_init_common_param_for_processors(file);
}

References create_init_common_param_for_processors(), and create_init_common_param_for_templates().

Referenced by put_generated_resources_for_program().

Here is the call graph for this function:

Here is the caller graph for this function:

create_init_common_param_for_arrays()

void create_init_common_param_for_arrays	(	FILE*	file,
		entity	module
	)

NODIMA: Number Of DIMensions of an Array ATOT: Array TO Template

The primary entity is the initial mapping ??? not sure... some decision should be involved...

RANGEA: lower, upper, size and declaration, aso

RANGEA contents:

1: lower bound 2: upper bound 3: size, (2)-(1)+1 4: new declaration flag

5: distribution parameter n, 6: alignment rate a, 7: alignment shift, b-t_{m}

5: distribution parameter n, 6: cycle length n*p, 7: initial cycle number, 8: alignment shift, b-t_{m}

5: distribution parameter n 6: cycle length n*p, 7: initial cycle number, 8: alignment shift, b-t_{m} 9: alignment rate a, 10: chunck size ceil(n,|a|)

ALIGN

Parameters

file	ile
module	odule

Definition at line 158 of file inits.c.

{
    list l = list_of_distributed_arrays_for_module(module);
    
    fprintf(file, "!\n! Arrays Initializations for %s\n!\n",
            module_local_name(module));
 
    MAP(ENTITY, array,
    {
        int an = load_hpf_number(array);
        int nd = NumberOfDimension(array);
        align al = load_hpf_alignment(array);
        entity template = align_template(al);
        int tn = load_hpf_number(template);
        distribute di = load_hpf_distribution(template);
        int i;
        
        /* NODIMA: Number Of  DIMensions of an Array
         * ATOT: Array TO Template
         */
        fprintf(file, 
                "!\n! initializing array %s, number %d\n!\n"
                "      NODIMA(%d) = %d\n"
                "      ATOT(%d) = %d\n",
                entity_local_name(array), an, an, nd, an, tn);
 
        if (dynamic_entity_p(array) && array==load_primary_entity(array))
        {
            /* The primary entity is the initial mapping ???
             * not sure... some decision should be involved...
             */
            fprintf(file, "\n"
                    "      MSTATUS(%d) = %d\n"
                    "      LIVEMAPPING(%d) = .TRUE.\n", an, an, an);
        }
        
        /* RANGEA: lower, upper, size and declaration, aso
         */
        i = 1;
        for (i=1; i<=nd; i++)
        {
            dimension d = entity_ith_dimension(array, i);
            int lb = HpfcExpressionToInt(dimension_lower(d));
            int ub = HpfcExpressionToInt(dimension_upper(d));
            int sz = (ub-lb+1);
            tag decl = new_declaration_tag(array, i);
            alignment a = FindAlignmentOfDim(align_alignment(al), i);
            
            /* RANGEA contents:
             *
             * 1: lower bound
             * 2: upper bound
             * 3: size, (2)-(1)+1
             * 4: new declaration flag
             */
            fprintf(file, "\n"
                    "      RANGEA(%d, %d, 1) = %d\n"
                    "      RANGEA(%d, %d, 2) = %d\n"
                    "      RANGEA(%d, %d, 3) = %d\n!\n"
                    "      RANGEA(%d, %d, 4) = %d\n", 
                    an, i, lb, an, i, ub, an, i, sz,
                    an, i, code_number(decl));
            
            switch(decl)
            {
             case is_hpf_newdecl_none:
                 break;
             case is_hpf_newdecl_alpha:
                 /*
                  * 5: 1 - lower bound
                  */
                 fprintf(file, "      RANGEA(%d, %d, 5) = %d\n", 
                         an, i, (1-lb));
                 break;
             case is_hpf_newdecl_beta:
             {
                 int tdim = alignment_templatedim(a);
                 int procdim = 0;
                 distribution
                     d = FindDistributionOfDim(distribute_distribution(di), 
                                               tdim,
                                               &procdim);
                 int param = HpfcExpressionToInt(distribution_parameter(d));
                 int rate;
                 int shift;
                 dimension 
                     dim = FindIthDimension(template, tdim);
                 
                 pips_assert("block distribution",
                             style_block_p(distribution_style(d)));
                 
                 rate = HpfcExpressionToInt(alignment_rate(a));
                 shift = (HpfcExpressionToInt(alignment_constant(a)) -
                          HpfcExpressionToInt(dimension_lower(dim)));
 
                 /* 5: distribution parameter n, 
                  * 6: alignment rate a,
                  * 7: alignment shift, b-t_{m}
                  */
                 fprintf(file, 
                         "      RANGEA(%d, %d, 5) = %d\n"
                         "      RANGEA(%d, %d, 6) = %d\n"
                         "      RANGEA(%d, %d, 7) = %d\n",
                         an, i, param, an, i, rate, an, i, shift);
                 
                 break;
             }
             case is_hpf_newdecl_gamma:
             {
                 int tdim = alignment_templatedim(a);
                 int procdim = 0;
                 distribution
                     d = FindDistributionOfDim(distribute_distribution(di), 
                                               tdim,
                                               &procdim);
                 int param = HpfcExpressionToInt(distribution_parameter(d));
                 int sc;
                 int no;
                 int shift;
                 dimension 
                     dim = FindIthDimension(template, tdim);
                 entity
                     proc = distribute_processors(di);
                 
                 pips_assert("cyclic distribution",
                             style_cyclic_p(distribution_style(d)));
                 
                 sc = param*SizeOfIthDimension(proc, procdim);
                 shift = (HpfcExpressionToInt(alignment_constant(a)) -
                          HpfcExpressionToInt(dimension_lower(dim)));
                 no = (lb + shift) / sc ;
                 
                 /* 5: distribution parameter n,
                  * 6: cycle length n*p,
                  * 7: initial cycle number,
                  * 8: alignment shift, b-t_{m}
                  */
                 fprintf(file,
                         "      RANGEA(%d, %d, 5) = %d\n"
                         "      RANGEA(%d, %d, 6) = %d\n"
                         "      RANGEA(%d, %d, 7) = %d\n"
                         "      RANGEA(%d, %d, 8) = %d\n", 
                         an, i, param, an, i, sc, an, i, no, an, i, shift);
                 
                 break;
             }
             case is_hpf_newdecl_delta:
             {
                 int tdim = alignment_templatedim(a);
                 int procdim = 0;
                 distribution
                     d = FindDistributionOfDim(distribute_distribution(di), 
                                               tdim,
                                               &procdim);
                 int rate = HpfcExpressionToInt(alignment_rate(a));
                 int cst  = HpfcExpressionToInt(alignment_constant(a));
                 int param = HpfcExpressionToInt(distribution_parameter(d));
                 int sc;
                 int no;
                 int shift;
                 int chck;                    
                 dimension 
                     templdim = FindIthDimension(template, tdim);
                 entity
                     proc = distribute_processors(di);
                 
                 pips_assert("cyclic distribution",
                             style_cyclic_p(distribution_style(d)));
                 
                 sc = param*SizeOfIthDimension(proc, procdim);
                 shift = (cst - HpfcExpressionToInt(dimension_lower(templdim)));
                 no = (rate*lb + shift) / sc ;
                 chck = iceil(param, abs(rate));
                 
                 /*  5: distribution parameter n
                  *  6: cycle length n*p,
                  *  7: initial cycle number,
                  *  8: alignment shift, b-t_{m}
                  *  9: alignment rate a,
                  * 10: chunck size ceil(n,|a|)
                  */
                 fprintf(file,
                         "      RANGEA(%d, %d, 5) = %d\n"
                         "      RANGEA(%d, %d, 6) = %d\n"
                         "      RANGEA(%d, %d, 7) = %d\n"
                         "      RANGEA(%d, %d, 8) = %d\n"
                         "      RANGEA(%d, %d, 9) = %d\n"
                         "      RANGEA(%d, %d, 10) = %d\n",
                         an, i, param, an, i, sc, an, i, no,
                         an, i, shift, an, i, rate, an, i, chck);
                 break;
             }
             default:
                 pips_internal_error("unexpected decl. tag (%d)", decl);
             }
         }
 
         fprintf(file, "\n");
 
         /* ALIGN
          */
 
         for(i=1 ; i<=NumberOfDimension(template) ; i++)
         {
             alignment
                 a = FindAlignmentOfTemplateDim(align_alignment(al), i);
 
              if (a==alignment_undefined)
              {
                  fprintf(file, "      ALIGN(%d, %d, 1) = INTFLAG\n", an, i);
              }
             else
             {
                 int adim = alignment_arraydim(a);
 
                 fprintf(file, 
                         "      ALIGN(%d, %d, 1) = %d\n"
                         "      ALIGN(%d, %d, 2) = %d\n"
                         "      ALIGN(%d, %d, 3) = %d\n", 
                         an, i, adim, an, i,
                         adim ? HpfcExpressionToInt(alignment_rate(a)) : 0,
                         an, i, HpfcExpressionToInt(alignment_constant(a)));
 
             }
          }
     },
         l);
 
    gen_free_list(l);
}

References abs, align_alignment, align_template, alignment_arraydim, alignment_constant, alignment_rate, alignment_templatedim, alignment_undefined, array, code_number(), dimension_lower, dimension_upper, distribute_distribution, distribute_processors, distribution_parameter, distribution_style, dynamic_entity_p, ENTITY, entity_ith_dimension(), entity_local_name(), FindAlignmentOfDim(), FindAlignmentOfTemplateDim(), FindDistributionOfDim(), FindIthDimension(), fprintf(), gen_free_list(), HpfcExpressionToInt(), iceil, is_hpf_newdecl_alpha, is_hpf_newdecl_beta, is_hpf_newdecl_delta, is_hpf_newdecl_gamma, is_hpf_newdecl_none, list_of_distributed_arrays_for_module(), load_hpf_alignment(), load_hpf_distribution(), load_hpf_number(), load_primary_entity(), MAP, module, module_local_name(), new_declaration_tag(), NumberOfDimension(), pips_assert, pips_internal_error, SizeOfIthDimension(), style_block_p, and style_cyclic_p.

Referenced by put_generated_resources_for_common(), and put_generated_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

create_init_common_param_for_processors()

void create_init_common_param_for_processors

(

FILE*

file

)

NODIMP: Number Of DIMensions of a Processors arrangement

RANGEP: lower, upper, size

Parameters

file

ile

Definition at line 470 of file inits.c.

{
    fprintf(file, "!\n! Processors Initializations\n!\n");
 
    MAP(ENTITY, proc,
    {
        int pn = load_hpf_number(proc);
        int nd  = NumberOfDimension(proc);
        int procdim = 1;
         
         fprintf(file, "!\n! initializing processors %s, number %d\n!\n",
                 entity_local_name(proc), pn);
 
         /* NODIMP: Number Of  DIMensions of a Processors arrangement
          */
         fprintf(file, "      NODIMP(%d) = %d\n", pn, nd);
         
         /* RANGEP: lower, upper, size 
          */
         MAP(DIMENSION, d,
         {
              int lb = HpfcExpressionToInt(dimension_lower(d));
              int ub = HpfcExpressionToInt(dimension_upper(d));
              int sz = (ub-lb+1);
 
              fprintf(file, "\n"
                      "      RANGEP(%d, %d, 1) = %d\n"
                      "      RANGEP(%d, %d, 2) = %d\n"
                      "      RANGEP(%d, %d, 3) = %d\n",
                      pn, procdim, lb, pn, procdim, ub, pn, procdim, sz);
              
              procdim++;
          },
              variable_dimensions(type_variable(entity_type(proc))));
     },
         list_of_processors());
}

References DIMENSION, dimension_lower, dimension_upper, ENTITY, entity_local_name(), entity_type, fprintf(), HpfcExpressionToInt(), list_of_processors(), load_hpf_number(), MAP, NumberOfDimension(), type_variable, and variable_dimensions.

Referenced by create_init_common_param().

Here is the call graph for this function:

Here is the caller graph for this function:

create_init_common_param_for_templates()

void create_init_common_param_for_templates

(

FILE*

file

)

NODIMT: Number Of DIMensions of a Template TTOP: Template TO Processors arrangement

RANGET: lower, upper, size

DIST

Parameters

file

ile

Definition at line 391 of file inits.c.

{
    fprintf(file, "!\n! Templates Initializations\n!\n");
 
    MAP(ENTITY, template,
    {
         int tn = load_hpf_number(template);
         int nd  = NumberOfDimension(template);
         distribute di = load_hpf_distribution(template);
         entity proc = distribute_processors(di);
         int pn = load_hpf_number(proc);
         int procdim = 1;
         int tempdim = 1;
         
         /* NODIMT: Number Of  DIMensions of a Template
          * TTOP: Template TO Processors arrangement
          */
         fprintf(file,
                 "!\n! initializing template %s, number %d\n!\n"
                 "      NODIMT(%d) = %d\n"
                 "      TTOP(%d) = %d\n", 
                 entity_local_name(template), tn, tn, nd, tn, pn);
         
         /* RANGET: lower, upper, size 
          */
         MAP(DIMENSION, d,
         {
             int lb = HpfcExpressionToInt(dimension_lower(d));
             int ub = HpfcExpressionToInt(dimension_upper(d));
             int sz = (ub-lb+1);
             
              fprintf(file, "\n"
                      "      RANGET(%d, %d, 1) = %d\n"
                      "      RANGET(%d, %d, 2) = %d\n"
                      "      RANGET(%d, %d, 3) = %d\n",
                      tn, tempdim, lb, tn, tempdim, ub, tn, tempdim, sz);
 
              tempdim++;
          },
              variable_dimensions(type_variable(entity_type(template))));
 
         /* DIST
          */
         tempdim = 1;
         fprintf(file, "\n");
         MAP(DISTRIBUTION, d,
         {
              int param;
              bool block_case = false;
 
              switch(style_tag(distribution_style(d)))
              {
              case is_style_none:
                  break;
              case is_style_block:
                  block_case = true;
                  _FALLTHROUGH_;
              case is_style_cyclic:
                  param = HpfcExpressionToInt(distribution_parameter(d));
                  if (!block_case) param = -param;
                  fprintf(file, 
                          "      DIST(%d, %d, 1) = %d\n"
                          "      DIST(%d, %d, 2) = %d\n", 
                          tn, procdim, tempdim, tn, procdim, param);
                  procdim++;
                  break;
              default:
                  pips_internal_error("unexpected style tag");
                  break;
              }
 
              tempdim++;
          },
              distribute_distribution(di));
     },
         list_of_templates());
}

References _FALLTHROUGH_, DIMENSION, dimension_lower, dimension_upper, distribute_distribution, distribute_processors, DISTRIBUTION, distribution_parameter, distribution_style, ENTITY, entity_local_name(), entity_type, fprintf(), HpfcExpressionToInt(), is_style_block, is_style_cyclic, is_style_none, list_of_templates(), load_hpf_distribution(), load_hpf_number(), MAP, NumberOfDimension(), pips_internal_error, style_tag, type_variable, and variable_dimensions.

Referenced by create_init_common_param().

Here is the call graph for this function:

Here is the caller graph for this function:

create_parameters_h()

void create_parameters_h	(	FILE *	file,
		entity	module
	)

create_parameters_h

to be called after the declaration_with_overlaps() call. it generates the parameters for module.

formal parameters are passed the value by the caller as far as overlapable dimensions are concerned.

otherwise it is a secondary copy

Parameters

file	ile
module	odule

Definition at line 65 of file inits.c.

{
    entity newarray = entity_undefined;
    int i;
    list l = list_of_distributed_arrays_for_module(module);
 
    fprintf(file, "!\n! parameters generated for %s\n!\n",
            module_local_name(module));
 
    MAP(ENTITY, array,
    {
        bool is_argument = storage_formal_p(entity_storage(array));
        int andim;
        newarray = load_new_node(array);
        andim  = NumberOfDimension(newarray);
 
        pips_debug(8, "considering array %s (new is %s)\n",
                   entity_name(array), entity_name(newarray));
 
        /* formal parameters are passed the value by the caller
         * as far as overlapable dimensions are concerned.
         */
        if (!dynamic_entity_p(array) || !bound_similar_mapping_p(array) ||
            (bound_similar_mapping_p(array) &&
             array==load_similar_mapping(array)))
            for (i=1 ; i<=andim ; i++)
            {
                if (!is_argument || !ith_dim_overlapable_p(array, i))
                {
                    string ld = bound_parameter_name(newarray, LOWER, i);
                    string ud = bound_parameter_name(newarray, UPPER, i);
                    dimension d = FindIthDimension(newarray, i);
                    
                    fprintf(file,
                            "      integer \n"
                            "     $    %s,\n"
                            "     $    %s\n" 
                            "      parameter(%s = %d)\n"
                            "      parameter(%s = %d)\n",
                            ld, ud, 
                            ld, HpfcExpressionToInt(dimension_lower(d)),
                            ud, HpfcExpressionToInt(dimension_upper(d)));
 
                    free(ld); free(ud);
                }
            }
        /* otherwise it is a secondary copy */
    },
        l);
 
    gen_free_list(l);
}

References array, bound_parameter_name(), bound_similar_mapping_p(), dimension_lower, dimension_upper, dynamic_entity_p, ENTITY, entity_name, entity_storage, entity_undefined, FindIthDimension(), fprintf(), free(), gen_free_list(), HpfcExpressionToInt(), ith_dim_overlapable_p(), list_of_distributed_arrays_for_module(), load_new_node(), load_similar_mapping(), LOWER, MAP, module, module_local_name(), NumberOfDimension(), pips_debug, storage_formal_p, ud(), and UPPER.

Referenced by put_generated_resources_for_common(), and put_generated_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

max_size_of_processors()

int max_size_of_processors

(

void

)

Definition at line 120 of file inits.c.

{
    int current_max = 1;
 
    MAP(ENTITY, e, 
    {
        variable a;
        
        pips_assert("variable", type_variable_p(entity_type(e)));
        a = type_variable(entity_type(e));
        
        current_max = max(current_max,
                          element_number(variable_basic(a), variable_dimensions(a)));
    }, 
        list_of_processors());
 
    return current_max;
}

References current_max, element_number(), ENTITY, entity_type, list_of_processors(), MAP, max, pips_assert, type_variable, type_variable_p, variable_basic, and variable_dimensions.

Referenced by create_common_parameters_h().

Here is the call graph for this function:

Here is the caller graph for this function: