1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11  
  12 
  13 
  14 
  15 
  16 
  17 
  18 
  19 
  20 
  21 
  22 
  23 
  24 #ifndef ADIOI_INCLUDE
  25 #define ADIOI_INCLUDE
  26 
  27 
  28 
  29 
  30 
  31 struct ADIOI_Hints_struct {
  32     int initialized;
  33     int striping_factor;
  34     int striping_unit;
  35     int cb_read;
  36     int cb_write;
  37     int cb_nodes;
  38     int cb_buffer_size;
  39     int cb_pfr;
  40     int cb_fr_type;
  41     int cb_fr_alignment;
  42     int cb_ds_threshold;
  43     int cb_alltoall;
  44     int ds_read;
  45     int ds_write;
  46     int no_indep_rw;
  47     int ind_rd_buffer_size;
  48     int ind_wr_buffer_size;
  49     int deferred_open;
  50     int min_fdomain_size;
  51     char *cb_config_list;
  52     int *ranklist;
  53     union {
  54             struct {
  55                     int listio_read;
  56                     int listio_write;
  57             } pvfs;
  58             struct {
  59                     int debugmask;
  60                     int posix_read;
  61                     int posix_write;
  62                     int listio_read;
  63                     int listio_write;
  64                     int dtype_read;
  65                     int dtype_write;
  66             } pvfs2;
  67             struct {
  68                     int start_iodevice;
  69                     int co_ratio;
  70                     int coll_threshold;
  71                     int ds_in_coll;
  72             } lustre;
  73                 struct {
  74                         unsigned read_chunk_sz; 
  75                         unsigned write_chunk_sz; 
  76                 } xfs;
  77         struct {
  78             int *bridgelist; 
  79             int *bridgelistnum; 
  80 
  81 
  82             int numbridges; 
  83         } bg;
  84     } fs_hints;
  85 
  86 };
  87 
  88 typedef struct ADIOI_Datarep {
  89     char *name;
  90     void *state;
  91     MPI_Datarep_extent_function *extent_fn;
  92     MPI_Datarep_conversion_function *read_conv_fn;
  93     MPI_Datarep_conversion_function *write_conv_fn;
  94     struct ADIOI_Datarep *next; 
  95 } ADIOI_Datarep;
  96 
  97 
  98 
  99 
 100 
 101 
 102 enum {
 103     ADIOI_HINT_AUTO    = 0,
 104     ADIOI_HINT_ENABLE  = 1,
 105     ADIOI_HINT_DISABLE = 2
 106 };
 107 
 108 
 109 
 110   
 111 
 112 typedef struct ADIOI_Fl_node {  
 113     MPI_Datatype type;
 114     MPI_Count count;                   
 115     ADIO_Offset *blocklens;      
 116     ADIO_Offset *indices;        
 117     
 118 
 119 
 120 
 121 
 122 
 123 
 124 
 125     ADIO_Offset lb_idx;
 126     ADIO_Offset ub_idx;
 127     struct ADIOI_Fl_node *next;  
 128 } ADIOI_Flatlist_node;
 129 
 130 #ifdef ROMIO_PVFS2
 131 #include <pvfs2.h>
 132 #endif
 133 typedef struct ADIOI_AIO_req_str {
 134         
 135 
 136         MPI_Request req;
 137         MPI_Offset nbytes;
 138         
 139 #ifdef ROMIO_HAVE_WORKING_AIO
 140         struct aiocb *aiocbp;
 141 #endif
 142 #ifdef ROMIO_PVFS2
 143         PVFS_sys_op_id op_id;
 144         PVFS_sysresp_io resp_io;
 145         PVFS_Request file_req;
 146         PVFS_Request mem_req;
 147 #endif
 148 #ifdef ROMIO_NTFS
 149     
 150     LPOVERLAPPED    lpOvl;
 151     
 152         HANDLE fd;
 153 #endif
 154 } ADIOI_AIO_Request;
 155 
 156 struct ADIOI_Fns_struct {
 157     void (*ADIOI_xxx_Open) (ADIO_File fd, int *error_code);
 158     void (*ADIOI_xxx_OpenColl) (ADIO_File fd, int rank, 
 159                     int access_mode, int *error_code);
 160     void (*ADIOI_xxx_ReadContig) (ADIO_File fd, void *buf, int count,
 161                    MPI_Datatype datatype, int file_ptr_type,
 162                    ADIO_Offset offset, ADIO_Status *status, int *error_code);
 163     void (*ADIOI_xxx_WriteContig) (ADIO_File fd, const void *buf, int count,
 164                    MPI_Datatype datatype, int file_ptr_type,
 165                    ADIO_Offset offset, ADIO_Status *status, int *error_code);  
 166     void (*ADIOI_xxx_ReadStridedColl) (ADIO_File fd, void *buf, int count,
 167                MPI_Datatype datatype, int file_ptr_type,
 168                ADIO_Offset offset, ADIO_Status *status, int *error_code);
 169     void (*ADIOI_xxx_WriteStridedColl) (ADIO_File fd, const void *buf, int count,
 170                MPI_Datatype datatype, int file_ptr_type,
 171                ADIO_Offset offset, ADIO_Status *status, int *error_code);
 172     ADIO_Offset (*ADIOI_xxx_SeekIndividual) (ADIO_File fd, ADIO_Offset offset, 
 173                        int whence, int *error_code);
 174     void (*ADIOI_xxx_Fcntl) (ADIO_File fd, int flag, 
 175                              ADIO_Fcntl_t *fcntl_struct, int *error_code); 
 176     void (*ADIOI_xxx_SetInfo) (ADIO_File fd, MPI_Info users_info, 
 177                                int *error_code);
 178     void (*ADIOI_xxx_ReadStrided) (ADIO_File fd, void *buf, int count,
 179                MPI_Datatype datatype, int file_ptr_type,
 180                ADIO_Offset offset, ADIO_Status *status, int *error_code);
 181     void (*ADIOI_xxx_WriteStrided) (ADIO_File fd, const void *buf, int count,
 182                MPI_Datatype datatype, int file_ptr_type,
 183                ADIO_Offset offset, ADIO_Status *status, int *error_code);
 184     void (*ADIOI_xxx_Close) (ADIO_File fd, int *error_code);
 185     void (*ADIOI_xxx_IreadContig) (ADIO_File fd, void *buf, int count, 
 186                    MPI_Datatype datatype, int file_ptr_type, 
 187                    ADIO_Offset offset, ADIO_Request *request, int *error_code);
 188     void (*ADIOI_xxx_IwriteContig) (ADIO_File fd, const void *buf, int count,
 189                    MPI_Datatype datatype, int file_ptr_type,
 190                    ADIO_Offset offset, ADIO_Request *request, int *error_code);
 191     int (*ADIOI_xxx_ReadDone) (ADIO_Request *request, ADIO_Status *status, 
 192                int *error_code); 
 193     int (*ADIOI_xxx_WriteDone) (ADIO_Request *request, ADIO_Status *status, 
 194                int *error_code);
 195     void (*ADIOI_xxx_ReadComplete) (ADIO_Request *request, ADIO_Status *status, 
 196                int *error_code); 
 197     void (*ADIOI_xxx_WriteComplete) (ADIO_Request *request, ADIO_Status *status,
 198                int *error_code); 
 199     void (*ADIOI_xxx_IreadStrided) (ADIO_File fd, void *buf, int count,
 200                MPI_Datatype datatype, int file_ptr_type,
 201                ADIO_Offset offset, ADIO_Request *request, int *error_code);
 202     void (*ADIOI_xxx_IwriteStrided) (ADIO_File fd, const void *buf, int count,
 203                MPI_Datatype datatype, int file_ptr_type,
 204                ADIO_Offset offset, ADIO_Request *request, int *error_code);
 205     void (*ADIOI_xxx_Flush) (ADIO_File fd, int *error_code); 
 206     void (*ADIOI_xxx_Resize) (ADIO_File fd, ADIO_Offset size, int *error_code);
 207     void (*ADIOI_xxx_Delete) (const char *filename, int *error_code);
 208     int  (*ADIOI_xxx_Feature) (ADIO_File fd, int flag);
 209     const char *fsname;
 210     void (*ADIOI_xxx_IreadStridedColl) (ADIO_File fd, void *buf, int count,
 211            MPI_Datatype datatype, int file_ptr_type,
 212            ADIO_Offset offset, ADIO_Request *request, int *error_code);
 213     void (*ADIOI_xxx_IwriteStridedColl) (ADIO_File fd, const void *buf,
 214            int count, MPI_Datatype datatype, int file_ptr_type,
 215            ADIO_Offset offset, ADIO_Request *request, int *error_code);
 216 };
 217 
 218 
 219 #define ADIOI_READ                26
 220 #define ADIOI_WRITE               27
 221 
 222 #define ADIOI_MIN(a, b) ((a) < (b) ? (a) : (b))
 223 #define ADIOI_MAX(a, b) ((a) > (b) ? (a) : (b))
 224 
 225 
 226 #define ADIOI_SWAP(x, y, T) do { T temp##x##y = x; x = y; y = temp##x##y; } while (0);
 227 
 228 #define ADIOI_PREALLOC_BUFSZ      16777216    
 229 
 230 
 231 
 232 
 233     
 234 #define ADIOI_CB_BUFFER_SIZE_DFLT         "16777216"
 235     
 236 #define ADIOI_IND_RD_BUFFER_SIZE_DFLT     "4194304"
 237     
 238 
 239 
 240 
 241 #define ADIOI_IND_WR_BUFFER_SIZE_DFLT     "524288"
 242     
 243 #define ADIOI_CB_CONFIG_LIST_DFLT "*:1"
 244 
 245 
 246 
 247 
 248 #define ADIOI_OpenColl(fd, rank, access_mode, error_code) \
 249         (*(fd->fns->ADIOI_xxx_OpenColl))(fd, rank, access_mode, error_code)
 250 
 251 #define ADIO_ReadContig(fd,buf,count,datatype,file_ptr_type,offset,status,error_code) \
 252         (*(fd->fns->ADIOI_xxx_ReadContig))(fd,buf,count,datatype,file_ptr_type,offset,status,error_code)
 253 
 254 #define ADIO_WriteContig(fd,buf,count,datatype,file_ptr_type,offset,status,error_code) \
 255         (*(fd->fns->ADIOI_xxx_WriteContig))(fd,buf,count,datatype,file_ptr_type,offset,status,error_code)
 256 
 257 #define ADIO_SeekIndividual(fd,offset,whence,error_code) \
 258         (*(fd->fns->ADIOI_xxx_SeekIndividual))(fd,offset,whence,error_code)
 259 
 260 #define ADIO_Fcntl(fd,flag,fcntl_struct,error_code) \
 261         (*(fd->fns->ADIOI_xxx_Fcntl))(fd,flag,fcntl_struct,error_code)
 262 
 263 #define ADIO_IreadContig(fd,buf,count,datatype,file_ptr_type,offset,request,error_code) \
 264         (*(fd->fns->ADIOI_xxx_IreadContig))(fd,buf,count,datatype,file_ptr_type,offset,request,error_code)
 265 
 266 #define ADIO_IwriteContig(fd,buf,count,datatype,file_ptr_type,offset,request,error_code) \
 267         (*(fd->fns->ADIOI_xxx_IwriteContig))(fd,buf,count,datatype,file_ptr_type,offset,request,error_code)
 268 
 269 
 270 #define ADIO_ReadDone(request,status,error_code) \
 271         (*((*(request))->fd->fns->ADIOI_xxx_ReadDone))(request,status,error_code)
 272 
 273 #define ADIO_WriteDone(request,status,error_code) \
 274         (*((*(request))->fd->fns->ADIOI_xxx_WriteDone))(request,status,error_code)
 275 
 276 #define ADIO_ReadIcomplete(request,status,error_code) \
 277         (*((*(request))->fd->fns->ADIOI_xxx_ReadIcomplete))(request,status,error_code)
 278 
 279 #define ADIO_WriteIcomplete(request,status,error_code) \
 280         (*((*(request))->fd->fns->ADIOI_xxx_WriteIcomplete))(request,status,error_code)
 281 
 282 #define ADIO_ReadComplete(request,status,error_code) \
 283         (*((*(request))->fd->fns->ADIOI_xxx_ReadComplete))(request,status,error_code)
 284 
 285 #define ADIO_WriteComplete(request,status,error_code) \
 286         (*((*(request))->fd->fns->ADIOI_xxx_WriteComplete))(request,status,error_code)
 287 
 288 #define ADIO_ReadStrided(fd,buf,count,datatype,file_ptr_type,offset,status,error_code) \
 289         (*(fd->fns->ADIOI_xxx_ReadStrided))(fd,buf,count,datatype,file_ptr_type,offset,status,error_code)
 290 
 291 #define ADIO_WriteStrided(fd,buf,count,datatype,file_ptr_type,offset,status,error_code) \
 292         (*(fd->fns->ADIOI_xxx_WriteStrided))(fd,buf,count,datatype,file_ptr_type,offset,status,error_code)
 293 
 294 #define ADIO_ReadStridedColl(fd,buf,count,datatype,file_ptr_type,offset,status,error_code) \
 295         (*(fd->fns->ADIOI_xxx_ReadStridedColl))(fd,buf,count,datatype,file_ptr_type,offset,status,error_code)
 296 
 297 #define ADIO_WriteStridedColl(fd,buf,count,datatype,file_ptr_type,offset,status,error_code) \
 298         (*(fd->fns->ADIOI_xxx_WriteStridedColl))(fd,buf,count,datatype,file_ptr_type,offset,status,error_code)
 299 
 300 #define ADIO_IreadStrided(fd,buf,count,datatype,file_ptr_type,offset,request,error_code) \
 301         (*(fd->fns->ADIOI_xxx_IreadStrided))(fd,buf,count,datatype,file_ptr_type,offset,request,error_code)
 302 
 303 #define ADIO_IwriteStrided(fd,buf,count,datatype,file_ptr_type,offset,request,error_code) \
 304         (*(fd->fns->ADIOI_xxx_IwriteStrided))(fd,buf,count,datatype,file_ptr_type,offset,request,error_code)
 305 
 306 #define ADIO_IreadStridedColl(fd,buf,count,datatype,file_ptr_type,offset,request,error_code) \
 307         (*(fd->fns->ADIOI_xxx_IreadStridedColl))(fd,buf,count,datatype,file_ptr_type,offset,request,error_code)
 308 
 309 #define ADIO_IwriteStridedColl(fd,buf,count,datatype,file_ptr_type,offset,request,error_code) \
 310         (*(fd->fns->ADIOI_xxx_IwriteStridedColl))(fd,buf,count,datatype,file_ptr_type,offset,request,error_code)
 311 
 312 #define ADIO_Flush(fd,error_code) (*(fd->fns->ADIOI_xxx_Flush))(fd,error_code)
 313 
 314 #define ADIO_Resize(fd,size,error_code) \
 315         (*(fd->fns->ADIOI_xxx_Resize))(fd,size,error_code)
 316 
 317 #define ADIO_Delete(filename,error_code) \
 318         (*(fd->fns->ADIOI_xxx_Delete))(filename,error_code)
 319 
 320 #define ADIO_SetInfo(fd, users_info, error_code) \
 321         (*(fd->fns->ADIOI_xxx_SetInfo))(fd, users_info, error_code)
 322 
 323 #define ADIO_Feature(fd, flag) \
 324         (*(fd->fns->ADIOI_xxx_Feature))(fd, flag)
 325 
 326 
 327 
 328 
 329 
 330 typedef struct {
 331     ADIO_Offset *offsets;   
 332     ADIO_Offset *lens;      
 333     MPI_Aint *mem_ptrs;     
 334 
 335 
 336     int count;             
 337 } ADIOI_Access;
 338 
 339 
 340 
 341 typedef struct {
 342     ADIO_Offset *offsets; 
 343     ADIO_Offset *lens;    
 344     int count;            
 345 } ADIOI_Offlen;
 346 
 347 
 348 
 349 
 350 int ADIOI_Type_get_envelope (MPI_Datatype datatype, int *num_integers,
 351                              int *num_addresses, int *num_datatypes, int *combiner);
 352 int ADIOI_Type_get_contents (MPI_Datatype datatype, int max_integers,
 353                              int max_addresses, int max_datatypes, int array_of_integers[],
 354                              MPI_Aint array_of_addresses[], MPI_Datatype array_of_datatypes[]);
 355 void ADIOI_SetFunctions(ADIO_File fd);
 356 void ADIOI_Flatten_datatype(MPI_Datatype type);
 357 void ADIOI_Flatten(MPI_Datatype type, ADIOI_Flatlist_node *flat,
 358                   ADIO_Offset st_offset, MPI_Count *curr_index);
 359 void ADIOI_Delete_flattened(MPI_Datatype datatype);
 360 ADIOI_Flatlist_node * ADIOI_Flatten_and_find(MPI_Datatype);
 361 MPI_Count ADIOI_Count_contiguous_blocks(MPI_Datatype type, MPI_Count *curr_index);
 362 void ADIOI_Complete_async(int *error_code);
 363 void *ADIOI_Malloc_fn(size_t size, int lineno, const char *fname);
 364 void *ADIOI_Calloc_fn(size_t nelem, size_t elsize, int lineno, const char *fname);
 365 void *ADIOI_Realloc_fn(void *ptr, size_t size, int lineno, const char *fname);
 366 void ADIOI_Free_fn(void *ptr, int lineno, const char *fname);
 367 void ADIOI_Datatype_iscontig(MPI_Datatype datatype, int *flag);
 368 void ADIOI_Get_position(ADIO_File fd, ADIO_Offset *offset);
 369 void ADIOI_Get_eof_offset(ADIO_File fd, ADIO_Offset *eof_offset);
 370 void ADIOI_Get_byte_offset(ADIO_File fd, ADIO_Offset offset,
 371                            ADIO_Offset *disp);
 372 void ADIOI_process_system_hints(ADIO_File fd, MPI_Info info);
 373 void ADIOI_incorporate_system_hints(MPI_Info info, MPI_Info sysinfo, 
 374                 MPI_Info *new_info);
 375 void ADIOI_Info_print_keyvals(MPI_Info info);
 376 
 377 
 378 void ADIOI_GEN_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct,
 379                      int *error_code);
 380 void ADIOI_GEN_Flush(ADIO_File fd, int *error_code);
 381 void ADIOI_GEN_OpenColl(ADIO_File fd, int rank, 
 382                 int access_mode, int *error_code);
 383 void ADIOI_SCALEABLE_OpenColl(ADIO_File fd, int rank, 
 384                 int access_mode, int *error_code);
 385 void ADIOI_FAILSAFE_OpenColl(ADIO_File fd, int rank, 
 386                 int access_mode, int *error_code);
 387 void ADIOI_GEN_Delete(const char *filename, int *error_code);
 388 void ADIOI_GEN_ReadContig(ADIO_File fd, void *buf, int count, 
 389                           MPI_Datatype datatype, int file_ptr_type,
 390                           ADIO_Offset offset, ADIO_Status *status,
 391                           int *error_code);
 392 int ADIOI_GEN_aio(ADIO_File fd, void *buf, int len, ADIO_Offset offset,
 393                   int wr, MPI_Request *request);
 394 void ADIOI_GEN_IreadContig(ADIO_File fd, void *buf, int count, 
 395                            MPI_Datatype datatype, int file_ptr_type,
 396                            ADIO_Offset offset, ADIO_Request *request,
 397                            int *error_code);
 398 void ADIOI_GEN_WriteContig(ADIO_File fd, const void *buf, int count,
 399                            MPI_Datatype datatype, int file_ptr_type,
 400                            ADIO_Offset offset, ADIO_Status *status,
 401                            int *error_code);
 402 void ADIOI_GEN_IwriteContig(ADIO_File fd, const void *buf, int count,
 403                             MPI_Datatype datatype, int file_ptr_type,
 404                             ADIO_Offset offset, ADIO_Request *request,
 405                             int *error_code);
 406 void ADIOI_GEN_ReadStrided(ADIO_File fd, void *buf, int count,
 407                            MPI_Datatype datatype, int file_ptr_type,
 408                            ADIO_Offset offset, ADIO_Status *status, int
 409                            *error_code);
 410 void ADIOI_GEN_IreadStrided(ADIO_File fd, void *buf, int count,
 411                             MPI_Datatype datatype, int file_ptr_type,
 412                             ADIO_Offset offset, ADIO_Request *request, int
 413                             *error_code);
 414 void ADIOI_GEN_IwriteStrided(ADIO_File fd, const void *buf, int count,
 415                              MPI_Datatype datatype, int file_ptr_type,
 416                              ADIO_Offset offset, ADIO_Request *request, int
 417                              *error_code);
 418 int ADIOI_GEN_IODone(ADIO_Request *request, ADIO_Status *status,
 419                      int *error_code);
 420 void ADIOI_GEN_IOComplete(ADIO_Request *request, ADIO_Status *status,
 421                           int *error_code);
 422 int ADIOI_GEN_aio_poll_fn(void *extra_state, ADIO_Status *status);
 423 int ADIOI_GEN_aio_wait_fn(int count, void **array_of_states, double timeout, 
 424                 ADIO_Status *status);
 425 int ADIOI_GEN_aio_query_fn(void *extra_state, ADIO_Status *status);
 426 int ADIOI_GEN_aio_free_fn(void *extra_state);
 427 int ADIOI_GEN_Feature(ADIO_File fd, int feature);
 428 
 429 void ADIOI_GEN_ReadStrided_naive(ADIO_File fd, void *buf, int count,
 430                        MPI_Datatype buftype, int file_ptr_type,
 431                        ADIO_Offset offset, ADIO_Status *status, int
 432                        *error_code);
 433 void ADIOI_GEN_WriteStrided(ADIO_File fd, const void *buf, int count,
 434                        MPI_Datatype datatype, int file_ptr_type,
 435                        ADIO_Offset offset, ADIO_Status *status, int
 436                        *error_code);
 437 void ADIOI_GEN_WriteStrided_naive(ADIO_File fd, const void *buf, int count,
 438                        MPI_Datatype datatype, int file_ptr_type,
 439                        ADIO_Offset offset, ADIO_Status *status, int
 440                        *error_code);
 441 void ADIOI_NOLOCK_WriteStrided(ADIO_File fd, const void *buf, int count,
 442                        MPI_Datatype datatype, int file_ptr_type,
 443                        ADIO_Offset offset, ADIO_Status *status, int
 444                        *error_code);
 445 void ADIOI_GEN_ReadStridedColl(ADIO_File fd, void *buf, int count,
 446                        MPI_Datatype datatype, int file_ptr_type,
 447                        ADIO_Offset offset, ADIO_Status *status, int
 448                        *error_code);
 449 #ifdef HAVE_MPI_GREQUEST_EXTENSIONS
 450 void ADIOI_GEN_IreadStridedColl(ADIO_File fd, void *buf, int count,
 451                        MPI_Datatype datatype, int file_ptr_type,
 452                        ADIO_Offset offset, MPI_Request *request,
 453                        int *error_code);
 454 #else
 455 #define ADIOI_GEN_IreadStridedColl NULL
 456 #endif
 457 void ADIOI_GEN_WriteStridedColl(ADIO_File fd, const void *buf, int count,
 458                        MPI_Datatype datatype, int file_ptr_type,
 459                        ADIO_Offset offset, ADIO_Status *status, int
 460                        *error_code);
 461 #ifdef HAVE_MPI_GREQUEST_EXTENSIONS
 462 void ADIOI_GEN_IwriteStridedColl(ADIO_File fd, const void *buf, int count,
 463                        MPI_Datatype datatype, int file_ptr_type,
 464                        ADIO_Offset offset, MPI_Request *request,
 465                        int *error_code);
 466 #else
 467 #define ADIOI_GEN_IwriteStridedColl NULL
 468 #endif
 469 void ADIOI_Calc_my_off_len(ADIO_File fd, int bufcount, MPI_Datatype
 470                             datatype, int file_ptr_type, ADIO_Offset 
 471                             offset, ADIO_Offset **offset_list_ptr, ADIO_Offset
 472                             **len_list_ptr, ADIO_Offset *start_offset_ptr,
 473                             ADIO_Offset *end_offset_ptr, int
 474                            *contig_access_count_ptr);
 475 void ADIOI_Calc_file_domains(ADIO_Offset *st_offsets, ADIO_Offset
 476                              *end_offsets, int nprocs, int nprocs_for_coll,
 477                              ADIO_Offset *min_st_offset_ptr,
 478                              ADIO_Offset **fd_start_ptr, ADIO_Offset 
 479                              **fd_end_ptr, int min_fd_size, 
 480                              ADIO_Offset *fd_size_ptr,
 481                              int striping_unit);
 482 int ADIOI_Calc_aggregator(ADIO_File fd,
 483                                  ADIO_Offset off,
 484                                  ADIO_Offset min_off,
 485                                  ADIO_Offset *len,
 486                                  ADIO_Offset fd_size,
 487                                  ADIO_Offset *fd_start,
 488                                  ADIO_Offset *fd_end);
 489 void ADIOI_Calc_my_req(ADIO_File fd, ADIO_Offset *offset_list, 
 490                             ADIO_Offset *len_list, int
 491                             contig_access_count, ADIO_Offset 
 492                             min_st_offset, ADIO_Offset *fd_start,
 493                             ADIO_Offset *fd_end, ADIO_Offset fd_size,
 494                             int nprocs,
 495                             int *count_my_req_procs_ptr,
 496                             int **count_my_req_per_proc_ptr,
 497                             ADIOI_Access **my_req_ptr,
 498                             int **buf_idx_ptr);
 499 void ADIOI_Calc_others_req(ADIO_File fd, int count_my_req_procs, 
 500                                 int *count_my_req_per_proc,
 501                                 ADIOI_Access *my_req, 
 502                                 int nprocs, int myrank,
 503                                 int *count_others_req_procs_ptr,
 504                                 ADIOI_Access **others_req_ptr);  
 505 
 506 
 507 
 508 typedef enum {
 509     ADIOI_IRC_STATE_GEN_IREADSTRIDEDCOLL,
 510     ADIOI_IRC_STATE_GEN_IREADSTRIDEDCOLL_INDIO,
 511     ADIOI_IRC_STATE_ICALC_OTHERS_REQ,
 512     ADIOI_IRC_STATE_ICALC_OTHERS_REQ_MAIN,
 513     ADIOI_IRC_STATE_IREAD_AND_EXCH,
 514     ADIOI_IRC_STATE_IREAD_AND_EXCH_L1_BEGIN,
 515     ADIOI_IRC_STATE_R_IEXCHANGE_DATA,
 516     ADIOI_IRC_STATE_R_IEXCHANGE_DATA_RECV,
 517     ADIOI_IRC_STATE_R_IEXCHANGE_DATA_FILL,
 518     ADIOI_IRC_STATE_COMPLETE
 519 } ADIOI_IRC_State;
 520 
 521 typedef enum {
 522     ADIOI_IWC_STATE_GEN_IWRITESTRIDEDCOLL,
 523     ADIOI_IWC_STATE_GEN_IWRITESTRIDEDCOLL_INDIO,
 524     ADIOI_IWC_STATE_GEN_IWRITESTRIDEDCOLL_BCAST,
 525     ADIOI_IWC_STATE_ICALC_OTHERS_REQ,
 526     ADIOI_IWC_STATE_ICALC_OTHERS_REQ_MAIN,
 527     ADIOI_IWC_STATE_IEXCH_AND_WRITE,
 528     ADIOI_IWC_STATE_IEXCH_AND_WRITE_L1_BODY,
 529     ADIOI_IWC_STATE_W_IEXCHANGE_DATA,
 530     ADIOI_IWC_STATE_W_IEXCHANGE_DATA_HOLE,
 531     ADIOI_IWC_STATE_W_IEXCHANGE_DATA_SEND,
 532     ADIOI_IWC_STATE_W_IEXCHANGE_DATA_WAIT,
 533     ADIOI_IWC_STATE_COMPLETE
 534 } ADIOI_IWC_State;
 535 
 536 typedef struct ADIOI_NBC_Request                ADIOI_NBC_Request;
 537 
 538 typedef struct ADIOI_GEN_IreadStridedColl_vars  ADIOI_GEN_IreadStridedColl_vars;
 539 typedef struct ADIOI_Iread_and_exch_vars        ADIOI_Iread_and_exch_vars;
 540 typedef struct ADIOI_R_Iexchange_data_vars      ADIOI_R_Iexchange_data_vars;
 541 
 542 typedef struct ADIOI_GEN_IwriteStridedColl_vars ADIOI_GEN_IwriteStridedColl_vars;
 543 typedef struct ADIOI_Iexch_and_write_vars       ADIOI_Iexch_and_write_vars;
 544 typedef struct ADIOI_W_Iexchange_data_vars      ADIOI_W_Iexchange_data_vars;
 545 
 546 typedef struct ADIOI_Icalc_others_req_vars {
 547     
 548     MPI_Request req1;
 549     MPI_Request *req2;
 550     int num_req2;
 551 
 552     
 553     ADIO_File fd;
 554     int count_my_req_procs;
 555     int *count_my_req_per_proc;
 556     ADIOI_Access *my_req;
 557     int nprocs;
 558     int myrank;
 559     int *count_others_req_procs_ptr;
 560     ADIOI_Access **others_req_ptr;
 561 
 562     
 563     int *count_others_req_per_proc;
 564     int count_others_req_procs;
 565     ADIOI_Access *others_req;
 566 
 567     
 568     void (*next_fn)(ADIOI_NBC_Request *, int *);
 569 } ADIOI_Icalc_others_req_vars;
 570 
 571 struct ADIOI_NBC_Request {
 572     int rdwr;           
 573     MPI_Request req;    
 574     MPI_Count nbytes;   
 575 
 576     union {
 577         struct {
 578             ADIOI_IRC_State state;      
 579             ADIOI_GEN_IreadStridedColl_vars *rsc_vars;
 580             ADIOI_Iread_and_exch_vars       *rae_vars;
 581             ADIOI_R_Iexchange_data_vars     *red_vars;
 582         } rd;
 583         struct {
 584             ADIOI_IWC_State state;      
 585             ADIOI_GEN_IwriteStridedColl_vars *wsc_vars;
 586             ADIOI_Iexch_and_write_vars       *eaw_vars;
 587             ADIOI_W_Iexchange_data_vars      *wed_vars;
 588         } wr;
 589     } data;
 590     ADIOI_Icalc_others_req_vars *cor_vars;
 591 };
 592 
 593 void ADIOI_Icalc_others_req(ADIOI_NBC_Request *nbc_req, int *error_code);
 594 void ADIOI_Icalc_others_req_main(ADIOI_NBC_Request *nbc_req, int *error_code);
 595 void ADIOI_Icalc_others_req_fini(ADIOI_NBC_Request *nbc_req, int *error_code);
 596 
 597 
 598 
 599 
 600 #define TEMP_OFF 0
 601 #define REAL_OFF 1
 602 #define MAX_OFF_TYPE 2
 603 
 604 
 605 #define DATA_TAG 30
 606 #define AMT_TAG 31
 607 
 608 
 609 #define ADIOI_FR_AAR 0
 610 #define ADIOI_FR_FSZ -1
 611 #define ADIOI_FR_USR_REALMS -2
 612 
 613 typedef struct flatten_state
 614 {
 615     ADIO_Offset abs_off;
 616     ADIO_Offset cur_sz;
 617     ADIO_Offset idx;
 618     ADIO_Offset cur_reg_off;
 619 } flatten_state;
 620 
 621 typedef struct view_state
 622 {
 623     ADIO_Offset fp_ind;    
 624     ADIO_Offset disp;      
 625     ADIO_Offset byte_off;
 626     ADIO_Offset sz;
 627     ADIO_Offset ext;       
 628     ADIO_Offset type_sz;
 629 
 630     
 631     flatten_state cur_state;
 632     
 633     flatten_state tmp_state;
 634 
 635     
 636     ADIO_Offset pre_sz;
 637     int pre_ol_ct;
 638     MPI_Aint *pre_disp_arr;
 639     int *pre_blk_arr;
 640     
 641     ADIOI_Flatlist_node *flat_type_p;
 642 } view_state;
 643 
 644 void ADIOI_Calc_bounds (ADIO_File fd, int count, MPI_Datatype buftype,
 645                         int file_ptr_type, ADIO_Offset offset,
 646                         ADIO_Offset *st_offset, ADIO_Offset *end_offset);
 647 int ADIOI_Agg_idx (int rank, ADIO_File fd);
 648 void ADIOI_Calc_file_realms (ADIO_File fd, ADIO_Offset min_st_offset,
 649                              ADIO_Offset max_end_offset);
 650 void ADIOI_IOFiletype(ADIO_File fd, void *buf, int count,
 651                       MPI_Datatype datatype, int file_ptr_type,
 652                       ADIO_Offset offset, MPI_Datatype custom_ftype,
 653                       int rdwr, ADIO_Status *status, int
 654                       *error_code);
 655 void ADIOI_IOStridedColl(ADIO_File fd, void *buf, int count, int rdwr,
 656                        MPI_Datatype datatype, int file_ptr_type,
 657                        ADIO_Offset offset, ADIO_Status *status, int
 658                        *error_code);
 659 void ADIOI_Print_flatlist_node(ADIOI_Flatlist_node *flatlist_node_p);
 660 ADIOI_Flatlist_node * ADIOI_Add_contig_flattened(MPI_Datatype contig_type);
 661 void ADIOI_Exch_file_views(int myrank, int nprocs, int file_ptr_type,
 662                            ADIO_File fd, int count,
 663                            MPI_Datatype datatype, ADIO_Offset off,
 664                            view_state *my_mem_view_state_arr,
 665                            view_state *agg_file_view_state_arr,
 666                            view_state *client_file_view_state_arr);
 667 int ADIOI_init_view_state(int file_ptr_type,
 668                     int nprocs, 
 669                     view_state *view_state_arr,
 670                     int op_type);
 671 int ADIOI_Build_agg_reqs(ADIO_File fd, int rw_type, int nprocs,
 672                          view_state *client_file_view_state_arr,
 673                          MPI_Datatype *client_comm_dtype_arr,
 674                          ADIO_Offset *client_comm_sz_arr,
 675                          ADIO_Offset *agg_dtype_offset_p,
 676                          MPI_Datatype *agg_dtype_p);
 677 int ADIOI_Build_client_reqs(ADIO_File fd, 
 678                             int nprocs,
 679                             view_state *my_mem_view_state_arr,
 680                             view_state *agg_file_view_state_arr,
 681                             ADIO_Offset *agg_comm_sz_arr,
 682                             MPI_Datatype *agg_comm_dtype_arr);
 683 int ADIOI_Build_client_pre_req(ADIO_File fd,
 684                                int agg_rank,
 685                                int agg_idx,
 686                                view_state *my_mem_view_state_p,
 687                                view_state *agg_file_view_state_p,
 688                                ADIO_Offset max_pre_req_sz,
 689                                int max_ol_ct);
 690 int ADIOI_Build_client_req(ADIO_File fd,
 691                            int agg_rank,
 692                            int agg_idx,
 693                            view_state *my_mem_view_state_p,
 694                            view_state *agg_file_view_state_p,
 695                            ADIO_Offset agg_comm_sz,
 696                            MPI_Datatype *agg_comm_dtype_p);
 697 
 698 void ADIOI_P2PContigWriteAggregation(ADIO_File fd,
 699                                      const void *buf,
 700                                      int *error_code,
 701                                      ADIO_Offset *st_offsets,
 702                                      ADIO_Offset *end_offset,
 703                                      ADIO_Offset *fd_start,
 704                                      ADIO_Offset *fd_end);
 705 
 706 void ADIOI_P2PContigReadAggregation(ADIO_File fd,
 707                                      const void *buf,
 708                                      int *error_code,
 709                                      ADIO_Offset *st_offsets,
 710                                      ADIO_Offset *end_offset,
 711                                      ADIO_Offset *fd_start,
 712                                      ADIO_Offset *fd_end);
 713 
 714 int ADIOI_OneSidedCleanup(ADIO_File fd);
 715 void ADIOI_OneSidedWriteAggregation(ADIO_File fd,
 716         ADIO_Offset *offset_list,
 717         ADIO_Offset *len_list,
 718         int contig_access_count,
 719         const void *buf,
 720         MPI_Datatype datatype,
 721         int *error_code,
 722         ADIO_Offset *st_offsets,
 723         ADIO_Offset *end_offsets,
 724         int numNonZeroDataOffsets,
 725         ADIO_Offset *fd_start,
 726         ADIO_Offset* fd_end,
 727         int *hole_found);
 728 void ADIOI_OneSidedReadAggregation(ADIO_File fd,
 729         ADIO_Offset *offset_list,
 730         ADIO_Offset *len_list,
 731         int contig_access_count,
 732         const void *buf,
 733         MPI_Datatype datatype,
 734         int *error_code,
 735         ADIO_Offset *st_offsets,
 736         ADIO_Offset *end_offsets,
 737         int numNonZeroDataOffsets,
 738         ADIO_Offset *fd_start,
 739         ADIO_Offset* fd_end);
 740 ADIO_Offset ADIOI_GEN_SeekIndividual(ADIO_File fd, ADIO_Offset offset, 
 741                                      int whence, int *error_code);
 742 void ADIOI_GEN_Resize(ADIO_File fd, ADIO_Offset size, int *error_code);
 743 void ADIOI_GEN_SetInfo(ADIO_File fd, MPI_Info users_info, int *error_code);
 744 void ADIOI_GEN_Close(ADIO_File fd, int *error_code);
 745 void ADIOI_Shfp_fname(ADIO_File fd, int rank, int *error_code);
 746 void ADIOI_GEN_Prealloc(ADIO_File fd, ADIO_Offset size, int *error_code);
 747 int ADIOI_Error(ADIO_File fd, int error_code, char *string);
 748 int MPIR_Err_setmsg( int, int, const char *, const char *, const char *, ... );
 749 int ADIOI_End_call(MPI_Comm comm, int keyval, void *attribute_val, void *extra_state);
 750 int MPIR_Status_set_bytes(MPI_Status *status, MPI_Datatype datatype, MPI_Count nbytes);
 751 int ADIOI_Uses_generic_read(ADIO_File fd);
 752 int ADIOI_Uses_generic_write(ADIO_File fd);
 753 int ADIOI_Err_create_code(const char *myname, const char *filename, int my_errno);
 754 int ADIOI_Type_create_hindexed_x(int count,
 755                 const MPI_Count array_of_blocklengths[],
 756                 const MPI_Aint array_of_displacements[],
 757                 MPI_Datatype oldtype,
 758                 MPI_Datatype *newtype);
 759 
 760 
 761 int ADIOI_FAKE_IODone(ADIO_Request *request, ADIO_Status *status,
 762                       int *error_code);
 763 void ADIOI_FAKE_IreadContig(ADIO_File fd, void *buf, int count, 
 764                            MPI_Datatype datatype, int file_ptr_type,
 765                            ADIO_Offset offset, ADIO_Request *request,
 766                             int *error_code);
 767 void ADIOI_FAKE_IreadStrided(ADIO_File fd, void *buf, int count, 
 768                             MPI_Datatype datatype, int file_ptr_type,
 769                             ADIO_Offset offset, ADIO_Request *request,
 770                              int *error_code);
 771 void ADIOI_FAKE_IwriteContig(ADIO_File fd, const void *buf, int count,
 772                             MPI_Datatype datatype, int file_ptr_type,
 773                             ADIO_Offset offset, ADIO_Request *request,
 774                              int *error_code);
 775 void ADIOI_FAKE_IwriteStrided(ADIO_File fd, const void *buf, int count,
 776                              MPI_Datatype datatype, int file_ptr_type,
 777                              ADIO_Offset offset, ADIO_Request *request,
 778                               int *error_code);
 779 void ADIOI_FAKE_IOComplete(ADIO_Request *request, ADIO_Status *status,
 780                            int *error_code);
 781 
 782 
 783 
 784 int MPIOI_File_read(MPI_File fh,
 785                     MPI_Offset offset,
 786                     int file_ptr_type,
 787                     void *buf,
 788                     int count,
 789                     MPI_Datatype datatype,
 790                     char *myname,
 791                     MPI_Status *status);
 792 int MPIOI_File_write(MPI_File fh,
 793                      MPI_Offset offset,
 794                      int file_ptr_type,
 795                      const void *buf,
 796                      int count,
 797                      MPI_Datatype datatype,
 798                      char *myname,
 799                      MPI_Status *status);
 800 int MPIOI_File_read_all(MPI_File fh,
 801                         MPI_Offset offset,
 802                         int file_ptr_type,
 803                         void *buf,
 804                         int count,
 805                         MPI_Datatype datatype,
 806                         char *myname,
 807                         MPI_Status *status);
 808 int MPIOI_File_write_all(MPI_File fh,
 809                          MPI_Offset offset,
 810                          int file_ptr_type,
 811                          const void *buf,
 812                          int count,
 813                          MPI_Datatype datatype,
 814                          char *myname,
 815                          MPI_Status *status);
 816 int MPIOI_File_read_all_begin(MPI_File fh,
 817                               MPI_Offset offset,
 818                               int file_ptr_type,
 819                               void *buf,
 820                               int count,
 821                               MPI_Datatype datatype,
 822                               char *myname);
 823 int MPIOI_File_write_all_begin(MPI_File fh,
 824                                MPI_Offset offset,
 825                                int file_ptr_type,
 826                                const void *buf,
 827                                int count,
 828                                MPI_Datatype datatype,
 829                                char *myname);
 830 int MPIOI_File_read_all_end(MPI_File fh,
 831                             void *buf,
 832                             char *myname,
 833                             MPI_Status *status);
 834 int MPIOI_File_write_all_end(MPI_File fh,
 835                              const void *buf,
 836                              char *myname,
 837                              MPI_Status *status);
 838 int MPIOI_File_iwrite(MPI_File fh,
 839                       MPI_Offset offset,
 840                       int file_ptr_type,
 841                       const void *buf,
 842                       int count,
 843                       MPI_Datatype datatype,
 844                       char *myname,
 845                       MPI_Request *request);
 846 int MPIOI_File_iread(MPI_File fh,
 847                      MPI_Offset offset,
 848                      int file_ptr_type,
 849                      void *buf,
 850                      int count,
 851                      MPI_Datatype datatype,
 852                      char *myname,
 853                      MPI_Request *request);
 854 int MPIOI_File_iwrite_all(MPI_File fh,
 855             MPI_Offset offset,
 856             int file_ptr_type,
 857             const void *buf,
 858             int count,
 859             MPI_Datatype datatype,
 860             char *myname,
 861             MPI_Request *request);
 862 int MPIOI_File_iread_all(MPI_File fh,
 863             MPI_Offset offset,
 864             int file_ptr_type,
 865             void *buf,
 866             int count,
 867             MPI_Datatype datatype,
 868             char *myname,
 869             MPI_Request *request);
 870 
 871 
 872 
 873 
 874 
 875 #if (defined(ROMIO_HFS) || defined(ROMIO_XFS))
 876 
 877 # define ADIOI_WRITE_LOCK(fd, offset, whence, len) \
 878    do {if (((fd)->file_system == ADIO_XFS) || ((fd)->file_system == ADIO_HFS)) \
 879      ADIOI_Set_lock64((fd)->fd_sys, F_SETLKW64, F_WRLCK, offset, whence, len);\
 880    else ADIOI_Set_lock((fd)->fd_sys, F_SETLKW, F_WRLCK, offset, whence, len); } while (0) 
 881 
 882 # define ADIOI_READ_LOCK(fd, offset, whence, len) \
 883    do {if (((fd)->file_system == ADIO_XFS) || ((fd)->file_system == ADIO_HFS)) \
 884      ADIOI_Set_lock64((fd)->fd_sys, F_SETLKW64, F_RDLCK, offset, whence, len);\
 885    else ADIOI_Set_lock((fd)->fd_sys, F_SETLKW, F_RDLCK, offset, whence, len); }while (0)
 886 
 887 # define ADIOI_UNLOCK(fd, offset, whence, len) \
 888    do {if (((fd)->file_system == ADIO_XFS) || ((fd)->file_system == ADIO_HFS)) \
 889      ADIOI_Set_lock64((fd)->fd_sys, F_SETLK64, F_UNLCK, offset, whence, len); \
 890    else ADIOI_Set_lock((fd)->fd_sys, F_SETLK, F_UNLCK, offset, whence, len); }while (0)
 891 
 892 #elif (defined(ROMIO_NTFS))
 893 
 894 #define ADIOI_LOCK_CMD          0
 895 #define ADIOI_UNLOCK_CMD        1
 896 
 897 #   define ADIOI_WRITE_LOCK(fd, offset, whence, len) \
 898           ADIOI_Set_lock((fd)->fd_sys, ADIOI_LOCK_CMD, LOCKFILE_EXCLUSIVE_LOCK, offset, whence, len)
 899 #   define ADIOI_READ_LOCK(fd, offset, whence, len) \
 900           ADIOI_Set_lock((fd)->fd_sys, ADIOI_LOCK_CMD, 0, offset, whence, len)
 901 #   define ADIOI_UNLOCK(fd, offset, whence, len) \
 902           ADIOI_Set_lock((fd)->fd_sys, ADIOI_UNLOCK_CMD, LOCKFILE_FAIL_IMMEDIATELY, offset, whence, len)
 903 
 904 #else
 905 
 906 #ifdef ADIOI_MPE_LOGGING
 907 #   define ADIOI_WRITE_LOCK(fd, offset, whence, len) do { \
 908         MPE_Log_event( ADIOI_MPE_writelock_a, 0, NULL ); \
 909         ADIOI_Set_lock((fd)->fd_sys, F_SETLKW, F_WRLCK, offset, whence, len); \
 910         MPE_Log_event( ADIOI_MPE_writelock_b, 0, NULL ); } while( 0 )
 911 #   define ADIOI_READ_LOCK(fd, offset, whence, len) \
 912         MPE_Log_event( ADIOI_MPE_readlock_a, 0, NULL ); do { \
 913         ADIOI_Set_lock((fd)->fd_sys, F_SETLKW, F_RDLCK, offset, whence, len); \
 914         MPE_Log_event( ADIOI_MPE_readlock_b, 0, NULL ); } while( 0 )
 915 #   define ADIOI_UNLOCK(fd, offset, whence, len) do { \
 916         MPE_Log_event( ADIOI_MPE_unlock_a, 0, NULL ); \
 917         ADIOI_Set_lock((fd)->fd_sys, F_SETLK, F_UNLCK, offset, whence, len); \
 918         MPE_Log_event( ADIOI_MPE_unlock_b, 0, NULL ); } while( 0 )
 919 #else
 920 #   define ADIOI_WRITE_LOCK(fd, offset, whence, len) \
 921           ADIOI_Set_lock((fd)->fd_sys, F_SETLKW, F_WRLCK, offset, whence, len)
 922 #   define ADIOI_READ_LOCK(fd, offset, whence, len) \
 923           ADIOI_Set_lock((fd)->fd_sys, F_SETLKW, F_RDLCK, offset, whence, len)
 924 #   define ADIOI_UNLOCK(fd, offset, whence, len) \
 925           ADIOI_Set_lock((fd)->fd_sys, F_SETLK, F_UNLCK, offset, whence, len)
 926 #endif
 927 
 928 #endif
 929 
 930 int ADIOI_Set_lock(FDTYPE fd_sys, int cmd, int type, ADIO_Offset offset, int whence, ADIO_Offset len);
 931 int ADIOI_Set_lock64(FDTYPE fd_sys, int cmd, int type, ADIO_Offset offset, int whence, ADIO_Offset len);
 932 
 933 #define ADIOI_Malloc(a) ADIOI_Malloc_fn(a,__LINE__,__FILE__)
 934 #define ADIOI_Calloc(a,b) ADIOI_Calloc_fn(a,b,__LINE__,__FILE__)
 935 #define ADIOI_Realloc(a,b) ADIOI_Realloc_fn(a,b,__LINE__,__FILE__)
 936 #define ADIOI_Free(a) ADIOI_Free_fn(a,__LINE__,__FILE__)
 937 
 938 int ADIOI_Strncpy( char *outstr, const char *instr, size_t maxlen );
 939 int ADIOI_Strnapp( char *, const char *, size_t );
 940 char *ADIOI_Strdup( const char * );
 941 
 942 
 943 
 944 
 945 
 946 
 947 
 948 
 949 #define ADIOI_Info_set(info_,key_str_,val_) \
 950     MPI_Info_set((info_),((char*)key_str_),(char*)(val_))
 951 #define ADIOI_Info_get(info_,key_str_,val_len_,val_,flag_) \
 952     MPI_Info_get((info_),((char*)key_str_),(val_len_),(val_),(flag_))
 953 #define ADIOI_Info_get_valuelen(info_,key_str_,val_len_,flag_) \
 954     MPI_Info_get_valuelen((info_),((char*)key_str_),(val_len_),(flag_))
 955 #define ADIOI_Info_delete(info_,key_str_) \
 956     MPI_Info_delete((info_),((char*)key_str_))
 957 
 958 
 959 
 960 
 961 #ifndef ATTRIBUTE
 962 #ifdef HAVE_GCC_ATTRIBUTE
 963 #define ATTRIBUTE(a) __attribute__(a)
 964 #else
 965 #define ATTRIBUTE(a)
 966 #endif
 967 #endif
 968 
 969 
 970 
 971 #ifdef HAVE_SNPRINTF
 972 #define ADIOI_Snprintf snprintf
 973 
 974 #ifdef NEEDS_SNPRINTF_DECL
 975 extern int snprintf( char *, size_t, const char *, ... ) ATTRIBUTE((format(printf,3,4)));
 976 #endif
 977 #else
 978 int ADIOI_Snprintf( char *str, size_t size, const char *format, ... ) 
 979      ATTRIBUTE((format(printf,3,4)));
 980 #endif 
 981 
 982 #define FPRINTF fprintf
 983 
 984 #ifndef HAVE_STRERROR
 985 #  ifdef HAVE_SYSERRLIST
 986       extern char *sys_errlist[];
 987 #     define strerror(n) sys_errlist[n]
 988 #  else 
 989 #     define PRINT_ERR_MSG
 990 #  endif
 991 #endif
 992 
 993 #include "adioi_error.h"
 994 
 995 
 996 
 997 #ifdef ADIOI_MPE_LOGGING
 998 #include "mpe.h"
 999 
1000 int  ADIOI_MPE_open_a;
1001 int  ADIOI_MPE_open_b;
1002 int  ADIOI_MPE_read_a;
1003 int  ADIOI_MPE_read_b;
1004 int  ADIOI_MPE_write_a;
1005 int  ADIOI_MPE_write_b;
1006 int  ADIOI_MPE_lseek_a;
1007 int  ADIOI_MPE_lseek_b;
1008 int  ADIOI_MPE_close_a;
1009 int  ADIOI_MPE_close_b;
1010 int  ADIOI_MPE_writelock_a;
1011 int  ADIOI_MPE_writelock_b;
1012 int  ADIOI_MPE_readlock_a;
1013 int  ADIOI_MPE_readlock_b;
1014 int  ADIOI_MPE_unlock_a;
1015 int  ADIOI_MPE_unlock_b;
1016 int  ADIOI_MPE_postwrite_a;
1017 int  ADIOI_MPE_postwrite_b;
1018 int  ADIOI_MPE_openinternal_a;
1019 int  ADIOI_MPE_openinternal_b;
1020 int  ADIOI_MPE_stat_a;
1021 int  ADIOI_MPE_stat_b;
1022 int  ADIOI_MPE_iread_a;
1023 int  ADIOI_MPE_iread_b;
1024 int  ADIOI_MPE_iwrite_a;
1025 int  ADIOI_MPE_iwrite_b;
1026 #endif
1027 
1028 #ifdef ROMIO_INSIDE_MPICH
1029 
1030 
1031 
1032 
1033 
1034   
1035 
1036   #include "glue_romio.h"
1037 
1038   #define ADIOI_AINT_CAST_TO_VOID_PTR (void*)(MPIU_Pint)
1039   
1040 
1041   #define ADIOI_AINT_CAST_TO_LONG_LONG (long long)
1042   #define ADIOI_AINT_CAST_TO_OFFSET ADIOI_AINT_CAST_TO_LONG_LONG
1043 
1044   #define ADIOI_ENSURE_AINT_FITS_IN_PTR(aint_value) MPIR_Ext_ensure_Aint_fits_in_pointer(aint_value)
1045   #define ADIOI_Assert MPIR_Ext_assert
1046 #else
1047   #include <assert.h>
1048   #define ADIOI_AINT_CAST_TO_VOID_PTR (void*)
1049   #define ADIOI_AINT_CAST_TO_LONG_LONG (long long)
1050   #define ADIOI_AINT_CAST_TO_OFFSET ADIOI_AINT_CAST_TO_LONG_LONG
1051   #define ADIOI_ENSURE_AINT_FITS_IN_PTR(aint_value) 
1052   #define ADIOI_Assert assert
1053   #define MPIU_Upint unsigned long
1054   #define MPID_THREADPRIV_DECL
1055 #endif
1056 
1057 #ifdef USE_DBG_LOGGING    
1058 
1059 #define DBGT_FPRINTF if (MPIR_Ext_dbg_romio_verbose_enabled) fprintf(stderr,"%s:%d:",__FILE__,__LINE__); \
1060 if (MPIR_Ext_dbg_romio_terse_enabled) fprintf
1061 
1062 #define DBG_FPRINTF if (MPIR_Ext_dbg_romio_verbose_enabled) fprintf(stderr,"%s:%d:",__FILE__,__LINE__); \
1063 if (MPIR_Ext_dbg_romio_typical_enabled) fprintf
1064 
1065 #define DBGV_FPRINTF if (MPIR_Ext_dbg_romio_verbose_enabled) fprintf(stderr,"%s:%d:",__FILE__,__LINE__); \
1066  if (MPIR_Ext_dbg_romio_verbose_enabled) fprintf
1067 #else 
1068 #define DBGT_FPRINTF if (0) fprintf
1069 #define DBG_FPRINTF if (0) fprintf
1070 #define DBGV_FPRINTF if (0) fprintf
1071 #endif
1072 
1073 
1074 
1075 typedef struct wcThreadFuncData {
1076     ADIO_File fd;
1077     int io_kind;
1078     char *buf;
1079     int size;
1080     ADIO_Offset offset;
1081     ADIO_Status *status;
1082     int error_code;
1083 } ADIOI_IO_ThreadFuncData;
1084 
1085 void *ADIOI_IO_Thread_Func(void *vptr_args);
1086 
1087 
1088 #ifdef HAVE_LIMITS_H
1089 #include <limits.h>
1090 #endif
1091 
1092 #ifndef PATH_MAX
1093 #define PATH_MAX 65535
1094 #endif
1095 
1096 #if (HAVE_DECL_PWRITE == 0)
1097 #include <sys/types.h>
1098 #include <unistd.h>
1099 ssize_t pread(int fd, void *buf, size_t count, off_t offset);
1100 ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset);
1101 
1102 #endif
1103 
1104 #endif