MultiVectorImpl.h

Go to the documentation of this file.

/*
 * Copyright 2020 IFPEN-CEA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#pragma once
 
#include <iostream>
#include <map>
 
#include <alien/core/backend/BackEnd.h>
#include <alien/core/backend/VectorConverterRegisterer.h>
#include <alien/core/block/Block.h>
#include <alien/core/block/VBlock.h>
#include <alien/core/impl/IVectorImpl.h>
#include <alien/data/Space.h>
#include <alien/distribution/VectorDistribution.h>
#include <alien/utils/Precomp.h>
#include <alien/utils/UserFeatureMng.h>
#include <alien/utils/time_stamp/TimestampMng.h>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Alien
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ALIEN_EXPORT MultiVectorImpl : public TimestampMng
, public UserFeatureMng
, public ObjectWithTrace
{
 public:
  MultiVectorImpl();

  MultiVectorImpl(
  std::shared_ptr<ISpace> space, std::shared_ptr<VectorDistribution> dist);

  ~MultiVectorImpl() override;
 
 protected:
  MultiVectorImpl(const MultiVectorImpl& impl);
 
 public:
  MultiVectorImpl(MultiVectorImpl&& impl) = delete;
  void operator=(const MultiVectorImpl&) = delete;
  void operator=(MultiVectorImpl&&) = delete;
 
 public:
  void setBlockInfos(const Block* blocks);

  void setBlockInfos(const VBlock* blocks);

  void setBlockInfos(Arccore::Integer block_size);

  void free();

  void clear();

  const ISpace& space() const { return *m_space.get(); }

  const VectorDistribution& distribution() const { return *m_distribution.get(); }

  const Block* block() const;

  const VBlock* vblock() const;
 
 public:
  MultiVectorImpl* clone() const;

  template <typename tag>
  const typename AlgebraTraits<tag>::vector_type& get() const;

  template <typename tag>
  typename AlgebraTraits<tag>::vector_type& get(bool update_stamp);

  template <typename tag>
  void release() const;
 
 private:
  template <typename vector_type>
  IVectorImpl*& getImpl(BackEndId backend) const;

  void updateImpl(IVectorImpl* target) const;
 
 protected:
  template <typename vector_type>
  void insert(const BackEndId& backend, vector_type* v);
 
 private:
  std::shared_ptr<ISpace> m_space;
  std::shared_ptr<VectorDistribution> m_distribution;
  typedef std::map<BackEndId, IVectorImpl*> MultiVectorImplMap;
  mutable MultiVectorImplMap m_impls2;
  std::shared_ptr<Block> m_block;
  std::shared_ptr<VBlock> m_variable_block;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename tag>
const typename AlgebraTraits<tag>::vector_type&
MultiVectorImpl::get() const
{
  typedef typename AlgebraTraits<tag>::vector_type vector_type;
  IVectorImpl*& impl2 = getImpl<vector_type>(AlgebraTraits<tag>::name());
  ALIEN_ASSERT(
  (impl2->backend() == AlgebraTraits<tag>::name()), ("Inconsistent backend"));
  updateImpl(impl2);
  return *dynamic_cast<vector_type*>(impl2);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename tag>
typename AlgebraTraits<tag>::vector_type&
MultiVectorImpl::get(const bool update_stamp)
{
  typedef typename AlgebraTraits<tag>::vector_type vector_type;
  IVectorImpl*& impl2 = getImpl<vector_type>(AlgebraTraits<tag>::name());
  ALIEN_ASSERT(
  (impl2->backend() == AlgebraTraits<tag>::name()), ("Inconsistent backend"));
  updateImpl(impl2);
  if (update_stamp) {
    impl2->updateTimestamp();
  }
  return *dynamic_cast<vector_type*>(impl2);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename tag>
void MultiVectorImpl::release() const
{
  auto finder = m_impls2.find(AlgebraTraits<tag>::name());
  if (finder == m_impls2.end())
    return; // already freed
  delete finder->second, finder->second = NULL;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename vector_type>
IVectorImpl*&
MultiVectorImpl::getImpl(BackEndId backend) const
{
  auto inserter = m_impls2.insert(MultiVectorImplMap::value_type(backend, NULL));
  IVectorImpl*& impl2 = inserter.first->second;
  if (impl2 == NULL) {
    auto new_impl = new vector_type(this); // constructeur associ� � un multi-impl
    new_impl->init(*m_distribution.get(), true);
    impl2 = new_impl;
  }
  return impl2;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename vector_type>
void MultiVectorImpl::insert(const BackEndId& backend, vector_type* v)
{
  if (m_impls2.find(backend) != m_impls2.end()) {
    alien_fatal([&] { cout() << "try to insert already inserted value"; });
  }
  m_impls2[backend] = v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Alien
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/