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 #include <string.h>
00009 #include <stdio.h>
00010 #include <stdlib.h>
00011 
00012 #include "./dataloop.h"
00013 
00014 #undef DEBUG_DLOOP_SIZE
00015 #undef DLOOP_DEBUG_MEMORY
00016 
00017 /* Dataloops
00018  *
00019  * The functions here are used for the creation, copying, update, and display
00020  * of DLOOP_Dataloop structures and trees of these structures.
00021  *
00022  * Currently we store trees of dataloops in contiguous regions of memory.  They
00023  * are stored in such a way that subtrees are also stored contiguously.  This
00024  * makes it somewhat easier to copy these subtrees around.  Keep this in mind
00025  * when looking at the functions below.
00026  *
00027  * The structures used in this file are defined in mpid_datatype.h.  There is
00028  * no separate mpid_dataloop.h at this time.
00029  *
00030  * OPTIMIZATIONS:
00031  *
00032  * There are spots in the code with OPT tags that indicate where we could 
00033  * optimize particular calculations or avoid certain checks.
00034  *
00035  * NOTES:
00036  *
00037  * Don't have locks in place at this time!
00038  */
00039 
00040 /* Some functions in this file are responsible for allocation of space for
00041  * dataloops.  These structures include the dataloop structure itself
00042  * followed by a sequence of variable-sized arrays, depending on the loop
00043  * kind.  For example, a dataloop of kind DLOOP_KIND_INDEXED has a
00044  * dataloop structure followed by an array of block sizes and then an array
00045  * of offsets.
00046  *
00047  * For efficiency and ease of cleanup (preserving a single free at
00048  * deallocation), we want to allocate this memory as a single large chunk.
00049  * However, we must perform some alignment of the components of this chunk
00050  * in order to obtain correct and efficient operation across all platforms.
00051  */
00052 
00053 
00054 /*@
00055   Dataloop_free - deallocate the resources used to store a dataloop
00056 
00057   Input Parameters:
00058 . dataloop - pointer to dataloop structure
00059 @*/
00060 void PREPEND_PREFIX(Dataloop_free)(DLOOP_Dataloop **dataloop)
00061 {
00062 
00063     if (*dataloop == NULL) return;
00064 
00065 #ifdef DLOOP_DEBUG_MEMORY
00066     DLOOP_dbg_printf("DLOOP_Dataloop_free: freeing loop @ %x.\n",
00067              (int) *dataloop);
00068 #endif
00069 
00070     memset(*dataloop, 0, sizeof(DLOOP_Dataloop_common));
00071     DLOOP_Free(*dataloop);
00072     *dataloop = NULL;
00073     return;
00074 }
00075 /*@
00076   Dataloop_copy - Copy an arbitrary dataloop structure, updating
00077   pointers as necessary
00078 
00079   Input Parameters:
00080 + dest   - pointer to destination region
00081 . src    - pointer to original dataloop structure
00082 - size   - size of dataloop structure
00083 
00084   This routine parses the dataloop structure as it goes in order to
00085   determine what exactly it needs to update.
00086 
00087   Notes:
00088   It assumes that the source dataloop was allocated in our usual way;
00089   this means that the entire dataloop is in a contiguous region and that
00090   the root of the tree is first in the array.
00091 
00092   This has some implications:
00093 + we can use a contiguous copy mechanism to copy the majority of the
00094   structure
00095 - all pointers in the region are relative to the start of the data region
00096   the first dataloop in the array is the root of the tree
00097 @*/
00098 void PREPEND_PREFIX(Dataloop_copy)(void *dest,
00099                    void *src,
00100                    int size)
00101 {
00102     DLOOP_Offset ptrdiff;
00103 
00104 #ifdef DLOOP_DEBUG_MEMORY
00105     DLOOP_dbg_printf("DLOOP_Dataloop_copy: copying from %x to %x (%d bytes).\n",
00106              (int) src, (int) dest, size);
00107 #endif
00108 
00109     /* copy region first */
00110     memcpy(dest, src, size);
00111 
00112     /* Calculate difference in starting locations. DLOOP_Dataloop_update()
00113      * then traverses the new structure and updates internal pointers by
00114      * adding this difference to them. This way we can just copy the
00115      * structure, including pointers, in one big block.
00116      */
00117     ptrdiff = (char *) dest - (char *) src;
00118 
00119     /* traverse structure updating pointers */
00120     PREPEND_PREFIX(Dataloop_update)(dest, ptrdiff);
00121 
00122     return;
00123 }
00124 
00125 
00126 /*@
00127   Dataloop_update - update pointers after a copy operation
00128 
00129   Input Parameters:
00130 + dataloop - pointer to loop to update
00131 - ptrdiff - value indicating offset between old and new pointer values
00132 
00133   This function is used to recursively update all the pointers in a
00134   dataloop tree.
00135 @*/
00136 void PREPEND_PREFIX(Dataloop_update)(DLOOP_Dataloop *dataloop,
00137                      DLOOP_Offset ptrdiff)
00138 {
00139     /* OPT: only declare these variables down in the Struct case */
00140     int i;
00141     DLOOP_Dataloop **looparray;
00142 
00143     switch(dataloop->kind & DLOOP_KIND_MASK) {
00144     case DLOOP_KIND_CONTIG:
00145     case DLOOP_KIND_VECTOR:
00146         /*
00147          * All these really ugly assignments are really of the form:
00148          *
00149          * ((char *) dataloop->loop_params.c_t.loop) += ptrdiff;
00150          *
00151          * However, some compilers spit out warnings about casting on the
00152          * LHS, so we get this much nastier form instead (using common
00153          * struct for contig and vector): 
00154          */
00155         dataloop->loop_params.cm_t.dataloop = (DLOOP_Dataloop *) 
00156         ((char *) dataloop->loop_params.cm_t.dataloop + ptrdiff);
00157 
00158         if (!(dataloop->kind & DLOOP_FINAL_MASK))
00159         PREPEND_PREFIX(Dataloop_update)(dataloop->loop_params.cm_t.dataloop, ptrdiff);
00160         break;
00161 
00162     case DLOOP_KIND_BLOCKINDEXED:
00163         dataloop->loop_params.bi_t.offset_array = (DLOOP_Offset *)
00164         ((char *) dataloop->loop_params.bi_t.offset_array + ptrdiff);
00165         dataloop->loop_params.bi_t.dataloop = (DLOOP_Dataloop *)
00166         ((char *) dataloop->loop_params.bi_t.dataloop + ptrdiff);
00167 
00168         if (!(dataloop->kind & DLOOP_FINAL_MASK))
00169         PREPEND_PREFIX(Dataloop_update)(dataloop->loop_params.bi_t.dataloop, ptrdiff);
00170         break;
00171 
00172     case DLOOP_KIND_INDEXED:
00173         dataloop->loop_params.i_t.blocksize_array = (DLOOP_Count *)
00174         ((char *) dataloop->loop_params.i_t.blocksize_array + ptrdiff);
00175         dataloop->loop_params.i_t.offset_array = (DLOOP_Offset *)
00176         ((char *) dataloop->loop_params.i_t.offset_array + ptrdiff);
00177         dataloop->loop_params.i_t.dataloop = (DLOOP_Dataloop *)
00178         ((char *) dataloop->loop_params.i_t.dataloop + ptrdiff);
00179 
00180         if (!(dataloop->kind & DLOOP_FINAL_MASK))
00181         PREPEND_PREFIX(Dataloop_update)(dataloop->loop_params.i_t.dataloop, ptrdiff);
00182         break;
00183 
00184     case DLOOP_KIND_STRUCT:
00185         dataloop->loop_params.s_t.blocksize_array = (DLOOP_Count *)
00186         ((char *) dataloop->loop_params.s_t.blocksize_array + ptrdiff);
00187         dataloop->loop_params.s_t.offset_array = (DLOOP_Offset *)
00188         ((char *) dataloop->loop_params.s_t.offset_array + ptrdiff);
00189         dataloop->loop_params.s_t.dataloop_array = (DLOOP_Dataloop **)
00190         ((char *) dataloop->loop_params.s_t.dataloop_array + ptrdiff);
00191 
00192         /* fix the N dataloop pointers too */
00193         looparray = dataloop->loop_params.s_t.dataloop_array;
00194         for (i=0; i < dataloop->loop_params.s_t.count; i++) {
00195         looparray[i] = (DLOOP_Dataloop *)
00196             ((char *) looparray[i] + ptrdiff);
00197         }
00198 
00199         if (dataloop->kind & DLOOP_FINAL_MASK) break;
00200 
00201         for (i=0; i < dataloop->loop_params.s_t.count; i++) {
00202         PREPEND_PREFIX(Dataloop_update)(looparray[i], ptrdiff);
00203         }
00204         break;
00205     default:
00206         /* --BEGIN ERROR HANDLING-- */
00207         DLOOP_Assert(0);
00208         break;
00209         /* --END ERROR HANDLING-- */
00210     }
00211     return;
00212 }
00213 
00214 /*@
00215   Dataloop_alloc - allocate the resources used to store a dataloop with
00216                    no old loops associated with it.
00217 
00218   Input Parameters:
00219 + kind          - kind of dataloop to allocate
00220 . count         - number of elements in dataloop (kind dependent)
00221 . new_loop_p    - address at which to store new dataloop pointer
00222 - new_loop_sz_p - pointer to integer in which to store new loop size
00223 
00224   Notes:
00225   The count parameter passed into this function will often be different
00226   from the count passed in at the MPI layer due to optimizations.
00227 @*/
00228 void PREPEND_PREFIX(Dataloop_alloc)(int kind,
00229                     DLOOP_Count count,
00230                     DLOOP_Dataloop **new_loop_p,
00231                     int *new_loop_sz_p)
00232 {
00233     PREPEND_PREFIX(Dataloop_alloc_and_copy)(kind,
00234                         count,
00235                         NULL,
00236                         0,
00237                         new_loop_p,
00238                         new_loop_sz_p);
00239     return;
00240 }
00241 
00242 /*@
00243   Dataloop_alloc_and_copy - allocate the resources used to store a
00244                             dataloop and copy in old dataloop as
00245                 appropriate
00246 
00247   Input Parameters:
00248 + kind          - kind of dataloop to allocate
00249 . count         - number of elements in dataloop (kind dependent)
00250 . old_loop      - pointer to old dataloop (or NULL for none)
00251 . old_loop_sz   - size of old dataloop (should be zero if old_loop is NULL)
00252 . new_loop_p    - address at which to store new dataloop pointer
00253 - new_loop_sz_p - pointer to integer in which to store new loop size
00254 
00255   Notes:
00256   The count parameter passed into this function will often be different
00257   from the count passed in at the MPI layer.
00258 @*/
00259 void PREPEND_PREFIX(Dataloop_alloc_and_copy)(int kind,
00260                          DLOOP_Count count,
00261                          DLOOP_Dataloop *old_loop,
00262                          int old_loop_sz,
00263                          DLOOP_Dataloop **new_loop_p,
00264                          int *new_loop_sz_p)
00265 {
00266     int new_loop_sz = 0;
00267     int align_sz = 8; /* default aligns everything to 8-byte boundaries */
00268     int epsilon;
00269     int loop_sz = sizeof(DLOOP_Dataloop);
00270     int off_sz = 0, blk_sz = 0, ptr_sz = 0, extent_sz = 0;
00271 
00272     char *pos;
00273     DLOOP_Dataloop *new_loop;
00274 
00275 #ifdef HAVE_MAX_STRUCT_ALIGNMENT
00276     if (align_sz > HAVE_MAX_STRUCT_ALIGNMENT) {
00277     align_sz = HAVE_MAX_STRUCT_ALIGNMENT;
00278     }
00279 #endif
00280 
00281     if (old_loop != NULL) {
00282     DLOOP_Assert((old_loop_sz % align_sz) == 0);
00283     }
00284 
00285     /* calculate the space that we actually need for everything */
00286     switch (kind) {
00287     case DLOOP_KIND_STRUCT:
00288         /* need space for dataloop pointers and extents */
00289         ptr_sz = count * sizeof(DLOOP_Dataloop *);
00290         extent_sz = count * sizeof(DLOOP_Offset);
00291     case DLOOP_KIND_INDEXED:
00292         /* need space for block sizes */
00293         blk_sz = count * sizeof(DLOOP_Count);
00294     case DLOOP_KIND_BLOCKINDEXED:
00295         /* need space for block offsets */
00296         off_sz = count * sizeof(DLOOP_Offset);
00297     case DLOOP_KIND_CONTIG:
00298     case DLOOP_KIND_VECTOR:
00299         break;
00300     default:
00301         DLOOP_Assert(0);
00302     }
00303 
00304     /* pad everything that we're going to allocate */
00305     epsilon = loop_sz % align_sz;
00306     if (epsilon) loop_sz += align_sz - epsilon;
00307 
00308     epsilon = off_sz % align_sz;
00309     if (epsilon) off_sz += align_sz - epsilon;
00310 
00311     epsilon = blk_sz % align_sz;
00312     if (epsilon) blk_sz += align_sz - epsilon;
00313 
00314     epsilon = ptr_sz % align_sz;
00315     if (epsilon) ptr_sz += align_sz - epsilon;
00316 
00317     epsilon = extent_sz % align_sz;
00318     if (epsilon) extent_sz += align_sz - epsilon;
00319 
00320     new_loop_sz += loop_sz + off_sz + blk_sz + ptr_sz +
00321     extent_sz + old_loop_sz;
00322 
00323     /* allocate space */
00324     new_loop = (DLOOP_Dataloop *) DLOOP_Malloc(new_loop_sz);
00325     if (new_loop == NULL) {
00326     *new_loop_p = NULL;
00327     return;
00328     }
00329 
00330 #ifdef DLOOP_DEBUG_MEMORY
00331     DLOOP_dbg_printf("DLOOP_Dataloop_alloc_and_copy: new loop @ %x (tot sz = %d, loop = %d, off = %d, blk = %d, ptr = %d, extent = %d, old = %d)\n",
00332              (int) new_loop,
00333              new_loop_sz,
00334              loop_sz,
00335              off_sz,
00336              blk_sz,
00337              ptr_sz,
00338              extent_sz,
00339              old_loop_sz);
00340 #endif
00341 
00342     /* set all the pointers in the new dataloop structure */
00343     switch (kind) {
00344     case DLOOP_KIND_STRUCT:
00345         /* order is:
00346          * - pointers
00347          * - blocks
00348          * - offsets
00349          * - extents
00350          */
00351         new_loop->loop_params.s_t.dataloop_array =
00352         (DLOOP_Dataloop **) (((char *) new_loop) + loop_sz);
00353         new_loop->loop_params.s_t.blocksize_array =
00354         (DLOOP_Count *) (((char *) new_loop) + loop_sz + ptr_sz);
00355         new_loop->loop_params.s_t.offset_array =
00356         (DLOOP_Offset *) (((char *) new_loop) + loop_sz +
00357                   ptr_sz + blk_sz);
00358         new_loop->loop_params.s_t.el_extent_array =
00359         (DLOOP_Offset *) (((char *) new_loop) + loop_sz +
00360                   ptr_sz + blk_sz + off_sz);
00361         break;
00362     case DLOOP_KIND_INDEXED:
00363         /* order is:
00364          * - blocks
00365          * - offsets
00366          */
00367         new_loop->loop_params.i_t.blocksize_array =
00368         (DLOOP_Count *) (((char *) new_loop) + loop_sz);
00369         new_loop->loop_params.i_t.offset_array =
00370         (DLOOP_Offset *) (((char *) new_loop) + loop_sz + blk_sz);
00371         if (old_loop == NULL) {
00372         new_loop->loop_params.i_t.dataloop = NULL;
00373         }
00374         else {
00375         new_loop->loop_params.i_t.dataloop =
00376             (DLOOP_Dataloop *) (((char *) new_loop) +
00377                     (new_loop_sz - old_loop_sz));
00378         }
00379         break;
00380     case DLOOP_KIND_BLOCKINDEXED:
00381         new_loop->loop_params.bi_t.offset_array =
00382         (DLOOP_Offset *) (((char *) new_loop) + loop_sz);
00383         if (old_loop == NULL) {
00384         new_loop->loop_params.bi_t.dataloop = NULL;
00385         }
00386         else {
00387         new_loop->loop_params.bi_t.dataloop =
00388             (DLOOP_Dataloop *) (((char *) new_loop) +
00389                     (new_loop_sz - old_loop_sz));
00390         }
00391         break;
00392     case DLOOP_KIND_CONTIG:
00393         if (old_loop == NULL) {
00394         new_loop->loop_params.c_t.dataloop = NULL;
00395         }
00396         else {
00397         new_loop->loop_params.c_t.dataloop =
00398             (DLOOP_Dataloop *) (((char *) new_loop) +
00399                     (new_loop_sz - old_loop_sz));
00400         }
00401         break;
00402     case DLOOP_KIND_VECTOR:
00403         if (old_loop == NULL) {
00404         new_loop->loop_params.v_t.dataloop = NULL;
00405         }
00406         else {
00407         new_loop->loop_params.v_t.dataloop =
00408             (DLOOP_Dataloop *) (((char *) new_loop) +
00409                     (new_loop_sz - old_loop_sz));
00410         }
00411         break;
00412     default:
00413         DLOOP_Assert(0);
00414     }
00415 
00416     pos = ((char *) new_loop) + (new_loop_sz - old_loop_sz);
00417     if (old_loop != NULL) {
00418     PREPEND_PREFIX(Dataloop_copy)(pos, old_loop, old_loop_sz);
00419     }
00420 
00421     *new_loop_p    = new_loop;
00422     *new_loop_sz_p = new_loop_sz;
00423     return;
00424 }
00425 
00426 /*@
00427   Dataloop_struct_alloc - allocate the resources used to store a dataloop and
00428                           copy in old dataloop as appropriate.  this version
00429                           is specifically for use when a struct dataloop is
00430                           being created; the space to hold old dataloops in
00431                           this case must be described back to the
00432                           implementation in order for efficient copying.
00433 
00434   Input Parameters:
00435 + count         - number of elements in dataloop (kind dependent)
00436 . old_loop_sz   - size of old dataloop (should be zero if old_loop is NULL)
00437 . basic_ct      - number of basic types for which new dataloops are needed
00438 . old_loop_p    - address at which to store pointer to old loops
00439 . new_loop_p    - address at which to store new struct dataloop pointer
00440 - new_loop_sz_p - address at which to store new loop size
00441 
00442   Notes:
00443   The count parameter passed into this function will often be different
00444   from the count passed in at the MPI layer due to optimizations.
00445 
00446   The caller is responsible for filling in the region pointed to by
00447   old_loop_p (count elements).
00448 @*/
00449 void PREPEND_PREFIX(Dataloop_struct_alloc)(DLOOP_Count count,
00450                        int old_loop_sz,
00451                        int basic_ct,
00452                        DLOOP_Dataloop **old_loop_p,
00453                        DLOOP_Dataloop **new_loop_p,
00454                        int *new_loop_sz_p)
00455 {
00456     int new_loop_sz = 0;
00457     int align_sz = 8; /* default aligns everything to 8-byte boundaries */
00458     int epsilon;
00459     int loop_sz = sizeof(DLOOP_Dataloop);
00460     int off_sz, blk_sz, ptr_sz, extent_sz, basic_sz;
00461 
00462     DLOOP_Dataloop *new_loop;
00463 
00464 #ifdef HAVE_MAX_STRUCT_ALIGNMENT
00465     if (align_sz > HAVE_MAX_STRUCT_ALIGNMENT) {
00466     align_sz = HAVE_MAX_STRUCT_ALIGNMENT;
00467     }
00468 #endif
00469 
00470     /* calculate the space that we actually need for everything */
00471     ptr_sz    = count * sizeof(DLOOP_Dataloop *);
00472     extent_sz = count * sizeof(DLOOP_Offset);
00473     blk_sz    = count * sizeof(DLOOP_Count);
00474     off_sz    = count * sizeof(DLOOP_Offset);
00475     basic_sz  = sizeof(DLOOP_Dataloop);
00476 
00477     /* pad everything that we're going to allocate */
00478     epsilon = loop_sz % align_sz;
00479     if (epsilon) loop_sz += align_sz - epsilon;
00480 
00481     epsilon = off_sz % align_sz;
00482     if (epsilon) off_sz += align_sz - epsilon;
00483 
00484     epsilon = blk_sz % align_sz;
00485     if (epsilon) blk_sz += align_sz - epsilon;
00486 
00487     epsilon = ptr_sz % align_sz;
00488     if (epsilon) ptr_sz += align_sz - epsilon;
00489 
00490     epsilon = extent_sz % align_sz;
00491     if (epsilon) extent_sz += align_sz - epsilon;
00492 
00493     epsilon = basic_sz % align_sz;
00494     if (epsilon) basic_sz += align_sz - epsilon;
00495 
00496     /* note: we pad *each* basic type dataloop, because the
00497      * code used to create them assumes that we're going to
00498      * do that.
00499      */
00500 
00501     new_loop_sz += loop_sz + off_sz + blk_sz + ptr_sz +
00502     extent_sz + (basic_ct * basic_sz) + old_loop_sz;
00503 
00504     /* allocate space */
00505     new_loop = (DLOOP_Dataloop *) DLOOP_Malloc(new_loop_sz);
00506     if (new_loop == NULL) {
00507     *new_loop_p = NULL;
00508     return;
00509     }
00510 
00511 #ifdef DLOOP_DEBUG_MEMORY
00512     DLOOP_dbg_printf("DLOOP_Dataloop_struct_alloc: new loop @ %x (tot sz = %d, loop = %d, off = %d, blk = %d, ptr = %d, extent = %d, basics = %d, old = %d)\n",
00513              (int) new_loop,
00514              new_loop_sz,
00515              loop_sz,
00516              off_sz,
00517              blk_sz,
00518              ptr_sz,
00519              extent_sz,
00520              basic_sz,
00521              old_loop_sz);
00522 #endif
00523 
00524     /* set all the pointers in the new dataloop structure */
00525     new_loop->loop_params.s_t.dataloop_array = (DLOOP_Dataloop **)
00526     (((char *) new_loop) + loop_sz);
00527     new_loop->loop_params.s_t.blocksize_array = (DLOOP_Count *)
00528     (((char *) new_loop) + loop_sz + ptr_sz);
00529     new_loop->loop_params.s_t.offset_array = (DLOOP_Offset *)
00530     (((char *) new_loop) + loop_sz + ptr_sz + blk_sz);
00531     new_loop->loop_params.s_t.el_extent_array = (DLOOP_Offset *)
00532     (((char *) new_loop) + loop_sz + ptr_sz + blk_sz + off_sz);
00533 
00534     *old_loop_p = (DLOOP_Dataloop *)
00535     (((char *) new_loop) + loop_sz + ptr_sz + blk_sz + off_sz + extent_sz);
00536     *new_loop_p = new_loop;
00537     *new_loop_sz_p = new_loop_sz;
00538 
00539     return;
00540 }
00541 
00542 /*@
00543   Dataloop_dup - make a copy of a dataloop
00544 
00545   Returns 0 on success, -1 on failure.
00546 @*/
00547 void PREPEND_PREFIX(Dataloop_dup)(DLOOP_Dataloop *old_loop,
00548                   int old_loop_sz,
00549                   DLOOP_Dataloop **new_loop_p)
00550 {
00551     DLOOP_Dataloop *new_loop;
00552 
00553     DLOOP_Assert(old_loop != NULL);
00554     DLOOP_Assert(old_loop_sz > 0);
00555     
00556     new_loop = (DLOOP_Dataloop *) DLOOP_Malloc(old_loop_sz);
00557     if (new_loop == NULL) {
00558     *new_loop_p = NULL;
00559     return;
00560     }
00561 
00562     PREPEND_PREFIX(Dataloop_copy)(new_loop, old_loop, old_loop_sz);
00563     *new_loop_p = new_loop;
00564     return;
00565 }
00566 
00567 /*@
00568   Dataloop_stream_size - return the size of the data described by the dataloop
00569 
00570   Input Parameters:
00571 + dl_p   - pointer to dataloop for which we will return the size
00572 - sizefn - function for determining size of types in the corresponding stream
00573            (passing NULL will instead result in el_size values being used)
00574 
00575 @*/
00576 DLOOP_Offset
00577 PREPEND_PREFIX(Dataloop_stream_size)(struct DLOOP_Dataloop *dl_p,
00578                      DLOOP_Offset (*sizefn)(DLOOP_Type el_type))
00579 {
00580     DLOOP_Offset ret;
00581     DLOOP_Offset tmp_sz, tmp_ct = 1;
00582  
00583     for (;;)
00584     {
00585         if ((dl_p->kind & DLOOP_KIND_MASK) == DLOOP_KIND_STRUCT)
00586         {
00587             int i;
00588             
00589             tmp_sz = 0;
00590             for (i = 0; i < dl_p->loop_params.s_t.count; i++)
00591             {
00592                 ret += dl_p->loop_params.s_t.blocksize_array[i] *
00593                     PREPEND_PREFIX(Dataloop_stream_size)(dl_p->loop_params.s_t.dataloop_array[i], sizefn);
00594             }
00595             return tmp_sz * tmp_ct;
00596         }
00597 
00598         switch (dl_p->kind & DLOOP_KIND_MASK) {
00599         case DLOOP_KIND_CONTIG:
00600             tmp_ct *= dl_p->loop_params.c_t.count;
00601 #ifdef DLOOP_DEBUG_SIZE
00602             DLOOP_dbg_printf("stream_size: contig: ct = %d; new tot_ct = %d\n",
00603                              (int) dl_p->loop_params.c_t.count, (int) tmp_ct);
00604 #endif
00605             break;
00606         case DLOOP_KIND_VECTOR:
00607             tmp_ct *= dl_p->loop_params.v_t.count * dl_p->loop_params.v_t.blocksize;
00608 #ifdef DLOOP_DEBUG_SIZE
00609             DLOOP_dbg_printf("stream_size: vector: ct = %d; blk = %d; new tot_ct = %d\n",
00610                              (int) dl_p->loop_params.v_t.count,
00611                              (int) dl_p->loop_params.v_t.blocksize,
00612                              (int) tmp_ct);
00613 #endif
00614             break;
00615         case DLOOP_KIND_BLOCKINDEXED:
00616             tmp_ct *= dl_p->loop_params.bi_t.count * dl_p->loop_params.bi_t.blocksize;
00617 #ifdef DLOOP_DEBUG_SIZE
00618             DLOOP_dbg_printf("stream_size: blkindexed: blks = %d; new tot_ct = %d\n",
00619                              (int) dl_p->loop_params.bi_t.count *
00620                              (int) dl_p->loop_params.bi_t.blocksize,
00621                              (int) tmp_ct);
00622 #endif
00623             break;
00624         case DLOOP_KIND_INDEXED:
00625             tmp_ct *= dl_p->loop_params.i_t.total_blocks;
00626 #ifdef DLOOP_DEBUG_SIZE
00627             DLOOP_dbg_printf("stream_size: contig: blks = %d; new tot_ct = %d\n",
00628                              (int) dl_p->loop_params.i_t.total_blocks,
00629                              (int) tmp_ct);
00630 #endif
00631             break;
00632         default:
00633             /* --BEGIN ERROR HANDLING-- */
00634             DLOOP_Assert(0);
00635             break;
00636             /* --END ERROR HANDLING-- */
00637         }
00638 
00639         if (dl_p->kind & DLOOP_FINAL_MASK) break;
00640         else {
00641             DLOOP_Assert(dl_p->loop_params.cm_t.dataloop != NULL);
00642             dl_p = dl_p->loop_params.cm_t.dataloop;
00643         }
00644     }
00645 
00646     /* call fn for size using bottom type, or use size if fnptr is NULL */
00647     tmp_sz = ((sizefn) ? sizefn(dl_p->el_type) : dl_p->el_size);
00648 
00649     return tmp_sz * tmp_ct;
00650 }
00651 
00652 /* --BEGIN ERROR HANDLING-- */
00653 /*@
00654   Dataloop_print - dump a dataloop tree to stdout for debugging
00655   purposes
00656 
00657   Input Parameters:
00658 + dataloop - root of tree to dump
00659 - depth - starting depth; used to help keep up with where we are in the tree
00660 @*/
00661 void PREPEND_PREFIX(Dataloop_print)(struct DLOOP_Dataloop *dataloop,
00662                     int depth)
00663 {
00664     int i;
00665 
00666     if (dataloop == NULL)
00667     {
00668         DLOOP_dbg_printf("dataloop is NULL (probably basic type)\n");
00669         return;
00670     }
00671 
00672     DLOOP_dbg_printf("loc=%p, treedepth=%d, kind=%d, el_extent=%ld\n",
00673              dataloop, (int) depth, (int) dataloop->kind, (long) dataloop->el_extent);
00674     switch(dataloop->kind & DLOOP_KIND_MASK) {
00675     case DLOOP_KIND_CONTIG:
00676         DLOOP_dbg_printf("\tCONTIG: count=%d, datatype=%p\n", 
00677                  (int) dataloop->loop_params.c_t.count, 
00678                  dataloop->loop_params.c_t.dataloop);
00679         if (!(dataloop->kind & DLOOP_FINAL_MASK))
00680         PREPEND_PREFIX(Dataloop_print)(dataloop->loop_params.c_t.dataloop, depth+1);
00681         break;
00682     case DLOOP_KIND_VECTOR:
00683         DLOOP_dbg_printf("\tVECTOR: count=%d, blksz=%d, stride=%d, datatype=%p\n",
00684                  (int) dataloop->loop_params.v_t.count, 
00685                  (int) dataloop->loop_params.v_t.blocksize, 
00686                  (int) dataloop->loop_params.v_t.stride,
00687                  dataloop->loop_params.v_t.dataloop);
00688         if (!(dataloop->kind & DLOOP_FINAL_MASK))
00689         PREPEND_PREFIX(Dataloop_print)(dataloop->loop_params.v_t.dataloop, depth+1);
00690         break;
00691     case DLOOP_KIND_BLOCKINDEXED:
00692         DLOOP_dbg_printf("\tBLOCKINDEXED: count=%d, blksz=%d, datatype=%p\n",
00693                  (int) dataloop->loop_params.bi_t.count, 
00694                  (int) dataloop->loop_params.bi_t.blocksize, 
00695                  dataloop->loop_params.bi_t.dataloop);
00696         /* print out offsets later */
00697         if (!(dataloop->kind & DLOOP_FINAL_MASK))
00698         PREPEND_PREFIX(Dataloop_print)(dataloop->loop_params.bi_t.dataloop, depth+1);
00699         break;
00700     case DLOOP_KIND_INDEXED:
00701         DLOOP_dbg_printf("\tINDEXED: count=%d, datatype=%p\n",
00702                  (int) dataloop->loop_params.i_t.count,
00703                  dataloop->loop_params.i_t.dataloop);
00704         /* print out blocksizes and offsets later */
00705         if (!(dataloop->kind & DLOOP_FINAL_MASK))
00706         PREPEND_PREFIX(Dataloop_print)(dataloop->loop_params.i_t.dataloop, depth+1);
00707         break;
00708     case DLOOP_KIND_STRUCT:
00709         DLOOP_dbg_printf("\tSTRUCT: count=%d\n", (int) dataloop->loop_params.s_t.count);
00710         DLOOP_dbg_printf("\tblocksizes:\n");
00711         for (i=0; i < dataloop->loop_params.s_t.count; i++)
00712         DLOOP_dbg_printf("\t\t%d\n", (int) dataloop->loop_params.s_t.blocksize_array[i]);
00713         DLOOP_dbg_printf("\toffsets:\n");
00714         for (i=0; i < dataloop->loop_params.s_t.count; i++)
00715         DLOOP_dbg_printf("\t\t%d\n", (int) dataloop->loop_params.s_t.offset_array[i]);
00716         DLOOP_dbg_printf("\tdatatypes:\n");
00717         for (i=0; i < dataloop->loop_params.s_t.count; i++)
00718         DLOOP_dbg_printf("\t\t%p\n", dataloop->loop_params.s_t.dataloop_array[i]);
00719         if (dataloop->kind & DLOOP_FINAL_MASK) break;
00720 
00721         for (i=0; i < dataloop->loop_params.s_t.count; i++) {
00722         PREPEND_PREFIX(Dataloop_print)(dataloop->loop_params.s_t.dataloop_array[i],depth+1);
00723         }
00724         break;
00725     default:
00726         DLOOP_Assert(0);
00727         break;
00728     }
00729     return;
00730 }
00731 /* --END ERROR HANDLING-- */
libs/ck-libs/ampi/romio/common/dataloop/dataloop.c
