cuda-cccl 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.4__cp313-cp313-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/thrust/system/tbb/detail/copy_if.inl

@@ -1,136 +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/function.h>
-#include <thrust/distance.h>
-#include <thrust/iterator/iterator_traits.h>
-#include <thrust/system/tbb/detail/copy_if.h>
-
-#include <tbb/blocked_range.h>
-#include <tbb/parallel_scan.h>
-
-THRUST_NAMESPACE_BEGIN
-namespace system
-{
-namespace tbb
-{
-namespace detail
-{
-namespace copy_if_detail
-{
-
-template <typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate, typename Size>
-struct body
-{
-  InputIterator1 first;
-  InputIterator2 stencil;
-  OutputIterator result;
-  thrust::detail::wrapped_function<Predicate, bool> pred;
-  Size sum;
-
-  body(InputIterator1 first, InputIterator2 stencil, OutputIterator result, Predicate pred)
-      : first(first)
-      , stencil(stencil)
-      , result(result)
-      , pred{pred}
-      , sum(0)
-  {}
-
-  body(body& b, ::tbb::split)
-      : first(b.first)
-      , stencil(b.stencil)
-      , result(b.result)
-      , pred{b.pred}
-      , sum(0)
-  {}
-
-  void operator()(const ::tbb::blocked_range<Size>& r, ::tbb::pre_scan_tag)
-  {
-    InputIterator2 iter = stencil + r.begin();
-
-    for (Size i = r.begin(); i != r.end(); ++i, ++iter)
-    {
-      if (pred(*iter))
-      {
-        ++sum;
-      }
-    }
-  }
-
-  void operator()(const ::tbb::blocked_range<Size>& r, ::tbb::final_scan_tag)
-  {
-    InputIterator1 iter1 = first + r.begin();
-    InputIterator2 iter2 = stencil + r.begin();
-    OutputIterator iter3 = result + sum;
-
-    for (Size i = r.begin(); i != r.end(); ++i, ++iter1, ++iter2)
-    {
-      if (pred(*iter2))
-      {
-        *iter3 = *iter1;
-        ++sum;
-        ++iter3;
-      }
-    }
-  }
-
-  void reverse_join(body& b)
-  {
-    sum = b.sum + sum;
-  }
-
-  void assign(body& b)
-  {
-    sum = b.sum;
-  }
-}; // end body
-
-} // namespace copy_if_detail
-
-template <typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
-OutputIterator
-copy_if(tag, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
-{
-  using Size = thrust::detail::it_difference_t<InputIterator1>;
-  using Body = typename copy_if_detail::body<InputIterator1, InputIterator2, OutputIterator, Predicate, Size>;
-
-  Size n = ::cuda::std::distance(first, last);
-
-  if (n != 0)
-  {
-    Body body(first, stencil, result, pred);
-    ::tbb::parallel_scan(::tbb::blocked_range<Size>(0, n), body);
-    ::cuda::std::advance(result, body.sum);
-  }
-
-  return result;
-} // end copy_if()
-
-} // namespace detail
-} // namespace tbb
-} // namespace system
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/system/tbb/detail/for_each.inl

@@ -1,91 +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/seq.h>
-#include <thrust/detail/static_assert.h>
-#include <thrust/distance.h>
-#include <thrust/iterator/iterator_traits.h>
-
-#include <tbb/blocked_range.h>
-#include <tbb/parallel_for.h>
-
-THRUST_NAMESPACE_BEGIN
-namespace system
-{
-namespace tbb
-{
-namespace detail
-{
-namespace for_each_detail
-{
-
-template <typename RandomAccessIterator, typename Size, typename UnaryFunction>
-struct body
-{
-  RandomAccessIterator m_first;
-  UnaryFunction m_f;
-
-  body(RandomAccessIterator first, UnaryFunction f)
-      : m_first(first)
-      , m_f(f)
-  {}
-
-  void operator()(const ::tbb::blocked_range<Size>& r) const
-  {
-    // we assume that blocked_range specifies a contiguous range of integers
-    thrust::for_each_n(seq, m_first + r.begin(), r.size(), m_f);
-  } // end operator()()
-}; // end body
-
-template <typename Size, typename RandomAccessIterator, typename UnaryFunction>
-body<RandomAccessIterator, Size, UnaryFunction> make_body(RandomAccessIterator first, UnaryFunction f)
-{
-  return body<RandomAccessIterator, Size, UnaryFunction>(first, f);
-} // end make_body()
-
-} // namespace for_each_detail
-
-template <typename DerivedPolicy, typename RandomAccessIterator, typename Size, typename UnaryFunction>
-RandomAccessIterator for_each_n(execution_policy<DerivedPolicy>&, RandomAccessIterator first, Size n, UnaryFunction f)
-{
-  ::tbb::parallel_for(::tbb::blocked_range<Size>(0, n), for_each_detail::make_body<Size>(first, f));
-
-  // return the end of the range
-  return first + n;
-} // end for_each_n
-
-template <typename DerivedPolicy, typename RandomAccessIterator, typename UnaryFunction>
-RandomAccessIterator
-for_each(execution_policy<DerivedPolicy>& s, RandomAccessIterator first, RandomAccessIterator last, UnaryFunction f)
-{
-  return tbb::detail::for_each_n(s, first, ::cuda::std::distance(first, last), f);
-} // end for_each()
-
-} // end namespace detail
-} // end namespace tbb
-} // end namespace system
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/system/tbb/detail/memory.inl

@@ -1,94 +0,0 @@
-/*
- *  Copyright 2008-2018 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/system/cpp/detail/execution_policy.h>
-#include <thrust/system/cpp/memory.h>
-#include <thrust/system/tbb/memory.h>
-
-#include <cuda/std/limits>
-
-THRUST_NAMESPACE_BEGIN
-namespace system
-{
-namespace tbb
-{
-
-namespace detail
-{
-
-// XXX circular #inclusion problems cause the compiler to believe that cpp::malloc
-//     is not defined
-//     WAR the problem by using adl to call cpp::malloc, which requires it to depend
-//     on a template parameter
-template <typename Tag>
-pointer<void> malloc_workaround(Tag t, std::size_t n)
-{
-  return pointer<void>(malloc(t, n));
-} // end malloc_workaround()
-
-// XXX circular #inclusion problems cause the compiler to believe that cpp::free
-//     is not defined
-//     WAR the problem by using adl to call cpp::free, which requires it to depend
-//     on a template parameter
-template <typename Tag>
-void free_workaround(Tag t, pointer<void> ptr)
-{
-  free(t, ptr.get());
-} // end free_workaround()
-
-} // namespace detail
-
-inline pointer<void> malloc(std::size_t n)
-{
-  // XXX this is how we'd like to implement this function,
-  //     if not for circular #inclusion problems:
-  //
-  // return pointer<void>(thrust::system::cpp::malloc(n))
-  //
-  return detail::malloc_workaround(cpp::tag(), n);
-} // end malloc()
-
-template <typename T>
-pointer<T> malloc(std::size_t n)
-{
-  pointer<void> raw_ptr = thrust::system::tbb::malloc(sizeof(T) * n);
-  return pointer<T>(reinterpret_cast<T*>(raw_ptr.get()));
-} // end malloc()
-
-inline void free(pointer<void> ptr)
-{
-  // XXX this is how we'd like to implement this function,
-  //     if not for circular #inclusion problems:
-  //
-  // thrust::system::cpp::free(ptr)
-  //
-  detail::free_workaround(cpp::tag(), ptr);
-} // end free()
-
-} // namespace tbb
-} // namespace system
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/system/tbb/detail/merge.inl

@@ -1,327 +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/binary_search.h>
-#include <thrust/detail/seq.h>
-#include <thrust/detail/temporary_array.h>
-#include <thrust/iterator/iterator_traits.h>
-#include <thrust/merge.h>
-#include <thrust/system/tbb/detail/execution_policy.h>
-
-#include <tbb/parallel_for.h>
-
-THRUST_NAMESPACE_BEGIN
-namespace system
-{
-namespace tbb
-{
-namespace detail
-{
-namespace merge_detail
-{
-
-template <typename InputIterator1, typename InputIterator2, typename OutputIterator, typename StrictWeakOrdering>
-struct range
-{
-  InputIterator1 first1, last1;
-  InputIterator2 first2, last2;
-  OutputIterator result;
-  StrictWeakOrdering comp;
-  size_t grain_size;
-
-  range(InputIterator1 first1,
-        InputIterator1 last1,
-        InputIterator2 first2,
-        InputIterator2 last2,
-        OutputIterator result,
-        StrictWeakOrdering comp,
-        size_t grain_size = 1024)
-      : first1(first1)
-      , last1(last1)
-      , first2(first2)
-      , last2(last2)
-      , result(result)
-      , comp(comp)
-      , grain_size(grain_size)
-  {}
-
-  range(range& r, ::tbb::split)
-      : first1(r.first1)
-      , last1(r.last1)
-      , first2(r.first2)
-      , last2(r.last2)
-      , result(r.result)
-      , comp(r.comp)
-      , grain_size(r.grain_size)
-  {
-    // we can assume n1 and n2 are not both 0
-    size_t n1 = ::cuda::std::distance(first1, last1);
-    size_t n2 = ::cuda::std::distance(first2, last2);
-
-    InputIterator1 mid1 = first1;
-    InputIterator2 mid2 = first2;
-
-    if (n1 > n2)
-    {
-      mid1 += n1 / 2;
-      mid2 = thrust::lower_bound(thrust::seq, first2, last2, raw_reference_cast(*mid1), comp);
-    }
-    else
-    {
-      mid2 += n2 / 2;
-      mid1 = thrust::upper_bound(thrust::seq, first1, last1, raw_reference_cast(*mid2), comp);
-    }
-
-    // set first range to [first1, mid1), [first2, mid2), result
-    r.last1 = mid1;
-    r.last2 = mid2;
-
-    // set second range to [mid1, last1), [mid2, last2), result + (mid1 - first1) + (mid2 - first2)
-    first1 = mid1;
-    first2 = mid2;
-    result += ::cuda::std::distance(r.first1, mid1) + ::cuda::std::distance(r.first2, mid2);
-  }
-
-  bool empty() const
-  {
-    return (first1 == last1) && (first2 == last2);
-  }
-
-  bool is_divisible() const
-  {
-    return static_cast<size_t>(::cuda::std::distance(first1, last1) + ::cuda::std::distance(first2, last2))
-         > grain_size;
-  }
-};
-
-struct body
-{
-  template <typename Range>
-  void operator()(Range& r) const
-  {
-    thrust::merge(thrust::seq, r.first1, r.last1, r.first2, r.last2, r.result, r.comp);
-  }
-};
-
-} // end namespace merge_detail
-
-namespace merge_by_key_detail
-{
-
-template <typename InputIterator1,
-          typename InputIterator2,
-          typename InputIterator3,
-          typename InputIterator4,
-          typename OutputIterator1,
-          typename OutputIterator2,
-          typename StrictWeakOrdering>
-struct range
-{
-  InputIterator1 keys_first1, keys_last1;
-  InputIterator2 keys_first2, keys_last2;
-  InputIterator3 values_first1;
-  InputIterator4 values_first2;
-  OutputIterator1 keys_result;
-  OutputIterator2 values_result;
-  StrictWeakOrdering comp;
-  size_t grain_size;
-
-  range(InputIterator1 keys_first1,
-        InputIterator1 keys_last1,
-        InputIterator2 keys_first2,
-        InputIterator2 keys_last2,
-        InputIterator3 values_first1,
-        InputIterator4 values_first2,
-        OutputIterator1 keys_result,
-        OutputIterator2 values_result,
-        StrictWeakOrdering comp,
-        size_t grain_size = 1024)
-      : keys_first1(keys_first1)
-      , keys_last1(keys_last1)
-      , keys_first2(keys_first2)
-      , keys_last2(keys_last2)
-      , values_first1(values_first1)
-      , values_first2(values_first2)
-      , keys_result(keys_result)
-      , values_result(values_result)
-      , comp(comp)
-      , grain_size(grain_size)
-  {}
-
-  range(range& r, ::tbb::split)
-      : keys_first1(r.keys_first1)
-      , keys_last1(r.keys_last1)
-      , keys_first2(r.keys_first2)
-      , keys_last2(r.keys_last2)
-      , values_first1(r.values_first1)
-      , values_first2(r.values_first2)
-      , keys_result(r.keys_result)
-      , values_result(r.values_result)
-      , comp(r.comp)
-      , grain_size(r.grain_size)
-  {
-    // we can assume n1 and n2 are not both 0
-    size_t n1 = ::cuda::std::distance(keys_first1, keys_last1);
-    size_t n2 = ::cuda::std::distance(keys_first2, keys_last2);
-
-    InputIterator1 mid1 = keys_first1;
-    InputIterator2 mid2 = keys_first2;
-
-    if (n1 > n2)
-    {
-      mid1 += n1 / 2;
-      mid2 = thrust::lower_bound(thrust::seq, keys_first2, keys_last2, raw_reference_cast(*mid1), comp);
-    }
-    else
-    {
-      mid2 += n2 / 2;
-      mid1 = thrust::upper_bound(thrust::seq, keys_first1, keys_last1, raw_reference_cast(*mid2), comp);
-    }
-
-    // set first range to [keys_first1, mid1), [keys_first2, mid2), keys_result, values_result
-    r.keys_last1 = mid1;
-    r.keys_last2 = mid2;
-
-    // set second range to [mid1, keys_last1), [mid2, keys_last2), keys_result + (mid1 - keys_first1) + (mid2 -
-    // keys_first2), values_result + (mid1 - keys_first1) + (mid2 - keys_first2)
-    keys_first1 = mid1;
-    keys_first2 = mid2;
-    values_first1 += ::cuda::std::distance(r.keys_first1, mid1);
-    values_first2 += ::cuda::std::distance(r.keys_first2, mid2);
-    keys_result += ::cuda::std::distance(r.keys_first1, mid1) + ::cuda::std::distance(r.keys_first2, mid2);
-    values_result += ::cuda::std::distance(r.keys_first1, mid1) + ::cuda::std::distance(r.keys_first2, mid2);
-  }
-
-  bool empty() const
-  {
-    return (keys_first1 == keys_last1) && (keys_first2 == keys_last2);
-  }
-
-  bool is_divisible() const
-  {
-    return static_cast<size_t>(
-             ::cuda::std::distance(keys_first1, keys_last1) + ::cuda::std::distance(keys_first2, keys_last2))
-         > grain_size;
-  }
-};
-
-struct body
-{
-  template <typename Range>
-  void operator()(Range& r) const
-  {
-    thrust::merge_by_key(
-      thrust::seq,
-      r.keys_first1,
-      r.keys_last1,
-      r.keys_first2,
-      r.keys_last2,
-      r.values_first1,
-      r.values_first2,
-      r.keys_result,
-      r.values_result,
-      r.comp);
-  }
-};
-
-} // end namespace merge_by_key_detail
-
-template <typename DerivedPolicy,
-          typename InputIterator1,
-          typename InputIterator2,
-          typename OutputIterator,
-          typename StrictWeakOrdering>
-OutputIterator
-merge(execution_policy<DerivedPolicy>&,
-      InputIterator1 first1,
-      InputIterator1 last1,
-      InputIterator2 first2,
-      InputIterator2 last2,
-      OutputIterator result,
-      StrictWeakOrdering comp)
-{
-  using Range = typename merge_detail::range<InputIterator1, InputIterator2, OutputIterator, StrictWeakOrdering>;
-  using Body  = merge_detail::body;
-  Range range(first1, last1, first2, last2, result, comp);
-  Body body;
-
-  ::tbb::parallel_for(range, body);
-
-  ::cuda::std::advance(result, ::cuda::std::distance(first1, last1) + ::cuda::std::distance(first2, last2));
-
-  return result;
-} // end merge()
-
-template <typename DerivedPolicy,
-          typename InputIterator1,
-          typename InputIterator2,
-          typename InputIterator3,
-          typename InputIterator4,
-          typename OutputIterator1,
-          typename OutputIterator2,
-          typename StrictWeakOrdering>
-thrust::pair<OutputIterator1, OutputIterator2> merge_by_key(
-  execution_policy<DerivedPolicy>&,
-  InputIterator1 keys_first1,
-  InputIterator1 keys_last1,
-  InputIterator2 keys_first2,
-  InputIterator2 keys_last2,
-  InputIterator3 values_first3,
-  InputIterator4 values_first4,
-  OutputIterator1 keys_result,
-  OutputIterator2 values_result,
-  StrictWeakOrdering comp)
-{
-  using Range = typename merge_by_key_detail::range<
-    InputIterator1,
-    InputIterator2,
-    InputIterator3,
-    InputIterator4,
-    OutputIterator1,
-    OutputIterator2,
-    StrictWeakOrdering>;
-  using Body = merge_by_key_detail::body;
-
-  Range range(
-    keys_first1, keys_last1, keys_first2, keys_last2, values_first3, values_first4, keys_result, values_result, comp);
-  Body body;
-
-  ::tbb::parallel_for(range, body);
-
-  ::cuda::std::advance(keys_result,
-                       ::cuda::std::distance(keys_first1, keys_last1) + ::cuda::std::distance(keys_first2, keys_last2));
-  ::cuda::std::advance(values_result,
-                       ::cuda::std::distance(keys_first1, keys_last1) + ::cuda::std::distance(keys_first2, keys_last2));
-
-  return thrust::make_pair(keys_result, values_result);
-}
-
-} // end namespace detail
-} // end namespace tbb
-} // end namespace system
-THRUST_NAMESPACE_END