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