One commit to rule them all

Author: Nikita Kulikov

cpp/oneapi/dal/backend/interop/data_conversion.hpp

@@ -24,7 +24,7 @@ namespace oneapi::dal::backend::interop {
 // TODO: Remove using namespace
 using namespace daal::data_management;
 
-features::IndexNumType getIndexNumType(data_type t) {
+inline features::IndexNumType getIndexNumType(data_type t) {
     switch (t) {
         case data_type::int32: return features::DAAL_INT32_S;
         case data_type::int64: return features::DAAL_INT64_S;
@@ -36,7 +36,19 @@ features::IndexNumType getIndexNumType(data_type t) {
     }
 }
 
-internal::ConversionDataType getConversionDataType(data_type t) {
+inline data_type get_dal_data_type(features::IndexNumType t) {
+    switch (t) {
+        case features::DAAL_INT32_S: return data_type::int32;
+        case features::DAAL_INT64_S: return data_type::int64;
+        case features::DAAL_INT32_U: return data_type::uint32;
+        case features::DAAL_INT64_U: return data_type::uint64;
+        case features::DAAL_FLOAT32: return data_type::float32;
+        case features::DAAL_FLOAT64: return data_type::float64;
+        default: return data_type::float32;
+    }
+}
+
+inline internal::ConversionDataType getConversionDataType(data_type t) {
     switch (t) {
         case data_type::int32: return internal::DAAL_INT32;
         case data_type::float32: return internal::DAAL_SINGLE;
@@ -46,11 +58,11 @@ internal::ConversionDataType getConversionDataType(data_type t) {
 }
 
 template <typename DownCast, typename UpCast, typename... Args>
-void daal_convert_dispatcher(data_type src_type,
-                             data_type dst_type,
-                             DownCast&& dcast,
-                             UpCast&& ucast,
-                             Args&&... args) {
+inline void daal_convert_dispatcher(data_type src_type,
+                                    data_type dst_type,
+                                    DownCast&& dcast,
+                                    UpCast&& ucast,
+                                    Args&&... args) {
     auto from_type = getIndexNumType(src_type);
     auto to_type = getConversionDataType(dst_type);
 
@@ -74,11 +86,11 @@ void daal_convert_dispatcher(data_type src_type,
     }
 }
 
-void daal_convert(const void* src,
-                  void* dst,
-                  data_type src_type,
-                  data_type dst_type,
-                  std::int64_t element_count) {
+inline void daal_convert(const void* src,
+                         void* dst,
+                         data_type src_type,
+                         data_type dst_type,
+                         std::int64_t element_count) {
     daal_convert_dispatcher(src_type,
                             dst_type,
                             internal::getVectorDownCast,
@@ -88,13 +100,13 @@ void daal_convert(const void* src,
                             dst);
 }
 
-void daal_convert(const void* src,
-                  void* dst,
-                  data_type src_type,
-                  data_type dst_type,
-                  std::int64_t src_stride,
-                  std::int64_t dst_stride,
-                  std::int64_t element_count) {
+inline void daal_convert(const void* src,
+                         void* dst,
+                         data_type src_type,
+                         data_type dst_type,
+                         std::int64_t src_stride,
+                         std::int64_t dst_stride,
+                         std::int64_t element_count) {
     daal_convert_dispatcher(src_type,
                             dst_type,
                             internal::getVectorStrideDownCast,

cpp/oneapi/dal/backend/interop/table_conversion.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2020 Intel Corporation
+* Copyright 2021 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -14,291 +14,4 @@
 * limitations under the License.
 *******************************************************************************/
 
-#pragma once
-
-#ifdef ONEDAL_DATA_PARALLEL
-#include <daal/include/data_management/data/internal/numeric_table_sycl_homogen.h>
-#endif
-
-#include "oneapi/dal/backend/memory.hpp"
-#include "oneapi/dal/table/detail/table_builder.hpp"
-#include "oneapi/dal/table/backend/interop/sycl_table_adapter.hpp"
-#include "oneapi/dal/table/backend/interop/host_homogen_table_adapter.hpp"
-#include "oneapi/dal/table/backend/interop/host_soa_table_adapter.hpp"
-#include "oneapi/dal/table/backend/interop/host_csr_table_adapter.hpp"
-#include "oneapi/dal/backend/interop/csr_block_owner.hpp"
-
-namespace oneapi::dal::backend::interop {
-
-template <typename Data>
-inline auto allocate_daal_homogen_table(std::int64_t row_count, std::int64_t column_count) {
-    return daal::data_management::HomogenNumericTable<Data>::create(
-        dal::detail::integral_cast<std::size_t>(column_count),
-        dal::detail::integral_cast<std::size_t>(row_count),
-        daal::data_management::NumericTable::doAllocate);
-}
-
-template <typename Data>
-inline auto empty_daal_homogen_table(std::int64_t column_count) {
-    return daal::data_management::HomogenNumericTable<Data>::create(
-        dal::detail::integral_cast<std::size_t>(column_count),
-        dal::detail::integral_cast<std::size_t>(0),
-        daal::data_management::NumericTable::notAllocate);
-}
-
-template <typename Data>
-inline auto convert_to_daal_homogen_table(array<Data>& data,
-                                          std::int64_t row_count,
-                                          std::int64_t column_count,
-                                          bool allow_copy = false) {
-    if (!data.get_count()) {
-        return daal::services::SharedPtr<daal::data_management::HomogenNumericTable<Data>>();
-    }
-
-    if (allow_copy) {
-        data.need_mutable_data();
-    }
-
-    ONEDAL_ASSERT(data.has_mutable_data());
-    const auto daal_data =
-        daal::services::SharedPtr<Data>(data.get_mutable_data(), daal_object_owner{ data });
-
-    return daal::data_management::HomogenNumericTable<Data>::create(
-        daal_data,
-        dal::detail::integral_cast<std::size_t>(column_count),
-        dal::detail::integral_cast<std::size_t>(row_count));
-}
-
-template <typename Data>
-inline daal::data_management::NumericTablePtr copy_to_daal_homogen_table(const table& table) {
-    // TODO: Preserve information about features
-    const bool allow_copy = true;
-    auto rows = row_accessor<const Data>{ table }.pull();
-    return convert_to_daal_homogen_table(rows,
-                                         table.get_row_count(),
-                                         table.get_column_count(),
-                                         allow_copy);
-}
-
-template <typename Data>
-inline table convert_from_daal_homogen_table(const daal::data_management::NumericTablePtr& nt) {
-    if (nt->getNumberOfRows() == 0) {
-        return table{};
-    }
-    daal::data_management::BlockDescriptor<Data> block;
-    const std::int64_t row_count = dal::detail::integral_cast<std::int64_t>(nt->getNumberOfRows());
-    const std::int64_t column_count =
-        dal::detail::integral_cast<std::int64_t>(nt->getNumberOfColumns());
-
-    nt->getBlockOfRows(0, row_count, daal::data_management::readOnly, block);
-    Data* data = block.getBlockPtr();
-    array<Data> arr(data, row_count * column_count, [nt, block](Data* p) mutable {
-        nt->releaseBlockOfRows(block);
-    });
-    return detail::homogen_table_builder{}.reset(arr, row_count, column_count).build();
-}
-
-inline daal::data_management::NumericTablePtr wrap_by_host_homogen_adapter(
-    const homogen_table& table) {
-    const auto& dtype = table.get_metadata().get_data_type(0);
-
-    switch (dtype) {
-        case data_type::float32: return host_homogen_table_adapter<float>::create(table);
-        case data_type::float64: return host_homogen_table_adapter<double>::create(table);
-        case data_type::int32: return host_homogen_table_adapter<std::int32_t>::create(table);
-        default: return daal::data_management::NumericTablePtr();
-    }
-}
-
-inline daal::data_management::NumericTablePtr wrap_by_host_soa_adapter(const homogen_table& table) {
-    const auto& dtype = table.get_metadata().get_data_type(0);
-
-    switch (dtype) {
-        case data_type::float32: return host_soa_table_adapter::create<float>(table);
-        case data_type::float64: return host_soa_table_adapter::create<double>(table);
-        case data_type::int32: return host_soa_table_adapter::create<std::int32_t>(table);
-        default: return daal::data_management::NumericTablePtr();
-    }
-}
-
-template <typename Data>
-inline daal::data_management::NumericTablePtr convert_to_daal_table(const homogen_table& table) {
-    if (table.get_data_layout() == data_layout::row_major) {
-        if (auto wrapper = wrap_by_host_homogen_adapter(table)) {
-            return wrapper;
-        }
-    }
-    else if (table.get_data_layout() == data_layout::column_major) {
-        if (auto wrapper = wrap_by_host_soa_adapter(table)) {
-            return wrapper;
-        }
-    }
-    return copy_to_daal_homogen_table<Data>(table);
-}
-
-template <typename T>
-inline auto convert_to_daal_csr_table(array<T>& data,
-                                      array<std::int64_t>& column_indices,
-                                      array<std::int64_t>& row_indices,
-                                      std::int64_t row_count,
-                                      std::int64_t column_count,
-                                      bool allow_copy = false) {
-    ONEDAL_ASSERT(data.get_count() == column_indices.get_count());
-    ONEDAL_ASSERT(row_indices.get_count() == row_count + 1);
-
-    if (!data.get_count() || !column_indices.get_count() || !row_indices.get_count()) {
-        return daal::services::SharedPtr<daal::data_management::CSRNumericTable>();
-    }
-
-    if (allow_copy) {
-        data.need_mutable_data();
-        column_indices.need_mutable_data();
-        row_indices.need_mutable_data();
-    }
-
-    ONEDAL_ASSERT(data.has_mutable_data());
-    ONEDAL_ASSERT(column_indices.has_mutable_data());
-    ONEDAL_ASSERT(row_indices.has_mutable_data());
-
-    const auto daal_data =
-        daal::services::SharedPtr<T>(data.get_mutable_data(), daal_object_owner{ data });
-    ONEDAL_ASSERT(sizeof(std::size_t) == sizeof(std::int64_t));
-    const auto daal_column_indices = daal::services::SharedPtr<std::size_t>(
-        reinterpret_cast<std::size_t*>(column_indices.get_mutable_data()),
-        daal_object_owner{ column_indices });
-    const auto daal_row_indices = daal::services::SharedPtr<std::size_t>(
-        reinterpret_cast<std::size_t*>(row_indices.get_mutable_data()),
-        daal_object_owner{ row_indices });
-
-    return daal::data_management::CSRNumericTable::create(
-        daal_data,
-        daal_column_indices,
-        daal_row_indices,
-        dal::detail::integral_cast<std::size_t>(column_count),
-        dal::detail::integral_cast<std::size_t>(row_count));
-}
-
-template <typename Float>
-inline daal::data_management::CSRNumericTablePtr copy_to_daal_csr_table(const csr_table& table) {
-    const bool allow_copy = true;
-    auto [data, column_indices, row_offsets] = csr_accessor<const Float>{ table }.pull();
-    return convert_to_daal_csr_table(data,
-                                     column_indices,
-                                     row_offsets,
-                                     table.get_row_count(),
-                                     table.get_column_count(),
-                                     allow_copy);
-}
-
-template <typename T>
-inline table convert_from_daal_csr_table(const daal::data_management::NumericTablePtr& nt) {
-    auto block_owner = std::make_shared<csr_block_owner<T>>(csr_block_owner<T>{ nt });
-
-    ONEDAL_ASSERT(sizeof(std::size_t) == sizeof(std::int64_t));
-
-    return csr_table{
-        array<T>{ block_owner->get_data(),
-                  block_owner->get_element_count(),
-                  [block_owner](const T* p) {} },
-        array<std::int64_t>{ reinterpret_cast<std::int64_t*>(block_owner->get_column_indices()),
-                             block_owner->get_element_count(),
-                             [block_owner](const std::int64_t* p) {} },
-        array<std::int64_t>{ reinterpret_cast<std::int64_t*>(block_owner->get_row_indices()),
-                             block_owner->get_row_count() + 1,
-                             [block_owner](const std::int64_t* p) {} },
-        block_owner->get_column_count()
-    };
-}
-
-inline daal::data_management::CSRNumericTablePtr wrap_by_host_csr_adapter(const csr_table& table) {
-    const auto& dtype = table.get_metadata().get_data_type(0);
-
-    switch (dtype) {
-        case data_type::float32: return host_csr_table_adapter<float>::create(table);
-        case data_type::float64: return host_csr_table_adapter<double>::create(table);
-        case data_type::int32: return host_csr_table_adapter<std::int32_t>::create(table);
-        default: return daal::data_management::CSRNumericTablePtr();
-    }
-}
-
-template <typename Float>
-inline daal::data_management::CSRNumericTablePtr convert_to_daal_table(const csr_table& table) {
-    auto wrapper = wrap_by_host_csr_adapter(table);
-    if (!wrapper) {
-        return copy_to_daal_csr_table<Float>(table);
-    }
-    else {
-        return wrapper;
-    }
-}
-
-template <typename Data>
-inline daal::data_management::NumericTablePtr convert_to_daal_table(const table& table) {
-    if (table.get_kind() == homogen_table::kind()) {
-        const auto& homogen = static_cast<const homogen_table&>(table);
-        return convert_to_daal_table<Data>(homogen);
-    }
-    else if (table.get_kind() == csr_table::kind()) {
-        const auto& csr = static_cast<const csr_table&>(table);
-        return convert_to_daal_table<Data>(csr);
-    }
-    else {
-        return copy_to_daal_homogen_table<Data>(table);
-    }
-}
-
-template <typename Data>
-inline table convert_from_daal_table(const daal::data_management::NumericTablePtr& nt) {
-    if (nt->getDataLayout() == daal::data_management::NumericTableIface::StorageLayout::csrArray) {
-        return convert_from_daal_csr_table<Data>(nt);
-    }
-    else {
-        return convert_from_daal_homogen_table<Data>(nt);
-    }
-}
-
-#ifdef ONEDAL_DATA_PARALLEL
-inline daal::data_management::NumericTablePtr convert_to_daal_table(const sycl::queue& queue,
-                                                                    const table& table) {
-    if (!table.has_data()) {
-        return daal::data_management::NumericTablePtr{};
-    }
-    return interop::sycl_table_adapter::create(queue, table);
-}
-
-template <typename Data>
-inline daal::data_management::NumericTablePtr convert_to_daal_table(const sycl::queue& queue,
-                                                                    const array<Data>& data,
-                                                                    std::int64_t row_count,
-                                                                    std::int64_t column_count) {
-    using daal::services::Status;
-    using daal::services::SharedPtr;
-    using daal::services::internal::Buffer;
-    using daal::data_management::internal::SyclHomogenNumericTable;
-    using dal::detail::integral_cast;
-
-    ONEDAL_ASSERT(data.get_count() == row_count * column_count);
-    ONEDAL_ASSERT(data.has_mutable_data());
-    ONEDAL_ASSERT(is_same_context(queue, data));
-
-    const SharedPtr<Data> data_shared{ data.get_mutable_data(), daal_object_owner{ data } };
-
-    Status status;
-    const Buffer<Data> buffer{ data_shared,
-                               integral_cast<std::size_t>(data.get_count()),
-                               queue,
-                               status };
-    status_to_exception(status);
-
-    const auto table =
-        SyclHomogenNumericTable<Data>::create(buffer,
-                                              integral_cast<std::size_t>(column_count),
-                                              integral_cast<std::size_t>(row_count),
-                                              &status);
-    status_to_exception(status);
-
-    return table;
-}
-#endif
-
-} // namespace oneapi::dal::backend::interop
+#include "oneapi/dal/table/backend/interop/table_conversion.hpp"

cpp/oneapi/dal/detail/error_messages.cpp

@@ -116,6 +116,7 @@ MSG(object_does_not_provide_read_access_to_csr,
     "Given object does not provide read access to the block of CSR format")
 MSG(pull_column_interface_is_not_implemented,
     "Pull column interface is planned but not implemented yet")
+MSG(unsupported_table_conversion, "Unsupported table conversion")
 
 /* Ranges */
 MSG(invalid_range_of_rows, "Invalid range of rows")