task_info.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2011 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------


#ifndef dealii_matrix_free_task_info_h
#define dealii_matrix_free_task_info_h


#include <deal.II/base/exceptions.h>
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/index_set.h>
#include <deal.II/base/utilities.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/base/vectorization.h>
#include <deal.II/lac/dynamic_sparsity_pattern.h>


DEAL_II_NAMESPACE_OPEN



namespace internal
{
  struct MFWorkerInterface
  {
  public:
    virtual ~MFWorkerInterface() {}

    virtual void vector_update_ghosts_start() = 0;

    virtual void vector_update_ghosts_finish() = 0;

    virtual void vector_compress_start() = 0;

    virtual void vector_compress_finish() = 0;

    virtual void zero_dst_vector_range(const unsigned int range_index) = 0;

    virtual void cell(const std::pair<unsigned int,unsigned int> &cell_range) = 0;

    virtual void face(const std::pair<unsigned int,unsigned int> &face_range) = 0;

    virtual void boundary(const std::pair<unsigned int,unsigned int> &face_range) = 0;
  };



  namespace MatrixFreeFunctions
  {
    // forward declaration of internal data structure
    template <typename Number> struct ConstraintValues;

    struct TaskInfo
    {
      // enum for choice of how to build the task graph. Odd add versions with
      // preblocking and even versions with postblocking. partition_partition
      // and partition_color are deprecated but kept for backward
      // compatibility.
      enum TasksParallelScheme {none,
                                partition_partition,
                                partition_color,
                                color
                               };

      TaskInfo ();

      void clear ();

      void loop(MFWorkerInterface &worker) const;

      void collect_boundary_cells (const unsigned int n_active_cells,
                                   const unsigned int n_active_and_ghost_cells,
                                   const unsigned int vectorization_length,
                                   std::vector<unsigned int> &boundary_cells);

      void
      create_blocks_serial (const std::vector<unsigned int> &boundary_cells,
                            const std::vector<unsigned int> &cells_close_to_boundary,
                            const unsigned int               dofs_per_cell,
                            const std::vector<unsigned int> &cell_vectorization_categories,
                            const bool cell_vectorization_categories_strict,
                            std::vector<unsigned int>       &renumbering,
                            std::vector<unsigned char>      &incompletely_filled_vectorization);

      void
      initial_setup_blocks_tasks (const std::vector<unsigned int> &boundary_cells,
                                  std::vector<unsigned int>       &renumbering,
                                  std::vector<unsigned char>      &incompletely_filled_vectorization);

      void guess_block_size (const unsigned int dofs_per_cell);

      void
      make_thread_graph_partition_color (DynamicSparsityPattern     &connectivity,
                                         std::vector<unsigned int>  &renumbering,
                                         std::vector<unsigned char> &irregular_cells,
                                         const bool                 hp_bool);

      void
      make_thread_graph_partition_partition (const std::vector<unsigned int> &cell_active_fe_index,
                                             DynamicSparsityPattern     &connectivity,
                                             std::vector<unsigned int>  &renumbering,
                                             std::vector<unsigned char> &irregular_cells,
                                             const bool                 hp_bool);

      void
      make_thread_graph (const std::vector<unsigned int> &cell_active_fe_index,
                         DynamicSparsityPattern     &connectivity,
                         std::vector<unsigned int>  &renumbering,
                         std::vector<unsigned char> &irregular_cells,
                         const bool                 hp_bool);

      void make_connectivity_cells_to_blocks
      (const std::vector<unsigned char> &irregular_cells,
       const DynamicSparsityPattern     &connectivity_cells,
       DynamicSparsityPattern           &connectivity_blocks) const;

      void make_coloring_within_partitions_pre_blocked
      (const DynamicSparsityPattern          &connectivity,
       const unsigned int                    partition,
       const std::vector<unsigned int>       &cell_partition,
       const std::vector<unsigned int>       &partition_list,
       const std::vector<unsigned int>       &partition_size,
       std::vector<unsigned int>             &partition_color_list);

      void make_partitioning_within_partitions_post_blocked
      (const DynamicSparsityPattern          &connectivity,
       const std::vector<unsigned int>       &cell_active_fe_index,
       const unsigned int                    partition,
       const unsigned int                    cluster_size,
       const bool                            hp_bool,
       const std::vector<unsigned int>       &cell_partition,
       const std::vector<unsigned int>       &partition_list,
       const std::vector<unsigned int>       &partition_size,
       std::vector<unsigned int>             &partition_partition_list,
       std::vector<unsigned char>            &irregular_cells);

      void
      make_partitioning (const DynamicSparsityPattern &connectivity,
                         const unsigned int            cluster_size,
                         std::vector<unsigned int>    &cell_partition,
                         std::vector<unsigned int>    &partition_list,
                         std::vector<unsigned int>    &partition_size,
                         unsigned int                 &partition) const;

      void
      update_task_info (const unsigned int     partition);

      void create_flow_graph();

      std::size_t memory_consumption () const;

      template <typename StreamType>
      void print_memory_statistics (StreamType &out,
                                    std::size_t data_length) const;

      unsigned int n_active_cells;

      unsigned int n_ghost_cells;

      unsigned int vectorization_length;

      unsigned int block_size;

      unsigned int n_blocks;

      TasksParallelScheme scheme;

      std::vector<unsigned int> partition_row_index;

      std::vector<unsigned int> cell_partition_data;

      std::vector<unsigned int> face_partition_data;

      std::vector<unsigned int> boundary_partition_data;

      std::vector<unsigned int> ghost_face_partition_data;

      std::vector<unsigned int> refinement_edge_face_partition_data;

      std::vector<unsigned int> partition_evens;

      std::vector<unsigned int> partition_odds;

      std::vector<unsigned int> partition_n_blocked_workers;

      std::vector<unsigned int> partition_n_workers;

      unsigned int evens;

      unsigned int odds;

      unsigned int n_blocked_workers;

      unsigned int n_workers;

      std::vector<unsigned char> task_at_mpi_boundary;

      MPI_Comm communicator;

      unsigned int my_pid;

      unsigned int n_procs;
    };

    DEAL_II_DEPRECATED
    typedef TaskInfo SizeInfo;

  } // end of namespace MatrixFreeFunctions
} // end of namespace internal

DEAL_II_NAMESPACE_CLOSE

#endif