include/ntuple/qp_exe_stack.h

0001 /*
0002  *  qp_exe_stack.h  --
0003  *  Definitions and macros for the runtime stack
0004  *  handling.
0005  *
0006  *  Original: 17-Jan-1995 11:12
0007  *
0008  *  Author:   Maarten Ballintijn <Maarten.Ballintijn@cern.ch>
0009  *
0010  *  $Id$
0011  *
0012  *  $Log$
0013  *  Revision 1.10  1996/09/09 09:11:43  lecointe
0014  *  Split "qp_execute.c"in two smaller files, for optimization purpose.
0015  *  "qp_exec_global.h" contains the global variables that were in
0016  *  "qp_execute.c", and their initialization (if any)
0017  *
0018  *  Revision 1.9  1996/07/24 13:49:39  dinofm
0019  *  Just a few optimization in the qp_exe_evt function and stack handling
0020  *  macros. Warning, this optimizations would affect the 'hand-made'
0021  *  timing statistics.
0022  *
0023  *  Revision 1.8  1996/05/13 16:23:42  maartenb
0024  *  - Add 4+ dimension dynamic array access.
0025  *
0026  *  Revision 1.7  1996/04/29 11:43:35  maartenb
0027  *  - Add a macro to push a generic shape.
0028  *
0029  *  Revision 1.6  1996/04/26 09:09:12  maartenb
0030  *  - Implemented dynamic access to 3dim arrays.
0031  *
0032  *  Revision 1.5  1996/04/23 18:38:35  maartenb
0033  *  - Add RCS keywords
0034  *
0035  *
0036  */
0037
0038
0039 #define MAX_FRAME_PTR   100
0040 #define STACK_SIZE  100000
0041
0042
0043 /* the stack grow downwards */
0044 #ifdef INIT_STACK_TO_NULL
0045 Extern Int32    *stack=0;
0046 #else
0047 Extern Int32    *stack;
0048 #endif
0049
0050 /* the frame list extends upward  i=1,2,3,... */
0051 /* frame[i] is the first used word */
0052 Extern int  frame[MAX_FRAME_PTR+1];
0053 Extern int  frame_size[MAX_FRAME_PTR+1];
0054 Extern DataType frame_type[MAX_FRAME_PTR+1];
0055
0056 /* framep == 0 means no frames on stack */
0057 /* frame[0] is used to align the first stack frame */
0058 Extern int  framep;
0059
0060 /* Stack to check shape conformance at runtime */
0061
0062 typedef struct {
0063     int ndim;
0064     int range[MAX_DIMENSION];
0065 } Shape;
0066
0067 Extern Shape    shape_stack[MAX_FRAME_PTR+1];
0068 Extern Shape    *shape_sp;
0069
0070 /****/
0071
0072 Extern bool db_stack;
0073
0074
0075 #define SET_FRAME_TYPE( type )                      \
0076     do {                                \
0077 if(db_stack) sf_report("SET_FRAME_TYPE: Type=%s [%d]\n",datatype_to_str(type),framep);\
0078         frame_type[framep] = type;              \
0079     } while( 0 )
0080
0081 #define NEW_FRAME( type, size, ptr )                    \
0082     {                               \
0083         int newfp;                  \
0084         if ( framep == MAX_FRAME_PTR ) {            \
0085             sf_report( "qp_execute_seq: MAX_FRAME_PTR " \
0086                 "exceeded\n");              \
0087             *errp = R_INTERNAL_ERROR;           \
0088         }                           \
0089         newfp = (frame[framep] - datatype_size[type]*(size)) & MAX_ALIGN;   \
0090         if ( newfp < 0 ) {                  \
0091             sf_report( "qp_execute_seq: Stack overflow" );  \
0092             *errp = R_INTERNAL_ERROR;           \
0093         }                           \
0094         framep += 1;                        \
0095         frame[framep] = newfp;                  \
0096         frame_size[framep] = (size);                \
0097         frame_type[framep] = type;              \
0098         ptr = (void *) (stack + newfp);             \
0099     }
0100
0101 #define STACK_INIT                          \
0102     do {                                \
0103         framep = 0;                     \
0104         shape_sp = shape_stack;                 \
0105     } while ( 0 )
0106
0107 #define STACK_ALLOC                         \
0108     do {                                \
0109 if(db_stack) sf_report("STACK_ALLOC (%d words)\n", STACK_SIZE);/**/\
0110     stack = (Int32 *) calloc( sizeof(Int32), STACK_SIZE );      \
0111     if ( stack == 0 ) {                     \
0112         sf_report( "STACK_ALLOC: Cannot allocate stack\n" );    \
0113         *errp = R_ALLOC_ERROR;                  \
0114     }                               \
0115     frame[0] = STACK_SIZE; /* first unusable word ! */      \
0116     framep = 0;                         \
0117     } while ( 0 )
0118
0119 #define POP_FRAME(N)                            \
0120     do {                                \
0121 if(db_stack) sf_report("POP_FRAME: n=%d [%d]\n", N, framep - N);/**/\
0122         if ( framep >= (N) ) {                  \
0123             framep -= N;                    \
0124         } else {                        \
0125             sf_report( "POP_FRAME(%d): Failed framep = %d\n",\
0126                 N, framep );                \
0127             *errp = R_ALLOC_ERROR;              \
0128         }                           \
0129     } while (0)
0130
0131 #define SQUEEZE_FRAME( N )                  \
0132     do {                                \
0133         Int32       *new, *old = &stack[frame[framep]]; \
0134         int     size = frame_size[framep];      \
0135         DataType    type = frame_type[framep];      \
0136 if(db_stack) sf_report("SQUEEZE_FRAME: type=%s, n=%d [%d]\n",datatype_to_str(type),N,framep-((N)+1));\
0137                                     \
0138         if ( framep > (N) ) {                   \
0139             framep -= (N)+1;                \
0140             NEW_FRAME(type,size,new);           \
0141             (void) memmove( new, old,           \
0142             (size_t) size*4*datatype_size[type] );  \
0143         } else {                        \
0144             sf_report( "SQUEEZE_FRAME(%d): Failed framep = %d\n",\
0145                 N, framep );                \
0146             *errp = R_ALLOC_ERROR;              \
0147         }                           \
0148     } while (0)
0149
0150
0151 #define SHAPE_PUSH_1( N )                       \
0152     do {                                \
0153 if(db_stack) sf_report("SHAPE_PUSH_1: (%d) [%d]\n", N, shape_sp-shape_stack+1 );/**/\
0154         (++shape_sp)->ndim = 1;                 \
0155         shape_sp->range[0] = N;                 \
0156     } while(0)
0157
0158
0159 #define SHAPE_PUSH_2( n1, n2 )                      \
0160     do {                                \
0161 if(db_stack) sf_report("SHAPE_PUSH_2: (%d,%d) [%d]\n", n1, n2, shape_sp-shape_stack+1 );/**/\
0162         (++shape_sp)->ndim = 2;                 \
0163         shape_sp->range[0] = n1;                \
0164         shape_sp->range[1] = n2;                \
0165     } while(0)
0166
0167
0168 #define SHAPE_PUSH_3( n1, n2, n3 )                  \
0169     do {                                \
0170 if(db_stack) sf_report("SHAPE_PUSH_3: (%d,%d,%d) [%d]\n", n1, n2, n3, shape_sp-shape_stack+1 );/**/\
0171         (++shape_sp)->ndim = 3;                 \
0172         shape_sp->range[0] = n1;                \
0173         shape_sp->range[1] = n2;                \
0174         shape_sp->range[2] = n3;                \
0175     } while(0)
0176
0177
0178 #define SHAPE_PUSH_N( _n, _nv )                 \
0179     do { int i;                             \
0180 if(db_stack) { sf_report("SHAPE_PUSH_N: n=%d [%d] (", _n, shape_sp-shape_stack+1 );/**/\
0181 for( i=0 ; i<_n ; i++ ) { printf( " %d", _nv[i] ); } printf("\n" ); }   \
0182         (++shape_sp)->ndim = _n;                \
0183         for ( i=0 ; i < _n ; i++ ) {                \
0184             shape_sp->range[i] = _nv[i];            \
0185         }                           \
0186     } while(0)
0187
0188
0189 #define SHAPE_LOAD(pc)                          \
0190     do {                                \
0191         register int    *p, i = *pc++;              \
0192 if(db_stack) sf_report("SHAPE_LOAD: [%d]\n", shape_sp-shape_stack+1 );/**/\
0193         (++shape_sp)->ndim = i;                 \
0194         p = shape_sp->range;                    \
0195         for( ; i > 0 ; i-- ) {                  \
0196             *p++ = *pc++;                   \
0197         }                           \
0198     } while (0)
0199
0200
0201 #define SHAPE_ADJUST(I)                         \
0202     do {                                \
0203 if(db_stack) sf_report("SHAPE_ADJUST: i=%d [%d]\n", I, shape_sp-shape_stack );/**/\
0204         shape_sp->range[shape_sp->ndim-1] = I;          \
0205     } while (0);
0206
0207 #define SHAPE_CHECK_N(_n,flag)                      \
0208     do {                                \
0209         int i, j, d = 0, n = _n, *p[MAX_EXPRS];     \
0210         Shape   *sp = shape_sp;                 \
0211 if(db_stack) sf_report("SHAPE_CHECK_N: n=%d [%d]\n", _n, shape_sp-shape_stack );/**/\
0212                                     \
0213         flag = TRUE;                        \
0214         d = sp->ndim;   /* conformance checked at compile time */\
0215         for ( i=0 ; i < n ; i++, sp-- ) {           \
0216             p[i] = sp->range;               \
0217             qp_assert( d == sp->ndim );         \
0218         }                           \
0219         for ( j=0 ; j < d ; j++, p[0]++ ) {         \
0220             for ( i=1 ; i < n ; i++ ) {         \
0221                 if ( *(p[i]++) != *p[0] ) {     \
0222                     flag = FALSE;           \
0223                     break;              \
0224                 }                   \
0225             }                       \
0226             if ( !flag ) break;             \
0227         }                           \
0228     } while (0)
0229
0230
0231 #define SHAPE_POP(N)                            \
0232     do {                                \
0233 if(db_stack) sf_report("SHAPE_POP: n=%d [%d]\n", N, shape_sp-shape_stack-N);/**/\
0234         shape_sp -= N;                      \
0235     } while(0)