Tpetra_Apply_Helpers.hpp

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TPETRA_APPLY_HELPERS_HPP
#define TPETRA_APPLY_HELPERS_HPP
#include <type_traits>
#include "Teuchos_ScalarTraits.hpp"
#include "Tpetra_CrsMatrix.hpp"
#include "Tpetra_Details_Profiling.hpp"
 
namespace Tpetra {
 
 
 
template <class MatrixArray, class MultiVectorArray>
void batchedApply(const MatrixArray &Matrices,
                  const typename std::remove_pointer<typename MultiVectorArray::value_type>::type &X,
                  MultiVectorArray &Y,
                  typename std::remove_pointer<typename MatrixArray::value_type>::type::scalar_type alpha = Teuchos::ScalarTraits<typename std::remove_pointer<typename MatrixArray::value_type>::type::scalar_type>::one(),
                  typename std::remove_pointer<typename MatrixArray::value_type>::type::scalar_type beta  = Teuchos::ScalarTraits<typename std::remove_pointer<typename MatrixArray::value_type>::type::scalar_type>::zero(),
                  Teuchos::RCP<Teuchos::ParameterList> params                                             = Teuchos::null) {
  Tpetra::Details::ProfilingRegion regionTotal("Tpetra::batchedApply");
 
  using size_type   = typename MatrixArray::size_type;
  using matrix_type = typename std::remove_pointer<typename MatrixArray::value_type>::type;
  using map_type    = typename matrix_type::map_type;
  using import_type = typename matrix_type::import_type;
  using export_type = typename matrix_type::export_type;
  using MV          = typename matrix_type::MV;
  using scalar_type = typename matrix_type::scalar_type;
 
  using Teuchos::RCP;
  using Teuchos::rcp_const_cast;
 
  const scalar_type ONE  = Teuchos::ScalarTraits<scalar_type>::one();
  const scalar_type ZERO = Teuchos::ScalarTraits<scalar_type>::zero();
 
  size_type N = Matrices.size();
  if (N == 0) return;
  int numRanks = X.getMap()->getComm()->getSize();
 
  // If X is aliased to any Y but the last one, throw
  for (size_type i = 0; i < N - 1; i++) {
    TEUCHOS_TEST_FOR_EXCEPTION(&X == Y[i], std::runtime_error, "Tpetra::batchedApply(): X cannot be aliased to any Y except the final one.");
  }
 
  /* Checks for whether the reduced communication path can be used */
  RCP<const map_type> compare_colMap = Matrices[0]->getColMap();
  RCP<const import_type> importer    = Matrices[0]->getGraph()->getImporter();
 
  bool can_batch, check_maps;
  if (params.is_null() || !params->isParameter("can batch")) {
    can_batch  = (importer.is_null() || N == 1) ? false : true;
    check_maps = true;
  } else {
    can_batch  = (!params->get<bool>("can batch") || importer.is_null() || N == 1) ? false : true;
    check_maps = false;
  }
  // We can't batch with replicated Y's
  if (numRanks > 1) {
    for (size_type i = 0; i < N && can_batch; i++) {
      if (!Y[i]->isDistributed())
        can_batch = false;
    }
  }
 
  // Do the domain/column maps all match?
  for (size_type i = 1; i < N && check_maps && can_batch; i++) {
    if (!Matrices[i]->getColMap()->isSameAs(*compare_colMap)) {
      can_batch = false;
    }
  }
 
  if (can_batch) {
    /* Batching path: Guarantees an existing importer and N>1 */
 
    // Special case for alpha = 0
    if (alpha == ZERO) {
      if (beta == ZERO) {
        for (size_type i = 0; i < N; i++) Y[i]->putScalar(ZERO);
      } else if (beta != ONE) {
        for (size_type i = 0; i < N; i++) Y[i]->scale(beta);
      }
      if (!params.is_null()) params->set("can batch", true);
      return;
    }
 
    const bool Y_is_overwritten = (beta == ZERO);
 
    // Start by importing X to Matrices[0]'s temporary
    RCP<const MV> X_colMap;
    {
      Tpetra::Details::ProfilingRegion regionImport("Tpetra::batchedApply: Import");
      RCP<MV> X_colMapNonConst = Matrices[0]->getColumnMapMultiVector(X);
 
      // Import from the domain Map MV to the column Map MV.
      X_colMapNonConst->doImport(X, *importer, INSERT);
      X_colMap = rcp_const_cast<const MV>(X_colMapNonConst);
    }
 
    for (size_type i = 0; i < N; i++) {
      RCP<const export_type> exporter = Matrices[i]->getGraph()->getExporter();
 
      // Temporary MV for doExport (if needed),
      RCP<MV> Y_rowMap = Matrices[i]->getRowMapMultiVector(*Y[i]);
      if (!exporter.is_null()) {
        Matrices[i]->localApply(*X_colMap, *Y_rowMap, Teuchos::NO_TRANS, alpha, ZERO);
        {
          Tpetra::Details::ProfilingRegion regionExport("Tpetra::batchedApply: Export");
          if (Y_is_overwritten) {
            Y[i]->putScalar(ZERO);
          } else {
            Y[i]->scale(beta);
          }
          Y[i]->doExport(*Y_rowMap, *exporter, ADD_ASSIGN);
        }
      } else {  // Don't do an Export: row Map and range Map are the same.
        // Check for aliasing
        if (!Y[i]->isConstantStride() || X_colMap.getRawPtr() == Y[i]) {
          Y_rowMap = Matrices[i]->getRowMapMultiVector(*Y[i], true);
          if (beta != ZERO) {
            Tpetra::deep_copy(*Y_rowMap, *Y[i]);
          }
 
          Matrices[i]->localApply(*X_colMap, *Y_rowMap, Teuchos::NO_TRANS, alpha, beta);
          Tpetra::deep_copy(*Y[i], *Y_rowMap);
        } else {
          Matrices[i]->localApply(*X_colMap, *Y[i], Teuchos::NO_TRANS, alpha, beta);
        }
      }
    }
    if (!params.is_null()) params->set("can batch", true);
  } else {
    /* Non-batching path */
    for (size_type i = 0; i < N; i++) {
      Matrices[i]->apply(X, *Y[i], Teuchos::NO_TRANS, alpha, beta);
    }
    if (!params.is_null()) params->set("can batch", false);
  }
}
 
}  // namespace Tpetra
 
#endif  // TPETRA_APPLY_HELPERS_HPP