Tpetra_Details_Hash.hpp

/*
// @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_HASH_HPP
#define TPETRA_DETAILS_HASH_HPP
 
#include "Tpetra_ConfigDefs.hpp"
#ifdef TPETRA_USE_MURMUR_HASH
#  include <Kokkos_Functional.hpp> // hash function used by Kokkos::UnorderedMap
#endif // TPETRA_USE_MURMUR_HASH
#include <type_traits> // make_signed
 
namespace Tpetra {
namespace Details {
 
namespace Impl {

int getRecommendedSizeInt (const int size);
 
} // namespace Impl

template<class KeyType,
         class DeviceType,
         class OffsetType = typename std::make_signed<typename Kokkos::View<KeyType*, DeviceType>::size_type>::type,
         class ResultType = int>
struct Hash {
  typedef KeyType argument_type;

  typedef ResultType result_type;

  typedef OffsetType offset_type;

  static KOKKOS_INLINE_FUNCTION result_type
  hashFunc (const argument_type& key, const offset_type& size) {
    static_assert (! std::is_same<result_type, int>::value,
                   "Not yet implemented for ResultType != int");
  }

  static result_type getRecommendedSize (const offset_type size) {
    static_assert (! std::is_same<result_type, int>::value,
                   "Not yet implemented for ResultType != int");
  }
};

template<class KeyType, class DeviceType, class OffsetType>
struct Hash<KeyType, DeviceType, OffsetType, int> {
  typedef KeyType argument_type;

  typedef int result_type;

  typedef OffsetType offset_type;

  static KOKKOS_INLINE_FUNCTION result_type
  hashFunc (const argument_type& key, const offset_type& size)
  {
#ifdef TPETRA_USE_MURMUR_HASH
    Kokkos::pod_hash<argument_type> hash;
    const uint32_t k = hash (key);
    return static_cast<result_type> (k % size);
#else
    // We are using Epetra's hash function by default, as we have
    // observed that it is much faster than the Murmur hash
    // function. However, this is not a good hash function for general
    // sets of keys.  For our typical use case, this is good.  Use
    // Murmur hash if the maps are sparse.
    const unsigned int seed = (2654435761U);
    const int intkey = (int) ((key & 0x000000007fffffffLL) +
                              ((key & 0x7fffffff80000000LL) >> 31));
    return static_cast<result_type> ((seed ^ intkey) % static_cast<int> (size));
#endif
  }

  static result_type getRecommendedSize (const offset_type size)
  {
    return Impl::getRecommendedSizeInt (static_cast<int> (size));
  }
};
 
} // namespace Details
} // namespace Tpetra
 
#endif // TPETRA_DETAILS_HASH_HPP