Charm++: Charm Source Code Documentation

00001 /* -*- Mode: C; c-basic-offset:4 ; -*- */
00002 
00003 /*
00004  *  (C) 2001 by Argonne National Laboratory.
00005  *      See COPYRIGHT in top-level directory.
00006  */
00007 
00008 #ifndef DATALOOP_PARTS_H
00009 #define DATALOOP_PARTS_H
00010 
00011 /* Check that all the appropriate defines are present */
00012 #ifndef PREPEND_PREFIX
00013 #error "PREPEND_PREFIX must be defined before dataloop_parts.h is included."
00014 #endif
00015 
00016 #ifndef DLOOP_Offset
00017 #error "DLOOP_Offset must be defined before dataloop_parts.h is included."
00018 #endif
00019 
00020 #ifndef DLOOP_Count
00021 #error "DLOOP_Count must be defined before dataloop_parts.h is included."
00022 #endif
00023 
00024 #ifndef DLOOP_Handle
00025 #error "DLOOP_Handle must be defined before dataloop_parts.h is included."
00026 #endif
00027 
00028 #ifndef DLOOP_Buffer
00029 #error "DLOOP_Buffer must be defined before dataloop_parts.h is included."
00030 #endif
00031 
00032 #ifndef DLOOP_Type
00033 #error "DLOOP_Type must be defined before dataloop_parts.h is included."
00034 #endif
00035 
00036 /* Redefine all of the internal structures in terms of the prefix */
00037 #define DLOOP_Dataloop              PREPEND_PREFIX(Dataloop)
00038 #define DLOOP_Dataloop_contig       PREPEND_PREFIX(Dataloop_contig)
00039 #define DLOOP_Dataloop_vector       PREPEND_PREFIX(Dataloop_vector)
00040 #define DLOOP_Dataloop_blockindexed PREPEND_PREFIX(Dataloop_blockindexed)
00041 #define DLOOP_Dataloop_indexed      PREPEND_PREFIX(Dataloop_indexed)
00042 #define DLOOP_Dataloop_struct       PREPEND_PREFIX(Dataloop_struct)
00043 #define DLOOP_Dataloop_common       PREPEND_PREFIX(Dataloop_common)
00044 #define DLOOP_Segment               PREPEND_PREFIX(Segment)
00045 #define DLOOP_Dataloop_stackelm     PREPEND_PREFIX(Dataloop_stackelm)
00046 
00047 /* These flags are used at creation time to specify what types of
00048  * optimizations may be applied. They are also passed in at Segment_init
00049  * time to specify which dataloop to use.
00050  *
00051  * Note: The flag to MPID_Segment_init() was originally simply "hetero"
00052  * and was a boolean value (0 meaning homogeneous). Some MPICH2 code
00053  * may still rely on HOMOGENEOUS being "0" and HETEROGENEOUS being "1".
00054  */
00055 #define DLOOP_DATALOOP_HOMOGENEOUS   0
00056 #define DLOOP_DATALOOP_HETEROGENEOUS 1
00057 #define DLOOP_DATALOOP_ALL_BYTES     2
00058 
00059 /* NOTE: ASSUMING LAST TYPE IS SIGNED */
00060 #define SEGMENT_IGNORE_LAST ((DLOOP_Offset) -1)
00061 /*
00062  * Each of the MPI datatypes can be mapped into one of 5 very simple
00063  * loops.  This loop has the following parameters:
00064  * - count
00065  * - blocksize[] 
00066  * - offset[]
00067  * - stride 
00068  * - datatype[]
00069  *
00070  * where each [] indicates that a field may be *either* an array or a scalar.
00071  * For each such type, we define a struct that describes these parameters
00072  */
00073 
00074 /*S
00075   DLOOP_Dataloop_contig - Description of a contiguous dataloop
00076 
00077   Fields:
00078 + count - Number of elements
00079 - dataloop - Dataloop of the elements
00080 
00081   Module:
00082   Datatype
00083   S*/
00084 typedef struct DLOOP_Dataloop_contig {
00085     DLOOP_Count count;
00086     struct DLOOP_Dataloop *dataloop;
00087 } DLOOP_Dataloop_contig;
00088 
00089 /*S
00090   DLOOP_Dataloop_vector - Description of a vector or strided dataloop
00091 
00092   Fields:
00093 + count - Number of elements
00094 . blocksize - Number of dataloops in each element
00095 . stride - Stride (in bytes) between each block
00096 - dataloop - Dataloop of each element
00097 
00098   Module:
00099   Datatype
00100   S*/
00101 typedef struct DLOOP_Dataloop_vector { 
00102     DLOOP_Count count;
00103     struct DLOOP_Dataloop *dataloop;
00104     DLOOP_Count blocksize;
00105     DLOOP_Offset stride;
00106 } DLOOP_Dataloop_vector;
00107 
00108 /*S
00109   DLOOP_Dataloop_blockindexed - Description of a block-indexed dataloop
00110 
00111   Fields:
00112 + count - Number of blocks
00113 . blocksize - Number of elements in each block
00114 . offset_array - Array of offsets (in bytes) to each block
00115 . total_blocks - count of total blocks in the array (cached value)
00116 - dataloop - Dataloop of each element
00117 
00118   Module:
00119   Datatype
00120 
00121   S*/
00122 typedef struct DLOOP_Dataloop_blockindexed {
00123     DLOOP_Count count;
00124     struct DLOOP_Dataloop *dataloop;
00125     DLOOP_Count blocksize;
00126     DLOOP_Offset *offset_array;
00127 } DLOOP_Dataloop_blockindexed;
00128 
00129 /*S
00130   DLOOP_Dataloop_indexed - Description of an indexed dataloop
00131 
00132   Fields:
00133 + count - Number of blocks
00134 . blocksize_array - Array giving the number of elements in each block
00135 . offset_array - Array of offsets (in bytes) to each block
00136 . total_blocks - count of total blocks in the array (cached value)
00137 - dataloop - Dataloop of each element
00138 
00139   Module:
00140   Datatype
00141 
00142   S*/
00143 typedef struct DLOOP_Dataloop_indexed {
00144     DLOOP_Count count;
00145     struct DLOOP_Dataloop *dataloop;
00146     DLOOP_Count *blocksize_array;
00147     DLOOP_Offset *offset_array;
00148     DLOOP_Count total_blocks;
00149 } DLOOP_Dataloop_indexed;
00150 
00151 /*S
00152   DLOOP_Dataloop_struct - Description of a structure dataloop
00153 
00154   Fields:
00155 + count - Number of blocks
00156 . blocksize_array - Array giving the number of elements in each block
00157 . offset_array - Array of offsets (in bytes) to each block
00158 - dataloop_array - Array of dataloops describing the elements of each block
00159 
00160   Module:
00161   Datatype
00162 
00163   S*/
00164 typedef struct DLOOP_Dataloop_struct {
00165     DLOOP_Count count;
00166     struct DLOOP_Dataloop **dataloop_array;
00167     DLOOP_Count            *blocksize_array;
00168     DLOOP_Offset           *offset_array;
00169     DLOOP_Offset           *el_extent_array; /* need more than one */
00170 } DLOOP_Dataloop_struct;
00171 
00172 /* In many cases, we need the count and the next dataloop item. This
00173    common structure gives a quick access to both.  Note that all other 
00174    structures must use the same ordering of elements.
00175    Question: should we put the pointer first in case 
00176    sizeof(pointer)>sizeof(int) ? 
00177 */
00178 typedef struct DLOOP_Dataloop_common {
00179     DLOOP_Count count;
00180     struct DLOOP_Dataloop *dataloop;
00181 } DLOOP_Dataloop_common;
00182 
00183 /*S
00184   DLOOP_Dataloop - Description of the structure used to hold a dataloop
00185   description
00186 
00187   Fields:
00188 +  kind - Describes the type of the dataloop.  This is divided into three
00189    separate bit fields\:
00190 .vb
00191      Dataloop type (e.g., DLOOP_CONTIG etc.).  3 bits
00192      IsFinal (a "leaf" dataloop; see text) 1 bit
00193      Element Size (units for fields.) 2 bits
00194         Element size has 4 values
00195         0   - Elements are in units of bytes
00196         1   - Elements are in units of 2 bytes
00197         2   - Elements are in units of 4 bytes
00198         3   - Elements are in units of 8 bytes
00199 .ve
00200   The dataloop type is one of 'DLOOP_CONTIG', 'DLOOP_VECTOR', 
00201   'DLOOP_BLOCKINDEXED', 'DLOOP_INDEXED', or 'DLOOP_STRUCT'.  
00202 . loop_parms - A union containing the 5 dataloop structures, e.g., 
00203   'DLOOP_Dataloop_contig', 'DLOOP_Dataloop_vector', etc.  A sixth element in
00204   this union, 'count', allows quick access to the shared 'count' field in the
00205   five dataloop structure.
00206 . extent - The extent of the dataloop
00207 
00208   Module:
00209   Datatype
00210 
00211   S*/
00212 typedef struct DLOOP_Dataloop { 
00213     int kind;                  /* Contains both the loop type 
00214                   (contig, vector, blockindexed, indexed,
00215                   or struct) and a bit that indicates 
00216                   whether the dataloop is a leaf type. */
00217     union {
00218     DLOOP_Count                 count;
00219     DLOOP_Dataloop_contig       c_t;
00220     DLOOP_Dataloop_vector       v_t;
00221     DLOOP_Dataloop_blockindexed bi_t;
00222     DLOOP_Dataloop_indexed      i_t;
00223     DLOOP_Dataloop_struct       s_t;
00224     DLOOP_Dataloop_common       cm_t;
00225     } loop_params;
00226     DLOOP_Offset el_size; /* I don't feel like dealing with the bit manip. 
00227                * needed to get the packed size right at the moment.
00228                */
00229     DLOOP_Offset el_extent;
00230     DLOOP_Type   el_type;
00231 } DLOOP_Dataloop;
00232 
00233 #define DLOOP_FINAL_MASK  0x00000008
00234 #define DLOOP_KIND_MASK   0x00000007
00235 #define DLOOP_KIND_CONTIG 0x1
00236 #define DLOOP_KIND_VECTOR 0x2
00237 #define DLOOP_KIND_BLOCKINDEXED 0x3
00238 #define DLOOP_KIND_INDEXED 0x4
00239 #define DLOOP_KIND_STRUCT 0x5
00240 
00241 /* The max datatype depth is the maximum depth of the stack used to 
00242    evaluate datatypes.  It represents the length of the chain of 
00243    datatype dependencies.  Defining this and testing when a datatype
00244    is created removes a test in the datatype evaluation loop. */
00245 #define DLOOP_MAX_DATATYPE_DEPTH 8
00246 
00247 /*S
00248   DLOOP_Dataloop_stackelm - Structure for an element of the stack used
00249   to process dataloops
00250 
00251   Fields:
00252 + curcount - Current loop count value (between 0 and 
00253              loop.loop_params.count-1) 
00254 . orig_count - original count value (cached so we don't have to look it up)
00255 . curoffset - Offset into memory relative to the pointer to the buffer
00256               passed in by the user.  Used to maintain our position as we
00257               move up and down the stack.  NEED MORE NOTES ON THIS!!!
00258 . orig_offset - original offset, set before the stackelm is processed, so that
00259                 we know where the offset was.  this is used in processing indexed
00260                 types and possibly others.  it is set for all types, but not
00261         referenced in some cases.
00262 . curblock - Current block value...NEED MORE NOTES ON THIS!!!
00263 . orig_block - original block value (caches so we don't have to look it up);
00264                INVALID FOR INDEX AND STRUCT TYPES.
00265 - loop_p  - pointer to Loop-based description of the dataloop
00266 
00267 S*/
00268 typedef struct DLOOP_Dataloop_stackelm {
00269     int may_require_reloading; /* indicates that items below might
00270                 * need reloading (e.g. this is a struct)
00271                 */
00272 
00273     DLOOP_Count  curcount;
00274     DLOOP_Offset curoffset;
00275     DLOOP_Count  curblock;
00276 
00277     DLOOP_Count  orig_count;
00278     DLOOP_Offset orig_offset;
00279     DLOOP_Count  orig_block;
00280 
00281     struct DLOOP_Dataloop *loop_p;
00282 } DLOOP_Dataloop_stackelm;
00283 
00284 /*S
00285   DLOOP_Segment - Description of the Segment datatype
00286 
00287   Notes:
00288   This has no corresponding MPI datatype.
00289 
00290   Module:
00291   Segment
00292 
00293   Questions:
00294   Should this have an id for allocation and similarity purposes?
00295   S*/
00296 typedef struct DLOOP_Segment { 
00297     void *ptr; /* pointer to datatype buffer */
00298     DLOOP_Handle handle;
00299     DLOOP_Offset stream_off; /* next offset into data stream resulting from datatype
00300                       * processing.  in other words, how many bytes have
00301                   * we created/used by parsing so far?  that amount + 1.
00302                   */
00303     DLOOP_Dataloop_stackelm stackelm[DLOOP_MAX_DATATYPE_DEPTH];
00304     int  cur_sp;   /* Current stack pointer when using dataloop */
00305     int  valid_sp; /* maximum valid stack pointer.  This is used to 
00306                       maintain information on the stack after it has
00307                       been placed there by following the datatype field
00308                       in a DLOOP_Dataloop_st for any type except struct */
00309 
00310     struct DLOOP_Dataloop builtin_loop; /* used for both predefined types (which
00311                           * won't have a loop already) and for 
00312                   * situations where a count is passed in 
00313                   * and we need to create a contig loop
00314                   * to handle it
00315                   */
00316     /* other, device-specific information */
00317 } DLOOP_Segment;
00318 
00319 /* Dataloop functions (dataloop.c) */
00320 void PREPEND_PREFIX(Dataloop_copy)(void *dest,
00321                    void *src,
00322                    int size);
00323 void PREPEND_PREFIX(Dataloop_update)(DLOOP_Dataloop *dataloop,
00324                      DLOOP_Offset ptrdiff);
00325 DLOOP_Offset
00326 PREPEND_PREFIX(Dataloop_stream_size)(DLOOP_Dataloop *dl_p,
00327                      DLOOP_Offset (*sizefn)(DLOOP_Type el_type));
00328 void PREPEND_PREFIX(Dataloop_print)(DLOOP_Dataloop *dataloop,
00329                     int depth);
00330 
00331 void PREPEND_PREFIX(Dataloop_alloc)(int kind,
00332                     DLOOP_Count count,
00333                     DLOOP_Dataloop **new_loop_p,
00334                     int *new_loop_sz_p);
00335 void PREPEND_PREFIX(Dataloop_alloc_and_copy)(int kind,
00336                          DLOOP_Count count,
00337                          DLOOP_Dataloop *old_loop,
00338                          int old_loop_sz,
00339                          DLOOP_Dataloop **new_loop_p,
00340                          int *new_loop_sz_p);
00341 void PREPEND_PREFIX(Dataloop_struct_alloc)(DLOOP_Count count,
00342                        int old_loop_sz,
00343                        int basic_ct,
00344                        DLOOP_Dataloop **old_loop_p,
00345                        DLOOP_Dataloop **new_loop_p,
00346                        int *new_loop_sz_p);
00347 void PREPEND_PREFIX(Dataloop_dup)(DLOOP_Dataloop *old_loop,
00348                   int old_loop_sz,
00349                   DLOOP_Dataloop **new_loop_p);
00350 
00351 void PREPEND_PREFIX(Dataloop_free)(DLOOP_Dataloop **dataloop);
00352 
00353 /* Segment functions (segment.c) */
00354 DLOOP_Segment * PREPEND_PREFIX(Segment_alloc)(void);
00355 
00356 void PREPEND_PREFIX(Segment_free)(DLOOP_Segment *segp);
00357 
00358 int PREPEND_PREFIX(Segment_init)(const DLOOP_Buffer buf,
00359                  DLOOP_Count count,
00360                  DLOOP_Handle handle,
00361                  DLOOP_Segment *segp,
00362                  int hetero);
00363 
00364 void
00365 PREPEND_PREFIX(Segment_manipulate)(DLOOP_Segment *segp,
00366                    DLOOP_Offset first, 
00367                    DLOOP_Offset *lastp, 
00368                    int (*piecefn) (DLOOP_Offset *blocks_p,
00369                            DLOOP_Type el_type,
00370                            DLOOP_Offset rel_off,
00371                            DLOOP_Buffer bufp,
00372                            void *v_paramp),
00373                    int (*vectorfn) (DLOOP_Offset *blocks_p,
00374                             DLOOP_Count count,
00375                             DLOOP_Count blklen,
00376                             DLOOP_Offset stride,
00377                             DLOOP_Type el_type,
00378                             DLOOP_Offset rel_off,
00379                             DLOOP_Buffer bufp,
00380                             void *v_paramp),
00381                    int (*blkidxfn) (DLOOP_Offset *blocks_p,
00382                             DLOOP_Count count,
00383                             DLOOP_Count blklen,
00384                             DLOOP_Offset *offsetarray,
00385                             DLOOP_Type el_type,
00386                             DLOOP_Offset rel_off,
00387                             DLOOP_Buffer bufp,
00388                             void *v_paramp),
00389                    int (*indexfn) (DLOOP_Offset *blocks_p,
00390                            DLOOP_Count count,
00391                            DLOOP_Count *blockarray,
00392                            DLOOP_Offset *offsetarray,
00393                            DLOOP_Type el_type,
00394                            DLOOP_Offset rel_off,
00395                            DLOOP_Buffer bufp,
00396                            void *v_paramp),
00397                    DLOOP_Offset (*sizefn) (DLOOP_Type el_type),
00398                    void *pieceparams);
00399 
00400 /* Common segment operations (segment_ops.c) */
00401 void PREPEND_PREFIX(Segment_count_contig_blocks)(DLOOP_Segment *segp,
00402                          DLOOP_Offset first,
00403                          DLOOP_Offset *lastp,
00404                          DLOOP_Count *countp);
00405 void PREPEND_PREFIX(Segment_mpi_flatten)(DLOOP_Segment *segp,
00406                      DLOOP_Offset first,
00407                      DLOOP_Offset *lastp,
00408                      int *blklens,
00409                      MPI_Aint *disps,
00410                      int *lengthp);
00411 
00412 #define DLOOP_M2M_TO_USERBUF   0
00413 #define DLOOP_M2M_FROM_USERBUF 1
00414 
00415 struct PREPEND_PREFIX(m2m_params) {
00416     int direction; /* M2M_TO_USERBUF or M2M_FROM_USERBUF */
00417     char *streambuf;
00418     char *userbuf;
00419 };
00420 
00421 void PREPEND_PREFIX(Segment_pack)(struct DLOOP_Segment *segp,
00422                   DLOOP_Offset   first,
00423                   DLOOP_Offset  *lastp,
00424                   void *streambuf);
00425 void PREPEND_PREFIX(Segment_unpack)(struct DLOOP_Segment *segp,
00426                     DLOOP_Offset   first,
00427                     DLOOP_Offset  *lastp,
00428                     void *streambuf);
00429 
00430 /* Segment piece functions that are used in specific cases elsewhere */
00431 int PREPEND_PREFIX(Segment_contig_m2m)(DLOOP_Offset *blocks_p,
00432                        DLOOP_Type el_type,
00433                        DLOOP_Offset rel_off,
00434                        void *bufp, /* unused */
00435                        void *v_paramp);
00436 int PREPEND_PREFIX(Segment_vector_m2m)(DLOOP_Offset *blocks_p,
00437                        DLOOP_Count count, /* unused */
00438                        DLOOP_Count blksz,
00439                        DLOOP_Offset stride,
00440                        DLOOP_Type el_type,
00441                        DLOOP_Offset rel_off,
00442                        void *bufp, /* unused */
00443                        void *v_paramp);
00444 int PREPEND_PREFIX(Segment_blkidx_m2m)(DLOOP_Offset *blocks_p,
00445                        DLOOP_Count count,
00446                        DLOOP_Count blocklen,
00447                        DLOOP_Offset *offsetarray,
00448                        DLOOP_Type el_type,
00449                        DLOOP_Offset rel_off,
00450                        void *bufp, /*unused */
00451                        void *v_paramp);
00452 int PREPEND_PREFIX(Segment_index_m2m)(DLOOP_Offset *blocks_p,
00453                       DLOOP_Count count,
00454                       DLOOP_Count *blockarray,
00455                       DLOOP_Offset *offsetarray,
00456                       DLOOP_Type el_type,
00457                       DLOOP_Offset rel_off,
00458                       void *bufp, /*unused */
00459                       void *v_paramp);
00460 #endif
00461 
00462 
00463
libs/ck-libs/ampi/romio/common/dataloop/dataloop_parts.h
