C-DVM compiler
Preliminary design
* 22 June 2000 *


Contents

1 Purpose of the Compiler

1.1 Parallelization
1.2 Debugging extensions

2 The sequence of compilation
3 Compilation of C-DVM constructs

3.1 Distribution of data

3.1.1 DISTRIBUTE directive
3.1.2 GENBLOCK distribution format
3.1.3 ONTO clause
3.1.4 REDISTRIBUTE directive
3.1.5 ALIGN directive
3.1.6 REALIGN directive
3.1.7 TEMPLATE clause
3.1.8 CREATE_TEMPLATE directive

3.2 Distribution of computations (loops and tasks)

3.2.1 PARALLEL directive
3.2.2 ACROSS clause
3.2.3 PROCESSORS directive and NUMBER_OF_PROCESSORS() function
3.2.4 TASK directive
3.2.5 MAP directive
3.2.6 TASK_REGION directive
3.2.7 ON-block construction
3.2.8 ON-loop construction

3.3 Shadow edges

3.3.1 SHADOW clause
3.3.2 SHADOW_RENEW clause
3.3.3 SHADOW_GROUP directive
3.3.4 CREATE_SHADOW_GROUP directive
3.3.5 SHADOW_START directive
3.3.6 SHADOW_START clause
3.3.7 SHADOW_WAIT directive
3.3.8 SHADOW_WAIT clause

3.4 Remote access

3.4.1 REMOTE_ACCESS directive and clause
3.4.2 REMOTE_GROUP directive
3.4.3 PREFETCH directive
3.4.4 RESET directive
3.4.5 Remote references

3.5 Reduction operations

3.5.1 REDUCTION_GROUP directive
3.5.2 REDUCTION clause
3.5.3 Reduction variables and operations
3.5.4 REDUCTION_START directive
3.5.5 REDUCTION_WAIT directive

3.6 Implicit constructions

3.6.1 Creation and deletion of distributed arrays
3.6.2 Static distributed arrays
3.6.3 References to distributed data
3.6.4 Own computation
3.6.5 Initializing and finalizing of program execution
3.6.6 Input-output functions

3.7 Debugging extensions

3.7.1 Performance analyzer. Loops
3.7.2 Performance analyzer. INTERVAL directive
3.7.3 Debugger. Data tracing
3.7.4 Debugger. Computation tracing
3.7.5 Sequential code


1 Purpose of the Compiler

C-DVM is the C language extended by special annotations for specifying parallel execution of a program. These annotations are called DVM-directives. C-DVM compiler translates an annotated C-DVM program to a SPMD stile program that contains calls to run-time library (RTL).

Besides "pure" parallel code the compiler should be able to produce an "extended" debugging code to use features of the performance analyzer and debugger, and also a "sequential" code (i.e. without RTL calls) with such debugging extensions.

1.1 Parallelization

Compiler should recognize the following four types of constructs and perform corresponding actions and code transformations:

1.2 Debugging extensions

For the Performance Analyzer the Compiler should process:

All of these are implemented as invocations of corresponding functions of the analyzer.

For the Debugger the Compiler should provide:

All of these are implemented as invocation of corresponding functions of the debugger. A point of registration of initialized variables is determined by the compiler.

Sequential execution mode is required to obtain performance characteristics of source program and so called "reference" trace to debug in trace comparison mode. All DVM-directives are ignored except for the following:

2 The sequence of compilation

Program compilation is accomplished in the following steps.

For convenience and flexibility output code is written without direct use of RTL functions. Output code contains macros providing all necessary information at a given point of output program, hiding low-level details of RTL library interface. The final generation is performed by the C preprocessor using macrodefinitions of C-DVM macros (File cdvm_c.h.)

3 Compilation of C-DVM constructs

Necessity of program transformation for parallel execution is caused by distribution of data and computations.

Distribution of data consists in splitting of arrays into parts and placing such parts to local memories of different processors. On each processor RTL defines size of local part (considering shadow edges) and allocates memory for it. For program this local part is accessible through array handler. So original sequential statements for allocating and accessing distributed data should be found in source code and replaced.

Distribution of computation consists in splitting of the whole index space of a loop to parts and execution on different processors of different set of loop iterations. In every processor local part of parallel loop is described by a loop handler. So sequential loop headers should be replaced.

In this section all transformations of C-DVM program performed by the compiler are described.

3.1 Distribution of data

3.1.1 DISTRIBUTE directive

Context and syntax.  

    DVM( ["*"] DISTRIBUTE [ format...] [ ONTO target ]
            [ ; SHADOW-clause ] [ ; TEMPLATE-clause ] )
            C-declaration ;

Proposed compiler output.  

    long array-id [ rank+1 ];

Note.  Source declaration is substituted. All other information from the declaration and directive will be used later in other constructions generating and distributed data references recognizing.

3.1.2 GENBLOCK distribution format

Context and syntax.  

    DVM(DISTRIBUTE ... "[" GENBLOCK( int-array ) "]"... )
    DVM(REDISTRIBUTE ... "[" GENBLOCK( int-array ) "]"... )

Proposed compiler output.  

    DVM_GENBLOCK(am,ps,k,gbs);

Note.  The macro is generated not at the point of DISTRIBUTE directive, but in a sequence of (explicit or implicit) array creation. Macro DVM_GENBLOCK(am,ps,k,gbs) is expanded to

    DVM_AM=am? am : getam_();
    DVM_PS=ps? ps : getps_(NULL);
    genbli_(&DVM_PS, &DVM_AM, (AddrType*) gbs, k);

3.1.3 ONTO clause

Context and syntax.  

    DVM(DISTRIBUTE ... ONTO target ... )

Proposed compiler output.  

    DVM_ONTO(ps,k,ls,hs)

Note.  The macro is generated not at the point of DISTRIBUTE directive, but in a sequence of (explicit or implicit) array creation. It creates a processors subsystem which will be used instead of the current one (default). Macro DVM_ONTO(ps,k,ls,hs) is expanded to

    DVM_PS=ps;
    DVM_PS=crtps_(&DVM_PS,  ls, hs,  DVM_0000);

3.1.4 REDISTRIBUTE directive

Context and syntax.  

    DVM(REDISTRIBUTE array format... [ NEW ] ) ;

Proposed compiler output.  

    DVM_REDISTRIBUTE(amv,ps,k,axs,new);

Note.  The executable directive is converted to a statement. Macro DVM_REDISTRIBUTE(amv,ps,k,axs,new) is expanded to

    {DVM_PS=ps;
    redis_((AMViewRef*) amv, &DVM_PS, k, axs, 0, new);
    }

3.1.5 ALIGN directive

Context and syntax.  

    DVM(["*"] ALIGN [ "["dummy-var"]"... ]
            WITH base "["align-expr"]"...
            [ ; SHADOW-clause ] )
            C-declaration ;

Proposed compiler output.  

    long array-id [ rank+1 ];

Note.  Source declaration is substituted. All the other information from the declaration and directive should be used later in generating other constructions and recognizing of references to distributed data.

3.1.6 REALIGN directive

Context and syntax.  

    DVM( REALIGN array "["dummy-var"]"...
            WITH base "["align-expr"]"... ) ;

Proposed compiler output.  

    DVM_REALIGN(arr,base,k,i,a,b,new);

Note.  The executable directive is converted to a statement. Macro DVM_REALIGN(arr,base,k,i,a,b,new) is expanded to

    {realn_(arr, (PatternRef*)(base), i, a, b, new);
    }

3.1.7 TEMPLATE clause

Context and syntax.  

    DVM(DISTRIBUTE ... ; TEMPLATE [ "["size"]"... ] )
            void * template-id ;

Proposed compiler output.  

    AMViewRef template-id;

Note.  Source declaration is substituted. Distribution formats will be used in creation of the template. If sizes present creation will be implicit.

3.1.8 CREATE_TEMPLATE directive

Context and syntax.  

    DVM(CREATE_TEMPLATE template-id "["size"]"... ) ;

Proposed compiler output.  

    DVM_CREATE_TEMPLATE(am,t,r,di);
    DVM_DISTRIBUTE(amv,ps,k,axs);

Note.  The executable directive is converted to a statement. Macro DVM_CREATE_TEMPLATE(am,t,r,di) is expanded to

    {if(am==0) DVM_AM=getam_();
    else DVM_AM=am;
    t=crtamv_( (AMRef*)DVM_AM, r, di, 0);
    }

Macro DVM_DISTRIBUTE(amv,ps,k,axs) is expanded to

    {DVM_PS=ps;
    DVM_AMV=amv;
    distr_( &DVM_AMV, &DVM_PS, k, axs, 0);
    }

These macros are also generated to create and distribute an implicit template for any distributed (not aligned) array.

3.2 Distribution of computations (loops and tasks)

3.2.1 PARALLEL directive

Context and syntax.  

    DVM ( PARALLEL "["loop-var"]"...
        ON base "["align_expr"]"...
        [ ; sub-directives]... )
        loop-nest

Proposed compiler output.  

    {
        [ dvm_create_rg ]
    DVM_PARALLEL(n,r);
        [ other sub-directives... ]
    DVM_DO_ON((n,r,vs,ls,hs,ss,base,rb,is,as,bs);
        [ dvm_reduction or dvm_reduction20 ]
    {
    DVM_DOPL(n)
    loop-headers DVM_FOR...
    {
        loop-body
    }
    }
        [ end_reduction ]
    DVM_END_PARALLEL(n);
    }

Note.  Macro DVM_PARALLEL(n,r) is expanded to

    {long DVM_LO##n[r],
        DVM_HI##n[r],
        DVM_ST##n[r];
    LoopRef DVM_LP##n;
    DVM_LP##n=crtpl_(DVM_A0(r))

Macro Macro DVM_DO_ON(n,r,vs,ls,hs,ss,base,rb,is,as,bs) is expanded to

    mappl_(&DVM_LP##n,  (PatternRef*)(base),
        is, as, bs, vs,  1,
        ls, hs, ss, DVM_LO##n, DVM_HI##n, DVM_ST##n);

Macro DVM_DOPL(n) is expanded to

    while(dopl_(&DVM_LP##n))

Macro DVM_FOR(n,v,k,lh) is expanded to

    for(v=DVM_LO##n[k]; v<=DVM_HI##n[k]; v+=DVM_ST##n[k])

Macro DVM_REDBLACK(n,v,k,e,lh) is expanded to

    for(v=DVM_LO##n[k]+(DVM_LO##n[k]+e)%2;v<=DVM_HI##n[k];v+=2)

Macro DVM_END_PARALLEL(n) is expanded to

    endpl_(&DVM_LP##n);}

3.2.2 ACROSS clause

Context and syntax.  

    DVM ( PARALLEL ... ; ACROSS array "["widths"]"... )

Proposed compiler output.  

     dvm_parallel ... sub_directives
    DVM_ACROSS(loopid, (
        DVM_ACROSS_SH(a,k,ls,hs,corner)  // for each renewee
        ...
        ))
    { dvm_dopl
      loop-headers...
      loop-body
    }
    DVM_END_ACROSS()
    [ end_reduction ]
    dvm_end_parallel

Note.  Macro DVM_ACROSS(loopid,shads) is expanded to

    {ShadowGroupRef DVM_LSG;
    ShadowGroupRef DVM_HSG;
    int DVM_LorH;
    DVM_LSG=crtshg_(0);
    DVM_HSG=crtshg_(0);
    DVM_LorH=1;
    shads;
    strtsh_(&DVM_HSG);
    waitsh_(&DVM_HSG);
    delshg_(&DVM_HSG);
    DVM_LorH=0;
    shads;
    recvsh_(&DVM_LSG);
    waitsh_(&DVM_LSG);

Macro DVM_END_ACROSS() is expanded to

    sendsh_(&DVM_LSG);
    waitsh_(&DVM_LSG);
    delshg_(&DVM_LSG);
    }

Macro DVM_ACROSS_SH(a,k,ls,hs,corner) is expanded to

    ((DVM_LorH ?
    inssh_(&DVM_HSG, a, 0, hs, corner)
    :inssh_(&DVM_LSG, a, ls, 0, corner) ),
    )

3.2.3 PROCESSORS directive and NUMBER_OF_PROCESSORS() function

Context and syntax.  

    DVM(PROCESSORS "["dim"]"...) void * proc_id ;

Proposed compiler output.  

    PSRef proc_id;
    ...
    DVM_PROCESSORS(Iproc_id),r,dims);

Note.  Source declaration is substituted. The macro is generated not at the point of declaration, but in a sequence of implicit actions. Macro DVM_PROCESSORS(proc,r,dims) is expanded to

    {DVM_PS=getps_(NULL);
    proc=psview_(&DVM_PS, r, dims, 0);
    }

Macro NUMBER_OF_PROCESSORS() is expanded to

    (DVM_PS=getps_(NULL), getsiz_((ObjectRef*)&DVM_PS,0))

3.2.4 TASK directive

Context and syntax.  

    DVM(TASK) void * task-id "["size"]"

Proposed compiler output.  

    AMViewRef AMV_task-id;
    PSRef  task-id [ size ]={0};
    ...
    DVM_TASK(task-id,n);

Note.  Source declaration is substituted. The macro is generated not at the point of declaration, but in a sequence of implicit actions. Macro DVM_TASK(id,n) is expanded to

    AMV_##id=crtamv_(getam_(), 1, n, 0);

3.2.5 MAP directive

Context and syntax.  

    DVM(MAP task-id"["task_ind"]" ONTO proc-section );

Proposed compiler output.  

    DVM_MAP(task,ind, [ DVM_ONTO(ps,k,ls,hs) ]) ;

Note.  The executable directive is converted to a statement. Macro DVM_MAP(task,ind,ps) is expanded to

    ps;
    task[ind]=DVM_PS;
    mapam_(getamr_(&AMV_##task,ind), &DVM_PS);

3.2.6 TASK_REGION directive

Context and syntax.  

    DVM(TASK_REGION task-id)
    {
        ON-block... |  ON-loop
    }

Proposed compiler output.  

    {DVM_TASKREGION(no,task);
    ...
    }

Note.  Macro DVM_TASKREGION(no,task) is expanded to

    AMViewRef AMV_0;
    AMViewRef DVM_LP##no=AMV_##task;

3.2.7 ON-block construction

Context and syntax.  

    DVM(ON task-id "["task-ind"]")
    {   C-statements   }

Proposed compiler output.  

    if(DVM_RUN(task,ind))
        { statements
        DVM_STOP();
        }

Note.  Macro DVM_RUN(task,ind) is expanded to

    runam_(getamr_(&AMV_##task,ind))

Macro DVM_STOP() is expanded to

    stopam_()

3.2.8 ON-loop construction

Context and syntax.  

    DVM(PARALLEL "["var"]" ON task-id "["var"]")
    DO(var, ..., ..., ...)
        {   C-statements   }

Proposed compiler output.  

    for(var=0; ...)
    if(DVM_RUN(task,var))
        { statements
        DVM_STOP();
        }

3.3 Shadow edges

3.3.1 SHADOW clause

Context and syntax.  

    DVM( DISTRIBUTE | ALIGN ...
             ; SHADOW "["widths"]"... )

Note.  Nothing is generated at this point. Compiler keeps provided widths as the maximal width of shadow edges. They will be used for array creation.

3.3.2 SHADOW_RENEW clause

Context and syntax.  

    DVM(PARALLEL ... ; SHADOW_RENEW renewee... ... )
    renewee ::=  array [ "["widhs"]"... ] [ CORNER ]

Proposed compiler output.  

    DVM_SHADOW_RENEW(loop-number,
        (DVM_SHADOWS(a,k,ls,hs,corner), // for each renewee
        ...
        ))

Note.  It is shorthand for the sequence "CREATE_SHADOW_GROUP; SHADOW_START; SHADOW_WAIT;" with temporary shadow group, performed before the loop. Macro DVM_SHADOW_RENEW(n,das) is expanded to

    {ShadowGroupRef DVM_SG=crtshg_(0);
    das;
    strtsh_(&DVM_SG);
    waitsh_(&DVM_SG);
    delshg_(&DVM_SG); }

Macro DVM_SHADOWS(a,k,ls,hs,corner) is expanded to

    inssh_(&DVM_SG, a, ls, hs, corner)

3.3.3 SHADOW_GROUP directive

Context and syntax.  

    DVM(SHADOW_GROUP) void * sh-group-id;

Proposed compiler output.  

    ShadowGroupRef sh-group-id;

Note.  Source declaration is substituted.

3.3.4 CREATE_SHADOW_GROUP directive

Context and syntax.  

    DVM(CREATE_SHADOW_GROUP sh-group-id : renewee... );

Proposed compiler output.  

    DVM_CREATE_SHADOW_GROUP( sh-group-id,
        (DVM_SHADOWS(a,k,ls,hs,corner), // for each renewee
        ...
        ))

Note.  The executable directive is converted to a statement. Macro DVM_CREATE_SHADOW_GROUP(sg,shads) is expanded to

    {ShadowGroupRef DVM_SG;
    if(sg!=0) delshg_(&sg);
    DVM_SG=crtshg_(0);
    shads;
    sg=DVM_SG;
    }

3.3.5 SHADOW_START directive

Context and syntax.  

    DVM(SHADOW_START sh-group-id);

Proposed compiler output.  

    DVM_SHADOW_START(sg);

Note.  The executable directive is converted to a statement. Macro DVM_SHADOW_START(sg) is expanded to

    strtsh_(&sg)

3.3.6 SHADOW_START clause

Context and syntax.  

    DVM(PARALLEL ... ; SHADOW_START sh-group-id ... ) ...

Proposed compiler output.  

    DVM_PAR_SHADOW_START(n,sg); // in loop header

Note.  Macro DVM_PAR_SHADOW_START(n,sg) is expanded to

    exfrst_(&DVM_LP##n,&sg)

3.3.7 SHADOW_WAIT directive

Context and syntax.  

    DVM(SHADOW_WAIT sh-group-id);

Proposed compiler output.  

    DVM_SHADOW_WAIT(sg);

Note.  The executable directive is converted to a statement. Macro DVM_SHADOW_WAIT(sg) is expanded to

    waitsh_(&sg)

3.3.8 SHADOW_WAIT clause

Context and syntax.  

    DVM(PARALLEL ... ; SHADOW_WAIT sh-group-id ...) ...

Proposed compiler output.  

    DVM_PAR_SHADOW_WAIT(n,sg); // in loop header

Note.  Macro DVM_PAR_SHADOW_WAIT(n,sg) is expanded to

    imlast_(&DVM_LP##n,&sg)

3.4 Remote access

3.4.1 REMOTE_ACCESS directive and clause

Context and syntax.  

    DVM(REMOTE_ACCESS ra-reference...)
        C-statement
    DVM(PARALLEL ... ;
        REMOTE_ACCESS [ ra-group : ] ra-reference...
        ...) ...
    ra-reference ::= array [ "["[expr]"]"... ]

Proposed compiler output.  

    DVM_BLOCK_BEG();
    DVM_REMOTE20(arr,buf,k,as,bs);
    statements using remote references
    DVM_BLOCK_END();

Note.  Macro DVM_REMOTE20(arr,buf,k,as,bs) is expanded to

    {static long buf[2*k+2];
    crtrbl_(arr, buf, NULL, 0, NULL, 1, as, bs);
    loadrb_(buf, 1);
    waitrb_(buf);}

Macro DVM_REMOTE20G(n,rg,arr,buf,k,is,as,bs) is expanded to

    if(RMG_##rg==1) {waitbg_(&rg); RMG_##rg=2;}
    if(RMG_##rg==0)
        {crtrbl_(arr, buf, NULL, 1, &DVM_LP##n, is, as, bs);
        loadrb_(buf, 1);
        waitrb_(buf);
        if(rg==0) {rg=crtbg_(1, 1);}
        insrb_(&rg, buf);
        }

3.4.2 REMOTE_GROUP directive

Context and syntax.  

    DVM(REMOTE_GROUP) void * ra-group-id;

Proposed compiler output.  

    RegularAccessGroupRef ra-group-id;
    long  RMG_ra-group-id;

Note.  Source declaration is substituted. The PREFETCH and RESET operations require a flag variable to control buffer update operations.

3.4.3 PREFETCH directive

Context and syntax.  

    DVM(PREFETCH ra-group-id );

Proposed compiler output.  

    DVM_PREFETCH(rg);

Note.  The executable directive is converted to a statement. Macro DVM_PREFETCH(rg) is expanded to

    if(rg==0) {RMG_##rg=0;}
    else {loadbg_(&rg, 1);
        RMG_##rg=1;
        }

3.4.4 RESET directive

Context and syntax.  

    DVM(RESET ra-group-id );

Proposed compiler output.  

    DVM_RESET(rg);

Note.  The executable directive is converted to a statement. Macro DVM_RESET(rg) is expanded to

    delbg_(&rg);
    rg=0;
    RMG_##rg=0;

3.4.5 Remote references

Remote references are substituted by references to remote buffers.

3.5 Reduction operations

3.5.1 REDUCTION_GROUP directive

Context and syntax.  

    DVM(REDUCTION_GROUP) void * red-group-id;

Proposed compiler output.  

    RedGroupRef red-group-id;

Note.  Source declaration is substituted.

3.5.2 REDUCTION clause

Context and syntax.  

    DVM( PARALLEL | TASK_REGION ... ;
        REDUCTION [ red-group-id : ] red-operation...
        ... ) ...

Proposed compiler output.  

    DVM_CREATE_RG(rg, (
        DVM_RVAL(...) | DVM_RLOC(...)  // for each operation
        ...
        ));
        loop creation and mapping
    DVM_REDUCTION20(loopid,rg);       // insert to the group
        loop headers and body
    [ DVM_END_REDUCTION(); ]          // synchronous reduction

Note.  Macro DVM_CREATE_RG(rg,rvs) is expanded to

    if(rg==0) rg=crtrg_(1,1);
    (void)rvs;

Macro DVM_REDUCTION(loopid,rvs) is expanded to

    { RedGroupRef DVM_RG;
    LoopRef DVM_LP0=0;
    PSSpaceRef DVM_PSSpace=DVM_LP##loopid;
    DVM_RG=crtrg_(1, 1);
    (void)rvs;
    DVM_INSERT_RV();

Macro DVM_REDUCTION20(loopid, rg) is expanded to

    { RedGroupRef DVM_RG=rg;
    LoopRef DVM_LP0=0;
    PSSpaceRef DVM_PSSpace=DVM_LP##loopid;
    DVM_INSERT_RV();
    rg=DVM_RG;}

Macro DVM_INSERT_RV() is expanded to

    while(CDVM_TOP!=CDVM_BOTTOM) {
    insred_( &DVM_RG, (RedRef*)CDVM_TOP, &DVM_PSSpace, 1);
    }

Macro DVM_END_REDUCTION() is expanded to

    {strtrd_(&DVM_RG);
    waitrd_(&DVM_RG);
    delrg_(&DVM_RG);}
    }

3.5.3 Reduction variables and operations

Context and syntax.  

    DVM(...; REDUCTION ... MAX(red-var) ... )
    DVM(...; REDUCTION ... MIN(red-var) ... )
    DVM(...; REDUCTION ... SUM(red-var) ... )
    DVM(...; REDUCTION ... PROD(red-var) ... )
    DVM(...; REDUCTION ... AND(red-var) ... )
    DVM(...; REDUCTION ... OR(red-var) ... )
    DVM(...; REDUCTION ... MAXLOC(red-var,loc-var) ... )
    DVM(...; REDUCTION ... MINLOC(red-var,loc-var) ... )

Proposed compiler output.  

    DVM_RVAR(rf_MAX,var,t,l)
    DVM_RVAR(rf_MIN,var,t,l)
    DVM_RVAR(rf_SUM,var,t,l)
    DVM_RVAR(rf_PROD,var,t,l)
    DVM_RVAR(rf_AND,var,t,l)
    DVM_RVAR(rf_OR,var,t,l)
    DVM_RLOC(rf_MAX,var,t,l,loc-var)
    DVM_RLOC(rf_MIN,var,t,l,loc-var)

Note.  The parameter t is a code of type of variable (rt_INT, rt_LONG, rt_FLOAT, rt_DOUBLE). Parameter l is the number of elements in red-var (if it is an array) or 1. Macro DVM_RVAR(f,v,t,l) is expanded to

    crtred_(f, &(v), t, l, 0, 0, 1)

Macro DVM_RLOC(f,v,t,l,loc) is expanded to

    crtred_(f, &(v), t, l, &(loc), sizeof(loc), 1)

3.5.4 REDUCTION_START directive

Context and syntax.  

    DVM(REDUCTION_START red-group-id);

Proposed compiler output.  

    DVM_REDUCTION_START(red-group-id);

Note.  The executable directive is converted to a statement. Macro DVM_REDUCTION_START(rg) is expanded to

    strtrd_((RedGroupRef*) &rg)

3.5.5 REDUCTION_WAIT directive

Context and syntax.  

    DVM(REDUCTION_WAIT red-group-id);

Proposed compiler output.  

    DVM_REDUCTION_WAIT(red-group-id);

Note.  The executable directive is converted to a statement. Macro DVM_REDUCTION_WAIT(rg) is expanded to

    waitrd_((RedGroupRef*) &rg);
    delrg_((RedGroupRef*) &rg);
    rg=0;

3.6 Implicit constructions

3.6.1 Creation and deletion of distributed arrays

Context and syntax.  

    array = malloc(dim1 *...* dimr * elem-size);
    free( array );

Proposed compiler output.   It includes all or part of the following statements depending on array declaration.

  [ DVM_CREATE_TEMPLATE(am,t,r,di); // implicit template   ]
  [ DVM_ONTO(ps,k,ls,hs);           // target system       ]
  [ DVM_DISTRIBUTE(amv,ps,k,axs);   // distribute template ]
  [ DVM_GENBLOCK(am,ps,k,gbs);      // GENBLOCK parameters ]
    DVM_MALLOC(arr,r,len,dim,lw,hw,redis) // initialize array handler
  [ DVM_ALIGN(arr,base,k,i,a,b)     // align with template ]

Note.  Macro Macro DVM_MALLOC(arr,r,len,dim,lw,hw,redis) is expanded to

    {crtda_( arr, 0, NULL, r, len, dim, 0, redis, lw, hw );
    }

Macro DVM_ALIGN(arr,base,k,i,a,b) is expanded to

    {align_( arr, &(base), i, a, b);
    }

Macro DVM_FREE(arr) is expanded to

    (delda_(arr));

3.6.2 Static distributed arrays

Context and syntax.  

    DVM(DISTRIBUTE | ALIGN...)
        element-type array-id "["const-dim"]"...;

Proposed compiler output.   Standard array creation sequence as for malloc.

Note.  For global declarations implicit malloc is inserted at the beginning of the main function. For local declarations it is inserted before the first statement of the block.

3.6.3 References to distributed data

Context and syntax.   Ordinary references to array elements array[ind1]...[indr] with distributed array. Special form array(ind1,...,indr) is allowed for macro simulation of dynamic arrays.

Proposed compiler output.  

    DAElm<r>(type,array-id,ind1,...indr)

Note.  These are macros of RTL.

3.6.4 Own computation

Context and syntax.  

        lhs=rhs; // assignment

Proposed compiler output.  

    if(DVM_ISLOCAL(lhs)) {
        lhs = rhs ; }
    DVM_ENDLOCAL();

Note.  Own computation statement is an assignement to a distributed array in a non distributed branch of program. It should be guarded by the test of locality. Macro DVM_ISLOCAL(a,r,ind) is expanded to

    tstelm_(a, ind)

Macro DVM_ENDLOCAL() is expanded to

    dskpbl_()

3.6.5 Initializing and finalizing of program execution

Context and syntax.  

    int main( int argc, char ** arg)
    {
        declarations...
        first-statement
        ...
        [ exit(rc); ]
        ...
        return rc;
    }

Proposed compiler output.  

    int main( int argn, char ** args)
    {
        declarations...
        DVM_INIT(0,argn,args); // initialization of RTL
        [ implicit static array creation ]
        [ tracing of initialized variables ]
        [ other implicit actions ]
        first-statement
        ...
        [ DVM_EXIT(rc); ]  // exit through RTL
        ...
        DVM_RETURN(rc);    // exit through RTL
    }

Note.  For correct generation the main function must get a command-line parameters (which will be passed to RTL) and must have return or exit statement. Macro DVM_INIT(argn,args) is expanded to

    {rtl_init(0L,argn,args);
    }

Macro DVM_RETURN(r) is expanded to

    {lexit_(r);}

Macro DVM_EXIT(r) is expanded to

    {lexit_(r);}

3.6.6 Input-output functions

Compilation of input-output functions is reduced to renaming of iofun to its RTL analog dvm_iofun. The only exception is fread() and fwrite() functions, when they are applied to a distributed array. In this case the array is read or written as a whole, i.e. size parameter of the function is ignored.

3.7 Debugging extensions

3.7.1 Performance analyzer. Loops

Context and syntax.  

    [ DVM(PARALLEL... ) ]
        DO(var,first,last,step)    // or
        FOR(var,times)
            loop-body

Proposed compiler output.  

    BPLOOP(n)  // for parallel loop or
    BSLOOP(n)  // for sequential loop
        code for loop
    ELOOP(n)

Note.  The argument n is a serial number of the loop used to identify paired commands. The set of loops for which the macros are generated depends on a command-line options (-e1...-e4). Macro DVM_BPLOOP(n) is expanded to

    bploop_(n);

Macro DVM_BSLOOP(n) is expanded to

    bsloop_(n);

Macro DVM_ELOOP(n) is expanded to

    eloop_(n, line);

3.7.2 Performance analyzer. INTERVAL directive

Context and syntax.  

    DVM(INTERVAL  [ int-expr ] )
    { C-statements }

Proposed compiler output.  

    DVM_BINTER(n,v)
      { code for statements }
    DVM_EINTER(n)

Note.  The argument n is a serial number of the loop used to identify paired commands. If int-expr does not present, the argument v has some standard value. Macro DVM_BINTER(n,v) is expanded to

    binter_(n, v)

Macro DVM_EINTER(n) is expanded to

    einter_(n,line )

3.7.3 Debugger. Data tracing

Context and syntax.   Any reference to ordinary or distributed variable var in C-statements or variable initialization.

Proposed compiler output.  

    DVM_STVA(type,rt,var,base,rhs)  // lh-side of assignement
    DVM_LDV(type,rt,var,base)  // for read access
    DVM_STV(type,rt,var,base)  // to register initialization

Note.  The set of references, the macros are generated for, depends on a command-line options (-d1...-d4). Macro DVM_LDV(type,rt,var,base) is expanded to

    *(type*) ( ( DVM2A((long)&(var),rt) &&
    dldv_(&CDVM_TOP[1],
        (AddrType *)&CDVM_TOP[0],
        (long *) base, #var, -1) && 0) ? 0 :
    )

Macro DVM_STV(type,rt,var,base) is expanded to

    ( DVM2A((long)&(var), rt),
    dprstv_(&CDVM_TOP[1], (AddrType *)&CDVM_TOP[0],
    (long *) base, #var, -1),
    dstv_())

Macro DVM_STVA(type,rt,var,base,rhs) is expanded to

    ( DVM2A((long)&(var), rt),
    dprstv_(&CDVM_TOP[1], (AddrType *)&CDVM_TOP[0],
    (long *) base, #var, -1),
    (*(type *)(CDVM_TOP[0]) = rhs),
    dstv_())

Such an awful construction arised as a result of porting to MS Visual-C 5.0. -- Unusual order of calculation of comma-expression.

3.7.4 Debugger. Computation tracing

Context and syntax.   Any loop or task region construct.

Proposed compiler output.  

        parallel loop creation
    DVM_PLOOP(n,r,ls,hs,ss)   // or DVM_SLOOP(n)
        loop-headers
    DVM_ITER(r,vars)
        code for loop body
    DVM_ENDLOOP(n)

for loop or

    DVM_BTASK(n)     // in TASK_REGION header
        ...
    DVM_ETASK(n)
        ON-block or ON-loop body
        ...
    DVM_NTASK(ind)   // end of TASK_REGION construct

for task region.

Note.  Macro DVM_PLOOP(n,r,ls,hs,ss) is expanded to

    dbegpl_(r, n, ls, hs, ss);

Parameters are the same as for loop creation. Macro DVM_SLOOP(n) is expanded to

    dbegsl_(n);

Macro DVM_ENDLOOP(n) is expanded to

    dendl_(n, line);

Macro DVM_ITER(r,vars) is expanded to

    diter_(vars, NULL );

Macro DVM_BTASK(n) is expanded to

    dbegtr_(n);

Macro DVM_ETASK(n) is expanded to

    dendl_(n, );

Macro DVM_NTASK(ind) is expanded to

    diter_(ind, 0);

3.7.5 Sequential code

Generation of sequential code is set by the command-line option -s. All DVM-directives ignored except for the following:

Note that preprocessor statements #define should be kept in place unlike the parallel code from which they moved to the beginning if the file.