Merge Release v1.1.0

The Ginkgo team is proud to announce the new minor release of Ginkgo version 1.1.0. This release brings several performance improvements, adds Windows support, adds support for factorizations inside Ginkgo and a new ILU preconditioner based on ParILU algorithm, among other things. For detailed information, check the respective issue. Supported systems and requirements: + For all platforms, cmake 3.9+ + Linux and MacOS + gcc: 5.3+, 6.3+, 7.3+, 8.1+ + clang: 3.9+ + Intel compiler: 2017+ + Apple LLVM: 8.0+ + CUDA module: CUDA 9.0+ + Windows + MinGW and CygWin: gcc 5.3+, 6.3+, 7.3+, 8.1+ + Microsoft Visual Studio: VS 2017 15.7+ + CUDA module: CUDA 9.0+, Microsoft Visual Studio + OpenMP module: MinGW or CygWin. The current known issues can be found in the [known issues page](https://github.com/ginkgo-project/ginkgo/wiki/Known-Issues). Additions: + Upper and lower triangular solvers ([#327](#327), [#336](#336), [#341](#341), [#342](#342)) + New factorization support in Ginkgo, and addition of the ParILU algorithm ([#305](#305), [#315](#315), [#319](#319), [#324](#324)) + New ILU preconditioner ([#348](#348), [#353](#353)) + Windows MinGW and Cygwin support ([#347](#347)) + Windows Visual studio support ([#351](#351)) + New example showing how to use ParILU as a preconditioner ([#358](#358)) + New example on using loggers for debugging ([#360](#360)) + Add two new 9pt and 27pt stencil examples ([#300](#300), [#306](#306)) + Allow benchmarking CuSPARSE spmv formats through Ginkgo's benchmarks ([#303](#303)) + New benchmark for sparse matrix format conversions ([#312](https://github.com/ginkgo-project/ginkgo/issues/312)[#317](https://github.com/ginkgo-project/ginkgo/issues/317)) + Add conversions between CSR and Hybrid formats ([#302](#302), [#310](#310)) + Support for sorting rows in the CSR format by column idices ([#322](#322)) + Addition of a CUDA COO SpMM kernel for improved performance ([#345](#345)) + Addition of a LinOp to handle perturbations of the form (identity + scalar * basis * projector) ([#334](#334)) + New sparsity matrix representation format with Reference and OpenMP kernels ([#349](#349), [#350](#350)) Fixes: + Accelerate GMRES solver for CUDA executor ([#363](#363)) + Fix BiCGSTAB solver convergence ([#359](#359)) + Fix CGS logging by reporting the residual for every sub iteration ([#328](#328)) + Fix CSR,Dense->Sellp conversion's memory access violation ([#295](#295)) + Accelerate CSR->Ell,Hybrid conversions on CUDA ([#313](#313), [#318](#318)) + Fixed slowdown of COO SpMV on OpenMP ([#340](#340)) + Fix gcc 6.4.0 internal compiler error ([#316](#316)) + Fix compilation issue on Apple clang++ 10 ([#322](#322)) + Make Ginkgo able to compile on Intel 2017 and above ([#337](#337)) + Make the benchmarks spmv/solver use the same matrix formats ([#366](#366)) + Fix self-written isfinite function ([#348](#348)) + Fix Jacobi issues shown by cuda-memcheck Tools and ecosystem: + Multiple improvements to the CI system and tools ([#296](#296), [#311](#311), [#365](#365)) + Multiple improvements to the Ginkgo containers ([#328](#328), [#361](#361)) + Add sonarqube analysis to Ginkgo ([#304](#304), [#308](#308), [#309](#309)) + Add clang-tidy and iwyu support to Ginkgo ([#298](#298)) + Improve Ginkgo's support of xSDK M12 policy by adding the `TPL_` arguments to CMake ([#300](#300)) + Add support for the xSDK R7 policy ([#325](#325)) + Fix examples in html documentation ([#367](#367))
ginkgo-project · Oct 20, 2019 · b9bec82 · b9bec82
2 parents 4524464 + c217c76
commit b9bec82
Show file tree

Hide file tree

Showing 292 changed files with 41,877 additions and 2,894 deletions.
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
diff --git a/CHANGELOG.md b/CHANGELOG.md
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,17 +1,9 @@
 cmake_minimum_required(VERSION 3.9)
 
-project(Ginkgo LANGUAGES C CXX VERSION 1.0.0 DESCRIPTION "A numerical linear algebra library targeting many-core architectures")
+project(Ginkgo LANGUAGES C CXX VERSION 1.1.0 DESCRIPTION "A numerical linear algebra library targeting many-core architectures")
 set(Ginkgo_VERSION_TAG "master")
 set(PROJECT_VERSION_TAG ${Ginkgo_VERSION_TAG})
 
-# Load CMake helpers and modules
-include(cmake/build_helpers.cmake)
-include(cmake/create_test.cmake)
-include(cmake/install_helpers.cmake)
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
-
-include(cmake/build_type_helpers.cmake)
-
 # Ginkgo configuration options
 option(GINKGO_DEVEL_TOOLS "Add development tools to the build system" ON)
 option(GINKGO_BUILD_TESTS "Generate build files for unit tests" ON)
@@ -22,21 +14,41 @@ option(GINKGO_BUILD_OMP "Compile OpenMP kernels for CPU" OFF)
 option(GINKGO_BUILD_CUDA "Compile kernels for NVIDIA GPUs" OFF)
 option(GINKGO_BUILD_DOC "Generate documentation" OFF)
 option(GINKGO_SKIP_DEPENDENCY_UPDATE
-       "Do not update dependencies each time the project is rebuilt" ON)
+    "Do not update dependencies each time the project is rebuilt" ON)
 option(GINKGO_EXPORT_BUILD_DIR
     "Make Ginkgo export its build directory to the CMake package registry."
     OFF)
+option(GINKGO_WITH_CLANG_TIDY "Make Ginkgo call `clang-tidy` to find programming issues." OFF)
+option(GINKGO_WITH_IWYU "Make Ginkgo call `iwyu` (Include What You Use) to find include issues." OFF)
 set(GINKGO_VERBOSE_LEVEL "1" CACHE STRING
-  "Verbosity level. Put 0 to turn off. 1 activates a few important messages.")
-set(GINKGO_COMPILER_FLAGS "-Wpedantic" CACHE STRING
-  "Set the required CXX compiler flags, mainly used for warnings. Current default is `-Wpedantic`")
+    "Verbosity level. Put 0 to turn off. 1 activates a few important messages.")
+if(MSVC)
+    set(GINKGO_COMPILER_FLAGS "" CACHE STRING
+        "Set the required CXX compiler flags, mainly used for warnings. Current default is ``")
+else()
+    set(GINKGO_COMPILER_FLAGS "-Wpedantic" CACHE STRING
+        "Set the required CXX compiler flags, mainly used for warnings. Current default is `-Wpedantic`")
+endif()
 set(GINKGO_CUDA_COMPILER_FLAGS "" CACHE STRING
-  "Set the required NVCC compiler flags, mainly used for warnings. Current default is an empty string")
+    "Set the required NVCC compiler flags, mainly used for warnings. Current default is an empty string")
 set(GINKGO_CUDA_ARCHITECTURES "Auto" CACHE STRING
     "A list of target NVIDIA GPU achitectures. See README.md for more detail.")
+option(GINKGO_CUDA_DEFAULT_HOST_COMPILER "Tell Ginkgo to not automatically set the CUDA host compiler" OFF)
 option(GINKGO_JACOBI_FULL_OPTIMIZATIONS "Use all the optimizations for the CUDA Jacobi algorithm" OFF)
 option(BUILD_SHARED_LIBS "Build shared (.so, .dylib, .dll) libraries" ON)
 
+if(BUILD_SHARED_LIBS AND (WIN32 OR CYGWIN) AND (GINKGO_BUILD_TESTS OR GINKGO_BUILD_EXAMPLES OR GINKGO_BUILD_BENCHMARKS))
+    # Change shared libraries output only if this build has executable program with shared libraries.
+    set(GINKGO_CHANGED_SHARED_LIBRARY TRUE)
+    option(GINKGO_CHECK_PATH "Tell Ginkgo to check if the environment variable PATH is available for this build." ON)
+    set(GINKGO_WINDOWS_SHARED_LIBRARY_RELPATH "windows_shared_library" CACHE STRING
+        "Set Ginkgo's shared library relative path in windows. Current default is `windows_shared_library`. \
+        This absoulte path ${PROJECT_BINARY_DIR}/GINKGO_WINDOWS_SHARED_LIBRARY_RELPATH must be in the environment variable PATH.")
+    set(GINKGO_WINDOWS_SHARED_LIBRARY_PATH ${PROJECT_BINARY_DIR}/${GINKGO_WINDOWS_SHARED_LIBRARY_RELPATH})
+else()
+    set(GINKGO_CHANGED_SHARED_LIBRARY FALSE)
+endif()
+
 if(GINKGO_BUILD_TESTS AND (GINKGO_BUILD_CUDA OR GINKGO_BUILD_OMP))
     message(STATUS "GINKGO_BUILD_TESTS is ON, enabling GINKGO_BUILD_REFERENCE")
     set(GINKGO_BUILD_REFERENCE ON CACHE BOOL "Compile reference CPU kernels" FORCE)
@@ -49,7 +61,7 @@ endif()
 
 # Ensure we have a debug postfix
 if(NOT DEFINED CMAKE_DEBUG_POSTFIX)
-  set(CMAKE_DEBUG_POSTFIX "d")
+    set(CMAKE_DEBUG_POSTFIX "d")
 endif()
 
 if(GINKGO_BUILD_TESTS)
@@ -58,10 +70,29 @@ if(GINKGO_BUILD_TESTS)
         ${CMAKE_CURRENT_LIST_DIR}/cmake/CTestCustom.cmake.in
         ${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake @ONLY)
 
+    # For testing, we need some special matrices
+    add_subdirectory(matrices)
+
     enable_testing()
     include(CTest)
 endif()
 
+if (GINKGO_WITH_CLANG_TIDY)
+  find_program(GINKGO_CLANG_TIDY_PATH clang-tidy)
+endif()
+
+if (GINKGO_WITH_IWYU)
+  find_program(GINKGO_IWYU_PATH iwyu)
+endif()
+
+
+# Load CMake helpers and modules
+include(cmake/build_helpers.cmake)
+include(cmake/build_type_helpers.cmake)
+include(cmake/create_test.cmake)
+include(cmake/install_helpers.cmake)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
+
 
 # Find important header files, store the definitions in include/ginkgo/config.h.in
 # For details, see https://gitlab.kitware.com/cmake/community/wikis/doc/tutorials/How-To-Write-Platform-Checks
@@ -78,14 +109,27 @@ endif()
 configure_file(${Ginkgo_SOURCE_DIR}/include/ginkgo/config.hpp.in
     ${Ginkgo_BINARY_DIR}/include/ginkgo/config.hpp @ONLY)
 
+# This is modified from https://gitlab.kitware.com/cmake/community/wikis/FAQ#dynamic-replace
+if(MSVC)
+    if(BUILD_SHARED_LIBS)
+        ginkgo_switch_to_windows_dynamic("CXX")
+        ginkgo_switch_to_windows_dynamic("C")
+        set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
+    else()
+        ginkgo_switch_to_windows_static("CXX")
+        ginkgo_switch_to_windows_static("C")
+        set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS FALSE)
+    endif()
+endif()
+
 # Try to find the third party packages before using our subdirectories
 include(cmake/package_helpers.cmake)
-ginkgo_find_package(GTest 1.8.1)
-ginkgo_find_package(gflags 2.2.2)
-ginkgo_find_package(RapidJSON 1.1.0)
+ginkgo_find_package(GTest "GTest::GTest;GTest::Main" FALSE 1.8.1)
+ginkgo_find_package(gflags gflags FALSE 2.2.2)
+ginkgo_find_package(RapidJSON rapidjson TRUE 1.1.0)
 add_subdirectory(third_party)    # Third-party tools and libraries
 
-# Needs to be first in order for `CMAKE_CUDA_DEVICE_LINK_EXECUTABLE` to be 
+# Needs to be first in order for `CMAKE_CUDA_DEVICE_LINK_EXECUTABLE` to be
 # propagated to the other parts of Ginkgo in case of building as static libraries
 if(GINKGO_BUILD_CUDA)
     add_subdirectory(cuda)       # High-performance kernels for NVIDIA GPUs
@@ -116,9 +160,13 @@ if(GINKGO_DEVEL_TOOLS)
 endif()
 
 # Generate the global `ginkgo/ginkgo.hpp` header with every call of make
-add_custom_target(generate_ginkgo_header ALL
+find_program(BASH bash)
+if(NOT "${BASH}" STREQUAL "BASH-NOTFOUND")
+    add_custom_target(generate_ginkgo_header ALL
         COMMAND ${Ginkgo_SOURCE_DIR}/dev_tools/scripts/update_ginkgo_header.sh
         WORKING_DIRECTORY ${Ginkgo_SOURCE_DIR})
+endif()
+unset(BASH CACHE)
 
 
 # Installation

diff --git a/INSTALL.md b/INSTALL.md
@@ -8,18 +8,23 @@ Use the standard cmake build procedure:
 mkdir build; cd build
 cmake -G "Unix Makefiles" [OPTIONS] .. && make
 ```
+Use `cmake --build .` in some systems like MinGW or Microsoft Visual Studio which do not use `make`.
+
+For Microsoft Visual Studio, use `cmake --build . --config <build_type>` to decide the build type. The possible options are `Debug`, `Release`, `RelWithDebInfo` and `MinSizeRel`.
+
 Replace `[OPTIONS]` with desired cmake options for your build.
 Ginkgo adds the following additional switches to control what is being built:
 
 *   `-DGINKGO_DEVEL_TOOLS={ON, OFF}` sets up the build system for development
     (requires clang-format, will also download git-cmake-format),
-    default is `ON`
+    default is `ON`.
 *   `-DGINKGO_BUILD_TESTS={ON, OFF}` builds Ginkgo's tests
-    (will download googletest), default is `ON`
+    (will download googletest), default is `ON`.
 *   `-DGINKGO_BUILD_BENCHMARKS={ON, OFF}` builds Ginkgo's benchmarks
-    (will download gflags and rapidjson), default is `ON`
+    (will download gflags and rapidjson), default is `ON`.
 *   `-DGINKGO_BUILD_EXAMPLES={ON, OFF}` builds Ginkgo's examples, default is `ON`
-*   `-DGINKGO_BUILD_EXTLIB_EXAMPLE={ON, OFF}` builds the interfacing example with deal.II, default is `OFF`
+*   `-DGINKGO_BUILD_EXTLIB_EXAMPLE={ON, OFF}` builds the interfacing example
+    with deal.II, default is `OFF`.
 *   `-DGINKGO_BUILD_REFERENCE={ON, OFF}` build reference implementations of the
     kernels, useful for testing, default is `ON`
 *   `-DGINKGO_BUILD_OMP={ON, OFF}` builds optimized OpenMP versions of the kernels,
@@ -36,17 +41,23 @@ Ginkgo adds the following additional switches to control what is being built:
     Ginkgo's documentation. The default is `OFF`.
 *   `-DGINKGO_EXPORT_BUILD_DIR={ON, OFF}` adds the Ginkgo build directory to the
     CMake package registry. The default is `OFF`.
+*   `-DGINKGO_WITH_CLANG_TIDY={ON, OFF}` makes Ginkgo call `clang-tidy` to find
+    programming issues. The path can be manually controlled with the CMake
+    variable `-DGINKGO_CLANG_TIDY_PATH=<path>`. The default is `OFF`.
+*   `-DGINKGO_WITH_IWYU={ON, OFF}` makes Ginkgo call `iwyu` to find include
+    issues. The path can be manually controlled with the CMake variable
+    `-DGINKGO_IWYU_PATH=<path>`. The default is `OFF`.
 *   `-DGINKGO_VERBOSE_LEVEL=integer` sets the verbosity of Ginkgo.
     * `0` disables all output in the main libraries,
     * `1` enables a few important messages related to unexpected behavior (default).
 *   `-DCMAKE_INSTALL_PREFIX=path` sets the installation path for `make install`.
-    The default value is usually something like `/usr/local`
+    The default value is usually something like `/usr/local`.
 *   `-DCMAKE_BUILD_TYPE=type` specifies which configuration will be used for
     this build of Ginkgo. The default is `RELEASE`. Supported values are CMake's
     standard build types such as `DEBUG` and `RELEASE` and the Ginkgo specific 
 	`COVERAGE`, `ASAN` (AddressSanitizer) and `TSAN` (ThreadSanitizer) types.
 *   `-DBUILD_SHARED_LIBS={ON, OFF}` builds ginkgo as shared libraries (`OFF`)
-    or as dynamic libraries (`ON`), default is `ON`
+    or as dynamic libraries (`ON`), default is `ON`.
 *   `-DGINKGO_JACOBI_FULL_OPTIMIZATIONS={ON, OFF}` use all the optimizations
     for the CUDA Jacobi algorithm. `OFF` by default. Setting this option to `ON`
     may lead to very slow compile time (>20 minutes) for the
@@ -75,6 +86,14 @@ Ginkgo adds the following additional switches to control what is being built:
     this option see the
     [`ARCHITECTURES` specification list](https://github.com/ginkgo-project/CudaArchitectureSelector/blob/master/CudaArchitectureSelector.cmake#L58)
     section in the documentation of the CudaArchitectureSelector CMake module.
+* `-DGINKGO_WINDOWS_SHARED_LIBRARY_RELPATH=<path>` where <path> is a relative
+    path built with `PROJECT_BINARY_DIR`. Users must add the absolute path
+    (`PROJECT_BINARY_DIR`/`GINKGO_WINDOWS_SHARED_LIBRARY_RELPATH`) into the
+    environment variable PATH when building shared libraries and executable
+    program, default is `windows_shared_library`.
+* `-DGINKGO_CHECK_PATH={ON, OFF}` checks if the environment variable PATH is valid.
+    It is checked only when building shared libraries and executable program,
+    default is `ON`.
 
 For example, to build everything (in debug mode), use:
 
@@ -107,15 +126,27 @@ packages can be turned off by disabling the relevant options.
 
 By default, Ginkgo uses the internal version of each package. For each of the
 packages `GTEST`, `GFLAGS`, `RAPIDJSON` and `CAS`, it is possible to force
-Ginkgo to try to use an external version of a package. For this, set the CMake
-option `-DGINKGO_USE_EXTERNAL_<package>=ON`.
-
-If the external packages were not installed to the default location, the
-CMake option `-DCMAKE_PREFIX_PATH=<path-list>` needs to be set to the semicolon
-(`;`) separated list of install paths of these external packages. For more
-Information, see the [CMake documentation for CMAKE_PREFIX_PATH](https://cmake.org/cmake/help/v3.9/variable/CMAKE_PREFIX_PATH.html)
+Ginkgo to try to use an external version of a package. For this, Ginkgo provides
+two ways to find packages. To rely on the CMake `find_package` command, use the
+CMake option `-DGINKGO_USE_EXTERNAL_<package>=ON`. Note that, if the external
+packages were not installed to the default location, the CMake option
+`-DCMAKE_PREFIX_PATH=<path-list>` needs to be set to the semicolon (`;`)
+separated list of install paths of these external packages. For more
+Information, see the [CMake documentation for
+CMAKE_PREFIX_PATH](https://cmake.org/cmake/help/v3.9/variable/CMAKE_PREFIX_PATH.html)
 for details.
 
+To manually configure the paths, Ginkgo relies on the [standard xSDK Installation
+policies](https://xsdk.info/policies/) for all packages except `CAS` (as it is
+neither a library nor a header, it cannot be expressed through the `TPL`
+format):
++ `-DTPL_ENABLE_<package>=ON`
++ `-DTPL_<package>_LIBRARIES=/path/to/libraries.{so|a}`
++ `-DTPL_<package>_INCLUDE_DIRS=/path/to/header/directory`
+
+When applicable (e.g. for `GTest` libraries), a `;` separated list can be given
+to the `TPL_<package>_{LIBRARIES|INCLUDE_DIRS}` variables.
+
 ### Installing Ginkgo
 
 To install Ginkgo into the specified folder, execute the following command in

diff --git a/README.md b/README.md
@@ -1,10 +1,9 @@
 ![Ginkgo](/assets/logo.png)
 
 [![Build status](https://gitlab.com/ginkgo-project/ginkgo-public-ci/badges/master/build.svg)](https://github.com/ginkgo-project/ginkgo/commits/master)
-[![Coverage](https://codecov.io/gh/ginkgo-project/ginkgo/branch/master/graph/badge.svg)](https://codecov.io/gh/ginkgo-project/ginkgo)
 [![CDash dashboard](https://img.shields.io/badge/CDash-Access-blue.svg)](http://my.cdash.org/index.php?project=Ginkgo+Project)
 [![Documentation](https://img.shields.io/badge/Documentation-latest-blue.svg)](https://ginkgo-project.github.io/ginkgo/doc/master/)
-[![License](https://img.shields.io/github/license/ginkgo-project/ginkgo.svg)](LICENSE)
+[![License](https://img.shields.io/github/license/ginkgo-project/ginkgo.svg)](./LICENSE)
 [![c++ standard](https://img.shields.io/badge/c%2B%2B-11-blue.svg)](https://en.wikipedia.org/wiki/C%2B%2B#Standardization)
 
 Ginkgo is a high-performance linear algebra library for manycore systems, with a
@@ -34,6 +33,7 @@ For Ginkgo core library:
 *   C++11 compliant compiler, one of:
     *   _gcc 5.3+, 6.3+, 7.3+, 8.1+_
     *   _clang 3.9+_
+    *   _Intel compiler 2017+_
     *   _Apple LLVM 8.0+_ (__TODO__: verify)
 
 The Ginkgo CUDA module has the following __additional__ requirements:
@@ -48,13 +48,32 @@ In addition, if you want to contribute code to Ginkgo, you will also need the
 following:
 
 *   _clang-format 5.0.1+_ (ships as part of _clang_)
+*   _clang-tidy_ (optional, when setting the flag `-DGINKGO_WITH_CLANG_TIDY=ON`)
+*   _iwyu_ (Include What You Use, optional, when setting the flag `-DGINKGO_WITH_IWYU=ON`)
 
 ### Windows
 
-Windows is currently not supported, but we are working on porting the library
-there. If you are interested in helping us with this effort, feel free to
-contact one of the developers. (The library itself doesn't use any non-standard
-C++ features, so most of the effort here is in modifying the build system.)
+The prequirement needs to be verified
+*   _cmake 3.9+_
+*   C++11 compliant 64-bits compiler:
+    *   _MinGW : gcc 5.3+, 6.3+, 7.3+, 8.1+_
+    *   _Cygwin : gcc 5.3+, 6.3+, 7.3+, 8.1+_
+    *   _Microsoft Visual Studio : VS 2017 15.7+_
+
+__NOTE:__ Need to add `--autocrlf=input` after `git clone` in _Cygwin_.
+
+The Ginkgo CUDA module has the following __additional__ requirements:
+
+*   _CUDA 9.0+_
+*   _Microsoft Visual Studio_
+*   Any host compiler restrictions your version of CUDA may impose also apply
+    here. For the newest CUDA version, this information can be found in the
+    [CUDA installation guide for Windows](https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html)
+
+The Ginkgo OMP module has the following __additional__ requirements:
+*  _MinGW_ or _Cygwin_
+
+__NOTE:__ _Microsoft Visual Studio_ only supports OpenMP 2.0, so it can not compile the ginkgo OMP module.
 
 __NOTE:__ Some restrictions will also apply on the version of C and C++ standard
 libraries installed on the system. This needs further investigation.
@@ -91,7 +110,7 @@ Ginkgo does comprehensive unit tests using Google Tests. These tests are enabled
 A unique feature of Ginkgo is the ability to run benchmarks and view your results
 with the help of the [Ginkgo Performance Explorer (GPE)](https://ginkgo-project.github.io/gpe/). 
 
-More details about this can be found in the [documentation](https://ginkgo-project.github.io/ginkgo/doc/master/)
+More details about this can be found in the [BENCHMARKING.md page](./BENCHMARKING.md)
 
 Contributing to Ginkgo
 ---------------------------
@@ -103,7 +122,7 @@ external contributors like in the example below.
 
 #### Contributors
 I hereby place all my contributions in this codebase under a BSD-3-Clause
-license, as specified in the repository's [LICENSE](LICENSE) file.
+license, as specified in the repository's [LICENSE](./LICENSE) file.
 
 Name Surname <email@domain> Institution(s)
 
@@ -113,11 +132,16 @@ Contributing guidelines can be accessed in our Wiki under the [Developer's
 Homepage](https://github.com/ginkgo-project/ginkgo/wiki/Developers-Homepage).
 This page also contains other information useful to developers, such as writing
 proper commit messages, understanding Ginkgo's library design, relevant C++
-information, and more.
+information, and more. In general, always refer to this page for developer
+information.
+
+### Support
+If you have any question, bug to report or would like to propose a new feature,
+feel free to [create an
+issue on GitHub](https://github.com/ginkgo-project/ginkgo/issues/new). Another possibility
+is to send an email to [Ginkgo's main email address]([email protected])
+or to contact any of the main [contributors](contributors.txt).
 
-In general, always refer to this page for developer information. If you think
-that anything is missing, feel free to [create an
-issue](https://github.com/ginkgo-project/ginkgo/issues/new).  
 
 ### Licensing
 

diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
@@ -4,12 +4,22 @@ if (NOT CMAKE_BUILD_TYPE STREQUAL "Release")
         "will be affected")
 endif()
 
+function(ginkgo_benchmark_cusp_linops name)
+    target_compile_definitions("${name}" PRIVATE HAS_CUDA=1)
+    target_link_libraries("${name}" ginkgo ${CUDA_RUNTIME_LIBS}
+        ${CUBLAS} ${CUSPARSE})
+    target_include_directories("${name}" SYSTEM PRIVATE ${CUDA_INCLUDE_DIRS})
+    if(CMAKE_CUDA_COMPILER_VERSION GREATER_EQUAL "9.2")
+        target_compile_definitions("${name}" PRIVATE ALLOWMP=1)
+    endif()
+endfunction()
+
+add_subdirectory(conversions)
 add_subdirectory(matrix_generator)
 add_subdirectory(matrix_statistics)
 add_subdirectory(preconditioner)
 add_subdirectory(solver)
 add_subdirectory(spmv)
-add_subdirectory(spmv_comparison_cuda)
 
 add_custom_target(make_run_all_benchmarks ALL)
 add_custom_command(

diff --git a/benchmark/conversions/CMakeLists.txt b/benchmark/conversions/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_executable(conversions conversions.cpp)
+target_link_libraries(conversions ginkgo gflags rapidjson)