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 "adio.h"
00010 
00011 void ADIOI_GEN_SetInfo(ADIO_File fd, MPI_Info users_info, int *error_code)
00012 {
00013 /* if fd->info is null, create a new info object. 
00014    Initialize fd->info to default values.
00015    Initialize fd->hints to default values.
00016    Examine the info object passed by the user. If it contains values that
00017    ROMIO understands, override the default. */
00018 
00019     MPI_Info info;
00020     char *value;
00021     int flag, intval, tmp_val, nprocs;
00022 
00023     if (fd->info == MPI_INFO_NULL) MPI_Info_create(&(fd->info));
00024     info = fd->info;
00025 
00026     /* Note that fd->hints is allocated at file open time; thus it is
00027      * not necessary to allocate it, or check for allocation, here.
00028      */
00029 
00030     value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
00031     if (value == NULL) {
00032         /* NEED TO HANDLE ENOMEM */
00033     }
00034 
00035     /* initialize info and hints to default values if they haven't been
00036      * previously initialized
00037      */
00038     if (!fd->hints->initialized) {
00039         /* buffer size for collective I/O */
00040         MPI_Info_set(info, "cb_buffer_size", ADIOI_CB_BUFFER_SIZE_DFLT); 
00041         fd->hints->cb_buffer_size = atoi(ADIOI_CB_BUFFER_SIZE_DFLT);
00042 
00043         /* default is to let romio automatically decide when to use
00044          * collective buffering
00045          */
00046         MPI_Info_set(info, "romio_cb_read", "automatic"); 
00047         fd->hints->cb_read = ADIOI_HINT_AUTO;
00048         MPI_Info_set(info, "romio_cb_write", "automatic"); 
00049         fd->hints->cb_write = ADIOI_HINT_AUTO;
00050 
00051         fd->hints->cb_config_list = NULL;
00052 
00053         /* number of processes that perform I/O in collective I/O */
00054         MPI_Comm_size(fd->comm, &nprocs);
00055         sprintf(value, "%d", nprocs);
00056         MPI_Info_set(info, "cb_nodes", value);
00057         fd->hints->cb_nodes = nprocs;
00058 
00059         /* hint indicating that no indep. I/O will be performed on this file */
00060         MPI_Info_set(info, "romio_no_indep_rw", "false");
00061         fd->hints->no_indep_rw = 0;
00062 
00063         /* buffer size for data sieving in independent reads */
00064         MPI_Info_set(info, "ind_rd_buffer_size", ADIOI_IND_RD_BUFFER_SIZE_DFLT);
00065         fd->hints->ind_rd_buffer_size = atoi(ADIOI_IND_RD_BUFFER_SIZE_DFLT);
00066 
00067         /* buffer size for data sieving in independent writes */
00068         MPI_Info_set(info, "ind_wr_buffer_size", ADIOI_IND_WR_BUFFER_SIZE_DFLT);
00069         fd->hints->ind_wr_buffer_size = atoi(ADIOI_IND_WR_BUFFER_SIZE_DFLT);
00070 
00071         /* default is to let romio automatically decide when to use data
00072          * sieving
00073          */
00074         MPI_Info_set(info, "romio_ds_read", "automatic"); 
00075         fd->hints->ds_read = ADIOI_HINT_AUTO;
00076         MPI_Info_set(info, "romio_ds_write", "automatic"); 
00077         fd->hints->ds_write = ADIOI_HINT_AUTO;
00078 
00079         fd->hints->initialized = 1;
00080     }
00081 
00082     /* add in user's info if supplied */
00083     if (users_info != MPI_INFO_NULL) {
00084         MPI_Info_get(users_info, "cb_buffer_size", MPI_MAX_INFO_VAL, 
00085                      value, &flag);
00086         if (flag && ((intval=atoi(value)) > 0)) {
00087             tmp_val = intval;
00088             MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
00089             if (tmp_val != intval) {
00090                 FPRINTF(stderr, "ADIOI_GEN_SetInfo: the value for key \"cb_buffer_size\" must be the same on all processes\n");
00091                 MPI_Abort(MPI_COMM_WORLD, 1);
00092             }
00093             else {
00094                 MPI_Info_set(info, "cb_buffer_size", value);
00095                 fd->hints->cb_buffer_size = intval;
00096             }
00097         }
00098 
00099         /* new hints for enabling/disabling coll. buffering on
00100          * reads/writes
00101          */
00102         MPI_Info_get(users_info, "romio_cb_read", MPI_MAX_INFO_VAL, value, &flag);
00103         if (flag) {
00104             if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) {
00105                 MPI_Info_set(info, "romio_cb_read", value);
00106                 fd->hints->cb_read = ADIOI_HINT_ENABLE;
00107             }
00108             else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) {
00109                 MPI_Info_set(info, "romio_cb_read", value);
00110                 fd->hints->cb_read = ADIOI_HINT_DISABLE;
00111             }
00112             else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC"))
00113             {
00114                 MPI_Info_set(info, "romio_cb_read", value);
00115                 fd->hints->cb_read = ADIOI_HINT_AUTO;
00116             }
00117 
00118             tmp_val = fd->hints->cb_read;
00119             MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
00120             if (tmp_val != fd->hints->cb_read) {
00121                 FPRINTF(stderr, "ADIOI_GEN_SetInfo: the value for key \"romio_cb_read\" must be the same on all processes\n");
00122                 MPI_Abort(MPI_COMM_WORLD, 1);
00123             }
00124         }
00125         MPI_Info_get(users_info, "romio_cb_write", MPI_MAX_INFO_VAL, value, &flag);
00126         if (flag) {
00127             if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) {
00128                 MPI_Info_set(info, "romio_cb_write", value);
00129                 fd->hints->cb_write = ADIOI_HINT_ENABLE;
00130             }
00131             else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) {
00132                 MPI_Info_set(info, "romio_cb_write", value);
00133                 fd->hints->cb_write = ADIOI_HINT_DISABLE;
00134             }
00135             else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC"))
00136             {
00137                 MPI_Info_set(info, "romio_cb_write", value);
00138                 fd->hints->cb_write = ADIOI_HINT_AUTO;
00139             }
00140         
00141             tmp_val = fd->hints->cb_write;
00142             MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
00143             if (tmp_val != fd->hints->cb_write) {
00144                 FPRINTF(stderr, "ADIOI_GEN_SetInfo: the value for key \"romio_cb_write\" must be the same on all processes\n");
00145                 MPI_Abort(MPI_COMM_WORLD, 1);
00146             }
00147         }
00148 
00149         /* new hint for specifying no indep. read/write will be performed */
00150         MPI_Info_get(users_info, "romio_no_indep_rw", MPI_MAX_INFO_VAL, value,
00151                      &flag);
00152         if (flag) {
00153             if (!strcmp(value, "true") || !strcmp(value, "TRUE")) {
00154                 MPI_Info_set(info, "romio_no_indep_rw", value);
00155                 fd->hints->no_indep_rw = 1;
00156                 tmp_val = 1;
00157             }
00158             else if (!strcmp(value, "false") || !strcmp(value, "FALSE")) {
00159                 MPI_Info_set(info, "romio_no_indep_rw", value);
00160                 fd->hints->no_indep_rw = 0;
00161                 tmp_val = 0;
00162             }
00163             else {
00164                 /* default is above */
00165                 tmp_val = 0;
00166             }
00167             MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
00168             if (tmp_val != fd->hints->no_indep_rw) {
00169                 FPRINTF(stderr, "ADIOI_GEN_SetInfo: the value for key \"romio_no_indep_rw\" must be the same on all processes\n");
00170                 MPI_Abort(MPI_COMM_WORLD, 1);
00171             }
00172         }
00173         /* new hints for enabling/disabling data sieving on
00174          * reads/writes
00175          */
00176         MPI_Info_get(users_info, "romio_ds_read", MPI_MAX_INFO_VAL, value, 
00177                      &flag);
00178         if (flag) {
00179             if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) {
00180                 MPI_Info_set(info, "romio_ds_read", value);
00181                 fd->hints->ds_read = ADIOI_HINT_ENABLE;
00182             }
00183             else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) {
00184                 MPI_Info_set(info, "romio_ds_read", value);
00185                 fd->hints->ds_read = ADIOI_HINT_DISABLE;
00186             }
00187             else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC"))
00188             {
00189                 MPI_Info_set(info, "romio_ds_read", value);
00190                 fd->hints->ds_read = ADIOI_HINT_AUTO;
00191             }
00192             /* otherwise ignore */
00193         }
00194         MPI_Info_get(users_info, "romio_ds_write", MPI_MAX_INFO_VAL, value, 
00195                      &flag);
00196         if (flag) {
00197             if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) {
00198                 MPI_Info_set(info, "romio_ds_write", value);
00199                 fd->hints->ds_write = ADIOI_HINT_ENABLE;
00200             }
00201             else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) {
00202                 MPI_Info_set(info, "romio_ds_write", value);
00203                 fd->hints->ds_write = ADIOI_HINT_DISABLE;
00204             }
00205             else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC"))
00206             {
00207                 MPI_Info_set(info, "romio_ds_write", value);
00208                 fd->hints->ds_write = ADIOI_HINT_AUTO;
00209             }
00210             /* otherwise ignore */
00211         }
00212 
00213         MPI_Info_get(users_info, "cb_nodes", MPI_MAX_INFO_VAL, 
00214                      value, &flag);
00215         if (flag && ((intval=atoi(value)) > 0)) {
00216             tmp_val = intval;
00217             MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
00218             if (tmp_val != intval) {
00219                 FPRINTF(stderr, "ADIOI_GEN_SetInfo: the value for key \"cb_nodes\" must be the same on all processes\n");
00220                 MPI_Abort(MPI_COMM_WORLD, 1);
00221             }
00222             else {
00223                 if (intval < nprocs) {
00224                     MPI_Info_set(info, "cb_nodes", value);
00225                     fd->hints->cb_nodes = intval;
00226                 }
00227             }
00228         }
00229 
00230         MPI_Info_get(users_info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, 
00231                      value, &flag);
00232         if (flag && ((intval = atoi(value)) > 0)) {
00233             MPI_Info_set(info, "ind_wr_buffer_size", value);
00234             fd->hints->ind_wr_buffer_size = intval;
00235         }
00236 
00237         MPI_Info_get(users_info, "ind_rd_buffer_size", MPI_MAX_INFO_VAL, 
00238                      value, &flag);
00239         if (flag && ((intval = atoi(value)) > 0)) {
00240             MPI_Info_set(info, "ind_rd_buffer_size", value);
00241             fd->hints->ind_rd_buffer_size = intval;
00242         }
00243 
00244         MPI_Info_get(users_info, "cb_config_list", MPI_MAX_INFO_VAL,
00245                      value, &flag);
00246         if (flag) {
00247             if (fd->hints->cb_config_list == NULL) {
00248                 /* only set cb_config_list if it isn't already set.
00249                  * Note that since we set it below, this ensures that
00250                  * the cb_config_list hint will be set at file open time
00251                  * either by the user or to the default
00252                  */
00253                 MPI_Info_set(info, "cb_config_list", value);
00254                 fd->hints->cb_config_list = ADIOI_Malloc((strlen(value)+1) * sizeof(char));
00255                 if (fd->hints->cb_config_list == NULL) {
00256                     /* NEED TO HANDLE ENOMEM */
00257                 }
00258                 strcpy(fd->hints->cb_config_list, value);
00259             }
00260             /* if it has been set already, we ignore it the second time. 
00261              * otherwise we would get an error if someone used the same
00262              * info value with a cb_config_list value in it in a couple
00263              * of calls, which would be irritating. */
00264         }
00265     }
00266 
00267     /* handle cb_config_list default value here; avoids an extra
00268      * free/alloc and insures it is always set
00269      */
00270     if (fd->hints->cb_config_list == NULL) {
00271         MPI_Info_set(info, "cb_config_list", ADIOI_CB_CONFIG_LIST_DFLT);
00272         fd->hints->cb_config_list = ADIOI_Malloc((strlen(ADIOI_CB_CONFIG_LIST_DFLT)+1) * sizeof(char));
00273         if (fd->hints->cb_config_list == NULL) {
00274             /* NEED TO HANDLE ENOMEM */
00275         }
00276         strcpy(fd->hints->cb_config_list, ADIOI_CB_CONFIG_LIST_DFLT);
00277     }
00278 
00279     if ((fd->file_system == ADIO_PIOFS) || (fd->file_system == ADIO_PVFS)) {
00280     /* no data sieving for writes in PIOFS and PVFS, because they do not
00281        support file locking */
00282         MPI_Info_get(info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL,
00283                      value, &flag);
00284         if (flag) {
00285             /* get rid of this value if it is set */
00286             MPI_Info_delete(info, "ind_wr_buffer_size");
00287         }
00288         fd->hints->ind_wr_buffer_size = -1;
00289         MPI_Info_set(info, "romio_ds_write", "disable");
00290         fd->hints->ds_write = ADIOI_HINT_DISABLE;
00291     }
00292 
00293     ADIOI_Free(value);
00294 
00295     *error_code = MPI_SUCCESS;
00296 }
libs/ck-libs/ampi/romio/adio/common/ad_hints.c
