Zoltan2_StridedData.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_STRIDEDDATA_HPP_
#define _ZOLTAN2_STRIDEDDATA_HPP_

#include <Zoltan2_Standards.hpp>
#include <Zoltan2_Environment.hpp>
#include <typeinfo>

namespace Zoltan2{

template<typename lno_t, typename scalar_t>
class StridedData {
private:
  ArrayRCP<const scalar_t> vec_;
  int stride_;

public:

  StridedData(ArrayRCP<const scalar_t> x, int stride) :  
    vec_(x), stride_(stride)
    { }

  StridedData(): vec_(), stride_(0)
    { }

  lno_t size() const { return vec_.size(); }

  scalar_t operator[](lno_t idx) const { return vec_[idx*stride_]; }

  template <typename T> void getInputArray(ArrayRCP<const T> &array) const;

  void getStridedList(ArrayRCP<const scalar_t> &vec, int &stride) const
  {
    vec = vec_;
    stride = stride_;
  }

  void getStridedList(size_t &len, const scalar_t *&vec, int &stride) const
  {
    len = vec_.size();
    if (len != 0) vec = vec_.getRawPtr();
    else          vec = NULL;
    stride = stride_;
  }

  StridedData & operator= (const StridedData &sInput)
  {
    if (this != &sInput)
      sInput.getStridedList(vec_, stride_);

    return *this;
  }
};

// Helper function needed for T=scalar_t specialization
// Separate function needed // because, with T != scalar_t, 
// "array = vec_" // would not compile; 
// ArrayRCP does not overload "=" operator for different types.
// Separate helper function needed (outside StridedData class)
// because cannot specialize member function of templated class.
template<typename scalar_t, typename T>
static void getInputArrayHelper(
  ArrayRCP<const T> &target,
  const ArrayRCP<const scalar_t> &src)
{
  // Create a copy of desired type T
  // From logic in getInputArray, we know stride == 1.
  size_t n = src.size();
  T *tmp = new T [n];

  if (!tmp){
    std::cerr << "Error: " << __FILE__ << ", " << __LINE__<< std::endl;
    std::cerr << n << " objects" << std::endl;
    throw std::bad_alloc();
  }

  for (size_t i=0; i < n; i++){
    tmp[i] = static_cast<T>(src[i]);
  }
  target = arcp(tmp, 0, n);
}

// Specialization with T == scalar_t:  just copy ArrayRCP
template<typename scalar_t>
static void getInputArrayHelper(
  ArrayRCP<const scalar_t> &target,
  const ArrayRCP<const scalar_t> &src)
{
  target = src;
}

// Member function for getting unstrided view/copy of StridedData.
template<typename lno_t, typename scalar_t>
  template<typename T>
     void StridedData<lno_t, scalar_t>::getInputArray(
       ArrayRCP<const T> &array) const
{
  if (vec_.size() < 1){
    array = ArrayRCP<const T>();
  }
  else if (stride_ > 1) {
    // Create an unstrided copy
    size_t n = vec_.size() / stride_;
    T *tmp = new T [n];

    if (!tmp){
      std::cerr << "Error: " << __FILE__ << ", " << __LINE__<< std::endl;
      std::cerr << n << " objects" << std::endl;
      throw std::bad_alloc();
    }

    for (size_t i=0,j=0; i < n; i++,j+=stride_){
      tmp[i] = static_cast<T>(vec_[j]);
    }
    array = arcp(tmp, 0, n);
  }
  else { // stride == 1
    Zoltan2::getInputArrayHelper<scalar_t, T>(array, vec_);
  }
  return;
}

}  // namespace Zoltan2

#endif