Add CMake building for base, prec, ext, util, krylov, cbind

cmake
Luca Pepè Sciarria 2 months ago
parent 7857015923
commit 5b81cbac12

@ -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_<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_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 <integer>"
FULL_DOCS "Property to mark executable targets run as tests that they require at least <MIN_RANKS> 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} $<TARGET_OBJECTS:base_C>)
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
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules>
$<INSTALL_INTERFACE:modules>
${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
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules>
$<INSTALL_INTERFACE:modules>)
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
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules>
$<INSTALL_INTERFACE:modules>)
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
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules>
$<INSTALL_INTERFACE:modules>)
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} $<TARGET_OBJECTS:psb_util_C>)
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
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules>
$<INSTALL_INTERFACE:modules>)
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
# $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules>
# $<INSTALL_INTERFACE:modules>)
# Include directories for the cbind library
target_include_directories(cbind PUBLIC
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules> # Path for building
$<INSTALL_INTERFACE:modules> # 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
# $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules>
# $<INSTALL_INTERFACE:modules>)
# Include directories for the cbind library
#target_include_directories(cbind_C PUBLIC
# $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include> # Path for building
# $<INSTALL_INTERFACE:include> # 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)

@ -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()

@ -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()

@ -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()

@ -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()

@ -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)

@ -0,0 +1,79 @@
# CMake file to be called in script mode (${CMAKE_COMMAND} -P <file>) 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()

@ -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@" )

@ -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`

@ -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@

@ -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()

@ -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)

@ -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()

@ -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()

@ -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()

@ -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()
Loading…
Cancel
Save