MemoryStorage.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (c) 2021.                                                        *
 * The Regents of the University of Michigan and DFT-EFE developers.          *
 *                                                                            *
 * This file is part of the DFT-EFE code.                                     *
 *                                                                            *
 * DFT-EFE is free software: you can redistribute it and/or modify            *
 *   it under the terms of the Lesser GNU General Public License as           *
 *   published by the Free Software Foundation, either version 3 of           *
 *   the License, or (at your option) any later version.                      *
 *                                                                            *
 * DFT-EFE is distributed in the hope that it will be useful, but             *
 *   WITHOUT ANY WARRANTY; without even the implied warranty                  *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                     *
 *   See the Lesser GNU General Public License for more details.              *
 *                                                                            *
 * You should have received a copy of the GNU Lesser General Public           *
 *   License at the top level of DFT-EFE distribution.  If not, see           *
 *   <https://www.gnu.org/licenses/>.                                         *
 ******************************************************************************/
 
/*
 * @author Ian C. Lin, Sambit Das.
 */
 
#ifndef dftefeMemoryStorage_h
#define dftefeMemoryStorage_h
 
#include <utils/MemoryManager.h>
#include <utils/TypeConfig.h>
#include <vector>
namespace dftefe
{
  namespace utils
  {
    template <typename ValueType, dftefe::utils::MemorySpace memorySpace>
    class MemoryStorage
    {
      //
      // typedefs
      //
    public:
      typedef ValueType        value_type;
      typedef ValueType *      pointer;
      typedef ValueType &      reference;
      typedef const ValueType &const_reference;
      typedef ValueType *      iterator;
      typedef const ValueType *const_iterator;
 
    public:
      MemoryStorage() = default;
 
      MemoryStorage(const MemoryStorage &u);
 
      MemoryStorage(MemoryStorage &&u) noexcept;
 
      explicit MemoryStorage(size_type size, ValueType initVal = ValueType());
 
      ~MemoryStorage();
 
      void
      setValue(const ValueType val);
 
      void
      setZero(size_type size, const size_type offset);
 
      iterator
      begin();
 
      const_iterator
      begin() const;
 
      iterator
      end();
 
      const_iterator
      end() const;
 
 
      MemoryStorage &
      operator=(const MemoryStorage &rhs);
 
 
      MemoryStorage &
      operator=(MemoryStorage &&rhs) noexcept;
 
      //      // This part does not work for GPU version, will work on this
      //      until
      //      // having cleaner solution.
      //      /**
      //       * @brief Operator to get a reference to a element of the Vector
      //       * @param[in] i is the index to the element of the Vector
      //       * @returns reference to the element of the Vector
      //       * @throws exception if i >= size of the Vector
      //       */
      //      reference
      //      operator[](size_type i);
      //
      //      /**
      //       * @brief Operator to get a const reference to a element of the Vector
      //       * @param[in] i is the index to the element of the Vector
      //       * @returns const reference to the element of the Vector
      //       * @throws exception if i >= size of the Vector
      //       */
      //      const_reference
      //      operator[](size_type i) const;
 
      void
      resize(size_type size, ValueType initVal = ValueType());
 
      size_type
      size() const;
 
      ValueType *
      data() noexcept;
 
      const ValueType *
      data() const noexcept;
 
      template <dftefe::utils::MemorySpace memorySpaceDst>
      void
      copyTo(MemoryStorage<ValueType, memorySpaceDst> &dstMemoryStorage) const;
 
      template <dftefe::utils::MemorySpace memorySpaceDst>
      void
      copyTo(MemoryStorage<ValueType, memorySpaceDst> &dstMemoryStorage,
             const size_type                           N,
             const size_type                           srcOffset,
             const size_type                           dstOffset) const;
 
      template <dftefe::utils::MemorySpace memorySpaceSrc>
      void
      copyFrom(
        const MemoryStorage<ValueType, memorySpaceSrc> &srcMemoryStorage);
 
      template <dftefe::utils::MemorySpace memorySpaceSrc>
      void
      copyFrom(MemoryStorage<ValueType, memorySpaceSrc> &srcMemoryStorage,
               const size_type                           N,
               const size_type                           srcOffset,
               const size_type                           dstOffset);
 
      template <dftefe::utils::MemorySpace memorySpaceDst>
      void
      copyTo(ValueType *dst) const;
 
      template <dftefe::utils::MemorySpace memorySpaceDst>
      void
      copyTo(ValueType *     dst,
             const size_type N,
             const size_type srcOffset,
             const size_type dstOffset) const;
 
      template <dftefe::utils::MemorySpace memorySpaceSrc>
      void
      copyFrom(const ValueType *src);
 
      template <dftefe::utils::MemorySpace memorySpaceSrc>
      void
      copyFrom(const ValueType *src,
               const size_type  N,
               const size_type  srcOffset,
               const size_type  dstOffset);
 
      void
      copyTo(std::vector<ValueType> &dst) const;
 
      void
      copyTo(std::vector<ValueType> &dst,
             const size_type         N,
             const size_type         srcOffset,
             const size_type         dstOffset) const;
 
      void
      copyFrom(const std::vector<ValueType> &src);
 
      void
      copyFrom(const std::vector<ValueType> &src,
               const size_type               N,
               const size_type               srcOffset,
               const size_type               dstOffset);
 
 
    private:
      ValueType *d_data = nullptr;
      size_type  d_size = 0;
    };
 
    //
    // helper functions
    //
 
    template <typename ValueType, utils::MemorySpace memorySpaceDst>
    MemoryStorage<ValueType, memorySpaceDst>
    memoryStorageFromSTL(const std::vector<ValueType> &src);
 
    template <typename ValueType, dftefe::utils::MemorySpace memorySpace>
    void
    swap(MemoryStorage<ValueType, memorySpace> &X,
         MemoryStorage<ValueType, memorySpace> &Y);
 
  } // namespace utils
} // end of namespace dftefe
 
#include "MemoryStorage.t.cpp"
 
#endif