root/ompi/mca/io/romio321/romio/adio/common/hint_fns.c

DEFINITIONS

1. ADIOI_Info_check_and_install_int
2. ADIOI_Info_check_and_install_enabled
3. ADIOI_Info_check_and_install_true
4. ADIOI_Info_check_and_install_str

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /* 
   3  *
   4  *   Copyright (C) 2013 UChicago/Argonne, LLC
   5  *   See COPYRIGHT notice in top-level directory.
   6  */
   7 
   8 #include "adio.h"
   9 #include "hint_fns.h"
  10 
  11 
  12 int ADIOI_Info_check_and_install_int(ADIO_File fd, MPI_Info info, const char *key, 
  13         int *local_cache, char *funcname, int *error_code)
  14 {
  15     int intval, tmp_val, flag, ret=0;
  16     char *value;
  17 
  18     value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
  19     if (value == NULL) {
  20         *error_code = MPIO_Err_create_code(*error_code,
  21                                            MPIR_ERR_RECOVERABLE,
  22                                            funcname,
  23                                            __LINE__,
  24                                            MPI_ERR_OTHER,
  25                                            "**nomem2",0);
  26         return -1;
  27     }
  28 
  29     ADIOI_Info_get(info, key, MPI_MAX_INFO_VAL, value, &flag);
  30     if (flag) {
  31         intval = atoi(value);
  32         tmp_val = intval;
  33 
  34         MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
  35         /* --BEGIN ERROR HANDLING-- */
  36         if (tmp_val != intval) {
  37             MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(funcname,
  38                     key, 
  39                     error_code);
  40             ret = -1;
  41             goto fn_exit;
  42         }
  43         /* --END ERROR HANDLING-- */
  44 
  45         ADIOI_Info_set(fd->info, key, value);
  46         /* some file systems do not cache hints in the fd struct */
  47         if (local_cache != NULL) *local_cache = intval;
  48     }
  49 fn_exit:
  50     ADIOI_Free(value);
  51     return ret;
  52 }
  53 
  54 int ADIOI_Info_check_and_install_enabled(ADIO_File fd, MPI_Info info, const char *key, 
  55         int *local_cache, char *funcname, int *error_code)
  56 {
  57     int tmp_val, flag, ret=0;
  58     char *value;
  59 
  60     value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
  61     if (value == NULL) {
  62         *error_code = MPIO_Err_create_code(*error_code,
  63                                            MPIR_ERR_RECOVERABLE,
  64                                            funcname,
  65                                            __LINE__,
  66                                            MPI_ERR_OTHER,
  67                                            "**nomem2",0);
  68         return -1;
  69     }
  70 
  71     ADIOI_Info_get(info, key, MPI_MAX_INFO_VAL, value, &flag);
  72     if (flag) {
  73         if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) {
  74             ADIOI_Info_set(fd->info, key, value);
  75             *local_cache = ADIOI_HINT_ENABLE;
  76         }
  77         else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) {
  78             ADIOI_Info_set(fd->info, key, value);
  79             *local_cache = ADIOI_HINT_DISABLE;
  80         }
  81         else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC"))
  82         {
  83             ADIOI_Info_set(fd->info, key, value);
  84             *local_cache = ADIOI_HINT_AUTO;
  85         }
  86 
  87         tmp_val = *local_cache;
  88 
  89         MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
  90         /* --BEGIN ERROR HANDLING-- */
  91         if (tmp_val != *local_cache) {
  92             MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(funcname,
  93                     key,
  94                     error_code);
  95             ret = -1;
  96             goto fn_exit;
  97         }
  98         /* --END ERROR HANDLING-- */
  99     }
 100 fn_exit:
 101     ADIOI_Free(value);
 102     return ret;
 103 }
 104 int ADIOI_Info_check_and_install_true(ADIO_File fd, MPI_Info info, const char *key, 
 105         int *local_cache, char *funcname, int *error_code)
 106 {
 107     int flag, tmp_val, ret=0;
 108     char *value;
 109 
 110     value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
 111     if (value == NULL) {
 112         *error_code = MPIO_Err_create_code(*error_code,
 113                                            MPIR_ERR_RECOVERABLE,
 114                                            funcname,
 115                                            __LINE__,
 116                                            MPI_ERR_OTHER,
 117                                            "**nomem2",0);
 118         return -1;
 119     }
 120 
 121     ADIOI_Info_get(info, key, MPI_MAX_INFO_VAL, value, &flag);
 122     if (flag) {
 123         if (!strcmp(value, "true") || !strcmp(value, "TRUE")) {
 124             ADIOI_Info_set(fd->info, key, value);
 125             *local_cache = 1;
 126         }
 127         else if (!strcmp(value, "false") || !strcmp(value, "FALSE")) {
 128             ADIOI_Info_set(fd->info, key, value);
 129             *local_cache = 0;
 130         }
 131         tmp_val = *local_cache;
 132 
 133         MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
 134         /* --BEGIN ERROR HANDLING-- */
 135         if (tmp_val != *local_cache) {
 136             MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(funcname,
 137                     key,
 138                     error_code);
 139             ret = -1;
 140             goto fn_exit;
 141         }
 142         /* --END ERROR HANDLING-- */
 143     }
 144 fn_exit:
 145     ADIOI_Free(value);
 146     return ret;
 147 }
 148 int ADIOI_Info_check_and_install_str(ADIO_File fd, MPI_Info info, const char *key, 
 149         char **local_cache, char *funcname, int *error_code)
 150 {
 151     int flag, ret=0;
 152     size_t len;
 153     char *value;
 154 
 155     value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
 156     if (value == NULL) {
 157         *error_code = MPIO_Err_create_code(*error_code,
 158                                            MPIR_ERR_RECOVERABLE,
 159                                            funcname,
 160                                            __LINE__,
 161                                            MPI_ERR_OTHER,
 162                                            "**nomem2",0);
 163         return -1;
 164     }
 165 
 166     ADIOI_Info_get(info, key, MPI_MAX_INFO_VAL,
 167             value, &flag);
 168     if (flag) {
 169         ADIOI_Info_set(fd->info, "cb_config_list", value);
 170         len = (strlen(value)+1) * sizeof(char);
 171         *local_cache = ADIOI_Malloc(len);
 172         if (*local_cache == NULL) {
 173             *error_code = MPIO_Err_create_code(*error_code,
 174                     MPIR_ERR_RECOVERABLE,
 175                     funcname,
 176                     __LINE__,
 177                     MPI_ERR_OTHER,
 178                     "**nomem2",0);
 179             ret = -1;
 180             goto fn_exit;
 181         }
 182         ADIOI_Strncpy(*local_cache, value, len);
 183     }
 184     /* if it has been set already, we ignore it the second time. 
 185      * otherwise we would get an error if someone used the same
 186      * info value with a cb_config_list value in it in a couple
 187      * of calls, which would be irritating. */
 188 fn_exit:
 189     ADIOI_Free(value);
 190     return ret;
 191 }