Tpetra_TsqrAdaptor.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//          Tpetra: Templated Linear Algebra Services Package
//                 Copyright (2008) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// ************************************************************************
// @HEADER

#ifndef TPETRA_TSQRADAPTOR_HPP
#define TPETRA_TSQRADAPTOR_HPP


#include "Tpetra_ConfigDefs.hpp"

#ifdef HAVE_TPETRA_TSQR
#  include "Tsqr_NodeTsqrFactory.hpp" // create intranode TSQR object
#  include "Tsqr.hpp" // full (internode + intranode) TSQR
#  include "Tsqr_DistTsqr.hpp" // internode TSQR
// Subclass of TSQR::MessengerBase, implemented using Teuchos
// communicator template helper functions
#  include "Tsqr_TeuchosMessenger.hpp"
#  include "Tpetra_MultiVector.hpp"
#  include "Teuchos_ParameterListAcceptorDefaultBase.hpp"
#  include <stdexcept>

namespace Tpetra {

  template<class MV>
  class TsqrAdaptor : public Teuchos::ParameterListAcceptorDefaultBase {
  public:
    using scalar_type = typename MV::scalar_type;
    using ordinal_type = typename MV::local_ordinal_type;
    using dense_matrix_type =
      Teuchos::SerialDenseMatrix<ordinal_type, scalar_type>;
    using magnitude_type =
      typename Teuchos::ScalarTraits<scalar_type>::magnitudeType;

  private:
    using node_tsqr_factory_type =
      TSQR::NodeTsqrFactory<scalar_type, ordinal_type,
                            typename MV::device_type>;
    using node_tsqr_type = TSQR::NodeTsqr<ordinal_type, scalar_type>;
    using dist_tsqr_type = TSQR::DistTsqr<ordinal_type, scalar_type>;
    using tsqr_type = TSQR::Tsqr<ordinal_type, scalar_type>;

    TSQR::MatView<ordinal_type, scalar_type>
    get_mat_view(MV& X)
    {
      TEUCHOS_ASSERT( ! tsqr_.is_null() );
      // FIXME (mfh 18 Oct 2010, 22 Dec 2019) Check Teuchos::Comm<int>
      // object in Q to make sure it is the same communicator as the
      // one we are using in our dist_tsqr_type implementation.

      const ordinal_type lclNumRows(X.getLocalLength());
      const ordinal_type numCols(X.getNumVectors());
      scalar_type* X_ptr = nullptr;
      // LAPACK and BLAS functions require "LDA" >= 1, even if the
      // corresponding matrix dimension is zero.
      ordinal_type X_stride = 1;
      if(tsqr_->wants_device_memory()) {
        X.sync_device();
        X.modify_device();
        auto X_view = X.getLocalViewDevice();
        X_ptr = reinterpret_cast<scalar_type*>(X_view.data());
        X_stride = static_cast<ordinal_type>(X_view.stride(1));
        if(X_stride == 0) {
          X_stride = ordinal_type(1); // see note above
        }
      }
      else {
        X.sync_host();
        X.modify_host();
        auto X_view = X.getLocalViewHost();
        X_ptr = reinterpret_cast<scalar_type*>(X_view.data());
        X_stride = static_cast<ordinal_type>(X_view.stride(1));
        if(X_stride == 0) {
          X_stride = ordinal_type(1); // see note above
        }
      }
      using mat_view_type = TSQR::MatView<ordinal_type, scalar_type>;
      return mat_view_type(lclNumRows, numCols, X_ptr, X_stride);
    }

  public:
    TsqrAdaptor(const Teuchos::RCP<Teuchos::ParameterList>& plist) :
      nodeTsqr_(node_tsqr_factory_type::getNodeTsqr()),
      distTsqr_(new dist_tsqr_type),
      tsqr_(new tsqr_type(nodeTsqr_, distTsqr_))
    {
      setParameterList(plist);
    }

    TsqrAdaptor() :
      nodeTsqr_(node_tsqr_factory_type::getNodeTsqr()),
      distTsqr_(new dist_tsqr_type),
      tsqr_(new tsqr_type(nodeTsqr_, distTsqr_))
    {
      setParameterList(Teuchos::null);
    }

    Teuchos::RCP<const Teuchos::ParameterList>
    getValidParameters() const
    {
      if(defaultParams_.is_null()) {
        auto params = Teuchos::parameterList("TSQR implementation");
        params->set("NodeTsqr", *(nodeTsqr_->getValidParameters()));
        params->set("DistTsqr", *(distTsqr_->getValidParameters()));
        defaultParams_ = params;
      }
      return defaultParams_;
    }

    void
    setParameterList(const Teuchos::RCP<Teuchos::ParameterList>& plist)
    {
      auto params = plist.is_null() ?
        Teuchos::parameterList(*getValidParameters()) : plist;
      using Teuchos::sublist;
      nodeTsqr_->setParameterList(sublist(params, "NodeTsqr"));
      distTsqr_->setParameterList(sublist(params, "DistTsqr"));

      this->setMyParamList(params);
    }

    void
    factorExplicit(MV& A,
                   MV& Q,
                   dense_matrix_type& R,
                   const bool forceNonnegativeDiagonal=false)
    {
      TEUCHOS_TEST_FOR_EXCEPTION
        (! A.isConstantStride(), std::invalid_argument, "TsqrAdaptor::"
         "factorExplicit: Input MultiVector A must have constant stride.");
      TEUCHOS_TEST_FOR_EXCEPTION
        (! Q.isConstantStride(), std::invalid_argument, "TsqrAdaptor::"
         "factorExplicit: Input MultiVector Q must have constant stride.");
      prepareTsqr(Q); // Finish initializing TSQR.
      TEUCHOS_ASSERT( ! tsqr_.is_null() );

      auto A_view = get_mat_view(A);
      auto Q_view = get_mat_view(Q);
      constexpr bool contiguousCacheBlocks = false;
      tsqr_->factorExplicitRaw(A_view.extent(0),
                               A_view.extent(1),
                               A_view.data(), A_view.stride(1),
                               Q_view.data(), Q_view.stride(1),
                               R.values(), R.stride(),
                               contiguousCacheBlocks,
                               forceNonnegativeDiagonal);
    }

    int
    revealRank(MV& Q,
               dense_matrix_type& R,
               const magnitude_type& tol)
    {
      TEUCHOS_TEST_FOR_EXCEPTION
        (! Q.isConstantStride(), std::invalid_argument, "TsqrAdaptor::"
         "revealRank: Input MultiVector Q must have constant stride.");
      prepareTsqr(Q); // Finish initializing TSQR.

      auto Q_view = get_mat_view(Q);
      constexpr bool contiguousCacheBlocks = false;
      return tsqr_->revealRankRaw(Q_view.extent(0),
                                  Q_view.extent(1),
                                  Q_view.data(), Q_view.stride(1),
                                  R.values(), R.stride(),
                                  tol, contiguousCacheBlocks);
    }

  private:
    Teuchos::RCP<node_tsqr_type> nodeTsqr_;

    Teuchos::RCP<dist_tsqr_type> distTsqr_;

    Teuchos::RCP<tsqr_type> tsqr_;

    mutable Teuchos::RCP<const Teuchos::ParameterList> defaultParams_;

    bool ready_ = false;

    void
    prepareTsqr(const MV& mv)
    {
      if(! ready_) {
        prepareDistTsqr(mv);
        ready_ = true;
      }
    }

    void
    prepareDistTsqr(const MV& mv)
    {
      using Teuchos::RCP;
      using Teuchos::rcp_implicit_cast;
      using mess_type = TSQR::TeuchosMessenger<scalar_type>;
      using base_mess_type = TSQR::MessengerBase<scalar_type>;

      auto comm = mv.getMap()->getComm();
      RCP<mess_type> mess(new mess_type(comm));
      auto messBase = rcp_implicit_cast<base_mess_type>(mess);
      distTsqr_->init(messBase);
    }
  };

} // namespace Tpetra

#endif // HAVE_TPETRA_TSQR

#endif // TPETRA_TSQRADAPTOR_HPP