Add Runtime Options for logMsgAbort and abort

src/Infrastructure/Util/src/ESMF_LogErr.F90

@@ -1804,6 +1804,10 @@ end subroutine f_ESMF_VMGlobalGet
     type(ESMF_LogEntry), dimension(:), pointer             :: localbuf
     character(len=ESMF_MAXPATHLEN)                         :: fname
     character(ESMF_MAXSTR)                                 :: petNumChar
+    integer                                                :: msgAbortCnt
+    type(ESMF_LogMsg_Flag)                                 :: msgAbortLst(6)
+    character(ESMF_MAXSTR)                                 :: envRtAbort
+    integer                                                :: idxRtAbort
     character(8)                                           :: position
     integer                                                :: petCount
     integer                                                :: digits
@@ -1864,7 +1868,58 @@ end subroutine f_ESMF_VMGlobalGet
     alog%flushed = ESMF_FALSE
     alog%dirty = ESMF_FALSE
     alog%FileIsOpen=ESMF_FALSE
-    alog%logmsgAbort => null ()
+    if (associated (alog%logmsgAbort)) deallocate (alog%logmsgAbort)
+    call c_ESMC_VMGetEnv("ESMF_RUNTIME_LOGMSGABORT", envRtAbort, localrc)
+    if (localrc /= ESMF_SUCCESS) then
+      write (ESMF_UtilIOStderr,*) ESMF_METHOD,  &
+          ": VMGetEnv - ESMF_RUNTIME_LOGMSGABORT "
+      call ESMF_UtilIOUnitFlush(ESMF_UtilIOStderr, rc=rc)
+      if (present(rc)) rc=localrc
+      return
+    end if
+    msgAbortCnt = 0
+    idxRtAbort = index (envRtAbort, "ESMF_LOGMSG_INFO")
+    if (idxRtAbort > 0) then
+      msgAbortCnt = msgAbortCnt + 1
+      msgAbortLst(msgAbortCnt) = ESMF_LOGMSG_INFO
+    endif
+    idxRtAbort = index (envRtAbort, "ESMF_LOGMSG_WARNING")
+    if (idxRtAbort > 0) then
+      msgAbortCnt = msgAbortCnt + 1
+      msgAbortLst(msgAbortCnt) = ESMF_LOGMSG_WARNING
+    endif
+    idxRtAbort = index (envRtAbort, "ESMF_LOGMSG_ERROR")
+    if (idxRtAbort > 0) then
+      msgAbortCnt = msgAbortCnt + 1
+      msgAbortLst(msgAbortCnt) = ESMF_LOGMSG_ERROR
+    endif
+    idxRtAbort = index (envRtAbort, "ESMF_LOGMSG_TRACE")
+    if (idxRtAbort > 0) then
+      msgAbortCnt = msgAbortCnt + 1
+      msgAbortLst(msgAbortCnt) = ESMF_LOGMSG_TRACE
+    endif
+    idxRtAbort = index (envRtAbort, "ESMF_LOGMSG_DEBUG")
+    if (idxRtAbort > 0) then
+      msgAbortCnt = msgAbortCnt + 1
+      msgAbortLst(msgAbortCnt) = ESMF_LOGMSG_DEBUG
+    endif
+    idxRtAbort = index (envRtAbort, "ESMF_LOGMSG_JSON")
+    if (idxRtAbort > 0) then
+      msgAbortCnt = msgAbortCnt + 1
+      msgAbortLst(msgAbortCnt) = ESMF_LOGMSG_JSON
+    endif
+    if (msgAbortCnt > 6) then
+      write (ESMF_UtilIOStderr,*) ESMF_METHOD,  &
+          ": msgAbortLst overflow - ESMF_RUNTIME_LOGMSGABORT"
+      call ESMF_UtilIOUnitFlush(ESMF_UtilIOStderr, rc=rc)
+      if (present(rc)) rc=ESMF_RC_BUFFER_SHORT
+      return
+    elseif (msgAbortCnt == 0) then
+      alog%logmsgAbort => null ()
+    else
+      allocate(alog%logmsgAbort(msgAbortCnt))
+      alog%logmsgAbort=msgAbortLst(1:msgAbortCnt)
+    endif
     nullify(alog%errorMask)
     alog%errorMaskCount=0
     if (present(logkindflag)) then

src/Infrastructure/VM/interface/ESMCI_VM_F.C

@@ -1205,6 +1205,39 @@ extern "C" {
     if (rc!=NULL) *rc = ESMF_SUCCESS;
   }
 
+  void FTN_X(c_esmc_vmgetenv)(char *name, char *value, int *rc,
+    ESMCI_FortranStrLenArg name_l, ESMCI_FortranStrLenArg value_l){
+#undef  ESMC_METHOD
+#define ESMC_METHOD "c_esmc_vmgetenv()"
+    // Initialize return code; assume routine not implemented
+    if (rc!=NULL) *rc = ESMC_RC_NOT_IMPL;
+    try{
+      std::string nameStr(name, name_l);
+      std::string envVarStr;
+      char const *envVar = ESMCI::VM::getenv(nameStr.c_str());
+      if (envVar != NULL && strlen(envVar) > 0) {
+        envVarStr.assign(envVar);
+      }else{
+        envVarStr.assign("");
+      }
+      std::strncpy (value, envVarStr.c_str(), value_l);
+    }catch(int localrc){
+      if (ESMC_LogDefault.MsgFoundError(localrc, ESMCI_ERR_PASSTHRU,
+        ESMC_CONTEXT, rc))
+        return; // bail out
+    }catch(std::exception &x){
+      ESMC_LogDefault.MsgFoundError(ESMC_RC_INTNRL_BAD, x.what(), ESMC_CONTEXT,
+        rc);
+      return; // bail out
+    }catch(...){
+      ESMC_LogDefault.MsgFoundError(ESMC_RC_INTNRL_BAD, "- Caught exception",
+        ESMC_CONTEXT, rc);
+      return;
+    }
+    // return successfully
+    if (rc!=NULL) *rc = ESMF_SUCCESS;
+  }
+
   void FTN_X(c_esmc_vmsetenv)(char *name, char *value, int *rc,
     ESMCI_FortranStrLenArg name_l, ESMCI_FortranStrLenArg value_l){
 #undef  ESMC_METHOD

src/Infrastructure/VM/interface/ESMF_VM.F90

@@ -458,6 +458,7 @@ subroutine c_ESMC_VMSendRecvNB(vm, sendData, sendSize, dst, recvData, &
   public ESMF_VMInitializePreMPI
   public ESMF_VMInitialize
   public ESMF_VMSet
+  public ESMF_VMGetEnv
   public ESMF_VMSetEnv
   public ESMF_VMFinalize
   public ESMF_VMAbort
@@ -9398,6 +9399,49 @@ end subroutine ESMF_VMSet
 !------------------------------------------------------------------------------
 
 
+! -------------------------- ESMF-internal method -----------------------------
+#undef  ESMF_METHOD
+#define ESMF_METHOD "ESMF_VMGetEnv()"
+!BOPI
+! !IROUTINE: ESMF_VMGetEnv - Get environment variable cached in the Global VM
+
+! !INTERFACE:
+  subroutine ESMF_VMGetEnv(name, value, rc)
+!
+! !ARGUMENTS:
+    character(*), intent(in)            :: name
+    character(*), intent(out)           :: value
+    integer,      intent(out), optional :: rc
+!
+! !DESCRIPTION:
+!   Get environment variable cached in the Global VM.
+!
+!   The arguments are:
+!   \begin{description}
+!     \item [name]
+!        The name of the environment variable.
+!     \item [value]
+!        The value of the environment variable.
+!   \item[{[rc]}]
+!        Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
+!   \end{description}
+!
+!EOPI
+!------------------------------------------------------------------------------
+    integer                 :: localrc      ! local return code
+
+    ! Call into the C++ interface.
+    call c_ESMC_VMGetEnv(name, value, localrc)
+    if (ESMF_LogFoundError(localrc, ESMF_ERR_PASSTHRU, &
+      ESMF_CONTEXT, rcToReturn=rc)) return
+
+    ! return successfully
+    if (present(rc)) rc = ESMF_SUCCESS
+
+  end subroutine ESMF_VMGetEnv
+!------------------------------------------------------------------------------
+
+
 ! -------------------------- ESMF-internal method -----------------------------
 #undef  ESMF_METHOD
 #define ESMF_METHOD "ESMF_VMSetEnv()"

src/Infrastructure/VM/src/ESMCI_VM.C

@@ -3370,6 +3370,18 @@ VM *VM::initialize(
       esmfRuntimeEnv.push_back(esmfRuntimeVarName);
       esmfRuntimeEnvValue.push_back(esmfRuntimeVarValue);
     }
+    esmfRuntimeVarName = "ESMF_RUNTIME_LOGMSGABORT";
+    esmfRuntimeVarValue = std::getenv(esmfRuntimeVarName);
+    if (esmfRuntimeVarValue){
+      esmfRuntimeEnv.push_back(esmfRuntimeVarName);
+      esmfRuntimeEnvValue.push_back(esmfRuntimeVarValue);
+    }
+    esmfRuntimeVarName = "ESMF_RUNTIME_ABORT";
+    esmfRuntimeVarValue = std::getenv(esmfRuntimeVarName);
+    if (esmfRuntimeVarValue){
+      esmfRuntimeEnv.push_back(esmfRuntimeVarName);
+      esmfRuntimeEnvValue.push_back(esmfRuntimeVarValue);
+    }
 
     int count = esmfRuntimeEnv.size();
     GlobalVM->broadcast(&count, sizeof(int), 0);

src/Infrastructure/VM/src/ESMCI_VMKernel.C

@@ -899,6 +899,20 @@ struct SpawnArg{
 void VMK::abort(){
   // abort default (all MPI) virtual machine
   int finalized;
+
+  char const *envRuntimeAbort = VM::getenv("ESMF_RUNTIME_ABORT");
+  if (envRuntimeAbort != NULL && strlen(envRuntimeAbort) > 0) {
+    string runtimeAbort(envRuntimeAbort);
+    transform(runtimeAbort.begin(), runtimeAbort.end(),
+      runtimeAbort.begin(), ::toupper);
+    if (runtimeAbort.find("SIGABRT") != string::npos) {
+      std::abort();
+    } else if (runtimeAbort.find("SIGQUIT") != string::npos) {
+#ifdef SIGQUIT
+      raise (SIGQUIT);
+#endif
+    }
+  }
   MPI_Finalized(&finalized);
   if (!finalized)
     MPI_Abort(default_mpi_c, EXIT_FAILURE);

src/Superstructure/ESMFMod/src/ESMF_Init.F90

@@ -1107,6 +1107,9 @@ subroutine ESMF_FrameworkInternalInit(lang, configFilenameFromArgNum, &
           endif
         endif
 
+        call ingest_environment_variable("ESMF_RUNTIME_LOGMSGABORT")
+        call ingest_environment_variable("ESMF_RUNTIME_ABORT")
+
       endif ! have a default Config
 
       if (present(configFilenameFromArgNum).or.present(configFilename)) &

src/addon/ESMX/ESMX_App.F90

@@ -65,6 +65,8 @@ program ESMX_App
                 "ESMF_RUNTIME_TRACE_COMPONENT", & ! ESMF_Initialize option
                 "ESMF_RUNTIME_TRACE_FLUSH    ", & ! ESMF_Initialize option
                 "ESMF_RUNTIME_COMPLIANCECHECK", & ! ESMF_Initialize option
+                "ESMF_RUNTIME_LOGMSGABORT    ", & ! ESMF_Initialize option
+                "ESMF_RUNTIME_ABORT          ", & ! ESMF_Initialize option
                 "startTime                   ", & ! ESMX_App option
                 "stopTime                    ", & ! ESMX_App option
                 "logFlush                    ", & ! ESMX_App option