]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Generalize FEEvaluationBase::read_write_operation_contiguous for SM 11082/head
authorPeter Munch <peterrmuench@gmail.com>
Thu, 22 Oct 2020 13:25:03 +0000 (15:25 +0200)
committerPeter Munch <peterrmuench@gmail.com>
Sat, 24 Oct 2020 12:48:02 +0000 (14:48 +0200)
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/matrix_free/vector_access_internal.h

index e3269ebe28ef9def9596584bcfca836b7bbe7889..759c64f7fed1689a3a165f7b86e9889616331582 100644 (file)
@@ -4597,8 +4597,6 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
       n_components_> &                              vectors_sm,
     const std::bitset<VectorizedArrayType::size()> &mask) const
 {
-  (void)vectors_sm; // TODO: use it
-
   // This functions processes the functions read_dof_values,
   // distribute_local_to_global, and set_dof_values with the same code for
   // contiguous cell indices (DG case). The distinction between these three
@@ -4665,6 +4663,96 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
   for (unsigned int v = n_filled_lanes; v < VectorizedArrayType::size(); ++v)
     dof_indices[v] = numbers::invalid_unsigned_int;
 
+  if (vectors_sm[0] != nullptr)
+    {
+      const auto compute_vector_ptrs = [&](const unsigned int comp) {
+        std::array<typename VectorType::value_type *,
+                   VectorizedArrayType::size()>
+          vector_ptrs = {};
+
+        (void)comp;
+
+        /*
+        for (unsigned int v = 0; v < n_filled_lanes; ++v)
+          {
+            const auto &temp =
+              this->dof_info->dof_indices_contiguous_sm
+                [ind][this->cell * VectorizedArrayType::size() + v];
+
+            if (temp.first != numbers::invalid_unsigned_int)
+              vector_ptrs[v] = const_cast<typename VectorType::value_type *>(
+                vectors_sm[comp]->operator[](temp.first).data() + temp.second);
+            else
+              vector_ptrs[v] = nullptr;
+          }
+        for (unsigned int v = n_filled_lanes; v < VectorizedArrayType::size();
+             ++v)
+          vector_ptrs[v] = nullptr;
+         */
+
+        return vector_ptrs;
+      };
+
+      if (n_filled_lanes == VectorizedArrayType::size() &&
+          n_lanes == VectorizedArrayType::size())
+        {
+          if (n_components == 1 || n_fe_components == 1)
+            for (unsigned int comp = 0; comp < n_components; ++comp)
+              {
+                auto vector_ptrs = compute_vector_ptrs(comp);
+
+                operation.process_dofs_vectorized_transpose(
+                  this->data->dofs_per_component_on_cell,
+                  vector_ptrs,
+                  values_dofs[comp],
+                  vector_selector);
+              }
+          else
+            {
+              auto vector_ptrs = compute_vector_ptrs(0);
+              operation.process_dofs_vectorized_transpose(
+                this->data->dofs_per_component_on_cell * n_components,
+                vector_ptrs,
+                &values_dofs[0][0],
+                vector_selector);
+            }
+        }
+      else
+        for (unsigned int comp = 0; comp < n_components; ++comp)
+          {
+            auto vector_ptrs = compute_vector_ptrs(comp);
+
+            for (unsigned int i = 0; i < this->data->dofs_per_component_on_cell;
+                 ++i)
+              operation.process_empty(values_dofs[comp][i]);
+
+            if (n_components == 1 || n_fe_components == 1)
+              {
+                for (unsigned int v = 0; v < n_filled_lanes; ++v)
+                  if (mask[v] == true)
+                    for (unsigned int i = 0;
+                         i < this->data->dofs_per_component_on_cell;
+                         ++i)
+                      operation.process_dof(vector_ptrs[v][i],
+                                            values_dofs[comp][i][v]);
+              }
+            else
+              {
+                for (unsigned int v = 0; v < n_filled_lanes; ++v)
+                  if (mask[v] == true)
+                    for (unsigned int i = 0;
+                         i < this->data->dofs_per_component_on_cell;
+                         ++i)
+                      operation.process_dof(
+                        vector_ptrs[v]
+                                   [i + comp * this->data
+                                                 ->dofs_per_component_on_cell],
+                        values_dofs[comp][i][v]);
+              }
+          }
+      return;
+    }
+
   // In the case with contiguous cell indices, we know that there are no
   // constraints and that the indices within each element are contiguous
   if (n_filled_lanes == VectorizedArrayType::size() &&
@@ -4859,7 +4947,9 @@ namespace internal
   const std::vector<ArrayView<const typename VectorType::value_type>> *
   get_shared_vector_data(VectorType &vec /*other parameters?*/)
   {
-    return &vec.shared_vector_data();
+    // return &vec.shared_vector_data();
+    (void)vec;
+    return nullptr;
   }
 
   template <typename VectorType,
index 6244ee7fbbe18f6fcfafa0c77487e4ddf374877e..1874593d6122188f6252245630cd99d9957ea105 100644 (file)
@@ -227,6 +227,15 @@ namespace internal
 
 
 
+    template <typename VectorNumberType>
+    void
+    process_dof(const VectorNumberType &global, Number &local) const
+    {
+      local = global;
+    }
+
+
+
     template <typename VectorType>
     void
     process_dofs_vectorized(const unsigned int   dofs_per_cell,
@@ -290,6 +299,34 @@ namespace internal
 
 
 
+    template <typename Number2>
+    void
+    process_dofs_vectorized_transpose(
+      const unsigned int                                        dofs_per_cell,
+      const std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
+      VectorizedArrayType *                                     dof_values,
+      std::integral_constant<bool, true>) const
+    {
+      dealii::vectorized_load_and_transpose(dofs_per_cell,
+                                            global_ptr,
+                                            dof_values);
+    }
+
+
+
+    template <typename Number2>
+    void
+    process_dofs_vectorized_transpose(
+      const unsigned int,
+      const std::array<Number2 *, VectorizedArrayType::size()> &,
+      VectorizedArrayType *,
+      std::integral_constant<bool, false>) const
+    {
+      Assert(false, ExcNotImplemented());
+    }
+
+
+
     // variant where VectorType::value_type is the same as Number -> can call
     // gather
     template <typename VectorType>
@@ -382,6 +419,14 @@ namespace internal
     }
 
 
+    template <typename VectorNumberType>
+    void
+    process_dof(VectorNumberType &global, Number &local) const
+    {
+      global += local;
+    }
+
+
 
     template <typename VectorType>
     void
@@ -450,6 +495,35 @@ namespace internal
 
 
 
+    template <typename Number2>
+    void
+    process_dofs_vectorized_transpose(
+      const unsigned int                                  dofs_per_cell,
+      std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
+      VectorizedArrayType *                               dof_values,
+      std::integral_constant<bool, true>) const
+    {
+      vectorized_transpose_and_store(true,
+                                     dofs_per_cell,
+                                     dof_values,
+                                     global_ptr);
+    }
+
+
+
+    template <typename Number2>
+    void
+    process_dofs_vectorized_transpose(
+      const unsigned int,
+      std::array<Number2 *, VectorizedArrayType::size()> &,
+      VectorizedArrayType *,
+      std::integral_constant<bool, false>) const
+    {
+      Assert(false, ExcNotImplemented());
+    }
+
+
+
     // variant where VectorType::value_type is the same as Number -> can call
     // scatter
     template <typename VectorType>
@@ -547,6 +621,15 @@ namespace internal
 
 
 
+    template <typename VectorNumberType>
+    void
+    process_dof(VectorNumberType &global, Number &local) const
+    {
+      global = local;
+    }
+
+
+
     template <typename VectorType>
     void
     process_dofs_vectorized(const unsigned int   dofs_per_cell,
@@ -608,6 +691,35 @@ namespace internal
 
 
 
+    template <typename Number2>
+    void
+    process_dofs_vectorized_transpose(
+      const unsigned int                                  dofs_per_cell,
+      std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
+      VectorizedArrayType *                               dof_values,
+      std::integral_constant<bool, true>) const
+    {
+      vectorized_transpose_and_store(false,
+                                     dofs_per_cell,
+                                     dof_values,
+                                     global_ptr);
+    }
+
+
+
+    template <typename Number2>
+    void
+    process_dofs_vectorized_transpose(
+      const unsigned int,
+      std::array<Number2 *, VectorizedArrayType::size()> &,
+      VectorizedArrayType *,
+      std::integral_constant<bool, false>) const
+    {
+      Assert(false, ExcNotImplemented());
+    }
+
+
+
     template <typename VectorType>
     void
     process_dof_gather(const unsigned int * indices,

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.