Date: 2016-07-24T16:51:00+00:00

Actual source code: sfbasic.c
petsc-3.7.3 2016-07-24
Report Typos and Errors

      2: #include <petsc/private/sfimpl.h> /*I "petscsf.h" I*/

      4: typedef struct _n_PetscSFBasicPack *PetscSFBasicPack;
      5: struct _n_PetscSFBasicPack {
      6:   void (*Pack)(PetscInt,PetscInt,const PetscInt*,const void*,void*);
      7:   void (*UnpackInsert)(PetscInt,PetscInt,const PetscInt*,void*,const void*);
      8:   void (*UnpackAdd)(PetscInt,PetscInt,const PetscInt*,void*,const void*);
      9:   void (*UnpackMin)(PetscInt,PetscInt,const PetscInt*,void*,const void*);
     10:   void (*UnpackMax)(PetscInt,PetscInt,const PetscInt*,void*,const void*);
     11:   void (*UnpackMinloc)(PetscInt,PetscInt,const PetscInt*,void*,const void*);
     12:   void (*UnpackMaxloc)(PetscInt,PetscInt,const PetscInt*,void*,const void*);
     13:   void (*UnpackMult)(PetscInt,PetscInt,const PetscInt*,void*,const void *);
     14:   void (*UnpackLAND)(PetscInt,PetscInt,const PetscInt*,void*,const void *);
     15:   void (*UnpackBAND)(PetscInt,PetscInt,const PetscInt*,void*,const void *);
     16:   void (*UnpackLOR)(PetscInt,PetscInt,const PetscInt*,void*,const void *);
     17:   void (*UnpackBOR)(PetscInt,PetscInt,const PetscInt*,void*,const void *);
     18:   void (*UnpackLXOR)(PetscInt,PetscInt,const PetscInt*,void*,const void *);
     19:   void (*UnpackBXOR)(PetscInt,PetscInt,const PetscInt*,void*,const void *);
     20:   void (*FetchAndInsert)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     21:   void (*FetchAndAdd)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     22:   void (*FetchAndMin)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     23:   void (*FetchAndMax)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     24:   void (*FetchAndMinloc)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     25:   void (*FetchAndMaxloc)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     26:   void (*FetchAndMult)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     27:   void (*FetchAndLAND)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     28:   void (*FetchAndBAND)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     29:   void (*FetchAndLOR)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     30:   void (*FetchAndBOR)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     31:   void (*FetchAndLXOR)(PetscInt,PetscInt,const PetscInt*,void*,void*);
     32:   void (*FetchAndBXOR)(PetscInt,PetscInt,const PetscInt*,void*,void*);

     34:   MPI_Datatype     unit;
     35:   size_t           unitbytes;   /* Number of bytes in a unit */
     36:   PetscInt         bs;          /* Number of basic units in a unit */
     37:   const void       *key;        /* Array used as key for operation */
     38:   char             *root;       /* Packed root data, contiguous by leaf rank */
     39:   char             *leaf;       /* Packed leaf data, contiguous by root rank */
     40:   MPI_Request      *requests;   /* Array of root requests followed by leaf requests */
     41:   PetscSFBasicPack next;
     42: };

     44: typedef struct {
     45:   PetscMPIInt      tag;
     46:   PetscMPIInt      niranks;     /* Number of incoming ranks (ranks accessing my roots) */
     47:   PetscMPIInt      *iranks;     /* Array of ranks that reference my roots */
     48:   PetscInt         itotal;      /* Total number of graph edges referencing my roots */
     49:   PetscInt         *ioffset;    /* Array of length niranks+1 holding offset in irootloc[] for each rank */
     50:   PetscInt         *irootloc;   /* Incoming roots referenced by ranks starting at ioffset[rank] */
     51:   PetscSFBasicPack avail;       /* One or more entries per MPI Datatype, lazily constructed */
     52:   PetscSFBasicPack inuse;       /* Buffers being used for transactions that have not yet completed */
     53: } PetscSF_Basic;

     55: #if !defined(PETSC_HAVE_MPI_TYPE_DUP) /* Danger: type is not reference counted; subject to ABA problem */
     56: PETSC_STATIC_INLINE PetscErrorCode MPI_Type_dup(MPI_Datatype datatype,MPI_Datatype *newtype)
     57: {
     58:   *newtype = datatype;
     59:   return 0;
     60: }
     61: #endif

     63: /*
     64:  * MPI_Reduce_local is not really useful because it can't handle sparse data and it vectorizes "in the wrong direction",
     65:  * therefore we pack data types manually. This section defines packing routines for the standard data types.
     66:  */

     68: #define CPPJoin2_exp(a,b) a ## b
     69: #define CPPJoin2(a,b) CPPJoin2_exp(a,b)
     70: #define CPPJoin3_exp_(a,b,c) a ## b ## _ ## c
     71: #define CPPJoin3_(a,b,c) CPPJoin3_exp_(a,b,c)

     73: /* Basic types without addition */
     74: #define DEF_PackNoInit(type,BS)                                         \
     75:   static void CPPJoin3_(Pack_,type,BS)(PetscInt n,PetscInt bs,const PetscInt *idx,const void *unpacked,void *packed) { \
     76:     const type *u = (const type*)unpacked;                              \
     77:     type *p = (type*)packed;                                            \
     78:     PetscInt i,j,k;                                                     \
     79:     for (i=0; i<n; i++)                                                 \
     80:       for (j=0; j<bs; j+=BS)                                            \
     81:         for (k=j; k<j+BS; k++)                                          \
     82:           p[i*bs+k] = u[idx[i]*bs+k];                                   \
     83:   }                                                                     \
     84:   static void CPPJoin3_(UnpackInsert_,type,BS)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
     85:     type *u = (type*)unpacked;                                          \
     86:     const type *p = (const type*)packed;                                \
     87:     PetscInt i,j,k;                                                     \
     88:     for (i=0; i<n; i++)                                                 \
     89:       for (j=0; j<bs; j+=BS)                                            \
     90:         for (k=j; k<j+BS; k++)                                          \
     91:           u[idx[i]*bs+k] = p[i*bs+k];                                   \
     92:   }                                                                     \
     93:   static void CPPJoin3_(FetchAndInsert_,type,BS)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
     94:     type *u = (type*)unpacked;                                          \
     95:     type *p = (type*)packed;                                            \
     96:     PetscInt i,j,k;                                                     \
     97:     for (i=0; i<n; i++) {                                               \
     98:       PetscInt ii = idx[i];                                             \
     99:       for (j=0; j<bs; j+=BS)                                            \
    100:         for (k=j; k<j+BS; k++) {                                        \
    101:           type t = u[ii*bs+k];                                          \
    102:           u[ii*bs+k] = p[i*bs+k];                                       \
    103:           p[i*bs+k] = t;                                                \
    104:         }                                                               \
    105:     }                                                                   \
    106:   }

    108: /* Basic types defining addition */
    109: #define DEF_PackAddNoInit(type,BS)                                      \
    110:   DEF_PackNoInit(type,BS)                                               \
    111:   static void CPPJoin3_(UnpackAdd_,type,BS)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    112:     type *u = (type*)unpacked;                                          \
    113:     const type *p = (const type*)packed;                                \
    114:     PetscInt i,j,k;                                                     \
    115:     for (i=0; i<n; i++)                                                 \
    116:       for (j=0; j<bs; j+=BS)                                            \
    117:         for (k=j; k<j+BS; k++)                                          \
    118:           u[idx[i]*bs+k] += p[i*bs+k];                                  \
    119:   }                                                                     \
    120:   static void CPPJoin3_(FetchAndAdd_,type,BS)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    121:     type *u = (type*)unpacked;                                          \
    122:     type *p = (type*)packed;                                            \
    123:     PetscInt i,j,k;                                                     \
    124:     for (i=0; i<n; i++) {                                               \
    125:       PetscInt ii = idx[i];                                             \
    126:       for (j=0; j<bs; j+=BS)                                            \
    127:         for (k=j; k<j+BS; k++) {                                        \
    128:           type t = u[ii*bs+k];                                          \
    129:           u[ii*bs+k] = t + p[i*bs+k];                                   \
    130:           p[i*bs+k] = t;                                                \
    131:         }                                                               \
    132:     }                                                                   \
    133:   }                                                                     \
    134:   static void CPPJoin3_(UnpackMult_,type,BS)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    135:     type *u = (type*)unpacked;                                          \
    136:     const type *p = (const type*)packed;                                \
    137:     PetscInt i,j,k;                                                     \
    138:     for (i=0; i<n; i++)                                                 \
    139:       for (j=0; j<bs; j+=BS)                                            \
    140:         for (k=j; k<j+BS; k++)                                          \
    141:           u[idx[i]*bs+k] *= p[i*bs+k];                                  \
    142:   }                                                                     \
    143:   static void CPPJoin3_(FetchAndMult_,type,BS)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    144:     type *u = (type*)unpacked;                                          \
    145:     type *p = (type*)packed;                                            \
    146:     PetscInt i,j,k;                                                     \
    147:     for (i=0; i<n; i++) {                                               \
    148:       PetscInt ii = idx[i];                                             \
    149:       for (j=0; j<bs; j+=BS)                                            \
    150:         for (k=j; k<j+BS; k++) {                                        \
    151:           type t = u[ii*bs+k];                                          \
    152:           u[ii*bs+k] = t * p[i*bs+k];                                   \
    153:           p[i*bs+k] = t;                                                \
    154:         }                                                               \
    155:     }                                                                   \
    156:   }
    157: #define DEF_Pack(type,BS)                                               \
    158:   DEF_PackAddNoInit(type,BS)                                            \
    159:   static void CPPJoin3_(PackInit_,type,BS)(PetscSFBasicPack link) {     \
    160:     link->Pack = CPPJoin3_(Pack_,type,BS);                              \
    161:     link->UnpackInsert = CPPJoin3_(UnpackInsert_,type,BS);              \
    162:     link->UnpackAdd = CPPJoin3_(UnpackAdd_,type,BS);                    \
    163:     link->UnpackMult = CPPJoin3_(UnpackMult_,type,BS);                  \
    164:     link->FetchAndInsert = CPPJoin3_(FetchAndInsert_,type,BS);          \
    165:     link->FetchAndAdd = CPPJoin3_(FetchAndAdd_,type,BS);                \
    166:     link->FetchAndMult = CPPJoin3_(FetchAndMult_,type,BS);              \
    167:     link->unitbytes = sizeof(type);                                     \
    168:   }
    169: /* Comparable types */
    170: #define DEF_PackCmp(type)                                               \
    171:   DEF_PackAddNoInit(type,1)                                             \
    172:   static void CPPJoin2(UnpackMax_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    173:     type *u = (type*)unpacked;                                          \
    174:     const type *p = (const type*)packed;                                \
    175:     PetscInt i;                                                         \
    176:     for (i=0; i<n; i++) {                                               \
    177:       type v = u[idx[i]];                                               \
    178:       u[idx[i]] = PetscMax(v,p[i]);                                     \
    179:     }                                                                   \
    180:   }                                                                     \
    181:   static void CPPJoin2(UnpackMin_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    182:     type *u = (type*)unpacked;                                          \
    183:     const type *p = (const type*)packed;                                \
    184:     PetscInt i;                                                         \
    185:     for (i=0; i<n; i++) {                                               \
    186:       type v = u[idx[i]];                                               \
    187:       u[idx[i]] = PetscMin(v,p[i]);                                     \
    188:     }                                                                   \
    189:   }                                                                     \
    190:   static void CPPJoin2(FetchAndMax_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    191:     type *u = (type*)unpacked;                                          \
    192:     type *p = (type*)packed;                                            \
    193:     PetscInt i;                                                         \
    194:     for (i=0; i<n; i++) {                                               \
    195:       PetscInt j = idx[i];                                              \
    196:       type v = u[j];                                                    \
    197:       u[j] = PetscMax(v,p[i]);                                          \
    198:       p[i] = v;                                                         \
    199:     }                                                                   \
    200:   }                                                                     \
    201:   static void CPPJoin2(FetchAndMin_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    202:     type *u = (type*)unpacked;                                          \
    203:     type *p = (type*)packed;                                            \
    204:     PetscInt i;                                                         \
    205:     for (i=0; i<n; i++) {                                               \
    206:       PetscInt j = idx[i];                                              \
    207:       type v = u[j];                                                    \
    208:       u[j] = PetscMin(v,p[i]);                                          \
    209:       p[i] = v;                                                         \
    210:     }                                                                   \
    211:   }                                                                     \
    212:   static void CPPJoin2(PackInit_,type)(PetscSFBasicPack link) {         \
    213:     link->Pack = CPPJoin3_(Pack_,type,1);                               \
    214:     link->UnpackInsert = CPPJoin3_(UnpackInsert_,type,1);               \
    215:     link->UnpackAdd  = CPPJoin3_(UnpackAdd_,type,1);                    \
    216:     link->UnpackMax  = CPPJoin2(UnpackMax_,type);                       \
    217:     link->UnpackMin  = CPPJoin2(UnpackMin_,type);                       \
    218:     link->UnpackMult = CPPJoin3_(UnpackMult_,type,1);                   \
    219:     link->FetchAndInsert = CPPJoin3_(FetchAndInsert_,type,1);           \
    220:     link->FetchAndAdd = CPPJoin3_(FetchAndAdd_ ,type,1);                \
    221:     link->FetchAndMax = CPPJoin2(FetchAndMax_ ,type);                   \
    222:     link->FetchAndMin = CPPJoin2(FetchAndMin_ ,type);                   \
    223:     link->FetchAndMult = CPPJoin3_(FetchAndMult_,type,1);               \
    224:     link->unitbytes = sizeof(type);                                     \
    225:   }

    227: /* Logical Types */
    228: #define DEF_PackLog(type)                                               \
    229:   static void CPPJoin2(UnpackLAND_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    230:     type *u = (type*)unpacked;                                          \
    231:     const type *p = (const type*)packed;                                \
    232:     PetscInt i;                                                         \
    233:     for (i=0; i<n; i++) {                                               \
    234:       type v = u[idx[i]];                                               \
    235:       u[idx[i]] = v && p[i];                                            \
    236:     }                                                                   \
    237:   }                                                                     \
    238:   static void CPPJoin2(UnpackLOR_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    239:     type *u = (type*)unpacked;                                          \
    240:     const type *p = (const type*)packed;                                \
    241:     PetscInt i;                                                         \
    242:     for (i=0; i<n; i++) {                                               \
    243:       type v = u[idx[i]];                                               \
    244:       u[idx[i]] = v || p[i];                                            \
    245:     }                                                                   \
    246:   }                                                                     \
    247:   static void CPPJoin2(UnpackLXOR_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    248:     type *u = (type*)unpacked;                                          \
    249:     const type *p = (const type*)packed;                                \
    250:     PetscInt i;                                                         \
    251:     for (i=0; i<n; i++) {                                               \
    252:       type v = u[idx[i]];                                               \
    253:       u[idx[i]] = (!v)!=(!p[i]);                                        \
    254:     }                                                                   \
    255:   }                                                                     \
    256:   static void CPPJoin2(FetchAndLAND_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    257:     type *u = (type*)unpacked;                                          \
    258:     type *p = (type*)packed;                                            \
    259:     PetscInt i;                                                         \
    260:     for (i=0; i<n; i++) {                                               \
    261:       PetscInt j = idx[i];                                              \
    262:       type v = u[j];                                                    \
    263:       u[j] = v && p[i];                                                 \
    264:       p[i] = v;                                                         \
    265:     }                                                                   \
    266:   }                                                                     \
    267:   static void CPPJoin2(FetchAndLOR_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    268:     type *u = (type*)unpacked;                                          \
    269:     type *p = (type*)packed;                                            \
    270:     PetscInt i;                                                         \
    271:     for (i=0; i<n; i++) {                                               \
    272:       PetscInt j = idx[i];                                              \
    273:       type v = u[j];                                                    \
    274:       u[j] = v || p[i];                                                 \
    275:       p[i] = v;                                                         \
    276:     }                                                                   \
    277:   }                                                                     \
    278:   static void CPPJoin2(FetchAndLXOR_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    279:     type *u = (type*)unpacked;                                          \
    280:     type *p = (type*)packed;                                            \
    281:     PetscInt i;                                                         \
    282:     for (i=0; i<n; i++) {                                               \
    283:       PetscInt j = idx[i];                                              \
    284:       type v = u[j];                                                    \
    285:       u[j] = (!v)!=(!p[i]);                                             \
    286:       p[i] = v;                                                         \
    287:     }                                                                   \
    288:   }                                                                     \
    289:   static void CPPJoin2(PackInit_Logical_,type)(PetscSFBasicPack link) { \
    290:     link->UnpackLAND = CPPJoin2(UnpackLAND_,type);                      \
    291:     link->UnpackLOR  = CPPJoin2(UnpackLOR_,type);                       \
    292:     link->UnpackLXOR = CPPJoin2(UnpackLXOR_,type);                      \
    293:     link->FetchAndLAND = CPPJoin2(FetchAndLAND_,type);                  \
    294:     link->FetchAndLOR  = CPPJoin2(FetchAndLOR_,type);                   \
    295:     link->FetchAndLXOR = CPPJoin2(FetchAndLXOR_,type);                  \
    296:   }

    299: /* Bitwise Types */
    300: #define DEF_PackBit(type)                                               \
    301:   static void CPPJoin2(UnpackBAND_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    302:     type *u = (type*)unpacked;                                          \
    303:     const type *p = (const type*)packed;                                \
    304:     PetscInt i;                                                         \
    305:     for (i=0; i<n; i++) {                                               \
    306:       type v = u[idx[i]];                                               \
    307:       u[idx[i]] = v & p[i];                                             \
    308:     }                                                                   \
    309:   }                                                                     \
    310:   static void CPPJoin2(UnpackBOR_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    311:     type *u = (type*)unpacked;                                          \
    312:     const type *p = (const type*)packed;                                \
    313:     PetscInt i;                                                         \
    314:     for (i=0; i<n; i++) {                                               \
    315:       type v = u[idx[i]];                                               \
    316:       u[idx[i]] = v | p[i];                                             \
    317:     }                                                                   \
    318:   }                                                                     \
    319:   static void CPPJoin2(UnpackBXOR_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    320:     type *u = (type*)unpacked;                                          \
    321:     const type *p = (const type*)packed;                                \
    322:     PetscInt i;                                                         \
    323:     for (i=0; i<n; i++) {                                               \
    324:       type v = u[idx[i]];                                               \
    325:       u[idx[i]] = v^p[i];                                               \
    326:     }                                                                   \
    327:   }                                                                     \
    328:   static void CPPJoin2(FetchAndBAND_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    329:     type *u = (type*)unpacked;                                          \
    330:     type *p = (type*)packed;                                            \
    331:     PetscInt i;                                                         \
    332:     for (i=0; i<n; i++) {                                               \
    333:       PetscInt j = idx[i];                                              \
    334:       type v = u[j];                                                    \
    335:       u[j] = v & p[i];                                                  \
    336:       p[i] = v;                                                         \
    337:     }                                                                   \
    338:   }                                                                     \
    339:   static void CPPJoin2(FetchAndBOR_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    340:     type *u = (type*)unpacked;                                          \
    341:     type *p = (type*)packed;                                            \
    342:     PetscInt i;                                                         \
    343:     for (i=0; i<n; i++) {                                               \
    344:       PetscInt j = idx[i];                                              \
    345:       type v = u[j];                                                    \
    346:       u[j] = v | p[i];                                                  \
    347:       p[i] = v;                                                         \
    348:     }                                                                   \
    349:   }                                                                     \
    350:   static void CPPJoin2(FetchAndBXOR_,type)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    351:     type *u = (type*)unpacked;                                          \
    352:     type *p = (type*)packed;                                            \
    353:     PetscInt i;                                                         \
    354:     for (i=0; i<n; i++) {                                               \
    355:       PetscInt j = idx[i];                                              \
    356:       type v = u[j];                                                    \
    357:       u[j] = v^p[i];                                                    \
    358:       p[i] = v;                                                         \
    359:     }                                                                   \
    360:   }                                                                     \
    361:   static void CPPJoin2(PackInit_Bitwise_,type)(PetscSFBasicPack link) { \
    362:     link->UnpackBAND = CPPJoin2(UnpackBAND_,type);                      \
    363:     link->UnpackBOR  = CPPJoin2(UnpackBOR_,type);                       \
    364:     link->UnpackBXOR = CPPJoin2(UnpackBXOR_,type);                      \
    365:     link->FetchAndBAND = CPPJoin2(FetchAndBAND_,type);                  \
    366:     link->FetchAndBOR  = CPPJoin2(FetchAndBOR_,type);                   \
    367:     link->FetchAndBXOR = CPPJoin2(FetchAndBXOR_,type);                  \
    368:   }

    370: /* Pair types */
    371: #define CPPJoinloc_exp(base,op,t1,t2) base ## op ## loc_ ## t1 ## _ ## t2
    372: #define CPPJoinloc(base,op,t1,t2) CPPJoinloc_exp(base,op,t1,t2)
    373: #define PairType(type1,type2) CPPJoin3_(_pairtype_,type1,type2)
    374: #define DEF_UnpackXloc(type1,type2,locname,op)                              \
    375:   static void CPPJoinloc(Unpack,locname,type1,type2)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    376:     PairType(type1,type2) *u = (PairType(type1,type2)*)unpacked;        \
    377:     const PairType(type1,type2) *p = (const PairType(type1,type2)*)packed; \
    378:     PetscInt i;                                                         \
    379:     for (i=0; i<n; i++) {                                               \
    380:       PetscInt j = idx[i];                                              \
    381:       if (p[i].a op u[j].a) {                                           \
    382:         u[j].a = p[i].a;                                                \
    383:         u[j].b = p[i].b;                                                \
    384:       } else if (u[j].a == p[i].a) {                                    \
    385:         u[j].b = PetscMin(u[j].b,p[i].b);                               \
    386:       }                                                                 \
    387:     }                                                                   \
    388:   }                                                                     \
    389:   static void CPPJoinloc(FetchAnd,locname,type1,type2)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    390:     PairType(type1,type2) *u = (PairType(type1,type2)*)unpacked;        \
    391:     PairType(type1,type2) *p = (PairType(type1,type2)*)packed;          \
    392:     PetscInt i;                                                         \
    393:     for (i=0; i<n; i++) {                                               \
    394:       PetscInt j = idx[i];                                              \
    395:       PairType(type1,type2) v;                                          \
    396:       v.a = u[j].a;                                                     \
    397:       v.b = u[j].b;                                                     \
    398:       if (p[i].a op u[j].a) {                                           \
    399:         u[j].a = p[i].a;                                                \
    400:         u[j].b = p[i].b;                                                \
    401:       } else if (u[j].a == p[i].a) {                                    \
    402:         u[j].b = PetscMin(u[j].b,p[i].b);                               \
    403:       }                                                                 \
    404:       p[i].a = v.a;                                                     \
    405:       p[i].b = v.b;                                                     \
    406:     }                                                                   \
    407:   }
    408: #define DEF_PackPair(type1,type2)                                       \
    409:   typedef struct {type1 a; type2 b;} PairType(type1,type2);             \
    410:   static void CPPJoin3_(Pack_,type1,type2)(PetscInt n,PetscInt bs,const PetscInt *idx,const void *unpacked,void *packed) { \
    411:     const PairType(type1,type2) *u = (const PairType(type1,type2)*)unpacked; \
    412:     PairType(type1,type2) *p = (PairType(type1,type2)*)packed;          \
    413:     PetscInt i;                                                         \
    414:     for (i=0; i<n; i++) {                                               \
    415:       p[i].a = u[idx[i]].a;                                             \
    416:       p[i].b = u[idx[i]].b;                                             \
    417:     }                                                                   \
    418:   }                                                                     \
    419:   static void CPPJoin3_(UnpackInsert_,type1,type2)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    420:     PairType(type1,type2) *u = (PairType(type1,type2)*)unpacked;       \
    421:     const PairType(type1,type2) *p = (const PairType(type1,type2)*)packed; \
    422:     PetscInt i;                                                         \
    423:     for (i=0; i<n; i++) {                                               \
    424:       u[idx[i]].a = p[i].a;                                             \
    425:       u[idx[i]].b = p[i].b;                                             \
    426:     }                                                                   \
    427:   }                                                                     \
    428:   static void CPPJoin3_(UnpackAdd_,type1,type2)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,const void *packed) { \
    429:     PairType(type1,type2) *u = (PairType(type1,type2)*)unpacked;       \
    430:     const PairType(type1,type2) *p = (const PairType(type1,type2)*)packed; \
    431:     PetscInt i;                                                         \
    432:     for (i=0; i<n; i++) {                                               \
    433:       u[idx[i]].a += p[i].a;                                            \
    434:       u[idx[i]].b += p[i].b;                                            \
    435:     }                                                                   \
    436:   }                                                                     \
    437:   static void CPPJoin3_(FetchAndInsert_,type1,type2)(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    438:     PairType(type1,type2) *u = (PairType(type1,type2)*)unpacked;        \
    439:     PairType(type1,type2) *p = (PairType(type1,type2)*)packed;          \
    440:     PetscInt i;                                                         \
    441:     for (i=0; i<n; i++) {                                               \
    442:       PetscInt j = idx[i];                                              \
    443:       PairType(type1,type2) v;                                          \
    444:       v.a = u[j].a;                                                     \
    445:       v.b = u[j].b;                                                     \
    446:       u[j].a = p[i].a;                                                  \
    447:       u[j].b = p[i].b;                                                  \
    448:       p[i].a = v.a;                                                     \
    449:       p[i].b = v.b;                                                     \
    450:     }                                                                   \
    451:   }                                                                     \
    452:   static void FetchAndAdd_ ## type1 ## _ ## type2(PetscInt n,PetscInt bs,const PetscInt *idx,void *unpacked,void *packed) { \
    453:     PairType(type1,type2) *u = (PairType(type1,type2)*)unpacked;       \
    454:     PairType(type1,type2) *p = (PairType(type1,type2)*)packed;         \
    455:     PetscInt i;                                                         \
    456:     for (i=0; i<n; i++) {                                               \
    457:       PetscInt j = idx[i];                                              \
    458:       PairType(type1,type2) v;                                          \
    459:       v.a = u[j].a;                                                     \
    460:       v.b = u[j].b;                                                     \
    461:       u[j].a = v.a + p[i].a;                                            \
    462:       u[j].b = v.b + p[i].b;                                            \
    463:       p[i].a = v.a;                                                     \
    464:       p[i].b = v.b;                                                     \
    465:     }                                                                   \
    466:   }                                                                     \
    467:   DEF_UnpackXloc(type1,type2,Max,>)                                     \
    468:   DEF_UnpackXloc(type1,type2,Min,<)                                     \
    469:   static void CPPJoin3_(PackInit_,type1,type2)(PetscSFBasicPack link) { \
    470:     link->Pack = CPPJoin3_(Pack_,type1,type2);                          \
    471:     link->UnpackInsert = CPPJoin3_(UnpackInsert_,type1,type2);          \
    472:     link->UnpackAdd = CPPJoin3_(UnpackAdd_,type1,type2);                \
    473:     link->UnpackMaxloc = CPPJoin3_(UnpackMaxloc_,type1,type2);          \
    474:     link->UnpackMinloc = CPPJoin3_(UnpackMinloc_,type1,type2);          \
    475:     link->FetchAndInsert = CPPJoin3_(FetchAndInsert_,type1,type2);      \
    476:     link->FetchAndAdd = CPPJoin3_(FetchAndAdd_,type1,type2);            \
    477:     link->FetchAndMaxloc = CPPJoin3_(FetchAndMaxloc_,type1,type2);      \
    478:     link->FetchAndMinloc = CPPJoin3_(FetchAndMinloc_,type1,type2);      \
    479:     link->unitbytes = sizeof(PairType(type1,type2));                    \
    480:   }

    482: /* Currently only dumb blocks of data */
    483: #define BlockType(unit,count) CPPJoin3_(_blocktype_,unit,count)
    484: #define DEF_Block(unit,count)                                           \
    485:   typedef struct {unit v[count];} BlockType(unit,count);                \
    486:   DEF_PackNoInit(BlockType(unit,count),1)                               \
    487:   static void CPPJoin3_(PackInit_block_,unit,count)(PetscSFBasicPack link) { \
    488:     link->Pack = CPPJoin3_(Pack_,BlockType(unit,count),1);               \
    489:     link->UnpackInsert = CPPJoin3_(UnpackInsert_,BlockType(unit,count),1); \
    490:     link->FetchAndInsert = CPPJoin3_(FetchAndInsert_,BlockType(unit,count),1); \
    491:     link->unitbytes = sizeof(BlockType(unit,count));                    \
    492:   }

    494: DEF_PackCmp(int)
    495: DEF_PackBit(int)
    496: DEF_PackLog(int)
    497: DEF_PackCmp(PetscInt)
    498: DEF_PackBit(PetscInt)
    499: DEF_PackLog(PetscInt)
    500: DEF_Pack(PetscInt,2)
    501: DEF_Pack(PetscInt,3)
    502: DEF_Pack(PetscInt,4)
    503: DEF_Pack(PetscInt,5)
    504: DEF_Pack(PetscInt,7)
    505: DEF_PackCmp(PetscReal)
    506: DEF_PackLog(PetscReal)
    507: DEF_Pack(PetscReal,2)
    508: DEF_Pack(PetscReal,3)
    509: DEF_Pack(PetscReal,4)
    510: DEF_Pack(PetscReal,5)
    511: DEF_Pack(PetscReal,7)
    512: #if defined(PETSC_HAVE_COMPLEX)
    513: DEF_Pack(PetscComplex,1)
    514: DEF_Pack(PetscComplex,2)
    515: DEF_Pack(PetscComplex,3)
    516: DEF_Pack(PetscComplex,4)
    517: DEF_Pack(PetscComplex,5)
    518: DEF_Pack(PetscComplex,7)
    519: #endif
    520: DEF_PackPair(int,int)
    521: DEF_PackPair(PetscInt,PetscInt)
    522: DEF_Block(int,1)
    523: DEF_Block(int,2)
    524: DEF_Block(int,3)
    525: DEF_Block(int,4)
    526: DEF_Block(int,5)
    527: DEF_Block(int,6)
    528: DEF_Block(int,7)
    529: DEF_Block(int,8)

    533: static PetscErrorCode PetscSFSetUp_Basic(PetscSF sf)
    534: {
    535:   PetscSF_Basic *bas = (PetscSF_Basic*)sf->data;
    537:   PetscInt *rlengths,*ilengths,i;
    538:   MPI_Comm comm;
    539:   MPI_Request *rootreqs,*leafreqs;

    542:   PetscObjectGetComm((PetscObject)sf,&comm);
    543:   PetscObjectGetNewTag((PetscObject)sf,&bas->tag);
    544:   /*
    545:    * Inform roots about how many leaves and from which ranks
    546:    */
    547:   PetscMalloc1(sf->nranks,&rlengths);
    548:   /* Determine number, sending ranks, and length of incoming  */
    549:   for (i=0; i<sf->nranks; i++) {
    550:     rlengths[i] = sf->roffset[i+1] - sf->roffset[i]; /* Number of roots referenced by my leaves; for rank sf->ranks[i] */
    551:   }
    552:   PetscCommBuildTwoSided(comm,1,MPIU_INT,sf->nranks,sf->ranks,rlengths,&bas->niranks,&bas->iranks,(void**)&ilengths);
    553:   PetscFree(rlengths);

    555:   /* Send leaf identities to roots */
    556:   for (i=0,bas->itotal=0; i<bas->niranks; i++) bas->itotal += ilengths[i];
    557:   PetscMalloc2(bas->niranks+1,&bas->ioffset,bas->itotal,&bas->irootloc);
    558:   PetscMalloc2(bas->niranks,&rootreqs,sf->nranks,&leafreqs);
    559:   bas->ioffset[0] = 0;
    560:   for (i=0; i<bas->niranks; i++) {
    561:     bas->ioffset[i+1] = bas->ioffset[i] + ilengths[i];
    562:     MPI_Irecv(bas->irootloc+bas->ioffset[i],ilengths[i],MPIU_INT,bas->iranks[i],bas->tag,comm,&rootreqs[i]);
    563:   }
    564:   for (i=0; i<sf->nranks; i++) {
    565:     PetscMPIInt npoints;
    566:     PetscMPIIntCast(sf->roffset[i+1] - sf->roffset[i],&npoints);
    567:     MPI_Isend(sf->rremote+sf->roffset[i],npoints,MPIU_INT,sf->ranks[i],bas->tag,comm,&leafreqs[i]);
    568:   }
    569:   MPI_Waitall(bas->niranks,rootreqs,MPI_STATUSES_IGNORE);
    570:   MPI_Waitall(sf->nranks,leafreqs,MPI_STATUSES_IGNORE);
    571:   PetscFree(ilengths);
    572:   PetscFree2(rootreqs,leafreqs);
    573:   return(0);
    574: }

    578: static PetscErrorCode PetscSFBasicPackTypeSetup(PetscSFBasicPack link,MPI_Datatype unit)
    579: {
    581:   PetscBool      isInt,isPetscInt,isPetscReal,is2Int,is2PetscInt;
    582:   PetscInt       nPetscIntContig,nPetscRealContig;
    583: #if defined(PETSC_HAVE_COMPLEX)
    584:   PetscBool isPetscComplex;
    585:   PetscInt nPetscComplexContig;
    586: #endif

    589:   MPIPetsc_Type_compare(unit,MPI_INT,&isInt);
    590:   MPIPetsc_Type_compare(unit,MPIU_INT,&isPetscInt);
    591:   MPIPetsc_Type_compare_contig(unit,MPIU_INT,&nPetscIntContig);
    592:   MPIPetsc_Type_compare(unit,MPIU_REAL,&isPetscReal);
    593:   MPIPetsc_Type_compare_contig(unit,MPIU_REAL,&nPetscRealContig);
    594: #if defined(PETSC_HAVE_COMPLEX)
    595:   MPIPetsc_Type_compare(unit,MPIU_COMPLEX,&isPetscComplex);
    596:   MPIPetsc_Type_compare_contig(unit,MPIU_COMPLEX,&nPetscComplexContig);
    597: #endif
    598:   MPIPetsc_Type_compare(unit,MPI_2INT,&is2Int);
    599:   MPIPetsc_Type_compare(unit,MPIU_2INT,&is2PetscInt);
    600:   link->bs = 1;
    601:   if (isInt) {PackInit_int(link); PackInit_Logical_int(link); PackInit_Bitwise_int(link);}
    602:   else if (isPetscInt) {PackInit_PetscInt(link); PackInit_Logical_PetscInt(link); PackInit_Bitwise_PetscInt(link);}
    603:   else if (isPetscReal) {PackInit_PetscReal(link); PackInit_Logical_PetscReal(link);}
    604: #if defined(PETSC_HAVE_COMPLEX)
    605:   else if (isPetscComplex) PackInit_PetscComplex_1(link);
    606: #endif
    607:   else if (is2Int) PackInit_int_int(link);
    608:   else if (is2PetscInt) PackInit_PetscInt_PetscInt(link);
    609:   else if (nPetscIntContig) {
    610:     if (nPetscIntContig%7 == 0) PackInit_PetscInt_7(link);
    611:     else if (nPetscIntContig%5 == 0) PackInit_PetscInt_5(link);
    612:     else if (nPetscIntContig%4 == 0) PackInit_PetscInt_4(link);
    613:     else if (nPetscIntContig%3 == 0) PackInit_PetscInt_3(link);
    614:     else if (nPetscIntContig%2 == 0) PackInit_PetscInt_2(link);
    615:     else PackInit_PetscInt(link);
    616:     link->bs = nPetscIntContig;
    617:     link->unitbytes *= nPetscIntContig;
    618:   } else if (nPetscRealContig) {
    619:     if (nPetscRealContig%7 == 0) PackInit_PetscReal_7(link);
    620:     else if (nPetscRealContig%5 == 0) PackInit_PetscReal_5(link);
    621:     else if (nPetscRealContig%4 == 0) PackInit_PetscReal_4(link);
    622:     else if (nPetscRealContig%3 == 0) PackInit_PetscReal_3(link);
    623:     else if (nPetscRealContig%2 == 0) PackInit_PetscReal_2(link);
    624:     else PackInit_PetscReal(link);
    625:     link->bs = nPetscRealContig;
    626:     link->unitbytes *= nPetscRealContig;
    627: #if defined(PETSC_HAVE_COMPLEX)
    628:   } else if (nPetscComplexContig) {
    629:     if (nPetscComplexContig%7 == 0) PackInit_PetscComplex_7(link);
    630:     else if (nPetscComplexContig%5 == 0) PackInit_PetscComplex_5(link);
    631:     else if (nPetscComplexContig%4 == 0) PackInit_PetscComplex_4(link);
    632:     else if (nPetscComplexContig%3 == 0) PackInit_PetscComplex_3(link);
    633:     else if (nPetscComplexContig%2 == 0) PackInit_PetscComplex_2(link);
    634:     else PackInit_PetscComplex_1(link);
    635:     link->bs = nPetscComplexContig;
    636:     link->unitbytes *= nPetscComplexContig;
    637: #endif
    638:   } else {
    639:     MPI_Aint lb,bytes;
    640:     MPI_Type_get_extent(unit,&lb,&bytes);
    641:     if (lb != 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Datatype with nonzero lower bound %ld\n",(long)lb);
    642:     if (bytes % sizeof(int)) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"No support for type size not divisible by %D",sizeof(int));
    643:     switch (bytes / sizeof(int)) {
    644:     case 1: PackInit_block_int_1(link); break;
    645:     case 2: PackInit_block_int_2(link); break;
    646:     case 3: PackInit_block_int_3(link); break;
    647:     case 4: PackInit_block_int_4(link); break;
    648:     case 5: PackInit_block_int_5(link); break;
    649:     case 6: PackInit_block_int_6(link); break;
    650:     case 7: PackInit_block_int_7(link); break;
    651:     case 8: PackInit_block_int_8(link); break;
    652:     default: SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"No support for arbitrary block sizes");
    653:     }
    654:   }
    655:   MPI_Type_dup(unit,&link->unit);
    656:   return(0);
    657: }

    661: static PetscErrorCode PetscSFBasicPackGetUnpackOp(PetscSF sf,PetscSFBasicPack link,MPI_Op op,void (**UnpackOp)(PetscInt,PetscInt,const PetscInt*,void*,const void*))
    662: {
    664:   *UnpackOp = NULL;
    665:   if (op == MPIU_REPLACE) *UnpackOp = link->UnpackInsert;
    666:   else if (op == MPI_SUM || op == MPIU_SUM) *UnpackOp = link->UnpackAdd;
    667:   else if (op == MPI_PROD) *UnpackOp = link->UnpackMult;
    668:   else if (op == MPI_MAX || op == MPIU_MAX) *UnpackOp = link->UnpackMax;
    669:   else if (op == MPI_MIN || op == MPIU_MIN) *UnpackOp = link->UnpackMin;
    670:   else if (op == MPI_LAND) *UnpackOp = link->UnpackLAND;
    671:   else if (op == MPI_BAND) *UnpackOp = link->UnpackBAND;
    672:   else if (op == MPI_LOR) *UnpackOp = link->UnpackLOR;
    673:   else if (op == MPI_BOR) *UnpackOp = link->UnpackBOR;
    674:   else if (op == MPI_LXOR) *UnpackOp = link->UnpackLXOR;
    675:   else if (op == MPI_BXOR) *UnpackOp = link->UnpackBXOR;
    676:   else if (op == MPI_MAXLOC) *UnpackOp = link->UnpackMaxloc;
    677:   else if (op == MPI_MINLOC) *UnpackOp = link->UnpackMinloc;
    678:   else *UnpackOp = NULL;
    679:   return(0);
    680: }
    683: static PetscErrorCode PetscSFBasicPackGetFetchAndOp(PetscSF sf,PetscSFBasicPack link,MPI_Op op,void (**FetchAndOp)(PetscInt,PetscInt,const PetscInt*,void*,void*))
    684: {
    686:   *FetchAndOp = NULL;
    687:   if (op == MPIU_REPLACE) *FetchAndOp = link->FetchAndInsert;
    688:   else if (op == MPI_SUM || op == MPIU_SUM) *FetchAndOp = link->FetchAndAdd;
    689:   else if (op == MPI_MAX || op == MPIU_MAX) *FetchAndOp = link->FetchAndMax;
    690:   else if (op == MPI_MIN || op == MPIU_MIN) *FetchAndOp = link->FetchAndMin;
    691:   else if (op == MPI_MAXLOC) *FetchAndOp = link->FetchAndMaxloc;
    692:   else if (op == MPI_MINLOC) *FetchAndOp = link->FetchAndMinloc;
    693:   else if (op == MPI_PROD)   *FetchAndOp = link->FetchAndMult;
    694:   else if (op == MPI_LAND)   *FetchAndOp = link->FetchAndLAND;
    695:   else if (op == MPI_BAND)   *FetchAndOp = link->FetchAndBAND;
    696:   else if (op == MPI_LOR)    *FetchAndOp = link->FetchAndLOR;
    697:   else if (op == MPI_BOR)    *FetchAndOp = link->FetchAndBOR;
    698:   else if (op == MPI_LXOR)   *FetchAndOp = link->FetchAndLXOR;
    699:   else if (op == MPI_BXOR)   *FetchAndOp = link->FetchAndBXOR;
    700:   else SETERRQ(PetscObjectComm((PetscObject)sf),PETSC_ERR_SUP,"No support for MPI_Op");
    701:   return(0);
    702: }

    706: static PetscErrorCode PetscSFBasicPackGetReqs(PetscSF sf,PetscSFBasicPack link,MPI_Request **rootreqs,MPI_Request **leafreqs)
    707: {
    708:   PetscSF_Basic *bas = (PetscSF_Basic*)sf->data;

    711:   if (rootreqs) *rootreqs = link->requests;
    712:   if (leafreqs) *leafreqs = link->requests + bas->niranks;
    713:   return(0);
    714: }

    718: static PetscErrorCode PetscSFBasicPackWaitall(PetscSF sf,PetscSFBasicPack link)
    719: {
    720:   PetscSF_Basic  *bas = (PetscSF_Basic*)sf->data;

    724:   MPI_Waitall(bas->niranks+sf->nranks,link->requests,MPI_STATUSES_IGNORE);
    725:   return(0);
    726: }

    730: static PetscErrorCode PetscSFBasicGetRootInfo(PetscSF sf,PetscInt *nrootranks,const PetscMPIInt **rootranks,const PetscInt **rootoffset,const PetscInt **rootloc)
    731: {
    732:   PetscSF_Basic *bas = (PetscSF_Basic*)sf->data;

    735:   if (nrootranks) *nrootranks = bas->niranks;
    736:   if (rootranks)  *rootranks  = bas->iranks;
    737:   if (rootoffset) *rootoffset = bas->ioffset;
    738:   if (rootloc)    *rootloc    = bas->irootloc;
    739:   return(0);
    740: }

    744: static PetscErrorCode PetscSFBasicGetLeafInfo(PetscSF sf,PetscInt *nleafranks,const PetscMPIInt **leafranks,const PetscInt **leafoffset,const PetscInt **leafloc)
    745: {
    747:   if (nleafranks) *nleafranks = sf->nranks;
    748:   if (leafranks)  *leafranks  = sf->ranks;
    749:   if (leafoffset) *leafoffset = sf->roffset;
    750:   if (leafloc)    *leafloc    = sf->rmine;
    751:   return(0);
    752: }

    756: static PetscErrorCode PetscSFBasicGetPack(PetscSF sf,MPI_Datatype unit,const void *key,PetscSFBasicPack *mylink)
    757: {
    758:   PetscSF_Basic    *bas = (PetscSF_Basic*)sf->data;
    759:   PetscErrorCode   ierr;
    760:   PetscSFBasicPack link,*p;
    761:   PetscInt         nrootranks,nleafranks;
    762:   const PetscInt   *rootoffset,*leafoffset;

    765:   /* Look for types in cache */
    766:   for (p=&bas->avail; (link=*p); p=&link->next) {
    767:     PetscBool match;
    768:     MPIPetsc_Type_compare(unit,link->unit,&match);
    769:     if (match) {
    770:       *p = link->next;          /* Remove from available list */
    771:       goto found;
    772:     }
    773:   }

    775:   /* Create new composite types for each send rank */
    776:   PetscSFBasicGetRootInfo(sf,&nrootranks,NULL,&rootoffset,NULL);
    777:   PetscSFBasicGetLeafInfo(sf,&nleafranks,NULL,&leafoffset,NULL);
    778:   PetscNew(&link);
    779:   PetscSFBasicPackTypeSetup(link,unit);
    780:   PetscCalloc2(rootoffset[nrootranks]*link->unitbytes,&link->root,leafoffset[nleafranks]*link->unitbytes,&link->leaf);
    781:   PetscCalloc1(nrootranks+nleafranks,&link->requests);

    783: found:
    784:   link->key  = key;
    785:   link->next = bas->inuse;
    786:   bas->inuse = link;

    788:   *mylink = link;
    789:   return(0);
    790: }

    794: static PetscErrorCode PetscSFBasicGetPackInUse(PetscSF sf,MPI_Datatype unit,const void *key,PetscCopyMode cmode,PetscSFBasicPack *mylink)
    795: {
    796:   PetscSF_Basic    *bas = (PetscSF_Basic*)sf->data;
    797:   PetscErrorCode   ierr;
    798:   PetscSFBasicPack link,*p;

    801:   /* Look for types in cache */
    802:   for (p=&bas->inuse; (link=*p); p=&link->next) {
    803:     PetscBool match;
    804:     MPIPetsc_Type_compare(unit,link->unit,&match);
    805:     if (match && (key == link->key)) {
    806:       switch (cmode) {
    807:       case PETSC_OWN_POINTER: *p = link->next; break; /* Remove from inuse list */
    808:       case PETSC_USE_POINTER: break;
    809:       default: SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"invalid cmode");
    810:       }
    811:       *mylink = link;
    812:       return(0);
    813:     }
    814:   }
    815:   SETERRQ(PetscObjectComm((PetscObject)sf),PETSC_ERR_ARG_WRONGSTATE,"Could not find pack");
    816:   return(0);
    817: }

    821: static PetscErrorCode PetscSFBasicReclaimPack(PetscSF sf,PetscSFBasicPack *link)
    822: {
    823:   PetscSF_Basic *bas = (PetscSF_Basic*)sf->data;

    826:   (*link)->key  = NULL;
    827:   (*link)->next = bas->avail;
    828:   bas->avail    = *link;
    829:   *link         = NULL;
    830:   return(0);
    831: }

    835: static PetscErrorCode PetscSFSetFromOptions_Basic(PetscOptionItems *PetscOptionsObject,PetscSF sf)
    836: {

    840:   PetscOptionsHead(PetscOptionsObject,"PetscSF Basic options");
    841:   PetscOptionsTail();
    842:   return(0);
    843: }

    847: static PetscErrorCode PetscSFReset_Basic(PetscSF sf)
    848: {
    849:   PetscSF_Basic    *bas = (PetscSF_Basic*)sf->data;
    850:   PetscErrorCode   ierr;
    851:   PetscSFBasicPack link,next;

    854:   PetscFree(bas->iranks);
    855:   PetscFree2(bas->ioffset,bas->irootloc);
    856:   if (bas->inuse) SETERRQ(PetscObjectComm((PetscObject)sf),PETSC_ERR_ARG_WRONGSTATE,"Outstanding operation has not been completed");
    857:   for (link=bas->avail; link; link=next) {
    858:     next = link->next;
    859: #if defined(PETSC_HAVE_MPI_TYPE_DUP)
    860:     MPI_Type_free(&link->unit);
    861: #endif
    862:     PetscFree2(link->root,link->leaf);
    863:     PetscFree(link->requests);
    864:     PetscFree(link);
    865:   }
    866:   bas->avail = NULL;
    867:   return(0);
    868: }

    872: static PetscErrorCode PetscSFDestroy_Basic(PetscSF sf)
    873: {

    877:   PetscSFReset_Basic(sf);
    878:   PetscFree(sf->data);
    879:   return(0);
    880: }

    884: static PetscErrorCode PetscSFView_Basic(PetscSF sf,PetscViewer viewer)
    885: {
    886:   /* PetscSF_Basic *bas = (PetscSF_Basic*)sf->data; */
    888:   PetscBool      iascii;

    891:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    892:   if (iascii) {
    893:     PetscViewerASCIIPrintf(viewer,"  sort=%s\n",sf->rankorder ? "rank-order" : "unordered");
    894:   }
    895:   return(0);
    896: }

    900: /* Send from roots to leaves */
    901: static PetscErrorCode PetscSFBcastBegin_Basic(PetscSF sf,MPI_Datatype unit,const void *rootdata,void *leafdata)
    902: {
    903:   PetscSF_Basic     *bas = (PetscSF_Basic*)sf->data;
    904:   PetscErrorCode    ierr;
    905:   PetscSFBasicPack  link;
    906:   PetscInt          i,nrootranks,nleafranks;
    907:   const PetscInt    *rootoffset,*leafoffset,*rootloc,*leafloc;
    908:   const PetscMPIInt *rootranks,*leafranks;
    909:   MPI_Request       *rootreqs,*leafreqs;
    910:   size_t            unitbytes;

    913:   PetscSFBasicGetRootInfo(sf,&nrootranks,&rootranks,&rootoffset,&rootloc);
    914:   PetscSFBasicGetLeafInfo(sf,&nleafranks,&leafranks,&leafoffset,&leafloc);
    915:   PetscSFBasicGetPack(sf,unit,rootdata,&link);

    917:   unitbytes = link->unitbytes;

    919:   PetscSFBasicPackGetReqs(sf,link,&rootreqs,&leafreqs);
    920:   /* Eagerly post leaf receives */
    921:   for (i=0; i<nleafranks; i++) {
    922:     PetscMPIInt n = leafoffset[i+1] - leafoffset[i];
    923:     MPI_Irecv(link->leaf+leafoffset[i]*unitbytes,n,unit,leafranks[i],bas->tag,PetscObjectComm((PetscObject)sf),&leafreqs[i]);
    924:   }
    925:   /* Pack and send root data */
    926:   for (i=0; i<nrootranks; i++) {
    927:     PetscMPIInt n          = rootoffset[i+1] - rootoffset[i];
    928:     void        *packstart = link->root+rootoffset[i]*unitbytes;
    929:     (*link->Pack)(n,link->bs,rootloc+rootoffset[i],rootdata,packstart);
    930:     MPI_Isend(packstart,n,unit,rootranks[i],bas->tag,PetscObjectComm((PetscObject)sf),&rootreqs[i]);
    931:   }
    932:   return(0);
    933: }

    937: PetscErrorCode PetscSFBcastEnd_Basic(PetscSF sf,MPI_Datatype unit,const void *rootdata,void *leafdata)
    938: {
    939:   PetscErrorCode   ierr;
    940:   PetscSFBasicPack link;
    941:   PetscInt         i,nleafranks;
    942:   const PetscInt   *leafoffset,*leafloc;

    945:   PetscSFBasicGetPackInUse(sf,unit,rootdata,PETSC_OWN_POINTER,&link);
    946:   PetscSFBasicPackWaitall(sf,link);
    947:   PetscSFBasicGetLeafInfo(sf,&nleafranks,NULL,&leafoffset,&leafloc);
    948:   for (i=0; i<nleafranks; i++) {
    949:     PetscMPIInt n          = leafoffset[i+1] - leafoffset[i];
    950:     const void  *packstart = link->leaf+leafoffset[i]*link->unitbytes;
    951:     (*link->UnpackInsert)(n,link->bs,leafloc+leafoffset[i],leafdata,packstart);
    952:   }
    953:   PetscSFBasicReclaimPack(sf,&link);
    954:   return(0);
    955: }

    959: /* leaf -> root with reduction */
    960: PetscErrorCode PetscSFReduceBegin_Basic(PetscSF sf,MPI_Datatype unit,const void *leafdata,void *rootdata,MPI_Op op)
    961: {
    962:   PetscSF_Basic     *bas = (PetscSF_Basic*)sf->data;
    963:   PetscSFBasicPack  link;
    964:   PetscErrorCode    ierr;
    965:   PetscInt          i,nrootranks,nleafranks;
    966:   const PetscInt    *rootoffset,*leafoffset,*rootloc,*leafloc;
    967:   const PetscMPIInt *rootranks,*leafranks;
    968:   MPI_Request       *rootreqs,*leafreqs;
    969:   size_t            unitbytes;

    972:   PetscSFBasicGetRootInfo(sf,&nrootranks,&rootranks,&rootoffset,&rootloc);
    973:   PetscSFBasicGetLeafInfo(sf,&nleafranks,&leafranks,&leafoffset,&leafloc);
    974:   PetscSFBasicGetPack(sf,unit,rootdata,&link);

    976:   unitbytes = link->unitbytes;

    978:   PetscSFBasicPackGetReqs(sf,link,&rootreqs,&leafreqs);
    979:   /* Eagerly post root receives */
    980:   for (i=0; i<nrootranks; i++) {
    981:     PetscMPIInt n = rootoffset[i+1] - rootoffset[i];
    982:     MPI_Irecv(link->root+rootoffset[i]*unitbytes,n,unit,rootranks[i],bas->tag,PetscObjectComm((PetscObject)sf),&rootreqs[i]);
    983:   }
    984:   /* Pack and send leaf data */
    985:   for (i=0; i<nleafranks; i++) {
    986:     PetscMPIInt n          = leafoffset[i+1] - leafoffset[i];
    987:     void        *packstart = link->leaf+leafoffset[i]*unitbytes;
    988:     (*link->Pack)(n,link->bs,leafloc+leafoffset[i],leafdata,packstart);
    989:     MPI_Isend(packstart,n,unit,leafranks[i],bas->tag,PetscObjectComm((PetscObject)sf),&leafreqs[i]);
    990:   }
    991:   return(0);
    992: }

    996: static PetscErrorCode PetscSFReduceEnd_Basic(PetscSF sf,MPI_Datatype unit,const void *leafdata,void *rootdata,MPI_Op op)
    997: {
    998:   void             (*UnpackOp)(PetscInt,PetscInt,const PetscInt*,void*,const void*);
    999:   PetscErrorCode   ierr;
    1000:   PetscSFBasicPack link;
    1001:   PetscInt         i,nrootranks;
    1002:   PetscMPIInt      typesize = -1;
    1003:   const PetscInt   *rootoffset,*rootloc;

    1006:   PetscSFBasicGetPackInUse(sf,unit,rootdata,PETSC_OWN_POINTER,&link);
    1007:   /* This implementation could be changed to unpack as receives arrive, at the cost of non-determinism */
    1008:   PetscSFBasicPackWaitall(sf,link);
    1009:   PetscSFBasicGetRootInfo(sf,&nrootranks,NULL,&rootoffset,&rootloc);
    1010:   PetscSFBasicPackGetUnpackOp(sf,link,op,&UnpackOp);
    1011:   if (UnpackOp) {
    1012:     typesize = link->unitbytes;
    1013:   }
    1014:   else {
    1015:     MPI_Type_size(unit,&typesize);
    1016:   }
    1017:   for (i=0; i<nrootranks; i++) {
    1018:     PetscMPIInt n   = rootoffset[i+1] - rootoffset[i];
    1019:     char *packstart = (char *) link->root+rootoffset[i]*typesize;

    1021:     if (UnpackOp) {
    1022:       (*UnpackOp)(n,link->bs,rootloc+rootoffset[i],rootdata,(const void *)packstart);
    1023:     }
    1024: #if PETSC_HAVE_MPI_REDUCE_LOCAL
    1025:     else if (n) { /* the op should be defined to operate on the whole datatype, so we ignore link->bs */
    1026:       PetscInt j;

    1028:       for (j = 0; j < n; j++) {
    1029:         MPI_Reduce_local(packstart+j*typesize,((char *) rootdata)+(rootloc[rootoffset[i]+j])*typesize,1,unit,op);
    1030:       }
    1031:     }
    1032: #else
    1033:     else {
    1034:       SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"No unpacking reduction operation for this MPI_Op");
    1035:     }
    1036: #endif
    1037:   }
    1038:   PetscSFBasicReclaimPack(sf,&link);
    1039:   return(0);
    1040: }

    1044: static PetscErrorCode PetscSFFetchAndOpBegin_Basic(PetscSF sf,MPI_Datatype unit,void *rootdata,const void *leafdata,void *leafupdate,MPI_Op op)
    1045: {

    1049:   PetscSFReduceBegin_Basic(sf,unit,leafdata,rootdata,op);
    1050:   return(0);
    1051: }

    1055: static PetscErrorCode PetscSFFetchAndOpEnd_Basic(PetscSF sf,MPI_Datatype unit,void *rootdata,const void *leafdata,void *leafupdate,MPI_Op op)
    1056: {
    1057:   PetscSF_Basic     *bas = (PetscSF_Basic*)sf->data;
    1058:   void              (*FetchAndOp)(PetscInt,PetscInt,const PetscInt*,void*,void*);
    1059:   PetscErrorCode    ierr;
    1060:   PetscSFBasicPack  link;
    1061:   PetscInt          i,nrootranks,nleafranks;
    1062:   const PetscInt    *rootoffset,*leafoffset,*rootloc,*leafloc;
    1063:   const PetscMPIInt *rootranks,*leafranks;
    1064:   MPI_Request       *rootreqs,*leafreqs;
    1065:   size_t            unitbytes;

    1068:   PetscSFBasicGetPackInUse(sf,unit,rootdata,PETSC_OWN_POINTER,&link);
    1069:   /* This implementation could be changed to unpack as receives arrive, at the cost of non-determinism */
    1070:   PetscSFBasicPackWaitall(sf,link);
    1071:   unitbytes = link->unitbytes;
    1072:   PetscSFBasicGetRootInfo(sf,&nrootranks,&rootranks,&rootoffset,&rootloc);
    1073:   PetscSFBasicGetLeafInfo(sf,&nleafranks,&leafranks,&leafoffset,&leafloc);
    1074:   PetscSFBasicPackGetReqs(sf,link,&rootreqs,&leafreqs);
    1075:   /* Post leaf receives */
    1076:   for (i=0; i<nleafranks; i++) {
    1077:     PetscMPIInt n = leafoffset[i+1] - leafoffset[i];
    1078:     MPI_Irecv(link->leaf+leafoffset[i]*unitbytes,n,unit,leafranks[i],bas->tag,PetscObjectComm((PetscObject)sf),&leafreqs[i]);
    1079:   }
    1080:   /* Process local fetch-and-op, post root sends */
    1081:   PetscSFBasicPackGetFetchAndOp(sf,link,op,&FetchAndOp);
    1082:   for (i=0; i<nrootranks; i++) {
    1083:     PetscMPIInt n          = rootoffset[i+1] - rootoffset[i];
    1084:     void        *packstart = link->root+rootoffset[i]*unitbytes;

    1086:     (*FetchAndOp)(n,link->bs,rootloc+rootoffset[i],rootdata,packstart);
    1087:     MPI_Isend(packstart,n,unit,rootranks[i],bas->tag,PetscObjectComm((PetscObject)sf),&rootreqs[i]);
    1088:   }
    1089:   PetscSFBasicPackWaitall(sf,link);
    1090:   for (i=0; i<nleafranks; i++) {
    1091:     PetscMPIInt n          = leafoffset[i+1] - leafoffset[i];
    1092:     const void  *packstart = link->leaf+leafoffset[i]*unitbytes;
    1093:     (*link->UnpackInsert)(n,link->bs,leafloc+leafoffset[i],leafupdate,packstart);
    1094:   }
    1095:   PetscSFBasicReclaimPack(sf,&link);
    1096:   return(0);
    1097: }

    1101: PETSC_EXTERN PetscErrorCode PetscSFCreate_Basic(PetscSF sf)
    1102: {
    1103:   PetscSF_Basic  *bas = (PetscSF_Basic*)sf->data;

    1107:   sf->ops->SetUp           = PetscSFSetUp_Basic;
    1108:   sf->ops->SetFromOptions  = PetscSFSetFromOptions_Basic;
    1109:   sf->ops->Reset           = PetscSFReset_Basic;
    1110:   sf->ops->Destroy         = PetscSFDestroy_Basic;
    1111:   sf->ops->View            = PetscSFView_Basic;
    1112:   sf->ops->BcastBegin      = PetscSFBcastBegin_Basic;
    1113:   sf->ops->BcastEnd        = PetscSFBcastEnd_Basic;
    1114:   sf->ops->ReduceBegin     = PetscSFReduceBegin_Basic;
    1115:   sf->ops->ReduceEnd       = PetscSFReduceEnd_Basic;
    1116:   sf->ops->FetchAndOpBegin = PetscSFFetchAndOpBegin_Basic;
    1117:   sf->ops->FetchAndOpEnd   = PetscSFFetchAndOpEnd_Basic;

    1119:   PetscNewLog(sf,&bas);
    1120:   sf->data = (void*)bas;
    1121:   return(0);
    1122: }