Add more ssize_t casts.

Author: breyerml

include/plssvm/backends/OpenMP/kernel/cg_explicit/blas.hpp

@@ -43,8 +43,8 @@ inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num
     PLSSVM_ASSERT(C.shape() == (plssvm::shape{ num_rhs, num_rows }), "C matrix sizes mismatch!: {} != [{}, {}]", C.shape(), num_rhs, num_rows);
 
     // calculate constants
-    const auto blocked_num_rhs = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_num_rhs = static_cast<plssvm::detail::ssize_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_num_rows = static_cast<plssvm::detail::ssize_t>(std::ceil(static_cast<real_type>(num_rows) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
     const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);

include/plssvm/backends/OpenMP/kernel/cg_explicit/kernel_matrix_assembly.hpp

@@ -46,7 +46,7 @@ void device_kernel_assembly(const std::vector<real_type> &q, std::vector<real_ty
 
     // calculate constants
     const std::size_t dept = q.size();
-    const auto blocked_dept = static_cast<std::size_t>(std::ceil(static_cast<real_type>(dept) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_dept = static_cast<plssvm::detail::ssize_t>(std::ceil(static_cast<real_type>(dept) / INTERNAL_BLOCK_SIZE));
     const std::size_t num_features = data.num_cols();
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows

include/plssvm/backends/OpenMP/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp

@@ -55,7 +55,7 @@ inline void device_kernel_assembly_symm(const real_type alpha, const std::vector
 
     // calculate constants
     const std::size_t dept = q.size();
-    const auto blocked_dept = static_cast<std::size_t>(std::ceil(static_cast<real_type>(dept) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_dept = static_cast<plssvm::detail::ssize_t>(std::ceil(static_cast<real_type>(dept) / INTERNAL_BLOCK_SIZE));
     const std::size_t num_features = data.num_cols();
     const std::size_t num_classes = B.num_rows();
 

include/plssvm/backends/OpenMP/kernel/predict_kernel.hpp

@@ -38,9 +38,9 @@ inline void device_kernel_w_linear(soa_matrix<real_type> &w, const aos_matrix<re
     PLSSVM_ASSERT(w.shape() == (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }), "Shape mismatch: {} vs {}!", w.shape(), (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }));
 
     // calculate constants
-    const std::size_t num_classes = alpha.num_rows();
-    const std::size_t num_support_vectors = support_vectors.num_rows();
-    const std::size_t num_features = support_vectors.num_cols();
+    const auto num_classes = static_cast<plssvm::detail::ssize_t>(alpha.num_rows());
+    const auto num_support_vectors = static_cast<plssvm::detail::ssize_t>(support_vectors.num_rows());
+    const auto num_features = static_cast<plssvm::detail::ssize_t>(support_vectors.num_cols());
 
 #pragma omp parallel for collapse(2) default(none) shared(w, support_vectors, alpha) firstprivate(num_classes, num_features, num_support_vectors)
     for (plssvm::detail::ssize_t a = 0; a < num_classes; ++a) {
@@ -68,9 +68,9 @@ inline void device_kernel_predict_linear(aos_matrix<real_type> &prediction, cons
     PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), w.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), w.num_rows() }));
 
     // calculate constants
-    const std::size_t num_classes = prediction.num_cols();
-    const std::size_t num_predict_points = predict_points.num_rows();
-    const std::size_t num_features = predict_points.num_cols();
+    const auto num_classes = static_cast<plssvm::detail::ssize_t>(prediction.num_cols());
+    const auto num_predict_points = static_cast<plssvm::detail::ssize_t>(predict_points.num_rows());
+    const auto num_features = static_cast<plssvm::detail::ssize_t>(predict_points.num_cols());
 
 #pragma omp parallel for collapse(2) default(none) shared(prediction, w, rho, predict_points) firstprivate(num_classes, num_features, num_predict_points)
     for (plssvm::detail::ssize_t point_index = 0; point_index < num_predict_points; ++point_index) {
@@ -104,12 +104,12 @@ inline void device_kernel_predict(aos_matrix<real_type> &prediction, const aos_m
     PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }));
 
     // calculate constants
-    const std::size_t num_classes = alpha.num_rows();
-    const std::size_t num_support_vectors = support_vectors.num_rows();
-    const auto blocked_num_support_vectors = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_support_vectors) / INTERNAL_BLOCK_SIZE));
-    const std::size_t num_predict_points = predict_points.num_rows();
-    const auto blocked_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_predict_points) / INTERNAL_BLOCK_SIZE));
-    const std::size_t num_features = predict_points.num_cols();
+    const auto num_classes = static_cast<plssvm::detail::ssize_t>(alpha.num_rows());
+    const auto num_support_vectors = static_cast<plssvm::detail::ssize_t>(support_vectors.num_rows());
+    const auto blocked_num_support_vectors = static_cast<plssvm::detail::ssize_t>(std::ceil(static_cast<real_type>(num_support_vectors) / INTERNAL_BLOCK_SIZE));
+    const auto num_predict_points = static_cast<plssvm::detail::ssize_t>(predict_points.num_rows());
+    const auto blocked_num_predict_points = static_cast<plssvm::detail::ssize_t>(std::ceil(static_cast<real_type>(num_predict_points) / INTERNAL_BLOCK_SIZE));
+    const auto num_features = static_cast<plssvm::detail::ssize_t>(predict_points.num_cols());
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
     const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);

include/plssvm/backends/gpu_csvm.hpp

@@ -242,6 +242,7 @@ std::vector<::plssvm::detail::move_only_any> gpu_csvm<device_ptr_t, queue_t, pin
     PLSSVM_ASSERT(q_red.size() == A.num_rows() - 1, "The q_red size ({}) mismatches the number of data points after dimensional reduction ({})!", q_red.size(), A.num_rows() - 1);
 
     const std::size_t num_devices = this->num_available_devices();
+    const auto signed_num_devices = static_cast<ssize_t>(num_devices);
     const std::size_t num_rows_reduced = A.shape().x - 1;
 
     // update the data distribution: only the upper triangular kernel matrix is used
@@ -255,8 +256,8 @@ std::vector<::plssvm::detail::move_only_any> gpu_csvm<device_ptr_t, queue_t, pin
     std::vector<device_ptr_type> q_red_d(num_devices);
 
     // split memory allocation and memory copy! (necessary to remove locks on some systems and setups)
-#pragma omp parallel for if (num_devices > 1)
-    for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+    for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
         // check whether the current device is responsible for at least one data point!
         if (data_distribution_->place_specific_num_rows(device_id) == 0) {
             continue;
@@ -271,8 +272,8 @@ std::vector<::plssvm::detail::move_only_any> gpu_csvm<device_ptr_t, queue_t, pin
     // pin the data matrix
     const pinned_memory_type pm{ A };
 
-#pragma omp parallel for if (num_devices > 1)
-    for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+    for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
         // check whether the current device is responsible for at least one data point!
         if (data_distribution_->place_specific_num_rows(device_id) == 0) {
             continue;
@@ -334,6 +335,7 @@ void gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::blas_level_3(const solver
     PLSSVM_ASSERT(B.padding() == C.padding(), "The B ({}) and C ({}) matrices must have the same padding!", B.padding(), C.padding());
 
     const std::size_t num_devices = this->num_available_devices();
+    const auto signed_num_devices = static_cast<ssize_t>(num_devices);
 
     // the C and B matrices; completely stored on each device
     std::vector<device_ptr_type> B_d(num_devices);
@@ -346,8 +348,8 @@ void gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::blas_level_3(const solver
     }
 
     // split memory allocation and memory copy!
-#pragma omp parallel for if (num_devices > 1)
-    for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+    for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
         // check whether the current device is responsible for at least one data point!
         if (data_distribution_->place_specific_num_rows(device_id) == 0) {
             continue;
@@ -359,8 +361,8 @@ void gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::blas_level_3(const solver
         C_d[device_id] = device_ptr_type{ C.shape(), C.padding(), device };
     }
 
-#pragma omp parallel for ordered if (num_devices > 1)
-    for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for ordered if (signed_num_devices > 1)
+    for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
         // check whether the current device is responsible for at least one data point!
         if (data_distribution_->place_specific_num_rows(device_id) == 0) {
             continue;
@@ -495,6 +497,7 @@ aos_matrix<real_type> gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::predict_
     const std::size_t num_support_vectors = support_vectors.num_rows();
     const std::size_t num_features = predict_points.num_cols();
     const std::size_t num_devices = this->num_available_devices();
+    const auto signed_num_devices = static_cast<ssize_t>(num_devices);
 
     // the result matrix
     aos_matrix<real_type> out_ret{ shape{ num_predict_points, num_classes }, real_type{ 0.0 }, shape{ PADDING_SIZE, PADDING_SIZE } };
@@ -504,8 +507,8 @@ aos_matrix<real_type> gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::predict_
     std::vector<device_ptr_type> alpha_d(num_devices);
 
     // split memory allocation and memory copy!
-#pragma omp parallel for if (num_devices > 1)
-    for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+    for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
         const queue_type &device = devices_[device_id];
 
         // allocate memory on the device
@@ -532,8 +535,8 @@ aos_matrix<real_type> gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::predict_
 
             std::vector<device_ptr_type> sv_d(num_devices);
             // split memory allocation and memory copy!
-#pragma omp parallel for if (num_devices > 1)
-            for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+            for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
                 // check whether the current device is responsible for at least one data point!
                 if (data_distribution_->place_specific_num_rows(device_id) == 0) {
                     continue;
@@ -544,8 +547,8 @@ aos_matrix<real_type> gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::predict_
                 sv_d[device_id] = device_ptr_type{ shape{ data_distribution_->place_specific_num_rows(device_id), num_features }, support_vectors.padding(), device };
             }
 
-#pragma omp parallel for ordered if (num_devices > 1)
-            for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for ordered if (signed_num_devices > 1)
+            for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
                 // check whether the current device is responsible for at least one data point!
                 if (data_distribution_->place_specific_num_rows(device_id) == 0) {
                     continue;
@@ -599,30 +602,30 @@ aos_matrix<real_type> gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::predict_
 
         // upload the w vector to all devices
         // split memory allocation and memory copy!
-#pragma omp parallel for if (num_devices > 1)
-        for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+        for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
             const queue_type &device = devices_[device_id];
 
             // allocate memory on the device
             sv_or_w_d[device_id] = device_ptr_type{ shape{ num_classes, num_features }, shape{ PADDING_SIZE, PADDING_SIZE }, device };
         }
-#pragma omp parallel for if (num_devices > 1)
-        for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+        for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
             // copy data to the device
             sv_or_w_d[device_id].copy_to_device(w);
         }
     } else {
         // use the support vectors for all other kernel functions
         // split memory allocation and memory copy!
-#pragma omp parallel for if (num_devices > 1)
-        for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+        for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
             const queue_type &device = devices_[device_id];
 
             // allocate memory on the device
             sv_or_w_d[device_id] = device_ptr_type{ support_vectors.shape(), support_vectors.padding(), device };
         }
-#pragma omp parallel for if (num_devices > 1)
-        for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+        for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
             // copy data to the device
             sv_or_w_d[device_id].copy_to_device(support_vectors);
         }
@@ -637,8 +640,8 @@ aos_matrix<real_type> gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::predict_
     std::vector<device_ptr_type> rho_d(num_devices);
 
     // split memory allocation and memory copy!
-#pragma omp parallel for if (num_devices > 1)
-    for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+    for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
         // check whether the current device is responsible for at least one data point!
         if (data_distribution_->place_specific_num_rows(device_id) == 0) {
             continue;
@@ -651,8 +654,8 @@ aos_matrix<real_type> gpu_csvm<device_ptr_t, queue_t, pinned_memory_t>::predict_
         rho_d[device_id] = device_ptr_type{ num_classes + PADDING_SIZE, device };
     }
 
-#pragma omp parallel for if (num_devices > 1)
-    for (ssize_t device_id = 0; device_id < num_devices; ++device_id) {
+#pragma omp parallel for if (signed_num_devices > 1)
+    for (ssize_t device_id = 0; device_id < signed_num_devices; ++device_id) {
         // check whether the current device is responsible for at least one data point!
         if (data_distribution_->place_specific_num_rows(device_id) == 0) {
             continue;

include/plssvm/data_set/classification_data_set.hpp

@@ -386,8 +386,8 @@ void classification_data_set<U>::map_label() {
     aos_matrix<real_type> tmp{ shape{ mapper.num_mappings(), labels_ptr_->size() }, real_type{ -1.0 } };
 
 #pragma omp parallel for collapse(2)
-    for (detail::ssize_t label = 0; label < tmp.num_rows(); ++label) {
-        for (detail::ssize_t i = 0; i < tmp.num_cols(); ++i) {
+    for (detail::ssize_t label = 0; label < static_cast<detail::ssize_t>(tmp.num_rows()); ++label) {
+        for (detail::ssize_t i = 0; i < static_cast<detail::ssize_t>(tmp.num_cols()); ++i) {
             if (label == mapper.get_mapped_index_by_label((*labels_ptr_)[i])) {
                 tmp(label, i) = real_type{ 1.0 };
             }

include/plssvm/data_set/min_max_scaler.hpp

@@ -17,6 +17,7 @@
 #include "plssvm/detail/io/file_reader.hpp"                // plssvm::detail::io::file_reader
 #include "plssvm/detail/io/scaling_factors_parsing.hpp"    // plssvm::detail::io::parse_scaling_factors
 #include "plssvm/detail/logging.hpp"                       // plssvm::detail::log
+#include "plssvm/detail/ssize.hpp"                         // plssvm::detail::ssize_t
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // plssvm::detail::tracking_entry
 #include "plssvm/exceptions/exceptions.hpp"                // plssvm::min_max_scaler_exception
 #include "plssvm/matrix.hpp"                               // plssvm::matrix, plssvm::layout_type
@@ -47,6 +48,8 @@ class min_max_scaler {
     struct factors {
         /// The used size type.
         using size_type = std::size_t;
+        /// The used signed size type.
+        using ssize_type = detail::ssize_t;
 
         /**
          * @brief Default construct new scaling factors.
@@ -168,6 +171,7 @@ void min_max_scaler::scale(plssvm::matrix<real_type, layout> &data) {
     const std::chrono::time_point start_time = std::chrono::steady_clock::now();
 
     using size_type = typename plssvm::matrix<real_type, layout>::size_type;
+    using ssize_type = typename plssvm::matrix<real_type, layout>::ssize_type;
     const size_type num_data_points = data.num_rows();
     const size_type num_features = data.num_cols();
 
@@ -184,7 +188,7 @@ void min_max_scaler::scale(plssvm::matrix<real_type, layout> &data) {
 
 // calculate min/max values of all data points at the specific feature
 #pragma omp parallel for default(shared) firstprivate(feature) reduction(min : min_value) reduction(max : max_value)
-            for (size_type data_point = 0; data_point < num_data_points; ++data_point) {
+            for (ssize_type data_point = 0; data_point < static_cast<ssize_type>(num_data_points); ++data_point) {
                 min_value = std::min(min_value, data(data_point, feature));
                 max_value = std::max(max_value, data(data_point, feature));
             }
@@ -216,7 +220,7 @@ void min_max_scaler::scale(plssvm::matrix<real_type, layout> &data) {
 
 // scale values
 #pragma omp parallel for default(shared) firstprivate(lower, upper)
-    for (size_type i = 0; i < scaling_factors_.size(); ++i) {
+    for (ssize_type i = 0; i < detail::size(scaling_factors_); ++i) {
         // extract feature-wise min and max values
         const factors factor = scaling_factors_[i];
         // scale data values

include/plssvm/data_set/regression_data_set.hpp

@@ -18,7 +18,7 @@
 #include "plssvm/data_set/min_max_scaler.hpp"              // plssvm::min_max_scaler
 #include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
 #include "plssvm/detail/logging.hpp"                       // plssvm::detail::log
-#include "plssvm/detail/ssize.hpp"                         // plssvm::detail::ssize_t
+#include "plssvm/detail/ssize.hpp"                         // plssvm::detail::{ssize_t, ssize}
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // plssvm::detail::tracking::tracking_entry
 #include "plssvm/detail/type_list.hpp"                     // plssvm::detail::{supported_label_types_regression, tuple_contains_v}
 #include "plssvm/file_format_types.hpp"                    // plssvm::file_format_type
@@ -237,7 +237,7 @@ void regression_data_set<U>::map_label() {
     // convert input labels to now mapped values
     std::vector<real_type> labels(labels_ptr_->size());
 #pragma omp parallel for
-    for (detail::ssize_t i = 0; i < labels.size(); ++i) {
+    for (detail::ssize_t i = 0; i < detail::ssize(labels); ++i) {
         labels[i] = static_cast<real_type>((*labels_ptr_)[i]);
     }