Tpetra_Details_PackTraits.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @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>
struct PackTraits {
  using value_type = T;

  static const bool compileTimeSize = true;

  using input_buffer_type = Kokkos::View<const char*, Kokkos::AnonymousSpace>;

  using output_buffer_type = Kokkos::View<char*, Kokkos::AnonymousSpace>;

  using input_array_type = Kokkos::View<const value_type*, Kokkos::AnonymousSpace>;

  using output_array_type = Kokkos::View<value_type*, Kokkos::AnonymousSpace>;

  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);
  }

  //    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 ((void*) 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 ((void*) &outVal, inBuf, numBytes);
    return numBytes;
  }
}; // struct PackTraits
 
} // namespace Details
} // namespace Tpetra
 
#endif // TPETRA_DETAILS_PACKTRAITS_HPP