/* ************************************************************************ * Copyright (C) 2018-2025 Advanced Micro Devices, Inc. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * ************************************************************************ */ // #pragma once #include "host_alloc.hpp" #include "type_utils.h" #include #include // // Local declaration of the device batch vector. // template class device_batch_vector; //! //! @brief Implementation of the batch vector on host. //! template class host_batch_vector { public: //! //! @brief Delete copy constructor. //! host_batch_vector(const host_batch_vector& that) = delete; //! //! @brief Delete copy assignement. //! host_batch_vector& operator=(const host_batch_vector& that) = delete; //! //! @brief Constructor. //! @param n The length of the vector. //! @param inc The increment. //! @param batch_count The batch count. //! explicit host_batch_vector(int64_t n, int64_t inc, int64_t batch_count) : m_n(n) , m_inc(inc ? inc : 1) , m_nmemb(calculate_nmemb(n, inc)) , m_batch_count(batch_count) { if(false == this->try_initialize_memory()) { this->free_memory(); throw std::bad_alloc{}; } } //! //! @brief Constructor. //! @param n The length of the vector. //! @param inc The increment. //! @param stride (UNUSED) The stride. //! @param batch_count The batch count. //! explicit host_batch_vector(int64_t n, int64_t inc, hipblasStride stride, int64_t batch_count) : host_batch_vector(n, inc, batch_count) { } //! //! @brief Destructor. //! ~host_batch_vector() { this->free_memory(); } //! //! @brief Returns the length of the vector. //! int64_t n() const { return this->m_n; } //! //! @brief Returns the increment of the vector. //! int64_t inc() const { return this->m_inc; } //! //! @brief Returns the batch count. //! int64_t batch_count() const { return this->m_batch_count; } //! //! @brief Returns the stride value. //! hipblasStride stride() const { return 0; } //! //! @brief Random access to the vectors. //! @param batch_index the batch index. //! @return The mutable pointer. //! T* operator[](int64_t batch_index) { return this->m_data[batch_index]; } //! //! @brief Constant random access to the vectors. //! @param batch_index the batch index. //! @return The non-mutable pointer. //! const T* operator[](int64_t batch_index) const { return this->m_data[batch_index]; } //! //! @brief Cast to a double pointer. //! // clang-format off operator T**() // clang-format on { return this->m_data; } //! //! @brief Constant cast to a double pointer. //! operator const T* const *() { return this->m_data; } //! //! @brief Get data reinterpretted as hipblas_internal_type //! inline hipblas_internal_type** internal_type() { return reinterpret_cast**>(this->m_data); } //! //! @brief Copy from a host batched vector. //! @param that the vector the data is copied from. //! @return true if the copy is done successfully, false otherwise. //! bool copy_from(const host_batch_vector& that) { if((this->batch_count() == that.batch_count()) && (this->n() == that.n()) && (this->inc() == that.inc())) { size_t num_bytes = m_nmemb * sizeof(T) * m_batch_count; if(m_batch_count > 0) memcpy((*this)[0], that[0], num_bytes); return true; } else { return false; } } //! //! @brief Transfer from a device batched vector. //! @param that the vector the data is copied from. //! @return the hip error. //! hipError_t transfer_from(const device_batch_vector& that) { hipError_t hip_err; size_t num_bytes = m_nmemb * sizeof(T) * m_batch_count; if(m_batch_count > 0) { if(hipSuccess != (hip_err = hipMemcpy((*this)[0], that[0], num_bytes, hipMemcpyDeviceToHost))) { return hip_err; } } return hipSuccess; } //! //! @brief Check if memory exists. //! @return hipSuccess if memory exists, hipErrorOutOfMemory otherwise. //! hipError_t memcheck() const { return (nullptr != this->m_data) ? hipSuccess : hipErrorOutOfMemory; } private: int64_t m_n{}; int64_t m_inc{}; size_t m_nmemb{}; int64_t m_batch_count{}; T** m_data{}; static size_t calculate_nmemb(size_t n, int64_t inc) { // allocate when n is zero return 1 + ((n ? n : 1) - 1) * std::abs(inc ? inc : 1); } bool try_initialize_memory() { bool success = (nullptr != (this->m_data = (T**)host_calloc(this->m_batch_count, sizeof(T*)))); if(success) { size_t nmemb = size_t(this->m_n) * std::abs(this->m_inc); for(int64_t batch_index = 0; batch_index < this->m_batch_count; ++batch_index) { if(batch_index == 0) { success = (nullptr != (m_data[batch_index] = (T*)host_calloc(m_nmemb * m_batch_count, sizeof(T)))); if(false == success) { break; } } else { m_data[batch_index] = m_data[0] + batch_index * m_nmemb; } } } return success; } void free_memory() { if(nullptr != this->m_data) { for(int64_t batch_index = 0; batch_index < this->m_batch_count; ++batch_index) { if(batch_index == 0 && nullptr != this->m_data[batch_index]) { host_free(this->m_data[batch_index]); this->m_data[batch_index] = nullptr; } else { m_data[batch_index] = nullptr; } } host_free(this->m_data); this->m_data = nullptr; } } };