Zoltan2_VectorAdapter.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//   Zoltan2: A package of combinatorial algorithms for scientific computing
//
// Copyright 2012 NTESS and the Zoltan2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef _ZOLTAN2_VECTORADAPTER_HPP_
#define _ZOLTAN2_VECTORADAPTER_HPP_
 
#include <Zoltan2_Adapter.hpp>
 
namespace Zoltan2 {
 
template <typename User>
  class VectorAdapter : public AdapterWithCoords<User> {
public:
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  typedef typename InputTraits<User>::scalar_t scalar_t;
  typedef typename InputTraits<User>::lno_t    lno_t;
  typedef typename InputTraits<User>::gno_t    gno_t;
  typedef typename InputTraits<User>::part_t   part_t;
  typedef typename InputTraits<User>::node_t   node_t;
  typedef typename InputTraits<User>::offset_t offset_t;
  typedef User user_t;
  typedef User userCoord_t;
  typedef VectorAdapter<User> base_adapter_t;
#endif
 
  // The Adapter interface.
 
  enum BaseAdapterType adapterType() const override {return VectorAdapterType;}
 
  // User's adapter interface:
  // The user must implement these methods in his VectorAdapter
 
  virtual int getNumEntriesPerID() const = 0;
 
  virtual void getEntriesView(const scalar_t *&elements,
    int &stride, int idx = 0) const {
    // If adapter does not define getEntriesView, getEntriesKokkosView is called.
    // If adapter does not define getEntriesKokkosView, getEntriesView is called.
    // Allows forward and backwards compatibility.
    // coordinates in MJ are LayoutLeft since Tpetra Multivector gives LayoutLeft
    Kokkos::View<scalar_t **, Kokkos::LayoutLeft,
      typename node_t::device_type> kokkosEntries;
    getEntriesKokkosView(kokkosEntries);
    elements = kokkosEntries.data();
    stride = 1;
  }
 
  virtual void getEntriesKokkosView(
    // coordinates in MJ are LayoutLeft since Tpetra Multivector gives LayoutLeft
    Kokkos::View<scalar_t **, Kokkos::LayoutLeft,
      typename node_t::device_type> & elements) const {
    // If adapter does not define getEntriesKokkosView, getEntriesView is called.
    // If adapter does not define getEntriesView, getEntriesKokkosView is called.
    // Allows forward and backwards compatibility.
    // coordinates in MJ are LayoutLeft since Tpetra Multivector gives LayoutLeft
    typedef Kokkos::View<scalar_t **, Kokkos::LayoutLeft,
      typename node_t::device_type> kokkos_entries_view_t;
    elements = kokkos_entries_view_t("entries", this->getLocalNumIDs(),
      this->getNumEntriesPerID());
    typename kokkos_entries_view_t::host_mirror_type host_elements =
      Kokkos::create_mirror_view(elements);
    for(int j = 0; j < this->getNumEntriesPerID(); ++j) {
      const scalar_t * ptr_elements;
      int stride;
      getEntriesView(ptr_elements, stride, j);
      size_t i = 0;
      for(size_t n = 0; n < this->getLocalNumIDs() * stride; n += stride) {
        host_elements(i++,j) = ptr_elements[n];
      }
    }
    Kokkos::deep_copy(elements, host_elements);
  }
 
  virtual void getEntriesHostView(typename AdapterWithCoords<User>::CoordsHostView & elements) const {
      Z2_THROW_NOT_IMPLEMENTED
 
  }
 
  virtual void getEntriesDeviceView(typename AdapterWithCoords<User>::CoordsDeviceView& elements) const {
      Z2_THROW_NOT_IMPLEMENTED
  }
 
  void generateFiles(
    const char *fileprefix,
    const Teuchos::Comm<int> &comm
  ) const
  {
    // Generate the graph file with weights using the base adapter method
    this->generateWeightFileOnly(fileprefix, comm);
 
    //  Generate the coords file with local method
    this->generateCoordsFileOnly(fileprefix, comm);
  }
 
  // Handy pseudonyms, since vectors are often used as coordinates
  // User should not implement these methods.
 
  inline int getDimension() const {return getNumEntriesPerID();}
 
  inline void getCoordinatesView(const scalar_t *&elements, int &stride,
                                 int idx = 0) const override
  {
    getEntriesView(elements, stride, idx);
  }
 
  void getCoordinatesKokkosView(
    // coordinates in MJ are LayoutLeft since Tpetra Multivector gives LayoutLeft
    typename AdapterWithCoords<User>::CoordsDeviceView & elements) const override
  {
    getEntriesKokkosView(elements);
  }
 
  void getCoordinatesHostView(typename AdapterWithCoords<User>::CoordsHostView &elements) const override
  {
    getEntriesHostView(elements);
  }
  void getCoordinatesDeviceView(typename AdapterWithCoords<User>::CoordsDeviceView &elements) const override
  {
    getEntriesDeviceView(elements);
  }
 
private:
 
  void generateCoordsFileOnly(
    const char* fileprefix,
    const Teuchos::Comm<int> &comm) const;
 
};
 
template <typename User>
void VectorAdapter<User>::generateCoordsFileOnly(
  const char *fileprefix,
  const Teuchos::Comm<int> &comm
) const
{
  // Writes a chaco-formatted coordinates file
  // This function is SERIAL and can be quite slow.  Use it for debugging only.
 
  int np = comm.getSize();
  int me = comm.getRank();
 
  // append suffix to filename
 
  std::string filenamestr = fileprefix;
  filenamestr = filenamestr + ".coords";
  const char *filename = filenamestr.c_str();
 
  for (int p = 0; p < np; p++) {
 
    // Is it this processor's turn to write to files?
    if (me == p) {
 
      std::ofstream fp;
      if (me == 0) {
        // open file for writing
        fp.open(filename, std::ios::out);
      }
      else {
        // open file for appending
        fp.open(filename, std::ios::app);
      }
 
      // Get the vector entries
      size_t len = this->getLocalNumIDs();
      int nvec = this->getNumEntriesPerID();
      const scalar_t **values = new const scalar_t *[nvec];
      int *strides = new int[nvec];
      for (int n = 0; n < nvec; n++)
        getEntriesView(values[n], strides[n], n);
 
      // write vector entries to coordinates file
 
      for (size_t i = 0; i < len; i++) {
        for (int n = 0; n < nvec; n++)
          fp << values[n][i*strides[n]] << " ";
        fp << "\n";
      }
 
      // clean up and close the file
      delete [] strides;
      delete [] values;
      fp.close();
    }
    comm.barrier();
  }
}
 
 
}  //namespace Zoltan2
 
#endif