hot fix: add -ffree-line-length-256 compilation flag for fortran

example.

.gitignore

@@ -5,6 +5,7 @@
 
 # header files generated
 cbind/*.h
+amgprec/amg_config.h
 
 # Make.inc generated
 /Make.inc

CMakeLists.txt

@@ -0,0 +1,542 @@
+cmake_minimum_required(VERSION 3.10)
+project(amg4psblas VERSION 1.0 LANGUAGES C CXX Fortran)
+
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
+
+
+set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to the PSBLAS installation
+directory")
+if(PSBLAS_INSTALL_DIR STREQUAL "")
+     message(FATAL_ERROR "Please specify the path to the PSBLAS installation directory using -DPSBLAS_INSTALL_DIR=<path> or set it in ccmake.")
+endif()
+
+
+# Check for the installation path for psblas
+#if(NOT DEFINED PSBLAS_INSTALL_DIR)
+#    message(FATAL_ERROR "Please specify the path to the psblas installation directory using -DPSBLAS_INSTALL_DIR=<path>")
+#endif()
+message(STATUS "psblas directory is ${PSBLAS_INSTALL_DIR};;")
+
+
+message(STATUS "PSBLAS DIRECTORY INC ${INCDIR}; MOD ${MODDIR}; LIB ${LIBDIR};")
+
+
+#set(CMAKE_CXX_STANDARD 17) # Set cxx standard for the c++ part of the library
+
+
+# Find the psblas package
+find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
+
+if(NOT psblas_FOUND)
+    message(FATAL_ERROR "PSBLAS not found!")
+else()
+    message(STATUS "Found PSBLAS: ${psblas_LIBRARIES}")
+endif()
+
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # Add -g to the Fortran compiler flags.
+    # We use STRING(APPEND) to ensure we don't overwrite other important flags.
+    string(APPEND CMAKE_Fortran_FLAGS " -g")
+    string(APPEND CMAKE_CXX_FLAGS " -g")
+    message(STATUS "Fortran and CXX debug flags added: -g")
+endif()
+
+    string(APPEND CMAKE_Fortran_FLAGS " -O2")
+    string(APPEND CMAKE_CXX_FLAGS " -O2")
+    message(STATUS "Fortran and CXX optimization flags added: -O2")
+
+
+
+# Set the include and library directories based on the provided path
+#set(TEST_INSTALLDIR "${PSBLAS_INSTALL_DIR}")
+set(INCDIR "${PSBLAS_INSTALL_DIR}/${PSB_CMAKE_INSTALL_INCLUDEDIR}")
+set(MODDIR "${PSBLAS_INSTALL_DIR}/${PSB_CMAKE_INSTALL_MODULDIR}")
+set(LIBDIR "${PSBLAS_INSTALL_DIR}/${PSB_CMAKE_INSTALL_LIBDIR}")
+
+
+# Include directories for the project
+include_directories(${PSBLAS_INSTALL_DIR} ${MPI_INCLUDE_PATH} )
+
+
+# Include directories for the Fortran compiler
+include_directories(${INCDIR} ${MODDIR} ${LIBDIR})
+
+
+
+message(STATUS "Using IPK size: ${PSB_IPK_SIZE}")
+message(STATUS "Using LPK size: ${PSB_LPK_SIZE}")
+
+# Add PSB_IPK/LPK flag only for fortran files.
+set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -DPSB_IPK${PSB_IPK_SIZE}")
+set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -DPSB_LPK${PSB_LPK_SIZE}")
+
+
+
+
+# Specify the installation directory
+
+#set(${CMAKE_INSTALL_LIBDIR} "lib")
+#message(STATUS "\t\t install libdir ${CMAKE_INSTALL_LIBDIR};")
+#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}")
+
+
+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}")
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+#set(CMAKE_INSTALL_LIBDIR "lib" CACHE STRING "Library install directory")
+#set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE STRING "Include directory")
+#set(CMAKE_INSTALL_MODULDIR "modules" CACHE STRING "Module directory")
+
+message(STATUS "Initial CMAKE_INSTALL_LIBDIR: ${CMAKE_INSTALL_LIBDIR}")
+set(AMG_CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})
+
+if(NOT AMG_CMAKE_INSTALL_LIBDIR)
+    message(STATUS "CMAKE_INSTALL_LIBDIR is set to default value lib")
+    #set(CMAKE_INSTALL_LIBDIR "lib" CACHE STRING "Library install directory" FORCE)
+    set(CMAKE_INSTALL_LIBDIR ${PSB_CMAKE_INSTALL_LIBDIR})
+    set(AMG_CMAKE_INSTALL_LIBDIR ${PSB_CMAKE_INSTALL_LIBDIR})
+else()
+    set(CMAKE_INSTALL_LIBDIR ${AMG_CMAKE_INSTALL_LIBDIR})
+    message(STATUS "CMAKE_INSTALL_LIBDIR is set to: ${CMAKE_INSTALL_LIBDIR}")
+endif()
+
+if(NOT AMG_CMAKE_INSTALL_INCLUDEDIR)
+    message(STATUS "CMAKE_INSTALL_INCLUDEDIR is set to default value lib")
+    #set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE STRING "Include directory" FORCE)
+    set(CMAKE_INSTALL_INCLUDEDIR ${PSB_CMAKE_INSTALL_INCLUDEDIR})
+    set(AMG_CMAKE_INSTALL_INCLUDEDIR ${PSB_CMAKE_INSTALL_INCLUDEDIR})
+else()
+    set(CMAKE_INSTALL_INCLUDEDIR ${AMG_CMAKE_INSTALL_INCLUDEDIR})
+    message(STATUS "CMAKE_INSTALL_INCLUDEDIR is set to: ${CMAKE_INSTALL_INCLUDEDIR}")
+endif()
+
+if(NOT AMG_CMAKE_INSTALL_MODULDIR)
+    message(STATUS "CMAKE_INSTALL_MODULDIR is set to default value lib")
+    #set(CMAKE_INSTALL_MODULDIR "modules" CACHE STRING "Modules directory" FORCE)
+    set(CMAKE_INSTALL_MODULDIR ${PSB_CMAKE_INSTALL_MODULDIR})
+    set(AMG_CMAKE_INSTALL_LIBDIR ${PSB_CMAKE_INSTALL_MODULDIR})
+else()
+    set(CMAKE_INSTALL_MODULDIR ${AMG_CMAKE_INSTALL_MODULDIR})
+    message(STATUS "CMAKE_INSTALL_MODULDIR is set to: ${CMAKE_INSTALL_MODULDIR}")
+endif()
+
+
+
+
+
+
+
+
+
+
+  
+
+
+#-----------------------------------------------------
+# Publicize installed location to other CMake projects
+#-----------------------------------------------------
+#install(EXPORT ${CMAKE_PROJECT_NAME}-targets
+#  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake"
+#)
+
+
+message(STATUS "NAME project ${CMAKE_PROJECT_NAME};")
+
+install(EXPORT ${CMAKE_PROJECT_NAME}-targets
+  FILE ${CMAKE_PROJECT_NAME}Config.cmake
+  NAMESPACE ${CMAKE_PROJECT_NAME}::
+  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 "${amg4psblas_VERSION}"
+  COMPATIBILITY SameMajorVersion
+  )
+
+configure_file("${CMAKE_SOURCE_DIR}/cmake/${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"
+    "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}Targets.cmake"
+  DESTINATION
+    "${CMAKE_INSTALL_LIBDIR}/cmake/${CMAKE_PROJECT_NAME}"
+)
+
+
+
+
+
+
+
+#------------------------------------------
+# 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
+#---------------------------------
+
+
+
+find_package( MPI REQUIRED Fortran C CXX )
+
+if(MPI_FOUND)
+  #-----------------------------------------------
+  # Work around an issue present on fedora systems
+  #-----------------------------------------------
+  if( (MPI_CXX_LINK_FLAGS MATCHES "noexecstack") OR (MPI_Fortran_LINK_FLAGS MATCHES "noexecstack") )
+    message ( WARNING
+      "The `noexecstack` linker flag was found in the MPI_<lang>_LINK_FLAGS variable. This is
+known to cause segmentation faults for some Fortran codes. See, e.g.,
+https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71729 or
+https://github.com/sourceryinstitute/OpenCoarrays/issues/317.
+
+`noexecstack` is being replaced with `execstack`"
+      )
+    string(REPLACE "noexecstack"
+      "execstack" MPI_CXX_LINK_FLAGS_FIXED ${MPI_CXX_LINK_FLAGS})
+    string(REPLACE "noexecstack"
+      "execstack" MPI_C_LINK_FLAGS_FIXED ${MPI_C_LINK_FLAGS})
+    string(REPLACE "noexecstack"
+      "execstack" MPI_Fortran_LINK_FLAGS_FIXED ${MPI_Fortran_LINK_FLAGS})
+    set(MPI_CXX_LINK_FLAGS "${MPI_CXX_LINK_FLAGS_FIXED}" CACHE STRING
+      "MPI CXX linking flags" FORCE)
+    set(MPI_C_LINK_FLAGS "${MPI_C_LINK_FLAGS_FIXED}" CACHE STRING
+      "MPI C linking flags" FORCE)
+    set(MPI_Fortran_LINK_FLAGS "${MPI_Fortran_LINK_FLAGS_FIXED}" CACHE STRING
+      "MPI Fortran linking flags" FORCE)
+      
+  endif()
+
+    message(STATUS "Found MPI: ${MPI_C_LIBRARIES} - ${MPI_CXX_LIBRARIES} - ${MPI_Fortran_LIBRARIES}")
+    
+    
+  #----------------
+  # Setup MPI compilers
+  #----------------  
+  set(CMAKE_C_COMPILER ${MPI_C_COMPILER} CACHE FILEPATH "C compiler" FORCE)
+  set(CMAKE_CXX_COMPILER ${MPI_CXX_COMPILER} CACHE FILEPATH "C++ compiler" FORCE)
+  set(CMAKE_Fortran_COMPILER ${MPI_Fortran_COMPILER} CACHE FILEPATH "Fortran compiler" FORCE)
+    
+  #----------------
+  # Setup MPI flags
+  #----------------
+  list(REMOVE_DUPLICATES MPI_Fortran_INCLUDE_PATH)
+  set(CMAKE_C_COMPILE_FLAGS ${CMAKE_C_COMPILE_FLAGS} ${MPI_C_COMPILE_FLAGS})
+  set(CMAKE_C_LINK_FLAGS ${CMAKE_C_LINK_FLAGS} ${MPI_C_LINK_FLAGS})
+  set(CMAKE_CXX_COMPILE_FLAGS ${CMAKE_CXX_COMPILE_FLAGS} ${MPI_CXX_COMPILE_FLAGS})
+  set(CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS} ${MPI_CXX_LINK_FLAGS})
+  set(CMAKE_Fortran_COMPILE_FLAGS ${CMAKE_Fortran_COMPILE_FLAGS} ${MPI_Fortran_COMPILE_FLAGS})
+  set(CMAKE_Fortran_LINK_FLAGS ${CMAKE_Fortran_LINK_FLAGS} ${MPI_Fortran_LINK_FLAGS})
+  include_directories(BEFORE ${MPI_C_INCLUDE_PATH} ${MPI_CXX_INCLUDE_PATH} ${MPI_Fortran_INCLUDE_PATH})
+message(STATUS "${MPI_C_INCLUDE_PATH}; ${MPI_Fortran_INCLUDE_PATH};; ${CMAKE_Fortran_LINK_FLAGS} ;")
+  if(MPI_Fortran_HAVE_F90_MODULE OR MPI_Fortran_HAVE_F08_MODULE)
+    add_compile_options(-DPSB_MPI_MOD)
+    message(STATUS "-DPSB_MPI_MOD")
+    #add_compile_options(-DSERIAL_MPI) # Is it right??
+    #message(STATUS "-DSERIAL_MPI")
+  endif()
+  set(PSB_SERIAL_MPI OFF)
+  
+else()
+  message(STATUS "MPI  not found, serial ahead")
+  add_compile_options(-DPSB_SERIAL_MPI)
+  add_compile_options(-DPSB_MPI_MOD)
+  set(PSB_SERIAL_MPI ON)
+  set(CSERIALMPI "#define PSB_SERIAL_MPI")
+endif()
+
+add_compile_options(-O3)
+add_compile_options($<$<COMPILE_LANGUAGE:Fortran>:-frecursive>)
+
+if(MPI_FOUND)
+  execute_process(COMMAND ${MPIEXEC} --version
+    OUTPUT_VARIABLE mpi_version_out)
+  if (mpi_version_out MATCHES "[Oo]pen[ -][Mm][Pp][Ii]")
+    message( STATUS "OpenMPI detected")
+    set ( openmpi true )
+  endif()
+  
+  
+  set(MPI_H_COPIED FALSE)
+  set(MPI_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include") # Define the include directory
+
+  # Create the include directory if it doesn't exist
+  file(MAKE_DIRECTORY "${MPI_INCLUDE_DIR}")
+
+  foreach(path IN LISTS MPI_INCLUDE_PATH)
+    # Construct the full path to the mpi.h file
+    set(mpi_h_path "${path}/mpi.h")
+    
+    # Check if the mpi.h file exists
+    if(EXISTS "${mpi_h_path}")
+        # Copy the mpi.h file to the include directory
+        file(COPY "${mpi_h_path}" DESTINATION "${MPI_INCLUDE_DIR}")
+        message(STATUS "Copied mpi.h from ${mpi_h_path} to ${MPI_INCLUDE_DIR}")
+        set(MPI_H_COPIED TRUE)
+        break()  # Exit the loop once we've copied the file
+    endif()
+  endforeach()
+
+  if(NOT MPI_H_COPIED)
+    message(WARNING "mpi.h not found in any of the specified paths: ${MPI_INCLUDE_PATH}")
+  endif()
+
+  # Add the created include directory to the project's include directories
+  #include_directories("${MPI_INCLUDE_DIR}")
+endif()
+
+
+
+#------------------------------------------
+# Configure the amg_config.h file
+#------------------------------------------
+
+message(STATUS "bin dir ${CMAKE_CURRENT_BINARY_DIR}; source dir ${CMAKE_CURRENT_SOURCE_DIR};;")
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/amgprec/amg_config.h.in 
+    ${CMAKE_CURRENT_BINARY_DIR}/include/amg_config.h 	
+    @ONLY  # Replace variables only
+)
+
+
+
+#---------------------------------------
+# Add the AMG libraries
+#---------------------------------------
+
+# In your CMakeLists.txt
+set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -ffree-line-length-256")
+
+message(STATUS "MPI_LIBRARIES: ${MPI_LIBRARIES}")
+message(STATUS "MPI_CXX_LIBRARIES: ${MPI_CXX_LIBRARIES}")
+
+
+
+include(${CMAKE_CURRENT_LIST_DIR}/amgprec/CMakeLists.txt)  # include amgprec_source_files and amgprec_source_C_files source files
+
+include_directories("${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}")
+
+add_library(amgprec_C OBJECT ${amgprec_source_C_files})
+add_library(amgprec_CPP OBJECT ${amgprec_source_CPP_files})
+
+target_link_libraries(amgprec_C
+  #PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
+  #PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
+  psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base
+  #${MPI_C_LIBRARIES}
+  )  #TODO  check actual libraries needed
+
+target_link_libraries(amgprec_CPP
+  #PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
+  #PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
+  psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base
+  stdc++
+  ${MPI_CXX_LIBRARIES})  #TODO  check actual libraries needed
+
+add_library(amgprec ${amgprec_source_files} $<TARGET_OBJECTS:amgprec_CPP> $<TARGET_OBJECTS:amgprec_C> )
+
+set_target_properties(amgprec
+  PROPERTIES
+  Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules"  
+  POSITION_INDEPENDENT_CODE TRUE
+  OUTPUT_NAME amg_prec
+  LINKER_LANGUAGE Fortran
+  )
+
+target_include_directories(amgprec PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules> 
+  $<INSTALL_INTERFACE:modules>)
+
+message(STATUS "include dir := ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}")
+
+#target_include_directories(base PUBLIC ${CMAKE_Fortran_MODULE_DIRECTORY})
+
+target_include_directories(amgprec PUBLIC ${INCDIR} ${MODDIR})
+target_link_libraries(amgprec
+  #PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
+  #PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
+  psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base
+  #${MPI_Fortran_LIBRARIES} ${MPI_CXX_LIBRARIES} ${MPI_C_LIBRARIES}
+  )  #TODO  check actual libraries needed
+
+
+
+
+
+
+
+include(${CMAKE_CURRENT_LIST_DIR}/cbind/CMakeLists.txt)  # include amgprec_source_files and amgprec_source_C_files source files
+
+
+foreach(path IN LISTS amgcbind_header_C_files)
+  # Copy the header file to the include directory
+  file(COPY "${path}" DESTINATION "${CMAKE_BINARY_DIR}/include")
+endforeach()
+
+
+add_library(amgcbind_C OBJECT ${amgcbind_source_C_files})
+
+target_link_libraries(amgcbind_C
+  #PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
+  #PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
+  psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base)  #TODO  check actual libraries needed
+
+add_library(amgcbind ${amgcbind_source_files} $<TARGET_OBJECTS:amgcbind_C>)
+
+set_target_properties(amgcbind
+  PROPERTIES
+  Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules"  
+  POSITION_INDEPENDENT_CODE TRUE
+  OUTPUT_NAME amg_cbind
+  LINKER_LANGUAGE Fortran
+  )
+
+target_include_directories(amgcbind PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules> 
+  $<INSTALL_INTERFACE:modules>)
+
+message(STATUS "include dir := ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}")
+
+#target_include_directories(base PUBLIC ${CMAKE_Fortran_MODULE_DIRECTORY})
+
+target_include_directories(amgcbind PUBLIC ${INCDIR} ${MODDIR})
+target_link_libraries(amgcbind
+  #PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
+  #PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
+  PUBLIC amgprec psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base)  #TODO  check actual libraries needed
+
+
+
+
+
+
+install(DIRECTORY ${CMAKE_BINARY_DIR}/include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  FILES_MATCHING PATTERN "*.h")
+
+install(DIRECTORY ${CMAKE_BINARY_DIR}/modules/ DESTINATION "${CMAKE_INSTALL_MODULDIR}"
+  FILES_MATCHING PATTERN "*.mod")
+
+
+
+
+
+
+# Install the library
+install(TARGETS amgprec amgcbind
+  EXPORT ${CMAKE_PROJECT_NAME}-targets
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+)
+
+
+
+if(WIN32) #TODO
+#  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()
+
+
+message(STATUS "install directory is ${CMAKE_INSTALL_LIBDIR};;;")
+
+# Step 2: Create the configuration file from the template
+#configure_package_config_file(
+#  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/amg4psblasConfig.cmake.in"
+#  "${CMAKE_CURRENT_BINARY_DIR}/amg4psblasConfig.cmake"
+#  INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/amg4psblas"
+#)
+
+# Step 3: Install the generated config files
+#install(FILES 
+#  "${CMAKE_CURRENT_BINARY_DIR}/amg4psblasConfig.cmake"
+#  "${CMAKE_CURRENT_BINARY_DIR}/amg4psblasConfigVersion.cmake"
+#  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/amg4psblas"
+#)
+
+# Step 4: Export targets so that the build directory can be used directly
+#export(
+#  EXPORT ${CMAKE_PROJECT_NAME}-targets
+#  FILE "${CMAKE_CURRENT_BINARY_DIR}/amg4psblasTargets.cmake"
+#    NAMESPACE psblas::
+#)
+export(
+  EXPORT ${CMAKE_PROJECT_NAME}-targets
+  FILE "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}Targets.cmake"
+    NAMESPACE ${CMAKE_PROJECT_NAME}::
+)
+
+#export(
+#  EXPORT ${CMAKE_PROJECT_NAME}-targets
+#  FILE "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}Targets.cmake"
+#    NAMESPACE ${CMAKE_PROJECT_NAME}::
+#)
+
+		
+ 
+
+# Set the installation directory for the test files
+set(INSTALL_TEST_DIR "${CMAKE_INSTALL_PREFIX}/samples" CACHE PATH "Installation directory for sample files")
+
+function(install_directory_recursive source_dir install_base_dir) # Function to install a directory and its subdirectories recursively
+    file(GLOB_RECURSE ALL_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/${source_dir}" "${source_dir}/*")
+
+    foreach(FILE_PATH IN LISTS ALL_FILES)
+        # Construct the full source and destination paths
+        set(FULL_SOURCE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${source_dir}/${FILE_PATH}")
+        set(FULL_INSTALL_PATH "${install_base_dir}/${FILE_PATH}")
+
+        # Check if it's a directory
+        if(IS_DIRECTORY "${FULL_SOURCE_PATH}")
+            # Create the directory in the install destination
+            file(MAKE_DIRECTORY "${FULL_INSTALL_PATH}")
+        else()
+            # Install the file
+            install(FILES "${FULL_SOURCE_PATH}" DESTINATION "${install_base_dir}" RENAME "${FILE_PATH}")
+        endif()
+    endforeach()
+endfunction()
+
+
+
+# Install test/fileread directory
+install_directory_recursive(samples/simple "${INSTALL_TEST_DIR}/simple")
+
+# Install test/pdegen directory
+install_directory_recursive(samples/advanced "${INSTALL_TEST_DIR}/advanced")
+
+
+
+message(STATUS "CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX} - ${PSB_CMAKE_INSTALL_PREFIX};")
+message(STATUS "CMAKE_INSTALL_LIBDIR: ${CMAKE_INSTALL_LIBDIR} - ${PSB_CMAKE_INSTALL_LIBDIR};")
+message(STATUS "CMAKE_INSTALL_INCLUDEDIR: ${CMAKE_INSTALL_INCLUDEDIR} - ${PSB_CMAKE_INSTALL_INCLUDEDIR};")
+message(STATUS "CMAKE_INSTALL_MODULDIR: ${CMAKE_INSTALL_MODULDIR} - ${PSB_CMAKE_INSTALL_MODULDIR};")
+

Makefile

@@ -21,7 +21,7 @@ amgp:
 cbnd: amgp
 	cd cbind && $(MAKE)  objs
 
-install: lib
+install: all
 	mkdir -p $(INSTALL_LIBDIR) &&\
 	   $(INSTALL_DATA) lib/*.a  $(INSTALL_LIBDIR)
 	mkdir -p  $(INSTALL_INCLUDEDIR) &&\
@@ -45,7 +45,7 @@ cleanlib:
 	(cd modules; /bin/rm -f *.a *$(.mod) *$(.fh))
 
 distclean: clean samplesclean
-	/bin/rm -fr Make.inc
+	/bin/rm -fr Make.inc amgprec/amg_config.h
 
 samplesclean: clean
 	(cd samples/simple/fileread && $(MAKE) clean)
@@ -57,5 +57,5 @@ check: all
 	make check -C samples/advanced/pdegen
 
 clean:  cleanlib
-	(cd amgprec && $(MAKE) clean)
-	(cd cbind && $(MAKE) clean)
+	(cd amgprec && $(MAKE) veryclean)
+	(cd cbind && $(MAKE) veryclean)

README.md

@@ -74,3 +74,9 @@ In the European project “Energy oriented Center of Excellence: toward exascale
 - Fabio Durastante       (University of Pisa and IAC-CNR, IT)
 - Salvatore Filippone    (University of Rome Tor Vergata and IAC-CNR, IT)
 
+**Contributors** (_roughly reverse cronological order_):
+
+- Luca       Pepè Sciarria
+- Andea      Di Iorio
+- Ambra	     Abdullahi Hassan
+- Alfredo    Buttari

amgprec/CMakeLists.txt

@@ -0,0 +1,907 @@
+set(AMG_amgprec_source_files
+  amg_s_ainv_solver.F90
+  amg_d_ainv_solver.F90
+  amg_z_base_solver_mod.f90
+  amg_z_slu_solver.F90
+  amg_z_gs_solver.f90
+  amg_d_ilu_fact_mod.f90
+#  amg_z_hybrid_aggregator_mod.F90
+  amg_c_base_smoother_mod.f90
+  amg_s_matchboxp_mod.F90
+  amg_c_gs_solver.f90
+  amg_z_prec_type.f90
+  amg_s_base_solver_mod.f90
+  amg_d_slu_solver.F90
+  amg_z_inner_mod.f90
+  amg_d_base_aggregator_mod.f90
+  amg_c_diag_solver.f90
+  amg_z_krm_solver.f90
+  impl/amg_zfile_prec_descr.f90
+  impl/amg_c_hierarchy_rebld.f90
+  impl/amg_dcprecset.F90
+  impl/amg_sprecinit.F90
+  impl/amg_cprecinit.F90
+  impl/amg_smlprec_aply.f90
+  impl/level/amg_s_base_onelev_map_rstr.F90
+  impl/level/amg_c_base_onelev_csetr.f90
+  impl/level/amg_d_base_onelev_map_rstr.F90
+  impl/level/amg_z_base_onelev_setsv.F90
+  impl/level/amg_d_base_onelev_descr.f90
+  impl/level/amg_d_base_onelev_setag.f90
+  impl/level/amg_s_base_onelev_dump.f90
+  impl/level/amg_s_base_onelev_build.f90
+  impl/level/amg_c_base_onelev_map_rstr.F90
+  impl/level/amg_z_base_onelev_memory_use.f90
+  impl/level/amg_s_base_onelev_map_prol.F90
+  impl/level/amg_d_base_onelev_csetc.F90
+  impl/level/amg_d_base_onelev_cnv.f90
+  impl/level/amg_c_base_onelev_setsv.F90
+  impl/level/amg_c_base_onelev_descr.f90
+  impl/level/amg_z_base_onelev_setsm.F90
+  impl/level/amg_d_base_onelev_csetr.f90
+  impl/level/amg_s_base_onelev_descr.f90
+  impl/level/amg_c_base_onelev_build.f90
+  impl/level/amg_c_base_onelev_setag.f90
+  impl/level/amg_c_base_onelev_free_smoothers.f90
+  impl/level/amg_c_base_onelev_memory_use.f90
+  impl/level/amg_s_base_onelev_csetr.f90
+  impl/level/amg_s_base_onelev_mat_asb.f90
+  impl/level/amg_c_base_onelev_free.f90
+  impl/level/amg_d_base_onelev_free_smoothers.f90
+  impl/level/amg_z_base_onelev_map_prol.F90
+  impl/level/amg_s_base_onelev_free_smoothers.f90
+  impl/level/amg_d_base_onelev_map_prol.F90
+  impl/level/amg_d_base_onelev_free.f90
+  impl/level/amg_z_base_onelev_cnv.f90
+  impl/level/amg_s_base_onelev_cseti.F90
+  impl/level/amg_s_base_onelev_csetc.F90
+  impl/level/amg_c_base_onelev_map_prol.F90
+  impl/level/amg_d_base_onelev_check.f90
+  impl/level/amg_d_base_onelev_setsm.F90
+  impl/level/amg_s_base_onelev_setsv.F90
+  impl/level/amg_z_base_onelev_mat_asb.f90
+  impl/level/amg_c_base_onelev_mat_asb.f90
+  impl/level/amg_z_base_onelev_cseti.F90
+  impl/level/amg_z_base_onelev_descr.f90
+  impl/level/amg_z_base_onelev_map_rstr.F90
+  impl/level/amg_z_base_onelev_check.f90
+  impl/level/amg_c_base_onelev_cnv.f90
+  impl/level/amg_z_base_onelev_build.f90
+  impl/level/amg_d_base_onelev_build.f90
+  impl/level/amg_c_base_onelev_cseti.F90
+  impl/level/amg_c_base_onelev_check.f90
+  impl/level/amg_s_base_onelev_check.f90
+  impl/level/amg_s_base_onelev_memory_use.f90
+  impl/level/amg_s_base_onelev_cnv.f90
+  impl/level/amg_z_base_onelev_setag.f90
+  impl/level/amg_s_base_onelev_free.f90
+  impl/level/amg_z_base_onelev_dump.f90
+  impl/level/amg_z_base_onelev_csetr.f90
+  impl/level/amg_z_base_onelev_free_smoothers.f90
+  impl/level/amg_c_base_onelev_csetc.F90
+  impl/level/amg_d_base_onelev_dump.f90
+  impl/level/amg_z_base_onelev_csetc.F90
+  impl/level/amg_d_base_onelev_setsv.F90
+  impl/level/amg_s_base_onelev_setsm.F90
+  impl/level/amg_d_base_onelev_mat_asb.f90
+  impl/level/amg_s_base_onelev_setag.f90
+  impl/level/amg_d_base_onelev_cseti.F90
+  impl/level/amg_d_base_onelev_memory_use.f90
+  impl/level/amg_c_base_onelev_setsm.F90
+  impl/level/amg_z_base_onelev_free.f90
+  impl/level/amg_c_base_onelev_dump.f90
+  impl/amg_z_hierarchy_bld.F90
+  impl/amg_zfile_prec_memory_use.f90
+  impl/amg_c_smoothers_bld.f90
+  impl/amg_dmlprec_aply.f90
+  impl/amg_cprecaply.f90
+  impl/amg_zcprecset.F90
+  impl/amg_z_smoothers_bld.f90
+  impl/amg_cprecset.F90
+  impl/amg_cfile_prec_memory_use.f90
+  impl/amg_z_extprol_bld.F90
+  impl/amg_sprecbld.f90
+  impl/amg_s_hierarchy_rebld.f90
+  impl/amg_s_smoothers_bld.f90
+  impl/amg_dprecinit.F90
+  impl/amg_zmlprec_bld.f90
+  impl/amg_smlprec_bld.f90
+  impl/amg_sfile_prec_memory_use.f90
+  impl/amg_dprecaply.f90
+  impl/amg_zprecbld.f90
+  impl/amg_z_hierarchy_rebld.f90
+  impl/amg_c_extprol_bld.F90
+  impl/amg_zprecaply.f90
+  impl/amg_s_extprol_bld.F90
+  impl/amg_dfile_prec_memory_use.f90
+  impl/solver/amg_z_invt_solver_clone_settings.f90
+  impl/solver/amg_c_gs_solver_clear_data.f90
+  impl/solver/amg_d_base_solver_apply.f90
+  impl/solver/amg_s_ilu_solver_apply.f90
+  impl/solver/amg_d_jac_solver_apply.f90
+  impl/solver/amg_z_base_solver_csetr.f90
+  impl/solver/amg_z_ilu_solver_dmp.f90
+  impl/solver/amg_d_diag_solver_dmp.f90
+  impl/solver/amg_c_invt_solver_check.f90
+  impl/solver/amg_z_base_solver_descr.f90
+  impl/solver/amg_d_mumps_solver_apply_vect.F90
+  impl/solver/amg_d_l1_jac_solver_bld.f90
+  impl/solver/amg_z_base_solver_cseti.f90
+  impl/solver/amg_d_ainv_solver_check.f90
+  impl/solver/amg_s_invt_solver_bld.f90
+  impl/solver/amg_z_ainv_solver_clone_settings.f90
+  impl/solver/amg_c_bwgs_solver_bld.f90
+  impl/solver/amg_z_base_ainv_solver_apply_vect.f90
+  impl/solver/amg_d_id_solver_apply.f90
+  impl/solver/amg_s_base_solver_apply_vect.f90
+  impl/solver/amg_s_base_solver_clone.f90
+  impl/solver/amg_c_base_ainv_update_a.f90
+  impl/solver/amg_s_id_solver_clone.f90
+  impl/solver/amg_s_invk_solver_clone_settings.f90
+  impl/solver/amg_z_ainv_solver_bld.f90
+  impl/solver/amg_z_diag_solver_cnv.f90
+  impl/solver/amg_d_mumps_solver_bld.F90
+  impl/solver/amg_d_jac_solver_clear_data.f90
+  impl/solver/amg_c_jac_solver_clone_settings.f90
+  impl/solver/amg_z_gs_solver_clear_data.f90
+  impl/solver/amg_c_ainv_solver_cseti.f90
+  impl/solver/amg_z_base_solver_cnv.f90
+  impl/solver/amg_s_bwgs_solver_bld.f90
+  impl/solver/amg_s_id_solver_apply_vect.f90
+  impl/solver/amg_z_jac_solver_clone.f90
+  impl/solver/amg_z_ainv_solver_check.f90
+  impl/solver/amg_d_ilu_solver_clear_data.f90
+  impl/solver/amg_s_invk_solver_cseti.f90
+  impl/solver/amg_s_ainv_solver_csetc.f90
+  impl/solver/amg_z_base_ainv_solver_apply.f90
+  impl/solver/amg_c_gs_solver_clone.f90
+  impl/solver/amg_d_base_ainv_solver_apply.f90
+#  impl/solver/amg_d_ainv_solver_setr.f90
+  impl/solver/amg_d_invt_solver_clone.f90
+  impl/solver/amg_d_gs_solver_apply_vect.f90
+  impl/solver/amg_s_base_solver_dmp.f90
+  impl/solver/amg_d_ainv_solver_descr.f90
+  impl/solver/amg_d_jac_solver_clone_settings.f90
+  impl/solver/amg_z_base_solver_check.f90
+  impl/solver/amg_z_diag_solver_clone.f90
+  impl/solver/amg_s_invk_solver_clone.f90
+#  impl/solver/amg_d_ainv_solver_setc.f90
+  impl/solver/amg_d_gs_solver_clear_data.f90
+  impl/solver/amg_c_invt_solver_bld.f90
+  impl/solver/amg_s_jac_solver_clear_data.f90
+  impl/solver/amg_d_jac_solver_dmp.f90
+  
+  impl/solver/amg_c_base_solver_dmp.f90
+  impl/solver/amg_s_diag_solver_dmp.f90
+  impl/solver/amg_d_invt_solver_check.f90
+  impl/solver/amg_c_ilu_solver_clear_data.f90
+  impl/solver/amg_z_invt_solver_descr.f90
+  impl/solver/amg_d_diag_solver_clone.f90
+  impl/solver/amg_s_jac_solver_bld.f90
+  impl/solver/amg_s_mumps_solver_apply.F90
+  impl/solver/amg_z_jac_solver_clone_settings.f90
+#  impl/solver/amg_d_invt_solver_seti.f90
+  impl/solver/amg_s_base_ainv_solver_apply_vect.f90
+  impl/solver/amg_z_diag_solver_apply.f90
+  impl/solver/amg_s_base_solver_free.f90
+  impl/solver/amg_d_ainv_solver_clone.f90
+  impl/solver/amg_s_krm_solver_impl.f90
+#  impl/solver/amg_d_ainv_solver_seti.f90
+  impl/solver/amg_z_ainv_solver_clone.f90
+  impl/solver/amg_d_base_ainv_solver_free.f90
+#  impl/solver/amg_c_invk_solver_seti.f90
+  impl/solver/amg_s_ilu_solver_dmp.f90
+  impl/solver/amg_z_base_solver_apply.f90
+  impl/solver/amg_d_ilu_solver_apply_vect.f90
+  impl/solver/amg_z_jac_solver_dmp.f90
+  impl/solver/amg_c_base_ainv_solver_cnv.f90
+  impl/solver/amg_s_gs_solver_cnv.f90
+  impl/solver/amg_s_id_solver_apply.f90
+  impl/solver/amg_d_jac_solver_apply_vect.f90
+  impl/solver/amg_s_base_solver_bld.f90
+  impl/solver/amg_z_base_solver_csetc.f90
+  impl/solver/amg_d_gs_solver_cnv.f90
+  impl/solver/amg_d_bwgs_solver_apply.f90
+  impl/solver/amg_c_diag_solver_dmp.f90
+  impl/solver/amg_d_ilu_solver_dmp.f90
+  impl/solver/amg_s_base_solver_check.f90
+  impl/solver/amg_c_invk_solver_clone.f90
+  impl/solver/amg_d_invk_solver_check.f90
+  impl/solver/amg_z_ilu_solver_clone.f90
+  impl/solver/amg_d_base_solver_cseti.f90
+  impl/solver/amg_c_base_solver_bld.f90
+  impl/solver/amg_z_jac_solver_apply_vect.f90
+  impl/solver/amg_z_id_solver_apply.f90
+  impl/solver/amg_d_base_solver_bld.f90
+#  impl/solver/amg_s_ainv_solver_seti.f90
+  impl/solver/amg_z_jac_solver_bld.f90
+  impl/solver/amg_z_base_solver_apply_vect.f90
+  impl/solver/amg_d_base_solver_clone.f90
+  impl/solver/amg_d_ainv_solver_csetr.f90
+  impl/solver/amg_s_invt_solver_cseti.f90
+  impl/solver/amg_c_id_solver_apply_vect.f90
+  impl/solver/amg_s_mumps_solver_apply_vect.F90
+  impl/solver/amg_z_ilu_solver_apply.f90
+  impl/solver/amg_c_diag_solver_apply_vect.f90
+  impl/solver/amg_s_gs_solver_dmp.f90
+  impl/solver/amg_z_base_ainv_solver_dmp.f90
+  impl/solver/amg_c_diag_solver_cnv.f90
+#  impl/solver/amg_z_invt_solver_setr.f90
+  impl/solver/amg_z_diag_solver_apply_vect.f90
+  impl/solver/amg_d_ainv_solver_cseti.f90
+  impl/solver/amg_z_ilu_solver_clear_data.f90
+  impl/solver/amg_d_base_solver_csetc.f90
+  impl/solver/amg_c_invk_solver_descr.f90
+  impl/solver/amg_d_invt_solver_csetr.f90
+  impl/solver/amg_d_invt_solver_cseti.f90
+  impl/solver/amg_z_invk_solver_bld.f90
+  impl/solver/amg_s_jac_solver_clone.f90
+  impl/solver/amg_d_bwgs_solver_bld.f90
+  impl/solver/amg_z_diag_solver_bld.f90
+  impl/solver/amg_s_l1_jac_solver_bld.f90
+  impl/solver/amg_s_invt_solver_descr.f90
+  impl/solver/amg_s_ilu_solver_bld.f90
+  impl/solver/amg_c_gs_solver_clone_settings.f90
+  impl/solver/amg_c_jac_solver_bld.f90
+  impl/solver/amg_d_gs_solver_clone_settings.f90
+  impl/solver/amg_d_base_solver_descr.f90
+  impl/solver/amg_d_base_solver_dmp.f90
+  impl/solver/amg_c_ainv_solver_bld.f90
+  impl/solver/amg_s_invt_solver_check.f90
+  impl/solver/amg_z_gs_solver_apply_vect.f90
+  impl/solver/amg_z_ainv_solver_descr.f90
+#  impl/solver/amg_c_invt_solver_seti.f90
+  impl/solver/amg_c_base_solver_apply.f90
+  impl/solver/amg_z_gs_solver_dmp.f90
+  impl/solver/amg_d_ainv_solver_clone_settings.f90
+  impl/solver/amg_c_id_solver_apply.f90
+  impl/solver/amg_z_base_solver_clone.f90
+  impl/solver/amg_s_invk_solver_check.f90
+  impl/solver/amg_c_gs_solver_bld.f90
+  impl/solver/amg_s_ilu_solver_cnv.f90
+  impl/solver/amg_z_ainv_solver_csetc.f90
+  impl/solver/amg_s_ainv_solver_clone_settings.f90
+  impl/solver/amg_c_base_ainv_solver_apply_vect.f90
+  impl/solver/amg_s_diag_solver_apply.f90
+  impl/solver/amg_s_base_ainv_update_a.f90
+  impl/solver/amg_c_base_solver_csetc.f90
+  impl/solver/amg_c_jac_solver_clone.f90
+  impl/solver/amg_c_base_solver_descr.f90
+  impl/solver/amg_c_invt_solver_clone.f90
+  impl/solver/amg_c_ilu_solver_bld.f90
+  impl/solver/amg_d_base_ainv_solver_apply_vect.f90
+  impl/solver/amg_d_base_solver_apply_vect.f90
+  impl/solver/amg_z_invt_solver_check.f90
+  impl/solver/amg_c_base_solver_cseti.f90
+  impl/solver/amg_s_jac_solver_dmp.f90
+#  impl/solver/amg_s_invk_solver_seti.f90
+  impl/solver/amg_s_ainv_solver_check.f90
+  impl/solver/amg_d_base_solver_clear_data.f90
+  impl/solver/amg_z_gs_solver_clone_settings.f90
+  impl/solver/amg_c_invk_solver_check.f90
+  impl/solver/amg_s_base_solver_cseti.f90
+  impl/solver/amg_z_base_ainv_solver_free.f90
+  impl/solver/amg_z_invk_solver_clone_settings.f90
+  impl/solver/amg_c_base_ainv_solver_dmp.f90
+  impl/solver/amg_s_gs_solver_clear_data.f90
+  impl/solver/amg_s_base_ainv_solver_apply.f90
+  impl/solver/amg_c_base_solver_apply_vect.f90
+  impl/solver/amg_d_diag_solver_cnv.f90
+  impl/solver/amg_d_id_solver_apply_vect.f90
+  impl/solver/amg_z_base_solver_bld.f90
+  impl/solver/amg_z_base_solver_dmp.f90
+  impl/solver/amg_d_invt_solver_clone_settings.f90
+  impl/solver/amg_c_diag_solver_clone.f90
+  impl/solver/amg_z_gs_solver_apply.f90
+  impl/solver/amg_c_invt_solver_clone_settings.f90
+  impl/solver/amg_z_base_solver_free.f90
+  impl/solver/amg_d_diag_solver_clear_data.f90
+  impl/solver/amg_d_ilu_solver_clone_settings.f90
+#  impl/solver/amg_z_invt_solver_seti.f90
+#  impl/solver/amg_z_ainv_solver_seti.f90
+  impl/solver/amg_c_diag_solver_apply.f90
+  impl/solver/amg_d_base_ainv_solver_dmp.f90
+  impl/solver/amg_c_invt_solver_csetr.f90
+#  impl/solver/amg_c_invt_solver_setr.f90
+  impl/solver/amg_c_jac_solver_clear_data.f90
+  impl/solver/amg_c_invk_solver_bld.f90
+  impl/solver/amg_c_ainv_solver_csetc.f90
+  impl/solver/amg_s_ainv_solver_cseti.f90
+  impl/solver/amg_z_base_solver_clear_data.f90
+  impl/solver/amg_z_invk_solver_check.f90
+  impl/solver/amg_c_diag_solver_bld.f90
+  impl/solver/amg_d_invk_solver_clone_settings.f90
+  impl/solver/amg_s_ainv_solver_clone.f90
+  impl/solver/amg_s_diag_solver_clear_data.f90
+  impl/solver/amg_d_gs_solver_clone.f90
+  impl/solver/amg_s_base_solver_csetr.f90
+  impl/solver/amg_c_ilu_solver_dmp.f90
+  impl/solver/amg_c_base_solver_cnv.f90
+#  impl/solver/amg_z_ainv_solver_setc.f90
+  impl/solver/amg_z_jac_solver_apply.f90
+  impl/solver/amg_s_ainv_solver_descr.f90
+  impl/solver/amg_z_base_ainv_solver_cnv.f90
+  impl/solver/amg_c_ilu_solver_apply.f90
+  impl/solver/amg_c_ilu_solver_cnv.f90
+  impl/solver/amg_z_bwgs_solver_bld.f90
+  impl/solver/amg_c_base_ainv_solver_free.f90
+  impl/solver/amg_s_base_solver_clone_settings.f90
+  impl/solver/amg_z_invt_solver_bld.f90
+  impl/solver/amg_s_base_ainv_solver_free.f90
+  impl/solver/amg_s_base_solver_clear_data.f90
+  impl/solver/amg_s_invt_solver_csetr.f90
+  impl/solver/amg_d_diag_solver_apply_vect.f90
+  impl/solver/amg_s_diag_solver_bld.f90
+  impl/solver/amg_s_diag_solver_cnv.f90
+  impl/solver/amg_d_diag_solver_apply.f90
+  impl/solver/amg_d_invk_solver_descr.f90
+  impl/solver/amg_z_mumps_solver_apply.F90
+  impl/solver/amg_s_base_solver_descr.f90
+  impl/solver/amg_c_jac_solver_apply_vect.f90
+  impl/solver/amg_s_base_ainv_solver_dmp.f90
+  impl/solver/amg_z_krm_solver_impl.f90
+  impl/solver/amg_z_invt_solver_csetr.f90
+  impl/solver/amg_c_ainv_solver_check.f90
+#  impl/solver/amg_s_invt_solver_seti.f90
+  impl/solver/amg_z_ainv_solver_cseti.f90
+  impl/solver/amg_z_invk_solver_clone.f90
+  impl/solver/amg_s_base_solver_csetc.f90
+  impl/solver/amg_z_bwgs_solver_apply_vect.f90
+  impl/solver/amg_c_bwgs_solver_apply.f90
+  impl/solver/amg_c_base_solver_csetr.f90
+  impl/solver/amg_c_invk_solver_cseti.f90
+  impl/solver/amg_d_krm_solver_impl.f90
+  impl/solver/amg_s_invk_solver_bld.f90
+  impl/solver/amg_c_mumps_solver_apply.F90
+  impl/solver/amg_z_jac_solver_cnv.f90
+#  impl/solver/amg_s_ainv_solver_setr.f90
+  impl/solver/amg_d_gs_solver_bld.f90
+  impl/solver/amg_c_ilu_solver_clone_settings.f90
+  impl/solver/amg_z_base_solver_clone_settings.f90
+  impl/solver/amg_d_ilu_solver_clone.f90
+  impl/solver/amg_c_ilu_solver_clone.f90
+  impl/solver/amg_d_ainv_solver_bld.f90
+  impl/solver/amg_c_gs_solver_apply.f90
+  impl/solver/amg_z_mumps_solver_apply_vect.F90
+  impl/solver/amg_c_ainv_solver_clone.f90
+  impl/solver/amg_c_base_solver_clear_data.f90
+  impl/solver/amg_z_diag_solver_dmp.f90
+  impl/solver/amg_z_id_solver_apply_vect.f90
+  impl/solver/amg_d_ilu_solver_bld.f90
+  impl/solver/amg_s_base_solver_apply.f90
+  impl/solver/amg_s_ainv_solver_csetr.f90
+  impl/solver/amg_z_ilu_solver_cnv.f90
+  impl/solver/amg_s_invk_solver_descr.f90
+  impl/solver/amg_d_jac_solver_bld.f90
+  impl/solver/amg_z_invk_solver_cseti.f90
+  impl/solver/amg_z_id_solver_clone.f90
+  impl/solver/amg_d_id_solver_clone.f90
+  impl/solver/amg_z_diag_solver_clear_data.f90
+  impl/solver/amg_s_gs_solver_bld.f90
+  impl/solver/amg_s_bwgs_solver_apply.f90
+  impl/solver/amg_s_gs_solver_clone.f90
+  impl/solver/amg_s_jac_solver_apply.f90
+  impl/solver/amg_z_ilu_solver_clone_settings.f90
+  impl/solver/amg_c_mumps_solver_bld.F90
+  impl/solver/amg_d_mumps_solver_apply.F90
+#  impl/solver/amg_s_ainv_solver_setc.f90
+  impl/solver/amg_d_base_solver_cnv.f90
+  impl/solver/amg_s_ilu_solver_clear_data.f90
+  impl/solver/amg_d_bwgs_solver_apply_vect.f90
+  impl/solver/amg_s_jac_solver_apply_vect.f90
+  impl/solver/amg_c_invk_solver_clone_settings.f90
+  impl/solver/amg_c_base_solver_clone_settings.f90
+  impl/solver/amg_z_gs_solver_cnv.f90
+  impl/solver/amg_s_invt_solver_clone.f90
+#  impl/solver/amg_z_invk_solver_seti.f90
+  impl/solver/amg_c_ainv_solver_csetr.f90
+  impl/solver/amg_c_jac_solver_apply.f90
+  impl/solver/amg_c_gs_solver_dmp.f90
+  impl/solver/amg_z_ilu_solver_bld.f90
+  impl/solver/amg_c_invt_solver_descr.f90
+  impl/solver/amg_z_invt_solver_clone.f90
+  impl/solver/amg_d_base_ainv_update_a.f90
+  impl/solver/amg_c_base_solver_clone.f90
+  impl/solver/amg_s_diag_solver_clone.f90
+  impl/solver/amg_d_invt_solver_bld.f90
+#  impl/solver/amg_c_ainv_solver_setc.f90
+  impl/solver/amg_d_gs_solver_dmp.f90
+  impl/solver/amg_s_gs_solver_apply.f90
+  impl/solver/amg_d_jac_solver_clone.f90
+  impl/solver/amg_z_jac_solver_clear_data.f90
+  impl/solver/amg_c_invt_solver_cseti.f90
+  impl/solver/amg_d_ilu_solver_apply.f90
+#  impl/solver/amg_c_ainv_solver_setr.f90
+  impl/solver/amg_c_gs_solver_cnv.f90
+  impl/solver/amg_c_diag_solver_clear_data.f90
+  impl/solver/amg_c_base_solver_check.f90
+  impl/solver/amg_c_base_solver_free.f90
+  impl/solver/amg_z_invt_solver_cseti.f90
+  impl/solver/amg_d_base_solver_check.f90
+  impl/solver/amg_d_invk_solver_clone.f90
+  impl/solver/amg_c_krm_solver_impl.f90
+  impl/solver/amg_d_base_ainv_solver_cnv.f90
+  impl/solver/amg_d_invk_solver_cseti.f90
+  impl/solver/amg_z_mumps_solver_bld.F90
+  impl/solver/amg_z_gs_solver_bld.f90
+#  impl/solver/amg_z_ainv_solver_setr.f90
+  impl/solver/amg_s_gs_solver_apply_vect.f90
+  impl/solver/amg_s_jac_solver_clone_settings.f90
+  impl/solver/amg_z_gs_solver_clone.f90
+  impl/solver/amg_c_gs_solver_apply_vect.f90
+  impl/solver/amg_d_base_solver_csetr.f90
+  impl/solver/amg_s_ainv_solver_bld.f90
+  impl/solver/amg_z_l1_jac_solver_bld.f90
+  impl/solver/amg_z_base_ainv_update_a.f90
+  impl/solver/amg_z_ainv_solver_csetr.f90
+  impl/solver/amg_s_ilu_solver_apply_vect.f90
+#  impl/solver/amg_s_invt_solver_setr.f90
+#  impl/solver/amg_d_invt_solver_setr.f90
+  impl/solver/amg_d_invk_solver_bld.f90
+  impl/solver/amg_s_jac_solver_cnv.f90
+  impl/solver/amg_z_bwgs_solver_apply.f90
+  impl/solver/amg_s_bwgs_solver_apply_vect.f90
+#  impl/solver/amg_d_invk_solver_seti.f90
+  impl/solver/amg_d_ilu_solver_cnv.f90
+  impl/solver/amg_s_mumps_solver_bld.F90
+  impl/solver/amg_s_gs_solver_clone_settings.f90
+  impl/solver/amg_c_jac_solver_dmp.f90
+  impl/solver/amg_d_jac_solver_cnv.f90
+  impl/solver/amg_c_ilu_solver_apply_vect.f90
+  impl/solver/amg_c_mumps_solver_apply_vect.F90
+  impl/solver/amg_z_ilu_solver_apply_vect.f90
+  impl/solver/amg_s_ilu_solver_clone_settings.f90
+  impl/solver/amg_c_ainv_solver_clone_settings.f90
+#  impl/solver/amg_c_ainv_solver_seti.f90
+  impl/solver/amg_s_ilu_solver_clone.f90
+  impl/solver/amg_d_diag_solver_bld.f90
+  impl/solver/amg_c_l1_jac_solver_bld.f90
+  impl/solver/amg_c_bwgs_solver_apply_vect.f90
+  impl/solver/amg_c_jac_solver_cnv.f90
+  impl/solver/amg_c_id_solver_clone.f90
+  impl/solver/amg_d_gs_solver_apply.f90
+  impl/solver/amg_z_invk_solver_descr.f90
+  impl/solver/amg_s_diag_solver_apply_vect.f90
+  impl/solver/amg_s_base_solver_cnv.f90
+  impl/solver/amg_d_base_solver_clone_settings.f90
+  impl/solver/amg_s_invt_solver_clone_settings.f90
+  impl/solver/amg_d_ainv_solver_csetc.f90
+  impl/solver/amg_d_invt_solver_descr.f90
+  impl/solver/amg_d_base_solver_free.f90
+  impl/solver/amg_c_base_ainv_solver_apply.f90
+  impl/solver/amg_s_base_ainv_solver_cnv.f90
+  impl/solver/amg_c_ainv_solver_descr.f90
+  impl/amg_sfile_prec_descr.f90
+  impl/amg_zprecinit.F90
+  impl/amg_dprecbld.f90
+  impl/amg_sprecaply.f90
+  impl/amg_cprecbld.f90
+  impl/amg_cfile_prec_descr.f90
+  impl/amg_s_hierarchy_bld.F90
+  impl/amg_dfile_prec_descr.f90
+  impl/amg_ccprecset.F90
+  impl/amg_d_hierarchy_bld.F90
+  impl/amg_c_hierarchy_bld.F90
+  impl/smoother/amg_d_base_smoother_clone_settings.f90
+  impl/smoother/amg_d_as_smoother_check.f90
+  impl/smoother/amg_c_l1_jac_smoother_clone.f90
+  impl/smoother/amg_z_l1_jac_smoother_bld.f90
+  impl/smoother/amg_s_poly_smoother_clear_data.f90
+  impl/smoother/amg_s_poly_smoother_apply_vect.f90
+  impl/smoother/amg_z_jac_smoother_clone_settings.f90
+  impl/smoother/amg_s_poly_smoother_csetc.f90
+  impl/smoother/amg_s_as_smoother_prol_a.f90
+  impl/smoother/amg_s_base_smoother_csetc.f90
+  impl/smoother/amg_s_as_smoother_apply.f90
+  impl/smoother/amg_z_base_smoother_csetr.f90
+  impl/smoother/amg_c_jac_smoother_apply.f90
+  impl/smoother/amg_s_base_smoother_clone.f90
+  impl/smoother/amg_d_jac_smoother_dmp.f90
+  impl/smoother/amg_z_base_smoother_cnv.f90
+  impl/smoother/amg_s_jac_smoother_apply.f90
+  impl/smoother/amg_z_jac_smoother_bld.f90
+  impl/smoother/amg_c_as_smoother_clone.f90
+  impl/smoother/amg_d_as_smoother_apply_vect.f90
+  impl/smoother/amg_d_poly_smoother_descr.f90
+  impl/smoother/amg_s_as_smoother_csetc.f90
+  impl/smoother/amg_z_base_smoother_cseti.f90
+  impl/smoother/amg_s_base_smoother_cseti.f90
+  impl/smoother/amg_s_base_smoother_free.f90
+  impl/smoother/amg_d_jac_smoother_clone.f90
+  impl/smoother/amg_d_jac_smoother_apply_vect.f90
+  impl/smoother/amg_c_as_smoother_clear_data.f90
+  impl/smoother/amg_s_poly_smoother_descr.f90
+  impl/smoother/amg_z_as_smoother_cseti.f90
+  impl/smoother/amg_s_as_smoother_apply_vect.f90
+  impl/smoother/amg_c_jac_smoother_csetr.f90
+  impl/smoother/amg_d_base_smoother_free.f90
+  impl/smoother/amg_z_as_smoother_bld.f90
+  impl/smoother/amg_s_base_smoother_clear_data.f90
+  impl/smoother/amg_c_jac_smoother_bld.f90
+  impl/smoother/amg_d_as_smoother_restr_v.f90
+  impl/smoother/amg_c_as_smoother_check.f90
+  impl/smoother/amg_d_poly_smoother_cseti.f90
+  impl/smoother/amg_d_as_smoother_clone.f90
+  impl/smoother/amg_z_as_smoother_clear_data.f90
+  impl/smoother/amg_d_as_smoother_free.f90
+  impl/smoother/amg_s_as_smoother_cnv.f90
+  impl/smoother/amg_s_base_smoother_dmp.f90
+  impl/smoother/amg_d_l1_jac_smoother_descr.f90
+  impl/smoother/amg_s_poly_smoother_cnv.f90
+  impl/smoother/amg_d_jac_smoother_csetr.f90
+  impl/smoother/amg_d_base_smoother_apply.f90
+  impl/smoother/amg_s_as_smoother_cseti.f90
+  impl/smoother/amg_s_base_smoother_apply_vect.f90
+  impl/smoother/amg_c_base_smoother_cseti.f90
+  impl/smoother/amg_c_as_smoother_cnv.f90
+  impl/smoother/amg_z_jac_smoother_cnv.f90
+  impl/smoother/amg_s_poly_smoother_bld.f90
+  impl/smoother/amg_d_jac_smoother_cseti.f90
+  impl/smoother/amg_s_as_smoother_prol_v.f90
+  impl/smoother/amg_c_as_smoother_restr_a.f90
+  impl/smoother/amg_d_base_smoother_bld.f90
+  impl/smoother/amg_c_jac_smoother_clone.f90
+  impl/smoother/amg_d_jac_smoother_bld.f90
+  impl/smoother/amg_z_jac_smoother_apply_vect.f90
+  impl/smoother/amg_c_as_smoother_prol_v.f90
+  impl/smoother/amg_z_jac_smoother_csetc.f90
+  impl/smoother/amg_z_as_smoother_prol_v.f90
+  impl/smoother/amg_d_base_smoother_cnv.f90
+  impl/smoother/amg_c_l1_jac_smoother_bld.f90
+  impl/smoother/amg_z_as_smoother_apply_vect.f90
+  impl/smoother/amg_s_as_smoother_restr_v.f90
+  impl/smoother/amg_d_l1_jac_smoother_bld.f90
+  impl/smoother/amg_s_jac_smoother_bld.f90
+  impl/smoother/amg_s_poly_smoother_clone_settings.f90
+  impl/smoother/amg_d_base_smoother_check.f90
+  impl/smoother/amg_z_base_smoother_bld.f90
+  impl/smoother/amg_s_l1_jac_smoother_clone.f90
+  impl/smoother/amg_c_jac_smoother_clone_settings.f90
+  impl/smoother/amg_s_poly_smoother_dmp.f90
+  impl/smoother/amg_c_base_smoother_csetr.f90
+  impl/smoother/amg_d_poly_smoother_clone_settings.f90
+  impl/smoother/amg_z_as_smoother_clone_settings.f90
+  impl/smoother/amg_z_jac_smoother_csetr.f90
+  impl/smoother/amg_d_jac_smoother_csetc.f90
+  impl/smoother/amg_z_base_smoother_dmp.f90
+  impl/smoother/amg_s_jac_smoother_csetr.f90
+  impl/smoother/amg_s_base_smoother_bld.f90
+  impl/smoother/amg_z_jac_smoother_descr.f90
+  impl/smoother/amg_z_jac_smoother_cseti.f90
+  impl/smoother/amg_d_as_smoother_dmp.f90
+  impl/smoother/amg_d_jac_smoother_apply.f90
+  impl/smoother/amg_c_jac_smoother_dmp.f90
+  impl/smoother/amg_z_as_smoother_apply.f90
+  impl/smoother/amg_z_as_smoother_check.f90
+  impl/smoother/amg_z_jac_smoother_clear_data.f90
+  impl/smoother/amg_s_base_smoother_descr.f90
+  impl/smoother/amg_s_jac_smoother_clone.f90
+  impl/smoother/amg_z_jac_smoother_clone.f90
+  impl/smoother/amg_c_as_smoother_clone_settings.f90
+  impl/smoother/amg_c_base_smoother_check.f90
+  impl/smoother/amg_d_poly_smoother_apply_vect.f90
+  impl/smoother/amg_s_l1_jac_smoother_bld.f90
+  impl/smoother/amg_c_as_smoother_apply_vect.f90
+  impl/smoother/amg_z_as_smoother_cnv.f90
+  impl/smoother/amg_z_as_smoother_csetc.f90
+  impl/smoother/amg_d_as_smoother_csetc.f90
+  impl/smoother/amg_d_jac_smoother_cnv.f90
+  impl/smoother/amg_c_as_smoother_csetc.f90
+  impl/smoother/amg_z_base_smoother_clone_settings.f90
+  impl/smoother/amg_s_as_smoother_free.f90
+  impl/smoother/amg_z_base_smoother_free.f90
+  impl/smoother/amg_c_base_smoother_apply.f90
+  impl/smoother/amg_z_l1_jac_smoother_descr.f90
+  impl/smoother/amg_s_as_smoother_clone_settings.f90
+  impl/smoother/amg_d_base_smoother_csetr.f90
+  impl/smoother/amg_c_jac_smoother_clear_data.f90
+  impl/smoother/amg_d_poly_smoother_bld.f90
+  impl/smoother/amg_z_base_smoother_csetc.f90
+  impl/smoother/amg_z_base_smoother_clone.f90
+  impl/smoother/amg_s_jac_smoother_apply_vect.f90
+  impl/smoother/amg_z_base_smoother_clear_data.f90
+  impl/smoother/amg_c_base_smoother_clone_settings.f90
+  impl/smoother/amg_d_base_smoother_clone.f90
+  impl/smoother/amg_d_base_smoother_cseti.f90
+  impl/smoother/amg_z_l1_jac_smoother_clone.f90
+  impl/smoother/amg_s_l1_jac_smoother_descr.f90
+  impl/smoother/amg_c_jac_smoother_descr.f90
+  impl/smoother/amg_z_base_smoother_check.f90
+  impl/smoother/amg_d_jac_smoother_clear_data.f90
+  impl/smoother/amg_d_as_smoother_prol_a.f90
+  impl/smoother/amg_c_as_smoother_apply.f90
+  impl/smoother/amg_c_base_smoother_cnv.f90
+  impl/smoother/amg_c_jac_smoother_cnv.f90
+  impl/smoother/amg_c_base_smoother_csetc.f90
+  impl/smoother/amg_d_base_smoother_csetc.f90
+  impl/smoother/amg_d_poly_smoother_csetr.f90
+  impl/smoother/amg_c_jac_smoother_cseti.f90
+  impl/smoother/amg_s_base_smoother_cnv.f90
+  impl/smoother/amg_s_poly_smoother_csetr.f90
+  impl/smoother/amg_s_base_smoother_clone_settings.f90
+  impl/smoother/amg_s_as_smoother_restr_a.f90
+  impl/smoother/amg_d_base_smoother_dmp.f90
+  impl/smoother/amg_d_jac_smoother_descr.f90
+  impl/smoother/amg_c_base_smoother_free.f90
+  impl/smoother/amg_c_as_smoother_free.f90
+  impl/smoother/amg_s_jac_smoother_clear_data.f90
+  impl/smoother/amg_s_jac_smoother_cseti.f90
+  impl/smoother/amg_d_poly_smoother_clone.f90
+  impl/smoother/amg_s_jac_smoother_csetc.f90
+  impl/smoother/amg_s_as_smoother_dmp.f90
+  impl/smoother/amg_s_base_smoother_apply.f90
+  impl/smoother/amg_s_as_smoother_clone.f90
+  impl/smoother/amg_c_l1_jac_smoother_descr.f90
+  impl/smoother/amg_s_jac_smoother_cnv.f90
+  impl/smoother/amg_z_as_smoother_free.f90
+  impl/smoother/amg_s_poly_smoother_clone.f90
+  impl/smoother/amg_s_as_smoother_clear_data.f90
+  impl/smoother/amg_s_jac_smoother_dmp.f90
+  impl/smoother/amg_c_base_smoother_clone.f90
+  impl/smoother/amg_d_poly_smoother_csetc.f90
+  impl/smoother/amg_d_as_smoother_cseti.f90
+  impl/smoother/amg_z_base_smoother_descr.f90
+  impl/smoother/amg_d_as_smoother_restr_a.f90
+  impl/smoother/amg_s_base_smoother_check.f90
+  impl/smoother/amg_c_as_smoother_restr_v.f90
+  impl/smoother/amg_d_poly_smoother_cnv.f90
+  impl/smoother/amg_c_jac_smoother_csetc.f90
+  impl/smoother/amg_z_jac_smoother_dmp.f90
+  impl/smoother/amg_z_base_smoother_apply.f90
+  impl/smoother/amg_s_base_smoother_csetr.f90
+  impl/smoother/amg_d_as_smoother_apply.f90
+  impl/smoother/amg_c_as_smoother_prol_a.f90
+  impl/smoother/amg_d_poly_smoother_clear_data.f90
+  impl/smoother/amg_c_base_smoother_descr.f90
+  impl/smoother/amg_d_as_smoother_bld.f90
+  impl/smoother/amg_c_as_smoother_bld.f90
+  impl/smoother/amg_c_as_smoother_cseti.f90
+  impl/smoother/amg_s_as_smoother_bld.f90
+  impl/smoother/amg_z_as_smoother_restr_a.f90
+  impl/smoother/amg_d_as_smoother_clear_data.f90
+  impl/smoother/amg_d_l1_jac_smoother_clone.f90
+  impl/smoother/amg_c_base_smoother_dmp.f90
+  impl/smoother/amg_d_base_smoother_descr.f90
+  impl/smoother/amg_c_base_smoother_apply_vect.f90
+  impl/smoother/amg_d_base_smoother_apply_vect.f90
+  impl/smoother/amg_c_base_smoother_clear_data.f90
+  impl/smoother/amg_d_poly_smoother_dmp.f90
+  impl/smoother/amg_s_poly_smoother_cseti.f90
+  impl/smoother/amg_s_as_smoother_check.f90
+  impl/smoother/amg_s_jac_smoother_descr.f90
+  impl/smoother/amg_d_jac_smoother_clone_settings.f90
+  impl/smoother/amg_d_as_smoother_prol_v.f90
+  impl/smoother/amg_z_jac_smoother_apply.f90
+  impl/smoother/amg_d_as_smoother_cnv.f90
+  impl/smoother/amg_c_jac_smoother_apply_vect.f90
+  impl/smoother/amg_c_as_smoother_dmp.f90
+  impl/smoother/amg_c_base_smoother_bld.f90
+  impl/smoother/amg_d_as_smoother_clone_settings.f90
+  impl/smoother/amg_d_base_smoother_clear_data.f90
+  impl/smoother/amg_s_jac_smoother_clone_settings.f90
+  impl/smoother/amg_z_as_smoother_dmp.f90
+  impl/smoother/amg_z_as_smoother_clone.f90
+  impl/smoother/amg_z_as_smoother_restr_v.f90
+  impl/smoother/amg_z_as_smoother_prol_a.f90
+  impl/smoother/amg_z_base_smoother_apply_vect.f90
+  impl/amg_d_smoothers_bld.f90
+  impl/amg_zprecset.F90
+  impl/amg_d_hierarchy_rebld.f90
+  impl/amg_d_extprol_bld.F90
+  impl/amg_dprecset.F90
+  impl/amg_scprecset.F90
+  impl/amg_sprecset.F90
+  impl/amg_dmlprec_bld.f90
+  impl/amg_zmlprec_aply.f90
+  impl/aggregator/amg_d_dec_aggregator_tprol.f90
+  impl/aggregator/amg_s_parmatch_aggregator_mat_asb.F90
+  impl/aggregator/amg_s_parmatch_aggregator_tprol.F90
+  impl/aggregator/amg_z_dec_aggregator_tprol.f90
+  impl/aggregator/amg_saggrmat_smth_bld.f90
+  impl/aggregator/amg_s_soc2_map_bld.F90
+  impl/aggregator/amg_s_parmatch_spmm_bld_inner.F90
+  impl/aggregator/amg_caggrmat_minnrg_bld.f90
+  impl/aggregator/amg_d_soc2_map_bld.F90
+  impl/aggregator/amg_s_dec_aggregator_tprol.f90
+  impl/aggregator/amg_s_parmatch_aggregator_inner_mat_asb.F90
+  impl/aggregator/amg_s_dec_aggregator_mat_bld.f90
+  impl/aggregator/amg_c_dec_aggregator_mat_asb.f90
+  impl/aggregator/amg_s_rap.f90
+  impl/aggregator/amg_s_map_to_tprol.f90
+  impl/aggregator/amg_d_parmatch_aggregator_tprol.F90
+  impl/aggregator/amg_saggrmat_nosmth_bld.f90
+  impl/aggregator/amg_c_soc1_map_bld.F90
+  impl/aggregator/amg_d_parmatch_aggregator_mat_asb.F90
+  impl/aggregator/amg_zaggrmat_smth_bld.f90
+  impl/aggregator/amg_d_parmatch_smth_bld.F90
+  impl/aggregator/amg_caggrmat_nosmth_bld.f90
+  impl/aggregator/amg_c_map_to_tprol.f90
+  impl/aggregator/amg_d_rap.f90
+  impl/aggregator/amg_d_map_to_tprol.f90
+  impl/aggregator/amg_daggrmat_minnrg_bld.f90
+  impl/aggregator/amg_d_dec_aggregator_mat_asb.f90
+  impl/aggregator/amg_z_dec_aggregator_mat_bld.f90
+  impl/aggregator/amg_d_parmatch_spmm_bld.F90
+  impl/aggregator/amg_d_parmatch_aggregator_mat_bld.F90
+  impl/aggregator/amg_d_ptap_bld.f90
+  impl/aggregator/amg_z_symdec_aggregator_tprol.f90
+  impl/aggregator/amg_s_symdec_aggregator_tprol.f90
+  impl/aggregator/amg_z_soc1_map_bld.F90
+  impl/aggregator/amg_d_parmatch_unsmth_bld.F90
+  impl/aggregator/amg_z_map_to_tprol.f90
+  impl/aggregator/amg_d_soc1_map_bld.F90
+  impl/aggregator/amg_d_parmatch_spmm_bld_ov.F90
+  impl/aggregator/amg_s_parmatch_aggregator_mat_bld.F90
+  impl/aggregator/amg_s_parmatch_unsmth_bld.F90
+  impl/aggregator/amg_d_parmatch_aggregator_inner_mat_asb.F90
+  impl/aggregator/amg_s_parmatch_spmm_bld.F90
+  impl/aggregator/amg_c_symdec_aggregator_tprol.f90
+  impl/aggregator/amg_zaggrmat_minnrg_bld.f90
+  impl/aggregator/amg_c_dec_aggregator_tprol.f90
+  impl/aggregator/amg_z_dec_aggregator_mat_asb.f90
+  impl/aggregator/amg_c_rap.f90
+  impl/aggregator/amg_s_parmatch_spmm_bld_ov.F90
+  impl/aggregator/amg_s_ptap_bld.f90
+  impl/aggregator/amg_s_soc1_map_bld.F90
+  impl/aggregator/amg_d_dec_aggregator_mat_bld.f90
+  impl/aggregator/amg_z_ptap_bld.f90
+  impl/aggregator/amg_daggrmat_smth_bld.f90
+  impl/aggregator/amg_z_soc2_map_bld.F90
+  impl/aggregator/amg_caggrmat_smth_bld.f90
+  impl/aggregator/amg_saggrmat_minnrg_bld.f90
+  impl/aggregator/amg_c_soc2_map_bld.F90
+  impl/aggregator/amg_s_dec_aggregator_mat_asb.f90
+  impl/aggregator/amg_z_rap.f90
+  impl/aggregator/amg_s_parmatch_smth_bld.F90
+  impl/aggregator/amg_c_dec_aggregator_mat_bld.f90
+  impl/aggregator/amg_daggrmat_nosmth_bld.f90
+  impl/aggregator/amg_d_symdec_aggregator_tprol.f90
+  impl/aggregator/amg_d_parmatch_spmm_bld_inner.F90
+  impl/aggregator/amg_c_ptap_bld.f90
+  impl/aggregator/amg_zaggrmat_nosmth_bld.f90
+  impl/amg_cmlprec_aply.f90
+  impl/amg_cmlprec_bld.f90
+  amg_d_invt_solver.f90
+  amg_c_id_solver.f90
+  amg_base_ainv_mod.F90
+  amg_d_matchboxp_mod.F90
+  amg_z_base_smoother_mod.f90
+  amg_s_invk_solver.f90
+  amg_c_base_solver_mod.f90
+  amg_s_ilu_solver.f90
+  amg_z_ilu_fact_mod.f90
+  amg_prec_mod.f90
+  amg_d_gs_solver.f90
+  amg_d_jac_smoother.f90
+  amg_z_symdec_aggregator_mod.f90
+  amg_s_gs_solver.f90
+  amg_ainv_mod.f90
+  amg_d_parmatch_aggregator_mod.F90
+  amg_z_as_smoother.f90
+  amg_c_inner_mod.f90
+  amg_d_poly_smoother.f90
+  amg_z_onelev_mod.f90
+  amg_z_diag_solver.f90
+  amg_c_symdec_aggregator_mod.f90
+  amg_c_prec_mod.f90
+  amg_d_sludist_solver.F90
+  amg_d_base_solver_mod.f90
+  amg_c_dec_aggregator_mod.f90
+  amg_c_ilu_fact_mod.f90
+  amg_s_onelev_mod.f90
+  amg_d_base_ainv_mod.f90
+  amg_d_invk_solver.f90
+  amg_z_invt_solver.f90
+  amg_z_prec_mod.f90
+  amg_s_prec_mod.f90
+  amg_d_mumps_solver.F90
+  amg_d_umf_solver.F90
+#  amg_d_hybrid_aggregator_mod.F90
+  amg_d_id_solver.f90
+#  amg_c_hybrid_aggregator_mod.F90
+  amg_z_base_ainv_mod.f90
+  amg_z_sludist_solver.F90
+  amg_d_ilu_solver.f90
+  amg_s_base_ainv_mod.f90
+  amg_c_invt_solver.f90
+#  amg_s_hybrid_aggregator_mod.F90
+  amg_d_prec_type.f90
+  amg_d_base_smoother_mod.f90
+  amg_c_base_ainv_mod.f90
+  amg_s_prec_type.f90
+  amg_s_diag_solver.f90
+  amg_z_base_aggregator_mod.f90
+  amg_z_dec_aggregator_mod.f90
+  amg_prec_type.f90
+  amg_s_invt_solver.f90
+  amg_s_base_smoother_mod.f90
+  amg_c_ainv_solver.F90
+  amg_d_dec_aggregator_mod.f90
+  amg_s_slu_solver.F90
+  amg_d_diag_solver.f90
+  amg_z_id_solver.f90
+  amg_c_slu_solver.F90
+  amg_s_jac_smoother.f90
+  amg_s_dec_aggregator_mod.f90
+  amg_d_inner_mod.f90
+  amg_s_mumps_solver.F90
+  amg_d_jac_solver.f90
+  amg_s_krm_solver.f90
+  amg_s_as_smoother.f90
+  amg_d_onelev_mod.f90
+  amg_z_jac_solver.f90
+  amg_d_symdec_aggregator_mod.f90
+  amg_c_onelev_mod.f90
+  amg_s_parmatch_aggregator_mod.F90
+  amg_c_ilu_solver.f90
+  amg_d_poly_coeff_mod.f90
+  amg_s_jac_solver.f90
+  amg_base_prec_type.F90
+  amg_s_base_aggregator_mod.f90
+  amg_z_ainv_solver.F90
+  amg_d_prec_mod.f90
+  amg_c_prec_type.f90
+  amg_d_as_smoother.f90
+  amg_z_ilu_solver.f90
+  amg_c_base_aggregator_mod.f90
+  amg_s_id_solver.f90
+  amg_c_krm_solver.f90
+  amg_z_jac_smoother.f90
+  amg_c_as_smoother.f90
+  amg_z_invk_solver.f90
+  amg_d_krm_solver.f90
+  amg_c_invk_solver.f90
+  amg_c_mumps_solver.F90
+  amg_c_jac_solver.f90
+  amg_z_umf_solver.F90
+  amg_s_symdec_aggregator_mod.f90
+  amg_s_poly_smoother.f90
+  amg_s_inner_mod.f90
+  amg_s_ilu_fact_mod.f90
+  amg_z_mumps_solver.F90
+  amg_c_jac_smoother.f90
+)
+foreach(file IN LISTS AMG_amgprec_source_files)
+  list(APPEND amgprec_source_files ${CMAKE_CURRENT_LIST_DIR}/${file})
+endforeach()
+
+
+list(APPEND AMG_amgprec_source_C_files impl/amg_dslu_interface.c)
+list(APPEND AMG_amgprec_source_C_files impl/amg_zslu_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_sslu_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_dumf_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_cslu_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_dslud_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_zumf_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_zslud_interface.c)
+
+
+set(AMG_amgprec_source_CPP_files
+impl/aggregator/computeCandidateMate.cpp
+impl/aggregator/processExposedVertex.cpp
+impl/aggregator/processMatchedVertices.cpp
+impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.cpp
+impl/aggregator/processCrossEdge.cpp
+impl/aggregator/findOwnerOfGhost.cpp
+impl/aggregator/MatchBoxPC.cpp
+impl/aggregator/queueTransfer.cpp
+impl/aggregator/clean.cpp
+impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC.cpp
+impl/aggregator/extractUChunk.cpp
+impl/aggregator/processMatchedVerticesAndSendMessages.cpp
+impl/aggregator/sendBundledMessages.cpp
+impl/aggregator/initialize.cpp
+impl/aggregator/isAlreadyMatched.cpp
+impl/aggregator/processMessages.cpp
+impl/aggregator/parallelComputeCandidateMateB.cpp
+)
+
+
+foreach(file IN LISTS AMG_amgprec_source_C_files)
+  list(APPEND amgprec_source_C_files ${CMAKE_CURRENT_LIST_DIR}/${file})
+endforeach()
+
+
+foreach(file IN LISTS AMG_amgprec_source_CPP_files)
+  list(APPEND amgprec_source_CPP_files ${CMAKE_CURRENT_LIST_DIR}/${file})
+endforeach()

amgprec/Makefile

@@ -66,7 +66,7 @@ LIBNAME=libamg_prec.a
 all: objs impld
 
 objs: $(OBJS)
-	/bin/cp -p amg_const.h $(INCDIR)
+	/bin/cp -p amg_const.h amg_config.h $(INCDIR)
 	/bin/cp -p *$(.mod) $(MODDIR)
 
 impld: objs

amgprec/amg_base_ainv_mod.F90

@@ -55,10 +55,6 @@ module amg_base_ainv_mod
   integer, parameter   :: amg_ainv_llk_noth_ = amg_ainv_s_ft_llk_  + 1
   integer, parameter   :: amg_ainv_mlk_      = amg_ainv_llk_noth_  + 1
   integer, parameter   :: amg_ainv_lmx_      = amg_ainv_mlk_
-#if defined(HAVE_TUMA_SAINV)
-  integer, parameter   :: amg_ainv_s_tuma_    = amg_ainv_lmx_  + 1
-  integer, parameter   :: amg_ainv_l_tuma_    = amg_ainv_s_tuma_  + 1
-#endif
 
 
 end module amg_base_ainv_mod

amgprec/amg_base_prec_type.F90

@@ -621,9 +621,13 @@ contains
 
   subroutine amg_warn_coarse_mat(val,expected)
     integer(psb_ipk_) :: val, expected
+    integer(psb_mpk_) :: mval, mexp
     if (val /= expected) then
+      mval = val
+      mexp = expected
       write(0,*) 'Warning: resetting COARSE_MAT on an existing hierarchy from ',&
-           & amg_get_coarse_mat_name(val), ' to ',amg_get_coarse_mat_name(expected)
+           & amg_get_coarse_mat_name(mval), &
+           & ' to ',amg_get_coarse_mat_name(mexp)
     end if
   end subroutine amg_warn_coarse_mat
 
@@ -1207,7 +1211,7 @@ contains
     implicit none
     type(psb_ctxt_type), intent(in) :: ctxt
     type(amg_ml_parms), intent(inout)   :: dat
-    integer(psb_ipk_), intent(in), optional :: root
+    integer(psb_mpk_), intent(in), optional :: root
 
     call psb_bcast(ctxt,dat%sweeps_pre,root)
     call psb_bcast(ctxt,dat%sweeps_post,root)
@@ -1229,7 +1233,7 @@ contains
     implicit none
     type(psb_ctxt_type), intent(in) :: ctxt
     type(amg_sml_parms), intent(inout)   :: dat
-    integer(psb_ipk_), intent(in), optional :: root
+    integer(psb_mpk_), intent(in), optional :: root
 
     call psb_bcast(ctxt,dat%amg_ml_parms,root)
     call psb_bcast(ctxt,dat%aggr_omega_val,root)
@@ -1240,7 +1244,7 @@ contains
     implicit none
     type(psb_ctxt_type), intent(in) :: ctxt
     type(amg_dml_parms), intent(inout)   :: dat
-    integer(psb_ipk_), intent(in), optional :: root
+    integer(psb_mpk_), intent(in), optional :: root
 
     call psb_bcast(ctxt,dat%amg_ml_parms,root)
     call psb_bcast(ctxt,dat%aggr_omega_val,root)

amgprec/amg_c_base_aggregator_mod.f90

@@ -302,7 +302,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
 
     ! Do nothing
-    
+    info = psb_success_    
     return
   end subroutine amg_c_base_aggregator_set_aggr_type
 
@@ -486,6 +486,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='c_base_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.

amgprec/amg_c_dec_aggregator_mod.f90

@@ -150,7 +150,7 @@ contains
     class(amg_c_dec_aggregator_type), intent(inout) :: ag
     type(amg_sml_parms), intent(in)   :: parms
     integer(psb_ipk_), intent(out) :: info
-
+    info = psb_success_
     select case(parms%aggr_type)
     case (amg_noalg_)
       ag%soc_map_bld => null()
@@ -192,6 +192,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_c_mumps_solver.F90

@@ -52,10 +52,10 @@
 !
 module amg_c_mumps_solver
   use amg_c_base_solver_mod
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_MODULES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_MODULES)
   use cmumps_struc_def
 #endif
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_INCLUDES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_INCLUDES)
   include 'cmumps_struc.h'
 #endif  
   
@@ -68,7 +68,7 @@ module amg_c_mumps_solver
   end type amg_c_mumps_rcntl_item
 
   type, extends(amg_c_base_solver_type) :: amg_c_mumps_solver_type
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     type(cmumps_struc), allocatable  :: id
 #else
     integer, allocatable :: id
@@ -189,7 +189,7 @@ contains
 
     info = 0
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     
     call psb_erractionsave(err_act)
 
@@ -239,7 +239,7 @@ contains
     character(len=20)  :: name='c_mumps_solver_clear_data'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     if (allocated(sv%id)) then      
       if (sv%built) then 
@@ -279,7 +279,7 @@ contains
     character(len=20)  :: name='c_mumps_solver_free'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     call sv%clear_data(info)
     if ((info == 0).and.allocated(sv%icntl)) deallocate(sv%icntl,stat=info)
@@ -383,7 +383,7 @@ subroutine c_mumps_solver_csetc(sv,what,val,info,idx)
 
 
   select case(psb_toupper(trim(what)))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = sv%stringval(psb_toupper(trim(val)))
 #endif
@@ -421,7 +421,7 @@ subroutine c_mumps_solver_cseti(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = val
   case('MUMPS_PRINT_ERR')
@@ -467,7 +467,7 @@ subroutine c_mumps_solver_csetr(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_RPAR_ENTRY')
     if(present(idx)) then 
       ! Note: this will allocate %item
@@ -504,7 +504,7 @@ subroutine c_mumps_solver_default(sv)
   info = psb_success_
   call psb_erractionsave(err_act)
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   if (.not.allocated(sv%id)) then 
     allocate(sv%id,stat=info)
     if (info /= psb_success_) then
@@ -561,7 +561,7 @@ function c_mumps_solver_sizeof(sv) result(val)
   class(amg_c_mumps_solver_type), intent(in) :: sv
   integer(psb_epk_) :: val
   integer             :: i
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   val = (sv%id%INFOG(22)+sv%id%INFOG(32))*1d+6
 #else
   val = 0 

amgprec/amg_c_prec_type.f90

@@ -113,6 +113,7 @@ module amg_c_prec_type
     procedure, pass(prec)               :: free           => amg_c_prec_free
     procedure, pass(prec)               :: allocate_wrk   => amg_c_allocate_wrk
     procedure, pass(prec)               :: free_wrk       => amg_c_free_wrk
+    procedure, pass(prec)               :: deallocate_wrk => amg_c_free_wrk
     procedure, pass(prec)               :: is_allocated_wrk => amg_c_is_allocated_wrk
     procedure, pass(prec)               :: get_complexity => amg_c_get_compl
     procedure, pass(prec)               :: cmp_complexity => amg_c_cmp_compl

amgprec/amg_c_slu_solver.F90

@@ -51,7 +51,7 @@ module amg_c_slu_solver
   use iso_c_binding
   use amg_c_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
 
   type, extends(amg_c_base_solver_type) :: amg_c_slu_solver_type
 

amgprec/amg_c_symdec_aggregator_mod.f90

@@ -97,7 +97,7 @@ contains
     character(len=*), intent(in), optional  :: prefix
 
     character(1024)    :: prefix_
-
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_config.h.in

@@ -0,0 +1,17 @@
+#ifndef AMG_CONFIG_H
+#define AMG_CONFIG_H
+
+#include "psb_config.h"
+
+@CHAVEUMF@
+@CHAVESLU@
+@CSLUVERSION@
+@CHAVESLUDIST@
+@CSLUDISTVERSION@
+@CHAVEMUMPS@
+@CHAVEMUMPSMODULES@
+@CHAVEMUMPSINCLUDES@
+@CXXMATCHBOXBIT@
+
+
+#endif

amgprec/amg_d_base_aggregator_mod.f90

@@ -302,7 +302,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
 
     ! Do nothing
-    
+    info = psb_success_    
     return
   end subroutine amg_d_base_aggregator_set_aggr_type
 
@@ -486,6 +486,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='d_base_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.

amgprec/amg_d_dec_aggregator_mod.f90

@@ -150,7 +150,7 @@ contains
     class(amg_d_dec_aggregator_type), intent(inout) :: ag
     type(amg_dml_parms), intent(in)   :: parms
     integer(psb_ipk_), intent(out) :: info
-
+    info = psb_success_
     select case(parms%aggr_type)
     case (amg_noalg_)
       ag%soc_map_bld => null()
@@ -192,6 +192,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_d_matchboxp_mod.F90

@@ -73,6 +73,22 @@ module amg_d_matchboxp_mod
   use iso_c_binding
   use psb_base_cbind_mod
 
+#if defined(PSB_SERIAL_MPI)
+  interface MatchingC
+    subroutine dMatchingC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
+         & verdistance, mate) bind(c,name='dMatching')
+      use iso_c_binding
+      import :: psb_c_ipk_, psb_c_lpk_
+      implicit none
+
+      integer(psb_c_lpk_), value :: nlver,nledge
+      integer(psb_c_lpk_) :: verlocptr(*),verlocind(*), verdistance(*)
+      integer(psb_c_lpk_) :: mate(*)
+      real(c_double) :: edgelocweight(*)
+    end subroutine dMatchingC
+  end interface MatchingC
+
+#else
   interface MatchBoxPC
     subroutine dMatchBoxPC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
          & verdistance, mate, myrank, numprocs, icomm,&
@@ -93,7 +109,7 @@ module amg_d_matchboxp_mod
       real(c_double)     :: msgpercent(*)
     end subroutine dMatchBoxPC
   end interface MatchBoxPC
-
+#endif
   interface amg_i_aggr_assign
     module procedure amg_i_d_aggr_assign
   end interface amg_i_aggr_assign
@@ -145,7 +161,7 @@ contains
     logical, parameter  :: dump=.false., debug=.false., dump_mate=.false., &
          & debug_ilaggr=.false., debug_sync=.false., debug_mate=.false.
     integer(psb_ipk_), save :: idx_bldmtc=-1, idx_phase1=-1, idx_phase2=-1, idx_phase3=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
     integer, parameter :: ilaggr_neginit=-1, ilaggr_nonlocal=-2
 
     ictxt = desc_a%get_ctxt()
@@ -608,7 +624,7 @@ contains
     logical, parameter :: old_style=.false., sort_minp=.true.
     character(len=40) :: name='build_matching', fname
     integer(psb_ipk_), save :: idx_cmboxp=-1, idx_bldahat=-1, idx_phase2=-1, idx_phase3=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
 
     ictxt = desc_a%get_ctxt()
     call psb_info(ictxt,iam,np)
@@ -810,7 +826,7 @@ contains
     character(len=80) :: aname
     real(psb_dpk_), parameter :: eps=epsilon(1.d0)
     integer(psb_ipk_), save   :: idx_glbt=-1, idx_phase1=-1, idx_phase2=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
     logical, parameter :: debug_symmetry = .false., check_size=.false.
     logical, parameter :: unroll_logtrans=.false.
 
@@ -863,7 +879,7 @@ contains
     nr = tcoo1%get_nrows()
     nc = tcoo1%get_ncols()
     nz = tcoo1%get_nzeros()
-    call tcoo2%allocate(nr,nc,int(1.25*nz))
+    call tcoo2%allocate(nr,nc,int(1.25*nz,psb_ipk_))
     k2 = 0
     !
     ! Build the entries of \^A for matching
@@ -1040,7 +1056,8 @@ contains
     integer(psb_c_lpk_) :: ph1_card(*),ph2_card(*)
     real(c_double)  :: edgelocweight(:)
     real(c_double)      :: msgpercent(*)
-    integer(psb_ipk_)   :: info, me, np
+    integer(psb_ipk_)   :: info
+    integer(psb_mpk_)   :: me, np
     integer(psb_c_mpk_) :: icomm, mrank, mnp
     logical, optional   :: display_inp
     !
@@ -1129,11 +1146,15 @@ contains
       call psb_barrier(ictxt)
       if (me == 0) write(0,*)' Calling MatchBoxP '
     end if
-
+#if defined(PSB_SERIAL_MPI)
+    call MatchingC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
+         & verdistance, mate)
+#else
     call MatchBoxPC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
          & verdistance, mate, mrank, mnp, icomm,&
          & msgindsent,msgactualsent,msgpercent,&
          & ph0_time, ph1_time, ph2_time, ph1_card, ph2_card)
+#endif
     verlocptr(:)   = verlocptr(:)  + 1
     verlocind(:)   = verlocind(:) + 1
     verdistance(:) = verdistance(:) + 1

amgprec/amg_d_mumps_solver.F90

@@ -52,10 +52,10 @@
 !
 module amg_d_mumps_solver
   use amg_d_base_solver_mod
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_MODULES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_MODULES)
   use dmumps_struc_def
 #endif
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_INCLUDES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_INCLUDES)
   include 'dmumps_struc.h'
 #endif  
   
@@ -68,7 +68,7 @@ module amg_d_mumps_solver
   end type amg_d_mumps_rcntl_item
 
   type, extends(amg_d_base_solver_type) :: amg_d_mumps_solver_type
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     type(dmumps_struc), allocatable  :: id
 #else
     integer, allocatable :: id
@@ -189,7 +189,7 @@ contains
 
     info = 0
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     
     call psb_erractionsave(err_act)
 
@@ -239,7 +239,7 @@ contains
     character(len=20)  :: name='d_mumps_solver_clear_data'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     if (allocated(sv%id)) then      
       if (sv%built) then 
@@ -279,7 +279,7 @@ contains
     character(len=20)  :: name='d_mumps_solver_free'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     call sv%clear_data(info)
     if ((info == 0).and.allocated(sv%icntl)) deallocate(sv%icntl,stat=info)
@@ -383,7 +383,7 @@ subroutine d_mumps_solver_csetc(sv,what,val,info,idx)
 
 
   select case(psb_toupper(trim(what)))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = sv%stringval(psb_toupper(trim(val)))
 #endif
@@ -421,7 +421,7 @@ subroutine d_mumps_solver_cseti(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = val
   case('MUMPS_PRINT_ERR')
@@ -467,7 +467,7 @@ subroutine d_mumps_solver_csetr(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_RPAR_ENTRY')
     if(present(idx)) then 
       ! Note: this will allocate %item
@@ -504,7 +504,7 @@ subroutine d_mumps_solver_default(sv)
   info = psb_success_
   call psb_erractionsave(err_act)
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   if (.not.allocated(sv%id)) then 
     allocate(sv%id,stat=info)
     if (info /= psb_success_) then
@@ -561,7 +561,7 @@ function d_mumps_solver_sizeof(sv) result(val)
   class(amg_d_mumps_solver_type), intent(in) :: sv
   integer(psb_epk_) :: val
   integer             :: i
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   val = (sv%id%INFOG(22)+sv%id%INFOG(32))*1d+6
 #else
   val = 0 

amgprec/amg_d_parmatch_aggregator_mod.F90

@@ -119,10 +119,6 @@
 module amg_d_parmatch_aggregator_mod
   use amg_d_base_aggregator_mod
   use amg_d_matchboxp_mod
-#if defined(SERIAL_MPI)
-  type, extends(amg_d_base_aggregator_type) :: amg_d_parmatch_aggregator_type
-  end type amg_d_parmatch_aggregator_type
-#else 
   type, extends(amg_d_base_aggregator_type) :: amg_d_parmatch_aggregator_type
     integer(psb_ipk_) :: matching_alg
     integer(psb_ipk_) :: n_sweeps   ! When n_sweeps >1 we need an auxiliary descriptor
@@ -400,6 +396,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else
@@ -451,6 +448,7 @@ contains
     class(amg_d_base_aggregator_type), target, intent(inout) :: agnext
     integer(psb_ipk_), intent(out)       :: info
 
+    info = psb_success_
     !
     !
     select type(agnext)
@@ -590,7 +588,7 @@ contains
     class(amg_d_parmatch_aggregator_type), intent(inout) :: ag
     integer(psb_ipk_), intent(out)       :: info
 
-    info = 0
+    info = psb_success_
     if ((info == 0).and.allocated(ag%w)) deallocate(ag%w,stat=info)
     if ((info == 0).and.allocated(ag%w_nxt)) deallocate(ag%w_nxt,stat=info)
     if ((info == 0).and.allocated(ag%prol)) then
@@ -629,7 +627,7 @@ contains
     class(amg_d_base_aggregator_type), allocatable, intent(inout) :: agnext
     integer(psb_ipk_), intent(out)       :: info
 
-    info = 0
+    info = psb_success_
     if (allocated(agnext)) then
       call agnext%free(info)
       if (info == 0) deallocate(agnext,stat=info)
@@ -658,6 +656,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='d_parmatch_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.
@@ -675,11 +674,6 @@ contains
       map = psb_linmap(psb_map_gen_linear_,desc_a,&
            & desc_ac,op_restr,op_prol,ilaggr,nlaggr)
     end if
-    if(info /= psb_success_) then
-      call psb_errpush(psb_err_from_subroutine_,name,a_err='sp_Free')
-      goto 9999
-    end if
-
     call psb_erractionrestore(err_act)
     return
 
@@ -687,5 +681,4 @@ contains
 
     return
   end subroutine amg_d_parmatch_aggregator_bld_map
-#endif
 end module amg_d_parmatch_aggregator_mod

amgprec/amg_d_prec_type.f90

@@ -113,6 +113,7 @@ module amg_d_prec_type
     procedure, pass(prec)               :: free           => amg_d_prec_free
     procedure, pass(prec)               :: allocate_wrk   => amg_d_allocate_wrk
     procedure, pass(prec)               :: free_wrk       => amg_d_free_wrk
+    procedure, pass(prec)               :: deallocate_wrk => amg_d_free_wrk
     procedure, pass(prec)               :: is_allocated_wrk => amg_d_is_allocated_wrk
     procedure, pass(prec)               :: get_complexity => amg_d_get_compl
     procedure, pass(prec)               :: cmp_complexity => amg_d_cmp_compl

amgprec/amg_d_slu_solver.F90

@@ -51,7 +51,7 @@ module amg_d_slu_solver
   use iso_c_binding
   use amg_d_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
 
   type, extends(amg_d_base_solver_type) :: amg_d_slu_solver_type
 

amgprec/amg_d_sludist_solver.F90

@@ -52,7 +52,7 @@ module amg_d_sludist_solver
   use iso_c_binding
   use amg_d_base_solver_mod
 
-#if (!defined(HAVE_SLUDIST_)) || defined(IPK8) 
+#if (!defined(AMG_HAVE_SLUDIST)) || defined(PSB_IPK8) 
 
   type, extends(amg_d_base_solver_type) :: amg_d_sludist_solver_type
 

amgprec/amg_d_symdec_aggregator_mod.f90

@@ -97,7 +97,7 @@ contains
     character(len=*), intent(in), optional  :: prefix
 
     character(1024)    :: prefix_
-
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_d_umf_solver.F90

@@ -51,7 +51,7 @@ module amg_d_umf_solver
   use iso_c_binding
   use amg_d_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
   type, extends(amg_d_base_solver_type) :: amg_d_umf_solver_type
 
   end type amg_d_umf_solver_type

amgprec/amg_s_base_aggregator_mod.f90

@@ -302,7 +302,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
 
     ! Do nothing
-    
+    info = psb_success_    
     return
   end subroutine amg_s_base_aggregator_set_aggr_type
 
@@ -486,6 +486,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='s_base_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.

amgprec/amg_s_dec_aggregator_mod.f90

@@ -150,7 +150,7 @@ contains
     class(amg_s_dec_aggregator_type), intent(inout) :: ag
     type(amg_sml_parms), intent(in)   :: parms
     integer(psb_ipk_), intent(out) :: info
-
+    info = psb_success_
     select case(parms%aggr_type)
     case (amg_noalg_)
       ag%soc_map_bld => null()
@@ -192,6 +192,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_s_matchboxp_mod.F90

@@ -73,6 +73,22 @@ module amg_s_matchboxp_mod
   use iso_c_binding
   use psb_base_cbind_mod
 
+#if defined(PSB_SERIAL_MPI)
+  interface MatchingC
+    subroutine sMatchingC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
+         & verdistance, mate) bind(c,name='sMatching')
+      use iso_c_binding
+      import :: psb_c_ipk_, psb_c_lpk_
+      implicit none
+
+      integer(psb_c_lpk_), value :: nlver,nledge
+      integer(psb_c_lpk_) :: verlocptr(*),verlocind(*), verdistance(*)
+      integer(psb_c_lpk_) :: mate(*)
+      real(c_float) :: edgelocweight(*)
+    end subroutine sMatchingC
+  end interface MatchingC
+
+#else
   interface MatchBoxPC
     subroutine sMatchBoxPC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
          & verdistance, mate, myrank, numprocs, icomm,&
@@ -93,7 +109,7 @@ module amg_s_matchboxp_mod
       real(c_double)     :: msgpercent(*)
     end subroutine sMatchBoxPC
   end interface MatchBoxPC
-
+#endif
   interface amg_i_aggr_assign
     module procedure amg_i_s_aggr_assign
   end interface amg_i_aggr_assign
@@ -145,7 +161,7 @@ contains
     logical, parameter  :: dump=.false., debug=.false., dump_mate=.false., &
          & debug_ilaggr=.false., debug_sync=.false., debug_mate=.false.
     integer(psb_ipk_), save :: idx_bldmtc=-1, idx_phase1=-1, idx_phase2=-1, idx_phase3=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
     integer, parameter :: ilaggr_neginit=-1, ilaggr_nonlocal=-2
 
     ictxt = desc_a%get_ctxt()
@@ -608,7 +624,7 @@ contains
     logical, parameter :: old_style=.false., sort_minp=.true.
     character(len=40) :: name='build_matching', fname
     integer(psb_ipk_), save :: idx_cmboxp=-1, idx_bldahat=-1, idx_phase2=-1, idx_phase3=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
 
     ictxt = desc_a%get_ctxt()
     call psb_info(ictxt,iam,np)
@@ -810,7 +826,7 @@ contains
     character(len=80) :: aname
     real(psb_spk_), parameter :: eps=epsilon(1.d0)
     integer(psb_ipk_), save   :: idx_glbt=-1, idx_phase1=-1, idx_phase2=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
     logical, parameter :: debug_symmetry = .false., check_size=.false.
     logical, parameter :: unroll_logtrans=.false.
 
@@ -863,7 +879,7 @@ contains
     nr = tcoo1%get_nrows()
     nc = tcoo1%get_ncols()
     nz = tcoo1%get_nzeros()
-    call tcoo2%allocate(nr,nc,int(1.25*nz))
+    call tcoo2%allocate(nr,nc,int(1.25*nz,psb_ipk_))
     k2 = 0
     !
     ! Build the entries of \^A for matching
@@ -1040,7 +1056,8 @@ contains
     integer(psb_c_lpk_) :: ph1_card(*),ph2_card(*)
     real(c_float)  :: edgelocweight(:)
     real(c_double)      :: msgpercent(*)
-    integer(psb_ipk_)   :: info, me, np
+    integer(psb_ipk_)   :: info
+    integer(psb_mpk_)   :: me, np
     integer(psb_c_mpk_) :: icomm, mrank, mnp
     logical, optional   :: display_inp
     !
@@ -1129,11 +1146,15 @@ contains
       call psb_barrier(ictxt)
       if (me == 0) write(0,*)' Calling MatchBoxP '
     end if
-
+#if defined(PSB_SERIAL_MPI)
+    call MatchingC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
+         & verdistance, mate)
+#else
     call MatchBoxPC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
          & verdistance, mate, mrank, mnp, icomm,&
          & msgindsent,msgactualsent,msgpercent,&
          & ph0_time, ph1_time, ph2_time, ph1_card, ph2_card)
+#endif
     verlocptr(:)   = verlocptr(:)  + 1
     verlocind(:)   = verlocind(:) + 1
     verdistance(:) = verdistance(:) + 1

amgprec/amg_s_mumps_solver.F90

@@ -52,10 +52,10 @@
 !
 module amg_s_mumps_solver
   use amg_s_base_solver_mod
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_MODULES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_MODULES)
   use smumps_struc_def
 #endif
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_INCLUDES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_INCLUDES)
   include 'smumps_struc.h'
 #endif  
   
@@ -68,7 +68,7 @@ module amg_s_mumps_solver
   end type amg_s_mumps_rcntl_item
 
   type, extends(amg_s_base_solver_type) :: amg_s_mumps_solver_type
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     type(smumps_struc), allocatable  :: id
 #else
     integer, allocatable :: id
@@ -189,7 +189,7 @@ contains
 
     info = 0
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     
     call psb_erractionsave(err_act)
 
@@ -239,7 +239,7 @@ contains
     character(len=20)  :: name='s_mumps_solver_clear_data'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     if (allocated(sv%id)) then      
       if (sv%built) then 
@@ -279,7 +279,7 @@ contains
     character(len=20)  :: name='s_mumps_solver_free'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     call sv%clear_data(info)
     if ((info == 0).and.allocated(sv%icntl)) deallocate(sv%icntl,stat=info)
@@ -383,7 +383,7 @@ subroutine s_mumps_solver_csetc(sv,what,val,info,idx)
 
 
   select case(psb_toupper(trim(what)))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = sv%stringval(psb_toupper(trim(val)))
 #endif
@@ -421,7 +421,7 @@ subroutine s_mumps_solver_cseti(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = val
   case('MUMPS_PRINT_ERR')
@@ -467,7 +467,7 @@ subroutine s_mumps_solver_csetr(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_RPAR_ENTRY')
     if(present(idx)) then 
       ! Note: this will allocate %item
@@ -504,7 +504,7 @@ subroutine s_mumps_solver_default(sv)
   info = psb_success_
   call psb_erractionsave(err_act)
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   if (.not.allocated(sv%id)) then 
     allocate(sv%id,stat=info)
     if (info /= psb_success_) then
@@ -561,7 +561,7 @@ function s_mumps_solver_sizeof(sv) result(val)
   class(amg_s_mumps_solver_type), intent(in) :: sv
   integer(psb_epk_) :: val
   integer             :: i
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   val = (sv%id%INFOG(22)+sv%id%INFOG(32))*1d+6
 #else
   val = 0 

amgprec/amg_s_parmatch_aggregator_mod.F90

@@ -119,10 +119,6 @@
 module amg_s_parmatch_aggregator_mod
   use amg_s_base_aggregator_mod
   use amg_s_matchboxp_mod
-#if defined(SERIAL_MPI)
-  type, extends(amg_s_base_aggregator_type) :: amg_s_parmatch_aggregator_type
-  end type amg_s_parmatch_aggregator_type
-#else 
   type, extends(amg_s_base_aggregator_type) :: amg_s_parmatch_aggregator_type
     integer(psb_ipk_) :: matching_alg
     integer(psb_ipk_) :: n_sweeps   ! When n_sweeps >1 we need an auxiliary descriptor
@@ -400,6 +396,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else
@@ -451,6 +448,7 @@ contains
     class(amg_s_base_aggregator_type), target, intent(inout) :: agnext
     integer(psb_ipk_), intent(out)       :: info
 
+    info = psb_success_
     !
     !
     select type(agnext)
@@ -590,7 +588,7 @@ contains
     class(amg_s_parmatch_aggregator_type), intent(inout) :: ag
     integer(psb_ipk_), intent(out)       :: info
 
-    info = 0
+    info = psb_success_
     if ((info == 0).and.allocated(ag%w)) deallocate(ag%w,stat=info)
     if ((info == 0).and.allocated(ag%w_nxt)) deallocate(ag%w_nxt,stat=info)
     if ((info == 0).and.allocated(ag%prol)) then
@@ -629,7 +627,7 @@ contains
     class(amg_s_base_aggregator_type), allocatable, intent(inout) :: agnext
     integer(psb_ipk_), intent(out)       :: info
 
-    info = 0
+    info = psb_success_
     if (allocated(agnext)) then
       call agnext%free(info)
       if (info == 0) deallocate(agnext,stat=info)
@@ -658,6 +656,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='s_parmatch_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.
@@ -675,11 +674,6 @@ contains
       map = psb_linmap(psb_map_gen_linear_,desc_a,&
            & desc_ac,op_restr,op_prol,ilaggr,nlaggr)
     end if
-    if(info /= psb_success_) then
-      call psb_errpush(psb_err_from_subroutine_,name,a_err='sp_Free')
-      goto 9999
-    end if
-
     call psb_erractionrestore(err_act)
     return
 
@@ -687,5 +681,4 @@ contains
 
     return
   end subroutine amg_s_parmatch_aggregator_bld_map
-#endif
 end module amg_s_parmatch_aggregator_mod

amgprec/amg_s_prec_type.f90

@@ -113,6 +113,7 @@ module amg_s_prec_type
     procedure, pass(prec)               :: free           => amg_s_prec_free
     procedure, pass(prec)               :: allocate_wrk   => amg_s_allocate_wrk
     procedure, pass(prec)               :: free_wrk       => amg_s_free_wrk
+    procedure, pass(prec)               :: deallocate_wrk => amg_s_free_wrk
     procedure, pass(prec)               :: is_allocated_wrk => amg_s_is_allocated_wrk
     procedure, pass(prec)               :: get_complexity => amg_s_get_compl
     procedure, pass(prec)               :: cmp_complexity => amg_s_cmp_compl

amgprec/amg_s_slu_solver.F90

@@ -51,7 +51,7 @@ module amg_s_slu_solver
   use iso_c_binding
   use amg_s_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
 
   type, extends(amg_s_base_solver_type) :: amg_s_slu_solver_type
 

amgprec/amg_s_symdec_aggregator_mod.f90

@@ -97,7 +97,7 @@ contains
     character(len=*), intent(in), optional  :: prefix
 
     character(1024)    :: prefix_
-
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_z_base_aggregator_mod.f90

@@ -302,7 +302,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
 
     ! Do nothing
-    
+    info = psb_success_    
     return
   end subroutine amg_z_base_aggregator_set_aggr_type
 
@@ -486,6 +486,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='z_base_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.

amgprec/amg_z_dec_aggregator_mod.f90

@@ -150,7 +150,7 @@ contains
     class(amg_z_dec_aggregator_type), intent(inout) :: ag
     type(amg_dml_parms), intent(in)   :: parms
     integer(psb_ipk_), intent(out) :: info
-
+    info = psb_success_
     select case(parms%aggr_type)
     case (amg_noalg_)
       ag%soc_map_bld => null()
@@ -192,6 +192,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_z_mumps_solver.F90

@@ -52,10 +52,10 @@
 !
 module amg_z_mumps_solver
   use amg_z_base_solver_mod
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_MODULES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_MODULES)
   use zmumps_struc_def
 #endif
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_INCLUDES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_INCLUDES)
   include 'zmumps_struc.h'
 #endif  
   
@@ -68,7 +68,7 @@ module amg_z_mumps_solver
   end type amg_z_mumps_rcntl_item
 
   type, extends(amg_z_base_solver_type) :: amg_z_mumps_solver_type
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     type(zmumps_struc), allocatable  :: id
 #else
     integer, allocatable :: id
@@ -189,7 +189,7 @@ contains
 
     info = 0
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     
     call psb_erractionsave(err_act)
 
@@ -239,7 +239,7 @@ contains
     character(len=20)  :: name='z_mumps_solver_clear_data'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     if (allocated(sv%id)) then      
       if (sv%built) then 
@@ -279,7 +279,7 @@ contains
     character(len=20)  :: name='z_mumps_solver_free'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     call sv%clear_data(info)
     if ((info == 0).and.allocated(sv%icntl)) deallocate(sv%icntl,stat=info)
@@ -383,7 +383,7 @@ subroutine z_mumps_solver_csetc(sv,what,val,info,idx)
 
 
   select case(psb_toupper(trim(what)))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = sv%stringval(psb_toupper(trim(val)))
 #endif
@@ -421,7 +421,7 @@ subroutine z_mumps_solver_cseti(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = val
   case('MUMPS_PRINT_ERR')
@@ -467,7 +467,7 @@ subroutine z_mumps_solver_csetr(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_RPAR_ENTRY')
     if(present(idx)) then 
       ! Note: this will allocate %item
@@ -504,7 +504,7 @@ subroutine z_mumps_solver_default(sv)
   info = psb_success_
   call psb_erractionsave(err_act)
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   if (.not.allocated(sv%id)) then 
     allocate(sv%id,stat=info)
     if (info /= psb_success_) then
@@ -561,7 +561,7 @@ function z_mumps_solver_sizeof(sv) result(val)
   class(amg_z_mumps_solver_type), intent(in) :: sv
   integer(psb_epk_) :: val
   integer             :: i
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   val = (sv%id%INFOG(22)+sv%id%INFOG(32))*1d+6
 #else
   val = 0 

amgprec/amg_z_prec_type.f90

@@ -113,6 +113,7 @@ module amg_z_prec_type
     procedure, pass(prec)               :: free           => amg_z_prec_free
     procedure, pass(prec)               :: allocate_wrk   => amg_z_allocate_wrk
     procedure, pass(prec)               :: free_wrk       => amg_z_free_wrk
+    procedure, pass(prec)               :: deallocate_wrk => amg_z_free_wrk
     procedure, pass(prec)               :: is_allocated_wrk => amg_z_is_allocated_wrk
     procedure, pass(prec)               :: get_complexity => amg_z_get_compl
     procedure, pass(prec)               :: cmp_complexity => amg_z_cmp_compl

amgprec/amg_z_slu_solver.F90

@@ -51,7 +51,7 @@ module amg_z_slu_solver
   use iso_c_binding
   use amg_z_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
 
   type, extends(amg_z_base_solver_type) :: amg_z_slu_solver_type
 

amgprec/amg_z_sludist_solver.F90

@@ -52,7 +52,7 @@ module amg_z_sludist_solver
   use iso_c_binding
   use amg_z_base_solver_mod
 
-#if (!defined(HAVE_SLUDIST_)) || defined(IPK8) 
+#if (!defined(AMG_HAVE_SLUDIST)) || defined(PSB_IPK8) 
 
   type, extends(amg_z_base_solver_type) :: amg_z_sludist_solver_type
 

amgprec/amg_z_symdec_aggregator_mod.f90

@@ -97,7 +97,7 @@ contains
     character(len=*), intent(in), optional  :: prefix
 
     character(1024)    :: prefix_
-
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_z_umf_solver.F90

@@ -51,7 +51,7 @@ module amg_z_umf_solver
   use iso_c_binding
   use amg_z_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
   type, extends(amg_z_base_solver_type) :: amg_z_umf_solver_type
 
   end type amg_z_umf_solver_type

amgprec/impl/Makefile

@@ -5,6 +5,7 @@ MODDIR=../../modules
 HERE=..
 
 FINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(MODDIR) $(FMFLAG)$(INCDIR) $(PSBLAS_INCLUDES)
+CINCLUDES=-I. -I.. -I$(PSBLAS_INCDIR)
 
 
 

amgprec/impl/aggregator/Makefile

@@ -5,7 +5,8 @@ MODDIR=../../../modules
 HERE=../..
 
 FINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(MODDIR) $(FMFLAG)$(INCDIR) $(PSBLAS_INCLUDES)
-CXXINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(INCDIR) $(FMFLAG)/.
+CXXINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(INCDIR) $(FMFLAG)/. -I$(PSBLAS_INCDIR)
+CINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(INCDIR) $(FMFLAG)/. -I$(PSBLAS_INCDIR)
 
 #CINCLUDES= -I${SUPERLU_INCDIR} -I${HSL_INCDIR}  -I${SPRAL_INCDIR} -I/home/users/pasqua/Ambra/BootCMatch/include -lBCM -L/home/users/pasqua/Ambra/BootCMatch/lib  -lm
 
@@ -61,7 +62,8 @@ amg_s_parmatch_unsmth_bld.o \
 amg_s_parmatch_smth_bld.o \
 amg_s_parmatch_spmm_bld_inner.o
 
-MPCOBJS=MatchBoxPC.o \
+MPCOBJS=Matching.o \
+MatchBoxPC.o \
 sendBundledMessages.o \
 initialize.o \
 extractUChunk.o \

amgprec/impl/aggregator/MatchBoxPC.cpp

@@ -40,15 +40,17 @@
 // ************************************************************************
 #include <stdio.h>
 #include <stdlib.h>
-#if !defined(SERIAL_MPI)
+#include "amg_config.h"
+#include "MatchBoxPC.h"
+#if !defined(PSB_SERIAL_MPI)
 #include <mpi.h>
 #endif
 
-#include "MatchBoxPC.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#if !defined(PSB_SERIAL_MPI)
 
 void dMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 		MilanLongInt* verLocPtr, MilanLongInt* verLocInd, MilanReal* edgeLocWeight,
@@ -58,7 +60,6 @@ void dMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 		MilanLongInt* msgIndSent, MilanLongInt* msgActualSent, MilanReal* msgPercent,
 		MilanReal* ph0_time, MilanReal* ph1_time, MilanReal* ph2_time,
 		MilanLongInt* ph1_card, MilanLongInt* ph2_card ) {
-#if !defined(SERIAL_MPI)
   MPI_Comm C_comm=MPI_Comm_f2c(icomm);
 
 #ifdef DEBUG
@@ -72,7 +73,7 @@ void dMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
   double tmr = MPI_Wtime();
 #endif
 
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
 	//fprintf(stderr,"Warning: using buggy OpenMP matching!\n");
         dalgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(NLVer, NLEdge,
 							   verLocPtr, verLocInd, edgeLocWeight,
@@ -97,7 +98,6 @@ void dMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 	fprintf(stderr, "Elaboration time: %f for %ld nodes\n", tmr, NLVer);
 #endif
 	
-#endif
 }
 
 void sMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
@@ -108,13 +108,12 @@ void sMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 		MilanLongInt* msgIndSent, MilanLongInt* msgActualSent, MilanReal* msgPercent,
 		MilanReal* ph0_time, MilanReal* ph1_time, MilanReal* ph2_time,
 		MilanLongInt* ph1_card, MilanLongInt* ph2_card ) {
-#if !defined(SERIAL_MPI)
   MPI_Comm C_comm=MPI_Comm_f2c(icomm);
 #ifdef DEBUG
   fprintf(stderr,"MatchBoxPC: rank %d nlver %ld nledge %ld [ %ld %ld ]\n",
 	  myRank,NLVer, NLEdge,verDistance[0],verDistance[1]);
 #endif
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
 	//fprintf(stderr,"Warning: using buggy OpenMP matching!\n");
   salgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(NLVer, NLEdge,
 							      verLocPtr, verLocInd, edgeLocWeight,
@@ -132,9 +131,10 @@ void sMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 							    ph0_time, ph1_time, ph2_time,
 							    ph1_card, ph2_card );
 #endif
-#endif
 }
 
+#endif
+  
 #ifdef __cplusplus
 }
 #endif

amgprec/impl/aggregator/MatchBoxPC.h

@@ -59,7 +59,10 @@
 #include <assert.h>
 #include <map>
 #include <vector>
-#ifdef OPENMP
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
+
+#ifdef PSB_OPENMP
 // OpenMP is included and used if and only if the OpenMP version of the matching
 // is required
 #include "omp.h"
@@ -82,7 +85,6 @@ const int BundleTag = 9;  // Predefined tag
 
 static vector<MilanLongInt> DEFAULT_VECTOR;
 
-#if !defined(SERIAL_MPI)
 
 // MPI type map
 template <typename T>
@@ -95,14 +97,12 @@ template <>
 inline MPI_Datatype TypeMap<double>() { return MPI_DOUBLE; }
 template <>
 inline MPI_Datatype TypeMap<float>() { return MPI_FLOAT; }
-#endif
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-#if !defined(SERIAL_MPI)
 
 #define MilanMpiLongInt MPI_LONG_LONG
 
@@ -117,7 +117,7 @@ extern "C"
 // Regular long integer:
 #ifndef LONG_INT_H
 #define LONG_INT_H
-#ifdef BIT64
+#ifdef AMG_MATCHBOXP_BIT64
     typedef int64_t MilanLongInt;
     typedef MPI_LONG MilanMpiLongInt;
 #else
@@ -163,7 +163,7 @@ extern "C"
 #define MilanIntMax INT32_MAX
 #define MilanIntMin INT32_MIN
 
-#ifdef BIT64
+#ifdef AMG_MATCHBOXP_BIT64
 #define MilanLongIntMax INT64_MAX
 #define MilanLongIntMin -INT64_MAX
 #else
@@ -630,8 +630,9 @@ is disabled there is no reason to actually compile or reference them. */
                      MilanReal *ph0_time, MilanReal *ph1_time, MilanReal *ph2_time,
                      MilanLongInt *ph1_card, MilanLongInt *ph2_card);
 
-#endif
+
 #ifdef __cplusplus
 }
 #endif
 #endif
+#endif

amgprec/impl/aggregator/Matching.c

@@ -0,0 +1,504 @@
+/*
+                             AMG4PSBLAS version 1.2
+    Algebraic Multigrid Package
+               based on PSBLAS (Parallel Sparse BLAS version 3.9)
+
+    (C) Copyright 2021
+
+        Salvatore Filippone
+        Pasqua D'Ambra
+        Fabio Durastante
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+      1. Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions, and the following disclaimer in the
+         documentation and/or other materials provided with the distribution.
+      3. The name of the AMG4PSBLAS group or the names of its contributors may
+         not be used to endorse or promote products derived from this
+         software without specific written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AMG4PSBLAS GROUP OR ITS CONTRIBUTORS
+    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+
+    Includes material from BootCMatch, see copyright below.
+*/
+
+/*
+                BootCMatch
+     Bootstrap AMG based on Compatible weighted Matching, version 0.9
+    (C) Copyright 2017
+                       Pasqua D'Ambra         IAC-CNR, IT
+                       Panayot S. Vassilevski Portland State University, OR USA
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions, and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+    3. The name of the BootCMatch group or the names of its contributors may
+       not be used to endorse or promote products derived from this
+       software without specific written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE BootCMatch GROUP OR ITS CONTRIBUTORS
+  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+
+*/
+#include "amg_config.h"
+#if defined(PSB_SERIAL_MPI)
+#include <stdlib.h>
+#include "psb_types.h"
+
+psb_l_t d_trymatch(psb_l_t rowindex, psb_l_t colindex,
+		     psb_l_t nrows_W, psb_l_t *W_i, psb_l_t *W_j, psb_d_t *W_data,
+		     psb_l_t *jrowindex, psb_l_t ljrowindex,
+		     psb_l_t *jcolindex, psb_l_t ljcolindex, psb_l_t *rmatch)
+{
+
+  psb_l_t tryrowmatch, trycolmatch;
+  psb_l_t i, j, k, nzrow_W, startj, kindex;
+  psb_d_t cweight, nweight; 
+
+  //  psb_l_t     *W_i = bcm_CSRMatrixI(W);
+  //  psb_l_t     *W_j = bcm_CSRMatrixJ(W);
+  //  psb_l_t     nrows_W  =  bcm_CSRMatrixNumRows(W);
+  //  psb_d_t  *W_data=bcm_CSRMatrixData(W);
+
+  k=-1;
+  i=0;
+  while (i<ljrowindex && k ==-1)
+    {
+      if(jrowindex[i]==colindex) k=i;
+      i++;
+    }
+  if(k >= 0)
+    {
+      ljrowindex=ljrowindex-1;
+      for(i=k; i<ljrowindex; ++i) jrowindex[i]=jrowindex[i+1];
+    }
+
+  k=-1;
+  i=0;
+  while(i<ljcolindex && k==-1)
+    {
+      if(jcolindex[i]==rowindex) k=i;
+      i++;
+    }
+  if(k >= 0)
+    {
+      ljcolindex=ljcolindex-1;
+      for(i=k; i<ljcolindex; ++i) jcolindex[i]=jcolindex[i+1];
+    }
+
+  nzrow_W=W_i[rowindex+1]-W_i[rowindex];
+  startj=W_i[rowindex];
+  kindex=-1;
+  k=0;
+  while(k<nzrow_W && kindex==-1) 
+    {
+      if(W_j[startj+k]==colindex) kindex=startj+k;
+      k++;
+    }
+  cweight=W_data[kindex];
+
+  while((rmatch[rowindex]==-1 && rmatch[colindex]==-1)
+	&& (ljrowindex !=0 || ljcolindex !=0))    
+    {
+
+      if (rmatch[rowindex] == -1 && ljrowindex !=0)
+	{
+	  tryrowmatch=jrowindex[0];
+	  nzrow_W=W_i[rowindex+1]-W_i[rowindex];
+	  startj=W_i[rowindex];
+	  k=0;
+	  kindex=-1;
+	  while(k<nzrow_W && kindex==-1) 
+	    {
+	      if(W_j[startj+k]==tryrowmatch) kindex=startj+k;
+	      k++;
+	    }
+	  nweight=W_data[kindex];
+
+	  ljrowindex=ljrowindex-1;
+	  for(i=0; i<ljrowindex; ++i) jrowindex[i]=jrowindex[i+1];
+        
+	  if(nweight > cweight && rmatch[tryrowmatch]==-1)
+	    {
+          
+              nzrow_W=W_i[tryrowmatch+1]-W_i[tryrowmatch];
+	      psb_l_t *trymatchindexrow;
+	      trymatchindexrow= (psb_l_t *) calloc(nzrow_W, sizeof(psb_l_t));
+
+	      startj=W_i[tryrowmatch];
+	      for(k=0; k<nzrow_W; ++k) trymatchindexrow[k]=W_j[startj+k]; 
+
+	      d_trymatch(rowindex,tryrowmatch,
+			   nrows_W, W_i, W_j, W_data,
+			   jrowindex,ljrowindex,
+			   trymatchindexrow,nzrow_W,rmatch);
+	      free(trymatchindexrow);
+	    }
+	}
+
+      if(rmatch[colindex]==-1 && ljcolindex!=0)
+	{
+	  trycolmatch=jcolindex[0];
+	  nzrow_W=W_i[colindex+1]-W_i[colindex];
+	  startj=W_i[colindex];
+	  k=0;
+	  kindex=-1;
+	  while(k<nzrow_W && kindex==-1) 
+	    {
+	      if(W_j[startj+k]==trycolmatch) kindex=startj+k;
+	      k++;
+	    }
+	  nweight=W_data[kindex];
+
+	  ljcolindex=ljcolindex-1;
+	  for(i=0; i<ljcolindex; ++i) jcolindex[i]=jcolindex[i+1];
+        
+	  if(nweight > cweight && rmatch[trycolmatch]==-1)
+	    {
+	      nzrow_W=W_i[trycolmatch+1]-W_i[trycolmatch];
+	      psb_l_t *trymatchindexcol;
+	      trymatchindexcol= (psb_l_t *) calloc(nzrow_W, sizeof(psb_l_t));
+
+	      startj=W_i[trycolmatch];
+	      for(k=0; k<nzrow_W; ++k) trymatchindexcol[k]=W_j[startj+k];
+
+	      d_trymatch(colindex,trycolmatch,
+			   nrows_W, W_i, W_j, W_data,			   
+			   jcolindex,ljcolindex,
+			   trymatchindexcol,nzrow_W,rmatch);
+	      free(trymatchindexcol);
+	    }
+	}
+    }
+        
+  if(rmatch[rowindex]==-1 & rmatch[colindex]==-1)
+    {
+      rmatch[rowindex]=colindex;
+      rmatch[colindex]=rowindex;
+    }
+
+  return 0;
+}
+
+
+
+
+psb_l_t *d_CSRMatrixHMatch( psb_l_t  nrows_B,  psb_l_t  ncols_B,
+			       psb_l_t  nnz_B,  psb_l_t     *B_i,
+			       psb_l_t     *B_j, psb_d_t  *B_data)
+{
+
+  psb_l_t i, j, k, *rmatch;
+  psb_d_t  *c, alpha;
+  psb_l_t jbp, nzrows_B;
+  psb_d_t tmp=0.0;
+  psb_l_t rno, cno, nzrows_cno, startj, ljrowindex, ljjrowindex;
+  psb_l_t *jrowindex, *jjrowindex;
+
+#if 0
+  psb_l_t     *B_i = bcm_CSRMatrixI(B);
+  psb_l_t     *B_j = bcm_CSRMatrixJ(B);
+  psb_d_t  *B_data = bcm_CSRMatrixData(B);
+  psb_l_t  nrows_B  =  bcm_CSRMatrixNumRows(B);
+  psb_l_t  ncols_B  =  bcm_CSRMatrixNumCols(B);
+  psb_l_t  nnz_B  =  bcm_CSRMatrixNumNonzeros(B);
+#endif
+  //  assert(nrows_B==ncols_B);
+
+  rmatch = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+
+  for(i=0; i<nrows_B; ++i)  rmatch[i]=-1;
+
+  jrowindex = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+  jjrowindex = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+
+  jbp=0;
+  for(i=0; i< nrows_B; ++i)
+    { 
+      nzrows_B=B_i[i+1]-B_i[i];
+
+      for(j=0; j<nzrows_B; ++j) jrowindex[j]=B_j[jbp+j];
+      for(j=0; j<nzrows_B; ++j)
+	{
+	  rno=i;
+	  cno=B_j[jbp+j];
+
+	  startj=B_i[cno];
+	  nzrows_cno=B_i[cno+1]-startj;
+
+	  for(k=0; k<nzrows_cno; ++k) jjrowindex[k]=B_j[startj+k];
+
+	  if(rmatch[rno] == -1 && rmatch[cno] == -1)
+	    d_trymatch(rno,cno,nrows_B,B_i,B_j,B_data,
+			 jrowindex,nzrows_B,jjrowindex,nzrows_cno,rmatch);
+        
+	}
+
+      jbp=jbp+nzrows_B;
+    }
+   
+  free(jrowindex);
+  free(jjrowindex);
+  
+  return rmatch;
+}
+
+
+void dMatching(psb_l_t NLVer, psb_l_t NLEdge,
+	       psb_l_t *verLocPtr, psb_l_t *verLocInd, psb_d_t *edgeLocWeight,
+	       psb_l_t *verDistance, psb_l_t *Mate)
+{
+  psb_l_t *lmate;
+  lmate = d_CSRMatrixHMatch( NLVer, NLVer,   NLEdge,
+			       verLocPtr, verLocInd,edgeLocWeight);
+  for (psb_l_t i=0; i<NLVer; i++){
+    Mate[i] = lmate[i];
+  }
+  free(lmate);
+  return;
+}
+
+
+psb_l_t s_trymatch(psb_l_t rowindex, psb_l_t colindex,
+		     psb_l_t nrows_W, psb_l_t *W_i, psb_l_t *W_j, psb_s_t *W_data,
+		     psb_l_t *jrowindex, psb_l_t ljrowindex,
+		     psb_l_t *jcolindex, psb_l_t ljcolindex, psb_l_t *rmatch)
+{
+
+  psb_l_t tryrowmatch, trycolmatch;
+  psb_l_t i, j, k, nzrow_W, startj, kindex;
+  psb_s_t cweight, nweight; 
+
+  //  psb_l_t     *W_i = bcm_CSRMatrixI(W);
+  //  psb_l_t     *W_j = bcm_CSRMatrixJ(W);
+  //  psb_l_t     nrows_W  =  bcm_CSRMatrixNumRows(W);
+  //  psb_s_t  *W_data=bcm_CSRMatrixData(W);
+
+  k=-1;
+  i=0;
+  while (i<ljrowindex && k ==-1)
+    {
+      if(jrowindex[i]==colindex) k=i;
+      i++;
+    }
+  if(k >= 0)
+    {
+      ljrowindex=ljrowindex-1;
+      for(i=k; i<ljrowindex; ++i) jrowindex[i]=jrowindex[i+1];
+    }
+
+  k=-1;
+  i=0;
+  while(i<ljcolindex && k==-1)
+    {
+      if(jcolindex[i]==rowindex) k=i;
+      i++;
+    }
+  if(k >= 0)
+    {
+      ljcolindex=ljcolindex-1;
+      for(i=k; i<ljcolindex; ++i) jcolindex[i]=jcolindex[i+1];
+    }
+
+  nzrow_W=W_i[rowindex+1]-W_i[rowindex];
+  startj=W_i[rowindex];
+  kindex=-1;
+  k=0;
+  while(k<nzrow_W && kindex==-1) 
+    {
+      if(W_j[startj+k]==colindex) kindex=startj+k;
+      k++;
+    }
+  cweight=W_data[kindex];
+
+  while((rmatch[rowindex]==-1 && rmatch[colindex]==-1)
+	&& (ljrowindex !=0 || ljcolindex !=0))    
+    {
+
+      if (rmatch[rowindex] == -1 && ljrowindex !=0)
+	{
+	  tryrowmatch=jrowindex[0];
+	  nzrow_W=W_i[rowindex+1]-W_i[rowindex];
+	  startj=W_i[rowindex];
+	  k=0;
+	  kindex=-1;
+	  while(k<nzrow_W && kindex==-1) 
+	    {
+	      if(W_j[startj+k]==tryrowmatch) kindex=startj+k;
+	      k++;
+	    }
+	  nweight=W_data[kindex];
+
+	  ljrowindex=ljrowindex-1;
+	  for(i=0; i<ljrowindex; ++i) jrowindex[i]=jrowindex[i+1];
+        
+	  if(nweight > cweight && rmatch[tryrowmatch]==-1)
+	    {
+          
+              nzrow_W=W_i[tryrowmatch+1]-W_i[tryrowmatch];
+	      psb_l_t *trymatchindexrow;
+	      trymatchindexrow= (psb_l_t *) calloc(nzrow_W, sizeof(psb_l_t));
+
+	      startj=W_i[tryrowmatch];
+	      for(k=0; k<nzrow_W; ++k) trymatchindexrow[k]=W_j[startj+k]; 
+
+	      s_trymatch(rowindex,tryrowmatch,
+			   nrows_W, W_i, W_j, W_data,
+			   jrowindex,ljrowindex,
+			   trymatchindexrow,nzrow_W,rmatch);
+	      free(trymatchindexrow);
+	    }
+	}
+
+      if(rmatch[colindex]==-1 && ljcolindex!=0)
+	{
+	  trycolmatch=jcolindex[0];
+	  nzrow_W=W_i[colindex+1]-W_i[colindex];
+	  startj=W_i[colindex];
+	  k=0;
+	  kindex=-1;
+	  while(k<nzrow_W && kindex==-1) 
+	    {
+	      if(W_j[startj+k]==trycolmatch) kindex=startj+k;
+	      k++;
+	    }
+	  nweight=W_data[kindex];
+
+	  ljcolindex=ljcolindex-1;
+	  for(i=0; i<ljcolindex; ++i) jcolindex[i]=jcolindex[i+1];
+        
+	  if(nweight > cweight && rmatch[trycolmatch]==-1)
+	    {
+	      nzrow_W=W_i[trycolmatch+1]-W_i[trycolmatch];
+	      psb_l_t *trymatchindexcol;
+	      trymatchindexcol= (psb_l_t *) calloc(nzrow_W, sizeof(psb_l_t));
+
+	      startj=W_i[trycolmatch];
+	      for(k=0; k<nzrow_W; ++k) trymatchindexcol[k]=W_j[startj+k];
+
+	      s_trymatch(colindex,trycolmatch,
+			   nrows_W, W_i, W_j, W_data,			   
+			   jcolindex,ljcolindex,
+			   trymatchindexcol,nzrow_W,rmatch);
+	      free(trymatchindexcol);
+	    }
+	}
+    }
+        
+  if(rmatch[rowindex]==-1 & rmatch[colindex]==-1)
+    {
+      rmatch[rowindex]=colindex;
+      rmatch[colindex]=rowindex;
+    }
+
+  return 0;
+}
+
+
+
+
+psb_l_t *s_CSRMatrixHMatch( psb_l_t  nrows_B,  psb_l_t  ncols_B,
+			       psb_l_t  nnz_B,  psb_l_t     *B_i,
+			       psb_l_t     *B_j, psb_s_t  *B_data)
+{
+
+  psb_l_t i, j, k, *rmatch;
+  psb_s_t  *c, alpha;
+  psb_l_t jbp, nzrows_B;
+  psb_s_t tmp=0.0;
+  psb_l_t rno, cno, nzrows_cno, startj, ljrowindex, ljjrowindex;
+  psb_l_t *jrowindex, *jjrowindex;
+
+#if 0
+  psb_l_t     *B_i = bcm_CSRMatrixI(B);
+  psb_l_t     *B_j = bcm_CSRMatrixJ(B);
+  psb_s_t  *B_data = bcm_CSRMatrixData(B);
+  psb_l_t  nrows_B  =  bcm_CSRMatrixNumRows(B);
+  psb_l_t  ncols_B  =  bcm_CSRMatrixNumCols(B);
+  psb_l_t  nnz_B  =  bcm_CSRMatrixNumNonzeros(B);
+#endif
+  //  assert(nrows_B==ncols_B);
+
+  rmatch = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+
+  for(i=0; i<nrows_B; ++i)  rmatch[i]=-1;
+
+  jrowindex = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+  jjrowindex = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+
+  jbp=0;
+  for(i=0; i< nrows_B; ++i)
+    { 
+      nzrows_B=B_i[i+1]-B_i[i];
+
+      for(j=0; j<nzrows_B; ++j) jrowindex[j]=B_j[jbp+j];
+      for(j=0; j<nzrows_B; ++j)
+	{
+	  rno=i;
+	  cno=B_j[jbp+j];
+
+	  startj=B_i[cno];
+	  nzrows_cno=B_i[cno+1]-startj;
+
+	  for(k=0; k<nzrows_cno; ++k) jjrowindex[k]=B_j[startj+k];
+
+	  if(rmatch[rno] == -1 && rmatch[cno] == -1)
+	    s_trymatch(rno,cno,nrows_B,B_i,B_j,B_data,
+			 jrowindex,nzrows_B,jjrowindex,nzrows_cno,rmatch);
+        
+	}
+
+      jbp=jbp+nzrows_B;
+    }
+   
+  free(jrowindex);
+  free(jjrowindex);
+  
+  return rmatch;
+}
+
+
+void sMatching(psb_l_t NLVer, psb_l_t NLEdge,
+	       psb_l_t *verLocPtr, psb_l_t *verLocInd, psb_s_t *edgeLocWeight,
+	       psb_l_t *verDistance, psb_l_t *Mate)
+{
+
+  psb_l_t *lmate;
+  lmate = s_CSRMatrixHMatch( NLVer, NLVer,   NLEdge,
+			       verLocPtr, verLocInd,edgeLocWeight);
+  for (psb_l_t i=0; i<NLVer; i++){
+    Mate[i] = lmate[i];
+  }
+  free(lmate);
+  return;
+}
+
+#endif

amgprec/impl/aggregator/Matching.h

@@ -0,0 +1,81 @@
+/*
+                             AMG4PSBLAS version 1.2
+    Algebraic Multigrid Package
+               based on PSBLAS (Parallel Sparse BLAS version 3.9)
+
+    (C) Copyright 2021
+
+        Salvatore Filippone
+        Pasqua D'Ambra
+        Fabio Durastante
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+      1. Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions, and the following disclaimer in the
+         documentation and/or other materials provided with the distribution.
+      3. The name of the AMG4PSBLAS group or the names of its contributors may
+         not be used to endorse or promote products derived from this
+         software without specific written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AMG4PSBLAS GROUP OR ITS CONTRIBUTORS
+    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+
+    Includes material from BootCMatch, see copyright below.
+*/
+
+/*
+                BootCMatch
+     Bootstrap AMG based on Compatible weighted Matching, version 0.9
+    (C) Copyright 2017
+                       Pasqua D'Ambra         IAC-CNR, IT
+                       Panayot S. Vassilevski Portland State University, OR USA
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions, and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+    3. The name of the BootCMatch group or the names of its contributors may
+       not be used to endorse or promote products derived from this
+       software without specific written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE BootCMatch GROUP OR ITS CONTRIBUTORS
+  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+
+*/
+#include "amg_config.h"
+
+#if defined(PSB_SERIAL_MPI)
+#include "psb_types.h"
+void dMatching(psb_l_t NLVer, psb_l_t NLEdge,
+	       psb_l_t *verLocPtr, psb_l_t *verLocInd, psb_d_t *edgeLocWeight,
+	       psb_l_t *verDistance, psb_l_t *Mate);
+void sMatching(psb_l_t NLVer, psb_l_t NLEdge,
+	       psb_l_t *verLocPtr, psb_l_t *verLocInd, psb_s_t *edgeLocWeight,
+	       psb_l_t *verDistance, psb_l_t *Mate);
+#endif

amgprec/impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC.cpp

@@ -70,7 +70,7 @@
  Statistics: ph1_card, ph2_card : Size: |P| number of processes in the comm-world (number of matched edges in Phase 1 and Phase 2)
  */
 
-#ifdef SERIAL_MPI
+#ifdef PSB_SERIAL_MPI
 #else
 
 // DOUBLE PRECISION VERSION
@@ -86,7 +86,7 @@ void dalgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC(
 							      MilanReal* msgPercent,
                                                               MilanReal* ph0_time, MilanReal* ph1_time, MilanReal* ph2_time,
                                                               MilanLongInt* ph1_card, MilanLongInt* ph2_card ) {
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 #ifdef PRINT_DEBUG_INFO_
     cout<<"\n("<<myRank<<")Within algoEdgeApproxDominatingEdgesLinearSearchMessageBundling()"; fflush(stdout);
 #endif
@@ -1313,7 +1313,7 @@ void salgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC(
       MilanReal* msgPercent,
       MilanReal* ph0_time, MilanReal* ph1_time, MilanReal* ph2_time,
       MilanLongInt* ph1_card, MilanLongInt* ph2_card ) {
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 #ifdef PRINT_DEBUG_INFO_
     cout<<"\n("<<myRank<<")Within algoEdgeApproxDominatingEdgesLinearSearchMessageBundling()"; fflush(stdout);
 #endif

amgprec/impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.cpp

@@ -70,7 +70,7 @@
  Statistics: ph1_card, ph2_card : Size: |P| number of processes in the comm-world (number of matched edges in Phase 1 and Phase 2)
  */
 //#define DEBUG_HANG_
-#ifdef SERIAL_MPI
+#ifdef PSB_SERIAL_MPI
 #else
 
 // DOUBLE PRECISION VERSION
@@ -102,7 +102,7 @@ void dalgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(
      *            i+1-th value is the position of the first element on the i+1-th row
      */
 
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 #ifdef PRINT_DEBUG_INFO_
     cout << "\n(" << myRank << ")Within algoEdgeApproxDominatingEdgesLinearSearchMessageBundling()";
     fflush(stdout);
@@ -583,7 +583,7 @@ void salgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(
      *            i+1-th value is the position of the first element on the i+1-th row
      */
 
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 #ifdef PRINT_DEBUG_INFO_
     cout << "\n(" << myRank << ")Within algoEdgeApproxDominatingEdgesLinearSearchMessageBundling()";
     fflush(stdout);

amgprec/impl/aggregator/amg_c_ptap_bld.f90

@@ -488,7 +488,7 @@ subroutine amg_lc_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
   integer(psb_lpk_) :: nrow, nglob, ncol, ntaggr, nrl, nzl, ip, &
        &  nzt, naggrm1, naggrp1, i, k
   integer(psb_lpk_) ::  nrsave, ncsave, nzsave, nza
-  logical, parameter :: do_timings=.true., oldstyle=.false., debug=.false.  
+  logical, parameter :: do_timings=.false., oldstyle=.false., debug=.false.  
   integer(psb_ipk_), save :: idx_spspmm=-1
 
   name='amg_ptap_bld'

amgprec/impl/aggregator/amg_c_soc1_map_bld.F90

@@ -72,7 +72,7 @@ subroutine amg_c_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod
   use amg_base_prec_type
   use amg_c_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
   implicit none
@@ -103,7 +103,7 @@ subroutine amg_c_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)   :: name, ch_err
   integer(psb_ipk_), save :: idx_soc1_p1=-1, idx_soc1_p2=-1, idx_soc1_p3=-1
   integer(psb_ipk_), save :: idx_soc1_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc1_map_bld'
@@ -172,7 +172,7 @@ subroutine amg_c_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk

amgprec/impl/aggregator/amg_c_soc2_map_bld.F90

@@ -71,7 +71,7 @@ subroutine amg_c_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod 
   use amg_base_prec_type
   use amg_c_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
 
@@ -104,7 +104,7 @@ subroutine amg_c_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)  :: name, ch_err
   integer(psb_ipk_), save :: idx_soc2_p1=-1, idx_soc2_p2=-1, idx_soc2_p3=-1
   integer(psb_ipk_), save :: idx_soc2_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc2_map_bld'
@@ -211,7 +211,7 @@ subroutine amg_c_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk

amgprec/impl/aggregator/amg_d_parmatch_aggregator_inner_mat_asb.F90

@@ -98,11 +98,7 @@ subroutine  amg_d_parmatch_aggregator_inner_mat_asb(ag,parms,a,desc_a,&
      & ac,desc_ac, op_prol,op_restr,info)
   use psb_base_mod
   use amg_base_prec_type
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_aggregator_inner_mat_asb
-#endif
   implicit none
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
   type(amg_dml_parms), intent(inout)    :: parms
@@ -133,8 +129,6 @@ subroutine  amg_d_parmatch_aggregator_inner_mat_asb(ag,parms,a,desc_a,&
   ictxt = desc_a%get_context()
   call psb_info(ictxt,me,np)
 
-#if !defined(SERIAL_MPI)
-
   if (debug) write(0,*) me,' ',trim(name),' Start:',&
        & allocated(ag%ac),allocated(ag%desc_ac), allocated(ag%prol),allocated(ag%restr)
 
@@ -146,16 +140,17 @@ subroutine  amg_d_parmatch_aggregator_inner_mat_asb(ag,parms,a,desc_a,&
   case(amg_repl_mat_)
     !
     !
-    info = psb_err_internal_error_
-    call psb_errpush(info,name,a_err='no repl coarse_mat_ here')
-    goto 9999
-
+    if (np>1) then 
+      info = psb_err_internal_error_
+      call psb_errpush(info,name,a_err='no repl coarse_mat_ here')
+      goto 9999
+    end if
   case default
     info = psb_err_internal_error_
     call psb_errpush(info,name,a_err='invalid amg_coarse_mat_')
     goto 9999
   end select
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_aggregator_mat_asb.F90

@@ -98,11 +98,7 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
      & ac,desc_ac, op_prol,op_restr,info)
   use psb_base_mod
   use amg_base_prec_type
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_aggregator_mat_asb
-#endif
   implicit none
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
   type(amg_dml_parms), intent(inout)    :: parms
@@ -112,7 +108,7 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
   type(psb_desc_type), intent(inout)    :: desc_ac
   integer(psb_ipk_), intent(out)        :: info
   !
-  type(psb_ctxt_type)         :: ictxt
+  type(psb_ctxt_type)         :: ctxt
   integer(psb_ipk_)           :: np, me
   type(psb_ld_coo_sparse_mat) :: tmpcoo
   type(psb_ldspmat_type)      :: tmp_ac
@@ -128,15 +124,13 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
   debug_unit  = psb_get_debug_unit()
   debug_level = psb_get_debug_level()
   info  = psb_success_
-  ictxt = desc_a%get_context()
-  call psb_info(ictxt,me,np)
+  ctxt = desc_a%get_context()
+  call psb_info(ctxt,me,np)
   if (psb_get_errstatus().ne.0) then
     write(0,*) me,' From:',trim(name),':',psb_get_errstatus()
     return
   end if
 
-
-#if !defined(SERIAL_MPI)
   if (debug) write(0,*) me,' ',trim(name),' Start:',&
        & allocated(ag%ac),allocated(ag%desc_ac), allocated(ag%prol),allocated(ag%restr)
 
@@ -169,22 +163,21 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
     call op_prol%mv_to(tmpcoo)
     nzl = tmpcoo%get_nzeros()
     call psb_loc_to_glob(tmpcoo%ja(1:nzl),desc_ac,info,'I')
+    call tmpcoo%set_ncols(i_nr)
     call op_prol%mv_from(tmpcoo)
 
     call op_restr%mv_to(tmpcoo)
     nzl = tmpcoo%get_nzeros()
     call psb_loc_to_glob(tmpcoo%ia(1:nzl),desc_ac,info,'I')
+    call tmpcoo%set_nrows(i_nr)
     call op_restr%mv_from(tmpcoo)
 
-    call op_prol%set_ncols(i_nr)
-    call op_restr%set_nrows(i_nr)
-
     call psb_gather(tmp_ac,ac,desc_ac,info,root=-ione,&
          & dupl=psb_dupl_add_,keeploc=.false.)
     call tmp_ac%mv_to(tmpcoo)
     call ac%mv_from(tmpcoo)
 
-    call psb_cdall(ictxt,desc_ac,info,mg=ntaggr,repl=.true.)
+    call psb_cdall(ctxt,desc_ac,info,mg=ntaggr,repl=.true.)
     if (info == psb_success_) call psb_cdasb(desc_ac,info)
     !
     ! Now that we have the descriptors and the restrictor, we should
@@ -199,7 +192,7 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
     call psb_errpush(info,name,a_err='invalid amg_coarse_mat_')
     goto 9999
   end select
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_aggregator_mat_bld.F90

@@ -135,11 +135,7 @@ subroutine  amg_d_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
   use psb_base_mod
   use amg_d_inner_mod
   use amg_base_prec_type
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_aggregator_mat_bld
-#endif
   implicit none
 
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
@@ -176,7 +172,6 @@ subroutine  amg_d_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
   ! algorithm specified by
   !
 
-#if !defined(SERIAL_MPI)
   call clean_shortcuts(ag)
   !
   ! When requesting smoothed aggregation we cannot use the
@@ -212,14 +207,12 @@ subroutine  amg_d_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
     call psb_errpush(psb_err_from_subroutine_,name,a_err='Inner aggrmat asb')
     goto 9999
   end if
-#endif
   call psb_erractionrestore(err_act)
   return
 
 9999 call psb_error_handler(err_act)
   return
 
-#if !defined(SERIAL_MPI)
 
 contains
   subroutine clean_shortcuts(ag)
@@ -248,5 +241,4 @@ contains
       end if
     end if
   end subroutine clean_shortcuts
-#endif
 end subroutine amg_d_parmatch_aggregator_mat_bld

amgprec/impl/aggregator/amg_d_parmatch_aggregator_tprol.F90

@@ -47,11 +47,7 @@ subroutine  amg_d_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
   use psb_base_mod
   use amg_base_prec_type
   use amg_d_inner_mod
-#if defined(SERIAL_MPI)
-  use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_aggregator_build_tprol
-#endif
   use iso_c_binding
   implicit none
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
@@ -88,7 +84,7 @@ subroutine  amg_d_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
   type(psb_ldspmat_type)              :: tmp_prol, tmp_pg, tmp_restr
   type(psb_desc_type)                 :: tmp_desc_ac, tmp_desc_ax, tmp_desc_p
   integer(psb_ipk_), save             :: idx_mboxp=-1, idx_spmmbld=-1, idx_sweeps_mult=-1
-  logical, parameter :: dump=.false., do_timings=.true., debug=.false., &
+  logical, parameter :: dump=.false., do_timings=.false., debug=.false., &
        & dump_prol_restr=.false.
 
   name='d_parmatch_tprol'
@@ -120,8 +116,6 @@ subroutine  amg_d_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
        &   amg_aggr_ord_nat_,is_legal_ml_aggr_ord)
   call amg_check_def(parms%aggr_thresh,'Aggr_Thresh',dzero,is_legal_d_aggr_thrs)
 
-#if !defined(SERIAL_MPI)
-
   match_algorithm = ag%matching_alg
   n_sweeps        = ag%n_sweeps
   if (2**n_sweeps /= ag%orig_aggr_size) then
@@ -466,7 +460,7 @@ subroutine  amg_d_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
     call psb_errpush(psb_err_from_subroutine_,name,a_err='amg_bootCMatch_if')
     goto 9999
   end if
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_smth_bld.F90

@@ -110,11 +110,7 @@ subroutine amg_d_parmatch_smth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
   use amg_base_prec_type
   use amg_d_inner_mod
   use amg_d_base_aggregator_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_smth_bld
-#endif
   implicit none
 
   ! Arguments
@@ -194,8 +190,6 @@ subroutine amg_d_parmatch_smth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
 
   if (do_timings) call psb_tic(idx_phase1)
 
-#if !defined(SERIAL_MPI)
-
   naggr  = nlaggr(me+1)
   ntaggr = sum(nlaggr)
   naggrm1 = sum(nlaggr(1:me))
@@ -403,7 +397,7 @@ subroutine amg_d_parmatch_smth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done smooth_aggregate '
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_spmm_bld.F90

@@ -99,11 +99,7 @@ subroutine amg_d_parmatch_spmm_bld(a,desc_a,ilaggr,nlaggr,parms,&
      & ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_d_inner_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_spmm_bld
-#endif
   implicit none
 
   ! Arguments
@@ -140,7 +136,6 @@ subroutine amg_d_parmatch_spmm_bld(a,desc_a,ilaggr,nlaggr,parms,&
   debug_unit  = psb_get_debug_unit()
   debug_level = psb_get_debug_level()
 
-#if !defined(SERIAL_MPI)
   call a%cp_to(acsr)
 
   call  amg_d_parmatch_spmm_bld_inner(acsr,desc_a,ilaggr,nlaggr,parms,&
@@ -154,7 +149,7 @@ subroutine amg_d_parmatch_spmm_bld(a,desc_a,ilaggr,nlaggr,parms,&
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done spmm_bld '
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_spmm_bld_inner.F90

@@ -99,11 +99,7 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
      & ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_d_inner_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_spmm_bld_inner
-#endif
   implicit none
 
   ! Arguments
@@ -131,7 +127,7 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
        &  nzt, naggrm1, naggrp1, i, k
   integer(psb_lpk_), allocatable :: ia(:),ja(:)
   !integer(psb_lpk_) ::  nrsave, ncsave, nzsave, nza, nrpsave, ncpsave, nzpsave
-  logical, parameter :: do_timings=.true., oldstyle=.false., debug=.false.
+  logical, parameter :: do_timings=.false., oldstyle=.false., debug=.false.
   integer(psb_ipk_), save :: idx_spspmm=-1, idx_prolcnv=-1, idx_proltrans=-1, idx_asb=-1
 
   name='amg_parmatch_spmm_bld_inner'
@@ -139,7 +135,6 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
   info=psb_success_
   call psb_erractionsave(err_act)
 
-
   ictxt = desc_a%get_context()
   call psb_info(ictxt, me, np)
   debug_unit  = psb_get_debug_unit()
@@ -163,7 +158,6 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
   naggrm1 = sum(nlaggr(1:me))
   naggrp1 = sum(nlaggr(1:me+1))
 
-#if !defined(SERIAL_MPI)
   !
   ! Here T_PROL should be arriving with GLOBAL indices on the cols
   ! and LOCAL indices on the rows.
@@ -203,11 +197,10 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
     goto 9999
   end if
 
-
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done smooth_aggregate '
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_spmm_bld_ov.F90

@@ -99,11 +99,7 @@ subroutine amg_d_parmatch_spmm_bld_ov(a,desc_a,ilaggr,nlaggr,parms,&
      & ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_d_inner_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_spmm_bld_ov
-#endif
   implicit none
 
   ! Arguments
@@ -141,8 +137,6 @@ subroutine amg_d_parmatch_spmm_bld_ov(a,desc_a,ilaggr,nlaggr,parms,&
   debug_unit  = psb_get_debug_unit()
   debug_level = psb_get_debug_level()
 
-#if !defined(SERIAL_MPI)
-
   call a%mv_to(acsr)
 
   call  amg_d_parmatch_spmm_bld_inner(acsr,desc_a,ilaggr,nlaggr,parms,&
@@ -158,7 +152,6 @@ subroutine amg_d_parmatch_spmm_bld_ov(a,desc_a,ilaggr,nlaggr,parms,&
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done spmm_bld '
-#endif
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_unsmth_bld.F90

@@ -109,11 +109,7 @@ subroutine amg_d_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
   use amg_base_prec_type
   use amg_d_inner_mod
   use amg_d_base_aggregator_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_unsmth_bld
-#endif
   implicit none
 
   ! Arguments
@@ -168,7 +164,6 @@ subroutine amg_d_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
     goto 9999
   end if
 
-#if !defined(SERIAL_MPI)
   nglob = desc_a%get_global_rows()
   nrow  = desc_a%get_local_rows()
   ncol  = desc_a%get_local_cols()
@@ -209,7 +204,8 @@ subroutine amg_d_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
   call op_prol%mv_from(coo_prol)
 
   if (debug) write(0,*)  me,' ',trim(name),' After  mv_from',psb_get_errstatus()
-  if (debug) write(0,*)  me,' ',trim(name),' ',ac%get_fmt(),ac%get_nrows(),ac%get_ncols(),ac%get_nzeros(),naggr,ntaggr
+  if (debug) write(0,*)  me,' ',trim(name),' ',ac%get_fmt(),ac%get_nrows(),&
+       & ac%get_ncols(),ac%get_nzeros(),naggr,ntaggr
   ! write(0,*)  me,' ',trim(name),' Final AC newstyle ',ac%get_fmt(),ac%get_nrows(),ac%get_ncols(),ac%get_nzeros()
 
   if (debug) then
@@ -236,7 +232,6 @@ subroutine amg_d_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
     goto 9999
   end if
 
-#endif
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_ptap_bld.f90

@@ -488,7 +488,7 @@ subroutine amg_ld_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
   integer(psb_lpk_) :: nrow, nglob, ncol, ntaggr, nrl, nzl, ip, &
        &  nzt, naggrm1, naggrp1, i, k
   integer(psb_lpk_) ::  nrsave, ncsave, nzsave, nza
-  logical, parameter :: do_timings=.true., oldstyle=.false., debug=.false.  
+  logical, parameter :: do_timings=.false., oldstyle=.false., debug=.false.  
   integer(psb_ipk_), save :: idx_spspmm=-1
 
   name='amg_ptap_bld'

amgprec/impl/aggregator/amg_d_soc1_map_bld.F90

@@ -72,7 +72,7 @@ subroutine amg_d_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod
   use amg_base_prec_type
   use amg_d_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
   implicit none
@@ -103,7 +103,7 @@ subroutine amg_d_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)   :: name, ch_err
   integer(psb_ipk_), save :: idx_soc1_p1=-1, idx_soc1_p2=-1, idx_soc1_p3=-1
   integer(psb_ipk_), save :: idx_soc1_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc1_map_bld'
@@ -172,7 +172,7 @@ subroutine amg_d_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk

amgprec/impl/aggregator/amg_d_soc2_map_bld.F90

@@ -71,7 +71,7 @@ subroutine amg_d_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod 
   use amg_base_prec_type
   use amg_d_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
 
@@ -104,7 +104,7 @@ subroutine amg_d_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)  :: name, ch_err
   integer(psb_ipk_), save :: idx_soc2_p1=-1, idx_soc2_p2=-1, idx_soc2_p3=-1
   integer(psb_ipk_), save :: idx_soc2_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc2_map_bld'
@@ -211,7 +211,7 @@ subroutine amg_d_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk

amgprec/impl/aggregator/amg_s_parmatch_aggregator_inner_mat_asb.F90

@@ -98,11 +98,7 @@ subroutine  amg_s_parmatch_aggregator_inner_mat_asb(ag,parms,a,desc_a,&
      & ac,desc_ac, op_prol,op_restr,info)
   use psb_base_mod
   use amg_base_prec_type
-#if defined(SERIAL_MPI)
-    use amg_s_parmatch_aggregator_mod
-#else
   use amg_s_parmatch_aggregator_mod, amg_protect_name => amg_s_parmatch_aggregator_inner_mat_asb
-#endif
   implicit none
   class(amg_s_parmatch_aggregator_type), target, intent(inout) :: ag
   type(amg_sml_parms), intent(inout)    :: parms
@@ -133,8 +129,6 @@ subroutine  amg_s_parmatch_aggregator_inner_mat_asb(ag,parms,a,desc_a,&
   ictxt = desc_a%get_context()
   call psb_info(ictxt,me,np)
 
-#if !defined(SERIAL_MPI)
-
   if (debug) write(0,*) me,' ',trim(name),' Start:',&
        & allocated(ag%ac),allocated(ag%desc_ac), allocated(ag%prol),allocated(ag%restr)
 
@@ -146,16 +140,17 @@ subroutine  amg_s_parmatch_aggregator_inner_mat_asb(ag,parms,a,desc_a,&
   case(amg_repl_mat_)
     !
     !
-    info = psb_err_internal_error_
-    call psb_errpush(info,name,a_err='no repl coarse_mat_ here')
-    goto 9999
-
+    if (np>1) then 
+      info = psb_err_internal_error_
+      call psb_errpush(info,name,a_err='no repl coarse_mat_ here')
+      goto 9999
+    end if
   case default
     info = psb_err_internal_error_
     call psb_errpush(info,name,a_err='invalid amg_coarse_mat_')
     goto 9999
   end select
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_s_parmatch_aggregator_mat_asb.F90

@@ -98,11 +98,7 @@ subroutine  amg_s_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
      & ac,desc_ac, op_prol,op_restr,info)
   use psb_base_mod
   use amg_base_prec_type
-#if defined(SERIAL_MPI)
-    use amg_s_parmatch_aggregator_mod
-#else
   use amg_s_parmatch_aggregator_mod, amg_protect_name => amg_s_parmatch_aggregator_mat_asb
-#endif
   implicit none
   class(amg_s_parmatch_aggregator_type), target, intent(inout) :: ag
   type(amg_sml_parms), intent(inout)    :: parms
@@ -112,7 +108,7 @@ subroutine  amg_s_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
   type(psb_desc_type), intent(inout)    :: desc_ac
   integer(psb_ipk_), intent(out)        :: info
   !
-  type(psb_ctxt_type)         :: ictxt
+  type(psb_ctxt_type)         :: ctxt
   integer(psb_ipk_)           :: np, me
   type(psb_ls_coo_sparse_mat) :: tmpcoo
   type(psb_lsspmat_type)      :: tmp_ac
@@ -128,15 +124,13 @@ subroutine  amg_s_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
   debug_unit  = psb_get_debug_unit()
   debug_level = psb_get_debug_level()
   info  = psb_success_
-  ictxt = desc_a%get_context()
-  call psb_info(ictxt,me,np)
+  ctxt = desc_a%get_context()
+  call psb_info(ctxt,me,np)
   if (psb_get_errstatus().ne.0) then
     write(0,*) me,' From:',trim(name),':',psb_get_errstatus()
     return
   end if
 
-
-#if !defined(SERIAL_MPI)
   if (debug) write(0,*) me,' ',trim(name),' Start:',&
        & allocated(ag%ac),allocated(ag%desc_ac), allocated(ag%prol),allocated(ag%restr)
 
@@ -169,22 +163,21 @@ subroutine  amg_s_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
     call op_prol%mv_to(tmpcoo)
     nzl = tmpcoo%get_nzeros()
     call psb_loc_to_glob(tmpcoo%ja(1:nzl),desc_ac,info,'I')
+    call tmpcoo%set_ncols(i_nr)
     call op_prol%mv_from(tmpcoo)
 
     call op_restr%mv_to(tmpcoo)
     nzl = tmpcoo%get_nzeros()
     call psb_loc_to_glob(tmpcoo%ia(1:nzl),desc_ac,info,'I')
+    call tmpcoo%set_nrows(i_nr)
     call op_restr%mv_from(tmpcoo)
 
-    call op_prol%set_ncols(i_nr)
-    call op_restr%set_nrows(i_nr)
-
     call psb_gather(tmp_ac,ac,desc_ac,info,root=-ione,&
          & dupl=psb_dupl_add_,keeploc=.false.)
     call tmp_ac%mv_to(tmpcoo)
     call ac%mv_from(tmpcoo)
 
-    call psb_cdall(ictxt,desc_ac,info,mg=ntaggr,repl=.true.)
+    call psb_cdall(ctxt,desc_ac,info,mg=ntaggr,repl=.true.)
     if (info == psb_success_) call psb_cdasb(desc_ac,info)
     !
     ! Now that we have the descriptors and the restrictor, we should
@@ -199,7 +192,7 @@ subroutine  amg_s_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
     call psb_errpush(info,name,a_err='invalid amg_coarse_mat_')
     goto 9999
   end select
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_s_parmatch_aggregator_mat_bld.F90

@@ -135,11 +135,7 @@ subroutine  amg_s_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
   use psb_base_mod
   use amg_s_inner_mod
   use amg_base_prec_type
-#if defined(SERIAL_MPI)
-    use amg_s_parmatch_aggregator_mod
-#else
   use amg_s_parmatch_aggregator_mod, amg_protect_name => amg_s_parmatch_aggregator_mat_bld
-#endif
   implicit none
 
   class(amg_s_parmatch_aggregator_type), target, intent(inout) :: ag
@@ -176,7 +172,6 @@ subroutine  amg_s_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
   ! algorithm specified by
   !
 
-#if !defined(SERIAL_MPI)
   call clean_shortcuts(ag)
   !
   ! When requesting smoothed aggregation we cannot use the
@@ -212,14 +207,12 @@ subroutine  amg_s_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
     call psb_errpush(psb_err_from_subroutine_,name,a_err='Inner aggrmat asb')
     goto 9999
   end if
-#endif
   call psb_erractionrestore(err_act)
   return
 
 9999 call psb_error_handler(err_act)
   return
 
-#if !defined(SERIAL_MPI)
 
 contains
   subroutine clean_shortcuts(ag)
@@ -248,5 +241,4 @@ contains
       end if
     end if
   end subroutine clean_shortcuts
-#endif
 end subroutine amg_s_parmatch_aggregator_mat_bld

amgprec/impl/aggregator/amg_s_parmatch_aggregator_tprol.F90

@@ -47,11 +47,7 @@ subroutine  amg_s_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
   use psb_base_mod
   use amg_base_prec_type
   use amg_s_inner_mod
-#if defined(SERIAL_MPI)
-  use amg_s_parmatch_aggregator_mod
-#else
   use amg_s_parmatch_aggregator_mod, amg_protect_name => amg_s_parmatch_aggregator_build_tprol
-#endif
   use iso_c_binding
   implicit none
   class(amg_s_parmatch_aggregator_type), target, intent(inout) :: ag
@@ -88,7 +84,7 @@ subroutine  amg_s_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
   type(psb_lsspmat_type)              :: tmp_prol, tmp_pg, tmp_restr
   type(psb_desc_type)                 :: tmp_desc_ac, tmp_desc_ax, tmp_desc_p
   integer(psb_ipk_), save             :: idx_mboxp=-1, idx_spmmbld=-1, idx_sweeps_mult=-1
-  logical, parameter :: dump=.false., do_timings=.true., debug=.false., &
+  logical, parameter :: dump=.false., do_timings=.false., debug=.false., &
        & dump_prol_restr=.false.
 
   name='s_parmatch_tprol'
@@ -120,8 +116,6 @@ subroutine  amg_s_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
        &   amg_aggr_ord_nat_,is_legal_ml_aggr_ord)
   call amg_check_def(parms%aggr_thresh,'Aggr_Thresh',szero,is_legal_s_aggr_thrs)
 
-#if !defined(SERIAL_MPI)
-
   match_algorithm = ag%matching_alg
   n_sweeps        = ag%n_sweeps
   if (2**n_sweeps /= ag%orig_aggr_size) then
@@ -466,7 +460,7 @@ subroutine  amg_s_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
     call psb_errpush(psb_err_from_subroutine_,name,a_err='amg_bootCMatch_if')
     goto 9999
   end if
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_s_parmatch_smth_bld.F90

@@ -110,11 +110,7 @@ subroutine amg_s_parmatch_smth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
   use amg_base_prec_type
   use amg_s_inner_mod
   use amg_s_base_aggregator_mod
-#if defined(SERIAL_MPI)
-    use amg_s_parmatch_aggregator_mod
-#else
   use amg_s_parmatch_aggregator_mod, amg_protect_name => amg_s_parmatch_smth_bld
-#endif
   implicit none
 
   ! Arguments
@@ -194,8 +190,6 @@ subroutine amg_s_parmatch_smth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
 
   if (do_timings) call psb_tic(idx_phase1)
 
-#if !defined(SERIAL_MPI)
-
   naggr  = nlaggr(me+1)
   ntaggr = sum(nlaggr)
   naggrm1 = sum(nlaggr(1:me))
@@ -403,7 +397,7 @@ subroutine amg_s_parmatch_smth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done smooth_aggregate '
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_s_parmatch_spmm_bld.F90

@@ -99,11 +99,7 @@ subroutine amg_s_parmatch_spmm_bld(a,desc_a,ilaggr,nlaggr,parms,&
      & ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_s_inner_mod
-#if defined(SERIAL_MPI)
-    use amg_s_parmatch_aggregator_mod
-#else
   use amg_s_parmatch_aggregator_mod, amg_protect_name => amg_s_parmatch_spmm_bld
-#endif
   implicit none
 
   ! Arguments
@@ -140,7 +136,6 @@ subroutine amg_s_parmatch_spmm_bld(a,desc_a,ilaggr,nlaggr,parms,&
   debug_unit  = psb_get_debug_unit()
   debug_level = psb_get_debug_level()
 
-#if !defined(SERIAL_MPI)
   call a%cp_to(acsr)
 
   call  amg_s_parmatch_spmm_bld_inner(acsr,desc_a,ilaggr,nlaggr,parms,&
@@ -154,7 +149,7 @@ subroutine amg_s_parmatch_spmm_bld(a,desc_a,ilaggr,nlaggr,parms,&
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done spmm_bld '
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_s_parmatch_spmm_bld_inner.F90

@@ -99,11 +99,7 @@ subroutine amg_s_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
      & ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_s_inner_mod
-#if defined(SERIAL_MPI)
-    use amg_s_parmatch_aggregator_mod
-#else
   use amg_s_parmatch_aggregator_mod, amg_protect_name => amg_s_parmatch_spmm_bld_inner
-#endif
   implicit none
 
   ! Arguments
@@ -131,7 +127,7 @@ subroutine amg_s_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
        &  nzt, naggrm1, naggrp1, i, k
   integer(psb_lpk_), allocatable :: ia(:),ja(:)
   !integer(psb_lpk_) ::  nrsave, ncsave, nzsave, nza, nrpsave, ncpsave, nzpsave
-  logical, parameter :: do_timings=.true., oldstyle=.false., debug=.false.
+  logical, parameter :: do_timings=.false., oldstyle=.false., debug=.false.
   integer(psb_ipk_), save :: idx_spspmm=-1, idx_prolcnv=-1, idx_proltrans=-1, idx_asb=-1
 
   name='amg_parmatch_spmm_bld_inner'
@@ -139,7 +135,6 @@ subroutine amg_s_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
   info=psb_success_
   call psb_erractionsave(err_act)
 
-
   ictxt = desc_a%get_context()
   call psb_info(ictxt, me, np)
   debug_unit  = psb_get_debug_unit()
@@ -163,7 +158,6 @@ subroutine amg_s_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
   naggrm1 = sum(nlaggr(1:me))
   naggrp1 = sum(nlaggr(1:me+1))
 
-#if !defined(SERIAL_MPI)
   !
   ! Here T_PROL should be arriving with GLOBAL indices on the cols
   ! and LOCAL indices on the rows.
@@ -203,11 +197,10 @@ subroutine amg_s_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
     goto 9999
   end if
 
-
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done smooth_aggregate '
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_s_parmatch_spmm_bld_ov.F90

@@ -99,11 +99,7 @@ subroutine amg_s_parmatch_spmm_bld_ov(a,desc_a,ilaggr,nlaggr,parms,&
      & ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_s_inner_mod
-#if defined(SERIAL_MPI)
-    use amg_s_parmatch_aggregator_mod
-#else
   use amg_s_parmatch_aggregator_mod, amg_protect_name => amg_s_parmatch_spmm_bld_ov
-#endif
   implicit none
 
   ! Arguments
@@ -141,8 +137,6 @@ subroutine amg_s_parmatch_spmm_bld_ov(a,desc_a,ilaggr,nlaggr,parms,&
   debug_unit  = psb_get_debug_unit()
   debug_level = psb_get_debug_level()
 
-#if !defined(SERIAL_MPI)
-
   call a%mv_to(acsr)
 
   call  amg_s_parmatch_spmm_bld_inner(acsr,desc_a,ilaggr,nlaggr,parms,&
@@ -158,7 +152,6 @@ subroutine amg_s_parmatch_spmm_bld_ov(a,desc_a,ilaggr,nlaggr,parms,&
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done spmm_bld '
-#endif
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_s_parmatch_unsmth_bld.F90

@@ -109,11 +109,7 @@ subroutine amg_s_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
   use amg_base_prec_type
   use amg_s_inner_mod
   use amg_s_base_aggregator_mod
-#if defined(SERIAL_MPI)
-    use amg_s_parmatch_aggregator_mod
-#else
   use amg_s_parmatch_aggregator_mod, amg_protect_name => amg_s_parmatch_unsmth_bld
-#endif
   implicit none
 
   ! Arguments
@@ -168,7 +164,6 @@ subroutine amg_s_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
     goto 9999
   end if
 
-#if !defined(SERIAL_MPI)
   nglob = desc_a%get_global_rows()
   nrow  = desc_a%get_local_rows()
   ncol  = desc_a%get_local_cols()
@@ -209,7 +204,8 @@ subroutine amg_s_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
   call op_prol%mv_from(coo_prol)
 
   if (debug) write(0,*)  me,' ',trim(name),' After  mv_from',psb_get_errstatus()
-  if (debug) write(0,*)  me,' ',trim(name),' ',ac%get_fmt(),ac%get_nrows(),ac%get_ncols(),ac%get_nzeros(),naggr,ntaggr
+  if (debug) write(0,*)  me,' ',trim(name),' ',ac%get_fmt(),ac%get_nrows(),&
+       & ac%get_ncols(),ac%get_nzeros(),naggr,ntaggr
   ! write(0,*)  me,' ',trim(name),' Final AC newstyle ',ac%get_fmt(),ac%get_nrows(),ac%get_ncols(),ac%get_nzeros()
 
   if (debug) then
@@ -236,7 +232,6 @@ subroutine amg_s_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
     goto 9999
   end if
 
-#endif
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_s_ptap_bld.f90

@@ -488,7 +488,7 @@ subroutine amg_ls_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
   integer(psb_lpk_) :: nrow, nglob, ncol, ntaggr, nrl, nzl, ip, &
        &  nzt, naggrm1, naggrp1, i, k
   integer(psb_lpk_) ::  nrsave, ncsave, nzsave, nza
-  logical, parameter :: do_timings=.true., oldstyle=.false., debug=.false.  
+  logical, parameter :: do_timings=.false., oldstyle=.false., debug=.false.  
   integer(psb_ipk_), save :: idx_spspmm=-1
 
   name='amg_ptap_bld'

amgprec/impl/aggregator/amg_s_soc1_map_bld.F90

@@ -72,7 +72,7 @@ subroutine amg_s_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod
   use amg_base_prec_type
   use amg_s_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
   implicit none
@@ -103,7 +103,7 @@ subroutine amg_s_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)   :: name, ch_err
   integer(psb_ipk_), save :: idx_soc1_p1=-1, idx_soc1_p2=-1, idx_soc1_p3=-1
   integer(psb_ipk_), save :: idx_soc1_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc1_map_bld'
@@ -172,7 +172,7 @@ subroutine amg_s_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk

amgprec/impl/aggregator/amg_s_soc2_map_bld.F90

@@ -71,7 +71,7 @@ subroutine amg_s_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod 
   use amg_base_prec_type
   use amg_s_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
 
@@ -104,7 +104,7 @@ subroutine amg_s_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)  :: name, ch_err
   integer(psb_ipk_), save :: idx_soc2_p1=-1, idx_soc2_p2=-1, idx_soc2_p3=-1
   integer(psb_ipk_), save :: idx_soc2_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc2_map_bld'
@@ -211,7 +211,7 @@ subroutine amg_s_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk

amgprec/impl/aggregator/amg_z_ptap_bld.f90

@@ -488,7 +488,7 @@ subroutine amg_lz_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
   integer(psb_lpk_) :: nrow, nglob, ncol, ntaggr, nrl, nzl, ip, &
        &  nzt, naggrm1, naggrp1, i, k
   integer(psb_lpk_) ::  nrsave, ncsave, nzsave, nza
-  logical, parameter :: do_timings=.true., oldstyle=.false., debug=.false.  
+  logical, parameter :: do_timings=.false., oldstyle=.false., debug=.false.  
   integer(psb_ipk_), save :: idx_spspmm=-1
 
   name='amg_ptap_bld'

amgprec/impl/aggregator/amg_z_soc1_map_bld.F90

@@ -72,7 +72,7 @@ subroutine amg_z_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod
   use amg_base_prec_type
   use amg_z_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
   implicit none
@@ -103,7 +103,7 @@ subroutine amg_z_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)   :: name, ch_err
   integer(psb_ipk_), save :: idx_soc1_p1=-1, idx_soc1_p2=-1, idx_soc1_p3=-1
   integer(psb_ipk_), save :: idx_soc1_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc1_map_bld'
@@ -172,7 +172,7 @@ subroutine amg_z_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk

amgprec/impl/aggregator/amg_z_soc2_map_bld.F90

@@ -71,7 +71,7 @@ subroutine amg_z_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod 
   use amg_base_prec_type
   use amg_z_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
 
@@ -104,7 +104,7 @@ subroutine amg_z_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)  :: name, ch_err
   integer(psb_ipk_), save :: idx_soc2_p1=-1, idx_soc2_p2=-1, idx_soc2_p3=-1
   integer(psb_ipk_), save :: idx_soc2_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc2_map_bld'
@@ -211,7 +211,7 @@ subroutine amg_z_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk

amgprec/impl/aggregator/clean.cpp

@@ -1,6 +1,6 @@
 #include "MatchBoxPC.h"
 // TODO comment
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 
 void clean(MilanLongInt NLVer,
            MilanInt myRank,

amgprec/impl/aggregator/computeCandidateMate.cpp

@@ -8,6 +8,7 @@
  * @param edgeLocWeight
  * @return
  */
+#if !defined(PSB_SERIAL_MPI)
 
 MilanLongInt firstComputeCandidateMateD(MilanLongInt adj1,
                                        MilanLongInt adj2,
@@ -136,3 +137,4 @@ MilanLongInt computeCandidateMateS(MilanLongInt adj1,
     return w;
 }
 
+#endif

amgprec/impl/aggregator/dataStrStaticQueue.h

@@ -41,7 +41,10 @@
 
 #ifndef _static_Queue_
 #define _static_Queue_
+#include "amg_config.h"
 
+
+#if !defined(PSB_SERIAL_MPI)
 #include "primitiveDataTypeDefinitions.h"
 #include "preProcessorDirectives.h"
 
@@ -199,3 +202,4 @@ class staticQueue
 };
 
 #endif
+#endif

amgprec/impl/aggregator/extractUChunk.cpp

@@ -1,4 +1,8 @@
+#include "amg_config.h"
 #include "MatchBoxPC.h"
+
+#if !defined(PSB_SERIAL_MPI)
+
 void extractUChunk(
     vector<MilanLongInt> &UChunkBeingProcessed,
     vector<MilanLongInt> &U,
@@ -28,3 +32,4 @@ void extractUChunk(
 
     } // End of critical U // End of critical U
 }
+#endif

amgprec/impl/aggregator/findOwnerOfGhost.cpp

@@ -1,4 +1,6 @@
+#include "amg_config.h"
 #include "MatchBoxPC.h"
+#if !defined(PSB_SERIAL_MPI)
 /// Find the owner of a ghost node:
 MilanInt findOwnerOfGhost(MilanLongInt vtxIndex, MilanLongInt *mVerDistance,
                           MilanInt myRank, MilanInt numProcs)
@@ -26,3 +28,4 @@ MilanInt findOwnerOfGhost(MilanLongInt vtxIndex, MilanLongInt *mVerDistance,
 
   return Current;
 } // End of findOwnerOfGhost()
+#endif

amgprec/impl/aggregator/initialize.cpp

@@ -1,4 +1,7 @@
+#include "amg_config.h"
 #include "MatchBoxPC.h"
+#if !defined(PSB_SERIAL_MPI)
+
 void initialize(MilanLongInt NLVer, MilanLongInt NLEdge,
                 MilanLongInt StartIndex, MilanLongInt EndIndex,
                 MilanLongInt *numGhostEdges,
@@ -301,3 +304,4 @@ void initialize(MilanLongInt NLVer, MilanLongInt NLEdge,
         } // End of single region
     }     // End of parallel region
 }
+#endif

amgprec/impl/aggregator/isAlreadyMatched.cpp

@@ -1,4 +1,7 @@
+#include "amg_config.h"
 #include "MatchBoxPC.h"
+#if !defined(PSB_SERIAL_MPI)
+
 /**
  * //TODO documentation
  * @param k
@@ -43,3 +46,4 @@ bool isAlreadyMatched(MilanLongInt node,
 
     return val >= 0; // Already matched
 }
+#endif

amgprec/impl/aggregator/parallelComputeCandidateMateB.cpp

@@ -1,4 +1,6 @@
+#include "amg_config.h"
 #include "MatchBoxPC.h"
+#if !defined(PSB_SERIAL_MPI)
 
 void PARALLEL_COMPUTE_CANDIDATE_MATE_BD(MilanLongInt NLVer,
                                               MilanLongInt *verLocPtr,
@@ -53,4 +55,4 @@ void PARALLEL_COMPUTE_CANDIDATE_MATE_BS(MilanLongInt NLVer,
         }
     }
 }
-
+#endif

amgprec/impl/aggregator/preProcessorDirectives.h

@@ -41,6 +41,8 @@
 
 #ifndef _preprocessor_Directives_
 #define _preprocessor_Directives_
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
 
 //I/O
 #include <iostream>
@@ -72,10 +74,10 @@
 #include <map>
 
 //MPI:
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 #include "mpi.h"
 #endif
 
 
-
+#endif
 #endif

amgprec/impl/aggregator/primitiveDataTypeDefinitions.h

@@ -41,14 +41,16 @@
 
 #ifndef _primitiveDataType_Definition_
 #define _primitiveDataType_Definition_
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
 
 #include "preProcessorDirectives.h"
 
 using namespace std;
 
 //Comment out these if you do not need 64 bits.
-//#ifndef BIT64
-//	#define BIT64
+//#ifndef AMG_MATCHBOXP_BIT64
+//	#define AMG_MATCHBOXP_BIT64
 //#endif
 
 //Regular integer:
@@ -61,7 +63,7 @@ using namespace std;
 //Regular long Integer:
 #ifndef LONG_INT_H
 #define LONG_INT_H
-	#ifdef BIT64
+	#ifdef AMG_MATCHBOXP_BIT64
 	typedef int64_t MilanLongInt;
 //	typedef MPI_LONG MilanMpiLongInt;
 	#else
@@ -106,7 +108,7 @@ using namespace std;
 #define MilanIntMax INT_MAX
 #define MilanIntMin INT_MIN
 
-#ifdef BIT64
+#ifdef AMG_MATCHBOXP_BIT64
 	#define MilanLongIntMax LONG_MAX
 	#define MilanLongIntMin -LONG_MAX
 #else
@@ -152,5 +154,5 @@ const float FMINUS_INFINITY = -FPLUS_INFINITY;
 
 
 #endif
-
+#endif
 #endif

amgprec/impl/aggregator/processCrossEdge.cpp

@@ -1,3 +1,5 @@
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
 #include "MatchBoxPC.h"
 void PROCESS_CROSS_EDGE(MilanLongInt *edge,
                         MilanLongInt *S)
@@ -21,3 +23,4 @@ void PROCESS_CROSS_EDGE(MilanLongInt *edge,
 
     // End: PARALLEL_PROCESS_CROSS_EDGE_B
 }
+#endif

amgprec/impl/aggregator/processExposedVertex.cpp

@@ -1,3 +1,5 @@
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
 #include "MatchBoxPC.h" 
 void PARALLEL_PROCESS_EXPOSED_VERTEX_BD(MilanLongInt NLVer,
                                        MilanLongInt *candidateMate,
@@ -367,3 +369,4 @@ void PARALLEL_PROCESS_EXPOSED_VERTEX_BS(MilanLongInt NLVer,
     } // End of parallel region
 }
 
+#endif

amgprec/impl/aggregator/processMatchedVertices.cpp

@@ -1,3 +1,5 @@
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
 #include "MatchBoxPC.h"
 void processMatchedVerticesD(
     MilanLongInt NLVer,
@@ -583,3 +585,4 @@ void processMatchedVerticesS(
     } // End of parallel region
 }
 
+#endif

amgprec/impl/aggregator/processMatchedVerticesAndSendMessages.cpp

@@ -1,3 +1,5 @@
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
 #include "MatchBoxPC.h"
 //#define DEBUG_HANG_
 void processMatchedVerticesAndSendMessagesD(
@@ -589,3 +591,4 @@ void processMatchedVerticesAndSendMessagesS(
 #endif
 }
 
+#endif

amgprec/impl/aggregator/processMessages.cpp

@@ -1,6 +1,7 @@
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
 #include "MatchBoxPC.h"
 //#define DEBUG_HANG_
-#if !defined(SERIAL_MPI)
 
 void processMessagesD(
     MilanLongInt NLVer,

amgprec/impl/aggregator/queueTransfer.cpp

@@ -1,3 +1,5 @@
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
 #include "MatchBoxPC.h"
 void queuesTransfer(vector<MilanLongInt> &U,
                     vector<MilanLongInt> &privateU,
@@ -31,3 +33,4 @@ void queuesTransfer(vector<MilanLongInt> &U,
 
 }
 
+#endif

amgprec/impl/aggregator/sendBundledMessages.cpp

@@ -1,3 +1,5 @@
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
 #include "MatchBoxPC.h"
 void sendBundledMessages(MilanLongInt *numGhostEdges,
 			 MilanInt *BufferSize,
@@ -154,7 +156,7 @@ void sendBundledMessages(MilanLongInt *numGhostEdges,
 
 #pragma omp task depend(inout : OneMessageSize, *BufferSize) depend(out : numMessagesToSend) depend(in : *numGhostEdges)
 {
-
+  
 #ifdef PRINT_DEBUG_INFO_
   cout << "\n(" << myRank << ")Number of Ghost edges = " << *numGhostEdges;
   cout << "\n(" << myRank << ")Total number of potential message X 2 = " << *numGhostEdges * 2;
@@ -206,3 +208,4 @@ void sendBundledMessages(MilanLongInt *numGhostEdges,
 }
 }
 }
+#endif

amgprec/impl/amg_c_extprol_bld.F90

@@ -127,9 +127,9 @@ subroutine amg_c_extprol_bld(a,desc_a,p,prolv,restrv,info,amold,vmold,imold)
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Entering '
-#if defined(LPK8)
+#if defined(PSB_LPK8)
   info=psb_err_internal_error_
-  call psb_errpush(info,name,a_err='Need fix for LPK8')
+  call psb_errpush(info,name,a_err='Need fix for PSB_LPK8')
   goto 9999
 #else
   
@@ -373,9 +373,9 @@ contains
     info = psb_success_
     ctxt = desc_a%get_context()
     call psb_info(ctxt,me,np)
-#if defined(LPK8)
+#if defined(PSB_LPK8)
     info=psb_err_internal_error_
-    call psb_errpush(info,name,a_err='Need fix for LPK8')
+    call psb_errpush(info,name,a_err='Need fix for PSB_LPK8')
     goto 9999
 #else
     allocate(nlaggr(np),ilaggr(1))

amgprec/impl/amg_ccprecset.F90

@@ -90,10 +90,10 @@ subroutine amg_ccprecseti(p,what,val,info,ilev,ilmax,pos,idx)
   use amg_c_ainv_solver
   use amg_c_invk_solver
   use amg_c_invt_solver
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
   use amg_c_slu_solver
 #endif
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   use amg_c_mumps_solver
 #endif
 
@@ -329,10 +329,10 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
   use amg_c_ainv_solver
   use amg_c_invk_solver
   use amg_c_invt_solver
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
   use amg_c_slu_solver
 #endif
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   use amg_c_mumps_solver
 #endif
   use amg_c_krm_solver, only : amg_c_krm_solver_type
@@ -480,9 +480,9 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
           select case (psb_toupper(string))
           case('BJAC')
             call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
 #else
             call p%precv(nlev_)%set('SUB_SOLVE',amg_ilu_n_,info,pos=pos)
@@ -494,9 +494,9 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
 
           case('L1-BJAC')
             call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_l1_bjac_,info,pos=pos)
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
 #else
             call p%precv(nlev_)%set('SUB_SOLVE',amg_ilu_n_,info,pos=pos)
@@ -506,14 +506,14 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
                & amg_distr_mat_)
             call p%precv(nlev_)%set('COARSE_MAT',amg_distr_mat_,info)
           case('SLU')
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
             call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
             if (hier_asb) &
                  & call amg_warn_coarse_mat(p%precv(nlev_)%parms%get_coarse_mat(),&
                  & amg_repl_mat_)
             call p%precv(nlev_)%set('COARSE_MAT',amg_repl_mat_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
             call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
             if (hier_asb) &
@@ -550,7 +550,7 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
                  & amg_repl_mat_)
             call p%precv(nlev_)%set('COARSE_MAT',amg_repl_mat_,info,pos=pos)
           case('MUMPS')
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
             call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
             if (hier_asb) &
@@ -566,14 +566,14 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
             call p%precv(nlev_)%set('COARSE_MAT',amg_distr_mat_,info,pos=pos)
 #endif
          case('UMF')
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
             call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
             if (hier_asb) &
                  & call amg_warn_coarse_mat(p%precv(nlev_)%parms%get_coarse_mat(),&
                  & amg_repl_mat_)
             call p%precv(nlev_)%set('COARSE_MAT',amg_repl_mat_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
             call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
             if (hier_asb) &
@@ -590,14 +590,14 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
 #endif
 
           case('SLUDIST')
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
             call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
             if (hier_asb) &
                  & call amg_warn_coarse_mat(p%precv(nlev_)%parms%get_coarse_mat(),&
                  & amg_repl_mat_)
             call p%precv(nlev_)%set('COARSE_MAT',amg_repl_mat_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
             call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
             call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
             if (hier_asb) &
@@ -709,9 +709,9 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
         select case (psb_toupper(trim(string)))
         case('BJAC')
           call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
 #else
           call p%precv(nlev_)%set('SUB_SOLVE',amg_ilu_n_,info,pos=pos)
@@ -722,9 +722,9 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
           call p%precv(nlev_)%set('COARSE_MAT',amg_distr_mat_,info)
         case('L1-BJAC')
           call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_l1_bjac_,info,pos=pos)
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
 #else
           call p%precv(nlev_)%set('SUB_SOLVE',amg_ilu_n_,info,pos=pos)
@@ -734,14 +734,14 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
                & amg_distr_mat_)
           call p%precv(nlev_)%set('COARSE_MAT',amg_distr_mat_,info)
         case('SLU')
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
           call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
           if (hier_asb) &
                & call amg_warn_coarse_mat(p%precv(nlev_)%parms%get_coarse_mat(),&
                & amg_repl_mat_)
           call p%precv(nlev_)%set('COARSE_MAT',amg_repl_mat_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
           call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
           if (hier_asb) &
@@ -778,7 +778,7 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
                & amg_repl_mat_)
           call p%precv(nlev_)%set('COARSE_MAT',amg_repl_mat_,info,pos=pos)
         case('MUMPS')
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
           call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
           if (hier_asb) &
@@ -794,14 +794,14 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
           call p%precv(nlev_)%set('COARSE_MAT',amg_distr_mat_,info,pos=pos)
 #endif
         case('UMF')
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
           call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
           if (hier_asb) &
                & call amg_warn_coarse_mat(p%precv(nlev_)%parms%get_coarse_mat(),&
                & amg_repl_mat_)
           call p%precv(nlev_)%set('COARSE_MAT',amg_repl_mat_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
           call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
           if (hier_asb) &
@@ -818,14 +818,14 @@ subroutine amg_ccprecsetc(p,what,string,info,ilev,ilmax,pos,idx)
 #endif
 
         case('SLUDIST')
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
           call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_slu_,info,pos=pos)
           if (hier_asb) &
                & call amg_warn_coarse_mat(p%precv(nlev_)%parms%get_coarse_mat(),&
                & amg_repl_mat_)
           call p%precv(nlev_)%set('COARSE_MAT',amg_repl_mat_,info,pos=pos)
-#elif defined(HAVE_MUMPS_)
+#elif defined(AMG_HAVE_MUMPS)
           call p%precv(nlev_)%set('SMOOTHER_TYPE',amg_bjac_,info,pos=pos)
           call p%precv(nlev_)%set('SUB_SOLVE',amg_mumps_,info,pos=pos)
           if (hier_asb) &

amgprec/impl/amg_cprecinit.F90

@@ -99,7 +99,7 @@ subroutine amg_cprecinit(ctxt,prec,ptype,info)
   use amg_c_ilu_solver
   use amg_c_gs_solver
 
-#if defined(HAVE_SLU_)
+#if defined(AMG_HAVE_SLU)
   use amg_c_slu_solver
 #endif
 
@@ -230,9 +230,9 @@ subroutine amg_cprecinit(ctxt,prec,ptype,info)
     end do
     call prec%set('ML_CYCLE','VCYCLE',info)
     call prec%set('SMOOTHER_TYPE','FBGS',info)
-#if  defined(HAVE_MUMPS_)
+#if  defined(AMG_HAVE_MUMPS)
     call prec%set('COARSE_SOLVE','MUMPS',info)
-#elif defined(HAVE_SLU_)
+#elif defined(AMG_HAVE_SLU)
     call prec%set('COARSE_SOLVE','SLU',info)
 #else
     call prec%set('COARSE_SOLVE','ILU',info)

amgprec/impl/amg_cslu_interface.c

@@ -88,8 +88,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * October 15, 2003
  *
  */
-
-#ifdef Have_SLU_
+#include "amg_config.h"
+#ifdef AMG_HAVE_SLU
 #include "slu_cdefs.h"
 #define HANDLE_SIZE  8
 
@@ -111,7 +111,7 @@ typedef struct {
 
 
 int  amg_cslu_fact(int n, int nnz, 
-#ifdef HAVE_SLU_
+#ifdef AMG_HAVE_SLU
 		   complex *values,
 #else
 		   void *values,
@@ -128,7 +128,7 @@ int  amg_cslu_fact(int n, int nnz,
  *
  */
  
-#ifdef Have_SLU_
+#ifdef AMG_HAVE_SLU
     SuperMatrix A, AC;
     SuperMatrix *L, *U;
     int *perm_r; /* row permutations from partial pivoting */
@@ -177,10 +177,10 @@ int  amg_cslu_fact(int n, int nnz,
     
     panel_size = sp_ienv(1);
     relax = sp_ienv(2);
-#if defined(SLU_VERSION_5)
+#if defined(AMG_SLU_VERSION_5)
     cgstrf(&options, &AC, relax, panel_size, etree,
 	   NULL, 0, perm_c, perm_r, L, U, &Glu, &stat, &info);
-#elif defined(SLU_VERSION_4)
+#elif defined(AMG_SLU_VERSION_4)
     cgstrf(&options, &AC, relax, panel_size, etree,
 	   NULL, 0, perm_c, perm_r, L, U, &stat, &info);
 #else
@@ -229,7 +229,7 @@ int  amg_cslu_fact(int n, int nnz,
 
 
 int amg_cslu_solve(int itrans, int n, int nrhs,
-#ifdef HAVE_SLU_
+#ifdef AMG_HAVE_SLU
 		   complex *b,
 #else
 		   void *b,
@@ -242,7 +242,7 @@ int amg_cslu_solve(int itrans, int n, int nrhs,
    *
    */
   int info;
-#ifdef Have_SLU_ 
+#ifdef AMG_HAVE_SLU 
     SuperMatrix  B;
     SuperMatrix *L, *U;
     int *perm_r; /* row permutations from partial pivoting */
@@ -304,7 +304,7 @@ int amg_cslu_free(void *f_factors)
  *      free all storage in the end
  *
  */
-#ifdef Have_SLU_ 
+#ifdef AMG_HAVE_SLU 
   factors_t *LUfactors; 
   
   /* Free the LU factors in the factors handle */