Charm++: Charm Source Code Documentation

00001 /* -*- Mode: C; c-basic-offset:4 ; -*- */
00002 /* 
00003  *   $Id$    
00004  *
00005  *   Copyright (C) 1997 University of Chicago. 
00006  *   See COPYRIGHT notice in top-level directory.
00007  */
00008 
00009 #include "mpioimpl.h"
00010 
00011 #ifdef HAVE_WEAK_SYMBOLS
00012 
00013 #if defined(HAVE_PRAGMA_WEAK)
00014 #pragma weak MPI_File_open = PMPI_File_open
00015 #elif defined(HAVE_PRAGMA_HP_SEC_DEF)
00016 #pragma _HP_SECONDARY_DEF PMPI_File_open MPI_File_open
00017 #elif defined(HAVE_PRAGMA_CRI_DUP)
00018 #pragma _CRI duplicate MPI_File_open as PMPI_File_open
00019 /* end of weak pragmas */
00020 #endif
00021 
00022 /* Include mapping from MPI->PMPI */
00023 #define MPIO_BUILD_PROFILING
00024 #include "mpioprof.h"
00025 #endif
00026 
00027 extern int ADIO_Init_keyval;
00028 
00029 /*@
00030     MPI_File_open - Opens a file
00031 
00032 Input Parameters:
00033 . comm - communicator (handle)
00034 . filename - name of file to open (string)
00035 . amode - file access mode (integer)
00036 . info - info object (handle)
00037 
00038 Output Parameters:
00039 . fh - file handle (handle)
00040 
00041 .N fortran
00042 @*/
00043 int MPI_File_open(MPI_Comm comm, char *filename, int amode, 
00044                   MPI_Info info, MPI_File *fh)
00045 {
00046     int error_code, file_system, flag, /* tmp_amode, */rank, orig_amode;
00047 #ifndef PRINT_ERR_MSG
00048     static char myname[] = "MPI_FILE_OPEN";
00049 #endif
00050     char *tmp;
00051     MPI_Comm dupcomm, dupcommself;
00052     ADIOI_Fns *fsops;
00053 
00054 #ifdef MPI_hpux
00055     int fl_xmpi;
00056 
00057     HPMP_IO_OPEN_START(fl_xmpi, comm);
00058 #endif /* MPI_hpux */
00059 
00060     if (comm == MPI_COMM_NULL) {
00061 #ifdef PRINT_ERR_MSG
00062         FPRINTF(stderr, "MPI_File_open: Invalid communicator\n");
00063         MPI_Abort(MPI_COMM_WORLD, 1);
00064 #else
00065         error_code = MPIR_Err_setmsg(MPI_ERR_COMM, MPIR_ERR_COMM_NULL,
00066                                      myname, (char *) 0, (char *) 0);
00067         return ADIOI_Error(MPI_FILE_NULL, error_code, myname);
00068 #endif
00069     }
00070 
00071     MPI_Comm_test_inter(comm, &flag);
00072     if (flag) {
00073 #ifdef PRINT_ERR_MSG
00074         FPRINTF(stderr, "MPI_File_open: Intercommunicator cannot be passed to MPI_File_open\n");
00075         MPI_Abort(MPI_COMM_WORLD, 1);
00076 #else
00077         error_code = MPIR_Err_setmsg(MPI_ERR_COMM, MPIR_ERR_COMM_INTER,
00078                                      myname, (char *) 0, (char *) 0);
00079         return ADIOI_Error(MPI_FILE_NULL, error_code, myname);
00080 #endif
00081     }
00082 
00083     if ( ((amode&MPI_MODE_RDONLY)?1:0) + ((amode&MPI_MODE_RDWR)?1:0) +
00084          ((amode&MPI_MODE_WRONLY)?1:0) != 1 ) {
00085 #ifdef PRINT_ERR_MSG
00086         FPRINTF(stderr, "MPI_File_open: Exactly one of MPI_MODE_RDONLY, MPI_MODE_WRONLY, or MPI_MODE_RDWR must be specified\n");
00087         MPI_Abort(MPI_COMM_WORLD, 1); 
00088 #else
00089         error_code = MPIR_Err_setmsg(MPI_ERR_AMODE, 3,
00090                                      myname, (char *) 0, (char *) 0);
00091         return ADIOI_Error(MPI_FILE_NULL, error_code, myname);
00092 #endif
00093     }
00094 
00095     if ((amode & MPI_MODE_RDONLY) && 
00096             ((amode & MPI_MODE_CREATE) || (amode & MPI_MODE_EXCL))) {
00097 #ifdef PRINT_ERR_MSG
00098         FPRINTF(stderr, "MPI_File_open: It is erroneous to specify MPI_MODE_CREATE or MPI_MODE_EXCL with MPI_MODE_RDONLY\n");
00099         MPI_Abort(MPI_COMM_WORLD, 1);
00100 #else
00101         error_code = MPIR_Err_setmsg(MPI_ERR_AMODE, 5,
00102                                      myname, (char *) 0, (char *) 0);
00103         return ADIOI_Error(MPI_FILE_NULL, error_code, myname);
00104 #endif
00105     }
00106 
00107     if ((amode & MPI_MODE_RDWR) && (amode & MPI_MODE_SEQUENTIAL)) {
00108 #ifdef PRINT_ERR_MSG
00109         FPRINTF(stderr, "MPI_File_open: It is erroneous to specify MPI_MODE_SEQUENTIAL with MPI_MODE_RDWR\n");
00110         MPI_Abort(MPI_COMM_WORLD, 1);
00111 #else
00112         error_code = MPIR_Err_setmsg(MPI_ERR_AMODE, 7,
00113                                      myname, (char *) 0, (char *) 0);
00114         return ADIOI_Error(MPI_FILE_NULL, error_code, myname);
00115 #endif
00116     }
00117 
00118 /* check if amode is the same on all processes */
00119     MPI_Comm_dup(comm, &dupcomm);
00120 
00121 /*  
00122     Removed this check because broadcast is too expensive. 
00123     tmp_amode = amode;
00124     MPI_Bcast(&tmp_amode, 1, MPI_INT, 0, dupcomm);
00125     if (amode != tmp_amode) {
00126         FPRINTF(stderr, "MPI_File_open: amode must be the same on all processes\n");
00127         MPI_Abort(MPI_COMM_WORLD, 1);
00128     }
00129 */
00130 
00131 /* check if ADIO has been initialized. If not, initialize it */
00132     if (ADIO_Init_keyval == MPI_KEYVAL_INVALID) {
00133 
00134 /* check if MPI itself has been initialized. If not, flag an error.
00135    Can't initialize it here, because don't know argc, argv */
00136         MPI_Initialized(&flag);
00137         if (!flag) {
00138             FPRINTF(stderr, "Error: MPI_Init() must be called before using MPI-IO\n");
00139             MPI_Abort(MPI_COMM_WORLD, 1);
00140         }
00141 
00142         MPI_Keyval_create(MPI_NULL_COPY_FN, ADIOI_End_call, &ADIO_Init_keyval,
00143                           (void *) 0);  
00144 
00145 /* put a dummy attribute on MPI_COMM_WORLD, because we want the delete
00146    function to be called when MPI_COMM_WORLD is freed. Hopefully the
00147    MPI library frees MPI_COMM_WORLD when MPI_Finalize is called,
00148    though the standard does not mandate this. */
00149 
00150         MPI_Attr_put(MPI_COMM_WORLD, ADIO_Init_keyval, (void *) 0);
00151 
00152 /* initialize ADIO */
00153 
00154         ADIO_Init( (int *)0, (char ***)0, &error_code);
00155     }
00156 
00157 
00158     file_system = -1;
00159 
00160     /* resolve file system type from file name; this is a collective call */
00161     ADIO_ResolveFileType(dupcomm, filename, &file_system, &fsops, &error_code);
00162     if (error_code != MPI_SUCCESS) {
00163         /* ADIO_ResolveFileType() will print as informative a message as it
00164          * possibly can or call MPIR_Err_setmsg.  We just need to propagate 
00165          * the error up.  In the PRINT_ERR_MSG case MPI_Abort has already
00166          * been called as well, so we probably didn't even make it this far.
00167          */
00168 #ifdef PRINT_ERR_MSG
00169         MPI_Abort(MPI_COMM_WORLD, 1); /* this is mostly here for clarity */
00170 #else
00171         return ADIOI_Error(MPI_FILE_NULL, error_code, myname);
00172 #endif
00173     }
00174 
00175     /* Test for invalid flags in amode.
00176      *
00177      * eventually we should allow the ADIO implementations to test for 
00178      * invalid flags through some functional interface rather than having
00179      *  these tests here. -- Rob, 06/06/2001
00180      */
00181     if (((file_system == ADIO_PIOFS) || (file_system == ADIO_PVFS)) && 
00182         (amode & MPI_MODE_SEQUENTIAL)) {
00183 #ifdef PRINT_ERR_MSG
00184         FPRINTF(stderr, "MPI_File_open: MPI_MODE_SEQUENTIAL not supported on PIOFS and PVFS\n");
00185         MPI_Abort(MPI_COMM_WORLD, 1);
00186 #else
00187         error_code = MPIR_Err_setmsg(MPI_ERR_UNSUPPORTED_OPERATION, 
00188                     MPIR_ERR_NO_MODE_SEQ, myname, (char *) 0, (char *) 0);
00189         return ADIOI_Error(MPI_FILE_NULL, error_code, myname);
00190 #endif
00191     }
00192 
00193     /* strip off prefix if there is one */
00194     tmp = strchr(filename, ':');
00195     /* Only skip prefixes greater than length one to allow for windows drive specification (c:\...)*/
00196     /*if (tmp) filename = tmp + 1;*/
00197     if (tmp > filename + 1)
00198         filename = tmp + 1;
00199 
00200     orig_amode = amode;
00201     MPI_Comm_rank(dupcomm, &rank);
00202 
00203     if ((amode & MPI_MODE_CREATE) && (amode & MPI_MODE_EXCL)) {
00204         /* the open should fail if the file exists. Only process 0 should
00205            check this. Otherwise, if all processes try to check and the file 
00206            does not exist, one process will create the file and others who 
00207            reach later will return error. */
00208 
00209         if (!rank) {
00210             MPI_Comm_dup(MPI_COMM_SELF, &dupcommself);
00211             /* NOTE: dupcommself is freed either in ADIO_Open if the open fails,
00212              * or in ADIO_Close.
00213              */
00214             *fh = ADIO_Open(MPI_COMM_SELF, dupcommself, filename, file_system, amode, 
00215                             0, MPI_BYTE, MPI_BYTE, M_ASYNC, info, 
00216                             ADIO_PERM_NULL, &error_code);
00217             /* broadcast the error code to other processes */
00218             MPI_Bcast(&error_code, 1, MPI_INT, 0, dupcomm);
00219             /* if no error, close the file. It will be reopened normally 
00220                below. */
00221             if (error_code == MPI_SUCCESS) ADIO_Close(*fh, &error_code);
00222         }
00223         else MPI_Bcast(&error_code, 1, MPI_INT, 0, dupcomm);
00224 
00225         if (error_code != MPI_SUCCESS) {
00226             MPI_Comm_free(&dupcomm);
00227             *fh = MPI_FILE_NULL;
00228 #ifdef MPI_hpux
00229             HPMP_IO_OPEN_END(fl_xmpi, *fh, comm);
00230 #endif /* MPI_hpux */
00231             return error_code;
00232         }
00233         else amode = amode ^ MPI_MODE_EXCL;  /* turn off MPI_MODE_EXCL */
00234     }
00235 
00236 /* use default values for disp, etype, filetype */    
00237 /* set iomode=M_ASYNC. It is used to implement the Intel PFS interface
00238    on top of ADIO. Not relevant for MPI-IO implementation */    
00239 
00240     *fh = ADIO_Open(comm, dupcomm, filename, file_system, amode, 0, MPI_BYTE,
00241                     MPI_BYTE, M_ASYNC, info, ADIO_PERM_NULL, &error_code);
00242 
00243     /* if MPI_MODE_EXCL was removed, add it back */
00244     if ((error_code == MPI_SUCCESS) && (amode != orig_amode))
00245         (*fh)->access_mode = orig_amode;
00246 
00247     /* determine name of file that will hold the shared file pointer */
00248     /* can't support shared file pointers on a file system that doesn't
00249        support file locking, e.g., PIOFS, PVFS */
00250     if ((error_code == MPI_SUCCESS) && ((*fh)->file_system != ADIO_PIOFS)
00251           && ((*fh)->file_system != ADIO_PVFS)) {
00252         ADIOI_Shfp_fname(*fh, rank);
00253 
00254         /* if MPI_MODE_APPEND, set the shared file pointer to end of file.
00255            indiv. file pointer already set to end of file in ADIO_Open. 
00256            Here file view is just bytes. */
00257         if ((*fh)->access_mode & MPI_MODE_APPEND) {
00258             if (!rank) ADIO_Set_shared_fp(*fh, (*fh)->fp_ind, &error_code);
00259             MPI_Barrier(dupcomm);
00260         }
00261     }
00262 
00263 #ifdef MPI_hpux
00264     HPMP_IO_OPEN_END(fl_xmpi, *fh, comm);
00265 #endif /* MPI_hpux */
00266     return error_code;
00267 }
00268 
00269 
00270 /* define this missing function as empty, since
00271    we don't care about error handling in AMPI */
00272 int MPIR_Err_setmsg( int a, int b, const char *c, const char *d, const char *e, ...){
00273   return 0;
00274 }
00275
libs/ck-libs/ampi/romio/mpi-io/open.c
