Add files using upload-large-folder tool

.gitattributes

@@ -95,3 +95,4 @@ miniCUDA124/bin/nvprof.exe filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/npps64_12.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvrtc64_120_0.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvrtc-builtins64_124.dll filter=lfs diff=lfs merge=lfs -text
+miniCUDA124/bin/nvjpeg64_12.dll filter=lfs diff=lfs merge=lfs -text

miniCUDA124/bin/nvjpeg64_12.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae60b58ff90f87e2b5002c6ddc3b7eef0538e0537a9011042303e646175ce7af
+size 4913152

miniCUDA124/include/thrust/system/cuda/detail/async/copy.h

@@ -0,0 +1,545 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#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/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/async/transform.h>
+#include <thrust/system/cuda/detail/cross_system.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/type_traits/logical_metafunctions.h>
+#include <thrust/detail/static_assert.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+#include <thrust/distance.h>
+#include <thrust/advance.h>
+#include <thrust/uninitialized_copy.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+// ContiguousIterator input and output iterators
+// TriviallyCopyable elements
+// Host to device, device to host, device to device
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  FromPolicy& from_exec
+, ToPolicy&   to_exec
+, ForwardIt   first
+, Size        n
+, OutputIt    output
+) ->
+  typename std::enable_if<
+    is_indirectly_trivially_relocatable_to<ForwardIt, OutputIt>::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const device_alloc = get_async_device_allocator(
+    select_device_system(from_exec, to_exec)
+  );
+
+  using pointer
+    = typename thrust::detail::allocator_traits<decltype(device_alloc)>::
+      template rebind_traits<void>::pointer;
+
+  unique_eager_event e;
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(
+    select_device_system(from_exec, to_exec)
+  );
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(from_exec))
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(to_exec))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        extract_dependencies(
+          std::move(thrust::detail::derived_cast(from_exec))
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(to_exec))
+        )
+      )
+    );
+  }
+
+  // Run copy.
+
+  thrust::cuda_cub::throw_on_error(
+    cudaMemcpyAsync(
+      thrust::raw_pointer_cast(&*output)
+    , thrust::raw_pointer_cast(&*first)
+    , sizeof(T) * n
+    , direction_of_copy(from_exec, to_exec)
+    , e.stream().native_handle()
+    )
+  , "after copy launch"
+  );
+
+  return e;
+}
+
+// Non-ContiguousIterator input or output, or non-TriviallyRelocatable value type
+// Device to device
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  thrust::cuda::execution_policy<FromPolicy>& from_exec
+, thrust::cuda::execution_policy<ToPolicy>&   to_exec
+, ForwardIt                                   first
+, Size                                        n
+, OutputIt                                    output
+) ->
+  typename std::enable_if<
+    conjunction<
+      negation<
+        is_indirectly_trivially_relocatable_to<ForwardIt, OutputIt>
+      >
+    , decltype(is_device_to_device_copy(from_exec, to_exec))
+    >::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  return async_transform_n(
+    select_device_system(from_exec, to_exec)
+  , first, n, output, thrust::identity<T>()
+  );
+}
+
+template <typename OutputIt>
+void async_copy_n_compile_failure_no_cuda_to_non_contiguous_output()
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (negation<is_contiguous_iterator<OutputIt>>::value)
+  , "copying to non-ContiguousIterators in another system from the CUDA system "
+    "is not supported; use `THRUST_PROCLAIM_CONTIGUOUS_ITERATOR(Iterator)` to "
+    "indicate that an iterator points to elements that are contiguous in memory."
+  );
+}
+
+// Non-ContiguousIterator output iterator
+// TriviallyRelocatable value type
+// Device to host, host to device
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  FromPolicy& from_exec
+, ToPolicy&   to_exec
+, ForwardIt   first
+, Size        n
+, OutputIt    output
+) ->
+  typename std::enable_if<
+    conjunction<
+      negation<is_contiguous_iterator<OutputIt>>
+    , is_trivially_relocatable_to<
+        typename iterator_traits<ForwardIt>::value_type
+      , typename iterator_traits<OutputIt>::value_type
+      >
+    , disjunction<
+        decltype(is_host_to_device_copy(from_exec, to_exec))
+      , decltype(is_device_to_host_copy(from_exec, to_exec))
+      >
+    >::value
+  , unique_eager_event
+  >::type
+{
+  async_copy_n_compile_failure_no_cuda_to_non_contiguous_output<OutputIt>();
+
+  return {};
+}
+
+// Workaround for MSVC's lack of expression SFINAE and also for an NVCC bug.
+// In NVCC, when two SFINAE-enabled overloads are only distinguishable by a
+// part of a SFINAE condition that is in a `decltype`, NVCC thinks they are the
+// same overload and emits an error.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt
+  // MSVC2015 WAR: doesn't like decltype(...)::value in superclass definition
+, typename IsH2DCopy = decltype(is_host_to_device_copy(
+    std::declval<FromPolicy const&>()
+  , std::declval<ToPolicy const&>()))
+>
+struct is_buffered_trivially_relocatable_host_to_device_copy
+  : thrust::integral_constant<
+      bool
+    ,    !is_contiguous_iterator<ForwardIt>::value
+      && is_contiguous_iterator<OutputIt>::value
+      && is_trivially_relocatable_to<
+            typename iterator_traits<ForwardIt>::value_type
+          , typename iterator_traits<OutputIt>::value_type
+          >::value
+      && IsH2DCopy::value
+    >
+{};
+
+// Non-ContiguousIterator input iterator, ContiguousIterator output iterator
+// TriviallyRelocatable value type
+// Host to device
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  FromPolicy&                               from_exec
+, thrust::cuda::execution_policy<ToPolicy>& to_exec
+, ForwardIt                                 first
+, Size                                      n
+, OutputIt                                  output
+) ->
+  typename std::enable_if<
+    is_buffered_trivially_relocatable_host_to_device_copy<
+      FromPolicy
+    , thrust::cuda::execution_policy<ToPolicy>
+    , ForwardIt, OutputIt
+    >::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const host_alloc = get_async_host_allocator(
+    from_exec
+  );
+
+  // Create host-side buffer.
+
+  auto buffer = uninitialized_allocate_unique_n<T>(host_alloc, n);
+
+  auto const buffer_ptr = buffer.get();
+
+  // Copy into host-side buffer.
+
+  // TODO: Switch to an async call once we have async interfaces for host
+  // systems and support for cross system dependencies.
+  uninitialized_copy_n(from_exec, first, n, buffer_ptr);
+
+  // Run device-side copy.
+
+  auto new_to_exec = thrust::detail::derived_cast(to_exec).rebind_after(
+    std::tuple_cat(
+      std::make_tuple(
+        std::move(buffer)
+      )
+    , extract_dependencies(
+        std::move(thrust::detail::derived_cast(from_exec))
+      )
+    , extract_dependencies(
+        std::move(thrust::detail::derived_cast(to_exec))
+      )
+    )
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(to_exec)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_to_exec)
+    )>::value
+  ));
+
+  return async_copy_n(
+    from_exec
+    // TODO: We have to cast back to the right execution_policy class. Ideally,
+    // we should be moving here.
+  , new_to_exec
+  , buffer_ptr
+  , n
+  , output
+  );
+}
+
+// Workaround for MSVC's lack of expression SFINAE and also for an NVCC bug.
+// In NVCC, when two SFINAE-enabled overloads are only distinguishable by a
+// part of a SFINAE condition that is in a `decltype`, NVCC thinks they are the
+// same overload and emits an error.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt
+  // MSVC2015 WAR: doesn't like decltype(...)::value in superclass definition
+, typename IsD2HCopy = decltype(is_device_to_host_copy(
+    std::declval<FromPolicy const&>()
+  , std::declval<ToPolicy const&>()))
+>
+struct is_buffered_trivially_relocatable_device_to_host_copy
+  : thrust::integral_constant<
+      bool
+    ,    !is_contiguous_iterator<ForwardIt>::value
+      && is_contiguous_iterator<OutputIt>::value
+      && is_trivially_relocatable_to<
+            typename iterator_traits<ForwardIt>::value_type
+          , typename iterator_traits<OutputIt>::value_type
+          >::value
+      && IsD2HCopy::value
+    >
+{};
+
+// Non-ContiguousIterator input iterator, ContiguousIterator output iterator
+// TriviallyRelocatable value type
+// Device to host
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  thrust::cuda::execution_policy<FromPolicy>& from_exec
+, ToPolicy&                                   to_exec
+, ForwardIt                                   first
+, Size                                        n
+, OutputIt                                    output
+) ->
+  typename std::enable_if<
+    is_buffered_trivially_relocatable_device_to_host_copy<
+      thrust::cuda::execution_policy<FromPolicy>
+    , ToPolicy
+    , ForwardIt, OutputIt
+    >::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const device_alloc = get_async_device_allocator(
+    from_exec
+  );
+
+  // Create device-side buffer.
+
+  auto buffer = uninitialized_allocate_unique_n<T>(device_alloc, n);
+
+  auto const buffer_ptr = buffer.get();
+
+  // Run device-side copy.
+
+  auto f0 = async_copy_n(
+    from_exec
+  , from_exec
+  , first
+  , n
+  , buffer_ptr
+  );
+
+  // Run copy back to host.
+
+  auto new_from_exec = thrust::detail::derived_cast(from_exec).rebind_after(
+    std::move(buffer)
+  , std::move(f0)
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(from_exec)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_from_exec)
+    )>::value
+  ));
+
+  return async_copy_n(
+    new_from_exec
+  , to_exec
+  , buffer_ptr
+  , n
+  , output
+  );
+}
+
+template <typename InputType, typename OutputType>
+void async_copy_n_compile_failure_non_trivially_relocatable_elements()
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (is_trivially_relocatable_to<OutputType, InputType>::value)
+  , "only sequences of TriviallyRelocatable elements can be copied to and from "
+    "the CUDA system; use `THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(T)` to "
+    "indicate that a type can be copied by bitwise (e.g. by `memcpy`)"
+  );
+}
+
+// Non-TriviallyRelocatable value type
+// Host to device, device to host
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  FromPolicy& from_exec
+, ToPolicy&   to_exec
+, ForwardIt   first
+, Size        n
+, OutputIt    output
+) ->
+  typename std::enable_if<
+    conjunction<
+      negation<
+        is_trivially_relocatable_to<
+          typename iterator_traits<ForwardIt>::value_type
+        , typename iterator_traits<OutputIt>::value_type
+        >
+      >
+    , disjunction<
+        decltype(is_host_to_device_copy(from_exec, to_exec))
+      , decltype(is_device_to_host_copy(from_exec, to_exec))
+      >
+    >::value
+  , unique_eager_event
+  >::type
+{
+  // TODO: We could do more here with cudaHostRegister.
+
+  async_copy_n_compile_failure_non_trivially_relocatable_elements<
+    typename thrust::iterator_traits<ForwardIt>::value_type
+  , typename std::add_lvalue_reference<
+      typename thrust::iterator_traits<OutputIt>::value_type
+    >::type
+  >();
+
+  return {};
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+>
+auto async_copy(
+  thrust::cuda::execution_policy<FromPolicy>&         from_exec
+, thrust::cpp::execution_policy<ToPolicy>&            to_exec
+, ForwardIt                                           first
+, Sentinel                                            last
+, OutputIt                                            output
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_copy_n(
+    from_exec, to_exec, first, distance(first, last), output
+  )
+)
+
+// ADL entry point.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+>
+auto async_copy(
+  thrust::cpp::execution_policy<FromPolicy>& from_exec
+, thrust::cuda::execution_policy<ToPolicy>&  to_exec
+, ForwardIt                                  first
+, Sentinel                                   last
+, OutputIt                                   output
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_copy_n(
+    from_exec, to_exec, first, distance(first, last), output
+  )
+)
+
+// ADL entry point.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+>
+auto async_copy(
+  thrust::cuda::execution_policy<FromPolicy>& from_exec
+, thrust::cuda::execution_policy<ToPolicy>&   to_exec
+, ForwardIt                                   first
+, Sentinel                                    last
+, OutputIt                                    output
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_copy_n(
+    from_exec, to_exec, first, distance(first, last), output
+  )
+)
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+

miniCUDA124/include/thrust/system/cuda/detail/async/customization.h

@@ -0,0 +1,135 @@
+/******************************************************************************
+ * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#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/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/detail/type_deduction.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/execute_with_allocator.h>
+#include <thrust/system/cuda/memory_resource.h>
+#include <thrust/mr/host_memory_resource.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/disjoint_sync_pool.h>
+#include <thrust/mr/sync_pool.h>
+#include <thrust/per_device_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+using default_async_host_resource =
+  thrust::mr::synchronized_pool_resource<
+    thrust::host_memory_resource
+  >;
+
+template <typename DerivedPolicy>
+auto get_async_host_allocator(
+  thrust::detail::execution_policy_base<DerivedPolicy>&
+)
+THRUST_RETURNS(
+  thrust::mr::stateless_resource_allocator<
+    thrust::detail::uint8_t, default_async_host_resource
+  >{}
+)
+
+///////////////////////////////////////////////////////////////////////////////
+
+using default_async_device_resource =
+  thrust::mr::disjoint_synchronized_pool_resource<
+    thrust::system::cuda::memory_resource
+  , thrust::mr::new_delete_resource
+  >;
+
+template <typename DerivedPolicy>
+auto get_async_device_allocator(
+  thrust::detail::execution_policy_base<DerivedPolicy>&
+)
+THRUST_RETURNS(
+  thrust::per_device_allocator<
+    thrust::detail::uint8_t, default_async_device_resource, par_t
+  >{}
+)
+
+template <typename Allocator, template <typename> class BaseSystem>
+auto get_async_device_allocator(
+  thrust::detail::execute_with_allocator<Allocator, BaseSystem>& exec
+)
+THRUST_RETURNS(exec.get_allocator())
+
+template <typename Allocator, template <typename> class BaseSystem>
+auto get_async_device_allocator(
+  thrust::detail::execute_with_allocator_and_dependencies<
+    Allocator, BaseSystem
+  >& exec
+)
+THRUST_RETURNS(exec.get_allocator())
+
+///////////////////////////////////////////////////////////////////////////////
+
+using default_async_universal_host_pinned_resource =
+  thrust::mr::synchronized_pool_resource<
+    thrust::system::cuda::universal_host_pinned_memory_resource
+  >;
+
+template <typename DerivedPolicy>
+auto get_async_universal_host_pinned_allocator(
+  thrust::detail::execution_policy_base<DerivedPolicy>&
+)
+THRUST_RETURNS(
+  thrust::mr::stateless_resource_allocator<
+    thrust::detail::uint8_t, default_async_universal_host_pinned_resource
+  >{}
+)
+
+}}} // namespace system::cuda::detail
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+

miniCUDA124/include/thrust/system/cuda/detail/async/exclusive_scan.h

@@ -0,0 +1,209 @@
+/******************************************************************************
+ * Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#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/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/iterator/iterator_traits.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/future.h>
+
+#include <thrust/type_traits/remove_cvref.h>
+
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+// TODO specialize for thrust::plus to use e.g. ExclusiveSum instead of ExcScan
+//  - Note that thrust::plus<> is transparent, cub::Sum is not. This should be
+//    fixed in CUB first).
+//  - Need to check if CUB actually optimizes for sums before putting in effort
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cuda
+{
+namespace detail
+{
+
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Size,
+          typename OutputIt,
+          typename InitialValueType,
+          typename BinaryOp>
+unique_eager_event
+async_exclusive_scan_n(execution_policy<DerivedPolicy>& policy,
+                       ForwardIt first,
+                       Size n,
+                       OutputIt out,
+                       InitialValueType init,
+                       BinaryOp op)
+{
+  using InputValueT = cub::detail::InputValue<InitialValueType>;
+  using Dispatch32 = cub::DispatchScan<ForwardIt,
+                                       OutputIt,
+                                       BinaryOp,
+                                       InputValueT,
+                                       thrust::detail::int32_t,
+                                       InitialValueType>;
+  using Dispatch64 = cub::DispatchScan<ForwardIt,
+                                       OutputIt,
+                                       BinaryOp,
+                                       InputValueT,
+                                       thrust::detail::int64_t,
+                                       InitialValueType>;
+
+  InputValueT init_value(init);
+
+  auto const device_alloc = get_async_device_allocator(policy);
+  unique_eager_event ev;
+
+  // Determine temporary device storage requirements.
+  cudaError_t status;
+  size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                n,
+                                (nullptr,
+                                  tmp_size,
+                                  first,
+                                  out,
+                                  op,
+                                  init_value,
+                                  n_fixed,
+                                  nullptr));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for exclusive_scan");
+  }
+
+  // Allocate temporary storage.
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, tmp_size
+  );
+  void* const tmp_ptr = raw_pointer_cast(content.get());
+
+  // Set up stream with dependencies.
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    ev = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content),
+          unique_stream(nonowning, user_raw_stream)
+        ),
+        extract_dependencies(std::move(thrust::detail::derived_cast(policy)))));
+  }
+  else
+  {
+    ev = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(std::move(content)),
+        extract_dependencies(std::move(thrust::detail::derived_cast(policy)))));
+  }
+
+  // Run scan.
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                n,
+                                (tmp_ptr,
+                                  tmp_size,
+                                  first,
+                                  out,
+                                  op,
+                                  init_value,
+                                  n_fixed,
+                                  user_raw_stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after dispatching exclusive_scan kernel");
+  }
+
+  return ev;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Sentinel,
+          typename OutputIt,
+          typename InitialValueType,
+          typename BinaryOp>
+auto async_exclusive_scan(execution_policy<DerivedPolicy>& policy,
+                          ForwardIt first,
+                          Sentinel&& last,
+                          OutputIt&& out,
+                          InitialValueType &&init,
+                          BinaryOp&& op)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_exclusive_scan_n(
+    policy,
+    first,
+    distance(first, THRUST_FWD(last)),
+    THRUST_FWD(out),
+    THRUST_FWD(init),
+    THRUST_FWD(op)
+  )
+)
+
+} // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif // C++14
+

miniCUDA124/include/thrust/system/cuda/detail/async/for_each.h

@@ -0,0 +1,165 @@
+
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#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/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+template <typename ForwardIt, typename UnaryFunction>
+struct async_for_each_fn
+{
+  ForwardIt first;
+  UnaryFunction f;
+
+  __host__ __device__
+  async_for_each_fn(ForwardIt&& first_, UnaryFunction&& f_)
+    : first(std::move(first_)), f(std::move(f_))
+  {}
+
+  template <typename Index>
+  __host__ __device__
+  void operator()(Index idx)
+  {
+    f(thrust::raw_reference_cast(first[idx]));
+  }
+};
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename UnaryFunction
+>
+unique_eager_event async_for_each_n(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Size                             n,
+  UnaryFunction                    func
+) {
+  unique_eager_event e;
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      extract_dependencies(
+        std::move(thrust::detail::derived_cast(policy))
+      )
+    );
+  }
+
+  // Run for_each.
+
+  async_for_each_fn<ForwardIt, UnaryFunction> wrapped(
+    std::move(first), std::move(func)
+  );
+
+  thrust::cuda_cub::throw_on_error(
+    thrust::cuda_cub::__parallel_for::parallel_for(
+      n, std::move(wrapped), e.stream().native_handle()
+    )
+  , "after for_each launch"
+  );
+
+  return e;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename UnaryFunction
+>
+auto async_for_each(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Sentinel                         last,
+  UnaryFunction&&                  func
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_for_each_n(
+    policy, first, distance(first, last), THRUST_FWD(func)
+  )
+);
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+

miniCUDA124/include/thrust/system/cuda/detail/async/inclusive_scan.h

@@ -0,0 +1,202 @@
+/******************************************************************************
+ * Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#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/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/iterator/iterator_traits.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/future.h>
+
+#include <thrust/type_traits/remove_cvref.h>
+
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+// TODO specialize for thrust::plus to use e.g. InclusiveSum instead of IncScan
+//  - Note that thrust::plus<> is transparent, cub::Sum is not. This should be
+//    fixed in CUB first).
+//  - Need to check if CUB actually optimizes for sums before putting in effort
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cuda
+{
+namespace detail
+{
+
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Size,
+          typename OutputIt,
+          typename BinaryOp>
+unique_eager_event
+async_inclusive_scan_n(execution_policy<DerivedPolicy>& policy,
+                       ForwardIt first,
+                       Size n,
+                       OutputIt out,
+                       BinaryOp op)
+{
+  using AccumT = typename thrust::iterator_traits<ForwardIt>::value_type;
+  using Dispatch32 = cub::DispatchScan<ForwardIt,
+                                       OutputIt,
+                                       BinaryOp,
+                                       cub::NullType,
+                                       thrust::detail::int32_t,
+                                       AccumT>;
+  using Dispatch64 = cub::DispatchScan<ForwardIt,
+                                       OutputIt,
+                                       BinaryOp,
+                                       cub::NullType,
+                                       thrust::detail::int64_t,
+                                       AccumT>;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+  unique_eager_event ev;
+
+  // Determine temporary device storage requirements.
+  cudaError_t status;
+  size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                n,
+                                (nullptr,
+                                  tmp_size,
+                                  first,
+                                  out,
+                                  op,
+                                  cub::NullType{},
+                                  n_fixed,
+                                  nullptr));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for inclusive_scan");
+  }
+
+  // Allocate temporary storage.
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, tmp_size
+  );
+  void* const tmp_ptr = raw_pointer_cast(content.get());
+
+  // Set up stream with dependencies.
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    ev = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content),
+          unique_stream(nonowning, user_raw_stream)
+        ),
+        extract_dependencies(std::move(thrust::detail::derived_cast(policy)))));
+  }
+  else
+  {
+    ev = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(std::move(content)),
+        extract_dependencies(std::move(thrust::detail::derived_cast(policy)))));
+  }
+
+  // Run scan.
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                n,
+                                (tmp_ptr,
+                                 tmp_size,
+                                 first,
+                                 out,
+                                 op,
+                                 cub::NullType{},
+                                 n_fixed,
+                                 user_raw_stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after dispatching inclusive_scan kernel");
+  }
+
+  return ev;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Sentinel,
+          typename OutputIt,
+          typename BinaryOp>
+auto async_inclusive_scan(execution_policy<DerivedPolicy>& policy,
+                          ForwardIt first,
+                          Sentinel&& last,
+                          OutputIt&& out,
+                          BinaryOp&& op)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_inclusive_scan_n(
+    policy,
+    first,
+    distance(first, THRUST_FWD(last)),
+    THRUST_FWD(out),
+    THRUST_FWD(op)
+  )
+)
+
+} // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif // C++14
+

miniCUDA124/include/thrust/system/cuda/detail/async/reduce.h

@@ -0,0 +1,351 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Optimize for thrust::plus
+
+// TODO: Move into system::cuda
+
+#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/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/reduce.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename T, typename BinaryOp
+>
+unique_eager_future<remove_cvref_t<T>> async_reduce_n(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Size                             n
+, T                                init
+, BinaryOp                         op
+) {
+  using U = remove_cvref_t<T>;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  using pointer
+    = typename thrust::detail::allocator_traits<decltype(device_alloc)>::
+      template rebind_traits<U>::pointer;
+
+  unique_eager_future_promise_pair<U, pointer> fp;
+
+  // Determine temporary device storage requirements.
+
+  size_t tmp_size = 0;
+  thrust::cuda_cub::throw_on_error(
+    cub::DeviceReduce::Reduce(
+      nullptr
+    , tmp_size
+    , first
+    , static_cast<U*>(nullptr)
+    , n
+    , op
+    , init
+    , nullptr // Null stream, just for sizing.
+    )
+  , "after reduction sizing"
+  );
+
+  // Allocate temporary storage.
+
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, sizeof(U) + tmp_size
+  );
+
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  auto const content_ptr = content.get();
+  U* const ret_ptr = thrust::detail::aligned_reinterpret_cast<U*>(
+    raw_pointer_cast(content_ptr)
+  );
+  void* const tmp_ptr = static_cast<void*>(
+    raw_pointer_cast(content_ptr + sizeof(U))
+  );
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    fp = make_dependent_future<U, pointer>(
+      [] (decltype(content) const& c)
+      {
+        return pointer(
+          thrust::detail::aligned_reinterpret_cast<U*>(
+            raw_pointer_cast(c.get())
+          )
+        );
+      }
+    , std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        , unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    fp = make_dependent_future<U, pointer>(
+      [] (decltype(content) const& c)
+      {
+        return pointer(
+          thrust::detail::aligned_reinterpret_cast<U*>(
+            raw_pointer_cast(c.get())
+          )
+        );
+      }
+    , std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+
+  // Run reduction.
+
+  thrust::cuda_cub::throw_on_error(
+    cub::DeviceReduce::Reduce(
+      tmp_ptr
+    , tmp_size
+    , first
+    , ret_ptr
+    , n
+    , op
+    , init
+    , fp.future.stream().native_handle()
+    )
+  , "after reduction launch"
+  );
+
+  return std::move(fp.future);
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename T, typename BinaryOp
+>
+auto async_reduce(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Sentinel                         last
+, T                                init
+, BinaryOp                         op
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_reduce_n(
+    policy, first, distance(first, last), init, op
+  )
+)
+
+} // cuda_cub
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace system { namespace cuda { namespace detail
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename OutputIt
+, typename T, typename BinaryOp
+>
+unique_eager_event async_reduce_into_n(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Size                             n
+, OutputIt                         output
+, T                                init
+, BinaryOp                         op
+) {
+  using U = remove_cvref_t<T>;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  unique_eager_event e;
+
+  // Determine temporary device storage requirements.
+
+  size_t tmp_size = 0;
+  thrust::cuda_cub::throw_on_error(
+    cub::DeviceReduce::Reduce(
+      nullptr
+    , tmp_size
+    , first
+    , static_cast<U*>(nullptr)
+    , n
+    , op
+    , init
+    , nullptr // Null stream, just for sizing.
+    )
+  , "after reduction sizing"
+  );
+
+  // Allocate temporary storage.
+
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, tmp_size
+  );
+
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  auto const content_ptr = content.get();
+
+  void* const tmp_ptr = static_cast<void*>(
+    raw_pointer_cast(content_ptr)
+  );
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        , unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+
+  // Run reduction.
+
+  thrust::cuda_cub::throw_on_error(
+    cub::DeviceReduce::Reduce(
+      tmp_ptr
+    , tmp_size
+    , first
+    , output
+    , n
+    , op
+    , init
+    , e.stream().native_handle()
+    )
+  , "after reduction launch"
+  );
+
+  return e;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+, typename T, typename BinaryOp
+>
+auto async_reduce_into(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Sentinel                         last
+, OutputIt                         output
+, T                                init
+, BinaryOp                         op
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_reduce_into_n(
+    policy, first, distance(first, last), output, init, op
+  )
+)
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+

miniCUDA124/include/thrust/system/cuda/detail/async/scan.h

@@ -0,0 +1,43 @@
+/******************************************************************************
+ * Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#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/cpp14_required.h>
+
+#include <thrust/system/cuda/detail/async/exclusive_scan.h>
+#include <thrust/system/cuda/detail/async/inclusive_scan.h>

miniCUDA124/include/thrust/system/cuda/detail/async/sort.h

@@ -0,0 +1,525 @@
+/******************************************************************************
+ * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#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/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/async/copy.h>
+#include <thrust/system/cuda/detail/sort.h>
+#include <thrust/detail/alignment.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+#include <thrust/type_traits/is_operator_less_or_greater_function_object.h>
+#include <thrust/type_traits/logical_metafunctions.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/static_assert.h>
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+// Non-ContiguousIterator input and output iterators
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename StrictWeakOrdering
+>
+auto async_stable_sort_n(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Size                             n,
+  StrictWeakOrdering               comp
+) ->
+  typename std::enable_if<
+    negation<is_contiguous_iterator<ForwardIt>>::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  // Create device-side buffer.
+
+  // FIXME: Combine this temporary allocation with the main one for CUB.
+  auto device_buffer = uninitialized_allocate_unique_n<T>(device_alloc, n);
+
+  auto const device_buffer_ptr = device_buffer.get();
+
+  // Synthesize a suitable new execution policy, because we don't want to
+  // try and extract twice from the one we were passed.
+  typename remove_cvref_t<decltype(policy)>::tag_type tag_policy{};
+
+  // Copy from the input into the buffer.
+
+  auto new_policy0 = thrust::detail::derived_cast(policy).rebind_after(
+    std::move(device_buffer)
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(policy)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_policy0)
+    )>::value
+  ));
+
+  auto f0 = async_copy_n(
+    new_policy0
+  , tag_policy
+  , first
+  , n
+  , device_buffer_ptr
+  );
+
+  // Sort the buffer.
+
+  auto new_policy1 = thrust::detail::derived_cast(policy).rebind_after(
+    std::move(f0)
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(policy)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_policy1)
+    )>::value
+  ));
+
+  auto f1 = async_sort_n(
+    new_policy1
+  , tag_policy
+  , device_buffer_ptr
+  , n
+  , comp
+  );
+
+  // Copy from the buffer into the input.
+  // FIXME: Combine this with the potential memcpy at the end of the main sort
+  // routine.
+
+  auto new_policy2 = thrust::detail::derived_cast(policy).rebind_after(
+    std::move(f1)
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(policy)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_policy2)
+    )>::value
+  ));
+
+  return async_copy_n(
+    new_policy2
+  , tag_policy
+  , device_buffer_ptr
+  , n
+  , first
+  );
+}
+
+// ContiguousIterator iterators
+// Non-Scalar value type or user-defined StrictWeakOrdering
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename StrictWeakOrdering
+>
+auto async_stable_sort_n(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Size                             n,
+  StrictWeakOrdering               comp
+) ->
+  typename std::enable_if<
+    conjunction<
+      is_contiguous_iterator<ForwardIt>
+    , disjunction<
+        negation<
+          std::is_scalar<
+            typename iterator_traits<ForwardIt>::value_type
+          >
+        >
+      , negation<
+          is_operator_less_or_greater_function_object<StrictWeakOrdering>
+        >
+      >
+    >::value
+  , unique_eager_event
+  >::type
+{
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  unique_eager_event e;
+
+  // Determine temporary device storage requirements.
+
+  size_t tmp_size = 0;
+  thrust::cuda_cub::throw_on_error(
+    thrust::cuda_cub::__merge_sort::doit_step<
+      /* Sort items? */ std::false_type, /* Stable? */ std::true_type
+    >(
+      nullptr
+    , tmp_size
+    , first
+    , static_cast<thrust::detail::uint8_t*>(nullptr) // Items.
+    , n
+    , comp
+    , nullptr // Null stream, just for sizing.
+    )
+  , "after merge sort sizing"
+  );
+
+  // Allocate temporary storage.
+
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, tmp_size
+  );
+
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  auto const content_ptr = content.get();
+
+  void* const tmp_ptr = static_cast<void*>(
+    raw_pointer_cast(content_ptr)
+  );
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        , unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+
+  // Run merge sort.
+
+  thrust::cuda_cub::throw_on_error(
+    thrust::cuda_cub::__merge_sort::doit_step<
+      /* Sort items? */ std::false_type, /* Stable? */ std::true_type
+    >(
+      tmp_ptr
+    , tmp_size
+    , first
+    , static_cast<thrust::detail::uint8_t*>(nullptr) // Items.
+    , n
+    , comp
+    , e.stream().native_handle()
+    )
+  , "after merge sort sizing"
+  );
+
+  return e;
+}
+
+template <typename T, typename Size, typename StrictWeakOrdering>
+typename std::enable_if<
+  is_operator_less_function_object<StrictWeakOrdering>::value
+, cudaError_t
+>::type
+invoke_radix_sort(
+  cudaStream_t          stream
+, void*                 tmp_ptr
+, std::size_t&          tmp_size
+, cub::DoubleBuffer<T>& keys
+, Size&                 n
+, StrictWeakOrdering
+)
+{
+  return cub::DeviceRadixSort::SortKeys(
+    tmp_ptr
+  , tmp_size
+  , keys
+  , n
+  , 0
+  , sizeof(T) * 8
+  , stream
+  );
+}
+
+template <typename T, typename Size, typename StrictWeakOrdering>
+typename std::enable_if<
+  is_operator_greater_function_object<StrictWeakOrdering>::value
+, cudaError_t
+>::type
+invoke_radix_sort(
+  cudaStream_t          stream
+, void*                 tmp_ptr
+, std::size_t&          tmp_size
+, cub::DoubleBuffer<T>& keys
+, Size&                 n
+, StrictWeakOrdering
+)
+{
+  return cub::DeviceRadixSort::SortKeysDescending(
+    tmp_ptr
+  , tmp_size
+  , keys
+  , n
+  , 0
+  , sizeof(T) * 8
+  , stream
+  );
+}
+
+// ContiguousIterator iterators
+// Scalar value type
+// operator< or operator>
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename StrictWeakOrdering
+>
+auto async_stable_sort_n(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Size                             n
+, StrictWeakOrdering               comp
+) ->
+  typename std::enable_if<
+    conjunction<
+      is_contiguous_iterator<ForwardIt>
+    , std::is_scalar<
+        typename iterator_traits<ForwardIt>::value_type
+      >
+    , is_operator_less_or_greater_function_object<StrictWeakOrdering>
+    >::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  unique_eager_event e;
+
+  cub::DoubleBuffer<T> keys(
+    raw_pointer_cast(&*first), nullptr
+  );
+
+  // Determine temporary device storage requirements.
+
+  size_t tmp_size = 0;
+  thrust::cuda_cub::throw_on_error(
+    invoke_radix_sort(
+      nullptr // Null stream, just for sizing.
+    , nullptr
+    , tmp_size
+    , keys
+    , n
+    , comp
+    )
+  , "after radix sort sizing"
+  );
+
+  // Allocate temporary storage.
+
+  size_t keys_temp_storage = thrust::detail::aligned_storage_size(
+    sizeof(T) * n, 128
+  );
+
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, keys_temp_storage + tmp_size
+  );
+
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  auto const content_ptr = content.get();
+
+  keys.d_buffers[1] = thrust::detail::aligned_reinterpret_cast<T*>(
+    raw_pointer_cast(content_ptr)
+  );
+
+  void* const tmp_ptr = static_cast<void*>(
+    raw_pointer_cast(content_ptr + keys_temp_storage)
+  );
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        , unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+
+  // Run radix sort.
+
+  thrust::cuda_cub::throw_on_error(
+    invoke_radix_sort(
+      e.stream().native_handle()
+    , tmp_ptr
+    , tmp_size
+    , keys
+    , n
+    , comp
+    )
+  , "after radix sort launch"
+  );
+
+  if (0 != keys.selector)
+  {
+    auto new_policy0 = thrust::detail::derived_cast(policy).rebind_after(
+      std::move(e)
+    );
+
+    THRUST_STATIC_ASSERT((
+      std::tuple_size<decltype(
+        extract_dependencies(policy)
+      )>::value + 1
+      <=
+      std::tuple_size<decltype(
+        extract_dependencies(new_policy0)
+      )>::value
+    ));
+
+    // Synthesize a suitable new execution policy, because we don't want to
+    // try and extract twice from the one we were passed.
+    typename remove_cvref_t<decltype(policy)>::tag_type tag_policy{};
+
+    using return_future = decltype(e);
+    return return_future(async_copy_n(
+      new_policy0
+    , tag_policy
+    , keys.d_buffers[1]
+    , n
+    , keys.d_buffers[0]
+    ));
+  }
+  else
+    return e;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename StrictWeakOrdering
+>
+auto async_stable_sort(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Sentinel                         last,
+  StrictWeakOrdering               comp
+)
+// A GCC 5 bug requires an explicit trailing return type here, so stick with
+// THRUST_DECLTYPE_RETURNS for now.
+THRUST_DECLTYPE_RETURNS(
+  thrust::system::cuda::detail::async_stable_sort_n(
+    policy, first, distance(first, last), comp
+  )
+)
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+

miniCUDA124/include/thrust/system/cuda/detail/async/transform.h

@@ -0,0 +1,169 @@
+/******************************************************************************
+ * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#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/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/distance.h>
+#include <thrust/advance.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+template <typename ForwardIt, typename OutputIt, typename UnaryOperation>
+struct async_transform_fn
+{
+  ForwardIt first_;
+  OutputIt output_;
+  UnaryOperation op_;
+
+  __host__ __device__
+  async_transform_fn(ForwardIt&& first, OutputIt&& output, UnaryOperation&& op)
+    : first_(std::move(first)), output_(std::move(output)), op_(std::move(op))
+  {}
+
+  template <typename Index>
+  __host__ __device__
+  void operator()(Index idx)
+  {
+    output_[idx] = op_(thrust::raw_reference_cast(first_[idx]));
+  }
+};
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename OutputIt, typename UnaryOperation
+>
+unique_eager_event async_transform_n(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Size                             n,
+  OutputIt                         output,
+  UnaryOperation                   op
+) {
+  unique_eager_event e;
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      extract_dependencies(
+        std::move(thrust::detail::derived_cast(policy))
+      )
+    );
+  }
+
+  // Run transform.
+
+  async_transform_fn<ForwardIt, OutputIt, UnaryOperation> wrapped(
+    std::move(first), std::move(output), std::move(op)
+  );
+
+  thrust::cuda_cub::throw_on_error(
+    thrust::cuda_cub::__parallel_for::parallel_for(
+      n, std::move(wrapped), e.stream().native_handle()
+    )
+  , "after transform launch"
+  );
+
+  return e;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+, typename UnaryOperation
+>
+auto async_transform(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Sentinel                         last,
+  OutputIt                         output,
+  UnaryOperation&&                 op
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_transform_n(
+    policy, first, distance(first, last), output, THRUST_FWD(op)
+  )
+);
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+

miniCUDA124/include/thrust/system/cuda/detail/core/agent_launcher.h

@@ -0,0 +1,1172 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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 <cub/detail/device_synchronize.cuh>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/core/triple_chevron_launch.h>
+#include <thrust/system/cuda/detail/core/util.h>
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+
+#include <cassert>
+
+#include <nv/target>
+
+/**
+ * @def THRUST_DISABLE_KERNEL_VISIBILITY_WARNING_SUPPRESSION
+ * If defined, the default suppression of kernel visibility attribute warning is disabled.
+ */
+#if !defined(THRUST_DISABLE_KERNEL_VISIBILITY_WARNING_SUPPRESSION)
+_CCCL_DIAG_SUPPRESS_GCC("-Wattributes")
+_CCCL_DIAG_SUPPRESS_CLANG("-Wattributes")
+#if !defined(_CCCL_CUDA_COMPILER_NVHPC)
+_CCCL_DIAG_SUPPRESS_NVHPC(attribute_requires_external_linkage)
+#endif // !_LIBCUDACXX_COMPILER_NVHPC_CUDA
+#endif // !THRUST_DISABLE_KERNEL_VISIBILITY_WARNING_SUPPRESSION
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+namespace core {
+
+#ifndef THRUST_DETAIL_KERNEL_ATTRIBUTES
+#define THRUST_DETAIL_KERNEL_ATTRIBUTES CCCL_DETAIL_KERNEL_ATTRIBUTES
+#endif
+
+#if defined(__CUDA_ARCH__) || defined(_NVHPC_CUDA)
+#if 0
+  template <class Agent, class... Args>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void
+  __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+      _kernel_agent(Args... args)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(args..., shmem);
+  }
+#else
+  template <class Agent, class _0>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, shmem);
+  }
+  template <class Agent, class _0, class _1>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD, _xE xE)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE, shmem);
+  }
+#endif
+
+  ////////////////////////////////////////////////////////////
+
+
+#if 0
+  template <class Agent, class... Args>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void
+  __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+      _kernel_agent_vshmem(char* vshmem, Args... args)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(args..., vshmem);
+  }
+#else
+  template <class Agent, class _0>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, vshmem);
+  }
+  template <class Agent, class _0, class _1>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD, _xE xE)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE, vshmem);
+  }
+#endif
+#else
+#if 0
+  template <class , class... Args >
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void  _kernel_agent(Args... args) {}
+  template <class , class... Args >
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void  _kernel_agent_vshmem(char*, Args... args) {}
+#else
+  template <class, class _0>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0) {}
+  template <class, class _0, class _1>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0,_1) {}
+  template <class, class _0, class _1, class _2>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0,_1,_2) {}
+  template <class, class _0, class _1, class _2, class _3>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0,_1,_2,_3) {}
+  template <class, class _0, class _1, class _2, class _3, class _4>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0,_1,_2,_3, _4) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0,_1,_2,_3, _4, _5) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0,_1,_2,_3, _4, _5, _6) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0,_1,_2,_3, _4, _5, _6, _7) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0,_1,_2,_3, _4, _5, _6, _7, _8) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB,_xC) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB,_xC, _xD) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB,_xC, _xD, _xE) {}
+  ////////////////////////////////////////////////////////////
+  template <class, class _0>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0) {}
+  template <class, class _0, class _1>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0,_1) {}
+  template <class, class _0, class _1, class _2>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0,_1,_2) {}
+  template <class, class _0, class _1, class _2, class _3>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0,_1,_2,_3) {}
+  template <class, class _0, class _1, class _2, class _3, class _4>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4, _5) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4, _5, _6) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4, _5, _6, _7) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4, _5, _6, _7, _8) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+  THRUST_DETAIL_KERNEL_ATTRIBUTES void _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD, _xE) {}
+#endif
+#endif
+
+
+  template<class Agent>
+  struct AgentLauncher : Agent
+  {
+    core::AgentPlan plan;
+    size_t          count;
+    cudaStream_t    stream;
+    char const*     name;
+    unsigned int    grid;
+    char*           vshmem;
+    bool            has_shmem;
+    size_t          shmem_size;
+
+    enum
+    {
+      MAX_SHMEM_PER_BLOCK = 48 * 1024,
+    };
+    typedef
+        typename has_enough_shmem<Agent,
+                                  MAX_SHMEM_PER_BLOCK>::type has_enough_shmem_t;
+    typedef
+        has_enough_shmem<Agent,
+                                  MAX_SHMEM_PER_BLOCK> shm1;
+
+    template <class Size>
+    THRUST_RUNTIME_FUNCTION
+    AgentLauncher(AgentPlan    plan_,
+                  Size         count_,
+                  cudaStream_t stream_,
+                  char const*  name_)
+        : plan(plan_),
+          count((size_t)count_),
+          stream(stream_),
+          name(name_),
+          grid(static_cast<unsigned int>((count + plan.items_per_tile - 1) / plan.items_per_tile)),
+          vshmem(NULL),
+          has_shmem((size_t)core::get_max_shared_memory_per_block() >= (size_t)plan.shared_memory_size),
+          shmem_size(has_shmem ? plan.shared_memory_size : 0)
+    {
+      assert(count > 0);
+    }
+
+    template <class Size>
+    THRUST_RUNTIME_FUNCTION
+    AgentLauncher(AgentPlan    plan_,
+                  Size         count_,
+                  cudaStream_t stream_,
+                  char*        vshmem,
+                  char const*  name_)
+        : plan(plan_),
+          count((size_t)count_),
+          stream(stream_),
+          name(name_),
+          grid(static_cast<unsigned int>((count + plan.items_per_tile - 1) / plan.items_per_tile)),
+          vshmem(vshmem),
+          has_shmem((size_t)core::get_max_shared_memory_per_block() >= (size_t)plan.shared_memory_size),
+          shmem_size(has_shmem ? plan.shared_memory_size : 0)
+    {
+      assert(count > 0);
+    }
+
+    THRUST_RUNTIME_FUNCTION
+    AgentLauncher(AgentPlan    plan_,
+                  cudaStream_t stream_,
+                  char const*  name_)
+        : plan(plan_),
+          count(0),
+          stream(stream_),
+          name(name_),
+          grid(plan.grid_size),
+          vshmem(NULL),
+          has_shmem((size_t)core::get_max_shared_memory_per_block() >= (size_t)plan.shared_memory_size),
+          shmem_size(has_shmem ? plan.shared_memory_size : 0)
+    {
+      assert(plan.grid_size > 0);
+    }
+
+    THRUST_RUNTIME_FUNCTION
+    AgentLauncher(AgentPlan    plan_,
+                  cudaStream_t stream_,
+                  char*        vshmem,
+                  char const*  name_)
+        : plan(plan_),
+          count(0),
+          stream(stream_),
+          name(name_),
+          grid(plan.grid_size),
+          vshmem(vshmem),
+          has_shmem((size_t)core::get_max_shared_memory_per_block() >= (size_t)plan.shared_memory_size),
+          shmem_size(has_shmem ? plan.shared_memory_size : 0)
+    {
+      assert(plan.grid_size > 0);
+    }
+
+#if 0
+    THRUST_RUNTIME_FUNCTION
+    AgentPlan static get_plan(cudaStream_t s, void* d_ptr = 0)
+    {
+      // in separable compilation mode, we have no choice
+      // but to call kernel to get agent_plan
+      // otherwise the risk is something may fail
+      // if user mix & match ptx versions in a separably compiled function
+      // http://nvbugs/1772071
+      // XXX may be it is too string of a requirements, consider relaxing it in
+      // the future
+#ifdef __CUDACC_RDC__
+      return core::get_agent_plan<Agent>(s, d_ptr);
+#else
+      return get_agent_plan<Agent>(core::get_ptx_version());
+#endif
+    }
+    THRUST_RUNTIME_FUNCTION
+    AgentPlan static get_plan_default()
+    {
+      return get_agent_plan<Agent>(sm_arch<0>::type::ver);
+    }
+#endif
+
+    THRUST_RUNTIME_FUNCTION
+    typename core::get_plan<Agent>::type static get_plan(cudaStream_t , void* d_ptr = 0)
+    {
+      THRUST_UNUSED_VAR(d_ptr);
+      return get_agent_plan<Agent>(core::get_ptx_version());
+    }
+
+    THRUST_RUNTIME_FUNCTION
+    typename core::get_plan<Agent>::type static get_plan()
+    {
+      return get_agent_plan<Agent>(lowest_supported_sm_arch::ver);
+    }
+
+    THRUST_RUNTIME_FUNCTION void sync() const
+    {
+      CubDebug(cub::detail::DebugSyncStream(stream));
+    }
+
+    template<class K>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    max_blocks_per_sm_impl(K k, int block_threads)
+    {
+      int occ;
+      cudaError_t status = cub::MaxSmOccupancy(occ, k, block_threads);
+      return cuda_optional<int>(status == cudaSuccess ? occ : -1, status);
+    }
+
+    template <class K>
+    cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    max_sm_occupancy(K k) const
+    {
+      return max_blocks_per_sm_impl(k, plan.block_threads);
+    }
+
+    template<class K>
+    THRUST_RUNTIME_FUNCTION
+    void print_info(K k) const
+    {
+      #if THRUST_DEBUG_SYNC_FLAG
+      cuda_optional<int> occ = max_sm_occupancy(k);
+      const int ptx_version = core::get_ptx_version();
+      if (count > 0)
+      {
+        _CubLog("Invoking %s<<<%u, %d, %d, %lld>>>(), %llu items total, %d items per thread, %d SM occupancy, %d vshmem size, %d ptx_version \n",
+                name,
+                grid,
+                plan.block_threads,
+                (has_shmem ? (int)plan.shared_memory_size : 0),
+                (long long)stream,
+                (long long)count,
+                plan.items_per_thread,
+                (int)occ,
+                (!has_shmem ? (int)plan.shared_memory_size : 0),
+                (int)ptx_version);
+      }
+      else
+      {
+        _CubLog("Invoking %s<<<%u, %d, %d, %lld>>>(), %d items per thread, %d SM occupancy, %d vshmem size, %d ptx_version\n",
+                name,
+                grid,
+                plan.block_threads,
+                (has_shmem ? (int)plan.shared_memory_size : 0),
+                (long long)stream,
+                plan.items_per_thread,
+                (int)occ,
+                (!has_shmem ? (int)plan.shared_memory_size : 0),
+                (int)ptx_version);
+      }
+      #else
+      (void)k;
+      #endif
+    }
+
+    ////////////////////
+    //  Variadic code
+    ////////////////////
+
+#if 0
+    template<class... Args>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      return max_blocks_per_sm_impl(_kernel_agent<Agent, Args...>, plan.block_threads);
+    }
+#else
+    template<class _0>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0) = _kernel_agent<Agent, _0>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0, _1) = _kernel_agent<Agent, _0, _1>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2) = _kernel_agent<Agent, _0, _1, _2>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3) = _kernel_agent<Agent, _0, _1, _2,_3>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4) = _kernel_agent<Agent, _0, _1, _2,_3,_4>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD,_xE) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD,_xE>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+#endif
+
+
+
+#if 0
+
+    // If we are guaranteed to have enough shared memory
+    // don't compile other kernel which accepts pointer
+    // and save on compilations
+    template <class... Args>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, Args... args) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      print_info(_kernel_agent<Agent, Args...>);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(_kernel_agent<Agent, Args...>, args...);
+    }
+
+    // If there is a risk of not having enough shared memory
+    // we compile generic kernel instead.
+    // This kernel is likely to be somewhat slower, but it can accomodate
+    // both shared and virtualized shared memories.
+    // Alternative option is to compile two kernels, one using shared and one
+    // using virtualized shared memory. While this can be slightly faster if we
+    // do actually have enough shared memory, the compilation time will double.
+    //
+    template <class... Args>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, Args... args) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      print_info(_kernel_agent_vshmem<Agent, Args...>);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(_kernel_agent_vshmem<Agent, Args...>, vshmem, args...);
+    }
+
+    template <class... Args>
+    void THRUST_RUNTIME_FUNCTION
+    launch(Args... args) const
+    {
+      launch_impl(has_enough_shmem_t(),args...);
+      sync();
+    }
+#else
+    template <class _0>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0) = _kernel_agent_vshmem<Agent, _0>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0);
+    }
+    template <class _0, class _1>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1) = _kernel_agent_vshmem<Agent, _0, _1>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1);
+    }
+    template <class _0, class _1, class _2>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2) = _kernel_agent_vshmem<Agent, _0, _1, _2>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2);
+    }
+    template <class _0, class _1, class _2, class _3>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3);
+    }
+    template <class _0, class _1, class _2, class _3, class _4>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8>;
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA,_xB xB) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA,_xB xB,_xC xC) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA,_xB xB,_xC xC,_xD xD) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA,_xB xB,_xC xC,_xD xD,_xE xE) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD, _xE) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD, _xE>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE);
+    }
+
+    ////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////
+
+    template <class _0>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0) = _kernel_agent<Agent, _0>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0);
+    }
+    template <class _0, class _1>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0, _1) = _kernel_agent<Agent, _0, _1>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1);
+    }
+    template <class _0, class _1, class _2>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2) = _kernel_agent<Agent, _0, _1, _2>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2);
+    }
+    template <class _0, class _1, class _2, class _3>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3) = _kernel_agent<Agent, _0, _1, _2,_3>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3);
+    }
+    template <class _0, class _1, class _2, class _3, class _4>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4) = _kernel_agent<Agent, _0, _1, _2,_3,_4>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD, _xE xE) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD,_xE) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD,_xE>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr,x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE);
+    }
+
+    ////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////
+
+    template <class _0>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0) const
+    {
+      launch_impl(has_enough_shmem_t(), x0);
+      sync();
+    }
+    template <class _0, class _1>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1);
+      sync();
+    }
+    template <class _0, class _1, class _2>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD, _xE xE) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE);
+      sync();
+    }
+#endif
+
+
+  };
+
+} // namespace core
+} // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif

miniCUDA124/include/thrust/system/cuda/detail/core/alignment.h

@@ -0,0 +1,258 @@
+/*
+ *  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.
+ */
+
+// TODO: This can probably be removed.
+
+#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/cuda/detail/util.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+namespace alignment_of_detail {
+
+
+  template <typename T>
+  class alignment_of_impl;
+
+  template <typename T, std::size_t size_diff>
+  struct helper
+  {
+    static const std::size_t value = size_diff;
+  };
+
+  template <typename T>
+  class helper<T, 0>
+  {
+  public:
+    static const std::size_t value = alignment_of_impl<T>::value;
+  };
+
+  template <typename T>
+  class alignment_of_impl
+  {
+  private:
+    struct big
+    {
+      T    x;
+      char c;
+    };
+
+  public:
+    static const std::size_t value = helper<big, sizeof(big) - sizeof(T)>::value;
+  };
+
+
+}    // end alignment_of_detail
+
+
+template <typename T>
+struct alignment_of
+    : alignment_of_detail::alignment_of_impl<T>
+{
+};
+
+
+template <std::size_t Align>
+struct aligned_type;
+
+// __align__ is CUDA-specific, so guard it
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+// implementing aligned_type portably is tricky:
+
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+// implement aligned_type with specialization because MSVC
+// requires literals as arguments to declspec(align(n))
+template <>
+struct aligned_type<1>
+{
+  struct __align__(1) type{};
+};
+
+template <>
+struct aligned_type<2>
+{
+  struct __align__(2) type{};
+};
+
+template <>
+struct aligned_type<4>
+{
+  struct __align__(4) type{};
+};
+
+template <>
+struct aligned_type<8>
+{
+  struct __align__(8) type{};
+};
+
+template <>
+struct aligned_type<16>
+{
+  struct __align__(16) type{};
+};
+
+template <>
+struct aligned_type<32>
+{
+  struct __align__(32) type{};
+};
+
+template <>
+struct aligned_type<64>
+{
+  struct __align__(64) type{};
+};
+
+template <>
+struct aligned_type<128>
+{
+  struct __align__(128) type{};
+};
+
+template <>
+struct aligned_type<256>
+{
+  struct __align__(256) type{};
+};
+
+template <>
+struct aligned_type<512>
+{
+  struct __align__(512) type{};
+};
+
+template <>
+struct aligned_type<1024>
+{
+  struct __align__(1024) type{};
+};
+
+template <>
+struct aligned_type<2048>
+{
+  struct __align__(2048) type{};
+};
+
+template <>
+struct aligned_type<4096>
+{
+  struct __align__(4096) type{};
+};
+
+template <>
+struct aligned_type<8192>
+{
+  struct __align__(8192) type{};
+};
+#elif (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) && (THRUST_GCC_VERSION < 40300)
+// implement aligned_type with specialization because gcc 4.2
+// requires literals as arguments to __attribute__(aligned(n))
+template <>
+struct aligned_type<1>
+{
+  struct __align__(1) type{};
+};
+
+template <>
+struct aligned_type<2>
+{
+  struct __align__(2) type{};
+};
+
+template <>
+struct aligned_type<4>
+{
+  struct __align__(4) type{};
+};
+
+template <>
+struct aligned_type<8>
+{
+  struct __align__(8) type{};
+};
+
+template <>
+struct aligned_type<16>
+{
+  struct __align__(16) type{};
+};
+
+template <>
+struct aligned_type<32>
+{
+  struct __align__(32) type{};
+};
+
+template <>
+struct aligned_type<64>
+{
+  struct __align__(64) type{};
+};
+
+template <>
+struct aligned_type<128>
+{
+  struct __align__(128) type{};
+};
+
+#else
+// assume the compiler allows template parameters as
+// arguments to __align__
+template <std::size_t Align>
+struct aligned_type
+{
+  struct __align__(Align) type{};
+};
+#endif    // THRUST_HOST_COMPILER
+#else
+template <std::size_t Align>
+struct aligned_type
+{
+  struct type
+  {
+  };
+};
+#endif    // THRUST_DEVICE_COMPILER
+
+
+template <std::size_t Len, std::size_t Align>
+struct aligned_storage
+{
+  union type
+  {
+    unsigned char data[Len];
+
+    typename aligned_type<Align>::type align;
+  };
+};
+
+
+}    // end cuda_
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/system/cuda/detail/core/triple_chevron_launch.h

@@ -0,0 +1,160 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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/cuda/detail/core/alignment.h>
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+
+#include <cassert>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+namespace launcher {
+
+  struct _CCCL_ATTRIBUTE_HIDDEN triple_chevron
+  {
+    typedef size_t Size;
+    dim3 const grid;
+    dim3 const block;
+    Size const shared_mem;
+    cudaStream_t const stream;
+
+    THRUST_RUNTIME_FUNCTION
+    triple_chevron(dim3         grid_,
+                   dim3         block_,
+                   Size         shared_mem_ = 0,
+                   cudaStream_t stream_     = 0)
+        : grid(grid_),
+          block(block_),
+          shared_mem(shared_mem_),
+          stream(stream_) {}
+
+    template<class K, class... Args>
+    cudaError_t __host__
+    doit_host(K k, Args const&... args) const
+    {
+      k<<<grid, block, shared_mem, stream>>>(args...);
+      return cudaPeekAtLastError();
+    }
+
+    template<class T>
+    size_t __device__
+    align_up(size_t offset) const
+    {
+      size_t alignment = alignment_of<T>::value;
+      return alignment * ((offset + (alignment - 1))/ alignment);
+    }
+
+    size_t __device__ argument_pack_size(size_t size) const { return size; }
+    template <class Arg, class... Args>
+    size_t __device__
+    argument_pack_size(size_t size, Arg const& arg, Args const&... args) const
+    {
+      size = align_up<Arg>(size);
+      return argument_pack_size(size + sizeof(Arg), args...);
+    }
+
+    template <class Arg>
+    size_t __device__ copy_arg(char* buffer, size_t offset, Arg arg) const
+    {
+      offset = align_up<Arg>(offset);
+      for (int i = 0; i != sizeof(Arg); ++i)
+        buffer[offset+i] = *((char*)&arg + i);
+      return offset + sizeof(Arg);
+    }
+
+    __device__
+    void fill_arguments(char*, size_t) const
+    {}
+
+    template<class Arg, class... Args>
+    __device__
+    void fill_arguments(char* buffer,
+                     size_t offset,
+                     Arg const& arg,
+                     Args const& ... args) const
+    {
+      fill_arguments(buffer, copy_arg(buffer, offset, arg), args...);
+    }
+
+    #ifdef THRUST_RDC_ENABLED
+    template<class K, class... Args>
+    cudaError_t __device__
+    doit_device(K k, Args const&... args) const
+    {
+      const size_t size = argument_pack_size(0,args...);
+      void *param_buffer = cudaGetParameterBuffer(64,size);
+      fill_arguments((char*)param_buffer, 0, args...);
+      return launch_device(k, param_buffer);
+    }
+
+    template <class K>
+    cudaError_t __device__
+    launch_device(K k, void* buffer) const
+    {
+      return cudaLaunchDevice((void*)k,
+                              buffer,
+                              dim3(grid),
+                              dim3(block),
+                              shared_mem,
+                              stream);
+    }
+    #else
+    template<class K, class... Args>
+    cudaError_t __device__
+    doit_device(K, Args const&... ) const
+    {
+      return cudaErrorNotSupported;
+    }
+    #endif
+
+    __thrust_exec_check_disable__
+    template <class K, class... Args>
+    THRUST_FUNCTION
+    cudaError_t doit(K k, Args const&... args) const
+    {
+      NV_IF_TARGET(NV_IS_HOST,
+                   (return doit_host(k, args...);),
+                   (return doit_device(k, args...);));
+    }
+
+  }; // struct triple_chevron
+
+}    // namespace launcher
+}    // namespace cuda_
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/system/cuda/detail/core/util.h

@@ -0,0 +1,811 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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/raw_pointer_cast.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/system_error.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+#include <cub/block/block_load.cuh>
+#include <cub/block/block_scan.cuh>
+#include <cub/block/block_store.cuh>
+#include <cub/util_temporary_storage.cuh>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+namespace core {
+
+#ifdef _NVHPC_CUDA
+#  if (__NVCOMPILER_CUDA_ARCH__ >= 600)
+#    define THRUST_TUNING_ARCH sm60
+#  elif (__NVCOMPILER_CUDA_ARCH__ >= 520)
+#    define THRUST_TUNING_ARCH sm52
+#  elif (__NVCOMPILER_CUDA_ARCH__ >= 350)
+#    define THRUST_TUNING_ARCH sm35
+#  else
+#    define THRUST_TUNING_ARCH sm30
+#  endif
+#else
+#  if (__CUDA_ARCH__ >= 600)
+#    define THRUST_TUNING_ARCH sm60
+#  elif (__CUDA_ARCH__ >= 520)
+#    define THRUST_TUNING_ARCH sm52
+#  elif (__CUDA_ARCH__ >= 350)
+#    define THRUST_TUNING_ARCH sm35
+#  elif (__CUDA_ARCH__ >= 300)
+#    define THRUST_TUNING_ARCH sm30
+#  elif !defined (__CUDA_ARCH__)
+#    define THRUST_TUNING_ARCH sm30
+#  endif
+#endif
+
+  // Typelist - a container of types, supports up to 10 types
+  // --------------------------------------------------------------------------
+
+  class _;
+  template <class = _, class = _, class = _, class = _, class = _, class = _, class = _, class = _, class = _, class = _>
+  struct typelist;
+
+  // -------------------------------------
+
+  // supported SM arch
+  // ---------------------
+  struct sm30  { enum { ver = 300, warpSize = 32 }; };
+  struct sm35  { enum { ver = 350, warpSize = 32 }; };
+  struct sm52  { enum { ver = 520, warpSize = 32 }; };
+  struct sm60  { enum { ver = 600, warpSize = 32 }; };
+
+  // list of sm, checked from left to right order
+  // the rightmost is the lowest sm arch supported
+  // --------------------------------------------
+  typedef typelist<sm60,sm52,sm35,sm30> sm_list;
+
+  // lowest supported SM arch
+  // --------------------------------------------------------------------------
+
+  template<class, class>
+  struct lowest_supported_sm_arch_impl;
+
+  template <class SM, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  struct lowest_supported_sm_arch_impl<SM, typelist<_0, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+       : lowest_supported_sm_arch_impl<_0, typelist<    _1, _2, _3, _4, _5, _6, _7, _8, _9> > {};
+  template <class SM>
+  struct lowest_supported_sm_arch_impl<SM, typelist<> >
+  {
+    typedef SM type;
+  };
+
+  typedef typename lowest_supported_sm_arch_impl<_,sm_list>::type lowest_supported_sm_arch;
+
+  // metafunction to match next viable PtxPlan specialization
+  // --------------------------------------------------------------------------
+
+  __THRUST_DEFINE_HAS_NESTED_TYPE(has_tuning_t, tuning)
+  __THRUST_DEFINE_HAS_NESTED_TYPE(has_type_t, type)
+
+  template <template <class> class, class, class>
+  struct specialize_plan_impl_loop;
+  template <template <class> class, class>
+  struct specialize_plan_impl_match;
+
+  // we loop through the sm_list
+  template <template <class> class P, class SM, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  struct specialize_plan_impl_loop<P, SM, typelist<_0, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+       : specialize_plan_impl_loop<P, SM, typelist<    _1, _2, _3, _4, _5, _6, _7, _8, _9> > {};
+
+  // until we find first lowest match
+  template <template <class> class P, class SM, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  struct specialize_plan_impl_loop <P, SM,  typelist<SM, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+       : specialize_plan_impl_match<P,      typelist<SM, _1, _2, _3, _4, _5, _6, _7, _8, _9> > {};
+
+  template<class, class>
+  struct has_sm_tuning_impl;
+
+  // specializing for Tunig which needs 1 arg
+  template <class SM,
+            template <class, class> class Tuning,
+            class _0>
+  struct has_sm_tuning_impl<SM, Tuning<lowest_supported_sm_arch, _0> > : has_type_t<Tuning<SM, _0> > {};
+
+  // specializing for Tunig which needs 2 args
+  template <class SM,
+            template <class, class,class> class Tuning,
+            class _0, class _1>
+  struct has_sm_tuning_impl<SM, Tuning<lowest_supported_sm_arch, _0, _1> > : has_type_t<Tuning<SM, _0, _1> > {};
+
+  template <template <class> class P, class SM>
+  struct has_sm_tuning : has_sm_tuning_impl<SM, typename P<lowest_supported_sm_arch>::tuning > {};
+
+  // once first match is found in sm_list, all remaining sm are possible
+  // candidate for tuning, so pick the first available
+  //   if the plan P has SM-level tuning then pick it,
+  //   otherwise move on to the next sm in the sm_list
+  template <template <class> class P, class SM, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  struct specialize_plan_impl_match<P, typelist<SM, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+      : thrust::detail::conditional<
+            has_sm_tuning<P, SM>::value,
+            P<SM>,
+            specialize_plan_impl_match<P, typelist<_1, _2, _3, _4, _5, _6, _7, _8, _9> > >::type {};
+
+    template <template <class> class Plan, class SM = THRUST_TUNING_ARCH>
+    struct specialize_plan_msvc10_war
+    {
+      // if Plan has tuning type, this means it has SM-specific tuning
+      // so loop through sm_list to find match,
+      // otherwise just specialize on provided SM
+      typedef thrust::detail::conditional<has_tuning_t<Plan<lowest_supported_sm_arch> >::value,
+                                  specialize_plan_impl_loop<Plan, SM, sm_list>,
+                                  Plan<SM> >
+          type;
+    };
+
+    template <template <class> class Plan, class SM = THRUST_TUNING_ARCH>
+    struct specialize_plan : specialize_plan_msvc10_war<Plan,SM>::type::type {};
+
+
+    /////////////////////////
+    /////////////////////////
+    /////////////////////////
+
+    // retrieve temp storage size from an Agent
+    // ---------------------------------------------------------------------------
+    // metafunction introspects Agent, and if it finds TempStorage type
+    // it will return its size
+
+    __THRUST_DEFINE_HAS_NESTED_TYPE(has_temp_storage, TempStorage)
+
+    template <class Agent, class U>
+    struct temp_storage_size_impl;
+
+    template <class Agent>
+    struct temp_storage_size_impl<Agent, thrust::detail::false_type>
+    {
+      enum
+      {
+        value = 0
+      };
+    };
+
+    template <class Agent>
+    struct temp_storage_size_impl<Agent, thrust::detail::true_type>
+    {
+      enum
+      {
+        value = sizeof(typename Agent::TempStorage)
+      };
+    };
+
+    template <class Agent>
+    struct temp_storage_size
+        : temp_storage_size_impl<Agent, typename has_temp_storage<Agent>::type>
+    {
+    };
+
+    // check whether all Agents requires < MAX_SHMEM shared memory
+    // ---------------------------------------------------------------------------
+    // if so, we can use simpler kernel for dispatch, which assumes that all
+    // shared memory is on chip.
+    // Otherwise, a kernel will be compiled which can also accept virtualized
+    // shared memory, in case there is not enough on chip. This kernel is about
+    // 10% slower
+
+    template <bool, class, size_t, class>
+    struct has_enough_shmem_impl;
+
+    template <bool V, class A, size_t S, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    struct has_enough_shmem_impl<V, A, S, typelist<_0, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+        : has_enough_shmem_impl<
+              V && (temp_storage_size<specialize_plan<A::template PtxPlan, _0> >::value <= S),
+              A,
+              S,
+              typelist<_1, _2, _3, _4, _5, _6, _7, _8, _9> >
+    {
+    };
+    template <bool V, class A, size_t S>
+    struct has_enough_shmem_impl<V, A, S, typelist<> >
+    {
+      enum
+      {
+        value = V
+      };
+      typedef typename thrust::detail::conditional<value,
+                                           thrust::detail::true_type,
+                                           thrust::detail::false_type>::type type;
+    };
+
+    template <class Agent, size_t MAX_SHMEM>
+    struct has_enough_shmem : has_enough_shmem_impl<true, Agent, MAX_SHMEM, sm_list>
+    {
+    };
+
+    /////////////////////////
+    /////////////////////////
+    /////////////////////////
+
+    // AgentPlan structure and helpers
+    // --------------------------------
+
+    struct AgentPlan
+    {
+      int block_threads;
+      int items_per_thread;
+      int items_per_tile;
+      int shared_memory_size;
+      int grid_size;
+
+      THRUST_RUNTIME_FUNCTION
+      AgentPlan() {}
+
+      THRUST_RUNTIME_FUNCTION
+      AgentPlan(int block_threads_,
+                int items_per_thread_,
+                int shared_memory_size_,
+                int grid_size_ = 0)
+          : block_threads(block_threads_),
+            items_per_thread(items_per_thread_),
+            items_per_tile(items_per_thread * block_threads),
+            shared_memory_size(shared_memory_size_),
+            grid_size(grid_size_)
+      {
+      }
+
+      THRUST_RUNTIME_FUNCTION
+      AgentPlan(AgentPlan const& plan)
+          : block_threads(plan.block_threads),
+            items_per_thread(plan.items_per_thread),
+            items_per_tile(plan.items_per_tile),
+            shared_memory_size(plan.shared_memory_size),
+            grid_size(plan.grid_size) {}
+
+      template <class PtxPlan>
+      THRUST_RUNTIME_FUNCTION
+      AgentPlan(PtxPlan,
+                typename thrust::detail::disable_if_convertible<
+                    PtxPlan,
+                    AgentPlan>::type* = NULL)
+          : block_threads(PtxPlan::BLOCK_THREADS),
+            items_per_thread(PtxPlan::ITEMS_PER_THREAD),
+            items_per_tile(PtxPlan::ITEMS_PER_TILE),
+            shared_memory_size(temp_storage_size<PtxPlan>::value),
+            grid_size(0)
+      {
+      }
+    };    // struct AgentPlan
+
+
+    __THRUST_DEFINE_HAS_NESTED_TYPE(has_Plan, Plan)
+
+    template <class Agent>
+    struct return_Plan
+    {
+      typedef typename Agent::Plan type;
+    };
+
+    template <class Agent>
+    struct get_plan : thrust::detail::conditional<
+                          has_Plan<Agent>::value,
+                          return_Plan<Agent>,
+                          thrust::detail::identity_<AgentPlan> >::type
+    {
+    };
+
+    // returns AgentPlan corresponding to a given ptx version
+    // ------------------------------------------------------
+
+    template<class, class>
+    struct get_agent_plan_impl;
+
+    template<class Agent, class SM, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    struct get_agent_plan_impl<Agent,typelist<SM,_1,_2,_3,_4,_5,_6,_7,_8,_9> >
+    {
+      typedef typename get_plan<Agent>::type Plan;
+      Plan THRUST_RUNTIME_FUNCTION
+      static get(int ptx_version)
+      {
+        if (ptx_version >= SM::ver)
+          return Plan(specialize_plan<Agent::template PtxPlan, SM>());
+        else
+          return get_agent_plan_impl<Agent,
+                                     typelist<_1, _2, _3, _4, _5, _6, _7, _8, _9> >::
+              get(ptx_version);
+      }
+    };
+
+    template<class Agent>
+    struct get_agent_plan_impl<Agent,typelist<lowest_supported_sm_arch> >
+    {
+      typedef typename get_plan<Agent>::type Plan;
+      Plan THRUST_RUNTIME_FUNCTION
+      static get(int /* ptx_version */)
+      {
+        typedef typename get_plan<Agent>::type Plan;
+        return Plan(specialize_plan<Agent::template PtxPlan, lowest_supported_sm_arch>());
+      }
+    };
+
+    template <class Agent>
+    THRUST_RUNTIME_FUNCTION
+    typename get_plan<Agent>::type get_agent_plan(int ptx_version)
+    {
+      NV_IF_TARGET(
+        NV_IS_DEVICE,
+        (
+          THRUST_UNUSED_VAR(ptx_version);
+          using plan_type = typename get_plan<Agent>::type;
+          using ptx_plan  = typename Agent::ptx_plan;
+          return plan_type{ptx_plan{}};
+        ), // NV_IS_HOST:
+        ( return get_agent_plan_impl<Agent, sm_list>::get(ptx_version); ));
+    }
+
+// XXX keep this dead-code for now as a gentle reminder
+//     that kernel luunch which reats plan values is the most robust
+//     mechanism to extract sm-specific tuning parameters
+// TODO: since we are unable to afford kernel launch + cudaMemcpy ON EVERY
+//       algorithm invocation, we need to design a good caching strategy
+//       such that when the algorithm is called multiple times, only the
+//       first invocation will invoke kernel launch + cudaMemcpy, but
+//       the subsequent invocations, will just read cached values from host mem
+//       If launched from device, this is just a device-function call
+//       no caching is required.
+// ----------------------------------------------------------------------------
+  // if we don't know ptx version, we can call kernel
+  // to retrieve AgentPlan from device code. Slower, but guaranteed to work
+  // -----------------------------------------------------------------------
+#if 0
+  template<class Agent>
+  void __global__ get_agent_plan_kernel(AgentPlan *plan);
+
+  static __device__ AgentPlan agent_plan_device;
+
+  template<class Agent>
+  AgentPlan __device__ get_agent_plan_dev()
+  {
+    AgentPlan plan;
+    plan.block_threads      = Agent::ptx_plan::BLOCK_THREADS;
+    plan.items_per_thread   = Agent::ptx_plan::ITEMS_PER_THREAD;
+    plan.items_per_tile     = Agent::ptx_plan::ITEMS_PER_TILE;
+    plan.shared_memory_size = temp_storage_size<typename Agent::ptx_plan>::value;
+    return plan;
+  }
+
+  template <class Agent, class F>
+  AgentPlan __host__ __device__ __forceinline__
+  xget_agent_plan_impl(F f, cudaStream_t s, void* d_ptr)
+  {
+    AgentPlan plan;
+#ifdef __CUDA_ARCH__
+    plan = get_agent_plan_dev<Agent>();
+#else
+    static cub::Mutex mutex;
+    bool lock = false;
+    if (d_ptr == 0)
+    {
+      lock = true;
+      cudaGetSymbolAddress(&d_ptr, agent_plan_device);
+    }
+    if (lock)
+      mutex.Lock();
+    f<<<1,1,0,s>>>((AgentPlan*)d_ptr);
+    cudaMemcpyAsync((void*)&plan,
+                    d_ptr,
+                    sizeof(AgentPlan),
+                    cudaMemcpyDeviceToHost,
+                    s);
+    if (lock)
+      mutex.Unlock();
+    cudaStreamSynchronize(s);
+#endif
+    return plan;
+  }
+
+  template <class Agent>
+  AgentPlan THRUST_RUNTIME_FUNCTION
+  get_agent_plan(cudaStream_t s = 0, void *ptr = 0)
+  {
+    return xget_agent_plan_impl<Agent>(get_agent_plan_kernel<Agent>,
+                                        s,
+                                        ptr);
+  }
+
+  template<class Agent>
+  void __global__ get_agent_plan_kernel(AgentPlan *plan)
+  {
+    *plan = get_agent_plan_dev<Agent>();
+  }
+#endif
+
+  /////////////////////////
+  /////////////////////////
+  /////////////////////////
+
+  THRUST_RUNTIME_FUNCTION
+  inline int get_sm_count()
+  {
+    int dev_id;
+    cuda_cub::throw_on_error(cudaGetDevice(&dev_id),
+                             "get_sm_count :"
+                             "failed to cudaGetDevice");
+
+    cudaError_t status;
+    int         i32value;
+    status = cudaDeviceGetAttribute(&i32value,
+                                    cudaDevAttrMultiProcessorCount,
+                                    dev_id);
+    cuda_cub::throw_on_error(status,
+                             "get_sm_count:"
+                             "failed to sm_count");
+    return i32value;
+  }
+
+  THRUST_RUNTIME_FUNCTION
+  inline size_t get_max_shared_memory_per_block()
+  {
+    int dev_id;
+    cuda_cub::throw_on_error(cudaGetDevice(&dev_id),
+                             "get_max_shared_memory_per_block :"
+                             "failed to cudaGetDevice");
+
+    cudaError_t status;
+    int         i32value;
+    status = cudaDeviceGetAttribute(&i32value,
+                                    cudaDevAttrMaxSharedMemoryPerBlock,
+                                    dev_id);
+    cuda_cub::throw_on_error(status,
+                             "get_max_shared_memory_per_block :"
+                             "failed to get max shared memory per block");
+
+    return static_cast<size_t>(i32value);
+  }
+
+  THRUST_RUNTIME_FUNCTION
+  inline size_t virtual_shmem_size(size_t shmem_per_block)
+  {
+    size_t max_shmem_per_block = core::get_max_shared_memory_per_block();
+    if (shmem_per_block > max_shmem_per_block)
+      return shmem_per_block;
+    else
+      return 0;
+  }
+
+  THRUST_RUNTIME_FUNCTION
+  inline size_t vshmem_size(size_t shmem_per_block, size_t num_blocks)
+  {
+    size_t max_shmem_per_block = core::get_max_shared_memory_per_block();
+    if (shmem_per_block > max_shmem_per_block)
+      return shmem_per_block*num_blocks;
+    else
+      return 0;
+  }
+
+  // LoadIterator
+  // ------------
+  // if trivial iterator is passed, wrap loads into LDG
+  //
+  template <class PtxPlan, class It>
+  struct LoadIterator
+  {
+    typedef typename iterator_traits<It>::value_type      value_type;
+    typedef typename iterator_traits<It>::difference_type size_type;
+
+    typedef typename thrust::detail::conditional<
+        is_contiguous_iterator<It>::value,
+        cub::CacheModifiedInputIterator<PtxPlan::LOAD_MODIFIER,
+                                        value_type,
+                                        size_type>,
+                                        It>::type type;
+  };    // struct Iterator
+
+  template <class PtxPlan, class It>
+  typename LoadIterator<PtxPlan, It>::type __device__ __forceinline__
+  make_load_iterator_impl(It it, thrust::detail::true_type /* is_trivial */)
+  {
+    return raw_pointer_cast(&*it);
+  }
+
+  template <class PtxPlan, class It>
+  typename LoadIterator<PtxPlan, It>::type __device__ __forceinline__
+  make_load_iterator_impl(It it, thrust::detail::false_type /* is_trivial */)
+  {
+    return it;
+  }
+
+  template <class PtxPlan, class It>
+  typename LoadIterator<PtxPlan, It>::type __device__ __forceinline__
+  make_load_iterator(PtxPlan const&, It it)
+  {
+    return make_load_iterator_impl<PtxPlan>(
+        it, typename is_contiguous_iterator<It>::type());
+  }
+
+  template<class>
+  struct get_arch;
+
+  template<template<class> class Plan, class Arch>
+  struct get_arch<Plan<Arch> > { typedef Arch type; };
+
+  // BlockLoad
+  // -----------
+  // a helper metaprogram that returns type of a block loader
+  template <class PtxPlan,
+            class It,
+            class T    = typename iterator_traits<It>::value_type>
+  struct BlockLoad
+  {
+    using type = cub::BlockLoad<T,
+                                PtxPlan::BLOCK_THREADS,
+                                PtxPlan::ITEMS_PER_THREAD,
+                                PtxPlan::LOAD_ALGORITHM,
+                                1,
+                                1,
+                                get_arch<PtxPlan>::type::ver>;
+  };
+
+  // BlockStore
+  // -----------
+  // a helper metaprogram that returns type of a block loader
+  template <class PtxPlan,
+            class It,
+            class T = typename iterator_traits<It>::value_type>
+  struct BlockStore
+  {
+    using type = cub::BlockStore<T,
+                                 PtxPlan::BLOCK_THREADS,
+                                 PtxPlan::ITEMS_PER_THREAD,
+                                 PtxPlan::STORE_ALGORITHM,
+                                 1,
+                                 1,
+                                 get_arch<PtxPlan>::type::ver>;
+  };
+
+  // cuda_optional
+  // --------------
+  // used for function that return cudaError_t along with the result
+  //
+  template <class T>
+  class cuda_optional
+  {
+    cudaError_t status_{cudaSuccess};
+    T           value_{};
+
+  public:
+    cuda_optional() = default;
+
+    __host__ __device__
+    cuda_optional(T v, cudaError_t status = cudaSuccess) : status_(status), value_(v) {}
+
+    bool __host__ __device__
+    isValid() const { return cudaSuccess == status_; }
+
+    cudaError_t __host__ __device__
+    status() const { return status_; }
+
+    __host__ __device__ T const &
+    value() const { return value_; }
+
+    __host__ __device__ operator T const &() const { return value_; }
+  };
+
+  THRUST_RUNTIME_FUNCTION
+  inline int get_ptx_version()
+  {
+    int ptx_version = 0;
+    if (cub::PtxVersion(ptx_version) != cudaSuccess)
+    {
+      // Failure might mean that there's no device found
+      const int current_device = cub::CurrentDevice();
+      if (current_device < 0)
+      {
+        cuda_cub::throw_on_error(cudaErrorNoDevice, "No GPU is available\n");
+      }
+
+      // Any subsequent failure means the provided device binary does not match
+      // the generated function code
+      int major = 0, minor = 0;
+      cudaError_t attr_status;
+
+      attr_status = cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, current_device);
+      cuda_cub::throw_on_error(attr_status,
+                              "get_ptx_version :"
+                              "failed to get major CUDA device compute capability version.");
+
+      attr_status = cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, current_device);
+      cuda_cub::throw_on_error(attr_status,
+                              "get_ptx_version :"
+                              "failed to get minor CUDA device compute capability version.");
+
+      // Index from which SM code has to start in the message below
+      int code_offset = 37;
+      char str[] = "This program was not compiled for SM     \n";
+
+      auto print_1_helper = [&](int v) {
+        str[code_offset] = static_cast<char>(v) + '0';
+        code_offset++;
+      };
+
+      // Assume two digits will be enough
+      auto print_2_helper = [&](int v) {
+        if (v / 10 != 0) {
+          print_1_helper(v / 10);
+        }
+        print_1_helper(v % 10);
+      };
+
+      print_2_helper(major);
+      print_2_helper(minor);
+
+      cuda_cub::throw_on_error(cudaErrorInvalidDevice, str);
+    }
+
+    return ptx_version;
+  }
+
+  THRUST_RUNTIME_FUNCTION
+  inline cudaError_t sync_stream(cudaStream_t stream)
+  {
+    return cub::SyncStream(stream);
+  }
+
+  inline void __device__ sync_threadblock()
+  {
+    cub::CTA_SYNC();
+  }
+
+#define CUDA_CUB_RET_IF_FAIL(e) \
+  {                             \
+    auto const error = (e);     \
+    if (cub::Debug(error, __FILE__, __LINE__)) return error; \
+  }
+
+  // uninitialized
+  // -------
+  // stores type in uninitialized form
+  //
+  template <class T>
+  struct uninitialized
+  {
+    typedef typename cub::UnitWord<T>::DeviceWord DeviceWord;
+
+    enum
+    {
+      WORDS = sizeof(T) / sizeof(DeviceWord)
+    };
+
+    DeviceWord storage[WORDS];
+
+    __host__ __device__ __forceinline__ T& get()
+    {
+      return reinterpret_cast<T&>(*this);
+    }
+
+    __host__ __device__ __forceinline__ operator T&() { return get(); }
+  };
+
+  // uninitialized_array
+  // --------------
+  // allocates uninitialized data on stack
+  template<class T, size_t N>
+  struct array
+  {
+    typedef T value_type;
+    typedef T ref[N];
+    enum {SIZE = N};
+    private:
+      T data_[N];
+
+    public:
+      __host__ __device__ T* data() { return data_; }
+      __host__ __device__ const T* data() const { return data_; }
+      __host__ __device__ T& operator[](unsigned int idx) { return ((T*)data_)[idx]; }
+      __host__ __device__ T const& operator[](unsigned int idx) const { return ((T*)data_)[idx]; }
+      __host__ __device__ unsigned int size() const { return N; }
+      __host__ __device__ operator ref&() { return data_; }
+  };
+
+
+  // uninitialized_array
+  // --------------
+  // allocates uninitialized data on stack
+  template<class T, size_t N>
+  struct uninitialized_array
+  {
+    typedef T value_type;
+    typedef T ref[N];
+    enum {SIZE = N};
+    private:
+      char data_[N * sizeof(T)];
+
+    public:
+      __host__ __device__ T* data() { return data_; }
+      __host__ __device__ const T* data() const { return data_; }
+      __host__ __device__ T& operator[](unsigned int idx) { return ((T*)data_)[idx]; }
+      __host__ __device__ T const& operator[](unsigned int idx) const { return ((T*)data_)[idx]; }
+      __host__ __device__ T& operator[](int idx) { return ((T*)data_)[idx]; }
+      __host__ __device__ T const& operator[](int idx) const { return ((T*)data_)[idx]; }
+      __host__ __device__ unsigned int size() const { return N; }
+      __host__ __device__ operator ref&() { return *reinterpret_cast<ref*>(data_); }
+      __host__ __device__ ref& get_ref() { return (ref&)*this; }
+  };
+
+  __host__ __device__ __forceinline__ size_t align_to(size_t n, size_t align)
+  {
+    return ((n+align-1)/align) * align;
+  }
+
+  namespace host {
+    inline cuda_optional<size_t> get_max_shared_memory_per_block()
+    {
+      cudaError_t status = cudaSuccess;
+      int         dev_id = 0;
+      status             = cudaGetDevice(&dev_id);
+      if (status != cudaSuccess) return cuda_optional<size_t>(0, status);
+
+      int max_shmem = 0;
+      status        = cudaDeviceGetAttribute(&max_shmem,
+                                      cudaDevAttrMaxSharedMemoryPerBlock,
+                                      dev_id);
+      if (status != cudaSuccess) return cuda_optional<size_t>(0, status);
+      return cuda_optional<size_t>(max_shmem, status);
+    }
+  }
+
+  template <int           ALLOCATIONS>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  alias_storage(void*   storage_ptr,
+                size_t& storage_size,
+                void* (&allocations)[ALLOCATIONS],
+                size_t (&allocation_sizes)[ALLOCATIONS])
+  {
+    return cub::AliasTemporaries(storage_ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+  }
+
+
+}    // namespace core
+using core::sm60;
+using core::sm52;
+using core::sm35;
+using core::sm30;
+} // namespace cuda_
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/system/cuda/detail/internal/copy_cross_system.h

@@ -0,0 +1,252 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditionu and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+// XXX
+// this file must not be included on its own, ever,
+// but must be part of include in thrust/system/cuda/detail/copy.h
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/distance.h>
+#include <thrust/advance.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/cuda/detail/uninitialized_copy.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __copy {
+
+
+  template <class H,
+            class D,
+            class T,
+            class Size>
+  THRUST_HOST_FUNCTION void
+  trivial_device_copy(thrust::cpp::execution_policy<H>&      ,
+                      thrust::cuda_cub::execution_policy<D>& device_s,
+                      T*                                     dst,
+                      T const*                               src,
+                      Size                                   count)
+  {
+    cudaError status;
+    status = cuda_cub::trivial_copy_to_device(dst,
+                                              src,
+                                              count,
+                                              cuda_cub::stream(device_s));
+    cuda_cub::throw_on_error(status, "__copy::trivial_device_copy H->D: failed");
+  }
+
+  template <class D,
+            class H,
+            class T,
+            class Size>
+  THRUST_HOST_FUNCTION void
+  trivial_device_copy(thrust::cuda_cub::execution_policy<D>& device_s,
+                      thrust::cpp::execution_policy<H>&      ,
+                      T*                                     dst,
+                      T const*                               src,
+                      Size                                   count)
+  {
+    cudaError status;
+    status = cuda_cub::trivial_copy_from_device(dst,
+                                                src,
+                                                count,
+                                                cuda_cub::stream(device_s));
+    cuda_cub::throw_on_error(status, "trivial_device_copy D->H failed");
+  }
+
+  template <class System1,
+            class System2,
+            class InputIt,
+            class Size,
+            class OutputIt>
+  OutputIt __host__
+  cross_system_copy_n(thrust::execution_policy<System1>& sys1,
+                      thrust::execution_policy<System2>& sys2,
+                      InputIt                            begin,
+                      Size                               n,
+                      OutputIt                           result,
+                      thrust::detail::true_type)    // trivial copy
+
+  {
+    typedef typename iterator_traits<InputIt>::value_type InputTy;
+    if (n > 0) {
+      trivial_device_copy(derived_cast(sys1),
+                          derived_cast(sys2),
+                          reinterpret_cast<InputTy*>(thrust::raw_pointer_cast(&*result)),
+                          reinterpret_cast<InputTy const*>(thrust::raw_pointer_cast(&*begin)),
+                          n);
+    }
+
+    return result + n;
+  }
+
+  // non-trivial H->D copy
+  template <class H,
+            class D,
+            class InputIt,
+            class Size,
+            class OutputIt>
+  OutputIt __host__
+  cross_system_copy_n(thrust::cpp::execution_policy<H>&      host_s,
+                      thrust::cuda_cub::execution_policy<D>& device_s,
+                      InputIt                                first,
+                      Size                                   num_items,
+                      OutputIt                               result,
+                      thrust::detail::false_type)    // non-trivial copy
+  {
+    // get type of the input data
+    typedef typename thrust::iterator_value<InputIt>::type InputTy;
+
+    // copy input data into host temp storage
+    InputIt last = first;
+    thrust::advance(last, num_items);
+    thrust::detail::temporary_array<InputTy, H> temp(host_s, num_items);
+
+    for (Size idx = 0; idx != num_items; idx++)
+    {
+      ::new (static_cast<void*>(temp.data().get()+idx)) InputTy(*first);
+      ++first;
+    }
+
+    // allocate device temporary storage
+    thrust::detail::temporary_array<InputTy, D> d_in_ptr(device_s, num_items);
+
+    // trivial copy data from host to device
+    cudaError status = cuda_cub::trivial_copy_to_device(d_in_ptr.data().get(),
+                                                        temp.data().get(),
+                                                        num_items,
+                                                        cuda_cub::stream(device_s));
+    cuda_cub::throw_on_error(status, "__copy:: H->D: failed");
+
+
+    // device->device copy
+    OutputIt ret = cuda_cub::copy_n(device_s, d_in_ptr.data(), num_items, result);
+
+    return ret;
+  }
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+  // non-trivial copy D->H, only supported with NVCC compiler
+  // because copy ctor must have  __device__ annotations, which is nvcc-only
+  // feature
+  template <class D,
+            class H,
+            class InputIt,
+            class Size,
+            class OutputIt>
+  OutputIt __host__
+  cross_system_copy_n(thrust::cuda_cub::execution_policy<D>& device_s,
+                      thrust::cpp::execution_policy<H>&   host_s,
+                      InputIt                             first,
+                      Size                                num_items,
+                      OutputIt                            result,
+                      thrust::detail::false_type)    // non-trivial copy
+
+  {
+    // get type of the input data
+    typedef typename thrust::iterator_value<InputIt>::type InputTy;
+
+    // allocate device temp storage
+    thrust::detail::temporary_array<InputTy, D> d_in_ptr(device_s, num_items);
+
+    // uninitialize copy into temp device storage
+    cuda_cub::uninitialized_copy_n(device_s, first, num_items, d_in_ptr.data());
+
+    // allocate host temp storage
+    thrust::detail::temporary_array<InputTy, H> temp(host_s, num_items);
+
+    // trivial copy from device to host
+    cudaError status;
+    status = cuda_cub::trivial_copy_from_device(temp.data().get(),
+                                                d_in_ptr.data().get(),
+                                                num_items,
+                                                cuda_cub::stream(device_s));
+    cuda_cub::throw_on_error(status, "__copy:: D->H: failed");
+
+    // host->host copy
+    OutputIt ret = thrust::copy_n(host_s, temp.data(), num_items, result);
+
+    return ret;
+  }
+#endif
+
+  template <class System1,
+            class System2,
+            class InputIt,
+            class Size,
+            class OutputIt>
+  OutputIt __host__
+  cross_system_copy_n(cross_system<System1, System2> systems,
+                      InputIt  begin,
+                      Size     n,
+                      OutputIt result)
+  {
+    return cross_system_copy_n(
+        derived_cast(systems.sys1),
+        derived_cast(systems.sys2),
+        begin,
+        n,
+        result,
+        typename is_indirectly_trivially_relocatable_to<InputIt, OutputIt>::type());
+  }
+
+  template <class System1,
+            class System2,
+            class InputIterator,
+            class OutputIterator>
+  OutputIterator __host__
+  cross_system_copy(cross_system<System1, System2> systems,
+                    InputIterator  begin,
+                    InputIterator  end,
+                    OutputIterator result)
+  {
+    return cross_system_copy_n(systems,
+                               begin,
+                               thrust::distance(begin, end),
+                               result);
+  }
+
+}    // namespace __copy
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/system/cuda/detail/internal/copy_device_to_device.h

@@ -0,0 +1,114 @@
+
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __copy {
+  template <class Derived,
+            class InputIt,
+            class OutputIt>
+  OutputIt THRUST_RUNTIME_FUNCTION
+  device_to_device(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   OutputIt                   result,
+                   thrust::detail::true_type)
+  {
+    typedef typename thrust::iterator_traits<InputIt>::value_type InputTy;
+    const auto n = thrust::distance(first, last);
+    if (n > 0) {
+      cudaError status;
+      status = trivial_copy_device_to_device(policy,
+                                             reinterpret_cast<InputTy*>(thrust::raw_pointer_cast(&*result)),
+                                             reinterpret_cast<InputTy const*>(thrust::raw_pointer_cast(&*first)),
+                                             n);
+      cuda_cub::throw_on_error(status, "__copy:: D->D: failed");
+    }
+
+    return result + n;
+  }
+
+  template <class Derived,
+            class InputIt,
+            class OutputIt>
+  OutputIt THRUST_RUNTIME_FUNCTION
+  device_to_device(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   OutputIt                   result,
+                   thrust::detail::false_type)
+  {
+    typedef typename thrust::iterator_traits<InputIt>::value_type InputTy;
+    return cuda_cub::transform(policy,
+                              first,
+                              last,
+                              result,
+                              thrust::identity<InputTy>());
+  }
+
+  template <class Derived,
+            class InputIt,
+            class OutputIt>
+  OutputIt THRUST_RUNTIME_FUNCTION
+  device_to_device(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   OutputIt                   result)
+  {
+    return device_to_device(policy,
+                            first,
+                            last,
+                            result,
+                            typename is_indirectly_trivially_relocatable_to<InputIt, OutputIt>::type());
+  }
+}    // namespace __copy
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/reduce_by_key.h

@@ -0,0 +1,1217 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/detail/mpl/math.h>
+#include <thrust/detail/raw_reference_cast.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/type_traits/iterator/is_output_iterator.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+#include <thrust/pair.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/device_reduce.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator1,
+          typename OutputIterator2,
+          typename BinaryPredicate>
+__host__ __device__ thrust::pair<OutputIterator1, OutputIterator2>
+reduce_by_key(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    InputIterator1                                              keys_first,
+    InputIterator1                                              keys_last,
+    InputIterator2                                              values_first,
+    OutputIterator1                                             keys_output,
+    OutputIterator2                                             values_output,
+    BinaryPredicate                                             binary_pred);
+
+namespace cuda_cub {
+
+namespace __reduce_by_key {
+
+  template<bool> struct is_true : thrust::detail::false_type {};
+  template<> struct is_true<true> : thrust::detail::true_type {};
+
+  namespace mpl = thrust::detail::mpl::math;
+
+  template <int                     _BLOCK_THREADS,
+            int                     _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier  _LOAD_MODIFIER    = cub::LOAD_DEFAULT,
+            cub::BlockScanAlgorithm _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS    = _BLOCK_THREADS,
+      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = BLOCK_THREADS * ITEMS_PER_THREAD
+    };
+
+    static const cub::BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier  LOAD_MODIFIER  = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM;
+  };    // struct PtxPolicy
+
+  template <class Arch, class Key, class Value>
+  struct Tuning;
+
+  template <class Key, class Value>
+  struct Tuning<sm30, Key, Value>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES      = mpl::max<size_t, sizeof(Key), sizeof(Value)>::value,
+      COMBINED_INPUT_BYTES = sizeof(Key) + sizeof(Value),
+
+      NOMINAL_4B_ITEMS_PER_THREAD = 6,
+
+      ITEMS_PER_THREAD = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<
+              int,
+              1,
+              static_cast<int>(((NOMINAL_4B_ITEMS_PER_THREAD * 8) +
+               COMBINED_INPUT_BYTES - 1) /
+                  COMBINED_INPUT_BYTES)>::value>::value,
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning sm30
+
+  template<class Key, class Value>
+  struct Tuning<sm35,Key,Value> : Tuning<sm30,Key,Value>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES      = mpl::max<size_t, sizeof(Key), sizeof(Value)>::value,
+      COMBINED_INPUT_BYTES = sizeof(Key) + sizeof(Value),
+
+      NOMINAL_4B_ITEMS_PER_THREAD = 6,
+
+      ITEMS_PER_THREAD =
+          (MAX_INPUT_BYTES <= 8)
+              ? 6
+              : mpl::min<
+                    int,
+                    NOMINAL_4B_ITEMS_PER_THREAD,
+                    mpl::max<
+                        int,
+                        1,
+                        ((NOMINAL_4B_ITEMS_PER_THREAD * 8) +
+                         COMBINED_INPUT_BYTES - 1) /
+                            COMBINED_INPUT_BYTES>::value>::value,
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning sm35
+
+  template<class Key, class Value>
+  struct Tuning<sm52,Key,Value> : Tuning<sm30,Key,Value>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES      = mpl::max<size_t, sizeof(Key), sizeof(Value)>::value,
+      COMBINED_INPUT_BYTES = sizeof(Key) + sizeof(Value),
+
+      NOMINAL_4B_ITEMS_PER_THREAD = 9,
+
+      ITEMS_PER_THREAD =
+          (MAX_INPUT_BYTES <= 8)
+              ? 9
+              : mpl::min<
+                    int,
+                    NOMINAL_4B_ITEMS_PER_THREAD,
+                    mpl::max<
+                        int,
+                        1,
+                        ((NOMINAL_4B_ITEMS_PER_THREAD * 8) +
+                         COMBINED_INPUT_BYTES - 1) /
+                            COMBINED_INPUT_BYTES>::value>::value,
+    };
+
+    typedef PtxPolicy<256,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning sm52
+
+  template <class KeysInputIt,
+            class ValuesInputIt,
+            class KeysOutputIt,
+            class ValuesOutputIt,
+            class EqualityOp,
+            class ReductionOp,
+            class NumRunsOutputIt,
+            class Size>
+  struct ReduceByKeyAgent
+  {
+    typedef typename iterator_traits<KeysInputIt>::value_type   key_type;
+    typedef typename iterator_traits<ValuesInputIt>::value_type value_type;
+    typedef Size                                                size_type;
+
+    typedef cub::KeyValuePair<size_type, value_type> size_value_pair_t;
+    typedef cub::KeyValuePair<key_type, value_type>  key_value_pair_t;
+
+    typedef cub::ReduceByKeyScanTileState<value_type, size_type> ScanTileState;
+    typedef cub::ReduceBySegmentOp<ReductionOp> ReduceBySegmentOp;
+
+    template<class Arch>
+    struct PtxPlan : Tuning<Arch,key_type, value_type>::type
+    {
+      typedef Tuning<Arch, key_type, value_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, KeysInputIt>::type    KeysLoadIt;
+      typedef typename core::LoadIterator<PtxPlan, ValuesInputIt>::type  ValuesLoadIt;
+
+      typedef typename core::BlockLoad<PtxPlan, KeysLoadIt>::type   BlockLoadKeys;
+      typedef typename core::BlockLoad<PtxPlan, ValuesLoadIt>::type BlockLoadValues;
+
+      typedef cub::BlockDiscontinuity<key_type,
+                                      PtxPlan::BLOCK_THREADS,
+                                      1,
+                                      1,
+                                      Arch::ver>
+          BlockDiscontinuityKeys;
+
+      typedef cub::TilePrefixCallbackOp<size_value_pair_t,
+                                        ReduceBySegmentOp,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+      typedef cub::BlockScan<size_value_pair_t,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage              scan;
+          typename TilePrefixCallback::TempStorage     prefix;
+          typename BlockDiscontinuityKeys::TempStorage discontinuity;
+        } scan_storage;
+
+        typename BlockLoadKeys::TempStorage   load_keys;
+        typename BlockLoadValues::TempStorage load_values;
+
+        core::uninitialized_array<key_value_pair_t, PtxPlan::ITEMS_PER_TILE + 1>
+          raw_exchange;
+      };    // union TempStorage
+    };  // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::KeysLoadIt             KeysLoadIt;
+    typedef typename ptx_plan::ValuesLoadIt           ValuesLoadIt;
+    typedef typename ptx_plan::BlockLoadKeys          BlockLoadKeys;
+    typedef typename ptx_plan::BlockLoadValues        BlockLoadValues;
+    typedef typename ptx_plan::BlockDiscontinuityKeys BlockDiscontinuityKeys;
+    typedef typename ptx_plan::TilePrefixCallback     TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan              BlockScan;
+    typedef typename ptx_plan::TempStorage            TempStorage;
+
+    enum
+    {
+      BLOCK_THREADS     = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_THREAD  = ptx_plan::ITEMS_PER_THREAD,
+      ITEMS_PER_TILE    = ptx_plan::ITEMS_PER_TILE,
+      TWO_PHASE_SCATTER = (ITEMS_PER_THREAD > 1),
+
+      // Whether or not the scan operation has a zero-valued identity value
+      // (true if we're performing addition on a primitive type)
+      HAS_IDENTITY_ZERO = thrust::detail::is_same<ReductionOp,
+                                                  plus<value_type> >::value &&
+                          thrust::detail::is_arithmetic<value_type>::value
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &                      storage;
+      KeysLoadIt                         keys_load_it;
+      ValuesLoadIt                       values_load_it;
+      KeysOutputIt                       keys_output_it;
+      ValuesOutputIt                     values_output_it;
+      NumRunsOutputIt                    num_runs_output_it;
+      cub::InequalityWrapper<EqualityOp> inequality_op;
+      ReduceBySegmentOp                  scan_op;
+
+      //---------------------------------------------------------------------
+      // Block scan utility methods
+      //---------------------------------------------------------------------
+
+      // Scan with identity (first tile)
+      //
+      THRUST_DEVICE_FUNCTION void
+      scan_tile(size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+                size_value_pair_t &tile_aggregate,
+                thrust::detail::true_type /* has_identity */)
+      {
+        size_value_pair_t identity;
+        identity.value = 0;
+        identity.key   = 0;
+        BlockScan(storage.scan_storage.scan)
+            .ExclusiveScan(scan_items, scan_items, identity, scan_op, tile_aggregate);
+      }
+
+      // Scan without identity (first tile).
+      // Without an identity, the first output item is undefined.
+      //
+      THRUST_DEVICE_FUNCTION void
+      scan_tile(size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+                size_value_pair_t &tile_aggregate,
+                thrust::detail::false_type /* has_identity */)
+      {
+        BlockScan(storage.scan_storage.scan)
+            .ExclusiveScan(scan_items, scan_items, scan_op, tile_aggregate);
+      }
+
+      // Scan with identity (subsequent tile)
+      //
+      THRUST_DEVICE_FUNCTION void
+      scan_tile(size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+                size_value_pair_t & tile_aggregate,
+                TilePrefixCallback &prefix_op,
+                thrust::detail::true_type /*  has_identity */)
+      {
+        BlockScan(storage.scan_storage.scan)
+            .ExclusiveScan(scan_items,
+                           scan_items,
+                           scan_op,
+                           prefix_op);
+        tile_aggregate = prefix_op.GetBlockAggregate();
+      }
+
+      // Scan without identity (subsequent tile).
+      // Without an identity, the first output item is undefined.
+      THRUST_DEVICE_FUNCTION void
+      scan_tile(size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+                size_value_pair_t & tile_aggregate,
+                TilePrefixCallback &prefix_op,
+                thrust::detail::false_type /* has_identity */)
+      {
+        BlockScan(storage.scan_storage.scan)
+            .ExclusiveScan(scan_items,
+                           scan_items,
+                           scan_op,
+                           prefix_op);
+        tile_aggregate = prefix_op.GetBlockAggregate();
+      }
+
+      //---------------------------------------------------------------------
+      // Zip utility methods
+      //---------------------------------------------------------------------
+
+
+      template <bool IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      zip_values_and_flags(size_type num_remaining,
+                           value_type (&values)[ITEMS_PER_THREAD],
+                           size_type (&segment_flags)[ITEMS_PER_THREAD],
+                           size_value_pair_t (&scan_items)[ITEMS_PER_THREAD])
+      {
+        // Zip values and segment_flags
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          // Set segment_flags for first out-of-bounds item, zero for others
+          if (IS_LAST_TILE &&
+              Size(threadIdx.x * ITEMS_PER_THREAD) + ITEM == num_remaining)
+            segment_flags[ITEM] = 1;
+
+          scan_items[ITEM].value = values[ITEM];
+          scan_items[ITEM].key   = segment_flags[ITEM];
+        }
+      }
+
+      THRUST_DEVICE_FUNCTION void zip_keys_and_values(
+          key_type (&keys)[ITEMS_PER_THREAD],
+          size_type (&segment_indices)[ITEMS_PER_THREAD],
+          size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+          key_value_pair_t (&scatter_items)[ITEMS_PER_THREAD])
+      {
+        // Zip values and segment_flags
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          scatter_items[ITEM].key   = keys[ITEM];
+          scatter_items[ITEM].value = scan_items[ITEM].value;
+          segment_indices[ITEM]     = scan_items[ITEM].key;
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Scatter utility methods
+      //---------------------------------------------------------------------
+
+      // Directly scatter flagged items to output offsets
+      // (specialized for IS_SEGMENTED_REDUCTION_FIXUP == false)
+      THRUST_DEVICE_FUNCTION void scatter_direct(
+          key_value_pair_t (&scatter_items)[ITEMS_PER_THREAD],
+          size_type (&segment_flags)[ITEMS_PER_THREAD],
+          size_type (&segment_indices)[ITEMS_PER_THREAD])
+      {
+        // Scatter flagged keys and values
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          if (segment_flags[ITEM])
+          {
+            keys_output_it[segment_indices[ITEM]] = scatter_items[ITEM].key;
+            values_output_it[segment_indices[ITEM]] = scatter_items[ITEM].value;
+          }
+        }
+      }
+
+      // 2-phase scatter flagged items to output offsets
+      // (specialized for IS_SEGMENTED_REDUCTION_FIXUP == false
+      //
+      // The exclusive scan causes each head flag to be paired with
+      // the previous value aggregate:
+      //   * the scatter offsets must be decremented for value aggregates
+      //
+      THRUST_DEVICE_FUNCTION void scatter_two_phase(
+          key_value_pair_t (&scatter_items)[ITEMS_PER_THREAD],
+          size_type (&segment_flags)[ITEMS_PER_THREAD],
+          size_type (&segment_indices)[ITEMS_PER_THREAD],
+          size_type num_tile_segments,
+          size_type num_tile_segments_prefix)
+      {
+        using core::sync_threadblock;
+
+        sync_threadblock();
+
+        // Compact and scatter keys
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          if (segment_flags[ITEM])
+          {
+            int idx = static_cast<int>(segment_indices[ITEM] -
+                                       num_tile_segments_prefix);
+            storage.raw_exchange[idx] = scatter_items[ITEM];
+          }
+        }
+
+        sync_threadblock();
+
+        for (int item = threadIdx.x; item < num_tile_segments; item += BLOCK_THREADS)
+        {
+          size_type        idx  = num_tile_segments_prefix + item;
+          key_value_pair_t pair = storage.raw_exchange[item];
+          keys_output_it[idx]   = pair.key;
+          values_output_it[idx] = pair.value;
+        }
+      }
+
+
+      // Scatter flagged items
+      //
+      THRUST_DEVICE_FUNCTION void scatter(
+          key_value_pair_t (&scatter_items)[ITEMS_PER_THREAD],
+          size_type (&segment_flags)[ITEMS_PER_THREAD],
+          size_type (&segment_indices)[ITEMS_PER_THREAD],
+          size_type num_tile_segments,
+          size_type num_tile_segments_prefix)
+      {
+        // Do a one-phase scatter if (a) two-phase is disabled or
+        // (b) the average number of selected items per thread is less than one
+        if (TWO_PHASE_SCATTER && (num_tile_segments > BLOCK_THREADS))
+        {
+          scatter_two_phase(scatter_items,
+                            segment_flags,
+                            segment_indices,
+                            num_tile_segments,
+                            num_tile_segments_prefix);
+        }
+        else
+        {
+          scatter_direct(scatter_items,
+                         segment_flags,
+                         segment_indices);
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Finalization utility methods
+      //---------------------------------------------------------------------
+
+      // Finalize the carry-out from the last tile
+      // (specialized for IS_SEGMENTED_REDUCTION_FIXUP == false)
+      THRUST_DEVICE_FUNCTION void
+      finalize_last_tile(size_type num_segments,
+                         size_type num_remaining,
+                         key_type    last_key,
+                         value_type  last_value)
+      {
+        // Last thread will output final count and last item, if necessary
+        if (threadIdx.x == BLOCK_THREADS - 1)
+        {
+          // If the last tile is a whole tile, the inclusive prefix
+          // contains accumulated value reduction for the last segment
+          if (num_remaining == ITEMS_PER_TILE)
+          {
+            // Scatter key and value
+            keys_output_it[num_segments]   = last_key;
+            values_output_it[num_segments] = last_value;
+            num_segments++;
+          }
+
+          // Output the total number of items selected
+          *num_runs_output_it = num_segments;
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Cooperatively scan a device-wide sequence of tiles with other CTAs
+      //---------------------------------------------------------------------
+
+      // Process first tile of input (dynamic chained scan).
+      // Returns the running  count of segments
+      // and aggregated values (including this tile)
+      //
+      template <bool IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      consume_first_tile(Size           num_remaining,
+                         Size           tile_offset,
+                         ScanTileState &tile_state)
+      {
+        using core::sync_threadblock;
+
+        key_type          keys[ITEMS_PER_THREAD];               // Tile keys
+        key_type          pred_keys[ITEMS_PER_THREAD];          // Tile keys shifted up (predecessor)
+        value_type        values[ITEMS_PER_THREAD];             // Tile values
+        size_type         segment_flags[ITEMS_PER_THREAD];      // Segment head flags
+        size_type         segment_indices[ITEMS_PER_THREAD];    // Segment indices
+        size_value_pair_t scan_items[ITEMS_PER_THREAD];         // Zipped values and segment flags|indices
+        key_value_pair_t  scatter_items[ITEMS_PER_THREAD];      // Zipped key value pairs for scattering
+
+        // Load keys (last tile repeats final element)
+        if (IS_LAST_TILE)
+        {
+          // Fill last elements with the first element
+          // because collectives are not suffix guarded
+          BlockLoadKeys(storage.load_keys)
+              .Load(keys_load_it + tile_offset,
+                    keys,
+                    num_remaining,
+                    *(keys_load_it + tile_offset));
+        }
+        else
+        {
+          BlockLoadKeys(storage.load_keys)
+              .Load(keys_load_it + tile_offset, keys);
+        }
+
+        sync_threadblock();
+
+        // Load values (last tile repeats final element)
+        if (IS_LAST_TILE)
+        {
+          BlockLoadValues(storage.load_values)
+              .Load(values_load_it + tile_offset,
+                    values,
+                    num_remaining,
+                    *(values_load_it + tile_offset));
+        }
+        else
+        {
+          BlockLoadValues(storage.load_values)
+              .Load(values_load_it + tile_offset, values);
+        }
+
+        sync_threadblock();
+
+        // Set head segment_flags.
+        // First tile sets the first flag for the first item
+        BlockDiscontinuityKeys(storage.scan_storage.discontinuity)
+            .FlagHeads(segment_flags, keys, pred_keys, inequality_op);
+
+        // Unset the flag for the first item in the first tile
+        // so we won't scatter it
+        //
+        if (threadIdx.x == 0)
+          segment_flags[0] = 0;
+
+        // Zip values and segment_flags
+        zip_values_and_flags<IS_LAST_TILE>(num_remaining,
+                                           values,
+                                           segment_flags,
+                                           scan_items);
+
+        // Exclusive scan of values and segment_flags
+        size_value_pair_t tile_aggregate;
+        scan_tile(scan_items, tile_aggregate, is_true<HAS_IDENTITY_ZERO>());
+
+        if (threadIdx.x == 0)
+        {
+          // Update tile status if this is not the last tile
+          if (!IS_LAST_TILE)
+            tile_state.SetInclusive(0, tile_aggregate);
+
+          // Initialize the segment index for the first scan item if necessary
+          // (the exclusive prefix for the first item is garbage)
+          if (!HAS_IDENTITY_ZERO)
+            scan_items[0].key = 0;
+        }
+
+        // Unzip values and segment indices
+        zip_keys_and_values(pred_keys,
+                            segment_indices,
+                            scan_items,
+                            scatter_items);
+
+        // Scatter flagged items
+        scatter(scatter_items,
+                segment_flags,
+                segment_indices,
+                tile_aggregate.key,
+                0);
+
+        if (IS_LAST_TILE)
+        {
+          // Finalize the carry-out from the last tile
+          finalize_last_tile(tile_aggregate.key,
+                             num_remaining,
+                             keys[ITEMS_PER_THREAD - 1],
+                             tile_aggregate.value);
+        }
+      }
+
+      // Process subsequent tile of input (dynamic chained scan).
+      // Returns the running count of segments
+      // and aggregated values (including this tile)
+
+      template <bool IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      consume_subsequent_tile(Size           num_remaining,
+                              int            tile_idx,
+                              Size           tile_offset,
+                              ScanTileState &tile_state)
+      {
+        using core::sync_threadblock;
+
+        key_type          keys[ITEMS_PER_THREAD];               // Tile keys
+        key_type          pred_keys[ITEMS_PER_THREAD];          // Tile keys shifted up (predecessor)
+        value_type        values[ITEMS_PER_THREAD];             // Tile values
+        size_type         segment_flags[ITEMS_PER_THREAD];      // Segment head flags
+        size_type         segment_indices[ITEMS_PER_THREAD];    // Segment indices
+        size_value_pair_t scan_items[ITEMS_PER_THREAD];         // Zipped values and segment flags|indices
+        key_value_pair_t  scatter_items[ITEMS_PER_THREAD];      // Zipped key value pairs for scattering
+
+        // Load keys (last tile repeats final element)
+        if (IS_LAST_TILE)
+        {
+          BlockLoadKeys(storage.load_keys)
+              .Load(keys_load_it + tile_offset,
+                    keys,
+                    num_remaining,
+                    *(keys_load_it + tile_offset));
+        }
+        else
+        {
+          BlockLoadKeys(storage.load_keys)
+              .Load(keys_load_it + tile_offset, keys);
+        }
+
+        key_type tile_pred_key = (threadIdx.x == 0)
+                                     ? keys_load_it[tile_offset - 1]
+                                     : key_type();
+
+        sync_threadblock();
+
+        // Load values (last tile repeats final element)
+        if (IS_LAST_TILE)
+        {
+          BlockLoadValues(storage.load_values)
+              .Load(values_load_it + tile_offset,
+                    values,
+                    num_remaining,
+                    *(values_load_it + tile_offset));
+        }
+        else
+        {
+          BlockLoadValues(storage.load_values)
+              .Load(values_load_it + tile_offset, values);
+        }
+
+        sync_threadblock();
+
+        // Set head segment_flags
+        BlockDiscontinuityKeys(storage.scan_storage.discontinuity)
+            .FlagHeads(segment_flags,
+                       keys,
+                       pred_keys,
+                       inequality_op,
+                       tile_pred_key);
+
+        // Zip values and segment_flags
+        zip_values_and_flags<IS_LAST_TILE>(num_remaining,
+                                           values,
+                                           segment_flags,
+                                           scan_items);
+
+        // Exclusive scan of values and segment_flags
+        size_value_pair_t  tile_aggregate;
+        TilePrefixCallback prefix_op(tile_state, storage.scan_storage.prefix, scan_op, tile_idx);
+        scan_tile(scan_items,
+                  tile_aggregate,
+                  prefix_op,
+                  is_true<HAS_IDENTITY_ZERO>());
+        size_value_pair_t tile_inclusive_prefix = prefix_op.GetInclusivePrefix();
+
+        // Unzip values and segment indices
+        zip_keys_and_values(pred_keys, segment_indices, scan_items, scatter_items);
+
+        // Scatter flagged items
+        scatter(scatter_items,
+                segment_flags,
+                segment_indices,
+                tile_aggregate.key,
+                prefix_op.GetExclusivePrefix().key);
+
+        if (IS_LAST_TILE)
+        {
+          // Finalize the carry-out from the last tile
+          finalize_last_tile(tile_inclusive_prefix.key,
+                             num_remaining,
+                             keys[ITEMS_PER_THREAD - 1],
+                             tile_inclusive_prefix.value);
+        }
+      }
+      template <bool IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      consume_tile(size_type      num_remaining,
+                   int            tile_idx,
+                   size_type      tile_offset,
+                   ScanTileState &tile_state)
+      {
+        if (tile_idx == 0)
+        {
+          consume_first_tile<IS_LAST_TILE>(num_remaining,
+                                           tile_offset,
+                                           tile_state);
+        }
+        else
+        {
+          consume_subsequent_tile<IS_LAST_TILE>(num_remaining,
+                                                tile_idx,
+                                                tile_offset,
+                                                tile_state);
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor : consume_range
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION impl(TempStorage &   storage_,
+                                  KeysInputIt     keys_input_it_,
+                                  ValuesInputIt   values_input_it_,
+                                  KeysOutputIt    keys_output_it_,
+                                  ValuesOutputIt  values_output_it_,
+                                  NumRunsOutputIt num_runs_output_it_,
+                                  EqualityOp      equality_op_,
+                                  ReductionOp     reduction_op_,
+                                  Size            num_items,
+                                  int             /*num_tiles*/,
+                                  ScanTileState & tile_state)
+          : storage(storage_),
+            keys_load_it(core::make_load_iterator(ptx_plan(), keys_input_it_)),
+            values_load_it(core::make_load_iterator(ptx_plan(), values_input_it_)),
+            keys_output_it(keys_output_it_),
+            values_output_it(values_output_it_),
+            num_runs_output_it(num_runs_output_it_),
+            inequality_op(equality_op_),
+            scan_op(reduction_op_)
+      {
+        // Blocks are launched in increasing order,
+        // so just assign one tile per block
+        //
+        int  tile_idx          = blockIdx.x;
+        Size tile_offset       = static_cast<Size>(tile_idx) * ITEMS_PER_TILE;
+        Size num_remaining     = num_items - tile_offset;
+
+        if (num_remaining > ITEMS_PER_TILE)
+        {
+          // Not the last tile (full)
+          consume_tile<false>(num_remaining, tile_idx, tile_offset, tile_state);
+        }
+        else if (num_remaining > 0)
+        {
+          // The last tile (possibly partially-full)
+          consume_tile<true>(num_remaining, tile_idx, tile_offset, tile_state);
+        }
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(KeysInputIt     keys_input_it,
+                       ValuesInputIt   values_input_it,
+                       KeysOutputIt    keys_output_it,
+                       ValuesOutputIt  values_output_it,
+                       NumRunsOutputIt num_runs_output_it,
+                       ScanTileState   tile_state,
+                       EqualityOp      equality_op,
+                       ReductionOp     reduction_op,
+                       Size            num_items,
+                       int             num_tiles,
+                       char *          shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage*>(shmem);
+
+      impl(storage,
+           keys_input_it,
+           values_input_it,
+           keys_output_it,
+           values_output_it,
+           num_runs_output_it,
+           equality_op,
+           reduction_op,
+           num_items,
+           num_tiles,
+           tile_state);
+    }
+
+  };    // struct ReduceByKeyAgent
+
+  template <class ScanTileState,
+            class Size,
+            class NumSelectedIt>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       NumSelectedIt num_selected_out,
+                       char *        /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+      if (blockIdx.x == 0 && threadIdx.x == 0)
+        *num_selected_out = 0;
+    }
+  }; // struct InitAgent
+
+  template <class KeysInputIt,
+            class ValuesInputIt,
+            class KeysOutputIt,
+            class ValuesOutputIt,
+            class NumRunsOutputIt,
+            class EqualityOp,
+            class ReductionOp,
+            class Size>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  doit_step(void *          d_temp_storage,
+            size_t &        temp_storage_bytes,
+            KeysInputIt     keys_input_it,
+            ValuesInputIt   values_input_it,
+            KeysOutputIt    keys_output_it,
+            ValuesOutputIt  values_output_it,
+            NumRunsOutputIt num_runs_output_it,
+            EqualityOp      equality_op,
+            ReductionOp     reduction_op,
+            Size            num_items,
+            cudaStream_t    stream)
+  {
+    using core::AgentPlan;
+    using core::AgentLauncher;
+
+    cudaError_t status = cudaSuccess;
+    if (num_items == 0)
+      return cudaErrorNotSupported;
+
+    typedef AgentLauncher<
+        ReduceByKeyAgent<KeysInputIt,
+                         ValuesInputIt,
+                         KeysOutputIt,
+                         ValuesOutputIt,
+                         EqualityOp,
+                         ReductionOp,
+                         NumRunsOutputIt,
+                         Size> >
+        reduce_by_key_agent;
+
+    typedef typename reduce_by_key_agent::ScanTileState ScanTileState;
+    typedef AgentLauncher<
+        InitAgent<ScanTileState,
+                  Size,
+                  NumRunsOutputIt> >
+        init_agent;
+
+    AgentPlan reduce_by_key_plan = reduce_by_key_agent::get_plan(stream);
+    AgentPlan init_plan          = init_agent::get_plan();
+
+    // Number of input tiles
+    int  tile_size = reduce_by_key_plan.items_per_tile;
+    Size num_tiles = cub::DivideAndRoundUp(num_items, tile_size);
+
+    size_t vshmem_size = core::vshmem_size(reduce_by_key_plan.shared_memory_size,
+                                           num_tiles);
+
+    size_t allocation_sizes[2] = {9, vshmem_size};
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles), allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    void *allocations[2] = {NULL, NULL};
+    status = cub::AliasTemporaries(d_temp_storage,
+                                   temp_storage_bytes,
+                                   allocations,
+                                   allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_state;
+    status = tile_state.Init(static_cast<int>(num_tiles), allocations[0], allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    init_agent ia(init_plan, num_tiles, stream, "reduce_by_key::init_agent");
+    ia.launch(tile_state, num_tiles, num_runs_output_it);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    char *vshmem_ptr = vshmem_size > 0 ? (char *)allocations[1] : NULL;
+
+    reduce_by_key_agent rbka(reduce_by_key_plan,
+                             num_items,
+                             stream,
+                             vshmem_ptr,
+                             "reduce_by_keys::reduce_by_key_agent");
+    rbka.launch(keys_input_it,
+                values_input_it,
+                keys_output_it,
+                values_output_it,
+                num_runs_output_it,
+                tile_state,
+                equality_op,
+                reduction_op,
+                num_items,
+                num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    return status;
+  }
+
+  template <typename Size,
+            typename Derived,
+            typename KeysInputIt,
+            typename ValuesInputIt,
+            typename KeysOutputIt,
+            typename ValuesOutputIt,
+            typename EqualityOp,
+            typename ReductionOp>
+  THRUST_RUNTIME_FUNCTION
+  pair<KeysOutputIt, ValuesOutputIt>
+  reduce_by_key_dispatch(execution_policy<Derived>& policy,
+                         KeysInputIt                keys_first,
+                         Size                       num_items,
+                         ValuesInputIt              values_first,
+                         KeysOutputIt               keys_output,
+                         ValuesOutputIt             values_output,
+                         EqualityOp                 equality_op,
+                         ReductionOp                reduction_op)
+  {
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    if (num_items == 0)
+    {
+      return thrust::make_pair(keys_output, values_output);
+    }
+
+    cudaError_t status;
+    status = doit_step(NULL,
+                       temp_storage_bytes,
+                       keys_first,
+                       values_first,
+                       keys_output,
+                       values_output,
+                       reinterpret_cast<Size*>(NULL),
+                       equality_op,
+                       reduction_op,
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "reduce_by_key failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(Size), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "reduce failed on 1st alias_storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "reduce failed on 2nd alias_storage");
+
+    Size* d_num_runs_out
+      = thrust::detail::aligned_reinterpret_cast<Size*>(allocations[0]);
+
+    status = doit_step(allocations[1],
+                       temp_storage_bytes,
+                       keys_first,
+                       values_first,
+                       keys_output,
+                       values_output,
+                       d_num_runs_out,
+                       equality_op,
+                       reduction_op,
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "reduce_by_key failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "reduce_by_key: failed to synchronize");
+
+    int num_runs_out = cuda_cub::get_value(policy, d_num_runs_out);
+
+    return thrust::make_pair(
+      keys_output + num_runs_out,
+      values_output + num_runs_out
+    );
+  }
+
+  template <typename Derived,
+            typename KeysInputIt,
+            typename ValuesInputIt,
+            typename KeysOutputIt,
+            typename ValuesOutputIt,
+            typename EqualityOp,
+            typename ReductionOp>
+  THRUST_RUNTIME_FUNCTION
+  pair<KeysOutputIt, ValuesOutputIt>
+  reduce_by_key(execution_policy<Derived>& policy,
+                KeysInputIt                keys_first,
+                KeysInputIt                keys_last,
+                ValuesInputIt              values_first,
+                KeysOutputIt               keys_output,
+                ValuesOutputIt             values_output,
+                EqualityOp                 equality_op,
+                ReductionOp                reduction_op)
+  {
+    using size_type = typename iterator_traits<KeysInputIt>::difference_type;
+
+    size_type num_items = thrust::distance(keys_first, keys_last);
+
+    pair<KeysOutputIt, ValuesOutputIt> result = thrust::make_pair(keys_output, values_output);
+
+    if (num_items == 0)
+    {
+      return result;
+    }
+
+    THRUST_INDEX_TYPE_DISPATCH(result,
+                               reduce_by_key_dispatch,
+                               num_items,
+                               (policy,
+                                keys_first,
+                                num_items_fixed,
+                                values_first,
+                                keys_output,
+                                values_output,
+                                equality_op,
+                                reduction_op));
+
+    return result;
+  }
+
+}    // namespace __reduce_by_key
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt,
+          class BinaryPred,
+          class BinaryOp>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+reduce_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first,
+              KeyOutputIt                keys_output,
+              ValOutputIt                values_output,
+              BinaryPred                 binary_pred,
+              BinaryOp                   binary_op)
+{
+  auto ret = thrust::make_pair(keys_output, values_output);
+  THRUST_CDP_DISPATCH((ret = __reduce_by_key::reduce_by_key(policy,
+                                                            keys_first,
+                                                            keys_last,
+                                                            values_first,
+                                                            keys_output,
+                                                            values_output,
+                                                            binary_pred,
+                                                            binary_op);),
+                      (ret =
+                         thrust::reduce_by_key(cvt_to_seq(derived_cast(policy)),
+                                               keys_first,
+                                               keys_last,
+                                               values_first,
+                                               keys_output,
+                                               values_output,
+                                               binary_pred,
+                                               binary_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt,
+          class BinaryPred>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+reduce_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first,
+              KeyOutputIt                keys_output,
+              ValOutputIt                values_output,
+              BinaryPred                 binary_pred)
+{
+  typedef typename thrust::detail::eval_if<
+    thrust::detail::is_output_iterator<ValOutputIt>::value,
+    thrust::iterator_value<ValInputIt>,
+    thrust::iterator_value<ValOutputIt>
+  >::type value_type;
+  return cuda_cub::reduce_by_key(policy,
+                              keys_first,
+                              keys_last,
+                              values_first,
+                              keys_output,
+                              values_output,
+                              binary_pred,
+                              plus<value_type>());
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+reduce_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first,
+              KeyOutputIt                keys_output,
+              ValOutputIt                values_output)
+{
+  typedef typename thrust::iterator_value<KeyInputIt>::type KeyT;
+  return cuda_cub::reduce_by_key(policy,
+                              keys_first,
+                              keys_last,
+                              values_first,
+                              keys_output,
+                              values_output,
+                              equal_to<KeyT>());
+}
+
+} // namespace cuda_
+
+THRUST_NAMESPACE_END
+
+#include <thrust/memory.h>
+#include <thrust/reduce.h>
+
+#endif

miniCUDA124/include/thrust/system/cuda/detail/remove.h

@@ -0,0 +1,142 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/copy_if.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+// in-place
+
+template <class Derived,
+          class InputIt,
+          class StencilIt,
+          class Predicate>
+InputIt __host__ __device__
+remove_if(execution_policy<Derived> &policy,
+          InputIt                    first,
+          InputIt                    last,
+          StencilIt                  stencil,
+          Predicate                  predicate)
+{
+  return cuda_cub::copy_if(policy, first, last, stencil, first,
+    thrust::detail::not1(predicate));
+}
+
+template <class Derived,
+          class InputIt,
+          class Predicate>
+InputIt __host__ __device__
+remove_if(execution_policy<Derived> &policy,
+          InputIt                    first,
+          InputIt                    last,
+          Predicate                  predicate)
+{
+  return cuda_cub::copy_if(policy, first, last, first,
+    thrust::detail::not1(predicate));
+}
+
+
+template <class Derived,
+          class InputIt,
+          class T>
+InputIt __host__ __device__
+remove(execution_policy<Derived> &policy,
+       InputIt                    first,
+       InputIt                    last,
+       const T &                  value)
+{
+  using thrust::placeholders::_1;
+
+  return cuda_cub::remove_if(policy, first, last, _1 == value);
+}
+
+// copy
+
+template <class Derived,
+          class InputIt,
+          class StencilIt,
+          class OutputIt,
+          class Predicate>
+OutputIt __host__ __device__
+remove_copy_if(execution_policy<Derived> &policy,
+               InputIt                    first,
+               InputIt                    last,
+               StencilIt                  stencil,
+               OutputIt                   result,
+               Predicate                  predicate)
+{
+  return cuda_cub::copy_if(policy, first, last, stencil, result,
+    thrust::detail::not1(predicate));
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class Predicate>
+OutputIt __host__ __device__
+remove_copy_if(execution_policy<Derived> &policy,
+               InputIt                    first,
+               InputIt                    last,
+               OutputIt                   result,
+               Predicate                  predicate)
+{
+  return cuda_cub::copy_if(policy, first, last, result,
+    thrust::detail::not1(predicate));
+}
+
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class T>
+OutputIt __host__ __device__
+remove_copy(execution_policy<Derived> &policy,
+            InputIt                    first,
+            InputIt                    last,
+            OutputIt                   result,
+            const T &                  value)
+{
+  thrust::detail::equal_to_value<T> pred(value);
+  return cuda_cub::remove_copy_if(policy, first, last, result, pred);
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/replace.h

@@ -0,0 +1,221 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/detail/internal_functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+  namespace __replace
+  {
+    template<class T>
+    struct constant_f
+    {
+      T value;
+
+      THRUST_FUNCTION
+      constant_f(T const &x) : value(x) {}
+
+      template<class U>
+      THRUST_DEVICE_FUNCTION
+      T operator()(U const &)  const
+      {
+        return value;
+      }
+    }; // struct constant_f
+
+    template<class Predicate, class NewType, class OutputType>
+    struct new_value_if_f
+    {
+      Predicate pred;
+      NewType new_value;
+
+      THRUST_FUNCTION
+      new_value_if_f(Predicate pred_, NewType new_value_)
+          : pred(pred_), new_value(new_value_) {}
+
+      template<class T>
+      OutputType THRUST_DEVICE_FUNCTION
+      operator()(T const &x)
+      {
+        return pred(x) ? new_value : x;
+      }
+
+      template<class T, class P>
+      OutputType THRUST_DEVICE_FUNCTION
+      operator()(T const &x, P const& y)
+      {
+        return pred(y) ? new_value : x;
+      }
+    }; // struct new_value_if_f
+
+  } // namespace __replace
+
+template <class Derived,
+          class Iterator,
+          class T>
+void __host__ __device__
+replace(execution_policy<Derived> &policy,
+        Iterator                   first,
+        Iterator                   last,
+        T const &                  old_value,
+        T const &                  new_value)
+{
+  using thrust::placeholders::_1;
+
+  cuda_cub::transform_if(policy,
+                      first,
+                      last,
+                      first,
+                      __replace::constant_f<T>(new_value),
+                      _1 == old_value);
+}
+
+template <class Derived,
+          class Iterator,
+          class Predicate,
+          class T>
+void __host__ __device__
+replace_if(execution_policy<Derived> &policy,
+           Iterator                   first,
+           Iterator                   last,
+           Predicate                  pred,
+           T const &                  new_value)
+{
+  cuda_cub::transform_if(policy,
+                      first,
+                      last,
+                      first,
+                      __replace::constant_f<T>(new_value),
+                      pred);
+}
+
+template <class Derived,
+          class Iterator,
+          class StencilIt,
+          class Predicate,
+          class T>
+void __host__ __device__
+replace_if(execution_policy<Derived> &policy,
+           Iterator                   first,
+           Iterator                   last,
+           StencilIt                  stencil,
+           Predicate                  pred,
+           T const &                  new_value)
+{
+  cuda_cub::transform_if(policy,
+                      first,
+                      last,
+                      stencil,
+                      first,
+                      __replace::constant_f<T>(new_value),
+                      pred);
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class Predicate,
+          class T>
+OutputIt __host__ __device__
+replace_copy_if(execution_policy<Derived> &policy,
+                InputIt                    first,
+                InputIt                    last,
+                OutputIt                   result,
+                Predicate                  predicate,
+                T const &                  new_value)
+{
+  typedef typename iterator_traits<OutputIt>::value_type output_type;
+  typedef __replace::new_value_if_f<Predicate, T, output_type> new_value_if_t;
+  return cuda_cub::transform(policy,
+                             first,
+                             last,
+                             result,
+                             new_value_if_t(predicate, new_value));
+}
+
+template <class Derived,
+          class InputIt,
+          class StencilIt,
+          class OutputIt,
+          class Predicate,
+          class T>
+OutputIt __host__ __device__
+replace_copy_if(execution_policy<Derived> &policy,
+                InputIt                    first,
+                InputIt                    last,
+                StencilIt                  stencil,
+                OutputIt                   result,
+                Predicate                  predicate,
+                T const &                  new_value)
+{
+  typedef typename iterator_traits<OutputIt>::value_type output_type;
+  typedef __replace::new_value_if_f<Predicate, T, output_type> new_value_if_t;
+  return cuda_cub::transform(policy,
+                           first,
+                           last,
+                           stencil,
+                           result,
+                           new_value_if_t(predicate, new_value));
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class T>
+OutputIt __host__ __device__
+replace_copy(execution_policy<Derived> &policy,
+             InputIt                    first,
+             InputIt                    last,
+             OutputIt                   result,
+             T const &                  old_value,
+             T const &                  new_value)
+{
+  return cuda_cub::replace_copy_if(policy,
+                                   first,
+                                   last,
+                                   result,
+                                   thrust::detail::equal_to_value<T>(old_value),
+                                   new_value);
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/reverse.h

@@ -0,0 +1,105 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived, class ItemsIt, class ResultIt>
+ResultIt __host__ __device__
+reverse_copy(execution_policy<Derived> &policy,
+             ItemsIt                    first,
+             ItemsIt                    last,
+             ResultIt                   result);
+
+template <class Derived, class ItemsIt>
+void __host__ __device__
+reverse(execution_policy<Derived> &policy,
+        ItemsIt                    first,
+        ItemsIt                    last);
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/advance.h>
+#include <thrust/distance.h>
+#include <thrust/system/cuda/detail/swap_ranges.h>
+#include <thrust/system/cuda/detail/copy.h>
+#include <thrust/iterator/reverse_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class ItemsIt,
+          class ResultIt>
+ResultIt __host__ __device__
+reverse_copy(execution_policy<Derived> &policy,
+             ItemsIt                    first,
+             ItemsIt                    last,
+             ResultIt                   result)
+{
+  return cuda_cub::copy(policy,
+                        thrust::make_reverse_iterator(last),
+                        thrust::make_reverse_iterator(first),
+                        result);
+}
+
+template <class Derived,
+          class ItemsIt>
+void __host__ __device__
+reverse(execution_policy<Derived> &policy,
+        ItemsIt                    first,
+        ItemsIt                    last)
+{
+  typedef typename thrust::iterator_difference<ItemsIt>::type difference_type;
+
+  // find the midpoint of [first,last)
+  difference_type N = thrust::distance(first, last);
+  ItemsIt mid(first);
+  thrust::advance(mid, N / 2);
+
+  cuda_cub::swap_ranges(policy, first, mid, thrust::make_reverse_iterator(last));
+}
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/scan.h

@@ -0,0 +1,363 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/distance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/dispatch.h>
+
+#include <cub/device/device_scan.cuh>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub
+{
+namespace detail
+{
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          typename ScanOp>
+__host__ __device__
+OutputIt inclusive_scan_n_impl(thrust::cuda_cub::execution_policy<Derived> &policy,
+                               InputIt first,
+                               Size num_items,
+                               OutputIt result,
+                               ScanOp scan_op)
+{
+  using AccumT = typename thrust::iterator_traits<InputIt>::value_type;
+  using Dispatch32 = cub::DispatchScan<InputIt,
+                                       OutputIt,
+                                       ScanOp,
+                                       cub::NullType,
+                                       thrust::detail::int32_t,
+                                       AccumT>;
+  using Dispatch64 = cub::DispatchScan<InputIt,
+                                       OutputIt,
+                                       ScanOp,
+                                       cub::NullType,
+                                       thrust::detail::int64_t,
+                                       AccumT>;
+
+  cudaStream_t stream = thrust::cuda_cub::stream(policy);
+  cudaError_t status;
+
+  // Determine temporary storage requirements:
+  size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (nullptr,
+                                 tmp_size,
+                                 first,
+                                 result,
+                                 scan_op,
+                                 cub::NullType{},
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for inclusive_scan");
+  }
+
+  // Run scan:
+  {
+    // Allocate temporary storage:
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived> tmp{
+      policy,
+      tmp_size};
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (tmp.data().get(),
+                                 tmp_size,
+                                 first,
+                                 result,
+                                 scan_op,
+                                 cub::NullType{},
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after dispatching inclusive_scan kernel");
+    thrust::cuda_cub::throw_on_error(thrust::cuda_cub::synchronize_optional(policy),
+                                     "inclusive_scan failed to synchronize");
+  }
+
+  return result + num_items;
+}
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          typename InitValueT,
+          typename ScanOp>
+__host__ __device__
+OutputIt exclusive_scan_n_impl(thrust::cuda_cub::execution_policy<Derived> &policy,
+                               InputIt first,
+                               Size num_items,
+                               OutputIt result,
+                               InitValueT init,
+                               ScanOp scan_op)
+{
+  using InputValueT = cub::detail::InputValue<InitValueT>;
+  using Dispatch32 = cub::DispatchScan<InputIt,
+                                       OutputIt,
+                                       ScanOp,
+                                       InputValueT,
+                                       thrust::detail::int32_t,
+                                       InitValueT>;
+  using Dispatch64 = cub::DispatchScan<InputIt,
+                                       OutputIt,
+                                       ScanOp,
+                                       InputValueT,
+                                       thrust::detail::int64_t,
+                                       InitValueT>;
+
+  cudaStream_t stream = thrust::cuda_cub::stream(policy);
+  cudaError_t status;
+
+  // Determine temporary storage requirements:
+  size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (nullptr,
+                                 tmp_size,
+                                 first,
+                                 result,
+                                 scan_op,
+                                 InputValueT(init),
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for exclusive_scan");
+  }
+
+  // Run scan:
+  {
+    // Allocate temporary storage:
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived> tmp{
+      policy,
+      tmp_size};
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (tmp.data().get(),
+                                 tmp_size,
+                                 first,
+                                 result,
+                                 scan_op,
+                                 InputValueT(init),
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after dispatching exclusive_scan kernel");
+    thrust::cuda_cub::throw_on_error(thrust::cuda_cub::synchronize_optional(policy),
+                                     "exclusive_scan failed to synchronize");
+  }
+
+  return result + num_items;
+}
+
+} // namespace detail
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          typename ScanOp>
+__host__ __device__
+OutputIt inclusive_scan_n(thrust::cuda_cub::execution_policy<Derived> &policy,
+                          InputIt first,
+                          Size num_items,
+                          OutputIt result,
+                          ScanOp scan_op)
+{
+  THRUST_CDP_DISPATCH(
+    (result = thrust::cuda_cub::detail::inclusive_scan_n_impl(policy,
+                                                              first,
+                                                              num_items,
+                                                              result,
+                                                              scan_op);),
+    (result = thrust::inclusive_scan(cvt_to_seq(derived_cast(policy)),
+                                     first,
+                                     first + num_items,
+                                     result,
+                                     scan_op);));
+  return result;
+}
+
+template <typename Derived, typename InputIt, typename OutputIt, typename ScanOp>
+__host__ __device__
+OutputIt inclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result,
+                        ScanOp scan_op)
+{
+  using diff_t = typename thrust::iterator_traits<InputIt>::difference_type;
+  diff_t const num_items = thrust::distance(first, last);
+  return thrust::cuda_cub::inclusive_scan_n(policy,
+                                            first,
+                                            num_items,
+                                            result,
+                                            scan_op);
+}
+
+template <typename Derived, typename InputIt, typename OutputIt>
+__host__ __device__
+OutputIt inclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result)
+{
+  return thrust::cuda_cub::inclusive_scan(policy,
+                                          first,
+                                          last,
+                                          result,
+                                          thrust::plus<>{});
+}
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          typename T,
+          typename ScanOp>
+__host__ __device__
+OutputIt exclusive_scan_n(thrust::cuda_cub::execution_policy<Derived> &policy,
+                          InputIt first,
+                          Size num_items,
+                          OutputIt result,
+                          T init,
+                          ScanOp scan_op)
+{
+  THRUST_CDP_DISPATCH(
+    (result = thrust::cuda_cub::detail::exclusive_scan_n_impl(policy,
+                                                              first,
+                                                              num_items,
+                                                              result,
+                                                              init,
+                                                              scan_op);),
+    (result = thrust::exclusive_scan(cvt_to_seq(derived_cast(policy)),
+                                     first,
+                                     first + num_items,
+                                     result,
+                                     init,
+                                     scan_op);));
+  return result;
+}
+
+template <typename Derived,
+          typename InputIt,
+          typename OutputIt,
+          typename T,
+          typename ScanOp>
+__host__ __device__
+OutputIt exclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result,
+                        T init,
+                        ScanOp scan_op)
+{
+  using diff_t = typename thrust::iterator_traits<InputIt>::difference_type;
+  diff_t const num_items = thrust::distance(first, last);
+  return thrust::cuda_cub::exclusive_scan_n(policy,
+                                            first,
+                                            num_items,
+                                            result,
+                                            init,
+                                            scan_op);
+}
+
+template <typename Derived, typename InputIt, typename OutputIt, typename T>
+__host__ __device__
+OutputIt exclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result,
+                        T init)
+{
+  return thrust::cuda_cub::exclusive_scan(policy,
+                                          first,
+                                          last,
+                                          result,
+                                          init,
+                                          thrust::plus<>{});
+}
+
+template <typename Derived, typename InputIt, typename OutputIt>
+__host__ __device__
+OutputIt exclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result)
+{
+  using init_type = typename thrust::iterator_traits<InputIt>::value_type;
+  return cuda_cub::exclusive_scan(policy, first, last, result, init_type{});
+};
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/scan.h>
+
+#endif // NVCC

miniCUDA124/include/thrust/system/cuda/detail/scan_by_key.h

@@ -0,0 +1,500 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+#include <thrust/iterator/iterator_traits.h>
+
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/detail/mpl/math.h>
+#include <thrust/detail/temporary_array.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/dispatch.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/dispatch/dispatch_scan_by_key.cuh>
+#include <cub/util_type.cuh>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub
+{
+namespace detail
+{
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename KeysInIt,
+          typename ValuesInIt,
+          typename ValuesOutIt,
+          typename EqualityOpT,
+          typename ScanOpT,
+          typename SizeT>
+__host__ __device__
+ValuesOutIt inclusive_scan_by_key_n(
+  thrust::cuda_cub::execution_policy<Derived>& policy,
+  KeysInIt keys,
+  ValuesInIt values,
+  ValuesOutIt result,
+  SizeT num_items,
+  EqualityOpT equality_op,
+  ScanOpT scan_op)
+{
+  if (num_items == 0)
+  {
+    return result;
+  }
+
+  // Convert to raw pointers if possible:
+  using KeysInUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<KeysInIt>;
+  using ValuesInUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<ValuesInIt>;
+  using ValuesOutUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<ValuesOutIt>;
+  using AccumT = typename thrust::iterator_traits<ValuesInUnwrapIt>::value_type;
+
+  auto keys_unwrap = thrust::detail::try_unwrap_contiguous_iterator(keys);
+  auto values_unwrap = thrust::detail::try_unwrap_contiguous_iterator(values);
+  auto result_unwrap = thrust::detail::try_unwrap_contiguous_iterator(result);
+
+  using Dispatch32 = cub::DispatchScanByKey<KeysInUnwrapIt,
+                                            ValuesInUnwrapIt,
+                                            ValuesOutUnwrapIt,
+                                            EqualityOpT,
+                                            ScanOpT,
+                                            cub::NullType,
+                                            thrust::detail::int32_t,
+                                            AccumT>;
+  using Dispatch64 = cub::DispatchScanByKey<KeysInUnwrapIt,
+                                            ValuesInUnwrapIt,
+                                            ValuesOutUnwrapIt,
+                                            EqualityOpT,
+                                            ScanOpT,
+                                            cub::NullType,
+                                            thrust::detail::int64_t,
+                                            AccumT>;
+
+  cudaStream_t stream = thrust::cuda_cub::stream(policy);
+  cudaError_t status{};
+
+  // Determine temporary storage requirements:
+  std::size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (nullptr,
+                                 tmp_size,
+                                 keys_unwrap,
+                                 values_unwrap,
+                                 result_unwrap,
+                                 equality_op,
+                                 scan_op,
+                                 cub::NullType{},
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for inclusive_scan_by_key");
+  }
+
+  // Run scan:
+  {
+    // Allocate temporary storage:
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived> tmp{
+      policy,
+      tmp_size};
+
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (tmp.data().get(),
+                                 tmp_size,
+                                 keys_unwrap,
+                                 values_unwrap,
+                                 result_unwrap,
+                                 equality_op,
+                                 scan_op,
+                                 cub::NullType{},
+                                 num_items_fixed,
+                                 stream));
+
+    thrust::cuda_cub::throw_on_error(
+      status, "after dispatching inclusive_scan_by_key kernel");
+
+    thrust::cuda_cub::throw_on_error(
+      thrust::cuda_cub::synchronize_optional(policy),
+      "inclusive_scan_by_key failed to synchronize");
+  }
+
+  return result + num_items;
+}
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename KeysInIt,
+          typename ValuesInIt,
+          typename ValuesOutIt,
+          typename InitValueT,
+          typename EqualityOpT,
+          typename ScanOpT,
+          typename SizeT>
+__host__ __device__
+ValuesOutIt exclusive_scan_by_key_n(
+  thrust::cuda_cub::execution_policy<Derived>& policy,
+  KeysInIt keys,
+  ValuesInIt values,
+  ValuesOutIt result,
+  SizeT num_items,
+  InitValueT init_value,
+  EqualityOpT equality_op,
+  ScanOpT scan_op)
+{
+
+  if (num_items == 0)
+  {
+    return result;
+  }
+
+  // Convert to raw pointers if possible:
+  using KeysInUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<KeysInIt>;
+  using ValuesInUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<ValuesInIt>;
+  using ValuesOutUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<ValuesOutIt>;
+
+  auto keys_unwrap = thrust::detail::try_unwrap_contiguous_iterator(keys);
+  auto values_unwrap = thrust::detail::try_unwrap_contiguous_iterator(values);
+  auto result_unwrap = thrust::detail::try_unwrap_contiguous_iterator(result);
+
+  using Dispatch32 = cub::DispatchScanByKey<KeysInUnwrapIt,
+                                            ValuesInUnwrapIt,
+                                            ValuesOutUnwrapIt,
+                                            EqualityOpT,
+                                            ScanOpT,
+                                            InitValueT,
+                                            thrust::detail::int32_t,
+                                            InitValueT>;
+  using Dispatch64 = cub::DispatchScanByKey<KeysInUnwrapIt,
+                                            ValuesInUnwrapIt,
+                                            ValuesOutUnwrapIt,
+                                            EqualityOpT,
+                                            ScanOpT,
+                                            InitValueT,
+                                            thrust::detail::int64_t,
+                                            InitValueT>;
+
+  cudaStream_t stream = thrust::cuda_cub::stream(policy);
+  cudaError_t status{};
+
+  // Determine temporary storage requirements:
+  std::size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (nullptr,
+                                 tmp_size,
+                                 keys_unwrap,
+                                 values_unwrap,
+                                 result_unwrap,
+                                 equality_op,
+                                 scan_op,
+                                 init_value,
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for exclusive_scan_by_key");
+  }
+
+  // Run scan:
+  {
+    // Allocate temporary storage:
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived> tmp{
+      policy,
+      tmp_size};
+
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (tmp.data().get(),
+                                 tmp_size,
+                                 keys_unwrap,
+                                 values_unwrap,
+                                 result_unwrap,
+                                 equality_op,
+                                 scan_op,
+                                 init_value,
+                                 num_items_fixed,
+                                 stream));
+
+    thrust::cuda_cub::throw_on_error(
+      status, "after dispatching exclusive_scan_by_key kernel");
+
+    thrust::cuda_cub::throw_on_error(
+      thrust::cuda_cub::synchronize_optional(policy),
+      "exclusive_scan_by_key failed to synchronize");
+  }
+
+  return result + num_items;
+}
+
+
+} // namespace detail
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+//---------------------------
+//   Inclusive scan
+//---------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class BinaryPred,
+          class ScanOp>
+ValOutputIt __host__ __device__
+inclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      BinaryPred                 binary_pred,
+                      ScanOp                     scan_op)
+{
+  ValOutputIt ret = value_result;
+  THRUST_CDP_DISPATCH(
+    (ret = thrust::cuda_cub::detail::inclusive_scan_by_key_n(
+       policy,
+       key_first,
+       value_first,
+       value_result,
+       thrust::distance(key_first, key_last),
+       binary_pred,
+       scan_op);),
+    (ret = thrust::inclusive_scan_by_key(cvt_to_seq(derived_cast(policy)),
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         binary_pred,
+                                         scan_op);));
+
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class BinaryPred>
+ValOutputIt __host__ __device__
+inclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      BinaryPred                 binary_pred)
+{
+  return cuda_cub::inclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         binary_pred,
+                                         thrust::plus<>());
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt>
+ValOutputIt __host__ __device__
+inclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result)
+{
+  return cuda_cub::inclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         thrust::equal_to<>());
+}
+
+
+//---------------------------
+//   Exclusive scan
+//---------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class Init,
+          class BinaryPred,
+          class ScanOp>
+ValOutputIt __host__ __device__
+exclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      Init                       init,
+                      BinaryPred                 binary_pred,
+                      ScanOp                     scan_op)
+{
+  ValOutputIt ret = value_result;
+  THRUST_CDP_DISPATCH(
+    (ret = thrust::cuda_cub::detail::exclusive_scan_by_key_n(
+       policy,
+       key_first,
+       value_first,
+       value_result,
+       thrust::distance(key_first, key_last),
+       init,
+       binary_pred,
+       scan_op);),
+    (ret = thrust::exclusive_scan_by_key(cvt_to_seq(derived_cast(policy)),
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         init,
+                                         binary_pred,
+                                         scan_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class Init,
+          class BinaryPred>
+ValOutputIt __host__ __device__
+exclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      Init                       init,
+                      BinaryPred                 binary_pred)
+{
+  return cuda_cub::exclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         init,
+                                         binary_pred,
+                                         thrust::plus<>());
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class Init>
+ValOutputIt __host__ __device__
+exclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      Init                       init)
+{
+  return cuda_cub::exclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         init,
+                                         thrust::equal_to<>());
+}
+
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt>
+ValOutputIt __host__ __device__
+exclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result)
+{
+  using value_type = typename thrust::iterator_traits<ValInputIt>::value_type;
+  return cuda_cub::exclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         value_type{});
+}
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/scan.h>
+
+#endif // NVCC

miniCUDA124/include/thrust/system/cuda/detail/scatter.h

@@ -0,0 +1,114 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/iterator/permutation_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class ItemsIt,
+          class MapIt,
+          class ResultIt>
+void __host__ __device__
+scatter(execution_policy<Derived>& policy,
+        ItemsIt                    first,
+        ItemsIt                    last,
+        MapIt                      map,
+        ResultIt                   result)
+{
+  cuda_cub::transform(policy,
+                   first,
+                   last,
+                   thrust::make_permutation_iterator(result, map),
+                   identity());
+}
+
+template <class Derived,
+          class ItemsIt,
+          class MapIt,
+          class StencilIt,
+          class ResultIt,
+          class Predicate>
+void __host__ __device__
+scatter_if(execution_policy<Derived>& policy,
+           ItemsIt                    first,
+           ItemsIt                    last,
+           MapIt                      map,
+           StencilIt                  stencil,
+           ResultIt                   result,
+           Predicate                  predicate)
+{
+  cuda_cub::transform_if(policy,
+                      first,
+                      last,
+                      stencil,
+                      thrust::make_permutation_iterator(result, map),
+                      identity(),
+                      predicate);
+}
+
+template <class Derived,
+          class ItemsIt,
+          class MapIt,
+          class StencilIt,
+          class ResultIt,
+          class Predicate>
+void __host__ __device__
+scatter_if(execution_policy<Derived>& policy,
+           ItemsIt                    first,
+           ItemsIt                    last,
+           MapIt                      map,
+           StencilIt                  stencil,
+           ResultIt                   result)
+{
+  cuda_cub::scatter_if(policy,
+                    first,
+                    last,
+                    map,
+                    stencil,
+                    result,
+                    identity());
+}
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/sequence.h

@@ -0,0 +1,30 @@
+/*
+ *  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
+
+// this system has no special version of this algorithm
+

miniCUDA124/include/thrust/system/cuda/detail/set_operations.h

@@ -0,0 +1,1947 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/mpl/math.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/distance.h>
+#include <thrust/extrema.h>
+#include <thrust/pair.h>
+#include <thrust/set_operations.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+namespace __set_operations {
+
+  template <bool UpperBound,
+            class IntT,
+            class Size,
+            class It,
+            class T,
+            class Comp>
+  THRUST_DEVICE_FUNCTION void
+  binary_search_iteration(It   data,
+                          Size &begin,
+                          Size &end,
+                          T    key,
+                          int  shift,
+                          Comp comp)
+  {
+
+    IntT scale = (1 << shift) - 1;
+    Size mid   = (begin + scale * end) >> shift;
+
+    T    key2 = data[mid];
+    bool pred = UpperBound ? !comp(key, key2) : comp(key2, key);
+    if (pred)
+      begin = mid + 1;
+    else
+      end = mid;
+  }
+
+  template <bool UpperBound, class Size, class T, class It, class Comp>
+  THRUST_DEVICE_FUNCTION Size
+  binary_search(It data, Size count, T key, Comp comp)
+  {
+    Size begin = 0;
+    Size end   = count;
+    while (begin < end)
+      binary_search_iteration<UpperBound, int>(data,
+                                               begin,
+                                               end,
+                                               key,
+                                               1,
+                                               comp);
+    return begin;
+  }
+
+  template <bool UpperBound, class IntT, class Size, class T, class It, class Comp>
+  THRUST_DEVICE_FUNCTION Size
+  biased_binary_search(It data, Size count, T key, IntT levels, Comp comp)
+  {
+    Size begin = 0;
+    Size end   = count;
+
+    if (levels >= 4 && begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 9, comp);
+    if (levels >= 3 && begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 7, comp);
+    if (levels >= 2 && begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 5, comp);
+    if (levels >= 1 && begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 4, comp);
+
+    while (begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 1, comp);
+    return begin;
+  }
+
+  template <bool UpperBound, class Size, class It1, class It2, class Comp>
+  THRUST_DEVICE_FUNCTION Size
+  merge_path(It1 a, Size aCount, It2 b, Size bCount, Size diag, Comp comp)
+  {
+    typedef typename thrust::iterator_traits<It1>::value_type T;
+
+    Size begin = thrust::max<Size>(0, diag - bCount);
+    Size end   = thrust::min<Size>(diag, aCount);
+
+    while (begin < end)
+    {
+      Size  mid  = (begin + end) >> 1;
+      T    aKey = a[mid];
+      T    bKey = b[diag - 1 - mid];
+      bool pred = UpperBound ? comp(aKey, bKey) : !comp(bKey, aKey);
+      if (pred)
+        begin = mid + 1;
+      else
+        end = mid;
+    }
+    return begin;
+  }
+
+  template <class It1, class It2, class Size, class Size2, class CompareOp>
+  THRUST_DEVICE_FUNCTION pair<Size, Size>
+  balanced_path(It1       keys1,
+                It2       keys2,
+                Size      num_keys1,
+                Size      num_keys2,
+                Size      diag,
+                Size2     levels,
+                CompareOp compare_op)
+  {
+    typedef typename iterator_traits<It1>::value_type T;
+
+    Size index1 = merge_path<false>(keys1,
+                                    num_keys1,
+                                    keys2,
+                                    num_keys2,
+                                    diag,
+                                    compare_op);
+    Size index2 = diag - index1;
+
+    bool star = false;
+    if (index2 < num_keys2)
+    {
+      T x = keys2[index2];
+
+      // Search for the beginning of the duplicate run in both A and B.
+      Size start1 = biased_binary_search<false>(keys1,
+                                                index1,
+                                                x,
+                                                levels,
+                                                compare_op);
+      Size start2 = biased_binary_search<false>(keys2,
+                                                index2,
+                                                x,
+                                                levels,
+                                                compare_op);
+
+      // The distance between x's merge path and its lower_bound is its rank.
+      // We add up the a and b ranks and evenly distribute them to
+      // get a stairstep path.
+      Size run1      = index1 - start1;
+      Size run2      = index2 - start2;
+      Size total_run = run1 + run2;
+
+      // Attempt to advance b and regress a.
+      Size advance2 = max<Size>(total_run >> 1, total_run - run1);
+      Size end2     = min<Size>(num_keys2, start2 + advance2 + 1);
+
+      Size run_end2 = index2 + binary_search<true>(keys2 + index2,
+                                                   end2 - index2,
+                                                   x,
+                                                   compare_op);
+      run2 = run_end2 - start2;
+
+      advance2      = min<Size>(advance2, run2);
+      Size advance1 = total_run - advance2;
+
+      bool round_up      = (advance1 == advance2 + 1) && (advance2 < run2);
+      if (round_up) star = true;
+
+      index1 = start1 + advance1;
+    }
+    return thrust::make_pair(index1, (diag - index1) + star);
+  }    // func balanced_path
+
+  template <int                      _BLOCK_THREADS,
+            int                      _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm  _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier   _LOAD_MODIFIER    = cub::LOAD_LDG,
+            cub::BlockScanAlgorithm  _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS    = _BLOCK_THREADS,
+      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = _BLOCK_THREADS * _ITEMS_PER_THREAD - 1
+    };
+
+    static const cub::BlockLoadAlgorithm  LOAD_ALGORITHM  = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier   LOAD_MODIFIER   = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm  SCAN_ALGORITHM  = _SCAN_ALGORITHM;
+  };    // PtxPolicy
+
+  template<class Arch, class T, class U>
+  struct Tuning;
+
+  namespace mpl = thrust::detail::mpl::math;
+
+  template<class T, class U>
+  struct Tuning<sm30,T,U>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES             = mpl::max<size_t, sizeof(T), sizeof(U)>::value,
+      COMBINED_INPUT_BYTES        = sizeof(T),    // + sizeof(Value),
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      ITEMS_PER_THREAD            = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<
+              int,
+              1,
+              static_cast<int>(((NOMINAL_4B_ITEMS_PER_THREAD * 4) +
+               COMBINED_INPUT_BYTES - 1) /
+                  COMBINED_INPUT_BYTES)>::value>::value,
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  }; // tuning sm30
+
+  template<class T, class U>
+  struct Tuning<sm52,T,U>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES             = mpl::max<size_t, sizeof(T), sizeof(U)>::value,
+      COMBINED_INPUT_BYTES        = sizeof(T), // + sizeof(U),
+      NOMINAL_4B_ITEMS_PER_THREAD = 15,
+      ITEMS_PER_THREAD            = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<
+              int,
+              1,
+              static_cast<int>(((NOMINAL_4B_ITEMS_PER_THREAD * 4) +
+               COMBINED_INPUT_BYTES - 1) /
+                  COMBINED_INPUT_BYTES)>::value>::value,
+    };
+
+    typedef PtxPolicy<256,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  }; // tuning sm52
+
+  template<class T, class U>
+  struct Tuning<sm60,T,U>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES             = mpl::max<size_t, sizeof(T), sizeof(U)>::value,
+      COMBINED_INPUT_BYTES        = sizeof(T), // + sizeof(U),
+      NOMINAL_4B_ITEMS_PER_THREAD = 19,
+      ITEMS_PER_THREAD            = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<
+              int,
+              1,
+              static_cast<int>(((NOMINAL_4B_ITEMS_PER_THREAD * 4) +
+               COMBINED_INPUT_BYTES - 1) /
+                  COMBINED_INPUT_BYTES)>::value>::value,
+    };
+
+    typedef PtxPolicy<512,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  }; // tuning sm60
+
+  template <class KeysIt1,
+            class KeysIt2,
+            class ValuesIt1,
+            class ValuesIt2,
+            class KeysOutputIt,
+            class ValuesOutputIt,
+            class Size,
+            class CompareOp,
+            class SetOp,
+            class HAS_VALUES>
+  struct SetOpAgent
+  {
+    typedef typename iterator_traits<KeysIt1>::value_type  key1_type;
+    typedef typename iterator_traits<KeysIt2>::value_type  key2_type;
+    typedef typename iterator_traits<ValuesIt1>::value_type value1_type;
+    typedef typename iterator_traits<ValuesIt2>::value_type value2_type;
+
+    typedef key1_type  key_type;
+    typedef value1_type value_type;
+
+    typedef cub::ScanTileState<Size> ScanTileState;
+
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, key_type, value_type>::type
+    {
+      typedef Tuning<Arch, key_type, value_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, KeysIt1>::type   KeysLoadIt1;
+      typedef typename core::LoadIterator<PtxPlan, KeysIt2>::type   KeysLoadIt2;
+      typedef typename core::LoadIterator<PtxPlan, ValuesIt1>::type ValuesLoadIt1;
+      typedef typename core::LoadIterator<PtxPlan, ValuesIt2>::type ValuesLoadIt2;
+
+      typedef typename core::BlockLoad<PtxPlan, KeysLoadIt1>::type   BlockLoadKeys1;
+      typedef typename core::BlockLoad<PtxPlan, KeysLoadIt2>::type   BlockLoadKeys2;
+      typedef typename core::BlockLoad<PtxPlan, ValuesLoadIt1>::type BlockLoadValues1;
+      typedef typename core::BlockLoad<PtxPlan, ValuesLoadIt2>::type BlockLoadValues2;
+
+      typedef cub::TilePrefixCallbackOp<Size,
+                                        cub::Sum,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+
+      typedef cub::BlockScan<Size,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+      // gather required temporary storage in a union
+      //
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage          scan;
+          typename TilePrefixCallback::TempStorage prefix;
+        } scan_storage;
+
+        struct LoadStorage
+        {
+          core::uninitialized_array<int, PtxPlan::BLOCK_THREADS> offset;
+          union
+          {
+            // FIXME These don't appear to be used anywhere?
+            typename BlockLoadKeys1::TempStorage   load_keys1;
+            typename BlockLoadKeys2::TempStorage   load_keys2;
+            typename BlockLoadValues1::TempStorage load_values1;
+            typename BlockLoadValues2::TempStorage load_values2;
+
+            // Allocate extra shmem than truely neccessary
+            // This will permit to avoid range checks in
+            // serial set operations, e.g. serial_set_difference
+            core::uninitialized_array<
+                key_type,
+                PtxPlan::ITEMS_PER_TILE + PtxPlan::BLOCK_THREADS>
+                keys_shared;
+
+            core::uninitialized_array<
+                value_type,
+                PtxPlan::ITEMS_PER_TILE + PtxPlan::BLOCK_THREADS>
+                values_shared;
+          }; // anon union
+        } load_storage; // struct LoadStorage
+      };    // union TempStorage
+    };      // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::KeysLoadIt1   KeysLoadIt1;
+    typedef typename ptx_plan::KeysLoadIt2   KeysLoadIt2;
+    typedef typename ptx_plan::ValuesLoadIt1 ValuesLoadIt1;
+    typedef typename ptx_plan::ValuesLoadIt2 ValuesLoadIt2;
+
+    typedef typename ptx_plan::BlockLoadKeys1   BlockLoadKeys1;
+    typedef typename ptx_plan::BlockLoadKeys2   BlockLoadKeys2;
+    typedef typename ptx_plan::BlockLoadValues1 BlockLoadValues1;
+    typedef typename ptx_plan::BlockLoadValues2 BlockLoadValues2;
+
+    typedef typename ptx_plan::TilePrefixCallback TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan BlockScan;
+
+    typedef typename ptx_plan::TempStorage TempStorage;
+
+    enum
+    {
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &  storage;
+      ScanTileState &tile_state;
+      KeysLoadIt1    keys1_in;
+      KeysLoadIt2    keys2_in;
+      ValuesLoadIt1  values1_in;
+      ValuesLoadIt2  values2_in;
+      Size           keys1_count;
+      Size           keys2_count;
+      KeysOutputIt   keys_out;
+      ValuesOutputIt values_out;
+      CompareOp      compare_op;
+      SetOp          set_op;
+      pair<Size, Size> *partitions;
+      std::size_t *output_count;
+
+      //---------------------------------------------------------------------
+      // Utility functions
+      //---------------------------------------------------------------------
+
+      template <bool IS_FULL_TILE, class T, class It1, class It2>
+      THRUST_DEVICE_FUNCTION void
+      gmem_to_reg(T (&output)[ITEMS_PER_THREAD],
+                  It1 input1,
+                  It2 input2,
+                  int count1,
+                  int count2)
+      {
+        if (IS_FULL_TILE)
+        {
+#pragma unroll
+          for (int ITEM = 0; ITEM < ITEMS_PER_THREAD - 1; ++ITEM)
+          {
+            int idx      = BLOCK_THREADS * ITEM + threadIdx.x;
+            output[ITEM] = (idx < count1)
+                               ? static_cast<T>(input1[idx])
+                               : static_cast<T>(input2[idx - count1]);
+          }
+
+          // last ITEM might be a conditional load even for full tiles
+          // please check first before attempting to load.
+          int ITEM = ITEMS_PER_THREAD - 1;
+          int idx  = BLOCK_THREADS * ITEM + threadIdx.x;
+          if (idx < count1 + count2)
+            output[ITEM] = (idx < count1)
+                               ? static_cast<T>(input1[idx])
+                               : static_cast<T>(input2[idx - count1]);
+        }
+        else
+        {
+#pragma unroll
+          for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+          {
+            int idx = BLOCK_THREADS * ITEM + threadIdx.x;
+            if (idx < count1 + count2)
+            {
+              output[ITEM] = (idx < count1)
+                                 ? static_cast<T>(input1[idx])
+                                 : static_cast<T>(input2[idx - count1]);
+            }
+          }
+        }
+      }
+
+      template <class T, class It>
+      THRUST_DEVICE_FUNCTION void
+      reg_to_shared(It output,
+                    T (&input)[ITEMS_PER_THREAD])
+      {
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int idx = BLOCK_THREADS * ITEM + threadIdx.x;
+          output[idx] = input[ITEM];
+        }
+      }
+
+      template <class OutputIt, class T, class SharedIt>
+      void THRUST_DEVICE_FUNCTION
+      scatter(OutputIt output,
+              T (&input)[ITEMS_PER_THREAD],
+              SharedIt shared,
+              int      active_mask,
+              Size     thread_output_prefix,
+              Size     tile_output_prefix,
+              int      tile_output_count)
+      {
+        using core::sync_threadblock;
+
+
+
+        int local_scatter_idx = thread_output_prefix - tile_output_prefix;
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          if (active_mask & (1 << ITEM))
+          {
+            shared[local_scatter_idx++] = input[ITEM];
+          }
+        }
+        sync_threadblock();
+
+        for (int item = threadIdx.x;
+             item < tile_output_count;
+             item += BLOCK_THREADS)
+        {
+          output[tile_output_prefix + item] = shared[item];
+        }
+      }
+
+      int THRUST_DEVICE_FUNCTION
+      serial_set_op(key_type *keys,
+                    int       keys1_beg,
+                    int       keys2_beg,
+                    int       keys1_count,
+                    int       keys2_count,
+                    key_type (&output)[ITEMS_PER_THREAD],
+                    int (&indices)[ITEMS_PER_THREAD],
+                    CompareOp compare_op,
+                    SetOp     set_op)
+      {
+        int active_mask = set_op(keys,
+                                 keys1_beg,
+                                 keys2_beg,
+                                 keys1_count,
+                                 keys2_count,
+                                 output,
+                                 indices,
+                                 compare_op);
+
+        return active_mask;
+      }
+
+      //---------------------------------------------------------------------
+      // Tile operations
+      //---------------------------------------------------------------------
+
+      template <bool IS_LAST_TILE>
+      void THRUST_DEVICE_FUNCTION
+      consume_tile(Size tile_idx)
+      {
+        using core::sync_threadblock;
+        using core::uninitialized_array;
+
+        pair<Size, Size> partition_beg = partitions[tile_idx + 0];
+        pair<Size, Size> partition_end = partitions[tile_idx + 1];
+
+        Size keys1_beg = partition_beg.first;
+        Size keys1_end = partition_end.first;
+        Size keys2_beg = partition_beg.second;
+        Size keys2_end = partition_end.second;
+
+        // number of keys per tile
+        //
+        int num_keys1 = static_cast<int>(keys1_end - keys1_beg);
+        int num_keys2 = static_cast<int>(keys2_end - keys2_beg);
+
+
+       // load keys into shared memory for further processing
+        key_type keys_loc[ITEMS_PER_THREAD];
+
+        gmem_to_reg<!IS_LAST_TILE>(keys_loc,
+                                   keys1_in + keys1_beg,
+                                   keys2_in + keys2_beg,
+                                   num_keys1,
+                                   num_keys2);
+
+        reg_to_shared(&storage.load_storage.keys_shared[0], keys_loc);
+
+        sync_threadblock();
+
+        int diag_loc = min<int>(ITEMS_PER_THREAD * threadIdx.x,
+                                num_keys1 + num_keys2);
+
+        pair<int, int> partition_loc =
+            balanced_path(&storage.load_storage.keys_shared[0],
+                          &storage.load_storage.keys_shared[num_keys1],
+                          num_keys1,
+                          num_keys2,
+                          diag_loc,
+                          4,
+                          compare_op);
+
+        int keys1_beg_loc = partition_loc.first;
+        int keys2_beg_loc = partition_loc.second;
+
+        // compute difference between next and current thread
+        // to obtain number of elements per thread
+        int value = threadIdx.x == 0
+                        ? (num_keys1 << 16) | num_keys2
+                        : (partition_loc.first << 16) | partition_loc.second;
+
+        int dst = threadIdx.x == 0 ? BLOCK_THREADS - 1 : threadIdx.x - 1;
+        storage.load_storage.offset[dst] = value;
+
+        core::sync_threadblock();
+
+        pair<int,int> partition1_loc = thrust::make_pair(
+          storage.load_storage.offset[threadIdx.x] >> 16,
+          storage.load_storage.offset[threadIdx.x] & 0xFFFF);
+
+        int keys1_end_loc = partition1_loc.first;
+        int keys2_end_loc = partition1_loc.second;
+
+        int num_keys1_loc = keys1_end_loc - keys1_beg_loc;
+        int num_keys2_loc = keys2_end_loc - keys2_beg_loc;
+
+        // perform serial set operation
+        //
+        int indices[ITEMS_PER_THREAD];
+
+        int active_mask = serial_set_op(&storage.load_storage.keys_shared[0],
+                                        keys1_beg_loc,
+                                        keys2_beg_loc + num_keys1,
+                                        num_keys1_loc,
+                                        num_keys2_loc,
+                                        keys_loc,
+                                        indices,
+                                        compare_op,
+                                        set_op);
+        sync_threadblock();
+#if 0
+        if (ITEMS_PER_THREAD*threadIdx.x >= num_keys1 + num_keys2)
+          active_mask = 0;
+#endif
+
+        // look-back scan over thread_output_count
+        // to compute global thread_output_base and tile_otput_count;
+        Size tile_output_count    = 0;
+        Size thread_output_prefix = 0;
+        Size tile_output_prefix   = 0;
+        Size thread_output_count = static_cast<Size>(__popc(active_mask));
+
+        if (tile_idx == 0)    // first tile
+        {
+          BlockScan(storage.scan_storage.scan)
+              .ExclusiveSum(thread_output_count,
+                            thread_output_prefix,
+                            tile_output_count);
+          if (threadIdx.x == 0)
+          {
+            // Update tile status if this is not the last tile
+            if (!IS_LAST_TILE)
+            {
+              tile_state.SetInclusive(0, tile_output_count);
+            }
+          }
+        }
+        else
+        {
+          TilePrefixCallback prefix_cb(tile_state,
+                                       storage.scan_storage.prefix,
+                                       cub::Sum(),
+                                       tile_idx);
+
+          BlockScan(storage.scan_storage.scan)
+              .ExclusiveSum(thread_output_count,
+                            thread_output_prefix,
+                            prefix_cb);
+          tile_output_count  = prefix_cb.GetBlockAggregate();
+          tile_output_prefix = prefix_cb.GetExclusivePrefix();
+        }
+
+        sync_threadblock();
+
+        // scatter results
+        //
+        scatter(keys_out,
+                keys_loc,
+                &storage.load_storage.keys_shared[0],
+                active_mask,
+                thread_output_prefix,
+                tile_output_prefix,
+                tile_output_count);
+
+        if (HAS_VALUES::value)
+        {
+          value_type values_loc[ITEMS_PER_THREAD];
+          gmem_to_reg<!IS_LAST_TILE>(values_loc,
+                                     values1_in + keys1_beg,
+                                     values2_in + keys2_beg,
+                                     num_keys1,
+                                     num_keys2);
+
+          sync_threadblock();
+
+          reg_to_shared(&storage.load_storage.values_shared[0], values_loc);
+
+          sync_threadblock();
+
+          // gather items from shared mem
+          //
+#pragma unroll
+          for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+          {
+            if (active_mask & (1 << ITEM))
+            {
+              values_loc[ITEM] = storage.load_storage.values_shared[indices[ITEM]];
+            }
+          }
+
+          sync_threadblock();
+
+          scatter(values_out,
+                  values_loc,
+                  &storage.load_storage.values_shared[0],
+                  active_mask,
+                  thread_output_prefix,
+                  tile_output_prefix,
+                  tile_output_count);
+        }
+
+        if (IS_LAST_TILE && threadIdx.x == 0)
+        {
+          *output_count = tile_output_prefix + tile_output_count;
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      impl(TempStorage &  storage_,
+           ScanTileState &tile_state_,
+           KeysIt1        keys1_,
+           KeysIt2        keys2_,
+           ValuesIt1      values1_,
+           ValuesIt2      values2_,
+           Size           keys1_count_,
+           Size           keys2_count_,
+           KeysOutputIt   keys_out_,
+           ValuesOutputIt values_out_,
+           CompareOp      compare_op_,
+           SetOp          set_op_,
+           pair<Size, Size> *partitions_,
+           std::size_t * output_count_)
+          : storage(storage_),
+            tile_state(tile_state_),
+            keys1_in(core::make_load_iterator(ptx_plan(), keys1_)),
+            keys2_in(core::make_load_iterator(ptx_plan(), keys2_)),
+            values1_in(core::make_load_iterator(ptx_plan(), values1_)),
+            values2_in(core::make_load_iterator(ptx_plan(), values2_)),
+            keys1_count(keys1_count_),
+            keys2_count(keys2_count_),
+            keys_out(keys_out_),
+            values_out(values_out_),
+            compare_op(compare_op_),
+            set_op(set_op_),
+            partitions(partitions_),
+            output_count(output_count_)
+      {
+        int  tile_idx      = blockIdx.x;
+        int  num_tiles     = gridDim.x;
+
+        if (tile_idx < num_tiles-1)
+        {
+          consume_tile<false>(tile_idx);
+        }
+        else
+        {
+          consume_tile<true>(tile_idx);
+        }
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(KeysIt1        keys1,
+                       KeysIt2        keys2,
+                       ValuesIt1      values1,
+                       ValuesIt2      values2,
+                       Size           keys1_count,
+                       Size           keys2_count,
+                       KeysOutputIt   keys_output,
+                       ValuesOutputIt values_output,
+                       CompareOp      compare_op,
+                       SetOp          set_op,
+                       pair<Size, Size> *partitions,
+                       std::size_t *  output_count,
+                       ScanTileState tile_state,
+                       char *        shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
+
+      impl(storage,
+           tile_state,
+           keys1,
+           keys2,
+           values1,
+           values2,
+           keys1_count,
+           keys2_count,
+           keys_output,
+           values_output,
+           compare_op,
+           set_op,
+           partitions,
+           output_count);
+    }
+  };    // struct SetOpAgent
+
+  template <class KeysIt1,
+            class KeysIt2,
+            class Size,
+            class CompareOp>
+  struct PartitionAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<256> {};
+
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(KeysIt1 keys1,
+                       KeysIt2 keys2,
+                       Size    keys1_count,
+                       Size    keys2_count,
+                       Size    num_partitions,
+                       pair<Size, Size> *partitions,
+                       CompareOp compare_op,
+                       int       items_per_tile,
+                       char * /*shmem*/)
+    {
+      Size partition_idx = blockDim.x * blockIdx.x + threadIdx.x;
+      if (partition_idx < num_partitions)
+      {
+        Size partition_at = min<Size>(partition_idx * items_per_tile,
+                                      keys1_count + keys2_count);
+        pair<Size, Size> diag = balanced_path(keys1,
+                                              keys2,
+                                              keys1_count,
+                                              keys2_count,
+                                              partition_at,
+                                              4ll,
+                                              compare_op);
+        partitions[partition_idx] = diag;
+      }
+    }
+  };    // struct PartitionAgent
+
+  template <class ScanTileState,
+            class Size>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       char * /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+    }
+  }; // struct InitAgent
+
+  //---------------------------------------------------------------------
+  // Serial set operations
+  //---------------------------------------------------------------------
+
+  // serial_set_intersection
+  // -----------------------
+  // emit A if A and B are in range and equal.
+  struct serial_set_intersection
+  {
+    // max_input_size <= 32
+    template <class T, class CompareOp, int ITEMS_PER_THREAD>
+    int THRUST_DEVICE_FUNCTION
+    operator()(T * keys,
+               int keys1_beg,
+               int keys2_beg,
+               int keys1_count,
+               int keys2_count,
+               T (&output)[ITEMS_PER_THREAD],
+               int (&indices)[ITEMS_PER_THREAD],
+               CompareOp compare_op)
+    {
+      int active_mask = 0;
+
+      int aBegin = keys1_beg;
+      int bBegin = keys2_beg;
+      int aEnd   = keys1_beg + keys1_count;
+      int bEnd   = keys2_beg + keys2_count;
+
+      T aKey = keys[aBegin];
+      T bKey = keys[bBegin];
+
+#pragma unroll
+      for (int i = 0; i < ITEMS_PER_THREAD; ++i)
+      {
+        bool pA = compare_op(aKey, bKey);
+        bool pB = compare_op(bKey, aKey);
+
+        // The outputs must come from A by definition of set interection.
+        output[i]  = aKey;
+        indices[i] = aBegin;
+
+        if ((aBegin < aEnd) && (bBegin < bEnd) && pA == pB)
+          active_mask |= 1 << i;
+
+        if (!pB) {aKey = keys[++aBegin]; }
+        if (!pA) {bKey = keys[++bBegin]; }
+      }
+      return active_mask;
+    }
+  };    // struct serial_set_intersection
+
+  // serial_set_symmetric_difference
+  // ---------------------
+  // emit A if A < B and emit B if B < A.
+  struct serial_set_symmetric_difference
+  {
+    // max_input_size <= 32
+    template <class T, class CompareOp, int ITEMS_PER_THREAD>
+    int THRUST_DEVICE_FUNCTION
+    operator()(T * keys,
+               int keys1_beg,
+               int keys2_beg,
+               int keys1_count,
+               int keys2_count,
+               T (&output)[ITEMS_PER_THREAD],
+               int (&indices)[ITEMS_PER_THREAD],
+               CompareOp compare_op)
+    {
+      int active_mask = 0;
+
+      int aBegin = keys1_beg;
+      int bBegin = keys2_beg;
+      int aEnd   = keys1_beg + keys1_count;
+      int bEnd   = keys2_beg + keys2_count;
+      int end    = aEnd + bEnd;
+
+      T aKey = keys[aBegin];
+      T bKey = keys[bBegin];
+
+
+#pragma unroll
+      for (int i = 0; i < ITEMS_PER_THREAD; ++i)
+      {
+        bool pB = aBegin >= aEnd;
+        bool pA = !pB && bBegin >= bEnd;
+
+        if (!pA && !pB)
+        {
+          pA = compare_op(aKey, bKey);
+          pB = !pA && compare_op(bKey, aKey);
+        }
+
+        // The outputs must come from A by definition of set difference.
+        output[i]  = pA ? aKey : bKey;
+        indices[i] = pA ? aBegin : bBegin;
+
+        if (aBegin + bBegin < end && pA != pB)
+          active_mask |= 1 << i;
+
+        if (!pB) {aKey = keys[++aBegin]; }
+        if (!pA) {bKey = keys[++bBegin]; }
+
+      }
+      return active_mask;
+    }
+  };    // struct set_symmetric_difference
+
+  // serial_set_difference
+  // ---------------------
+  // emit A if A < B
+  struct serial_set_difference
+  {
+    // max_input_size <= 32
+    template <class T, class CompareOp, int ITEMS_PER_THREAD>
+    int THRUST_DEVICE_FUNCTION
+    operator()(T * keys,
+               int keys1_beg,
+               int keys2_beg,
+               int keys1_count,
+               int keys2_count,
+               T (&output)[ITEMS_PER_THREAD],
+               int (&indices)[ITEMS_PER_THREAD],
+               CompareOp compare_op)
+    {
+      int active_mask = 0;
+
+      int aBegin = keys1_beg;
+      int bBegin = keys2_beg;
+      int aEnd   = keys1_beg + keys1_count;
+      int bEnd   = keys2_beg + keys2_count;
+      int end    = aEnd + bEnd;
+
+      T aKey = keys[aBegin];
+      T bKey = keys[bBegin];
+
+#pragma unroll
+      for (int i = 0; i < ITEMS_PER_THREAD; ++i)
+      {
+        bool pB = aBegin >= aEnd;
+        bool pA = !pB && bBegin >= bEnd;
+
+        if (!pA && !pB)
+        {
+          pA = compare_op(aKey, bKey);
+          pB = !pA && compare_op(bKey, aKey);
+        }
+
+        // The outputs must come from A by definition of set difference.
+        output[i]  = aKey;
+        indices[i] = aBegin;
+
+        if (aBegin + bBegin < end && pA)
+          active_mask |= 1 << i;
+
+        if (!pB) { aKey = keys[++aBegin]; }
+        if (!pA) { bKey = keys[++bBegin]; }
+      }
+      return active_mask;
+    }
+  };    // struct set_difference
+
+  // serial_set_union
+  // ----------------
+  // emit A if A <= B else emit B
+  struct serial_set_union
+  {
+    // max_input_size <= 32
+    template <class T, class CompareOp, int ITEMS_PER_THREAD>
+    int THRUST_DEVICE_FUNCTION
+    operator()(T * keys,
+               int keys1_beg,
+               int keys2_beg,
+               int keys1_count,
+               int keys2_count,
+               T (&output)[ITEMS_PER_THREAD],
+               int (&indices)[ITEMS_PER_THREAD],
+               CompareOp compare_op)
+    {
+      int active_mask = 0;
+
+      int aBegin = keys1_beg;
+      int bBegin = keys2_beg;
+      int aEnd   = keys1_beg + keys1_count;
+      int bEnd   = keys2_beg + keys2_count;
+      int end    = aEnd + bEnd;
+
+      T aKey = keys[aBegin];
+      T bKey = keys[bBegin];
+
+#pragma unroll
+      for (int i = 0; i < ITEMS_PER_THREAD; ++i)
+      {
+        bool pB = aBegin >= aEnd;
+        bool pA = !pB && bBegin >= bEnd;
+
+        if (!pA && !pB)
+        {
+          pA = compare_op(aKey, bKey);
+          pB = !pA && compare_op(bKey, aKey);
+        }
+
+        // Output A in case of a tie, so check if b < a.
+        output[i]  = pB ? bKey : aKey;
+        indices[i] = pB ? bBegin : aBegin;
+
+        if (aBegin + bBegin < end)
+          active_mask |= 1 << i;
+
+        if (!pB) { aKey = keys[++aBegin]; }
+        if (!pA) { bKey = keys[++bBegin]; }
+
+      }
+      return active_mask;
+    }
+  };    // struct set_union
+
+  template <class HAS_VALUES,
+            class KeysIt1,
+            class KeysIt2,
+            class ValuesIt1,
+            class ValuesIt2,
+            class Size,
+            class KeysOutputIt,
+            class ValuesOutputIt,
+            class CompareOp,
+            class SetOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *         d_temp_storage,
+            size_t &       temp_storage_size,
+            KeysIt1        keys1,
+            KeysIt2        keys2,
+            ValuesIt1      values1,
+            ValuesIt2      values2,
+            Size           num_keys1,
+            Size           num_keys2,
+            KeysOutputIt   keys_output,
+            ValuesOutputIt values_output,
+            std::size_t *  output_count,
+            CompareOp      compare_op,
+            SetOp          set_op,
+            cudaStream_t   stream)
+  {
+    Size keys_total = num_keys1 + num_keys2;
+    if (keys_total == 0)
+      return cudaErrorNotSupported;
+
+    cudaError_t status = cudaSuccess;
+
+    using core::AgentPlan;
+    using core::AgentLauncher;
+
+    typedef AgentLauncher<
+        SetOpAgent<KeysIt1,
+                   KeysIt2,
+                   ValuesIt1,
+                   ValuesIt2,
+                   KeysOutputIt,
+                   ValuesOutputIt,
+                   Size,
+                   CompareOp,
+                   SetOp,
+                   HAS_VALUES> >
+        set_op_agent;
+
+    typedef AgentLauncher<PartitionAgent<KeysIt1, KeysIt2, Size, CompareOp> >
+        partition_agent;
+
+    typedef typename set_op_agent::ScanTileState ScanTileState;
+    typedef AgentLauncher<InitAgent<ScanTileState, Size> > init_agent;
+
+
+    AgentPlan set_op_plan    = set_op_agent::get_plan(stream);
+    AgentPlan init_plan      = init_agent::get_plan();
+    AgentPlan partition_plan = partition_agent::get_plan();
+
+    int  tile_size = set_op_plan.items_per_tile;
+    Size num_tiles = (keys_total + tile_size - 1) / tile_size;
+
+    size_t tile_agent_storage;
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles),
+                                           tile_agent_storage);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    size_t vshmem_storage = core::vshmem_size(set_op_plan.shared_memory_size,
+                                              num_tiles);
+    size_t partition_agent_storage = (num_tiles + 1) * sizeof(Size) * 2;
+
+    void *allocations[3] = {NULL, NULL, NULL};
+    size_t allocation_sizes[3] = {tile_agent_storage,
+                                  partition_agent_storage,
+                                  vshmem_storage};
+
+    status = core::alias_storage(d_temp_storage,
+                                 temp_storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_state;
+    status = tile_state.Init(static_cast<int>(num_tiles),
+                             allocations[0],
+                             allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    pair<Size, Size> *partitions = (pair<Size, Size> *)allocations[1];
+    char *vshmem_ptr = vshmem_storage > 0 ? (char *)allocations[2] : NULL;
+
+    init_agent ia(init_plan, num_tiles, stream, "set_op::init_agent");
+    ia.launch(tile_state, num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    partition_agent pa(partition_plan, num_tiles+1, stream, "set_op::partition agent");
+    pa.launch(keys1,
+              keys2,
+              num_keys1,
+              num_keys2,
+              num_tiles+1,
+              partitions,
+              compare_op,
+              tile_size);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    set_op_agent sa(set_op_plan, keys_total, stream, vshmem_ptr, "set_op::set_op_agent");
+    sa.launch(keys1,
+              keys2,
+              values1,
+              values2,
+              num_keys1,
+              num_keys2,
+              keys_output,
+              values_output,
+              compare_op,
+              set_op,
+              partitions,
+              output_count,
+              tile_state);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    return status;
+ }
+
+ template <typename HAS_VALUES,
+           typename Derived,
+           typename KeysIt1,
+           typename KeysIt2,
+           typename ValuesIt1,
+           typename ValuesIt2,
+           typename KeysOutputIt,
+           typename ValuesOutputIt,
+           typename CompareOp,
+           typename SetOp>
+  THRUST_RUNTIME_FUNCTION
+  pair<KeysOutputIt, ValuesOutputIt>
+  set_operations(execution_policy<Derived>& policy,
+                 KeysIt1                    keys1_first,
+                 KeysIt1                    keys1_last,
+                 KeysIt2                    keys2_first,
+                 KeysIt2                    keys2_last,
+                 ValuesIt1                  values1_first,
+                 ValuesIt2                  values2_first,
+                 KeysOutputIt               keys_output,
+                 ValuesOutputIt             values_output,
+                 CompareOp                  compare_op,
+                 SetOp                      set_op)
+  {
+    typedef typename iterator_traits<KeysIt1>::difference_type size_type;
+
+    size_type num_keys1 = static_cast<size_type>(thrust::distance(keys1_first, keys1_last));
+    size_type num_keys2 = static_cast<size_type>(thrust::distance(keys2_first, keys2_last));
+
+    if (num_keys1 + num_keys2 == 0)
+      return thrust::make_pair(keys_output, values_output);
+
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    THRUST_DOUBLE_INDEX_TYPE_DISPATCH(status, doit_step<HAS_VALUES>,
+        num_keys1, num_keys2, (NULL,
+                                   temp_storage_bytes,
+                                   keys1_first,
+                                   keys2_first,
+                                   values1_first,
+                                   values2_first,
+                                   num_keys1_fixed,
+                                   num_keys2_fixed,
+                                   keys_output,
+                                   values_output,
+                                   reinterpret_cast<std::size_t*>(NULL),
+                                   compare_op,
+                                   set_op,
+                                   stream));
+    cuda_cub::throw_on_error(status, "set_operations failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(std::size_t), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "set_operations failed on 1st alias_storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "set_operations failed on 2nd alias_storage");
+
+    std::size_t* d_output_count
+      = thrust::detail::aligned_reinterpret_cast<std::size_t*>(allocations[0]);
+
+    THRUST_DOUBLE_INDEX_TYPE_DISPATCH(status, doit_step<HAS_VALUES>,
+        num_keys1, num_keys2, (allocations[1],
+                                   temp_storage_bytes,
+                                   keys1_first,
+                                   keys2_first,
+                                   values1_first,
+                                   values2_first,
+                                   num_keys1_fixed,
+                                   num_keys2_fixed,
+                                   keys_output,
+                                   values_output,
+                                   d_output_count,
+                                   compare_op,
+                                   set_op,
+                                   stream));
+    cuda_cub::throw_on_error(status, "set_operations failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "set_operations failed to synchronize");
+
+    std::size_t output_count = cuda_cub::get_value(policy, d_output_count);
+
+    return thrust::make_pair(keys_output + output_count, values_output + output_count);
+  }
+}    // namespace __set_operations
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt,
+          class CompareOp>
+OutputIt __host__ __device__
+set_difference(execution_policy<Derived> &policy,
+               ItemsIt1                   items1_first,
+               ItemsIt1                   items1_last,
+               ItemsIt2                   items2_first,
+               ItemsIt2                   items2_last,
+               OutputIt                   result,
+               CompareOp                  compare)
+{
+  THRUST_CDP_DISPATCH(
+    (using items1_t  = thrust::iterator_value_t<ItemsIt1>;
+     items1_t *null_ = nullptr;
+     auto tmp = __set_operations::set_operations<thrust::detail::false_type>(
+       policy,
+       items1_first,
+       items1_last,
+       items2_first,
+       items2_last,
+       null_,
+       null_,
+       result,
+       null_,
+       compare,
+       __set_operations::serial_set_difference());
+     result = tmp.first;),
+    (result = thrust::set_difference(cvt_to_seq(derived_cast(policy)),
+                                     items1_first,
+                                     items1_last,
+                                     items2_first,
+                                     items2_last,
+                                     result,
+                                     compare);));
+  return result;
+}
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt>
+OutputIt __host__ __device__
+set_difference(execution_policy<Derived> &policy,
+               ItemsIt1                   items1_first,
+               ItemsIt1                   items1_last,
+               ItemsIt2                   items2_first,
+               ItemsIt2                   items2_last,
+               OutputIt                   result)
+{
+  typedef typename thrust::iterator_value<ItemsIt1>::type value_type;
+  return cuda_cub::set_difference(policy,
+                                  items1_first,
+                                  items1_last,
+                                  items2_first,
+                                  items2_last,
+                                  result,
+                                  less<value_type>());
+}
+
+/*****************************/
+
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt,
+          class CompareOp>
+OutputIt __host__ __device__
+set_intersection(execution_policy<Derived> &policy,
+                 ItemsIt1                   items1_first,
+                 ItemsIt1                   items1_last,
+                 ItemsIt2                   items2_first,
+                 ItemsIt2                   items2_last,
+                 OutputIt                   result,
+                 CompareOp                  compare)
+{
+  THRUST_CDP_DISPATCH(
+    (using items1_t  = thrust::iterator_value_t<ItemsIt1>;
+     items1_t *null_ = NULL;
+     auto tmp = __set_operations::set_operations<thrust::detail::false_type>(
+       policy,
+       items1_first,
+       items1_last,
+       items2_first,
+       items2_last,
+       null_,
+       null_,
+       result,
+       null_,
+       compare,
+       __set_operations::serial_set_intersection());
+     result = tmp.first;),
+    (result = thrust::set_intersection(cvt_to_seq(derived_cast(policy)),
+                                       items1_first,
+                                       items1_last,
+                                       items2_first,
+                                       items2_last,
+                                       result,
+                                       compare);));
+  return result;
+}
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt>
+OutputIt __host__ __device__
+set_intersection(execution_policy<Derived> &policy,
+                 ItemsIt1                   items1_first,
+                 ItemsIt1                   items1_last,
+                 ItemsIt2                   items2_first,
+                 ItemsIt2                   items2_last,
+                 OutputIt                   result)
+{
+  typedef typename thrust::iterator_value<ItemsIt1>::type value_type;
+  return cuda_cub::set_intersection(policy,
+                                    items1_first,
+                                    items1_last,
+                                    items2_first,
+                                    items2_last,
+                                    result,
+                                    less<value_type>());
+}
+
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt,
+          class CompareOp>
+OutputIt __host__ __device__
+set_symmetric_difference(execution_policy<Derived> &policy,
+                         ItemsIt1                   items1_first,
+                         ItemsIt1                   items1_last,
+                         ItemsIt2                   items2_first,
+                         ItemsIt2                   items2_last,
+                         OutputIt                   result,
+                         CompareOp                  compare)
+{
+  THRUST_CDP_DISPATCH(
+    (using items1_t  = thrust::iterator_value_t<ItemsIt1>;
+     items1_t *null_ = nullptr;
+     auto tmp = __set_operations::set_operations<thrust::detail::false_type>(
+       policy,
+       items1_first,
+       items1_last,
+       items2_first,
+       items2_last,
+       null_,
+       null_,
+       result,
+       null_,
+       compare,
+       __set_operations::serial_set_symmetric_difference());
+     result = tmp.first;),
+    (result = thrust::set_symmetric_difference(cvt_to_seq(derived_cast(policy)),
+                                               items1_first,
+                                               items1_last,
+                                               items2_first,
+                                               items2_last,
+                                               result,
+                                               compare);));
+  return result;
+}
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt>
+OutputIt __host__ __device__
+set_symmetric_difference(execution_policy<Derived> &policy,
+                         ItemsIt1                   items1_first,
+                         ItemsIt1                   items1_last,
+                         ItemsIt2                   items2_first,
+                         ItemsIt2                   items2_last,
+                         OutputIt                   result)
+{
+  typedef typename thrust::iterator_value<ItemsIt1>::type value_type;
+  return cuda_cub::set_symmetric_difference(policy,
+                                            items1_first,
+                                            items1_last,
+                                            items2_first,
+                                            items2_last,
+                                            result,
+                                            less<value_type>());
+}
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt,
+          class CompareOp>
+OutputIt __host__ __device__
+set_union(execution_policy<Derived> &policy,
+          ItemsIt1                   items1_first,
+          ItemsIt1                   items1_last,
+          ItemsIt2                   items2_first,
+          ItemsIt2                   items2_last,
+          OutputIt                   result,
+          CompareOp                  compare)
+{
+  THRUST_CDP_DISPATCH(
+    (using items1_t  = thrust::iterator_value_t<ItemsIt1>;
+     items1_t *null_ = nullptr;
+     auto tmp = __set_operations::set_operations<thrust::detail::false_type>(
+       policy,
+       items1_first,
+       items1_last,
+       items2_first,
+       items2_last,
+       null_,
+       null_,
+       result,
+       null_,
+       compare,
+       __set_operations::serial_set_union());
+     result = tmp.first;),
+    (result = thrust::set_union(cvt_to_seq(derived_cast(policy)),
+                                items1_first,
+                                items1_last,
+                                items2_first,
+                                items2_last,
+                                result,
+                                compare);));
+  return result;
+}
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt>
+OutputIt __host__ __device__
+set_union(execution_policy<Derived> &policy,
+          ItemsIt1                   items1_first,
+          ItemsIt1                   items1_last,
+          ItemsIt2                   items2_first,
+          ItemsIt2                   items2_last,
+          OutputIt                   result)
+{
+  typedef typename thrust::iterator_value<ItemsIt1>::type value_type;
+  return cuda_cub::set_union(policy,
+                             items1_first,
+                             items1_last,
+                             items2_first,
+                             items2_last,
+                             result,
+                             less<value_type>());
+}
+
+
+/*****************************/
+/*****************************/
+/*****     *_by_key      *****/
+/*****************************/
+/*****************************/
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt,
+          class CompareOp>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_difference_by_key(execution_policy<Derived> &policy,
+                      KeysIt1                    keys1_first,
+                      KeysIt1                    keys1_last,
+                      KeysIt2                    keys2_first,
+                      KeysIt2                    keys2_last,
+                      ItemsIt1                   items1_first,
+                      ItemsIt2                   items2_first,
+                      KeysOutputIt               keys_result,
+                      ItemsOutputIt              items_result,
+                      CompareOp                  compare_op)
+{
+  auto ret = thrust::make_pair(keys_result, items_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __set_operations::set_operations<thrust::detail::true_type>(
+       policy,
+       keys1_first,
+       keys1_last,
+       keys2_first,
+       keys2_last,
+       items1_first,
+       items2_first,
+       keys_result,
+       items_result,
+       compare_op,
+       __set_operations::serial_set_difference());),
+    (ret = thrust::set_difference_by_key(cvt_to_seq(derived_cast(policy)),
+                                         keys1_first,
+                                         keys1_last,
+                                         keys2_first,
+                                         keys2_last,
+                                         items1_first,
+                                         items2_first,
+                                         keys_result,
+                                         items_result,
+                                         compare_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_difference_by_key(execution_policy<Derived> &policy,
+                      KeysIt1                    keys1_first,
+                      KeysIt1                    keys1_last,
+                      KeysIt2                    keys2_first,
+                      KeysIt2                    keys2_last,
+                      ItemsIt1                   items1_first,
+                      ItemsIt2                   items2_first,
+                      KeysOutputIt               keys_result,
+                      ItemsOutputIt              items_result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type value_type;
+  return cuda_cub::set_difference_by_key(policy,
+                                         keys1_first,
+                                         keys1_last,
+                                         keys2_first,
+                                         keys2_last,
+                                         items1_first,
+                                         items2_first,
+                                         keys_result,
+                                         items_result,
+                                         less<value_type>());
+}
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt,
+          class CompareOp>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_intersection_by_key(execution_policy<Derived> &policy,
+                        KeysIt1                    keys1_first,
+                        KeysIt1                    keys1_last,
+                        KeysIt2                    keys2_first,
+                        KeysIt2                    keys2_last,
+                        ItemsIt1                   items1_first,
+                        KeysOutputIt               keys_result,
+                        ItemsOutputIt              items_result,
+                        CompareOp                  compare_op)
+{
+  auto ret = thrust::make_pair(keys_result, items_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __set_operations::set_operations<thrust::detail::true_type>(
+       policy,
+       keys1_first,
+       keys1_last,
+       keys2_first,
+       keys2_last,
+       items1_first,
+       items1_first,
+       keys_result,
+       items_result,
+       compare_op,
+       __set_operations::serial_set_intersection());),
+    (ret = thrust::set_intersection_by_key(cvt_to_seq(derived_cast(policy)),
+                                           keys1_first,
+                                           keys1_last,
+                                           keys2_first,
+                                           keys2_last,
+                                           items1_first,
+                                           keys_result,
+                                           items_result,
+                                           compare_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_intersection_by_key(execution_policy<Derived> &policy,
+                        KeysIt1                    keys1_first,
+                        KeysIt1                    keys1_last,
+                        KeysIt2                    keys2_first,
+                        KeysIt2                    keys2_last,
+                        ItemsIt1                   items1_first,
+                        KeysOutputIt               keys_result,
+                        ItemsOutputIt              items_result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type value_type;
+  return cuda_cub::set_intersection_by_key(policy,
+                                           keys1_first,
+                                           keys1_last,
+                                           keys2_first,
+                                           keys2_last,
+                                           items1_first,
+                                           keys_result,
+                                           items_result,
+                                           less<value_type>());
+}
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt,
+          class CompareOp>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_symmetric_difference_by_key(execution_policy<Derived> &policy,
+                                KeysIt1                    keys1_first,
+                                KeysIt1                    keys1_last,
+                                KeysIt2                    keys2_first,
+                                KeysIt2                    keys2_last,
+                                ItemsIt1                   items1_first,
+                                ItemsIt2                   items2_first,
+                                KeysOutputIt               keys_result,
+                                ItemsOutputIt              items_result,
+                                CompareOp                  compare_op)
+{
+  auto ret = thrust::make_pair(keys_result, items_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __set_operations::set_operations<thrust::detail::true_type>(
+       policy,
+       keys1_first,
+       keys1_last,
+       keys2_first,
+       keys2_last,
+       items1_first,
+       items2_first,
+       keys_result,
+       items_result,
+       compare_op,
+       __set_operations::serial_set_symmetric_difference());),
+    (ret =
+       thrust::set_symmetric_difference_by_key(cvt_to_seq(derived_cast(policy)),
+                                               keys1_first,
+                                               keys1_last,
+                                               keys2_first,
+                                               keys2_last,
+                                               items1_first,
+                                               items2_first,
+                                               keys_result,
+                                               items_result,
+                                               compare_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_symmetric_difference_by_key(execution_policy<Derived> &policy,
+                                KeysIt1                    keys1_first,
+                                KeysIt1                    keys1_last,
+                                KeysIt2                    keys2_first,
+                                KeysIt2                    keys2_last,
+                                ItemsIt1                   items1_first,
+                                ItemsIt2                   items2_first,
+                                KeysOutputIt               keys_result,
+                                ItemsOutputIt              items_result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type value_type;
+  return cuda_cub::set_symmetric_difference_by_key(policy,
+                                                   keys1_first,
+                                                   keys1_last,
+                                                   keys2_first,
+                                                   keys2_last,
+                                                   items1_first,
+                                                   items2_first,
+                                                   keys_result,
+                                                   items_result,
+                                                   less<value_type>());
+}
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt,
+          class CompareOp>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_union_by_key(execution_policy<Derived> &policy,
+                 KeysIt1                    keys1_first,
+                 KeysIt1                    keys1_last,
+                 KeysIt2                    keys2_first,
+                 KeysIt2                    keys2_last,
+                 ItemsIt1                   items1_first,
+                 ItemsIt2                   items2_first,
+                 KeysOutputIt               keys_result,
+                 ItemsOutputIt              items_result,
+                 CompareOp                  compare_op)
+{
+  auto ret = thrust::make_pair(keys_result, items_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __set_operations::set_operations<thrust::detail::true_type>(
+       policy,
+       keys1_first,
+       keys1_last,
+       keys2_first,
+       keys2_last,
+       items1_first,
+       items2_first,
+       keys_result,
+       items_result,
+       compare_op,
+       __set_operations::serial_set_union());),
+    (ret = thrust::set_union_by_key(cvt_to_seq(derived_cast(policy)),
+                                    keys1_first,
+                                    keys1_last,
+                                    keys2_first,
+                                    keys2_last,
+                                    items1_first,
+                                    items2_first,
+                                    keys_result,
+                                    items_result,
+                                    compare_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_union_by_key(execution_policy<Derived> &policy,
+                 KeysIt1                    keys1_first,
+                 KeysIt1                    keys1_last,
+                 KeysIt2                    keys2_first,
+                 KeysIt2                    keys2_last,
+                 ItemsIt1                   items1_first,
+                 ItemsIt2                   items2_first,
+                 KeysOutputIt               keys_result,
+                 ItemsOutputIt              items_result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type value_type;
+  return cuda_cub::set_union_by_key(policy,
+                                    keys1_first,
+                                    keys1_last,
+                                    keys2_first,
+                                    keys2_last,
+                                    items1_first,
+                                    items2_first,
+                                    keys_result,
+                                    items_result,
+                                    less<value_type>());
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/sort.h

@@ -0,0 +1,636 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/distance.h>
+#include <thrust/extrema.h>
+#include <thrust/sequence.h>
+#include <thrust/sort.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/core/util.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/integer_math.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/trivial_sequence.h>
+
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+#include <cub/device/device_radix_sort.cuh>
+#include <cub/device/device_merge_sort.cuh>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __merge_sort {
+
+  template <class KeysIt,
+            class ItemsIt,
+            class Size,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  doit_step(void*        d_temp_storage,
+            size_t&      temp_storage_bytes,
+            KeysIt       keys,
+            ItemsIt      ,
+            Size         keys_count,
+            CompareOp    compare_op,
+            cudaStream_t stream,
+            thrust::detail::integral_constant<bool, false> /* sort_keys */)
+  {
+    using ItemsInputIt = cub::NullType *;
+    ItemsInputIt items = nullptr;
+
+    using DispatchMergeSortT = cub::DispatchMergeSort<KeysIt,
+                                                      ItemsInputIt,
+                                                      KeysIt,
+                                                      ItemsInputIt,
+                                                      Size,
+                                                      CompareOp>;
+
+
+    return DispatchMergeSortT::Dispatch(d_temp_storage,
+                                        temp_storage_bytes,
+                                        keys,
+                                        items,
+                                        keys,
+                                        items,
+                                        keys_count,
+                                        compare_op,
+                                        stream);
+  }
+
+  template <class KeysIt,
+            class ItemsIt,
+            class Size,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            KeysIt keys,
+            ItemsIt items,
+            Size keys_count,
+            CompareOp compare_op,
+            cudaStream_t stream,
+            thrust::detail::integral_constant<bool, true> /* sort_items */)
+  {
+    using DispatchMergeSortT =
+      cub::DispatchMergeSort<KeysIt, ItemsIt, KeysIt, ItemsIt, Size, CompareOp>;
+
+    return DispatchMergeSortT::Dispatch(d_temp_storage,
+                                        temp_storage_bytes,
+                                        keys,
+                                        items,
+                                        keys,
+                                        items,
+                                        keys_count,
+                                        compare_op,
+                                        stream);
+  }
+
+  template <class SORT_ITEMS,
+            class /* STABLE */,
+            class KeysIt,
+            class ItemsIt,
+            class Size,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            KeysIt keys,
+            ItemsIt items,
+            Size keys_count,
+            CompareOp compare_op,
+            cudaStream_t stream)
+  {
+    if (keys_count == 0)
+    {
+      return cudaSuccess;
+    }
+
+    thrust::detail::integral_constant<bool, SORT_ITEMS::value> sort_items{};
+
+    return doit_step(d_temp_storage,
+                     temp_storage_bytes,
+                     keys,
+                     items,
+                     keys_count,
+                     compare_op,
+                     stream,
+                     sort_items);
+  }
+
+  template <typename SORT_ITEMS,
+            typename STABLE,
+            typename Derived,
+            typename KeysIt,
+            typename ItemsIt,
+            typename CompareOp>
+  THRUST_RUNTIME_FUNCTION
+  void merge_sort(execution_policy<Derived>& policy,
+                  KeysIt                     keys_first,
+                  KeysIt                     keys_last,
+                  ItemsIt                    items_first,
+                  CompareOp                  compare_op)
+
+  {
+    typedef typename iterator_traits<KeysIt>::difference_type size_type;
+
+    size_type count = static_cast<size_type>(thrust::distance(keys_first, keys_last));
+
+    size_t       storage_size = 0;
+    cudaStream_t stream       = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    status = doit_step<SORT_ITEMS, STABLE>(NULL,
+                                           storage_size,
+                                           keys_first,
+                                           items_first,
+                                           count,
+                                           compare_op,
+                                           stream);
+    cuda_cub::throw_on_error(status, "merge_sort: failed on 1st step");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = doit_step<SORT_ITEMS, STABLE>(ptr,
+                                           storage_size,
+                                           keys_first,
+                                           items_first,
+                                           count,
+                                           compare_op,
+                                           stream);
+    cuda_cub::throw_on_error(status, "merge_sort: failed on 2nd step");
+
+    status = cuda_cub::synchronize_optional(policy);
+    cuda_cub::throw_on_error(status, "merge_sort: failed to synchronize");
+  }
+}    // namespace __merge_sort
+
+namespace __radix_sort {
+
+  template <class SORT_ITEMS, class Comparator>
+  struct dispatch;
+
+  // sort keys in ascending order
+  template <class K>
+  struct dispatch<thrust::detail::false_type, thrust::less<K> >
+  {
+    template <class Key, class Item, class Size>
+    THRUST_RUNTIME_FUNCTION static cudaError_t
+    doit(void*                    d_temp_storage,
+         size_t&                  temp_storage_bytes,
+         cub::DoubleBuffer<Key>&  keys_buffer,
+         cub::DoubleBuffer<Item>& /*items_buffer*/,
+         Size                     count,
+         cudaStream_t             stream)
+    {
+      return cub::DeviceRadixSort::SortKeys(d_temp_storage,
+                                            temp_storage_bytes,
+                                            keys_buffer,
+                                            static_cast<int>(count),
+                                            0,
+                                            static_cast<int>(sizeof(Key) * 8),
+                                            stream);
+    }
+  }; // struct dispatch -- sort keys in ascending order;
+
+  // sort keys in descending order
+  template <class K>
+  struct dispatch<thrust::detail::false_type, thrust::greater<K> >
+  {
+    template <class Key, class Item, class Size>
+    THRUST_RUNTIME_FUNCTION static cudaError_t
+    doit(void*                    d_temp_storage,
+         size_t&                  temp_storage_bytes,
+         cub::DoubleBuffer<Key>&  keys_buffer,
+         cub::DoubleBuffer<Item>& /*items_buffer*/,
+         Size                     count,
+         cudaStream_t             stream)
+    {
+      return cub::DeviceRadixSort::SortKeysDescending(d_temp_storage,
+                                                      temp_storage_bytes,
+                                                      keys_buffer,
+                                                      static_cast<int>(count),
+                                                      0,
+                                                      static_cast<int>(sizeof(Key) * 8),
+                                                      stream);
+    }
+  }; // struct dispatch -- sort keys in descending order;
+
+  // sort pairs in ascending order
+  template <class K>
+  struct dispatch<thrust::detail::true_type, thrust::less<K> >
+  {
+    template <class Key, class Item, class Size>
+    THRUST_RUNTIME_FUNCTION static cudaError_t
+    doit(void*                    d_temp_storage,
+         size_t&                  temp_storage_bytes,
+         cub::DoubleBuffer<Key>&  keys_buffer,
+         cub::DoubleBuffer<Item>& items_buffer,
+         Size                     count,
+         cudaStream_t             stream)
+    {
+      return cub::DeviceRadixSort::SortPairs(d_temp_storage,
+                                             temp_storage_bytes,
+                                             keys_buffer,
+                                             items_buffer,
+                                             static_cast<int>(count),
+                                             0,
+                                             static_cast<int>(sizeof(Key) * 8),
+                                             stream);
+    }
+  }; // struct dispatch -- sort pairs in ascending order;
+
+  // sort pairs in descending order
+  template <class K>
+  struct dispatch<thrust::detail::true_type, thrust::greater<K> >
+  {
+    template <class Key, class Item, class Size>
+    THRUST_RUNTIME_FUNCTION static cudaError_t
+    doit(void*                    d_temp_storage,
+         size_t&                  temp_storage_bytes,
+         cub::DoubleBuffer<Key>&  keys_buffer,
+         cub::DoubleBuffer<Item>& items_buffer,
+         Size                     count,
+         cudaStream_t             stream)
+    {
+      return cub::DeviceRadixSort::SortPairsDescending(d_temp_storage,
+                                                       temp_storage_bytes,
+                                                       keys_buffer,
+                                                       items_buffer,
+                                                       static_cast<int>(count),
+                                                       0,
+                                                       static_cast<int>(sizeof(Key) * 8),
+                                                       stream);
+    }
+  }; // struct dispatch -- sort pairs in descending order;
+
+  template <typename SORT_ITEMS,
+            typename Derived,
+            typename Key,
+            typename Item,
+            typename Size,
+            typename CompareOp>
+  THRUST_RUNTIME_FUNCTION
+  void radix_sort(execution_policy<Derived>& policy,
+                  Key*                       keys,
+                  Item*                      items,
+                  Size                       count,
+                  CompareOp)
+  {
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cub::DoubleBuffer<Key>  keys_buffer(keys, NULL);
+    cub::DoubleBuffer<Item> items_buffer(items, NULL);
+
+    Size keys_count = count;
+    Size items_count = SORT_ITEMS::value ? count : 0;
+
+    cudaError_t status;
+
+    status = dispatch<SORT_ITEMS, CompareOp>::doit(NULL,
+                                                   temp_storage_bytes,
+                                                   keys_buffer,
+                                                   items_buffer,
+                                                   keys_count,
+                                                   stream);
+    cuda_cub::throw_on_error(status, "radix_sort: failed on 1st step");
+
+    size_t keys_temp_storage  = core::align_to(sizeof(Key) * keys_count, 128);
+    size_t items_temp_storage = core::align_to(sizeof(Item) * items_count, 128);
+
+    size_t storage_size = keys_temp_storage
+                        + items_temp_storage
+                        + temp_storage_bytes;
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+
+    keys_buffer.d_buffers[1]  = thrust::detail::aligned_reinterpret_cast<Key*>(
+      tmp.data().get()
+    );
+    items_buffer.d_buffers[1] = thrust::detail::aligned_reinterpret_cast<Item*>(
+      tmp.data().get() + keys_temp_storage
+    );
+    void *ptr = static_cast<void*>(
+      tmp.data().get() + keys_temp_storage + items_temp_storage
+    );
+
+    status = dispatch<SORT_ITEMS, CompareOp>::doit(ptr,
+                                                   temp_storage_bytes,
+                                                   keys_buffer,
+                                                   items_buffer,
+                                                   keys_count,
+                                                   stream);
+    cuda_cub::throw_on_error(status, "radix_sort: failed on 2nd step");
+
+    if (keys_buffer.selector != 0)
+    {
+      Key* temp_ptr = reinterpret_cast<Key*>(keys_buffer.d_buffers[1]);
+      cuda_cub::copy_n(policy, temp_ptr, keys_count, keys);
+    }
+    THRUST_IF_CONSTEXPR(SORT_ITEMS::value)
+    {
+      if (items_buffer.selector != 0)
+      {
+        Item *temp_ptr = reinterpret_cast<Item *>(items_buffer.d_buffers[1]);
+        cuda_cub::copy_n(policy, temp_ptr, items_count, items);
+      }
+    }
+  }
+}    // __radix_sort
+
+//---------------------------------------------------------------------
+// Smart sort picks at compile-time whether to dispatch radix or merge sort
+//---------------------------------------------------------------------
+
+namespace __smart_sort {
+
+  template <class Key, class CompareOp>
+  struct can_use_primitive_sort
+      : thrust::detail::and_<
+            thrust::detail::is_arithmetic<Key>,
+            thrust::detail::or_<
+                thrust::detail::is_same<CompareOp, thrust::less<Key> >,
+                thrust::detail::is_same<CompareOp, thrust::greater<Key> > > > {};
+
+  template <class Iterator, class CompareOp>
+  struct enable_if_primitive_sort
+      : thrust::detail::enable_if<
+            can_use_primitive_sort<typename iterator_value<Iterator>::type,
+                                   CompareOp>::value> {};
+
+  template <class Iterator, class CompareOp>
+  struct enable_if_comparison_sort
+      : thrust::detail::disable_if<
+            can_use_primitive_sort<typename iterator_value<Iterator>::type,
+                                   CompareOp>::value> {};
+
+
+  template <class SORT_ITEMS,
+            class STABLE,
+            class Policy,
+            class KeysIt,
+            class ItemsIt,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION typename enable_if_comparison_sort<KeysIt, CompareOp>::type
+  smart_sort(Policy&   policy,
+             KeysIt    keys_first,
+             KeysIt    keys_last,
+             ItemsIt   items_first,
+             CompareOp compare_op)
+  {
+    __merge_sort::merge_sort<SORT_ITEMS, STABLE>(policy,
+                                                 keys_first,
+                                                 keys_last,
+                                                 items_first,
+                                                 compare_op);
+
+  }
+
+  template <class SORT_ITEMS,
+            class STABLE,
+            class Policy,
+            class KeysIt,
+            class ItemsIt,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION typename enable_if_primitive_sort<KeysIt, CompareOp>::type
+  smart_sort(execution_policy<Policy>& policy,
+             KeysIt                    keys_first,
+             KeysIt                    keys_last,
+             ItemsIt                   items_first,
+             CompareOp                 compare_op)
+  {
+    // ensure sequences have trivial iterators
+    thrust::detail::trivial_sequence<KeysIt, Policy>
+        keys(policy, keys_first, keys_last);
+
+    if (SORT_ITEMS::value)
+    {
+      thrust::detail::trivial_sequence<ItemsIt, Policy>
+          values(policy, items_first, items_first + (keys_last - keys_first));
+
+      __radix_sort::radix_sort<SORT_ITEMS>(
+          policy,
+          thrust::raw_pointer_cast(&*keys.begin()),
+          thrust::raw_pointer_cast(&*values.begin()),
+          keys_last - keys_first,
+          compare_op);
+
+      if (!is_contiguous_iterator<ItemsIt>::value)
+      {
+        cuda_cub::copy(policy, values.begin(), values.end(), items_first);
+      }
+    }
+    else
+    {
+      __radix_sort::radix_sort<SORT_ITEMS>(
+          policy,
+          thrust::raw_pointer_cast(&*keys.begin()),
+          thrust::raw_pointer_cast(&*keys.begin()),
+          keys_last - keys_first,
+          compare_op);
+    }
+
+    // copy results back, if necessary
+    if (!is_contiguous_iterator<KeysIt>::value)
+    {
+      cuda_cub::copy(policy, keys.begin(), keys.end(), keys_first);
+    }
+
+    cuda_cub::throw_on_error(
+      cuda_cub::synchronize_optional(policy),
+      "smart_sort: failed to synchronize");
+  }
+}    // namespace __smart_sort
+
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+
+__thrust_exec_check_disable__
+template <class Derived, class ItemsIt, class CompareOp>
+void __host__ __device__
+sort(execution_policy<Derived>& policy,
+     ItemsIt                    first,
+     ItemsIt                    last,
+     CompareOp                  compare_op)
+{
+  THRUST_CDP_DISPATCH(
+    (using item_t = thrust::iterator_value_t<ItemsIt>; item_t *null_ = nullptr;
+     __smart_sort::smart_sort<thrust::detail::false_type,
+                              thrust::detail::false_type>(policy,
+                                                          first,
+                                                          last,
+                                                          null_,
+                                                          compare_op);),
+    (thrust::sort(cvt_to_seq(derived_cast(policy)), first, last, compare_op);));
+}
+
+__thrust_exec_check_disable__
+template <class Derived, class ItemsIt, class CompareOp>
+void __host__ __device__
+stable_sort(execution_policy<Derived>& policy,
+            ItemsIt                    first,
+            ItemsIt                    last,
+            CompareOp                  compare_op)
+{
+  THRUST_CDP_DISPATCH(
+    (using item_t = thrust::iterator_value_t<ItemsIt>; item_t *null_ = nullptr;
+     __smart_sort::smart_sort<thrust::detail::false_type,
+                              thrust::detail::true_type>(policy,
+                                                         first,
+                                                         last,
+                                                         null_,
+                                                         compare_op);),
+    (thrust::stable_sort(cvt_to_seq(derived_cast(policy)),
+                         first,
+                         last,
+                         compare_op);));
+}
+
+__thrust_exec_check_disable__
+template <class Derived, class KeysIt, class ValuesIt, class CompareOp>
+void __host__ __device__
+sort_by_key(execution_policy<Derived>& policy,
+            KeysIt                     keys_first,
+            KeysIt                     keys_last,
+            ValuesIt                   values,
+            CompareOp                  compare_op)
+{
+  THRUST_CDP_DISPATCH(
+    (__smart_sort::smart_sort<thrust::detail::true_type,
+                              thrust::detail::false_type>(policy,
+                                                          keys_first,
+                                                          keys_last,
+                                                          values,
+                                                          compare_op);),
+    (thrust::sort_by_key(cvt_to_seq(derived_cast(policy)),
+                         keys_first,
+                         keys_last,
+                         values,
+                         compare_op);));
+}
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt,
+          class ValuesIt,
+          class CompareOp>
+void __host__ __device__
+stable_sort_by_key(execution_policy<Derived> &policy,
+            KeysIt                     keys_first,
+            KeysIt                     keys_last,
+            ValuesIt                   values,
+            CompareOp                  compare_op)
+{
+  THRUST_CDP_DISPATCH(
+    (__smart_sort::smart_sort<thrust::detail::true_type,
+                              thrust::detail::true_type>(policy,
+                                                         keys_first,
+                                                         keys_last,
+                                                         values,
+                                                         compare_op);),
+    (thrust::stable_sort_by_key(cvt_to_seq(derived_cast(policy)),
+                                keys_first,
+                                keys_last,
+                                values,
+                                compare_op);));
+}
+
+// API with default comparator
+
+template <class Derived, class ItemsIt>
+void __host__ __device__
+sort(execution_policy<Derived>& policy,
+     ItemsIt                    first,
+     ItemsIt                    last)
+{
+  typedef typename thrust::iterator_value<ItemsIt>::type item_type;
+  cuda_cub::sort(policy, first, last, less<item_type>());
+}
+
+template <class Derived, class ItemsIt>
+void __host__ __device__
+stable_sort(execution_policy<Derived>& policy,
+            ItemsIt                    first,
+            ItemsIt                    last)
+{
+  typedef typename thrust::iterator_value<ItemsIt>::type item_type;
+  cuda_cub::stable_sort(policy, first, last, less<item_type>());
+}
+
+template <class Derived, class KeysIt, class ValuesIt>
+void __host__ __device__
+sort_by_key(execution_policy<Derived>& policy,
+            KeysIt                     keys_first,
+            KeysIt                     keys_last,
+            ValuesIt                   values)
+{
+  typedef typename thrust::iterator_value<KeysIt>::type key_type;
+  cuda_cub::sort_by_key(policy, keys_first, keys_last, values, less<key_type>());
+}
+
+template <class Derived, class KeysIt, class ValuesIt>
+void __host__ __device__
+stable_sort_by_key(
+    execution_policy<Derived>& policy, KeysIt keys_first, KeysIt keys_last, ValuesIt values)
+{
+  typedef typename thrust::iterator_value<KeysIt>::type key_type;
+  cuda_cub::stable_sort_by_key(policy, keys_first, keys_last, values, less<key_type>());
+}
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/swap_ranges.h

@@ -0,0 +1,110 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/swap.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+namespace __swap_ranges {
+
+
+  template <class ItemsIt1, class ItemsIt2>
+  struct swap_f
+  {
+    ItemsIt1 items1;
+    ItemsIt2 items2;
+
+    typedef  typename iterator_traits<ItemsIt1>::value_type value1_type;
+    typedef  typename iterator_traits<ItemsIt2>::value_type value2_type;
+
+    THRUST_FUNCTION
+    swap_f(ItemsIt1 items1_, ItemsIt2 items2_)
+        : items1(items1_), items2(items2_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      value1_type item1 = items1[idx];
+      value2_type item2 = items2[idx];
+      // XXX thrust::swap is buggy
+      // if reference_type of ItemIt1/ItemsIt2
+      // is a proxy reference, then KABOOM!
+      // to avoid this, just copy the value first before swap
+      // *todo* specialize on real & proxy references
+      using thrust::swap;
+      swap(item1, item2);
+      items1[idx] = item1;
+      items2[idx] = item2;
+    }
+  };
+}    // namespace __swap_ranges
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2>
+ItemsIt2 __host__ __device__
+swap_ranges(execution_policy<Derived> &policy,
+            ItemsIt1                   first1,
+            ItemsIt1                   last1,
+            ItemsIt2                   first2)
+{
+  typedef typename iterator_traits<ItemsIt1>::difference_type size_type;
+
+  size_type num_items = static_cast<size_type>(thrust::distance(first1, last1));
+
+  cuda_cub::parallel_for(policy,
+                         __swap_ranges::swap_f<ItemsIt1,
+                                               ItemsIt2>(first1, first2),
+                         num_items);
+
+  return first2 + num_items;
+}
+
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/tabulate.h

@@ -0,0 +1,91 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/distance.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/execution_policy.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __tabulate {
+
+  template <class Iterator, class TabulateOp, class Size>
+  struct functor
+  {
+    Iterator items;
+    TabulateOp op;
+
+    __host__ __device__
+    functor(Iterator items_, TabulateOp op_)
+        : items(items_), op(op_) {}
+
+    void __device__ operator()(Size idx)
+    {
+      items[idx] = op(idx);
+    }
+  };    // struct functor
+
+}    // namespace __tabulate
+
+template <class Derived,
+          class Iterator,
+          class TabulateOp>
+void __host__ __device__
+tabulate(execution_policy<Derived>& policy,
+         Iterator                   first,
+         Iterator                   last,
+         TabulateOp                 tabulate_op)
+{
+  typedef typename iterator_traits<Iterator>::difference_type size_type;
+
+  size_type count = thrust::distance(first, last);
+
+  typedef __tabulate::functor<Iterator, TabulateOp, size_type> functor_t;
+
+  cuda_cub::parallel_for(policy,
+                         functor_t(first, tabulate_op),
+                         count);
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/temporary_buffer.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright 2008-2016 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
+
+// this system has no special temporary buffer functions
+

miniCUDA124/include/thrust/system/cuda/detail/terminate.h

@@ -0,0 +1,70 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#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/cuda/detail/util.h>
+#include <cstdio>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cuda
+{
+namespace detail
+{
+
+
+inline __device__
+void terminate()
+{
+  thrust::cuda_cub::terminate();
+}
+
+
+inline __host__ __device__
+void terminate_with_message(const char* message)
+{
+  printf("%s\n", message);
+  thrust::cuda_cub::terminate();
+}
+
+
+} // end detail
+} // end cuda
+} // end system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/cuda/detail/transform.h

@@ -0,0 +1,424 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/detail/type_traits/result_of_adaptable_function.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+
+namespace __transform {
+
+  struct no_stencil_tag
+  {
+  };
+
+  struct always_true_predicate
+  {
+    template <class T>
+    bool THRUST_DEVICE_FUNCTION operator()(T const &) const
+    {
+      return true;
+    }
+  };
+
+  template <class InputIt,
+            class OutputIt,
+            class StencilIt,
+            class TransformOp,
+            class Predicate>
+  struct unary_transform_f
+  {
+    InputIt     input;
+    OutputIt    output;
+    StencilIt   stencil;
+    TransformOp op;
+    Predicate   pred;
+
+    THRUST_FUNCTION
+    unary_transform_f(InputIt     input_,
+                      OutputIt    output_,
+                      StencilIt   stencil_,
+                      TransformOp op_,
+                      Predicate   pred_)
+        : input(input_),
+          output(output_),
+          stencil(stencil_),
+          op(op_),
+          pred(pred_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      if (pred(raw_reference_cast(stencil[idx])))
+        output[idx] = op(raw_reference_cast(input[idx]));
+    }
+  }; // struct unary_transform_stencil_f
+
+  template <class InputIt,
+            class OutputIt,
+            class TransformOp,
+            class Predicate>
+  struct unary_transform_f<InputIt,
+                           OutputIt,
+                           no_stencil_tag,
+                           TransformOp,
+                           Predicate>
+  {
+    InputIt     input;
+    OutputIt    output;
+    TransformOp op;
+    Predicate   pred;
+
+    THRUST_FUNCTION
+    unary_transform_f(InputIt        input_,
+                      OutputIt       output_,
+                      no_stencil_tag,
+                      TransformOp    op_,
+                      Predicate      pred_)
+        : input(input_), output(output_), op(op_), pred(pred_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      if (pred(raw_reference_cast(input[idx])))
+        output[idx] = op(raw_reference_cast(input[idx]));
+    }
+  }; // struct unary_transform_f
+
+  template <class InputIt1,
+            class InputIt2,
+            class OutputIt,
+            class StencilIt,
+            class TransformOp,
+            class Predicate>
+  struct binary_transform_f
+  {
+    InputIt1    input1;
+    InputIt2    input2;
+    OutputIt    output;
+    StencilIt   stencil;
+    TransformOp op;
+    Predicate   pred;
+
+    THRUST_FUNCTION
+    binary_transform_f(InputIt1    input1_,
+                       InputIt2    input2_,
+                       OutputIt    output_,
+                       StencilIt   stencil_,
+                       TransformOp op_,
+                       Predicate   pred_)
+        : input1(input1_),
+          input2(input2_),
+          output(output_),
+          stencil(stencil_),
+          op(op_),
+          pred(pred_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      if (pred(raw_reference_cast(stencil[idx])))
+        output[idx] = op(raw_reference_cast(input1[idx]),
+                         raw_reference_cast(input2[idx]));
+    }
+  }; // struct binary_transform_stencil_f
+
+  template <class InputIt1,
+            class InputIt2,
+            class OutputIt,
+            class TransformOp,
+            class Predicate>
+  struct binary_transform_f<InputIt1,
+                            InputIt2,
+                            OutputIt,
+                            no_stencil_tag,
+                            TransformOp,
+                            Predicate>
+  {
+    InputIt1    input1;
+    InputIt2    input2;
+    OutputIt    output;
+    TransformOp op;
+    Predicate   pred;
+
+    THRUST_FUNCTION
+    binary_transform_f(InputIt1       input1_,
+                       InputIt2       input2_,
+                       OutputIt       output_,
+                       no_stencil_tag ,
+                       TransformOp    op_,
+                       Predicate      pred_)
+        : input1(input1_),
+          input2(input2_),
+          output(output_),
+          op(op_),
+          pred(pred_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      if (pred(raw_reference_cast(input1[idx])))
+        output[idx] = op(raw_reference_cast(input1[idx]),
+                         raw_reference_cast(input2[idx]));
+    }
+  }; // struct binary_transform_f
+
+  template <class Policy,
+            class InputIt,
+            class Size,
+            class OutputIt,
+            class StencilIt,
+            class TransformOp,
+            class Predicate>
+  OutputIt THRUST_FUNCTION
+  unary(Policy &     policy,
+        InputIt      items,
+        OutputIt     result,
+        Size         num_items,
+        StencilIt    stencil,
+        TransformOp  transform_op,
+        Predicate    predicate)
+  {
+    if (num_items == 0)
+      return result;
+
+    typedef unary_transform_f<InputIt,
+                              OutputIt,
+                              StencilIt,
+                              TransformOp,
+                              Predicate>
+        unary_transform_t;
+
+    cuda_cub::parallel_for(policy,
+                           unary_transform_t(items,
+                                             result,
+                                             stencil,
+                                             transform_op,
+                                             predicate),
+                           num_items);
+
+    return result + num_items;
+  }
+
+  template <class Policy,
+            class InputIt1,
+            class InputIt2,
+            class Size,
+            class OutputIt,
+            class StencilIt,
+            class TransformOp,
+            class Predicate>
+  OutputIt THRUST_FUNCTION
+  binary(Policy &    policy,
+         InputIt1    items1,
+         InputIt2    items2,
+         OutputIt    result,
+         Size        num_items,
+         StencilIt   stencil,
+         TransformOp transform_op,
+         Predicate   predicate)
+  {
+    if (num_items == 0)
+      return result;
+
+    typedef binary_transform_f<InputIt1,
+                               InputIt2,
+                               OutputIt,
+                               StencilIt,
+                               TransformOp,
+                               Predicate>
+        binary_transform_t;
+
+    cuda_cub::parallel_for(policy,
+                           binary_transform_t(items1,
+                                              items2,
+                                              result,
+                                              stencil,
+                                              transform_op,
+                                              predicate),
+                           num_items);
+
+    return result + num_items;
+  }
+
+}    // namespace __transform
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+//-------------------------
+//  one input data stream
+//-------------------------
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class StencilInputIt,
+          class TransformOp,
+          class Predicate>
+OutputIt THRUST_FUNCTION
+transform_if(execution_policy<Derived> &policy,
+             InputIt                    first,
+             InputIt                    last,
+             StencilInputIt             stencil,
+             OutputIt                   result,
+             TransformOp                transform_op,
+             Predicate                  predicate)
+{
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
+  return __transform::unary(policy,
+                            first,
+                            result,
+                            num_items,
+                            stencil,
+                            transform_op,
+                            predicate);
+}    // func transform_if
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class TransformOp,
+          class Predicate>
+OutputIt THRUST_FUNCTION
+transform_if(execution_policy<Derived> &policy,
+             InputIt                    first,
+             InputIt                    last,
+             OutputIt                   result,
+             TransformOp                transform_op,
+             Predicate                  predicate)
+{
+  return cuda_cub::transform_if(policy,
+                                first,
+                                last,
+                                __transform::no_stencil_tag(),
+                                result,
+                                transform_op,
+                                predicate);
+}    // func transform_if
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class TransformOp>
+OutputIt THRUST_FUNCTION
+transform(execution_policy<Derived> &policy,
+          InputIt                    first,
+          InputIt                    last,
+          OutputIt                   result,
+          TransformOp                transform_op)
+{
+  return cuda_cub::transform_if(policy,
+                                first,
+                                last,
+                                result,
+                                transform_op,
+                                __transform::always_true_predicate());
+} // func transform
+
+//-------------------------
+// two input data streams
+//-------------------------
+
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class StencilInputIt,
+          class OutputIt,
+          class TransformOp,
+          class Predicate>
+OutputIt THRUST_FUNCTION
+transform_if(execution_policy<Derived> &policy,
+             InputIt1                   first1,
+             InputIt1                   last1,
+             InputIt2                   first2,
+             StencilInputIt             stencil,
+             OutputIt                   result,
+             TransformOp                transform_op,
+             Predicate                  predicate)
+{
+  typedef typename iterator_traits<InputIt1>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first1, last1));
+  return __transform::binary(policy,
+                             first1,
+                             first2,
+                             result,
+                             num_items,
+                             stencil,
+                             transform_op,
+                             predicate);
+}    // func transform_if
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class OutputIt,
+          class TransformOp>
+OutputIt THRUST_FUNCTION
+transform(execution_policy<Derived> &policy,
+          InputIt1                   first1,
+          InputIt1                   last1,
+          InputIt2                   first2,
+          OutputIt                   result,
+          TransformOp                transform_op)
+{
+  return cuda_cub::transform_if(policy,
+                                first1,
+                                last1,
+                                first2,
+                                __transform::no_stencil_tag(),
+                                result,
+                                transform_op,
+                                __transform::always_true_predicate());
+} // func transform
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/transform_reduce.h

@@ -0,0 +1,76 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/system/cuda/detail/reduce.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt,
+          class TransformOp,
+          class T,
+          class ReduceOp>
+T __host__ __device__
+transform_reduce(execution_policy<Derived> &policy,
+                 InputIt                    first,
+                 InputIt                    last,
+                 TransformOp                transform_op,
+                 T                          init,
+                 ReduceOp                   reduce_op)
+{
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
+  typedef transform_input_iterator_t<T,
+                                     InputIt,
+                                     TransformOp>
+      transformed_iterator_t;
+
+  return cuda_cub::reduce_n(policy,
+                            transformed_iterator_t(first, transform_op),
+                            num_items,
+                            init,
+                            reduce_op);
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/transform_scan.h

@@ -0,0 +1,117 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/detail/type_traits.h>
+#include <thrust/distance.h>
+#include <thrust/system/cuda/detail/scan.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class TransformOp,
+          class ScanOp>
+OutputIt __host__ __device__
+transform_inclusive_scan(execution_policy<Derived> &policy,
+                         InputIt                    first,
+                         InputIt                    last,
+                         OutputIt                   result,
+                         TransformOp                transform_op,
+                         ScanOp                     scan_op)
+{
+  // Use the transformed input iterator's value type per https://wg21.link/P0571
+  using input_type = typename thrust::iterator_value<InputIt>::type;
+  using result_type = thrust::detail::invoke_result_t<TransformOp, input_type>;
+  using value_type = thrust::remove_cvref_t<result_type>;
+
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
+  typedef transform_input_iterator_t<value_type,
+                                     InputIt,
+                                     TransformOp>
+      transformed_iterator_t;
+
+  return cuda_cub::inclusive_scan_n(policy,
+                                 transformed_iterator_t(first, transform_op),
+                                 num_items,
+                                 result,
+                                 scan_op);
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class TransformOp,
+          class InitialValueType,
+          class ScanOp>
+OutputIt __host__ __device__
+transform_exclusive_scan(execution_policy<Derived> &policy,
+                         InputIt                    first,
+                         InputIt                    last,
+                         OutputIt                   result,
+                         TransformOp                transform_op,
+                         InitialValueType           init,
+                         ScanOp                     scan_op)
+{
+  // Use the initial value type per https://wg21.link/P0571
+  using result_type = thrust::remove_cvref_t<InitialValueType>;
+
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
+  typedef transform_input_iterator_t<result_type,
+                                     InputIt,
+                                     TransformOp>
+      transformed_iterator_t;
+
+  return cuda_cub::exclusive_scan_n(policy,
+                                 transformed_iterator_t(first, transform_op),
+                                 num_items,
+                                 result,
+                                 init,
+                                 scan_op);
+}
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/uninitialized_copy.h

@@ -0,0 +1,119 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/distance.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+namespace __uninitialized_copy {
+
+  template <class InputIt, class OutputIt>
+  struct functor
+  {
+    InputIt  input;
+    OutputIt output;
+
+    typedef typename iterator_traits<InputIt>::value_type  InputType;
+    typedef typename iterator_traits<OutputIt>::value_type OutputType;
+
+    THRUST_FUNCTION
+    functor(InputIt input_, OutputIt output_)
+        : input(input_), output(output_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      InputType const &in  = raw_reference_cast(input[idx]);
+      OutputType &     out = raw_reference_cast(output[idx]);
+
+#if defined(__CUDA__) && defined(__clang__)
+      // XXX unsafe, but clang is seemngly unable to call in-place new
+      out = in;
+#else
+      ::new (static_cast<void *>(&out)) OutputType(in);
+#endif
+    }
+  };    // struct functor
+
+}    // namespace __uninitialized_copy
+
+template <class Derived,
+          class InputIt,
+          class Size,
+          class OutputIt>
+OutputIt __host__ __device__
+uninitialized_copy_n(execution_policy<Derived> &policy,
+                     InputIt                    first,
+                     Size                       count,
+                     OutputIt                   result)
+{
+  typedef __uninitialized_copy::functor<InputIt,OutputIt> functor_t;
+
+  cuda_cub::parallel_for(policy,
+                         functor_t(first, result),
+                         count);
+
+  return result + count;
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt>
+OutputIt __host__ __device__
+uninitialized_copy(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   OutputIt                   result)
+{
+  return cuda_cub::uninitialized_copy_n(policy,
+                                        first,
+                                        thrust::distance(first, last),
+                                        result);
+}
+
+}    // namespace cuda_
+
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/uninitialized_fill.h

@@ -0,0 +1,117 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/distance.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+namespace __uninitialized_fill {
+
+  template <class Iterator, class T>
+  struct functor
+  {
+    Iterator  items;
+    T         value;
+
+    typedef typename iterator_traits<Iterator>::value_type value_type;
+
+    THRUST_FUNCTION
+    functor(Iterator items_, T const& value_)
+        : items(items_), value(value_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      value_type& out = raw_reference_cast(items[idx]);
+
+#if defined(__CUDA__) && defined(__clang__)
+      // XXX unsafe. cuda-clang is seemingly unable to call ::new in device code
+      out = value;
+#else
+      ::new (static_cast<void *>(&out)) value_type(value);
+#endif
+    }
+  };    // struct functor
+
+}    // namespace __uninitialized_copy
+
+template <class Derived,
+          class Iterator,
+          class Size,
+          class T>
+Iterator __host__ __device__
+uninitialized_fill_n(execution_policy<Derived>& policy,
+                     Iterator                   first,
+                     Size                       count,
+                     T const&                   x)
+{
+  typedef __uninitialized_fill::functor<Iterator,T> functor_t;
+
+  cuda_cub::parallel_for(policy,
+                         functor_t(first, x),
+                         count);
+
+  return first + count;
+}
+
+template <class Derived,
+          class Iterator,
+          class T>
+void __host__ __device__
+uninitialized_fill(execution_policy<Derived>& policy,
+                   Iterator                   first,
+                   Iterator                   last,
+                   T const&                   x)
+{
+  cuda_cub::uninitialized_fill_n(policy,
+                              first,
+                              thrust::distance(first, last),
+                              x);
+}
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/unique.h

@@ -0,0 +1,829 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/advance.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/device_select.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__ ForwardIterator
+unique(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    ForwardIterator                                             first,
+    ForwardIterator                                             last,
+    BinaryPredicate                                             binary_pred);
+
+template <typename DerivedPolicy,
+          typename InputIterator,
+          typename OutputIterator,
+          typename BinaryPredicate>
+__host__ __device__ OutputIterator
+unique_copy(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    InputIterator                                               first,
+    InputIterator                                               last,
+    OutputIterator                                              result,
+    BinaryPredicate                                             binary_pred);
+
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__ typename thrust::iterator_traits<ForwardIterator>::difference_type
+unique_count(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    ForwardIterator                                             first,
+    ForwardIterator                                             last,
+    BinaryPredicate                                             binary_pred);
+
+namespace cuda_cub {
+
+// XXX  it should be possible to unify unique & unique_by_key into a single
+//      agent with various specializations, similar to what is done
+//      with partition
+namespace __unique {
+
+  template <int                     _BLOCK_THREADS,
+            int                     _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier  _LOAD_MODIFIER    = cub::LOAD_LDG,
+            cub::BlockScanAlgorithm _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS    = _BLOCK_THREADS,
+      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = _BLOCK_THREADS * _ITEMS_PER_THREAD,
+    };
+    static const cub::BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier  LOAD_MODIFIER  = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM;
+  };    // struct PtxPolicy
+
+  template<class,class>
+  struct Tuning;
+
+  namespace mpl = thrust::detail::mpl::math;
+
+  template<class T, int NOMINAL_4B_ITEMS_PER_THREAD>
+  struct items_per_thread
+  {
+    enum
+    {
+      value = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<int,
+                   1,
+                   static_cast<int>(NOMINAL_4B_ITEMS_PER_THREAD * 4 /
+                    sizeof(T))>::value>::value
+    };
+  };
+
+  template<class T>
+  struct Tuning<sm52,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 11,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<64,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm52
+
+
+  template <class T>
+  struct Tuning<sm35, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 9,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm35
+
+  template<class T>
+  struct Tuning<sm30,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm30
+
+  template <class ItemsIt,
+            class ItemsOutputIt,
+            class BinaryPred,
+            class Size,
+            class NumSelectedOutIt>
+  struct UniqueAgent
+  {
+    typedef typename iterator_traits<ItemsIt>::value_type item_type;
+
+    typedef cub::ScanTileState<Size> ScanTileState;
+
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, item_type>::type
+    {
+      typedef Tuning<Arch, item_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, ItemsIt>::type ItemsLoadIt;
+
+      typedef typename core::BlockLoad<PtxPlan, ItemsLoadIt>::type BlockLoadItems;
+
+      typedef cub::BlockDiscontinuity<item_type,
+                                      PtxPlan::BLOCK_THREADS,
+                                      1,
+                                      1,
+                                      Arch::ver>
+          BlockDiscontinuityItems;
+
+      typedef cub::TilePrefixCallbackOp<Size,
+                                        cub::Sum,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+      typedef cub::BlockScan<Size,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+      typedef core::uninitialized_array<item_type, PtxPlan::ITEMS_PER_TILE>
+          shared_items_t;
+
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage               scan;
+          typename TilePrefixCallback::TempStorage      prefix;
+          typename BlockDiscontinuityItems::TempStorage discontinuity;
+        } scan_storage;
+
+        typename BlockLoadItems::TempStorage  load_items;
+        shared_items_t shared_items;
+
+      };    // union TempStorage
+    };      // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::ItemsLoadIt             ItemsLoadIt;
+    typedef typename ptx_plan::BlockLoadItems          BlockLoadItems;
+    typedef typename ptx_plan::BlockDiscontinuityItems BlockDiscontinuityItems;
+    typedef typename ptx_plan::TilePrefixCallback      TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan               BlockScan;
+    typedef typename ptx_plan::shared_items_t          shared_items_t;
+    typedef typename ptx_plan::TempStorage             TempStorage;
+
+    enum
+    {
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = ptx_plan::ITEMS_PER_TILE
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &                      temp_storage;
+      ScanTileState &                    tile_state;
+      ItemsLoadIt                        items_in;
+      ItemsOutputIt                      items_out;
+      cub::InequalityWrapper<BinaryPred> predicate;
+      Size                               num_items;
+
+      //---------------------------------------------------------------------
+      // Utility functions
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      shared_items_t &get_shared()
+      {
+        return temp_storage.shared_items;
+      }
+
+      void THRUST_DEVICE_FUNCTION
+      scatter(item_type (&items)[ITEMS_PER_THREAD],
+              Size (&selection_flags)[ITEMS_PER_THREAD],
+              Size (&selection_indices)[ITEMS_PER_THREAD],
+              int  /*num_tile_items*/,
+              int  num_tile_selections,
+              Size num_selections_prefix,
+              Size /*num_selections*/)
+      {
+        using core::sync_threadblock;
+
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int local_scatter_offset = selection_indices[ITEM] -
+                                     num_selections_prefix;
+          if (selection_flags[ITEM])
+          {
+            get_shared()[local_scatter_offset] = items[ITEM];
+          }
+        }
+
+        sync_threadblock();
+
+        for (int item = threadIdx.x;
+             item < num_tile_selections;
+             item += BLOCK_THREADS)
+        {
+          items_out[num_selections_prefix + item] = get_shared()[item];
+        }
+
+        sync_threadblock();
+      }
+
+      //---------------------------------------------------------------------
+      // Tile processing
+      //---------------------------------------------------------------------
+
+      template <bool IS_LAST_TILE, bool IS_FIRST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile_impl(int  num_tile_items,
+                        int  tile_idx,
+                        Size tile_base)
+      {
+        using core::sync_threadblock;
+        using core::uninitialized_array;
+
+        item_type items_loc[ITEMS_PER_THREAD];
+        Size      selection_flags[ITEMS_PER_THREAD];
+        Size      selection_idx[ITEMS_PER_THREAD];
+
+        if (IS_LAST_TILE)
+        {
+          BlockLoadItems(temp_storage.load_items)
+              .Load(items_in + tile_base,
+                    items_loc,
+                    num_tile_items,
+                    *(items_in + tile_base));
+        }
+        else
+        {
+          BlockLoadItems(temp_storage.load_items)
+              .Load(items_in + tile_base, items_loc);
+        }
+
+
+        sync_threadblock();
+
+        if (IS_FIRST_TILE)
+        {
+          BlockDiscontinuityItems(temp_storage.scan_storage.discontinuity)
+              .FlagHeads(selection_flags, items_loc, predicate);
+        }
+        else
+        {
+          item_type tile_predecessor = items_in[tile_base - 1];
+          BlockDiscontinuityItems(temp_storage.scan_storage.discontinuity)
+              .FlagHeads(selection_flags, items_loc, predicate, tile_predecessor);
+        }
+
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          // Set selection_flags for out-of-bounds items
+          if ((IS_LAST_TILE) &&
+              (Size(threadIdx.x * ITEMS_PER_THREAD) + ITEM >= num_tile_items))
+            selection_flags[ITEM] = 1;
+        }
+
+        sync_threadblock();
+
+        Size num_tile_selections   = 0;
+        Size num_selections        = 0;
+        Size num_selections_prefix = 0;
+        if (IS_FIRST_TILE)
+        {
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            num_tile_selections);
+
+          if (threadIdx.x == 0)
+          {
+            // Update tile status if this is not the last tile
+            if (!IS_LAST_TILE)
+              tile_state.SetInclusive(0, num_tile_selections);
+          }
+
+          // Do not count any out-of-bounds selections
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+          }
+          num_selections = num_tile_selections;
+        }
+        else
+        {
+          TilePrefixCallback prefix_cb(tile_state,
+                                       temp_storage.scan_storage.prefix,
+                                       cub::Sum(),
+                                       tile_idx);
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            prefix_cb);
+
+          num_selections        = prefix_cb.GetInclusivePrefix();
+          num_tile_selections   = prefix_cb.GetBlockAggregate();
+          num_selections_prefix = prefix_cb.GetExclusivePrefix();
+
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+            num_selections -= num_discount;
+          }
+        }
+
+        sync_threadblock();
+
+        scatter(items_loc,
+                selection_flags,
+                selection_idx,
+                num_tile_items,
+                num_tile_selections,
+                num_selections_prefix,
+                num_selections);
+
+        return num_selections;
+      }
+
+
+      template <bool IS_LAST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile(int  num_tile_items,
+                   int  tile_idx,
+                   Size tile_base)
+      {
+        if (tile_idx == 0)
+        {
+          return consume_tile_impl<IS_LAST_TILE, true>(num_tile_items,
+                                                       tile_idx,
+                                                       tile_base);
+        }
+        else
+        {
+          return consume_tile_impl<IS_LAST_TILE, false>(num_tile_items,
+                                                        tile_idx,
+                                                        tile_base);
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      impl(TempStorage &    temp_storage_,
+           ScanTileState &  tile_state_,
+           ItemsLoadIt      items_in_,
+           ItemsOutputIt    items_out_,
+           BinaryPred       binary_pred_,
+           Size             num_items_,
+           int              num_tiles,
+           NumSelectedOutIt num_selected_out)
+          : temp_storage(temp_storage_),
+            tile_state(tile_state_),
+            items_in(items_in_),
+            items_out(items_out_),
+            predicate(binary_pred_),
+            num_items(num_items_)
+      {
+        int  tile_idx  = blockIdx.x;
+        Size tile_base = tile_idx * ITEMS_PER_TILE;
+
+        if (tile_idx < num_tiles - 1)
+        {
+          consume_tile<false>(ITEMS_PER_TILE,
+                              tile_idx,
+                              tile_base);
+        }
+        else
+        {
+          int  num_remaining  = static_cast<int>(num_items - tile_base);
+          Size num_selections = consume_tile<true>(num_remaining,
+                                                   tile_idx,
+                                                   tile_base);
+          if (threadIdx.x == 0)
+          {
+            *num_selected_out = num_selections;
+          }
+        }
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ItemsIt          items_in,
+                       ItemsOutputIt    items_out,
+                       BinaryPred       binary_pred,
+                       NumSelectedOutIt num_selected_out,
+                       Size             num_items,
+                       ScanTileState    tile_state,
+                       int              num_tiles,
+                       char *           shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
+
+      impl(storage,
+           tile_state,
+           core::make_load_iterator(ptx_plan(), items_in),
+           items_out,
+           binary_pred,
+           num_items,
+           num_tiles,
+           num_selected_out);
+    }
+  };    // struct UniqueAgent
+
+  template <class ScanTileState,
+            class NumSelectedIt,
+            class Size>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       NumSelectedIt num_selected_out,
+                       char * /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+      if (blockIdx.x == 0 && threadIdx.x == 0)
+        *num_selected_out = 0;
+    }
+
+  }; // struct InitAgent
+
+  template <class ItemsInputIt,
+            class ItemsOutputIt,
+            class BinaryPred,
+            class Size,
+            class NumSelectedOutIt>
+  static cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *           d_temp_storage,
+            size_t &         temp_storage_bytes,
+            ItemsInputIt     items_in,
+            ItemsOutputIt    items_out,
+            BinaryPred       binary_pred,
+            NumSelectedOutIt num_selected_out,
+            Size             num_items,
+            cudaStream_t     stream)
+  {
+    using core::AgentLauncher;
+    using core::AgentPlan;
+    using core::get_agent_plan;
+
+    typedef AgentLauncher<
+        UniqueAgent<ItemsInputIt,
+                    ItemsOutputIt,
+                    BinaryPred,
+                    Size,
+                    NumSelectedOutIt> >
+        unique_agent;
+
+    typedef typename unique_agent::ScanTileState ScanTileState;
+
+    typedef AgentLauncher<
+        InitAgent<ScanTileState, NumSelectedOutIt, Size> >
+        init_agent;
+
+    using core::get_plan;
+    typename get_plan<init_agent>::type   init_plan   = init_agent::get_plan();
+    typename get_plan<unique_agent>::type unique_plan = unique_agent::get_plan(stream);
+
+
+    int tile_size = unique_plan.items_per_tile;
+    size_t num_tiles = cub::DivideAndRoundUp(num_items, tile_size);
+
+    size_t vshmem_size = core::vshmem_size(unique_plan.shared_memory_size,
+                                           num_tiles);
+
+    cudaError_t status = cudaSuccess;
+    size_t      allocation_sizes[2] = {0, vshmem_size};
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles), allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    void *allocations[2] = {NULL, NULL};
+    //
+    status = cub::AliasTemporaries(d_temp_storage,
+                                   temp_storage_bytes,
+                                   allocations,
+                                   allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_status;
+    status =  tile_status.Init(static_cast<int>(num_tiles), allocations[0], allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    num_tiles = max<size_t>(1,num_tiles);
+    init_agent ia(init_plan, num_tiles, stream, "unique_by_key::init_agent");
+    ia.launch(tile_status, num_tiles, num_selected_out);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    if (num_items == 0) { return status; }
+
+    char *vshmem_ptr = vshmem_size > 0 ? (char *)allocations[1] : NULL;
+
+    unique_agent ua(unique_plan, num_items, stream, vshmem_ptr, "unique_by_key::unique_agent");
+    ua.launch(items_in,
+              items_out,
+              binary_pred,
+              num_selected_out,
+              num_items,
+              tile_status,
+              num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    return status;
+  }
+
+  template <typename Derived,
+            typename ItemsInputIt,
+            typename ItemsOutputIt,
+            typename BinaryPred>
+  THRUST_RUNTIME_FUNCTION
+  ItemsOutputIt unique(execution_policy<Derived>& policy,
+                       ItemsInputIt               items_first,
+                       ItemsInputIt               items_last,
+                       ItemsOutputIt              items_result,
+                       BinaryPred                 binary_pred)
+  {
+    //  typedef typename iterator_traits<ItemsInputIt>::difference_type size_type;
+    typedef int size_type;
+
+    size_type    num_items          = static_cast<size_type>(thrust::distance(items_first, items_last));
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    status = doit_step(NULL,
+                       temp_storage_bytes,
+                       items_first,
+                       items_result,
+                       binary_pred,
+                       reinterpret_cast<size_type*>(NULL),
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "unique: failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(size_type), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "unique: failed on 1st step");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "unique: failed on 2nd step");
+
+    size_type* d_num_selected_out
+      = thrust::detail::aligned_reinterpret_cast<size_type*>(allocations[0]);
+
+    status = doit_step(allocations[1],
+                       temp_storage_bytes,
+                       items_first,
+                       items_result,
+                       binary_pred,
+                       d_num_selected_out,
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "unique: failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "unique: failed to synchronize");
+
+    size_type num_selected = get_value(policy, d_num_selected_out);
+
+    return items_result + num_selected;
+  }
+}    // namespace __unique
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class BinaryPred>
+OutputIt __host__ __device__
+unique_copy(execution_policy<Derived> &policy,
+            InputIt                    first,
+            InputIt                    last,
+            OutputIt                   result,
+            BinaryPred                 binary_pred)
+{
+  THRUST_CDP_DISPATCH(
+    (result = __unique::unique(policy, first, last, result, binary_pred);),
+    (result = thrust::unique_copy(cvt_to_seq(derived_cast(policy)),
+                                  first,
+                                  last,
+                                  result,
+                                  binary_pred);));
+  return result;
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt>
+OutputIt __host__ __device__
+unique_copy(execution_policy<Derived> &policy,
+            InputIt                    first,
+            InputIt                    last,
+            OutputIt                   result)
+{
+  typedef typename iterator_traits<InputIt>::value_type input_type;
+  return cuda_cub::unique_copy(policy, first, last, result, equal_to<input_type>());
+}
+
+
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ForwardIt,
+          class BinaryPred>
+ForwardIt __host__ __device__
+unique(execution_policy<Derived> &policy,
+       ForwardIt                  first,
+       ForwardIt                  last,
+       BinaryPred                 binary_pred)
+{
+  ForwardIt ret = first;
+  THRUST_CDP_DISPATCH(
+    (ret = cuda_cub::unique_copy(policy, first, last, first, binary_pred);),
+    (ret = thrust::unique(cvt_to_seq(derived_cast(policy)),
+                          first,
+                          last,
+                          binary_pred);));
+  return ret;
+}
+
+template <class Derived,
+          class ForwardIt>
+ForwardIt __host__ __device__
+unique(execution_policy<Derived> &policy,
+       ForwardIt                  first,
+       ForwardIt                  last)
+{
+  typedef typename iterator_traits<ForwardIt>::value_type input_type;
+  return cuda_cub::unique(policy, first, last, equal_to<input_type>());
+}
+
+
+template <typename BinaryPred>
+struct zip_adj_not_predicate {
+  template <typename TupleType>
+  bool __host__ __device__ operator()(TupleType&& tuple) {
+      return !binary_pred(thrust::get<0>(tuple), thrust::get<1>(tuple));
+  }
+
+  BinaryPred binary_pred;
+};
+
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ForwardIt,
+          class BinaryPred>
+typename thrust::iterator_traits<ForwardIt>::difference_type
+__host__ __device__
+unique_count(execution_policy<Derived> &policy,
+       ForwardIt                  first,
+       ForwardIt                  last,
+       BinaryPred                 binary_pred)
+{
+  if (first == last) {
+    return 0;
+  }
+  auto size = thrust::distance(first, last);
+  auto it = thrust::make_zip_iterator(thrust::make_tuple(first, thrust::next(first)));
+  return 1 + thrust::count_if(policy, it, thrust::next(it, size - 1), zip_adj_not_predicate<BinaryPred>{binary_pred});
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+//
+#include <thrust/memory.h>
+#include <thrust/unique.h>
+#endif

miniCUDA124/include/thrust/system/cuda/detail/unique_by_key.h

@@ -0,0 +1,927 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/detail/mpl/math.h>
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+#include <thrust/pair.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/device_select.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy,
+          typename ForwardIterator1,
+          typename ForwardIterator2>
+__host__ __device__ thrust::pair<ForwardIterator1, ForwardIterator2>
+unique_by_key(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    ForwardIterator1                                            keys_first,
+    ForwardIterator1                                            keys_last,
+    ForwardIterator2                                            values_first);
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator1,
+          typename OutputIterator2>
+__host__ __device__ thrust::pair<OutputIterator1, OutputIterator2>
+unique_by_key_copy(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    InputIterator1                                              keys_first,
+    InputIterator1                                              keys_last,
+    InputIterator2                                              values_first,
+    OutputIterator1                                             keys_result,
+    OutputIterator2                                             values_result);
+
+
+namespace cuda_cub {
+
+// XXX  it should be possible to unify unique & unique_by_key into a single
+//      agent with various specializations, similar to what is done
+//      with partition
+namespace __unique_by_key {
+
+  template <int                     _BLOCK_THREADS,
+            int                     _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier  _LOAD_MODIFIER    = cub::LOAD_LDG,
+            cub::BlockScanAlgorithm _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS    = _BLOCK_THREADS,
+      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = _BLOCK_THREADS * _ITEMS_PER_THREAD,
+    };
+    static const cub::BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier  LOAD_MODIFIER  = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM;
+  };    // struct PtxPolicy
+
+  template<class,class>
+  struct Tuning;
+
+  namespace mpl = thrust::detail::mpl::math;
+
+  template<class T, size_t NOMINAL_4B_ITEMS_PER_THREAD>
+  struct items_per_thread
+  {
+    enum
+    {
+      value = mpl::min<
+          int,
+          static_cast<int>(NOMINAL_4B_ITEMS_PER_THREAD),
+          mpl::max<int,
+                   1,
+                   static_cast<int>(NOMINAL_4B_ITEMS_PER_THREAD * 4 /
+                   sizeof(T))>::value>::value
+    };
+  };
+
+
+  template<class T>
+  struct Tuning<sm52,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 11,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<64,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm52
+
+  template<class T>
+  struct Tuning<sm35,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 9,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm35
+
+  template<class T>
+  struct Tuning<sm30,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm30
+
+  template <class KeyInputIt,
+            class ValInputIt,
+            class KeyOutputIt,
+            class ValOutputIt,
+            class BinaryPred,
+            class Size,
+            class NumSelectedOutIt>
+  struct UniqueByKeyAgent
+  {
+    typedef typename iterator_traits<KeyInputIt>::value_type key_type;
+    typedef typename iterator_traits<ValInputIt>::value_type value_type;
+
+    typedef cub::ScanTileState<Size> ScanTileState;
+
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, key_type>::type
+    {
+      typedef Tuning<Arch, key_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, KeyInputIt>::type KeyLoadIt;
+      typedef typename core::LoadIterator<PtxPlan, ValInputIt>::type ValLoadIt;
+
+      typedef typename core::BlockLoad<PtxPlan, KeyLoadIt>::type BlockLoadKeys;
+      typedef typename core::BlockLoad<PtxPlan, ValLoadIt>::type BlockLoadValues;
+
+      typedef cub::BlockDiscontinuity<key_type,
+                                      PtxPlan::BLOCK_THREADS,
+                                      1,
+                                      1,
+                                      Arch::ver>
+          BlockDiscontinuityKeys;
+
+      typedef cub::TilePrefixCallbackOp<Size,
+                                        cub::Sum,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+      typedef cub::BlockScan<Size,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+      typedef core::uninitialized_array<key_type, PtxPlan::ITEMS_PER_TILE>
+          shared_keys_t;
+      typedef core::uninitialized_array<value_type, PtxPlan::ITEMS_PER_TILE>
+          shared_values_t;
+
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage              scan;
+          typename TilePrefixCallback::TempStorage     prefix;
+          typename BlockDiscontinuityKeys::TempStorage discontinuity;
+        } scan_storage;
+
+        typename BlockLoadKeys::TempStorage   load_keys;
+        typename BlockLoadValues::TempStorage load_values;
+
+        shared_keys_t   shared_keys;
+        shared_values_t shared_values;
+      };    // union TempStorage
+    };    // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::KeyLoadIt              KeyLoadIt;
+    typedef typename ptx_plan::ValLoadIt              ValLoadIt;
+    typedef typename ptx_plan::BlockLoadKeys          BlockLoadKeys;
+    typedef typename ptx_plan::BlockLoadValues        BlockLoadValues;
+    typedef typename ptx_plan::BlockDiscontinuityKeys BlockDiscontinuityKeys;
+    typedef typename ptx_plan::TilePrefixCallback     TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan              BlockScan;
+    typedef typename ptx_plan::TempStorage            TempStorage;
+    typedef typename ptx_plan::shared_keys_t          shared_keys_t;
+    typedef typename ptx_plan::shared_values_t        shared_values_t;
+
+    enum
+    {
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = ptx_plan::ITEMS_PER_TILE
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &                      temp_storage;
+      ScanTileState &                    tile_state;
+      KeyLoadIt                          keys_in;
+      ValLoadIt                          values_in;
+      KeyOutputIt                        keys_out;
+      ValOutputIt                        values_out;
+      cub::InequalityWrapper<BinaryPred> predicate;
+      Size                               num_items;
+
+      //---------------------------------------------------------------------
+      // Utility functions
+      //---------------------------------------------------------------------
+
+      struct key_tag {};
+      struct value_tag {};
+
+      THRUST_DEVICE_FUNCTION
+      shared_keys_t &get_shared(key_tag)
+      {
+        return temp_storage.shared_keys;
+      }
+      THRUST_DEVICE_FUNCTION
+      shared_values_t &get_shared(value_tag)
+      {
+        return temp_storage.shared_values;
+      }
+
+
+      template <class Tag,
+                class OutputIt,
+                class T>
+      void THRUST_DEVICE_FUNCTION
+      scatter(Tag      tag,
+              OutputIt items_out,
+              T (&items)[ITEMS_PER_THREAD],
+              Size (&selection_flags)[ITEMS_PER_THREAD],
+              Size (&selection_indices)[ITEMS_PER_THREAD],
+              int  /*num_tile_items*/,
+              int  num_tile_selections,
+              Size num_selections_prefix,
+              Size /*num_selections*/)
+      {
+        using core::sync_threadblock;
+
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int local_scatter_offset = selection_indices[ITEM] -
+                                     num_selections_prefix;
+          if (selection_flags[ITEM])
+          {
+            get_shared(tag)[local_scatter_offset] = items[ITEM];
+          }
+        }
+
+        sync_threadblock();
+
+        for (int item = threadIdx.x;
+             item < num_tile_selections;
+             item += BLOCK_THREADS)
+        {
+          items_out[num_selections_prefix + item] = get_shared(tag)[item];
+        }
+
+        sync_threadblock();
+      }
+
+      //---------------------------------------------------------------------
+      // Tile processing
+      //---------------------------------------------------------------------
+
+      template <bool IS_LAST_TILE, bool IS_FIRST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile_impl(int  num_tile_items,
+                        int  tile_idx,
+                        Size tile_base)
+      {
+        using core::sync_threadblock;
+
+        key_type keys[ITEMS_PER_THREAD];
+        Size     selection_flags[ITEMS_PER_THREAD];
+        Size     selection_idx[ITEMS_PER_THREAD];
+
+        if (IS_LAST_TILE)
+        {
+          // Fill last elements with the first element
+          // because collectives are not suffix guarded
+          BlockLoadKeys(temp_storage.load_keys)
+              .Load(keys_in + tile_base,
+                    keys,
+                    num_tile_items,
+                    *(keys_in + tile_base));
+        }
+        else
+        {
+          BlockLoadKeys(temp_storage.load_keys).Load(keys_in + tile_base, keys);
+        }
+
+
+        sync_threadblock();
+
+        value_type values[ITEMS_PER_THREAD];
+        if (IS_LAST_TILE)
+        {
+          // Fill last elements with the first element
+          // because collectives are not suffix guarded
+          BlockLoadValues(temp_storage.load_values)
+              .Load(values_in + tile_base,
+                    values,
+                    num_tile_items,
+                    *(values_in + tile_base));
+        }
+        else
+        {
+          BlockLoadValues(temp_storage.load_values)
+              .Load(values_in + tile_base, values);
+        }
+
+        sync_threadblock();
+
+        if (IS_FIRST_TILE)
+        {
+          BlockDiscontinuityKeys(temp_storage.scan_storage.discontinuity)
+              .FlagHeads(selection_flags, keys, predicate);
+        }
+        else
+        {
+          key_type tile_predecessor = keys_in[tile_base - 1];
+          BlockDiscontinuityKeys(temp_storage.scan_storage.discontinuity)
+              .FlagHeads(selection_flags, keys, predicate, tile_predecessor);
+        }
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          // Set selection_flags for out-of-bounds items
+          if ((IS_LAST_TILE) && (Size(threadIdx.x * ITEMS_PER_THREAD) + ITEM >= num_tile_items))
+            selection_flags[ITEM] = 1;
+        }
+
+        sync_threadblock();
+
+
+        Size num_tile_selections   = 0;
+        Size num_selections        = 0;
+        Size num_selections_prefix = 0;
+        if (IS_FIRST_TILE)
+        {
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            num_tile_selections);
+
+          if (threadIdx.x == 0)
+          {
+            // Update tile status if this is not the last tile
+            if (!IS_LAST_TILE)
+              tile_state.SetInclusive(0, num_tile_selections);
+          }
+
+          // Do not count any out-of-bounds selections
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+          }
+          num_selections = num_tile_selections;
+        }
+        else
+        {
+          TilePrefixCallback prefix_cb(tile_state,
+                                       temp_storage.scan_storage.prefix,
+                                       cub::Sum(),
+                                       tile_idx);
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            prefix_cb);
+
+          num_selections        = prefix_cb.GetInclusivePrefix();
+          num_tile_selections   = prefix_cb.GetBlockAggregate();
+          num_selections_prefix = prefix_cb.GetExclusivePrefix();
+
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+            num_selections -= num_discount;
+          }
+        }
+
+        sync_threadblock();
+
+        scatter(key_tag(),
+                keys_out,
+                keys,
+                selection_flags,
+                selection_idx,
+                num_tile_items,
+                num_tile_selections,
+                num_selections_prefix,
+                num_selections);
+
+        sync_threadblock();
+
+        scatter(value_tag(),
+                values_out,
+                values,
+                selection_flags,
+                selection_idx,
+                num_tile_items,
+                num_tile_selections,
+                num_selections_prefix,
+                num_selections);
+
+        return num_selections;
+      }
+
+
+      template <bool IS_LAST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile(int  num_tile_items,
+                   int  tile_idx,
+                   Size tile_base)
+      {
+        if (tile_idx == 0)
+        {
+          return consume_tile_impl<IS_LAST_TILE, true>(num_tile_items,
+                                                       tile_idx,
+                                                       tile_base);
+        }
+        else
+        {
+          return consume_tile_impl<IS_LAST_TILE, false>(num_tile_items,
+                                                        tile_idx,
+                                                        tile_base);
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      impl(TempStorage &    temp_storage_,
+           ScanTileState &  tile_state_,
+           KeyLoadIt        keys_in_,
+           ValLoadIt        values_in_,
+           KeyOutputIt      keys_out_,
+           ValOutputIt      values_out_,
+           BinaryPred       binary_pred_,
+           Size             num_items_,
+           int              num_tiles,
+           NumSelectedOutIt num_selected_out)
+          // filed ctors
+          : temp_storage(temp_storage_),
+            tile_state(tile_state_),
+            keys_in(keys_in_),
+            values_in(values_in_),
+            keys_out(keys_out_),
+            values_out(values_out_),
+            predicate(binary_pred_),
+            num_items(num_items_)
+      {
+        int  tile_idx  = blockIdx.x;
+        Size tile_base = tile_idx * ITEMS_PER_TILE;
+
+        if (tile_idx < num_tiles - 1)
+        {
+          consume_tile<false>(ITEMS_PER_TILE,
+                              tile_idx,
+                              tile_base);
+        }
+        else
+        {
+          int  num_remaining  = static_cast<int>(num_items - tile_base);
+          Size num_selections = consume_tile<true>(num_remaining,
+                                                   tile_idx,
+                                                   tile_base);
+          if (threadIdx.x == 0)
+          {
+            *num_selected_out = num_selections;
+          }
+        }
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(KeyInputIt       keys_in,
+                       ValInputIt       values_in,
+                       KeyOutputIt      keys_out,
+                       ValOutputIt      values_out,
+                       BinaryPred       binary_pred,
+                       NumSelectedOutIt num_selected_out,
+                       Size             num_items,
+                       ScanTileState    tile_state,
+                       int              num_tiles,
+                       char *           shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
+
+      impl(storage,
+           tile_state,
+           core::make_load_iterator(ptx_plan(), keys_in),
+           core::make_load_iterator(ptx_plan(), values_in),
+           keys_out,
+           values_out,
+           binary_pred,
+           num_items,
+           num_tiles,
+           num_selected_out);
+    }
+  }; // struct UniqueByKeyAgent
+
+
+  template <class ScanTileState,
+            class NumSelectedIt,
+            class Size>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       NumSelectedIt num_selected_out,
+                       char * /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+      if (blockIdx.x == 0 && threadIdx.x == 0)
+        *num_selected_out = 0;
+    }
+
+  }; // struct InitAgent
+
+
+  template <class KeyInputIt,
+            class ValInputIt,
+            class KeyOutputIt,
+            class ValOutputIt,
+            class BinaryPred,
+            class Size,
+            class NumSelectedOutIt>
+  static cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *           d_temp_storage,
+            size_t &         temp_storage_bytes,
+            KeyInputIt       keys_in,
+            ValInputIt       values_in,
+            KeyOutputIt      keys_out,
+            ValOutputIt      values_out,
+            BinaryPred       binary_pred,
+            NumSelectedOutIt num_selected_out,
+            Size             num_items,
+            cudaStream_t     stream)
+  {
+    using core::AgentLauncher;
+    using core::AgentPlan;
+    using core::get_agent_plan;
+
+    typedef AgentLauncher<
+        UniqueByKeyAgent<KeyInputIt,
+                         ValInputIt,
+                         KeyOutputIt,
+                         ValOutputIt,
+                         BinaryPred,
+                         Size,
+                         NumSelectedOutIt> >
+        unique_agent;
+
+    typedef typename unique_agent::ScanTileState ScanTileState;
+
+    typedef AgentLauncher<
+        InitAgent<ScanTileState, NumSelectedOutIt, Size> >
+        init_agent;
+
+    using core::get_plan;
+    typename get_plan<init_agent>::type   init_plan   = init_agent::get_plan();
+    typename get_plan<unique_agent>::type unique_plan = unique_agent::get_plan(stream);
+
+
+    int tile_size = unique_plan.items_per_tile;
+    size_t num_tiles = cub::DivideAndRoundUp(num_items, tile_size);
+
+    size_t vshmem_size = core::vshmem_size(unique_plan.shared_memory_size,
+                                           num_tiles);
+
+    cudaError_t status = cudaSuccess;
+    size_t      allocation_sizes[2] = {0, vshmem_size};
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles), allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    void *allocations[2] = {NULL, NULL};
+    //
+    status = cub::AliasTemporaries(d_temp_storage,
+                                   temp_storage_bytes,
+                                   allocations,
+                                   allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_status;
+    status =  tile_status.Init(static_cast<int>(num_tiles), allocations[0], allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    num_tiles = max<size_t>(1,num_tiles);
+    init_agent ia(init_plan, num_tiles, stream, "unique_by_key::init_agent");
+    ia.launch(tile_status, num_tiles, num_selected_out);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    if (num_items == 0) { return status; }
+
+    char *vshmem_ptr = vshmem_size > 0 ? (char *)allocations[1] : NULL;
+
+    unique_agent ua(unique_plan, num_items, stream, vshmem_ptr, "unique_by_key::unique_agent");
+    ua.launch(keys_in,
+              values_in,
+              keys_out,
+              values_out,
+              binary_pred,
+              num_selected_out,
+              num_items,
+              tile_status,
+              num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    return status;
+  }
+
+  template <typename Derived,
+            typename KeyInputIt,
+            typename ValInputIt,
+            typename KeyOutputIt,
+            typename ValOutputIt,
+            typename BinaryPred>
+  THRUST_RUNTIME_FUNCTION
+  pair<KeyOutputIt, ValOutputIt>
+  unique_by_key(execution_policy<Derived>& policy,
+                KeyInputIt                 keys_first,
+                KeyInputIt                 keys_last,
+                ValInputIt                 values_first,
+                KeyOutputIt                keys_result,
+                ValOutputIt                values_result,
+                BinaryPred                 binary_pred)
+  {
+
+    typedef int size_type;
+
+    size_type num_items
+      = static_cast<size_type>(thrust::distance(keys_first, keys_last));
+
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    status = __unique_by_key::doit_step(NULL,
+                                        temp_storage_bytes,
+                                        keys_first,
+                                        values_first,
+                                        keys_result,
+                                        values_result,
+                                        binary_pred,
+                                        reinterpret_cast<size_type*>(NULL),
+                                        num_items,
+                                        stream);
+    cuda_cub::throw_on_error(status, "unique_by_key: failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(size_type), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "unique_by_key failed on 1st alias_storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "unique_by_key failed on 2nd alias_storage");
+
+    size_type* d_num_selected_out
+      = thrust::detail::aligned_reinterpret_cast<size_type*>(allocations[0]);
+
+    status = __unique_by_key::doit_step(allocations[1],
+                                        temp_storage_bytes,
+                                        keys_first,
+                                        values_first,
+                                        keys_result,
+                                        values_result,
+                                        binary_pred,
+                                        d_num_selected_out,
+                                        num_items,
+                                        stream);
+    cuda_cub::throw_on_error(status, "unique_by_key: failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "unique_by_key: failed to synchronize");
+
+    size_type num_selected = get_value(policy, d_num_selected_out);
+
+    return thrust::make_pair(
+      keys_result + num_selected,
+      values_result + num_selected
+    );
+  }
+
+} // namespace __unique_by_key
+
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt,
+          class BinaryPred>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+unique_by_key_copy(execution_policy<Derived> &policy,
+                   KeyInputIt                 keys_first,
+                   KeyInputIt                 keys_last,
+                   ValInputIt                 values_first,
+                   KeyOutputIt                keys_result,
+                   ValOutputIt                values_result,
+                   BinaryPred                 binary_pred)
+{
+  auto ret = thrust::make_pair(keys_result, values_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __unique_by_key::unique_by_key(policy,
+                                          keys_first,
+                                          keys_last,
+                                          values_first,
+                                          keys_result,
+                                          values_result,
+                                          binary_pred);),
+    (ret = thrust::unique_by_key_copy(cvt_to_seq(derived_cast(policy)),
+                                      keys_first,
+                                      keys_last,
+                                      values_first,
+                                      keys_result,
+                                      values_result,
+                                      binary_pred);));
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+unique_by_key_copy(execution_policy<Derived> &policy,
+                   KeyInputIt                 keys_first,
+                   KeyInputIt                 keys_last,
+                   ValInputIt                 values_first,
+                   KeyOutputIt                keys_result,
+                   ValOutputIt                values_result)
+{
+  typedef typename iterator_traits<KeyInputIt>::value_type key_type;
+  return cuda_cub::unique_by_key_copy(policy,
+                                   keys_first,
+                                   keys_last,
+                                   values_first,
+                                   keys_result,
+                                   values_result,
+                                   equal_to<key_type>());
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class BinaryPred>
+pair<KeyInputIt, ValInputIt> __host__ __device__
+unique_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first,
+              BinaryPred                 binary_pred)
+{
+  auto ret = thrust::make_pair(keys_first, values_first);
+  THRUST_CDP_DISPATCH(
+    (ret = cuda_cub::unique_by_key_copy(policy,
+                                         keys_first,
+                                         keys_last,
+                                         values_first,
+                                         keys_first,
+                                         values_first,
+                                         binary_pred);),
+    (ret = thrust::unique_by_key(cvt_to_seq(derived_cast(policy)),
+                                  keys_first,
+                                  keys_last,
+                                  values_first,
+                                  binary_pred);));
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt>
+pair<KeyInputIt, ValInputIt> __host__ __device__
+unique_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first)
+{
+  typedef typename iterator_traits<KeyInputIt>::value_type key_type;
+  return cuda_cub::unique_by_key(policy,
+                              keys_first,
+                              keys_last,
+                              values_first,
+                              equal_to<key_type>());
+}
+
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/memory.h>
+#include <thrust/unique.h>
+
+#endif

miniCUDA124/include/thrust/system/cuda/detail/util.h

@@ -0,0 +1,650 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights meserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#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 <cstdio>
+#include <exception>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system_error.h>
+#include <thrust/system/cuda/error.h>
+
+#include <cub/detail/device_synchronize.cuh>
+#include <cub/config.cuh>
+#include <cub/util_device.cuh>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+inline __host__ __device__
+cudaStream_t
+default_stream()
+{
+#ifdef CUDA_API_PER_THREAD_DEFAULT_STREAM
+  return cudaStreamPerThread;
+#else
+  return cudaStreamLegacy;
+#endif
+}
+
+// Fallback implementation of the customization point.
+template <class Derived>
+__host__ __device__
+cudaStream_t
+get_stream(execution_policy<Derived> &)
+{
+  return default_stream();
+}
+
+// Entry point/interface.
+template <class Derived>
+__host__ __device__ cudaStream_t
+stream(execution_policy<Derived> &policy)
+{
+  return get_stream(derived_cast(policy));
+}
+
+
+// Fallback implementation of the customization point.
+template <class Derived>
+__host__ __device__
+bool
+must_perform_optional_stream_synchronization(execution_policy<Derived> &)
+{
+  return true;
+}
+
+// Entry point/interface.
+template <class Derived>
+__host__ __device__ bool
+must_perform_optional_synchronization(execution_policy<Derived> &policy)
+{
+  return must_perform_optional_stream_synchronization(derived_cast(policy));
+}
+
+
+// Fallback implementation of the customization point.
+__thrust_exec_check_disable__
+template <class Derived>
+__host__ __device__
+cudaError_t
+synchronize_stream(execution_policy<Derived> &policy)
+{
+  return cub::SyncStream(stream(policy));
+}
+
+// Entry point/interface.
+template <class Policy>
+__host__ __device__
+cudaError_t
+synchronize(Policy &policy)
+{
+  return synchronize_stream(derived_cast(policy));
+}
+
+// Fallback implementation of the customization point.
+__thrust_exec_check_disable__
+template <class Derived>
+__host__ __device__
+cudaError_t
+synchronize_stream_optional(execution_policy<Derived> &policy)
+{
+  cudaError_t result;
+
+  if (must_perform_optional_synchronization(policy))
+  {
+    result = synchronize_stream(policy);
+  }
+  else
+  {
+    result = cudaSuccess;
+  }
+
+  return result;
+}
+
+// Entry point/interface.
+template <class Policy>
+__host__ __device__
+cudaError_t
+synchronize_optional(Policy &policy)
+{
+  return synchronize_stream_optional(derived_cast(policy));
+}
+
+template <class Type>
+THRUST_HOST_FUNCTION cudaError_t
+trivial_copy_from_device(Type *       dst,
+                         Type const * src,
+                         size_t       count,
+                         cudaStream_t stream)
+{
+  cudaError status = cudaSuccess;
+  if (count == 0) return status;
+
+  status = ::cudaMemcpyAsync(dst,
+                             src,
+                             sizeof(Type) * count,
+                             cudaMemcpyDeviceToHost,
+                             stream);
+  cudaStreamSynchronize(stream);
+  return status;
+}
+
+template <class Type>
+THRUST_HOST_FUNCTION cudaError_t
+trivial_copy_to_device(Type *       dst,
+                       Type const * src,
+                       size_t       count,
+                       cudaStream_t stream)
+{
+  cudaError status = cudaSuccess;
+  if (count == 0) return status;
+
+  status = ::cudaMemcpyAsync(dst,
+                             src,
+                             sizeof(Type) * count,
+                             cudaMemcpyHostToDevice,
+                             stream);
+  cudaStreamSynchronize(stream);
+  return status;
+}
+
+template <class Policy, class Type>
+__host__ __device__ cudaError_t
+trivial_copy_device_to_device(Policy &    policy,
+                              Type *      dst,
+                              Type const *src,
+                              size_t      count)
+{
+  cudaError_t  status = cudaSuccess;
+  if (count == 0) return status;
+
+  cudaStream_t stream = cuda_cub::stream(policy);
+  //
+  status = ::cudaMemcpyAsync(dst,
+                             src,
+                             sizeof(Type) * count,
+                             cudaMemcpyDeviceToDevice,
+                             stream);
+  cuda_cub::synchronize(policy);
+  return status;
+}
+
+inline void __host__ __device__
+terminate()
+{
+  NV_IF_TARGET(NV_IS_HOST, (std::terminate();), (asm("trap;");));
+}
+
+__host__  __device__
+inline void throw_on_error(cudaError_t status)
+{
+  // Clear the global CUDA error state which may have been set by the last
+  // call. Otherwise, errors may "leak" to unrelated kernel launches.
+#ifdef THRUST_RDC_ENABLED
+  cudaGetLastError();
+#else
+  NV_IF_TARGET(NV_IS_HOST, (cudaGetLastError();));
+#endif
+
+  if (cudaSuccess != status)
+  {
+
+    // Can't use #if inside NV_IF_TARGET, use a temp macro to hoist the device
+    // instructions out of the target logic.
+#ifdef THRUST_RDC_ENABLED
+
+#define THRUST_TEMP_DEVICE_CODE \
+  printf("Thrust CUDA backend error: %s: %s\n", \
+         cudaGetErrorName(status), \
+         cudaGetErrorString(status))
+
+#else
+
+#define THRUST_TEMP_DEVICE_CODE \
+  printf("Thrust CUDA backend error: %d\n", \
+         static_cast<int>(status))
+
+#endif
+
+    NV_IF_TARGET(NV_IS_HOST, (
+      throw thrust::system_error(status, thrust::cuda_category());
+    ), (
+      THRUST_TEMP_DEVICE_CODE;
+      cuda_cub::terminate();
+    ));
+
+#undef THRUST_TEMP_DEVICE_CODE
+
+  }
+}
+
+__host__ __device__
+inline void throw_on_error(cudaError_t status, char const *msg)
+{
+  // Clear the global CUDA error state which may have been set by the last
+  // call. Otherwise, errors may "leak" to unrelated kernel launches.
+#ifdef THRUST_RDC_ENABLED
+  cudaGetLastError();
+#else
+  NV_IF_TARGET(NV_IS_HOST, (cudaGetLastError();));
+#endif
+
+  if (cudaSuccess != status)
+  {
+    // Can't use #if inside NV_IF_TARGET, use a temp macro to hoist the device
+    // instructions out of the target logic.
+#ifdef THRUST_RDC_ENABLED
+
+#define THRUST_TEMP_DEVICE_CODE \
+  printf("Thrust CUDA backend error: %s: %s: %s\n", \
+         cudaGetErrorName(status), \
+         cudaGetErrorString(status),\
+         msg)
+
+#else
+
+#define THRUST_TEMP_DEVICE_CODE \
+  printf("Thrust CUDA backend error: %d: %s\n", \
+         static_cast<int>(status),              \
+         msg)
+
+#endif
+
+    NV_IF_TARGET(NV_IS_HOST, (
+      throw thrust::system_error(status, thrust::cuda_category(), msg);
+    ), (
+      THRUST_TEMP_DEVICE_CODE;
+      cuda_cub::terminate();
+    ));
+
+#undef THRUST_TEMP_DEVICE_CODE
+
+  }
+}
+
+// FIXME: Move the iterators elsewhere.
+
+template <class ValueType,
+          class InputIt,
+          class UnaryOp>
+struct transform_input_iterator_t
+{
+  typedef transform_input_iterator_t                         self_t;
+  typedef typename iterator_traits<InputIt>::difference_type difference_type;
+  typedef ValueType                                          value_type;
+  typedef void                                               pointer;
+  typedef value_type                                         reference;
+  typedef std::random_access_iterator_tag                    iterator_category;
+
+  InputIt         input;
+  mutable UnaryOp op;
+
+  __host__ __device__ __forceinline__
+  transform_input_iterator_t(InputIt input, UnaryOp op)
+      : input(input), op(op) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+  transform_input_iterator_t(const self_t &) = default;
+#endif
+
+  // UnaryOp might not be copy assignable, such as when it is a lambda.  Define
+  // an explicit copy assignment operator that doesn't try to assign it.
+  __host__ __device__
+  self_t& operator=(const self_t& o)
+  {
+    input = o.input;
+    return *this;
+  }
+
+  /// Postfix increment
+  __host__ __device__ __forceinline__ self_t operator++(int)
+  {
+    self_t retval = *this;
+    ++input;
+    return retval;
+  }
+
+  /// Prefix increment
+  __host__ __device__ __forceinline__ self_t operator++()
+  {
+    ++input;
+    return *this;
+  }
+
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*() const
+  {
+    typename thrust::iterator_value<InputIt>::type x = *input;
+    return op(x);
+  }
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*()
+  {
+    typename thrust::iterator_value<InputIt>::type x = *input;
+    return op(x);
+  }
+
+  /// Addition
+  __host__ __device__ __forceinline__ self_t operator+(difference_type n) const
+  {
+    return self_t(input + n, op);
+  }
+
+  /// Addition assignment
+  __host__ __device__ __forceinline__ self_t &operator+=(difference_type n)
+  {
+    input += n;
+    return *this;
+  }
+
+  /// Subtraction
+  __host__ __device__ __forceinline__ self_t operator-(difference_type n) const
+  {
+    return self_t(input - n, op);
+  }
+
+  /// Subtraction assignment
+  __host__ __device__ __forceinline__ self_t &operator-=(difference_type n)
+  {
+    input -= n;
+    return *this;
+  }
+
+  /// Distance
+  __host__ __device__ __forceinline__ difference_type operator-(self_t other) const
+  {
+    return input - other.input;
+  }
+
+  /// Array subscript
+  __host__ __device__ __forceinline__ reference operator[](difference_type n) const
+  {
+    return op(input[n]);
+  }
+
+  /// Equal to
+  __host__ __device__ __forceinline__ bool operator==(const self_t &rhs) const
+  {
+    return (input == rhs.input);
+  }
+
+  /// Not equal to
+  __host__ __device__ __forceinline__ bool operator!=(const self_t &rhs) const
+  {
+    return (input != rhs.input);
+  }
+};    // struct transform_input_iterarot_t
+
+template <class ValueType,
+          class InputIt1,
+          class InputIt2,
+          class BinaryOp>
+struct transform_pair_of_input_iterators_t
+{
+  typedef transform_pair_of_input_iterators_t                 self_t;
+  typedef typename iterator_traits<InputIt1>::difference_type difference_type;
+  typedef ValueType                                           value_type;
+  typedef void                                                pointer;
+  typedef value_type                                          reference;
+  typedef std::random_access_iterator_tag                     iterator_category;
+
+  InputIt1         input1;
+  InputIt2         input2;
+  mutable BinaryOp op;
+
+  __host__ __device__ __forceinline__
+  transform_pair_of_input_iterators_t(InputIt1 input1_,
+                                      InputIt2 input2_,
+                                      BinaryOp op_)
+      : input1(input1_), input2(input2_), op(op_) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+  transform_pair_of_input_iterators_t(const self_t &) = default;
+#endif
+
+  // BinaryOp might not be copy assignable, such as when it is a lambda.
+  // Define an explicit copy assignment operator that doesn't try to assign it.
+  __host__ __device__
+  self_t& operator=(const self_t& o)
+  {
+    input1 = o.input1;
+    input2 = o.input2;
+    return *this;
+  }
+
+  /// Postfix increment
+  __host__ __device__ __forceinline__ self_t operator++(int)
+  {
+    self_t retval = *this;
+    ++input1;
+    ++input2;
+    return retval;
+  }
+
+  /// Prefix increment
+  __host__ __device__ __forceinline__ self_t operator++()
+  {
+    ++input1;
+    ++input2;
+    return *this;
+  }
+
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*() const
+  {
+    return op(*input1, *input2);
+  }
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*()
+  {
+    return op(*input1, *input2);
+  }
+
+  /// Addition
+  __host__ __device__ __forceinline__ self_t operator+(difference_type n) const
+  {
+    return self_t(input1 + n, input2 + n, op);
+  }
+
+  /// Addition assignment
+  __host__ __device__ __forceinline__ self_t &operator+=(difference_type n)
+  {
+    input1 += n;
+    input2 += n;
+    return *this;
+  }
+
+  /// Subtraction
+  __host__ __device__ __forceinline__ self_t operator-(difference_type n) const
+  {
+    return self_t(input1 - n, input2 - n, op);
+  }
+
+  /// Subtraction assignment
+  __host__ __device__ __forceinline__ self_t &operator-=(difference_type n)
+  {
+    input1 -= n;
+    input2 -= n;
+    return *this;
+  }
+
+  /// Distance
+  __host__ __device__ __forceinline__ difference_type operator-(self_t other) const
+  {
+    return input1 - other.input1;
+  }
+
+  /// Array subscript
+  __host__ __device__ __forceinline__ reference operator[](difference_type n) const
+  {
+    return op(input1[n], input2[n]);
+  }
+
+  /// Equal to
+  __host__ __device__ __forceinline__ bool operator==(const self_t &rhs) const
+  {
+    return (input1 == rhs.input1) && (input2 == rhs.input2);
+  }
+
+  /// Not equal to
+  __host__ __device__ __forceinline__ bool operator!=(const self_t &rhs) const
+  {
+    return (input1 != rhs.input1) || (input2 != rhs.input2);
+  }
+
+};    // struct transform_pair_of_input_iterators_t
+
+
+struct identity
+{
+  template <class T>
+  __host__ __device__ T const &
+  operator()(T const &t) const
+  {
+    return t;
+  }
+
+  template <class T>
+  __host__ __device__ T &
+  operator()(T &t) const
+  {
+    return t;
+  }
+};
+
+
+template <class T>
+struct counting_iterator_t
+{
+  typedef counting_iterator_t             self_t;
+  typedef T                               difference_type;
+  typedef T                               value_type;
+  typedef void                            pointer;
+  typedef T                               reference;
+  typedef std::random_access_iterator_tag iterator_category;
+
+  T count;
+
+  __host__ __device__ __forceinline__
+  counting_iterator_t(T count_) : count(count_) {}
+
+  /// Postfix increment
+  __host__ __device__ __forceinline__ self_t operator++(int)
+  {
+    self_t retval = *this;
+    ++count;
+    return retval;
+  }
+
+  /// Prefix increment
+  __host__ __device__ __forceinline__ self_t operator++()
+  {
+    ++count;
+    return *this;
+  }
+
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*() const
+  {
+    return count;
+  }
+
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*()
+  {
+    return count;
+  }
+
+  /// Addition
+  __host__ __device__ __forceinline__ self_t operator+(difference_type n) const
+  {
+    return self_t(count + n);
+  }
+
+  /// Addition assignment
+  __host__ __device__ __forceinline__ self_t &operator+=(difference_type n)
+  {
+    count += n;
+    return *this;
+  }
+
+  /// Subtraction
+  __host__ __device__ __forceinline__ self_t operator-(difference_type n) const
+  {
+    return self_t(count - n);
+  }
+
+  /// Subtraction assignment
+  __host__ __device__ __forceinline__ self_t &operator-=(difference_type n)
+  {
+    count -= n;
+    return *this;
+  }
+
+  /// Distance
+  __host__ __device__ __forceinline__ difference_type operator-(self_t other) const
+  {
+    return count - other.count;
+  }
+
+  /// Array subscript
+  __host__ __device__ __forceinline__ reference operator[](difference_type n) const
+  {
+    return count + n;
+  }
+
+  /// Equal to
+  __host__ __device__ __forceinline__ bool operator==(const self_t &rhs) const
+  {
+    return (count == rhs.count);
+  }
+
+  /// Not equal to
+  __host__ __device__ __forceinline__ bool operator!=(const self_t &rhs) const
+  {
+    return (count != rhs.count);
+  }
+
+};    // struct count_iterator_t
+
+}    // cuda_
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/system/detail/adl/adjacent_difference.h

@@ -0,0 +1,52 @@
+/*
+ *  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
+
+// the purpose of this header is to #include the adjacent_difference.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch adjacent_difference
+
+#include <thrust/system/detail/sequential/adjacent_difference.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/adjacent_difference.h>
+#include <thrust/system/cuda/detail/adjacent_difference.h>
+#include <thrust/system/omp/detail/adjacent_difference.h>
+#include <thrust/system/tbb/detail/adjacent_difference.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_ADJACENT_DIFFERENCE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/adjacent_difference.h>
+#include __THRUST_HOST_SYSTEM_ADJACENT_DIFFERENCE_HEADER
+#undef __THRUST_HOST_SYSTEM_ADJACENT_DIFFERENCE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ADJACENT_DIFFERENCE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/adjacent_difference.h>
+#include __THRUST_DEVICE_SYSTEM_ADJACENT_DIFFERENCE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ADJACENT_DIFFERENCE_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/assign_value.h

@@ -0,0 +1,52 @@
+/*
+ *  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
+
+// the purpose of this header is to #include the assign_value.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch assign_value
+
+#include <thrust/system/detail/sequential/assign_value.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/assign_value.h>
+#include <thrust/system/cuda/detail/assign_value.h>
+#include <thrust/system/omp/detail/assign_value.h>
+#include <thrust/system/tbb/detail/assign_value.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_ASSIGN_VALUE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/assign_value.h>
+#include __THRUST_HOST_SYSTEM_ASSIGN_VALUE_HEADER
+#undef __THRUST_HOST_SYSTEM_ASSIGN_VALUE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ASSIGN_VALUE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/assign_value.h>
+#include __THRUST_DEVICE_SYSTEM_ASSIGN_VALUE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ASSIGN_VALUE_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/binary_search.h

@@ -0,0 +1,52 @@
+/*
+ *  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
+
+// the purpose of this header is to #include the binary_search.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch binary_search
+
+#include <thrust/system/detail/sequential/binary_search.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/binary_search.h>
+#include <thrust/system/cuda/detail/binary_search.h>
+#include <thrust/system/omp/detail/binary_search.h>
+#include <thrust/system/tbb/detail/binary_search.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_BINARY_SEARCH_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/binary_search.h>
+#include __THRUST_HOST_SYSTEM_BINARY_SEARCH_HEADER
+#undef __THRUST_HOST_SYSTEM_BINARY_SEARCH_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_BINARY_SEARCH_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/binary_search.h>
+#include __THRUST_DEVICE_SYSTEM_BINARY_SEARCH_HEADER
+#undef __THRUST_DEVICE_SYSTEM_BINARY_SEARCH_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/copy.h

@@ -0,0 +1,52 @@
+/*
+ *  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
+
+// the purpose of this header is to #include the copy.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch copy
+
+#include <thrust/system/detail/sequential/copy.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/copy.h>
+#include <thrust/system/cuda/detail/copy.h>
+#include <thrust/system/omp/detail/copy.h>
+#include <thrust/system/tbb/detail/copy.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_COPY_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/copy.h>
+#include __THRUST_HOST_SYSTEM_COPY_HEADER
+#undef __THRUST_HOST_SYSTEM_COPY_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_COPY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/copy.h>
+#include __THRUST_DEVICE_SYSTEM_COPY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_COPY_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/copy_if.h

@@ -0,0 +1,52 @@
+/*
+ *  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_if.h 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
+
+// the purpose of this header is to #include the copy_if.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch copy_if
+
+#include <thrust/system/detail/sequential/copy_if.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/copy_if.h>
+#include <thrust/system/cuda/detail/copy_if.h>
+#include <thrust/system/omp/detail/copy_if.h>
+#include <thrust/system/tbb/detail/copy_if.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_COPY_IF_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/copy_if.h>
+#include __THRUST_HOST_SYSTEM_COPY_IF_HEADER
+#undef __THRUST_HOST_SYSTEM_COPY_IF_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_COPY_IF_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/copy_if.h>
+#include __THRUST_DEVICE_SYSTEM_COPY_IF_HEADER
+#undef __THRUST_DEVICE_SYSTEM_COPY_IF_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/count.h

@@ -0,0 +1,52 @@
+/*
+ *  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 count 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
+
+// the purpose of this header is to #include the count.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch count
+
+#include <thrust/system/detail/sequential/count.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/count.h>
+#include <thrust/system/cuda/detail/count.h>
+#include <thrust/system/omp/detail/count.h>
+#include <thrust/system/tbb/detail/count.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_COUNT_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/count.h>
+#include __THRUST_HOST_SYSTEM_COUNT_HEADER
+#undef __THRUST_HOST_SYSTEM_COUNT_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_COUNT_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/count.h>
+#include __THRUST_DEVICE_SYSTEM_COUNT_HEADER
+#undef __THRUST_DEVICE_SYSTEM_COUNT_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/equal.h

@@ -0,0 +1,52 @@
+/*
+ *  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 equal 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
+
+// the purpose of this header is to #include the equal.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch equal
+
+#include <thrust/system/detail/sequential/equal.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/equal.h>
+#include <thrust/system/cuda/detail/equal.h>
+#include <thrust/system/omp/detail/equal.h>
+#include <thrust/system/tbb/detail/equal.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_EQUAL_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/equal.h>
+#include __THRUST_HOST_SYSTEM_EQUAL_HEADER
+#undef __THRUST_HOST_SYSTEM_EQUAL_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_EQUAL_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/equal.h>
+#include __THRUST_DEVICE_SYSTEM_EQUAL_HEADER
+#undef __THRUST_DEVICE_SYSTEM_EQUAL_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/extrema.h

@@ -0,0 +1,52 @@
+/*
+ *  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 extrema 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
+
+// the purpose of this header is to #include the extrema.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch extrema
+
+#include <thrust/system/detail/sequential/extrema.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/extrema.h>
+#include <thrust/system/cuda/detail/extrema.h>
+#include <thrust/system/omp/detail/extrema.h>
+#include <thrust/system/tbb/detail/extrema.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_EXTREMA_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/extrema.h>
+#include __THRUST_HOST_SYSTEM_EXTREMA_HEADER
+#undef __THRUST_HOST_SYSTEM_EXTREMA_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_EXTREMA_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/extrema.h>
+#include __THRUST_DEVICE_SYSTEM_EXTREMA_HEADER
+#undef __THRUST_DEVICE_SYSTEM_EXTREMA_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/fill.h

@@ -0,0 +1,52 @@
+/*
+ *  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 fill 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
+
+// the purpose of this header is to #include the fill.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch fill
+
+#include <thrust/system/detail/sequential/fill.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/fill.h>
+#include <thrust/system/cuda/detail/fill.h>
+#include <thrust/system/omp/detail/fill.h>
+#include <thrust/system/tbb/detail/fill.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_FILL_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/fill.h>
+#include __THRUST_HOST_SYSTEM_FILL_HEADER
+#undef __THRUST_HOST_SYSTEM_FILL_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_FILL_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/fill.h>
+#include __THRUST_DEVICE_SYSTEM_FILL_HEADER
+#undef __THRUST_DEVICE_SYSTEM_FILL_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/find.h

@@ -0,0 +1,52 @@
+/*
+ *  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 fill 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
+
+// the purpose of this header is to #include the find.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch find
+
+#include <thrust/system/detail/sequential/find.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/find.h>
+#include <thrust/system/cuda/detail/find.h>
+#include <thrust/system/omp/detail/find.h>
+#include <thrust/system/tbb/detail/find.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_FIND_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/find.h>
+#include __THRUST_HOST_SYSTEM_FIND_HEADER
+#undef __THRUST_HOST_SYSTEM_FIND_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_FIND_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/find.h>
+#include __THRUST_DEVICE_SYSTEM_FIND_HEADER
+#undef __THRUST_DEVICE_SYSTEM_FIND_HEADER
+

miniCUDA124/include/thrust/system/detail/adl/for_each.h

@@ -0,0 +1,52 @@
+/*
+ *  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
+
+// the purpose of this header is to #include the for_each.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch for_each
+
+#include <thrust/system/detail/sequential/for_each.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/for_each.h>
+#include <thrust/system/cuda/detail/for_each.h>
+#include <thrust/system/omp/detail/for_each.h>
+#include <thrust/system/tbb/detail/for_each.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_FOR_EACH_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/for_each.h>
+#include __THRUST_HOST_SYSTEM_FOR_EACH_HEADER
+#undef __THRUST_HOST_SYSTEM_FOR_EACH_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_FOR_EACH_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/for_each.h>
+#include __THRUST_DEVICE_SYSTEM_FOR_EACH_HEADER
+#undef __THRUST_DEVICE_SYSTEM_FOR_EACH_HEADER
+