Merge pull request #431 from GEOS-ESM/develop

GitFlow: Merge develop into main for release

Author: mathomp4

.circleci/config.yml

@@ -17,12 +17,13 @@ workflows:
             - docker-hub-creds
           matrix:
             parameters:
-              compiler: [gfortran, ifort]
+              compiler: [gfortran, ifort, ifx]
           #baselibs_version: *baselibs_version
           repo: GEOSgcm
           checkout_fixture: true
           # V12 code uses a special branch for now.
           fixture_branch: feature/sdrabenh/gcm_v12
+          develop_repos: "GEOSgcm_GridComp GEOSgcm_App GMAO_Shared FVdycoreCubed_GridComp fvdycore"
           # We comment out this as it will "undo" the fixture_branch
           #mepodevelop: true
           persist_workspace: true # Needs to be true to run fv3/gcm experiment, costs extra
@@ -34,7 +35,7 @@ workflows:
             - docker-hub-creds
           matrix:
             parameters:
-              compiler: [gfortran, ifort]
+              compiler: [gfortran, ifort, ifx]
           requires:
             - build-GEOSgcm-on-<< matrix.compiler >>
           repo: GEOSgcm
@@ -48,7 +49,7 @@ workflows:
             - docker-hub-creds
           matrix:
             parameters:
-              compiler: [ifort]
+              compiler: [ifort, ifx]
               # There seems to be an issue with gfortran, mom6, and GNU
           requires:
             - build-GEOSgcm-on-<< matrix.compiler >>

CHANGELOG.md

@@ -17,6 +17,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Deprecated
 
+## [4.13.0] - 2025-03-18
+
+### Removed
+
+- Remove code for finding OS at NCCS as system is now all SLES15
+
+### Changed
+
+- Update Intel LLVM Fortran flags to use `-march=x86-64-v3` as `-march=core-avx2` is not (technically?) supported by `ifx`
+- Reworked FMS detection to better handle the different `FV_PRECISION` cases in `FindBaselibs.cmake`
+- Change f2py detection for the odd case where there might be multiple Python installations. For now, if the path to the Python executable does not match the path to the f2py executable, we issue a `WARNING`. We use a `WARNING` since some installations (e.g., Spack) will have the Python executable in a different location than the f2py executable.
+- Removed warning that Baselibs is not supported, to a STATUS message.
+
 ## [4.12.0] - 2025-02-11
 
 ### Changed

compiler/flags/IntelLLVM_Fortran.cmake

@@ -63,23 +63,18 @@ set (NO_RANGE_CHECK "")
 
 cmake_host_system_information(RESULT proc_description QUERY PROCESSOR_DESCRIPTION)
 if (${proc_description} MATCHES "EPYC")
-  # AMD EPYC processors support AVX2, but only via the -march=core-avx2 flag
-  set (COREAVX2_FLAG "-march=core-avx2")
+  set (MARCH_FLAG "-march=x86-64-v3")
 elseif (${proc_description} MATCHES "Hygon")
-  # Hygon processors support AVX2, but only via the -march=core-avx2 flag
-  set (COREAVX2_FLAG "-march=core-avx2")
+  set (MARCH_FLAG "-march=x86-64-v3")
 elseif (${proc_description} MATCHES "Intel")
   # All the Intel processors that GEOS runs on support AVX2, but to be
-  # consistent with the AMD processors, we use the -march=core-avx2 flag
-  set (COREAVX2_FLAG "-march=core-avx2")
-  # Previous versions of GEOS used this flag, which was not portable
-  # for AMD. Keeping here for a few versions for historical purposes.
-  #set (COREAVX2_FLAG "-xCORE-AVX2")
+  # consistent with the AMD processors, we use the -march=x86-64-v3 flag
+  set (MARCH_FLAG "-march=x86-64-v3")
 elseif ( ${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64" )
   # This is a fallback for when the above doesn't work. It should work
   # for most x86_64 processors, but it is not guaranteed to be optimal.
   message(WARNING "Unknown processory type. Defaulting to a generic x86_64 processor. Performance may be suboptimal.")
-  set (COREAVX2_FLAG "")
+  set (MARCH_FLAG "x86-64")
 else ()
   message(FATAL_ERROR "Unknown processor. Please file an issue at https://github.com/GEOS-ESM/ESMA_cmake")
 endif ()
@@ -108,7 +103,7 @@ set (GEOS_Fortran_NoVect_FPE_Flags "${common_Fortran_fpe_flags} ${ARCH_CONSISTEN
 
 # GEOS Vectorize
 # --------------
-set (GEOS_Fortran_Vect_Flags "${FOPT3} ${DEBINFO} ${COREAVX2_FLAG} -fma -qopt-report0 ${FTZ} ${ALIGN_ALL} ${NO_ALIAS} -align array32byte")
+set (GEOS_Fortran_Vect_Flags "${FOPT3} ${DEBINFO} ${MARCH_FLAG} -fma -qopt-report0 ${FTZ} ${ALIGN_ALL} ${NO_ALIAS} -align array32byte")
 set (GEOS_Fortran_Vect_FPE_Flags "${FPE3} ${FP_MODEL_CONSISTENT} ${NOOLD_MAXMINLOC}")
 
 # GEOS Release
@@ -118,7 +113,7 @@ set (GEOS_Fortran_Release_FPE_Flags "${GEOS_Fortran_Vect_FPE_Flags}")
 
 # GEOS Aggressive
 # ---------------
-set (GEOS_Fortran_Aggressive_Flags "${FOPT3} ${DEBINFO} ${COREAVX2_FLAG} -fma -qopt-report0 ${FTZ} ${ALIGN_ALL} ${NO_ALIAS} -align array32byte")
+set (GEOS_Fortran_Aggressive_Flags "${FOPT3} ${DEBINFO} ${MARCH_FLAG} -fma -qopt-report0 ${FTZ} ${ALIGN_ALL} ${NO_ALIAS} -align array32byte")
 #set (GEOS_Fortran_Aggressive_Flags "${FOPT3} ${DEBINFO} -xSKYLAKE-AVX512 -qopt-zmm-usage=high -fma -qopt-report0 ${FTZ} ${ALIGN_ALL} ${NO_ALIAS} -align array64byte")
 set (GEOS_Fortran_Aggressive_FPE_Flags "${FPE3} ${FP_MODEL_FAST2} ${USE_SVML} ${NOOLD_MAXMINLOC}")
 

external_libraries/DetermineSite.cmake

@@ -11,23 +11,6 @@ set(DETECTED_SITE "UNKNOWN")
 
 if (${BUILD_SITE} MATCHES "discover*" OR ${BUILD_SITE} MATCHES "borg*" OR ${BUILD_SITE} MATCHES "warp*")
   set (DETECTED_SITE "NCCS")
-  # NCCS now has two OSs. We need to detect if we are on SLES 15. If so, we set a flag "BUILT_ON_SLES15"
-  # which we will use to make sure people building on SLES15 run on SLES15
-  # The commmand we use in bash is:
-  #   grep VERSION_ID /etc/os-release | cut -d= -f2 | cut -d. -f1 | sed 's/"//g'
-  execute_process(
-    COMMAND grep VERSION_ID /etc/os-release
-    COMMAND cut -d= -f2
-    COMMAND cut -d. -f1
-    COMMAND sed s/\"//g
-    OUTPUT_VARIABLE OS_RELEASE
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-  if (OS_RELEASE STREQUAL "15")
-    set (BUILT_ON_SLES15 TRUE)
-  else ()
-    set (BUILT_ON_SLES15 FALSE)
-  endif ()
 elseif (${BUILD_SITE} MATCHES "pfe" OR ${BUILD_SITE} MATCHES "r[0-9]*i[0-9]*n[0-9]*" OR ${BUILD_SITE} MATCHES "r[0-9]*c[0-9]*t[0-9]*n[0-9]*")
   set (DETECTED_SITE "NAS")
 elseif (EXISTS /ford1/share/gmao_SIteam AND EXISTS /ford1/local AND ${CMAKE_SYSTEM_NAME} MATCHES "Linux")
@@ -80,12 +63,3 @@ endif ()
 
 set(GEOS_SITE ${DETECTED_SITE} CACHE STRING "Detected site for use with GEOS setup scripts")
 message(STATUS "Setting GEOS_SITE to ${GEOS_SITE}")
-
-if (DETECTED_SITE STREQUAL "NCCS")
-  if (BUILT_ON_SLES15)
-    message(STATUS "Building on SLES15 at NCCS. Can only run on Milan processors")
-  else ()
-    message(STATUS "Building on SLES12 at NCCS. Can run on Cascade Lake or Skylake processors")
-  endif ()
-endif ()
-

external_libraries/FindBaselibs.cmake

@@ -59,12 +59,7 @@ if (BASEDIR)
   endif ()
   set (BASEDIR "${BASEDIR}" CACHE PATH "Path to installed baselibs" FORCE)
 else ()
-  ecbuild_warn(
-    "BASEDIR not specified.\n"
-    "If you wish to use Baselibs, please use:\n"
-    "   cmake ... -DBASEDIR=<path-to-Baselibs>\n"
-    "or set BASEDIR in your environment.\n\n"
-    "Note that building GEOS-ESM code without Baselibs is unsupported.")
+  message(STATUS "BASEDIR not set. Baselibs not found. Assume we are using Spack or other methods to provide dependencies")
 endif ()
 
 if (ESMA_SDF)
@@ -282,42 +277,80 @@ if (Baselibs_FOUND)
   endif ()
 
   # - fms_r4
-  set (inc_fms_r4 ${BASEDIR}/FMS/include_r4)
-  set (lib_fms_r4 ${BASEDIR}/FMS/lib/libfms_r4.a)
-  add_library(FMS::fms_r4 STATIC IMPORTED)
-  set_target_properties(FMS::fms_r4 PROPERTIES
-    IMPORTED_LOCATION ${lib_fms_r4}
-    INCLUDE_DIRECTORIES "${inc_fms_r4}"
-    INTERFACE_INCLUDE_DIRECTORIES "${inc_fms_r4}"
-    INTERFACE_LINK_LIBRARIES  "NetCDF::NetCDF_Fortran;MPI::MPI_Fortran"
-    INTERFACE_LINK_DIRECTORIES "${BASEDIR}/FMS/lib"
-  )
-  if (FMS_BUILT_WITH_YAML)
-    target_link_libraries(FMS::fms_r4 INTERFACE ${LIBYAML_LIBRARIES})
-  endif ()
-  add_library(fms_r4 ALIAS FMS::fms_r4)
-  set(FMS_R4_FOUND TRUE CACHE BOOL "fms_r4 Found" FORCE)
+  if (FV_PRECISION STREQUAL R4 OR FV_PRECISION STREQUAL R4R8)
+    # Use find_path and find_library to find the include and library
+    find_path(FMS_INCLUDE_DIR_R4 NAMES fms.mod PATHS ${BASEDIR}/FMS/include_r4)
+    find_library(FMS_LIBRARIES_R4 NAMES fms_r4 PATHS ${BASEDIR}/FMS/lib ${BASEDIR}/FMS/lib64)
+    # We also need the path of where the library is for the INTERFACE_LINK_DIRECTORIES
+    get_filename_component(FMS_LIBRARIES_DIR_R4 ${FMS_LIBRARIES_R4} DIRECTORY)
+    add_library(FMS::fms_r4 STATIC IMPORTED)
+    set_target_properties(FMS::fms_r4 PROPERTIES
+      IMPORTED_LOCATION ${FMS_LIBRARIES_R4}
+      INCLUDE_DIRECTORIES "${FMS_INCLUDE_DIR_R4}"
+      INTERFACE_INCLUDE_DIRECTORIES "${FMS_INCLUDE_DIR_R4}"
+      INTERFACE_LINK_LIBRARIES  "NetCDF::NetCDF_Fortran;MPI::MPI_Fortran"
+      INTERFACE_LINK_DIRECTORIES "${FMS_LIBRARIES_DIR_R4}"
+    )
+    if (FMS_BUILT_WITH_YAML)
+      target_link_libraries(FMS::fms_r4 INTERFACE ${LIBYAML_LIBRARIES})
+    endif ()
+    # We will set FMS_R4_FOUND if both FMS_LIBRARIES_R4 and FMS_INCLUDE_DIR_R4 are found
+    # and are valid files and directories respectively
+    if (EXISTS ${FMS_LIBRARIES_R4} AND IS_DIRECTORY ${FMS_INCLUDE_DIR_R4})
+      message(STATUS "Found FMS::fms_r4: ${FMS_LIBRARIES_R4}")
+      message(STATUS "FMS::fms_r4 include directory: ${FMS_INCLUDE_DIR_R4}")
+      set(FMS_R4_FOUND TRUE CACHE BOOL "fms_r4 Found" FORCE)
+    else ()
+      message(FATAL_ERROR "FMS::fms_r4 not found")
+    endif()
+  endif()
 
   # - fms_r8
-  set (inc_fms_r8 ${BASEDIR}/FMS/include_r8)
-  set (lib_fms_r8 ${BASEDIR}/FMS/lib/libfms_r8.a)
-  add_library(FMS::fms_r8 STATIC IMPORTED)
-  set_target_properties(FMS::fms_r8 PROPERTIES
-    IMPORTED_LOCATION ${lib_fms_r8}
-    INCLUDE_DIRECTORIES "${inc_fms_r8}"
-    INTERFACE_INCLUDE_DIRECTORIES "${inc_fms_r8}"
-    INTERFACE_LINK_LIBRARIES  "NetCDF::NetCDF_Fortran;MPI::MPI_Fortran"
-    INTERFACE_LINK_DIRECTORIES "${BASEDIR}/FMS/lib"
-  )
-  if (FMS_BUILT_WITH_YAML)
-    target_link_libraries(FMS::fms_r8 INTERFACE ${LIBYAML_LIBRARIES})
-  endif ()
-  add_library(fms_r8 ALIAS FMS::fms_r8)
-  set(FMS_R8_FOUND TRUE CACHE BOOL "fms_r8 Found" FORCE)
+  if (FV_PRECISION STREQUAL R8 OR FV_PRECISION STREQUAL R4R8)
+    # Use find_path and find_library to find the include and library
+    find_path(FMS_INCLUDE_DIR_R8 NAMES fms.mod PATHS ${BASEDIR}/FMS/include_r8)
+    find_library(FMS_LIBRARIES_R8 NAMES fms_r8 PATHS ${BASEDIR}/FMS/lib ${BASEDIR}/FMS/lib64)
+    # We also need the path of where the library is for the INTERFACE_LINK_DIRECTORIES
+    get_filename_component(FMS_LIBRARIES_DIR_R8 ${FMS_LIBRARIES_R8} DIRECTORY)
+    add_library(FMS::fms_r8 STATIC IMPORTED)
+    set_target_properties(FMS::fms_r8 PROPERTIES
+      IMPORTED_LOCATION ${FMS_LIBRARIES_R8}
+      INCLUDE_DIRECTORIES "${FMS_INCLUDE_DIR_R8}"
+      INTERFACE_INCLUDE_DIRECTORIES "${FMS_INCLUDE_DIR_R8}"
+      INTERFACE_LINK_LIBRARIES  "NetCDF::NetCDF_Fortran;MPI::MPI_Fortran"
+      INTERFACE_LINK_DIRECTORIES "${FMS_LIBRARIES_DIR_R8}"
+    )
+    if (FMS_BUILT_WITH_YAML)
+      target_link_libraries(FMS::fms_r8 INTERFACE ${LIBYAML_LIBRARIES})
+    endif ()
+    # We will set FMS_R8_FOUND if both FMS_LIBRARIES_R8 and FMS_INCLUDE_DIR_R8 are found
+    # and are valid files and directories respectively
+    if (EXISTS ${FMS_LIBRARIES_R8} AND IS_DIRECTORY ${FMS_INCLUDE_DIR_R8})
+      message(STATUS "Found FMS::fms_r8: ${FMS_LIBRARIES_R8}")
+      message(STATUS "FMS::fms_r8 include directory: ${FMS_INCLUDE_DIR_R8}")
+      set(FMS_R8_FOUND TRUE CACHE BOOL "fms_r8 Found" FORCE)
+    else ()
+      message(FATAL_ERROR "FMS::fms_r8 not found")
+    endif()
+  endif()
 
-  if (FMS_R4_FOUND AND FMS_R8_FOUND)
-    set(FMS_FOUND TRUE CACHE BOOL "FMS Found" FORCE)
-  endif ()
+  if (FV_PRECISION STREQUAL R4R8)
+    # We will set FMS_FOUND if both fms_r4 and fms_r8 are found
+    # and are valid files and directories respectively
+    if (FMS_R4_FOUND AND FMS_R8_FOUND)
+      set(FMS_FOUND TRUE CACHE BOOL "FMS Found" FORCE)
+    endif()
+  elseif (FV_PRECISION STREQUAL R4)
+    if (FMS_R4_FOUND)
+      set(FMS_FOUND TRUE CACHE BOOL "FMS Found" FORCE)
+    endif()
+  elseif (FV_PRECISION STREQUAL R8)
+    if (FMS_R8_FOUND)
+      set(FMS_FOUND TRUE CACHE BOOL "FMS Found" FORCE)
+    endif()
+  else()
+    message(FATAL_ERROR "FMS Detection failed in odd way")
+  endif()
 
   if (FMS_FOUND)
     set (FMS_DIR ${BASEDIR}/FMS CACHE PATH "Path to FMS" FORCE)

python/esma_python.cmake

@@ -6,10 +6,14 @@ cmake_minimum_required(VERSION 3.24)
 
 # Find Python
 set(Python_FIND_STRATEGY LOCATION)
+set(Python_FIND_UNVERSIONED_NAMES FIRST)
+set(Python_FIND_FRAMEWORK LAST)
 find_package(Python COMPONENTS Interpreter)
 
 # Find Python2
 set(Python2_FIND_STRATEGY LOCATION)
+set(Python2_FIND_UNVERSIONED_NAMES FIRST)
+set(Python2_FIND_FRAMEWORK LAST)
 find_package(Python2 COMPONENTS Interpreter)
 list (APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/f2py2")
 include (esma_find_python2_module)
@@ -18,6 +22,8 @@ include (esma_add_f2py2_module)
 
 # Find Python3
 set(Python3_FIND_STRATEGY LOCATION)
+set(Python3_FIND_UNVERSIONED_NAMES FIRST)
+set(Python3_FIND_FRAMEWORK LAST)
 find_package(Python3 COMPONENTS Interpreter)
 list (APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/f2py3")
 include (esma_find_python3_module)

python/f2py/FindF2PY.cmake

@@ -31,11 +31,38 @@
 #
 
 # Path to the f2py executable
-find_program(F2PY_EXECUTABLE NAMES "f2py${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}"
-                                   "f2py-${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}"
-                                   "f2py${Python_VERSION_MAJOR}"
-                                   "f2py"
-                                   )
+
+## We might have an odd circumstance where there are a couple f2py around. As such,
+## we need to find the one that matches the Python_EXECUTABLE. This is a bit of a
+## hack, but it should work for most cases.
+
+## Find the directory where the Python_EXECUTABLE is located
+message(DEBUG "[F2PY]: Searching for f2py executable associated with Python_EXECUTABLE: ${Python_EXECUTABLE}")
+get_filename_component(PYTHON_EXECUTABLE_DIR ${Python_EXECUTABLE} DIRECTORY)
+message(DEBUG "[F2PY]: Python executable directory: ${PYTHON_EXECUTABLE_DIR}")
+
+find_program(F2PY_EXECUTABLE
+  NAMES "f2py"
+        "f2py${Python_VERSION_MAJOR}"
+        "f2py${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}"
+        "f2py-${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}"
+  PATHS ${PYTHON_EXECUTABLE_DIR}
+)
+
+message(DEBUG "[F2PY]: Found f2py executable: ${F2PY_EXECUTABLE}")
+
+# Now as a sanity check, we need to make sure that the f2py executable is
+# actually the one that is associated with the Python_EXECUTABLE
+get_filename_component(F2PY_EXECUTABLE_DIR ${F2PY_EXECUTABLE} DIRECTORY)
+message(DEBUG "[F2PY]: f2py executable directory: ${F2PY_EXECUTABLE_DIR}")
+
+# Now we issue a WARNING. We can't do more than that because of things like Spack
+# where f2py will be in a different location than python.
+if (NOT "${F2PY_EXECUTABLE_DIR}" STREQUAL "${PYTHON_EXECUTABLE_DIR}")
+  message(WARNING
+    "[F2PY]: The f2py executable [${F2PY_EXECUTABLE}] found is not the one associated with the Python_EXECUTABLE [${Python_EXECUTABLE}].\n"
+    "Please check your Python environment if this is not expected (for example, not a Spack install) or build with -DUSE_F2PY=OFF.")
+endif ()
 
 if(F2PY_EXECUTABLE)
    # extract the version string

python/f2py/try_f2py_compile.cmake

@@ -19,8 +19,22 @@ macro (try_f2py_compile file var)
    else ()
      set(MESON_F2PY_FCOMPILER "${CMAKE_Fortran_COMPILER}")
    endif ()
+   message(DEBUG "MESON_F2PY_FCOMPILER is set to ${MESON_F2PY_FCOMPILER}")
+   message(DEBUG "F2PY_COMPILER is set to ${F2PY_COMPILER}")
+   # hack for Macs. If the C compiler is clang and we are on Apple,
+   # we need to set the CC environment to /usr/bin/clang
+   if(APPLE AND CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
+     set(MESON_CCOMPILER "/usr/bin/clang")
+     message(STATUS "Detected AppleClang on macOS. Using ugly hack for meson by passing in CC=/usr/bin/clang")
+   else()
+     set(MESON_CCOMPILER "${CMAKE_C_COMPILER}")
+   endif()
+   message(DEBUG "MESON_CCOMPILER is set to ${MESON_CCOMPILER}")
+   list(APPEND ENV_LIST FC=${MESON_F2PY_FCOMPILER})
+   list(APPEND ENV_LIST CC=${MESON_CCOMPILER})
+   message(DEBUG "ENV_LIST is set to ${ENV_LIST}")
    execute_process(
-     COMMAND cmake -E env "FC=${MESON_F2PY_COMPILER}" ${F2PY_EXECUTABLE} -m test_ -c ${file} --fcompiler=${F2PY_FCOMPILER}
+     COMMAND cmake -E env ${ENV_LIST} ${F2PY_EXECUTABLE} -m test_ -c ${file} --fcompiler=${F2PY_FCOMPILER}
      WORKING_DIRECTORY ${_f2py_check_bindir}
      RESULT_VARIABLE result
      OUTPUT_QUIET