mpi_noncontiguous_partitioner.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2020 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_mpi_noncontiguous_partitioner_h
#define dealii_mpi_noncontiguous_partitioner_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/communication_pattern_base.h>
#include <deal.II/base/mpi_stub.h>
 
#include <deal.II/lac/vector_operation.h>
 
 
DEAL_II_NAMESPACE_OPEN
 
namespace Utilities
{
  namespace MPI
  {
    class NoncontiguousPartitioner
      : public Utilities::MPI::CommunicationPatternBase
    {
    public:
      NoncontiguousPartitioner() = default;
 
      NoncontiguousPartitioner(const IndexSet &indexset_locally_owned,
                               const IndexSet &indexset_ghost,
                               const MPI_Comm  communicator);
 
      NoncontiguousPartitioner(
        const std::vector<types::global_dof_index> &indices_locally_owned,
        const std::vector<types::global_dof_index> &indices_ghost,
        const MPI_Comm                              communicator);
 
      template <typename Number, unsigned int n_components_templated = 1>
      void
      export_to_ghosted_array(
        const ArrayView<const Number> &locally_owned_array,
        const ArrayView<Number>       &ghost_array,
        const unsigned int             n_components = 0) const;
 
      template <typename Number, unsigned int n_components_templated = 1>
      void
      export_to_ghosted_array(
        const unsigned int             communication_channel,
        const ArrayView<const Number> &locally_owned_array,
        const ArrayView<Number>       &temporary_storage,
        const ArrayView<Number>       &ghost_array,
        std::vector<MPI_Request>      &requests,
        const unsigned int             n_components = 0) const;
 
      template <typename Number, unsigned int n_components_templated = 1>
      void
      export_to_ghosted_array_start(
        const unsigned int             communication_channel,
        const ArrayView<const Number> &locally_owned_array,
        const ArrayView<Number>       &temporary_storage,
        std::vector<MPI_Request>      &requests,
        const unsigned int             n_components = 0) const;
 
      template <typename Number, unsigned int n_components_templated = 1>
      void
      export_to_ghosted_array_finish(
        const ArrayView<const Number> &temporary_storage,
        const ArrayView<Number>       &ghost_array,
        std::vector<MPI_Request>      &requests,
        const unsigned int             n_components = 0) const;
 
      template <typename Number>
      void
      import_from_ghosted_array(
        const VectorOperation::values vector_operation,
        const ArrayView<Number>      &ghost_array,
        const ArrayView<Number>      &locally_owned_storage) const;
 
      template <typename Number>
      void
      import_from_ghosted_array(const VectorOperation::values vector_operation,
                                const unsigned int        communication_channel,
                                const ArrayView<Number>  &ghost_array,
                                const ArrayView<Number>  &temporary_storage,
                                const ArrayView<Number>  &locally_owned_storage,
                                std::vector<MPI_Request> &requests) const;
 
      template <typename Number>
      void
      import_from_ghosted_array_start(
        const VectorOperation::values vector_operation,
        const unsigned int            communication_channel,
        const ArrayView<Number>      &ghost_array,
        const ArrayView<Number>      &temporary_storage,
        std::vector<MPI_Request>     &requests) const;
 
      template <typename Number>
      void
      import_from_ghosted_array_finish(
        const VectorOperation::values  vector_operation,
        const ArrayView<const Number> &temporary_storage,
        const ArrayView<Number>       &locally_owned_storage,
        std::vector<MPI_Request>      &requests) const;
 
      std::pair<unsigned int, unsigned int>
      n_targets() const;
 
      unsigned int
      temporary_storage_size() const;
 
      types::global_dof_index
      memory_consumption();
 
      MPI_Comm
      get_mpi_communicator() const override;
 
      void
      reinit(const IndexSet &locally_owned_indices,
             const IndexSet &ghost_indices,
             const MPI_Comm  communicator) override;
 
      void
      reinit(const std::vector<types::global_dof_index> &locally_owned_indices,
             const std::vector<types::global_dof_index> &ghost_indices,
             const MPI_Comm                              communicator);
 
    private:
      MPI_Comm communicator;
 
      std::vector<unsigned int> send_ranks;
 
      std::vector<types::global_dof_index> send_ptr;
 
      std::vector<types::global_dof_index> send_indices;
 
      std::vector<unsigned int> recv_ranks;
 
      std::vector<types::global_dof_index> recv_ptr;
 
      std::vector<types::global_dof_index> recv_indices;
 
      mutable std::vector<std::uint8_t> buffers;
 
      mutable std::vector<MPI_Request> requests;
    };
 
  } // namespace MPI
} // namespace Utilities
 
DEAL_II_NAMESPACE_CLOSE
 
#endif