Unify static asserts in OA ref

Author: sleeepyjack

include/cuco/detail/open_addressing/open_addressing_impl.cuh

@@ -69,11 +69,6 @@ template <class Key,
           class Allocator,
           class Storage>
 class open_addressing_impl {
-  static_assert(
-    cuco::is_bitwise_comparable_v<Key>,
-    "Key type must have unique object representations or have been explicitly declared as safe for "
-    "bitwise comparison via specialization of cuco::is_bitwise_comparable_v<Key>.");
-
   static_assert(cuda::std::is_base_of_v<cuco::detail::probing_scheme_base<ProbingScheme::cg_size>,
                                         ProbingScheme>,
                 "ProbingScheme must inherit from cuco::detail::probing_scheme_base");

include/cuco/static_map.cuh

@@ -95,12 +95,6 @@ template <class Key,
           class Allocator          = cuco::cuda_allocator<cuco::pair<Key, T>>,
           class Storage            = cuco::storage<1>>
 class static_map {
-  static_assert(sizeof(Key) <= cuco::detail::max_key_size,
-                "Key size exceeds the maximum supported size (8 bytes, or 16 with sm_90+).");
-
-  static_assert(sizeof(T) <= cuco::detail::max_payload_size,
-                "Payload size exceeds the maximum supported size (8 bytes, or 16 with sm_90+).");
-
   static_assert(cuco::is_bitwise_comparable_v<T>,
                 "Mapped type must have unique object representations or have been explicitly "
                 "declared as safe for bitwise comparison via specialization of "

include/cuco/static_map_ref.cuh

@@ -78,11 +78,6 @@ class static_map_ref
   static_assert(cuco::detail::is_valid_mapped_size(sizeof(T)),
                 "sizeof(mapped_type) must be 4 or 8 bytes (or 16 with sm_90+).");
 
-  static_assert(
-    cuco::is_bitwise_comparable_v<Key>,
-    "Key type must have unique object representations or have been explicitly declared as safe for "
-    "bitwise comparison via specialization of cuco::is_bitwise_comparable_v<Key>.");
-
  public:
   using key_type            = Key;                                     ///< Key type
   using mapped_type         = T;                                       ///< Mapped type

include/cuco/static_multimap.cuh

@@ -91,12 +91,6 @@ template <class Key,
           class Allocator          = cuco::cuda_allocator<cuco::pair<Key, T>>,
           class Storage            = cuco::storage<2>>
 class static_multimap {
-  static_assert(sizeof(Key) <= cuco::detail::max_key_size,
-                "Key size exceeds the maximum supported size (8 bytes, or 16 with sm_90+).");
-
-  static_assert(sizeof(T) <= cuco::detail::max_payload_size,
-                "Payload size exceeds the maximum supported size (8 bytes, or 16 with sm_90+).");
-
   static_assert(cuco::is_bitwise_comparable_v<T>,
                 "Mapped type must have unique object representations or have been explicitly "
                 "declared as safe for bitwise comparison via specialization of "

include/cuco/static_multimap_ref.cuh

@@ -75,11 +75,6 @@ class static_multimap_ref
   using impl_type = detail::
     open_addressing_ref_impl<Key, Scope, KeyEqual, ProbingScheme, StorageRef, allows_duplicates>;
 
-  static_assert(
-    cuco::is_bitwise_comparable_v<Key>,
-    "Key type must have unique object representations or have been explicitly declared as safe for "
-    "bitwise comparison via specialization of cuco::is_bitwise_comparable_v<Key>.");
-
  public:
   using key_type            = Key;                                     ///< Key type
   using mapped_type         = T;                                       ///< Mapped type