Actual source code: mpiuopen.c

      1: #define PETSC_DESIRE_FEATURE_TEST_MACROS /* for popen() */
      2: /*
      3:       Some PETSc utility routines to add simple parallel IO capabilities
      4: */
      5: #include <petscsys.h>
      6: #include <petsc/private/logimpl.h>
      7: #include <errno.h>

      9: /*@C
     10:     PetscFOpen - Has the first process in the communicator open a file;
     11:     all others do nothing.

     13:     Logically Collective

     15:     Input Parameters:
     16: +   comm - the communicator
     17: .   name - the filename
     18: -   mode - the mode for fopen(), usually "w"

     20:     Output Parameter:
     21: .   fp - the file pointer

     23:     Level: developer

     25:     Notes:
     26:        NULL (0), "stderr" or "stdout" may be passed in as the filename

     28:     Fortran Note:
     29:     This routine is not supported in Fortran.

     32: .seealso: PetscFClose(), PetscSynchronizedFGets(), PetscSynchronizedPrintf(), PetscSynchronizedFlush(),
     33:           PetscFPrintf()
     34: @*/
     35: PetscErrorCode  PetscFOpen(MPI_Comm comm,const char name[],const char mode[],FILE **fp)
     36: {
     38:   PetscMPIInt    rank;
     39:   FILE           *fd;
     40:   char           fname[PETSC_MAX_PATH_LEN],tname[PETSC_MAX_PATH_LEN];

     43:   MPI_Comm_rank(comm,&rank);
     44:   if (!rank) {
     45:     PetscBool isstdout,isstderr;
     46:     PetscStrcmp(name,"stdout",&isstdout);
     47:     PetscStrcmp(name,"stderr",&isstderr);
     48:     if (isstdout || !name) fd = PETSC_STDOUT;
     49:     else if (isstderr) fd = PETSC_STDERR;
     50:     else {
     51:       PetscBool devnull;
     52:       PetscStrreplace(PETSC_COMM_SELF,name,tname,PETSC_MAX_PATH_LEN);
     53:       PetscFixFilename(tname,fname);
     54:       PetscStrbeginswith(fname,"/dev/null",&devnull);
     55:       if (devnull) {
     56:         PetscStrcpy(fname,"/dev/null");
     57:       }
     58:       PetscInfo1(0,"Opening file %s\n",fname);
     59:       fd   = fopen(fname,mode);
     60:       if (!fd) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to open file %s\n",fname);
     61:     }
     62:   } else fd = NULL;
     63:   *fp = fd;
     64:   return(0);
     65: }

     67: /*@C
     68:     PetscFClose - Has the first processor in the communicator close a
     69:     file; all others do nothing.

     71:     Logically Collective

     73:     Input Parameters:
     74: +   comm - the communicator
     75: -   fd - the file, opened with PetscFOpen()

     77:    Level: developer

     79:     Fortran Note:
     80:     This routine is not supported in Fortran.

     83: .seealso: PetscFOpen()
     84: @*/
     85: PetscErrorCode  PetscFClose(MPI_Comm comm,FILE *fd)
     86: {
     88:   PetscMPIInt    rank;
     89:   int            err;

     92:   MPI_Comm_rank(comm,&rank);
     93:   if (!rank && fd != PETSC_STDOUT && fd != PETSC_STDERR) {
     94:     err = fclose(fd);
     95:     if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fclose() failed on file");
     96:   }
     97:   return(0);
     98: }

    100: #if defined(PETSC_HAVE_POPEN)
    101: static char PetscPOpenMachine[128] = "";

    103: /*@C
    104:       PetscPClose - Closes (ends) a program on processor zero run with PetscPOpen()

    106:      Collective, but only process 0 runs the command

    108:    Input Parameters:
    109: +   comm - MPI communicator, only processor zero runs the program
    110: -   fp - the file pointer where program input or output may be read or NULL if don't care

    112:    Level: intermediate

    114:    Notes:
    115:        Does not work under Windows

    117: .seealso: PetscFOpen(), PetscFClose(), PetscPOpen()

    119: @*/
    120: PetscErrorCode PetscPClose(MPI_Comm comm,FILE *fd)
    121: {
    123:   PetscMPIInt    rank;

    126:   MPI_Comm_rank(comm,&rank);
    127:   if (!rank) {
    128:     char buf[1024];
    129:     while (fgets(buf,1024,fd)) ; /* wait till it prints everything */
    130:     (void) pclose(fd);
    131:   }
    132:   return(0);
    133: }

    136: /*@C
    137:       PetscPOpen - Runs a program on processor zero and sends either its input or output to
    138:           a file.

    140:      Logically Collective, but only process 0 runs the command

    142:    Input Parameters:
    143: +   comm - MPI communicator, only processor zero runs the program
    144: .   machine - machine to run command on or NULL, or string with 0 in first location
    145: .   program - name of program to run
    146: -   mode - either r or w

    148:    Output Parameter:
    149: .   fp - the file pointer where program input or output may be read or NULL if don't care

    151:    Level: intermediate

    153:    Notes:
    154:        Use PetscPClose() to close the file pointer when you are finished with it
    155:        Does not work under Windows

    157:        If machine is not provided will use the value set with PetsPOpenSetMachine() if that was provided, otherwise
    158:        will use the machine running node zero of the communicator

    160:        The program string may contain ${DISPLAY}, ${HOMEDIRECTORY} or ${WORKINGDIRECTORY}; these
    161:     will be replaced with relevent values.

    163: .seealso: PetscFOpen(), PetscFClose(), PetscPClose(), PetscPOpenSetMachine()

    165: @*/
    166: PetscErrorCode  PetscPOpen(MPI_Comm comm,const char machine[],const char program[],const char mode[],FILE **fp)
    167: {
    169:   PetscMPIInt    rank;
    170:   size_t         i,len,cnt;
    171:   char           commandt[PETSC_MAX_PATH_LEN],command[PETSC_MAX_PATH_LEN];
    172:   FILE           *fd;

    175:   /* all processors have to do the string manipulation because PetscStrreplace() is a collective operation */
    176:   if (PetscPOpenMachine[0] || (machine && machine[0])) {
    177:     PetscStrcpy(command,"ssh ");
    178:     if (PetscPOpenMachine[0]) {
    179:       PetscStrcat(command,PetscPOpenMachine);
    180:     } else {
    181:       PetscStrcat(command,machine);
    182:     }
    183:     PetscStrcat(command," \" export DISPLAY=${DISPLAY}; ");
    184:     /*
    185:         Copy program into command but protect the " with a \ in front of it
    186:     */
    187:     PetscStrlen(command,&cnt);
    188:     PetscStrlen(program,&len);
    189:     for (i=0; i<len; i++) {
    190:       if (program[i] == '\"') command[cnt++] = '\\';
    191:       command[cnt++] = program[i];
    192:     }
    193:     command[cnt] = 0;

    195:     PetscStrcat(command,"\"");
    196:   } else {
    197:     PetscStrcpy(command,program);
    198:   }

    200:   PetscStrreplace(comm,command,commandt,1024);

    202:   MPI_Comm_rank(comm,&rank);
    203:   if (!rank) {
    204:     PetscInfo1(NULL,"Running command :%s\n",commandt);
    205:     if (!(fd = popen(commandt,mode))) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"Cannot run command %s",commandt);
    206:     if (fp) *fp = fd;
    207:   }
    208:   return(0);
    209: }

    211: /*@C
    212:       PetscPOpenSetMachine - Sets the name of the default machine to run PetscPOpen() calls on

    214:      Logically Collective, but only process 0 runs the command

    216:    Input Parameter:
    217: .   machine - machine to run command on or NULL for the current machine

    219:    Options Database:
    220: .   -popen_machine <machine> - run the process on this machine

    222:    Level: intermediate

    224: .seealso: PetscFOpen(), PetscFClose(), PetscPClose(), PetscPOpen()
    225: @*/
    226: PetscErrorCode  PetscPOpenSetMachine(const char machine[])
    227: {

    231:   if (machine) {
    232:     PetscStrcpy(PetscPOpenMachine,machine);
    233:   } else {
    234:     PetscPOpenMachine[0] = 0;
    235:   }
    236:   return(0);
    237: }

    239: #endif