Zoltan2_VectorAdapter.hpp

Go to the documentation of this file.

// @HEADER
//
// ***********************************************************************
//
//   Zoltan2: A package of combinatorial algorithms for scientific computing
//                  Copyright 2012 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.
//
// Questions? Contact Karen Devine      (kddevin@sandia.gov)
//                    Erik Boman        (egboman@sandia.gov)
//                    Siva Rajamanickam (srajama@sandia.gov)
//
// ***********************************************************************
//
// @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::HostMirror 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