diff --git a/.clang-tidy b/.clang-tidy index 0f25ded96..e906793e1 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -56,6 +56,7 @@ Checks: '-*, clang-analyzer-optin.performance.*, clang-analyzer-optin.portability.UnixAPI, clang-analyzer-security.*, + cppcoreguidelines-prefer-member-initializer, cppcoreguidelines-pro-type-cstyle-cast, cppcoreguidelines-pro-type-static-cast-downcast, cppcoreguidelines-slicing, @@ -120,70 +121,16 @@ HeaderFilterRegex: '' AnalyzeTemporaryDtors: false FormatStyle: 'file' CheckOptions: - - key: bugprone-argument-comment.CommentBoolLiterals - value: '0' - - key: bugprone-argument-comment.CommentCharacterLiterals - value: '0' - - key: bugprone-argument-comment.CommentFloatLiterals - value: '0' - - key: bugprone-argument-comment.CommentIntegerLiterals - value: '0' - - key: bugprone-argument-comment.CommentNullPtrs - value: '0' - - key: bugprone-argument-comment.CommentStringLiterals - value: '0' - - key: bugprone-argument-comment.CommentUserDefinedLiterals - value: '0' - - key: bugprone-argument-comment.IgnoreSingleArgument - value: '0' - - key: bugprone-argument-comment.StrictMode - value: '0' - - key: bugprone-assert-side-effect.AssertMacros - value: assert - - key: bugprone-assert-side-effect.CheckFunctionCalls - value: 'false' - - key: bugprone-dangling-handle.HandleClasses - value: 'std::basic_string_view;std::experimental::basic_string_view' - - key: bugprone-exception-escape.FunctionsThatShouldNotThrow - value: '' - - key: bugprone-exception-escape.IgnoredExceptions - value: '' - - key: bugprone-misplaced-widening-cast.CheckImplicitCasts - value: 'false' - - key: bugprone-reserved-identifier.AggressiveDependentMemberLookup - value: 'false' - - key: bugprone-reserved-identifier.AllowedIdentifiers + - key: performance-unnecessary-copy-initialization.ExcludedContainerTypes value: '' + - key: modernize-replace-auto-ptr.IncludeStyle + value: llvm + - key: performance-move-const-arg.CheckTriviallyCopyableMove + value: 'true' + - key: modernize-use-auto.MinTypeNameLength + value: '5' - key: bugprone-reserved-identifier.Invert value: 'false' - - key: bugprone-sizeof-expression.WarnOnSizeOfCompareToConstant - value: 'true' - - key: bugprone-sizeof-expression.WarnOnSizeOfConstant - value: 'true' - - key: bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression - value: 'false' - - key: bugprone-sizeof-expression.WarnOnSizeOfThis - value: 'true' - - key: bugprone-string-constructor.LargeLengthThreshold - value: '8388608' - - key: bugprone-string-constructor.WarnOnLargeLength - value: 'true' - - key: bugprone-suspicious-enum-usage.StrictMode - value: 'false' - - key: bugprone-suspicious-missing-comma.MaxConcatenatedTokens - value: '5' - - key: bugprone-suspicious-missing-comma.RatioThreshold - value: '0.200000' - - key: bugprone-suspicious-missing-comma.SizeThreshold - value: '5' - - key: bugprone-suspicious-string-compare.StringCompareLikeFunctions - value: '' - - key: bugprone-suspicious-string-compare.WarnOnImplicitComparison - value: 'true' - - key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison - value: 'false' - - key: bugprone-too-small-loop-variable.MagnitudeBitsUpperLimit - value: '16' - key: bugprone-unused-return-value.CheckedFunctions value: 'std::async; std::launder; @@ -276,148 +223,218 @@ std::vector::at; ::ttyname' - key: cert-dcl16-c.NewSuffixes value: 'L;LL;LU;LLU' - - key: cert-msc51-cpp.DisallowedSeedTypes - value: 'time_t,std::time_t' - - key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField - value: '0' - - key: cert-str34-c.DiagnoseSignedUnsignedCharComparisons - value: '0' - - key: cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors - value: '1' - - key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic - value: '1' - - key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctions - value: 'false' - - key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted - value: 'false' - - key: cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor - value: 'false' - - key: google-build-namespaces.HeaderFileExtensions - value: ';h;hh;hpp;hxx' - - key: google-global-names-in-headers.HeaderFileExtensions - value: ';h;hh;hpp;hxx' - - key: google-readability-braces-around-statements.ShortStatementLines - value: '1' - - key: google-readability-function-size.StatementThreshold - value: '800' - - key: google-readability-namespace-comments.ShortNamespaceLines - value: '10' - - key: google-readability-namespace-comments.SpacesBeforeComments - value: '2' - - key: google-runtime-int.SignedTypePrefix - value: int - - key: google-runtime-int.TypeSuffix - value: _t - - key: google-runtime-int.UnsignedTypePrefix - value: uint - - key: llvm-else-after-return.WarnOnConditionVariables - value: '0' - - key: llvm-else-after-return.WarnOnUnfixable - value: '0' - - key: llvm-qualified-auto.AddConstToQualified - value: '0' - - key: misc-throw-by-value-catch-by-reference.CheckThrowTemporaries - value: 'true' - - key: misc-throw-by-value-catch-by-reference.MaxSize - value: '64' - - key: misc-throw-by-value-catch-by-reference.WarnOnLargeObjects - value: 'false' - - key: modernize-avoid-bind.PermissiveParameterList - value: 'false' - - key: modernize-loop-convert.MaxCopySize - value: '16' - - key: modernize-loop-convert.MinConfidence - value: reasonable - - key: modernize-loop-convert.NamingStyle - value: CamelCase - - key: modernize-pass-by-value.IncludeStyle - value: llvm - - key: modernize-raw-string-literal.DelimiterStem - value: lit - - key: modernize-raw-string-literal.ReplaceShorterLiterals - value: 'false' - - key: modernize-replace-auto-ptr.IncludeStyle - value: llvm - - key: modernize-use-auto.MinTypeNameLength - value: '5' - - key: modernize-use-auto.RemoveStars - value: 'false' - - key: modernize-use-bool-literals.IgnoreMacros - value: 'true' - - key: modernize-use-default-member-init.IgnoreMacros - value: 'true' - - key: modernize-use-default-member-init.UseAssignment - value: 'false' - - key: modernize-use-emplace.ContainersWithPushBack - value: 'std::vector;std::list;std::deque' - - key: modernize-use-emplace.IgnoreImplicitConstructors - value: 'false' - - key: modernize-use-emplace.SmartPointers - value: 'std::shared_ptr;std::unique_ptr;std::auto_ptr;std::weak_ptr' - - key: modernize-use-emplace.TupleMakeFunctions - value: 'std::make_pair;std::make_tuple' - - key: modernize-use-emplace.TupleTypes - value: 'std::pair;std::tuple' - - key: modernize-use-equals-default.IgnoreMacros - value: 'true' - - key: modernize-use-equals-delete.IgnoreMacros - value: 'true' - - key: modernize-use-noexcept.ReplacementString - value: '' - - key: modernize-use-noexcept.UseNoexceptFalse - value: 'true' - - key: modernize-use-nullptr.NullMacros - value: 'NULL' - - key: modernize-use-override.AllowOverrideAndFinal - value: 'false' - - key: modernize-use-override.FinalSpelling - value: final - - key: modernize-use-override.IgnoreDestructors - value: 'false' - - key: modernize-use-override.OverrideSpelling - value: override - - key: performance-faster-string-find.StringLikeClasses - value: 'std::basic_string;std::basic_string_view' - - key: performance-for-range-copy.AllowedTypes - value: '' - - key: performance-for-range-copy.WarnOnAllAutoCopies - value: 'false' - - key: performance-inefficient-string-concatenation.StrictMode - value: 'false' - - key: performance-inefficient-vector-operation.EnableProto - value: 'false' - - key: performance-inefficient-vector-operation.VectorLikeClasses - value: 'std::vector' - - key: performance-move-const-arg.CheckTriviallyCopyableMove - value: 'true' - - key: performance-move-constructor-init.IncludeStyle - value: llvm - - key: performance-type-promotion-in-math-fn.IncludeStyle - value: llvm - - key: performance-unnecessary-copy-initialization.AllowedTypes - value: '' - - key: performance-unnecessary-value-param.AllowedTypes - value: '' - - key: performance-unnecessary-value-param.IncludeStyle - value: llvm - - key: readability-braces-around-statements.ShortStatementLines - value: '0' - - key: readability-identifier-naming.AggressiveDependentMemberLookup - value: 'false' - - key: readability-identifier-naming.IgnoreFailedSplit - value: 'false' - - key: readability-identifier-naming.IgnoreMainLikeFunctions - value: 'false' - - key: readability-inconsistent-declaration-parameter-name.IgnoreMacros + - key: readability-identifier-naming.GetConfigPerFile value: 'true' - key: readability-inconsistent-declaration-parameter-name.Strict value: 'false' + - key: modernize-use-default-member-init.UseAssignment + value: 'false' + - key: modernize-use-override.AllowOverrideAndFinal + value: 'false' + - key: modernize-loop-convert.IncludeStyle + value: llvm + - key: cert-str34-c.DiagnoseSignedUnsignedCharComparisons + value: 'false' + - key: misc-uniqueptr-reset-release.IncludeStyle + value: llvm + - key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison + value: 'false' + - key: readability-identifier-naming.AggressiveDependentMemberLookup + value: 'false' + - key: bugprone-suspicious-string-compare.WarnOnImplicitComparison + value: 'true' + - key: modernize-use-emplace.TupleTypes + value: 'std::pair;std::tuple' + - key: modernize-use-emplace.TupleMakeFunctions + value: 'std::make_pair;std::make_tuple' + - key: bugprone-argument-comment.CommentNullPtrs + value: '0' + - key: bugprone-argument-comment.StrictMode + value: '0' + - key: modernize-loop-convert.MakeReverseRangeHeader + value: '' + - key: modernize-use-bool-literals.IgnoreMacros + value: 'true' + - key: google-readability-namespace-comments.ShortNamespaceLines + value: '10' + - key: bugprone-suspicious-string-compare.StringCompareLikeFunctions + value: '' + - key: modernize-avoid-bind.PermissiveParameterList + value: 'false' + - key: modernize-use-override.FinalSpelling + value: final + - key: modernize-loop-convert.UseCxx20ReverseRanges + value: 'true' + - key: modernize-use-noexcept.ReplacementString + value: '' + - key: cppcoreguidelines-prefer-member-initializer.UseAssignment + value: 'false' + - key: performance-type-promotion-in-math-fn.IncludeStyle + value: llvm + - key: modernize-loop-convert.NamingStyle + value: CamelCase + - key: bugprone-suspicious-missing-comma.SizeThreshold + value: '5' + - key: readability-inconsistent-declaration-parameter-name.IgnoreMacros + value: 'true' + - key: performance-for-range-copy.WarnOnAllAutoCopies + value: 'false' + - key: bugprone-argument-comment.CommentIntegerLiterals + value: '0' + - key: google-runtime-int.UnsignedTypePrefix + value: uint + - key: modernize-loop-convert.MakeReverseRangeFunction + value: '' + - key: readability-identifier-naming.IgnoreFailedSplit + value: 'false' + - key: modernize-pass-by-value.IncludeStyle + value: llvm - key: readability-qualified-auto.AddConstToQualified value: 'true' - - key: readability-redundant-member-init.IgnoreBaseInCopyConstructors - value: 'false' + - key: bugprone-sizeof-expression.WarnOnSizeOfThis + value: 'true' + - key: bugprone-string-constructor.WarnOnLargeLength + value: 'true' + - key: bugprone-argument-comment.CommentCharacterLiterals + value: '0' + - key: bugprone-too-small-loop-variable.MagnitudeBitsUpperLimit + value: '16' + - key: bugprone-argument-comment.CommentFloatLiterals + value: '0' + - key: google-global-names-in-headers.HeaderFileExtensions + value: ';h;hh;hpp;hxx' - key: readability-uppercase-literal-suffix.IgnoreMacros value: 'true' + - key: modernize-use-nullptr.NullMacros + value: 'NULL' + - key: bugprone-suspicious-enum-usage.StrictMode + value: 'false' + - key: performance-unnecessary-copy-initialization.AllowedTypes + value: '' + - key: bugprone-suspicious-missing-comma.MaxConcatenatedTokens + value: '5' + - key: misc-throw-by-value-catch-by-reference.CheckThrowTemporaries + value: 'true' + - key: bugprone-string-constructor.LargeLengthThreshold + value: '8388608' + - key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctions + value: 'false' + - key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField + value: 'false' + - key: bugprone-exception-escape.FunctionsThatShouldNotThrow + value: '' + - key: performance-inefficient-vector-operation.EnableProto + value: 'false' + - key: bugprone-argument-comment.CommentStringLiterals + value: '0' + - key: modernize-loop-convert.MaxCopySize + value: '16' + - key: google-build-namespaces.HeaderFileExtensions + value: ';h;hh;hpp;hxx' + - key: cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors + value: 'true' + - key: performance-for-range-copy.AllowedTypes + value: '' + - key: modernize-use-override.IgnoreDestructors + value: 'false' + - key: bugprone-sizeof-expression.WarnOnSizeOfConstant + value: 'true' + - key: modernize-use-emplace.ContainersWithPushBack + value: 'std::vector;std::list;std::deque' + - key: bugprone-argument-comment.CommentBoolLiterals + value: '0' + - key: readability-braces-around-statements.ShortStatementLines + value: '0' + - key: bugprone-argument-comment.CommentUserDefinedLiterals + value: '0' + - key: modernize-use-override.OverrideSpelling + value: override + - key: performance-inefficient-string-concatenation.StrictMode + value: 'false' + - key: google-readability-braces-around-statements.ShortStatementLines + value: '1' + - key: google-runtime-int.TypeSuffix + value: _t + - key: bugprone-reserved-identifier.AllowedIdentifiers + value: '' + - key: modernize-use-emplace.IgnoreImplicitConstructors + value: 'false' + - key: modernize-use-equals-delete.IgnoreMacros + value: 'true' + - key: bugprone-misplaced-widening-cast.CheckImplicitCasts + value: 'false' - key: readability-uppercase-literal-suffix.NewSuffixes value: '' + - key: modernize-loop-convert.MinConfidence + value: reasonable + - key: performance-unnecessary-value-param.AllowedTypes + value: '' + - key: bugprone-suspicious-missing-comma.RatioThreshold + value: '0.200000' + - key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted + value: 'false' + - key: modernize-use-noexcept.UseNoexceptFalse + value: 'true' + - key: google-readability-namespace-comments.SpacesBeforeComments + value: '2' + - key: misc-throw-by-value-catch-by-reference.MaxSize + value: '64' + - key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic + value: 'true' + - key: bugprone-argument-comment.IgnoreSingleArgument + value: '0' + - key: bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression + value: 'false' + - key: performance-faster-string-find.StringLikeClasses + value: 'std::basic_string;std::basic_string_view' + - key: bugprone-assert-side-effect.CheckFunctionCalls + value: 'false' + - key: bugprone-string-constructor.StringNames + value: '::std::basic_string;::std::basic_string_view' + - key: bugprone-assert-side-effect.AssertMacros + value: assert + - key: bugprone-exception-escape.IgnoredExceptions + value: '' + - key: modernize-use-default-member-init.IgnoreMacros + value: 'true' + - key: llvm-qualified-auto.AddConstToQualified + value: 'false' + - key: readability-identifier-naming.IgnoreMainLikeFunctions + value: 'false' + - key: google-runtime-int.SignedTypePrefix + value: int + - key: google-readability-function-size.StatementThreshold + value: '800' + - key: llvm-else-after-return.WarnOnConditionVariables + value: 'false' + - key: cert-msc51-cpp.DisallowedSeedTypes + value: 'time_t,std::time_t' + - key: bugprone-sizeof-expression.WarnOnSizeOfCompareToConstant + value: 'true' + - key: bugprone-reserved-identifier.AggressiveDependentMemberLookup + value: 'false' + - key: modernize-raw-string-literal.DelimiterStem + value: lit + - key: modernize-use-equals-default.IgnoreMacros + value: 'true' + - key: misc-throw-by-value-catch-by-reference.WarnOnLargeObjects + value: 'false' + - key: cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor + value: 'false' + - key: modernize-raw-string-literal.ReplaceShorterLiterals + value: 'false' + - key: modernize-use-emplace.SmartPointers + value: 'std::shared_ptr;std::unique_ptr;std::auto_ptr;std::weak_ptr' + - key: performance-inefficient-vector-operation.VectorLikeClasses + value: 'std::vector' + - key: modernize-use-auto.RemoveStars + value: 'false' + - key: bugprone-dangling-handle.HandleClasses + value: 'std::basic_string_view;std::experimental::basic_string_view' + - key: performance-unnecessary-value-param.IncludeStyle + value: llvm + - key: readability-redundant-member-init.IgnoreBaseInCopyConstructors + value: 'false' + - key: llvm-else-after-return.WarnOnUnfixable + value: 'false' ... diff --git a/CMakeLists.txt b/CMakeLists.txt index bc2dfbc50..5710cca7a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -74,6 +74,8 @@ option(ENABLE_ARMA_NO_DEBUG OFF) option(ENABLE_STRIP "Create stripped binaries without debugging symbols (in Release build mode only)" OFF) +option(Boost_USE_STATIC_LIBS "Use Boost static libs" OFF) + if(ENABLE_PACKAGING) set(ENABLE_GENERIC_ARCH ON) set(ENABLE_ARMA_NO_DEBUG ON) @@ -671,19 +673,19 @@ if(NOT (GNURADIO_VERSION VERSION_LESS 3.8) AND (LOG4CPP_READY_FOR_CXX17 OR GNURA endif() if(FILESYSTEM_FOUND) set(CMAKE_CXX_STANDARD 17) - if(CMAKE_VERSION VERSION_GREATER 3.13) + # if(CMAKE_VERSION VERSION_GREATER 3.13) # UHD 3.15.0.0-5 does not support C++20 # GNU Radio 3.10.0.git does not support C++20 - if(((NOT UHD_FOUND) OR (UHD_FOUND AND ("${UHD_VERSION}" VERSION_LESS 3.14.99))) AND (GNURADIO_VERSION VERSION_LESS 3.9.99)) - # set(CMAKE_CXX_STANDARD 20) - if(CMAKE_VERSION VERSION_GREATER 3.20.99) - if(((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") AND NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "11.0.0")) OR - ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") AND NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "12.0"))) - # set(CMAKE_CXX_STANDARD 23) - endif() - endif() - endif() - endif() + # if(((NOT UHD_FOUND) OR (UHD_FOUND AND ("${UHD_VERSION}" VERSION_LESS 3.14.99))) AND (GNURADIO_VERSION VERSION_LESS 3.9.99)) + # set(CMAKE_CXX_STANDARD 20) + # if(CMAKE_VERSION VERSION_GREATER 3.20.99) + # if(((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") AND NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "11.0.0")) OR + # ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") AND NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "12.0"))) + # set(CMAKE_CXX_STANDARD 23) + # endif() + # endif() + # endif() + # endif() set(CMAKE_CXX_STANDARD_REQUIRED ON) endif() endif() @@ -711,9 +713,6 @@ set(Boost_ADDITIONAL_VERSIONS "1.70.0" "1.70" "1.71.0" "1.71" ) set(Boost_USE_MULTITHREAD ON) -#set(Boost_USE_STATIC_LIBS OFF) -option(Boost_USE_STATIC_LIBS "Use Boost static libs" OFF) - set(BOOST_COMPONENTS atomic chrono date_time serialization system thread) if(NOT ${FILESYSTEM_FOUND}) set(BOOST_COMPONENTS ${BOOST_COMPONENTS} filesystem) @@ -1807,6 +1806,8 @@ if(NOT TARGET BLAS::BLAS) ) endif() + + ################################################################################ # Check that LAPACK (Linear Algebra PACKage) is found in the system # See https://www.netlib.org/lapack/ @@ -1841,6 +1842,7 @@ if(NOT TARGET LAPACK::LAPACK) endif() + ################################################################################ # Armadillo - http://arma.sourceforge.net/ ################################################################################ @@ -2981,6 +2983,7 @@ else() endif() + ########################################## # gr-limesdr - OPTIONAL # https://github.com/myriadrf/gr-limesdr @@ -3008,6 +3011,7 @@ else() endif() + ############################################## # gr-iio - OPTIONAL # IIO blocks for GNU Radio @@ -3054,6 +3058,7 @@ if(ENABLE_PLUTOSDR OR ENABLE_FMCOMMS2) endif() + ##################################################################### # libiio - OPTIONAL # A library for interfacing with local and remote Linux IIO devices @@ -3081,6 +3086,7 @@ if(ENABLE_AD9361 OR ENABLE_FMCOMMS2) endif() + ############################################## # TELEORBIT FLEXIBAND FRONTEND - OPTIONAL ############################################## @@ -3112,6 +3118,7 @@ if(ENABLE_FLEXIBAND) endif() + ####################################################### # CTTC's digital array beamformer prototype - OPTIONAL ####################################################### @@ -3342,6 +3349,7 @@ add_feature_info(ENABLE_INSTALL_TESTS ENABLE_INSTALL_TESTS "Install test binarie add_feature_info(ENABLE_BENCHMARKS ENABLE_BENCHMARKS "Enables building of code snippet benchmarks.") add_feature_info(ENABLE_EXTERNAL_MATHJAX ENABLE_EXTERNAL_MATHJAX "Use MathJax from an external CDN in HTML docs when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME} doc'.") add_feature_info(ENABLE_OWN_CPUFEATURES ENABLE_OWN_CPUFEATURES "Force building own local version of the cpu_features library, even if it is already installed.") +add_feature_info(Boost_USE_STATIC_LIBS Boost_USE_STATIC_LIBS "Use Boost static libraries.") message(STATUS "") message(STATUS "***************************************") diff --git a/cmake/Toolchains/arm_cortex_a53_hardfp_native.cmake b/cmake/Toolchains/arm_cortex_a53_hardfp_native.cmake index 35e4d7f9e..d1e1e5417 100644 --- a/cmake/Toolchains/arm_cortex_a53_hardfp_native.cmake +++ b/cmake/Toolchains/arm_cortex_a53_hardfp_native.cmake @@ -5,7 +5,7 @@ # SPDX-License-Identifier: BSD-3-Clause ######################################################################## -# Toolchain file for building native on a ARM Cortex A72 w/ NEON +# Toolchain file for building native on a ARM Cortex A53 w/ NEON # Usage: cmake -DCMAKE_TOOLCHAIN_FILE= ######################################################################## set(CMAKE_CXX_COMPILER g++) diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index c1b7ffd93..1a3b673d8 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -42,7 +42,10 @@ All notable changes to GNSS-SDR will be documented in this file. readability of the code, could potentially increase performance, and allows for easier detection of unused data members (see https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md/#Rc-initialize). + Added the `cppcoreguidelines-prefer-member-initializer` clang-tidy check to + enforce this policy. - Non-functional change: Fixed formatting defects detected by clang-format 13.0. +- Non-functional change: Simplified flow graph disconnection. - Updated GSL implementation to v0.40.0. See https://github.com/gsl-lite/gsl-lite/releases/tag/v0.40.0 - CI - `cpplint` job on GitHub: Added the `build/include_what_you_use` filter @@ -95,6 +98,12 @@ All notable changes to GNSS-SDR will be documented in this file. - Added a new output parameter `Flag_PLL_180_deg_phase_locked` in the monitor output that indicates if the PLL got locked at 180 degrees, so the symbol sign is reversed. +- Fix bug in the satellite selection algorithm for configurations with a large + number of channels. The maximum number of channels per signal is now limited + to the number of available satellites per system minus one. The number of + channels performing concurrent acquisition, `Channels.in_acquisition`, cannot + be larger than the total number of channels. The program will stop if those + requirements are not met in the configuration file. See the definitions of concepts and metrics at https://gnss-sdr.org/design-forces/ diff --git a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.cc index f8c069eb5..05d26212c 100644 --- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.cc @@ -224,7 +224,7 @@ void GpsL1CaPcpsOpenClAcquisition::reset() } -float GpsL1CaPcpsOpenClAcquisition::calculate_threshold(float pfa) +float GpsL1CaPcpsOpenClAcquisition::calculate_threshold(float pfa) const { // Calculate the threshold unsigned int frequency_bins = 0; diff --git a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.h b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.h index b235fcbf3..6f73fd97e 100644 --- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.h +++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.h @@ -146,7 +146,7 @@ public: } private: - float calculate_threshold(float pfa); + float calculate_threshold(float pfa) const; const ConfigurationInterface* configuration_; pcps_opencl_acquisition_cc_sptr acquisition_cc_; gr::blocks::stream_to_vector::sptr stream_to_vector_; diff --git a/src/algorithms/channel/adapters/channel.cc b/src/algorithms/channel/adapters/channel.cc index 2352facaa..feac903cd 100644 --- a/src/algorithms/channel/adapters/channel.cc +++ b/src/algorithms/channel/adapters/channel.cc @@ -89,8 +89,8 @@ Channel::Channel(const ConfigurationInterface* configuration, acq_->set_threshold(threshold); acq_->init(); - - repeat_ = configuration->property("Acquisition_" + signal_str + std::to_string(channel_) + ".repeat_satellite", false); + repeat_ = configuration->property("Acquisition_" + signal_str + ".repeat_satellite", false); + repeat_ = configuration->property("Acquisition_" + signal_str + std::to_string(channel_) + ".repeat_satellite", repeat_); DLOG(INFO) << "Channel " << channel_ << " satellite repeat = " << repeat_; channel_fsm_->set_acquisition(acq_); diff --git a/src/algorithms/libs/opencl/fft_execute.cc b/src/algorithms/libs/opencl/fft_execute.cc index f3060852c..c481025c5 100644 --- a/src/algorithms/libs/opencl/fft_execute.cc +++ b/src/algorithms/libs/opencl/fft_execute.cc @@ -28,13 +28,16 @@ allocateTemporaryBufferInterleaved(cl_fft_plan *plan, cl_uint batchSize) size_t tmpLength = plan->n.x * plan->n.y * plan->n.z * batchSize * 2 * sizeof(cl_float); if (plan->tempmemobj) - clReleaseMemObject(plan->tempmemobj); + { + clReleaseMemObject(plan->tempmemobj); + } plan->tempmemobj = clCreateBuffer(plan->context, CL_MEM_READ_WRITE, tmpLength, nullptr, &err); } return err; } + static cl_int allocateTemporaryBufferPlannar(cl_fft_plan *plan, cl_uint batchSize) { @@ -46,10 +49,14 @@ allocateTemporaryBufferPlannar(cl_fft_plan *plan, cl_uint batchSize) size_t tmpLength = plan->n.x * plan->n.y * plan->n.z * batchSize * sizeof(cl_float); if (plan->tempmemobj_real) - clReleaseMemObject(plan->tempmemobj_real); + { + clReleaseMemObject(plan->tempmemobj_real); + } if (plan->tempmemobj_imag) - clReleaseMemObject(plan->tempmemobj_imag); + { + clReleaseMemObject(plan->tempmemobj_imag); + } plan->tempmemobj_real = clCreateBuffer(plan->context, CL_MEM_READ_WRITE, tmpLength, nullptr, &err); plan->tempmemobj_imag = clCreateBuffer(plan->context, CL_MEM_READ_WRITE, tmpLength, nullptr, &terr); @@ -58,6 +65,7 @@ allocateTemporaryBufferPlannar(cl_fft_plan *plan, cl_uint batchSize) return err; } + void getKernelWorkDimensions(cl_fft_plan *plan, cl_fft_kernel_info *kernelInfo, cl_int *batchSize, size_t *gWorkItems, size_t *lWorkItems) { *lWorkItems = kernelInfo->num_workitems_per_workgroup; @@ -83,6 +91,7 @@ void getKernelWorkDimensions(cl_fft_plan *plan, cl_fft_kernel_info *kernelInfo, *gWorkItems = numWorkGroups * *lWorkItems; } + cl_int clFFT_ExecuteInterleaved(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSize, clFFT_Direction dir, cl_mem data_in, cl_mem data_out, @@ -91,7 +100,9 @@ clFFT_ExecuteInterleaved(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSi int s; auto *plan = (cl_fft_plan *)Plan; if (plan->format != clFFT_InterleavedComplexFormat) - return CL_INVALID_VALUE; + { + return CL_INVALID_VALUE; + } cl_int err; size_t gWorkItems; @@ -101,7 +112,9 @@ clFFT_ExecuteInterleaved(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSi cl_int isInPlace = data_in == data_out ? 1 : 0; if ((err = allocateTemporaryBufferInterleaved(plan, batchSize)) != CL_SUCCESS) - return err; + { + return err; + } cl_mem memObj[3]; memObj[0] = data_in; @@ -146,7 +159,9 @@ clFFT_ExecuteInterleaved(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSi err |= clEnqueueNDRangeKernel(queue, kernelInfo->kernel, 1, nullptr, &gWorkItems, &lWorkItems, 0, nullptr, nullptr); if (err) - return err; + { + return err; + } currRead = (currWrite == 1) ? 1 : 2; currWrite = (currWrite == 1) ? 2 : 1; @@ -169,7 +184,9 @@ clFFT_ExecuteInterleaved(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSi err |= clEnqueueNDRangeKernel(queue, kernelInfo->kernel, 1, nullptr, &gWorkItems, &lWorkItems, 0, nullptr, nullptr); if (err) - return err; + { + return err; + } currRead = 1; currWrite = 1; @@ -181,6 +198,7 @@ clFFT_ExecuteInterleaved(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSi return err; } + cl_int clFFT_ExecutePlannar(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSize, clFFT_Direction dir, cl_mem data_in_real, cl_mem data_in_imag, cl_mem data_out_real, cl_mem data_out_imag, @@ -190,7 +208,9 @@ clFFT_ExecutePlannar(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSize, auto *plan = (cl_fft_plan *)Plan; if (plan->format != clFFT_SplitComplexFormat) - return CL_INVALID_VALUE; + { + return CL_INVALID_VALUE; + } cl_int err; size_t gWorkItems; @@ -200,7 +220,9 @@ clFFT_ExecutePlannar(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSize, cl_int isInPlace = ((data_in_real == data_out_real) && (data_in_imag == data_out_imag)) ? 1 : 0; if ((err = allocateTemporaryBufferPlannar(plan, batchSize)) != CL_SUCCESS) - return err; + { + return err; + } cl_mem memObj_real[3]; cl_mem memObj_imag[3]; @@ -252,7 +274,9 @@ clFFT_ExecutePlannar(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSize, err |= clEnqueueNDRangeKernel(queue, kernelInfo->kernel, 1, nullptr, &gWorkItems, &lWorkItems, 0, nullptr, nullptr); if (err) - return err; + { + return err; + } currRead = (currWrite == 1) ? 1 : 2; currWrite = (currWrite == 1) ? 2 : 1; @@ -276,7 +300,9 @@ clFFT_ExecutePlannar(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSize, err |= clEnqueueNDRangeKernel(queue, kernelInfo->kernel, 1, nullptr, &gWorkItems, &lWorkItems, 0, nullptr, nullptr); if (err) - return err; + { + return err; + } currRead = 1; currWrite = 1; @@ -288,6 +314,7 @@ clFFT_ExecutePlannar(cl_command_queue queue, clFFT_Plan Plan, cl_int batchSize, return err; } + cl_int clFFT_1DTwistInterleaved(clFFT_Plan Plan, cl_command_queue queue, cl_mem array, unsigned numRows, unsigned numCols, unsigned startRow, unsigned rowsToProcess, clFFT_Direction dir) @@ -304,12 +331,16 @@ clFFT_1DTwistInterleaved(clFFT_Plan Plan, cl_command_queue queue, cl_mem array, cl_device_id device_id; err = clGetCommandQueueInfo(queue, CL_QUEUE_DEVICE, sizeof(cl_device_id), &device_id, nullptr); if (err) - return err; + { + return err; + } size_t gSize; err = clGetKernelWorkGroupInfo(plan->twist_kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &gSize, nullptr); if (err) - return err; + { + return err; + } gSize = min(128, gSize); size_t numGlobalThreads[1] = {max(numCols / gSize, 1) * gSize}; @@ -327,6 +358,7 @@ clFFT_1DTwistInterleaved(clFFT_Plan Plan, cl_command_queue queue, cl_mem array, return err; } + cl_int clFFT_1DTwistPlannar(clFFT_Plan Plan, cl_command_queue queue, cl_mem array_real, cl_mem array_imag, unsigned numRows, unsigned numCols, unsigned startRow, unsigned rowsToProcess, clFFT_Direction dir) @@ -343,12 +375,16 @@ clFFT_1DTwistPlannar(clFFT_Plan Plan, cl_command_queue queue, cl_mem array_real, cl_device_id device_id; err = clGetCommandQueueInfo(queue, CL_QUEUE_DEVICE, sizeof(cl_device_id), &device_id, nullptr); if (err) - return err; + { + return err; + } size_t gSize; err = clGetKernelWorkGroupInfo(plan->twist_kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &gSize, nullptr); if (err) - return err; + { + return err; + } gSize = min(128, gSize); size_t numGlobalThreads[1] = {max(numCols / gSize, 1) * gSize}; diff --git a/src/algorithms/libs/opencl/fft_kernelstring.cc b/src/algorithms/libs/opencl/fft_kernelstring.cc index a659df259..87050c134 100644 --- a/src/algorithms/libs/opencl/fft_kernelstring.cc +++ b/src/algorithms/libs/opencl/fft_kernelstring.cc @@ -30,7 +30,7 @@ num2str(int num) { char temp[200]; snprintf(temp, sizeof(temp), "%d", num); - return string(temp); + return {temp}; } // For any n, this function decomposes n into factors for loacal memory tranpose @@ -155,15 +155,21 @@ getRadixArray(unsigned int n, unsigned int *radixArray, unsigned int *numRadices } } + static void insertHeader(string &kernelString, string &kernelName, clFFT_DataFormat dataFormat) { if (dataFormat == clFFT_SplitComplexFormat) - kernelString += string("__kernel void ") + kernelName + string("(__global float *in_real, __global float *in_imag, __global float *out_real, __global float *out_imag, int dir, int S)\n"); + { + kernelString += string("__kernel void ") + kernelName + string("(__global float *in_real, __global float *in_imag, __global float *out_real, __global float *out_imag, int dir, int S)\n"); + } else - kernelString += string("__kernel void ") + kernelName + string("(__global float2 *in, __global float2 *out, int dir, int S)\n"); + { + kernelString += string("__kernel void ") + kernelName + string("(__global float2 *in, __global float2 *out, int dir, int S)\n"); + } } + static void insertVariables(string &kStream, int maxRadix) { @@ -177,11 +183,14 @@ insertVariables(string &kStream, int maxRadix) kStream += string(" int groupId = get_group_id( 0 );\n"); } + static void formattedLoad(string &kernelString, int aIndex, int gIndex, clFFT_DataFormat dataFormat) { if (dataFormat == clFFT_InterleavedComplexFormat) - kernelString += string(" a[") + num2str(aIndex) + string("] = in[") + num2str(gIndex) + string("];\n"); + { + kernelString += string(" a[") + num2str(aIndex) + string("] = in[") + num2str(gIndex) + string("];\n"); + } else { kernelString += string(" a[") + num2str(aIndex) + string("].x = in_real[") + num2str(gIndex) + string("];\n"); @@ -189,11 +198,14 @@ formattedLoad(string &kernelString, int aIndex, int gIndex, clFFT_DataFormat dat } } + static void formattedStore(string &kernelString, int aIndex, int gIndex, clFFT_DataFormat dataFormat) { if (dataFormat == clFFT_InterleavedComplexFormat) - kernelString += string(" out[") + num2str(gIndex) + string("] = a[") + num2str(aIndex) + string("];\n"); + { + kernelString += string(" out[") + num2str(gIndex) + string("] = a[") + num2str(aIndex) + string("];\n"); + } else { kernelString += string(" out_real[") + num2str(gIndex) + string("] = a[") + num2str(aIndex) + string("].x;\n"); @@ -201,6 +213,7 @@ formattedStore(string &kernelString, int aIndex, int gIndex, clFFT_DataFormat da } } + static int insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXForm, int numXFormsPerWG, int R0, int mem_coalesce_width, clFFT_DataFormat dataFormat) { @@ -211,7 +224,9 @@ insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXF int lMemSize = 0; if (numXFormsPerWG > 1) - kernelString += string(" s = S & ") + num2str(numXFormsPerWG - 1) + string(";\n"); + { + kernelString += string(" s = S & ") + num2str(numXFormsPerWG - 1) + string(";\n"); + } if (numWorkItemsPerXForm >= mem_coalesce_width) { @@ -234,7 +249,9 @@ insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXF kernelString += string(" out_imag += offset;\n"); } for (i = 0; i < R0; i++) - formattedLoad(kernelString, i, i * numWorkItemsPerXForm, dataFormat); + { + formattedLoad(kernelString, i, i * numWorkItemsPerXForm, dataFormat); + } kernelString += string(" }\n"); } else @@ -255,7 +272,9 @@ insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXF kernelString += string(" out_imag += offset;\n"); } for (i = 0; i < R0; i++) - formattedLoad(kernelString, i, i * numWorkItemsPerXForm, dataFormat); + { + formattedLoad(kernelString, i, i * numWorkItemsPerXForm, dataFormat); + } } } else if (N >= mem_coalesce_width) @@ -286,17 +305,23 @@ insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXF { kernelString += string(" if( jj < s ) {\n"); for (j = 0; j < numInnerIter; j++) - formattedLoad(kernelString, i * numInnerIter + j, j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * N, dataFormat); + { + formattedLoad(kernelString, i * numInnerIter + j, j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * N, dataFormat); + } kernelString += string(" }\n"); if (i != numOuterIter - 1) - kernelString += string(" jj += ") + num2str(groupSize / mem_coalesce_width) + string(";\n"); + { + kernelString += string(" jj += ") + num2str(groupSize / mem_coalesce_width) + string(";\n"); + } } kernelString += string("}\n "); kernelString += string("else {\n"); for (i = 0; i < numOuterIter; i++) { for (j = 0; j < numInnerIter; j++) - formattedLoad(kernelString, i * numInnerIter + j, j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * N, dataFormat); + { + formattedLoad(kernelString, i * numInnerIter + j, j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * N, dataFormat); + } } kernelString += string("}\n"); @@ -315,7 +340,9 @@ insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXF kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < R0; i++) - kernelString += string(" a[") + num2str(i) + string("].x = lMemLoad[") + num2str(i * numWorkItemsPerXForm) + string("];\n"); + { + kernelString += string(" a[") + num2str(i) + string("].x = lMemLoad[") + num2str(i * numWorkItemsPerXForm) + string("];\n"); + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < numOuterIter; i++) @@ -329,7 +356,9 @@ insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXF kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < R0; i++) - kernelString += string(" a[") + num2str(i) + string("].y = lMemLoad[") + num2str(i * numWorkItemsPerXForm) + string("];\n"); + { + kernelString += string(" a[") + num2str(i) + string("].y = lMemLoad[") + num2str(i * numWorkItemsPerXForm) + string("];\n"); + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); lMemSize = (N + numWorkItemsPerXForm) * numXFormsPerWG; @@ -360,7 +389,9 @@ insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXF kernelString += string(" if(jj < s )\n"); formattedLoad(kernelString, i, i * groupSize, dataFormat); if (i != R0 - 1) - kernelString += string(" jj += ") + num2str(groupSize / N) + string(";\n"); + { + kernelString += string(" jj += ") + num2str(groupSize / N) + string(";\n"); + } } kernelString += string("}\n"); kernelString += string("else {\n"); @@ -385,19 +416,27 @@ insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXF for (i = 0; i < R0; i++) - kernelString += string(" lMemStore[") + num2str(i * (groupSize / N) * (N + numWorkItemsPerXForm)) + string("] = a[") + num2str(i) + string("].x;\n"); + { + kernelString += string(" lMemStore[") + num2str(i * (groupSize / N) * (N + numWorkItemsPerXForm)) + string("] = a[") + num2str(i) + string("].x;\n"); + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < R0; i++) - kernelString += string(" a[") + num2str(i) + string("].x = lMemLoad[") + num2str(i * numWorkItemsPerXForm) + string("];\n"); + { + kernelString += string(" a[") + num2str(i) + string("].x = lMemLoad[") + num2str(i * numWorkItemsPerXForm) + string("];\n"); + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < R0; i++) - kernelString += string(" lMemStore[") + num2str(i * (groupSize / N) * (N + numWorkItemsPerXForm)) + string("] = a[") + num2str(i) + string("].y;\n"); + { + kernelString += string(" lMemStore[") + num2str(i * (groupSize / N) * (N + numWorkItemsPerXForm)) + string("] = a[") + num2str(i) + string("].y;\n"); + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < R0; i++) - kernelString += string(" a[") + num2str(i) + string("].y = lMemLoad[") + num2str(i * numWorkItemsPerXForm) + string("];\n"); + { + kernelString += string(" a[") + num2str(i) + string("].y = lMemLoad[") + num2str(i * numWorkItemsPerXForm) + string("];\n"); + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); lMemSize = (N + numWorkItemsPerXForm) * numXFormsPerWG; @@ -406,6 +445,7 @@ insertGlobalLoadsAndTranspose(string &kernelString, int N, int numWorkItemsPerXF return lMemSize; } + static int insertGlobalStoresAndTranspose(string &kernelString, int N, int maxRadix, int Nr, int numWorkItemsPerXForm, int numXFormsPerWG, int mem_coalesce_width, clFFT_DataFormat dataFormat) { @@ -433,7 +473,9 @@ insertGlobalStoresAndTranspose(string &kernelString, int N, int maxRadix, int Nr formattedStore(kernelString, ind, i * numWorkItemsPerXForm, dataFormat); } if (numXFormsPerWG > 1) - kernelString += string(" }\n"); + { + kernelString += string(" }\n"); + } } else if (N >= mem_coalesce_width) { @@ -455,8 +497,12 @@ insertGlobalStoresAndTranspose(string &kernelString, int N, int maxRadix, int Nr kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < numOuterIter; i++) - for (j = 0; j < numInnerIter; j++) - kernelString += string(" a[") + num2str(i * numInnerIter + j) + string("].x = lMemStore[") + num2str(j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * (N + numWorkItemsPerXForm)) + string("];\n"); + { + for (j = 0; j < numInnerIter; j++) + { + kernelString += string(" a[") + num2str(i * numInnerIter + j) + string("].x = lMemStore[") + num2str(j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * (N + numWorkItemsPerXForm)) + string("];\n"); + } + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < maxRadix; i++) @@ -469,8 +515,12 @@ insertGlobalStoresAndTranspose(string &kernelString, int N, int maxRadix, int Nr kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < numOuterIter; i++) - for (j = 0; j < numInnerIter; j++) - kernelString += string(" a[") + num2str(i * numInnerIter + j) + string("].y = lMemStore[") + num2str(j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * (N + numWorkItemsPerXForm)) + string("];\n"); + { + for (j = 0; j < numInnerIter; j++) + { + kernelString += string(" a[") + num2str(i * numInnerIter + j) + string("].y = lMemStore[") + num2str(j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * (N + numWorkItemsPerXForm)) + string("];\n"); + } + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); kernelString += string("if((groupId == get_num_groups(0)-1) && s) {\n"); @@ -478,17 +528,23 @@ insertGlobalStoresAndTranspose(string &kernelString, int N, int maxRadix, int Nr { kernelString += string(" if( jj < s ) {\n"); for (j = 0; j < numInnerIter; j++) - formattedStore(kernelString, i * numInnerIter + j, j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * N, dataFormat); + { + formattedStore(kernelString, i * numInnerIter + j, j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * N, dataFormat); + } kernelString += string(" }\n"); if (i != numOuterIter - 1) - kernelString += string(" jj += ") + num2str(groupSize / mem_coalesce_width) + string(";\n"); + { + kernelString += string(" jj += ") + num2str(groupSize / mem_coalesce_width) + string(";\n"); + } } kernelString += string("}\n"); kernelString += string("else {\n"); for (i = 0; i < numOuterIter; i++) { for (j = 0; j < numInnerIter; j++) - formattedStore(kernelString, i * numInnerIter + j, j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * N, dataFormat); + { + formattedStore(kernelString, i * numInnerIter + j, j * mem_coalesce_width + i * (groupSize / mem_coalesce_width) * N, dataFormat); + } } kernelString += string("}\n"); @@ -512,7 +568,9 @@ insertGlobalStoresAndTranspose(string &kernelString, int N, int maxRadix, int Nr kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < maxRadix; i++) - kernelString += string(" a[") + num2str(i) + string("].x = lMemStore[") + num2str(i * (groupSize / N) * (N + numWorkItemsPerXForm)) + string("];\n"); + { + kernelString += string(" a[") + num2str(i) + string("].x = lMemStore[") + num2str(i * (groupSize / N) * (N + numWorkItemsPerXForm)) + string("];\n"); + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < maxRadix; i++) @@ -525,7 +583,9 @@ insertGlobalStoresAndTranspose(string &kernelString, int N, int maxRadix, int Nr kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); for (i = 0; i < maxRadix; i++) - kernelString += string(" a[") + num2str(i) + string("].y = lMemStore[") + num2str(i * (groupSize / N) * (N + numWorkItemsPerXForm)) + string("];\n"); + { + kernelString += string(" a[") + num2str(i) + string("].y = lMemStore[") + num2str(i * (groupSize / N) * (N + numWorkItemsPerXForm)) + string("];\n"); + } kernelString += string(" barrier( CLK_LOCAL_MEM_FENCE );\n"); kernelString += string("if((groupId == get_num_groups(0)-1) && s) {\n"); @@ -535,7 +595,9 @@ insertGlobalStoresAndTranspose(string &kernelString, int N, int maxRadix, int Nr formattedStore(kernelString, i, i * groupSize, dataFormat); kernelString += string(" }\n"); if (i != maxRadix - 1) - kernelString += string(" jj +=") + num2str(groupSize / N) + string(";\n"); + { + kernelString += string(" jj +=") + num2str(groupSize / N) + string(";\n"); + } } kernelString += string("}\n"); kernelString += string("else {\n"); @@ -551,6 +613,7 @@ insertGlobalStoresAndTranspose(string &kernelString, int N, int maxRadix, int Nr return lMemSize; } + static void insertfftKernel(string &kernelString, int Nr, int numIter) { @@ -561,6 +624,7 @@ insertfftKernel(string &kernelString, int Nr, int numIter) } } + static void insertTwiddleKernel(string &kernelString, int Nr, int numIter, int Nprev, int len, int numWorkItemsPerXForm) { @@ -573,16 +637,24 @@ insertTwiddleKernel(string &kernelString, int Nr, int numIter, int Nprev, int le if (z == 0) { if (Nprev > 1) - kernelString += string(" angf = (float) (ii >> ") + num2str(logNPrev) + string(");\n"); + { + kernelString += string(" angf = (float) (ii >> ") + num2str(logNPrev) + string(");\n"); + } else - kernelString += string(" angf = (float) ii;\n"); + { + kernelString += string(" angf = (float) ii;\n"); + } } else { if (Nprev > 1) - kernelString += string(" angf = (float) ((") + num2str(z * numWorkItemsPerXForm) + string(" + ii) >>") + num2str(logNPrev) + string(");\n"); + { + kernelString += string(" angf = (float) ((") + num2str(z * numWorkItemsPerXForm) + string(" + ii) >>") + num2str(logNPrev) + string(");\n"); + } else - kernelString += string(" angf = (float) (") + num2str(z * numWorkItemsPerXForm) + string(" + ii);\n"); + { + kernelString += string(" angf = (float) (") + num2str(z * numWorkItemsPerXForm) + string(" + ii);\n"); + } } for (k = 1; k < Nr; k++) @@ -596,30 +668,41 @@ insertTwiddleKernel(string &kernelString, int Nr, int numIter, int Nprev, int le } } + static int getPadding(int numWorkItemsPerXForm, int Nprev, int numWorkItemsReq, int numXFormsPerWG, int Nr, int numBanks, int *offset, int *midPad) { if ((numWorkItemsPerXForm <= Nprev) || (Nprev >= numBanks)) - *offset = 0; + { + *offset = 0; + } else { int numRowsReq = ((numWorkItemsPerXForm < numBanks) ? numWorkItemsPerXForm : numBanks) / Nprev; int numColsReq = 1; if (numRowsReq > Nr) - numColsReq = numRowsReq / Nr; + { + numColsReq = numRowsReq / Nr; + } numColsReq = Nprev * numColsReq; *offset = numColsReq; } if (numWorkItemsPerXForm >= numBanks || numXFormsPerWG == 1) - *midPad = 0; + { + *midPad = 0; + } else { int bankNum = ((numWorkItemsReq + *offset) * Nr) & (numBanks - 1); if (bankNum >= numWorkItemsPerXForm) - *midPad = 0; + { + *midPad = 0; + } else - *midPad = numWorkItemsPerXForm - bankNum; + { + *midPad = numWorkItemsPerXForm - bankNum; + } } int lMemSize = (numWorkItemsReq + *offset) * Nr * numXFormsPerWG + *midPad * (numXFormsPerWG - 1); @@ -644,6 +727,7 @@ insertLocalStores(string &kernelString, int numIter, int Nr, int numWorkItemsPer kernelString += string(" barrier(CLK_LOCAL_MEM_FENCE);\n"); } + static void insertLocalLoads(string &kernelString, int n, int Nr, int Nrn, int Nprev, int Ncurr, int numWorkItemsPerXForm, int numWorkItemsReq, int offset, string &comp) { @@ -676,6 +760,7 @@ insertLocalLoads(string &kernelString, int n, int Nr, int Nrn, int Nprev, int Nc kernelString += string(" barrier(CLK_LOCAL_MEM_FENCE);\n"); } + static void insertLocalLoadIndexArithmatic(string &kernelString, int Nprev, int Nr, int numWorkItemsReq, int numWorkItemsPerXForm, int numXFormsPerWG, int offset, int midPad) { @@ -687,33 +772,52 @@ insertLocalLoadIndexArithmatic(string &kernelString, int Nprev, int Nr, int numW if (Ncurr < numWorkItemsPerXForm) { if (Nprev == 1) - kernelString += string(" j = ii & ") + num2str(Ncurr - 1) + string(";\n"); + { + kernelString += string(" j = ii & ") + num2str(Ncurr - 1) + string(";\n"); + } else - kernelString += string(" j = (ii & ") + num2str(Ncurr - 1) + string(") >> ") + num2str(logNprev) + string(";\n"); + { + kernelString += string(" j = (ii & ") + num2str(Ncurr - 1) + string(") >> ") + num2str(logNprev) + string(";\n"); + } if (Nprev == 1) - kernelString += string(" i = ii >> ") + num2str(logNcurr) + string(";\n"); + { + kernelString += string(" i = ii >> ") + num2str(logNcurr) + string(";\n"); + } else - kernelString += string(" i = mad24(ii >> ") + num2str(logNcurr) + string(", ") + num2str(Nprev) + string(", ii & ") + num2str(Nprev - 1) + string(");\n"); + { + kernelString += string(" i = mad24(ii >> ") + num2str(logNcurr) + string(", ") + num2str(Nprev) + string(", ii & ") + num2str(Nprev - 1) + string(");\n"); + } } else { if (Nprev == 1) - kernelString += string(" j = ii;\n"); + { + kernelString += string(" j = ii;\n"); + } else - kernelString += string(" j = ii >> ") + num2str(logNprev) + string(";\n"); + { + kernelString += string(" j = ii >> ") + num2str(logNprev) + string(";\n"); + } if (Nprev == 1) - kernelString += string(" i = 0;\n"); + { + kernelString += string(" i = 0;\n"); + } else - kernelString += string(" i = ii & ") + num2str(Nprev - 1) + string(";\n"); + { + kernelString += string(" i = ii & ") + num2str(Nprev - 1) + string(";\n"); + } } if (numXFormsPerWG > 1) - kernelString += string(" i = mad24(jj, ") + num2str(incr) + string(", i);\n"); + { + kernelString += string(" i = mad24(jj, ") + num2str(incr) + string(", i);\n"); + } kernelString += string(" lMemLoad = sMem + mad24(j, ") + num2str(numWorkItemsReq + offset) + string(", i);\n"); } + static void insertLocalStoreIndexArithmatic(string &kernelString, int numWorkItemsReq, int numXFormsPerWG, int Nr, int offset, int midPad) { @@ -742,7 +846,9 @@ createLocalMemfftKernelString(cl_fft_plan *plan) assert(numRadix > 0 && "no radix array supplied\n"); if (n / radixArray[0] > plan->max_work_item_per_workgroup) - getRadixArray(n, radixArray, &numRadix, plan->max_radix); + { + getRadixArray(n, radixArray, &numRadix, plan->max_radix); + } assert(radixArray[0] <= plan->max_radix && "max radix choosen is greater than allowed\n"); assert(n / radixArray[0] <= plan->max_work_item_per_workgroup && "required work items per xform greater than maximum work items allowed per work group for local mem fft\n"); @@ -839,11 +945,14 @@ createLocalMemfftKernelString(cl_fft_plan *plan) insertHeader(*kernelString, kernelName, dataFormat); *kernelString += string("{\n"); if ((*kInfo)->lmem_size) - *kernelString += string(" __local float sMem[") + num2str((*kInfo)->lmem_size) + string("];\n"); + { + *kernelString += string(" __local float sMem[") + num2str((*kInfo)->lmem_size) + string("];\n"); + } *kernelString += localString; *kernelString += string("}\n"); } + // For n larger than what can be computed using local memory fft, global transposes // multiple kernel launces is needed. For these sizes, n can be decomposed using // much larger base radices i.e. say n = 262144 = 128 x 64 x 32. Thus three kernel @@ -864,7 +973,6 @@ createLocalMemfftKernelString(cl_fft_plan *plan) // in this example. Users can play with difference base radices and difference // decompositions of base radices to generates different kernels and see which gives // best performance. Following function is just fixed to use 128 as base radix - void getGlobalRadixInfo(int n, int *radix, int *R1, int *R2, int *numRadices) { int baseRadix = min(n, 128); @@ -878,7 +986,9 @@ void getGlobalRadixInfo(int n, int *radix, int *R1, int *R2, int *numRadices) } for (int i = 0; i < numR; i++) - radix[i] = baseRadix; + { + radix[i] = baseRadix; + } radix[numR] = N; numR++; @@ -906,6 +1016,7 @@ void getGlobalRadixInfo(int n, int *radix, int *R1, int *R2, int *numRadices) } } + static void createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir dir, int vertBS) { @@ -960,12 +1071,18 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir int strideI = Rinit; for (i = 0; i < numPasses; i++) - if (i != passNum) - strideI *= radixArr[i]; + { + if (i != passNum) + { + strideI *= radixArr[i]; + } + } int strideO = Rinit; for (i = 0; i < passNum; i++) - strideO *= radixArr[i]; + { + strideO *= radixArr[i]; + } int threadsPerXForm = R2; batchSize = R2 == 1 ? plan->max_work_item_per_workgroup : batchSize; @@ -986,30 +1103,44 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir int numBlocksPerXForm = strideI / batchSize; int numBlocks = numBlocksPerXForm; if (!vertical) - numBlocks *= BS; + { + numBlocks *= BS; + } else - numBlocks *= vertBS; + { + numBlocks *= vertBS; + } kernelName = string("fft") + num2str(kCount); *kInfo = (cl_fft_kernel_info *)malloc(sizeof(cl_fft_kernel_info)); (*kInfo)->kernel = nullptr; if (R2 == 1) - (*kInfo)->lmem_size = 0; + { + (*kInfo)->lmem_size = 0; + } else { if (strideO == 1) - (*kInfo)->lmem_size = (radix + 1) * batchSize; + { + (*kInfo)->lmem_size = (radix + 1) * batchSize; + } else - (*kInfo)->lmem_size = threadsPerBlock * R1; + { + (*kInfo)->lmem_size = threadsPerBlock * R1; + } } (*kInfo)->num_workgroups = numBlocks; (*kInfo)->num_xforms_per_workgroup = 1; (*kInfo)->num_workitems_per_workgroup = threadsPerBlock; (*kInfo)->dir = dir; if ((passNum == (numPasses - 1)) && (numPasses & 1)) - (*kInfo)->in_place_possible = 1; + { + (*kInfo)->in_place_possible = 1; + } else - (*kInfo)->in_place_possible = 0; + { + (*kInfo)->in_place_possible = 0; + } (*kInfo)->next = nullptr; (*kInfo)->kernel_name = (char *)malloc(sizeof(char) * (kernelName.size() + 1)); snprintf((*kInfo)->kernel_name, sizeof((*kInfo)->kernel_name), kernelName.c_str()); @@ -1026,7 +1157,9 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir localString += string("j = tid & ") + num2str(strideO - 1) + string(";\n"); int stride = radix * Rinit; for (i = 0; i < passNum; i++) - stride *= radixArr[i]; + { + stride *= radixArr[i]; + } localString += string("indexOut = mad24(i, ") + num2str(stride) + string(", j + ") + string("(xNum << ") + num2str((int)log2(n * BS)) + string("));\n"); localString += string("bNum = groupId;\n"); } @@ -1041,7 +1174,9 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir localString += string("j = tid & ") + num2str(strideO - 1) + string(";\n"); int stride = radix * Rinit; for (i = 0; i < passNum; i++) - stride *= radixArr[i]; + { + stride *= radixArr[i]; + } localString += string("indexOut = mad24(i, ") + num2str(stride) + string(", j);\n"); localString += string("indexIn += (xNum << ") + num2str(m) + string(");\n"); localString += string("indexOut += (xNum << ") + num2str(m) + string(");\n"); @@ -1059,15 +1194,21 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir localString += string("in_real += indexIn;\n"); localString += string("in_imag += indexIn;\n"); for (j = 0; j < R1; j++) - localString += string("a[") + num2str(j) + string("].x = in_real[") + num2str(j * gInInc * strideI) + string("];\n"); + { + localString += string("a[") + num2str(j) + string("].x = in_real[") + num2str(j * gInInc * strideI) + string("];\n"); + } for (j = 0; j < R1; j++) - localString += string("a[") + num2str(j) + string("].y = in_imag[") + num2str(j * gInInc * strideI) + string("];\n"); + { + localString += string("a[") + num2str(j) + string("].y = in_imag[") + num2str(j * gInInc * strideI) + string("];\n"); + } } else { localString += string("in += indexIn;\n"); for (j = 0; j < R1; j++) - localString += string("a[") + num2str(j) + string("] = in[") + num2str(j * gInInc * strideI) + string("];\n"); + { + localString += string("a[") + num2str(j) + string("] = in[") + num2str(j * gInInc * strideI) + string("];\n"); + } } localString += string("fftKernel") + num2str(R1) + string("(a, dir);\n"); @@ -1088,22 +1229,36 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir localString += string("lMemStore = sMem + tid;\n"); localString += string("lMemLoad = sMem + indexIn;\n"); for (k = 0; k < R1; k++) - localString += string("lMemStore[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("].x;\n"); + { + localString += string("lMemStore[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("].x;\n"); + } localString += string("barrier(CLK_LOCAL_MEM_FENCE);\n"); for (k = 0; k < numIter; k++) - for (t = 0; t < R2; t++) - localString += string("a[") + num2str(k * R2 + t) + string("].x = lMemLoad[") + num2str(t * batchSize + k * threadsPerBlock) + string("];\n"); + { + for (t = 0; t < R2; t++) + { + localString += string("a[") + num2str(k * R2 + t) + string("].x = lMemLoad[") + num2str(t * batchSize + k * threadsPerBlock) + string("];\n"); + } + } localString += string("barrier(CLK_LOCAL_MEM_FENCE);\n"); for (k = 0; k < R1; k++) - localString += string("lMemStore[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("].y;\n"); + { + localString += string("lMemStore[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("].y;\n"); + } localString += string("barrier(CLK_LOCAL_MEM_FENCE);\n"); for (k = 0; k < numIter; k++) - for (t = 0; t < R2; t++) - localString += string("a[") + num2str(k * R2 + t) + string("].y = lMemLoad[") + num2str(t * batchSize + k * threadsPerBlock) + string("];\n"); + { + for (t = 0; t < R2; t++) + { + localString += string("a[") + num2str(k * R2 + t) + string("].y = lMemLoad[") + num2str(t * batchSize + k * threadsPerBlock) + string("];\n"); + } + } localString += string("barrier(CLK_LOCAL_MEM_FENCE);\n"); for (j = 0; j < numIter; j++) - localString += string("fftKernel") + num2str(R2) + string("(a + ") + num2str(j * R2) + string(", dir);\n"); + { + localString += string("fftKernel") + num2str(R2) + string("(a + ") + num2str(j * R2) + string(", dir);\n"); + } } // twiddle @@ -1127,40 +1282,60 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir localString += string("lMemLoad = sMem + mad24(tid >> ") + num2str((int)log2(radix)) + string(", ") + num2str(radix + 1) + string(", tid & ") + num2str(radix - 1) + string(");\n"); for (i = 0; i < R1 / R2; i++) - for (j = 0; j < R2; j++) - localString += string("lMemStore[ ") + num2str(i + j * R1) + string("] = a[") + num2str(i * R2 + j) + string("].x;\n"); + { + for (j = 0; j < R2; j++) + { + localString += string("lMemStore[ ") + num2str(i + j * R1) + string("] = a[") + num2str(i * R2 + j) + string("].x;\n"); + } + } localString += string("barrier(CLK_LOCAL_MEM_FENCE);\n"); if (threadsPerBlock >= radix) { for (i = 0; i < R1; i++) - localString += string("a[") + num2str(i) + string("].x = lMemLoad[") + num2str(i * (radix + 1) * (threadsPerBlock / radix)) + string("];\n"); + { + localString += string("a[") + num2str(i) + string("].x = lMemLoad[") + num2str(i * (radix + 1) * (threadsPerBlock / radix)) + string("];\n"); + } } else { int innerIter = radix / threadsPerBlock; int outerIter = R1 / innerIter; for (i = 0; i < outerIter; i++) - for (j = 0; j < innerIter; j++) - localString += string("a[") + num2str(i * innerIter + j) + string("].x = lMemLoad[") + num2str(j * threadsPerBlock + i * (radix + 1)) + string("];\n"); + { + for (j = 0; j < innerIter; j++) + { + localString += string("a[") + num2str(i * innerIter + j) + string("].x = lMemLoad[") + num2str(j * threadsPerBlock + i * (radix + 1)) + string("];\n"); + } + } } localString += string("barrier(CLK_LOCAL_MEM_FENCE);\n"); for (i = 0; i < R1 / R2; i++) - for (j = 0; j < R2; j++) - localString += string("lMemStore[ ") + num2str(i + j * R1) + string("] = a[") + num2str(i * R2 + j) + string("].y;\n"); + { + for (j = 0; j < R2; j++) + { + localString += string("lMemStore[ ") + num2str(i + j * R1) + string("] = a[") + num2str(i * R2 + j) + string("].y;\n"); + } + } localString += string("barrier(CLK_LOCAL_MEM_FENCE);\n"); if (threadsPerBlock >= radix) { for (i = 0; i < R1; i++) - localString += string("a[") + num2str(i) + string("].y = lMemLoad[") + num2str(i * (radix + 1) * (threadsPerBlock / radix)) + string("];\n"); + { + localString += string("a[") + num2str(i) + string("].y = lMemLoad[") + num2str(i * (radix + 1) * (threadsPerBlock / radix)) + string("];\n"); + } } else { int innerIter = radix / threadsPerBlock; int outerIter = R1 / innerIter; for (i = 0; i < outerIter; i++) - for (j = 0; j < innerIter; j++) - localString += string("a[") + num2str(i * innerIter + j) + string("].y = lMemLoad[") + num2str(j * threadsPerBlock + i * (radix + 1)) + string("];\n"); + { + for (j = 0; j < innerIter; j++) + { + localString += string("a[") + num2str(i * innerIter + j) + string("].y = lMemLoad[") + num2str(j * threadsPerBlock + i * (radix + 1)) + string("];\n"); + } + } } localString += string("barrier(CLK_LOCAL_MEM_FENCE);\n"); @@ -1170,15 +1345,21 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir localString += string("out_real += indexOut;\n"); localString += string("out_imag += indexOut;\n"); for (k = 0; k < R1; k++) - localString += string("out_real[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("].x;\n"); + { + localString += string("out_real[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("].x;\n"); + } for (k = 0; k < R1; k++) - localString += string("out_imag[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("].y;\n"); + { + localString += string("out_imag[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("].y;\n"); + } } else { localString += string("out += indexOut;\n"); for (k = 0; k < R1; k++) - localString += string("out[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("];\n"); + { + localString += string("out[") + num2str(k * threadsPerBlock) + string("] = a[") + num2str(k) + string("];\n"); + } } } else @@ -1189,22 +1370,30 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir localString += string("out_real += indexOut;\n"); localString += string("out_imag += indexOut;\n"); for (k = 0; k < R1; k++) - localString += string("out_real[") + num2str(((k % R2) * R1 + (k / R2)) * strideO) + string("] = a[") + num2str(k) + string("].x;\n"); + { + localString += string("out_real[") + num2str(((k % R2) * R1 + (k / R2)) * strideO) + string("] = a[") + num2str(k) + string("].x;\n"); + } for (k = 0; k < R1; k++) - localString += string("out_imag[") + num2str(((k % R2) * R1 + (k / R2)) * strideO) + string("] = a[") + num2str(k) + string("].y;\n"); + { + localString += string("out_imag[") + num2str(((k % R2) * R1 + (k / R2)) * strideO) + string("] = a[") + num2str(k) + string("].y;\n"); + } } else { localString += string("out += indexOut;\n"); for (k = 0; k < R1; k++) - localString += string("out[") + num2str(((k % R2) * R1 + (k / R2)) * strideO) + string("] = a[") + num2str(k) + string("];\n"); + { + localString += string("out[") + num2str(((k % R2) * R1 + (k / R2)) * strideO) + string("] = a[") + num2str(k) + string("];\n"); + } } } insertHeader(*kernelString, kernelName, dataFormat); *kernelString += string("{\n"); if ((*kInfo)->lmem_size) - *kernelString += string(" __local float sMem[") + num2str((*kInfo)->lmem_size) + string("];\n"); + { + *kernelString += string(" __local float sMem[") + num2str((*kInfo)->lmem_size) + string("];\n"); + } *kernelString += localString; *kernelString += string("}\n"); @@ -1214,6 +1403,7 @@ createGlobalFFTKernelString(cl_fft_plan *plan, int n, int BS, cl_fft_kernel_dir } } + void FFT1D(cl_fft_plan *plan, cl_fft_kernel_dir dir) { unsigned int radixArray[10]; @@ -1237,21 +1427,29 @@ void FFT1D(cl_fft_plan *plan, cl_fft_kernel_dir dir) { getRadixArray(plan->n.x, radixArray, &numRadix, plan->max_radix); if (plan->n.x / radixArray[0] <= plan->max_work_item_per_workgroup) - createLocalMemfftKernelString(plan); + { + createLocalMemfftKernelString(plan); + } else - createGlobalFFTKernelString(plan, plan->n.x, 1, cl_fft_kernel_x, 1); + { + createGlobalFFTKernelString(plan, plan->n.x, 1, cl_fft_kernel_x, 1); + } } } break; case cl_fft_kernel_y: if (plan->n.y > 1) - createGlobalFFTKernelString(plan, plan->n.y, plan->n.x, cl_fft_kernel_y, 1); + { + createGlobalFFTKernelString(plan, plan->n.y, plan->n.x, cl_fft_kernel_y, 1); + } break; case cl_fft_kernel_z: if (plan->n.z > 1) - createGlobalFFTKernelString(plan, plan->n.z, plan->n.x * plan->n.y, cl_fft_kernel_z, 1); + { + createGlobalFFTKernelString(plan, plan->n.z, plan->n.x * plan->n.y, cl_fft_kernel_z, 1); + } default: return; } diff --git a/src/algorithms/libs/opencl/fft_setup.cc b/src/algorithms/libs/opencl/fft_setup.cc index c1817db22..447faed81 100644 --- a/src/algorithms/libs/opencl/fft_setup.cc +++ b/src/algorithms/libs/opencl/fft_setup.cc @@ -31,9 +31,13 @@ getBlockConfigAndKernelString(cl_fft_plan *plan) *plan->kernel_string += baseKernels; if (plan->format == clFFT_SplitComplexFormat) - *plan->kernel_string += twistKernelPlannar; + { + *plan->kernel_string += twistKernelPlannar; + } else - *plan->kernel_string += twistKernelInterleaved; + { + *plan->kernel_string += twistKernelInterleaved; + } switch (plan->dim) { @@ -72,13 +76,18 @@ deleteKernelInfo(cl_fft_kernel_info *kInfo) if (kInfo) { if (kInfo->kernel_name) - free(kInfo->kernel_name); + { + free(kInfo->kernel_name); + } if (kInfo->kernel) - clReleaseKernel(kInfo->kernel); + { + clReleaseKernel(kInfo->kernel); + } free(kInfo); } } + static void destroy_plan(cl_fft_plan *Plan) { @@ -125,6 +134,7 @@ destroy_plan(cl_fft_plan *Plan) } } + static int createKernelList(cl_fft_plan *plan) { @@ -136,21 +146,30 @@ createKernelList(cl_fft_plan *plan) { kernel_info->kernel = clCreateKernel(program, kernel_info->kernel_name, &err); if (!kernel_info->kernel || err != CL_SUCCESS) - return err; + { + return err; + } kernel_info = kernel_info->next; } if (plan->format == clFFT_SplitComplexFormat) - plan->twist_kernel = clCreateKernel(program, "clFFT_1DTwistSplit", &err); + { + plan->twist_kernel = clCreateKernel(program, "clFFT_1DTwistSplit", &err); + } else - plan->twist_kernel = clCreateKernel(program, "clFFT_1DTwistInterleaved", &err); + { + plan->twist_kernel = clCreateKernel(program, "clFFT_1DTwistInterleaved", &err); + } if (!plan->twist_kernel || err) - return err; + { + return err; + } return CL_SUCCESS; } + int getMaxKernelWorkGroupSize(cl_fft_plan *plan, unsigned int *max_wg_size, unsigned int num_devices, cl_device_id *devices) { int reg_needed = 0; @@ -166,13 +185,19 @@ int getMaxKernelWorkGroupSize(cl_fft_plan *plan, unsigned int *max_wg_size, unsi { err = clGetKernelWorkGroupInfo(kInfo->kernel, devices[i], CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &wg_size, nullptr); if (err != CL_SUCCESS) - return -1; + { + return -1; + } if (wg_size < kInfo->num_workitems_per_workgroup) - reg_needed |= 1; + { + reg_needed |= 1; + } if (*max_wg_size > wg_size) - *max_wg_size = wg_size; + { + *max_wg_size = wg_size; + } kInfo = kInfo->next; } @@ -181,6 +206,7 @@ int getMaxKernelWorkGroupSize(cl_fft_plan *plan, unsigned int *max_wg_size, unsi return reg_needed; } + #define ERR_MACRO(err) \ { \ if ((err) != CL_SUCCESS) \ @@ -192,6 +218,7 @@ int getMaxKernelWorkGroupSize(cl_fft_plan *plan, unsigned int *max_wg_size, unsi } \ } + clFFT_Plan clFFT_CreatePlan(cl_context context, clFFT_Dim3 n, clFFT_Dimension dim, clFFT_DataFormat dataFormat, cl_int *error_code) { @@ -326,11 +353,14 @@ patch_kernel_source: } if (error_code) - *error_code = CL_SUCCESS; + { + *error_code = CL_SUCCESS; + } return (clFFT_Plan)plan; } + void clFFT_DestroyPlan(clFFT_Plan plan) { auto *Plan = (cl_fft_plan *)plan; @@ -342,15 +372,20 @@ void clFFT_DestroyPlan(clFFT_Plan plan) } } + void clFFT_DumpPlan(clFFT_Plan Plan, FILE *file) { size_t gDim; size_t lDim; FILE *out; if (!file) - out = stdout; + { + out = stdout; + } else - out = file; + { + out = file; + } auto *plan = (cl_fft_plan *)Plan; cl_fft_kernel_info *kInfo = plan->kernel_info; diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Toolchains/arm_cortex_a53_hardfp_native.cmake b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Toolchains/arm_cortex_a53_hardfp_native.cmake index a9a5d47f6..cdfce09b4 100644 --- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Toolchains/arm_cortex_a53_hardfp_native.cmake +++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Toolchains/arm_cortex_a53_hardfp_native.cmake @@ -5,7 +5,7 @@ # SPDX-License-Identifier: BSD-3-Clause ######################################################################## -# Toolchain file for building native on a ARM Cortex A72 w/ NEON +# Toolchain file for building native on a ARM Cortex A53 w/ NEON # Usage: cmake -DCMAKE_TOOLCHAIN_FILE= ######################################################################## set(CMAKE_CXX_COMPILER g++) diff --git a/src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.cc b/src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.cc index 0d10cda6a..029f82e5c 100644 --- a/src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.cc +++ b/src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.cc @@ -283,7 +283,7 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con enable_ovf_check_buffer_monitor_active_ = false; // check buffer overflow and buffer monitor disabled by default // some basic checks - if ((rf_port_select_ != "A_BALANCED") and (rf_port_select_ != "B_BALANCED") and (rf_port_select_ != "A_N") and (rf_port_select_ != "B_N") and (rf_port_select_ != "B_P") and (rf_port_select_ != "C_N") and (rf_port_select_ != "C_P") and (rf_port_select_ != "TX_MONITOR1") and (rf_port_select_ != "TX_MONITOR2") and (rf_port_select_ != "TX_MONITOR1_2")) + if ((rf_port_select_ != "A_BALANCED") && (rf_port_select_ != "B_BALANCED") && (rf_port_select_ != "A_N") && (rf_port_select_ != "B_N") && (rf_port_select_ != "B_P") && (rf_port_select_ != "C_N") && (rf_port_select_ != "C_P") && (rf_port_select_ != "TX_MONITOR1") && (rf_port_select_ != "TX_MONITOR2") && (rf_port_select_ != "TX_MONITOR1_2")) { std::cout << "Configuration parameter rf_port_select should take one of these values:\n"; std::cout << " A_BALANCED, B_BALANCED, A_N, B_N, B_P, C_N, C_P, TX_MONITOR1, TX_MONITOR2, TX_MONITOR1_2\n"; @@ -293,7 +293,7 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con LOG(WARNING) << "Invalid configuration value for rf_port_select parameter. Set to rf_port_select=" << default_rf_port_select; } - if ((gain_mode_rx1_ != "manual") and (gain_mode_rx1_ != "slow_attack") and (gain_mode_rx1_ != "fast_attack") and (gain_mode_rx1_ != "hybrid")) + if ((gain_mode_rx1_ != "manual") && (gain_mode_rx1_ != "slow_attack") && (gain_mode_rx1_ != "fast_attack") && (gain_mode_rx1_ != "hybrid")) { std::cout << "Configuration parameter gain_mode_rx1 should take one of these values:\n"; std::cout << " manual, slow_attack, fast_attack, hybrid\n"; @@ -303,7 +303,7 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con LOG(WARNING) << "Invalid configuration value for gain_mode_rx1 parameter. Set to gain_mode_rx1=" << default_gain_mode; } - if ((gain_mode_rx2_ != "manual") and (gain_mode_rx2_ != "slow_attack") and (gain_mode_rx2_ != "fast_attack") and (gain_mode_rx2_ != "hybrid")) + if ((gain_mode_rx2_ != "manual") && (gain_mode_rx2_ != "slow_attack") && (gain_mode_rx2_ != "fast_attack") && (gain_mode_rx2_ != "hybrid")) { std::cout << "Configuration parameter gain_mode_rx2 should take one of these values:\n"; std::cout << " manual, slow_attack, fast_attack, hybrid\n"; @@ -315,7 +315,7 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con if (gain_mode_rx1_ == "manual") { - if (rf_gain_rx1_ > 73.0 or rf_gain_rx1_ < -1.0) + if (rf_gain_rx1_ > 73.0 || rf_gain_rx1_ < -1.0) { std::cout << "Configuration parameter rf_gain_rx1 should take values between -1.0 and 73 dB\n"; std::cout << "Error: provided value rf_gain_rx1=" << rf_gain_rx1_ << " is not among valid values\n"; @@ -327,7 +327,7 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con if (gain_mode_rx2_ == "manual") { - if (rf_gain_rx2_ > 73.0 or rf_gain_rx2_ < -1.0) + if (rf_gain_rx2_ > 73.0 || rf_gain_rx2_ < -1.0) { std::cout << "Configuration parameter rf_gain_rx2 should take values between -1.0 and 73 dB\n"; std::cout << "Error: provided value rf_gain_rx2=" << rf_gain_rx2_ << " is not among valid values\n"; @@ -337,7 +337,7 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con } } - if ((filter_source_ != "Off") and (filter_source_ != "Auto") and (filter_source_ != "File") and (filter_source_ != "Design")) + if ((filter_source_ != "Off") && (filter_source_ != "Auto") && (filter_source_ != "File") && (filter_source_ != "Design")) { std::cout << "Configuration parameter filter_source should take one of these values:\n"; std::cout << " Off: Disable filter\n"; @@ -350,7 +350,7 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con LOG(WARNING) << "Invalid configuration value for filter_source parameter. Set to filter_source=Off"; } - if (bandwidth_ < 200000 or bandwidth_ > 56000000) + if (bandwidth_ < 200000 || bandwidth_ > 56000000) { std::cout << "Configuration parameter bandwidth should take values between 200000 and 56000000 Hz\n"; std::cout << "Error: provided value bandwidth=" << bandwidth_ << " is not among valid values\n"; @@ -389,7 +389,7 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con // LOCAL OSCILLATOR DDS GENERATOR FOR DUAL FREQUENCY OPERATION if (enable_dds_lo_ == true) { - if (tx_bandwidth_ < static_cast(std::floor(static_cast(freq_dds_tx_hz_) * 1.1)) or (tx_bandwidth_ < 200000) or (tx_bandwidth_ > 1000000)) + if (tx_bandwidth_ < static_cast(std::floor(static_cast(freq_dds_tx_hz_) * 1.1)) || (tx_bandwidth_ < 200000) || (tx_bandwidth_ > 1000000)) { std::cout << "Configuration parameter tx_bandwidth value should be between " << std::max(static_cast(freq_dds_tx_hz_) * 1.1, 200000.0) << " and 1000000 Hz\n"; std::cout << "Error: provided value tx_bandwidth=" << tx_bandwidth_ << " is not among valid values\n"; @@ -397,7 +397,7 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con tx_bandwidth_ = 500000; LOG(WARNING) << "Invalid configuration value for tx_bandwidth parameter. Set to tx_bandwidth=500000"; } - if (tx_attenuation_db_ > 0.0 or tx_attenuation_db_ < -89.75) + if (tx_attenuation_db_ > 0.0 || tx_attenuation_db_ < -89.75) { std::cout << "Configuration parameter tx_attenuation_db should take values between 0.0 and -89.95 in 0.25 dB steps\n"; std::cout << "Error: provided value tx_attenuation_db=" << tx_attenuation_db_ << " is not among valid values\n"; @@ -908,11 +908,11 @@ void Ad9361FpgaSignalSource::disconnect(gr::top_block_sptr top_block) gr::basic_block_sptr Ad9361FpgaSignalSource::get_left_block() { LOG(WARNING) << "Trying to get signal source left block."; - return gr::basic_block_sptr(); + return {}; } gr::basic_block_sptr Ad9361FpgaSignalSource::get_right_block() { - return gr::basic_block_sptr(); + return {}; } diff --git a/src/algorithms/signal_source/adapters/file_source_base.cc b/src/algorithms/signal_source/adapters/file_source_base.cc index 1e868a2ae..f499318b1 100644 --- a/src/algorithms/signal_source/adapters/file_source_base.cc +++ b/src/algorithms/signal_source/adapters/file_source_base.cc @@ -65,6 +65,14 @@ FileSourceBase::FileSourceBase(ConfigurationInterface const* configuration, std: { filename_ = FLAGS_s; } + if (sampling_frequency_ == 0) + { + std::cerr << "Warning: parameter " << role << ".sampling_frequency is not set, this could lead to wrong results.\n" + << " Please set the " << role << ".sampling_frequency parameter in your configuration file.\n" + << " If not set, " << role << ".sampling_frequency=" << configuration->property("GNSS-SDR.internal_fs_sps"s, int64_t(0)) + << " will be assumed.\n"; + sampling_frequency_ = configuration->property("GNSS-SDR.internal_fs_sps"s, int64_t(0)); + } } diff --git a/src/algorithms/signal_source/adapters/fmcomms2_signal_source.cc b/src/algorithms/signal_source/adapters/fmcomms2_signal_source.cc index 659108da2..5b97b0bb9 100644 --- a/src/algorithms/signal_source/adapters/fmcomms2_signal_source.cc +++ b/src/algorithms/signal_source/adapters/fmcomms2_signal_source.cc @@ -91,7 +91,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu item_size_ = sizeof(gr_complex); // some basic checks - if ((rf_port_select_ != "A_BALANCED") and (rf_port_select_ != "B_BALANCED") and (rf_port_select_ != "A_N") and (rf_port_select_ != "B_N") and (rf_port_select_ != "B_P") and (rf_port_select_ != "C_N") and (rf_port_select_ != "C_P") and (rf_port_select_ != "TX_MONITOR1") and (rf_port_select_ != "TX_MONITOR2") and (rf_port_select_ != "TX_MONITOR1_2")) + if ((rf_port_select_ != "A_BALANCED") && (rf_port_select_ != "B_BALANCED") && (rf_port_select_ != "A_N") && (rf_port_select_ != "B_N") && (rf_port_select_ != "B_P") && (rf_port_select_ != "C_N") && (rf_port_select_ != "C_P") && (rf_port_select_ != "TX_MONITOR1") && (rf_port_select_ != "TX_MONITOR2") && (rf_port_select_ != "TX_MONITOR1_2")) { std::cout << "Configuration parameter rf_port_select should take one of these values:\n"; std::cout << " A_BALANCED, B_BALANCED, A_N, B_N, B_P, C_N, C_P, TX_MONITOR1, TX_MONITOR2, TX_MONITOR1_2\n"; @@ -101,7 +101,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu LOG(WARNING) << "Invalid configuration value for rf_port_select parameter. Set to rf_port_select=A_BALANCED"; } - if ((gain_mode_rx1_ != "manual") and (gain_mode_rx1_ != "slow_attack") and (gain_mode_rx1_ != "fast_attack") and (gain_mode_rx1_ != "hybrid")) + if ((gain_mode_rx1_ != "manual") && (gain_mode_rx1_ != "slow_attack") && (gain_mode_rx1_ != "fast_attack") && (gain_mode_rx1_ != "hybrid")) { std::cout << "Configuration parameter gain_mode_rx1 should take one of these values:\n"; std::cout << " manual, slow_attack, fast_attack, hybrid\n"; @@ -111,7 +111,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu LOG(WARNING) << "Invalid configuration value for gain_mode_rx1 parameter. Set to gain_mode_rx1=" << default_gain_mode; } - if ((gain_mode_rx2_ != "manual") and (gain_mode_rx2_ != "slow_attack") and (gain_mode_rx2_ != "fast_attack") and (gain_mode_rx2_ != "hybrid")) + if ((gain_mode_rx2_ != "manual") && (gain_mode_rx2_ != "slow_attack") && (gain_mode_rx2_ != "fast_attack") && (gain_mode_rx2_ != "hybrid")) { std::cout << "Configuration parameter gain_mode_rx2 should take one of these values:\n"; std::cout << " manual, slow_attack, fast_attack, hybrid\n"; @@ -121,7 +121,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu LOG(WARNING) << "Invalid configuration value for gain_mode_rx1 parameter. Set to gain_mode_rx2=" << default_gain_mode; } - if ((filter_source_ != "Off") and (filter_source_ != "Auto") and (filter_source_ != "File") and (filter_source_ != "Design")) + if ((filter_source_ != "Off") && (filter_source_ != "Auto") && (filter_source_ != "File") && (filter_source_ != "Design")) { std::cout << "Configuration parameter filter_source should take one of these values:\n"; std::cout << " Off: Disable filter\n"; @@ -138,7 +138,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu if (gain_mode_rx1_ == "manual") { - if (rf_gain_rx1_ > 73.0 or rf_gain_rx1_ < -1.0) + if (rf_gain_rx1_ > 73.0 || rf_gain_rx1_ < -1.0) { std::cout << "Configuration parameter rf_gain_rx1 should take values between -1.0 and 73 dB\n"; std::cout << "Error: provided value rf_gain_rx1=" << rf_gain_rx1_ << " is not among valid values\n"; @@ -150,7 +150,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu if (gain_mode_rx2_ == "manual") { - if (rf_gain_rx2_ > 73.0 or rf_gain_rx2_ < -1.0) + if (rf_gain_rx2_ > 73.0 || rf_gain_rx2_ < -1.0) { std::cout << "Configuration parameter rf_gain_rx2 should take values between -1.0 and 73 dB\n"; std::cout << "Error: provided value rf_gain_rx2=" << rf_gain_rx2_ << " is not among valid values\n"; @@ -160,7 +160,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu } } - if (bandwidth_ < 200000 or bandwidth_ > 56000000) + if (bandwidth_ < 200000 || bandwidth_ > 56000000) { std::cout << "Configuration parameter bandwidth should take values between 200000 and 56000000 Hz\n"; std::cout << "Error: provided value bandwidth=" << bandwidth_ << " is not among valid values\n"; @@ -177,7 +177,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu { if (RF_channels_ == 1) { - if (rx1_en_ and rx2_en_) + if (rx1_en_ && rx2_en_) { LOG(FATAL) << "Configuration error: both rx1 and rx2 are enabled but RF_channels=1 !"; } @@ -220,7 +220,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu // configure LO if (enable_dds_lo_ == true) { - if (tx_bandwidth_ < static_cast(std::floor(static_cast(freq_dds_tx_hz_) * 1.1)) or (tx_bandwidth_ < 200000) or (tx_bandwidth_ > 1000000)) + if (tx_bandwidth_ < static_cast(std::floor(static_cast(freq_dds_tx_hz_) * 1.1)) || (tx_bandwidth_ < 200000) || (tx_bandwidth_ > 1000000)) { std::cout << "Configuration parameter tx_bandwidth value should be between " << std::max(static_cast(freq_dds_tx_hz_) * 1.1, 200000.0) << " and 1000000 Hz\n"; std::cout << "Error: provided value tx_bandwidth=" << tx_bandwidth_ << " is not among valid values\n"; @@ -228,7 +228,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu tx_bandwidth_ = 500000; LOG(WARNING) << "Invalid configuration value for tx_bandwidth parameter. Set to tx_bandwidth=500000"; } - if (tx_attenuation_db_ > 0.0 or tx_attenuation_db_ < -89.75) + if (tx_attenuation_db_ > 0.0 || tx_attenuation_db_ < -89.75) { std::cout << "Configuration parameter tx_attenuation_db should take values between 0.0 and -89.95 in 0.25 dB steps\n"; std::cout << "Error: provided value tx_attenuation_db=" << tx_attenuation_db_ << " is not among valid values\n"; @@ -257,7 +257,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu } else if (RF_channels_ == 2) { - if (!(rx1_en_ and rx2_en_)) + if (!(rx1_en_ && rx2_en_)) { LOG(FATAL) << "Configuration error: RF_channels=2 but are not enabled both receivers in FMCOMMS2 !"; } @@ -294,7 +294,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu // configure LO if (enable_dds_lo_ == true) { - if (tx_bandwidth_ < static_cast(std::floor(static_cast(freq_dds_tx_hz_) * 1.1)) or (tx_bandwidth_ < 200000) or (tx_bandwidth_ > 1000000)) + if (tx_bandwidth_ < static_cast(std::floor(static_cast(freq_dds_tx_hz_) * 1.1)) || (tx_bandwidth_ < 200000) || (tx_bandwidth_ > 1000000)) { std::cout << "Configuration parameter tx_bandwidth value should be between " << std::max(static_cast(freq_dds_tx_hz_) * 1.1, 200000.0) << " and 1000000 Hz\n"; std::cout << "Error: provided value tx_bandwidth=" << tx_bandwidth_ << " is not among valid values\n"; @@ -302,7 +302,7 @@ Fmcomms2SignalSource::Fmcomms2SignalSource(const ConfigurationInterface *configu tx_bandwidth_ = 500000; LOG(WARNING) << "Invalid configuration value for tx_bandwidth parameter. Set to tx_bandwidth=500000"; } - if (tx_attenuation_db_ > 0.0 or tx_attenuation_db_ < -89.75) + if (tx_attenuation_db_ > 0.0 || tx_attenuation_db_ < -89.75) { std::cout << "Configuration parameter tx_attenuation_db should take values between 0.0 and -89.95 in 0.25 dB steps\n"; std::cout << "Error: provided value tx_attenuation_db=" << tx_attenuation_db_ << " is not among valid values\n"; @@ -433,7 +433,7 @@ void Fmcomms2SignalSource::disconnect(gr::top_block_sptr top_block) gr::basic_block_sptr Fmcomms2SignalSource::get_left_block() { LOG(WARNING) << "Trying to get signal source left block."; - return gr::basic_block_sptr(); + return {}; } diff --git a/src/algorithms/signal_source/adapters/limesdr_signal_source.cc b/src/algorithms/signal_source/adapters/limesdr_signal_source.cc index 19dee77e2..1912f4dbb 100644 --- a/src/algorithms/signal_source/adapters/limesdr_signal_source.cc +++ b/src/algorithms/signal_source/adapters/limesdr_signal_source.cc @@ -231,7 +231,7 @@ void LimesdrSignalSource::disconnect(gr::top_block_sptr top_block) gr::basic_block_sptr LimesdrSignalSource::get_left_block() { LOG(WARNING) << "Trying to get signal source left block."; - return gr::basic_block_sptr(); + return {}; } diff --git a/src/algorithms/signal_source/adapters/osmosdr_signal_source.cc b/src/algorithms/signal_source/adapters/osmosdr_signal_source.cc index 8809aa378..8db9bc0ee 100644 --- a/src/algorithms/signal_source/adapters/osmosdr_signal_source.cc +++ b/src/algorithms/signal_source/adapters/osmosdr_signal_source.cc @@ -210,7 +210,7 @@ void OsmosdrSignalSource::disconnect(gr::top_block_sptr top_block) gr::basic_block_sptr OsmosdrSignalSource::get_left_block() { LOG(WARNING) << "Trying to get signal source left block."; - return gr::basic_block_sptr(); + return {}; } diff --git a/src/algorithms/signal_source/adapters/plutosdr_signal_source.cc b/src/algorithms/signal_source/adapters/plutosdr_signal_source.cc index f16b7e901..0343f8154 100644 --- a/src/algorithms/signal_source/adapters/plutosdr_signal_source.cc +++ b/src/algorithms/signal_source/adapters/plutosdr_signal_source.cc @@ -71,7 +71,7 @@ PlutosdrSignalSource::PlutosdrSignalSource(const ConfigurationInterface* configu } // basic check - if ((gain_mode_ != "manual") and (gain_mode_ != "slow_attack") and (gain_mode_ != "fast_attack") and (gain_mode_ != "hybrid")) + if ((gain_mode_ != "manual") && (gain_mode_ != "slow_attack") && (gain_mode_ != "fast_attack") && (gain_mode_ != "hybrid")) { std::cout << "Configuration parameter gain_mode should take one of these values:\n"; std::cout << " manual, slow_attack, fast_attack, hybrid\n"; @@ -83,7 +83,7 @@ PlutosdrSignalSource::PlutosdrSignalSource(const ConfigurationInterface* configu if (gain_mode_ == "manual") { - if (rf_gain_ > 73.0 or rf_gain_ < -1.0) + if (rf_gain_ > 73.0 || rf_gain_ < -1.0) { std::cout << "Configuration parameter rf_gain should take values between -1.0 and 73 dB\n"; std::cout << "Error: provided value rf_gain=" << rf_gain_ << " is not among valid values\n"; @@ -93,7 +93,7 @@ PlutosdrSignalSource::PlutosdrSignalSource(const ConfigurationInterface* configu } } - if ((filter_source_ != "Off") and (filter_source_ != "Auto") and (filter_source_ != "File") and (filter_source_ != "Design")) + if ((filter_source_ != "Off") && (filter_source_ != "Auto") && (filter_source_ != "File") && (filter_source_ != "Design")) { std::cout << "Configuration parameter filter_source should take one of these values:\n"; std::cout << " Off: Disable filter\n"; @@ -108,7 +108,7 @@ PlutosdrSignalSource::PlutosdrSignalSource(const ConfigurationInterface* configu LOG(WARNING) << "Invalid configuration value for filter_source parameter. Set to filter_source=Off"; } - if (bandwidth_ < 200000 or bandwidth_ > 56000000) + if (bandwidth_ < 200000 || bandwidth_ > 56000000) { std::cout << "Configuration parameter bandwidth should take values between 200000 and 56000000 Hz\n"; std::cout << "Error: provided value bandwidth=" << bandwidth_ << " is not among valid values\n"; @@ -216,7 +216,7 @@ void PlutosdrSignalSource::disconnect(gr::top_block_sptr top_block) gr::basic_block_sptr PlutosdrSignalSource::get_left_block() { LOG(WARNING) << "Trying to get signal source left block."; - return gr::basic_block_sptr(); + return {}; } diff --git a/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc b/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc index dd205050a..f0fce6afd 100644 --- a/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc +++ b/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc @@ -84,6 +84,7 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_) d_trk_parameters(conf_), d_acquisition_gnss_synchro(nullptr), d_signal_type(d_trk_parameters.signal), + d_code_chip_rate(0.0), d_acq_code_phase_samples(0.0), d_acq_carrier_doppler_hz(0.0), d_current_correlation_time_s(0.0), diff --git a/src/core/receiver/control_thread.cc b/src/core/receiver/control_thread.cc index 5b0448799..c262e6a68 100644 --- a/src/core/receiver/control_thread.cc +++ b/src/core/receiver/control_thread.cc @@ -1207,6 +1207,7 @@ void ControlThread::keyboard_listener() { std::cout << "Quit keystroke order received, stopping GNSS-SDR !!\n"; control_queue_->push(pmt::make_any(command_event_make(200, 0))); + stop_ = true; read_keys = false; } else diff --git a/src/core/receiver/gnss_flowgraph.cc b/src/core/receiver/gnss_flowgraph.cc index 17292c3f4..530a30bb1 100644 --- a/src/core/receiver/gnss_flowgraph.cc +++ b/src/core/receiver/gnss_flowgraph.cc @@ -380,28 +380,14 @@ void GNSSFlowgraph::disconnect() return; } connected_ = false; - -#if ENABLE_FPGA - if (enable_fpga_offloading_ == true) + try { - if (disconnect_fpga_flowgraph() != 0) - { - return; - } + top_block_->disconnect_all(); } - else + catch (const std::exception& e) { - if (disconnect_desktop_flowgraph() != 0) - { - return; - } + LOG(INFO) << "Problem disconnecting the flowgraph: " << e.what(); } -#else - if (disconnect_desktop_flowgraph() != 0) - { - return; - } -#endif LOG(INFO) << "Flowgraph disconnected"; } @@ -410,6 +396,15 @@ void GNSSFlowgraph::disconnect() int GNSSFlowgraph::connect_desktop_flowgraph() { // Connect blocks to the top_block + const int max_channels_in_acq = configuration_->property("Channels.in_acquisition", 0); + if (max_channels_in_acq > channels_count_) + { + help_hint_ += " * The maximum number of channels with concurrent signal acquisition is set to Channels.in_acquisition=" + std::to_string(max_channels_in_acq) + ",\n"; + help_hint_ += " but the total number of channels is set to " + std::to_string(channels_count_) + ".\n"; + help_hint_ += " Please set Channels.in_acquisition to " + std::to_string(channels_count_) + " or lower, or increment the number of channels in your configuration file.\n"; + return 1; + } + if (connect_signal_sources() != 0) { return 1; @@ -458,7 +453,10 @@ int GNSSFlowgraph::connect_desktop_flowgraph() check_signal_conditioners(); - assign_channels(); + if (assign_channels() != 0) + { + return 1; + } if (connect_observables_to_pvt() != 0) { @@ -497,72 +495,18 @@ int GNSSFlowgraph::connect_desktop_flowgraph() } -int GNSSFlowgraph::disconnect_desktop_flowgraph() -{ - // Disconnect blocks between them - if (disconnect_signal_sources_from_signal_conditioners() != 0) - { - return 1; - } - - if (disconnect_sample_counter() != 0) - { - return 1; - } - - if (disconnect_signal_conditioners_from_channels() != 0) - { - return 1; - } - - if (disconnect_channels_from_observables() != 0) - { - return 1; - } - - if (disconnect_monitors() != 0) - { - return 1; - } - - if (disconnect_observables_from_pvt() != 0) - { - return 1; - } - - // Disconnect blocks from the top_block - if (disconnect_signal_sources() != 0) - { - return 1; - } - - if (disconnect_signal_conditioners() != 0) - { - return 1; - } - - if (disconnect_channels() != 0) - { - return 1; - } - - if (disconnect_observables() != 0) - { - return 1; - } - - if (disconnect_pvt() != 0) - { - return 1; - } - - return 0; -} - - #if ENABLE_FPGA int GNSSFlowgraph::connect_fpga_flowgraph() { + const int max_channels_in_acq = configuration_->property("Channels.in_acquisition", 0); + if (max_channels_in_acq != 1) + { + help_hint_ += " * The maximum number of channels with concurrent signal acquisition is set to Channels.in_acquisition=" + std::to_string(max_channels_in_acq) + ",\n"; + help_hint_ += " but it must be set to 1 in the FPGA flow graph.\n"; + help_hint_ += " Please set Channels.in_acquisition=1 in your configuration file.\n"; + return 1; + } + // Check that the Signal Source has been instantiated successfully for (auto& src : sig_source_) { @@ -610,7 +554,10 @@ int GNSSFlowgraph::connect_fpga_flowgraph() return 1; } - assign_channels(); + if (assign_channels() != 0) + { + return 1; + } if (connect_observables_to_pvt() != 0) { @@ -627,47 +574,6 @@ int GNSSFlowgraph::connect_fpga_flowgraph() LOG(INFO) << "The GNU Radio flowgraph for the current GNSS-SDR configuration with FPGA off-loading has been successfully connected"; return 0; } - - -int GNSSFlowgraph::disconnect_fpga_flowgraph() -{ - if (disconnect_fpga_sample_counter() != 0) - { - return 1; - } - - if (disconnect_monitors() != 0) - { - return 1; - } - - if (disconnect_channels_from_observables() != 0) - { - return 1; - } - - if (disconnect_observables_from_pvt() != 0) - { - return 1; - } - - if (disconnect_channels() != 0) - { - return 1; - } - - if (disconnect_observables() != 0) - { - return 1; - } - - if (disconnect_pvt() != 0) - { - return 1; - } - - return 0; -} #endif @@ -701,25 +607,6 @@ int GNSSFlowgraph::connect_signal_sources() } -int GNSSFlowgraph::disconnect_signal_sources() -{ - for (int i = 0; i < sources_count_; i++) - { - try - { - sig_source_.at(i)->disconnect(top_block_); - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect signal source block " << i << " internally: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - } - return 0; -} - - int GNSSFlowgraph::connect_signal_conditioners() { int error = 1; // this should be bool (true) @@ -791,25 +678,6 @@ int GNSSFlowgraph::connect_signal_conditioners() } -int GNSSFlowgraph::disconnect_signal_conditioners() -{ - for (auto& sig : sig_conditioner_) - { - try - { - sig->disconnect(top_block_); - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect signal conditioner block internally: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - } - return 0; -} - - int GNSSFlowgraph::connect_channels() { if (channels_count_ <= 0) @@ -852,25 +720,6 @@ int GNSSFlowgraph::connect_channels() } -int GNSSFlowgraph::disconnect_channels() -{ - for (int i = 0; i < channels_count_; i++) - { - try - { - channels_.at(i)->disconnect(top_block_); - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect channel " << i << " internally: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - } - return 0; -} - - int GNSSFlowgraph::connect_observables() { if (observables_ == nullptr) @@ -895,22 +744,6 @@ int GNSSFlowgraph::connect_observables() } -int GNSSFlowgraph::disconnect_observables() -{ - try - { - observables_->disconnect(top_block_); - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect observables block internally: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - return 0; -} - - int GNSSFlowgraph::connect_pvt() { if (pvt_ == nullptr) @@ -935,22 +768,6 @@ int GNSSFlowgraph::connect_pvt() } -int GNSSFlowgraph::disconnect_pvt() -{ - try - { - pvt_->disconnect(top_block_); - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect PVT block internally: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - return 0; -} - - int GNSSFlowgraph::connect_sample_counter() { // connect the sample counter to the Signal Conditioner @@ -981,23 +798,6 @@ int GNSSFlowgraph::connect_sample_counter() } -int GNSSFlowgraph::disconnect_sample_counter() -{ - try - { - top_block_->disconnect(sig_conditioner_.at(0)->get_right_block(), 0, ch_out_sample_counter_, 0); - top_block_->disconnect(ch_out_sample_counter_, 0, observables_->get_left_block(), channels_count_); // extra port for the sample counter pulse - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect sample counter: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - return 0; -} - - #if ENABLE_FPGA int GNSSFlowgraph::connect_fpga_sample_counter() { @@ -1033,22 +833,6 @@ int GNSSFlowgraph::connect_fpga_sample_counter() LOG(INFO) << "FPGA sample counter successfully connected"; return 0; } - - -int GNSSFlowgraph::disconnect_fpga_sample_counter() -{ - try - { - top_block_->disconnect(ch_out_fpga_sample_counter_, 0, observables_->get_left_block(), channels_count_); - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect FPGA sample counter: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - return 0; -} #endif @@ -1156,63 +940,6 @@ int GNSSFlowgraph::connect_signal_sources_to_signal_conditioners() } -int GNSSFlowgraph::disconnect_signal_sources_from_signal_conditioners() -{ - int signal_conditioner_ID = 0; - for (int i = 0; i < sources_count_; i++) - { - try - { - auto& src = sig_source_.at(i); - - // TODO: Remove this array implementation and create generic multistream connector - // (if a signal source has more than 1 stream, then connect it to the multistream signal conditioner) - if (src->implementation() == "Raw_Array_Signal_Source") - { - // Multichannel Array - for (int j = 0; j < GNSS_SDR_ARRAY_SIGNAL_CONDITIONER_CHANNELS; j++) - { - top_block_->disconnect(src->get_right_block(), j, sig_conditioner_.at(i)->get_left_block(), j); - } - } - else - { - auto RF_Channels = src->getRfChannels(); - - for (auto j = 0U; j < RF_Channels; ++j) - { - if (src->get_right_block()->output_signature()->max_streams() > 1 or src->get_right_block()->output_signature()->max_streams() == -1) - { - top_block_->disconnect(src->get_right_block(), j, sig_conditioner_.at(signal_conditioner_ID)->get_left_block(), 0); - } - else - { - if (j == 0) - { - // RF_channel 0 backward compatibility with single channel sources - top_block_->disconnect(src->get_right_block(), 0, sig_conditioner_.at(signal_conditioner_ID)->get_left_block(), 0); - } - else - { - // Multiple channel sources using multiple output blocks of single channel (requires RF_channel selector in call) - top_block_->disconnect(src->get_right_block(j), 0, sig_conditioner_.at(signal_conditioner_ID)->get_left_block(), 0); - } - } - signal_conditioner_ID++; - } - } - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect signal source " << i << " to signal conditioner " << i << ": " << e.what(); - top_block_->disconnect_all(); - return 1; - } - } - return 0; -} - - int GNSSFlowgraph::connect_signal_conditioners_to_channels() { for (int i = 0; i < channels_count_; i++) @@ -1356,38 +1083,6 @@ int GNSSFlowgraph::connect_signal_conditioners_to_channels() } -int GNSSFlowgraph::disconnect_signal_conditioners_from_channels() -{ - for (int i = 0; i < channels_count_; i++) - { - int selected_signal_conditioner_ID; - try - { - selected_signal_conditioner_ID = configuration_->property("Channel" + std::to_string(i) + ".RF_channel_ID", 0); - } - catch (const std::exception& e) - { - LOG(WARNING) << e.what(); - top_block_->disconnect_all(); - return 1; - } - try - { - top_block_->disconnect(sig_conditioner_.at(selected_signal_conditioner_ID)->get_right_block(), 0, - channels_.at(i)->get_left_block_trk(), 0); - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect signal conditioner " << selected_signal_conditioner_ID << " to channel " << i << ": " << e.what(); - top_block_->disconnect_all(); - return 1; - } - } - DLOG(INFO) << "Signal conditioner(s) successfully disconnected from channels"; - return 0; -} - - int GNSSFlowgraph::connect_channels_to_observables() { for (int i = 0; i < channels_count_; i++) @@ -1409,26 +1104,6 @@ int GNSSFlowgraph::connect_channels_to_observables() } -int GNSSFlowgraph::disconnect_channels_from_observables() -{ - for (int i = 0; i < channels_count_; i++) - { - try - { - top_block_->disconnect(channels_.at(i)->get_right_block(), 0, - observables_->get_left_block(), i); - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect channel " << i << " to observables: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - } - return 0; -} - - int GNSSFlowgraph::connect_observables_to_pvt() { // Connect the observables output of each channel to the PVT block @@ -1468,30 +1143,6 @@ int GNSSFlowgraph::connect_observables_to_pvt() } -int GNSSFlowgraph::disconnect_observables_from_pvt() -{ - try - { - for (int i = 0; i < channels_count_; i++) - { - top_block_->disconnect(observables_->get_right_block(), i, pvt_->get_left_block(), i); - top_block_->msg_disconnect(channels_.at(i)->get_right_block(), pmt::mp("telemetry"), pvt_->get_left_block(), pmt::mp("telemetry")); - } - top_block_->msg_disconnect(observables_->get_right_block(), pmt::mp("status"), channels_status_, pmt::mp("status")); - - top_block_->msg_disconnect(pvt_->get_left_block(), pmt::mp("pvt_to_observables"), observables_->get_right_block(), pmt::mp("pvt_to_observables")); - top_block_->msg_disconnect(pvt_->get_left_block(), pmt::mp("status"), channels_status_, pmt::mp("status")); - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect observables to PVT: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - return 0; -} - - int GNSSFlowgraph::connect_gnss_synchro_monitor() { try @@ -1654,44 +1305,6 @@ int GNSSFlowgraph::connect_gal_e6_has() } -int GNSSFlowgraph::disconnect_monitors() -{ - try - { - for (int i = 0; i < channels_count_; i++) - { - if (enable_monitor_) - { - top_block_->disconnect(observables_->get_right_block(), i, GnssSynchroMonitor_, i); - } - if (enable_acquisition_monitor_) - { - top_block_->disconnect(channels_.at(i)->get_right_block_acq(), 0, GnssSynchroAcquisitionMonitor_, i); - } - if (enable_tracking_monitor_) - { - top_block_->disconnect(channels_.at(i)->get_right_block_trk(), 0, GnssSynchroTrackingMonitor_, i); - } - if (enable_navdata_monitor_) - { - top_block_->msg_disconnect(channels_.at(i)->get_right_block(), pmt::mp("Nav_msg_from_TLM"), NavDataMonitor_, pmt::mp("Nav_msg_from_TLM")); - if (enable_e6_has_rx_) - { - top_block_->msg_disconnect(gal_e6_has_rx_, pmt::mp("Nav_msg_from_TLM"), NavDataMonitor_, pmt::mp("Nav_msg_from_TLM")); - } - } - } - } - catch (const std::exception& e) - { - LOG(INFO) << "Can't disconnect monitors: " << e.what(); - top_block_->disconnect_all(); - return 1; - } - return 0; -} - - void GNSSFlowgraph::check_signal_conditioners() { // check for unconnected signal conditioners and connect null_sinks @@ -1709,7 +1322,7 @@ void GNSSFlowgraph::check_signal_conditioners() } -void GNSSFlowgraph::assign_channels() +int GNSSFlowgraph::assign_channels() { // Put channels fixed to a given satellite at the beginning of the vector, then the rest std::vector vector_of_channels; @@ -1735,10 +1348,99 @@ void GNSSFlowgraph::assign_channels() } } + if (configuration_->property("Channels_1C.count", uint64_t(0ULL)) > available_GPS_1C_signals_.size() - 1) + { + help_hint_ += " * The number of GPS L1 channels is set to Channels_1C.count=" + std::to_string(configuration_->property("Channels_1C.count", 0)); + help_hint_ += " but the maximum number of available GPS satellites is " + std::to_string(available_GPS_1C_signals_.size()) + ".\n"; + help_hint_ += " Please set Channels_1C.count=" + std::to_string(available_GPS_1C_signals_.size() - 1) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_2S.count", uint64_t(0ULL)) > available_GPS_2S_signals_.size() - 1) + { + help_hint_ += " * The number of GPS L2 channels is set to Channels_2S.count=" + std::to_string(configuration_->property("Channels_2S.count", 0)); + help_hint_ += " but the maximum number of available GPS satellites is " + std::to_string(available_GPS_2S_signals_.size()) + ".\n"; + help_hint_ += " Please set Channels_2S.count=" + std::to_string(available_GPS_2S_signals_.size() - 1) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_L5.count", uint64_t(0ULL)) > available_GPS_L5_signals_.size() - 1) + { + help_hint_ += " * The number of GPS L5 channels is set to Channels_L5.count=" + std::to_string(configuration_->property("Channels_L5.count", 0)); + help_hint_ += " but the maximum number of available GPS satellites is " + std::to_string(available_GPS_L5_signals_.size()) + ".\n"; + help_hint_ += " Please set Channels_L5.count=" + std::to_string(available_GPS_L5_signals_.size() - 1) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_1B.count", uint64_t(0ULL)) > available_GAL_1B_signals_.size() - 1) + { + help_hint_ += " * The number of Galileo E1 channels is set to Channels_1B.count=" + std::to_string(configuration_->property("Channels_1B.count", 0)); + help_hint_ += " but the maximum number of available Galileo satellites is " + std::to_string(available_GAL_1B_signals_.size()) + ".\n"; + help_hint_ += " Please set Channels_1B.count=" + std::to_string(available_GAL_1B_signals_.size()) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_5X.count", uint64_t(0ULL)) > available_GAL_5X_signals_.size() - 1) + { + help_hint_ += " * The number of Galileo E5a channels is set to Channels_5X.count=" + std::to_string(configuration_->property("Channels_5X.count", 0)); + help_hint_ += " but the maximum number of available Galileo satellites is " + std::to_string(available_GAL_5X_signals_.size()) + ".\n"; + help_hint_ += " Please set Channels_5X.count=" + std::to_string(available_GAL_5X_signals_.size() - 1) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_7X.count", uint64_t(0ULL)) > available_GAL_7X_signals_.size() - 1) + { + help_hint_ += " * The number of Galileo E5b channels is set to Channels_7X.count=" + std::to_string(configuration_->property("Channels_7X.count", 0)); + help_hint_ += " but the maximum number of available Galileo satellites is " + std::to_string(available_GAL_7X_signals_.size()) + ".\n"; + help_hint_ += " Please set Channels_7X.count=" + std::to_string(available_GAL_7X_signals_.size() - 1) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_E6.count", uint64_t(0ULL)) > available_GAL_E6_signals_.size() - 1) + { + help_hint_ += " * The number of Galileo E6 channels is set to Channels_7X.count=" + std::to_string(configuration_->property("Channels_E6.count", 0)); + help_hint_ += " but the maximum number of available Galileo satellites is " + std::to_string(available_GAL_E6_signals_.size()) + ".\n"; + help_hint_ += " Please set Channels_E6.count=" + std::to_string(available_GAL_E6_signals_.size() - 1) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_1G.count", uint64_t(0ULL)) > available_GLO_1G_signals_.size() + 7) // satellites sharing same frequency number + { + help_hint_ += " * The number of Glonass L1 channels is set to Channels_1G.count=" + std::to_string(configuration_->property("Channels_1G.count", 0)); + help_hint_ += " but the maximum number of available Glonass satellites is " + std::to_string(available_GLO_1G_signals_.size() + 8) + ".\n"; + help_hint_ += " Please set Channels_1G.count=" + std::to_string(available_GLO_1G_signals_.size() + 7) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_2G.count", uint64_t(0ULL)) > available_GLO_2G_signals_.size() + 7) // satellites sharing same frequency number + { + help_hint_ += " * The number of Glonass L2 channels is set to Channels_2G.count=" + std::to_string(configuration_->property("Channels_2G.count", 0)); + help_hint_ += " but the maximum number of available Glonass satellites is " + std::to_string(available_GLO_2G_signals_.size() + 8) + ".\n"; + help_hint_ += " Please set Channels_2G.count=" + std::to_string(available_GLO_2G_signals_.size() + 7) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_B1.count", uint64_t(0ULL)) > available_BDS_B1_signals_.size() - 1) + { + help_hint_ += " * The number of BeiDou B1 channels is set to Channels_B1.count=" + std::to_string(configuration_->property("Channels_B1.count", 0)); + help_hint_ += " but the maximum number of available BeiDou satellites is " + std::to_string(available_BDS_B1_signals_.size()) + ".\n"; + help_hint_ += " Please set Channels_B1.count=" + std::to_string(available_BDS_B1_signals_.size() - 1) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + if (configuration_->property("Channels_B3.count", uint64_t(0ULL)) > available_BDS_B3_signals_.size() - 1) + { + help_hint_ += " * The number of BeiDou B3 channels is set to Channels_B3.count=" + std::to_string(configuration_->property("Channels_B3.count", 0)); + help_hint_ += " but the maximum number of available BeiDou satellites is " + std::to_string(available_BDS_B3_signals_.size()) + ".\n"; + help_hint_ += " Please set Channels_B3.count=" + std::to_string(available_BDS_B3_signals_.size() - 1) + " or lower in your configuration file.\n"; + top_block_->disconnect_all(); + return 1; + } + // Assign satellites to channels in the initialization for (unsigned int& i : vector_of_channels) { - const std::string gnss_signal = channels_.at(i)->get_signal().get_signal_str(); // use channel's implicit signal + const std::string gnss_signal_str = channels_.at(i)->get_signal().get_signal_str(); // use channel's implicit signal unsigned int sat = 0; try { @@ -1754,91 +1456,92 @@ void GNSSFlowgraph::assign_channels() float estimated_doppler; double RX_time; bool is_primary_freq; - channels_.at(i)->set_signal(search_next_signal(gnss_signal, false, is_primary_freq, assistance_available, estimated_doppler, RX_time)); + channels_.at(i)->set_signal(search_next_signal(gnss_signal_str, is_primary_freq, assistance_available, estimated_doppler, RX_time)); } else { - std::string gnss_system; - Gnss_Signal signal_value; - switch (mapStringValues_[gnss_signal]) + std::string gnss_system_str; + Gnss_Signal gnss_signal; + switch (mapStringValues_[gnss_signal_str]) { case evGPS_1C: - gnss_system = "GPS"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GPS_1C_signals_.remove(signal_value); + gnss_system_str = "GPS"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GPS_1C_signals_.remove(gnss_signal); break; case evGPS_2S: - gnss_system = "GPS"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GPS_2S_signals_.remove(signal_value); + gnss_system_str = "GPS"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GPS_2S_signals_.remove(gnss_signal); break; case evGPS_L5: - gnss_system = "GPS"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GPS_L5_signals_.remove(signal_value); + gnss_system_str = "GPS"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GPS_L5_signals_.remove(gnss_signal); break; case evGAL_1B: - gnss_system = "Galileo"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GAL_1B_signals_.remove(signal_value); + gnss_system_str = "Galileo"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GAL_1B_signals_.remove(gnss_signal); break; case evGAL_5X: - gnss_system = "Galileo"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GAL_5X_signals_.remove(signal_value); + gnss_system_str = "Galileo"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GAL_5X_signals_.remove(gnss_signal); break; case evGAL_7X: - gnss_system = "Galileo"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GAL_7X_signals_.remove(signal_value); + gnss_system_str = "Galileo"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GAL_7X_signals_.remove(gnss_signal); break; case evGAL_E6: - gnss_system = "Galileo"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GAL_E6_signals_.remove(signal_value); + gnss_system_str = "Galileo"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GAL_E6_signals_.remove(gnss_signal); break; case evGLO_1G: - gnss_system = "Glonass"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GLO_1G_signals_.remove(signal_value); + gnss_system_str = "Glonass"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GLO_1G_signals_.remove(gnss_signal); break; case evGLO_2G: - gnss_system = "Glonass"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GLO_2G_signals_.remove(signal_value); + gnss_system_str = "Glonass"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GLO_2G_signals_.remove(gnss_signal); break; case evBDS_B1: - gnss_system = "Beidou"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_BDS_B1_signals_.remove(signal_value); + gnss_system_str = "Beidou"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_BDS_B1_signals_.remove(gnss_signal); break; case evBDS_B3: - gnss_system = "Beidou"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_BDS_B3_signals_.remove(signal_value); + gnss_system_str = "Beidou"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_BDS_B3_signals_.remove(gnss_signal); break; default: LOG(ERROR) << "This should not happen :-("; - gnss_system = "GPS"; - signal_value = Gnss_Signal(Gnss_Satellite(gnss_system, sat), gnss_signal); - available_GPS_1C_signals_.remove(signal_value); + gnss_system_str = "GPS"; + gnss_signal = Gnss_Signal(Gnss_Satellite(gnss_system_str, sat), gnss_signal_str); + available_GPS_1C_signals_.remove(gnss_signal); break; } - channels_.at(i)->set_signal(signal_value); + channels_.at(i)->set_signal(gnss_signal); } } + return 0; } @@ -2052,7 +1755,6 @@ void GNSSFlowgraph::acquisition_manager(unsigned int who) if (sat_ == 0) { gnss_signal = search_next_signal(channels_[current_channel]->get_signal().get_signal_str(), - true, is_primary_freq, assistance_available, estimated_doppler, @@ -2816,7 +2518,6 @@ bool GNSSFlowgraph::is_multiband() const Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal, - const bool pop, bool& is_primary_frequency, bool& assistance_available, float& estimated_doppler, @@ -2824,18 +2525,15 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal { is_primary_frequency = false; assistance_available = false; - Gnss_Signal result; + Gnss_Signal result{}; bool found_signal = false; switch (mapStringValues_[searched_signal]) { case evGPS_1C: - // todo: assist the satellite selection with almanac and current PVT here (rehuse priorize_satellite function used in control_thread) + // todo: assist the satellite selection with almanac and current PVT here (reuse priorize_satellite function used in control_thread) result = available_GPS_1C_signals_.front(); available_GPS_1C_signals_.pop_front(); - if (!pop) - { - available_GPS_1C_signals_.push_back(result); - } + available_GPS_1C_signals_.push_back(result); is_primary_frequency = true; // indicate that the searched satellite signal belongs to "primary" link (L1, E1, B1, etc..) break; @@ -2859,35 +2557,20 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal RX_time = current_status.second->RX_time; // 3. return the GPS L2 satellite and remove it from list result = *it2; - if (pop) - { - available_GPS_2S_signals_.erase(it2); - } + available_GPS_2S_signals_.erase(it2); found_signal = true; assistance_available = true; break; } } } - // fallback: pick the front satellite because there is no tracked satellites in L1 to assist L2 - if (found_signal == false) - { - result = available_GPS_2S_signals_.front(); - available_GPS_2S_signals_.pop_front(); - if (!pop) - { - available_GPS_2S_signals_.push_back(result); - } - } } - else + // fallback: pick the front satellite because there is no tracked satellites in L1 to assist L2 + if (found_signal == false) { result = available_GPS_2S_signals_.front(); available_GPS_2S_signals_.pop_front(); - if (!pop) - { - available_GPS_2S_signals_.push_back(result); - } + available_GPS_2S_signals_.push_back(result); } break; @@ -2912,10 +2595,7 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal // std::cout << " Channel: " << it->first << " => Doppler: " << estimated_doppler << "[Hz] \n"; // 3. return the GPS L5 satellite and remove it from list result = *it2; - if (pop) - { - available_GPS_L5_signals_.erase(it2); - } + available_GPS_L5_signals_.erase(it2); found_signal = true; assistance_available = true; break; @@ -2928,20 +2608,14 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal { result = available_GPS_L5_signals_.front(); available_GPS_L5_signals_.pop_front(); - if (!pop) - { - available_GPS_L5_signals_.push_back(result); - } + available_GPS_L5_signals_.push_back(result); } break; case evGAL_1B: result = available_GAL_1B_signals_.front(); available_GAL_1B_signals_.pop_front(); - if (!pop) - { - available_GAL_1B_signals_.push_back(result); - } + available_GAL_1B_signals_.push_back(result); is_primary_frequency = true; // indicate that the searched satellite signal belongs to "primary" link (L1, E1, B1, etc..) break; @@ -2966,10 +2640,7 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal // std::cout << " Channel: " << it->first << " => Doppler: " << estimated_doppler << "[Hz] \n"; // 3. return the Gal 5X satellite and remove it from list result = *it2; - if (pop) - { - available_GAL_5X_signals_.erase(it2); - } + available_GAL_5X_signals_.erase(it2); found_signal = true; assistance_available = true; break; @@ -2982,10 +2653,7 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal { result = available_GAL_5X_signals_.front(); available_GAL_5X_signals_.pop_front(); - if (!pop) - { - available_GAL_5X_signals_.push_back(result); - } + available_GAL_5X_signals_.push_back(result); } break; @@ -3010,10 +2678,7 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal // std::cout << " Channel: " << it->first << " => Doppler: " << estimated_doppler << "[Hz] \n"; // 3. return the Gal 7X satellite and remove it from list result = *it2; - if (pop) - { - available_GAL_7X_signals_.erase(it2); - } + available_GAL_7X_signals_.erase(it2); found_signal = true; assistance_available = true; break; @@ -3026,10 +2691,7 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal { result = available_GAL_7X_signals_.front(); available_GAL_7X_signals_.pop_front(); - if (!pop) - { - available_GAL_7X_signals_.push_back(result); - } + available_GAL_7X_signals_.push_back(result); } break; @@ -3054,10 +2716,7 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal // std::cout << " Channel: " << it->first << " => Doppler: " << estimated_doppler << "[Hz] \n"; // 3. return the Gal E6 satellite and remove it from list result = *it2; - if (pop) - { - available_GAL_E6_signals_.erase(it2); - } + available_GAL_E6_signals_.erase(it2); found_signal = true; assistance_available = true; break; @@ -3070,57 +2729,43 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal { result = available_GAL_E6_signals_.front(); available_GAL_E6_signals_.pop_front(); - if (!pop) - { - available_GAL_E6_signals_.push_back(result); - } + available_GAL_E6_signals_.push_back(result); } break; case evGLO_1G: result = available_GLO_1G_signals_.front(); available_GLO_1G_signals_.pop_front(); - if (!pop) - { - available_GLO_1G_signals_.push_back(result); - } + available_GLO_1G_signals_.push_back(result); is_primary_frequency = true; // indicate that the searched satellite signal belongs to "primary" link (L1, E1, B1, etc..) break; case evGLO_2G: result = available_GLO_2G_signals_.front(); available_GLO_2G_signals_.pop_front(); - if (!pop) - { - available_GLO_2G_signals_.push_back(result); - } + available_GLO_2G_signals_.push_back(result); break; case evBDS_B1: result = available_BDS_B1_signals_.front(); available_BDS_B1_signals_.pop_front(); - if (!pop) - { - available_BDS_B1_signals_.push_back(result); - } + available_BDS_B1_signals_.push_back(result); is_primary_frequency = true; // indicate that the searched satellite signal belongs to "primary" link (L1, E1, B1, etc..) break; case evBDS_B3: result = available_BDS_B3_signals_.front(); available_BDS_B3_signals_.pop_front(); - if (!pop) - { - available_BDS_B3_signals_.push_back(result); - } + available_BDS_B3_signals_.push_back(result); break; default: LOG(ERROR) << "This should not happen :-("; - result = available_GPS_1C_signals_.front(); - if (pop) + if (!available_GPS_1C_signals_.empty()) { + result = available_GPS_1C_signals_.front(); available_GPS_1C_signals_.pop_front(); + available_GPS_1C_signals_.push_back(result); } break; } diff --git a/src/core/receiver/gnss_flowgraph.h b/src/core/receiver/gnss_flowgraph.h index 349db0878..b4bdbeeb9 100644 --- a/src/core/receiver/gnss_flowgraph.h +++ b/src/core/receiver/gnss_flowgraph.h @@ -183,36 +183,18 @@ private: int connect_tracking_monitor(); int connect_navdata_monitor(); - int disconnect_desktop_flowgraph(); - - int disconnect_signal_sources(); - int disconnect_signal_conditioners(); - int disconnect_channels(); - int disconnect_observables(); - int disconnect_pvt(); - int disconnect_sample_counter(); - - int disconnect_signal_sources_from_signal_conditioners(); - int disconnect_signal_conditioners_from_channels(); - int disconnect_channels_from_observables(); - int disconnect_observables_from_pvt(); - int disconnect_monitors(); - #if ENABLE_FPGA int connect_fpga_flowgraph(); - int disconnect_fpga_flowgraph(); int connect_fpga_sample_counter(); - int disconnect_fpga_sample_counter(); #endif - void assign_channels(); + int assign_channels(); void check_signal_conditioners(); void set_signals_list(); void set_channels_state(); // Initializes the channels state (start acquisition or keep standby) // using the configuration parameters (number of channels and max channels in acquisition) Gnss_Signal search_next_signal(const std::string& searched_signal, - const bool pop, bool& is_primary_frequency, bool& assistance_available, float& estimated_doppler, diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt index daa001b67..0902fb510 100644 --- a/src/tests/CMakeLists.txt +++ b/src/tests/CMakeLists.txt @@ -30,7 +30,7 @@ if(NOT GOOGLETEST_FOUND) "--build" "${CMAKE_BINARY_DIR}/gtest-${GNSSSDR_GTEST_LOCAL_VERSION}" "--config" $<$:Debug>$<$:Release>$<$:RelWithDebInfo>$<$:MinSizeRel>$<$:Debug>$<$:Debug>$<$:RelWithDebInfo>$<$:RelWithDebInfo>$<$:Debug> ) - if(CMAKE_VERSION VERSION_GREATER 3.12) + if(CMAKE_VERSION VERSION_GREATER 3.12 AND NOT CMAKE_CROSSCOMPILING) # Parallel building of gtest causes problems in some environments (e.g. Macports buildings) set(GTEST_BUILD_COMMAND ${GTEST_BUILD_COMMAND} "--parallel 1") endif() diff --git a/src/tests/system-tests/libs/spirent_motion_csv_dump_reader.cc b/src/tests/system-tests/libs/spirent_motion_csv_dump_reader.cc index d45b41e65..dc88d9e7b 100644 --- a/src/tests/system-tests/libs/spirent_motion_csv_dump_reader.cc +++ b/src/tests/system-tests/libs/spirent_motion_csv_dump_reader.cc @@ -22,46 +22,46 @@ Spirent_Motion_Csv_Dump_Reader::Spirent_Motion_Csv_Dump_Reader() + : header_lines(2), + TOW_ms(0.0), + Pos_X(0.0), + Pos_Y(0.0), + Pos_Z(0.0), + Vel_X(0.0), + Vel_Y(0.0), + Vel_Z(0.0), + Acc_X(0.0), + Acc_Y(0.0), + Acc_Z(0.0), + Jerk_X(0.0), + Jerk_Y(0.0), + Jerk_Z(0.0), + Lat(0.0), + Long(0.0), + Height(0.0), + Heading(0.0), + Elevation(0.0), + Bank(0.0), + Ang_vel_X(0.0), + Ang_vel_Y(0.0), + Ang_vel_Z(0.0), + Ang_acc_X(0.0), + Ang_acc_Y(0.0), + Ang_acc_Z(0.0), + Ant1_Pos_X(0.0), + Ant1_Pos_Y(0.0), + Ant1_Pos_Z(0.0), + Ant1_Vel_X(0.0), + Ant1_Vel_Y(0.0), + Ant1_Vel_Z(0.0), + Ant1_Acc_X(0.0), + Ant1_Acc_Y(0.0), + Ant1_Acc_Z(0.0), + Ant1_Lat(0.0), + Ant1_Long(0.0), + Ant1_Height(0.0), + Ant1_DOP(0.0) { - header_lines = 2; - TOW_ms = 0.0; - Pos_X = 0.0; - Pos_Y = 0.0; - Pos_Z = 0.0; - Vel_X = 0.0; - Vel_Y = 0.0; - Vel_Z = 0.0; - Acc_X = 0.0; - Acc_Y = 0.0; - Acc_Z = 0.0; - Jerk_X = 0.0; - Jerk_Y = 0.0; - Jerk_Z = 0.0; - Lat = 0.0; - Long = 0.0; - Height = 0.0; - Heading = 0.0; - Elevation = 0.0; - Bank = 0.0; - Ang_vel_X = 0.0; - Ang_vel_Y = 0.0; - Ang_vel_Z = 0.0; - Ang_acc_X = 0.0; - Ang_acc_Y = 0.0; - Ang_acc_Z = 0.0; - Ant1_Pos_X = 0.0; - Ant1_Pos_Y = 0.0; - Ant1_Pos_Z = 0.0; - Ant1_Vel_X = 0.0; - Ant1_Vel_Y = 0.0; - Ant1_Vel_Z = 0.0; - Ant1_Acc_X = 0.0; - Ant1_Acc_Y = 0.0; - Ant1_Acc_Z = 0.0; - Ant1_Lat = 0.0; - Ant1_Long = 0.0; - Ant1_Height = 0.0; - Ant1_DOP = 0.0; } diff --git a/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test.cc b/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test.cc index 3d4eda283..e9c5d9e45 100644 --- a/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test.cc @@ -71,7 +71,7 @@ private: GpsL1CaPcpsAcquisitionTest_msg_rx(); public: - int rx_message; + int rx_message{0}; ~GpsL1CaPcpsAcquisitionTest_msg_rx() override; //!< Default destructor }; @@ -97,7 +97,9 @@ void GpsL1CaPcpsAcquisitionTest_msg_rx::msg_handler_channel_events(const pmt::pm } -GpsL1CaPcpsAcquisitionTest_msg_rx::GpsL1CaPcpsAcquisitionTest_msg_rx() : gr::block("GpsL1CaPcpsAcquisitionTest_msg_rx", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0)) +GpsL1CaPcpsAcquisitionTest_msg_rx::GpsL1CaPcpsAcquisitionTest_msg_rx() + : gr::block("GpsL1CaPcpsAcquisitionTest_msg_rx", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0)) + { this->message_port_register_in(pmt::mp("events")); this->set_msg_handler(pmt::mp("events"), @@ -110,7 +112,6 @@ GpsL1CaPcpsAcquisitionTest_msg_rx::GpsL1CaPcpsAcquisitionTest_msg_rx() : gr::blo boost::bind(&GpsL1CaPcpsAcquisitionTest_msg_rx::msg_handler_channel_events, this, _1)); #endif #endif - rx_message = 0; } @@ -123,12 +124,11 @@ class GpsL1CaPcpsAcquisitionTest : public ::testing::Test { protected: GpsL1CaPcpsAcquisitionTest() + : item_size(sizeof(gr_complex)) + { config = std::make_shared(); - item_size = sizeof(gr_complex); gnss_synchro = Gnss_Synchro(); - doppler_max = 5000; - doppler_step = 100; } ~GpsL1CaPcpsAcquisitionTest() override = default; @@ -140,8 +140,8 @@ protected: std::shared_ptr config; Gnss_Synchro gnss_synchro{}; size_t item_size; - unsigned int doppler_max; - unsigned int doppler_step; + unsigned int doppler_max{5000}; + unsigned int doppler_step{100}; }; diff --git a/src/tests/unit-tests/signal-processing-blocks/adapter/adapter_test.cc b/src/tests/unit-tests/signal-processing-blocks/adapter/adapter_test.cc index f48fe1945..d43d459d6 100644 --- a/src/tests/unit-tests/signal-processing-blocks/adapter/adapter_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/adapter/adapter_test.cc @@ -53,9 +53,9 @@ public: DataTypeAdapter::DataTypeAdapter() + : file_name_input("adapter_test_input.dat"), + file_name_output("adapter_test_output.dat") { - file_name_input = "adapter_test_input.dat"; - file_name_output = "adapter_test_output.dat"; std::array input_bytes{2, 23, -1, 127, -127, 0}; std::array input_shorts{2, 23, -1, 127, -127, 0, 255, 255}; diff --git a/src/tests/unit-tests/signal-processing-blocks/filter/fir_filter_test.cc b/src/tests/unit-tests/signal-processing-blocks/filter/fir_filter_test.cc index 0ae347266..8bd2d98c4 100644 --- a/src/tests/unit-tests/signal-processing-blocks/filter/fir_filter_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/filter/fir_filter_test.cc @@ -44,10 +44,9 @@ DEFINE_int32(filter_test_nsamples, 1000000, "Number of samples to filter in the class FirFilterTest : public ::testing::Test { protected: - FirFilterTest() + FirFilterTest() : item_size(sizeof(gr_complex)) { queue = std::make_shared>(); - item_size = sizeof(gr_complex); config = std::make_shared(); } ~FirFilterTest() override = default; diff --git a/src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_lite_test.cc b/src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_lite_test.cc index c3f19b979..12d6ddce4 100644 --- a/src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_lite_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_lite_test.cc @@ -43,12 +43,10 @@ DEFINE_int32(notch_filter_lite_test_nsamples, 1000000, "Number of samples to fil class NotchFilterLiteTest : public ::testing::Test { protected: - NotchFilterLiteTest() + NotchFilterLiteTest() : item_size(sizeof(gr_complex)), nsamples(FLAGS_notch_filter_lite_test_nsamples) { queue = std::make_shared>(); - item_size = sizeof(gr_complex); config = std::make_shared(); - nsamples = FLAGS_notch_filter_lite_test_nsamples; } ~NotchFilterLiteTest() override = default; diff --git a/src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_test.cc b/src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_test.cc index 05818faa5..4c2a3cb4a 100644 --- a/src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_test.cc @@ -43,12 +43,10 @@ DEFINE_int32(notch_filter_test_nsamples, 1000000, "Number of samples to filter i class NotchFilterTest : public ::testing::Test { protected: - NotchFilterTest() + NotchFilterTest() : item_size(sizeof(gr_complex)), nsamples(FLAGS_notch_filter_test_nsamples) { queue = std::make_shared>(); - item_size = sizeof(gr_complex); config = std::make_shared(); - nsamples = FLAGS_notch_filter_test_nsamples; } ~NotchFilterTest() override = default; diff --git a/src/tests/unit-tests/signal-processing-blocks/filter/pulse_blanking_filter_test.cc b/src/tests/unit-tests/signal-processing-blocks/filter/pulse_blanking_filter_test.cc index f54031eb9..2bc731620 100644 --- a/src/tests/unit-tests/signal-processing-blocks/filter/pulse_blanking_filter_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/filter/pulse_blanking_filter_test.cc @@ -43,12 +43,10 @@ DEFINE_int32(pb_filter_test_nsamples, 1000000, "Number of samples to filter in t class PulseBlankingFilterTest : public ::testing::Test { protected: - PulseBlankingFilterTest() + PulseBlankingFilterTest() : item_size(sizeof(gr_complex)), nsamples(FLAGS_pb_filter_test_nsamples) { queue = std::make_shared>(); - item_size = sizeof(gr_complex); config = std::make_shared(); - nsamples = FLAGS_pb_filter_test_nsamples; } ~PulseBlankingFilterTest() override = default; bool stop = false; diff --git a/src/tests/unit-tests/signal-processing-blocks/libs/acquisition_dump_reader.cc b/src/tests/unit-tests/signal-processing-blocks/libs/acquisition_dump_reader.cc index 781dc3711..66a6ebf7b 100644 --- a/src/tests/unit-tests/signal-processing-blocks/libs/acquisition_dump_reader.cc +++ b/src/tests/unit-tests/signal-processing-blocks/libs/acquisition_dump_reader.cc @@ -196,21 +196,12 @@ Acquisition_Dump_Reader::Acquisition_Dump_Reader(const std::string& basename, unsigned int samples_per_code, int channel, int execution) + : d_basename(basename), + d_sat(sat), + d_doppler_max(doppler_max), + d_doppler_step(doppler_step), + d_samples_per_code(samples_per_code) { - d_basename = basename; - d_sat = sat; - d_doppler_max = doppler_max; - d_doppler_step = doppler_step; - d_samples_per_code = samples_per_code; - acq_doppler_hz = 0.0; - acq_delay_samples = 0.0; - test_statistic = 0.0; - input_power = 0.0; - threshold = 0.0; - positive_acq = 0; - sample_counter = 0; - num_dwells = 0; - PRN = 0; if (d_doppler_step == 0) { d_doppler_step = 1; diff --git a/src/tests/unit-tests/signal-processing-blocks/libs/acquisition_msg_rx.cc b/src/tests/unit-tests/signal-processing-blocks/libs/acquisition_msg_rx.cc index 596fd3994..c8701e41d 100644 --- a/src/tests/unit-tests/signal-processing-blocks/libs/acquisition_msg_rx.cc +++ b/src/tests/unit-tests/signal-processing-blocks/libs/acquisition_msg_rx.cc @@ -56,7 +56,9 @@ void Acquisition_msg_rx::msg_handler_channel_events(const pmt::pmt_t& msg) } -Acquisition_msg_rx::Acquisition_msg_rx() : gr::block("Acquisition_msg_rx", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0)) +Acquisition_msg_rx::Acquisition_msg_rx() + : gr::block("Acquisition_msg_rx", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0)), + rx_message(0) { this->message_port_register_in(pmt::mp("events")); this->set_msg_handler(pmt::mp("events"), @@ -69,7 +71,6 @@ Acquisition_msg_rx::Acquisition_msg_rx() : gr::block("Acquisition_msg_rx", gr::i boost::bind(&Acquisition_msg_rx::msg_handler_channel_events, this, _1)); #endif #endif - rx_message = 0; } diff --git a/src/tests/unit-tests/signal-processing-blocks/libs/observables_dump_reader.cc b/src/tests/unit-tests/signal-processing-blocks/libs/observables_dump_reader.cc index b3383b816..fd9904a6c 100644 --- a/src/tests/unit-tests/signal-processing-blocks/libs/observables_dump_reader.cc +++ b/src/tests/unit-tests/signal-processing-blocks/libs/observables_dump_reader.cc @@ -104,8 +104,8 @@ void Observables_Dump_Reader::close_obs_file() Observables_Dump_Reader::Observables_Dump_Reader(int n_channels_) + : n_channels(n_channels_) { - n_channels = n_channels_; RX_time = std::vector(n_channels); TOW_at_current_symbol_s = std::vector(n_channels); Carrier_Doppler_hz = std::vector(n_channels); diff --git a/src/tests/unit-tests/signal-processing-blocks/tracking/cubature_filter_test.cc b/src/tests/unit-tests/signal-processing-blocks/tracking/cubature_filter_test.cc index 698b950a4..2c78fa743 100644 --- a/src/tests/unit-tests/signal-processing-blocks/tracking/cubature_filter_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/tracking/cubature_filter_test.cc @@ -25,7 +25,7 @@ class TransitionModel : public ModelFunction { public: - explicit TransitionModel(const arma::mat& kf_F) { coeff_mat = kf_F; }; + explicit TransitionModel(const arma::mat& kf_F) : coeff_mat(kf_F){}; arma::vec operator()(const arma::vec& input) override { return coeff_mat * input; }; private: @@ -35,7 +35,7 @@ private: class MeasurementModel : public ModelFunction { public: - explicit MeasurementModel(const arma::mat& kf_H) { coeff_mat = kf_H; }; + explicit MeasurementModel(const arma::mat& kf_H) : coeff_mat(kf_H){}; arma::vec operator()(const arma::vec& input) override { return coeff_mat * input; }; private: diff --git a/src/tests/unit-tests/signal-processing-blocks/tracking/galileo_e1_dll_pll_veml_tracking_test.cc b/src/tests/unit-tests/signal-processing-blocks/tracking/galileo_e1_dll_pll_veml_tracking_test.cc index 23e095c98..734d70af2 100644 --- a/src/tests/unit-tests/signal-processing-blocks/tracking/galileo_e1_dll_pll_veml_tracking_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/tracking/galileo_e1_dll_pll_veml_tracking_test.cc @@ -41,12 +41,10 @@ class GalileoE1DllPllVemlTrackingInternalTest : public ::testing::Test { protected: GalileoE1DllPllVemlTrackingInternalTest() + : item_size(sizeof(gr_complex)) { factory = std::make_shared(); config = std::make_shared(); - item_size = sizeof(gr_complex); - stop = false; - message = 0; gnss_synchro = Gnss_Synchro(); } @@ -60,8 +58,8 @@ protected: std::shared_ptr config; Gnss_Synchro gnss_synchro{}; size_t item_size; - bool stop; - int message; + bool stop{false}; + int message{0}; }; diff --git a/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc b/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc index bd772cf9d..fb3a63cef 100644 --- a/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc @@ -102,7 +102,9 @@ void GpsL1CADllPllTrackingTest_msg_rx::msg_handler_channel_events(const pmt::pmt } -GpsL1CADllPllTrackingTest_msg_rx::GpsL1CADllPllTrackingTest_msg_rx() : gr::block("GpsL1CADllPllTrackingTest_msg_rx", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0)) +GpsL1CADllPllTrackingTest_msg_rx::GpsL1CADllPllTrackingTest_msg_rx() + : gr::block("GpsL1CADllPllTrackingTest_msg_rx", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0)), + rx_message(0) { this->message_port_register_in(pmt::mp("events")); this->set_msg_handler(pmt::mp("events"), @@ -115,7 +117,6 @@ GpsL1CADllPllTrackingTest_msg_rx::GpsL1CADllPllTrackingTest_msg_rx() : gr::block boost::bind(&GpsL1CADllPllTrackingTest_msg_rx::msg_handler_channel_events, this, _1)); #endif #endif - rx_message = 0; } @@ -166,11 +167,10 @@ public: double& rmse); bool save_mat_xy(std::vector& x, std::vector& y, std::string filename); - GpsL1CADllPllTrackingTest() + GpsL1CADllPllTrackingTest() : item_size(sizeof(gr_complex)) { factory = std::make_shared(); config = std::make_shared(); - item_size = sizeof(gr_complex); gnss_synchro = Gnss_Synchro(); } diff --git a/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test_fpga.cc b/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test_fpga.cc index 15fcf19f4..85d54d1a1 100644 --- a/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test_fpga.cc +++ b/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test_fpga.cc @@ -197,9 +197,11 @@ void GpsL1CADllPllTrackingTestFpga_msg_rx::msg_handler_channel_events(const pmt: } -GpsL1CADllPllTrackingTestFpga_msg_rx::GpsL1CADllPllTrackingTestFpga_msg_rx() : gr::block("GpsL1CADllPllTrackingTestFpga_msg_rx", - gr::io_signature::make(0, 0, 0), - gr::io_signature::make(0, 0, 0)) +GpsL1CADllPllTrackingTestFpga_msg_rx::GpsL1CADllPllTrackingTestFpga_msg_rx() + : gr::block("GpsL1CADllPllTrackingTestFpga_msg_rx", + gr::io_signature::make(0, 0, 0), + gr::io_signature::make(0, 0, 0)), + rx_message(0) { this->message_port_register_in(pmt::mp("events")); this->set_msg_handler(pmt::mp("events"), @@ -212,7 +214,6 @@ GpsL1CADllPllTrackingTestFpga_msg_rx::GpsL1CADllPllTrackingTestFpga_msg_rx() : g boost::bind(&GpsL1CADllPllTrackingTestFpga_msg_rx::msg_handler_channel_events, this, _1)); #endif #endif - rx_message = 0; } @@ -245,10 +246,10 @@ public: void check_results_codephase(arma::vec &true_time_s, arma::vec &true_value, arma::vec &meas_time_s, arma::vec &meas_value); - GpsL1CADllPllTrackingTestFpga() + GpsL1CADllPllTrackingTestFpga() : item_size(sizeof(gr_complex)) { config = std::make_shared(); - item_size = sizeof(gr_complex); + gnss_synchro = Gnss_Synchro(); } diff --git a/src/utils/front-end-cal/main.cc b/src/utils/front-end-cal/main.cc index b8e7ef7fc..38ee8206c 100644 --- a/src/utils/front-end-cal/main.cc +++ b/src/utils/front-end-cal/main.cc @@ -117,7 +117,7 @@ private: FrontEndCal_msg_rx(); public: - int rx_message; + int rx_message{0}; }; @@ -143,7 +143,8 @@ void FrontEndCal_msg_rx::msg_handler_channel_events(const pmt::pmt_t& msg) } -FrontEndCal_msg_rx::FrontEndCal_msg_rx() : gr::block("FrontEndCal_msg_rx", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0)) +FrontEndCal_msg_rx::FrontEndCal_msg_rx() + : gr::block("FrontEndCal_msg_rx", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0)) { this->message_port_register_in(pmt::mp("events")); this->set_msg_handler(pmt::mp("events"), @@ -156,7 +157,6 @@ FrontEndCal_msg_rx::FrontEndCal_msg_rx() : gr::block("FrontEndCal_msg_rx", gr::i boost::bind(&FrontEndCal_msg_rx::msg_handler_channel_events, this, _1)); #endif #endif - rx_message = 0; }