Merge branch 'next' of https://github.com/gnss-sdr/gnss-sdr into next

CMakeLists.txt

@@ -479,7 +479,7 @@ set(Boost_ADDITIONAL_VERSIONS
 )
 set(Boost_USE_MULTITHREAD ON)
 set(Boost_USE_STATIC_LIBS OFF)
-find_package(Boost COMPONENTS date_time system filesystem thread serialization chrono unit_test_framework program_options REQUIRED)
+find_package(Boost COMPONENTS date_time system filesystem thread serialization chrono REQUIRED)
 if(NOT Boost_FOUND)
      message(FATAL_ERROR "Fatal error: Boost (version >=${GNSSSDR_BOOST_MIN_VERSION}) required.")
 endif(NOT Boost_FOUND)

README.md

@@ -58,10 +58,9 @@ If you want to start building and running GNSS-SDR as quick and easy as possible
 ~~~~~~
 $ sudo apt-get install build-essential cmake git libboost-dev libboost-date-time-dev \
        libboost-system-dev libboost-filesystem-dev libboost-thread-dev libboost-chrono-dev \
-       libboost-serialization-dev libboost-program-options-dev libboost-test-dev \
+       libboost-serialization-dev liblog4cpp5-dev libuhd-dev gnuradio-dev gr-osmosdr \
-       liblog4cpp5-dev libuhd-dev gnuradio-dev gr-osmosdr libblas-dev liblapack-dev \
+       libblas-dev liblapack-dev libarmadillo-dev libgflags-dev libgoogle-glog-dev \
-       libarmadillo-dev libgflags-dev libgoogle-glog-dev libgnutls-openssl-dev \
+       libgnutls-openssl-dev python-mako python-six libmatio-dev googletest
-       python-mako python-six libmatio-dev googletest
 ~~~~~~
 
 Please note that `googletest` was named `libgtest-dev` in distributions older than Debian 9 Stretch and Ubuntu 17.04 Zesty.

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/Doxyfile.in

@@ -1117,7 +1117,7 @@ HTML_STYLESHEET        =
 # defined cascading style sheet that is included after the standard style sheets
 # created by doxygen. Using this option one can overrule certain style aspects.
 # This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefor more robust against future updates.
+# standard style sheet and is therefore more robust against future updates.
 # Doxygen will copy the style sheet file to the output directory. For an example
 # see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
@@ -2008,7 +2008,7 @@ PREDEFINED             = LV_HAVE_GENERIC \
 EXPAND_AS_DEFINED      =
 
 # If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
-# remove all refrences to function-like macros that are alone on a line, have an
+# remove all references to function-like macros that are alone on a line, have an
 # all uppercase name, and do not end with a semicolon. Such function macros are
 # typically used for boiler-plate code, and will confuse the parser if not
 # removed.

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/README.md

@@ -46,7 +46,7 @@ machine:
 
 ~~~~~~ 
 $ sudo apt-get install cmake python-mako python-six libboost-dev \
-  libboost-filesystem-dev libboost-system-dev libboost-program-options-dev
+  libboost-filesystem-dev libboost-system-dev
 ~~~~~~ 
 
 In order to build and install the library, go to the base folder of the

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/CMakeLists.txt

@@ -63,6 +63,7 @@ endif(UNIX)
 add_executable(volk_gnsssdr_profile
     ${CMAKE_CURRENT_SOURCE_DIR}/volk_gnsssdr_profile.cc
     ${PROJECT_SOURCE_DIR}/lib/qa_utils.cc
+    ${CMAKE_CURRENT_SOURCE_DIR}/volk_gnsssdr_option_helpers.cc
 )
 
 if(ENABLE_STATIC_LIBS)
@@ -87,26 +88,13 @@ install(
     COMPONENT "volk_gnsssdr"
 )
 
-# Launch volk_gnsssdr_profile if requested to do so
-if(ENABLE_PROFILING)
-   if(DEFINED VOLK_CONFIGPATH)
-        set( VOLK_CONFIG_ARG "-p${VOLK_CONFIGPATH}" )
-        set( VOLK_CONFIG "${VOLK_CONFIGPATH}/volk_gnsssdr_config" )
-   endif()
-   add_custom_command(OUTPUT ${VOLK_CONFIG}
-        COMMAND volk_gnsssdr_profile "${VOLK_CONFIG_ARG}"
-        DEPENDS volk_gnsssdr_profile
-        COMMENT "Launching profiler, this may take a few minutes..."
-    )
-    add_custom_target(volk-gnsssdr-profile-run ALL DEPENDS ${VOLK_CONFIG})
-endif()
 
 # MAKE volk_gnsssdr-config-info
-add_executable(volk_gnsssdr-config-info volk_gnsssdr-config-info.cc)
+add_executable(volk_gnsssdr-config-info volk_gnsssdr-config-info.cc ${CMAKE_CURRENT_SOURCE_DIR}/volk_gnsssdr_option_helpers.cc)
 if(ENABLE_STATIC_LIBS)
-   target_link_libraries(volk_gnsssdr-config-info volk_gnsssdr_static ${Boost_LIBRARIES} ${Clang_required_link} ${orc_lib})
+   target_link_libraries(volk_gnsssdr-config-info volk_gnsssdr_static ${Clang_required_link} ${orc_lib})
 else(ENABLE_STATIC_LIBS)
-   target_link_libraries(volk_gnsssdr-config-info volk_gnsssdr ${Boost_LIBRARIES} ${Clang_required_link} ${orc_lib})
+   target_link_libraries(volk_gnsssdr-config-info volk_gnsssdr ${Clang_required_link} ${orc_lib})
    add_dependencies(volk_gnsssdr-config-info volk_gnsssdr)
 endif(ENABLE_STATIC_LIBS)
 
@@ -123,3 +111,20 @@ install(
     COMPONENT "volk_gnsssdr"
 )
 
+
+# Launch volk_gnsssdr_profile if requested to do so
+if(ENABLE_PROFILING)
+   if(DEFINED VOLK_CONFIGPATH)
+        set( VOLK_CONFIG_ARG "-p${VOLK_CONFIGPATH}" )
+        set( VOLK_CONFIG "${VOLK_CONFIGPATH}/volk_gnsssdr_config" )
+   endif()
+   add_custom_command(OUTPUT ${VOLK_CONFIG}
+        COMMAND volk_gnsssdr_profile "${VOLK_CONFIG_ARG}"
+        DEPENDS volk_gnsssdr_profile
+        COMMENT "Launching profiler, this may take a few minutes..."
+    )
+    add_custom_target(volk-gnsssdr-profile-run ALL DEPENDS ${VOLK_CONFIG})
+endif()
+
+
+

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/volk_gnsssdr-config-info.cc

@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors)
+/* Copyright (C) 2010-2018 (see AUTHORS file for a list of contributors)
  *
  * This file is part of GNSS-SDR.
  *
@@ -22,86 +22,47 @@
 
 #include <volk_gnsssdr/constants.h>
 #include "volk_gnsssdr/volk_gnsssdr.h"
-#include <boost/program_options.hpp>
 #include <iostream>
+#include "volk_gnsssdr_option_helpers.h"
 
-namespace po = boost::program_options;
+void print_alignment()
-
-int
-main(int argc, char **argv)
 {
-  po::options_description desc("Program options: volk_gnsssdr-config-info [options]");
+  std::cout << "Alignment in bytes: " << volk_gnsssdr_get_alignment() << std::endl;
-  po::variables_map vm;
+}
-
+
-  desc.add_options()
+
-    ("help,h", "print help message")
+void print_malloc()
-    ("prefix", "print VOLK_GNSSSDR installation prefix")
+{
-    ("cc", "print VOLK_GNSSSDR C compiler version")
+  // You don't want to change the volk_malloc code, so just copy the if/else
-    ("cflags", "print VOLK_GNSSSDR CFLAGS")
+  // structure from there and give an explanation for the implementations
-    ("all-machines", "print VOLK_GNSSSDR machines built into library")
+  std::cout << "Used malloc implementation: ";
-    ("avail-machines", "print VOLK_GNSSSDR machines the current platform can use")
+  #if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || HAVE_POSIX_MEMALIGN
-    ("machine", "print the VOLK_GNSSSDR machine that will be used")
+  std::cout << "posix_memalign" << std::endl;
-    ("alignment", "print the alignment that will be used")
+  #elif _MSC_VER >= 1400
-    ("malloc", "print malloc implementation that will be used")
+  std::cout << "aligned_malloc" << std::endl;
-    ("version,v", "print VOLK_GNSSSDR version")
+  #else
-    ;
+      std::cout << "No standard handler available, using own implementation." << std::endl;
-
+  #endif
-  try {
+}
-    po::store(po::parse_command_line(argc, argv, desc), vm);
+
-    po::notify(vm);
+
-  }
+int main(int argc, char **argv)
-  catch (po::error& error){
+{
-    std::cerr << "Error: " << error.what() << std::endl << std::endl;
+    option_list our_options("volk_gnsssdr-config-info");
-    std::cerr << desc << std::endl;
+    our_options.add(option_t("prefix", "", "print the VOLK_GNSSSDR installation prefix", volk_gnsssdr_prefix()));
-    return 1;
+    our_options.add(option_t("cc", "", "print the VOLK_GNSSDR C compiler version", volk_gnsssdr_c_compiler()));
-  }
+    our_options.add(option_t("cflags", "", "print the VOLK_GNSSSDR CFLAGS", volk_gnsssdr_compiler_flags()));
-
+    our_options.add(option_t("all-machines", "", "print VOLK_GNSSSDR machines built", volk_gnsssdr_available_machines()));
-  if(vm.size() == 0 || vm.count("help")) {
+    our_options.add(option_t("avail-machines", "", "print VOLK_GNSSSDR machines on the current "
-    std::cout << desc << std::endl;
+            "platform", volk_gnsssdr_list_machines));
-    return 1;
+    our_options.add(option_t("machine", "", "print the current VOLK_GNSSSDR machine that will be used",
-  }
+            volk_gnsssdr_get_machine()));
-
+    our_options.add(option_t("alignment", "", "print the memory alignment", print_alignment));
-  if(vm.count("prefix"))
+    our_options.add(option_t("malloc", "", "print the malloc implementation used in volk_gnsssdr_malloc",
-    std::cout << volk_gnsssdr_prefix() << std::endl;
+            print_malloc));
-
+    our_options.add(option_t("version", "v", "print the VOLK_GNSSSDR version", volk_gnsssdr_version()));
-  if(vm.count("version"))
+
-    std::cout << volk_gnsssdr_version() << std::endl;
+    our_options.parse(argc, argv);
-
+
-  if(vm.count("cc"))
+    return 0;
-    std::cout << volk_gnsssdr_c_compiler() << std::endl;
-
-  if(vm.count("cflags"))
-    std::cout << volk_gnsssdr_compiler_flags() << std::endl;
-
-  // stick an extra ';' to make output of this and avail-machines the
-  // same structure for easier parsing
-  if(vm.count("all-machines"))
-    std::cout << volk_gnsssdr_available_machines() << ";" << std::endl;
-
-  if(vm.count("avail-machines")) {
-    volk_gnsssdr_list_machines();
-  }
-
-  if(vm.count("machine")) {
-    std::cout << volk_gnsssdr_get_machine() << std::endl;
-  }
-
-  if(vm.count("alignment")) {
-      std::cout << "Alignment in bytes: " << volk_gnsssdr_get_alignment() << std::endl;
-   }
-
-   // You don't want to change the volk_malloc code, so just copy the if/else
-   // structure from there and give an explanation for the implementations
-   if(vm.count("malloc")) {
-     std::cout << "Used malloc implementation: ";
- #if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || HAVE_POSIX_MEMALIGN
-     std::cout << "posix_memalign" << std::endl;
- #elif _MSC_VER >= 1400
-     std::cout << "aligned_malloc" << std::endl;
- #else
-     std::cout << "No standard handler available, using own implementation." << std::endl;
- #endif
-   }
-
-  return 0;
 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/volk_gnsssdr_option_helpers.cc

@@ -0,0 +1,158 @@
+/* Copyright (C) 2010-2018 (see AUTHORS file for a list of contributors)
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "volk_gnsssdr_option_helpers.h"
+
+#include <iostream>
+
+/*
+ * Option type
+ */
+option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)())
+        : longform("--" + longform),
+          shortform("-" + shortform),
+          msg(msg),
+          callback(callback) { option_type = VOID_CALLBACK; }
+
+option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(int))
+        : longform("--" + longform),
+          shortform("-" + shortform),
+          msg(msg),
+          callback((void (*)()) callback) { option_type = INT_CALLBACK; }
+
+option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(float))
+        : longform("--" + longform),
+          shortform("-" + shortform),
+          msg(msg),
+          callback((void (*)()) callback) { option_type = FLOAT_CALLBACK; }
+
+option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(bool))
+        : longform("--" + longform),
+          shortform("-" + shortform),
+          msg(msg),
+          callback((void (*)()) callback) { option_type = BOOL_CALLBACK; }
+
+option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(std::string))
+        : longform("--" + longform),
+          shortform("-" + shortform),
+          msg(msg),
+          callback((void (*)()) callback) { option_type = STRING_CALLBACK; }
+
+option_t::option_t(std::string longform, std::string shortform, std::string msg, std::string printval)
+        : longform("--" + longform),
+          shortform("-" + shortform),
+          msg(msg),
+          printval(printval) { option_type = STRING; }
+
+
+/*
+ * Option List
+ */
+
+option_list::option_list(std::string program_name) :
+        program_name(program_name) {
+    { internal_list = std::vector<option_t>(); }
+}
+
+void option_list::add(option_t opt) { internal_list.push_back(opt); }
+
+void option_list::parse(int argc, char **argv) {
+    for (int arg_number = 0; arg_number < argc; ++arg_number) {
+        for (std::vector<option_t>::iterator this_option = internal_list.begin();
+             this_option != internal_list.end();
+             this_option++) {
+            if (this_option->longform == std::string(argv[arg_number]) ||
+                this_option->shortform == std::string(argv[arg_number])) {
+                switch (this_option->option_type) {
+                    case VOID_CALLBACK:
+                        this_option->callback();
+                        break;
+                    case INT_CALLBACK:
+                        try {
+                            int int_val = std::stoi(argv[++arg_number]);
+                            ((void (*)(int)) this_option->callback)(int_val);
+                        } catch (std::exception &exc) {
+                            std::cout << "An int option can only receive a number" << std::endl;
+                            throw std::exception();
+                        };
+                        break;
+                    case FLOAT_CALLBACK:
+                        try {
+                            int int_val = std::stof(argv[++arg_number]);
+                            ((void (*)(float)) this_option->callback)(int_val);
+                        } catch (std::exception &exc) {
+                            std::cout << "A float option can only receive a number" << std::endl;
+                            throw std::exception();
+                        };
+                        break;
+                    case BOOL_CALLBACK:
+                        try {
+                            bool int_val = (bool) std::stoi(argv[++arg_number]);
+                            ((void (*)(bool)) this_option->callback)(int_val);
+                        } catch (std::exception &exc) {
+                            std::cout << "A bool option can only receive 0 or 1" << std::endl;
+                            throw std::exception();
+                        };
+                        break;
+                    case STRING_CALLBACK:
+                        try {
+                            ((void (*)(std::string)) this_option->callback)(argv[++arg_number]);
+                        } catch (std::exception &exc) {
+                            throw std::exception();
+                        };
+                    case STRING:
+                        std::cout << this_option->printval << std::endl;
+                        break;
+                }
+            }
+
+        }
+        if (std::string("--help") == std::string(argv[arg_number]) ||
+            std::string("-h") == std::string(argv[arg_number])) {
+            help();
+        }
+    }
+}
+
+void option_list::help() {
+    std::cout << program_name << std::endl;
+    std::cout << "  -h [ --help ] \t\tdisplay this help message" << std::endl;
+    for (std::vector<option_t>::iterator this_option = internal_list.begin();
+         this_option != internal_list.end();
+         this_option++) {
+        std::string help_line("  ");
+        if (this_option->shortform == "-") {
+            help_line += this_option->longform + " ";
+        } else {
+            help_line += this_option->shortform + " [ " + this_option->longform + " ]";
+        }
+
+        switch (help_line.size() / 8) {
+            case 0:
+                help_line += "\t";
+            case 1:
+                help_line += "\t";
+            case 2:
+                help_line += "\t";
+            case 3:
+                help_line += "\t";
+        }
+        help_line += this_option->msg;
+        std::cout << help_line << std::endl;
+    }
+}

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/volk_gnsssdr_option_helpers.h

@@ -0,0 +1,69 @@
+/* Copyright (C) 2010-2018 (see AUTHORS file for a list of contributors)
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef VOLK_VOLK_OPTION_HELPERS_H
+#define VOLK_VOLK_OPTION_HELPERS_H
+
+#include <string>
+#include <vector>
+
+typedef enum
+{
+    VOID_CALLBACK,
+    INT_CALLBACK,
+    BOOL_CALLBACK,
+    STRING_CALLBACK,
+    FLOAT_CALLBACK,
+    STRING,
+} VOLK_OPTYPE;
+
+class option_t {
+public:
+    option_t(std::string longform, std::string shortform, std::string msg, void (*callback)());
+    option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(int));
+    option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(float));
+    option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(bool));
+    option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(std::string));
+    option_t(std::string longform, std::string shortform, std::string msg, std::string printval);
+
+    std::string longform;
+    std::string shortform;
+    std::string msg;
+    VOLK_OPTYPE option_type;
+    std::string printval;
+    void (*callback)();
+
+};
+
+class option_list
+{
+public:
+    option_list(std::string program_name);
+
+    void add(option_t opt);
+
+    void parse(int argc, char **argv);
+
+    void help();
+private:
+    std::string program_name;
+    std::vector<option_t> internal_list;
+};
+
+
+#endif //VOLK_VOLK_OPTION_HELPERS_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/volk_gnsssdr_profile.cc

@@ -18,215 +18,131 @@
 
 #include "qa_utils.h"
 #include "kernel_tests.h"
+#include "volk_gnsssdr_option_helpers.h"
 #include "volk_gnsssdr_profile.h"
 
 #include <volk_gnsssdr/volk_gnsssdr.h>
 #include <volk_gnsssdr/volk_gnsssdr_prefs.h>
 
 #include <vector>
-#include <boost/exception/diagnostic_information.hpp>
 #include <boost/filesystem.hpp>
-#include <boost/program_options.hpp>
-#include <boost/xpressive/xpressive.hpp>
 #include <iostream>
 #include <fstream>
+#include <sys/stat.h>
 
 namespace fs = boost::filesystem;
 
-int main(int argc, char *argv[]) {
+volk_gnsssdr_test_params_t test_params(1e-6f, 327.f, 8111, 1987, false, "");
-    // Adding program options
-    try
-    {
-            boost::program_options::options_description desc("Options");
-            desc.add_options()
-              ("help,h", "Print help messages")
-              ("benchmark,b",
-                 boost::program_options::value<bool>()->default_value( false )
-                                                      ->implicit_value( true ),
-                 "Run all kernels (benchmark mode)")
-              ("tol,t",
-                 boost::program_options::value<float>()->default_value( 1e-6 ),
-                 "Set the default error tolerance for tests")
-              ("vlen,v",
-                 boost::program_options::value<int>()->default_value( 8111 ), //it is also prime
-                 "Set the default vector length for tests") // default is a mersenne prime
-              ("iter,i",
-                 boost::program_options::value<int>()->default_value( 1987 ),
-                 "Set the default number of test iterations per kernel")
-              ("tests-regex,R",
-                  boost::program_options::value<std::string>(),
-                  "Run tests matching regular expression.")
-              ("update,u",
-                  boost::program_options::value<bool>()->default_value( false )
-                                                       ->implicit_value( true ),
-                  "Run only kernels missing from config; use -R to further restrict the candidates")
-              ("dry-run,n",
-                  boost::program_options::value<bool>()->default_value( false )
-                                                        ->implicit_value( true ),
-                  "Dry run. Respect other options, but don't write to file")
-              ("json,j",
-                  boost::program_options::value<std::string>(),
-                  "JSON output file")
-              ("path,p",
-                  boost::program_options::value<std::string>(),
-                  "Specify volk_config path.")
-              ;
 
-            // Handle the options that were given
+void set_benchmark(bool val) { test_params.set_benchmark(val); }
-            boost::program_options::variables_map vm;
+void set_tolerance(float val) { test_params.set_tol(val); }
-            bool benchmark_mode;
+void set_vlen(int val) { test_params.set_vlen((unsigned int)val); }
-            std::string kernel_regex;
+void set_iter(int val) { test_params.set_iter((unsigned int)val); }
-            std::ofstream json_file;
+void set_substr(std::string val) { test_params.set_regex(val); }
-            float def_tol;
+bool update_mode = false;
-            lv_32fc_t def_scalar;
+void set_update(bool val) { update_mode = val; }
-            int def_iter;
+bool dry_run = false;
-            int def_vlen;
+void set_dryrun(bool val) { dry_run = val; }
-            bool def_benchmark_mode;
+std::string json_filename("");
-            std::string def_kernel_regex;
+void set_json(std::string val) { json_filename = val; }
-            bool update_mode = false;
+std::string volk_config_path("");
-            bool dry_run = false;
+void set_volk_config(std::string val) { volk_config_path = val; }
-            std::string config_file;
 
-            // Handle the provided options
+int main(int argc, char *argv[])
-            try {
+{
-                    boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);
+    option_list profile_options("volk_gnsssdr_profile");
-                    boost::program_options::notify(vm);
+    profile_options.add(option_t("benchmark", "b", "Run all kernels (benchmark mode)", set_benchmark));
-                    benchmark_mode = vm.count("benchmark")?vm["benchmark"].as<bool>():false;
+    profile_options.add(option_t("tol", "t", "Set the default tolerance for all tests", set_tolerance));
-                    if ( vm.count("tests-regex" ) ) {
+    profile_options.add(option_t("vlen", "v", "Set the default vector length for tests", set_vlen));
-                            kernel_regex = vm["tests-regex"].as<std::string>();
+    profile_options.add((option_t("iter", "i", "Set the default number of test iterations per kernel", set_iter)));
-                    }
+    profile_options.add((option_t("tests-substr", "R", "Run tests matching substring", set_substr)));
-                    else {
+    profile_options.add((option_t("update", "u", "Run only kernels missing from config", set_update)));
-                            kernel_regex = ".*";
+    profile_options.add((option_t("dry-run", "n", "Dry run. Respect other options, but don't write to file", set_dryrun)));
-                    }
+    profile_options.add((option_t("json", "j", "Write results to JSON file named as argument value", set_json)));
+    profile_options.add((option_t("path", "p", "Specify the volk_config path", set_volk_config)));
+    profile_options.parse(argc, argv);
 
-                    def_tol = vm["tol"].as<float>();
+    for (int arg_number = 0; arg_number < argc; ++arg_number) {
-                    def_scalar = 327.0;
+            if (std::string("--help") == std::string(argv[arg_number]) ||
-                    def_vlen = vm["vlen"].as<int>();
+                    std::string("-h") == std::string(argv[arg_number])) {
-                    def_iter = vm["iter"].as<int>();
-                    def_benchmark_mode = benchmark_mode;
-                    def_kernel_regex = kernel_regex;
-                    update_mode = vm["update"].as<bool>();
-                    dry_run = vm["dry-run"].as<bool>();
-            }
-            catch (const boost::program_options::error & error) {
-                    std::cerr << "Error: " << error.what() << std::endl << std::endl;
-                    std::cerr << desc << std::endl;
-                    return 1;
-            }
-
-            /** --help option */
-            if ( vm.count("help") ) {
-                    std::cout << "The VOLK_GNSSSDR profiler." << std::endl
-                            << desc << std::endl;
                     return 0;
             }
-
-            if ( vm.count("json") ) {
-                    std::string filename;
-                    try {
-                            filename = vm["json"].as<std::string>();
-                    }
-                    catch (const boost::bad_any_cast& error) {
-                            std::cerr << error.what() << std::endl;
-                            return 1;
-                    }
-                    json_file.open( filename.c_str() );
-            }
-
-            if ( vm.count("path") ) {
-                    try {
-                            config_file = vm["path"].as<std::string>() + "/volk_config";
-                    }
-                    catch (const boost::bad_any_cast& error) {
-                            std::cerr << error.what() << std::endl;
-                            return 1;
-                    }
-            }
-
-            volk_gnsssdr_test_params_t test_params(def_tol, def_scalar, def_vlen, def_iter,
-                    def_benchmark_mode, def_kernel_regex);
-
-            // Run tests
-            std::vector<volk_gnsssdr_test_results_t> results;
-            if(update_mode) {
-                    read_results(&results);
-                    if( vm.count("path") ) read_results(&results, config_file);
-                    else read_results(&results);
-            }
-
-
-            // Initialize the list of tests
-            // the default test parameters come from options
-            std::vector<volk_gnsssdr_test_case_t> test_cases = init_test_list(test_params);
-            boost::xpressive::sregex kernel_expression;
-            try {
-                    kernel_expression = boost::xpressive::sregex::compile(kernel_regex);
-            }
-            catch (const boost::xpressive::regex_error& error) {
-                    std::cerr << "Error occurred while compiling regex" << std::endl << std::endl;
-                    return 1;
-            }
-
-            // Iteratate through list of tests running each one
-            for(unsigned int ii = 0; ii < test_cases.size(); ++ii) {
-                    bool regex_match = true;
-
-                    volk_gnsssdr_test_case_t test_case = test_cases[ii];
-                    // if the kernel name matches regex then do the test
-                    if(boost::xpressive::regex_search(test_case.name(), kernel_expression)) {
-                            regex_match = true;
-                    }
-                    else {
-                            regex_match = false;
-                    }
-
-                    // if we are in update mode check if we've already got results
-                    // if we have any, then no need to test that kernel
-                    bool update = true;
-                    if(update_mode) {
-                            for(unsigned int jj=0; jj < results.size(); ++jj) {
-                                    if(results[jj].name == test_case.name() ||
-                                            results[jj].name == test_case.puppet_master_name()) {
-                                            update = false;
-                                            break;
-                                    }
-                            }
-                    }
-
-                    if( regex_match && update ) {
-                            try {
-                                    run_volk_gnsssdr_tests(test_case.desc(), test_case.kernel_ptr(), test_case.name(),
-                                            test_case.test_parameters(), &results, test_case.puppet_master_name());
-                            }
-                            catch (const std::string & error) {
-                                    std::cerr << "Caught Exception in 'run_volk_gnsssdr_tests': " << error << std::endl;
-                            }
-
-                    }
-            }
-
-
-            // Output results according to provided options
-            if(vm.count("json")) {
-                    write_json(json_file, results);
-                    json_file.close();
-            }
-
-            if(!dry_run) {
-                    if(vm.count("path")) write_results(&results, false, config_file);
-                    else write_results(&results, false);
-            }
-            else {
-                    std::cout << "Warning: this was a dry-run. Config not generated" << std::endl;
-            }
     }
-    catch(const boost::exception & e)
+    // Adding program options
-    {
+    std::ofstream json_file;
-            std::cerr << boost::diagnostic_information(e) << std::endl;
+    std::string config_file;
-            return 1;
+
+    if ( json_filename != "" ) {
+        json_file.open( json_filename.c_str() );
+    }
+
+    if ( volk_config_path != "" ) {
+        config_file = volk_config_path + "/volk_config";
+    }
+
+    // Run tests
+    std::vector<volk_gnsssdr_test_results_t> results;
+    if(update_mode) {
+        if( config_file != "" ) read_results(&results, config_file);
+        else read_results(&results);
+    }
+
+    // Initialize the list of tests
+    std::vector<volk_gnsssdr_test_case_t> test_cases = init_test_list(test_params);
+
+    // Iterate through list of tests running each one
+    std::string substr_to_match(test_params.kernel_regex());
+    for(unsigned int ii = 0; ii < test_cases.size(); ++ii) {
+        bool regex_match = true;
+
+        volk_gnsssdr_test_case_t test_case = test_cases[ii];
+        // if the kernel name matches regex then do the test
+        std::string test_case_name = test_case.name();
+        if(test_case_name.find(substr_to_match) == std::string::npos) {
+            regex_match = false;
+        }
+
+        // if we are in update mode check if we've already got results
+        // if we have any, then no need to test that kernel
+        bool update = true;
+        if(update_mode) {
+            for(unsigned int jj=0; jj < results.size(); ++jj) {
+                if(results[jj].name == test_case.name() ||
+                    results[jj].name == test_case.puppet_master_name()) {
+                    update = false;
+                    break;
+                }
+            }
+        }
+
+        if( regex_match && update ) {
+            try {
+            run_volk_gnsssdr_tests(test_case.desc(), test_case.kernel_ptr(), test_case.name(),
+                test_case.test_parameters(), &results, test_case.puppet_master_name());
+            }
+            catch (std::string &error) {
+                std::cerr << "Caught Exception in 'run_volk_gnssdr_tests': " << error << std::endl;
+            }
+        }
+    }
+
+
+    // Output results according to provided options
+    if(json_filename != "") {
+        write_json(json_file, results);
+        json_file.close();
+    }
+
+    if(!dry_run) {
+        if(config_file != "") write_results(&results, false, config_file);
+        else write_results(&results, false);
+    }
+    else {
+        std::cout << "Warning: this was a dry-run. Config not generated" << std::endl;
     }
 }
 
+
 void read_results(std::vector<volk_gnsssdr_test_results_t> *results)
 {
     char path[1024];
@@ -237,11 +153,12 @@ void read_results(std::vector<volk_gnsssdr_test_results_t> *results)
 
 void read_results(std::vector<volk_gnsssdr_test_results_t> *results, std::string path)
 {
-    const fs::path config_path(path);
+    struct stat buffer;
+    bool config_status = (stat (path.c_str(), &buffer) == 0);
 
-    if(fs::exists(config_path)) {
+    if( config_status ) {
         // a config exists and we are reading results from it
-        std::ifstream config(config_path.string().c_str());
+        std::ifstream config(path.c_str());
         char config_line[256];
         while(config.getline(config_line, 255)) {
             // tokenize the input line by kernel_name unaligned aligned
@@ -252,23 +169,23 @@ void read_results(std::vector<volk_gnsssdr_test_results_t> *results, std::string
             std::size_t str_size = config_str.size();
             std::size_t found = 1;
 
-            found = config_str.find(" ");
+            found = config_str.find(' ');
             // Split line by spaces
             while(found && found < str_size) {
-                found = config_str.find(" ");
+                    found = config_str.find(' ');
-                // kernel names MUST be less than 128 chars, which is
+                    // kernel names MUST be less than 128 chars, which is
-                // a length restricted by volk_gnsssdr/volk_gnsssdr_prefs.c
+                    // a length restricted by volk/volk_prefs.c
-                // on the last token in the parsed string we won't find a space
+                    // on the last token in the parsed string we won't find a space
-                // so make sure we copy at most 128 chars.
+                    // so make sure we copy at most 128 chars.
-                if(found > 127) {
+                    if(found > 127) {
-                    found = 127;
+                            found = 127;
-                }
+                    }
-                str_size = config_str.size();
+                    str_size = config_str.size();
-                char buffer[128]  = {'\0'};
+                    char buffer[128] = {'\0'};
-                config_str.copy(buffer, found + 1, 0);
+                    config_str.copy(buffer, found + 1, 0);
-                buffer[found] = '\0';
+                    buffer[found] = '\0';
-                single_kernel_result.push_back(std::string(buffer));
+                    single_kernel_result.push_back(std::string(buffer));
-                config_str.erase(0, found+1);
+                    config_str.erase(0, found+1);
             }
 
             if(single_kernel_result.size() == 3) {
@@ -305,17 +222,17 @@ void write_results(const std::vector<volk_gnsssdr_test_results_t> *results, bool
 
     std::ofstream config;
     if(update_result) {
-        std::cout << "Updating " << config_path << "..." << std::endl;
+        std::cout << "Updating " << path << "..." << std::endl;
-        config.open(config_path.string().c_str(), std::ofstream::app);
+        config.open(path.c_str(), std::ofstream::app);
         if (!config.is_open()) { //either we don't have write access or we don't have the dir yet
-            std::cout << "Error opening file " << config_path << std::endl;
+            std::cout << "Error opening file " << path << std::endl;
         }
     }
     else {
-        std::cout << "Writing " << config_path << "..." << std::endl;
+        std::cout << "Writing " << path << "..." << std::endl;
-        config.open(config_path.string().c_str());
+        config.open(path.c_str());
         if (!config.is_open()) { //either we don't have write access or we don't have the dir yet
-            std::cout << "Error opening file " << config_path << std::endl;
+            std::cout << "Error opening file " << path << std::endl;
         }
 
         config << "\

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Modules/CMakeParseArgumentsCopy.cmake

@@ -58,7 +58,7 @@
 # the new option.
 # E.g. my_install(TARGETS foo DESTINATION OPTIONAL) would result in
 # MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION would
-# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
+# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefore.
 
 #=============================================================================
 # Copyright 2010 Alexander Neundorf <neundorf@kde.org>

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Modules/VolkBoost.cmake

@@ -29,8 +29,6 @@ set(__INCLUDED_VOLK_BOOST_CMAKE TRUE)
 set(BOOST_REQUIRED_COMPONENTS
     filesystem
     system
-    unit_test_framework
-    program_options
 )
 
 if(UNIX AND NOT BOOST_ROOT AND EXISTS "/usr/lib64")

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Modules/VolkBuildTypes.cmake

@@ -29,7 +29,7 @@ set(__INCLUDED_VOLK_BUILD_TYPES_CMAKE TRUE)
 #  - RelWithDebInfo: -O3 -g
 #  - MinSizeRel: -Os
 
-# Addtional Build Types, defined below:
+# Additional Build Types, defined below:
 #  - NoOptWithASM: -O0 -g -save-temps
 #  - O2WithASM: -O2 -g -save-temps
 #  - O3WithASM: -O3 -g -save-temps

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/gen/volk_gnsssdr_kernel_defs.py

@@ -138,7 +138,7 @@ class impl_class:
                 arg_type, arg_name = m.groups()
                 self.args.append((arg_type, arg_name))
         except Exception as ex:
-            raise Exception('I cant parse the function prototype from: %s in %s\n%s'%(kern_name, body, ex))
+            raise Exception('I can\'t parse the function prototype from: %s in %s\n%s'%(kern_name, body, ex))
 
         assert self.name
         self.is_aligned = self.name.startswith('a_')

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/volk_gnsssdr_complex.h

@@ -73,6 +73,11 @@ template <typename T> inline T lv_conj(const T &x){
 
 #else /* __cplusplus */
 
+#if __STDC_VERSION__ >= 199901L /* C99 check */
+/* this allows us to conj in lv_conj without the double detour for single-precision floats */
+#include <tgmath.h>
+#endif /* C99 check */
+
 #include <complex.h>
 
 typedef char complex         lv_8sc_t;
@@ -96,7 +101,9 @@ typedef double complex       lv_64fc_t;
 #define lv_conj(x) (~(x))
 
 // When not available, use the c99 complex function family,
-// which always returns double regardless of the input type.
+// which always returns double regardless of the input type,
+// unless we have C99 and thus tgmath.h overriding functions
+// with type-generic versions.
 #else /* __GNUC__ */
 
 #define lv_creal(x) (creal(x))

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/volk_gnsssdr_malloc.h

@@ -38,7 +38,7 @@ __VOLK_DECL_BEGIN
  * memory that are guaranteed to be on an alignment, VOLK handles this
  * itself. The volk_gnsssdr_malloc function behaves like malloc in that it
  * returns a pointer to the allocated memory. However, it also takes
- * in an alignment specfication, which is usually something like 16 or
+ * in an alignment specification, which is usually something like 16 or
  * 32 to ensure that the aligned memory is located on a particular
  * byte boundary for use with SIMD.
  *

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32f_sincos_32fc.h

@@ -148,7 +148,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse4_1(lv_32fc_t* out, const f
     for(;number < num_points; number++)
         {
             float _in = *aPtr++;
-            *bPtr++ = lv_cmake(cos(_in), sin(_in));
+            *bPtr++ = lv_cmake(cosf(_in), sinf(_in));
         }
 }
 
@@ -242,7 +242,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse4_1(lv_32fc_t* out, const f
     for(;number < num_points; number++)
         {
             float _in = *aPtr++;
-            *bPtr++ = lv_cmake(cos(_in), sin(_in));
+            *bPtr++ = lv_cmake(cosf(_in), sinf(_in));
         }
 }
 
@@ -395,7 +395,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse2(lv_32fc_t* out, const flo
     for(number = sse_iters * 4; number < num_points; number++)
         {
             _in = *aPtr++;
-            *bPtr++ = lv_cmake((float)cos(_in), (float)sin(_in) );
+            *bPtr++ = lv_cmake((float)cosf(_in), (float)sinf(_in) );
         }
 
 }
@@ -548,7 +548,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse2(lv_32fc_t* out, const flo
     for(number = sse_iters * 4; number < num_points; number++)
         {
             _in = *aPtr++;
-            *bPtr++ = lv_cmake((float)cos(_in), (float)sin(_in) );
+            *bPtr++ = lv_cmake((float)cosf(_in), (float)sinf(_in) );
         }
 
 }
@@ -564,7 +564,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_generic(lv_32fc_t* out, const fl
     for(i = 0; i < num_points; i++)
         {
             _in = *in++;
-            *out++ = lv_cmake((float)cos(_in), (float)sin(_in) );
+            *out++ = lv_cmake((float)cosf(_in), (float)sinf(_in) );
         }
 }
 
@@ -709,7 +709,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_neon(lv_32fc_t* out, const float
     for(number = neon_iters * 4; number < num_points; number++)
         {
             _in = *aPtr++;
-            *bPtr++ = lv_cmake((float)cos(_in), (float)sin(_in) );
+            *bPtr++ = lv_cmake((float)cosf(_in), (float)sinf(_in) );
         }
 }
 

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_s32f_sincos_32fc.h

@@ -214,7 +214,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_sse2(lv_32fc_t* out, const fl
     _phase = _phase + phase_inc * (sse_iters * 4);
     for(number = sse_iters * 4; number < num_points; number++)
         {
-            *bPtr++ = lv_cmake((float)cos((_phase)), (float)sin((_phase)) );
+            *bPtr++ = lv_cmake((float)cosf((_phase)), (float)sinf((_phase)) );
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -371,7 +371,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_sse2(lv_32fc_t* out, const fl
     _phase = _phase + phase_inc * (sse_iters * 4);
     for(number = sse_iters * 4; number < num_points; number++)
         {
-            *bPtr++ = lv_cmake((float)cos(_phase), (float)sin(_phase) );
+            *bPtr++ = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -388,7 +388,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_generic(lv_32fc_t* out, const f
     unsigned int i;
     for(i = 0; i < num_points; i++)
         {
-            *out++ = lv_cmake((float)cos(_phase), (float)sin(_phase) );
+            *out++ = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -596,7 +596,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_avx2(lv_32fc_t* out, const fl
     _phase = _phase + phase_inc * (avx_iters * 8);
     for(number = avx_iters * 8; number < num_points; number++)
         {
-            out[number] = lv_cmake((float)cos(_phase), (float)sin(_phase) );
+            out[number] = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -764,7 +764,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_avx2(lv_32fc_t* out, const fl
     _phase = _phase + phase_inc * (avx_iters * 8);
     for(number = avx_iters * 8; number < num_points; number++)
         {
-            out[number] = lv_cmake((float)cos(_phase), (float)sin(_phase) );
+            out[number] = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -880,7 +880,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_neon(lv_32fc_t* out, const floa
     _phase = _phase + phase_inc * (neon_iters * 4);
     for(number = neon_iters * 4; number < num_points; number++)
         {
-            *bPtr++ = lv_cmake((float)cos(_phase), (float)sin(_phase) );
+            *bPtr++ = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
             _phase += phase_inc;
         }
     (*phase) = _phase;

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h

@@ -30,7 +30,6 @@
 
 #include "qa_utils.h"
 #include <vector>
-#include <boost/assign/list_of.hpp>
 #include <volk_gnsssdr/volk_gnsssdr.h>
 
 
@@ -47,6 +46,8 @@
     volk_gnsssdr_test_case_t(func##_get_func_desc(), (void(*)())func##_manual, std::string(#func),\
     test_params)
 
+#define QA(test) test_cases.push_back(test);
+
 std::vector<volk_gnsssdr_test_case_t> init_test_list(volk_gnsssdr_test_params_t test_params)
 {
 
@@ -64,41 +65,41 @@ std::vector<volk_gnsssdr_test_case_t> init_test_list(volk_gnsssdr_test_params_t
     volk_gnsssdr_test_params_t test_params_inacc2 = volk_gnsssdr_test_params_t(2e-1, test_params.scalar(),
                 test_params.vlen(), test_params.iter(), test_params.benchmark_mode(), test_params.kernel_regex());
 
-    std::vector<volk_gnsssdr_test_case_t> test_cases = boost::assign::list_of
+    std::vector<volk_gnsssdr_test_case_t> test_cases;
 
-        (VOLK_INIT_TEST(volk_gnsssdr_8i_accumulator_s8i, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8i_accumulator_s8i, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_8i_index_max_16u, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8i_index_max_16u, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_8i_max_s8i, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8i_max_s8i, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_8i_x2_add_8i, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8i_x2_add_8i, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_8ic_conjugate_8ic, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8ic_conjugate_8ic, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_8ic_magnitude_squared_8i, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8ic_magnitude_squared_8i, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_8ic_x2_dot_prod_8ic, test_params))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8ic_x2_dot_prod_8ic, test_params))
-        (VOLK_INIT_TEST(volk_gnsssdr_8ic_x2_multiply_8ic, test_params))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8ic_x2_multiply_8ic, test_params))
-        (VOLK_INIT_TEST(volk_gnsssdr_8ic_s8ic_multiply_8ic, test_params))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8ic_s8ic_multiply_8ic, test_params))
-        (VOLK_INIT_TEST(volk_gnsssdr_8u_x2_multiply_8u, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_8u_x2_multiply_8u, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_64f_accumulator_64f, test_params))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_64f_accumulator_64f, test_params))
-        (VOLK_INIT_TEST(volk_gnsssdr_32f_sincos_32fc, test_params_inacc))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_32f_sincos_32fc, test_params_inacc))
-        (VOLK_INIT_TEST(volk_gnsssdr_32f_index_max_32u, test_params))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_32f_index_max_32u, test_params))
-        (VOLK_INIT_TEST(volk_gnsssdr_32fc_convert_8ic, test_params))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_32fc_convert_8ic, test_params))
-        (VOLK_INIT_TEST(volk_gnsssdr_32fc_convert_16ic, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_32fc_convert_16ic, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_16ic_x2_dot_prod_16ic, test_params))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_16ic_x2_dot_prod_16ic, test_params))
-        (VOLK_INIT_TEST(volk_gnsssdr_16ic_x2_multiply_16ic, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_16ic_x2_multiply_16ic, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_16ic_convert_32fc, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_16ic_convert_32fc, test_params_more_iters))
-        (VOLK_INIT_TEST(volk_gnsssdr_16ic_conjugate_16ic, test_params_more_iters))
+    QA(VOLK_INIT_TEST(volk_gnsssdr_16ic_conjugate_16ic, test_params_more_iters))
-        (VOLK_INIT_PUPP(volk_gnsssdr_s32f_sincospuppet_32fc, volk_gnsssdr_s32f_sincos_32fc, test_params_inacc2))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_s32f_sincospuppet_32fc, volk_gnsssdr_s32f_sincos_32fc, test_params_inacc2))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_rotatorpuppet_16ic, volk_gnsssdr_16ic_s32fc_x2_rotator_16ic, test_params_int1))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_16ic_rotatorpuppet_16ic, volk_gnsssdr_16ic_s32fc_x2_rotator_16ic, test_params_int1))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerfastpuppet_16ic, volk_gnsssdr_16ic_resampler_fast_16ic, test_params))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerfastpuppet_16ic, volk_gnsssdr_16ic_resampler_fast_16ic, test_params))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerfastxnpuppet_16ic, volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn, test_params))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerfastxnpuppet_16ic, volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn, test_params))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerxnpuppet_16ic, volk_gnsssdr_16ic_xn_resampler_16ic_xn, test_params))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerxnpuppet_16ic, volk_gnsssdr_16ic_xn_resampler_16ic_xn, test_params))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16i_resamplerxnpuppet_16i, volk_gnsssdr_16i_xn_resampler_16i_xn, test_params))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_16i_resamplerxnpuppet_16i, volk_gnsssdr_16i_xn_resampler_16i_xn, test_params))
-        (VOLK_INIT_PUPP(volk_gnsssdr_32fc_resamplerxnpuppet_32fc, volk_gnsssdr_32fc_xn_resampler_32fc_xn, test_params))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_32fc_resamplerxnpuppet_32fc, volk_gnsssdr_32fc_xn_resampler_32fc_xn, test_params))
-        (VOLK_INIT_PUPP(volk_gnsssdr_32f_resamplerxnpuppet_32f, volk_gnsssdr_32f_xn_resampler_32f_xn, test_params))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_32f_resamplerxnpuppet_32f, volk_gnsssdr_32f_xn_resampler_32f_xn, test_params))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_dot_prod_16ic_xn, test_params))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_dot_prod_16ic_xn, test_params))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn, test_params_int16))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn, test_params_int16))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn, test_params_int16))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn, test_params_int16))
-        (VOLK_INIT_PUPP(volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc, volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn, test_params_int1))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc, volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn, test_params_int1))
-        (VOLK_INIT_PUPP(volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc, volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn, test_params_int1))
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc, volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn, test_params_int1))
-        ;
+    ;
 
     return test_cases;
 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.h

@@ -76,6 +76,13 @@ class volk_gnsssdr_test_params_t {
                            bool benchmark_mode, std::string kernel_regex) :
             _tol(tol), _scalar(scalar), _vlen(vlen), _iter(iter),
             _benchmark_mode(benchmark_mode), _kernel_regex(kernel_regex) {};
+        // setters
+        void set_tol(float tol) {_tol=tol;};
+        void set_scalar(lv_32fc_t scalar) {_scalar=scalar;};
+        void set_vlen(unsigned int vlen) {_vlen=vlen;};
+        void set_iter(unsigned int iter) {_iter=iter;};
+        void set_benchmark(bool benchmark) {_benchmark_mode=benchmark;};
+        void set_regex(std::string regex) {_kernel_regex=regex;};
         // getters
         float tol() {return _tol;};
         lv_32fc_t scalar() {return _scalar;};

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/volk_gnsssdr_malloc.c

@@ -50,7 +50,7 @@ void *volk_gnsssdr_malloc(size_t size, size_t alignment)
     else
         {
             fprintf(stderr,
-                    "VOLK: Error allocating memory "
+                    "VOLK_GNSSSDR: Error allocating memory "
                     "(posix_memalign: error %d: %s)\n", err, strerror(err));
             return NULL;
         }
@@ -70,7 +70,7 @@ void *volk_gnsssdr_malloc(size_t size, size_t alignment)
     void *ptr = _aligned_malloc(size, alignment);
     if(ptr == NULL)
         {
-            fprintf(stderr, "VOLK: Error allocating memory (_aligned_malloc)\n");
+            fprintf(stderr, "VOLK_GNSSSDR: Error allocating memory (_aligned_malloc)\n");
         }
     return ptr;
 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr.tmpl.h

@@ -82,7 +82,7 @@ extern VOLK_API ${kern.pname} ${kern.name}_u;
 //! Call into a specific implementation given by name
 extern VOLK_API void ${kern.name}_manual(${kern.arglist_full}, const char* impl_name);
 
-//! Get description paramaters for this kernel
+//! Get description parameters for this kernel
 extern VOLK_API volk_gnsssdr_func_desc_t ${kern.name}_get_func_desc(void);
 %endfor