Tpetra_Details_PackTraits.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.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ************************************************************************
// @HEADER

#ifndef TPETRA_DETAILS_PACKTRAITS_HPP
#define TPETRA_DETAILS_PACKTRAITS_HPP


#include "Tpetra_ConfigDefs.hpp"
#include "Kokkos_Core.hpp"

namespace Tpetra {
namespace Details {

template<class T, class D>
struct PackTraits {
  typedef T value_type;

  static const bool compileTimeSize = true;

  typedef Kokkos::View<const char*, D, Kokkos::MemoryUnmanaged> input_buffer_type;

  typedef Kokkos::View<char*, D, Kokkos::MemoryUnmanaged> output_buffer_type;

  typedef Kokkos::View<const value_type*, D, Kokkos::MemoryUnmanaged> input_array_type;

  typedef Kokkos::View<value_type*, D, Kokkos::MemoryUnmanaged> output_array_type;

  KOKKOS_INLINE_FUNCTION
  static size_t
  numValuesPerScalar (const value_type& /* x */) {
    // If your type T is something like Stokhos::UQ::PCE<S>, you must
    // reimplement this function.
    return static_cast<size_t> (1);
  }

  static Kokkos::View<value_type*, D>
  allocateArray (const value_type& x,
                 const size_t numEnt,
                 const std::string& label = "")
  {
    typedef Kokkos::View<value_type*, D> view_type;
    typedef typename view_type::size_type size_type;

    // When the traits::specialize type is non-void this exploits 
    // the fact that Kokkos::View's constructor ignores
    // size arguments beyond what the View's type specifies.  For
    // value_type = Stokhos::UQ::PCE<S>, numValuesPerScalar returns
    // something other than 1, and the constructor will actually use
    // that value.
    // Otherwise, the number of arguments must match the dynamic rank
    // (i.e. number *'s with the value_type of the View)
    const size_type numVals = numValuesPerScalar (x);
    if ( std::is_same< typename view_type::traits::specialize, void >::value ) {
      return view_type (label, static_cast<size_type> (numEnt));
    } 
    else {
      return view_type (label, static_cast<size_type> (numEnt), numVals);
    }
  }

  //    packArray error code (success = 0)}
  KOKKOS_INLINE_FUNCTION
  static Kokkos::pair<int, size_t>
  packArray (char outBuf[],
             const value_type inBuf[],
             const size_t numEnt)
  {
    size_t numBytes = 0;
    int errorCode = 0;
    typedef Kokkos::pair<int, size_t> pair_type;

    if (numEnt == 0) {
      return pair_type (errorCode, numBytes);
    }
    else {
      // NOTE (mfh 02 Feb 2015) This assumes that all instances of T
      // require the same number of bytes.  To generalize this, we
      // would need to sum up the counts for all entries of inBuf.
      // That of course would suggest that we would need to memcpy
      // each entry separately.
      //
      // We can't just default construct an instance of T, because if
      // T's size is run-time dependent, a default-constructed T might
      // not have the right size.  However, we require that all
      // entries of the input array have the correct size.
      numBytes = numEnt * packValueCount (inBuf[0]);

      // As of CUDA 6, it's totally fine to use memcpy in a CUDA device
      // function.  It does what one would expect.
      memcpy (outBuf, inBuf, numBytes);
      return pair_type (errorCode, numBytes);
    }
  }

  //    unpackArray error code (success = 0)}
  KOKKOS_INLINE_FUNCTION
  static Kokkos::pair<int, size_t>
  unpackArray (value_type outBuf[],
               const char inBuf[],
               const size_t numEnt)
  {
    size_t numBytes = 0;
    int errorCode = 0;
    typedef Kokkos::pair<int, size_t> pair_type;

    if (numEnt == 0) {
      return pair_type (errorCode, numBytes);
    }
    else {
      // NOTE (mfh 02 Feb 2015) This assumes that all instances of
      // value_type require the same number of bytes.  To generalize
      // this, we would need to sum up the counts for all entries of
      // inBuf.  That of course would suggest that we would need to
      // memcpy each entry separately.
      //
      // We can't just default construct an instance of value_type,
      // because if value_type's size is run-time dependent, a
      // default-constructed value_type might not have the right size.
      // However, we require that all entries of the input array have
      // the correct size.
      const value_type& val = outBuf[0];
      numBytes = numEnt * packValueCount (val);

      // As of CUDA 6, it's totally fine to use memcpy in a CUDA device
      // function.  It does what one would expect.
      memcpy (outBuf, inBuf, numBytes);
      return pair_type (errorCode, numBytes);
    }
  }

  KOKKOS_INLINE_FUNCTION
  static size_t
  packValueCount (const T& /* inVal */)
  {
    return sizeof (T);
  }

  KOKKOS_INLINE_FUNCTION
  static size_t
  packValue (char outBuf[],
             const T& inVal)
  {
    // It's actually OK for packValueCount to return an upper bound
    // (e.g., padding for alignment).  The memcpy call below will copy
    // any included padding as well as the actual data.
    const size_t numBytes = packValueCount (inVal);

    // As of CUDA 6, it's totally fine to use memcpy in a CUDA device
    // function.  It does what one would expect.
    memcpy (outBuf, &inVal, numBytes);
    return numBytes;
  }

  KOKKOS_INLINE_FUNCTION
  static size_t
  packValue (char outBuf[],
             const size_t outBufIndex,
             const T& inVal)
  {
    // It's actually OK for packValueCount to return an upper bound
    // (e.g., padding for alignment).  The memcpy call below will copy
    // any included padding as well as the actual data.
    const size_t numBytes = packValueCount (inVal);
    const size_t offset = outBufIndex * numBytes;

    // As of CUDA 6, it's totally fine to use memcpy in a CUDA device
    // function.  It does what one would expect.
    memcpy (outBuf + offset, &inVal, numBytes);
    return numBytes;
  }

  KOKKOS_INLINE_FUNCTION
  static size_t
  unpackValue (T& outVal, const char inBuf[])
  {
    // It's actually OK for packValueCount to return an upper bound
    // (e.g., padding for alignment).  The memcpy call below will copy
    // any included padding as well as the actual data.
    const size_t numBytes = packValueCount (outVal);

    // As of CUDA 6, it's totally fine to use memcpy in a CUDA device
    // function.  It does what one would expect.
    memcpy (&outVal, inBuf, numBytes);
    return numBytes;
  }
}; // struct PackTraits

} // namespace Details
} // namespace Tpetra

#endif // TPETRA_DETAILS_PACKTRAITS_HPP