cuda-cccl 0.3.0__cp312-cp312-manylinux_2_24_aarch64.whl → 0.3.2__cp312-cp312-manylinux_2_24_aarch64.whl

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

@@ -1,79 +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/temporary_allocator.h>
-#include <thrust/detail/temporary_buffer.h>
-#include <thrust/system/detail/bad_alloc.h>
-
-#include <cuda/std/cassert>
-
-#include <nv/target>
-
-#if _CCCL_CUDA_COMPILATION() && _CCCL_DEVICE_COMPILATION()
-#  include <thrust/system/cuda/detail/terminate.h>
-#endif // _CCCL_CUDA_COMPILATION() && _CCCL_DEVICE_COMPILATION()
-
-THRUST_NAMESPACE_BEGIN
-namespace detail
-{
-
-template <typename T, typename System>
-_CCCL_HOST_DEVICE typename temporary_allocator<T, System>::pointer
-temporary_allocator<T, System>::allocate(typename temporary_allocator<T, System>::size_type cnt)
-{
-  pointer_and_size result = thrust::get_temporary_buffer<T>(system(), cnt);
-
-  // handle failure
-  if (result.second < cnt)
-  {
-    // deallocate and throw
-    // note that we pass cnt to deallocate, not a value derived from result.second
-    deallocate(result.first, cnt);
-
-#if _CCCL_CUDA_COMPILATION()
-    NV_IF_TARGET(NV_IS_HOST,
-                 (throw thrust::system::detail::bad_alloc("temporary_buffer::allocate: get_temporary_buffer failed");),
-                 ( // NV_IS_DEVICE
-                   thrust::system::cuda::detail::terminate_with_message("temporary_buffer::allocate: "
-                                                                        "get_temporary_buffer failed");));
-#else
-    throw thrust::system::detail::bad_alloc("temporary_buffer::allocate: get_temporary_buffer failed");
-#endif
-  } // end if
-
-  return result.first;
-} // end temporary_allocator::allocate()
-
-template <typename T, typename System>
-_CCCL_HOST_DEVICE void temporary_allocator<T, System>::deallocate(
-  typename temporary_allocator<T, System>::pointer p, typename temporary_allocator<T, System>::size_type n) noexcept
-{
-  return thrust::return_temporary_buffer(system(), p, n);
-} // end temporary_allocator
-
-} // namespace detail
-THRUST_NAMESPACE_END

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

@@ -1,98 +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/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
-{
-
-template <typename Allocator>
-struct construct1_via_allocator
-{
-  Allocator& a;
-
-  _CCCL_HOST_DEVICE construct1_via_allocator(Allocator& a)
-      : a(a)
-  {}
-
-  template <typename T>
-  inline _CCCL_HOST_DEVICE void operator()(T& x)
-  {
-    allocator_traits<Allocator>::construct(a, &x);
-  }
-};
-
-// we need to construct T via the allocator if...
-template <typename Allocator, typename T>
-struct needs_default_construct_via_allocator
-    : ::cuda::std::disjunction<has_member_construct1<Allocator, T>, // if the Allocator does something interesting
-                                                                    // or if T's default constructor does something
-                                                                    // interesting
-                               thrust::detail::not_<::cuda::std::is_trivially_default_constructible<T>>>
-{};
-
-// we know that std::allocator::construct's only effect is to call T's
-// default constructor, so we needn't use it for default construction
-// unless T's constructor does something interesting
-template <typename U, typename T>
-struct needs_default_construct_via_allocator<std::allocator<U>, T>
-    : thrust::detail::not_<::cuda::std::is_trivially_default_constructible<T>>
-{};
-
-template <typename Allocator, typename Pointer, typename Size>
-_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<
-  needs_default_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value>
-value_initialize_range(Allocator& a, Pointer p, Size n)
-{
-  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, construct1_via_allocator<Allocator>(a));
-}
-
-template <typename Allocator, typename Pointer, typename Size>
-_CCCL_HOST_DEVICE
-typename disable_if<needs_default_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value>::type
-value_initialize_range(Allocator& a, Pointer p, Size n)
-{
-  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, typename pointer_element<Pointer>::type());
-}
-
-} // namespace allocator_traits_detail
-
-template <typename Allocator, typename Pointer, typename Size>
-_CCCL_HOST_DEVICE void value_initialize_range(Allocator& a, Pointer p, Size n)
-{
-  return allocator_traits_detail::value_initialize_range(a, p, n);
-}
-
-} // namespace detail
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/detail/device_delete.inl

@@ -1,52 +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/destroy_range.h>
-#include <thrust/device_delete.h>
-#include <thrust/device_free.h>
-
-THRUST_NAMESPACE_BEGIN
-
-namespace detail
-{
-
-// define an empty allocator class to use below
-struct device_delete_allocator
-{};
-
-} // namespace detail
-
-template <typename T>
-void device_delete(device_ptr<T> ptr, const size_t n)
-{
-  // we can use device_allocator to destroy the range
-  thrust::detail::device_delete_allocator a;
-  thrust::detail::destroy_range(a, ptr, n);
-  thrust::device_free(ptr);
-} // end device_delete()
-
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/detail/device_free.inl

@@ -1,47 +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/malloc_and_free.h>
-#include <thrust/device_free.h>
-#include <thrust/iterator/iterator_traits.h>
-#include <thrust/system/detail/generic/select_system.h>
-
-THRUST_NAMESPACE_BEGIN
-
-void device_free(thrust::device_ptr<void> ptr)
-{
-  using thrust::system::detail::generic::select_system;
-
-  using system = thrust::iterator_system<thrust::device_ptr<void>>::type;
-
-  // XXX lower to select_system(system) here
-  system s;
-
-  thrust::free(s, ptr);
-} // end device_free()
-
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/detail/device_new.inl

@@ -1,61 +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/device_malloc.h>
-#include <thrust/device_new.h>
-#include <thrust/uninitialized_fill.h>
-
-THRUST_NAMESPACE_BEGIN
-
-template <typename T>
-device_ptr<T> device_new(device_ptr<void> p, const size_t n)
-{
-  // XXX TODO dispatch n null device constructors at p here
-  // in the meantime, dispatch 1 null host constructor here
-  // and dispatch n copy constructors
-  return device_new<T>(p, T(), n);
-} // end device_new()
-
-template <typename T>
-device_ptr<T> device_new(device_ptr<void> p, const T& exemplar, const size_t n)
-{
-  device_ptr<T> result(reinterpret_cast<T*>(p.get()));
-
-  // run copy constructors at p here
-  thrust::uninitialized_fill(result, result + n, exemplar);
-
-  return result;
-} // end device_new()
-
-template <typename T>
-device_ptr<T> device_new(const size_t n)
-{
-  // call placement new
-  return device_new<T>(thrust::device_malloc<T>(n));
-} // end device_new()
-
-THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/detail/memory_wrapper.h

@@ -1,40 +0,0 @@
-/*
- *  Copyright 2020 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
-
-// When a compiler uses Thrust as part of its implementation of Standard C++
-// algorithms, a cycle of included files may result when Thrust code tries to
-// use a standard algorithm.  Having a macro that is defined only when Thrust
-// is including an algorithms-related header gives the compiler a chance to
-// detect and break the cycle of includes.  (<memory> declares several standard
-// algorithms, including all of the uninitialized_* algorithms.  "_ALGORITHMS_"
-// in the macro name is meant generically, not as a specific reference to
-// the header <algorithms>.)
-
-#define THRUST_INCLUDING_ALGORITHMS_HEADER
-#include <memory>
-#undef THRUST_INCLUDING_ALGORITHMS_HEADER

cuda/cccl/headers/include/thrust/detail/numeric_wrapper.h

@@ -1,37 +0,0 @@
-/*
- *  Copyright 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
-
-// When a compiler uses Thrust as part of its implementation of Standard C++
-// algorithms, a cycle of included files may result when Thrust code tries to
-// use a standard algorithm.  Having a macro that is defined only when Thrust
-// is including an algorithms-related header gives the compiler a chance to
-// detect and break the cycle of includes.
-
-#define THRUST_INCLUDING_ALGORITHMS_HEADER
-#include <numeric>
-#undef THRUST_INCLUDING_ALGORITHMS_HEADER

cuda/cccl/parallel/experimental/.gitignore

@@ -1,4 +0,0 @@
-# these are generated at build time depending on the CUDA
-# version we're building for:
-cu12/
-cu13/