task_info.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2011 - 2021 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.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
 
#ifndef dealii_matrix_free_task_info_h
#define dealii_matrix_free_task_info_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/index_set.h>
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/base/utilities.h>
#include <deal.II/base/vectorization.h>
 
 
DEAL_II_NAMESPACE_OPEN
 
 
// forward declaration
#ifndef DOXYGEN
class DynamicSparsityPattern;
#endif
 
 
namespace internal
{
  struct MFWorkerInterface
  {
  public:
    virtual ~MFWorkerInterface() = default;
 
    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_loop_pre_range(const unsigned int range_index) = 0;
 
    virtual void
    cell_loop_post_range(const unsigned int range_index) = 0;
 
    virtual void
    cell(const std::pair<unsigned int, unsigned int> &cell_range) = 0;
 
    virtual void
    cell(const unsigned int range_index) = 0;
 
    virtual void
    face(const unsigned int range_index) = 0;
 
    virtual void
    boundary(const unsigned int range_index) = 0;
  };
 
 
 
  namespace MatrixFreeFunctions
  {
    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
      make_boundary_cells_divisible(std::vector<unsigned int> &boundary_cells);
 
      void
      create_blocks_serial(
        const std::vector<unsigned int> &cells_with_comm,
        const unsigned int               dofs_per_cell,
        const bool                       categories_are_hp,
        const std::vector<unsigned int> &cell_vectorization_categories,
        const bool                       cell_vectorization_categories_strict,
        const std::vector<unsigned int> &parent_relation,
        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> cell_partition_data_hp;
 
      std::vector<unsigned int> cell_partition_data_hp_ptr;
 
      std::vector<unsigned int> face_partition_data;
 
      std::vector<unsigned int> face_partition_data_hp;
 
      std::vector<unsigned int> face_partition_data_hp_ptr;
 
      std::vector<unsigned int> boundary_partition_data;
 
      std::vector<unsigned int> boundary_partition_data_hp;
 
      std::vector<unsigned int> boundary_partition_data_hp_ptr;
 
      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;
 
      MPI_Comm communicator_sm;
 
      bool allow_ghosted_vectors_in_loops;
 
      unsigned int my_pid;
 
      unsigned int n_procs;
    };
 
  } // end of namespace MatrixFreeFunctions
} // end of namespace internal
 
DEAL_II_NAMESPACE_CLOSE
 
#endif