cuda-cccl 0.3.0__cp311-cp311-manylinux_2_24_aarch64.whl → 0.3.2__cp311-cp311-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/thrust/detail/allocator/copy_construct_range.inl

@@ -1,242 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-
-#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
-#  pragma GCC system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
-#  pragma clang system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
-#  pragma system_header
-#endif // no system header
-#include <thrust/advance.h>
-#include <thrust/detail/allocator/allocator_traits.h>
-#include <thrust/detail/copy.h>
-#include <thrust/detail/memory_wrapper.h>
-#include <thrust/detail/type_traits/pointer_traits.h>
-#include <thrust/distance.h>
-#include <thrust/for_each.h>
-#include <thrust/iterator/iterator_traits.h>
-#include <thrust/iterator/zip_iterator.h>
-#include <thrust/tuple.h>
-
-THRUST_NAMESPACE_BEGIN
-namespace detail
-{
-namespace allocator_traits_detail
-{
-
-template <typename Allocator, typename InputType, typename OutputType>
-struct copy_construct_with_allocator
-{
-  Allocator& a;
-
-  _CCCL_HOST_DEVICE copy_construct_with_allocator(Allocator& a)
-      : a(a)
-  {}
-
-  template <typename Tuple>
-  inline _CCCL_HOST_DEVICE void operator()(Tuple t)
-  {
-    const InputType& in = thrust::get<0>(t);
-    OutputType& out     = thrust::get<1>(t);
-
-    allocator_traits<Allocator>::construct(a, &out, in);
-  }
-};
-
-// we need to use allocator_traits<Allocator>::construct() to
-// copy construct a T if either:
-// 1. Allocator has a 2-argument construct() member or
-// 2. T has a non-trivial copy constructor
-template <typename Allocator, typename T>
-struct needs_copy_construct_via_allocator
-    : integral_constant<bool,
-                        (has_member_construct2<Allocator, T, T>::value
-                         || !::cuda::std::is_trivially_copy_constructible<T>::value)>
-{};
-
-// we know that std::allocator::construct's only effect is to call T's
-// copy constructor, so we needn't consider or use its construct() member for copy construction
-template <typename U, typename T>
-struct needs_copy_construct_via_allocator<std::allocator<U>, T>
-    : integral_constant<bool, !::cuda::std::is_trivially_copy_constructible<T>::value>
-{};
-
-// XXX it's regrettable that this implementation is copied almost
-//     exactly from system::detail::generic::uninitialized_copy
-//     perhaps generic::uninitialized_copy could call this routine
-//     with a default allocator
-template <typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
-_CCCL_HOST_DEVICE enable_if_convertible_t<FromSystem, ToSystem, Pointer> uninitialized_copy_with_allocator(
-  Allocator& a,
-  const thrust::execution_policy<FromSystem>&,
-  const thrust::execution_policy<ToSystem>& to_system,
-  InputIterator first,
-  InputIterator last,
-  Pointer result)
-{
-  // zip up the iterators
-  using IteratorTuple = thrust::tuple<InputIterator, Pointer>;
-  using ZipIterator   = thrust::zip_iterator<IteratorTuple>;
-
-  ZipIterator begin = thrust::make_zip_iterator(first, result);
-  ZipIterator end   = begin;
-
-  // get a zip_iterator pointing to the end
-  const thrust::detail::it_difference_t<InputIterator> n = ::cuda::std::distance(first, last);
-  ::cuda::std::advance(end, n);
-
-  // create a functor
-  using InputType  = it_value_t<InputIterator>;
-  using OutputType = it_value_t<Pointer>;
-
-  // do the for_each
-  // note we use to_system to dispatch the for_each
-  thrust::for_each(to_system, begin, end, copy_construct_with_allocator<Allocator, InputType, OutputType>(a));
-
-  // return the end of the output range
-  return thrust::get<1>(end.get_iterator_tuple());
-}
-
-// XXX it's regrettable that this implementation is copied almost
-//     exactly from system::detail::generic::uninitialized_copy_n
-//     perhaps generic::uninitialized_copy_n could call this routine
-//     with a default allocator
-template <typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
-_CCCL_HOST_DEVICE enable_if_convertible_t<FromSystem, ToSystem, Pointer> uninitialized_copy_with_allocator_n(
-  Allocator& a,
-  const thrust::execution_policy<FromSystem>&,
-  const thrust::execution_policy<ToSystem>& to_system,
-  InputIterator first,
-  Size n,
-  Pointer result)
-{
-  // zip up the iterators
-  using IteratorTuple = thrust::tuple<InputIterator, Pointer>;
-  using ZipIterator   = thrust::zip_iterator<IteratorTuple>;
-
-  ZipIterator begin = thrust::make_zip_iterator(first, result);
-
-  // create a functor
-  using InputType  = it_value_t<InputIterator>;
-  using OutputType = it_value_t<Pointer>;
-
-  // do the for_each_n
-  // note we use to_system to dispatch the for_each_n
-  ZipIterator end =
-    thrust::for_each_n(to_system, begin, n, copy_construct_with_allocator<Allocator, InputType, OutputType>(a));
-
-  // return the end of the output range
-  return thrust::get<1>(end.get_iterator_tuple());
-}
-
-template <typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
-_CCCL_HOST_DEVICE typename disable_if_convertible<FromSystem, ToSystem, Pointer>::type uninitialized_copy_with_allocator(
-  Allocator&,
-  const thrust::execution_policy<FromSystem>& from_system,
-  const thrust::execution_policy<ToSystem>& to_system,
-  InputIterator first,
-  InputIterator last,
-  Pointer result)
-{
-  // the systems aren't trivially interoperable
-  // just call two_system_copy and hope for the best
-  return thrust::detail::two_system_copy(from_system, to_system, first, last, result);
-} // end uninitialized_copy_with_allocator()
-
-template <typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
-_CCCL_HOST_DEVICE typename disable_if_convertible<FromSystem, ToSystem, Pointer>::type
-uninitialized_copy_with_allocator_n(
-  Allocator&,
-  const thrust::execution_policy<FromSystem>& from_system,
-  const thrust::execution_policy<ToSystem>& to_system,
-  InputIterator first,
-  Size n,
-  Pointer result)
-{
-  // the systems aren't trivially interoperable
-  // just call two_system_copy_n and hope for the best
-  return thrust::detail::two_system_copy_n(from_system, to_system, first, n, result);
-} // end uninitialized_copy_with_allocator_n()
-
-template <typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
-_CCCL_HOST_DEVICE
-typename disable_if<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value,
-                    Pointer>::type
-copy_construct_range(thrust::execution_policy<FromSystem>& from_system,
-                     Allocator& a,
-                     InputIterator first,
-                     InputIterator last,
-                     Pointer result)
-{
-  // just call two_system_copy
-  return thrust::detail::two_system_copy(from_system, allocator_system<Allocator>::get(a), first, last, result);
-}
-
-template <typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
-_CCCL_HOST_DEVICE
-typename disable_if<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value,
-                    Pointer>::type
-copy_construct_range_n(
-  thrust::execution_policy<FromSystem>& from_system, Allocator& a, InputIterator first, Size n, Pointer result)
-{
-  // just call two_system_copy_n
-  return thrust::detail::two_system_copy_n(from_system, allocator_system<Allocator>::get(a), first, n, result);
-}
-
-template <typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
-_CCCL_HOST_DEVICE ::cuda::std::
-  enable_if_t<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value, Pointer>
-  copy_construct_range(thrust::execution_policy<FromSystem>& from_system,
-                       Allocator& a,
-                       InputIterator first,
-                       InputIterator last,
-                       Pointer result)
-{
-  return uninitialized_copy_with_allocator(a, from_system, allocator_system<Allocator>::get(a), first, last, result);
-}
-
-template <typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
-_CCCL_HOST_DEVICE ::cuda::std::
-  enable_if_t<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value, Pointer>
-  copy_construct_range_n(
-    thrust::execution_policy<FromSystem>& from_system, Allocator& a, InputIterator first, Size n, Pointer result)
-{
-  return uninitialized_copy_with_allocator_n(a, from_system, allocator_system<Allocator>::get(a), first, n, result);
-}
-
-} // namespace allocator_traits_detail
-
-template <typename System, typename Allocator, typename InputIterator, typename Pointer>
-_CCCL_HOST_DEVICE Pointer copy_construct_range(
-  thrust::execution_policy<System>& from_system, Allocator& a, InputIterator first, InputIterator last, Pointer result)
-{
-  return allocator_traits_detail::copy_construct_range(from_system, a, first, last, result);
-}
-
-template <typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
-_CCCL_HOST_DEVICE Pointer copy_construct_range_n(
-  thrust::execution_policy<System>& from_system, Allocator& a, InputIterator first, Size n, Pointer result)
-{
-  return allocator_traits_detail::copy_construct_range_n(from_system, a, first, n, result);
-}
-
-} // namespace detail
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/detail/allocator/destroy_range.inl

@@ -1,137 +0,0 @@
-/*
- *  Copyright 2008-2021 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-
-#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
-#  pragma GCC system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
-#  pragma clang system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
-#  pragma system_header
-#endif // no system header
-
-#include <thrust/detail/allocator/allocator_traits.h>
-#include <thrust/detail/allocator/destroy_range.h>
-#include <thrust/detail/memory_wrapper.h>
-#include <thrust/detail/type_traits/pointer_traits.h>
-#include <thrust/for_each.h>
-
-THRUST_NAMESPACE_BEGIN
-namespace detail
-{
-namespace allocator_traits_detail
-{
-
-// destroy_range has three cases:
-// if Allocator has an effectful member function destroy:
-//   1. destroy via the allocator
-// else
-//   2. if T has a non-trivial destructor, destroy the range without using the allocator
-//   3. if T has a trivial destructor, do a no-op
-
-template <typename Allocator, typename T>
-struct has_effectful_member_destroy : has_member_destroy<Allocator, T>
-{};
-
-// std::allocator::destroy's only effect is to invoke its argument's destructor
-template <typename U, typename T>
-struct has_effectful_member_destroy<std::allocator<U>, T> : thrust::detail::false_type
-{};
-
-// case 1: Allocator has an effectful 1-argument member function "destroy"
-template <typename Allocator, typename Pointer>
-struct enable_if_destroy_range_case1
-    : ::cuda::std::enable_if<has_effectful_member_destroy<Allocator, typename pointer_element<Pointer>::type>::value>
-{};
-
-// case 2: Allocator has no member function "destroy", but T has a non-trivial destructor
-template <typename Allocator, typename Pointer>
-struct enable_if_destroy_range_case2
-    : ::cuda::std::enable_if<!has_effectful_member_destroy<Allocator, typename pointer_element<Pointer>::type>::value
-                             && !::cuda::std::is_trivially_destructible<typename pointer_element<Pointer>::type>::value>
-{};
-
-// case 3: Allocator has no member function "destroy", and T has a trivial destructor
-template <typename Allocator, typename Pointer>
-struct enable_if_destroy_range_case3
-    : ::cuda::std::enable_if<!has_effectful_member_destroy<Allocator, typename pointer_element<Pointer>::type>::value
-                             && ::cuda::std::is_trivially_destructible<typename pointer_element<Pointer>::type>::value>
-{};
-
-template <typename Allocator>
-struct destroy_via_allocator
-{
-  Allocator& a;
-
-  _CCCL_HOST_DEVICE destroy_via_allocator(Allocator& a) noexcept
-      : a(a)
-  {}
-
-  template <typename T>
-  inline _CCCL_HOST_DEVICE void operator()(T& x) noexcept
-  {
-    allocator_traits<Allocator>::destroy(a, &x);
-  }
-};
-
-// destroy_range case 1: destroy via allocator
-template <typename Allocator, typename Pointer, typename Size>
-_CCCL_HOST_DEVICE typename enable_if_destroy_range_case1<Allocator, Pointer>::type
-destroy_range(Allocator& a, Pointer p, Size n) noexcept
-{
-  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, destroy_via_allocator<Allocator>(a));
-}
-
-// we must prepare for His coming
-struct gozer
-{
-  _CCCL_EXEC_CHECK_DISABLE
-  template <typename T>
-  inline _CCCL_HOST_DEVICE void operator()(T& x) noexcept
-  {
-    x.~T();
-  }
-};
-
-// destroy_range case 2: destroy without the allocator
-template <typename Allocator, typename Pointer, typename Size>
-_CCCL_HOST_DEVICE typename enable_if_destroy_range_case2<Allocator, Pointer>::type
-destroy_range(Allocator& a, Pointer p, Size n) noexcept
-{
-  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, gozer());
-}
-
-// destroy_range case 3: no-op
-template <typename Allocator, typename Pointer, typename Size>
-_CCCL_HOST_DEVICE typename enable_if_destroy_range_case3<Allocator, Pointer>::type
-destroy_range(Allocator&, Pointer, Size) noexcept
-{
-  // no op
-}
-
-} // namespace allocator_traits_detail
-
-template <typename Allocator, typename Pointer, typename Size>
-_CCCL_HOST_DEVICE void destroy_range(Allocator& a, Pointer p, Size n) noexcept
-{
-  return allocator_traits_detail::destroy_range(a, p, n);
-}
-
-} // namespace detail
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/detail/allocator/fill_construct_range.inl

@@ -1,99 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-
-#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
-#  pragma GCC system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
-#  pragma clang system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
-#  pragma system_header
-#endif // no system header
-#include <thrust/detail/allocator/allocator_traits.h>
-#include <thrust/detail/memory_wrapper.h>
-#include <thrust/detail/type_traits.h>
-#include <thrust/detail/type_traits/pointer_traits.h>
-#include <thrust/for_each.h>
-#include <thrust/uninitialized_fill.h>
-
-THRUST_NAMESPACE_BEGIN
-namespace detail
-{
-namespace allocator_traits_detail
-{
-
-// fill_construct_range has 2 cases:
-// if Allocator has an effectful member function construct:
-//   1. construct via the allocator
-// else
-//   2. construct via uninitialized_fill
-
-template <typename Allocator, typename T, typename Arg1>
-struct has_effectful_member_construct2 : has_member_construct2<Allocator, T, Arg1>
-{};
-
-// std::allocator::construct's only effect is to invoke placement new
-template <typename U, typename T, typename Arg1>
-struct has_effectful_member_construct2<std::allocator<U>, T, Arg1> : thrust::detail::false_type
-{};
-
-template <typename Allocator, typename Arg1>
-struct construct2_via_allocator
-{
-  Allocator& a;
-  Arg1 arg;
-
-  _CCCL_HOST_DEVICE construct2_via_allocator(Allocator& a, const Arg1& arg)
-      : a(a)
-      , arg(arg)
-  {}
-
-  template <typename T>
-  inline _CCCL_HOST_DEVICE void operator()(T& x)
-  {
-    allocator_traits<Allocator>::construct(a, &x, arg);
-  }
-};
-
-template <typename Allocator, typename Pointer, typename Size, typename T>
-_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<
-  has_effectful_member_construct2<Allocator, typename pointer_element<Pointer>::type, T>::value>
-fill_construct_range(Allocator& a, Pointer p, Size n, const T& value)
-{
-  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, construct2_via_allocator<Allocator, T>(a, value));
-}
-
-template <typename Allocator, typename Pointer, typename Size, typename T>
-_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<
-  !has_effectful_member_construct2<Allocator, typename pointer_element<Pointer>::type, T>::value>
-fill_construct_range(Allocator& a, Pointer p, Size n, const T& value)
-{
-  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, value);
-}
-
-} // namespace allocator_traits_detail
-
-template <typename Alloc, typename Pointer, typename Size, typename T>
-_CCCL_HOST_DEVICE void fill_construct_range(Alloc& a, Pointer p, Size n, const T& value)
-{
-  return allocator_traits_detail::fill_construct_range(a, p, n, value);
-}
-
-} // namespace detail
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/detail/allocator/malloc_allocator.inl

@@ -1,68 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-
-#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
-#  pragma GCC system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
-#  pragma clang system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
-#  pragma system_header
-#endif // no system header
-#include <thrust/detail/allocator/malloc_allocator.h>
-#include <thrust/detail/malloc_and_free.h>
-#include <thrust/detail/raw_pointer_cast.h>
-#include <thrust/system/detail/bad_alloc.h>
-#include <thrust/system/detail/generic/select_system.h>
-
-THRUST_NAMESPACE_BEGIN
-namespace detail
-{
-
-template <typename T, typename System, typename Pointer>
-typename malloc_allocator<T, System, Pointer>::pointer
-malloc_allocator<T, System, Pointer>::allocate(typename malloc_allocator<T, System, Pointer>::size_type cnt)
-{
-  using thrust::system::detail::generic::select_system;
-
-  // XXX should use a hypothetical thrust::static_pointer_cast here
-  System system;
-
-  pointer result = thrust::malloc<T>(select_system(system), cnt);
-
-  if (result.get() == 0)
-  {
-    throw thrust::system::detail::bad_alloc("malloc_allocator::allocate: malloc failed");
-  } // end if
-
-  return result;
-} // end malloc_allocator::allocate()
-
-template <typename T, typename System, typename Pointer>
-void malloc_allocator<T, System, Pointer>::deallocate(typename malloc_allocator<T, System, Pointer>::pointer p,
-                                                      typename malloc_allocator<T, System, Pointer>::size_type) noexcept
-{
-  using thrust::system::detail::generic::select_system;
-
-  System system;
-  thrust::free(select_system(system), p);
-} // end malloc_allocator
-
-} // namespace detail
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/detail/allocator/tagged_allocator.inl

@@ -1,86 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-
-#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
-#  pragma GCC system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
-#  pragma clang system_header
-#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
-#  pragma system_header
-#endif // no system header
-#include <thrust/detail/allocator/tagged_allocator.h>
-
-#include <cuda/std/limits>
-
-THRUST_NAMESPACE_BEGIN
-namespace detail
-{
-
-template <typename T, typename Tag, typename Pointer>
-_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::tagged_allocator()
-{}
-
-template <typename T, typename Tag, typename Pointer>
-_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::tagged_allocator(const tagged_allocator<T, Tag, Pointer>&)
-{}
-
-template <typename T, typename Tag, typename Pointer>
-template <typename U, typename OtherPointer>
-_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::tagged_allocator(const tagged_allocator<U, Tag, OtherPointer>&)
-{}
-
-template <typename T, typename Tag, typename Pointer>
-_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::~tagged_allocator()
-{}
-
-template <typename T, typename Tag, typename Pointer>
-_CCCL_HOST_DEVICE typename tagged_allocator<T, Tag, Pointer>::pointer
-tagged_allocator<T, Tag, Pointer>::address(reference x) const
-{
-  return &x;
-}
-
-template <typename T, typename Tag, typename Pointer>
-_CCCL_HOST_DEVICE typename tagged_allocator<T, Tag, Pointer>::const_pointer
-tagged_allocator<T, Tag, Pointer>::address(const_reference x) const
-{
-  return &x;
-}
-
-template <typename T, typename Tag, typename Pointer>
-typename tagged_allocator<T, Tag, Pointer>::size_type tagged_allocator<T, Tag, Pointer>::max_size() const
-{
-  return (::cuda::std::numeric_limits<size_type>::max)() / sizeof(T);
-}
-
-template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
-_CCCL_HOST_DEVICE bool operator==(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&)
-{
-  return true;
-}
-
-template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
-_CCCL_HOST_DEVICE bool operator!=(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&)
-{
-  return false;
-}
-
-} // namespace detail
-THRUST_NAMESPACE_END