Cpp17

.travis.yml

@@ -65,7 +65,7 @@ jobs:
             - choco install visualstudio2019-workload-vctools
           install:
             - mkdir doxygen && cd doxygen
-            - curl https://www.doxygen.nl/files/doxygen-1.8.20.windows.x64.bin.zip -o doxygen.zip
+            - curl https://www.doxygen.nl/files/doxygen-1.9.1.windows.x64.bin.zip -o doxygen.zip
             - unzip doxygen.zip
             - export PATH=$PATH:$PWD
             - cd ..

CMakeLists.txt

@@ -81,7 +81,7 @@ if (MSVC)
     install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> CONFIGURATIONS "Debug" "RelWithDebInfo" DESTINATION "${CMAKE_INSTALL_BINDIR}")
 else ()
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -pg -O0 --coverage -ftest-coverage -fprofile-arcs")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}  -O2 -DNDEBUG -fno-rtti -flto")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}  -O2 -DNDEBUG -fno-rtti -flto=auto")
     message(STATUS "Using Link Time Optimization (-flto) on GNU platforms.")
     if (${CMAKE_GENERATOR} MATCHES "MinGW Makefiles")
         # To prevent a redefinition conflict
@@ -140,8 +140,8 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_C_EXTENSIONS OFF)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-# Setting C++ standard to C++11
-set(CMAKE_CXX_STANDARD 11)
+# Setting C++ standard to C++17
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # We use

libspider/api/debug-api.cpp

@@ -87,6 +87,8 @@ void spider::api::enableLogger(log::Type type) {
         case log::Type::EXPR:
             log::enable<log::EXPR>();
             break;
+        default:
+            printer::fprintf(stderr, "Unsupported logger enum type.\n");
     }
 }
 
@@ -116,6 +118,8 @@ void spider::api::disableLogger(log::Type type) {
         case log::Type::EXPR:
             log::disable<log::EXPR>();
             break;
+        default:
+            printer::fprintf(stderr, "Unsupported logger enum type.\n");
     }
 }
 

libspider/api/global-api.h

@@ -41,6 +41,7 @@
 #include <cstddef>
 #include <array>
 #include <functional>
+#include <memory>
 
 /* === non-namespace Enumeration(s) === */
 
@@ -288,10 +289,7 @@ namespace spider {
         return nameArray;
     }
 
-    inline std::array<Stack *, STACK_COUNT> &stackArray() {
-        static std::array<Stack *, STACK_COUNT> stackArray = {{ nullptr }};
-        return stackArray;
-    }
+    std::array<std::unique_ptr<Stack>, STACK_COUNT> &stackArray();
 
     /* === Type definition(s) === */
 

libspider/api/spider.cpp

@@ -116,6 +116,11 @@ static void printConfig(const spider::StartUpConfig &cfg) {
 
 /* === Function(s) definition === */
 
+std::array<std::unique_ptr<spider::Stack>, STACK_COUNT> &spider::stackArray() {
+    static std::array<std::unique_ptr<spider::Stack>, STACK_COUNT> stackArray = {{ nullptr }};
+    return stackArray;
+}
+
 spider::StartUpConfig spider::parseInputArguments(int32_t argc, char **argv) {
     spider::log::info("parsing of input arguments is not yet supported.\n");
     for (auto i = 0; i < argc; ++i) {
@@ -129,7 +134,7 @@ void spider::api::setStackAllocatorPolicy(StackID stackId,
                                           size_t alignment,
                                           size_t size,
                                           void *externBuffer) {
-    auto *stack = stackArray()[static_cast<size_t>(stackId)];
+    auto &stack = stackArray()[static_cast<size_t>(stackId)];
     switch (policy) {
         case AllocatorPolicy::FREELIST_FIND_FIRST:
             stack->setPolicy(new FreeListAllocatorPolicy(size, externBuffer, FreeListPolicy::FIND_FIRST, alignment));
@@ -143,6 +148,8 @@ void spider::api::setStackAllocatorPolicy(StackID stackId,
         case AllocatorPolicy::LINEAR_STATIC:
             stack->setPolicy(new LinearStaticAllocator(size, externBuffer, alignment));
             break;
+        default:
+            throwSpiderException("unsupported AllocatorPolicy value.");
     }
 }
 
@@ -161,7 +168,7 @@ void spider::start(const StartUpConfig &cfg) {
     /* == Initialize stacks == */
     auto it = EnumIterator<StackID>{ }.begin();
     for (auto &stack : stackArray()) {
-        stack = new Stack(*(it++));
+        stack = std::unique_ptr<Stack>(new Stack(*(it++)));
     }
     if (cfg.generalStackAllocatorPolicy_ != AllocatorPolicy::GENERIC) {
         api::setStackAllocatorPolicy(StackID::GENERAL,
@@ -296,7 +303,6 @@ void spider::quit() {
             totalAverage += stack->average();
             totalPeak += stack->peak();
         }
-        delete stack;
     }
     Stack::print("Total", totalPeak, totalAverage, 1, totalUsage);
 

libspider/archi/Cluster.cpp

@@ -37,7 +37,7 @@
 #include <archi/Cluster.h>
 #include <archi/Platform.h>
 #include <archi/MemoryInterface.h>
-#include <containers/array_handle.h>
+#include <containers/array_view.h>
 
 /* === Static variable(s) === */
 
@@ -48,14 +48,14 @@
 spider::Cluster::Cluster(size_t PECount, MemoryInterface *memoryInterface) :
         memoryInterface_{ memoryInterface } {
     PEArray_ = allocate<PE *, StackID::ARCHI>(PECount);
-    make_handle(PEArray_, PECount).assign(nullptr);
+    make_view(PEArray_, PECount).assign(nullptr);
     if (!memoryInterface) {
         throwSpiderException("nullptr MemoryInterface");
     }
 }
 
 spider::Cluster::~Cluster() {
-    for (auto &pe : make_handle(PEArray_, PECount_)) {
+    for (auto &pe : make_view(PEArray_, PECount_)) {
         destroy(pe);
     }
     destroy(PEArray_);
@@ -66,7 +66,7 @@ void spider::Cluster::addPE(PE *pe) {
     if (!pe) {
         return;
     }
-    make_handle(PEArray_, PECount_ + 1).at(PECount_) = pe;
+    make_view(PEArray_, PECount_ + 1).at(PECount_) = pe;
     PECount_++; /* = In case at throws, PECount is not change = */
     LRTCount_ += pe->isLRT();
     if (platform()) {

libspider/archi/Cluster.h

@@ -42,7 +42,7 @@
 #include <archi/PE.h>
 #include <common/Types.h>
 #include <containers/array.h>
-#include <containers/array_handle.h>
+#include <containers/array_view.h>
 
 namespace spider {
 
@@ -79,7 +79,7 @@ namespace spider {
          * @throws std::out_of_range if PE ix is out of bound.
          */
         inline void setPEStatus(size_t ix, bool status) {
-            auto handle = make_handle(PEArray_, PECount_);
+            auto handle = make_view(PEArray_, PECount_);
             status ? handle.at(ix)->enable() : handle.at(ix)->disable();
         }
 
@@ -89,8 +89,8 @@ namespace spider {
          * @brief Get the array of processing element of the cluster.
          * @return const reference to the @refitem spider::array of @refitem PE of the cluster.
          */
-        inline array_handle<PE *> peArray() const {
-            return make_handle(PEArray_, PECount_);
+        inline array_view<PE *> peArray() const {
+            return make_view(PEArray_, PECount_);
         }
 
         /**
@@ -108,7 +108,7 @@ namespace spider {
          * @throws @refitem std::out_of_range if ix is out of bound
          */
         inline PE *at(size_t ix) const {
-            return make_handle(PEArray_, PECount_).at(ix);
+            return make_view(PEArray_, PECount_).at(ix);
         }
 
         /**
@@ -148,7 +148,7 @@ namespace spider {
          * @brief Get the platform of the cluster.
          * @return @refitem Platform of the cluster.
          */
-        inline Platform *platform() const {
+        static inline Platform *platform() {
             return archi::platform();
         }
 

libspider/archi/MemoryBus.cpp

@@ -52,8 +52,8 @@
 spider::MemoryBus::MemoryBus() {
     sendCostRoutine_ = [](u64) -> u64 { return 0; };
     receiveCostRoutine_ = [](u64) -> u64 { return 0; };
-    sendRoutine_ = [](i64, const void *, const void *) { };
-    receiveRoutine_ = [](i64, const void *, const void *) { };
+    sendRoutine_ = [](i64, const void *, const void *) { /* = empty method = */ };
+    receiveRoutine_ = [](i64, const void *, const void *) { /* = empty method = */ };
 }
 
 uint64_t spider::MemoryBus::sendCost(uint64_t size) const {

libspider/common/Exception.h

@@ -44,7 +44,7 @@
 /* === Defines === */
 
 /* == Size of 50 minimum is required for the error message associated == */
-#define EXCEPTION_BUFFER_SIZE 400
+constexpr auto EXCEPTION_BUFFER_SIZE = 400;
 
 /* === Macros === */
 
@@ -79,12 +79,12 @@ namespace spider {
                            const char *msg, Args &&...args)
                 : exceptionMessage_{ } {
             /* == Writes exception header == */
-            int n = printer::sprintf(exceptionMessage_, EXCEPTION_BUFFER_SIZE, "%s::%s(%d): ", fileName,
-                                     fctName, lineNumber);
+            int n = printer::snprintf(exceptionMessage_, EXCEPTION_BUFFER_SIZE, "%s::%s(%d): ", fileName,
+                                      fctName, lineNumber);
 
             /* == Write the actual exception message == */
-            n = printer::sprintf(exceptionMessage_ + n, static_cast<size_t>(EXCEPTION_BUFFER_SIZE - n), msg,
-                                 std::forward<Args>(args)...);
+            n = printer::snprintf(exceptionMessage_ + n, static_cast<size_t>(EXCEPTION_BUFFER_SIZE - n), msg,
+                                  std::forward<Args>(args)...);
             if (n > EXCEPTION_BUFFER_SIZE) {
                 printer::fprintf(stderr, "Exception: ERROR: exception message too big.\n");
                 printer::fprintf(stderr, "Partially recovered exception: %s\n", exceptionMessage_);

libspider/common/Logger.h

@@ -49,14 +49,14 @@
 namespace spider {
     namespace log {
 
-        constexpr static const char green[] = "\x1B[32m";
-        constexpr static const char red[] = "\x1B[31m";
-        constexpr static const char yellow[] = "\x1B[33m";
-        constexpr static const char blue[] = "\x1B[34m";
-        constexpr static const char magenta[] = "\x1B[35m";
-        constexpr static const char cyan[] = "\x1B[36m";
-        constexpr static const char white[] = "\x1B[37m";
-        constexpr static const char normal[] = "\x1B[0m";
+        constexpr static auto green = "\x1B[32m";
+        constexpr static auto red = "\x1B[31m";
+        constexpr static auto yellow = "\x1B[33m";
+        constexpr static auto blue = "\x1B[34m";
+        constexpr static auto magenta = "\x1B[35m";
+        constexpr static auto cyan = "\x1B[36m";
+        constexpr static auto white = "\x1B[37m";
+        constexpr static auto normal = "\x1B[0m";
 
         inline std::mutex &mutex() {
             static std::mutex lock;

libspider/common/Printer.cpp

@@ -59,7 +59,7 @@ namespace spider {
             return res;
         }
 
-        int sprintf(char *str, size_t size, const char *format, ...) {
+        int snprintf(char *str, size_t size, const char *format, ...) {
             va_list list;
             va_start(list, format);
             auto res = std::vsnprintf(str, size, format, list);
@@ -79,7 +79,7 @@ namespace spider {
             return std::vfprintf(stream, format, list);
         }
 
-        int sprintf(char *str, size_t size, const char *format, va_list list) {
+        int snprintf(char *str, size_t size, const char *format, va_list list) {
             return std::vsnprintf(str, size, format, list);
         }
 

libspider/common/Printer.h

@@ -48,13 +48,13 @@ namespace spider {
 
         int fprintf(FILE *stream, const char *format, ...);
 
-        int sprintf(char *str, size_t size, const char *format, ...);
+        int snprintf(char *str, size_t size, const char *format, ...);
 
         int printf(const char *format, ...);
 
         int fprintf(FILE *stream, const char *format, va_list list);
 
-        int sprintf(char *str, size_t size, const char *format, va_list list);
+        int snprintf(char *str, size_t size, const char *format, va_list list);
 
         int printf(const char *format, va_list list);
     }

libspider/containers/array.h

@@ -40,7 +40,7 @@
 #include <cstdint>
 #include <vector>
 #include <memory/memory.h>
-#include <containers/array_handle.h>
+#include <containers/array_view.h>
 
 /* === Class definition === */
 
@@ -51,7 +51,7 @@ namespace spider {
      * @tparam T Type of the container content.
      */
     template<typename T>
-    class array : public array_handle<T> {
+    class array : public array_view<T> {
     public:
         using value_type = T;
         using size_type = size_t;
@@ -72,7 +72,7 @@ namespace spider {
          * @param stack  Stack on which the array should be allocated.
          * @param size   Size of the array.
          */
-        explicit array(size_type size, StackID stack = StackID::GENERAL) : array_handle<T>(allocate<T>(stack, size),
+        explicit array(size_type size, StackID stack = StackID::GENERAL) : array_view<T>(allocate<T>(stack, size),
                                                                                            size) { }
 
         /**
@@ -82,36 +82,36 @@ namespace spider {
          * @param value  Value to set to all the elements of the array.
          */
         array(size_t size, const_reference value, StackID stack = StackID::GENERAL) : array(size, stack) {
-            array_handle<T>::assign(value);
+            array_view<T>::assign(value);
         }
 
         array(std::initializer_list<value_type> il, StackID stack = StackID::GENERAL) : array(il.size(), stack) {
-            std::copy(il.begin(), il.end(), array_handle<T>::begin());
+            std::copy(il.begin(), il.end(), array_view<T>::begin());
         }
 
         array() noexcept = default;
 
         array(const array &other) : array(other.size_) {
-            std::copy(other.begin(), other.end(), array_handle<T>::begin());
+            std::copy(other.begin(), other.end(), array_view<T>::begin());
         };
 
         array(array &&other) noexcept: array() {
             swap(*this, other);
         }
 
-        array(T *data, size_type size) : array_handle<T>(data, size) { }
+        array(T *data, size_type size) : array_view<T>(data, size) { }
 
         ~array() {
-            deallocate(array_handle<T>::data_);
+            deallocate(array_view<T>::data_);
         }
 
         /* === Member functions === */
 
         array &operator=(const array &other) {
-            deallocate(array_handle<T>::data_);
-            array_handle<T>::data_ = allocate<T>(other.size_);
-            array_handle<T>::size_ = other.size_;
-            std::copy(other.begin(), other.end(), array_handle<T>::begin());
+            deallocate(array_view<T>::data_);
+            array_view<T>::data_ = allocate<T>(other.size_);
+            array_view<T>::size_ = other.size_;
+            std::copy(other.begin(), other.end(), array_view<T>::begin());
             return *this;
         }
 
@@ -132,7 +132,7 @@ namespace spider {
         inline friend void swap(array<T> &first, array<T> &second) noexcept {
             /* == Do the swapping of the values == */
             using std::swap;
-            swap(static_cast<array_handle<T> &>(first), static_cast<array_handle<T> &>(second));
+            swap(static_cast<array_view<T> &>(first), static_cast<array_view<T> &>(second));
         }
 
         /* === Non member functions === */