Merge pull request #799 from mkstoyanov/more_cpp17_features

* added usage of std::string_view
* better initialization of many structures
* replaced old make-unique and switch many unique_ptr to optional

Author: mkstoyanov

SparseGrids/TasmanianSparseGrid.cpp

@@ -72,10 +72,10 @@ bool TasmanianSparseGrid::isDpcppEnabled(){
     #endif
 }
 
-TasmanianSparseGrid::TasmanianSparseGrid() : acceleration(std::make_unique<AccelerationContext>()), using_dynamic_construction(false){}
+TasmanianSparseGrid::TasmanianSparseGrid() : acceleration(std::make_unique<AccelerationContext>()){}
 
 TasmanianSparseGrid::TasmanianSparseGrid(const TasmanianSparseGrid &source) :
-        acceleration(std::make_unique<AccelerationContext>()), using_dynamic_construction(false){
+        acceleration(std::make_unique<AccelerationContext>()){
     copyGrid(&source);
 }
 
@@ -160,7 +160,6 @@ void TasmanianSparseGrid::makeGlobalGrid(int dimensions, int outputs, int depth,
     clear();
     llimits = level_limits;
     base = GridGlobal(acceleration.get(), dimensions, outputs, depth, type, rule, anisotropic_weights, alpha, beta, custom_filename, llimits);
-    //base = Utils::make_unique<GridGlobal>(acceleration.get(), dimensions, outputs, depth, type, rule, anisotropic_weights, alpha, beta, custom_filename, llimits);
 }
 void TasmanianSparseGrid::makeGlobalGrid(int dimensions, int outputs, int depth, TypeDepth type, CustomTabulated &&crule,
                                          const int *anisotropic_weights, const int *level_limits){
@@ -191,7 +190,7 @@ void TasmanianSparseGrid::makeSequenceGrid(int dimensions, int outputs, int dept
     if (outputs < 0) throw std::invalid_argument("ERROR: makeSequenceGrid() requires non-negative outputs");
     if (depth < 0) throw std::invalid_argument("ERROR: makeSequenceGrid() requires non-negative depth");
     if (!OneDimensionalMeta::isSequence(rule)){
-        std::string message = "ERROR: makeSequenceGrid() is called with rule: " + IO::getRuleString(rule) + ", which is not a sequence rule";
+        std::string message = "ERROR: makeSequenceGrid() is called with rule: " + std::string(IO::getRuleString(rule)) + ", which is not a sequence rule";
         throw std::invalid_argument(message);
     }
     size_t expected_aw_size = (OneDimensionalMeta::isTypeCurved(type)) ? 2*dimensions : dimensions;
@@ -217,7 +216,7 @@ void TasmanianSparseGrid::makeLocalPolynomialGrid(int dimensions, int outputs, i
         throw std::invalid_argument(message);
     }
     if (!OneDimensionalMeta::isLocalPolynomial(rule)){
-        std::string message = "ERROR: makeLocalPolynomialGrid() is called with rule: " + IO::getRuleString(rule) + ", which is not a local polynomial rule";
+        std::string message = "ERROR: makeLocalPolynomialGrid() is called with rule: " + std::string(IO::getRuleString(rule)) + ", which is not a local polynomial rule";
         throw std::invalid_argument(message);
     }
     if ((!level_limits.empty()) && (level_limits.size() != (size_t) dimensions)) throw std::invalid_argument("ERROR: makeLocalPolynomialGrid() requires level_limits with either 0 or dimensions entries");

SparseGrids/TasmanianSparseGrid.hpp

@@ -2269,7 +2269,7 @@ class TasmanianSparseGrid{
     // must not invalidate aliases when the grid is moved, must be destroyed last for sycl
     std::unique_ptr<AccelerationContext> acceleration;
 
-    // contains all possible sparse grids with a null-grid (int) as the default
+    // contains all possible sparse grids with a null-grid std::monostate as the default
     using grid_variant = std::variant<std::monostate,
                                       GridGlobal,           // index 1
                                       GridSequence,         // index 2
@@ -2283,7 +2283,7 @@ class TasmanianSparseGrid{
     std::vector<int> conformal_asin_power;
     std::vector<int> llimits;
 
-    bool using_dynamic_construction;
+    bool using_dynamic_construction = false;
 
     mutable AccelerationDomainTransform acc_domain;
 };

SparseGrids/TasmanianSparseGridWrapC.cpp

@@ -31,6 +31,8 @@
 #ifndef __TASMANIAN_SPARSE_GRID_WRAPC_CPP
 #define __TASMANIAN_SPARSE_GRID_WRAPC_CPP
 
+#include <cstdlib>
+
 #include "TasmanianSparseGrid.hpp"
 
 // ------------ C Interface for use with Python ctypes and potentially other C codes -------------- //
@@ -149,18 +151,22 @@ int tsgGetOrder(void *grid){ return ((TasmanianSparseGrid*) grid)->getOrder(); }
 int tsgGetNumDimensions(void *grid){ return ((TasmanianSparseGrid*) grid)->getNumDimensions(); }
 int tsgGetNumOutputs(void *grid){ return ((TasmanianSparseGrid*) grid)->getNumOutputs(); }
 char* tsgGetRule(void *grid){
-    std::string cppstring = IO::getRuleString( ((TasmanianSparseGrid*) grid)->getRule() );
-    char *cstring = new char[cppstring.size() + 1];
-    for(size_t i=0; i<cppstring.size(); i++) cstring[i] = cppstring[i];
+    std::string_view cppstring = IO::getRuleString( ((TasmanianSparseGrid*) grid)->getRule() );
+    char *cstring = (char*) malloc((cppstring.size() + 1) * sizeof(char));
+    std::copy_n(cppstring.begin(), cppstring.size(), cstring);
     cstring[cppstring.size()] = '\0';
     return cstring;
 }
-void tsgCopyRuleChars(void *grid, int buffer_size, char *name, int *num_actual){
-    std::string cppstring = IO::getRuleString( ((TasmanianSparseGrid*) grid)->getRule() );
-    size_t max_num = std::min((size_t) buffer_size - 1, cppstring.size());
+void tsgCopyRuleChars(void *grid, size_t buffer_size, char *name, size_t *num_actual){
+    if (buffer_size == 0) {
+        *num_actual = 0;
+        return;
+    }
+    std::string_view cppstring = IO::getRuleString( ((TasmanianSparseGrid*) grid)->getRule() );
+    size_t max_num = std::min(buffer_size - 1, cppstring.size());
     std::copy_n(cppstring.begin(), max_num, name);
     name[max_num] = '\0';
-    *num_actual = (int) max_num;
+    *num_actual = max_num;
 }
 const char* tsgGetCustomRuleDescription(void *grid){ return ((TasmanianSparseGrid*) grid)->getCustomRuleDescription(); }
 

SparseGrids/tsgAcceleratedDataStructures.hpp

@@ -117,9 +117,9 @@ class GpuVector{
     }
 
     //! \brief Default constructor, creates an empty (null) array.
-    GpuVector() : num_entries(0), gpu_data(nullptr){}
+    GpuVector() = default;
     //! \brief Construct a vector with \b count number of entries.
-    GpuVector(AccelerationContext const *acc, size_t count) : num_entries(0), gpu_data(nullptr){ resize(acc, count); }
+    GpuVector(AccelerationContext const *acc, size_t count){ resize(acc, count); }
 
     /*!
      * \brief Same as \b GpuVector(dim1 * dim2), but guards against overflow.
@@ -129,11 +129,11 @@ class GpuVector{
      * and both integers are converted to size_t before multiplication which prevents overflow.
      * Note: the dimensions \b will \b not be stored, the underlying data is still one dimensional.
      */
-    GpuVector(AccelerationContext const *acc, int dim1, int dim2) : num_entries(0), gpu_data(nullptr){ resize(acc, Utils::size_mult(dim1, dim2)); }
+    GpuVector(AccelerationContext const *acc, int dim1, int dim2){ resize(acc, Utils::size_mult(dim1, dim2)); }
     //! \brief Create a vector with size that matches \b cpu_data and copy the data to the GPU device.
-    GpuVector(AccelerationContext const *acc, const std::vector<T> &cpu_data) : num_entries(0), gpu_data(nullptr){ load(acc, cpu_data); }
+    GpuVector(AccelerationContext const *acc, const std::vector<T> &cpu_data){ load(acc, cpu_data); }
     //! \brief Construct a vector and load with date provided on to the cpu.
-    GpuVector(AccelerationContext const *acc, int dim1, int dim2, T const *cpu_data) : num_entries(0), gpu_data(nullptr){ load(acc, Utils::size_mult(dim1, dim2), cpu_data); }
+    GpuVector(AccelerationContext const *acc, int dim1, int dim2, T const *cpu_data){ load(acc, Utils::size_mult(dim1, dim2), cpu_data); }
     //! \brief Construct a vector by loading from a given range.
     template<typename IteratorLike>
     GpuVector(AccelerationContext const *acc, IteratorLike ibegin, IteratorLike iend) : GpuVector(){
@@ -222,10 +222,10 @@ class GpuVector{
      */
     void load_internal(AccelerationContext const *acc, size_t count, const T* cpu_data);
 
-    size_t num_entries; // keep track of the size, update on every call that changes the gpu_data
-    T *gpu_data; // the GPU array
+    size_t num_entries = 0; // keep track of the size, update on every call that changes the gpu_data
+    T *gpu_data = nullptr; // the GPU array
     #ifdef Tasmanian_ENABLE_DPCPP
-    void* sycl_queue;
+    void* sycl_queue = nullptr;
     #endif
 };
 
@@ -779,7 +779,7 @@ struct AccelerationContext{
  */
 struct InternalSyclQueue{
     //! \brief Default constructor, assume we are not in a testing mode.
-    InternalSyclQueue() : use_testing(false){}
+    InternalSyclQueue() = default;
     //! \brief Initialize the testing, in which case the internal queue would be used in place of a new queue.
     void init_testing(int gpuid);
     //! \brief Auto-converts to a non-owning std::unique_ptr.
@@ -788,7 +788,7 @@ struct InternalSyclQueue{
                                                                          HandleDeleter<AccHandle::Syclqueue>(false));
     }
     //! \brief Indicates whether this is a testing run.
-    bool use_testing;
+    bool use_testing = false;
     //! \brief Holds the internal sycl::queue for testing.
     std::unique_ptr<int, HandleDeleter<AccHandle::Syclqueue>> test_queue;
 };

SparseGrids/tsgEnumerates.hpp

@@ -53,6 +53,7 @@
 #include <optional>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 #include <variant>

SparseGrids/tsgGridFourier.cpp

@@ -87,7 +87,7 @@ GridFourier::GridFourier(AccelerationContext const *acc, GridFourier const *four
     max_power(fourier->max_power){
 
     if (fourier->dynamic_values){
-        dynamic_values = Utils::make_unique<DynamicConstructorDataGlobal>(*fourier->dynamic_values);
+        dynamic_values = std::make_unique<DynamicConstructorDataGlobal>(*fourier->dynamic_values);
         if (num_outputs != fourier->num_outputs) dynamic_values->restrictData(ibegin, iend);
     }
 }
@@ -633,7 +633,7 @@ void GridFourier::evaluateHierarchicalFunctionsInternalGPU(const T gpu_x[], int
 }
 template<typename T> void GridFourier::loadGpuNodes() const{
     auto& ccache = getGpuCache<T>();
-    if (!ccache) ccache = Utils::make_unique<CudaFourierData<T>>();
+    if (!ccache) ccache = CudaFourierData<T>{};
     if (!ccache->num_nodes.empty()) return;
 
     std::vector<int> num_nodes(num_dimensions);
@@ -660,7 +660,7 @@ void GridFourier::clearGpuNodes() const{
 }
 template<typename T> void GridFourier::loadGpuCoefficients() const{
     auto& ccache = getGpuCache<T>();
-    if (!ccache) ccache = Utils::make_unique<CudaFourierData<T>>();
+    if (!ccache) ccache = CudaFourierData<T>{};
     if (!ccache->real.empty()) return;
     int num_points = points.getNumIndexes();
     size_t num_coeff = Utils::size_mult(num_outputs, num_points);
@@ -850,7 +850,7 @@ void GridFourier::mergeRefinement(){
 }
 
 void GridFourier::beginConstruction(){
-    dynamic_values = Utils::make_unique<DynamicConstructorDataGlobal>(num_dimensions, num_outputs);
+    dynamic_values = std::make_unique<DynamicConstructorDataGlobal>(num_dimensions, num_outputs);
     if (points.empty()){ // if we start dynamic construction from an empty grid
         for(int i=0; i<tensors.getNumIndexes(); i++){
             const int *t = tensors.getIndex(i);
@@ -869,9 +869,9 @@ void GridFourier::writeConstructionData(std::ostream &os, bool iomode) const{
 }
 void GridFourier::readConstructionData(std::istream &is, bool iomode){
     if (iomode == mode_ascii)
-        dynamic_values = Utils::make_unique<DynamicConstructorDataGlobal>(is, num_dimensions, num_outputs, IO::mode_ascii_type());
+        dynamic_values = std::make_unique<DynamicConstructorDataGlobal>(is, num_dimensions, num_outputs, IO::mode_ascii_type());
     else
-        dynamic_values = Utils::make_unique<DynamicConstructorDataGlobal>(is, num_dimensions, num_outputs, IO::mode_binary_type());
+        dynamic_values = std::make_unique<DynamicConstructorDataGlobal>(is, num_dimensions, num_outputs, IO::mode_binary_type());
     int max_level = dynamic_values->getMaxTensor();
     if (max_level + 1 > wrapper.getNumLevels())
         wrapper = OneDimensionalWrapper(max_level, rule_fourier, 0.0, 0.0);

SparseGrids/tsgGridFourier.hpp

@@ -36,7 +36,7 @@
 namespace TasGrid{
 
 #ifndef __TASMANIAN_DOXYGEN_SKIP
-class GridFourier : public BaseCanonicalGrid {
+class GridFourier final : public BaseCanonicalGrid {
 public:
     GridFourier(AccelerationContext const *acc) : BaseCanonicalGrid(acc){};
     friend struct GridReaderVersion5<GridFourier>;
@@ -181,27 +181,21 @@ class GridFourier : public BaseCanonicalGrid {
 
     std::vector<int> max_power;
 
-    std::unique_ptr<DynamicConstructorDataGlobal> dynamic_values;
-
     template<typename T> void loadGpuNodes() const;
     template<typename T> void loadGpuCoefficients() const;
-    inline std::unique_ptr<CudaFourierData<double>>& getGpuCacheOverload(double) const{ return gpu_cache; }
-    inline std::unique_ptr<CudaFourierData<float>>& getGpuCacheOverload(float) const{ return gpu_cachef; }
-    template<typename T> inline std::unique_ptr<CudaFourierData<T>>& getGpuCache() const{
+    inline std::optional<CudaFourierData<double>>& getGpuCacheOverload(double) const{ return gpu_cache; }
+    inline std::optional<CudaFourierData<float>>& getGpuCacheOverload(float) const{ return gpu_cachef; }
+    template<typename T> inline std::optional<CudaFourierData<T>>& getGpuCache() const{
         return getGpuCacheOverload(static_cast<T>(0.0));
     }
-    mutable std::unique_ptr<CudaFourierData<double>> gpu_cache;
-    mutable std::unique_ptr<CudaFourierData<float>> gpu_cachef;
+    mutable std::optional<CudaFourierData<double>> gpu_cache;
+    mutable std::optional<CudaFourierData<float>> gpu_cachef;
+
+    std::unique_ptr<DynamicConstructorDataGlobal> dynamic_values;
 };
 
 // Old version reader
 template<> struct GridReaderVersion5<GridFourier>{
-    template<typename iomode> static std::unique_ptr<GridFourier> read(AccelerationContext const *acc, std::istream &is){
-        std::unique_ptr<GridFourier> grid = Utils::make_unique<GridFourier>(acc);
-        read<iomode>(is, grid.get());
-        return grid;
-    }
-
     template<typename iomode> static void read(std::istream &is, GridFourier *grid) {
         grid->num_dimensions = IO::readNumber<iomode, int>(is);
         grid->num_outputs = IO::readNumber<iomode, int>(is);

SparseGrids/tsgGridGlobal.cpp

@@ -140,7 +140,7 @@ GridGlobal::GridGlobal(AccelerationContext const *acc, GridGlobal const *global,
     custom((global->rule == rule_customtabulated) ? global->custom : CustomTabulated()){
 
     if (global->dynamic_values){
-        dynamic_values = Utils::make_unique<DynamicConstructorDataGlobal>(*global->dynamic_values);
+        dynamic_values = std::make_unique<DynamicConstructorDataGlobal>(*global->dynamic_values);
         if (num_outputs != global->num_outputs) dynamic_values->restrictData(ibegin, iend);
     }
 }
@@ -353,7 +353,7 @@ void GridGlobal::mergeRefinement(){
 }
 
 void GridGlobal::beginConstruction(){
-    dynamic_values = Utils::make_unique<DynamicConstructorDataGlobal>(num_dimensions, num_outputs);
+    dynamic_values = std::make_unique<DynamicConstructorDataGlobal>(num_dimensions, num_outputs);
     if (points.empty()){ // if we start dynamic construction from an empty grid
         for(int i=0; i<tensors.getNumIndexes(); i++){
             const int *t = tensors.getIndex(i);
@@ -372,9 +372,9 @@ void GridGlobal::writeConstructionData(std::ostream &os, bool iomode) const{
 }
 void GridGlobal::readConstructionData(std::istream &is, bool iomode){
     if (iomode == mode_ascii)
-        dynamic_values = Utils::make_unique<DynamicConstructorDataGlobal>(is, num_dimensions, num_outputs, IO::mode_ascii_type());
+        dynamic_values = std::make_unique<DynamicConstructorDataGlobal>(is, num_dimensions, num_outputs, IO::mode_ascii_type());
     else
-        dynamic_values = Utils::make_unique<DynamicConstructorDataGlobal>(is, num_dimensions, num_outputs, IO::mode_binary_type());
+        dynamic_values = std::make_unique<DynamicConstructorDataGlobal>(is, num_dimensions, num_outputs, IO::mode_binary_type());
     int max_level = dynamic_values->getMaxTensor();
     if (max_level + 1 > wrapper.getNumLevels())
         wrapper = OneDimensionalWrapper(custom, max_level, rule, alpha, beta);
@@ -622,13 +622,13 @@ void GridGlobal::evaluateHierarchicalFunctionsGPU(const float gpu_x[], int cpu_n
 }
 template<typename T> void GridGlobal::loadGpuValues() const{
     auto& ccache = getGpuCache<T>();
-    if (!ccache) ccache = Utils::make_unique<CudaGlobalData<T>>();
+    if (!ccache) ccache = CudaGlobalData<T>{};
     if (ccache->values.empty()) ccache->values.load(acceleration, values.totalSize(), values.data());
 }
 void GridGlobal::clearGpuValues() const{ if (gpu_cache) gpu_cache->values.clear(); }
 template<typename T> void GridGlobal::loadGpuNodes() const{
     auto& ccache = getGpuCache<T>();
-    if (!ccache) ccache = Utils::make_unique<CudaGlobalData<T>>();
+    if (!ccache) ccache = CudaGlobalData<T>{};
     if (!ccache->nodes.empty()) return; // already loaded
     // data for stage 1 (Lagrange caching)
     ccache->nodes.load(acceleration, (OneDimensionalMeta::isNonNested(rule)) ? wrapper.getAllNodes() : wrapper.getUnique());

SparseGrids/tsgGridGlobal.hpp

@@ -37,7 +37,7 @@
 namespace TasGrid{
 
 #ifndef __TASMANIAN_DOXYGEN_SKIP
-class GridGlobal : public BaseCanonicalGrid{
+class GridGlobal final : public BaseCanonicalGrid{
 public:
     GridGlobal(AccelerationContext const *acc) : BaseCanonicalGrid(acc), rule(rule_none), alpha(0.0), beta(0.0){}
     friend struct GridReaderVersion5<GridGlobal>;
@@ -162,29 +162,22 @@ class GridGlobal : public BaseCanonicalGrid{
 
     CustomTabulated custom;
 
-    std::unique_ptr<DynamicConstructorDataGlobal> dynamic_values;
-
     template<typename T> void loadGpuNodes() const;
     template<typename T> void loadGpuValues() const;
-    inline std::unique_ptr<CudaGlobalData<double>>& getGpuCacheOverload(double) const{ return gpu_cache; }
-    inline std::unique_ptr<CudaGlobalData<float>>& getGpuCacheOverload(float) const{ return gpu_cachef; }
-    template<typename T> inline std::unique_ptr<CudaGlobalData<T>>& getGpuCache() const{
+    inline std::optional<CudaGlobalData<double>>& getGpuCacheOverload(double) const{ return gpu_cache; }
+    inline std::optional<CudaGlobalData<float>>& getGpuCacheOverload(float) const{ return gpu_cachef; }
+    template<typename T> inline std::optional<CudaGlobalData<T>>& getGpuCache() const{
         return getGpuCacheOverload(static_cast<T>(0.0));
     }
-    mutable std::unique_ptr<CudaGlobalData<double>> gpu_cache;
-    mutable std::unique_ptr<CudaGlobalData<float>> gpu_cachef;
+    mutable std::optional<CudaGlobalData<double>> gpu_cache;
+    mutable std::optional<CudaGlobalData<float>> gpu_cachef;
+
+    std::unique_ptr<DynamicConstructorDataGlobal> dynamic_values;
 };
 
 // Old version reader
 template<> struct GridReaderVersion5<GridGlobal>{
-    template<typename iomode> static std::unique_ptr<GridGlobal> read(AccelerationContext const *acc, std::istream &is){
-        std::unique_ptr<GridGlobal> grid = Utils::make_unique<GridGlobal>(acc);
-        read<iomode>(is, grid.get());
-        return grid;
-    }
-
     template<typename iomode> static void read(std::istream &is, GridGlobal *grid) {
-
         grid->num_dimensions = IO::readNumber<iomode, int>(is);
         grid->num_outputs = IO::readNumber<iomode, int>(is);
         grid->alpha = IO::readNumber<iomode, double>(is);