Average To Nodes

ScatterView averaging elements to nodes

In order to demonstrate a typical use case for Kokkos::ScatterView, we can think of a finite element program where the only information available is a mapping from elements to nodes, and we would like to average some quantity from the elements to the nodes. This average is the ratio of two sums, namely the sum of the adjacent element quantities divided by the sum of adjacent elements.

Computing the number of adjacent elements

Even just computing the number of elements adjacent to a node will already demonstrate most of the necessary workflow around Kokkos::ScatterView. The algorithm is as follows: we will iterate over mesh elements, in parallel, and each mesh element will identify its nodes and add one to an array entry specific to that node. Those entries are ultimately stored in a Kokkos::View with one entry per node, but during the algorithm they will be accessed through a Kokkos::ScatterView in order to prevent data races.

Kokkos::View<int*> count_adjacent_elements(Kokkos::View<int**> elements_to_nodes, int number_of_nodes) {
  Kokkos::View<int*> elements_per_node("elements_per_node", number_of_nodes);
  auto scatter_elements_per_node = Kokkos::Experimental::create_scatter_view(elements_per_node);
  Kokkos::parallel_for(elements_to_nodes.extent(0), KOKKOS_LAMBDA(int element) {
    auto access_elements_per_node = scatter_elements_per_node.access();
    for (int node_of_element = 0; node_of_element < elements_to_nodes.extent(1); ++node_of_element) {
      int node = elements_to_nodes(element, node_of_element);
      access_elements_per_node(node) += 1;
    }
  });
  Kokkos::Experimental::contribute(elements_per_node, scatter_elements_per_node);
  return elements_per_node;
}

Computing the value sums at nodes

Computing the sum of the element values adjacent to a node is almost identical to computing the number of elements around a node:

Kokkos::View<double*> sum_to_nodes(Kokkos::View<int**> elements_to_nodes, int number_of_nodes,
    Kokkos::View<double*> element_values) {
  Kokkos::View<double*> node_values("node_values", number_of_nodes);
  auto scatter_node_values = Kokkos::Experimental::create_scatter_view(node_values);
  Kokkos::parallel_for(elements_to_nodes.extent(0), KOKKOS_LAMBDA(int element) {
    auto access_node_values = scatter_node_values.access();
    for (int node_of_element = 0; node_of_element < elements_to_nodes.extent(1); ++node_of_element) {
      int node = elements_to_nodes(element, node_of_element);
      access_node_values(node) += element_values(element);
    }
  });
  Kokkos::Experimental::contribute(node_values, scatter_node_values);
  return node_values;
}

Computing the full average

Now that we have two sums at each node, it is sufficient to use one final loop over nodes to take the ratio of these two sums and define the average. This function will be structured by assuming that the number of elements adjacent to each node has been pre-computed.

Kokkos::View<double*> average_to_nodes(Kokkos::View<int**> elements_to_nodes, int number_of_nodes,
    Kokkos::View<double*> element_values,
    Kokkos::View<int*> elements_per_node) {
  auto node_values = sum_to_nodes(elements_to_nodes, number_of_nodes, element_values);
  Kokkos::parallel_for(number_of_nodes, KOKKOS_LAMBDA(int node) {
    node_values[node] /= elements_per_node[node];
  });
  return node_values;
}