diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 00000000..b6257a88 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,762 @@ +# FDEFINES : -DHAVE_LAPACK -DHAVE_FINAL -DHAVE_ISO_FORTRAN_ENV -DHAVE_FLUSH_STMT -DHAVE_VOLATILE -DSERIAL_MPI -DMPI_MOD +# CDEFINES : -DLowerUnderscore -DPtr64Bits + +#----------------------------------- +# Set oldest allowable CMake version +#----------------------------------- +cmake_minimum_required(VERSION 3.10) +cmake_policy(VERSION 3.11.1...3.13.3) + +set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake") + +#---------------------------------------------- +# Define canonical CMake build types and extras +#---------------------------------------------- +set ( CMAKE_CONFIGURATION_TYPES "Debug" "Release" "MinSizeRel" "RelWithDebInfo" "CodeCoverage" ) +set ( CMAKE_BUILD_TYPE "Release" + CACHE STRING "Select which configuration to build." ) +set_property ( CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES} ) + +#----------------------------------------------------- +# Determine version from .VERSION file or git describe +#----------------------------------------------------- +include(setVersion) +set_version( + VERSION_VARIABLE PSBLAS_Version + GIT_DESCRIBE_VAR full_git_describe + CUSTOM_VERSION_FILE "${CMAKE_SOURCE_DIR}/.VERSION") +message( STATUS "Building PSBLAS1 version: ${full_git_describe}" ) + +#------------------------------------------ +# Name project and specify source languages +#------------------------------------------ +project(psblas + VERSION "${PSBLAS_Version}" + LANGUAGES C Fortran) + +#-------------------------------------------------- +# Set option to allow building against OpenCoarrays +#-------------------------------------------------- +if(CMAKE_Fortran_COMPILER_ID MATCHES "GNU") + option(PSBLAS_USE_OpenCoarrays "Build enabling linkage to programs using OpenCoarrays" OFF) +endif() + +#----------------------------------------------------------------- +# Define a target to create a checksummed & signed release archive +#----------------------------------------------------------------- +set(${CMAKE_PROJECT_NAME}_dist_string "${CMAKE_PROJECT_NAME}-${full_git_describe}") +if(GIT_FOUND) + add_custom_target(dist # OUTPUT "${CMAKE_BINARY_DIR}/${_package_stem_name}.tar.gz" + COMMAND "${CMAKE_COMMAND}" -P "${CMAKE_SOURCE_DIR}/cmake/makeDist.cmake" "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" + COMMENT "Creating source release asset, ${_package_stem_name}.tar.gz, from ${_full_git_describe} using the `git archive` command." + VERBATIM) +endif() + +#-------------------------- +# Prohibit in-source builds +#-------------------------- +include(CheckOutOfSourceBuild) + +#---------------------------------------------------- +# Define coverage flags and report untested compilers +#---------------------------------------------------- +if ("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU" ) + set(gfortran_compiler true) + #TODO: check if it is needed an mpi compiler set(CMAKE_Fortran_COMPILER mpifort) + + set ( CMAKE_C_FLAGS_CODECOVERAGE "-fprofile-arcs -ftest-coverage -O0" + CACHE STRING "Code coverage C compiler flags") + set ( CMAKE_Fortran_FLAGS_CODECOVERAGE "-fprofile-arcs -ftest-coverage -O0" + CACHE STRING "Code coverage Fortran compiler flags") +else() + message(WARNING + "\n" + "Attempting untested CMake build with Fortran compiler: ${CMAKE_Fortran_COMPILER_ID}. " + "Please report any failures at https://github.com/sfilippone/psblas3\n\n" + ) +endif() + + + message(STATUS "cmake flags? ${CMAKE_Fortran_FLAGS};") + +#------------------------------------ +# Fortran name mangling introspection +#------------------------------------ +include("${CMAKE_CURRENT_LIST_DIR}/cmake/CapitalizeString.cmake") +include(FortranCInterface) +CapitalizeString(${FortranCInterface_GLOBAL__CASE} fc_case) +message(STATUS "Name mangling capitalization: ${fc_case}") +message(STATUS "Name mangling fortran global suffix underscore: ${FortranCInterface_GLOBAL__SUFFIX}") +if(FortranCInterface_GLOBAL__SUFFIX STREQUAL "") + add_compile_options("-D${fc_case}Case") +elseif(FortranCInterface_GLOBAL__SUFFIX STREQUAL "_") + add_compile_options("-D${fc_case}Underscore") +elseif(FortranCInterface_GLOBAL__SUFFIX STREQUAL "__") + add_compile_options("-D${fc_case}DoubleUnderscore") +else() + message( FATAL_ERROR "Fortran name mangling suffix, \'${FortranCInterface_GLOBAL__SUFFIX}\', unknown to PSBLAS") +endif() + + + message(STATUS "win? ${WIN32};") +if(TRUE )#NOT ${WIN32}) +#previous check did not work if WIN32 is empty string + #---------------------------------------------- + # Determine system endian-ness and pointer size + #---------------------------------------------- + include(TestBigEndian) + TEST_BIG_ENDIAN(IS_BIG_ENDIAN) + if(IS_BIG_ENDIAN) + message( STATUS "System appears to be big endian.") + else() + message( STATUS "System appears to be little endian.") + add_compile_options(-DLittleEndian) + endif() + include(CheckTypeSize) + CHECK_TYPE_SIZE("void *" VOID_P_SIZE LANGUAGE C) + if(${VOID_P_SIZE} EQUAL 8) + add_compile_options(-DPtr64Bits) + endif() + message(STATUS "Have 64bit pointers") + + #add define values for integer size (IPKx) and long size (LPKx) + CHECK_TYPE_SIZE("int" INT_SIZE LANGUAGE C) + CHECK_TYPE_SIZE("long" LONG_SIZE LANGUAGE C) + message(STATUS "INT SIZE ${INT_SIZE}") + + add_compile_options(-DIPK${INT_SIZE}) + add_compile_options(-DLPK${LONG_SIZE}) + + +endif() + + + + +#----------------------------------------- +# Check for some Fortran compiler features +#----------------------------------------- +include(CheckFortranSourceCompiles) +CHECK_Fortran_SOURCE_COMPILES( + " +integer, allocatable :: a(:), b(:) +allocate(a(5)) +a = [1,2,3,4,5] +call move_alloc(from=a, to=b) +end +" + HAVE_MOVE_ALLOC + SRC_EXT f90 + ) +if(HAVE_MOVE_ALLOC) + add_compile_options(-DHAVE_MOVE_ALLOC) + message(STATUS "-DHAVE_MOVE_ALLOC") +endif() +CHECK_Fortran_SOURCE_COMPILES( + "integer, volatile :: i ; end" + HAVE_VOLATILE + SRC_EXT f90 + ) +if(HAVE_VOLATILE) + add_compile_options(-DHAVE_VOLATILE) + message(STATUS "-DHAVE_VOLATILE") +endif() +CHECK_Fortran_SOURCE_COMPILES( + "use ISO_FORTRAN_ENV ; end" + HAVE_ISO_FORTRAN_ENV + SRC_EXT f90 + ) +if(HAVE_ISO_FORTRAN_ENV) + add_compile_options(-DHAVE_ISO_FORTRAN_ENV) + message(STATUS "-DHAVE_ISO_FORTRAN_ENV") +endif() +CHECK_Fortran_SOURCE_COMPILES( + "flush(5); end" + HAVE_FLUSH_STMT + SRC_EXT f90 + ) +if(HAVE_FLUSH_STMT) + add_compile_options(-DHAVE_FLUSH_STMT) + message(STATUS "-DHAVE_FLUSH_STMT") +endif() +CHECK_Fortran_SOURCE_COMPILES( + " +module conftest_mod + type foo + integer :: i + contains + final :: destroy_foo + end type foo + private destroy_foo +contains + subroutine destroy_foo(a) + type(foo) :: a + ! Just a test + end subroutine destroy_foo +end module conftest_mod +program conftest + use conftest_mod + type(foo) :: foovar +end program" + HAVE_FINAL + SRC_EXT f90 + ) +if(HAVE_FINAL) + add_compile_options(-DHAVE_FINAL) + message(STATUS "-DHAVE_FINAL") +endif() +CHECK_Fortran_SOURCE_COMPILES( + " +program xtt + type foo + integer :: i + end type foo + type, extends(foo) :: new_foo + integer :: j + end type new_foo + class(foo), allocatable :: fooab + type(new_foo) :: nfv + integer :: info + allocate(fooab, mold=nfv, stat=info) +end program" + HAVE_MOLD + SRC_EXT f90) +if(HAVE_MOLD) + add_compile_options(-DHAVE_MOLD) + message(STATUS "-DHAVE_MOLD") +endif() +CHECK_Fortran_SOURCE_COMPILES( + " +program conftest + type foo + integer :: i + end type foo + type, extends(foo) :: bar + integer j + end type bar + type(bar) :: barvar +end program " + HAVE_EXTENDS_TYPE_OF + SRC_EXT f90) +if(HAVE_EXTENDS_TYPE_OF) + add_compile_options(-DHAVE_EXTENDS_TYPE_OF) + message(STATUS "-DHAVE_EXTENDS_TYPE_OF") +endif() +CHECK_Fortran_SOURCE_COMPILES( + " +program stt + type foo + integer :: i + end type foo + type, extends(foo) :: new_foo + integer :: j + end type new_foo + type(foo) :: foov + type(new_foo) :: nfv1, nfv2 + + + write(*,*) 'foov == nfv1? ', same_type_as(foov,nfv1) + write(*,*) 'nfv2 == nfv1? ', same_type_as(nfv2,nfv1) +end program" + HAVE_SAME_TYPE_AS + SRC_EXT f90) +if(HAVE_SAME_TYPE_AS) + add_compile_options(-DHAVE_SAME_TYPE_AS) + message(STATUS "-DHAVE_SAME_TYPE_AS") +endif() + +#---------------------------------------------------------------------------- +# Find MPI and set some flags so that FC and CC can point to gfortran and gcc +#---------------------------------------------------------------------------- +find_package( MPI REQUIRED Fortran ) + +if(MPI_FOUND) + #----------------------------------------------- + # Work around an issue present on fedora systems + #----------------------------------------------- + if( (MPI_C_LINK_FLAGS MATCHES "noexecstack") OR (MPI_Fortran_LINK_FLAGS MATCHES "noexecstack") ) + message ( WARNING + "The `noexecstack` linker flag was found in the MPI__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_C_LINK_FLAGS_FIXED ${MPI_C_LINK_FLAGS}) + string(REPLACE "noexecstack" + "execstack" MPI_Fortran_LINK_FLAGS_FIXED ${MPI_Fortran_LINK_FLAGS}) + 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_Fortran_LIBRARIES}") + + #---------------- + # 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_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_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(-DMPI_MOD) + message(STATUS "-DMPI_MOD") + #add_compile_options(-DSERIAL_MPI) # Is it right?? + #message(STATUS "-DSERIAL_MPI") + endif() + set(SERIAL_MPI OFF) +else() + message(STATUS "MPI not found, serial ahead") + add_compile_options(-DSERIAL_MPI) + add_compile_options(-DMPI_MOD) + set(SERIAL_MPI ON) +endif() + +#------------------------------------------------------- +# Find and Use OpenCoarrays IFF gfortran AND options set +#------------------------------------------------------- + +if("${PSBLAS_USE_OpenCoarrays}" AND CMAKE_Fortran_COMPILER_ID MATCHES GNU) + message(STATUS "Set openCoarrays") + find_package(OpenCoarrays) +endif() + +#------------------------------ +# Find Linear Algebra Libraries +#------------------------------ +if(NOT APPLE) + set(BLA_STATIC ON) +endif() +find_package(BLAS REQUIRED) +find_package(LAPACK REQUIRED) +add_compile_options(-DHAVE_LAPACK) + + +#-------------------------------- +# Find METIS partitioning library +#-------------------------------- +include(${CMAKE_CURRENT_LIST_DIR}/cmake/FindMETIS.cmake) +find_package(METIS) + +#--------------------------------------------------- +# Use standardized GNU install directory conventions +#--------------------------------------------------- +include(GNUInstallDirs) +#set(mod_dir_tail "${${CMAKE_PROJECT_NAME}_dist_string}_${CMAKE_Fortran_COMPILER_ID}-${CMAKE_Fortran_COMPILER_VERSION}") +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/${${CMAKE_PROJECT_NAME}_dist_string}-tests") +set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}") +set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}") + +#----------------------------------- +# Turn on testing/ctest capabilities +#----------------------------------- +enable_testing() + +#------------------------------------------------------------------------------ +# Add custom properties on targets for controling number of ranks during tests +#------------------------------------------------------------------------------ +define_property(TARGET + PROPERTY MIN_RANKS + BRIEF_DOCS "Minimum allowable ranks for the test " + FULL_DOCS "Property to mark executable targets run as tests that they require at least ranks to run" + ) + +define_property(TARGET + PROPERTY POWER_2_RANKS + BRIEF_DOCS "True if test must be run with a power of 2 ranks (T/F)" + FULL_DOCS "Property to mark executable targets run as tests that they require 2^n ranks." + ) + +#----------------------------------------------------- +# Publicize installed location to other CMake projects +#----------------------------------------------------- +install(EXPORT ${CMAKE_PROJECT_NAME}-targets + DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake" +) +include(CMakePackageConfigHelpers) # standard CMake module +write_basic_package_version_file( + "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}ConfigVersion.cmake" + VERSION "${psblas_VERSION}" + COMPATIBILITY SameMajorVersion + ) + +configure_file("${CMAKE_SOURCE_DIR}/cmake/pkg/${CMAKE_PROJECT_NAME}Config.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${CMAKE_PROJECT_NAME}Config.cmake" @ONLY) + +install( + FILES + "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${CMAKE_PROJECT_NAME}Config.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}ConfigVersion.cmake" + DESTINATION + "${CMAKE_INSTALL_LIBDIR}/cmake/psblas" +) + +#------------------------------------------ +# Add portable unistall command to makefile +#------------------------------------------ +# Adapted from the CMake Wiki FAQ +configure_file ( "${CMAKE_SOURCE_DIR}/cmake/uninstall.cmake.in" "${CMAKE_BINARY_DIR}/uninstall.cmake" + @ONLY) + +add_custom_target ( uninstall + COMMAND ${CMAKE_COMMAND} -P "${CMAKE_BINARY_DIR}/uninstall.cmake" ) + +add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure) +# See JSON-Fortran's CMakeLists.txt file to find out how to get the check target to depend +# on the test executables + +#---------------------------------- +# Determine if we're using Open MPI +#--------------------------------- +if(MPI_FOUND) + execute_process(COMMAND ${MPIEXEC} --version + OUTPUT_VARIABLE mpi_version_out) + if (mpi_version_out MATCHES "[Oo]pen[ -][Mm][Pp][Ii]") + message( STATUS "OpenMPI detected") + set ( openmpi true ) + endif() +endif() + +#--------------------------------------- +# Add the PSBLAS libraries and utilities +#--------------------------------------- + +# Link order, left to right: +# cbind.a, util.a krylov.a prec.a base.a + +include(${CMAKE_CURRENT_LIST_DIR}/base/CMakeLists.txt) + +include_directories("${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}") + +if(WIN32) + add_library(psb_base_C STATIC ${base_source_C_files}) + target_compile_definitions(psb_base_C + PRIVATE -DWIN32 -D_LIB -DWIN64) + set_target_properties(psb_base_C + PROPERTIES + LINKER_LANGUAGE C + POSITION_INDEPENDENT_CODE TRUE) + target_link_libraries(psb_base_C + PUBLIC kernel32 user32 shell32) + add_library(base ${base_source_files}) + target_link_libraries(base + PUBLIC psb_base_C) +else() + message(STATUS " ----------------------- ;") + message(STATUS " ----------------------- ${base_source_C_files};") + add_library(base_C OBJECT ${base_source_C_files}) + add_library(base ${base_source_files} $) +endif() + + +# Set the Fortran module output directory for all targets +set(CMAKE_Fortran_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/modules) +#set(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/include") + +message(STATUS "fortran module direcotry ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}") + + +include_directories(${MPI_Fortran_INCLUDE_PATH}) + + +message(STATUS "Using MPI include at: ${MPI_Fortran_INCLUDE_PATH}") + + +set_target_properties(base + PROPERTIES + Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules" + POSITION_INDEPENDENT_CODE TRUE + OUTPUT_NAME psb_base + LINKER_LANGUAGE Fortran + ) + +target_include_directories(base PUBLIC + $ + $ + ${MPI_Fortran_INCLUDE_PATH}) + +message(STATUS "include dir := ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}") + +#target_include_directories(base PUBLIC ${CMAKE_Fortran_MODULE_DIRECTORY}) + + +target_link_libraries(base + PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES} + PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}) + +#add_custom_command( +# TARGET base POST_BUILD +# COMMAND ${CMAKE_COMMAND} -E cmake_copy_f90_mod +# ${MPI_Fortran_INCLUDE_PATH}mpi.mod ${CMAKE_BINARY_DIR}/include/mpi.mod +#) + + + + +include(${CMAKE_CURRENT_LIST_DIR}/prec/CMakeLists.txt) +add_library(prec ${prec_source_files}) +set_target_properties(prec + PROPERTIES + Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules" + POSITION_INDEPENDENT_CODE TRUE + OUTPUT_NAME psb_prec + LINKER_LANGUAGE Fortran + ) +target_include_directories(prec PUBLIC + $ + $) +target_link_libraries(prec PUBLIC base) + +include(${CMAKE_CURRENT_LIST_DIR}/krylov/CMakeLists.txt) +add_library(krylov ${krylov_source_files}) +set_target_properties(krylov + PROPERTIES + Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules" + POSITION_INDEPENDENT_CODE TRUE + OUTPUT_NAME psb_krylov + LINKER_LANGUAGE Fortran + ) +target_include_directories(krylov PUBLIC + $ + $) +target_link_libraries(krylov PUBLIC base prec) + + +include(${CMAKE_CURRENT_LIST_DIR}/ext/CMakeLists.txt) +add_library(ext ${ext_source_files}) +set_target_properties(ext + PROPERTIES + Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules" + POSITION_INDEPENDENT_CODE TRUE + OUTPUT_NAME psb_ext + LINKER_LANGUAGE Fortran + ) +target_include_directories(ext PUBLIC + $ + $) +target_link_libraries(ext PUBLIC base prec) #TODO: check actual dependencies + + + + +include(${CMAKE_CURRENT_LIST_DIR}/util/CMakeLists.txt) +if(WIN32) + if(METIS_FOUND) + add_library(psb_util_C STATIC ${util_source_C_files}) + target_compile_definitions(psb_util_C + PRIVATE -DWIN32 -D_LIB -DWIN64) + set_target_properties(psb_util_C + PROPERTIES + LINKER_LANGUAGE C + POSITION_INDEPENDENT_CODE TRUE) + target_link_libraries(psb_util_C + PUBLIC kernel32 user32 shell32) + endif() + add_library(util ${util_source_files}) + if(METIS_FOUND) + target_link_libraries(util + PUBLIC psb_util_C) + endif() +else() + add_library(psb_util_C OBJECT ${util_source_C_files}) + add_library(util ${util_source_files} $) +endif() +set_target_properties(util + PROPERTIES + Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules" + POSITION_INDEPENDENT_CODE TRUE + OUTPUT_NAME psb_util + LINKER_LANGUAGE Fortran + ) +target_include_directories(util PUBLIC + $ + $) +target_link_libraries(util PUBLIC base prec) +if(METIS_FOUND) + message(STATUS ${METIS_INCLUDES}) + target_include_directories(util + PUBLIC ${METIS_INCLUDES}) + target_include_directories(psb_util_C + PUBLIC ${METIS_INCLUDES}) + target_link_libraries(util + PUBLIC ${METIS_LIBRARIES}) + target_compile_definitions(psb_util_C + PUBLIC HAVE_METIS_) + target_compile_definitions(util + PUBLIC HAVE_METIS) +endif() + + + + + + + + + +# Include headers from the 'include' directory in the current directory +include_directories(${CMAKE_BINARY_DIR}/include) + + +include(${CMAKE_CURRENT_LIST_DIR}/cbind/CMakeLists.txt) +if(WIN32) + add_library(psb_cbind_C STATIC ${base_source_C_files}) + target_compile_definitions(psb_cbind_C + PRIVATE -DWIN32 -D_LIB -DWIN64) + set_target_properties(psb_cbind_C + PROPERTIES + LINKER_LANGUAGE C + POSITION_INDEPENDENT_CODE TRUE) + target_link_libraries(psb_cbind_C + PUBLIC kernel32 user32 shell32) + add_library(cbind ${cbind_source_files}) + target_link_libraries(cbind + PUBLIC psb_cbind_C) +else() + message(STATUS " ----------------------- ;") + message(STATUS " cbindcbind ----------------------- ${cbind_header_C_files};") + add_library(cbind_C OBJECT ${cbind_source_C_files}) + add_library(cbind ${cbind_source_files}) +endif() + + +#add_library(cbind ${cbind_source_files}) +set_target_properties(cbind + PROPERTIES + Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules" + POSITION_INDEPENDENT_CODE TRUE + OUTPUT_NAME psb_cbind + LINKER_LANGUAGE Fortran + ) +#target_include_directories(cbind PUBLIC +# $ +# $) +# Include directories for the cbind library +target_include_directories(cbind PUBLIC + $ # Path for building + $ # Path for installation +) +target_link_libraries(cbind PUBLIC base prec krylov ext util) + + +# Custom command to copy all header files +#add_custom_command( +# OUTPUT ${CMAKE_BINARY_DIR}/include/ # Dummy output to represent the target directory +# COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/include # Create the include directory if it doesn't exist +# COMMAND ${CMAKE_COMMAND} -E copy_if_different ${cbind_header_C_files} ${CMAKE_BINARY_DIR}/include/ # Copy all headers +# DEPENDS ${cbind_header_C_files} # Make the copy depend on the header files +# COMMENT "Copying header files to include directory" +#) + +# Create a custom target to copy headers +#add_custom_target(copy_headers ALL DEPENDS ${CMAKE_BINARY_DIR}/include/) + + foreach(path IN LISTS cbind_header_C_files) + + # Copy the header file to the include directory + file(COPY "${path}" DESTINATION "${CMAKE_BINARY_DIR}/include") + message(STATUS "Copied ${path} to ${CMAKE_BINARY_DIR}/include") + + endforeach() + + + +#target_include_directories(cbind PUBLIC +# $ +# $) +# Include directories for the cbind library +#target_include_directories(cbind_C PUBLIC +# $ # Path for building +# $ # Path for installation +# ${CMAKE_BINARY_DIR}/include # Include the copied headers +#) + + + + + +if(MPI_FOUND) +# Copy mpi.mod from the first available path in MPI_Fortran_INCLUDE_PATH + set(MPI_MOD_COPIED FALSE) + + foreach(path IN LISTS MPI_Fortran_INCLUDE_PATH) + # Construct the full path to the mpi.mod file + set(mpi_mod_path "${path}/mpi.mod") + + # Check if the mpi.mod file exists + if(EXISTS "${mpi_mod_path}") + # Copy the mpi.mod file to the module directory + file(COPY "${mpi_mod_path}" DESTINATION "${CMAKE_Fortran_MODULE_DIRECTORY}") + message(STATUS "Copied mpi.mod from ${mpi_mod_path} to ${CMAKE_Fortran_MODULE_DIRECTORY}") + set(MPI_MOD_COPIED TRUE) + break() # Exit the loop once we've copied the file + endif() + endforeach() + + if(NOT MPI_MOD_COPIED) + message(WARNING "mpi.mod not found in any of the specified paths: ${MPI_Fortran_INCLUDE_PATH}") + endif() + + + foreach(lib base prec krylov ext util cbind) + target_link_libraries(${lib} PUBLIC ${MPI_C_LIBRARIES} ${MPI_Fortran_LIBRARIES}) + endforeach() +endif() + +if(OpenCoarrays_FOUND) + foreach(lib base prec krylov ext util cbind) #TODO: check if cbind goes here! + target_link_libraries(${lib} PUBLIC OpenCoarrays::caf_mpi_static) + endforeach() +endif() + + + + +# Install the header files to the include directory +#install(FILES ${cbind_header_C_files} +# DESTINATION include +#) + +install(DIRECTORY "${CMAKE_BINARY_DIR}/include" DESTINATION "include" + FILES_MATCHING PATTERN "*.h") + +install(DIRECTORY "${CMAKE_BINARY_DIR}/modules" DESTINATION "modules" + FILES_MATCHING PATTERN "*.mod") + +install(TARGETS base prec krylov ext util cbind + EXPORT ${CMAKE_PROJECT_NAME}-targets + DESTINATION "${CMAKE_INSTALL_LIBDIR}" + LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" + ) + + + +if(WIN32) + install(TARGETS psb_base_C + EXPORT ${CMAKE_PROJECT_NAME}-targets + DESTINATION "${CMAKE_INSTALL_LIBDIR}" + LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" + ) + if(METIS_FOUND) + install(TARGETS psb_util_C + EXPORT ${CMAKE_PROJECT_NAME}-targets + DESTINATION "${CMAKE_INSTALL_LIBDIR}" + LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" + ) + endif() +endif() + +#----------------- +# Add PSBLAS tests +#----------------- + +# Unit tests targeting each function, argument, and branch of code +# add_mpi_test(initialize_mpi 2 initialize_mpi) diff --git a/base/CMakeLists.txt b/base/CMakeLists.txt new file mode 100644 index 00000000..fc30a22a --- /dev/null +++ b/base/CMakeLists.txt @@ -0,0 +1,638 @@ +set(PSB_base_source_files + comm/psb_dovrl_a.f90 + comm/psb_dovrl.f90 +# comm/psb_i2halo_a.f90 + comm/internals/psi_zswaptran.F90 +# comm/internals/psi_i2ovrl_upd_a.f90 + comm/internals/psi_lovrl_save.f90 + comm/internals/psi_movrl_save_a.f90 + comm/internals/psi_sovrl_restr_a.f90 + comm/internals/psi_sovrl_upd_a.f90 + comm/internals/psi_zswaptran_a.F90 + comm/internals/psi_lovrl_restr.f90 + comm/internals/psi_iswapdata.F90 + comm/internals/psi_covrl_upd_a.f90 + comm/internals/psi_dswaptran_a.F90 + comm/internals/psi_lovrl_upd.f90 + comm/internals/psi_dswapdata_a.F90 + comm/internals/psi_movrl_upd_a.f90 +# comm/internals/psi_i2swaptran_a.F90 + comm/internals/psi_dswaptran.F90 + comm/internals/psi_covrl_save_a.f90 + comm/internals/psi_eovrl_restr_a.f90 + comm/internals/psi_sswaptran_a.F90 + comm/internals/psi_dovrl_save_a.f90 + comm/internals/psi_lswapdata.F90 + comm/internals/psi_cswapdata.F90 + comm/internals/psi_dswapdata.F90 + comm/internals/psi_sovrl_save.f90 + comm/internals/psi_iswaptran.F90 + comm/internals/psi_sswapdata_a.F90 + comm/internals/psi_sswaptran.F90 + comm/internals/psi_lswaptran.F90 + comm/internals/psi_mswaptran_a.F90 +# comm/internals/psi_i2ovrl_restr_a.f90 + comm/internals/psi_covrl_restr.f90 + comm/internals/psi_mswapdata_a.F90 + comm/internals/psi_zovrl_restr_a.f90 + comm/internals/psi_dovrl_restr_a.f90 + comm/internals/psi_covrl_restr_a.f90 + comm/internals/psi_sswapdata.F90 + comm/internals/psi_sovrl_save_a.f90 + comm/internals/psi_iovrl_upd.f90 + comm/internals/psi_eswaptran_a.F90 + comm/internals/psi_iovrl_save.f90 + comm/internals/psi_zovrl_restr.f90 + comm/internals/psi_zovrl_upd.f90 + comm/internals/psi_dovrl_upd_a.f90 + comm/internals/psi_dovrl_restr.f90 + comm/internals/psi_zswapdata_a.F90 + comm/internals/psi_dovrl_save.f90 + comm/internals/psi_covrl_save.f90 +# comm/internals/psi_i2swapdata_a.F90 + comm/internals/psi_dovrl_upd.f90 + comm/internals/psi_eovrl_save_a.f90 + comm/internals/psi_zovrl_upd_a.f90 + comm/internals/psi_zswapdata.F90 + comm/internals/psi_covrl_upd.f90 + comm/internals/psi_cswaptran.F90 +# comm/internals/psi_i2ovrl_save_a.f90 + comm/internals/psi_sovrl_upd.f90 + comm/internals/psi_eswapdata_a.F90 + comm/internals/psi_movrl_restr_a.f90 + comm/internals/psi_iovrl_restr.f90 + comm/internals/psi_cswapdata_a.F90 + comm/internals/psi_zovrl_save.f90 + comm/internals/psi_eovrl_upd_a.f90 + comm/internals/psi_zovrl_save_a.f90 + comm/internals/psi_cswaptran_a.F90 + comm/internals/psi_sovrl_restr.f90 + comm/psb_dhalo.f90 + comm/psb_zgather_a.f90 + comm/psb_zovrl.f90 + comm/psb_mhalo_a.f90 + comm/psb_zscatter_a.F90 + comm/psb_chalo.f90 + comm/psb_zscatter.F90 + comm/psb_cscatter_a.F90 + comm/psb_cspgather.F90 + comm/psb_cscatter.F90 + comm/psb_shalo_a.f90 + comm/psb_cgather.f90 + comm/psb_zhalo.f90 + comm/psb_movrl_a.f90 + comm/psb_chalo_a.f90 +# comm/psb_i2scatter_a.F90 + comm/psb_sgather_a.f90 +# comm/psb_i2ovrl_a.f90 + comm/psb_zovrl_a.f90 + comm/psb_covrl.f90 + comm/psb_shalo.f90 + comm/psb_dscatter_a.F90 + comm/psb_lgather.f90 + comm/psb_iscatter.F90 + comm/psb_sovrl_a.f90 + comm/psb_dscatter.F90 + comm/psb_eovrl_a.f90 + comm/psb_lovrl.f90 +## comm/psb_lspgather.F90 +## comm/psb_ispgather.F90 + comm/psb_zhalo_a.f90 + comm/psb_sscatter_a.F90 + comm/psb_lscatter.F90 +# comm/psb_i2gather_a.f90 + comm/psb_ihalo.f90 + comm/psb_iovrl.f90 + comm/psb_zspgather.F90 + comm/psb_escatter_a.F90 + comm/psb_mscatter_a.F90 + comm/psb_egather_a.f90 + comm/psb_covrl_a.f90 + comm/psb_sgather.f90 + comm/psb_dhalo_a.f90 + comm/psb_zgather.f90 + comm/psb_igather.f90 + comm/psb_sovrl.f90 + comm/psb_sspgather.F90 + comm/psb_cgather_a.f90 + comm/psb_ehalo_a.f90 + comm/psb_dgather_a.f90 + comm/psb_dspgather.F90 + comm/psb_sscatter.F90 + comm/psb_mgather_a.f90 + comm/psb_dgather.f90 + comm/psb_lhalo.f90 + internals/psi_bld_glb_dep_list.F90 + internals/psi_graph_fnd_owner.F90 + internals/psi_sort_dl.f90 + internals/psi_indx_map_fnd_owner.F90 + internals/psi_fnd_owner.F90 + internals/psi_bld_tmpovrl.f90 + internals/psi_symm_dep_list.F90 + internals/psi_desc_impl.f90 +### internals/psi_compute_size.f90 + internals/psi_hash_impl.f90 + internals/psi_crea_ovr_elem.f90 + internals/psi_a2a_fnd_owner.F90 + internals/psi_bld_tmphalo.f90 + internals/psi_crea_bnd_elem.f90 + internals/psi_desc_index.F90 + internals/psi_xtr_loc_dl.F90 + internals/psi_crea_index.f90 + internals/psi_srtlist.f90 + internals/psi_adjcncy_fnd_owner.F90 + tools/psb_sins.f90 + tools/psb_zspasb.f90 + tools/psb_zspalloc.f90 +# tools/psb_i2_remote_vect.F90 + tools/psb_sfree_a.f90 + tools/psb_cdprt.f90 + tools/psb_c_glob_transpose.F90 + tools/psb_ssphalo.F90 + tools/psb_sallc.f90 + tools/psb_sspasb.f90 + tools/psb_zasb.f90 + tools/psb_z_par_csr_spspmm.f90 + tools/psb_iasb.f90 + tools/psb_cdalv.f90 + tools/psb_sspfree.f90 + tools/psb_icdasb.F90 + tools/psb_zallc_a.f90 + tools/psb_d_map.f90 + tools/psb_lfree.f90 +# tools/psb_i2ins_a.f90 + tools/psb_s_remap.F90 + tools/psb_cspalloc.f90 + tools/psb_glob_to_loc.f90 + tools/psb_cdrep.f90 + tools/psb_mins_a.f90 + tools/psb_dallc_a.f90 + tools/psb_d_remote_vect.F90 + tools/psb_cfree.f90 + tools/psb_scdbldext.F90 + tools/psb_cspins.F90 + tools/psb_z_remote_vect.F90 + tools/psb_ssprn.f90 + tools/psb_cdals.f90 + tools/psb_sgetelem.f90 + tools/psb_cspfree.f90 + tools/psb_cins.f90 +# tools/psb_i2free_a.f90 + tools/psb_dspins.F90 +# tools/psb_i2asb_a.f90 + tools/psb_dsphalo.F90 + tools/psb_d_glob_transpose.F90 + tools/psb_c_par_csr_spspmm.f90 + tools/psb_callc_a.f90 + tools/psb_masb_a.f90 + tools/psb_ccdbldext.F90 + tools/psb_dfree_a.f90 + tools/psb_dspasb.f90 + tools/psb_sasb_a.f90 + tools/psb_z_remote_mat.F90 + tools/psb_c_remote_vect.F90 + tools/psb_cd_switch_ovl_indxmap.f90 + tools/psb_dfree.f90 + tools/psb_dasb.f90 + tools/psb_cd_inloc.f90 + tools/psb_mfree_a.f90 + tools/psb_zspfree.f90 + tools/psb_s_glob_transpose.F90 + tools/psb_sfree.f90 + tools/psb_dcdbldext.F90 + tools/psb_eins_a.f90 + tools/psb_s_map.f90 + tools/psb_dsprn.f90 + tools/psb_d_remap.F90 + tools/psb_iins.f90 + tools/psb_sasb.f90 + tools/psb_zgetelem.f90 + tools/psb_z_map.f90 + tools/psb_dins_a.f90 + tools/psb_loc_to_glob.f90 + tools/psb_cgetelem.f90 + tools/psb_zcdbldext.F90 + tools/psb_d_remote_mat.F90 + tools/psb_cd_set_bld.f90 + tools/psb_zfree.f90 + tools/psb_zallc.f90 + tools/psb_lallc.f90 + tools/psb_cd_reinit.f90 + tools/psb_csphalo.F90 + tools/psb_cfree_a.f90 + tools/psb_cd_lstext.f90 + tools/psb_zfree_a.f90 + tools/psb_s_par_csr_spspmm.f90 + tools/psb_dgetelem.f90 + tools/psb_callc.f90 + tools/psb_d_par_csr_spspmm.f90 + tools/psb_sspins.F90 + tools/psb_sallc_a.f90 + tools/psb_c_remote_mat.F90 + tools/psb_zins.f90 + tools/psb_e_remote_vect.F90 + tools/psb_zsphalo.F90 + tools/psb_cdren.f90 + tools/psb_casb_a.f90 + tools/psb_dins.f90 + tools/psb_ifree.f90 + tools/psb_mallc_a.f90 + tools/psb_s_remote_vect.F90 + tools/psb_c_remap.F90 + tools/psb_efree_a.f90 + tools/psb_sins_a.f90 + tools/psb_cdins.F90 + tools/psb_cdall.f90 + tools/psb_lasb.f90 + tools/psb_csprn.f90 + tools/psb_casb.f90 + tools/psb_c_map.f90 + tools/psb_lins.f90 + tools/psb_cspasb.f90 + tools/psb_dspfree.f90 + tools/psb_sspalloc.f90 + tools/psb_z_remap.F90 + tools/psb_z_glob_transpose.F90 + tools/psb_easb_a.f90 + tools/psb_cins_a.f90 + tools/psb_iallc.f90 + tools/psb_m_remote_vect.F90 + tools/psb_eallc_a.f90 + tools/psb_dspalloc.f90 + tools/psb_zasb_a.f90 + tools/psb_s_remote_mat.F90 + tools/psb_cd_remap.F90 + tools/psb_zspins.F90 + tools/psb_zins_a.f90 + tools/psb_cdcpy.F90 +# tools/psb_i2allc_a.f90 + tools/psb_dallc.f90 + tools/psb_cd_renum_block.F90 + tools/psb_dasb_a.f90 + tools/psb_zsprn.f90 + tools/psb_get_overlap.f90 + serial/psb_crwextd.f90 + serial/psb_zspspmm.f90 + serial/psb_drwextd.f90 + serial/psb_dnumbmm.f90 + serial/psb_damax_s.f90 + serial/psb_zgeprt.f90 + serial/impl/psb_c_coo_impl.F90 + serial/impl/psb_d_coo_impl.F90 + serial/impl/psb_d_csc_impl.F90 + serial/impl/psb_s_coo_impl.F90 + serial/impl/psb_c_csc_impl.F90 + serial/impl/psb_c_rb_idx_tree_impl.F90 + serial/impl/psb_z_csc_impl.F90 + serial/impl/psb_d_mat_impl.F90 + serial/impl/psb_s_csr_impl.F90 + serial/impl/psb_c_mat_impl.F90 + serial/impl/psb_c_csr_impl.F90 + serial/impl/psb_z_mat_impl.F90 + serial/impl/psb_s_rb_idx_tree_impl.F90 + serial/impl/psb_d_csr_impl.F90 + serial/impl/psb_s_mat_impl.F90 + serial/impl/psb_s_base_mat_impl.F90 + serial/impl/psb_base_mat_impl.f90 + serial/impl/psb_d_rb_idx_tree_impl.F90 + serial/impl/psb_z_rb_idx_tree_impl.F90 + serial/impl/psb_z_csr_impl.F90 + serial/impl/psb_z_coo_impl.F90 + serial/impl/psb_c_base_mat_impl.F90 + serial/impl/psb_z_base_mat_impl.F90 + serial/impl/psb_d_base_mat_impl.F90 + serial/impl/psb_s_csc_impl.F90 + serial/smmp.f90 + serial/psi_m_serial_impl.F90 + serial/psb_spdot_srtd.f90 + serial/psb_sasum_s.f90 + serial/psb_snumbmm.f90 + serial/psb_camax_s.f90 + serial/lsmmp.f90 + serial/psb_csymbmm.f90 + serial/psb_dgeprt.f90 + serial/psb_zrwextd.f90 + serial/psb_srwextd.f90 + serial/psb_znumbmm.f90 + serial/sort/psb_c_msort_impl.f90 + serial/sort/psb_c_hsort_impl.f90 + serial/sort/psb_m_isort_impl.f90 + serial/sort/psb_m_msort_impl.f90 + serial/sort/psb_s_hsort_impl.f90 + serial/sort/psb_e_isort_impl.f90 + serial/sort/psb_m_qsort_impl.f90 + serial/sort/psb_z_hsort_impl.f90 + serial/sort/psb_s_qsort_impl.f90 + serial/sort/psb_z_qsort_impl.f90 + serial/sort/psb_c_isort_impl.f90 + serial/sort/psb_e_msort_impl.f90 + serial/sort/psb_d_msort_impl.f90 + serial/sort/psb_d_qsort_impl.f90 + serial/sort/psb_s_isort_impl.f90 + serial/sort/psb_z_isort_impl.f90 + serial/sort/psb_e_hsort_impl.f90 + serial/sort/psb_z_msort_impl.f90 + serial/sort/psb_s_msort_impl.f90 + serial/sort/psb_m_hsort_impl.f90 + serial/sort/psb_d_hsort_impl.f90 + serial/sort/psb_e_qsort_impl.f90 + serial/sort/psb_d_isort_impl.f90 + serial/sort/psb_c_qsort_impl.f90 + serial/psb_dasum_s.f90 + serial/psi_z_serial_impl.F90 + serial/psb_dsymbmm.f90 + serial/psb_samax_s.f90 + serial/psb_lsame.f90 + serial/psb_dspspmm.f90 + serial/psb_ssymbmm.f90 + serial/psb_cgeprt.f90 + serial/psb_sgeprt.f90 +# serial/psi_i2_serial_impl.F90 + serial/psi_e_serial_impl.F90 + serial/psb_zsymbmm.f90 + serial/psb_cspspmm.f90 + serial/psb_aspxpby.f90 + serial/psi_s_serial_impl.F90 + serial/psb_zamax_s.f90 + serial/psb_spge_dot.f90 + serial/psb_zasum_s.f90 + serial/psb_casum_s.f90 + serial/psi_d_serial_impl.F90 + serial/psi_c_serial_impl.F90 + serial/psb_sspspmm.f90 + serial/psb_cnumbmm.f90 + psblas/psb_damax.f90 + psblas/psb_dspmm.f90 + psblas/psb_dasum.f90 + psblas/psb_sgetmatinfo.F90 + psblas/psb_dspnrm1.f90 +### psblas/psb_zvmlt.f90 + psblas/psb_daxpby.f90 + psblas/psb_smlt_vect.f90 + psblas/psb_dspsm.f90 + psblas/psb_zabs_vect.f90 + psblas/psb_zspmm.f90 + psblas/psb_sinv_vect.f90 + psblas/psb_zinv_vect.f90 + psblas/psb_dmlt_vect.f90 + psblas/psb_sabs_vect.f90 + psblas/psb_ddot.f90 + psblas/psb_camax.f90 + psblas/psb_cdiv_vect.f90 + psblas/psb_ddiv_vect.f90 + psblas/psb_dabs_vect.f90 + psblas/psb_zmlt_vect.f90 + psblas/psb_caxpby.f90 + psblas/psb_zaxpby.f90 + psblas/psb_cspsm.f90 + psblas/psb_sspnrm1.f90 + psblas/psb_cabs_vect.f90 +### psblas/psb_dvmlt.f90 + psblas/psb_zdot.f90 + psblas/psb_zgetmatinfo.F90 + psblas/psb_znrm2.f90 + psblas/psb_sspmm.f90 + psblas/psb_cspmm.f90 + psblas/psb_cnrmi.f90 + psblas/psb_ccmp_vect.f90 + psblas/psb_casum.f90 + psblas/psb_scmp_vect.f90 +### psblas/psb_svmlt.f90 + psblas/psb_sdot.f90 + psblas/psb_cmlt_vect.f90 + psblas/psb_dnrmi.f90 + psblas/psb_dcmp_vect.f90 + psblas/psb_cnrm2.f90 + psblas/psb_cgetmatinfo.F90 +### psblas/psb_cvmlt.f90 + psblas/psb_zamax.f90 + psblas/psb_dinv_vect.f90 + psblas/psb_dnrm2.f90 + psblas/psb_zspsm.f90 + psblas/psb_snrm2.f90 + psblas/psb_sdiv_vect.f90 + psblas/psb_zdiv_vect.f90 + psblas/psb_znrmi.f90 + psblas/psb_saxpby.f90 + psblas/psb_zspnrm1.f90 + psblas/psb_dgetmatinfo.F90 + psblas/psb_sasum.f90 + psblas/psb_zcmp_vect.f90 + psblas/psb_samax.f90 + psblas/psb_snrmi.f90 + psblas/psb_cdot.f90 + psblas/psb_cspnrm1.f90 + psblas/psb_sspsm.f90 + psblas/psb_cinv_vect.f90 + psblas/psb_zasum.f90 + modules/comm/psi_z_comm_v_mod.f90 +# modules/comm/psb_i2_comm_a_mod.f90 + modules/comm/psb_m_comm_a_mod.f90 + modules/comm/psb_z_linmap_mod.f90 + modules/comm/psi_s_comm_a_mod.f90 +# modules/comm/psi_i2_comm_a_mod.f90 + modules/comm/psi_m_comm_a_mod.f90 + modules/comm/psi_l_comm_v_mod.f90 + modules/comm/psb_comm_mod.f90 + modules/comm/psb_l_comm_mod.f90 + modules/comm/psb_d_linmap_mod.f90 + modules/comm/psi_d_comm_v_mod.f90 + modules/comm/psb_c_linmap_mod.f90 + modules/comm/psb_s_comm_mod.f90 + modules/comm/psb_base_linmap_mod.f90 + modules/comm/psi_d_comm_a_mod.f90 + modules/comm/psb_s_linmap_mod.f90 + modules/comm/psi_s_comm_v_mod.f90 + modules/comm/psb_s_comm_a_mod.f90 + modules/comm/psb_c_comm_mod.f90 + modules/comm/psb_i_comm_mod.f90 + modules/comm/psi_c_comm_v_mod.f90 + modules/comm/psb_d_comm_a_mod.f90 + modules/comm/psi_z_comm_a_mod.f90 + modules/comm/psb_z_comm_mod.f90 + modules/comm/psi_i_comm_v_mod.f90 + modules/comm/psb_e_comm_a_mod.f90 + modules/comm/psb_d_comm_mod.f90 + modules/comm/psi_e_comm_a_mod.f90 + modules/comm/psb_c_comm_a_mod.f90 + modules/comm/psb_linmap_mod.f90 + modules/comm/psb_z_comm_a_mod.f90 + modules/comm/psi_c_comm_a_mod.f90 +# modules/auxil/psb_i2_isort_mod.f90 + modules/auxil/psb_z_ip_reord_mod.F90 + modules/auxil/psi_s_serial_mod.f90 + modules/auxil/psb_s_hsort_x_mod.f90 + modules/auxil/psb_s_qsort_mod.f90 + modules/auxil/psb_d_hsort_mod.f90 + modules/auxil/psi_alcx_mod.f90 + modules/auxil/psb_e_ip_reord_mod.F90 +# modules/auxil/psb_i2_msort_mod.f90 + modules/auxil/psb_rb_idx_tree_mod.f90 + modules/auxil/psb_m_isort_mod.f90 + modules/auxil/psb_e_msort_mod.f90 + modules/auxil/psb_c_msort_mod.f90 + modules/auxil/psb_e_isort_mod.f90 + modules/auxil/psb_c_rb_idx_tree_mod.f90 + modules/auxil/psb_c_realloc_mod.F90 + modules/auxil/psb_ip_reord_mod.F90 + modules/auxil/psb_e_qsort_mod.f90 + modules/auxil/psi_e_serial_mod.f90 + modules/auxil/psi_serial_mod.f90 + modules/auxil/psb_l_hsort_x_mod.f90 + modules/auxil/psi_lcx_mod.f90 + modules/auxil/psb_d_rb_idx_tree_mod.f90 + modules/auxil/psb_m_realloc_mod.F90 + modules/auxil/psb_z_isort_mod.f90 + modules/auxil/psb_e_hsort_mod.f90 + modules/auxil/psi_m_serial_mod.f90 +# modules/auxil/psi_i2_serial_mod.f90 + modules/auxil/psb_s_isort_mod.f90 + modules/auxil/psb_e_realloc_mod.F90 + modules/auxil/psb_c_hsort_mod.f90 + modules/auxil/psb_z_msort_mod.f90 + modules/auxil/psi_d_serial_mod.f90 + modules/auxil/psb_z_qsort_mod.f90 +# modules/auxil/psb_i2_hsort_mod.f90 + modules/auxil/psb_m_msort_mod.f90 + modules/auxil/psb_m_ip_reord_mod.F90 + modules/auxil/psb_string_mod.f90 + modules/auxil/psb_c_isort_mod.f90 + modules/auxil/psb_d_hsort_x_mod.f90 + modules/auxil/psb_s_hsort_mod.f90 + modules/auxil/psb_i_hsort_x_mod.f90 + modules/auxil/psb_d_qsort_mod.f90 + modules/auxil/psb_s_realloc_mod.F90 + modules/auxil/psb_m_hsort_mod.f90 + modules/auxil/psb_z_realloc_mod.F90 + modules/auxil/psb_z_rb_idx_tree_mod.f90 +# modules/auxil/psb_i2_ip_reord_mod.F90 +# modules/auxil/psb_i2_realloc_mod.F90 + modules/auxil/psb_s_rb_idx_tree_mod.f90 + modules/auxil/psb_c_hsort_x_mod.f90 + modules/auxil/psb_s_ip_reord_mod.F90 + modules/auxil/psb_d_isort_mod.f90 + modules/auxil/psi_z_serial_mod.f90 +# modules/auxil/psb_i2_qsort_mod.f90 + modules/auxil/psb_d_msort_mod.f90 + modules/auxil/psb_c_qsort_mod.f90 + modules/auxil/psb_z_hsort_x_mod.f90 + modules/auxil/psb_c_ip_reord_mod.F90 + modules/auxil/psb_sort_mod.f90 + modules/auxil/psi_acx_mod.f90 + modules/auxil/psb_d_realloc_mod.F90 + modules/auxil/psb_m_qsort_mod.f90 + modules/auxil/psb_s_msort_mod.f90 + modules/auxil/psi_c_serial_mod.f90 + modules/auxil/psb_d_ip_reord_mod.F90 + modules/auxil/psb_z_hsort_mod.f90 + modules/psi_d_mod.F90 + modules/psi_l_mod.F90 + modules/penv/psi_d_collective_mod.F90 + modules/penv/psi_m_p2p_mod.F90 +# modules/penv/psi_i2_collective_mod.F90 + modules/penv/psi_s_p2p_mod.F90 + modules/penv/psi_e_p2p_mod.F90 + modules/penv/psi_m_collective_mod.F90 + modules/penv/psi_d_p2p_mod.F90 + modules/penv/psi_p2p_mod.F90 + modules/penv/psi_penv_mod.F90 + modules/penv/psi_z_p2p_mod.F90 + modules/penv/psi_c_collective_mod.F90 + modules/penv/psi_collective_mod.F90 +# modules/penv/psi_i2_p2p_mod.F90 + modules/penv/psi_c_p2p_mod.F90 + modules/penv/psi_e_collective_mod.F90 + modules/penv/psi_z_collective_mod.F90 + modules/penv/psi_s_collective_mod.F90 + modules/psb_cbind_const_mod.F90 + modules/psi_s_mod.F90 + modules/psi_c_mod.F90 + modules/tools/psb_s_tools_a_mod.f90 + modules/tools/psb_d_tools_a_mod.f90 + modules/tools/psb_z_tools_a_mod.f90 + modules/tools/psb_i_tools_mod.F90 + modules/tools/psb_s_tools_mod.F90 + modules/tools/psb_tools_mod.f90 + modules/tools/psb_m_tools_a_mod.f90 + modules/tools/psb_cd_tools_mod.F90 + modules/tools/psb_d_tools_mod.F90 + modules/tools/psb_c_tools_mod.F90 + modules/tools/psb_e_tools_a_mod.f90 +# modules/tools/psb_i2_tools_a_mod.f90 + modules/tools/psb_c_tools_a_mod.f90 + modules/tools/psb_z_tools_mod.F90 + modules/tools/psb_l_tools_mod.F90 + modules/psb_realloc_mod.F90 + modules/psb_check_mod.f90 + modules/serial/psb_mat_mod.f90 + modules/serial/psb_s_csr_mat_mod.f90 + modules/serial/psb_z_mat_mod.F90 + modules/serial/psb_z_vect_mod.F90 + modules/serial/psb_l_base_vect_mod.F90 + modules/serial/psb_c_serial_mod.f90 + modules/serial/psb_z_csc_mat_mod.f90 + modules/serial/psb_d_csc_mat_mod.f90 + modules/serial/psb_z_serial_mod.f90 + modules/serial/psb_c_base_mat_mod.F90 + modules/serial/psb_z_base_mat_mod.F90 + modules/serial/psb_z_csr_mat_mod.f90 + modules/serial/psb_c_csc_mat_mod.f90 + modules/serial/psb_z_base_vect_mod.F90 + modules/serial/psb_l_vect_mod.F90 + modules/serial/psb_d_csr_mat_mod.f90 + modules/serial/psb_c_csr_mat_mod.f90 + modules/serial/psb_s_base_mat_mod.F90 + modules/serial/psb_base_mat_mod.F90 + modules/serial/psb_i_base_vect_mod.F90 + modules/serial/psb_s_vect_mod.F90 + modules/serial/psb_s_base_vect_mod.F90 + modules/serial/psb_d_base_vect_mod.F90 + modules/serial/psb_c_mat_mod.F90 + modules/serial/psb_d_base_mat_mod.F90 + modules/serial/psb_c_vect_mod.F90 + modules/serial/psb_d_mat_mod.F90 + modules/serial/psb_s_mat_mod.F90 + modules/serial/psb_i_vect_mod.F90 + modules/serial/psb_d_vect_mod.F90 + modules/serial/psb_c_base_vect_mod.F90 + modules/serial/psb_vect_mod.f90 + modules/serial/psb_d_serial_mod.f90 + modules/serial/psb_s_csc_mat_mod.f90 + modules/serial/psb_s_serial_mod.f90 + modules/serial/psb_serial_mod.f90 + modules/psi_mod.f90 + modules/error.f90 + modules/psb_const_mod.F90 + modules/psblas/psb_c_psblas_mod.F90 + modules/psblas/psb_s_psblas_mod.F90 + modules/psblas/psb_d_psblas_mod.F90 + modules/psblas/psb_z_psblas_mod.F90 + modules/psblas/psb_psblas_mod.f90 + modules/psb_error_impl.F90 + modules/psb_penv_mod.F90 + modules/psb_error_mod.F90 + modules/psb_timers_mod.f90 + modules/psi_i_mod.F90 + modules/psi_z_mod.F90 + modules/desc/psb_desc_const_mod.f90 + modules/desc/psb_indx_map_mod.F90 + modules/desc/psb_hash_mod.F90 + modules/desc/psb_desc_mod.F90 + modules/desc/psb_gen_block_map_mod.F90 + modules/desc/psb_list_map_mod.F90 + modules/desc/psb_repl_map_mod.F90 + modules/desc/psb_hash_map_mod.F90 + modules/desc/psb_glist_map_mod.F90 + modules/psb_base_mod.f90 +) +foreach(file IN LISTS PSB_base_source_files) + list(APPEND base_source_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach() + +list(APPEND PSB_base_source_C_files modules/cutil.c) +if (SERIAL_MPI) + list(APPEND PSB_base_source_C_files modules/fakempi.c) +endif() +foreach(file IN LISTS PSB_base_source_C_files) + list(APPEND base_source_C_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach() diff --git a/cbind/CMakeLists.txt b/cbind/CMakeLists.txt new file mode 100644 index 00000000..e7018c78 --- /dev/null +++ b/cbind/CMakeLists.txt @@ -0,0 +1,95 @@ +set(PSB_cbind_source_files + base/psb_d_tools_cbind_mod.F90 + base/psb_s_tools_cbind_mod.F90 + base/psb_d_psblas_cbind_mod.f90 + base/psb_objhandle_mod.F90 + base/psb_base_psblas_cbind_mod.f90 + base/psb_z_psblas_cbind_mod.f90 + base/psb_c_comm_cbind_mod.f90 + base/psb_z_serial_cbind_mod.F90 + base/psb_d_serial_cbind_mod.F90 + base/psb_c_tools_cbind_mod.F90 + base/psb_c_serial_cbind_mod.F90 + base/psb_base_string_cbind_mod.f90 + base/psb_base_tools_cbind_mod.F90 + base/psb_z_comm_cbind_mod.f90 + base/psb_s_serial_cbind_mod.F90 + base/psb_base_cbind_mod.f90 + base/psb_s_comm_cbind_mod.f90 + base/psb_s_psblas_cbind_mod.f90 + base/psb_c_psblas_cbind_mod.f90 + base/psb_d_comm_cbind_mod.f90 + base/psb_z_tools_cbind_mod.F90 + base/psb_cpenv_mod.f90 + util/psb_c_util_cbind_mod.f90 + util/psb_s_util_cbind_mod.f90 + util/psb_util_cbind_mod.f90 + util/psb_d_util_cbind_mod.f90 + util/psb_z_util_cbind_mod.f90 + krylov/psb_ckrylov_cbind_mod.f90 + krylov/psb_base_krylov_cbind_mod.f90 + krylov/psb_skrylov_cbind_mod.f90 + krylov/psb_dkrylov_cbind_mod.f90 + krylov/psb_zkrylov_cbind_mod.f90 + prec/psb_dprec_cbind_mod.f90 + prec/psb_cprec_cbind_mod.f90 + prec/psb_prec_cbind_mod.f90 + prec/psb_sprec_cbind_mod.f90 + prec/psb_zprec_cbind_mod.f90 +) +foreach(file IN LISTS PSB_cbind_source_files) + list(APPEND cbind_source_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach() + +list(APPEND PSB_cbind_source_C_files + base/psb_c_dcomm.c + base/psb_c_scomm.c + base/psb_c_zcomm.c + base/psb_c_ccomm.c + base/psb_c_dbase.c + base/psb_c_base.c + base/psb_c_zbase.c + base/psb_c_cbase.c + base/psb_c_sbase.c + prec/psb_c_dprec.c + prec/psb_c_cprec.c + prec/psb_c_zprec.c + prec/psb_c_sprec.c + test/pargen/ppdec.c + + ) + +list(APPEND PSB_cbind_header_C_files + base/psb_c_sbase.h + base/psb_c_base.h + base/psb_c_dcomm.h + base/psb_c_dbase.h + base/psb_c_scomm.h + base/psb_c_ccomm.h + base/psb_base_cbind.h + base/psb_c_cbase.h + base/psb_c_zbase.h + base/psb_c_zcomm.h + util/psb_c_zutil.h + util/psb_c_dutil.h + util/psb_c_sutil.h + util/psb_c_cutil.h + util/psb_util_cbind.h + krylov/psb_krylov_cbind.h + prec/psb_c_sprec.h + prec/psb_c_cprec.h + prec/psb_prec_cbind.h + prec/psb_c_dprec.h + prec/psb_c_zprec.h +) + +#if (SERIAL_MPI) +# list(APPEND PSB_base_source_C_files modules/fakempi.c) +#endif() + +foreach(file IN LISTS PSB_cbind_source_C_files) + list(APPEND cbind_source_C_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach() +foreach(file IN LISTS PSB_cbind_header_C_files) + list(APPEND cbind_header_C_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach() diff --git a/cmake/CapitalizeString.cmake b/cmake/CapitalizeString.cmake new file mode 100644 index 00000000..ae50b474 --- /dev/null +++ b/cmake/CapitalizeString.cmake @@ -0,0 +1,7 @@ +function(CapitalizeString string output_variable) + string(TOUPPER "${string}" _upper_string) + string(TOLOWER "${string}" _lower_string) + string(SUBSTRING "${_upper_string}" 0 1 _start) + string(SUBSTRING "${_lower_string}" 1 -1 _end) + set(${output_variable} "${_start}${_end}" PARENT_SCOPE) +endfunction() diff --git a/cmake/CheckOutOfSourceBuild.cmake b/cmake/CheckOutOfSourceBuild.cmake new file mode 100644 index 00000000..ad176952 --- /dev/null +++ b/cmake/CheckOutOfSourceBuild.cmake @@ -0,0 +1,21 @@ +#-------------------------- +# Prohibit in-source builds +#-------------------------- +if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}") + message(FATAL_ERROR "ERROR! " + "CMAKE_CURRENT_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}" + " == CMAKE_CURRENT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}" + "\nThis archive does not support in-source builds:\n" + "You must now delete the CMakeCache.txt file and the CMakeFiles/ directory under " + "the 'src' source directory or you will not be able to configure correctly!" + "\nYou must now run something like:\n" + " $ rm -r CMakeCache.txt CMakeFiles/" + "\n" + "Please create a directory outside the ${CMAKE_PROJECT_NAME} source tree and build under that outside directory " + "in a manner such as\n" + " $ mkdir build\n" + " $ cd build\n" + " $ CC=gcc FC=gfortran cmake -DBUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/path/to/install/dir /path/to/psblas3/src/dir \n" + "\nsubstituting the appropriate syntax for your shell (the above line assumes the bash shell)." + ) +endif() diff --git a/cmake/FindMETIS.cmake b/cmake/FindMETIS.cmake new file mode 100644 index 00000000..21f95f57 --- /dev/null +++ b/cmake/FindMETIS.cmake @@ -0,0 +1,95 @@ +if (METIS_INCLUDES AND METIS_LIBRARIES) + set(METIS_FIND_QUIETLY TRUE) +endif (METIS_INCLUDES AND METIS_LIBRARIES) + +if( DEFINED ENV{METISDIR} ) + if( NOT DEFINED METIS_ROOT ) + set(METIS_ROOT "$ENV{METISDIR}") + endif() +endif() + +if( (DEFINED ENV{METIS_ROOT}) OR (DEFINED METIS_ROOT) ) + if( NOT DEFINED METIS_ROOT) + set(METIS_ROOT "$ENV{METIS_ROOT}") + endif() + set(METIS_HINTS "${METIS_ROOT}") +endif() + +find_path(METIS_INCLUDES + NAMES + metis.h + HINTS + ${METIS_HINTS} + PATHS + "${INCLUDE_INSTALL_DIR}" + /usr/local/opt + /usr/local + PATH_SUFFIXES + include + ) + +if(METIS_INCLUDES) + foreach(include IN_LISTS METIS_INCLUDES) + get_filename_component(mts_include_dir "${include}" DIRECTORY) + get_filename_component(mts_abs_include_dir "${mts_include_dir}" ABSOLUTE) + get_filename_component(new_mts_hint "${include_dir}/.." ABSOLUTE ) + list(APPEND METIS_HINTS "${new_mts_hint}") + break() + endforeach() +endif() + +if(METIS_HINTS) + list(REMOVE_DUPLICATES METIS_HINTS) +endif() + +macro(_metis_check_version) + file(READ "${METIS_INCLUDES}/metis.h" _metis_version_header) + + string(REGEX MATCH "define[ \t]+METIS_VER_MAJOR[ \t]+([0-9]+)" _metis_major_version_match "${_metis_version_header}") + set(METIS_MAJOR_VERSION "${CMAKE_MATCH_1}") + string(REGEX MATCH "define[ \t]+METIS_VER_MINOR[ \t]+([0-9]+)" _metis_minor_version_match "${_metis_version_header}") + set(METIS_MINOR_VERSION "${CMAKE_MATCH_1}") + string(REGEX MATCH "define[ \t]+METIS_VER_SUBMINOR[ \t]+([0-9]+)" _metis_subminor_version_match "${_metis_version_header}") + set(METIS_SUBMINOR_VERSION "${CMAKE_MATCH_1}") + if(NOT METIS_MAJOR_VERSION) + message(STATUS "Could not determine Metis version. Assuming version 4.0.0") + set(METIS_VERSION 4.0.0) + else() + set(METIS_VERSION ${METIS_MAJOR_VERSION}.${METIS_MINOR_VERSION}.${METIS_SUBMINOR_VERSION}) + endif() + if(${METIS_VERSION} VERSION_LESS ${Metis_FIND_VERSION}) + set(METIS_VERSION_OK FALSE) + else() + set(METIS_VERSION_OK TRUE) + endif() + + if(NOT METIS_VERSION_OK) + message(STATUS "Metis version ${METIS_VERSION} found in ${METIS_INCLUDES}, " + "but at least version ${Metis_FIND_VERSION} is required") + endif(NOT METIS_VERSION_OK) +endmacro(_metis_check_version) + +if(METIS_INCLUDES AND Metis_FIND_VERSION) + _metis_check_version() +else() + set(METIS_VERSION_OK TRUE) +endif() + + +find_library(METIS_LIBRARIES metis + HINTS + ${METIS_HINTS} + PATHS + "${LIB_INSTALL_DIR}" + /usr/local/ + /usr/local/opt + PATH_SUFFIXES + lib + lib64 + metis/lib) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(METIS DEFAULT_MSG + METIS_INCLUDES METIS_LIBRARIES METIS_VERSION_OK) + +mark_as_advanced(METIS_INCLUDES METIS_LIBRARIES) diff --git a/cmake/makeDist.cmake b/cmake/makeDist.cmake new file mode 100644 index 00000000..f0b46566 --- /dev/null +++ b/cmake/makeDist.cmake @@ -0,0 +1,79 @@ +# CMake file to be called in script mode (${CMAKE_COMMAND} -P ) to +# Generate a source archive release asset from add_custom_command +# +# See SourceDistTarget.cmake + +if(NOT CMAKE_ARGV3) + message(FATAL_ERROR "Must pass the top level src dir to ${CMAKE_ARGV2} as the first argument") +endif() + +if(NOT CMAKE_ARGV4) + message(FATAL_ERROR "Must pass the top level src dir to ${CMAKE_ARGV2} as the second argument") +endif() + +find_package(Git) +if(NOT GIT_FOUND) + message( FATAL_ERROR "You can't create a source archive release asset without git!") +endif() + +execute_process(COMMAND "${GIT_EXECUTABLE}" describe --always + RESULT_VARIABLE git_status + OUTPUT_VARIABLE git_version + WORKING_DIRECTORY "${CMAKE_ARGV3}" + OUTPUT_STRIP_TRAILING_WHITESPACE) +if(NOT (git_status STREQUAL "0")) + message( FATAL_ERROR "git describe --always failed with exit status: ${git_status} and message: +${git_version}") +endif() + +set(archive "PSBLAS-${git_version}") +set(l_archive "PSBLAS-${git_version}") +set(release_asset "${CMAKE_ARGV4}/${archive}.tar.gz") +execute_process( + COMMAND "${GIT_EXECUTABLE}" archive "--prefix=${archive}/" -o "${release_asset}" "${git_version}" + RESULT_VARIABLE git_status + OUTPUT_VARIABLE git_output + WORKING_DIRECTORY "${CMAKE_ARGV3}" + OUTPUT_STRIP_TRAILING_WHITESPACE) + +if(NOT (git_status STREQUAL "0")) + message( FATAL_ERROR "git archive ... failed with exit status: ${git_status} and message: +${git_output}") +else() + message( STATUS "Source code release asset created from `git archive`: ${release_asset}") +endif() + +file(SHA256 "${release_asset}" tarball_sha256) +set(sha256_checksum "${tarball_sha256} ${archive}.tar.gz") +configure_file("${CMAKE_ARGV3}/cmake/PSBLAS-VER-SHA256.txt.in" + "${CMAKE_ARGV4}/${l_archive}-SHA256.txt" + @ONLY) +message( STATUS + "SHA 256 checksum of release tarball written out as: ${CMAKE_ARGV4}/${l_archive}-SHA256.txt" ) + +find_program(GPG_EXECUTABLE + gpg + DOC "Location of GnuPG (gpg) executable") + +if(GPG_EXECUTABLE) + execute_process( + COMMAND "${GPG_EXECUTABLE}" --armor --detach-sign --comment "@gpg_comment@" "${CMAKE_ARGV4}/${l_archive}-SHA256.txt" + RESULT_VARIABLE gpg_status + OUTPUT_VARIABLE gpg_output + WORKING_DIRECTORY "${CMAKE_ARGV4}") + if(NOT (gpg_status STREQUAL "0")) + message( WARNING "GPG signing of ${CMAKE_ARGV4}/${l_archive}-SHA256.txt appears to have failed +with status: ${gpg_status} and output: ${gpg_output}") + else() + configure_file("${CMAKE_ARGV3}/cmake/PSBLAS-VER-SHA256.txt.asc.in" + "${CMAKE_ARGV4}/${l_archive}-GPG.comment" + @ONLY) + file(READ "${CMAKE_ARGV4}/${l_archive}-GPG.comment" gpg_comment) + configure_file("${CMAKE_ARGV4}/${l_archive}-SHA256.txt.asc" + "${CMAKE_ARGV4}/${l_archive}-SHA256.txt.asc.out" + @ONLY) + file(RENAME "${CMAKE_ARGV4}/${l_archive}-SHA256.txt.asc.out" + "${CMAKE_ARGV4}/${l_archive}-SHA256.txt.asc") + message(STATUS "GPG signed SHA256 checksum created: ${CMAKE_ARGV4}/${l_archive}-SHA256.txt.asc") + endif() +endif() diff --git a/cmake/pkg/psblasConfig.cmake.in b/cmake/pkg/psblasConfig.cmake.in new file mode 100644 index 00000000..3fe60345 --- /dev/null +++ b/cmake/pkg/psblasConfig.cmake.in @@ -0,0 +1,16 @@ +# Config file for the INSTALLED package +# Allow other CMake projects to find this package if it is installed +# Requires the use of the standard CMake module CMakePackageConfigHelpers + +set ( @CMAKE_PROJECT_NAME@_VERSION @VERSION@ ) + +###@COMPILER_CONSISTENCY_CHECK@ + +@PACKAGE_INIT@ + +# Provide the targets +set_and_check ( @PACKAGE_NAME@_CONFIG_INSTALL_DIR "@PACKAGE_EXPORT_INSTALL_DIR@" ) +include ( "${@PACKAGE_NAME@_CONFIG_INSTALL_DIR}/@PACKAGE_NAME@-targets.cmake" ) + +# Make the module files available via include +set_and_check ( @CMAKE_PROJECT_NAME@_INCLUDE_DIRS "@PACKAGE_INSTALL_MOD_DIR@" ) diff --git a/cmake/psblas-VER-SHA256.txt.asc.in b/cmake/psblas-VER-SHA256.txt.asc.in new file mode 100644 index 00000000..22cd9211 --- /dev/null +++ b/cmake/psblas-VER-SHA256.txt.asc.in @@ -0,0 +1,12 @@ +Mac users can use GPGTools - https://gpgtools.org +Comment: Download Izaak Beekman's GPG public key from your +Comment: trusted key server or from +Comment: https://izaakbeekman.com/izaak.pubkey.txt +Comment: Next add it to your GPG keyring, e.g., +Comment: `curl https://izaakbeekman.com/izaak.pubkey.txt | gpg --import` +Comment: Make sure you have verified that the release archive's +Comment: SHA256 checksum matches the provided +Comment: psblas-@git_version@-SHA256.txt and ensure that this file +Comment: and it's signature are in the same directory. Then +Comment: verify with: +Comment: `gpg --verify psblas-@git_version@-SHA256.txt.asc` diff --git a/cmake/psblas-VER-SHA256.txt.in b/cmake/psblas-VER-SHA256.txt.in new file mode 100644 index 00000000..1b3888c4 --- /dev/null +++ b/cmake/psblas-VER-SHA256.txt.in @@ -0,0 +1,3 @@ +# To verify cryptographic checksums `shasum -c psblas-@git_version@-SHA256.txt` on Mac OS X, or +# `sha256sum -c psblas-@git_version@-SHA256.txt` on Linux. +@sha256_checksum@ diff --git a/cmake/setVersion.cmake b/cmake/setVersion.cmake new file mode 100644 index 00000000..f79ee619 --- /dev/null +++ b/cmake/setVersion.cmake @@ -0,0 +1,90 @@ +include(CMakeParseArguments) + +# Function to parse version info from git and/or .VERSION file +function(set_version) + set(options "") + set(oneValueArgs VERSION_VARIABLE GIT_DESCRIBE_VAR CUSTOM_VERSION_FILE CUSTOM_VERSION_REGEX ) + set(multiValueArgs "") + cmake_parse_arguments(set_version "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + # Algorithm: + # 1. Get first line of .VERSION file, which will be set via `git archive` so long as + # + # 2. If not a packaged release check if this is an active git repo + # 3. Get version info from `git describe` + # 4. First the most recent tag is fetched if available + # 5. Then the full `git describe` output is fetched + + + if(NOT set_version_CUSTOM_VERSION_REGEX) + set(_VERSION_REGEX "[vV]*[0-9]+\\.[0-9]+\\.[0-9]+") + else() + set(_VERSION_REGEX ${set_version_CUSTOM_VERSION_REGEX}) + endif() + if(NOT set_version_CUSTOM_VERSION_FILE) + set(_VERSION_FILE "${CMAKE_SOURCE_DIR}/.VERSION") + else() + set(_VERSION_FILE "${set_version_CUSTOM_VERSION_FILE}") + endif() + + file(STRINGS "${_VERSION_FILE}" first_line + LIMIT_COUNT 1 + ) + + string(REGEX MATCH ${_VERSION_REGEX} + _package_version "${first_line}") + + if((NOT (_package_version MATCHES ${_VERSION_REGEX})) AND (EXISTS "${CMAKE_SOURCE_DIR}/.git")) + message( STATUS "Build from git repository detected") + find_package(Git) + if(GIT_FOUND) + set(GIT_FOUND "${GIT_FOUND}" PARENT_SCOPE) + execute_process(COMMAND "${GIT_EXECUTABLE}" describe --abbrev=0 + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + RESULT_VARIABLE _git_status + OUTPUT_VARIABLE _git_output + OUTPUT_STRIP_TRAILING_WHITESPACE) + if((_git_status STREQUAL "0") AND (_git_output MATCHES ${_VERSION_REGEX})) + set(_package_version "${_git_output}") + endif() + execute_process(COMMAND "${GIT_EXECUTABLE}" describe --always + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + RESULT_VARIABLE _git_status + OUTPUT_VARIABLE _full_git_describe + OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT (_git_status STREQUAL "0")) + set(_full_git_describe NOTFOUND) + endif() + else() + message( WARNING "Could not find git executable!") + endif() + endif() + + if(NOT (_package_version MATCHES ${_VERSION_REGEX})) + message( WARNING "Could not extract version from git, falling back on ${_VERSION_FILE}.") + file(STRINGS ".VERSION" _package_version + REGEX ${_VERSION_REGEX} + ) + endif() + + if(NOT _full_git_describe) + set(_full_git_describe ${_package_version}) + endif() + + # Strip leading "v" character from package version tags so that + # the version string can be passed to the CMake `project` command + string(REPLACE "v" "" _package_version "${_package_version}") + string(REPLACE "V" "" _package_version "${_package_version}") + + if(set_version_VERSION_VARIABLE) + set(${set_version_VERSION_VARIABLE} ${_package_version} PARENT_SCOPE) + else() + set(PROJECT_VERSION ${_package_version} PARENT_SCOPE) + endif() + if(set_version_GIT_DESCRIBE_VAR) + set(${set_version_GIT_DESCRIBE_VAR} ${_full_git_describe} PARENT_SCOPE) + else() + set(FULL_GIT_DESCRIBE ${_full_git_describe} PARENT_SCOPE) + endif() + +endfunction() diff --git a/cmake/uninstall.cmake.in b/cmake/uninstall.cmake.in new file mode 100644 index 00000000..dd395930 --- /dev/null +++ b/cmake/uninstall.cmake.in @@ -0,0 +1,23 @@ +# Adapted from http://www.cmake.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F May 1, 2014 + +if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") + message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt") +endif(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") + +file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files) +string(REGEX REPLACE "\n" ";" files "${files}") +foreach(file ${files}) + message(STATUS "Uninstalling $ENV{DESTDIR}${file}") + if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + exec_program( + "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" + OUTPUT_VARIABLE rm_out + RETURN_VALUE rm_retval + ) + if(NOT "${rm_retval}" STREQUAL 0) + message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") + endif(NOT "${rm_retval}" STREQUAL 0) + else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + message(STATUS "File $ENV{DESTDIR}${file} does not exist.") + endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") +endforeach(file) diff --git a/ext/CMakeLists.txt b/ext/CMakeLists.txt new file mode 100644 index 00000000..c678d01e --- /dev/null +++ b/ext/CMakeLists.txt @@ -0,0 +1,428 @@ +set(PSB_ext_source_files + psb_s_hdia_mat_mod.f90 + impl/psb_d_ell_reinit.f90 + impl/psb_d_hll_reallocate_nz.f90 + impl/psb_z_dia_arwsum.f90 + impl/psb_d_mv_hdia_from_coo.f90 + impl/psb_z_hll_csgetptn.f90 + impl/psb_d_mv_ell_to_coo.f90 + impl/psb_d_ell_csgetblk.f90 + impl/psb_d_ell_reallocate_nz.f90 + impl/psb_d_dia_csgetptn.f90 + impl/psb_c_ell_rowsum.f90 + impl/psb_d_dia_reallocate_nz.f90 + impl/psb_z_mv_ell_to_fmt.f90 + impl/psi_d_xtr_ell_from_coo.f90 + impl/psb_s_mv_ell_to_fmt.f90 + impl/psb_z_mv_ell_from_coo.f90 + impl/psb_s_hll_scals.f90 + impl/psb_d_dia_get_diag.f90 + impl/psb_s_dia_csgetrow.f90 + impl/psb_d_hll_colsum.f90 + impl/psb_s_mv_ell_to_coo.f90 + impl/psb_z_cp_ell_from_fmt.f90 + impl/psb_c_hll_csnm1.f90 + impl/psb_c_hll_maxval.f90 + impl/psb_c_mv_hll_to_fmt.f90 + impl/psb_c_ell_scal.f90 + impl/psb_d_dia_allocate_mnnz.f90 + impl/psb_s_hll_reallocate_nz.f90 + impl/psb_s_hll_csgetptn.f90 + impl/psb_s_hdia_print.f90 + impl/psb_s_mv_hll_to_coo.f90 + impl/psb_c_hll_scal.f90 + impl/psb_s_cp_hll_to_fmt.f90 + impl/psb_s_hll_csnm1.f90 + impl/psb_z_hll_scals.f90 + impl/psb_z_dia_get_diag.f90 + impl/psb_c_cp_hll_from_coo.f90 + impl/psb_d_hll_arwsum.f90 + impl/psb_c_cp_dia_from_coo.f90 + impl/psb_c_ell_reallocate_nz.f90 + impl/psb_z_cp_hll_from_fmt.f90 + impl/psi_s_xtr_dia_from_coo.f90 + impl/psb_d_cp_hdia_from_coo.f90 + impl/psb_s_ell_csgetrow.f90 + impl/psb_s_mv_dia_to_coo.f90 + impl/psb_c_mv_hdia_to_coo.f90 + impl/psb_c_cp_dia_to_coo.f90 + impl/psb_s_hdia_allocate_mnnz.f90 + impl/psb_s_hll_print.f90 + impl/psb_d_ell_aclsum.f90 + impl/psb_c_cp_ell_to_coo.f90 + impl/psb_s_dia_mold.f90 + impl/psi_d_convert_dia_from_coo.f90 + impl/psb_d_hll_allocate_mnnz.f90 + impl/psb_d_dia_mold.f90 + impl/psi_z_convert_ell_from_coo.f90 + impl/psb_s_mv_dia_from_coo.f90 + impl/psb_d_hll_cssv.f90 + impl/psb_c_hll_rowsum.f90 + impl/psb_d_ell_mold.f90 + impl/psb_z_hll_csput.f90 + impl/psb_d_ell_colsum.f90 + impl/psb_s_ell_arwsum.f90 + impl/psb_c_hll_cssv.f90 + impl/psb_c_dia_reinit.f90 + impl/psi_z_xtr_dia_from_coo.f90 + impl/psb_z_hll_reallocate_nz.f90 + impl/psb_d_mv_ell_from_coo.f90 + impl/psb_d_ell_print.f90 + impl/psb_c_mv_ell_from_fmt.f90 + impl/psb_z_hll_csnmi.f90 + impl/psb_d_hll_maxval.f90 + impl/psb_z_ell_csmv.f90 + impl/psb_c_hdia_print.f90 + impl/psb_d_mv_hll_to_fmt.f90 + impl/psb_z_ell_cssm.f90 + impl/psb_s_dia_maxval.f90 + impl/psi_c_convert_dia_from_coo.f90 + impl/psb_c_cp_hdia_from_coo.f90 + impl/psb_s_dia_reallocate_nz.f90 + impl/psb_s_hll_csnmi.f90 + impl/psb_z_dia_scals.f90 + impl/psb_c_hll_csmm.f90 + impl/psb_z_ell_csgetptn.f90 + impl/psi_s_convert_hll_from_coo.f90 + impl/psb_d_cp_ell_from_fmt.f90 + impl/psb_z_hll_maxval.f90 + impl/psb_c_hll_reallocate_nz.f90 + impl/psb_c_mv_hdia_from_coo.f90 + impl/psb_c_ell_get_diag.f90 + impl/psb_s_cp_hll_to_coo.f90 + impl/psb_z_cp_hll_from_coo.f90 + impl/psb_s_dia_csmm.f90 + impl/psb_z_cp_hll_to_coo.f90 + impl/psi_c_xtr_ell_from_coo.f90 + impl/psb_z_hll_csmm.f90 + impl/psb_z_dia_reallocate_nz.f90 + impl/psb_d_dia_scal.f90 + impl/psb_s_mv_hll_to_fmt.f90 + impl/psb_d_hdia_mold.f90 + impl/psb_c_ell_maxval.f90 + impl/psb_z_hll_rowsum.f90 + impl/psb_z_ell_aclsum.f90 + impl/psb_d_cp_ell_to_coo.f90 + impl/psb_z_ell_print.f90 + impl/psb_d_ell_cssv.f90 + impl/psi_c_xtr_coo_from_dia.f90 + impl/psb_d_dia_csmm.f90 + impl/psi_s_convert_dia_from_coo.f90 + impl/psb_c_hll_csput.f90 + impl/psb_d_cp_hll_to_coo.f90 + impl/psb_s_ell_scals.f90 + impl/psb_s_ell_print.f90 + impl/psb_z_cp_hdia_to_coo.f90 + impl/psb_c_hll_mold.f90 + impl/psb_z_hll_print.f90 + impl/psb_s_cp_ell_from_coo.f90 + impl/psb_c_dns_mat_impl.f90 + impl/psb_c_mv_hll_from_fmt.f90 + impl/psb_z_hll_get_diag.f90 + impl/psb_z_cp_dia_from_coo.f90 + impl/psb_s_mv_hdia_from_coo.f90 + impl/psb_s_dia_colsum.f90 + impl/psb_z_cp_dia_to_coo.f90 + impl/psb_z_ell_allocate_mnnz.f90 + impl/psb_c_hll_colsum.f90 + impl/psb_s_ell_cssv.f90 + impl/psb_z_hll_csgetrow.f90 + impl/psb_d_ell_scals.f90 + impl/psb_c_dia_csmv.f90 + impl/psb_z_dia_csmm.f90 + impl/psb_s_ell_rowsum.f90 + impl/psb_c_cp_ell_from_fmt.f90 + impl/psb_z_dia_colsum.f90 + impl/psb_c_ell_mold.f90 + impl/psb_z_ell_maxval.f90 + impl/psb_z_ell_csgetblk.f90 + impl/psb_c_mv_ell_from_coo.f90 + impl/psb_c_mv_dia_from_coo.f90 + impl/psb_d_dia_csmv.f90 + impl/psb_z_hll_csgetblk.f90 + impl/psb_s_cp_hll_from_coo.f90 + impl/psb_d_mv_ell_to_fmt.f90 + impl/psb_c_cp_ell_to_fmt.f90 + impl/psb_z_ell_reinit.f90 + impl/psb_z_cp_hdia_from_coo.f90 + impl/psi_d_xtr_dia_from_coo.f90 + impl/psb_s_ell_scal.f90 + impl/psb_s_hll_rowsum.f90 + impl/psb_d_mv_hll_from_fmt.f90 + impl/psb_c_hdia_allocate_mnnz.f90 + impl/psb_s_ell_csmv.f90 + impl/psb_z_ell_scals.f90 + impl/psi_s_xtr_ell_from_coo.f90 + impl/psb_z_hdia_mold.f90 + impl/psb_s_cp_hdia_to_coo.f90 + impl/psb_s_hll_csput.f90 + impl/psb_s_hll_allocate_mnnz.f90 + impl/psb_z_ell_csmm.f90 + impl/psb_d_cp_dia_from_coo.f90 + impl/psb_s_ell_csgetptn.f90 + impl/psb_c_dia_csmm.f90 + impl/psb_z_ell_csput.f90 + impl/psb_s_cp_dia_to_coo.f90 + impl/psb_c_dia_scal.f90 + impl/psb_c_ell_print.f90 + impl/psb_z_hdia_print.f90 + impl/psb_d_ell_csnmi.f90 + impl/psb_d_mv_hdia_to_coo.f90 + impl/psb_c_mv_dia_to_coo.f90 + impl/psb_s_mv_hll_from_coo.f90 + impl/psb_d_hdia_print.f90 + impl/psb_s_hll_cssm.f90 + impl/psb_d_dia_colsum.f90 + impl/psb_d_mv_ell_from_fmt.f90 + impl/psb_d_hll_get_diag.f90 + impl/psb_z_dia_mold.f90 + impl/psb_z_dia_scal.f90 + impl/psb_d_hll_csgetptn.f90 + impl/psi_z_convert_dia_from_coo.f90 + impl/psb_s_dia_print.f90 + impl/psb_z_ell_arwsum.f90 + impl/psb_d_mv_dia_from_coo.f90 + impl/psi_c_xtr_dia_from_coo.f90 + impl/psb_d_hll_mold.f90 + impl/psi_s_xtr_coo_from_dia.f90 + impl/psb_z_dia_allocate_mnnz.f90 + impl/psb_z_cp_ell_from_coo.f90 + impl/psb_d_ell_allocate_mnnz.f90 + impl/psb_z_dia_csgetrow.f90 + impl/psb_s_ell_csmm.f90 + impl/psi_s_convert_ell_from_coo.f90 + impl/psb_c_dia_get_diag.f90 + impl/psb_c_hll_csgetptn.f90 + impl/psb_s_ell_colsum.f90 + impl/psb_d_dia_print.f90 + impl/psb_c_hll_cssm.f90 + impl/psb_s_dia_csmv.f90 + impl/psb_z_hdia_allocate_mnnz.f90 + impl/psb_z_ell_reallocate_nz.f90 + impl/psb_s_ell_cssm.f90 + impl/psb_c_hll_csgetrow.f90 + impl/psb_s_mv_hll_from_fmt.f90 + impl/psb_c_ell_colsum.f90 + impl/psb_c_ell_reinit.f90 + impl/psb_c_ell_cssm.f90 + impl/psb_c_ell_csput.f90 + impl/psb_s_hll_aclsum.f90 + impl/psb_s_hll_get_diag.f90 + impl/psb_z_ell_csnmi.f90 + impl/psb_s_hll_mold.f90 + impl/psb_c_ell_csnm1.f90 + impl/psb_s_dia_scal.f90 + impl/psb_s_hdia_mold.f90 + impl/psb_d_cp_hdia_to_coo.f90 + impl/psb_c_dia_csgetptn.f90 + impl/psb_z_mv_hll_from_fmt.f90 + impl/psb_c_ell_scals.f90 + impl/psb_z_hll_cssv.f90 + impl/psb_d_mv_dia_to_coo.f90 + impl/psb_z_mv_hdia_from_coo.f90 + impl/psb_d_dia_arwsum.f90 + impl/psb_d_hll_aclsum.f90 + impl/psb_c_hll_allocate_mnnz.f90 + impl/psb_z_hll_reinit.f90 + impl/psb_c_dia_scals.f90 + impl/psb_s_mv_ell_from_fmt.f90 + impl/psb_c_dia_allocate_mnnz.f90 + impl/psb_c_ell_csmm.f90 + impl/psb_d_ell_csmm.f90 + impl/psb_z_mv_dia_from_coo.f90 + impl/psb_c_ell_arwsum.f90 + impl/psb_s_ell_maxval.f90 + impl/psb_s_ell_reinit.f90 + impl/psb_z_ell_mold.f90 + impl/psb_s_cp_hdia_from_coo.f90 + impl/psb_s_hdia_csmv.f90 + impl/psb_s_ell_get_diag.f90 + impl/psb_s_ell_reallocate_nz.f90 + impl/psb_d_ell_csgetptn.f90 + impl/psb_c_hll_csgetblk.f90 + impl/psb_z_cp_hll_to_fmt.f90 + impl/psb_z_mv_hll_from_coo.f90 + impl/psb_c_hdia_mold.f90 + impl/psb_c_hdia_csmv.f90 + impl/psb_c_ell_csgetrow.f90 + impl/psb_d_hll_rowsum.f90 + impl/psb_z_ell_trim.f90 + impl/psb_d_hll_reinit.f90 + impl/psb_c_dia_rowsum.f90 + impl/psb_z_cp_ell_to_coo.f90 + impl/psb_d_dia_csgetrow.f90 + impl/psb_c_mv_hll_to_coo.f90 + impl/psb_d_hll_csnm1.f90 + impl/psb_z_hll_allocate_mnnz.f90 + impl/psb_d_ell_trim.f90 + impl/psi_z_xtr_coo_from_dia.f90 + impl/psb_z_ell_colsum.f90 + impl/psb_c_hll_get_diag.f90 + impl/psb_z_hll_colsum.f90 + impl/psb_d_dia_reinit.f90 + impl/psb_z_ell_rowsum.f90 + impl/psb_c_dia_mold.f90 + impl/psb_c_mv_ell_to_fmt.f90 + impl/psb_z_dia_csmv.f90 + impl/psb_d_ell_rowsum.f90 + impl/psb_s_ell_allocate_mnnz.f90 + impl/psb_z_ell_scal.f90 + impl/psb_d_hdia_allocate_mnnz.f90 + impl/psb_c_ell_trim.f90 + impl/psb_d_hdia_csmv.f90 + impl/psb_s_ell_mold.f90 + impl/psb_z_hll_mold.f90 + impl/psb_z_dia_reinit.f90 + impl/psb_c_ell_csgetblk.f90 + impl/psb_s_ell_trim.f90 + impl/psb_s_cp_dia_from_coo.f90 + impl/psb_s_hll_csmv.f90 + impl/psb_d_ell_arwsum.f90 + impl/psb_z_ell_cssv.f90 + impl/psb_c_dia_reallocate_nz.f90 + impl/psb_z_cp_ell_to_fmt.f90 + impl/psb_s_ell_csgetblk.f90 + impl/psb_d_mv_hll_from_coo.f90 + impl/psb_d_dns_mat_impl.f90 + impl/psb_z_dia_maxval.f90 + impl/psb_z_dns_mat_impl.f90 + impl/psi_d_xtr_coo_from_dia.f90 + impl/psi_c_convert_hll_from_coo.f90 + impl/psi_z_convert_hll_from_coo.f90 + impl/psb_z_mv_hdia_to_coo.f90 + impl/psb_d_cp_hll_from_fmt.f90 + impl/psb_c_ell_csnmi.f90 + impl/psb_d_ell_maxval.f90 + impl/psb_d_cp_ell_to_fmt.f90 + impl/psb_c_hll_aclsum.f90 + impl/psb_d_cp_dia_to_coo.f90 + impl/psb_s_dia_csgetptn.f90 + impl/psb_d_ell_get_diag.f90 + impl/psb_z_hll_scal.f90 + impl/psb_d_hll_csnmi.f90 + impl/psb_c_dia_csgetrow.f90 + impl/psb_z_mv_ell_to_coo.f90 + impl/psb_d_ell_csgetrow.f90 + impl/psb_s_dia_rowsum.f90 + impl/psb_z_ell_csnm1.f90 + impl/psb_s_dia_get_diag.f90 + impl/psb_z_mv_hll_to_fmt.f90 + impl/psb_d_dia_maxval.f90 + impl/psb_z_mv_hll_to_coo.f90 + impl/psb_z_dia_aclsum.f90 + impl/psb_c_hll_arwsum.f90 + impl/psb_c_ell_cssv.f90 + impl/psb_s_dia_scals.f90 + impl/psb_c_hll_csnmi.f90 + impl/psb_d_dia_scals.f90 + impl/psb_d_cp_hll_to_fmt.f90 + impl/psb_d_ell_csmv.f90 + impl/psb_z_dia_print.f90 + impl/psb_d_hll_scals.f90 + impl/psb_d_ell_csnm1.f90 + impl/psb_d_mv_hll_to_coo.f90 + impl/psb_z_hdia_csmv.f90 + impl/psb_d_cp_hll_from_coo.f90 + impl/psb_s_cp_hll_from_fmt.f90 + impl/psi_z_xtr_ell_from_coo.f90 + impl/psb_s_cp_ell_to_coo.f90 + impl/psb_d_ell_scal.f90 + impl/psb_c_mv_ell_to_coo.f90 + impl/psb_c_hll_csmv.f90 + impl/psb_s_hll_reinit.f90 + impl/psb_c_hll_scals.f90 + impl/psb_s_hll_csgetrow.f90 + impl/psb_s_cp_ell_from_fmt.f90 + impl/psb_d_hll_csgetrow.f90 + impl/psb_c_ell_allocate_mnnz.f90 + impl/psb_s_ell_csput.f90 + impl/psb_z_ell_csgetrow.f90 + impl/psb_s_hll_maxval.f90 + impl/psb_d_hll_print.f90 + impl/psb_s_ell_csnmi.f90 + impl/psb_s_dia_reinit.f90 + impl/psb_s_mv_hdia_to_coo.f90 + impl/psb_d_dia_aclsum.f90 + impl/psb_s_dia_aclsum.f90 + impl/psb_d_hll_csmv.f90 + impl/psb_z_dia_csgetptn.f90 + impl/psb_c_dia_aclsum.f90 + impl/psb_d_cp_ell_from_coo.f90 + impl/psb_s_ell_aclsum.f90 + impl/psb_c_ell_csgetptn.f90 + impl/psb_c_hll_print.f90 + impl/psb_s_hll_csgetblk.f90 + impl/psb_c_cp_hll_to_coo.f90 + impl/psb_z_hll_csmv.f90 + impl/psb_c_cp_hll_to_fmt.f90 + impl/psb_s_hll_cssv.f90 + impl/psb_s_dia_allocate_mnnz.f90 + impl/psb_s_dia_arwsum.f90 + impl/psb_d_hll_csput.f90 + impl/psb_s_hll_csmm.f90 + impl/psb_s_dns_mat_impl.f90 + impl/psb_c_ell_csmv.f90 + impl/psb_c_dia_arwsum.f90 + impl/psb_s_hll_scal.f90 + impl/psb_c_cp_hll_from_fmt.f90 + impl/psb_c_dia_colsum.f90 + impl/psb_z_hll_csnm1.f90 + impl/psi_d_convert_ell_from_coo.f90 + impl/psb_d_ell_cssm.f90 + impl/psb_c_dia_maxval.f90 + impl/psb_d_dia_rowsum.f90 + impl/psi_c_convert_ell_from_coo.f90 + impl/psb_d_hll_cssm.f90 + impl/psb_s_mv_ell_from_coo.f90 + impl/psi_d_convert_hll_from_coo.f90 + impl/psb_c_dia_print.f90 + impl/psb_c_ell_aclsum.f90 + impl/psb_z_hll_cssm.f90 + impl/psb_s_hll_colsum.f90 + impl/psb_z_hll_aclsum.f90 + impl/psb_z_dia_rowsum.f90 + impl/psb_d_ell_csput.f90 + impl/psb_d_hll_scal.f90 + impl/psb_z_mv_ell_from_fmt.f90 + impl/psb_z_hll_arwsum.f90 + impl/psb_c_mv_hll_from_coo.f90 + impl/psb_z_mv_dia_to_coo.f90 + impl/psb_d_hll_csgetblk.f90 + impl/psb_z_ell_get_diag.f90 + impl/psb_s_ell_csnm1.f90 + impl/psb_s_cp_ell_to_fmt.f90 + impl/psb_d_hll_csmm.f90 + impl/psb_c_cp_ell_from_coo.f90 + impl/psb_c_hll_reinit.f90 + impl/psb_c_cp_hdia_to_coo.f90 + impl/psb_s_hll_arwsum.f90 + psb_c_hdia_mat_mod.f90 + psi_ext_util_mod.f90 + psb_z_hdia_mat_mod.f90 + psi_z_ext_util_mod.f90 + psb_c_dns_mat_mod.f90 + psb_c_hll_mat_mod.f90 + psi_s_ext_util_mod.f90 + psb_c_dia_mat_mod.f90 + psi_c_ext_util_mod.f90 + psb_d_hdia_mat_mod.f90 + psi_i_ext_util_mod.f90 + psb_s_dia_mat_mod.f90 + psb_s_dns_mat_mod.f90 + psb_d_ell_mat_mod.f90 + psb_d_dia_mat_mod.f90 + psb_d_hll_mat_mod.f90 + psb_d_dns_mat_mod.f90 + psb_ext_mod.F90 + psb_c_ell_mat_mod.f90 + psb_s_ell_mat_mod.f90 + psb_s_hll_mat_mod.f90 + psi_d_ext_util_mod.f90 + psb_z_dia_mat_mod.f90 + psb_z_hll_mat_mod.f90 + psb_z_dns_mat_mod.f90 + psb_z_ell_mat_mod.f90 + ) +foreach(file IN LISTS PSB_ext_source_files) + list(APPEND ext_source_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach() diff --git a/krylov/CMakeLists.txt b/krylov/CMakeLists.txt new file mode 100644 index 00000000..9f2fe2d5 --- /dev/null +++ b/krylov/CMakeLists.txt @@ -0,0 +1,48 @@ +set(PSB_krylov_source_files + psb_base_krylov_conv_mod.f90 + psb_cbicg.f90 + psb_ccg.F90 + psb_ccgs.f90 + psb_ccgstab.f90 + psb_ccgstabl.f90 + psb_cfcg.F90 + psb_cgcr.f90 + psb_c_krylov_conv_mod.f90 + psb_ckrylov.f90 + psb_crgmres.f90 + psb_dbicg.f90 + psb_dcg.F90 + psb_dcgs.f90 + psb_dcgstab.f90 + psb_dcgstabl.f90 + psb_dfcg.F90 + psb_dgcr.f90 + psb_d_krylov_conv_mod.f90 + psb_dkrylov.f90 + psb_drgmres.f90 + psb_krylov_conv_mod.f90 + psb_krylov_mod.f90 + psb_sbicg.f90 + psb_scg.F90 + psb_scgs.f90 + psb_scgstab.f90 + psb_scgstabl.f90 + psb_sfcg.F90 + psb_sgcr.f90 + psb_s_krylov_conv_mod.f90 + psb_skrylov.f90 + psb_srgmres.f90 + psb_zbicg.f90 + psb_zcg.F90 + psb_zcgs.f90 + psb_zcgstab.f90 + psb_zcgstabl.f90 + psb_zfcg.F90 + psb_zgcr.f90 + psb_z_krylov_conv_mod.f90 + psb_zkrylov.f90 + psb_zrgmres.f90 + ) +foreach(file IN LISTS PSB_krylov_source_files) + list(APPEND krylov_source_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach() diff --git a/prec/CMakeLists.txt b/prec/CMakeLists.txt new file mode 100644 index 00000000..83bf7c82 --- /dev/null +++ b/prec/CMakeLists.txt @@ -0,0 +1,141 @@ + +set(PSB_prec_source_files + psb_c_diagprec.f90 + psb_prec_mod.f90 + psb_c_ainv_tools_mod.f90 + psb_s_ilu_fact_mod.f90 + psb_z_ainv_tools_mod.f90 + psb_s_ainv_fact_mod.f90 + psb_d_invt_fact_mod.f90 + psb_z_base_prec_mod.f90 + psb_s_invt_fact_mod.f90 + impl/psb_d_nullprec_impl.f90 + impl/psb_cprecinit.f90 + impl/psb_crwclip.f90 + impl/psb_z_sparsify.f90 + impl/psb_z_nullprec_impl.f90 + impl/psb_c_ilut_fact.f90 + impl/psb_d_sp_drop.f90 + impl/psb_c_ilu0_fact.f90 + impl/psb_d_prec_type_impl.f90 + impl/psb_s_invt_fact.f90 + impl/psb_z_ilut_fact.f90 + impl/psb_s_diagprec_impl.f90 + impl/psb_z_prec_type_impl.f90 + impl/psb_z_diagprec_impl.f90 + impl/psb_z_invk_fact.f90 + impl/psb_z_iluk_fact.f90 + impl/psb_s_ilut_fact.f90 + impl/psb_d_ilut_fact.f90 + impl/psb_dprecinit.f90 + impl/psb_s_sp_drop.f90 + impl/psb_s_iluk_fact.f90 + impl/psb_d_ainv_bld.f90 + impl/psb_d_sparsify.f90 + impl/psb_zprecinit.f90 + impl/psb_z_invt_fact.f90 + impl/psb_d_iluk_fact.f90 + impl/psb_c_sp_drop.f90 + impl/psb_z_bjacprec_impl.f90 + impl/psb_c_invk_fact.f90 + impl/psb_sprecinit.f90 + impl/psb_z_ilu0_fact.f90 + impl/psb_zprecbld.f90 + impl/psb_c_bjacprec_impl.f90 + impl/psb_s_ilu0_fact.f90 + impl/psb_s_prec_type_impl.f90 + impl/psb_s_nullprec_impl.f90 + impl/psb_s_bjacprec_impl.f90 + impl/psb_c_prec_type_impl.f90 + impl/psb_z_ainv_bld.f90 + impl/psb_s_invk_fact.f90 + impl/psb_z_sp_drop.f90 + impl/psb_c_diagprec_impl.f90 + impl/psb_d_invk_fact.f90 + impl/psb_c_invt_fact.f90 + impl/psb_dprecbld.f90 + impl/psb_c_iluk_fact.f90 + impl/psb_s_ainv_bld.f90 + impl/psb_c_nullprec_impl.f90 + impl/psb_c_sparsify.f90 + impl/psb_c_ainv_bld.f90 + impl/psb_s_sparsify.f90 + impl/psb_d_diagprec_impl.f90 + impl/psb_d_invt_fact.f90 + impl/psb_d_ilu0_fact.f90 + impl/psb_cprecbld.f90 + impl/psb_srwclip.f90 + impl/psb_d_bjacprec_impl.f90 + impl/psb_drwclip.f90 + impl/psb_zrwclip.f90 + impl/psb_sprecbld.f90 + psb_d_ainv_fact_mod.f90 + psb_z_prec_mod.f90 + psb_s_nullprec.f90 + psb_prec_type.f90 + psb_s_bjacprec.f90 + psb_z_diagprec.f90 + psb_z_bjacprec.f90 + psb_d_diagprec.f90 + psb_c_prec_mod.f90 + psb_d_nullprec.f90 + psb_s_diagprec.f90 + psb_c_prec_type.f90 + psb_c_ilu_fact_mod.f90 + psb_s_base_prec_mod.f90 + psb_c_nullprec.f90 + psb_c_invk_fact_mod.f90 + psb_z_invk_fact_mod.f90 + psb_z_prec_type.f90 + psb_c_invt_fact_mod.f90 + psb_s_prec_mod.f90 + psb_s_prec_type.f90 + psb_ainv_tools_mod.f90 + psb_d_invk_fact_mod.f90 + psb_c_bjacprec.f90 + psb_d_prec_type.f90 + psb_prec_const_mod.f90 + psb_s_ainv_tools_mod.f90 + psb_z_nullprec.f90 + psb_d_ainv_tools_mod.f90 + psb_d_bjacprec.f90 + psb_d_prec_mod.f90 + psb_c_base_prec_mod.f90 + psb_z_ainv_fact_mod.f90 + psb_d_base_prec_mod.f90 + psb_c_ainv_fact_mod.f90 + psb_s_invk_fact_mod.f90 + psb_d_ilu_fact_mod.f90 + psb_z_ilu_fact_mod.f90 + psb_z_invt_fact_mod.f90 + psb_d_biconjg_mod.F90 + impl/psb_zsparse_biconjg_llk_noth.F90 + impl/psb_ssparse_biconjg_s_llk.F90 + impl/psb_ssparse_biconjg_llk_noth.F90 + impl/psb_csparse_biconjg_s_llk.F90 + impl/psb_dsparse_biconjg_mlk.F90 + impl/psb_ssparse_biconjg_llk.F90 + impl/psb_csparse_biconjg_s_ft_llk.F90 + impl/psb_dsparse_biconjg_s_ft_llk.F90 + impl/psb_csparse_biconjg_llk_noth.F90 + impl/psb_dsparse_biconjg_s_llk.F90 + impl/psb_zsparse_biconjg_llk.F90 + impl/psb_csparse_biconjg_mlk.F90 + impl/psb_zsparse_biconjg_s_ft_llk.F90 + impl/psb_zsparse_biconjg_mlk.F90 + impl/psb_ssparse_biconjg_s_ft_llk.F90 + impl/psb_zsparse_biconjg_s_llk.F90 + impl/psb_dsparse_biconjg_llk.F90 + impl/psb_dsparse_biconjg_llk_noth.F90 + impl/psb_ssparse_biconjg_mlk.F90 + impl/psb_csparse_biconjg_llk.F90 + psb_biconjg_mod.F90 + psb_z_biconjg_mod.F90 + psb_s_biconjg_mod.F90 + psb_c_biconjg_mod.F90 + + ) + +foreach(file IN LISTS PSB_prec_source_files) + list(APPEND prec_source_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach() diff --git a/util/CMakeLists.txt b/util/CMakeLists.txt new file mode 100644 index 00000000..09152893 --- /dev/null +++ b/util/CMakeLists.txt @@ -0,0 +1,47 @@ +set(PSB_util_source_files + psb_s_mmio_impl.f90 + psb_s_mat_dist_mod.f90 + psb_renum_mod.f90 + psb_c_mmio_impl.f90 + psb_d_hbio_impl.f90 + psb_d_mat_dist_impl.f90 + psb_z_mat_dist_impl.f90 + psb_c_hbio_impl.f90 + psb_s_mat_dist_impl.f90 + psb_hbio_mod.f90 + psb_gps_mod.f90 + psb_z_renum_mod.f90 + psb_c_mat_dist_impl.f90 + psb_d_mat_dist_mod.f90 + psb_d_renum_mod.f90 + psb_s_renum_mod.f90 + psb_util_mod.f90 + psb_d_mmio_impl.f90 + psb_s_hbio_impl.f90 + psb_c_renum_mod.f90 + psb_mat_dist_mod.f90 + psb_z_mmio_impl.f90 + psb_c_mat_dist_mod.f90 + psb_blockpart_mod.f90 + psb_z_mat_dist_mod.f90 + psb_z_hbio_impl.f90 + psb_c_renum_impl.F90 + psb_partidx_mod.F90 + psi_build_mtpart.F90 + psb_z_renum_impl.F90 + psb_d_renum_impl.F90 + psb_i_mmio_impl.F90 + psb_metispart_mod.F90 + psb_mmio_mod.F90 + ) +foreach(file IN LISTS PSB_util_source_files) + list(APPEND util_source_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach() + +set(PSB_util_source_C_files + metis_int.c + psb_amd_order.c + ) +foreach(file IN LISTS PSB_util_source_C_files) + list(APPEND util_source_C_files ${CMAKE_CURRENT_LIST_DIR}/${file}) +endforeach()