Merge branch 'cmake' into development

gpucinterfaces
sfilippone 6 months ago
commit c162633845

@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.10)
project(amg4psblas VERSION 1.0 LANGUAGES C Fortran)
project(amg4psblas VERSION 1.0 LANGUAGES C CXX Fortran)
set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
@ -21,6 +21,10 @@ message(STATUS "psblas directory is ${PSBLAS_INSTALL_DIR};;")
message(STATUS "PSBLAS DIRECTORY INC ${INCDIR}; MOD ${MODDIR}; LIB ${LIBDIR};")
#set(CMAKE_CXX_STANDARD 17) # Set cxx standard for the c++ part of the library
# Find the psblas package
find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
@ -30,6 +34,19 @@ else()
message(STATUS "Found PSBLAS: ${psblas_LIBRARIES}")
endif()
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# Add -g to the Fortran compiler flags.
# We use STRING(APPEND) to ensure we don't overwrite other important flags.
string(APPEND CMAKE_Fortran_FLAGS " -g")
string(APPEND CMAKE_CXX_FLAGS " -g")
message(STATUS "Fortran and CXX debug flags added: -g")
endif()
string(APPEND CMAKE_Fortran_FLAGS " -O2")
string(APPEND CMAKE_CXX_FLAGS " -O2")
message(STATUS "Fortran and CXX optimization flags added: -O2")
# Set the include and library directories based on the provided path
#set(TEST_INSTALLDIR "${PSBLAS_INSTALL_DIR}")
@ -39,7 +56,7 @@ set(LIBDIR "${PSBLAS_INSTALL_DIR}/${PSB_CMAKE_INSTALL_LIBDIR}")
# Include directories for the project
include_directories(${PSBLAS_INSTALL_DIR})
include_directories(${PSBLAS_INSTALL_DIR} ${MPI_INCLUDE_PATH} )
# Include directories for the Fortran compiler
@ -142,7 +159,7 @@ write_basic_package_version_file(
COMPATIBILITY SameMajorVersion
)
configure_file("${CMAKE_SOURCE_DIR}/cmake/pkg/${CMAKE_PROJECT_NAME}Config.cmake.in"
configure_file("${CMAKE_SOURCE_DIR}/cmake/${CMAKE_PROJECT_NAME}Config.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${CMAKE_PROJECT_NAME}Config.cmake" @ONLY)
install(
@ -177,6 +194,80 @@ add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure)
#----------------------------------
# Determine if we're using Open MPI
#---------------------------------
find_package( MPI REQUIRED Fortran C CXX )
if(MPI_FOUND)
#-----------------------------------------------
# Work around an issue present on fedora systems
#-----------------------------------------------
if( (MPI_CXX_LINK_FLAGS MATCHES "noexecstack") OR (MPI_Fortran_LINK_FLAGS MATCHES "noexecstack") )
message ( WARNING
"The `noexecstack` linker flag was found in the MPI_<lang>_LINK_FLAGS variable. This is
known to cause segmentation faults for some Fortran codes. See, e.g.,
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71729 or
https://github.com/sourceryinstitute/OpenCoarrays/issues/317.
`noexecstack` is being replaced with `execstack`"
)
string(REPLACE "noexecstack"
"execstack" MPI_CXX_LINK_FLAGS_FIXED ${MPI_CXX_LINK_FLAGS})
string(REPLACE "noexecstack"
"execstack" MPI_C_LINK_FLAGS_FIXED ${MPI_C_LINK_FLAGS})
string(REPLACE "noexecstack"
"execstack" MPI_Fortran_LINK_FLAGS_FIXED ${MPI_Fortran_LINK_FLAGS})
set(MPI_CXX_LINK_FLAGS "${MPI_CXX_LINK_FLAGS_FIXED}" CACHE STRING
"MPI CXX linking flags" FORCE)
set(MPI_C_LINK_FLAGS "${MPI_C_LINK_FLAGS_FIXED}" CACHE STRING
"MPI C linking flags" FORCE)
set(MPI_Fortran_LINK_FLAGS "${MPI_Fortran_LINK_FLAGS_FIXED}" CACHE STRING
"MPI Fortran linking flags" FORCE)
endif()
message(STATUS "Found MPI: ${MPI_C_LIBRARIES} - ${MPI_CXX_LIBRARIES} - ${MPI_Fortran_LIBRARIES}")
#----------------
# Setup MPI compilers
#----------------
set(CMAKE_C_COMPILER ${MPI_C_COMPILER} CACHE FILEPATH "C compiler" FORCE)
set(CMAKE_CXX_COMPILER ${MPI_CXX_COMPILER} CACHE FILEPATH "C++ compiler" FORCE)
set(CMAKE_Fortran_COMPILER ${MPI_Fortran_COMPILER} CACHE FILEPATH "Fortran compiler" FORCE)
#----------------
# Setup MPI flags
#----------------
list(REMOVE_DUPLICATES MPI_Fortran_INCLUDE_PATH)
set(CMAKE_C_COMPILE_FLAGS ${CMAKE_C_COMPILE_FLAGS} ${MPI_C_COMPILE_FLAGS})
set(CMAKE_C_LINK_FLAGS ${CMAKE_C_LINK_FLAGS} ${MPI_C_LINK_FLAGS})
set(CMAKE_CXX_COMPILE_FLAGS ${CMAKE_CXX_COMPILE_FLAGS} ${MPI_CXX_COMPILE_FLAGS})
set(CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS} ${MPI_CXX_LINK_FLAGS})
set(CMAKE_Fortran_COMPILE_FLAGS ${CMAKE_Fortran_COMPILE_FLAGS} ${MPI_Fortran_COMPILE_FLAGS})
set(CMAKE_Fortran_LINK_FLAGS ${CMAKE_Fortran_LINK_FLAGS} ${MPI_Fortran_LINK_FLAGS})
include_directories(BEFORE ${MPI_C_INCLUDE_PATH} ${MPI_CXX_INCLUDE_PATH} ${MPI_Fortran_INCLUDE_PATH})
message(STATUS "${MPI_C_INCLUDE_PATH}; ${MPI_Fortran_INCLUDE_PATH};; ${CMAKE_Fortran_LINK_FLAGS} ;")
if(MPI_Fortran_HAVE_F90_MODULE OR MPI_Fortran_HAVE_F08_MODULE)
add_compile_options(-DPSB_MPI_MOD)
message(STATUS "-DPSB_MPI_MOD")
#add_compile_options(-DSERIAL_MPI) # Is it right??
#message(STATUS "-DSERIAL_MPI")
endif()
set(PSB_SERIAL_MPI OFF)
else()
message(STATUS "MPI not found, serial ahead")
add_compile_options(-DPSB_SERIAL_MPI)
add_compile_options(-DPSB_MPI_MOD)
set(PSB_SERIAL_MPI ON)
set(CSERIALMPI "#define PSB_SERIAL_MPI")
endif()
add_compile_options(-O3)
add_compile_options($<$<COMPILE_LANGUAGE:Fortran>:-frecursive>)
if(MPI_FOUND)
execute_process(COMMAND ${MPIEXEC} --version
OUTPUT_VARIABLE mpi_version_out)
@ -184,6 +275,34 @@ if(MPI_FOUND)
message( STATUS "OpenMPI detected")
set ( openmpi true )
endif()
set(MPI_H_COPIED FALSE)
set(MPI_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include") # Define the include directory
# Create the include directory if it doesn't exist
file(MAKE_DIRECTORY "${MPI_INCLUDE_DIR}")
foreach(path IN LISTS MPI_INCLUDE_PATH)
# Construct the full path to the mpi.h file
set(mpi_h_path "${path}/mpi.h")
# Check if the mpi.h file exists
if(EXISTS "${mpi_h_path}")
# Copy the mpi.h file to the include directory
file(COPY "${mpi_h_path}" DESTINATION "${MPI_INCLUDE_DIR}")
message(STATUS "Copied mpi.h from ${mpi_h_path} to ${MPI_INCLUDE_DIR}")
set(MPI_H_COPIED TRUE)
break() # Exit the loop once we've copied the file
endif()
endforeach()
if(NOT MPI_H_COPIED)
message(WARNING "mpi.h not found in any of the specified paths: ${MPI_INCLUDE_PATH}")
endif()
# Add the created include directory to the project's include directories
#include_directories("${MPI_INCLUDE_DIR}")
endif()
@ -205,8 +324,11 @@ configure_file(
# Add the AMG libraries
#---------------------------------------
# In your CMakeLists.txt
set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -ffree-line-length-256")
message(STATUS "MPI_LIBRARIES: ${MPI_LIBRARIES}")
message(STATUS "MPI_CXX_LIBRARIES: ${MPI_CXX_LIBRARIES}")
@ -215,19 +337,29 @@ include(${CMAKE_CURRENT_LIST_DIR}/amgprec/CMakeLists.txt) # include amgprec_sou
include_directories("${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}")
add_library(amgprec_C OBJECT ${amgprec_source_C_files})
add_library(amgprec_CPP OBJECT ${amgprec_source_CPP_files})
target_link_libraries(amgprec_C
#PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
#PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base) #TODO check actual libraries needed
psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base
#${MPI_C_LIBRARIES}
) #TODO check actual libraries needed
target_link_libraries(amgprec_CPP
#PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
#PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base
stdc++
${MPI_CXX_LIBRARIES}) #TODO check actual libraries needed
add_library(amgprec ${amgprec_source_files} $<TARGET_OBJECTS:amgprec_C>)
add_library(amgprec ${amgprec_source_files} $<TARGET_OBJECTS:amgprec_CPP> $<TARGET_OBJECTS:amgprec_C> )
set_target_properties(amgprec
PROPERTIES
Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules"
POSITION_INDEPENDENT_CODE TRUE
OUTPUT_NAME psb_amgprec
OUTPUT_NAME amg_prec
LINKER_LANGUAGE Fortran
)
@ -243,7 +375,9 @@ target_include_directories(amgprec PUBLIC ${INCDIR} ${MODDIR})
target_link_libraries(amgprec
#PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
#PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base) #TODO check actual libraries needed
psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base
#${MPI_Fortran_LIBRARIES} ${MPI_CXX_LIBRARIES} ${MPI_C_LIBRARIES}
) #TODO check actual libraries needed
@ -260,20 +394,20 @@ foreach(path IN LISTS amgcbind_header_C_files)
endforeach()
add_library(amgcbind_C OBJECT ${amgprec_source_C_files})
add_library(amgcbind_C OBJECT ${amgcbind_source_C_files})
target_link_libraries(amgcbind_C
#PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
#PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base) #TODO check actual libraries needed
add_library(amgcbind ${amgprec_source_files} $<TARGET_OBJECTS:amgcbind_C>)
add_library(amgcbind ${amgcbind_source_files} $<TARGET_OBJECTS:amgcbind_C>)
set_target_properties(amgcbind
PROPERTIES
Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules"
POSITION_INDEPENDENT_CODE TRUE
OUTPUT_NAME psb_amgcbind
OUTPUT_NAME amg_cbind
LINKER_LANGUAGE Fortran
)
@ -354,25 +488,50 @@ message(STATUS "install directory is ${CMAKE_INSTALL_LIBDIR};;;")
# FILE "${CMAKE_CURRENT_BINARY_DIR}/amg4psblasTargets.cmake"
# NAMESPACE psblas::
#)
export(
EXPORT ${CMAKE_PROJECT_NAME}-targets
FILE "${CMAKE_CURRENT_BINARY_DIR}/psblasTargets.cmake"
NAMESPACE ${CMAKE_PROJECT_NAME}::
)
export(
EXPORT ${CMAKE_PROJECT_NAME}-targets
FILE "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}Targets.cmake"
NAMESPACE ${CMAKE_PROJECT_NAME}::
)
#export(
# EXPORT ${CMAKE_PROJECT_NAME}-targets
# FILE "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}Targets.cmake"
# NAMESPACE ${CMAKE_PROJECT_NAME}::
#)
# Optionally, you can install the headers
#install(DIRECTORY include/
# DESTINATION include
#)
# Set the installation directory for the test files
set(INSTALL_TEST_DIR "${CMAKE_INSTALL_PREFIX}/samples" CACHE PATH "Installation directory for sample files")
function(install_directory_recursive source_dir install_base_dir) # Function to install a directory and its subdirectories recursively
file(GLOB_RECURSE ALL_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/${source_dir}" "${source_dir}/*")
foreach(FILE_PATH IN LISTS ALL_FILES)
# Construct the full source and destination paths
set(FULL_SOURCE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${source_dir}/${FILE_PATH}")
set(FULL_INSTALL_PATH "${install_base_dir}/${FILE_PATH}")
# Check if it's a directory
if(IS_DIRECTORY "${FULL_SOURCE_PATH}")
# Create the directory in the install destination
file(MAKE_DIRECTORY "${FULL_INSTALL_PATH}")
else()
# Install the file
install(FILES "${FULL_SOURCE_PATH}" DESTINATION "${install_base_dir}" RENAME "${FILE_PATH}")
endif()
endforeach()
endfunction()
# Install test/fileread directory
install_directory_recursive(samples/simple "${INSTALL_TEST_DIR}/simple")
# Install test/pdegen directory
install_directory_recursive(samples/advanced "${INSTALL_TEST_DIR}/advanced")

@ -875,6 +875,33 @@ list(APPEND AMG_amgprec_source_C_files impl/amg_dslud_interface.c)
list(APPEND AMG_amgprec_source_C_files impl/amg_zumf_interface.c)
list(APPEND AMG_amgprec_source_C_files impl/amg_zslud_interface.c)
set(AMG_amgprec_source_CPP_files
impl/aggregator/computeCandidateMate.cpp
impl/aggregator/processExposedVertex.cpp
impl/aggregator/processMatchedVertices.cpp
impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.cpp
impl/aggregator/processCrossEdge.cpp
impl/aggregator/findOwnerOfGhost.cpp
impl/aggregator/MatchBoxPC.cpp
impl/aggregator/queueTransfer.cpp
impl/aggregator/clean.cpp
impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC.cpp
impl/aggregator/extractUChunk.cpp
impl/aggregator/processMatchedVerticesAndSendMessages.cpp
impl/aggregator/sendBundledMessages.cpp
impl/aggregator/initialize.cpp
impl/aggregator/isAlreadyMatched.cpp
impl/aggregator/processMessages.cpp
impl/aggregator/parallelComputeCandidateMateB.cpp
)
foreach(file IN LISTS AMG_amgprec_source_C_files)
list(APPEND amgprec_source_C_files ${CMAKE_CURRENT_LIST_DIR}/${file})
endforeach()
foreach(file IN LISTS AMG_amgprec_source_CPP_files)
list(APPEND amgprec_source_CPP_files ${CMAKE_CURRENT_LIST_DIR}/${file})
endforeach()

@ -0,0 +1,117 @@
cmake_minimum_required(VERSION 3.15)
project(AMGExamples Fortran)
# Installation directories (passed as CMake variables)
set(AMG4PSBLAS_INSTALL_DIR "" CACHE PATH "Path to AMG installation")
set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to PSBLAS installation")
# Check if installation directories are set
if(NOT AMG4PSBLAS_INSTALL_DIR)
message(FATAL_ERROR "AMG_INSTALL_DIR must be set. Use -DAMG_INSTALL_DIR=/path/to/amg when running CMake.")
endif()
if(NOT PSBLAS_INSTALL_DIR)
message(FATAL_ERROR "PSBLAS_INSTALL_DIR must be set. Use -DPSBLAS_INSTALL_DIR=/path/to/psblas when running CMake.")
endif()
find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
find_package(amg4psblas REQUIRED PATHS ${AMG4PSBLAS_INSTALL_DIR})
# Include directories
include_directories(
"."
"${AMG4PSBLAS_INSTALL_DIR}/include"
"${AMG4PSBLAS_INSTALL_DIR}/modules"
"${PSBLAS_INSTALL_DIR}/include"
)
# Fortran module directory
set(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/modules")
set(FMFLAG "-I")
# Library directories
link_directories(
"${AMG4PSBLAS_INSTALL_DIR}/lib"
"${PSBLAS_INSTALL_DIR}/lib"
)
# Libraries
set(AMG_LIBS amg4psblas::amgprec)
set(PSBLAS_LIBS psblas::util psblas::linsolve psblas::prec psblas::base)
# Executable directory
set(EXEDIR "${CMAKE_CURRENT_BINARY_DIR}/runs")
file(MAKE_DIRECTORY "${EXEDIR}")
set(COMMON_SOURCE data_input.f90)
# Source files
set(DFSOBJS ${COMMON_SOURCE} amg_df_sample.f90)
set(SFSOBJS ${COMMON_SOURCE} amg_sf_sample.f90)
set(CFSOBJS ${COMMON_SOURCE} amg_cf_sample.f90)
set(ZFSOBJS ${COMMON_SOURCE} amg_zf_sample.f90)
# Function to create executable
macro(create_amg_executable target sources)
add_executable(${target} ${sources})
target_link_libraries(${target} PUBLIC
${AMG_LIBS}
${PSBLAS_LIBS}
)
# Move executable to EXEDIR (post-build)
#add_custom_command(TARGET ${target} POST_BUILD
# COMMAND ${CMAKE_COMMAND} -E move $<TARGET_FILE:${target}> ${EXEDIR}
#)
set_target_properties(${target} PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${EXEDIR}
)
endmacro()
# Create executables
create_amg_executable(amg_df_sample "${DFSOBJS}")
create_amg_executable(amg_sf_sample "${SFSOBJS}")
create_amg_executable(amg_cf_sample "${CFSOBJS}")
create_amg_executable(amg_zf_sample "${ZFSOBJS}")
# Create "runs" directory (if it doesn't exist)
add_custom_target(create_runs_dir
COMMAND ${CMAKE_COMMAND} -E make_directory "${EXEDIR}"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Creating runs directory"
)
add_dependencies(amg_df_sample create_runs_dir)
add_dependencies(amg_sf_sample create_runs_dir)
add_dependencies(amg_cf_sample create_runs_dir)
add_dependencies(amg_zf_sample create_runs_dir)
# lib target
add_custom_target(lib
COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target library
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Building library"
)
# verycleanlib target
add_custom_target(verycleanlib
COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target veryclean
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Cleaning library"
)
# Install target (optional)
install(TARGETS
amg_sf_sample
amg_df_sample
amg_cf_sample
amg_zf_sample
DESTINATION bin
)

@ -0,0 +1,229 @@
cmake_minimum_required(VERSION 3.15)
project(AMGExamples Fortran CXX)
# Installation directories (passed as CMake variables)
set(AMG4PSBLAS_INSTALL_DIR "" CACHE PATH "Path to AMG installation")
set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to PSBLAS installation")
# Check if installation directories are set
if(NOT AMG4PSBLAS_INSTALL_DIR)
message(FATAL_ERROR "AMG_INSTALL_DIR must be set. Use -DAMG_INSTALL_DIR=/path/to/amg when running CMake.")
endif()
if(NOT PSBLAS_INSTALL_DIR)
message(FATAL_ERROR "PSBLAS_INSTALL_DIR must be set. Use -DPSBLAS_INSTALL_DIR=/path/to/psblas when running CMake.")
endif()
find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
find_package(amg4psblas REQUIRED PATHS ${AMG4PSBLAS_INSTALL_DIR})
find_package(MPI REQUIRED Fortran CXX )
if(MPI_FOUND)
if( (MPI_CXX_LINK_FLAGS MATCHES "noexecstack") OR (MPI_Fortran_LINK_FLAGS MATCHES "noexecstack") )
message ( WARNING
"The `noexecstack` linker flag was found in the MPI_<lang>_LINK_FLAGS variable. This is
known to cause segmentation faults for some Fortran codes. See, e.g.,
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71729 or
https://github.com/sourceryinstitute/OpenCoarrays/issues/317.
`noexecstack` is being replaced with `execstack`"
)
string(REPLACE "noexecstack"
"execstack" MPI_CXX_LINK_FLAGS_FIXED ${MPI_CXX_LINK_FLAGS})
string(REPLACE "noexecstack"
"execstack" MPI_C_LINK_FLAGS_FIXED ${MPI_C_LINK_FLAGS})
string(REPLACE "noexecstack"
"execstack" MPI_Fortran_LINK_FLAGS_FIXED ${MPI_Fortran_LINK_FLAGS})
set(MPI_CXX_LINK_FLAGS "${MPI_CXX_LINK_FLAGS_FIXED}" CACHE STRING
"MPI CXX linking flags" FORCE)
set(MPI_C_LINK_FLAGS "${MPI_C_LINK_FLAGS_FIXED}" CACHE STRING
"MPI C linking flags" FORCE)
set(MPI_Fortran_LINK_FLAGS "${MPI_Fortran_LINK_FLAGS_FIXED}" CACHE STRING
"MPI Fortran linking flags" FORCE)
endif()
message(STATUS "Found MPI: ${MPI_C_LIBRARIES} - ${MPI_CXX_LIBRARIES} - ${MPI_Fortran_LIBRARIES}")
#----------------
# Setup MPI compiler
#----------------
set(CMAKE_C_COMPILER ${MPI_C_COMPILER} CACHE FILEPATH "C compiler" FORCE)
set(CMAKE_CXX_COMPILER ${MPI_CXX_COMPILER} CACHE FILEPATH "C++ compiler" FORCE)
set(CMAKE_Fortran_COMPILER ${MPI_Fortran_COMPILER} CACHE FILEPATH "Fortran compiler" FORCE)
endif()
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# Add -g to the Fortran compiler flags.
# We use STRING(APPEND) to ensure we don't overwrite other important flags.
string(APPEND CMAKE_Fortran_FLAGS " -g")
message(STATUS "Fortran debug flags added: -g")
endif()
# Include directories
include_directories(
"."
"${AMG4PSBLAS_INSTALL_DIR}/include"
"${AMG4PSBLAS_INSTALL_DIR}/modules"
"${PSBLAS_INSTALL_DIR}/include"
"${PSBLAS_INSTALL_DIR}/modules"
)
# Fortran module directory
set(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/modules")
set(FMFLAG "-I")
# Library directories
link_directories(
"${AMG4PSBLAS_INSTALL_DIR}/lib"
"${PSBLAS_INSTALL_DIR}/lib"
)
# Libraries
set(AMG_LIBS amg4psblas::amgprec)
set(PSBLAS_LIBS psblas::util psblas::linsolve psblas::prec psblas::base)
# Executable directory
set(EXEDIR "${CMAKE_CURRENT_BINARY_DIR}/runs")
file(MAKE_DIRECTORY "${EXEDIR}")
set(COMMON_SOURCE data_input.f90)
# Source files
set(DFSOBJS ${COMMON_SOURCE} amg_df_sample.f90)
set(SFSOBJS ${COMMON_SOURCE} amg_sf_sample.f90)
set(CFSOBJS ${COMMON_SOURCE} amg_cf_sample.f90)
set(ZFSOBJS ${COMMON_SOURCE} amg_zf_sample.f90)
# Source files
set(DGEN2D
amg_d_pde2d_poisson_mod.f90
amg_d_pde2d_exp_mod.f90
amg_d_pde2d_gauss_mod.f90
amg_d_pde2d_box_mod.f90
)
set(DGEN3D
amg_d_pde3d_poisson_mod.f90
amg_d_pde3d_exp_mod.f90
amg_d_pde3d_gauss_mod.f90
amg_d_pde3d_box_mod.f90
)
set(SGEN2D
amg_s_pde2d_poisson_mod.f90
amg_s_pde2d_exp_mod.f90
amg_s_pde2d_gauss_mod.f90
amg_s_pde2d_box_mod.f90
)
set(SGEN3D
amg_s_pde3d_poisson_mod.f90
amg_s_pde3d_exp_mod.f90
amg_s_pde3d_gauss_mod.f90
amg_s_pde3d_box_mod.f90
)
# Define executables and their sources
set(amg_d_pde3d_SOURCES
${COMMON_SOURCE}
amg_d_pde3d.F90
amg_d_genpde_mod.F90
${DGEN3D}
)
set(amg_s_pde3d_SOURCES
${COMMON_SOURCE}
amg_s_pde3d.F90
amg_s_genpde_mod.F90
${SGEN3D}
)
set(amg_d_pde2d_SOURCES
${COMMON_SOURCE}
amg_d_pde2d.F90
amg_d_genpde_mod.F90
${DGEN2D}
)
set(amg_s_pde2d_SOURCES
${COMMON_SOURCE}
amg_s_pde2d.F90
amg_s_genpde_mod.F90
${SGEN2D}
)
# Function to create executable
function(create_amg_executable target sources)
add_executable(${target} ${sources})
target_link_libraries(${target} PUBLIC
${AMG_LIBS}
${PSBLAS_LIBS}
${MPI_LIBRARIES}
)
# Move executable to EXEDIR (post-build)
#add_custom_command(TARGET ${target} POST_BUILD
# COMMAND ${CMAKE_COMMAND} -E move $<TARGET_FILE:${target}> ${EXEDIR}
#)
set_target_properties(${target} PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${EXEDIR}
LINKER_LANGUAGE Fortran
)
endfunction()
# Create executables
create_amg_executable(amg_d_pde3d "${amg_d_pde3d_SOURCES}")
create_amg_executable(amg_s_pde3d "${amg_s_pde3d_SOURCES}")
create_amg_executable(amg_d_pde2d "${amg_d_pde2d_SOURCES}")
create_amg_executable(amg_s_pde2d "${amg_s_pde2d_SOURCES}")
# Create "runs" directory (if it doesn't exist)
add_custom_target(create_runs_dir
COMMAND ${CMAKE_COMMAND} -E make_directory "${EXEDIR}"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Creating runs directory"
)
add_dependencies(amg_d_pde3d create_runs_dir)
add_dependencies(amg_s_pde3d create_runs_dir)
add_dependencies(amg_d_pde2d create_runs_dir)
add_dependencies(amg_s_pde2d create_runs_dir)
# lib target
add_custom_target(lib
COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target library
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Building library"
)
# verycleanlib target
add_custom_target(verycleanlib
COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target veryclean
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Cleaning library"
)
# Check target (simulated)
add_custom_target(check
COMMAND ${CMAKE_COMMAND} -E chdir "${EXEDIR}" "${EXEDIR}/amg_d_pde2d" < "amg_pde2d.inp"
COMMAND ${CMAKE_COMMAND} -E chdir "${EXEDIR}" "${EXEDIR}/amg_s_pde2d" < "amg_pde2d.inp"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS amg_d_pde2d amg_s_pde2d
COMMENT "Running check"
)
# Install target (optional)
install(TARGETS
amg_d_pde3d
amg_s_pde3d
amg_d_pde2d
amg_s_pde2d
DESTINATION bin
)

@ -0,0 +1,129 @@
cmake_minimum_required(VERSION 3.15)
project(AMGExamples Fortran)
# Installation directories (passed as CMake variables)
set(AMG4PSBLAS_INSTALL_DIR "" CACHE PATH "Path to AMG installation")
set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to PSBLAS installation")
# Check if installation directories are set
if(NOT AMG4PSBLAS_INSTALL_DIR)
message(FATAL_ERROR "AMG_INSTALL_DIR must be set. Use -DAMG_INSTALL_DIR=/path/to/amg when running CMake.")
endif()
if(NOT PSBLAS_INSTALL_DIR)
message(FATAL_ERROR "PSBLAS_INSTALL_DIR must be set. Use -DPSBLAS_INSTALL_DIR=/path/to/psblas when running CMake.")
endif()
find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
find_package(amg4psblas REQUIRED PATHS ${AMG4PSBLAS_INSTALL_DIR})
# Include directories
include_directories(
"."
"${AMG4PSBLAS_INSTALL_DIR}/include"
"${AMG4PSBLAS_INSTALL_DIR}/modules"
"${PSBLAS_INSTALL_DIR}/include"
)
# Fortran module directory
set(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/modules")
set(FMFLAG "-I")
# Library directories
link_directories(
"${AMG4PSBLAS_INSTALL_DIR}/lib"
"${PSBLAS_INSTALL_DIR}/lib"
)
# Libraries
set(AMG_LIBS amg4psblas::amgprec)
set(PSBLAS_LIBS psblas::util psblas::linsolve psblas::prec psblas::base)
# Executable directory
set(EXEDIR "${CMAKE_CURRENT_BINARY_DIR}/runs")
file(MAKE_DIRECTORY "${EXEDIR}")
set(COMMON_SOURCE data_input.f90)
# Source files
set(DMOBJS ${COMMON_SOURCE} amg_dexample_ml.f90)
set(D1OBJS ${COMMON_SOURCE} amg_dexample_1lev.f90)
set(ZMOBJS ${COMMON_SOURCE} amg_zexample_ml.f90)
set(Z1OBJS ${COMMON_SOURCE} amg_zexample_1lev.f90)
set(SMOBJS ${COMMON_SOURCE} amg_sexample_ml.f90)
set(S1OBJS ${COMMON_SOURCE} amg_sexample_1lev.f90)
set(CMOBJS ${COMMON_SOURCE} amg_cexample_ml.f90)
set(C1OBJS ${COMMON_SOURCE} amg_cexample_1lev.f90)
# Function to create executable
macro(create_amg_executable target sources)
add_executable(${target} ${sources})
target_link_libraries(${target} PUBLIC
${AMG_LIBS}
${PSBLAS_LIBS}
)
# Move executable to EXEDIR (post-build)
#add_custom_command(TARGET ${target} POST_BUILD
# COMMAND ${CMAKE_COMMAND} -E move $<TARGET_FILE:${target}> ${EXEDIR}
#)
set_target_properties(${target} PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${EXEDIR}
)
endmacro()
# Create executables
create_amg_executable(amg_dexample_ml "${DMOBJS}")
create_amg_executable(amg_dexample_1lev "${D1OBJS}")
create_amg_executable(amg_zexample_ml "${ZMOBJS}")
create_amg_executable(amg_zexample_1lev "${Z1OBJS}")
create_amg_executable(amg_sexample_ml "${SMOBJS}")
create_amg_executable(amg_sexample_1lev "${S1OBJS}")
create_amg_executable(amg_cexample_ml "${CMOBJS}")
create_amg_executable(amg_cexample_1lev "${C1OBJS}")
# Create "runs" directory (if it doesn't exist)
add_custom_target(create_runs_dir
COMMAND ${CMAKE_COMMAND} -E make_directory "${EXEDIR}"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Creating runs directory"
)
add_dependencies(amg_dexample_ml create_runs_dir)
add_dependencies(amg_dexample_1lev create_runs_dir)
add_dependencies(amg_zexample_ml create_runs_dir)
add_dependencies(amg_zexample_1lev create_runs_dir)
add_dependencies(amg_sexample_ml create_runs_dir)
add_dependencies(amg_sexample_1lev create_runs_dir)
add_dependencies(amg_cexample_ml create_runs_dir)
add_dependencies(amg_cexample_1lev create_runs_dir)
# lib target
add_custom_target(lib
COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target library
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Building library"
)
# verycleanlib target
add_custom_target(verycleanlib
COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target veryclean
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Cleaning library"
)
# Install target (optional)
install(TARGETS
amg_dexample_ml
amg_dexample_1lev
amg_zexample_ml
amg_zexample_1lev
amg_sexample_ml
amg_sexample_1lev
amg_cexample_ml
amg_cexample_1lev
DESTINATION bin
)

@ -0,0 +1,114 @@
cmake_minimum_required(VERSION 3.15)
project(AMGExamples Fortran)
# Installation directories (passed as CMake variables)
set(AMG4PSBLAS_INSTALL_DIR "" CACHE PATH "Path to AMG installation")
set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to PSBLAS installation")
# Check if installation directories are set
if(NOT AMG4PSBLAS_INSTALL_DIR)
message(FATAL_ERROR "AMG_INSTALL_DIR must be set. Use -DAMG_INSTALL_DIR=/path/to/amg when running CMake.")
endif()
if(NOT PSBLAS_INSTALL_DIR)
message(FATAL_ERROR "PSBLAS_INSTALL_DIR must be set. Use -DPSBLAS_INSTALL_DIR=/path/to/psblas when running CMake.")
endif()
find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
find_package(amg4psblas REQUIRED PATHS ${AMG4PSBLAS_INSTALL_DIR})
# Include directories
include_directories(
"."
"${AMG4PSBLAS_INSTALL_DIR}/include"
"${AMG4PSBLAS_INSTALL_DIR}/modules"
"${PSBLAS_INSTALL_DIR}/include"
)
# Fortran module directory
set(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/modules")
set(FMFLAG "-I")
# Library directories
link_directories(
"${AMG4PSBLAS_INSTALL_DIR}/lib"
"${PSBLAS_INSTALL_DIR}/lib"
)
# Libraries
set(AMG_LIBS amg4psblas::amgprec)
set(PSBLAS_LIBS psblas::util psblas::linsolve psblas::prec psblas::base)
# Executable directory
set(EXEDIR "${CMAKE_CURRENT_BINARY_DIR}/runs")
file(MAKE_DIRECTORY "${EXEDIR}")
set(COMMON_SOURCE data_input.f90)
# Source files
set(DMOBJS ${COMMON_SOURCE} amg_dexample_ml.f90 amg_dpde_mod.f90)
set(D1OBJS ${COMMON_SOURCE} amg_dexample_1lev.f90 amg_dpde_mod.f90)
set(SMOBJS ${COMMON_SOURCE} amg_sexample_ml.f90 amg_spde_mod.f90)
set(S1OBJS ${COMMON_SOURCE} amg_sexample_1lev.f90 amg_spde_mod.f90)
# Function to create executable
macro(create_amg_executable target sources)
add_executable(${target} ${sources})
target_link_libraries(${target} PUBLIC
${AMG_LIBS}
${PSBLAS_LIBS}
)
# Move executable to EXEDIR (post-build)
#add_custom_command(TARGET ${target} POST_BUILD
# COMMAND ${CMAKE_COMMAND} -E move $<TARGET_FILE:${target}> ${EXEDIR}
#)
set_target_properties(${target} PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${EXEDIR}
)
endmacro()
# Create executables
create_amg_executable(amg_dexample_ml "${DMOBJS}")
create_amg_executable(amg_dexample_1lev "${D1OBJS}")
create_amg_executable(amg_sexample_ml "${SMOBJS}")
create_amg_executable(amg_sexample_1lev "${S1OBJS}")
# Create "runs" directory (if it doesn't exist)
add_custom_target(create_runs_dir
COMMAND ${CMAKE_COMMAND} -E make_directory "${EXEDIR}"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Creating runs directory"
)
add_dependencies(amg_dexample_ml create_runs_dir)
add_dependencies(amg_dexample_1lev create_runs_dir)
add_dependencies(amg_sexample_ml create_runs_dir)
add_dependencies(amg_sexample_1lev create_runs_dir)
# lib target
add_custom_target(lib
COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target library
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Building library"
)
# verycleanlib target
add_custom_target(verycleanlib
COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target veryclean
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Cleaning library"
)
# Install target (optional)
install(TARGETS
amg_dexample_ml
amg_dexample_1lev
amg_sexample_ml
amg_sexample_1lev
DESTINATION bin
)
Loading…
Cancel
Save