[Sonar] fix a first bunch of issues

Author: frs69wq

include/dtlmod/CompressionReductionMethod.hpp

@@ -48,7 +48,7 @@ class CompressionReductionMethod : public ReductionMethod {
     [[nodiscard]] double get_compression_ratio() const { return compression_ratio_; }
     void set_compression_ratio(double ratio) { compression_ratio_ = ratio; }
     [[nodiscard]] const std::string& get_compressor_profile() const { return compressor_profile_; }
-    void set_compressor_profile(const std::string& profile) { compressor_profile_ = profile; }
+    void set_compressor_profile(std::string_view profile) { compressor_profile_ = profile; }
     [[nodiscard]] double get_data_smoothness() const { return data_smoothness_; }
     void set_data_smoothness(double smoothness) { data_smoothness_ = smoothness; }
     [[nodiscard]] double get_ratio_variability() const { return ratio_variability_; }
@@ -64,9 +64,11 @@ class CompressionReductionMethod : public ReductionMethod {
   static double derive_compression_ratio(double accuracy, const std::string& profile, double data_smoothness);
 
 public:
-  CompressionReductionMethod(const std::string& name) : ReductionMethod(name) {}
-  void parameterize_for_variable(const Variable& var, const std::map<std::string, std::string>& parameters) override;
-  void reduce_variable(const Variable& /* var*/) override {}
+  using ReductionMethod::ReductionMethod;
+  void parameterize_for_variable(const Variable& var,
+                                 const std::map<std::string, std::string, std::less<>>& parameters) override;
+  void reduce_variable(const Variable& /* var*/) override
+  { /* Variable metadata are not modfied when using compression */ }
 
   [[nodiscard]] size_t get_reduced_variable_global_size(const Variable& var) const override;
   [[nodiscard]] size_t get_reduced_variable_local_size(const Variable& var) const override;

include/dtlmod/DecimationReductionMethod.hpp

@@ -37,13 +37,13 @@ class DecimationReductionMethod : public ReductionMethod {
     void set_reduced_local_start_and_count(sg4::ActorPtr actor, const std::vector<size_t>& reduced_local_start,
                                            const std::vector<size_t>& reduced_local_count)
     {
-      reduced_local_start_and_count_.try_emplace(actor, std::make_pair(reduced_local_start, reduced_local_count));
+      reduced_local_start_and_count_.try_emplace(actor, reduced_local_start, reduced_local_count);
     }
 
     [[nodiscard]] const std::vector<size_t>& get_stride() const { return stride_; }
     void set_stride(const std::vector<size_t>& stride) { stride_ = stride; }
     [[nodiscard]] const std::string& get_interpolation_method() const { return interpolation_method_; }
-    void set_interpolation_method(const std::string& method) { interpolation_method_ = method; }
+    void set_interpolation_method(std::string_view method) { interpolation_method_ = method; }
     [[nodiscard]] double get_cost_per_element() const { return cost_per_element_; }
     void set_cost_per_element(double cost) { cost_per_element_ = cost; }
 
@@ -59,7 +59,8 @@ class DecimationReductionMethod : public ReductionMethod {
   std::map<const Variable*, std::shared_ptr<ParameterizedDecimation>> per_variable_parameterizations_;
 
 protected:
-  void parameterize_for_variable(const Variable& var, const std::map<std::string, std::string>& parameters) override;
+  void parameterize_for_variable(const Variable& var,
+                                 const std::map<std::string, std::string, std::less<>>& parameters) override;
 
   void reduce_variable(const Variable& var) override;
 
@@ -90,7 +91,7 @@ class DecimationReductionMethod : public ReductionMethod {
   }
 
 public:
-  DecimationReductionMethod(const std::string& name) : ReductionMethod(name) {}
+  using ReductionMethod::ReductionMethod;
 };
 ///\endcond
 } // namespace dtlmod

include/dtlmod/ReductionMethod.hpp

@@ -28,7 +28,8 @@ class ReductionMethod {
   ReductionMethod(const std::string& name) : name_(name) {}
   virtual ~ReductionMethod() = default;
 
-  virtual void parameterize_for_variable(const Variable& var, const std::map<std::string, std::string>& parameters) = 0;
+  virtual void parameterize_for_variable(const Variable& var,
+                                         const std::map<std::string, std::string, std::less<>>& parameters)         = 0;
   virtual void reduce_variable(const Variable& var)                                                                 = 0;
   virtual size_t get_reduced_variable_global_size(const Variable& var) const                                        = 0;
   virtual size_t get_reduced_variable_local_size(const Variable& var) const                                         = 0;

include/dtlmod/Variable.hpp

@@ -126,7 +126,8 @@ class Variable : public std::enable_shared_from_this<Variable> {
   /// @brief Assign a parameterized reduction method to the Variable.
   /// @param method a ReductionMethod (already defined).
   /// @param paramaters specific parameters in key-value form to apply the reduction method to the Variable.
-  void set_reduction_operation(std::shared_ptr<ReductionMethod> method, std::map<std::string, std::string> parameters);
+  void set_reduction_operation(std::shared_ptr<ReductionMethod> method,
+                               std::map<std::string, std::string, std::less<>> parameters);
 
   [[nodiscard]] bool is_reduced() const { return is_reduced_with_ != nullptr; }
 

src/CompressionReductionMethod.cpp

@@ -27,26 +27,26 @@ double CompressionReductionMethod::ParameterizedCompression::get_effective_ratio
 size_t CompressionReductionMethod::get_reduced_variable_global_size(const Variable& var) const
 {
   auto ratio = per_variable_parameterizations_.at(&var)->get_compression_ratio();
-  return static_cast<size_t>(std::ceil(var.get_global_size() / ratio));
+  return static_cast<size_t>(std::ceil(static_cast<double>(var.get_global_size()) / ratio));
 }
 
 size_t CompressionReductionMethod::get_reduced_variable_local_size(const Variable& var) const
 {
   auto ratio = per_variable_parameterizations_.at(&var)->get_compression_ratio();
-  return static_cast<size_t>(std::ceil(var.get_local_size() / ratio));
+  return static_cast<size_t>(std::ceil(static_cast<double>(var.get_local_size()) / ratio));
 }
 
 double CompressionReductionMethod::get_flop_amount_to_reduce_variable(const Variable& var) const
 {
   auto param        = per_variable_parameterizations_.at(&var);
-  auto num_elements = var.get_local_size() / var.get_element_size();
+  auto num_elements = static_cast<double>(var.get_local_size() / var.get_element_size());
   return param->get_compression_cost_per_element() * num_elements;
 }
 
 double CompressionReductionMethod::get_flop_amount_to_decompress_variable(const Variable& var) const
 {
   auto param        = per_variable_parameterizations_.at(&var);
-  auto num_elements = var.get_local_size() / var.get_element_size();
+  auto num_elements = static_cast<double>(var.get_local_size() / var.get_element_size());
   return param->get_decompression_cost_per_element() * num_elements;
 }
 
@@ -69,8 +69,8 @@ double CompressionReductionMethod::derive_compression_ratio(double accuracy, con
   return 1.0;
 }
 
-void CompressionReductionMethod::parameterize_for_variable(const Variable& var,
-                                                           const std::map<std::string, std::string>& parameters)
+void CompressionReductionMethod::parameterize_for_variable(
+    const Variable& var, const std::map<std::string, std::string, std::less<>>& parameters)
 {
   double new_accuracy                       = 1e-3;
   double new_compression_cost_per_element   = 1.0;
@@ -119,7 +119,7 @@ void CompressionReductionMethod::parameterize_for_variable(const Variable& var,
     } else if (key == "ratio_variability") {
       new_ratio_variability = std::stod(value);
     } else {
-      throw UnknownCompressionOptionException(XBT_THROW_POINT, key.c_str());
+      throw UnknownCompressionOptionException(XBT_THROW_POINT, key);
     }
   }
 
@@ -129,9 +129,8 @@ void CompressionReductionMethod::parameterize_for_variable(const Variable& var,
       throw InconsistentCompressionRatioException(
           XBT_THROW_POINT, "Compressor profile 'fixed' requires an explicit 'compression_ratio' parameter.");
     new_compression_ratio = derive_compression_ratio(new_accuracy, new_compressor_profile, new_data_smoothness);
-  } else if (ratio_explicitly_set) {
-    if (new_compression_ratio < 1.0)
-      throw InconsistentCompressionRatioException(XBT_THROW_POINT, "Compression ratio must be >= 1.0");
+  } else if (ratio_explicitly_set && new_compression_ratio < 1.0) {
+    throw InconsistentCompressionRatioException(XBT_THROW_POINT, "Compression ratio must be >= 1.0");
   }
 
   XBT_DEBUG("Compression parameterization for Variable %s: profile=%s, accuracy=%.2e, ratio=%.2f, "

src/DecimationReductionMethod.cpp

@@ -37,20 +37,21 @@ double DecimationReductionMethod::ParameterizedDecimation::get_flop_amount_to_de
   XBT_DEBUG("Compute decimation cost with: cost_per_element = %.2f and interpolation_method = %s", cost_per_element_,
             interpolation_method_.c_str());
   double amount = cost_per_element_;
+  auto local_size = static_cast<double>(var_->get_local_size());
   if (interpolation_method_.empty()) {
-    amount *= var_->get_local_size();
+    amount *= local_size;
   } else if (interpolation_method_ == "linear") {
-    amount = 2 * amount * var_->get_local_size();
+    amount = 2 * amount * local_size;
   } else if (interpolation_method_ == "quadratic") {
-    amount = 4 * amount * var_->get_local_size();
+    amount = 4 * amount * local_size;
   } else if (interpolation_method_ == "cubic") {
-    amount = 8 * amount * var_->get_local_size();
+    amount = 8 * amount * local_size;
   } // Sanity check done when parameterizing the reduction method for this variable
   return amount;
 }
 
-void DecimationReductionMethod::parameterize_for_variable(const Variable& var,
-                                                          const std::map<std::string, std::string>& parameters)
+void DecimationReductionMethod::parameterize_for_variable(
+    const Variable& var, const std::map<std::string, std::string, std::less<>>& parameters)
 {
   std::vector<size_t> new_stride;
   std::string new_interpolation_method;
@@ -103,7 +104,7 @@ void DecimationReductionMethod::parameterize_for_variable(const Variable& var,
     } else if (key == "cost_per_element")
       new_cost_per_element = std::stod(value);
     else
-      throw UnknownDecimationOptionException(XBT_THROW_POINT, key.c_str());
+      throw UnknownDecimationOptionException(XBT_THROW_POINT, key);
   }
 
   if (!exists) {
@@ -135,7 +136,8 @@ void DecimationReductionMethod::reduce_variable(const Variable& var)
   std::vector<size_t> reduced_shape;
   size_t i = 0;
   for (auto dim_size : original_shape)
-    reduced_shape.push_back(std::ceil(dim_size / (stride[i++] * 1.0)));
+    reduced_shape.push_back(
+        static_cast<size_t>(std::ceil(static_cast<double>(dim_size) / static_cast<double>(stride[i++]))));
   parameterization->set_reduced_shape(reduced_shape);
 
   auto self           = sg4::Actor::self();
@@ -145,9 +147,10 @@ void DecimationReductionMethod::reduce_variable(const Variable& var)
 
   for (size_t i = 0; i < original_shape.size(); i++) {
     // Sanity checks that shape, start, and count have the same size have already been done
-    size_t r_start = std::ceil(start[i] / (stride[i] * 1.0));
-    size_t r_next_start =
-        std::min(original_shape[i], static_cast<size_t>(std::ceil((start[i] + count[i]) / (stride[i] * 1.0))));
+    size_t r_start = static_cast<size_t>(std::ceil(static_cast<double>(start[i]) / static_cast<double>(stride[i])));
+    size_t r_next_start = std::min(
+        original_shape[i],
+        static_cast<size_t>(std::ceil(static_cast<double>(start[i] + count[i]) / static_cast<double>(stride[i]))));
     XBT_DEBUG("Dim %zu: stride = %zu, Start = %zu, r_start = %zu, Count = %zu, r_count = %zu", i, stride[i], start[i],
               r_start, count[i], r_next_start - r_start);
     reduced_start.push_back(r_start);

src/Stream.cpp

@@ -158,8 +158,7 @@ void Stream::export_metadata_to_file() const
 
 std::shared_ptr<ReductionMethod> Stream::define_reduction_method(const std::string& name)
 {
-  auto it = reduction_methods_.find(name);
-  if (it != reduction_methods_.end())
+  if (auto it = reduction_methods_.find(name); it != reduction_methods_.end())
     return it->second;
 
   std::shared_ptr<ReductionMethod> reduction_method;

src/Variable.cpp

@@ -60,7 +60,7 @@ void Variable::set_transaction_selection(unsigned int begin, unsigned int count)
 }
 
 void Variable::set_reduction_operation(std::shared_ptr<ReductionMethod> method,
-                                       std::map<std::string, std::string> parameters)
+                                       std::map<std::string, std::string, std::less<>> parameters)
 {
   auto stream = defined_in_stream_.lock();
   xbt_assert(stream, "Variable::set_reduction_operation called after its Stream has been destroyed");