Add files using upload-large-folder tool

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

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits extrema algorithms
+#include <thrust/system/detail/sequential/extrema.h>
+

miniCUDA124/include/thrust/system/cpp/detail/fill.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/cpp/detail/find.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits find
+#include <thrust/system/detail/sequential/find.h>
+

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

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits for_each
+#include <thrust/system/detail/sequential/for_each.h>
+

miniCUDA124/include/thrust/system/cpp/detail/gather.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/cpp/detail/generate.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/cpp/detail/get_value.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits get_value
+#include <thrust/system/detail/sequential/get_value.h>
+

miniCUDA124/include/thrust/system/cpp/detail/inner_product.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/cpp/detail/iter_swap.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits iter_swap
+#include <thrust/system/detail/sequential/iter_swap.h>
+

miniCUDA124/include/thrust/system/cpp/detail/logical.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/cpp/detail/malloc_and_free.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits malloc & free
+#include <thrust/system/detail/sequential/malloc_and_free.h>
+

miniCUDA124/include/thrust/system/cpp/detail/memory.inl

@@ -0,0 +1,60 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/cpp/memory.h>
+#include <thrust/system/cpp/detail/malloc_and_free.h>
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cpp
+{
+
+pointer<void> malloc(std::size_t n)
+{
+  tag t;
+  return pointer<void>(thrust::system::detail::sequential::malloc(t, n));
+} // end malloc()
+
+template<typename T>
+pointer<T> malloc(std::size_t n)
+{
+  pointer<void> raw_ptr = thrust::system::cpp::malloc(sizeof(T) * n);
+  return pointer<T>(reinterpret_cast<T*>(raw_ptr.get()));
+} // end malloc()
+
+void free(pointer<void> ptr)
+{
+  tag t;
+  return thrust::system::detail::sequential::free(t, ptr);
+} // end free()
+
+} // end cpp
+} // end system
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/cpp/detail/merge.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits merge
+#include <thrust/system/detail/sequential/merge.h>
+

miniCUDA124/include/thrust/system/cpp/detail/mismatch.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/cpp/detail/par.h

@@ -0,0 +1,69 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/allocator_aware_execution_policy.h>
+#include <thrust/system/cpp/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cpp
+{
+namespace detail
+{
+
+
+struct par_t : thrust::system::cpp::detail::execution_policy<par_t>,
+  thrust::detail::allocator_aware_execution_policy<
+    thrust::system::cpp::detail::execution_policy>
+{
+  __host__ __device__
+  constexpr par_t() : thrust::system::cpp::detail::execution_policy<par_t>() {}
+};
+
+
+} // end detail
+
+
+THRUST_INLINE_CONSTANT detail::par_t par;
+
+
+} // end cpp
+} // end system
+
+
+// alias par here
+namespace cpp
+{
+
+
+using thrust::system::cpp::par;
+
+
+} // end cpp
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/cpp/detail/partition.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits partition
+#include <thrust/system/detail/sequential/partition.h>
+

miniCUDA124/include/thrust/system/cpp/detail/per_device_resource.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system has no special per device resource functions
+

miniCUDA124/include/thrust/system/cpp/detail/reduce.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits reduce
+#include <thrust/system/detail/sequential/reduce.h>
+

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

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits reduce_by_key
+#include <thrust/system/detail/sequential/reduce_by_key.h>
+

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

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits remove
+#include <thrust/system/detail/sequential/remove.h>
+

miniCUDA124/include/thrust/system/cpp/detail/replace.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/cpp/detail/reverse.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/cpp/detail/scan.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits scan
+#include <thrust/system/detail/sequential/scan.h>
+

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

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits the scan_by_key algorithms
+#include <thrust/system/detail/sequential/scan_by_key.h>
+

miniCUDA124/include/thrust/system/cpp/detail/scatter.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/cpp/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/cpp/detail/set_operations.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits the set operations
+#include <thrust/system/detail/sequential/set_operations.h>
+

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

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits sort
+#include <thrust/system/detail/sequential/sort.h>
+

miniCUDA124/include/thrust/system/cpp/detail/swap_ranges.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
+
+// cpp has no special swap_ranges
+

miniCUDA124/include/thrust/system/cpp/detail/tabulate.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/cpp/detail/temporary_buffer.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 temporary buffer functions
+

miniCUDA124/include/thrust/system/cpp/detail/transform.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
+
+// cpp has no special transform
+

miniCUDA124/include/thrust/system/cpp/detail/transform_reduce.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/cpp/detail/transform_scan.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/cpp/detail/uninitialized_copy.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/cpp/detail/uninitialized_fill.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/cpp/detail/unique.h

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits unique
+#include <thrust/system/detail/sequential/unique.h>
+

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

@@ -0,0 +1,31 @@
+/*
+ *  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 inherits unique_by_key
+#include <thrust/system/detail/sequential/unique_by_key.h>
+

miniCUDA124/include/thrust/system/cpp/detail/vector.inl

@@ -0,0 +1,154 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/system/cpp/vector.h>
+#include <utility>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cpp
+{
+
+template<typename T, typename Allocator>
+  vector<T,Allocator>
+    ::vector()
+      : super_t()
+{}
+
+template<typename T, typename Allocator>
+  vector<T,Allocator>
+    ::vector(size_type n)
+      : super_t(n)
+{}
+
+template<typename T, typename Allocator>
+  vector<T,Allocator>
+    ::vector(size_type n, const value_type &value)
+      : super_t(n,value)
+{}
+
+template<typename T, typename Allocator>
+  vector<T,Allocator>
+    ::vector(const vector &x)
+      : super_t(x)
+{}
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename T, typename Allocator>
+    vector<T,Allocator>
+      ::vector(vector &&x)
+        : super_t(std::move(x))
+  {}
+#endif
+
+template<typename T, typename Allocator>
+  template<typename OtherT, typename OtherAllocator>
+    vector<T,Allocator>
+      ::vector(const thrust::detail::vector_base<OtherT,OtherAllocator> &x)
+        : super_t(x)
+{}
+
+template<typename T, typename Allocator>
+  template<typename OtherT, typename OtherAllocator>
+    vector<T,Allocator>
+      ::vector(const std::vector<OtherT,OtherAllocator> &x)
+        : super_t(x)
+{}
+
+template<typename T, typename Allocator>
+  template<typename InputIterator>
+    vector<T,Allocator>
+      ::vector(InputIterator first, InputIterator last)
+        : super_t(first,last)
+{}
+
+template<typename T, typename Allocator>
+  vector<T,Allocator> &
+    vector<T,Allocator>
+      ::operator=(const vector &x)
+{
+  super_t::operator=(x);
+  return *this;
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename T, typename Allocator>
+    vector<T,Allocator> &
+      vector<T,Allocator>
+        ::operator=(vector &&x)
+  {
+    super_t::operator=(std::move(x));
+    return *this;
+  }
+#endif
+
+  template<typename T, typename Allocator>
+    vector<T,Allocator>
+      ::vector(std::initializer_list<T> il)
+        : super_t(il)
+  {}
+
+  template<typename T, typename Allocator>
+    vector<T,Allocator>
+      ::vector(std::initializer_list<T> il, const Allocator& alloc)
+        : super_t(il, alloc)
+  {}
+
+  template<typename T, typename Allocator>
+    vector<T,Allocator> &
+      vector<T,Allocator>
+        ::operator=(std::initializer_list<T> il)
+  {
+    super_t::operator=(il);
+    return *this;
+  }
+
+template<typename T, typename Allocator>
+  template<typename OtherT, typename OtherAllocator>
+    vector<T,Allocator> &
+      vector<T,Allocator>
+        ::operator=(const std::vector<OtherT,OtherAllocator> &x)
+{
+  super_t::operator=(x);
+  return *this;
+}
+
+template<typename T, typename Allocator>
+  template<typename OtherT, typename OtherAllocator>
+    vector<T,Allocator> &
+      vector<T,Allocator>
+        ::operator=(const thrust::detail::vector_base<OtherT,OtherAllocator> &x)
+{
+  super_t::operator=(x);
+  return *this;
+}
+
+} // end cpp
+} // end system
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,302 @@
+/******************************************************************************
+ * 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/minmax.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/functional.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 <thrust/type_traits/is_contiguous_iterator.h>
+#include <thrust/type_traits/remove_cvref.h>
+
+#include <cub/device/device_adjacent_difference.cuh>
+#include <cub/device/device_select.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename BinaryFunction>
+__host__ __device__ OutputIterator
+adjacent_difference(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    InputIterator                                               first,
+    InputIterator                                               last,
+    OutputIterator                                              result,
+    BinaryFunction                                              binary_op);
+
+namespace cuda_cub {
+
+namespace __adjacent_difference {
+
+  template <bool MayAlias,
+            class InputIt,
+            class OutputIt,
+            class BinaryOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            InputIt first,
+            OutputIt result,
+            BinaryOp binary_op,
+            std::size_t num_items,
+            cudaStream_t stream)
+  {
+    if (num_items == 0)
+    {
+      return cudaSuccess;
+    }
+
+    constexpr bool may_alias = MayAlias;
+    constexpr bool read_left = true;
+
+    using Dispatch32 = cub::DispatchAdjacentDifference<InputIt,
+                                                       OutputIt,
+                                                       BinaryOp,
+                                                       thrust::detail::int32_t,
+                                                       may_alias,
+                                                       read_left>;
+    using Dispatch64 = cub::DispatchAdjacentDifference<InputIt,
+                                                       OutputIt,
+                                                       BinaryOp,
+                                                       thrust::detail::int64_t,
+                                                       may_alias,
+                                                       read_left>;
+
+    cudaError_t status;
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (d_temp_storage,
+                                 temp_storage_bytes,
+                                 first,
+                                 result,
+                                 num_items_fixed,
+                                 binary_op,
+                                 stream));
+    return status;
+  }
+
+  template <class InputIt,
+            class OutputIt,
+            class BinaryOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            InputIt first,
+            OutputIt result,
+            BinaryOp binary_op,
+            std::size_t num_items,
+            cudaStream_t stream,
+            thrust::detail::integral_constant<bool, false> /* comparable */)
+  {
+    constexpr bool may_alias = true;
+    return doit_step<may_alias>(d_temp_storage,
+                                temp_storage_bytes,
+                                first,
+                                result,
+                                binary_op,
+                                num_items,
+                                stream);
+  }
+
+  template <class InputIt,
+            class OutputIt,
+            class BinaryOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            InputIt first,
+            OutputIt result,
+            BinaryOp binary_op,
+            std::size_t num_items,
+            cudaStream_t stream,
+            thrust::detail::integral_constant<bool, true> /* comparable */)
+  {
+    // The documentation states that pointers might be equal but can't alias in
+    // any other way. That is, the distance should be equal to zero or exceed
+    // `num_items`. In the latter case, we use an optimized version.
+    if (first != result)
+    {
+      constexpr bool may_alias = false;
+      return doit_step<may_alias>(d_temp_storage,
+                                  temp_storage_bytes,
+                                  first,
+                                  result,
+                                  binary_op,
+                                  num_items,
+                                  stream);
+    }
+
+    constexpr bool may_alias = true;
+    return doit_step<may_alias>(d_temp_storage,
+                                temp_storage_bytes,
+                                first,
+                                result,
+                                binary_op,
+                                num_items,
+                                stream);
+  }
+
+  template <typename Derived,
+            typename InputIt,
+            typename OutputIt,
+            typename BinaryOp>
+  OutputIt THRUST_RUNTIME_FUNCTION
+  adjacent_difference(execution_policy<Derived>& policy,
+                      InputIt                    first,
+                      InputIt                    last,
+                      OutputIt                   result,
+                      BinaryOp                   binary_op)
+  {
+    const auto num_items =
+      static_cast<std::size_t>(thrust::distance(first, last));
+    std::size_t storage_size = 0;
+    cudaStream_t stream = cuda_cub::stream(policy);
+
+    using UnwrapInputIt = thrust::detail::try_unwrap_contiguous_iterator_return_t<InputIt>;
+    using UnwrapOutputIt = thrust::detail::try_unwrap_contiguous_iterator_return_t<OutputIt>;
+
+    using InputValueT = thrust::iterator_value_t<UnwrapInputIt>;
+    using OutputValueT = thrust::iterator_value_t<UnwrapOutputIt>;
+
+    constexpr bool can_compare_iterators =
+      std::is_pointer<UnwrapInputIt>::value &&
+      std::is_pointer<UnwrapOutputIt>::value &&
+      std::is_same<InputValueT, OutputValueT>::value;
+
+    auto first_unwrap = thrust::detail::try_unwrap_contiguous_iterator(first);
+    auto result_unwrap = thrust::detail::try_unwrap_contiguous_iterator(result);
+
+    thrust::detail::integral_constant<bool, can_compare_iterators> comparable;
+
+    cudaError_t status = doit_step(nullptr,
+                                   storage_size,
+                                   first_unwrap,
+                                   result_unwrap,
+                                   binary_op,
+                                   num_items,
+                                   stream,
+                                   comparable);
+    cuda_cub::throw_on_error(status, "adjacent_difference failed on 1st step");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+
+    status = doit_step(static_cast<void *>(tmp.data().get()),
+                       storage_size,
+                       first_unwrap,
+                       result_unwrap,
+                       binary_op,
+                       num_items,
+                       stream,
+                       comparable);
+    cuda_cub::throw_on_error(status, "adjacent_difference failed on 2nd step");
+
+    status = cuda_cub::synchronize_optional(policy);
+    cuda_cub::throw_on_error(status, "adjacent_difference failed to synchronize");
+
+    return result + num_items;
+  }
+
+}    // namespace __adjacent_difference
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class BinaryOp>
+OutputIt __host__ __device__
+adjacent_difference(execution_policy<Derived> &policy,
+                    InputIt                    first,
+                    InputIt                    last,
+                    OutputIt                   result,
+                    BinaryOp                   binary_op)
+{
+  THRUST_CDP_DISPATCH(
+    (result = __adjacent_difference::adjacent_difference(policy,
+                                                         first,
+                                                         last,
+                                                         result,
+                                                         binary_op);),
+    (result = thrust::adjacent_difference(cvt_to_seq(derived_cast(policy)),
+                                          first,
+                                          last,
+                                          result,
+                                          binary_op);));
+  return result;
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt>
+OutputIt __host__ __device__
+adjacent_difference(execution_policy<Derived> &policy,
+                    InputIt                    first,
+                    InputIt                    last,
+                    OutputIt                   result)
+{
+  typedef typename iterator_traits<InputIt>::value_type input_type;
+  return cuda_cub::adjacent_difference(policy,
+                                       first,
+                                       last,
+                                       result,
+                                       minus<input_type>());
+}
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+//
+#include <thrust/memory.h>
+#include <thrust/adjacent_difference.h>
+#endif
+

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

@@ -0,0 +1,102 @@
+/*
+ *  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
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/cuda/detail/copy.h>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+
+template<typename DerivedPolicy, typename Pointer1, typename Pointer2>
+inline __host__ __device__
+  void assign_value(thrust::cuda::execution_policy<DerivedPolicy> &exec, Pointer1 dst, Pointer2 src)
+{
+  // XXX war nvbugs/881631
+  struct war_nvbugs_881631
+  {
+    __host__ inline static void host_path(thrust::cuda::execution_policy<DerivedPolicy> &exec, Pointer1 dst, Pointer2 src)
+    {
+      cuda_cub::copy(exec, src, src + 1, dst);
+    }
+
+    __device__ inline static void device_path(thrust::cuda::execution_policy<DerivedPolicy> &, Pointer1 dst, Pointer2 src)
+    {
+      *thrust::raw_pointer_cast(dst) = *thrust::raw_pointer_cast(src);
+    }
+  };
+
+  NV_IF_TARGET(NV_IS_HOST, (
+    war_nvbugs_881631::host_path(exec,dst,src);
+  ), (
+    war_nvbugs_881631::device_path(exec,dst,src);
+  ));
+
+} // end assign_value()
+
+
+template<typename System1, typename System2, typename Pointer1, typename Pointer2>
+inline __host__ __device__
+  void assign_value(cross_system<System1,System2> &systems, Pointer1 dst, Pointer2 src)
+{
+  // XXX war nvbugs/881631
+  struct war_nvbugs_881631
+  {
+    __host__ inline static void host_path(cross_system<System1,System2> &systems, Pointer1 dst, Pointer2 src)
+    {
+      // rotate the systems so that they are ordered the same as (src, dst)
+      // for the call to thrust::copy
+      cross_system<System2,System1> rotated_systems = systems.rotate();
+      cuda_cub::copy(rotated_systems, src, src + 1, dst);
+    }
+
+    __device__ inline static void device_path(cross_system<System1,System2> &, Pointer1 dst, Pointer2 src)
+    {
+      // XXX forward the true cuda::execution_policy inside systems here
+      //     instead of materializing a tag
+      thrust::cuda::tag cuda_tag;
+      thrust::cuda_cub::assign_value(cuda_tag, dst, src);
+    }
+  };
+
+  NV_IF_TARGET(NV_IS_HOST, (
+    war_nvbugs_881631::host_path(systems,dst,src);
+  ), (
+    war_nvbugs_881631::device_path(systems,dst,src);
+  ));
+} // end assign_value()
+
+
+} // end cuda_cub
+THRUST_NAMESPACE_END
+#endif

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

@@ -0,0 +1,29 @@
+/*
+*  Copyright 2021 NVIDIA Corporation
+*
+*  Licensed under the Apache License, Version 2.0 (the "License");
+*  you may not use this file except in compliance with the License.
+*  You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+*  Unless required by applicable law or agreed to in writing, software
+*  distributed under the License is distributed on an "AS IS" BASIS,
+*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*  See the License for the specific language governing permissions and
+*  limitations under the License.
+*/
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// this system has no special version of this algorithm

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

@@ -0,0 +1,98 @@
+/*
+*  Copyright 2021-2022 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.
+*/
+
+/**
+ * \file
+ * Utilities for CUDA dynamic parallelism.
+ */
+
+#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/config.cuh>
+#include <cub/detail/detect_cuda_runtime.cuh>
+
+#include <nv/target>
+
+/**
+ * \def THRUST_CDP_DISPATCH
+ *
+ * If CUDA Dynamic Parallelism / CUDA Nested Parallelism is available, always
+ * run the parallel implementation. Otherwise, run the parallel implementation
+ * when called from the host, and fallback to the sequential implementation on
+ * the device.
+ *
+ * `par_impl` and `seq_impl` are blocks of C++ statements enclosed in
+ * parentheses, similar to NV_IF_TARGET blocks:
+ *
+ * \code
+ * THRUST_CDP_DISPATCH((launch_parallel_kernel();), (run_serial_impl();));
+ * \endcode
+ */
+
+#if defined(CUB_DETAIL_CDPv1)
+
+// Special case for NVCC -- need to inform the device path about the kernels
+// that are launched from the host path.
+#if defined(__CUDACC__) && defined(__CUDA_ARCH__)
+
+// seq_impl only used on platforms that do not support device synchronization.
+#define THRUST_CDP_DISPATCH(par_impl, seq_impl)                                \
+  if (false)                                                                   \
+  { /* Without this, the device pass won't compile any kernels. */             \
+    NV_IF_TARGET(NV_ANY_TARGET, par_impl);                                     \
+  }                                                                            \
+  NV_IF_TARGET(NV_PROVIDES_SM_90, seq_impl, par_impl)
+
+#else // NVCC device pass
+
+// seq_impl only used on platforms that do not support device synchronization.
+#define THRUST_CDP_DISPATCH(par_impl, seq_impl)                                \
+  NV_IF_TARGET(NV_PROVIDES_SM_90, seq_impl, par_impl)
+
+#endif // NVCC device pass
+
+#else // CDPv1 unavailable. Always fallback to serial on device:
+
+// Special case for NVCC -- need to inform the device path about the kernels
+// that are launched from the host path.
+#if defined(__CUDACC__) && defined(__CUDA_ARCH__)
+
+// Device-side launch not supported, fallback to sequential in device code.
+#define THRUST_CDP_DISPATCH(par_impl, seq_impl)                                \
+  if (false)                                                                   \
+  { /* Without this, the device pass won't compile any kernels. */             \
+    NV_IF_TARGET(NV_ANY_TARGET, par_impl);                                     \
+  }                                                                            \
+  NV_IF_TARGET(NV_IS_HOST, par_impl, seq_impl)
+
+#else // !(NVCC device pass):
+
+#define THRUST_CDP_DISPATCH(par_impl, seq_impl)                                \
+  NV_IF_TARGET(NV_IS_HOST, par_impl, seq_impl)
+
+#endif // NVCC device pass
+
+#endif // CDP version

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

@@ -0,0 +1,192 @@
+/******************************************************************************
+ * 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/advance.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/cross_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy, typename InputIt, typename OutputIt>
+__host__ __device__ OutputIt
+copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+     InputIt                                                     first,
+     InputIt                                                     last,
+     OutputIt                                                    result);
+
+template <class DerivedPolicy, class InputIt, class Size, class OutputIt>
+__host__ __device__ OutputIt
+copy_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+       InputIt                                                     first,
+       Size                                                        n,
+       OutputIt                                                    result);
+
+namespace cuda_cub {
+
+// D->D copy requires NVCC compiler
+template <class System,
+          class InputIterator,
+          class OutputIterator>
+OutputIterator __host__ __device__
+copy(execution_policy<System> &system,
+     InputIterator             first,
+     InputIterator             last,
+     OutputIterator            result);
+
+template <class System1,
+          class System2,
+          class InputIterator,
+          class OutputIterator>
+OutputIterator __host__
+copy(cross_system<System1, System2> systems,
+     InputIterator  first,
+     InputIterator  last,
+     OutputIterator result);
+
+template <class System,
+          class InputIterator,
+          class Size,
+          class OutputIterator>
+OutputIterator __host__ __device__
+copy_n(execution_policy<System> &system,
+       InputIterator             first,
+       Size                      n,
+       OutputIterator            result);
+
+template <class System1,
+          class System2,
+          class InputIterator,
+          class Size,
+          class OutputIterator>
+OutputIterator __host__
+copy_n(cross_system<System1, System2> systems,
+       InputIterator  first,
+       Size           n,
+       OutputIterator result);
+
+}    // namespace cuda_
+THRUST_NAMESPACE_END
+
+
+
+#include <thrust/system/cuda/detail/internal/copy_device_to_device.h>
+#include <thrust/system/cuda/detail/internal/copy_cross_system.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+// D->D copy requires NVCC compiler
+
+__thrust_exec_check_disable__
+template <class System,
+          class InputIterator,
+          class OutputIterator>
+OutputIterator __host__ __device__
+copy(execution_policy<System> &system,
+     InputIterator             first,
+     InputIterator             last,
+     OutputIterator            result)
+{
+  THRUST_CDP_DISPATCH(
+    (result = __copy::device_to_device(system, first, last, result);),
+    (result =
+       thrust::copy(cvt_to_seq(derived_cast(system)), first, last, result);));
+  return result;
+}    // end copy()
+
+__thrust_exec_check_disable__
+template <class System,
+          class InputIterator,
+          class Size,
+          class OutputIterator>
+OutputIterator __host__ __device__
+copy_n(execution_policy<System> &system,
+       InputIterator             first,
+       Size                      n,
+       OutputIterator            result)
+{
+  THRUST_CDP_DISPATCH(
+    (result = __copy::device_to_device(system,
+                                       first,
+                                       thrust::next(first, n),
+                                       result);),
+    (result =
+       thrust::copy_n(cvt_to_seq(derived_cast(system)), first, n, result);));
+  return result;
+} // end copy_n()
+#endif
+
+template <class System1,
+          class System2,
+          class InputIterator,
+          class OutputIterator>
+OutputIterator __host__
+copy(cross_system<System1, System2> systems,
+     InputIterator  first,
+     InputIterator  last,
+     OutputIterator result)
+{
+  return __copy::cross_system_copy(systems,first,last,result);
+} // end copy()
+
+template <class System1,
+          class System2,
+          class InputIterator,
+          class Size,
+          class OutputIterator>
+OutputIterator __host__
+copy_n(cross_system<System1, System2> systems,
+       InputIterator  first,
+       Size           n,
+       OutputIterator result)
+{
+  return __copy::cross_system_copy_n(systems, first, n, result);
+} // end copy_n()
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/memory.h>
+#include <thrust/detail/temporary_array.h>

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

@@ -0,0 +1,839 @@
+/******************************************************************************
+ * 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/function.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/distance.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/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
+// XXX declare generic copy_if interface
+// to avoid circulular dependency from thrust/copy.h
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate>
+__host__ __device__
+    OutputIterator
+    copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            InputIterator                                               first,
+            InputIterator                                               last,
+            OutputIterator                                              result,
+            Predicate                                                   pred);
+
+template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+__host__ __device__
+    OutputIterator
+    copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            InputIterator1                                              first,
+            InputIterator1                                              last,
+            InputIterator2                                              stencil,
+            OutputIterator                                              result,
+            Predicate                                                   pred);
+
+namespace cuda_cub {
+
+namespace __copy_if {
+
+  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;
+
+  template<class T>
+  struct Tuning<sm52, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 9,
+      ITEMS_PER_THREAD            = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))),
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning<350>
+
+
+  template<class T>
+  struct Tuning<sm35, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 10,
+      ITEMS_PER_THREAD            = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))),
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning<350>
+
+  template<class T>
+  struct Tuning<sm30, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      ITEMS_PER_THREAD            = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(3, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))),
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning<300>
+
+  struct no_stencil_tag_    {};
+  typedef no_stencil_tag_* no_stencil_tag;
+  template <class ItemsIt,
+            class StencilIt,
+            class OutputIt,
+            class Predicate,
+            class Size,
+            class NumSelectedOutputIt>
+  struct CopyIfAgent
+  {
+    typedef typename iterator_traits<ItemsIt>::value_type   item_type;
+    typedef typename iterator_traits<StencilIt>::value_type stencil_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::LoadIterator<PtxPlan, StencilIt>::type StencilLoadIt;
+
+      typedef typename core::BlockLoad<PtxPlan, ItemsLoadIt>::type   BlockLoadItems;
+      typedef typename core::BlockLoad<PtxPlan, StencilLoadIt>::type BlockLoadStencil;
+
+      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;
+
+
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage          scan;
+          typename TilePrefixCallback::TempStorage prefix;
+        } scan_storage;
+
+        typename BlockLoadItems::TempStorage   load_items;
+        typename BlockLoadStencil::TempStorage load_stencil;
+
+        core::uninitialized_array<item_type, PtxPlan::ITEMS_PER_TILE> raw_exchange;
+      };    // 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::StencilLoadIt      StencilLoadIt;
+    typedef typename ptx_plan::BlockLoadItems     BlockLoadItems;
+    typedef typename ptx_plan::BlockLoadStencil   BlockLoadStencil;
+    typedef typename ptx_plan::TilePrefixCallback TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan          BlockScan;
+    typedef typename ptx_plan::TempStorage        TempStorage;
+
+    enum
+    {
+      USE_STENCIL      = !thrust::detail::is_same<StencilIt, no_stencil_tag>::value,
+      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 &  storage;
+      ScanTileState &tile_state;
+      ItemsLoadIt    items_load_it;
+      StencilLoadIt  stencil_load_it;
+      OutputIt       output_it;
+      Predicate      predicate;
+      Size           num_items;
+
+      //------------------------------------------
+      // scatter results to memory
+      //------------------------------------------
+
+      THRUST_DEVICE_FUNCTION void
+      scatter(item_type (&items)[ITEMS_PER_THREAD],
+              Size (&selection_flags)[ITEMS_PER_THREAD],
+              Size (&selection_indices)[ITEMS_PER_THREAD],
+              int  num_tile_selections,
+              Size num_selections_prefix)
+      {
+        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])
+          {
+            new (&storage.raw_exchange[local_scatter_offset]) item_type(items[ITEM]);
+          }
+        }
+
+        sync_threadblock();
+
+        for (int item = threadIdx.x;
+             item < num_tile_selections;
+             item += BLOCK_THREADS)
+        {
+          output_it[num_selections_prefix + item] = storage.raw_exchange[item];
+        }
+      }    // func scatter
+
+      //------------------------------------------
+      // specialize predicate on different types
+      //------------------------------------------
+
+      template <int T>
+      struct __tag {};
+
+      enum ItemStencil
+      {
+        ITEM,
+        STENCIL
+      };
+
+      template <bool TAG, class T>
+      struct wrap_value
+      {
+        T const &              x;
+        THRUST_DEVICE_FUNCTION wrap_value(T const &x) : x(x) {}
+
+        THRUST_DEVICE_FUNCTION T const &operator()() const { return x; };
+      };    // struct wrap_type
+
+      //------- item
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<ITEM, item_type> const &x,
+                        __tag<false /* USE_STENCIL */>)
+      {
+        return predicate(x());
+      }
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<ITEM, item_type> const &,
+                        __tag<true>)
+      {
+        return false;
+      }
+
+      //-------- stencil
+
+      template <class T>
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<STENCIL, T> const &x,
+                        __tag<true>)
+      {
+        return predicate(x());
+      }
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<STENCIL, no_stencil_tag_> const &,
+                        __tag<true>)
+      {
+        return false;
+      }
+
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<STENCIL, stencil_type> const &,
+                        __tag<false>)
+      {
+        return false;
+      }
+
+      template <bool IS_LAST_TILE, ItemStencil TYPE, class T>
+      THRUST_DEVICE_FUNCTION void
+      compute_selection_flags(int num_tile_items,
+                              T (&values)[ITEMS_PER_THREAD],
+                              Size (&selection_flags)[ITEMS_PER_THREAD])
+      {
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          // Out-of-bounds items are selection_flags
+          selection_flags[ITEM] = 1;
+
+          if (!IS_LAST_TILE ||
+              (Size(threadIdx.x * ITEMS_PER_THREAD) + ITEM < num_tile_items))
+          {
+            selection_flags[ITEM] =
+                predicate_wrapper(wrap_value<TYPE, T>(values[ITEM]),
+                                  __tag<USE_STENCIL>());
+          }
+        }
+      }
+
+      //------------------------------------------
+      // consume tiles
+      //------------------------------------------
+
+      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)
+      {
+        item_type items_loc[ITEMS_PER_THREAD];
+        Size      selection_flags[ITEMS_PER_THREAD];
+        Size      selection_idx[ITEMS_PER_THREAD];
+
+        if (IS_LAST_TILE) {
+          BlockLoadItems(storage.load_items)
+              .Load(items_load_it + tile_base,
+                    items_loc,
+                    num_tile_items);
+        }
+        else
+        {
+          BlockLoadItems(storage.load_items)
+              .Load(items_load_it + tile_base,
+                    items_loc);
+        }
+
+        core::sync_threadblock();
+
+        if (USE_STENCIL)
+        {
+          stencil_type stencil_loc[ITEMS_PER_THREAD];
+
+          if (IS_LAST_TILE)
+          {
+            BlockLoadStencil(storage.load_stencil)
+                .Load(stencil_load_it + tile_base,
+                      stencil_loc,
+                      num_tile_items);
+          }
+          else
+          {
+            BlockLoadStencil(storage.load_stencil)
+                .Load(stencil_load_it + tile_base,
+                      stencil_loc);
+          }
+
+          compute_selection_flags<IS_LAST_TILE, STENCIL>(num_tile_items,
+                                                         stencil_loc,
+                                                         selection_flags);
+        }
+        else /* Use predicate on items rather then stencil */
+        {
+          compute_selection_flags<IS_LAST_TILE, ITEM>(num_tile_items,
+                                                      items_loc,
+                                                      selection_flags);
+        }
+
+        core::sync_threadblock();
+
+        Size num_tile_selections   = 0;
+        Size num_selections        = 0;
+        Size num_selections_prefix = 0;
+        if (IS_FIRST_TILE)
+        {
+          BlockScan(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,
+                                       storage.scan_storage.prefix,
+                                       cub::Sum(),
+                                       tile_idx);
+          BlockScan(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;
+          }
+        }
+
+        core::sync_threadblock();
+
+        scatter(items_loc,
+                selection_flags,
+                selection_idx,
+                num_tile_selections,
+                num_selections_prefix);
+
+
+        return num_selections;
+      }    // func consume_tile_impl
+
+      template <bool         IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION Size
+      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);
+        }
+      }    // func consume_tile
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION impl(TempStorage &       storage_,
+                                  ScanTileState &     tile_state_,
+                                  ItemsIt             items_it,
+                                  StencilIt           stencil_it,
+                                  OutputIt            output_it_,
+                                  Predicate           predicate_,
+                                  Size                num_items_,
+                                  int                 num_tiles,
+                                  NumSelectedOutputIt num_selected_out)
+          : storage(storage_),
+            tile_state(tile_state_),
+            items_load_it(core::make_load_iterator(ptx_plan(), items_it)),
+            stencil_load_it(core::make_load_iterator(ptx_plan(), stencil_it)),
+            output_it(output_it_),
+            predicate(predicate_),
+            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;
+          }
+        }
+      }    // ctor impl
+    };
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ItemsIt             items_it,
+                       StencilIt           stencil_it,
+                       OutputIt            output_it,
+                       Predicate           predicate,
+                       Size                num_items,
+                       NumSelectedOutputIt num_selected_out,
+                       ScanTileState       tile_state,
+                       int                 num_tiles,
+                       char *              shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
+
+      impl(storage,
+           tile_state,
+           items_it,
+           stencil_it,
+           output_it,
+           predicate,
+           num_items,
+           num_tiles,
+           num_selected_out);
+    }
+  };    // struct CopyIfAgent
+
+  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 ItemsIt,
+            class StencilIt,
+            class OutputIt,
+            class Predicate,
+            class Size,
+            class NumSelectedOutIt>
+  THRUST_RUNTIME_FUNCTION
+  static cudaError_t doit_step(void *           d_temp_storage,
+                               size_t &         temp_storage_bytes,
+                               ItemsIt          items,
+                               StencilIt        stencil,
+                               OutputIt         output_it,
+                               Predicate        predicate,
+                               NumSelectedOutIt num_selected_out,
+                               Size             num_items,
+                               cudaStream_t     stream)
+  {
+    if (num_items == 0)
+      return cudaSuccess;
+
+    using core::AgentLauncher;
+    using core::AgentPlan;
+    using core::get_agent_plan;
+
+    typedef AgentLauncher<
+        CopyIfAgent<ItemsIt,
+                    StencilIt,
+                    OutputIt,
+                    Predicate,
+                    Size,
+                    NumSelectedOutIt> >
+        copy_if_agent;
+
+    typedef typename copy_if_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<copy_if_agent>::type copy_if_plan = copy_if_agent::get_plan(stream);
+
+    int tile_size = copy_if_plan.items_per_tile;
+    size_t num_tiles = cub::DivideAndRoundUp(num_items, tile_size);
+
+    size_t vshmem_size = core::vshmem_size(copy_if_plan.shared_memory_size,
+                                           num_tiles);
+
+    cudaError_t status = cudaSuccess;
+    if (num_items == 0)
+      return status;
+
+    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);
+
+    init_agent ia(init_plan, num_tiles, stream, "copy_if::init_agent");
+
+    char *vshmem_ptr = vshmem_size > 0 ? (char*)allocations[1] : NULL;
+
+    copy_if_agent pa(copy_if_plan, num_items, stream, vshmem_ptr, "copy_if::partition_agent");
+
+    ia.launch(tile_status, num_tiles, num_selected_out);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    pa.launch(items,
+              stencil,
+              output_it,
+              predicate,
+              num_items,
+              num_selected_out,
+              tile_status,
+              num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    return status;
+  }
+
+  template <typename Derived,
+            typename InputIt,
+            typename StencilIt,
+            typename OutputIt,
+            typename Predicate>
+  THRUST_RUNTIME_FUNCTION
+  OutputIt copy_if(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   StencilIt                  stencil,
+                   OutputIt                   output,
+                   Predicate                  predicate)
+  {
+    typedef int size_type;
+
+    size_type    num_items          = static_cast<size_type>(thrust::distance(first, last));
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    if (num_items == 0)
+      return output;
+
+    cudaError_t status;
+    status = doit_step(NULL,
+                       temp_storage_bytes,
+                       first,
+                       stencil,
+                       output,
+                       predicate,
+                       reinterpret_cast<size_type*>(NULL),
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "copy_if 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, "copy_if 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, "copy_if failed on 2nd alias_storage");
+
+    size_type* d_num_selected_out
+      = thrust::detail::aligned_reinterpret_cast<size_type*>(allocations[0]);
+
+    status = doit_step(allocations[1],
+                       temp_storage_bytes,
+                       first,
+                       stencil,
+                       output,
+                       predicate,
+                       d_num_selected_out,
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "copy_if failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "copy_if failed to synchronize");
+
+    size_type num_selected = get_value(policy, d_num_selected_out);
+
+    return output + num_selected;
+  }
+
+}    // namespace __copy_if
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIterator,
+          class OutputIterator,
+          class Predicate>
+OutputIterator __host__ __device__
+copy_if(execution_policy<Derived> &policy,
+        InputIterator              first,
+        InputIterator              last,
+        OutputIterator             result,
+        Predicate                  pred)
+{
+  THRUST_CDP_DISPATCH((return __copy_if::copy_if(policy,
+                                                   first,
+                                                   last,
+                                                   __copy_if::no_stencil_tag(),
+                                                   result,
+                                                   pred);),
+                      (return
+                         thrust::copy_if(cvt_to_seq(derived_cast(policy)),
+                                         first,
+                                         last,
+                                         result,
+                                         pred);));
+} // func copy_if
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIterator,
+          class StencilIterator,
+          class OutputIterator,
+          class Predicate>
+OutputIterator __host__ __device__
+copy_if(execution_policy<Derived> &policy,
+        InputIterator              first,
+        InputIterator              last,
+        StencilIterator            stencil,
+        OutputIterator             result,
+        Predicate                  pred)
+{
+  THRUST_CDP_DISPATCH(
+    (return __copy_if::copy_if(policy, first, last, stencil, result, pred);),
+    (return thrust::copy_if(cvt_to_seq(derived_cast(policy)),
+                              first,
+                              last,
+                              stencil,
+                              result,
+                              pred);));
+}    // func copy_if
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/copy.h>
+#endif

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

@@ -0,0 +1,88 @@
+/******************************************************************************
+ * 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/system/cuda/detail/reduce.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt,
+          class UnaryPred>
+typename iterator_traits<InputIt>::difference_type __host__ __device__
+count_if(execution_policy<Derived> &policy,
+         InputIt                    first,
+         InputIt                    last,
+         UnaryPred                  unary_pred)
+{
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  typedef transform_input_iterator_t<size_type,
+                                     InputIt,
+                                     UnaryPred>
+      flag_iterator_t;
+
+  return cuda_cub::reduce_n(policy,
+                            flag_iterator_t(first, unary_pred),
+                            thrust::distance(first, last),
+                            size_type(0),
+                            plus<size_type>());
+}
+
+template <class Derived,
+          class InputIt,
+          class Value>
+typename iterator_traits<InputIt>::difference_type __host__ __device__
+count(execution_policy<Derived> &policy,
+      InputIt                    first,
+      InputIt                    last,
+      Value const &              value)
+{
+  return cuda_cub::count_if(policy,
+                            first,
+                            last,
+                            thrust::detail::equal_to_value<Value>(value));
+}
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

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

@@ -0,0 +1,347 @@
+/******************************************************************************
+ * 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/guarded_cuda_runtime_api.h>
+#include <thrust/system/cpp/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+  template <class Sys1, class Sys2>
+  struct cross_system : execution_policy<cross_system<Sys1, Sys2> >
+  {
+    typedef thrust::execution_policy<Sys1> policy1;
+    typedef thrust::execution_policy<Sys2> policy2;
+
+    policy1 &sys1;
+    policy2 &sys2;
+
+    inline __host__ __device__
+    cross_system(policy1 &sys1, policy2 &sys2) : sys1(sys1), sys2(sys2) {}
+
+    inline __host__ __device__
+    cross_system<Sys2, Sys1> rotate() const
+    {
+      return cross_system<Sys2, Sys1>(sys2, sys1);
+    }
+  };
+
+#if THRUST_CPP_DIALECT >= 2011
+  // Device to host.
+  template <class Sys1, class Sys2>
+  constexpr __host__ __device__
+  auto direction_of_copy(
+    thrust::system::cuda::execution_policy<Sys1> const&
+  , thrust::cpp::execution_policy<Sys2> const&
+  )
+  THRUST_DECLTYPE_RETURNS(
+    thrust::detail::integral_constant<
+      cudaMemcpyKind, cudaMemcpyDeviceToHost
+    >{}
+  )
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  constexpr __host__ __device__
+  auto direction_of_copy(
+    thrust::cpp::execution_policy<Sys1> const&
+  , thrust::system::cuda::execution_policy<Sys2> const&
+  )
+  THRUST_DECLTYPE_RETURNS(
+    thrust::detail::integral_constant<
+      cudaMemcpyKind, cudaMemcpyHostToDevice
+    >{}
+  )
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  constexpr __host__ __device__
+  auto direction_of_copy(
+    thrust::system::cuda::execution_policy<Sys1> const&
+  , thrust::system::cuda::execution_policy<Sys2> const&
+  )
+  THRUST_DECLTYPE_RETURNS(
+    thrust::detail::integral_constant<
+      cudaMemcpyKind, cudaMemcpyDeviceToDevice
+    >{}
+  )
+
+  // Device to device.
+  template <class DerivedPolicy>
+  constexpr __host__ __device__
+  auto direction_of_copy(execution_policy<DerivedPolicy> const &)
+  THRUST_DECLTYPE_RETURNS(
+    thrust::detail::integral_constant<
+      cudaMemcpyKind, cudaMemcpyDeviceToDevice
+    >{}
+  )
+
+  template <class Sys1, class Sys2>
+  constexpr __host__ __device__
+  auto direction_of_copy(
+    execution_policy<cross_system<Sys1, Sys2>> const &systems
+  )
+  THRUST_DECLTYPE_RETURNS(
+    direction_of_copy(
+      derived_cast(derived_cast(systems).sys1)
+    , derived_cast(derived_cast(systems).sys2)
+    )
+  )
+
+  template <typename ExecutionPolicy0,
+            typename ExecutionPolicy1,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy0>(),
+                                         std::declval<ExecutionPolicy1>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyDeviceToHost == Direction::value
+  >
+  is_device_to_host_copy(
+    ExecutionPolicy0 const& exec0
+  , ExecutionPolicy1 const& exec1
+  ) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyDeviceToHost == Direction::value
+  >
+  is_device_to_host_copy(ExecutionPolicy const& exec) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy0,
+            typename ExecutionPolicy1,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy0>(),
+                                         std::declval<ExecutionPolicy1>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyHostToDevice == Direction::value
+  >
+  is_host_to_device_copy(
+    ExecutionPolicy0 const& exec0
+  , ExecutionPolicy1 const& exec1
+  ) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyHostToDevice == Direction::value
+  >
+  is_host_to_device_copy(ExecutionPolicy const& exec) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy0,
+            typename ExecutionPolicy1,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy0>(),
+                                         std::declval<ExecutionPolicy1>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyDeviceToDevice == Direction::value
+  >
+  is_device_to_device_copy(
+    ExecutionPolicy0 const& exec0
+  , ExecutionPolicy1 const& exec1
+  ) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyDeviceToDevice == Direction::value
+  >
+  is_device_to_device_copy(ExecutionPolicy const& exec) noexcept
+  {
+    return {};
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::cuda::execution_policy<Sys1> &sys1,
+                       thrust::execution_policy<Sys2> &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::cuda::execution_policy<Sys1> const &sys1,
+                       thrust::execution_policy<Sys2> const &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::execution_policy<Sys1> &,
+                       thrust::cuda::execution_policy<Sys2> &sys2)
+  THRUST_DECLTYPE_RETURNS(sys2)
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::execution_policy<Sys1> const &,
+                       thrust::cuda::execution_policy<Sys2> const &sys2)
+  THRUST_DECLTYPE_RETURNS(sys2)
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::cuda::execution_policy<Sys1> &sys1,
+                       thrust::cuda::execution_policy<Sys2> &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::cuda::execution_policy<Sys1> const &sys1,
+                       thrust::cuda::execution_policy<Sys2> const &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::cuda::execution_policy<Sys1> &,
+                     thrust::execution_policy<Sys2> &sys2)
+  THRUST_DECLTYPE_RETURNS(sys2)
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::cuda::execution_policy<Sys1> const &,
+                     thrust::execution_policy<Sys2> const &sys2)
+  THRUST_DECLTYPE_RETURNS(sys2)
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::execution_policy<Sys1> &sys1,
+                     thrust::cuda::execution_policy<Sys2> &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::execution_policy<Sys1> const &sys1,
+                     thrust::cuda::execution_policy<Sys2> const &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::execution_policy<Sys1> &sys1,
+                     thrust::execution_policy<Sys2> &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::execution_policy<Sys1> const &sys1,
+                     thrust::execution_policy<Sys2> const &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+#endif
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  cross_system<Sys1, Sys2>
+  select_system(execution_policy<Sys1> const &             sys1,
+                thrust::cpp::execution_policy<Sys2> const &sys2)
+  {
+    thrust::execution_policy<Sys1> &     non_const_sys1 = const_cast<execution_policy<Sys1> &>(sys1);
+    thrust::cpp::execution_policy<Sys2> &non_const_sys2 = const_cast<thrust::cpp::execution_policy<Sys2> &>(sys2);
+    return cross_system<Sys1, Sys2>(non_const_sys1, non_const_sys2);
+  }
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  cross_system<Sys1, Sys2>
+  select_system(thrust::cpp::execution_policy<Sys1> const &sys1,
+                execution_policy<Sys2> const &             sys2)
+  {
+    thrust::cpp::execution_policy<Sys1> &non_const_sys1 = const_cast<thrust::cpp::execution_policy<Sys1> &>(sys1);
+    thrust::execution_policy<Sys2> &     non_const_sys2 = const_cast<execution_policy<Sys2> &>(sys2);
+    return cross_system<Sys1, Sys2>(non_const_sys1, non_const_sys2);
+  }
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,89 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/preprocessor.h>
+#include <thrust/detail/integer_traits.h>
+
+/**
+ * Dispatch between 32-bit and 64-bit index based versions of the same algorithm
+ * implementation. This version assumes that callables for both branches consist
+ * of the same tokens, and is intended to be used with Thrust-style dispatch
+ * interfaces, that always deduce the size type from the arguments.
+ */
+#define THRUST_INDEX_TYPE_DISPATCH(status, call, count, arguments) \
+    if (count <= thrust::detail::integer_traits<thrust::detail::int32_t>::const_max) { \
+        auto THRUST_PP_CAT2(count, _fixed) = static_cast<thrust::detail::int32_t>(count); \
+        status = call arguments; \
+    } \
+    else { \
+        auto THRUST_PP_CAT2(count, _fixed) = static_cast<thrust::detail::int64_t>(count); \
+        status = call arguments; \
+    }
+
+/**
+ * Dispatch between 32-bit and 64-bit index based versions of the same algorithm
+ * implementation. This version assumes that callables for both branches consist
+ * of the same tokens, and is intended to be used with Thrust-style dispatch
+ * interfaces, that always deduce the size type from the arguments.
+ *
+ * This version of the macro supports providing two count variables, which is
+ * necessary for set algorithms.
+ */
+#define THRUST_DOUBLE_INDEX_TYPE_DISPATCH(status, call, count1, count2, arguments) \
+    if (count1 + count2 <= thrust::detail::integer_traits<thrust::detail::int32_t>::const_max) { \
+        auto THRUST_PP_CAT2(count1, _fixed) = static_cast<thrust::detail::int32_t>(count1); \
+        auto THRUST_PP_CAT2(count2, _fixed) = static_cast<thrust::detail::int32_t>(count2); \
+        status = call arguments; \
+    } \
+    else { \
+        auto THRUST_PP_CAT2(count1, _fixed) = static_cast<thrust::detail::int64_t>(count1); \
+        auto THRUST_PP_CAT2(count2, _fixed) = static_cast<thrust::detail::int64_t>(count2); \
+        status = call arguments; \
+    }
+/**
+ * Dispatch between 32-bit and 64-bit index based versions of the same algorithm
+ * implementation. This version allows using different token sequences for callables
+ * in both branches, and is intended to be used with CUB-style dispatch interfaces,
+ * where the "simple" interface always forces the size to be `int` (making it harder
+ * for us to use), but the complex interface that we end up using doesn't actually
+ * provide a way to fully deduce the type from just the call, making the size type
+ * appear in the token sequence of the callable.
+ *
+ * See reduce_n_impl to see an example of how this is meant to be used.
+ */
+#define THRUST_INDEX_TYPE_DISPATCH2(status, call_32, call_64, count, arguments) \
+    if (count <= thrust::detail::integer_traits<thrust::detail::int32_t>::const_max) { \
+        auto THRUST_PP_CAT2(count, _fixed) = static_cast<thrust::detail::int32_t>(count); \
+        status = call_32 arguments; \
+    } \
+    else { \
+        auto THRUST_PP_CAT2(count, _fixed) = static_cast<thrust::detail::int64_t>(count); \
+        status = call_64 arguments; \
+    }
+

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

@@ -0,0 +1,82 @@
+/******************************************************************************
+ * 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/mismatch.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class BinaryPred>
+bool __host__ __device__
+equal(execution_policy<Derived>& policy,
+      InputIt1                   first1,
+      InputIt1                   last1,
+      InputIt2                   first2,
+      BinaryPred                 binary_pred)
+{
+  return cuda_cub::mismatch(policy, first1, last1, first2, binary_pred).first == last1;
+}
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2>
+bool __host__ __device__
+equal(execution_policy<Derived>& policy,
+      InputIt1                   first1,
+      InputIt1                   last1,
+      InputIt2                   first2)
+{
+  typedef typename thrust::iterator_value<InputIt1>::type InputType1;
+  return cuda_cub::equal(policy,
+                         first1,
+                         last1,
+                         first2,
+                         equal_to<InputType1>());
+}
+
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif

miniCUDA124/include/thrust/system/cuda/detail/error.inl

@@ -0,0 +1,107 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/system/cuda/error.h>
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+
+error_code make_error_code(cuda::errc::errc_t e)
+{
+  return error_code(static_cast<int>(e), cuda_category());
+} // end make_error_code()
+
+
+error_condition make_error_condition(cuda::errc::errc_t e)
+{
+  return error_condition(static_cast<int>(e), cuda_category());
+} // end make_error_condition()
+
+
+namespace cuda_cub
+{
+
+namespace detail
+{
+
+
+class cuda_error_category
+  : public error_category
+{
+  public:
+    inline cuda_error_category(void) {}
+
+    inline virtual const char *name(void) const
+    {
+      return "cuda";
+    }
+
+    inline virtual std::string message(int ev) const
+    {
+      char const* const unknown_str  = "unknown error";
+      char const* const unknown_name = "cudaErrorUnknown";
+      char const* c_str  = ::cudaGetErrorString(static_cast<cudaError_t>(ev));
+      char const* c_name = ::cudaGetErrorName(static_cast<cudaError_t>(ev));
+      return std::string(c_name ? c_name : unknown_name)
+           + ": " + (c_str ? c_str : unknown_str);
+    }
+
+    inline virtual error_condition default_error_condition(int ev) const
+    {
+      using namespace cuda::errc;
+
+      if(ev < ::cudaErrorUnknown)
+      {
+        return make_error_condition(static_cast<errc_t>(ev));
+      }
+
+      return system_category().default_error_condition(ev);
+    }
+}; // end cuda_error_category
+
+} // end detail
+
+} // end namespace cuda_cub
+
+
+const error_category &cuda_category(void)
+{
+  static const thrust::system::cuda_cub::detail::cuda_error_category result;
+  return result;
+}
+
+
+} // end namespace system
+
+THRUST_NAMESPACE_END
+