Tpetra_Details_CrsPadding.hpp

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TPETRA_DETAILS_CRSPADDING_HPP
#define TPETRA_DETAILS_CRSPADDING_HPP
 
#include "Tpetra_Details_Behavior.hpp"
#include "Tpetra_Util.hpp"
#include <algorithm>
#include <iostream>
#include <memory>
#include <sstream>
#include <vector>
 
namespace Tpetra {
  namespace Details {

    template<class LocalOrdinal, class GlobalOrdinal>
    class CrsPadding {
    private:
      using LO = LocalOrdinal;
      using GO = GlobalOrdinal;
 
      enum class Phase {
        SAME,
        PERMUTE,
        IMPORT
      };
 
    public:
      CrsPadding(const int myRank,
                 const size_t /* numSameIDs */,
                 const size_t /* numPermutes */)
        : myRank_(myRank)
      {}
 
      CrsPadding(const int myRank,
                 const size_t /* numImports */)
        : myRank_(myRank)
      {}
 
      void
      update_same(
        const LO targetLocalIndex,
        GO tgtGblColInds[],
        const size_t origNumTgtEnt,
        const bool tgtIsUnique,
        GO srcGblColInds[],
        const size_t origNumSrcEnt,
        const bool srcIsUnique)
      {
        const LO whichSame = targetLocalIndex;
        update_impl(Phase::SAME, whichSame, targetLocalIndex,
                    tgtGblColInds, origNumTgtEnt, tgtIsUnique,
                    srcGblColInds, origNumSrcEnt, srcIsUnique);
      }
 
      void
      update_permute(
        const LO whichPermute, // index in permuteFrom/To
        const LO targetLocalIndex,
        GO tgtGblColInds[],
        const size_t origNumTgtEnt,
        const bool tgtIsUnique,
        GO srcGblColInds[],
        const size_t origNumSrcEnt,
        const bool srcIsUnique)
      {
        update_impl(Phase::PERMUTE, whichPermute, targetLocalIndex,
                    tgtGblColInds, origNumTgtEnt, tgtIsUnique,
                    srcGblColInds, origNumSrcEnt, srcIsUnique);
      }
 
      void
      update_import(
        const LO whichImport,
        const LO targetLocalIndex,
        GO tgtGblColInds[],
        const size_t origNumTgtEnt,
        const bool tgtIsUnique,
        GO srcGblColInds[],
        const size_t origNumSrcEnt,
        const bool srcIsUnique)
      {
        update_impl(Phase::IMPORT, whichImport, targetLocalIndex,
                    tgtGblColInds, origNumTgtEnt, tgtIsUnique,
                    srcGblColInds, origNumSrcEnt, srcIsUnique);
      }
 
      void print(std::ostream& out) const {
        const size_t maxNumToPrint =
          Details::Behavior::verbosePrintCountThreshold();
        const size_t size = entries_.size();
        out << "entries: [";
        size_t k = 0;
        for (const auto& keyval : entries_) {
          if (k > maxNumToPrint) {
            out << "...";
            break;
          }
          out << "(" << keyval.first << ", ";
          Details::verbosePrintArray(out, keyval.second,
            "Global column indices", maxNumToPrint);
          out << ")";
          if (k + size_t(1) < size) {
            out << ", ";
          }
          ++k;
        }
        out << "]";
      }
 
      struct Result {
        size_t numInSrcNotInTgt;
        bool found;
      };

      Result
      get_result(const LO targetLocalIndex) const
      {
        auto it = entries_.find(targetLocalIndex);
        if (it == entries_.end()) {
          return {0, false};
        }
        else {
          return {it->second.size(), true};
        }
      }
 
    private:
      void
      update_impl(
        const Phase phase,
        const LO whichImport,
        const LO targetLocalIndex,
        GO tgtGblColInds[],
        const size_t origNumTgtEnt,
        const bool tgtIsUnique,
        GO srcGblColInds[],
        const size_t origNumSrcEnt,
        const bool srcIsUnique)
      {
        using std::endl;
        std::unique_ptr<std::string> prefix;
        if (verbose_) {
          prefix = createPrefix("update_impl");
          std::ostringstream os;
          os << *prefix << "Start: "
             << "targetLocalIndex=" << targetLocalIndex
             << ", origNumTgtEnt=" << origNumTgtEnt
             << ", origNumSrcEnt=" << origNumSrcEnt << endl;
          std::cerr << os.str();
        }
 
        // FIXME (08 Feb 2020) We only need to sort and unique
        // tgtGblColInds if we haven't already seen it before.
        size_t newNumTgtEnt = origNumTgtEnt;
        auto tgtEnd = tgtGblColInds + origNumTgtEnt;
        std::sort(tgtGblColInds, tgtEnd);
        if (! tgtIsUnique) {
          tgtEnd = std::unique(tgtGblColInds, tgtEnd);
          newNumTgtEnt = size_t(tgtEnd - tgtGblColInds);
          TEUCHOS_ASSERT( newNumTgtEnt <= origNumTgtEnt );
        }
 
        if (verbose_) {
          std::ostringstream os;
          os << *prefix << "finished src; process tgt" << endl;
          std::cerr << os.str();
        }
 
        size_t newNumSrcEnt = origNumSrcEnt;
        auto srcEnd = srcGblColInds + origNumSrcEnt;
        std::sort(srcGblColInds, srcEnd);
        if (! srcIsUnique) {
          srcEnd = std::unique(srcGblColInds, srcEnd);
          newNumSrcEnt = size_t(srcEnd - srcGblColInds);
          TEUCHOS_ASSERT( newNumSrcEnt <= origNumSrcEnt );
        }
 
        merge_with_current_state(phase, whichImport, targetLocalIndex,
                                 tgtGblColInds, newNumTgtEnt,
                                 srcGblColInds, newNumSrcEnt);
        if (verbose_) {
          std::ostringstream os;
          os << *prefix << "Done" << endl;
          std::cerr << os.str();
        }
      }
 
      std::vector<GO>&
      get_difference_col_inds(const Phase /* phase */,
                              const LO /* whichIndex */,
                              const LO tgtLclRowInd)
      {
        return entries_[tgtLclRowInd];
      }
 
      void
      merge_with_current_state(
        const Phase phase,
        const LO whichIndex,
        const LO tgtLclRowInd,
        const GO tgtColInds[], // sorted & merged
        const size_t numTgtEnt,
        const GO srcColInds[], // sorted & merged
        const size_t numSrcEnt)
      {
        using std::endl;
        std::unique_ptr<std::string> prefix;
        if (verbose_) {
          prefix = createPrefix("merge_with_current_state");
          std::ostringstream os;
          os << *prefix << "Start: "
             << "tgtLclRowInd=" << tgtLclRowInd
             << ", numTgtEnt=" << numTgtEnt
             << ", numSrcEnt=" << numSrcEnt << endl;
          std::cerr << os.str();
        }
        // We only need to accumulate those source indices that are
        // not already target indices.  This is because we always have
        // the target indices on input to this function, so there's no
        // need to store them here again.  That still could be a lot
        // to store, but it's better than duplicating target matrix
        // storage.
        //
        // This means that consumers of this data structure need to
        // treat entries_[tgtLclRowInd].size() as an increment, not as
        // the required new allocation size itself.
        //
        // We store
        //
        // difference(union(incoming source indices,
        //                  already stored source indices),
        //            target indices)
 
        auto tgtEnd = tgtColInds + numTgtEnt;
        auto srcEnd = srcColInds + numSrcEnt;
 
        // At least one input source index isn't in the target.
        std::vector<GO>& diffColInds =
          get_difference_col_inds(phase, whichIndex, tgtLclRowInd);
        const size_t oldDiffNumEnt = diffColInds.size();
 
        if (oldDiffNumEnt == 0) {
          if (verbose_) {
            std::ostringstream os;
            os << *prefix << "oldDiffNumEnt=0; call "
              "set_difference(src,tgt,diff)" << endl;
            std::cerr << os.str();
          }
          diffColInds.resize(numSrcEnt);
          auto diffEnd = std::set_difference(srcColInds, srcEnd,
                                             tgtColInds, tgtEnd,
                                             diffColInds.begin());
          const size_t newLen(diffEnd - diffColInds.begin());
          TEUCHOS_ASSERT( newLen <= numSrcEnt );
          diffColInds.resize(newLen);
        }
        else {
          // scratch = union(srcColInds, diffColInds);
          // diffColInds = difference(scratch, tgtColInds);
 
          const size_t maxUnionSize = numSrcEnt + oldDiffNumEnt;
          if (verbose_) {
            std::ostringstream os;
            os << *prefix << "oldDiffNumEnt=" << oldDiffNumEnt
               << ", maxUnionSize=" << maxUnionSize
               << "; call set_union(src,diff,union)" << endl;
            std::cerr << os.str();
          }
          if (scratchColInds_.size() < maxUnionSize) {
            scratchColInds_.resize(maxUnionSize);
          }
          auto unionBeg = scratchColInds_.begin();
          auto unionEnd = std::set_union(srcColInds, srcEnd,
             diffColInds.begin(), diffColInds.end(),
             unionBeg);
          const size_t unionSize(unionEnd - unionBeg);
          TEUCHOS_ASSERT( unionSize <= maxUnionSize );
 
          if (verbose_) {
            std::ostringstream os;
            os << *prefix << "oldDiffNumEnt=" << oldDiffNumEnt
               << ", unionSize=" << unionSize << "; call "
              "set_difference(union,tgt,diff)" << endl;
            std::cerr << os.str();
          }
          diffColInds.resize(unionSize);
          auto diffEnd = std::set_difference(unionBeg, unionEnd,
                                             tgtColInds, tgtEnd,
                                             diffColInds.begin());
          const size_t diffLen(diffEnd - diffColInds.begin());
          TEUCHOS_ASSERT( diffLen <= unionSize );
          diffColInds.resize(diffLen);
        }
 
        if (verbose_) {
          std::ostringstream os;
          os << *prefix << "Done" << endl;
          std::cerr << os.str();
        }
      }
 
      std::unique_ptr<std::string>
      createPrefix(const char funcName[])
      {
        std::ostringstream os;
        os << "Proc " << myRank_ << ": CrsPadding::" << funcName
           << ": ";
        return std::unique_ptr<std::string>(new std::string(os.str()));
      }
 
      // imports may overlap with sames and/or permutes, so it makes
      // sense to store them all in one map.
      std::map<LO, std::vector<GO> > entries_;
      std::vector<GO> scratchColInds_;
      int myRank_ = -1;
      bool verbose_ = Behavior::verbose("CrsPadding");
    };
  } // namespace Details
} // namespace Tpetra
 
#endif // TPETRA_DETAILS_CRSPADDING_HPP