MultiMatrixImpl.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 <map>
 
#include <alien/core/backend/BackEnd.h>
#include <alien/core/backend/MatrixConverterRegisterer.h>
#include <alien/core/block/Block.h>
#include <alien/core/block/VBlock.h>
#include <alien/core/impl/IMatrixImpl.h>
#include <alien/data/Space.h>
#include <alien/distribution/MatrixDistribution.h>
#include <alien/utils/ObjectWithLock.h>
#include <alien/utils/Precomp.h>
#include <alien/utils/UserFeatureMng.h>
#include <alien/utils/time_stamp/TimestampMng.h>
#include <cstdlib>
#include <iostream>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Alien
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ALIEN_EXPORT MultiMatrixImpl : public TimestampMng
, public UserFeatureMng
, public ObjectWithTrace
, public ObjectWithLock
{
 public:
  MultiMatrixImpl();

  MultiMatrixImpl(std::shared_ptr<ISpace> row_space, std::shared_ptr<ISpace> col_space,
                  std::shared_ptr<MatrixDistribution> dist);

  virtual ~MultiMatrixImpl();
 
 protected:
  MultiMatrixImpl(const MultiMatrixImpl& impl);
 
 public:
  void setBlockInfos(Arccore::Integer block_size);

  void setBlockInfos(const Block* blocks);

  void setBlockInfos(const VBlock* blocks);

  void setRowBlockInfos(const VBlock* blocks);

  void setColBlockInfos(const VBlock* blocks);

  void free();
  void clear();

  const ISpace& rowSpace() const { return *m_row_space.get(); }

  const ISpace& colSpace() const { return *m_col_space.get(); }

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

  const Block* block() const;

  const VBlock* vblock() const;

  const VBlock* rowBlock() const;

  const VBlock* colBlock() const;
 
 public:
  template <typename tag>
  const typename AlgebraTraits<tag>::matrix_type& get() const;

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

  template <typename tag>
  void release() const;

  MultiMatrixImpl* clone() const;
 
  // TOCHECK : should be removed or not ?
  //  void setTimestamp(Int64 stamp)
  //  {
  //    TimestampMng::setTimestamp(stamp);
  //  }
 
 private:
  template <typename matrix_type>
  IMatrixImpl*& getImpl(BackEndId backend) const;

  void updateImpl(IMatrixImpl* target) const;
 
 protected:
  template <typename matrix_type>
  void insert(BackEndId backend, matrix_type* m);
 
 private:
  std::shared_ptr<ISpace> m_row_space;
  std::shared_ptr<ISpace> m_col_space;
  std::shared_ptr<MatrixDistribution> m_distribution;
  typedef std::map<BackEndId, IMatrixImpl*> MultiMatrixImplMap;
  mutable MultiMatrixImplMap m_impls2;
  std::shared_ptr<Block> m_block;
  std::shared_ptr<VBlock> m_rows_block;
  std::shared_ptr<VBlock> m_cols_block;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename tag>
const typename AlgebraTraits<tag>::matrix_type&
MultiMatrixImpl::get() const
{
  // TOCHECK : to be removed or not ?
  //  ALIEN_ASSERT(!m_row_space.isNull(), ("Null row space matrix access"));
  //  ALIEN_ASSERT(!m_col_space.isNull(), ("Null col space matrix access"));
  typedef typename AlgebraTraits<tag>::matrix_type matrix_type;
  IMatrixImpl*& impl2 = getImpl<matrix_type>(AlgebraTraits<tag>::name());
  ALIEN_ASSERT(
  (impl2->backend() == AlgebraTraits<tag>::name()), ("Inconsistent backend"));
  updateImpl(impl2);
  return *dynamic_cast<matrix_type*>(impl2);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename tag>
typename AlgebraTraits<tag>::matrix_type&
MultiMatrixImpl::get(const bool update_stamp)
{
  // TOCHECK : to be removed or not ?
  //  ALIEN_ASSERT(!m_row_space.isNull(), ("Null row space matrix access"));
  //  ALIEN_ASSERT(!m_col_space.isNull(), ("Null col space matrix access"));
  typedef typename AlgebraTraits<tag>::matrix_type matrix_type;
  IMatrixImpl*& impl2 = getImpl<matrix_type>(AlgebraTraits<tag>::name());
  ALIEN_ASSERT(
  (impl2->backend() == AlgebraTraits<tag>::name()), ("Inconsistent backend"));
  updateImpl(impl2);
  if (update_stamp)
    impl2->updateTimestamp();
  return *dynamic_cast<matrix_type*>(impl2);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename tag>
void MultiMatrixImpl::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 matrix_type>
IMatrixImpl*&
MultiMatrixImpl::getImpl(BackEndId backend) const
{
  auto inserter = m_impls2.insert(MultiMatrixImplMap::value_type(backend, NULL));
  IMatrixImpl*& impl2 = inserter.first->second;
  if (impl2 == NULL) {
    matrix_type* new_impl = new matrix_type(this); // constructeur associé à un multi-impl
    //    new_impl->init(*m_row_space.get(),
    //                   *m_col_space.get(),
    //                   m_distribution);
    impl2 = new_impl;
  }
  return impl2;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename matrix_type>
void MultiMatrixImpl::insert(BackEndId backend, matrix_type* m)
{
  if (m_impls2.find(backend) != m_impls2.end()) {
    alien_fatal([&] { cout() << "try to insert already inserted value"; });
  }
  m_impls2[backend] = m;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Alien
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/