Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • devel
  • edd_merge_10to8
  • pulsar_timing_test_20220217
  • rs_spectrometer_bk_20250715
  • 241112+devel
  • 241114+devel
  • 250211+devel
  • 250716.0
  • cuda11.0.3
  • v0.1
10 results

Target

Select target project
  • mpifr-bdg/psrdada_cpp
  • twinchen/psrdada_cpp
  • nesser/psrdada_cpp
3 results
Select Git revision
  • devel
  • doc
  • v0.1
3 results
Show changes
Commits on Source (430)
Showing with 508 additions and 322 deletions
---
BasedOnStyle: LLVM
AccessModifierOffset: '-2'
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: 'true'
AlignConsecutiveAssignments: 'true'
AlignConsecutiveDeclarations: 'false'
AlignEscapedNewlines: Left
AlignOperands: 'true'
AlignTrailingComments: 'true'
AllowAllArgumentsOnNextLine: 'false'
AllowAllConstructorInitializersOnNextLine: 'false'
AllowAllParametersOfDeclarationOnNextLine: 'false'
AllowShortBlocksOnASingleLine: 'true'
AllowShortCaseLabelsOnASingleLine: 'true'
AllowShortFunctionsOnASingleLine: InlineOnly
AllowShortIfStatementsOnASingleLine: Never
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: 'true'
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: 'false'
AlwaysBreakTemplateDeclarations: 'Yes'
BinPackArguments: 'false'
BinPackParameters: 'false'
BreakBeforeBraces: Linux
BreakBeforeTernaryOperators: 'true'
BreakConstructorInitializers: BeforeColon
BreakStringLiterals: 'true'
CompactNamespaces: 'false'
ConstructorInitializerAllOnOneLineOrOnePerLine: 'false'
DerivePointerAlignment: 'false'
DisableFormat: 'false'
FixNamespaceComments: 'true'
IncludeBlocks: Regroup
IndentCaseLabels: 'false'
IndentPPDirectives: 'BeforeHash'
IndentWrappedFunctionNames: 'false'
IndentWidth: '4'
KeepEmptyLinesAtTheStartOfBlocks: 'false'
Language: Cpp
NamespaceIndentation: None
PointerAlignment: Left
ReflowComments: 'true'
SortIncludes: 'true'
SortUsingDeclarations: 'true'
SpaceAfterCStyleCast: 'false'
SpaceAfterLogicalNot: 'false'
SpaceAfterTemplateKeyword: 'true'
SpaceBeforeAssignmentOperators: 'true'
SpaceBeforeCtorInitializerColon: 'false'
SpaceBeforeInheritanceColon: 'false'
SpaceBeforeParens: Never
SpaceBeforeRangeBasedForLoopColon: 'false'
SpaceInEmptyParentheses: 'false'
SpacesInAngles: 'false'
SpacesInCStyleCastParentheses: 'false'
SpacesInContainerLiterals: 'false'
SpacesInParentheses: 'false'
SpacesInSquareBrackets: 'false'
Standard: Cpp11
TabWidth: '4'
UseTab: Never
......@@ -33,9 +33,14 @@
# Directories
build/
release/
debug/
obj-x86_64-linux-gnu/
# Editor files
*~
*\#
*.log
.vscode/
psrdada_cpp.sublime-project
psrdada_cpp.sublime-workspace
\ No newline at end of file
stages:
- build
- test
- binary_release
- deploy
image: edd01:5000/eddbase:latest
image: edd-registry:5000/edd_build:cuda12.6.1_ubuntu24.04
variables:
PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
......@@ -12,56 +13,116 @@ cache:
- .cache/pip
- .cache/apt
before_script:
- git submodule init
- git submodule update
- apt-get -y update && apt-get install -y python3-pip python3-graphviz doxygen
- pip3 install sphinx sphinxcontrib-apidoc sphinx-rtd-theme recommonmark \
sphinxcontrib-napoleon sphinx-autoapi breathe exhale
build_cuda:
build_cpp:
stage: build
before_script:
- apt-get -y update
- apt-get -y install psrdada psrdada-dev
script:
- mkdir build
- cd build
- cmake .. -DPSRDADA_INCLUDE_DIR=/usr/local/include/psrdada -DENABLE_CUDA=True
- make -j8
- apt-get install -y psrdada-dev
- cmake -S . -B build/ -DENABLE_BENCHMARK=ON -DFORCE_DOWNLOAD=ON -DBUILD_DADAFLOW=ON -DENABLE_CUDA=ON
- make -j -C build/
artifacts:
paths:
- build
cpplint:
stage: test
needs: []
before_script:
- apt-get -y update
- apt-get -y install python3-pip
script:
- pip3 install cpplint anybadge --break-system-packages
- cpplint --repository=. --recursive --output=junit . 2> cpplint.xml || true
- cpplint --repository=. --recursive --counting=toplevel ./psrdada_cpp > cpplint.txt || true
- CPPLS=$(sed -n 's/^Total errors found.*\s\([-0-9.]\)/\1/p' cpplint.txt)
- cat cpplint.txt
- echo Total $CPPLS
- anybadge --value=$CPPLS --label='cpplint' --file=cpplint.svg 50=green 100=yellow 200=orange 300000=red
allow_failure: true
artifacts:
paths:
- ./cpplint.svg
- ./cpplint.xml
run_tests:
test_cpp:
stage: test
needs: ["build_cpp"]
before_script:
- apt-get -y update
- apt-get -y install psrdada
script:
- cd build
- make CTEST_OUTPUT_ON_FAILURE=1 test
only:
- pushes
- merge_requests
- make -C build/ test
artifacts:
when: always
paths:
- build
make_doc:
benchmark:
stage: test
needs: ["build_cpp"]
before_script:
- apt-get -y update
- apt-get -y install psrdada psrdada-dev
script:
- cd build
- make doc
- make -C build/ run_benchmark
artifacts:
paths:
- build
pages:
# Sphinx build is incompatible with latest ubuntu version in
# build and needs update
#make_doc:
# stage: binary_release
# before_script:
# - apt-get -y update && apt-get install -y python3-pip python3-graphviz doxygen
# - pip3 install --break-system-packages Sphinx==3.4.3 sphinxcontrib-apidoc==0.3.0 sphinx-rtd-theme==0.5.1 recommonmark==0.7.1 \
# sphinxcontrib-napoleon==0.7 sphinx-autoapi==1.7.0 breathe==4.26.1 exhale==0.2.3 'jinja2<3.1'
# - export LC_CTYPE=en_US.UTF-8
# script:
# - cmake -S . -B builddoc/ -DENABLE_DOC=TRUE -DPSRDADA_INCLUDE_DIR=/usr/include/psrdada
# - make -C builddoc/ doc
# - mv builddoc/doc build/
# artifacts:
# paths:
# - build
include:
- project: MPIfR-BDG/edd_provisioning
file: '.build_template.yml'
build-deb:
needs: ["test_cpp"]
stage: binary_release
extends: .build_template
variables:
EDD_DEB_AUTO_CHANGELOG: "true"
upload-deb:
needs: ["build-deb"]
stage: deploy
dependencies:
- make_doc
script:
- mv doc/* public/
artifacts:
paths:
- public
only:
- dev
- cicd
- doc
extends: .upload_template
rules:
- if: '$CI_PROJECT_NAMESPACE == "mpifr-bdg" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
#pages:
#stage: deploy
#needs: ["make_doc"]
#script:
#- mkdir public
#- mv build/doc/* public/
#artifacts:
# paths:
# - public
#rules:
# - if: '$CI_PROJECT_NAMESPACE == "mpifr-bdg" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
......
[submodule "thirdparty/googletest"]
path = thirdparty/googletest
url = https://github.com/google/googletest.git
# project name and specify the minumum cmake version.
cmake_minimum_required (VERSION 3.11)
project (psrdada_cpp CXX)
cmake_minimum_required (VERSION 3.0)
enable_testing()
# Compiling and build options
option(ENABLE_CUDA " Compile with .cu and .cuh files the nvcc compiler. Requires CUDA toolkit to be installed." ON)
option(ENABLE_TESTING "Build and enable testing" ON)
option(ENABLE_BENCHMARK "Build and enable benchmark" OFF)
option(BUILD_SUBMODULES "Build submodules" ON)
option(BUILD_DADAFLOW "Build dadaflow" OFF)
option(FORCE_DOWNLOAD "Forces to download sources of external dependencies (gtest, gbenchmark). Useful when an existing system-wide installation exists which causes issues." OFF)
include(CheckLanguage)
check_language(CUDA)
if(ENABLE_CUDA AND NOT CMAKE_CUDA_COMPILER)
message(FATAL_ERROR "Cuda enabled but no cuda compiler found. Either specify CMAKE_CUDA_COMPILER manually or set ENABLE_CUDA=FALSE")
endif()
# The version number.
set (psrdada_cpp_VERSION_MAJOR 0)
set (psrdada_cpp_VERSION_MINOR 1)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
if(ENABLE_CUDA AND CMAKE_CUDA_COMPILER)
enable_language(CUDA)
if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
set(CMAKE_CUDA_ARCHITECTURES "75;80;89")
endif()
endif()
# The version number.
set(psrdada_cpp_VERSION_MAJOR 1)
set(psrdada_cpp_VERSION_MINOR 0)
set(psrdada_cpp_VERSION_PATCH 0)
set(PROJECT_VERSION "${psrdada_cpp_VERSION_MAJOR}.${psrdada_cpp_VERSION_MINOR}.${psrdada_cpp_VERSION_PATCH}")
# cmake setup.
set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
......@@ -30,48 +51,18 @@ if(NOT BINARY_INSTALL_DIR)
set(BINARY_INSTALL_DIR "bin/")
endif(NOT BINARY_INSTALL_DIR)
# Set build type
if (NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "")
set(CMAKE_BUILD_TYPE "RELEASE" CACHE STRING "" FORCE)
endif()
string(TOUPPER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_UPPER)
# get project dependencies and compiler settings.
include(dependencies)
# === process through the cheetah tree:
add_subdirectory(${CMAKE_PROJECT_NAME})
# ------------------------------------------------------------------
# Documentation
# ------------------------------------------------------------------
find_package(Doxygen)
find_program(SPHINX_EXECUTABLE
NAMES sphinx-build
DOC "Path to sphinx-build executable")
if(DOXYGEN_FOUND AND SPHINX_EXECUTABLE)
MESSAGE(STATUS "Found Doxygen and Sphinx to build documentation")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doc/DoxygenLayout.xml ${CMAKE_CURRENT_BINARY_DIR}/DoxygenLayout.xml COPYONLY)
# configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doc/Mainpage.md.in ${CMAKE_CURRENT_BINARY_DIR}/Mainpage.md)
add_custom_target(doxy ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Generating API documentation with Doxygen" VERBATIM)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Sphinx
"Failed to find sphinx-build executable"
SPHINX_EXECUTABLE)
set(SPHINX_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/doc)
set(SPHINX_BUILD ${CMAKE_CURRENT_BINARY_DIR}/doc)
add_custom_target(doc
${SPHINX_EXECUTABLE} -b html
-Dbreathe_projects.psrdada-cpp=${CMAKE_CURRENT_BINARY_DIR}/xml
${SPHINX_SOURCE} ${SPHINX_BUILD}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating documentation with Sphinx")
add_dependencies(doc doxy)
else()
MESSAGE(STATUS "Doxygen and Sphinx not found: cannot build documentation")
endif(DOXYGEN_FOUND AND SPHINX_EXECUTABLE)
# === Print build options summary.
set(DEBUG_PRINT ON)
if (DEBUG_PRINT)
......@@ -83,14 +74,10 @@ if (DEBUG_PRINT)
message(STATUS " Compiler Options:")
message(STATUS " Build type: ${CMAKE_BUILD_TYPE}")
message(STATUS " C++ Compiler: ${CMAKE_CXX_COMPILER}")
if (${CMAKE_BUILD_TYPE} MATCHES release)
message(STATUS " C++ flags: ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
elseif (${CMAKE_BUILD_TYPE} MATCHES debug)
message(STATUS " C++ flags: ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
elseif (${CMAKE_BUILD_TYPE} MATCHES relwithdebinfo)
message(STATUS " C++ flags: ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
elseif (${CMAKE_BUILD_TYPE} MATCHES minsizerel)
message(STATUS " C++ flags: ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_MINSIZEREL}")
message(STATUS " C++ flags: ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
if(ENABLE_CUDA)
message(STATUS " NVCC flags: ${CMAKE_CUDA_FLAGS} ${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
message(STATUS " CUDA arch: ${CMAKE_CUDA_ARCHITECTURES}")
endif ()
message(STATUS "")
message(STATUS "Install locations: (make install)")
......@@ -106,6 +93,3 @@ if (DEBUG_PRINT)
message(STATUS "****************************************************************************")
message(STATUS "")
endif (DEBUG_PRINT)
enable_testing()
# PSRDADA_CPP
PSRDADA_CPP contains C++ wrappers for a subset for PSRDADA functionality (HDUs, read/write clients, etc.) and implements various CLI application (from and to disk r/w, buffer synchronisation, buffer splitting etc.). PSRDADA_CPP also provides an interface for (high-performance) processing pipelines and DADA buffers. A few examples exists in the submodules (e.g. `gated_spectrometer`).
## Requirements
- psrdada
- boost 1.67 or later
- CMake 3.12 or later
- CUDA (optional, required to compile `.cu` and `.cuh` source)
## Installation
Clone the repository and enter the root folder
`git clone https://gitlab.mpcdf.mpg.de/mpifr-bdg/psrdada_cpp && cd psrdada_cpp`
Prepare and build the entire project
`cmake -S . -B <path-to-build> -DENABLE_CUDA=TRUE -DPSRDADA_INCLUDE_DIR=<path-to-psrdada-headers> && make -C <path-to-build>/`
### Custom CMake flags
All flags are passed to cmake with the CMake prefix `-D<flagname>`
| Flagname | Description | Values | Command |
|----------|-------------|---------------|---------|
| `ENABLE_CUDA` | Allows compilation with `nvcc` which is require to compile `.cuh` and `.cu` | `ON` (default), `OFF` | - |
| `BUILD_SUBMODULES` | Build submodules (excluding dadaflow). | `ON` (default), `OFF` | - |
| `BUILD_DADAFLOW` | Builds the dadaflow submodule. | `OFF` (default), `ON` | - |
| `ENABLE_TESTING` | Enables testing relying on `googletest`. If `googletest` is not found by cmake it gets pulled from remote. | `ON` (default), `OFF` | `make -C <path-to-build> test` |
| `ENABLE_BENCHMARK` | Enables benchmarks relying on `googlebenchmark`. If `googlebenchmark` is not found by cmake it gets pulled from remote. Only has effect when `BUILD_SUBMODULES` is `ON`. | `OFF` (default), `ON` | `make -C <path-to-build> run_benchmark` |
| `FORCE_DOWNLOAD` | Fetches the content of `googlebenchmark` and `googletest` from remote. Useful when an existing installation causes problems. | `OFF` (default), `ON` | - |
## Documentation
The documentation of psrdadad-cpp can be found at: http://mpifr-bdg.pages.mpcdf.de/psrdada_cpp/
# find the usual boost
find_package(Boost COMPONENTS log program_options system REQUIRED)
if(Boost_MAJOR_VERSION EQUAL 1 AND Boost_MINOR_VERSION LESS 58)
# -- pick up boost::endiam from the local copy
list(APPEND Boost_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/thirdparty/boost")
endif()
option(BOOST_ASIO_DEBUG "set to true to enable boost asio handler tracking" OFF)
if(BOOST_ASIO_DEBUG)
set(BOOST_ASIO_DEBUG true)
add_definitions(-DBOOST_ASIO_ENABLE_HANDLER_TRACKING)
else(BOOST_ASIO_DEBUG)
set(BOOST_ASIO_DEBUG false)
endif(BOOST_ASIO_DEBUG)
#
# Compiler defaults for cheetah
#
# Set the default build type
if (NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "release")
set(CMAKE_BUILD_TYPE "RELEASE")
endif ()
# The sub library psrdada_cpp::dadaflow requires at least std=c++20
if(BUILD_DADAFLOW)
# Here we check if the compiler (Clang and GCC) is able to support C++ 20
# Other compilers are not included yet
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 10)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Turn BUILD_DADAFLOW off when the standard is not sufficient
else()
message(WARNING "The Compiler does not support C++20, psrdada_cpp::dadaflow won't build")
message(WARNING "Setting BUILD_DADAFLOW=OFF")
set(BUILD_DADAFLOW OFF)
endif()
endif()
# Set the minimum standard when BUILD_DADAFLOW is OFF
if(NOT BUILD_DADAFLOW)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
endif()
# Set compiler flags
set(CMAKE_CXX_FLAGS "-fPIC")
set(CMAKE_CXX_FLAGS "--std=c++${CMAKE_CXX_STANDARD} -fPIC -fopenmp")
set(ARCH "native" CACHE STRING "target architecture (-march=native, x86-64), defautls to native")
set(ARCH "broadwell" CACHE STRING "target architecture (-march=native, x86-64), defaults to broadwell")
set(TUNE "generic" CACHE STRING "target tune architecture (-mtune=native, x86-64), defaults to generic")
if(CMAKE_CXX_COMPILER MATCHES icpc)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcheck -wd2259 -wd1125")
endif()
if (CMAKE_CXX_COMPILER_ID MATCHES Clang)
set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-isystem")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=${ARCH}")
if(CMAKE_BUILD_TYPE MATCHES profile)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
endif()
set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-isystem ")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -march=${ARCH} -mtune=${TUNE}")
endif ()
if (CMAKE_COMPILER_IS_GNUCXX)
## -Wl,--no-as-needed avoids linker problem with libfftwf3 on ubuntu systems
set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-isystem")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -Werror")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcast-align")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=${ARCH}")
if(CMAKE_BUILD_TYPE MATCHES profile)
# -pg for gprof
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -fprofile-arcs -ftest-coverage")
endif()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-ignored-attributes -pthread -Werror -Wcast-align -march=${ARCH} -mtune=${TUNE}")
endif ()
set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -Wno-unused-local-typedefs")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -Wall -Wextra -pedantic -Wno-unused-local-typedefs")
set(CMAKE_CXX_FLAGS_DEBUG "-O3 -g -pg -Wall -Wextra -pedantic -Wno-unused-local-typedefs")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -g -Wall -Wextra -pedantic -Wno-unused-local-typedefs")
set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -pg -Wall -Wextra -pedantic -Wno-unused-local-typedefs")
# Set include directories for dependencies
include_directories(
......
option(ENABLE_CUDA "Enable CUDA algorithms. Requires CUDA toolkit to be installed" ON)
if(ENABLE_CUDA)
find_package(CUDA REQUIRED)
include_directories(${CUDA_TOOLKIT_INCLUDE})
# add sdk samples useful headerfiles like cuda_helpers.h
if(CUDA_SMP_INC)
include_directories(${CUDA_SMP_INC})
endif(CUDA_SMP_INC)
set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
set(CUDA_PROPAGATE_HOST_FLAGS OFF)
add_definitions(-DENABLE_CUDA)
# Pass options to NVCC ( -ccbin /path --compiler-options -lfftw3f --compiler-options -lm --verbose)
list(APPEND CUDA_NVCC_FLAGS -DENABLE_CUDA --std c++${CMAKE_CXX_STANDARD} -Wno-deprecated-gpu-targets --ptxas-options=-v)
list(APPEND CUDA_NVCC_FLAGS_DEBUG --debug; --device-debug; --generate-line-info -Xcompiler "-Wextra" -Xcompiler "-Werror")
list(APPEND CUDA_NVCC_FLAGS_PROFILE --generate-line-info)
#list(APPEND CUDA_NVCC_FLAGS -arch compute_35) # minumum compute level (Sps restriction)
string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
if(NOT uppercase_CMAKE_BUILD_TYPE MATCHES "DEBUG")
message("Enabling device specific compilation as not in DEBUG mode")
list(APPEND CUDA_NVCC_FLAGS -gencode arch=compute_61,code=sm_61) # GTX1080Ti, Titan Xp
list(APPEND CUDA_NVCC_FLAGS -gencode arch=compute_61,code=compute_61) # Compatibility
#list(APPEND CUDA_NVCC_FLAGS -gencode arch=compute_52,code=sm_52) # TitanX
#list(APPEND CUDA_NVCC_FLAGS -gencode arch=compute_50,code=sm_50) # Maxwell
#list(APPEND CUDA_NVCC_FLAGS -gencode arch=compute_37,code=sm_37) # K80
endif(NOT uppercase_CMAKE_BUILD_TYPE MATCHES "DEBUG")
if(CUDA_VERSION VERSION_GREATER 10.0)
list(APPEND CUDA_NVCC_FLAGS -gencode arch=compute_75,code=sm_75) # RTX2080, CUDA10
endif()
list(APPEND CUDA_NVCC_FLAGS -O3 -use_fast_math -restrict)
set(CMAKE_CXX_FLAGS "-DENABLE_CUDA ${CMAKE_CXX_FLAGS}")
get_property(dirs DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
option(CUDA_USE_NVTX "set to true to enable NVTX macros for CUDA profiling" OFF)
if(CUDA_USE_NVTX)
set(CUDA_USE_NVTX true)
add_definitions(-DUSE_NVTX)
find_library(CUDA_NVTOOLSEXT_LIB
NAMES nvToolsExt
HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64)
list(APPEND CUDA_DEPENDENCY_LIBRARIES ${CUDA_NVTOOLSEXT_LIB})
else(CUDA_USE_NVTX)
set(CUDA_USE_NVTX false)
endif(CUDA_USE_NVTX)
macro(CUDA_GENERATE_LINK_FILE cuda_link_file cuda_target)
# Compute the file name of the intermedate link file used for separable
# compilation.
CUDA_COMPUTE_SEPARABLE_COMPILATION_OBJECT_FILE_NAME(cuda_link_file ${cuda_target} "${${cuda_target}_SEPARABLE_COMPILATION_OBJECTS}")
# Add a link phase for the separable compilation if it has been enabled. If
# it has been enabled then the ${cuda_target}_SEPARABLE_COMPILATION_OBJECTS
# variable will have been defined.
CUDA_LINK_SEPARABLE_COMPILATION_OBJECTS("${cuda_link_file}" ${cuda_target} "${_options}" "${${cuda_target}_SEPARABLE_COMPILATION_OBJECTS}")
endmacro()
#
# @macro CUDA_SUBPACKAGE_COMPILE
# Use to specify that certain objects should be compiled with
# alternative flags (e.g. a specific architecture)
# @example
# cuda_subpackage_compile(${my_cuda_files} OPTIONS "-arch compute_35")
#
macro(CUDA_SUBPACKAGE_COMPILE)
FILE(APPEND ${SUBPACKAGE_FILENAME}
"CUDA_ADD_CUDA_INCLUDE_ONCE()\n"
"cuda_compile(_cuda_objects "
)
foreach(arg ${ARGN})
if(EXISTS "${arg}")
set(_file "${arg}")
if(CMAKE_VERSION GREATER_EQUAL 3.17)
find_package(CUDAToolkit REQUIRED)
else() # Compatibility for cmake 3.16 (ubuntu20.4)
find_package(CUDA REQUIRED)
if (CUDA_CUFFT_LIBRARIES)
add_library(CUFFT_IMPORTED SHARED IMPORTED GLOBAL)
set_target_properties(CUFFT_IMPORTED PROPERTIES IMPORTED_LOCATION ${CUDA_CUFFT_LIBRARIES})
add_library(CUDA::cufft ALIAS CUFFT_IMPORTED)
else()
set(_file "${CMAKE_CURRENT_SOURCE_DIR}/${arg}")
if(NOT EXISTS "${_file}")
set(_file ${arg})
endif()
message(FATAL_ERROR "CUDA_CUFFT_LIBRARIES not found!")
endif()
FILE(APPEND ${SUBPACKAGE_FILENAME}
"${_file}\n"
)
endforeach(arg ${ARGV})
FILE(APPEND ${SUBPACKAGE_FILENAME}
")\n"
"list(APPEND lib_obj_cuda \${_cuda_objects})\n"
)
endmacro(CUDA_SUBPACKAGE_COMPILE)
endif()
set(CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
set(CUDA_PROPAGATE_HOST_FLAGS OFF)
set(CMAKE_CUDA_FLAGS "-DENABLE_CUDA --std=c++${CMAKE_CXX_STANDARD} -Wno-deprecated-gpu-targets --extended-lambda")
set(CMAKE_CUDA_FLAGS_DEBUG "-O0 -G --ptxas-options='-v' '-Xcompiler=-Wextra,-Werror,--all-warnings'")
set(CMAKE_CUDA_FLAGS_RELEASE "-O3 -use_fast_math -restrict")
set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "${CMAKE_CUDA_FLAGS_RELEASE} --generate-line-info")
# Here we need to add the cuda include path - otherwise it might fail when it is not set as ENV
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CUDAToolkit_INCLUDE_DIRS} -DENABLE_CUDA")
else(ENABLE_CUDA)
# dummies
macro(CUDA_SUBPACKAGE_COMPILE)
endmacro(CUDA_SUBPACKAGE_COMPILE)
endif(ENABLE_CUDA)
endif()
\ No newline at end of file
include(cuda)
include(compiler_settings)
include(cmake/compiler_settings.cmake)
include(cmake/cuda.cmake)
include(cmake/googletest.cmake)
include(cmake/boost.cmake)
include(cmake/googlebenchmark.cmake)
include(cmake/psrdada.cmake)
include_directories(${Boost_INCLUDE_DIR} ${PSRDADA_INCLUDE_DIR})
include_directories(${GTEST_INCLUDE_DIR})
set(DEPENDENCY_LIBRARIES
${Boost_LIBRARIES}
${PSRDADA_LIBRARIES}
${CUDA_CUDART_LIBRARY}
)
include(cmake/doxygen.cmake)
find_package(OpenMP REQUIRED)
if(OPENMP_FOUND)
message(STATUS "Found OpenMP" )
set(DEPENDENCY_LIBRARIES ${DEPENDENCY_LIBRARIES} ${OpenMP_EXE_LINKER_FLAGS})
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
# Find boost dependencies. DADAFLOW has an addtional dependency to Boost::json
if(BUILD_DADAFLOW)
set(BOOST_COMPONENTS log program_options system json)
else()
set(BOOST_COMPONENTS log program_options system)
endif()
find_package(Boost COMPONENTS ${BOOST_COMPONENTS} REQUIRED)
# Set all dependecy libraries required by psrdada_cpp
set(DEPENDENCY_LIBRARIES ${Boost_LIBRARIES} ${PSRDADA_LIBRARIES})
# ------------------------------------------------------------------
# Documentation
# ------------------------------------------------------------------
find_package(Doxygen)
find_program(SPHINX_EXECUTABLE
NAMES sphinx-build
DOC "Path to sphinx-build executable")
if(DOXYGEN_FOUND AND SPHINX_EXECUTABLE)
MESSAGE(STATUS "Found Doxygen and Sphinx to build documentation")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doc/DoxygenLayout.xml ${CMAKE_CURRENT_BINARY_DIR}/DoxygenLayout.xml COPYONLY)
add_custom_target(doxy ${DOXYGEN_EXECUTABLE}
${CMAKE_CURRENT_BINARY_DIR}/Doxyfile WORKING_DIRECTORY
${CMAKE_CURRENT_BINARY_DIR} COMMENT
"Generating API documentation with Doxygen" VERBATIM)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Sphinx
"Failed to find sphinx-build executable"
SPHINX_EXECUTABLE)
set(SPHINX_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/doc)
set(SPHINX_BUILD ${CMAKE_CURRENT_BINARY_DIR}/doc)
add_custom_target(doc
${SPHINX_EXECUTABLE} -b html
-Dbreathe_projects.psrdada-cpp=${CMAKE_CURRENT_BINARY_DIR}/xml
${SPHINX_SOURCE} ${SPHINX_BUILD}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating documentation with Sphinx")
add_dependencies(doc doxy)
else()
MESSAGE(STATUS "Doxygen and Sphinx not found: cannot build documentation")
endif(DOXYGEN_FOUND AND SPHINX_EXECUTABLE)
if(ENABLE_BENCHMARK)
if(NOT FORCE_DOWNLOAD)
find_package(benchmark QUIET)
if(benchmark_FOUND)
message(STATUS "Googlebenchmark found! Version: ${benchmark_VERSION}!")
endif()
endif()
if(FORCE_DOWNLOAD OR NOT benchmark_FOUND)
message(STATUS "Fetching content for googlebenchmark from remote..")
include(FetchContent)
FetchContent_Declare(
googlebenchmark
GIT_REPOSITORY https://github.com/google/benchmark.git
GIT_TAG v1.8.3
GIT_PROGRESS TRUE
INSTALL_COMMAND "")
# The flags are set to OFF to avoid dependency to googletest
set(BENCHMARK_USE_BUNDLED_GTEST, OFF CACHE BOOL "Disable testing" FORCE)
set(BENCHMARK_ENABLE_GTEST_TESTS OFF CACHE BOOL "Disable testing" FORCE)
set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "Disable testing" FORCE)
# Ensure the content is downloaded and built
FetchContent_MakeAvailable(googlebenchmark)
set(BENCHMARK_INCLUDE_DIR ${googlebenchmark_SOURCE_DIR}/include)
endif()
set(BENCHMARK_LIBRARIES benchmark::benchmark benchmark::benchmark_main)
endif()
# == googletest build - must be build with the same compiler flags
if(NOT GTEST_INCLUDE_DIR)
if(APPLE)
add_definitions(-DGTEST_USE_OWN_TR1_TUPLE=1)
else(APPLE)
add_definitions(-DGTEST_USE_OWN_TR1_TUPLE=0)
endif(APPLE)
add_subdirectory("thirdparty/googletest")
set(GTEST_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/googletest/include)
set(GTEST_LIBRARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/thirdparty/googletest)
message("BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}")
set(GTEST_LIBRARIES gtest_main gtest)
if(ENABLE_TESTING)
enable_testing()
if(NOT FORCE_DOWNLOAD)
find_package(GTest QUIET)
if (GTest_FOUND)
message(STATUS "Googletest found! Version: ${GTest_VERSION}")
endif()
endif()
if(FORCE_DOWNLOAD OR NOT GTest_FOUND)
message(STATUS "Fetching content for GTest from remote..")
include(FetchContent)
FetchContent_Declare(
googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG v1.14.0
GIT_PROGRESS TRUE
INSTALL_COMMAND ""
)
FetchContent_MakeAvailable(googletest)
set(GTEST_INCLUDE_DIR ${googletest_SOURCE_DIR}/googletest/include ${googletest_SOURCE_DIR}/googlemock/include)
endif()
set(GTEST_LIBRARIES GTest::gmock_main GTest::gmock GTest::gtest_main GTest::gtest)
endif()
IF (PSRDADA_INCLUDE_DIR)
SET(PSRDADA_INC_DIR ${PSRDADA_INCLUDE_DIR})
UNSET(PSRDADA_INCLUDE_DIR)
ENDIF (PSRDADA_INCLUDE_DIR)
# find_package(psrdada)
# if(psrdada_FOUND)
# message(STATUS "Found psrdada. Version: ${psrdada_VERSION}")
# else()
# Possibly FetchContent should be implemented here.
# But when psrdada was installed with autotools instead of cmake find_package fails
# and psrdada gets installed again.
message(STATUS "Trying to find psrdada")
find_path(PSRDADA_INCLUDE_DIR
NAMES psrdada/dada_def.h
PATH_SUFFIXES psrdada
PATHS
ENV PSRDADA_INC_DIR
${PSRDADA_INSTALL_DIR}/include
/usr/local/include
/usr/include
)
FIND_PATH(PSRDADA_INCLUDE_DIR dada_def.h
PATHS ${PSRDADA_INC_DIR}
${PSRDADA_INSTALL_DIR}/include
/usr/local/include/psrdada
/usr/local/include
/usr/include )
message("Found ${PSRDADA_INCLUDE_DIR} : ${PSRDADA_INSTALL_DIR}")
find_library(PSRDADA_LIBRARY
NAMES psrdada
PATHS
ENV PSRDADA_LIBRARY_DIR
${PSRDADA_INSTALL_DIR}/lib
/usr/local/lib
/usr/lib
)
SET(PSRDADA_NAMES psrdada)
FOREACH( lib ${PSRDADA_NAMES} )
FIND_LIBRARY(PSRDADA_LIBRARY_${lib}
NAMES ${lib}
PATHS ${PSRDADA_LIBRARY_DIR} ${PSRDADA_INSTALL_DIR} ${PSRDADA_INSTALL_DIR}/lib /usr/local/lib /usr/lib
)
LIST(APPEND PSRDADA_LIBRARIES ${PSRDADA_LIBRARY_${lib}})
ENDFOREACH(lib)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(PSRDADA
REQUIRED_VARS PSRDADA_LIBRARY PSRDADA_INCLUDE_DIR
VERSION_VAR PSRDADA_VERSION
)
# handle the QUIETLY and REQUIRED arguments and set PSRDADA_FOUND to TRUE if.
# all listed variables are TRUE
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(PSRDADA DEFAULT_MSG PSRDADA_LIBRARIES PSRDADA_INCLUDE_DIR)
if (PSRDADA_FOUND)
set(PSRDADA_LIBRARIES ${PSRDADA_LIBRARY})
set(PSRDADA_INCLUDE_DIRS ${PSRDADA_INCLUDE_DIR})
IF(NOT PSRDADA_FOUND)
SET( PSRDADA_LIBRARIES )
SET( PSRDADA_TEST_LIBRARIES )
ELSE(NOT PSRDADA_FOUND)
# -- add dependecies
LIST(APPEND PSRDADA_LIBRARIES ${CUDA_curand_LIBRARY})
ENDIF(NOT PSRDADA_FOUND)
mark_as_advanced(PSRDADA_INCLUDE_DIR PSRDADA_LIBRARY)
else()
MESSAGE(FATAL_ERROR psrdada not found)
endif()
LIST(APPEND PSRDADA_INCLUDE_DIR "${PSRDADA_INCLUDE_DIR}")
MARK_AS_ADVANCED(PSRDADA_LIBRARIES PSRDADA_TEST_LIBRARIES PSRDADA_INCLUDE_DIR)
MESSAGE(STATUS "Using psrdada includes from ${PSRDADA_INCLUDE_DIRS}")
include_directories(${PSRDADA_INCLUDE_DIRS})
# endif()
libdir=@CMAKE_INSTALL_FULL_LIBDIR@
includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
Name: psrdada_cpp
Description: PSRDADACPP
Version: @PROJECT_VERSION@
URL: https://gitlab.mpcdf.mpg.de/mpifr-bdg/psrdada_cpp
Requires: psrdada_cpp = @PROJECT_VERSION@
Libs: -L${libdir} -lpsrdada_cpp ${DEPENDENCY_LIBRARIES}
Cflags: -I${includedir}
\ No newline at end of file
@PACKAGE_INIT@
include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
check_required_components("@PROJECT_NAME@")
find_dependency(Boost REQUIRED COMPONENTS @BOOST_COMPONENTS@)
set(PSRDADA_CPP_INCLUDE_DIR "@CMAKE_INSTALL_PREFIX@/include/")
set(PSRDADA_CPP_LIBRARY_DIR "@CMAKE_INSTALL_PREFIX@/lib")
set(PSRDADA_CPP_LIBRARIES "psrdada_cpp::psrdada_cpp")
unset(_LIB)
\ No newline at end of file
# -------------------------------------------
# Build and integrate a thirdparty dependency
#
# Copyright Oxford university 2018
# Released under GPL v3
# --------------------------------------------
macro(add_thirdparty_subdirectory dependency_name dependency_dir)
set(dependency_install_path "thirdparty/${dependency_name}")
mark_as_advanced(dependency_install_path)
# save current project state
list(APPEND LIBRARY_INSTALL_DIR_STACK ${LIBRARY_INSTALL_DIR})
list(APPEND INCLUDE_INSTALL_DIR_STACK ${INCLUDE_INSTALL_DIR})
list(APPEND MODULES_INSTALL_DIR_STACK ${MODULES_INSTALL_DIR})
list(APPEND BINARY_INSTALL_DIR_STACK ${LIBRARY_INSTALL_DIR})
list(APPEND DOC_INSTALL_DIR_STACK ${DOC_INSTALL_DIR})
# set dependency install targets to be relative to the parent project
set(LIBRARY_INSTALL_DIR ${LIBRARY_INSTALL_DIR}/${dependency_install_path})
set(INCLUDE_INSTALL_DIR ${INCLUDE_INSTALL_DIR}/${dependency_install_path})
set(MODULES_INSTALL_DIR ${MODULES_INSTALL_DIR}/${dependency_install_path})
set(BINARY_INSTALL_DIR ${BINARY_INSTALL_DIR}/${dependency_install_path})
set(DOC_INSTALL_DIR ${DOC_INSTALL_DIR}/${dependency_install_path})
add_subdirectory(${dependency_dir})
# restore current project state
list(GET LIBRARY_INSTALL_DIR_STACK -1 LIBRARY_INSTALL_DIR)
list(REMOVE_AT LIBRARY_INSTALL_DIR_STACK -1)
list(GET INCLUDE_INSTALL_DIR_STACK -1 INCLUDE_INSTALL_DIR)
list(REMOVE_AT INCLUDE_INSTALL_DIR_STACK -1)
list(GET MODULES_INSTALL_DIR_STACK -1 MODULES_INSTALL_DIR)
list(REMOVE_AT MODULES_INSTALL_DIR_STACK -1)
list(GET BINARY_INSTALL_DIR_STACK -1 BINARY_INSTALL_DIR)
list(REMOVE_AT BINARY_INSTALL_DIR_STACK -1)
list(GET DOC_INSTALL_DIR_STACK -1 DOC_INSTALL_DIR)
list(REMOVE_AT DOC_INSTALL_DIR_STACK -1)
endmacro (add_thirdparty_directory)
psrdadacpp (250211+devel) UNRELEASED; urgency=medium
* Added missing runtime dependency: psrdada-dev
-- Niclas Esser <nesser@mpifr-bonn.mpg.de> Tue, 14 Nov 2024 20:43:10 +0000
psrdadacpp (241114+devel) UNRELEASED; urgency=medium
* Minor bug fixes
* CMake clean up
* Install one big library instead of multiple sub libraries
-- Niclas Esser <nesser@mpifr-bonn.mpg.de> Tue, 14 Nov 2024 20:43:10 +0000
psrdadacpp (241112+devel) UNRELEASED; urgency=medium
* New upstream release
* Added dadaflow library to the package
* Removed application libraries gated_spectrometer, merger, fft_spectrometer
* Refactored CMake project
-- Niclas Esser <nesser@mpifr-bonn.mpg.de> Tue, 12 Nov 2024 09:25:10 +0000
psrdadacpp (241017+devel1) UNRELEASED; urgency=medium
* New upstream release
* Install also testing tools
-- Tobias Winchen <twinchen@mpifr.de> Tue, 29 Oct 2024 13:28:20 +0000
psrdadacpp (241017+devel) noble; urgency=medium
[ Tobias Winchen ]
* Initial release.
* Created automatically
-- Niclas Esser <nesser@mpifr-bonn.mpg.de> Tue, 29 Oct 2024 10:35:07 +0000
Source: psrdadacpp
Section: science
Priority: optional
Maintainer: Tobias Winchen <twinchen@mpifr.de>
Build-Depends: dpkg-dev (>= 1.16.1~), debhelper (>= 12), debhelper-compat (= 12), psrdada, psrdada-dev, googletest, libgtest-dev, libgmock-dev
Vcs-Git:
Package: psrdadacpp
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
#, cuda-cudart-11-0, psrdada, libcufftw
Description: The psrdadacpp binary package
Package: psrdadacpp-dev
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}, psrdada-dev
Description: The psrdadacpp dev headers and runtime libraries.
Package: python3-psrdadacpp
Architecture: any
Depends: ${misc:Depends}, python3-all, python3-numpy, python3-posix-ipc
Description: The python3-psrdadacpp package contains the psrdada_cpp module.
#Package: psrdada-doc
#Architecture: any
#Depends: ${shlibs:Depends}, ${misc:Depends}
#Description: The psrdada documentation
Probably GPL-v3, but no thorough checking of license has been done.