task_info.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2011 - 2020 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>

#include <deal.II/lac/dynamic_sparsity_pattern.h>


DEAL_II_NAMESPACE_OPEN



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
    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
  {
    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> 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;
    };

    using SizeInfo DEAL_II_DEPRECATED = TaskInfo;

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

DEAL_II_NAMESPACE_CLOSE

#endif