layout.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_DETAIL_LAYOUT_HPP_
#define PLSSVM_DETAIL_LAYOUT_HPP_
#pragma once
 
#include "plssvm/detail/assert.hpp"               // PLSSVM_ASSERT, PLSSVM_ASSERT_ENABLED
#include "plssvm/detail/logger.hpp"               // plssvm::detail::log, plssvm::verbosity_level
#include "plssvm/detail/performance_tracker.hpp"  // plssvm::detail::tracking_entry
 
#include "fmt/chrono.h"              // format std::chrono types
#include "fmt/core.h"                // fmt::format
#include "fmt/ostream.h"             // format types with a user defined operator<<
 
#include <algorithm>                 // std::all_of
#include <chrono>                    // std::chrono::{time_point, steady_clock, duration_cast}
#include <cstddef>                   // std::size_t
#include <iosfwd>                    // forward declare std::ostream and std::istream
#include <iostream>                  // std::cout, std::endl
#include <vector>                    // std::vector
 
namespace plssvm::detail {
 
enum class layout_type {
    aos,
    soa
};
 
std::ostream &operator<<(std::ostream &out, layout_type layout);
 
std::istream &operator>>(std::istream &in, layout_type &layout);
 
template <typename real_type>
[[nodiscard]] inline std::vector<real_type> transform_to_aos_layout(const std::vector<std::vector<real_type>> &matrix, const std::size_t boundary_size, const std::size_t num_points, const std::size_t num_features) {
    std::vector<real_type> vec(num_points * (num_features + boundary_size));
 
    #pragma omp parallel for collapse(2) default(none) shared(vec, matrix) firstprivate(num_features, num_points, boundary_size)
    for (std::size_t row = 0; row < num_points; ++row) {
        for (std::size_t col = 0; col < num_features; ++col) {
            vec[row * (num_features + boundary_size) + col] = matrix[row][col];
        }
    }
 
    return vec;
}
 
template <typename real_type>
[[nodiscard]] inline std::vector<real_type> transform_to_soa_layout(const std::vector<std::vector<real_type>> &matrix, const std::size_t boundary_size, const std::size_t num_points, const std::size_t num_features) {
    std::vector<real_type> vec(num_features * (num_points + boundary_size));
 
    #pragma omp parallel for collapse(2) default(none) shared(vec, matrix) firstprivate(num_features, num_points, boundary_size)
    for (std::size_t col = 0; col < num_features; ++col) {
        for (std::size_t row = 0; row < num_points; ++row) {
            vec[col * (num_points + boundary_size) + row] = matrix[row][col];
        }
    }
 
    return vec;
}
 
template <typename real_type>
[[nodiscard]] inline std::vector<real_type> transform_to_layout(const layout_type layout, const std::vector<std::vector<real_type>> &matrix, const std::size_t boundary_size, const std::size_t num_points) {
    // perform some sanity checks
    PLSSVM_ASSERT(!matrix.empty(), "Matrix is empty!");
    PLSSVM_ASSERT(num_points <= matrix.size(), "Number of data points to transform can not exceed matrix size!");
    const typename std::vector<real_type>::size_type num_features = matrix.front().size();
#if defined(PLSSVM_ASSERT_ENABLED)
    const bool has_same_num_features = std::all_of(matrix.begin(), matrix.end(), [=](const std::vector<real_type> &point) { return point.size() == num_features; });
    PLSSVM_ASSERT(has_same_num_features, "Feature sizes mismatch! All features should have size {}.", num_features);
    PLSSVM_ASSERT(num_features > 0, "All features are empty!");
#endif
 
    const std::chrono::time_point start_time = std::chrono::steady_clock::now();
 
    std::vector<real_type> ret;
 
    switch (layout) {
        case layout_type::aos:
            ret = transform_to_aos_layout(matrix, boundary_size, num_points, num_features);
            break;
        case layout_type::soa:
            ret = transform_to_soa_layout(matrix, boundary_size, num_points, num_features);
            break;
    }
 
    const std::chrono::time_point end_time = std::chrono::steady_clock::now();
    detail::log(verbosity_level::full | verbosity_level::timing,
                "Transformed {}x{} dataset from 2D to 1D {} in {}.\n",
                detail::tracking_entry{ "transform", "num_data_points", num_points },
                detail::tracking_entry{ "transform", "num_features", num_features },
                detail::tracking_entry{ "transform", "layout", layout },
                detail::tracking_entry{ "transform", "time", std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time) });
 
    return ret;
}
 
}  // namespace plssvm::detail
 
#endif  // PLSSVM_DETAIL_LAYOUT_HPP_