diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/algorithm_wrapper.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/algorithm_wrapper.h new file mode 100644 index 0000000000000000000000000000000000000000..c09b9a0a0b4dcc52924425d1549093668e5d2952 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/algorithm_wrapper.h @@ -0,0 +1,27 @@ +/* + * Copyright 2020 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +// When a compiler uses Thrust as part of its implementation of Standard C++ +// algorithms, a cycle of included files may result when Thrust code tries to +// use a standard algorithm. Having a macro that is defined only when Thrust +// is including an algorithms-related header gives the compiler a chance to +// detect and break the cycle of includes. + +#define THRUST_INCLUDING_ALGORITHMS_HEADER +#include +#undef THRUST_INCLUDING_ALGORITHMS_HEADER diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/copy_construct_range.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/copy_construct_range.h new file mode 100644 index 0000000000000000000000000000000000000000..b3c2de32462772de3ecbeaee71ed37d57f3dc135 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/copy_construct_range.h @@ -0,0 +1,46 @@ +/* + * 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 +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ + +template +__host__ __device__ + Pointer copy_construct_range(thrust::execution_policy &from_system, + Allocator &a, + InputIterator first, + InputIterator last, + Pointer result); + +template +__host__ __device__ + Pointer copy_construct_range_n(thrust::execution_policy &from_system, + Allocator &a, + InputIterator first, + Size n, + Pointer result); + +} // end detail +THRUST_NAMESPACE_END + +#include + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/copy_construct_range.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/copy_construct_range.inl new file mode 100644 index 0000000000000000000000000000000000000000..a71cca1f7207278d6e3d9116ce48ce791e0fe98c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/copy_construct_range.inl @@ -0,0 +1,310 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ +namespace allocator_traits_detail +{ + + +template + struct copy_construct_with_allocator +{ + Allocator &a; + + __host__ __device__ + copy_construct_with_allocator(Allocator &a) + : a(a) + {} + + template + inline __host__ __device__ + void operator()(Tuple t) + { + const InputType &in = thrust::get<0>(t); + OutputType &out = thrust::get<1>(t); + + allocator_traits::construct(a, &out, in); + } +}; + + +// we need to use allocator_traits::construct() to +// copy construct a T if either: +// 1. Allocator has a 2-argument construct() member or +// 2. T has a non-trivial copy constructor +template + struct needs_copy_construct_via_allocator + : integral_constant< + bool, + (has_member_construct2::value || !has_trivial_copy_constructor::value) + > +{}; + + +// we know that std::allocator::construct's only effect is to call T's +// copy constructor, so we needn't consider or use its construct() member for copy construction +template + struct needs_copy_construct_via_allocator, T> + : integral_constant< + bool, + !has_trivial_copy_constructor::value + > +{}; + + +// XXX it's regrettable that this implementation is copied almost +// exactly from system::detail::generic::uninitialized_copy +// perhaps generic::uninitialized_copy could call this routine +// with a default allocator +template +__host__ __device__ + typename enable_if_convertible< + FromSystem, + ToSystem, + Pointer + >::type + uninitialized_copy_with_allocator(Allocator &a, + const thrust::execution_policy &, + const thrust::execution_policy &to_system, + InputIterator first, + InputIterator last, + Pointer result) +{ + // zip up the iterators + typedef thrust::tuple IteratorTuple; + typedef thrust::zip_iterator ZipIterator; + + ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result)); + ZipIterator end = begin; + + // get a zip_iterator pointing to the end + const typename thrust::iterator_difference::type n = thrust::distance(first,last); + thrust::advance(end,n); + + // create a functor + typedef typename iterator_traits::value_type InputType; + typedef typename iterator_traits::value_type OutputType; + + // do the for_each + // note we use to_system to dispatch the for_each + thrust::for_each(to_system, begin, end, copy_construct_with_allocator(a)); + + // return the end of the output range + return thrust::get<1>(end.get_iterator_tuple()); +} + + +// XXX it's regrettable that this implementation is copied almost +// exactly from system::detail::generic::uninitialized_copy_n +// perhaps generic::uninitialized_copy_n could call this routine +// with a default allocator +template +__host__ __device__ + typename enable_if_convertible< + FromSystem, + ToSystem, + Pointer + >::type + uninitialized_copy_with_allocator_n(Allocator &a, + const thrust::execution_policy &, + const thrust::execution_policy &to_system, + InputIterator first, + Size n, + Pointer result) +{ + // zip up the iterators + typedef thrust::tuple IteratorTuple; + typedef thrust::zip_iterator ZipIterator; + + ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result)); + + // create a functor + typedef typename iterator_traits::value_type InputType; + typedef typename iterator_traits::value_type OutputType; + + // do the for_each_n + // note we use to_system to dispatch the for_each_n + ZipIterator end = thrust::for_each_n(to_system, begin, n, copy_construct_with_allocator(a)); + + // return the end of the output range + return thrust::get<1>(end.get_iterator_tuple()); +} + + +template +__host__ __device__ + typename disable_if_convertible< + FromSystem, + ToSystem, + Pointer + >::type + uninitialized_copy_with_allocator(Allocator &, + const thrust::execution_policy &from_system, + const thrust::execution_policy &to_system, + InputIterator first, + InputIterator last, + Pointer result) +{ + // the systems aren't trivially interoperable + // just call two_system_copy and hope for the best + return thrust::detail::two_system_copy(from_system, to_system, first, last, result); +} // end uninitialized_copy_with_allocator() + + +template +__host__ __device__ + typename disable_if_convertible< + FromSystem, + ToSystem, + Pointer + >::type + uninitialized_copy_with_allocator_n(Allocator &, + const thrust::execution_policy &from_system, + const thrust::execution_policy &to_system, + InputIterator first, + Size n, + Pointer result) +{ + // the systems aren't trivially interoperable + // just call two_system_copy_n and hope for the best + return thrust::detail::two_system_copy_n(from_system, to_system, first, n, result); +} // end uninitialized_copy_with_allocator_n() + + +template +__host__ __device__ + typename disable_if< + needs_copy_construct_via_allocator< + Allocator, + typename pointer_element::type + >::value, + Pointer + >::type + copy_construct_range(thrust::execution_policy &from_system, + Allocator &a, + InputIterator first, + InputIterator last, + Pointer result) +{ + // just call two_system_copy + return thrust::detail::two_system_copy(from_system, allocator_system::get(a), first, last, result); +} + + +template +__host__ __device__ + typename disable_if< + needs_copy_construct_via_allocator< + Allocator, + typename pointer_element::type + >::value, + Pointer + >::type + copy_construct_range_n(thrust::execution_policy &from_system, + Allocator &a, + InputIterator first, + Size n, + Pointer result) +{ + // just call two_system_copy_n + return thrust::detail::two_system_copy_n(from_system, allocator_system::get(a), first, n, result); +} + + +template +__host__ __device__ + typename enable_if< + needs_copy_construct_via_allocator< + Allocator, + typename pointer_element::type + >::value, + Pointer + >::type + copy_construct_range(thrust::execution_policy &from_system, + Allocator &a, + InputIterator first, + InputIterator last, + Pointer result) +{ + return uninitialized_copy_with_allocator(a, from_system, allocator_system::get(a), first, last, result); +} + + +template +__host__ __device__ + typename enable_if< + needs_copy_construct_via_allocator< + Allocator, + typename pointer_element::type + >::value, + Pointer + >::type + copy_construct_range_n(thrust::execution_policy &from_system, + Allocator &a, + InputIterator first, + Size n, + Pointer result) +{ + return uninitialized_copy_with_allocator_n(a, from_system, allocator_system::get(a), first, n, result); +} + + +} // end allocator_traits_detail + + +template +__host__ __device__ + Pointer copy_construct_range(thrust::execution_policy &from_system, + Allocator &a, + InputIterator first, + InputIterator last, + Pointer result) +{ + return allocator_traits_detail::copy_construct_range(from_system, a, first, last, result); +} + + +template +__host__ __device__ + Pointer copy_construct_range_n(thrust::execution_policy &from_system, + Allocator &a, + InputIterator first, + Size n, + Pointer result) +{ + return allocator_traits_detail::copy_construct_range_n(from_system, a, first, n, result); +} + + +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/default_construct_range.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/default_construct_range.h new file mode 100644 index 0000000000000000000000000000000000000000..8b5026c05b342b0473b2c6aaee6c79e8845ccc5a --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/default_construct_range.h @@ -0,0 +1,36 @@ +/* + * 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_NAMESPACE_BEGIN +namespace detail +{ + + +template +__host__ __device__ +inline void default_construct_range(Allocator &a, Pointer p, Size n); + + +} // end detail +THRUST_NAMESPACE_END + +#include + + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/destroy_range.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/destroy_range.inl new file mode 100644 index 0000000000000000000000000000000000000000..662177f3a72f7ce97bdd8ce49ae637d2a096ee7f --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/destroy_range.inl @@ -0,0 +1,167 @@ +/* + * Copyright 2008-2021 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ +namespace allocator_traits_detail +{ + + +// destroy_range has three cases: +// if Allocator has an effectful member function destroy: +// 1. destroy via the allocator +// else +// 2. if T has a non-trivial destructor, destroy the range without using the allocator +// 3. if T has a trivial destructor, do a no-op + +template + struct has_effectful_member_destroy + : has_member_destroy +{}; + +// std::allocator::destroy's only effect is to invoke its argument's destructor +template + struct has_effectful_member_destroy, T> + : thrust::detail::false_type +{}; + +// case 1: Allocator has an effectful 1-argument member function "destroy" +template + struct enable_if_destroy_range_case1 + : thrust::detail::enable_if< + has_effectful_member_destroy< + Allocator, + typename pointer_element::type + >::value + > +{}; + +// case 2: Allocator has no member function "destroy", but T has a non-trivial destructor +template + struct enable_if_destroy_range_case2 + : thrust::detail::enable_if< + !has_effectful_member_destroy< + Allocator, + typename pointer_element::type + >::value && + !has_trivial_destructor< + typename pointer_element::type + >::value + > +{}; + +// case 3: Allocator has no member function "destroy", and T has a trivial destructor +template + struct enable_if_destroy_range_case3 + : thrust::detail::enable_if< + !has_effectful_member_destroy< + Allocator, + typename pointer_element::type + >::value && + has_trivial_destructor< + typename pointer_element::type + >::value + > +{}; + + + +template + struct destroy_via_allocator +{ + Allocator &a; + + __host__ __device__ + destroy_via_allocator(Allocator &a) + : a(a) + {} + + template + inline __host__ __device__ + void operator()(T &x) + { + allocator_traits::destroy(a, &x); + } +}; + + +// destroy_range case 1: destroy via allocator +template +__host__ __device__ + typename enable_if_destroy_range_case1::type + destroy_range(Allocator &a, Pointer p, Size n) +{ + thrust::for_each_n(allocator_system::get(a), p, n, destroy_via_allocator(a)); +} + + +// we must prepare for His coming +struct gozer +{ + __thrust_exec_check_disable__ + template + inline __host__ __device__ + void operator()(T &x) + { + x.~T(); + } +}; + +// destroy_range case 2: destroy without the allocator +template +__host__ __device__ + typename enable_if_destroy_range_case2::type + destroy_range(Allocator &a, Pointer p, Size n) +{ + thrust::for_each_n(allocator_system::get(a), p, n, gozer()); +} + + +// destroy_range case 3: no-op +template +__host__ __device__ + typename enable_if_destroy_range_case3::type + destroy_range(Allocator &, Pointer, Size) +{ + // no op +} + + +} // end allocator_traits_detail + + +template +__host__ __device__ + void destroy_range(Allocator &a, Pointer p, Size n) +{ + return allocator_traits_detail::destroy_range(a,p,n); +} + + +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/fill_construct_range.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/fill_construct_range.h new file mode 100644 index 0000000000000000000000000000000000000000..a7572cb2d2bc1c2e509dcb80911c60aacbbce6e4 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/fill_construct_range.h @@ -0,0 +1,35 @@ +/* + * 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_NAMESPACE_BEGIN +namespace detail +{ + + +template +__host__ __device__ +inline void fill_construct_range(Allocator &a, Pointer p, Size n, const T &value); + + +} // end detail +THRUST_NAMESPACE_END + +#include + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/no_throw_allocator.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/no_throw_allocator.h new file mode 100644 index 0000000000000000000000000000000000000000..a6c16985b11bb53c253fc9aa998cff5ad806ee43 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/no_throw_allocator.h @@ -0,0 +1,72 @@ +/* + * 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 + +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ + +template + struct no_throw_allocator : BaseAllocator +{ + private: + typedef BaseAllocator super_t; + + public: + inline __host__ __device__ + no_throw_allocator(const BaseAllocator &other = BaseAllocator()) + : super_t(other) + {} + + template + struct rebind + { + typedef no_throw_allocator::other> other; + }; // end rebind + + __host__ __device__ + void deallocate(typename super_t::pointer p, typename super_t::size_type n) + { + NV_IF_TARGET(NV_IS_HOST, ( + try + { + super_t::deallocate(p, n); + } // end try + catch(...) + { + // catch anything + } // end catch + ), ( + super_t::deallocate(p, n); + )); + } // end deallocate() + + inline __host__ __device__ + bool operator==(no_throw_allocator const &other) { return super_t::operator==(other); } + + inline __host__ __device__ + bool operator!=(no_throw_allocator const &other) { return super_t::operator!=(other); } +}; // end no_throw_allocator + +} // end detail +THRUST_NAMESPACE_END + + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/tagged_allocator.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/tagged_allocator.inl new file mode 100644 index 0000000000000000000000000000000000000000..bcd534cbceebb310f5acd7fd469f395c64deba3c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/tagged_allocator.inl @@ -0,0 +1,104 @@ +/* + * 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 +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ + + +template + __host__ __device__ + tagged_allocator + ::tagged_allocator() +{} + + +template + __host__ __device__ + tagged_allocator + ::tagged_allocator(const tagged_allocator &) +{} + + +template + template + __host__ __device__ + tagged_allocator + ::tagged_allocator(const tagged_allocator &) +{} + + +template + __host__ __device__ + tagged_allocator + ::~tagged_allocator() +{} + + +template + __host__ __device__ + typename tagged_allocator::pointer + tagged_allocator + ::address(reference x) const +{ + return &x; +} + + +template + __host__ __device__ + typename tagged_allocator::const_pointer + tagged_allocator + ::address(const_reference x) const +{ + return &x; +} + + +template + typename tagged_allocator::size_type + tagged_allocator + ::max_size() const +{ + return (std::numeric_limits::max)() / sizeof(T); +} + + +template +__host__ __device__ +bool operator==(const tagged_allocator &, const tagged_allocator &) +{ + return true; +} + + +template +__host__ __device__ +bool operator!=(const tagged_allocator &, const tagged_allocator &) +{ + return false; +} + + +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/binary_search.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/binary_search.inl new file mode 100644 index 0000000000000000000000000000000000000000..90350ced4bb3bed85d3a9cfa0911264ff7438415 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/binary_search.inl @@ -0,0 +1,480 @@ +/* + * 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 +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator lower_bound(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + const LessThanComparable &value) +{ + using thrust::system::detail::generic::lower_bound; + return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator lower_bound(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + const T &value, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::lower_bound; + return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator upper_bound(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + const LessThanComparable &value) +{ + using thrust::system::detail::generic::upper_bound; + return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator upper_bound(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + const T &value, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::upper_bound; + return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +bool binary_search(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + const LessThanComparable& value) +{ + using thrust::system::detail::generic::binary_search; + return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +bool binary_search(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + const T& value, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::binary_search; + return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair +equal_range(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + const T& value, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::equal_range; + return equal_range(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair +equal_range(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + const LessThanComparable& value) +{ + using thrust::system::detail::generic::equal_range; + return equal_range(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator lower_bound(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output) +{ + using thrust::system::detail::generic::lower_bound; + return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator lower_bound(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::lower_bound; + return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output, comp); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator upper_bound(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output) +{ + using thrust::system::detail::generic::upper_bound; + return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator upper_bound(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::upper_bound; + return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output, comp); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator binary_search(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output) +{ + using thrust::system::detail::generic::binary_search; + return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output); +} + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator binary_search(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::binary_search; + return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output, comp); +} + + +////////////////////// +// Scalar Functions // +////////////////////// + +template +ForwardIterator lower_bound(ForwardIterator first, + ForwardIterator last, + const LessThanComparable& value) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::lower_bound(select_system(system), first, last, value); +} + +template +ForwardIterator lower_bound(ForwardIterator first, + ForwardIterator last, + const T& value, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::lower_bound(select_system(system), first, last, value, comp); +} + +template +ForwardIterator upper_bound(ForwardIterator first, + ForwardIterator last, + const LessThanComparable& value) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::upper_bound(select_system(system), first, last, value); +} + +template +ForwardIterator upper_bound(ForwardIterator first, + ForwardIterator last, + const T& value, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::upper_bound(select_system(system), first, last, value, comp); +} + +template +bool binary_search(ForwardIterator first, + ForwardIterator last, + const LessThanComparable& value) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::binary_search(select_system(system), first, last, value); +} + +template +bool binary_search(ForwardIterator first, + ForwardIterator last, + const T& value, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::binary_search(select_system(system), first, last, value, comp); +} + +template +thrust::pair +equal_range(ForwardIterator first, + ForwardIterator last, + const LessThanComparable& value) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::equal_range(select_system(system), first, last, value); +} + +template +thrust::pair +equal_range(ForwardIterator first, + ForwardIterator last, + const T& value, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::equal_range(select_system(system), first, last, value, comp); +} + +////////////////////// +// Vector Functions // +////////////////////// + +template +OutputIterator lower_bound(ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::lower_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output); +} + +template +OutputIterator lower_bound(ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::lower_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output, comp); +} + +template +OutputIterator upper_bound(ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::upper_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output); +} + +template +OutputIterator upper_bound(ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::upper_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output, comp); +} + +template +OutputIterator binary_search(ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::binary_search(select_system(system1,system2,system3), first, last, values_first, values_last, output); +} + +template +OutputIterator binary_search(ForwardIterator first, + ForwardIterator last, + InputIterator values_first, + InputIterator values_last, + OutputIterator output, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::binary_search(select_system(system1,system2,system3), first, last, values_first, values_last, output, comp); +} + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config.h new file mode 100644 index 0000000000000000000000000000000000000000..5a5573a410e6ee8ec7b062ee4bd330390fb37e9b --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config.h @@ -0,0 +1,24 @@ +/* + * 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. + */ +/*! \file config.h + * \brief Defines platform configuration. + */ + +#pragma once + +#include +#include + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/compiler.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/compiler.h new file mode 100644 index 0000000000000000000000000000000000000000..e35652f6a41f93c13b69b5980a78fb4a2d49c4da --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/compiler.h @@ -0,0 +1,189 @@ +/* + * 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. + */ + +/*! \file compiler.h + * \brief Compiler-specific configuration + */ + +#pragma once + +// enumerate host compilers we know about +#define THRUST_HOST_COMPILER_UNKNOWN 0 +#define THRUST_HOST_COMPILER_MSVC 1 +#define THRUST_HOST_COMPILER_GCC 2 +#define THRUST_HOST_COMPILER_CLANG 3 +#define THRUST_HOST_COMPILER_INTEL 4 + +// enumerate device compilers we know about +#define THRUST_DEVICE_COMPILER_UNKNOWN 0 +#define THRUST_DEVICE_COMPILER_MSVC 1 +#define THRUST_DEVICE_COMPILER_GCC 2 +#define THRUST_DEVICE_COMPILER_CLANG 3 +#define THRUST_DEVICE_COMPILER_NVCC 4 + +// figure out which host compiler we're using +// XXX we should move the definition of THRUST_DEPRECATED out of this logic +#if defined(_MSC_VER) +#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_MSVC +#define THRUST_MSVC_VERSION _MSC_VER +#define THRUST_MSVC_VERSION_FULL _MSC_FULL_VER +#elif defined(__ICC) +#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_INTEL +#elif defined(__clang__) +#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_CLANG +#define THRUST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) +#elif defined(__GNUC__) +#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_GCC +#define THRUST_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) +#if (THRUST_GCC_VERSION >= 50000) +#define THRUST_MODERN_GCC +#else +#define THRUST_LEGACY_GCC +#endif +#else +#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_UNKNOWN +#endif // THRUST_HOST_COMPILER + +// figure out which device compiler we're using +#if defined(__CUDACC__) || defined(_NVHPC_CUDA) +#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC +#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC +#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_MSVC +#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC +#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_GCC +#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG +// CUDA-capable clang should behave similar to NVCC. +#if defined(__CUDA__) +#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC +#else +#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_CLANG +#endif +#else +#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_UNKNOWN +#endif + +// is the device compiler capable of compiling omp? +#if defined(_OPENMP) || defined(_NVHPC_STDPAR_OPENMP) +#define THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE THRUST_TRUE +#else +#define THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE THRUST_FALSE +#endif // _OPENMP + + +#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC) && !defined(__CUDA_ARCH__) + #define THRUST_DISABLE_MSVC_WARNING_BEGIN(x) \ + __pragma(warning(push)) \ + __pragma(warning(disable : x)) \ + /**/ + #define THRUST_DISABLE_MSVC_WARNING_END(x) \ + __pragma(warning(pop)) \ + /**/ +#else + #define THRUST_DISABLE_MSVC_WARNING_BEGIN(x) + #define THRUST_DISABLE_MSVC_WARNING_END(x) +#endif + +#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG) && !defined(__CUDA_ARCH__) + #define THRUST_IGNORE_CLANG_WARNING_IMPL(x) \ + THRUST_PP_STRINGIZE(clang diagnostic ignored x) \ + /**/ + #define THRUST_IGNORE_CLANG_WARNING(x) \ + THRUST_IGNORE_CLANG_WARNING_IMPL(THRUST_PP_STRINGIZE(x)) \ + /**/ + + #define THRUST_DISABLE_CLANG_WARNING_BEGIN(x) \ + _Pragma("clang diagnostic push") \ + _Pragma(THRUST_IGNORE_CLANG_WARNING(x)) \ + /**/ + #define THRUST_DISABLE_CLANG_WARNING_END(x) \ + _Pragma("clang diagnostic pop") \ + /**/ +#else + #define THRUST_DISABLE_CLANG_WARNING_BEGIN(x) + #define THRUST_DISABLE_CLANG_WARNING_END(x) +#endif + +#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) && !defined(__CUDA_ARCH__) + #define THRUST_IGNORE_GCC_WARNING_IMPL(x) \ + THRUST_PP_STRINGIZE(GCC diagnostic ignored x) \ + /**/ + #define THRUST_IGNORE_GCC_WARNING(x) \ + THRUST_IGNORE_GCC_WARNING_IMPL(THRUST_PP_STRINGIZE(x)) \ + /**/ + + #define THRUST_DISABLE_GCC_WARNING_BEGIN(x) \ + _Pragma("GCC diagnostic push") \ + _Pragma(THRUST_IGNORE_GCC_WARNING(x)) \ + /**/ + #define THRUST_DISABLE_GCC_WARNING_END(x) \ + _Pragma("GCC diagnostic pop") \ + /**/ +#else + #define THRUST_DISABLE_GCC_WARNING_BEGIN(x) + #define THRUST_DISABLE_GCC_WARNING_END(x) +#endif + +#define THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN \ + THRUST_DISABLE_MSVC_WARNING_BEGIN(4244 4267) \ + /**/ +#define THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END \ + THRUST_DISABLE_MSVC_WARNING_END(4244 4267) \ + /**/ +#define THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING(x) \ + THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN \ + x; \ + THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END \ + /**/ + +#define THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_BEGIN \ + THRUST_DISABLE_MSVC_WARNING_BEGIN(4800) \ + /**/ +#define THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_END \ + THRUST_DISABLE_MSVC_WARNING_END(4800) \ + /**/ +#define THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING(x) \ + THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_BEGIN \ + x; \ + THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_END \ + /**/ + +#define THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_BEGIN \ + THRUST_DISABLE_CLANG_WARNING_BEGIN(-Wself-assign) \ + /**/ +#define THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_END \ + THRUST_DISABLE_CLANG_WARNING_END(-Wself-assign) \ + /**/ +#define THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING(x) \ + THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_BEGIN \ + x; \ + THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_END \ + /**/ + +#define THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_BEGIN \ + THRUST_DISABLE_CLANG_WARNING_BEGIN(-Wreorder) \ + THRUST_DISABLE_GCC_WARNING_BEGIN(-Wreorder) \ + /**/ +#define THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_END \ + THRUST_DISABLE_CLANG_WARNING_END(-Wreorder) \ + THRUST_DISABLE_GCC_WARNING_END(-Wreorder) \ + /**/ +#define THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING(x) \ + THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_BEGIN \ + x; \ + THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_END \ + /**/ + + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/compiler_fence.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/compiler_fence.h new file mode 100644 index 0000000000000000000000000000000000000000..c379abaf364b460031a93a0ad6d4ee3d8419ab78 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/compiler_fence.h @@ -0,0 +1,62 @@ +/* + * 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 +#include + +// TODO: Enable this or remove this file once nvGRAPH/CUSP migrates off of it. +//#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC +// #pragma message("warning: The functionality in this header is unsafe, deprecated, and will soon be removed. Use C++11 or C11 atomics instead.") +//#else +// #warning The functionality in this header is unsafe, deprecated, and will soon be removed. Use C++11 or C11 atomics instead. +//#endif + +// msvc case +#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC + +#ifndef _DEBUG + +#include +#pragma intrinsic(_ReadWriteBarrier) +#define __thrust_compiler_fence() _ReadWriteBarrier() +#else + +#define __thrust_compiler_fence() do {} while (0) + +#endif // _DEBUG + +// gcc case +#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC + +#if THRUST_GCC_VERSION >= 40200 // atomic built-ins were introduced ~4.2 +#define __thrust_compiler_fence() __sync_synchronize() +#else +// allow the code to compile without any guarantees +#define __thrust_compiler_fence() do {} while (0) +#endif // THRUST_GCC_VERSION + +// unknown case +#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG +#define __thrust_compiler_fence() __sync_synchronize() +#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_UNKNOWN + +// allow the code to compile without any guarantees +#define __thrust_compiler_fence() do {} while (0) + +#endif + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/config.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/config.h new file mode 100644 index 0000000000000000000000000000000000000000..797f6605b082bc5f186a8b31708aeb01e3257334 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/config.h @@ -0,0 +1,40 @@ +/* + * 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. + */ + +/*! \file config.h + * \brief Defines platform configuration. + */ + +#pragma once + +// NOTE: The order of these #includes matters. + +#include +#include +#include +#include +#include +// host_system.h & device_system.h must be #included as early as possible +// because other config headers depend on it +#include +#include +#include +#include +#include +#include +#include +#include + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/cpp_compatibility.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/cpp_compatibility.h new file mode 100644 index 0000000000000000000000000000000000000000..18b9cbdcf59928bf383012fb3e785416adb37d15 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/cpp_compatibility.h @@ -0,0 +1,101 @@ +/* + * 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 + +#include + +#ifndef __has_cpp_attribute +# define __has_cpp_attribute(X) 0 +#endif + +// Trailing return types seem to confuse Doxygen, and cause it to interpret +// parts of the function's body as new function signatures. +#if defined(THRUST_DOXYGEN) +# define THRUST_TRAILING_RETURN(...) +#else +# define THRUST_TRAILING_RETURN(...) -> __VA_ARGS__ +#endif + +#if THRUST_CPP_DIALECT >= 2014 && __has_cpp_attribute(nodiscard) +# define THRUST_NODISCARD [[nodiscard]] +#else +# define THRUST_NODISCARD +#endif + +#if THRUST_CPP_DIALECT >= 2017 && __cpp_if_constexpr +# define THRUST_IF_CONSTEXPR if constexpr +#else +# define THRUST_IF_CONSTEXPR if +#endif + +// FIXME: Combine THRUST_INLINE_CONSTANT and +// THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT into one macro when NVCC properly +// supports `constexpr` globals in host and device code. +#if defined(__CUDA_ARCH__) || defined(_NVHPC_CUDA) +// FIXME: Add this when NVCC supports inline variables. +//# if THRUST_CPP_DIALECT >= 2017 +//# define THRUST_INLINE_CONSTANT inline constexpr +//# define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT inline constexpr +# if THRUST_CPP_DIALECT >= 2011 +# define THRUST_INLINE_CONSTANT static const __device__ +# define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static constexpr +# else +# define THRUST_INLINE_CONSTANT static const __device__ +# define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static const +# endif +#else +// FIXME: Add this when NVCC supports inline variables. +//# if THRUST_CPP_DIALECT >= 2017 +//# define THRUST_INLINE_CONSTANT inline constexpr +//# define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT inline constexpr +# if THRUST_CPP_DIALECT >= 2011 +# define THRUST_INLINE_CONSTANT static constexpr +# define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static constexpr +# else +# define THRUST_INLINE_CONSTANT static const +# define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static const +# endif +#endif + +// These definitions were intended for internal use only and are now obsolete. +// If you relied on them, consider porting your code to use the functionality +// in libcu++'s header. +// For a temporary workaround, define THRUST_PROVIDE_LEGACY_ARCH_MACROS to make +// them available again. These should be considered deprecated and will be +// fully removed in a future version. +#ifdef THRUST_PROVIDE_LEGACY_ARCH_MACROS + #ifndef THRUST_IS_DEVICE_CODE + #if defined(_NVHPC_CUDA) + #define THRUST_IS_DEVICE_CODE __builtin_is_device_code() + #define THRUST_IS_HOST_CODE (!__builtin_is_device_code()) + #define THRUST_INCLUDE_DEVICE_CODE 1 + #define THRUST_INCLUDE_HOST_CODE 1 + #elif defined(__CUDA_ARCH__) + #define THRUST_IS_DEVICE_CODE 1 + #define THRUST_IS_HOST_CODE 0 + #define THRUST_INCLUDE_DEVICE_CODE 1 + #define THRUST_INCLUDE_HOST_CODE 0 + #else + #define THRUST_IS_DEVICE_CODE 0 + #define THRUST_IS_HOST_CODE 1 + #define THRUST_INCLUDE_DEVICE_CODE 0 + #define THRUST_INCLUDE_HOST_CODE 1 + #endif + #endif +#endif // THRUST_PROVIDE_LEGACY_ARCH_MACROS diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/cpp_dialect.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/cpp_dialect.h new file mode 100644 index 0000000000000000000000000000000000000000..46b0caec78032efb3d450722a411c678060d9206 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/cpp_dialect.h @@ -0,0 +1,140 @@ +/* + * Copyright 2020 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/*! \file cpp_dialect.h + * \brief Detect the version of the C++ standard used by the compiler. + */ + +#pragma once + +#include + +// Deprecation warnings may be silenced by defining the following macros. These +// may be combined. +// - THRUST_IGNORE_DEPRECATED_CPP_DIALECT: +// Ignore all deprecated C++ dialects and outdated compilers. +// - THRUST_IGNORE_DEPRECATED_CPP_11: +// Ignore deprecation warnings when compiling with C++11. C++03 and outdated +// compilers will still issue warnings. +// - THRUST_IGNORE_DEPRECATED_COMPILER +// Ignore deprecation warnings when using deprecated compilers. Compiling +// with C++03 and C++11 will still issue warnings. + +// Check for the CUB opt-outs as well: +#if !defined(THRUST_IGNORE_DEPRECATED_CPP_DIALECT) && \ + defined(CUB_IGNORE_DEPRECATED_CPP_DIALECT) +# define THRUST_IGNORE_DEPRECATED_CPP_DIALECT +#endif +#if !defined(THRUST_IGNORE_DEPRECATED_CPP_11) && \ + defined(CUB_IGNORE_DEPRECATED_CPP_11) +# define THRUST_IGNORE_DEPRECATED_CPP_11 +#endif +#if !defined(THRUST_IGNORE_DEPRECATED_COMPILER) && \ + defined(CUB_IGNORE_DEPRECATED_COMPILER) +# define THRUST_IGNORE_DEPRECATED_COMPILER +#endif + +#ifdef THRUST_IGNORE_DEPRECATED_CPP_DIALECT +# define THRUST_IGNORE_DEPRECATED_CPP_11 +# define THRUST_IGNORE_DEPRECATED_COMPILER +#endif + +// Define this to override the built-in detection. +#ifndef THRUST_CPP_DIALECT + +// MSVC does not define __cplusplus correctly. _MSVC_LANG is used instead. +// This macro is only defined in MSVC 2015U3+. +# ifdef _MSVC_LANG // Do not replace with THRUST_HOST_COMPILER test (see above) +// MSVC2015 reports C++14 but lacks extended constexpr support. Treat as C++11. +# if THRUST_MSVC_VERSION < 1910 && _MSVC_LANG > 201103L /* MSVC < 2017 && CPP > 2011 */ +# define THRUST_CPLUSPLUS 201103L /* Fix to 2011 */ +# else +# define THRUST_CPLUSPLUS _MSVC_LANG /* We'll trust this for now. */ +# endif // MSVC 2015 C++14 fix +# else +# define THRUST_CPLUSPLUS __cplusplus +# endif + +// Detect current dialect: +# if THRUST_CPLUSPLUS < 201103L +# define THRUST_CPP_DIALECT 2003 +# elif THRUST_CPLUSPLUS < 201402L +# define THRUST_CPP_DIALECT 2011 +# elif THRUST_CPLUSPLUS < 201703L +# define THRUST_CPP_DIALECT 2014 +# elif THRUST_CPLUSPLUS == 201703L +# define THRUST_CPP_DIALECT 2017 +# elif THRUST_CPLUSPLUS > 201703L // unknown, but is higher than 2017. +# define THRUST_CPP_DIALECT 2020 +# endif + +# undef THRUST_CPLUSPLUS // cleanup + +#endif // !THRUST_CPP_DIALECT + +// Define THRUST_COMPILER_DEPRECATION macro: +#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC +# define THRUST_COMP_DEPR_IMPL(msg) \ + __pragma(message(__FILE__ ":" THRUST_COMP_DEPR_IMPL0(__LINE__) ": warning: " #msg)) +# define THRUST_COMP_DEPR_IMPL0(x) THRUST_COMP_DEPR_IMPL1(x) +# define THRUST_COMP_DEPR_IMPL1(x) #x +#else // clang / gcc: +# define THRUST_COMP_DEPR_IMPL(msg) THRUST_COMP_DEPR_IMPL0(GCC warning #msg) +# define THRUST_COMP_DEPR_IMPL0(expr) _Pragma(#expr) +# define THRUST_COMP_DEPR_IMPL1 /* intentionally blank */ +#endif + +#define THRUST_COMPILER_DEPRECATION(REQ) \ + THRUST_COMP_DEPR_IMPL(Thrust requires at least REQ. Define THRUST_IGNORE_DEPRECATED_CPP_DIALECT to suppress this message.) + +#define THRUST_COMPILER_DEPRECATION_SOFT(REQ, CUR) \ + THRUST_COMP_DEPR_IMPL(Thrust requires at least REQ. CUR is deprecated but still supported. CUR support will be removed in a future release. Define THRUST_IGNORE_DEPRECATED_CPP_DIALECT to suppress this message.) + +#ifndef THRUST_IGNORE_DEPRECATED_COMPILER + +// Compiler checks: +# if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC && THRUST_GCC_VERSION < 50000 + THRUST_COMPILER_DEPRECATION(GCC 5.0); +# elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG && THRUST_CLANG_VERSION < 70000 + THRUST_COMPILER_DEPRECATION(Clang 7.0); +# elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC && THRUST_MSVC_VERSION < 1910 + // <2017. Hard upgrade message: + THRUST_COMPILER_DEPRECATION(MSVC 2019 (19.20/16.0/14.20)); +# elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC && THRUST_MSVC_VERSION < 1920 + // >=2017, <2019. Soft deprecation message: + THRUST_COMPILER_DEPRECATION_SOFT(MSVC 2019 (19.20/16.0/14.20), MSVC 2017); +# endif + +#endif // THRUST_IGNORE_DEPRECATED_COMPILER + +#ifndef THRUST_IGNORE_DEPRECATED_DIALECT + +// Dialect checks: +# if THRUST_CPP_DIALECT < 2011 + // +#include + +#if defined(CUB_IGNORE_DEPRECATED_API) && !defined(THRUST_IGNORE_DEPRECATED_API) +# define THRUST_IGNORE_DEPRECATED_API +#endif + +#ifdef THRUST_IGNORE_DEPRECATED_API +# define THRUST_DEPRECATED +#elif THRUST_CPP_DIALECT >= 2014 +# define THRUST_DEPRECATED [[deprecated]] +#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC +# define THRUST_DEPRECATED __declspec(deprecated) +#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG +# define THRUST_DEPRECATED __attribute__((deprecated)) +#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC +# define THRUST_DEPRECATED __attribute__((deprecated)) +#else +# define THRUST_DEPRECATED +#endif diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/device_system.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/device_system.h new file mode 100644 index 0000000000000000000000000000000000000000..29418c90308a6f6cd6a506ea0f344ab9d27369da --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/device_system.h @@ -0,0 +1,44 @@ +/* + * 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 + +// reserve 0 for undefined +#define THRUST_DEVICE_SYSTEM_CUDA 1 +#define THRUST_DEVICE_SYSTEM_OMP 2 +#define THRUST_DEVICE_SYSTEM_TBB 3 +#define THRUST_DEVICE_SYSTEM_CPP 4 + +#ifndef THRUST_DEVICE_SYSTEM +#define THRUST_DEVICE_SYSTEM THRUST_DEVICE_SYSTEM_CUDA +#endif // THRUST_DEVICE_SYSTEM + +#ifdef THRUST_DEVICE_BACKEND +# error THRUST_DEVICE_BACKEND is no longer supported; use THRUST_DEVICE_SYSTEM instead. +#endif // THRUST_DEVICE_BACKEND + +#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA +#define __THRUST_DEVICE_SYSTEM_NAMESPACE cuda +#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_OMP +#define __THRUST_DEVICE_SYSTEM_NAMESPACE omp +#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_TBB +#define __THRUST_DEVICE_SYSTEM_NAMESPACE tbb +#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CPP +#define __THRUST_DEVICE_SYSTEM_NAMESPACE cpp +#endif + +#define __THRUST_DEVICE_SYSTEM_ROOT thrust/system/__THRUST_DEVICE_SYSTEM_NAMESPACE + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/exec_check_disable.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/exec_check_disable.h new file mode 100644 index 0000000000000000000000000000000000000000..9b25b375dfbfb572c25922e4e9b26a8bea032597 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/exec_check_disable.h @@ -0,0 +1,43 @@ +/* + * 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. + */ + +/*! \file exec_check_disable.h + * \brief Defines __thrust_exec_check_disable__ + */ + +#pragma once + +#include + +// #pragma nv_exec_check_disable is only recognized by NVCC. Having a macro +// expand to a #pragma (rather than _Pragma) only works with NVCC's compilation +// model, not with other compilers. +#if defined(__CUDACC__) && !defined(_NVHPC_CUDA) && \ + !(defined(__CUDA__) && defined(__clang__)) + +#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC +#define __thrust_exec_check_disable__ __pragma("nv_exec_check_disable") +#else // MSVC +#define __thrust_exec_check_disable__ _Pragma("nv_exec_check_disable") +#endif // MSVC + +#else + +#define __thrust_exec_check_disable__ + +#endif + + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/forceinline.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/forceinline.h new file mode 100644 index 0000000000000000000000000000000000000000..b001fd4b1148b6d77f99cad072c4c53fcbf7b033 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/forceinline.h @@ -0,0 +1,36 @@ +/* + * 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. + */ + +/*! \file forceinline.h + * \brief Defines __thrust_forceinline__ + */ + +#pragma once + +#include + +#if defined(__CUDACC__) || defined(_NVHPC_CUDA) + +#define __thrust_forceinline__ __forceinline__ + +#else + +// TODO add + +#define __thrust_forceinline__ + +#endif + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/global_workarounds.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/global_workarounds.h new file mode 100644 index 0000000000000000000000000000000000000000..9800f03593ac253914c149815a497bf01baee4b2 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/global_workarounds.h @@ -0,0 +1,27 @@ +/* + * 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 + +// XXX workaround gcc 4.8+'s complaints about unused local typedefs by silencing them globally +#if defined(THRUST_GCC_VERSION) && (THRUST_GCC_VERSION >= 40800) +# if defined(__NVCC__) && (CUDART_VERSION >= 6000) +# pragma GCC diagnostic ignored "-Wunused-local-typedefs" +# endif // nvcc & cuda 6+ +#endif // gcc 4.8 + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/host_device.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/host_device.h new file mode 100644 index 0000000000000000000000000000000000000000..5540f91260d807bfb2ef06064767aeaccea2fc1a --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/host_device.h @@ -0,0 +1,44 @@ +/* + * 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. + */ + +/*! \file host_device.h + * \brief Defines __host__ and __device__ + */ + +#pragma once + +#include + +// since nvcc defines __host__ and __device__ for us, +// and only nvcc knows what to do with __host__ and __device__, +// define them to be the empty string for other compilers + +#if THRUST_DEVICE_COMPILER != THRUST_DEVICE_COMPILER_NVCC + +// since __host__ & __device__ might have already be defined, only +// #define them if not defined already +// XXX this will break if the client does #include later + +#ifndef __host__ +#define __host__ +#endif // __host__ + +#ifndef __device__ +#define __device__ +#endif // __device__ + +#endif + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/host_system.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/host_system.h new file mode 100644 index 0000000000000000000000000000000000000000..f216f649237bd7f823f8fe744b72005511bc48f9 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/host_system.h @@ -0,0 +1,41 @@ +/* + * 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 + +// reserve 0 for undefined +#define THRUST_HOST_SYSTEM_CPP 1 +#define THRUST_HOST_SYSTEM_OMP 2 +#define THRUST_HOST_SYSTEM_TBB 3 + +#ifndef THRUST_HOST_SYSTEM +#define THRUST_HOST_SYSTEM THRUST_HOST_SYSTEM_CPP +#endif // THRUST_HOST_SYSTEM + +#ifdef THRUST_HOST_BACKEND +# error THRUST_HOST_BACKEND is no longer supported; use THRUST_HOST_SYSTEM instead. +#endif // THRUST_HOST_BACKEND + +#if THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_CPP +#define __THRUST_HOST_SYSTEM_NAMESPACE cpp +#elif THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_OMP +#define __THRUST_HOST_SYSTEM_NAMESPACE omp +#elif THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_TBB +#define __THRUST_HOST_SYSTEM_NAMESPACE tbb +#endif + +#define __THRUST_HOST_SYSTEM_ROOT thrust/system/__THRUST_HOST_SYSTEM_NAMESPACE + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/memory_resource.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/memory_resource.h new file mode 100644 index 0000000000000000000000000000000000000000..ab719c9bde9b67d5f7e97ad0846f45e4dad4838b --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/memory_resource.h @@ -0,0 +1,35 @@ +/* + * 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 + +#include +#include +#include + +#define THRUST_MR_DEFAULT_ALIGNMENT THRUST_ALIGNOF(THRUST_NS_QUALIFIER::detail::max_align_t) + +#if THRUST_CPP_DIALECT >= 2017 +# if __has_include() +# define THRUST_MR_STD_MR_HEADER +# define THRUST_MR_STD_MR_NS std::pmr +# elif __has_include() +# define THRUST_MR_STD_MR_HEADER +# define THRUST_MR_STD_MR_NS std::experimental::pmr +# endif +#endif diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/namespace.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/namespace.h new file mode 100644 index 0000000000000000000000000000000000000000..9c79046169353f8f373ef124a2b74757bd17da71 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/namespace.h @@ -0,0 +1,120 @@ +/* + * 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 + +/** + * \file namespace.h + * \brief Utilities that allow `thrust::` to be placed inside an + * application-specific namespace. + */ + +/** + * \def THRUST_CUB_WRAPPED_NAMESPACE + * If defined, this value will be used as the name of a namespace that wraps the + * `thrust::` and `cub::` namespaces. + * This macro should not be used with any other Thrust namespace macros. + */ +#ifdef THRUST_CUB_WRAPPED_NAMESPACE +#define THRUST_WRAPPED_NAMESPACE THRUST_CUB_WRAPPED_NAMESPACE +#endif + +/** + * \def THRUST_WRAPPED_NAMESPACE + * If defined, this value will be used as the name of a namespace that wraps the + * `thrust::` namespace. + * If THRUST_CUB_WRAPPED_NAMESPACE is set, this will inherit that macro's value. + * This macro should not be used with any other Thrust namespace macros. + */ +#ifdef THRUST_WRAPPED_NAMESPACE +#define THRUST_NS_PREFIX \ + namespace THRUST_WRAPPED_NAMESPACE \ + { + +#define THRUST_NS_POSTFIX } + +#define THRUST_NS_QUALIFIER ::THRUST_WRAPPED_NAMESPACE::thrust +#endif + +/** + * \def THRUST_NS_PREFIX + * This macro is inserted prior to all `namespace thrust { ... }` blocks. It is + * derived from THRUST_WRAPPED_NAMESPACE, if set, and will be empty otherwise. + * It may be defined by users, in which case THRUST_NS_PREFIX, + * THRUST_NS_POSTFIX, and THRUST_NS_QUALIFIER must all be set consistently. + */ +#ifndef THRUST_NS_PREFIX +#define THRUST_NS_PREFIX +#endif + +/** + * \def THRUST_NS_POSTFIX + * This macro is inserted following the closing braces of all + * `namespace thrust { ... }` block. It is defined appropriately when + * THRUST_WRAPPED_NAMESPACE is set, and will be empty otherwise. It may be + * defined by users, in which case THRUST_NS_PREFIX, THRUST_NS_POSTFIX, and + * THRUST_NS_QUALIFIER must all be set consistently. + */ +#ifndef THRUST_NS_POSTFIX +#define THRUST_NS_POSTFIX +#endif + +/** + * \def THRUST_NS_QUALIFIER + * This macro is used to qualify members of thrust:: when accessing them from + * outside of their namespace. By default, this is just `::thrust`, and will be + * set appropriately when THRUST_WRAPPED_NAMESPACE is defined. This macro may be + * defined by users, in which case THRUST_NS_PREFIX, THRUST_NS_POSTFIX, and + * THRUST_NS_QUALIFIER must all be set consistently. + */ +#ifndef THRUST_NS_QUALIFIER +#define THRUST_NS_QUALIFIER ::thrust +#endif + +/** + * \def THRUST_NAMESPACE_BEGIN + * This macro is used to open a `thrust::` namespace block, along with any + * enclosing namespaces requested by THRUST_WRAPPED_NAMESPACE, etc. + * This macro is defined by Thrust and may not be overridden. + */ +#define THRUST_NAMESPACE_BEGIN \ + THRUST_NS_PREFIX \ + namespace thrust \ + { + +/** + * \def THRUST_NAMESPACE_END + * This macro is used to close a `thrust::` namespace block, along with any + * enclosing namespaces requested by THRUST_WRAPPED_NAMESPACE, etc. + * This macro is defined by Thrust and may not be overridden. + */ +#define THRUST_NAMESPACE_END \ + } /* end namespace thrust */ \ + THRUST_NS_POSTFIX + +// The following is just here to add docs for the thrust namespace: + +THRUST_NS_PREFIX + +/*! \namespace thrust + * \brief \p thrust is the top-level namespace which contains all Thrust + * functions and types. + */ +namespace thrust +{ +} + +THRUST_NS_POSTFIX diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/simple_defines.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/simple_defines.h new file mode 100644 index 0000000000000000000000000000000000000000..e3ea2eb64e766ea2147ecf1de308a454a739d88e --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/simple_defines.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. + */ + +/*! \file simple_defines.h + * \brief Primitive macros without dependencies. + */ + +#pragma once + +#define THRUST_UNKNOWN 0 +#define THRUST_FALSE 0 +#define THRUST_TRUE 1 + +#define THRUST_UNUSED_VAR(expr) do { (void)(expr); } while (0) + +#define THRUST_PREVENT_MACRO_SUBSTITUTION + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/contiguous_storage.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/contiguous_storage.h new file mode 100644 index 0000000000000000000000000000000000000000..536c1c27c2e9d9c30451b9574300501614676e37 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/contiguous_storage.h @@ -0,0 +1,235 @@ +/* + * 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 +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +struct copy_allocator_t {}; + +// XXX parameter T is redundant with parameter Alloc +template + class contiguous_storage +{ + private: + typedef thrust::detail::allocator_traits alloc_traits; + + public: + typedef Alloc allocator_type; + typedef T value_type; + typedef typename alloc_traits::pointer pointer; + typedef typename alloc_traits::const_pointer const_pointer; + typedef typename alloc_traits::size_type size_type; + typedef typename alloc_traits::difference_type difference_type; + typedef typename alloc_traits::reference reference; + typedef typename alloc_traits::const_reference const_reference; + + typedef thrust::detail::normal_iterator iterator; + typedef thrust::detail::normal_iterator const_iterator; + + __thrust_exec_check_disable__ + __host__ __device__ + explicit contiguous_storage(const allocator_type &alloc = allocator_type()); + + __thrust_exec_check_disable__ + __host__ __device__ + explicit contiguous_storage(size_type n, const allocator_type &alloc = allocator_type()); + + __thrust_exec_check_disable__ + __host__ __device__ + explicit contiguous_storage(copy_allocator_t, const contiguous_storage &other); + + __thrust_exec_check_disable__ + __host__ __device__ + explicit contiguous_storage(copy_allocator_t, const contiguous_storage &other, size_type n); + + __thrust_exec_check_disable__ + __host__ __device__ + ~contiguous_storage(); + + __host__ __device__ + size_type size() const; + + __host__ __device__ + size_type max_size() const; + + __host__ __device__ + pointer data(); + + __host__ __device__ + const_pointer data() const; + + __host__ __device__ + iterator begin(); + + __host__ __device__ + const_iterator begin() const; + + __host__ __device__ + iterator end(); + + __host__ __device__ + const_iterator end() const; + + __host__ __device__ + reference operator[](size_type n); + + __host__ __device__ + const_reference operator[](size_type n) const; + + __host__ __device__ + allocator_type get_allocator() const; + + // note that allocate does *not* automatically call deallocate + __host__ __device__ + void allocate(size_type n); + + __host__ __device__ + void deallocate(); + + __host__ __device__ + void swap(contiguous_storage &x); + + __host__ __device__ + void default_construct_n(iterator first, size_type n); + + __host__ __device__ + void uninitialized_fill_n(iterator first, size_type n, const value_type &value); + + template + __host__ __device__ + iterator uninitialized_copy(InputIterator first, InputIterator last, iterator result); + + template + __host__ __device__ + iterator uninitialized_copy(thrust::execution_policy &from_system, + InputIterator first, + InputIterator last, + iterator result); + + template + __host__ __device__ + iterator uninitialized_copy_n(InputIterator first, Size n, iterator result); + + template + __host__ __device__ + iterator uninitialized_copy_n(thrust::execution_policy &from_system, + InputIterator first, + Size n, + iterator result); + + __host__ __device__ + void destroy(iterator first, iterator last); + + __host__ __device__ + void deallocate_on_allocator_mismatch(const contiguous_storage &other); + + __host__ __device__ + void destroy_on_allocator_mismatch(const contiguous_storage &other, + iterator first, iterator last); + + __host__ __device__ + void set_allocator(const allocator_type &alloc); + + __host__ __device__ + bool is_allocator_not_equal(const allocator_type &alloc) const; + + __host__ __device__ + bool is_allocator_not_equal(const contiguous_storage &other) const; + + __host__ __device__ + void propagate_allocator(const contiguous_storage &other); + +#if THRUST_CPP_DIALECT >= 2011 + __host__ __device__ + void propagate_allocator(contiguous_storage &other); + + // allow move assignment for a sane implementation of allocator propagation + // on move assignment + __host__ __device__ + contiguous_storage &operator=(contiguous_storage &&other); +#endif + + private: + // XXX we could inherit from this to take advantage of empty base class optimization + allocator_type m_allocator; + + iterator m_begin; + + size_type m_size; + + // disallow assignment + contiguous_storage &operator=(const contiguous_storage &x); + + __host__ __device__ + void swap_allocators(true_type, const allocator_type &); + + __host__ __device__ + void swap_allocators(false_type, allocator_type &); + + __host__ __device__ + bool is_allocator_not_equal_dispatch(true_type, const allocator_type &) const; + + __host__ __device__ + bool is_allocator_not_equal_dispatch(false_type, const allocator_type &) const; + + __host__ __device__ + void deallocate_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other); + + __host__ __device__ + void deallocate_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &other); + + __host__ __device__ + void destroy_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other, + iterator first, iterator last); + + __host__ __device__ + void destroy_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &other, + iterator first, iterator last); + + __host__ __device__ + void propagate_allocator_dispatch(true_type, const contiguous_storage &other); + + __host__ __device__ + void propagate_allocator_dispatch(false_type, const contiguous_storage &other); + +#if THRUST_CPP_DIALECT >= 2011 + __host__ __device__ + void propagate_allocator_dispatch(true_type, contiguous_storage &other); + + __host__ __device__ + void propagate_allocator_dispatch(false_type, contiguous_storage &other); +#endif +}; // end contiguous_storage + +} // end detail + +template +__host__ __device__ +void swap(detail::contiguous_storage &lhs, detail::contiguous_storage &rhs); + +THRUST_NAMESPACE_END + +#include + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/contiguous_storage.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/contiguous_storage.inl new file mode 100644 index 0000000000000000000000000000000000000000..7ae8657f081104ecfd47ab492d53d56e22028ea4 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/contiguous_storage.inl @@ -0,0 +1,550 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include + +#include + +#include // for std::runtime_error +#include // for use of std::swap in the WAR below + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +class allocator_mismatch_on_swap : public std::runtime_error +{ +public: + allocator_mismatch_on_swap() + :std::runtime_error("swap called on containers with allocators that propagate on swap, but compare non-equal") + { + } +}; + +__thrust_exec_check_disable__ +template +__host__ __device__ + contiguous_storage + ::contiguous_storage(const Alloc &alloc) + :m_allocator(alloc), + m_begin(pointer(static_cast(0))), + m_size(0) +{ + ; +} // end contiguous_storage::contiguous_storage() + +__thrust_exec_check_disable__ +template +__host__ __device__ + contiguous_storage + ::contiguous_storage(size_type n, const Alloc &alloc) + :m_allocator(alloc), + m_begin(pointer(static_cast(0))), + m_size(0) +{ + allocate(n); +} // end contiguous_storage::contiguous_storage() + +template +__host__ __device__ + contiguous_storage + ::contiguous_storage(copy_allocator_t, + const contiguous_storage &other) + :m_allocator(other.m_allocator), + m_begin(pointer(static_cast(0))), + m_size(0) +{ +} // end contiguous_storage::contiguous_storage() + +template +__host__ __device__ + contiguous_storage + ::contiguous_storage(copy_allocator_t, + const contiguous_storage &other, size_type n) + :m_allocator(other.m_allocator), + m_begin(pointer(static_cast(0))), + m_size(0) +{ + allocate(n); +} // end contiguous_storage::contiguous_storage() + +__thrust_exec_check_disable__ +template +__host__ __device__ + contiguous_storage + ::~contiguous_storage() +{ + deallocate(); +} // end contiguous_storage::~contiguous_storage() + +template +__host__ __device__ + typename contiguous_storage::size_type + contiguous_storage + ::size() const +{ + return m_size; +} // end contiguous_storage::size() + +template +__host__ __device__ + typename contiguous_storage::size_type + contiguous_storage + ::max_size() const +{ + return alloc_traits::max_size(m_allocator); +} // end contiguous_storage::max_size() + +template +__host__ __device__ + typename contiguous_storage::iterator + contiguous_storage + ::begin() +{ + return m_begin; +} // end contiguous_storage::begin() + +template +__host__ __device__ + typename contiguous_storage::const_iterator + contiguous_storage + ::begin() const +{ + return m_begin; +} // end contiguous_storage::begin() + +template +__host__ __device__ + typename contiguous_storage::iterator + contiguous_storage + ::end() +{ + return m_begin + size(); +} // end contiguous_storage::end() + +template +__host__ __device__ + typename contiguous_storage::const_iterator + contiguous_storage + ::end() const +{ + return m_begin + size(); +} // end contiguous_storage::end() + +template +__host__ __device__ + typename contiguous_storage::pointer + contiguous_storage + ::data() +{ + return &*m_begin; +} // end contiguous_storage::data() + +template +__host__ __device__ + typename contiguous_storage::const_pointer + contiguous_storage + ::data() const +{ + return &*m_begin; +} // end contiguous_storage::data() + +template +__host__ __device__ + typename contiguous_storage::reference + contiguous_storage + ::operator[](size_type n) +{ + return m_begin[n]; +} // end contiguous_storage::operator[]() + +template +__host__ __device__ + typename contiguous_storage::const_reference + contiguous_storage + ::operator[](size_type n) const +{ + return m_begin[n]; +} // end contiguous_storage::operator[]() + +__thrust_exec_check_disable__ +template +__host__ __device__ + typename contiguous_storage::allocator_type + contiguous_storage + ::get_allocator() const +{ + return m_allocator; +} // end contiguous_storage::get_allocator() + +template +__host__ __device__ + void contiguous_storage + ::allocate(size_type n) +{ + if(n > 0) + { + m_begin = iterator(alloc_traits::allocate(m_allocator,n)); + m_size = n; + } // end if + else + { + m_begin = iterator(pointer(static_cast(0))); + m_size = 0; + } // end else +} // end contiguous_storage::allocate() + +template +__host__ __device__ + void contiguous_storage + ::deallocate() +{ + if(size() > 0) + { + alloc_traits::deallocate(m_allocator,m_begin.base(), size()); + m_begin = iterator(pointer(static_cast(0))); + m_size = 0; + } // end if +} // end contiguous_storage::deallocate() + +template +__host__ __device__ + void contiguous_storage + ::swap(contiguous_storage &x) +{ + thrust::swap(m_begin, x.m_begin); + thrust::swap(m_size, x.m_size); + + swap_allocators( + integral_constant< + bool, + allocator_traits::propagate_on_container_swap::value + >(), + x.m_allocator); + + thrust::swap(m_allocator, x.m_allocator); +} // end contiguous_storage::swap() + +template +__host__ __device__ + void contiguous_storage + ::default_construct_n(iterator first, size_type n) +{ + default_construct_range(m_allocator, first.base(), n); +} // end contiguous_storage::default_construct_n() + +template +__host__ __device__ + void contiguous_storage + ::uninitialized_fill_n(iterator first, size_type n, const value_type &x) +{ + fill_construct_range(m_allocator, first.base(), n, x); +} // end contiguous_storage::uninitialized_fill() + +template + template + __host__ __device__ + typename contiguous_storage::iterator + contiguous_storage + ::uninitialized_copy(thrust::execution_policy &from_system, InputIterator first, InputIterator last, iterator result) +{ + return iterator(copy_construct_range(from_system, m_allocator, first, last, result.base())); +} // end contiguous_storage::uninitialized_copy() + +template + template + __host__ __device__ + typename contiguous_storage::iterator + contiguous_storage + ::uninitialized_copy(InputIterator first, InputIterator last, iterator result) +{ + // XXX assumes InputIterator's associated System is default-constructible + typename thrust::iterator_system::type from_system; + + return iterator(copy_construct_range(from_system, m_allocator, first, last, result.base())); +} // end contiguous_storage::uninitialized_copy() + +template + template + __host__ __device__ + typename contiguous_storage::iterator + contiguous_storage + ::uninitialized_copy_n(thrust::execution_policy &from_system, InputIterator first, Size n, iterator result) +{ + return iterator(copy_construct_range_n(from_system, m_allocator, first, n, result.base())); +} // end contiguous_storage::uninitialized_copy_n() + +template + template + __host__ __device__ + typename contiguous_storage::iterator + contiguous_storage + ::uninitialized_copy_n(InputIterator first, Size n, iterator result) +{ + // XXX assumes InputIterator's associated System is default-constructible + typename thrust::iterator_system::type from_system; + + return iterator(copy_construct_range_n(from_system, m_allocator, first, n, result.base())); +} // end contiguous_storage::uninitialized_copy_n() + +template +__host__ __device__ + void contiguous_storage + ::destroy(iterator first, iterator last) +{ + destroy_range(m_allocator, first.base(), last - first); +} // end contiguous_storage::destroy() + +template +__host__ __device__ + void contiguous_storage + ::deallocate_on_allocator_mismatch(const contiguous_storage &other) +{ + integral_constant< + bool, + allocator_traits::propagate_on_container_copy_assignment::value + > c; + + deallocate_on_allocator_mismatch_dispatch(c, other); +} // end contiguous_storage::deallocate_on_allocator_mismatch + +template +__host__ __device__ + void contiguous_storage + ::destroy_on_allocator_mismatch(const contiguous_storage &other, + iterator first, iterator last) +{ + integral_constant< + bool, + allocator_traits::propagate_on_container_copy_assignment::value + > c; + + destroy_on_allocator_mismatch_dispatch(c, other, first, last); +} // end contiguous_storage::destroy_on_allocator_mismatch + +__thrust_exec_check_disable__ +template +__host__ __device__ + void contiguous_storage + ::set_allocator(const Alloc &alloc) +{ + m_allocator = alloc; +} // end contiguous_storage::set_allocator() + +template +__host__ __device__ + bool contiguous_storage + ::is_allocator_not_equal(const Alloc &alloc) const +{ + return is_allocator_not_equal_dispatch( + integral_constant< + bool, + allocator_traits::is_always_equal::value + >(), + alloc); +} // end contiguous_storage::is_allocator_not_equal() + +template +__host__ __device__ + bool contiguous_storage + ::is_allocator_not_equal(const contiguous_storage &other) const +{ + return is_allocator_not_equal(m_allocator, other.m_allocator); +} // end contiguous_storage::is_allocator_not_equal() + +template +__host__ __device__ + void contiguous_storage + ::propagate_allocator(const contiguous_storage &other) +{ + integral_constant< + bool, + allocator_traits::propagate_on_container_copy_assignment::value + > c; + + propagate_allocator_dispatch(c, other); +} // end contiguous_storage::propagate_allocator() + +#if THRUST_CPP_DIALECT >= 2011 +template +__host__ __device__ + void contiguous_storage + ::propagate_allocator(contiguous_storage &other) +{ + integral_constant< + bool, + allocator_traits::propagate_on_container_move_assignment::value + > c; + + propagate_allocator_dispatch(c, other); +} // end contiguous_storage::propagate_allocator() + +template +__host__ __device__ + contiguous_storage &contiguous_storage + ::operator=(contiguous_storage &&other) +{ + if (size() > 0) + { + deallocate(); + } + propagate_allocator(other); + m_begin = std::move(other.m_begin); + m_size = std::move(other.m_size); + + other.m_begin = pointer(static_cast(0)); + other.m_size = 0; + + return *this; +} // end contiguous_storage::propagate_allocator() +#endif + +template +__host__ __device__ + void contiguous_storage + ::swap_allocators(true_type, const Alloc &) +{ +} // end contiguous_storage::swap_allocators() + +template +__host__ __device__ + void contiguous_storage + ::swap_allocators(false_type, Alloc &other) +{ + NV_IF_TARGET(NV_IS_DEVICE, ( + // allocators must be equal when swapping containers with allocators that propagate on swap + assert(!is_allocator_not_equal(other)); + ), ( + if (is_allocator_not_equal(other)) + { + throw allocator_mismatch_on_swap(); + } + )); + + thrust::swap(m_allocator, other); +} // end contiguous_storage::swap_allocators() + +template +__host__ __device__ + bool contiguous_storage + ::is_allocator_not_equal_dispatch(true_type /*is_always_equal*/, const Alloc &) const +{ + return false; +} // end contiguous_storage::is_allocator_not_equal_dispatch() + +__thrust_exec_check_disable__ +template +__host__ __device__ + bool contiguous_storage + ::is_allocator_not_equal_dispatch(false_type /*!is_always_equal*/, const Alloc& other) const +{ + return m_allocator != other; +} // end contiguous_storage::is_allocator_not_equal_dispatch() + +__thrust_exec_check_disable__ +template +__host__ __device__ + void contiguous_storage + ::deallocate_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other) +{ + if (m_allocator != other.m_allocator) + { + deallocate(); + } +} // end contiguous_storage::deallocate_on_allocator_mismatch() + +template +__host__ __device__ + void contiguous_storage + ::deallocate_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &) +{ +} // end contiguous_storage::deallocate_on_allocator_mismatch() + +__thrust_exec_check_disable__ +template +__host__ __device__ + void contiguous_storage + ::destroy_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other, + iterator first, iterator last) +{ + if (m_allocator != other.m_allocator) + { + destroy(first, last); + } +} // end contiguous_storage::destroy_on_allocator_mismatch() + +template +__host__ __device__ + void contiguous_storage + ::destroy_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &, + iterator, iterator) +{ +} // end contiguous_storage::destroy_on_allocator_mismatch() + +__thrust_exec_check_disable__ +template +__host__ __device__ + void contiguous_storage + ::propagate_allocator_dispatch(true_type, const contiguous_storage &other) +{ + m_allocator = other.m_allocator; +} // end contiguous_storage::propagate_allocator() + +template +__host__ __device__ + void contiguous_storage + ::propagate_allocator_dispatch(false_type, const contiguous_storage &) +{ +} // end contiguous_storage::propagate_allocator() + +#if THRUST_CPP_DIALECT >= 2011 +__thrust_exec_check_disable__ +template +__host__ __device__ + void contiguous_storage + ::propagate_allocator_dispatch(true_type, contiguous_storage &other) +{ + m_allocator = std::move(other.m_allocator); +} // end contiguous_storage::propagate_allocator() + +template +__host__ __device__ + void contiguous_storage + ::propagate_allocator_dispatch(false_type, contiguous_storage &) +{ +} // end contiguous_storage::propagate_allocator() +#endif + +} // end detail + +template +__host__ __device__ + void swap(detail::contiguous_storage &lhs, detail::contiguous_storage &rhs) +{ + lhs.swap(rhs); +} // end swap() + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy.h new file mode 100644 index 0000000000000000000000000000000000000000..d6c5bc805c4cba75175575b07c9744e8bc5e8a2e --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy.h @@ -0,0 +1,90 @@ +/* + * 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 +#include + +THRUST_NAMESPACE_BEGIN + +template +__host__ __device__ + OutputIterator copy(const thrust::detail::execution_policy_base &system, + InputIterator first, + InputIterator last, + OutputIterator result); + +template +__host__ __device__ + OutputIterator copy_n(const thrust::detail::execution_policy_base &system, + InputIterator first, + Size n, + OutputIterator result); + +template + OutputIterator copy(InputIterator first, + InputIterator last, + OutputIterator result); + +template + OutputIterator copy_n(InputIterator first, + Size n, + OutputIterator result); + + +namespace detail +{ + + +template +__host__ __device__ + OutputIterator two_system_copy(const thrust::execution_policy &from_system, + const thrust::execution_policy &two_system, + InputIterator first, + InputIterator last, + OutputIterator result); + + +template +__host__ __device__ + OutputIterator two_system_copy_n(const thrust::execution_policy &from_system, + const thrust::execution_policy &two_system, + InputIterator first, + Size n, + OutputIterator result); + + +} // end detail + +THRUST_NAMESPACE_END + +#include diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy_if.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy_if.h new file mode 100644 index 0000000000000000000000000000000000000000..32eb5e08323c856e720a8694a0458747e4049942 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy_if.h @@ -0,0 +1,71 @@ +/* + * 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 +#include + +THRUST_NAMESPACE_BEGIN + +template +__host__ __device__ + OutputIterator copy_if(const thrust::detail::execution_policy_base &exec, + InputIterator first, + InputIterator last, + OutputIterator result, + Predicate pred); + + +template +__host__ __device__ + OutputIterator copy_if(const thrust::detail::execution_policy_base &exec, + InputIterator1 first, + InputIterator1 last, + InputIterator2 stencil, + OutputIterator result, + Predicate pred); + + +template + OutputIterator copy_if(InputIterator first, + InputIterator last, + OutputIterator result, + Predicate pred); + + +template + OutputIterator copy_if(InputIterator1 first, + InputIterator1 last, + InputIterator2 stencil, + OutputIterator result, + Predicate pred); + +THRUST_NAMESPACE_END + +#include diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy_if.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy_if.inl new file mode 100644 index 0000000000000000000000000000000000000000..952541c51806cd4b8cb26fadbdebf35363225e71 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy_if.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 +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +__thrust_exec_check_disable__ +template +__host__ __device__ + OutputIterator copy_if(const thrust::detail::execution_policy_base &exec, + InputIterator first, + InputIterator last, + OutputIterator result, + Predicate pred) +{ + using thrust::system::detail::generic::copy_if; + return copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, pred); +} // end copy_if() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + OutputIterator copy_if(const thrust::detail::execution_policy_base &exec, + InputIterator1 first, + InputIterator1 last, + InputIterator2 stencil, + OutputIterator result, + Predicate pred) +{ + using thrust::system::detail::generic::copy_if; + return copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, result, pred); +} // end copy_if() + + +template + OutputIterator copy_if(InputIterator first, + InputIterator last, + OutputIterator result, + Predicate pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + + System1 system1; + System2 system2; + + return thrust::copy_if(select_system(system1,system2), first, last, result, pred); +} // end copy_if() + + +template + OutputIterator copy_if(InputIterator1 first, + InputIterator1 last, + InputIterator2 stencil, + OutputIterator result, + Predicate pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::copy_if(select_system(system1,system2,system3), first, last, stencil, result, pred); +} // end copy_if() + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/count.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/count.h new file mode 100644 index 0000000000000000000000000000000000000000..7c48bc5460605604b513b4704fb7b4122744865c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/count.h @@ -0,0 +1,60 @@ +/* + * 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 +#include + +THRUST_NAMESPACE_BEGIN + +template +__host__ __device__ + typename thrust::iterator_traits::difference_type + count(const thrust::detail::execution_policy_base &exec, + InputIterator first, + InputIterator last, + const EqualityComparable& value); + +template +__host__ __device__ + typename thrust::iterator_traits::difference_type + count_if(const thrust::detail::execution_policy_base &exec, + InputIterator first, + InputIterator last, + Predicate pred); + +template + typename thrust::iterator_traits::difference_type + count(InputIterator first, + InputIterator last, + const EqualityComparable& value); + +template + typename thrust::iterator_traits::difference_type + count_if(InputIterator first, + InputIterator last, + Predicate pred); + +THRUST_NAMESPACE_END + +#include diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/dependencies_aware_execution_policy.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/dependencies_aware_execution_policy.h new file mode 100644 index 0000000000000000000000000000000000000000..a7567a3fab30e082a251ee234ef0e9cde86c4a30 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/dependencies_aware_execution_policy.h @@ -0,0 +1,106 @@ +/* + * 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 +#include + +#if THRUST_CPP_DIALECT >= 2011 + +#include + +#include + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +template class ExecutionPolicyCRTPBase> +struct dependencies_aware_execution_policy +{ + template + __host__ + thrust::detail::execute_with_dependencies< + ExecutionPolicyCRTPBase, + Dependencies... + > + after(Dependencies&& ...dependencies) const + { + return { capture_as_dependency(THRUST_FWD(dependencies))... }; + } + + template + __host__ + thrust::detail::execute_with_dependencies< + ExecutionPolicyCRTPBase, + Dependencies... + > + after(std::tuple& dependencies) const + { + return { capture_as_dependency(dependencies) }; + } + template + __host__ + thrust::detail::execute_with_dependencies< + ExecutionPolicyCRTPBase, + Dependencies... + > + after(std::tuple&& dependencies) const + { + return { capture_as_dependency(std::move(dependencies)) }; + } + + template + __host__ + thrust::detail::execute_with_dependencies< + ExecutionPolicyCRTPBase, + Dependencies... + > + rebind_after(Dependencies&& ...dependencies) const + { + return { capture_as_dependency(THRUST_FWD(dependencies))... }; + } + + template + __host__ + thrust::detail::execute_with_dependencies< + ExecutionPolicyCRTPBase, + Dependencies... + > + rebind_after(std::tuple& dependencies) const + { + return { capture_as_dependency(dependencies) }; + } + template + __host__ + thrust::detail::execute_with_dependencies< + ExecutionPolicyCRTPBase, + Dependencies... + > + rebind_after(std::tuple&& dependencies) const + { + return { capture_as_dependency(std::move(dependencies)) }; + } +}; + +} // end detail + +THRUST_NAMESPACE_END + +#endif // THRUST_CPP_DIALECT >= 2011 + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/device_malloc.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/device_malloc.inl new file mode 100644 index 0000000000000000000000000000000000000000..f4222f51da300b49a2498b49c995dc1ae767de37 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/device_malloc.inl @@ -0,0 +1,53 @@ +/* + * 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 +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +thrust::device_ptr device_malloc(const std::size_t n) +{ + using thrust::system::detail::generic::select_system; + + typedef thrust::iterator_system< thrust::device_ptr >::type system; + + // XXX lower to select_system(system) here + system s; + + return thrust::device_ptr(thrust::malloc(s, n).get()); +} // end device_malloc() + + +template + thrust::device_ptr device_malloc(const std::size_t n) +{ + using thrust::system::detail::generic::select_system; + + typedef thrust::iterator_system< thrust::device_ptr >::type system; + + // XXX lower to select_system(system) here + system s; + + return thrust::device_ptr(thrust::malloc(s,n).get()); +} // end device_malloc() + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/device_ptr.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/device_ptr.inl new file mode 100644 index 0000000000000000000000000000000000000000..361c61f3314936a5517f15a409c57a94340c22c5 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/device_ptr.inl @@ -0,0 +1,64 @@ +/* + * 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 +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +template + __host__ __device__ + device_ptr device_pointer_cast(T *ptr) +{ + return device_ptr(ptr); +} // end device_pointer_cast() + +template + __host__ __device__ + device_ptr device_pointer_cast(const device_ptr &ptr) +{ + return ptr; +} // end device_pointer_cast() + + +namespace detail +{ + +template + struct is_device_ptr< thrust::device_ptr > + : public true_type +{ +}; // end is_device_ptr + +#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC) && (_MSC_VER <= 1400) +// XXX WAR MSVC 2005 problem with correctly implementing +// pointer_raw_pointer for device_ptr by specializing it here +template + struct pointer_raw_pointer< thrust::device_ptr > +{ + typedef typename device_ptr::raw_pointer type; +}; // end pointer_raw_pointer +#endif + + +} // end namespace detail + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/distance.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/distance.inl new file mode 100644 index 0000000000000000000000000000000000000000..6702c2b6f738d03810fd3c389852f925f820f77a --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/distance.inl @@ -0,0 +1,35 @@ +/* + * 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 +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +__thrust_exec_check_disable__ +template +inline __host__ __device__ + typename thrust::iterator_traits::difference_type + distance(InputIterator first, InputIterator last) +{ + return thrust::system::detail::generic::distance(first, last); +} // end distance() + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/execute_with_allocator.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/execute_with_allocator.h new file mode 100644 index 0000000000000000000000000000000000000000..430fe739c3f4ce938a1dcb979789dfdac75f0d61 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/execute_with_allocator.h @@ -0,0 +1,149 @@ +/* + * 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 + +#include +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +template < + typename T + , typename Allocator + , template class BaseSystem +> +__host__ +thrust::pair +get_temporary_buffer( + thrust::detail::execute_with_allocator& system + , std::ptrdiff_t n + ) +{ + typedef typename thrust::detail::remove_reference::type naked_allocator; + typedef typename thrust::detail::allocator_traits alloc_traits; + typedef typename alloc_traits::void_pointer void_pointer; + typedef typename alloc_traits::size_type size_type; + typedef typename alloc_traits::value_type value_type; + + // How many elements of type value_type do we need to accommodate n elements + // of type T? + size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type)); + + void_pointer ptr = alloc_traits::allocate(system.get_allocator(), num_elements); + + // Return the pointer and the number of elements of type T allocated. + return thrust::make_pair(thrust::reinterpret_pointer_cast(ptr),n); +} + +template < + typename Pointer + , typename Allocator + , template class BaseSystem +> +__host__ +void +return_temporary_buffer( + thrust::detail::execute_with_allocator& system + , Pointer p + , std::ptrdiff_t n + ) +{ + typedef typename thrust::detail::remove_reference::type naked_allocator; + typedef typename thrust::detail::allocator_traits alloc_traits; + typedef typename alloc_traits::pointer pointer; + typedef typename alloc_traits::size_type size_type; + typedef typename alloc_traits::value_type value_type; + typedef typename thrust::detail::pointer_traits::element_type T; + + size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type)); + + pointer to_ptr = thrust::reinterpret_pointer_cast(p); + alloc_traits::deallocate(system.get_allocator(), to_ptr, num_elements); +} + +#if THRUST_CPP_DIALECT >= 2011 + +template < + typename T, + template class BaseSystem, + typename Allocator, + typename ...Dependencies +> +__host__ +thrust::pair +get_temporary_buffer( + thrust::detail::execute_with_allocator_and_dependencies& system, + std::ptrdiff_t n + ) +{ + typedef typename thrust::detail::remove_reference::type naked_allocator; + typedef typename thrust::detail::allocator_traits alloc_traits; + typedef typename alloc_traits::void_pointer void_pointer; + typedef typename alloc_traits::size_type size_type; + typedef typename alloc_traits::value_type value_type; + + // How many elements of type value_type do we need to accommodate n elements + // of type T? + size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type)); + + void_pointer ptr = alloc_traits::allocate(system.get_allocator(), num_elements); + + // Return the pointer and the number of elements of type T allocated. + return thrust::make_pair(thrust::reinterpret_pointer_cast(ptr),n); +} + +template < + typename Pointer, + template class BaseSystem, + typename Allocator, + typename ...Dependencies +> +__host__ +void +return_temporary_buffer( + thrust::detail::execute_with_allocator_and_dependencies& system, + Pointer p, + std::ptrdiff_t n + ) +{ + typedef typename thrust::detail::remove_reference::type naked_allocator; + typedef typename thrust::detail::allocator_traits alloc_traits; + typedef typename alloc_traits::pointer pointer; + typedef typename alloc_traits::size_type size_type; + typedef typename alloc_traits::value_type value_type; + typedef typename thrust::detail::pointer_traits::element_type T; + + size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type)); + + pointer to_ptr = thrust::reinterpret_pointer_cast(p); + alloc_traits::deallocate(system.get_allocator(), to_ptr, num_elements); +} + +#endif + +} // namespace detail + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/execute_with_dependencies.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/execute_with_dependencies.h new file mode 100644 index 0000000000000000000000000000000000000000..ec54010b0520f3b83bb248420a1456268616470f --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/execute_with_dependencies.h @@ -0,0 +1,267 @@ +/* + * 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 +#include + +#if THRUST_CPP_DIALECT >= 2011 + +#include +#include + +#include +#include + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +struct capture_as_dependency_fn +{ + template + auto operator()(Dependency&& dependency) const + THRUST_DECLTYPE_RETURNS(capture_as_dependency(THRUST_FWD(dependency))) +}; + +// Default implementation: universal forwarding. +template +auto capture_as_dependency(Dependency&& dependency) +THRUST_DECLTYPE_RETURNS(THRUST_FWD(dependency)) + +template +auto capture_as_dependency(std::tuple& dependencies) +THRUST_DECLTYPE_RETURNS( + tuple_for_each(THRUST_FWD(dependencies), capture_as_dependency_fn{}) +) + +template class BaseSystem, typename... Dependencies> +struct execute_with_dependencies + : BaseSystem> +{ +private: + using super_t = BaseSystem>; + + std::tuple...> dependencies; + +public: + __host__ + execute_with_dependencies(super_t const &super, Dependencies && ...dependencies) + : super_t(super), dependencies(std::forward(dependencies)...) + { + } + + template + __host__ + execute_with_dependencies(super_t const &super, UDependencies && ...deps) + : super_t(super), dependencies(THRUST_FWD(deps)...) + { + } + + template + __host__ + execute_with_dependencies(UDependencies && ...deps) + : dependencies(THRUST_FWD(deps)...) + { + } + + template + __host__ + execute_with_dependencies(super_t const &super, std::tuple&& deps) + : super_t(super), dependencies(std::move(deps)) + { + } + + template + __host__ + execute_with_dependencies(std::tuple&& deps) + : dependencies(std::move(deps)) + { + } + + std::tuple...> + __host__ + extract_dependencies() + { + return std::move(dependencies); + } + + // Rebinding. + template + __host__ + execute_with_dependencies + rebind_after(UDependencies&& ...udependencies) const + { + return { capture_as_dependency(THRUST_FWD(udependencies))... }; + } + + // Rebinding. + template + __host__ + execute_with_dependencies + rebind_after(std::tuple& udependencies) const + { + return { capture_as_dependency(udependencies) }; + } + template + __host__ + execute_with_dependencies + rebind_after(std::tuple&& udependencies) const + { + return { capture_as_dependency(std::move(udependencies)) }; + } +}; + +template< + typename Allocator, + template class BaseSystem, + typename... Dependencies +> +struct execute_with_allocator_and_dependencies + : BaseSystem< + execute_with_allocator_and_dependencies< + Allocator, + BaseSystem, + Dependencies... + > + > +{ +private: + using super_t = BaseSystem< + execute_with_allocator_and_dependencies< + Allocator, + BaseSystem, + Dependencies... + > + >; + + std::tuple...> dependencies; + Allocator alloc; + +public: + template + __host__ + execute_with_allocator_and_dependencies(super_t const &super, Allocator a, UDependencies && ...deps) + : super_t(super), dependencies(THRUST_FWD(deps)...), alloc(a) + { + } + + template + __host__ + execute_with_allocator_and_dependencies(Allocator a, UDependencies && ...deps) + : dependencies(THRUST_FWD(deps)...), alloc(a) + { + } + + template + __host__ + execute_with_allocator_and_dependencies(super_t const &super, Allocator a, std::tuple&& deps) + : super_t(super), dependencies(std::move(deps)), alloc(a) + { + } + + template + __host__ + execute_with_allocator_and_dependencies(Allocator a, std::tuple&& deps) + : dependencies(std::move(deps)), alloc(a) + { + } + + std::tuple...> + __host__ + extract_dependencies() + { + return std::move(dependencies); + } + + __host__ + typename std::add_lvalue_reference::type + get_allocator() + { + return alloc; + } + + // Rebinding. + template + __host__ + execute_with_allocator_and_dependencies + rebind_after(UDependencies&& ...udependencies) const + { + return { alloc, capture_as_dependency(THRUST_FWD(udependencies))... }; + } + + // Rebinding. + template + __host__ + execute_with_allocator_and_dependencies + rebind_after(std::tuple& udependencies) const + { + return { alloc, capture_as_dependency(udependencies) }; + } + template + __host__ + execute_with_allocator_and_dependencies + rebind_after(std::tuple&& udependencies) const + { + return { alloc, capture_as_dependency(std::move(udependencies)) }; + } +}; + +template class BaseSystem, typename ...Dependencies> +__host__ +std::tuple...> +extract_dependencies(thrust::detail::execute_with_dependencies&& system) +{ + return std::move(system).extract_dependencies(); +} +template class BaseSystem, typename ...Dependencies> +__host__ +std::tuple...> +extract_dependencies(thrust::detail::execute_with_dependencies& system) +{ + return std::move(system).extract_dependencies(); +} + +template class BaseSystem, typename ...Dependencies> +__host__ +std::tuple...> +extract_dependencies(thrust::detail::execute_with_allocator_and_dependencies&& system) +{ + return std::move(system).extract_dependencies(); +} +template class BaseSystem, typename ...Dependencies> +__host__ +std::tuple...> +extract_dependencies(thrust::detail::execute_with_allocator_and_dependencies& system) +{ + return std::move(system).extract_dependencies(); +} + +template +__host__ +std::tuple<> +extract_dependencies(System &&) +{ + return std::tuple<>{}; +} + +} // end detail + +THRUST_NAMESPACE_END + +#endif // THRUST_CPP_DIALECT >= 2011 diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/extrema.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/extrema.inl new file mode 100644 index 0000000000000000000000000000000000000000..2c1750e7d481d2359c38fd21ea8b7764361bcb8c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/extrema.inl @@ -0,0 +1,169 @@ +/* + * 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 +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator min_element(const thrust::detail::execution_policy_base &exec, ForwardIterator first, ForwardIterator last) +{ + using thrust::system::detail::generic::min_element; + return min_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last); +} // end min_element() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator min_element(const thrust::detail::execution_policy_base &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp) +{ + using thrust::system::detail::generic::min_element; + return min_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp); +} // end min_element() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator max_element(const thrust::detail::execution_policy_base &exec, ForwardIterator first, ForwardIterator last) +{ + using thrust::system::detail::generic::max_element; + return max_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last); +} // end max_element() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator max_element(const thrust::detail::execution_policy_base &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp) +{ + using thrust::system::detail::generic::max_element; + return max_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp); +} // end max_element() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair minmax_element(const thrust::detail::execution_policy_base &exec, ForwardIterator first, ForwardIterator last) +{ + using thrust::system::detail::generic::minmax_element; + return minmax_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last); +} // end minmax_element() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair minmax_element(const thrust::detail::execution_policy_base &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp) +{ + using thrust::system::detail::generic::minmax_element; + return minmax_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp); +} // end minmax_element() + + +template +ForwardIterator min_element(ForwardIterator first, ForwardIterator last) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::min_element(select_system(system), first, last); +} // end min_element() + + +template +ForwardIterator min_element(ForwardIterator first, ForwardIterator last, + BinaryPredicate comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::min_element(select_system(system), first, last, comp); +} // end min_element() + + +template +ForwardIterator max_element(ForwardIterator first, ForwardIterator last) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::max_element(select_system(system), first, last); +} // end max_element() + + +template +ForwardIterator max_element(ForwardIterator first, ForwardIterator last, + BinaryPredicate comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::max_element(select_system(system), first, last, comp); +} // end max_element() + + +template +thrust::pair +minmax_element(ForwardIterator first, ForwardIterator last) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::minmax_element(select_system(system), first, last); +} // end minmax_element() + + +template +thrust::pair +minmax_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::minmax_element(select_system(system), first, last, comp); +} // end minmax_element() + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/arithmetic_operators.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/arithmetic_operators.h new file mode 100644 index 0000000000000000000000000000000000000000..443d307cbd60c194d200a2027804c16ec327e0c0 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/arithmetic_operators.h @@ -0,0 +1,436 @@ +/* + * 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 +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ +namespace functional +{ + +template +__host__ __device__ +actor< + composite< + transparent_unary_operator>, + actor + > +> +__host__ __device__ +operator-(const actor &_1) +{ + return compose(transparent_unary_operator>(), _1); +} // end operator-() + +// there's no standard unary_plus functional, so roll an ad hoc one here +struct unary_plus +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1) const + noexcept(noexcept(+THRUST_FWD(t1))) + THRUST_TRAILING_RETURN(decltype(+THRUST_FWD(t1))) + { + return +THRUST_FWD(t1); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_unary_operator, + actor + > +> +operator+(const actor &_1) +{ + return compose(transparent_unary_operator(), _1); +} // end operator+() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator+(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator+() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator+(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator+() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator+(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator+() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator-(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator-() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator-(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator-() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator-(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator-() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator*(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator*() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator*(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator*() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator*(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator*() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator/(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator/() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator/(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator/() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator/(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator/() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator%(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator%() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator%(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator%() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator%(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator%() + +// there's no standard prefix_increment functional, so roll an ad hoc one here +struct prefix_increment +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1) const + noexcept(noexcept(++THRUST_FWD(t1))) + THRUST_TRAILING_RETURN(decltype(++THRUST_FWD(t1))) + { + return ++THRUST_FWD(t1); + } +}; // end prefix_increment + +template +__host__ __device__ +actor< + composite< + transparent_unary_operator, + actor + > +> +operator++(const actor &_1) +{ + return compose(transparent_unary_operator(), _1); +} // end operator++() + + +// there's no standard postfix_increment functional, so roll an ad hoc one here +struct postfix_increment +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1) const + noexcept(noexcept(THRUST_FWD(t1)++)) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1)++)) + { + return THRUST_FWD(t1)++; + } +}; // end postfix_increment + +template +__host__ __device__ +actor< + composite< + transparent_unary_operator, + actor + > +> +operator++(const actor &_1, int) +{ + return compose(transparent_unary_operator(), _1); +} // end operator++() + + +// there's no standard prefix_decrement functional, so roll an ad hoc one here +struct prefix_decrement +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1) const + noexcept(noexcept(--THRUST_FWD(t1))) + THRUST_TRAILING_RETURN(decltype(--THRUST_FWD(t1))) + { + return --THRUST_FWD(t1); + } +}; // end prefix_decrement + +template +__host__ __device__ +actor< + composite< + transparent_unary_operator, + actor + > +> +operator--(const actor &_1) +{ + return compose(transparent_unary_operator(), _1); +} // end operator--() + + +// there's no standard postfix_decrement functional, so roll an ad hoc one here +struct postfix_decrement +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1) const + noexcept(noexcept(THRUST_FWD(t1)--)) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1)--)) + { + return THRUST_FWD(t1)--; + } +}; // end prefix_increment + +template +__host__ __device__ +actor< + composite< + transparent_unary_operator, + actor + > +> +operator--(const actor &_1, int) +{ + return compose(transparent_unary_operator(), _1); +} // end operator--() + +} // end functional +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/assignment_operator.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/assignment_operator.h new file mode 100644 index 0000000000000000000000000000000000000000..870354b6f0b59197cc7d80bb66a490f7ac81b5cd --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/assignment_operator.h @@ -0,0 +1,79 @@ +/* + * 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 +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +// XXX WAR circular inclusion with this forward declaration +template struct binary_function; + +namespace detail +{ +namespace functional +{ + +// XXX WAR circular inclusion with this forward declaration +template struct as_actor; + +// there's no standard assign functional, so roll an ad hoc one here +struct assign +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) = THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) = THRUST_FWD(t2))) + { + return THRUST_FWD(t1) = THRUST_FWD(t2); + } +}; + +template + struct assign_result +{ + typedef actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > + > type; +}; // end assign_result + +template + __host__ __device__ + typename assign_result::type + do_assign(const actor &_1, const T &_2) +{ + return compose(transparent_binary_operator(), + _1, + as_actor::convert(_2)); +} // end do_assign() + +} // end functional +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/bitwise_operators.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/bitwise_operators.h new file mode 100644 index 0000000000000000000000000000000000000000..065cd15403c764d00451c95bd3b72807d65451ae --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/bitwise_operators.h @@ -0,0 +1,338 @@ +/* + * 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 +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ +namespace functional +{ + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator&(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator&() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator&(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator&() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator&(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator&() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator|(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator|() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator|(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator|() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator|(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator|() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator^(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator^() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator^(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator^() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator^(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator^() + + +// there's no standard bit_not functional, so roll an ad hoc one here +struct bit_not +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1) const + noexcept(noexcept(~THRUST_FWD(t1))) + THRUST_TRAILING_RETURN(decltype(~THRUST_FWD(t1))) + { + return ~THRUST_FWD(t1); + } +}; // end prefix_increment + +template +__host__ __device__ +actor< + composite< + transparent_unary_operator, + actor + > +> +__host__ __device__ +operator~(const actor &_1) +{ + return compose(transparent_unary_operator(), _1); +} // end operator~() + +// there's no standard bit_lshift functional, so roll an ad hoc one here +struct bit_lshift +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) << THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) << THRUST_FWD(t2))) + { + return THRUST_FWD(t1) << THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator<<(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator<<() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + typename as_actor::type, + actor + > +> +operator<<(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator<<() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator<<(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator<<() + +// there's no standard bit_rshift functional, so roll an ad hoc one here +struct bit_rshift +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) >> THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) >> THRUST_FWD(t2))) + { + return THRUST_FWD(t1) >> THRUST_FWD(t2); + } +}; + + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator>>(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator>>() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + typename as_actor::type, + actor + > +> +operator>>(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator>>() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator>>(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator>>() + +} // end functional +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/compound_assignment_operators.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/compound_assignment_operators.h new file mode 100644 index 0000000000000000000000000000000000000000..b5ba77fb48d9bd0a559ea22cce5286471b927053 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/compound_assignment_operators.h @@ -0,0 +1,512 @@ +/* + * 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 +#include +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ +namespace functional +{ + +// there's no standard plus_equal functional, so roll an ad hoc one here +struct plus_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) += THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) += THRUST_FWD(t2))) + { + return THRUST_FWD(t1) += THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator+=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator+=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator+=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator+=() + +// there's no standard minus_equal functional, so roll an ad hoc one here +struct minus_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) -= THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) -= THRUST_FWD(t2))) + { + return THRUST_FWD(t1) -= THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator-=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator-=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator-=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator-=() + +// there's no standard multiplies_equal functional, so roll an ad hoc one here +struct multiplies_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) *= THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) *= THRUST_FWD(t2))) + { + return THRUST_FWD(t1) *= THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator*=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator*=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator*=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator*=() + +// there's no standard divides_equal functional, so roll an ad hoc one here +struct divides_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) /= THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) /= THRUST_FWD(t2))) + { + return THRUST_FWD(t1) /= THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator/=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator/=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator/=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator/=() + +// there's no standard modulus_equal functional, so roll an ad hoc one here +struct modulus_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) %= THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) %= THRUST_FWD(t2))) + { + return THRUST_FWD(t1) %= THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator%=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator%=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator%=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator%=() + +// there's no standard bit_and_equal functional, so roll an ad hoc one here +struct bit_and_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) &= THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) &= THRUST_FWD(t2))) + { + return THRUST_FWD(t1) &= THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator&=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator&=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator&=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator&=() + +// there's no standard bit_or_equal functional, so roll an ad hoc one here +struct bit_or_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) |= THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) |= THRUST_FWD(t2))) + { + return THRUST_FWD(t1) |= THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator|=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator|=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator|=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator|=() + +// there's no standard bit_xor_equal functional, so roll an ad hoc one here +struct bit_xor_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) ^= THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) ^= THRUST_FWD(t2))) + { + return THRUST_FWD(t1) ^= THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator^=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator|=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator^=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator|=() + +// there's no standard bit_lshift_equal functional, so roll an ad hoc one here +struct bit_lshift_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) <<= THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) <<= THRUST_FWD(t2))) + { + return THRUST_FWD(t1) <<= THRUST_FWD(t2); + } +}; +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator<<=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator<<=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator<<=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator<<=() + +// there's no standard bit_rshift_equal functional, so roll an ad hoc one here +struct bit_rshift_equal +{ + using is_transparent = void; + + __thrust_exec_check_disable__ + template + __host__ __device__ + constexpr auto operator()(T1&& t1, T2&& t2) const + noexcept(noexcept(THRUST_FWD(t1) >>= THRUST_FWD(t2))) + THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) >>= THRUST_FWD(t2))) + { + return THRUST_FWD(t1) >>= THRUST_FWD(t2); + } +}; + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + typename as_actor::type + > +> +operator>>=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator>>=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator, + actor, + actor + > +> +operator>>=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator(), + make_actor(_1), + make_actor(_2)); +} // end operator>>=() + +} // end functional +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/logical_operators.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/logical_operators.h new file mode 100644 index 0000000000000000000000000000000000000000..e1e4ff71994c9b7ba18a040933e479fab1864775 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/logical_operators.h @@ -0,0 +1,143 @@ +/* + * 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 +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ +namespace functional +{ + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator&&(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator&&() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator&&(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator&&() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator&&(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator&&() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator||(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator&&() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator||(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator&&() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator||(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator&&() + +template +__host__ __device__ +actor< + composite< + transparent_unary_operator>, + actor + > +> +operator!(const actor &_1) +{ + return compose(transparent_unary_operator>(), _1); +} // end operator!() + +} // end functional +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/relational_operators.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/relational_operators.h new file mode 100644 index 0000000000000000000000000000000000000000..6c58325e22513a0ede6d2532c38009ce2736cf98 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/relational_operators.h @@ -0,0 +1,322 @@ +/* + * 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 +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ +namespace functional +{ + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator==(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator==() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator==(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator==() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator==(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator==() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator!=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator!=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator!=(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator!=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator!=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator!=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator>(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator>() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator>(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator>() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator>(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator>() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator<(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator<() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator<(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator<() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator<(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator<() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator>=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator>=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator>=(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator>=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator>=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator>=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + typename as_actor::type + > +> +operator<=(const actor &_1, const T2 &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator<=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + typename as_actor::type, + actor + > +> +operator<=(const T1 &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator<=() + +template +__host__ __device__ +actor< + composite< + transparent_binary_operator>, + actor, + actor + > +> +operator<=(const actor &_1, const actor &_2) +{ + return compose(transparent_binary_operator>(), + make_actor(_1), + make_actor(_2)); +} // end operator<=() + +} // end functional +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/gather.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/gather.inl new file mode 100644 index 0000000000000000000000000000000000000000..3812702f61c6e28406d9aaf3091506c30ddc946c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/gather.inl @@ -0,0 +1,161 @@ +/* + * 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 + +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +__thrust_exec_check_disable__ +template +__host__ __device__ + OutputIterator gather(const thrust::detail::execution_policy_base &exec, + InputIterator map_first, + InputIterator map_last, + RandomAccessIterator input_first, + OutputIterator result) +{ + using thrust::system::detail::generic::gather; + return gather(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), map_first, map_last, input_first, result); +} // end gather() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + OutputIterator gather_if(const thrust::detail::execution_policy_base &exec, + InputIterator1 map_first, + InputIterator1 map_last, + InputIterator2 stencil, + RandomAccessIterator input_first, + OutputIterator result) +{ + using thrust::system::detail::generic::gather_if; + return gather_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), map_first, map_last, stencil, input_first, result); +} // end gather_if() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + OutputIterator gather_if(const thrust::detail::execution_policy_base &exec, + InputIterator1 map_first, + InputIterator1 map_last, + InputIterator2 stencil, + RandomAccessIterator input_first, + OutputIterator result, + Predicate pred) +{ + using thrust::system::detail::generic::gather_if; + return gather_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), map_first, map_last, stencil, input_first, result, pred); +} // end gather_if() + + +template + OutputIterator gather(InputIterator map_first, + InputIterator map_last, + RandomAccessIterator input_first, + OutputIterator result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::gather(select_system(system1,system2,system3), map_first, map_last, input_first, result); +} // end gather() + + +template + OutputIterator gather_if(InputIterator1 map_first, + InputIterator1 map_last, + InputIterator2 stencil, + RandomAccessIterator input_first, + OutputIterator result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + + return thrust::gather_if(select_system(system1,system2,system3,system4), map_first, map_last, stencil, input_first, result); +} // end gather_if() + + +template + OutputIterator gather_if(InputIterator1 map_first, + InputIterator1 map_last, + InputIterator2 stencil, + RandomAccessIterator input_first, + OutputIterator result, + Predicate pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + + return thrust::gather_if(select_system(system1,system2,system3,system4), map_first, map_last, stencil, input_first, result, pred); +} // end gather_if() + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/integer_math.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/integer_math.h new file mode 100644 index 0000000000000000000000000000000000000000..0f8c8aac16883cfad91c428a69a32ca696b0fb95 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/integer_math.h @@ -0,0 +1,152 @@ +/* + * 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 +#include + +#include + +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ + +template +__host__ __device__ __thrust_forceinline__ +Integer clz(Integer x) +{ + Integer result; + + NV_IF_TARGET(NV_IS_DEVICE, ( + result = ::__clz(x); + ), ( + int num_bits = 8 * sizeof(Integer); + int num_bits_minus_one = num_bits - 1; + result = num_bits; + for (int i = num_bits_minus_one; i >= 0; --i) + { + if ((Integer(1) << i) & x) + { + result = num_bits_minus_one - i; + break; + } + } + )); + + return result; +} + +template +__host__ __device__ __thrust_forceinline__ +bool is_power_of_2(Integer x) +{ + return 0 == (x & (x - 1)); +} + +template +__host__ __device__ __thrust_forceinline__ +bool is_odd(Integer x) +{ + return 1 & x; +} + +template +__host__ __device__ __thrust_forceinline__ +Integer log2(Integer x) +{ + Integer num_bits = 8 * sizeof(Integer); + Integer num_bits_minus_one = num_bits - 1; + + return num_bits_minus_one - clz(x); +} + + +template +__host__ __device__ __thrust_forceinline__ +Integer log2_ri(Integer x) +{ + Integer result = log2(x); + + // This is where we round up to the nearest log. + if (!is_power_of_2(x)) + ++result; + + return result; +} + +// x/y rounding towards +infinity for integers +// Used to determine # of blocks/warps etc. +template +__host__ __device__ __thrust_forceinline__ +#if THRUST_CPP_DIALECT >= 2011 +// FIXME: Should use common_type. +auto divide_ri(Integer0 const x, Integer1 const y) +THRUST_DECLTYPE_RETURNS((x + (y - 1)) / y) +#else +// FIXME: Should use common_type. +Integer0 divide_ri(Integer0 const x, Integer1 const y) +{ + return (x + (y - 1)) / y; +} +#endif + +// x/y rounding towards zero for integers. +// Used to determine # of blocks/warps etc. +template +__host__ __device__ __thrust_forceinline__ +#if THRUST_CPP_DIALECT >= 2011 +auto divide_rz(Integer0 const x, Integer1 const y) +THRUST_DECLTYPE_RETURNS(x / y) +#else +// FIXME: Should use common_type. +Integer0 divide_rz(Integer0 const x, Integer1 const y) +{ + return x / y; +} +#endif + +// Round x towards infinity to the next multiple of y. +template +__host__ __device__ __thrust_forceinline__ +#if THRUST_CPP_DIALECT >= 2011 +auto round_i(Integer0 const x, Integer1 const y) +THRUST_DECLTYPE_RETURNS(y * divide_ri(x, y)) +#else +Integer0 round_i(Integer0 const x, Integer1 const y) +{ + return y * divide_ri(x, y); +} +#endif + +// Round x towards 0 to the next multiple of y. +template +__host__ __device__ __thrust_forceinline__ +#if THRUST_CPP_DIALECT >= 2011 +auto round_z(Integer0 const x, Integer1 const y) +THRUST_DECLTYPE_RETURNS(y * divide_rz(x, y)) +#else +Integer0 round_z(Integer0 const x, Integer1 const y) +{ + return y * divide_rz(x, y); +} +#endif + +} // end detail + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/integer_traits.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/integer_traits.h new file mode 100644 index 0000000000000000000000000000000000000000..853af20b860d201a87b160c3445e5dc59343ddfc --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/integer_traits.h @@ -0,0 +1,130 @@ +/* + * 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 +#include +#include + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +template + class integer_traits +{ + public: + static constexpr bool is_integral = false; +}; + +template + class integer_traits_base +{ + public: + static constexpr bool is_integral = true; + static constexpr T const_min = min_val; + static constexpr T const_max = max_val; +}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + + +template<> + class integer_traits + : public std::numeric_limits, + public integer_traits_base +{}; + +} // end detail + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/logical.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/logical.inl new file mode 100644 index 0000000000000000000000000000000000000000..3d39cac926893040c41e2aeb2b03e9e09fa76668 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/logical.inl @@ -0,0 +1,95 @@ +/* + * 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 +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +__thrust_exec_check_disable__ +template +__host__ __device__ +bool all_of(const thrust::detail::execution_policy_base &exec, InputIterator first, InputIterator last, Predicate pred) +{ + using thrust::system::detail::generic::all_of; + return all_of(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred); +} // end all_of() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +bool any_of(const thrust::detail::execution_policy_base &exec, InputIterator first, InputIterator last, Predicate pred) +{ + using thrust::system::detail::generic::any_of; + return any_of(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred); +} // end any_of() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +bool none_of(const thrust::detail::execution_policy_base &exec, InputIterator first, InputIterator last, Predicate pred) +{ + using thrust::system::detail::generic::none_of; + return none_of(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred); +} // end none_of() + + +template +bool all_of(InputIterator first, InputIterator last, Predicate pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::all_of(select_system(system), first, last, pred); +} + + +template +bool any_of(InputIterator first, InputIterator last, Predicate pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::any_of(select_system(system), first, last, pred); +} + + +template +bool none_of(InputIterator first, InputIterator last, Predicate pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::none_of(select_system(system), first, last, pred); +} + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/memory_algorithms.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/memory_algorithms.h new file mode 100644 index 0000000000000000000000000000000000000000..2f6b3a81d71c22a08025505b1d5c39b4641d78fe --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/memory_algorithms.h @@ -0,0 +1,237 @@ +// Copyright (c) 2018 NVIDIA Corporation +// Author: Bryce Adelstein Lelbach +// +// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt) + +// TODO: These need to be turned into proper Thrust algorithms (dispatch layer, +// backends, etc). + +#pragma once + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + + +THRUST_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// + +template +__host__ __device__ +void destroy_at(T* location) +{ + location->~T(); +} + +template +__host__ __device__ +void destroy_at(Allocator const& alloc, T* location) +{ + typedef typename detail::allocator_traits< + typename detail::remove_cv< + typename detail::remove_reference::type + >::type + >::template rebind_traits::other traits; + + typename traits::allocator_type alloc_T(alloc); + + traits::destroy(alloc_T, location); +} + +template +__host__ __device__ +ForwardIt destroy(ForwardIt first, ForwardIt last) +{ + for (; first != last; ++first) + destroy_at(addressof(*first)); + + return first; +} + +template +__host__ __device__ +ForwardIt destroy(Allocator const& alloc, ForwardIt first, ForwardIt last) +{ + typedef typename iterator_traits::value_type T; + typedef typename detail::allocator_traits< + typename detail::remove_cv< + typename detail::remove_reference::type + >::type + >::template rebind_traits::other traits; + + typename traits::allocator_type alloc_T(alloc); + + for (; first != last; ++first) + destroy_at(alloc_T, addressof(*first)); + + return first; +} + +template +__host__ __device__ +ForwardIt destroy_n(ForwardIt first, Size n) +{ + for (; n > 0; (void) ++first, --n) + destroy_at(addressof(*first)); + + return first; +} + +template +__host__ __device__ +ForwardIt destroy_n(Allocator const& alloc, ForwardIt first, Size n) +{ + typedef typename iterator_traits::value_type T; + typedef typename detail::allocator_traits< + typename detail::remove_cv< + typename detail::remove_reference::type + >::type + >::template rebind_traits::other traits; + + typename traits::allocator_type alloc_T(alloc); + + for (; n > 0; (void) ++first, --n) + destroy_at(alloc_T, addressof(*first)); + + return first; +} + +template +__host__ __device__ +void uninitialized_construct( + ForwardIt first, ForwardIt last, Args const&... args +) +{ + using T = typename iterator_traits::value_type; + + ForwardIt current = first; + + // No exceptions in CUDA. + NV_IF_TARGET(NV_IS_HOST, ( + try { + for (; current != last; ++current) + { + ::new (static_cast(addressof(*current))) T(args...); + } + } catch (...) { + destroy(first, current); + throw; + } + ), ( + for (; current != last; ++current) + { + ::new (static_cast(addressof(*current))) T(args...); + } + )); +} + +template +void uninitialized_construct_with_allocator( + Allocator const& alloc, ForwardIt first, ForwardIt last, Args const&... args +) +{ + using T = typename iterator_traits::value_type; + using traits = typename detail::allocator_traits< + typename std::remove_cv< + typename std::remove_reference::type + >::type + >::template rebind_traits; + + typename traits::allocator_type alloc_T(alloc); + + ForwardIt current = first; + + // No exceptions in CUDA. + NV_IF_TARGET(NV_IS_HOST, ( + try { + for (; current != last; ++current) + { + traits::construct(alloc_T, addressof(*current), args...); + } + } catch (...) { + destroy(alloc_T, first, current); + throw; + } + ), ( + for (; current != last; ++current) + { + traits::construct(alloc_T, addressof(*current), args...); + } + )); +} + +template +void uninitialized_construct_n( + ForwardIt first, Size n, Args const&... args +) +{ + using T = typename iterator_traits::value_type; + + ForwardIt current = first; + + // No exceptions in CUDA. + NV_IF_TARGET(NV_IS_HOST, ( + try { + for (; n > 0; ++current, --n) + { + ::new (static_cast(addressof(*current))) T(args...); + } + } catch (...) { + destroy(first, current); + throw; + } + ), ( + for (; n > 0; ++current, --n) + { + ::new (static_cast(addressof(*current))) T(args...); + } + )); +} + +template +void uninitialized_construct_n_with_allocator( + Allocator const& alloc, ForwardIt first, Size n, Args const&... args +) +{ + using T = typename iterator_traits::value_type; + using traits = typename detail::allocator_traits< + typename std::remove_cv< + typename std::remove_reference::type + >::type + >::template rebind_traits; + + typename traits::allocator_type alloc_T(alloc); + + ForwardIt current = first; + + // No exceptions in CUDA. + NV_IF_TARGET(NV_IS_HOST, ( + try { + for (; n > 0; (void) ++current, --n) + { + traits::construct(alloc_T, addressof(*current), args...); + } + } catch (...) { + destroy(alloc_T, first, current); + throw; + } + ), ( + for (; n > 0; (void) ++current, --n) + { + traits::construct(alloc_T, addressof(*current), args...); + } + )); +} + +/////////////////////////////////////////////////////////////////////////////// + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/memory_wrapper.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/memory_wrapper.h new file mode 100644 index 0000000000000000000000000000000000000000..bfc9056fa15ff6d123659499e5fb9044f937f769 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/memory_wrapper.h @@ -0,0 +1,30 @@ +/* + * Copyright 2020 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +// When a compiler uses Thrust as part of its implementation of Standard C++ +// algorithms, a cycle of included files may result when Thrust code tries to +// use a standard algorithm. Having a macro that is defined only when Thrust +// is including an algorithms-related header gives the compiler a chance to +// detect and break the cycle of includes. ( declares several standard +// algorithms, including all of the uninitialized_* algorithms. "_ALGORITHMS_" +// in the macro name is meant generically, not as a specific reference to +// the header .) + +#define THRUST_INCLUDING_ALGORITHMS_HEADER +#include +#undef THRUST_INCLUDING_ALGORITHMS_HEADER diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/minmax.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/minmax.h new file mode 100644 index 0000000000000000000000000000000000000000..c565a74bdffba6d20db5a62cc86a3c7889f630c2 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/minmax.h @@ -0,0 +1,51 @@ +/* + * 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_NAMESPACE_BEGIN + +template +__host__ __device__ + T min THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs, BinaryPredicate comp) +{ + return comp(rhs, lhs) ? rhs : lhs; +} // end min() + +template +__host__ __device__ + T min THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs) +{ + return rhs < lhs ? rhs : lhs; +} // end min() + +template +__host__ __device__ + T max THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs, BinaryPredicate comp) +{ + return comp(lhs,rhs) ? rhs : lhs; +} // end max() + +template +__host__ __device__ + T max THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs) +{ + return lhs < rhs ? rhs : lhs; +} // end max() + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/mpl/math.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/mpl/math.h new file mode 100644 index 0000000000000000000000000000000000000000..bda98003cd5894617a468c3dfab42765375a66fd --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/mpl/math.h @@ -0,0 +1,175 @@ +/* + * 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. + */ + + +/*! \file math.h + * \brief Math-related metaprogramming functionality. + */ + + +#pragma once + +#include + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +namespace mpl +{ + +namespace math +{ + +namespace detail +{ + +// compute the log base-2 of an integer at compile time +template +struct log2 +{ + static const unsigned int value = log2::value; +}; + +template +struct log2<1, Cur> +{ + static const unsigned int value = Cur; +}; + +template +struct log2<0, Cur> +{ + // undefined +}; + +} // end namespace detail + + +template +struct log2 +{ + static const unsigned int value = detail::log2::value; +}; + + +template +struct min +{ + static const T value = (lhs < rhs) ? lhs : rhs; +}; + + +template +struct max +{ + static const T value = (!(lhs < rhs)) ? lhs : rhs; +}; + + +template + struct mul +{ + static const result_type value = x * y; +}; + + +template + struct mod +{ + static const result_type value = x % y; +}; + + +template + struct div +{ + static const result_type value = x / y; +}; + + +template + struct geq +{ + static const bool value = x >= y; +}; + + +template + struct lt +{ + static const bool value = x < y; +}; + + +template + struct gt +{ + static const bool value = x > y; +}; + + +template + struct or_ +{ + static const bool value = (x || y); +}; + + +template + struct bit_and +{ + static const result_type value = x & y; +}; + + +template + struct plus +{ + static const result_type value = x + y; +}; + + +template + struct minus +{ + static const result_type value = x - y; +}; + + +template + struct equal +{ + static const bool value = x == y; +}; + + +template + struct is_odd +{ + static const bool value = x & 1; +}; + + +} // end namespace math + +} // end namespace mpl + +} // end namespace detail + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/numeric_traits.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/numeric_traits.h new file mode 100644 index 0000000000000000000000000000000000000000..e728adcaf3e8c19fa6db82cba94d564dbb5d5dbf --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/numeric_traits.h @@ -0,0 +1,129 @@ +/* + * 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 +#include +#include + +//#include // for intmax_t (not provided on MSVS 2005) + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +// XXX good enough for the platforms we care about +typedef long long intmax_t; + +template + struct is_signed + : integral_constant::is_signed> +{}; // end is_signed + + +template + struct num_digits + : eval_if< + std::numeric_limits::is_specialized, + integral_constant< + int, + std::numeric_limits::digits + >, + integral_constant< + int, + sizeof(T) * std::numeric_limits::digits - (is_signed::value ? 1 : 0) + > + >::type +{}; // end num_digits + + +template + struct integer_difference + //: eval_if< + // sizeof(Integer) >= sizeof(intmax_t), + // eval_if< + // is_signed::value, + // identity_, + // identity_ + // >, + // eval_if< + // sizeof(Integer) < sizeof(std::ptrdiff_t), + // identity_, + // identity_ + // > + // > +{ + private: + // XXX workaround a pedantic warning in old versions of g++ + // which complains about &&ing with a constant value + template + struct and_ + { + static const bool value = false; + }; + + template + struct and_ + { + static const bool value = y; + }; + + public: + typedef typename + eval_if< + and_< + std::numeric_limits::is_signed, + // digits is the number of no-sign bits + (!std::numeric_limits::is_bounded || (int(std::numeric_limits::digits) + 1 >= num_digits::value)) + >::value, + identity_, + eval_if< + int(std::numeric_limits::digits) + 1 < num_digits::value, + identity_, + eval_if< + int(std::numeric_limits::digits) + 1 < num_digits::value, + identity_, + identity_ + > + > + >::type type; +}; // end integer_difference + + +template + struct numeric_difference + : eval_if< + is_integral::value, + integer_difference, + identity_ + > +{}; // end numeric_difference + + +template +__host__ __device__ +typename numeric_difference::type +numeric_distance(Number x, Number y) +{ + typedef typename numeric_difference::type difference_type; + return difference_type(y) - difference_type(x); +} // end numeric_distance + +} // end detail + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/pair.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/pair.inl new file mode 100644 index 0000000000000000000000000000000000000000..4b7dd6eb0fed52c782ef416ad39d67ce659277a3 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/pair.inl @@ -0,0 +1,231 @@ +/* + * Copyright 2008-2021 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +template + __host__ __device__ + pair + ::pair(void) + :first(),second() +{ + ; +} // end pair::pair() + + +template + __host__ __device__ + pair + ::pair(const T1 &x, const T2 &y) + :first(x),second(y) +{ + ; +} // end pair::pair() + + +template + template + __host__ __device__ + pair + ::pair(const pair &p) + :first(p.first),second(p.second) +{ + ; +} // end pair::pair() + + +template + template + __host__ __device__ + pair + ::pair(const std::pair &p) + :first(p.first),second(p.second) +{ + ; +} // end pair::pair() + + +template + inline __host__ __device__ + void pair + ::swap(thrust::pair &p) +{ + using thrust::swap; + + swap(first, p.first); + swap(second, p.second); +} // end pair::swap() + + +template + inline __host__ __device__ + bool operator==(const pair &x, const pair &y) +{ + return x.first == y.first && x.second == y.second; +} // end operator==() + + +template + inline __host__ __device__ + bool operator<(const pair &x, const pair &y) +{ + return x.first < y.first || (!(y.first < x.first) && x.second < y.second); +} // end operator<() + + +template + inline __host__ __device__ + bool operator!=(const pair &x, const pair &y) +{ + return !(x == y); +} // end operator==() + + +template + inline __host__ __device__ + bool operator>(const pair &x, const pair &y) +{ + return y < x; +} // end operator<() + + +template + inline __host__ __device__ + bool operator<=(const pair &x, const pair &y) +{ + return !(y < x); +} // end operator<=() + + +template + inline __host__ __device__ + bool operator>=(const pair &x, const pair &y) +{ + return !(x < y); +} // end operator>=() + + +template + inline __host__ __device__ + void swap(pair &x, pair &y) +{ + return x.swap(y); +} // end swap() + + +template + inline __host__ __device__ + pair make_pair(T1 x, T2 y) +{ + return pair(x,y); +} // end make_pair() + + +// specializations of tuple_element for pair +template + struct tuple_element<0, pair> +{ + typedef T1 type; +}; // end tuple_element + +template + struct tuple_element<1, pair> +{ + typedef T2 type; +}; // end tuple_element + + +// specialization of tuple_size for pair +template + struct tuple_size> +{ + static const unsigned int value = 2; +}; // end tuple_size + + + +namespace detail +{ + + +template struct pair_get {}; + +template + struct pair_get<0, Pair> +{ + inline __host__ __device__ + const typename tuple_element<0, Pair>::type & + operator()(const Pair &p) const + { + return p.first; + } // end operator()() + + inline __host__ __device__ + typename tuple_element<0, Pair>::type & + operator()(Pair &p) const + { + return p.first; + } // end operator()() +}; // end pair_get + + +template + struct pair_get<1, Pair> +{ + inline __host__ __device__ + const typename tuple_element<1, Pair>::type & + operator()(const Pair &p) const + { + return p.second; + } // end operator()() + + inline __host__ __device__ + typename tuple_element<1, Pair>::type & + operator()(Pair &p) const + { + return p.second; + } // end operator()() +}; // end pair_get + +} // end detail + + + +template + inline __host__ __device__ + typename tuple_element >::type & + get(pair &p) +{ + return detail::pair_get >()(p); +} // end get() + +template + inline __host__ __device__ + const typename tuple_element >::type & + get(const pair &p) +{ + return detail::pair_get >()(p); +} // end get() + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/pointer.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/pointer.h new file mode 100644 index 0000000000000000000000000000000000000000..aed1fcc2444fae71f3019e8a76ebbc4fd71e30c4 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/pointer.h @@ -0,0 +1,255 @@ +/* + * Copyright 2008-2021 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/*! \file + * \brief A pointer to a variable which resides in memory associated with a + * system. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +template +class pointer; + +// Specialize `thrust::iterator_traits` to avoid problems with the name of +// pointer's constructor shadowing its nested pointer type. We do this before +// pointer is defined so the specialization is correctly used inside the +// definition. +template +struct iterator_traits> +{ + using pointer = thrust::pointer; + using iterator_category = typename pointer::iterator_category; + using value_type = typename pointer::value_type; + using difference_type = typename pointer::difference_type; + using reference = typename pointer::reference; +}; + +THRUST_NAMESPACE_END + +namespace std +{ + +template +struct iterator_traits> +{ + using pointer = THRUST_NS_QUALIFIER::pointer; + using iterator_category = typename pointer::iterator_category; + using value_type = typename pointer::value_type; + using difference_type = typename pointer::difference_type; + using reference = typename pointer::reference; +}; + +} // namespace std + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +// this metafunction computes the type of iterator_adaptor thrust::pointer should inherit from +template + struct pointer_base +{ + // void pointers should have no element type + // note that we remove_cv from the Element type to get the value_type + typedef typename thrust::detail::eval_if< + thrust::detail::is_void::type>::value, + thrust::detail::identity_, + thrust::detail::remove_cv + >::type value_type; + + // if no Derived type is given, just use pointer + typedef typename thrust::detail::eval_if< + thrust::detail::is_same::value, + thrust::detail::identity_ >, + thrust::detail::identity_ + >::type derived_type; + + // void pointers should have no reference type + // if no Reference type is given, just use reference + typedef typename thrust::detail::eval_if< + thrust::detail::is_void::type>::value, + thrust::detail::identity_, + thrust::detail::eval_if< + thrust::detail::is_same::value, + thrust::detail::identity_ >, + thrust::detail::identity_ + > + >::type reference_type; + + typedef thrust::iterator_adaptor< + derived_type, // pass along the type of our Derived class to iterator_adaptor + Element *, // we adapt a raw pointer + value_type, // the value type + Tag, // system tag + thrust::random_access_traversal_tag, // pointers have random access traversal + reference_type, // pass along our Reference type + std::ptrdiff_t + > type; +}; // end pointer_base + + +} // end detail + + +// the base type for all of thrust's tagged pointers. +// for reasonable pointer-like semantics, derived types should reimplement the following: +// 1. no-argument constructor +// 2. constructor from OtherElement * +// 3. constructor from OtherPointer related by convertibility +// 4. constructor from OtherPointer to void +// 5. assignment from OtherPointer related by convertibility +// These should just call the corresponding members of pointer. +template + class pointer + : public thrust::detail::pointer_base::type +{ + private: + typedef typename thrust::detail::pointer_base::type super_t; + + typedef typename thrust::detail::pointer_base::derived_type derived_type; + + // friend iterator_core_access to give it access to dereference + friend class thrust::iterator_core_access; + + __host__ __device__ + typename super_t::reference dereference() const; + + // don't provide access to this part of super_t's interface + using super_t::base; + using typename super_t::base_type; + + public: + typedef typename super_t::base_type raw_pointer; + + // constructors + + __host__ __device__ + pointer(); + + // NOTE: This is needed so that Thrust smart pointers can be used in + // `std::unique_ptr`. + __host__ __device__ + pointer(std::nullptr_t); + + // OtherValue shall be convertible to Value + // XXX consider making the pointer implementation a template parameter which defaults to Element * + template + __host__ __device__ + explicit pointer(OtherElement *ptr); + + // OtherPointer's element_type shall be convertible to Element + // OtherPointer's system shall be convertible to Tag + template + __host__ __device__ + pointer(const OtherPointer &other, + typename thrust::detail::enable_if_pointer_is_convertible< + OtherPointer, + pointer + >::type * = 0); + + // OtherPointer's element_type shall be void + // OtherPointer's system shall be convertible to Tag + template + __host__ __device__ + explicit + pointer(const OtherPointer &other, + typename thrust::detail::enable_if_void_pointer_is_system_convertible< + OtherPointer, + pointer + >::type * = 0); + + // assignment + + // NOTE: This is needed so that Thrust smart pointers can be used in + // `std::unique_ptr`. + __host__ __device__ + derived_type& operator=(std::nullptr_t); + + // OtherPointer's element_type shall be convertible to Element + // OtherPointer's system shall be convertible to Tag + template + __host__ __device__ + typename thrust::detail::enable_if_pointer_is_convertible< + OtherPointer, + pointer, + derived_type & + >::type + operator=(const OtherPointer &other); + + // observers + + __host__ __device__ + Element *get() const; + + __host__ __device__ + Element *operator->() const; + + // NOTE: This is needed so that Thrust smart pointers can be used in + // `std::unique_ptr`. + __host__ __device__ + explicit operator bool() const; + + __host__ __device__ + static derived_type pointer_to(typename thrust::detail::pointer_traits_detail::pointer_to_param::type r) + { + return thrust::detail::pointer_traits::pointer_to(r); + } +}; // end pointer + +// Output stream operator +template +__host__ +std::basic_ostream & +operator<<(std::basic_ostream &os, + const pointer &p); + +// NOTE: This is needed so that Thrust smart pointers can be used in +// `std::unique_ptr`. +template +__host__ __device__ +bool operator==(std::nullptr_t, pointer p); + +template +__host__ __device__ +bool operator==(pointer p, std::nullptr_t); + +template +__host__ __device__ +bool operator!=(std::nullptr_t, pointer p); + +template +__host__ __device__ +bool operator!=(pointer p, std::nullptr_t); + +THRUST_NAMESPACE_END + +#include + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/pointer.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/pointer.inl new file mode 100644 index 0000000000000000000000000000000000000000..de05ff20f0cc2d0a5bb65ab399c46dd661063016 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/pointer.inl @@ -0,0 +1,209 @@ +/* + * Copyright 2008-2021 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +#include +#include + +THRUST_NAMESPACE_BEGIN + +template + __host__ __device__ + pointer + ::pointer() + : super_t(static_cast(nullptr)) +{} // end pointer::pointer + + +template + __host__ __device__ + pointer + ::pointer(std::nullptr_t) + : super_t(static_cast(nullptr)) +{} // end pointer::pointer + + +template + template + __host__ __device__ + pointer + ::pointer(OtherElement *other) + : super_t(other) +{} // end pointer::pointer + + +template + template + __host__ __device__ + pointer + ::pointer(const OtherPointer &other, + typename thrust::detail::enable_if_pointer_is_convertible< + OtherPointer, + pointer + >::type *) + : super_t(thrust::detail::pointer_traits::get(other)) +{} // end pointer::pointer + + +template + template + __host__ __device__ + pointer + ::pointer(const OtherPointer &other, + typename thrust::detail::enable_if_void_pointer_is_system_convertible< + OtherPointer, + pointer + >::type *) + : super_t(static_cast(thrust::detail::pointer_traits::get(other))) +{} // end pointer::pointer + + +template + __host__ __device__ + typename pointer::derived_type & + pointer + ::operator=(decltype(nullptr)) +{ + super_t::base_reference() = nullptr; + return static_cast(*this); +} // end pointer::operator= + + +template + template + __host__ __device__ + typename thrust::detail::enable_if_pointer_is_convertible< + OtherPointer, + pointer, + typename pointer::derived_type & + >::type + pointer + ::operator=(const OtherPointer &other) +{ + super_t::base_reference() = thrust::detail::pointer_traits::get(other); + return static_cast(*this); +} // end pointer::operator= + +namespace detail +{ + +// Implementation for dereference() when Reference is Element&, +// e.g. cuda's managed_memory_pointer +template +__host__ __device__ +Reference pointer_dereference_impl(const Derived& ptr, + thrust::detail::true_type /* is_cpp_ref */) +{ + return *ptr.get(); +} + +// Implementation for pointers with proxy references: +template +__host__ __device__ +Reference pointer_dereference_impl(const Derived& ptr, + thrust::detail::false_type /* is_cpp_ref */) +{ + return Reference(ptr); +} + +} // namespace detail + +template + __host__ __device__ + typename pointer::super_t::reference + pointer + ::dereference() const +{ + // Need to handle cpp refs and fancy refs differently: + typedef typename super_t::reference RefT; + typedef typename thrust::detail::is_reference::type IsCppRef; + + const derived_type& derivedPtr = static_cast(*this); + + return detail::pointer_dereference_impl(derivedPtr, IsCppRef()); +} // end pointer::dereference + + +template + __host__ __device__ + Element *pointer + ::get() const +{ + return super_t::base(); +} // end pointer::get + + +template + __host__ __device__ + Element *pointer + ::operator->() const +{ + return super_t::base(); +} // end pointer::operator-> + + +template + __host__ __device__ + pointer + ::operator bool() const +{ + return bool(get()); +} // end pointer::operator bool + + +template +__host__ +std::basic_ostream & +operator<<(std::basic_ostream &os, + const pointer &p) { + return os << p.get(); +} + +// NOTE: These are needed so that Thrust smart pointers work with +// `std::unique_ptr`. +template +__host__ __device__ +bool operator==(std::nullptr_t, pointer p) +{ + return nullptr == p.get(); +} + +template +__host__ __device__ +bool operator==(pointer p, std::nullptr_t) +{ + return nullptr == p.get(); +} + +template +__host__ __device__ +bool operator!=(std::nullptr_t, pointer p) +{ + return !(nullptr == p); +} + +template +__host__ __device__ +bool operator!=(pointer p, std::nullptr_t) +{ + return !(nullptr == p); +} + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/preprocessor.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/preprocessor.h new file mode 100644 index 0000000000000000000000000000000000000000..2e850c764dd86591c4ea720b68d2befe11d60aa7 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/preprocessor.h @@ -0,0 +1,1182 @@ +// Copyright (c) 2017-2018 NVIDIA Corporation +// Copyright (c) 2014-2018 Bryce Adelstein Lelbach +// Copyright (c) 2001-2015 Housemarque Oy (housemarque.com) +// Copyright (c) 2007-2015 Hartmut Kaiser +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd +// (`THRUST_CURRENT_FUNCTION`) +// +// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt) + +#pragma once + +/////////////////////////////////////////////////////////////////////////////// + +/// \def THRUST_PP_STRINGIZE(expr) +/// \brief Stringizes the expression \a expr. +/// +/// \par Example: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << THRUST_PP_STRINGIZE(foo) << "\n"; +/// } +/// \endcode +/// +/// The above code expands to: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << "foo" << "\n"; +/// } +/// \endcode +/// +#define THRUST_PP_STRINGIZE(expr) THRUST_PP_STRINGIZE_IMPL0(expr) +#define THRUST_PP_STRINGIZE_IMPL0(expr) #expr + +/////////////////////////////////////////////////////////////////////////////// + +/// \def THRUST_PP_CAT2(a, b) +/// \brief Concatenates the tokens \a a and \b b. +/// +/// \par Example: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << THRUST_PP_CAT2(1, THRUST_PP_CAT2(2, 3)) << "\n"; +/// } +/// \endcode +/// +/// The above code expands to: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << 123 << "\n"; +/// } +/// \endcode +/// +#define THRUST_PP_CAT2(a, b) THRUST_PP_CAT2_IMPL0(a, b) + +#if defined(_MSC_VER) \ + && (defined(__EDG__) || defined(__EDG_VERSION__)) \ + && (defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308) + #define THRUST_PP_CAT2_IMPL0(a, b) THRUST_PP_CAT2_IMPL1(~, a ## b) + #define THRUST_PP_CAT2_IMPL1(p, res) res +#else + #define THRUST_PP_CAT2_IMPL0(a, b) a ## b +#endif + +#define THRUST_PP_CAT3(a, b, c) \ + THRUST_PP_CAT2(a, \ + THRUST_PP_CAT2(b, c)) \ + /**/ + +#define THRUST_PP_CAT4(a, b, c, d) \ + THRUST_PP_CAT2(a, \ + THRUST_PP_CAT2(b, \ + THRUST_PP_CAT2(c, d))) \ + /**/ + +#define THRUST_PP_CAT5(a, b, c, d, e) \ + THRUST_PP_CAT2(a, \ + THRUST_PP_CAT2(b, \ + THRUST_PP_CAT2(c, \ + THRUST_PP_CAT2(d, e)))) \ + /**/ + +/////////////////////////////////////////////////////////////////////////////// + +/// \def THRUST_PP_EXPAND(x) +/// \brief Performs macro expansion on \a x. +/// +/// \par Example: +/// +/// \code +/// #include +/// #include +/// +/// #define FOO_BAR() "foo_bar" +/// #define BUZZ() THRUST_PP_EXPAND(THRUST_PP_CAT2(FOO_, BAR)()) +/// +/// int main() +/// { +/// std::cout << BUZZ() << "\n"; +/// } +/// \endcode +/// +/// The above code expands to: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << "foo_bar" << "\n"; +/// } +/// \endcode +/// +#define THRUST_PP_EXPAND(x) THRUST_PP_EXPAND_IMPL0(x) +#define THRUST_PP_EXPAND_IMPL0(x) x + +#define THRUST_PP_EXPAND_ARGS(...) THRUST_PP_EXPAND_ARGS_IMPL0(__VA_ARGS__) +#define THRUST_PP_EXPAND_ARGS_IMPL0(...) __VA_ARGS__ + +#define THRUST_PP_HEAD(x, ...) x + +#define THRUST_PP_TAIL(x, ...) __VA_ARGS__ + +/////////////////////////////////////////////////////////////////////////////// + +#define THRUST_PP_EMPTY() + +#define THRUST_PP_COMMA() , + +/////////////////////////////////////////////////////////////////////////////// + +#define THRUST_PP_INC(x) THRUST_PP_INC_IMPL0(x) + +#define THRUST_PP_INC_IMPL0(x) THRUST_PP_CAT2(THRUST_PP_INC_IMPL_TAG, x) + +#define THRUST_PP_INC_IMPL_TAG0 1 +#define THRUST_PP_INC_IMPL_TAG1 2 +#define THRUST_PP_INC_IMPL_TAG2 3 +#define THRUST_PP_INC_IMPL_TAG3 4 +#define THRUST_PP_INC_IMPL_TAG4 5 +#define THRUST_PP_INC_IMPL_TAG5 6 +#define THRUST_PP_INC_IMPL_TAG6 7 +#define THRUST_PP_INC_IMPL_TAG7 8 +#define THRUST_PP_INC_IMPL_TAG8 9 +#define THRUST_PP_INC_IMPL_TAG9 10 +#define THRUST_PP_INC_IMPL_TAG10 11 +#define THRUST_PP_INC_IMPL_TAG11 12 +#define THRUST_PP_INC_IMPL_TAG12 13 +#define THRUST_PP_INC_IMPL_TAG13 14 +#define THRUST_PP_INC_IMPL_TAG14 15 +#define THRUST_PP_INC_IMPL_TAG15 16 +#define THRUST_PP_INC_IMPL_TAG16 17 +#define THRUST_PP_INC_IMPL_TAG17 18 +#define THRUST_PP_INC_IMPL_TAG18 19 +#define THRUST_PP_INC_IMPL_TAG19 20 +#define THRUST_PP_INC_IMPL_TAG20 21 +#define THRUST_PP_INC_IMPL_TAG21 22 +#define THRUST_PP_INC_IMPL_TAG22 23 +#define THRUST_PP_INC_IMPL_TAG23 24 +#define THRUST_PP_INC_IMPL_TAG24 25 +#define THRUST_PP_INC_IMPL_TAG25 26 +#define THRUST_PP_INC_IMPL_TAG26 27 +#define THRUST_PP_INC_IMPL_TAG27 28 +#define THRUST_PP_INC_IMPL_TAG28 29 +#define THRUST_PP_INC_IMPL_TAG29 30 +#define THRUST_PP_INC_IMPL_TAG30 31 +#define THRUST_PP_INC_IMPL_TAG31 32 +#define THRUST_PP_INC_IMPL_TAG32 33 +#define THRUST_PP_INC_IMPL_TAG33 34 +#define THRUST_PP_INC_IMPL_TAG34 35 +#define THRUST_PP_INC_IMPL_TAG35 36 +#define THRUST_PP_INC_IMPL_TAG36 37 +#define THRUST_PP_INC_IMPL_TAG37 38 +#define THRUST_PP_INC_IMPL_TAG38 39 +#define THRUST_PP_INC_IMPL_TAG39 40 +#define THRUST_PP_INC_IMPL_TAG40 41 +#define THRUST_PP_INC_IMPL_TAG41 42 +#define THRUST_PP_INC_IMPL_TAG42 43 +#define THRUST_PP_INC_IMPL_TAG43 44 +#define THRUST_PP_INC_IMPL_TAG44 45 +#define THRUST_PP_INC_IMPL_TAG45 46 +#define THRUST_PP_INC_IMPL_TAG46 47 +#define THRUST_PP_INC_IMPL_TAG47 48 +#define THRUST_PP_INC_IMPL_TAG48 49 +#define THRUST_PP_INC_IMPL_TAG49 50 +#define THRUST_PP_INC_IMPL_TAG50 51 +#define THRUST_PP_INC_IMPL_TAG51 52 +#define THRUST_PP_INC_IMPL_TAG52 53 +#define THRUST_PP_INC_IMPL_TAG53 54 +#define THRUST_PP_INC_IMPL_TAG54 55 +#define THRUST_PP_INC_IMPL_TAG55 56 +#define THRUST_PP_INC_IMPL_TAG56 57 +#define THRUST_PP_INC_IMPL_TAG57 58 +#define THRUST_PP_INC_IMPL_TAG58 59 +#define THRUST_PP_INC_IMPL_TAG59 60 +#define THRUST_PP_INC_IMPL_TAG60 61 +#define THRUST_PP_INC_IMPL_TAG61 62 +#define THRUST_PP_INC_IMPL_TAG62 63 +#define THRUST_PP_INC_IMPL_TAG63 64 +#define THRUST_PP_INC_IMPL_TAG64 65 +#define THRUST_PP_INC_IMPL_TAG65 66 +#define THRUST_PP_INC_IMPL_TAG66 67 +#define THRUST_PP_INC_IMPL_TAG67 68 +#define THRUST_PP_INC_IMPL_TAG68 69 +#define THRUST_PP_INC_IMPL_TAG69 70 +#define THRUST_PP_INC_IMPL_TAG70 71 +#define THRUST_PP_INC_IMPL_TAG71 72 +#define THRUST_PP_INC_IMPL_TAG72 73 +#define THRUST_PP_INC_IMPL_TAG73 74 +#define THRUST_PP_INC_IMPL_TAG74 75 +#define THRUST_PP_INC_IMPL_TAG75 76 +#define THRUST_PP_INC_IMPL_TAG76 77 +#define THRUST_PP_INC_IMPL_TAG77 78 +#define THRUST_PP_INC_IMPL_TAG78 79 +#define THRUST_PP_INC_IMPL_TAG79 80 +#define THRUST_PP_INC_IMPL_TAG80 81 +#define THRUST_PP_INC_IMPL_TAG81 82 +#define THRUST_PP_INC_IMPL_TAG82 83 +#define THRUST_PP_INC_IMPL_TAG83 84 +#define THRUST_PP_INC_IMPL_TAG84 85 +#define THRUST_PP_INC_IMPL_TAG85 86 +#define THRUST_PP_INC_IMPL_TAG86 87 +#define THRUST_PP_INC_IMPL_TAG87 88 +#define THRUST_PP_INC_IMPL_TAG88 89 +#define THRUST_PP_INC_IMPL_TAG89 90 +#define THRUST_PP_INC_IMPL_TAG90 91 +#define THRUST_PP_INC_IMPL_TAG91 92 +#define THRUST_PP_INC_IMPL_TAG92 93 +#define THRUST_PP_INC_IMPL_TAG93 94 +#define THRUST_PP_INC_IMPL_TAG94 95 +#define THRUST_PP_INC_IMPL_TAG95 96 +#define THRUST_PP_INC_IMPL_TAG96 97 +#define THRUST_PP_INC_IMPL_TAG97 98 +#define THRUST_PP_INC_IMPL_TAG98 99 +#define THRUST_PP_INC_IMPL_TAG99 100 +#define THRUST_PP_INC_IMPL_TAG100 101 +#define THRUST_PP_INC_IMPL_TAG101 102 +#define THRUST_PP_INC_IMPL_TAG102 103 +#define THRUST_PP_INC_IMPL_TAG103 104 +#define THRUST_PP_INC_IMPL_TAG104 105 +#define THRUST_PP_INC_IMPL_TAG105 106 +#define THRUST_PP_INC_IMPL_TAG106 107 +#define THRUST_PP_INC_IMPL_TAG107 108 +#define THRUST_PP_INC_IMPL_TAG108 109 +#define THRUST_PP_INC_IMPL_TAG109 110 +#define THRUST_PP_INC_IMPL_TAG110 111 +#define THRUST_PP_INC_IMPL_TAG111 112 +#define THRUST_PP_INC_IMPL_TAG112 113 +#define THRUST_PP_INC_IMPL_TAG113 114 +#define THRUST_PP_INC_IMPL_TAG114 115 +#define THRUST_PP_INC_IMPL_TAG115 116 +#define THRUST_PP_INC_IMPL_TAG116 117 +#define THRUST_PP_INC_IMPL_TAG117 118 +#define THRUST_PP_INC_IMPL_TAG118 119 +#define THRUST_PP_INC_IMPL_TAG119 120 +#define THRUST_PP_INC_IMPL_TAG120 121 +#define THRUST_PP_INC_IMPL_TAG121 122 +#define THRUST_PP_INC_IMPL_TAG122 123 +#define THRUST_PP_INC_IMPL_TAG123 124 +#define THRUST_PP_INC_IMPL_TAG124 125 +#define THRUST_PP_INC_IMPL_TAG125 126 +#define THRUST_PP_INC_IMPL_TAG126 127 +#define THRUST_PP_INC_IMPL_TAG127 128 +#define THRUST_PP_INC_IMPL_TAG128 129 +#define THRUST_PP_INC_IMPL_TAG129 130 +#define THRUST_PP_INC_IMPL_TAG130 131 +#define THRUST_PP_INC_IMPL_TAG131 132 +#define THRUST_PP_INC_IMPL_TAG132 133 +#define THRUST_PP_INC_IMPL_TAG133 134 +#define THRUST_PP_INC_IMPL_TAG134 135 +#define THRUST_PP_INC_IMPL_TAG135 136 +#define THRUST_PP_INC_IMPL_TAG136 137 +#define THRUST_PP_INC_IMPL_TAG137 138 +#define THRUST_PP_INC_IMPL_TAG138 139 +#define THRUST_PP_INC_IMPL_TAG139 140 +#define THRUST_PP_INC_IMPL_TAG140 141 +#define THRUST_PP_INC_IMPL_TAG141 142 +#define THRUST_PP_INC_IMPL_TAG142 143 +#define THRUST_PP_INC_IMPL_TAG143 144 +#define THRUST_PP_INC_IMPL_TAG144 145 +#define THRUST_PP_INC_IMPL_TAG145 146 +#define THRUST_PP_INC_IMPL_TAG146 147 +#define THRUST_PP_INC_IMPL_TAG147 148 +#define THRUST_PP_INC_IMPL_TAG148 149 +#define THRUST_PP_INC_IMPL_TAG149 150 +#define THRUST_PP_INC_IMPL_TAG150 151 +#define THRUST_PP_INC_IMPL_TAG151 152 +#define THRUST_PP_INC_IMPL_TAG152 153 +#define THRUST_PP_INC_IMPL_TAG153 154 +#define THRUST_PP_INC_IMPL_TAG154 155 +#define THRUST_PP_INC_IMPL_TAG155 156 +#define THRUST_PP_INC_IMPL_TAG156 157 +#define THRUST_PP_INC_IMPL_TAG157 158 +#define THRUST_PP_INC_IMPL_TAG158 159 +#define THRUST_PP_INC_IMPL_TAG159 160 +#define THRUST_PP_INC_IMPL_TAG160 161 +#define THRUST_PP_INC_IMPL_TAG161 162 +#define THRUST_PP_INC_IMPL_TAG162 163 +#define THRUST_PP_INC_IMPL_TAG163 164 +#define THRUST_PP_INC_IMPL_TAG164 165 +#define THRUST_PP_INC_IMPL_TAG165 166 +#define THRUST_PP_INC_IMPL_TAG166 167 +#define THRUST_PP_INC_IMPL_TAG167 168 +#define THRUST_PP_INC_IMPL_TAG168 169 +#define THRUST_PP_INC_IMPL_TAG169 170 +#define THRUST_PP_INC_IMPL_TAG170 171 +#define THRUST_PP_INC_IMPL_TAG171 172 +#define THRUST_PP_INC_IMPL_TAG172 173 +#define THRUST_PP_INC_IMPL_TAG173 174 +#define THRUST_PP_INC_IMPL_TAG174 175 +#define THRUST_PP_INC_IMPL_TAG175 176 +#define THRUST_PP_INC_IMPL_TAG176 177 +#define THRUST_PP_INC_IMPL_TAG177 178 +#define THRUST_PP_INC_IMPL_TAG178 179 +#define THRUST_PP_INC_IMPL_TAG179 180 +#define THRUST_PP_INC_IMPL_TAG180 181 +#define THRUST_PP_INC_IMPL_TAG181 182 +#define THRUST_PP_INC_IMPL_TAG182 183 +#define THRUST_PP_INC_IMPL_TAG183 184 +#define THRUST_PP_INC_IMPL_TAG184 185 +#define THRUST_PP_INC_IMPL_TAG185 186 +#define THRUST_PP_INC_IMPL_TAG186 187 +#define THRUST_PP_INC_IMPL_TAG187 188 +#define THRUST_PP_INC_IMPL_TAG188 189 +#define THRUST_PP_INC_IMPL_TAG189 190 +#define THRUST_PP_INC_IMPL_TAG190 191 +#define THRUST_PP_INC_IMPL_TAG191 192 +#define THRUST_PP_INC_IMPL_TAG192 193 +#define THRUST_PP_INC_IMPL_TAG193 194 +#define THRUST_PP_INC_IMPL_TAG194 195 +#define THRUST_PP_INC_IMPL_TAG195 196 +#define THRUST_PP_INC_IMPL_TAG196 197 +#define THRUST_PP_INC_IMPL_TAG197 198 +#define THRUST_PP_INC_IMPL_TAG198 199 +#define THRUST_PP_INC_IMPL_TAG199 200 +#define THRUST_PP_INC_IMPL_TAG200 201 +#define THRUST_PP_INC_IMPL_TAG201 202 +#define THRUST_PP_INC_IMPL_TAG202 203 +#define THRUST_PP_INC_IMPL_TAG203 204 +#define THRUST_PP_INC_IMPL_TAG204 205 +#define THRUST_PP_INC_IMPL_TAG205 206 +#define THRUST_PP_INC_IMPL_TAG206 207 +#define THRUST_PP_INC_IMPL_TAG207 208 +#define THRUST_PP_INC_IMPL_TAG208 209 +#define THRUST_PP_INC_IMPL_TAG209 210 +#define THRUST_PP_INC_IMPL_TAG210 211 +#define THRUST_PP_INC_IMPL_TAG211 212 +#define THRUST_PP_INC_IMPL_TAG212 213 +#define THRUST_PP_INC_IMPL_TAG213 214 +#define THRUST_PP_INC_IMPL_TAG214 215 +#define THRUST_PP_INC_IMPL_TAG215 216 +#define THRUST_PP_INC_IMPL_TAG216 217 +#define THRUST_PP_INC_IMPL_TAG217 218 +#define THRUST_PP_INC_IMPL_TAG218 219 +#define THRUST_PP_INC_IMPL_TAG219 220 +#define THRUST_PP_INC_IMPL_TAG220 221 +#define THRUST_PP_INC_IMPL_TAG221 222 +#define THRUST_PP_INC_IMPL_TAG222 223 +#define THRUST_PP_INC_IMPL_TAG223 224 +#define THRUST_PP_INC_IMPL_TAG224 225 +#define THRUST_PP_INC_IMPL_TAG225 226 +#define THRUST_PP_INC_IMPL_TAG226 227 +#define THRUST_PP_INC_IMPL_TAG227 228 +#define THRUST_PP_INC_IMPL_TAG228 229 +#define THRUST_PP_INC_IMPL_TAG229 230 +#define THRUST_PP_INC_IMPL_TAG230 231 +#define THRUST_PP_INC_IMPL_TAG231 232 +#define THRUST_PP_INC_IMPL_TAG232 233 +#define THRUST_PP_INC_IMPL_TAG233 234 +#define THRUST_PP_INC_IMPL_TAG234 235 +#define THRUST_PP_INC_IMPL_TAG235 236 +#define THRUST_PP_INC_IMPL_TAG236 237 +#define THRUST_PP_INC_IMPL_TAG237 238 +#define THRUST_PP_INC_IMPL_TAG238 239 +#define THRUST_PP_INC_IMPL_TAG239 240 +#define THRUST_PP_INC_IMPL_TAG240 241 +#define THRUST_PP_INC_IMPL_TAG241 242 +#define THRUST_PP_INC_IMPL_TAG242 243 +#define THRUST_PP_INC_IMPL_TAG243 244 +#define THRUST_PP_INC_IMPL_TAG244 245 +#define THRUST_PP_INC_IMPL_TAG245 246 +#define THRUST_PP_INC_IMPL_TAG246 247 +#define THRUST_PP_INC_IMPL_TAG247 248 +#define THRUST_PP_INC_IMPL_TAG248 249 +#define THRUST_PP_INC_IMPL_TAG249 250 +#define THRUST_PP_INC_IMPL_TAG250 251 +#define THRUST_PP_INC_IMPL_TAG251 252 +#define THRUST_PP_INC_IMPL_TAG252 253 +#define THRUST_PP_INC_IMPL_TAG253 254 +#define THRUST_PP_INC_IMPL_TAG254 255 +#define THRUST_PP_INC_IMPL_TAG255 256 +#define THRUST_PP_INC_IMPL_TAG256 256 + +#define THRUST_PP_DEC(x) THRUST_PP_DEC_IMPL0(x) + +#define THRUST_PP_DEC_IMPL0(x) THRUST_PP_CAT2(THRUST_PP_DEC_IMPL_TAG, x) + +#define THRUST_PP_DEC_IMPL_TAG0 0 +#define THRUST_PP_DEC_IMPL_TAG1 0 +#define THRUST_PP_DEC_IMPL_TAG2 1 +#define THRUST_PP_DEC_IMPL_TAG3 2 +#define THRUST_PP_DEC_IMPL_TAG4 3 +#define THRUST_PP_DEC_IMPL_TAG5 4 +#define THRUST_PP_DEC_IMPL_TAG6 5 +#define THRUST_PP_DEC_IMPL_TAG7 6 +#define THRUST_PP_DEC_IMPL_TAG8 7 +#define THRUST_PP_DEC_IMPL_TAG9 8 +#define THRUST_PP_DEC_IMPL_TAG10 9 +#define THRUST_PP_DEC_IMPL_TAG11 10 +#define THRUST_PP_DEC_IMPL_TAG12 11 +#define THRUST_PP_DEC_IMPL_TAG13 12 +#define THRUST_PP_DEC_IMPL_TAG14 13 +#define THRUST_PP_DEC_IMPL_TAG15 14 +#define THRUST_PP_DEC_IMPL_TAG16 15 +#define THRUST_PP_DEC_IMPL_TAG17 16 +#define THRUST_PP_DEC_IMPL_TAG18 17 +#define THRUST_PP_DEC_IMPL_TAG19 18 +#define THRUST_PP_DEC_IMPL_TAG20 19 +#define THRUST_PP_DEC_IMPL_TAG21 20 +#define THRUST_PP_DEC_IMPL_TAG22 21 +#define THRUST_PP_DEC_IMPL_TAG23 22 +#define THRUST_PP_DEC_IMPL_TAG24 23 +#define THRUST_PP_DEC_IMPL_TAG25 24 +#define THRUST_PP_DEC_IMPL_TAG26 25 +#define THRUST_PP_DEC_IMPL_TAG27 26 +#define THRUST_PP_DEC_IMPL_TAG28 27 +#define THRUST_PP_DEC_IMPL_TAG29 28 +#define THRUST_PP_DEC_IMPL_TAG30 29 +#define THRUST_PP_DEC_IMPL_TAG31 30 +#define THRUST_PP_DEC_IMPL_TAG32 31 +#define THRUST_PP_DEC_IMPL_TAG33 32 +#define THRUST_PP_DEC_IMPL_TAG34 33 +#define THRUST_PP_DEC_IMPL_TAG35 34 +#define THRUST_PP_DEC_IMPL_TAG36 35 +#define THRUST_PP_DEC_IMPL_TAG37 36 +#define THRUST_PP_DEC_IMPL_TAG38 37 +#define THRUST_PP_DEC_IMPL_TAG39 38 +#define THRUST_PP_DEC_IMPL_TAG40 39 +#define THRUST_PP_DEC_IMPL_TAG41 40 +#define THRUST_PP_DEC_IMPL_TAG42 41 +#define THRUST_PP_DEC_IMPL_TAG43 42 +#define THRUST_PP_DEC_IMPL_TAG44 43 +#define THRUST_PP_DEC_IMPL_TAG45 44 +#define THRUST_PP_DEC_IMPL_TAG46 45 +#define THRUST_PP_DEC_IMPL_TAG47 46 +#define THRUST_PP_DEC_IMPL_TAG48 47 +#define THRUST_PP_DEC_IMPL_TAG49 48 +#define THRUST_PP_DEC_IMPL_TAG50 49 +#define THRUST_PP_DEC_IMPL_TAG51 50 +#define THRUST_PP_DEC_IMPL_TAG52 51 +#define THRUST_PP_DEC_IMPL_TAG53 52 +#define THRUST_PP_DEC_IMPL_TAG54 53 +#define THRUST_PP_DEC_IMPL_TAG55 54 +#define THRUST_PP_DEC_IMPL_TAG56 55 +#define THRUST_PP_DEC_IMPL_TAG57 56 +#define THRUST_PP_DEC_IMPL_TAG58 57 +#define THRUST_PP_DEC_IMPL_TAG59 58 +#define THRUST_PP_DEC_IMPL_TAG60 59 +#define THRUST_PP_DEC_IMPL_TAG61 60 +#define THRUST_PP_DEC_IMPL_TAG62 61 +#define THRUST_PP_DEC_IMPL_TAG63 62 +#define THRUST_PP_DEC_IMPL_TAG64 63 +#define THRUST_PP_DEC_IMPL_TAG65 64 +#define THRUST_PP_DEC_IMPL_TAG66 65 +#define THRUST_PP_DEC_IMPL_TAG67 66 +#define THRUST_PP_DEC_IMPL_TAG68 67 +#define THRUST_PP_DEC_IMPL_TAG69 68 +#define THRUST_PP_DEC_IMPL_TAG70 69 +#define THRUST_PP_DEC_IMPL_TAG71 70 +#define THRUST_PP_DEC_IMPL_TAG72 71 +#define THRUST_PP_DEC_IMPL_TAG73 72 +#define THRUST_PP_DEC_IMPL_TAG74 73 +#define THRUST_PP_DEC_IMPL_TAG75 74 +#define THRUST_PP_DEC_IMPL_TAG76 75 +#define THRUST_PP_DEC_IMPL_TAG77 76 +#define THRUST_PP_DEC_IMPL_TAG78 77 +#define THRUST_PP_DEC_IMPL_TAG79 78 +#define THRUST_PP_DEC_IMPL_TAG80 79 +#define THRUST_PP_DEC_IMPL_TAG81 80 +#define THRUST_PP_DEC_IMPL_TAG82 81 +#define THRUST_PP_DEC_IMPL_TAG83 82 +#define THRUST_PP_DEC_IMPL_TAG84 83 +#define THRUST_PP_DEC_IMPL_TAG85 84 +#define THRUST_PP_DEC_IMPL_TAG86 85 +#define THRUST_PP_DEC_IMPL_TAG87 86 +#define THRUST_PP_DEC_IMPL_TAG88 87 +#define THRUST_PP_DEC_IMPL_TAG89 88 +#define THRUST_PP_DEC_IMPL_TAG90 89 +#define THRUST_PP_DEC_IMPL_TAG91 90 +#define THRUST_PP_DEC_IMPL_TAG92 91 +#define THRUST_PP_DEC_IMPL_TAG93 92 +#define THRUST_PP_DEC_IMPL_TAG94 93 +#define THRUST_PP_DEC_IMPL_TAG95 94 +#define THRUST_PP_DEC_IMPL_TAG96 95 +#define THRUST_PP_DEC_IMPL_TAG97 96 +#define THRUST_PP_DEC_IMPL_TAG98 97 +#define THRUST_PP_DEC_IMPL_TAG99 98 +#define THRUST_PP_DEC_IMPL_TAG100 99 +#define THRUST_PP_DEC_IMPL_TAG101 100 +#define THRUST_PP_DEC_IMPL_TAG102 101 +#define THRUST_PP_DEC_IMPL_TAG103 102 +#define THRUST_PP_DEC_IMPL_TAG104 103 +#define THRUST_PP_DEC_IMPL_TAG105 104 +#define THRUST_PP_DEC_IMPL_TAG106 105 +#define THRUST_PP_DEC_IMPL_TAG107 106 +#define THRUST_PP_DEC_IMPL_TAG108 107 +#define THRUST_PP_DEC_IMPL_TAG109 108 +#define THRUST_PP_DEC_IMPL_TAG110 109 +#define THRUST_PP_DEC_IMPL_TAG111 110 +#define THRUST_PP_DEC_IMPL_TAG112 111 +#define THRUST_PP_DEC_IMPL_TAG113 112 +#define THRUST_PP_DEC_IMPL_TAG114 113 +#define THRUST_PP_DEC_IMPL_TAG115 114 +#define THRUST_PP_DEC_IMPL_TAG116 115 +#define THRUST_PP_DEC_IMPL_TAG117 116 +#define THRUST_PP_DEC_IMPL_TAG118 117 +#define THRUST_PP_DEC_IMPL_TAG119 118 +#define THRUST_PP_DEC_IMPL_TAG120 119 +#define THRUST_PP_DEC_IMPL_TAG121 120 +#define THRUST_PP_DEC_IMPL_TAG122 121 +#define THRUST_PP_DEC_IMPL_TAG123 122 +#define THRUST_PP_DEC_IMPL_TAG124 123 +#define THRUST_PP_DEC_IMPL_TAG125 124 +#define THRUST_PP_DEC_IMPL_TAG126 125 +#define THRUST_PP_DEC_IMPL_TAG127 126 +#define THRUST_PP_DEC_IMPL_TAG128 127 +#define THRUST_PP_DEC_IMPL_TAG129 128 +#define THRUST_PP_DEC_IMPL_TAG130 129 +#define THRUST_PP_DEC_IMPL_TAG131 130 +#define THRUST_PP_DEC_IMPL_TAG132 131 +#define THRUST_PP_DEC_IMPL_TAG133 132 +#define THRUST_PP_DEC_IMPL_TAG134 133 +#define THRUST_PP_DEC_IMPL_TAG135 134 +#define THRUST_PP_DEC_IMPL_TAG136 135 +#define THRUST_PP_DEC_IMPL_TAG137 136 +#define THRUST_PP_DEC_IMPL_TAG138 137 +#define THRUST_PP_DEC_IMPL_TAG139 138 +#define THRUST_PP_DEC_IMPL_TAG140 139 +#define THRUST_PP_DEC_IMPL_TAG141 140 +#define THRUST_PP_DEC_IMPL_TAG142 141 +#define THRUST_PP_DEC_IMPL_TAG143 142 +#define THRUST_PP_DEC_IMPL_TAG144 143 +#define THRUST_PP_DEC_IMPL_TAG145 144 +#define THRUST_PP_DEC_IMPL_TAG146 145 +#define THRUST_PP_DEC_IMPL_TAG147 146 +#define THRUST_PP_DEC_IMPL_TAG148 147 +#define THRUST_PP_DEC_IMPL_TAG149 148 +#define THRUST_PP_DEC_IMPL_TAG150 149 +#define THRUST_PP_DEC_IMPL_TAG151 150 +#define THRUST_PP_DEC_IMPL_TAG152 151 +#define THRUST_PP_DEC_IMPL_TAG153 152 +#define THRUST_PP_DEC_IMPL_TAG154 153 +#define THRUST_PP_DEC_IMPL_TAG155 154 +#define THRUST_PP_DEC_IMPL_TAG156 155 +#define THRUST_PP_DEC_IMPL_TAG157 156 +#define THRUST_PP_DEC_IMPL_TAG158 157 +#define THRUST_PP_DEC_IMPL_TAG159 158 +#define THRUST_PP_DEC_IMPL_TAG160 159 +#define THRUST_PP_DEC_IMPL_TAG161 160 +#define THRUST_PP_DEC_IMPL_TAG162 161 +#define THRUST_PP_DEC_IMPL_TAG163 162 +#define THRUST_PP_DEC_IMPL_TAG164 163 +#define THRUST_PP_DEC_IMPL_TAG165 164 +#define THRUST_PP_DEC_IMPL_TAG166 165 +#define THRUST_PP_DEC_IMPL_TAG167 166 +#define THRUST_PP_DEC_IMPL_TAG168 167 +#define THRUST_PP_DEC_IMPL_TAG169 168 +#define THRUST_PP_DEC_IMPL_TAG170 169 +#define THRUST_PP_DEC_IMPL_TAG171 170 +#define THRUST_PP_DEC_IMPL_TAG172 171 +#define THRUST_PP_DEC_IMPL_TAG173 172 +#define THRUST_PP_DEC_IMPL_TAG174 173 +#define THRUST_PP_DEC_IMPL_TAG175 174 +#define THRUST_PP_DEC_IMPL_TAG176 175 +#define THRUST_PP_DEC_IMPL_TAG177 176 +#define THRUST_PP_DEC_IMPL_TAG178 177 +#define THRUST_PP_DEC_IMPL_TAG179 178 +#define THRUST_PP_DEC_IMPL_TAG180 179 +#define THRUST_PP_DEC_IMPL_TAG181 180 +#define THRUST_PP_DEC_IMPL_TAG182 181 +#define THRUST_PP_DEC_IMPL_TAG183 182 +#define THRUST_PP_DEC_IMPL_TAG184 183 +#define THRUST_PP_DEC_IMPL_TAG185 184 +#define THRUST_PP_DEC_IMPL_TAG186 185 +#define THRUST_PP_DEC_IMPL_TAG187 186 +#define THRUST_PP_DEC_IMPL_TAG188 187 +#define THRUST_PP_DEC_IMPL_TAG189 188 +#define THRUST_PP_DEC_IMPL_TAG190 189 +#define THRUST_PP_DEC_IMPL_TAG191 190 +#define THRUST_PP_DEC_IMPL_TAG192 191 +#define THRUST_PP_DEC_IMPL_TAG193 192 +#define THRUST_PP_DEC_IMPL_TAG194 193 +#define THRUST_PP_DEC_IMPL_TAG195 194 +#define THRUST_PP_DEC_IMPL_TAG196 195 +#define THRUST_PP_DEC_IMPL_TAG197 196 +#define THRUST_PP_DEC_IMPL_TAG198 197 +#define THRUST_PP_DEC_IMPL_TAG199 198 +#define THRUST_PP_DEC_IMPL_TAG200 199 +#define THRUST_PP_DEC_IMPL_TAG201 200 +#define THRUST_PP_DEC_IMPL_TAG202 201 +#define THRUST_PP_DEC_IMPL_TAG203 202 +#define THRUST_PP_DEC_IMPL_TAG204 203 +#define THRUST_PP_DEC_IMPL_TAG205 204 +#define THRUST_PP_DEC_IMPL_TAG206 205 +#define THRUST_PP_DEC_IMPL_TAG207 206 +#define THRUST_PP_DEC_IMPL_TAG208 207 +#define THRUST_PP_DEC_IMPL_TAG209 208 +#define THRUST_PP_DEC_IMPL_TAG210 209 +#define THRUST_PP_DEC_IMPL_TAG211 210 +#define THRUST_PP_DEC_IMPL_TAG212 211 +#define THRUST_PP_DEC_IMPL_TAG213 212 +#define THRUST_PP_DEC_IMPL_TAG214 213 +#define THRUST_PP_DEC_IMPL_TAG215 214 +#define THRUST_PP_DEC_IMPL_TAG216 215 +#define THRUST_PP_DEC_IMPL_TAG217 216 +#define THRUST_PP_DEC_IMPL_TAG218 217 +#define THRUST_PP_DEC_IMPL_TAG219 218 +#define THRUST_PP_DEC_IMPL_TAG220 219 +#define THRUST_PP_DEC_IMPL_TAG221 220 +#define THRUST_PP_DEC_IMPL_TAG222 221 +#define THRUST_PP_DEC_IMPL_TAG223 222 +#define THRUST_PP_DEC_IMPL_TAG224 223 +#define THRUST_PP_DEC_IMPL_TAG225 224 +#define THRUST_PP_DEC_IMPL_TAG226 225 +#define THRUST_PP_DEC_IMPL_TAG227 226 +#define THRUST_PP_DEC_IMPL_TAG228 227 +#define THRUST_PP_DEC_IMPL_TAG229 228 +#define THRUST_PP_DEC_IMPL_TAG230 229 +#define THRUST_PP_DEC_IMPL_TAG231 230 +#define THRUST_PP_DEC_IMPL_TAG232 231 +#define THRUST_PP_DEC_IMPL_TAG233 232 +#define THRUST_PP_DEC_IMPL_TAG234 233 +#define THRUST_PP_DEC_IMPL_TAG235 234 +#define THRUST_PP_DEC_IMPL_TAG236 235 +#define THRUST_PP_DEC_IMPL_TAG237 236 +#define THRUST_PP_DEC_IMPL_TAG238 237 +#define THRUST_PP_DEC_IMPL_TAG239 238 +#define THRUST_PP_DEC_IMPL_TAG240 239 +#define THRUST_PP_DEC_IMPL_TAG241 240 +#define THRUST_PP_DEC_IMPL_TAG242 241 +#define THRUST_PP_DEC_IMPL_TAG243 242 +#define THRUST_PP_DEC_IMPL_TAG244 243 +#define THRUST_PP_DEC_IMPL_TAG245 244 +#define THRUST_PP_DEC_IMPL_TAG246 245 +#define THRUST_PP_DEC_IMPL_TAG247 246 +#define THRUST_PP_DEC_IMPL_TAG248 247 +#define THRUST_PP_DEC_IMPL_TAG249 248 +#define THRUST_PP_DEC_IMPL_TAG250 249 +#define THRUST_PP_DEC_IMPL_TAG251 250 +#define THRUST_PP_DEC_IMPL_TAG252 251 +#define THRUST_PP_DEC_IMPL_TAG253 252 +#define THRUST_PP_DEC_IMPL_TAG254 253 +#define THRUST_PP_DEC_IMPL_TAG255 254 +#define THRUST_PP_DEC_IMPL_TAG256 255 +#define THRUST_PP_DEC_IMPL_TAG257 256 + +#define THRUST_PP_BOOL(x) THRUST_PP_BOOL_IMPL0(x) + +#define THRUST_PP_BOOL_IMPL0(x) THRUST_PP_CAT2(THRUST_PP_BOOL_IMPL_TAG, x) + +#define THRUST_PP_BOOL_IMPL_TAG0 0 +#define THRUST_PP_BOOL_IMPL_TAG1 1 +#define THRUST_PP_BOOL_IMPL_TAG2 1 +#define THRUST_PP_BOOL_IMPL_TAG3 1 +#define THRUST_PP_BOOL_IMPL_TAG4 1 +#define THRUST_PP_BOOL_IMPL_TAG5 1 +#define THRUST_PP_BOOL_IMPL_TAG6 1 +#define THRUST_PP_BOOL_IMPL_TAG7 1 +#define THRUST_PP_BOOL_IMPL_TAG8 1 +#define THRUST_PP_BOOL_IMPL_TAG9 1 +#define THRUST_PP_BOOL_IMPL_TAG10 1 +#define THRUST_PP_BOOL_IMPL_TAG11 1 +#define THRUST_PP_BOOL_IMPL_TAG12 1 +#define THRUST_PP_BOOL_IMPL_TAG13 1 +#define THRUST_PP_BOOL_IMPL_TAG14 1 +#define THRUST_PP_BOOL_IMPL_TAG15 1 +#define THRUST_PP_BOOL_IMPL_TAG16 1 +#define THRUST_PP_BOOL_IMPL_TAG17 1 +#define THRUST_PP_BOOL_IMPL_TAG18 1 +#define THRUST_PP_BOOL_IMPL_TAG19 1 +#define THRUST_PP_BOOL_IMPL_TAG20 1 +#define THRUST_PP_BOOL_IMPL_TAG21 1 +#define THRUST_PP_BOOL_IMPL_TAG22 1 +#define THRUST_PP_BOOL_IMPL_TAG23 1 +#define THRUST_PP_BOOL_IMPL_TAG24 1 +#define THRUST_PP_BOOL_IMPL_TAG25 1 +#define THRUST_PP_BOOL_IMPL_TAG26 1 +#define THRUST_PP_BOOL_IMPL_TAG27 1 +#define THRUST_PP_BOOL_IMPL_TAG28 1 +#define THRUST_PP_BOOL_IMPL_TAG29 1 +#define THRUST_PP_BOOL_IMPL_TAG30 1 +#define THRUST_PP_BOOL_IMPL_TAG31 1 +#define THRUST_PP_BOOL_IMPL_TAG32 1 +#define THRUST_PP_BOOL_IMPL_TAG33 1 +#define THRUST_PP_BOOL_IMPL_TAG34 1 +#define THRUST_PP_BOOL_IMPL_TAG35 1 +#define THRUST_PP_BOOL_IMPL_TAG36 1 +#define THRUST_PP_BOOL_IMPL_TAG37 1 +#define THRUST_PP_BOOL_IMPL_TAG38 1 +#define THRUST_PP_BOOL_IMPL_TAG39 1 +#define THRUST_PP_BOOL_IMPL_TAG40 1 +#define THRUST_PP_BOOL_IMPL_TAG41 1 +#define THRUST_PP_BOOL_IMPL_TAG42 1 +#define THRUST_PP_BOOL_IMPL_TAG43 1 +#define THRUST_PP_BOOL_IMPL_TAG44 1 +#define THRUST_PP_BOOL_IMPL_TAG45 1 +#define THRUST_PP_BOOL_IMPL_TAG46 1 +#define THRUST_PP_BOOL_IMPL_TAG47 1 +#define THRUST_PP_BOOL_IMPL_TAG48 1 +#define THRUST_PP_BOOL_IMPL_TAG49 1 +#define THRUST_PP_BOOL_IMPL_TAG50 1 +#define THRUST_PP_BOOL_IMPL_TAG51 1 +#define THRUST_PP_BOOL_IMPL_TAG52 1 +#define THRUST_PP_BOOL_IMPL_TAG53 1 +#define THRUST_PP_BOOL_IMPL_TAG54 1 +#define THRUST_PP_BOOL_IMPL_TAG55 1 +#define THRUST_PP_BOOL_IMPL_TAG56 1 +#define THRUST_PP_BOOL_IMPL_TAG57 1 +#define THRUST_PP_BOOL_IMPL_TAG58 1 +#define THRUST_PP_BOOL_IMPL_TAG59 1 +#define THRUST_PP_BOOL_IMPL_TAG60 1 +#define THRUST_PP_BOOL_IMPL_TAG61 1 +#define THRUST_PP_BOOL_IMPL_TAG62 1 +#define THRUST_PP_BOOL_IMPL_TAG63 1 +#define THRUST_PP_BOOL_IMPL_TAG64 1 +#define THRUST_PP_BOOL_IMPL_TAG65 1 +#define THRUST_PP_BOOL_IMPL_TAG66 1 +#define THRUST_PP_BOOL_IMPL_TAG67 1 +#define THRUST_PP_BOOL_IMPL_TAG68 1 +#define THRUST_PP_BOOL_IMPL_TAG69 1 +#define THRUST_PP_BOOL_IMPL_TAG70 1 +#define THRUST_PP_BOOL_IMPL_TAG71 1 +#define THRUST_PP_BOOL_IMPL_TAG72 1 +#define THRUST_PP_BOOL_IMPL_TAG73 1 +#define THRUST_PP_BOOL_IMPL_TAG74 1 +#define THRUST_PP_BOOL_IMPL_TAG75 1 +#define THRUST_PP_BOOL_IMPL_TAG76 1 +#define THRUST_PP_BOOL_IMPL_TAG77 1 +#define THRUST_PP_BOOL_IMPL_TAG78 1 +#define THRUST_PP_BOOL_IMPL_TAG79 1 +#define THRUST_PP_BOOL_IMPL_TAG80 1 +#define THRUST_PP_BOOL_IMPL_TAG81 1 +#define THRUST_PP_BOOL_IMPL_TAG82 1 +#define THRUST_PP_BOOL_IMPL_TAG83 1 +#define THRUST_PP_BOOL_IMPL_TAG84 1 +#define THRUST_PP_BOOL_IMPL_TAG85 1 +#define THRUST_PP_BOOL_IMPL_TAG86 1 +#define THRUST_PP_BOOL_IMPL_TAG87 1 +#define THRUST_PP_BOOL_IMPL_TAG88 1 +#define THRUST_PP_BOOL_IMPL_TAG89 1 +#define THRUST_PP_BOOL_IMPL_TAG90 1 +#define THRUST_PP_BOOL_IMPL_TAG91 1 +#define THRUST_PP_BOOL_IMPL_TAG92 1 +#define THRUST_PP_BOOL_IMPL_TAG93 1 +#define THRUST_PP_BOOL_IMPL_TAG94 1 +#define THRUST_PP_BOOL_IMPL_TAG95 1 +#define THRUST_PP_BOOL_IMPL_TAG96 1 +#define THRUST_PP_BOOL_IMPL_TAG97 1 +#define THRUST_PP_BOOL_IMPL_TAG98 1 +#define THRUST_PP_BOOL_IMPL_TAG99 1 +#define THRUST_PP_BOOL_IMPL_TAG100 1 +#define THRUST_PP_BOOL_IMPL_TAG101 1 +#define THRUST_PP_BOOL_IMPL_TAG102 1 +#define THRUST_PP_BOOL_IMPL_TAG103 1 +#define THRUST_PP_BOOL_IMPL_TAG104 1 +#define THRUST_PP_BOOL_IMPL_TAG105 1 +#define THRUST_PP_BOOL_IMPL_TAG106 1 +#define THRUST_PP_BOOL_IMPL_TAG107 1 +#define THRUST_PP_BOOL_IMPL_TAG108 1 +#define THRUST_PP_BOOL_IMPL_TAG109 1 +#define THRUST_PP_BOOL_IMPL_TAG110 1 +#define THRUST_PP_BOOL_IMPL_TAG111 1 +#define THRUST_PP_BOOL_IMPL_TAG112 1 +#define THRUST_PP_BOOL_IMPL_TAG113 1 +#define THRUST_PP_BOOL_IMPL_TAG114 1 +#define THRUST_PP_BOOL_IMPL_TAG115 1 +#define THRUST_PP_BOOL_IMPL_TAG116 1 +#define THRUST_PP_BOOL_IMPL_TAG117 1 +#define THRUST_PP_BOOL_IMPL_TAG118 1 +#define THRUST_PP_BOOL_IMPL_TAG119 1 +#define THRUST_PP_BOOL_IMPL_TAG120 1 +#define THRUST_PP_BOOL_IMPL_TAG121 1 +#define THRUST_PP_BOOL_IMPL_TAG122 1 +#define THRUST_PP_BOOL_IMPL_TAG123 1 +#define THRUST_PP_BOOL_IMPL_TAG124 1 +#define THRUST_PP_BOOL_IMPL_TAG125 1 +#define THRUST_PP_BOOL_IMPL_TAG126 1 +#define THRUST_PP_BOOL_IMPL_TAG127 1 +#define THRUST_PP_BOOL_IMPL_TAG128 1 +#define THRUST_PP_BOOL_IMPL_TAG129 1 +#define THRUST_PP_BOOL_IMPL_TAG130 1 +#define THRUST_PP_BOOL_IMPL_TAG131 1 +#define THRUST_PP_BOOL_IMPL_TAG132 1 +#define THRUST_PP_BOOL_IMPL_TAG133 1 +#define THRUST_PP_BOOL_IMPL_TAG134 1 +#define THRUST_PP_BOOL_IMPL_TAG135 1 +#define THRUST_PP_BOOL_IMPL_TAG136 1 +#define THRUST_PP_BOOL_IMPL_TAG137 1 +#define THRUST_PP_BOOL_IMPL_TAG138 1 +#define THRUST_PP_BOOL_IMPL_TAG139 1 +#define THRUST_PP_BOOL_IMPL_TAG140 1 +#define THRUST_PP_BOOL_IMPL_TAG141 1 +#define THRUST_PP_BOOL_IMPL_TAG142 1 +#define THRUST_PP_BOOL_IMPL_TAG143 1 +#define THRUST_PP_BOOL_IMPL_TAG144 1 +#define THRUST_PP_BOOL_IMPL_TAG145 1 +#define THRUST_PP_BOOL_IMPL_TAG146 1 +#define THRUST_PP_BOOL_IMPL_TAG147 1 +#define THRUST_PP_BOOL_IMPL_TAG148 1 +#define THRUST_PP_BOOL_IMPL_TAG149 1 +#define THRUST_PP_BOOL_IMPL_TAG150 1 +#define THRUST_PP_BOOL_IMPL_TAG151 1 +#define THRUST_PP_BOOL_IMPL_TAG152 1 +#define THRUST_PP_BOOL_IMPL_TAG153 1 +#define THRUST_PP_BOOL_IMPL_TAG154 1 +#define THRUST_PP_BOOL_IMPL_TAG155 1 +#define THRUST_PP_BOOL_IMPL_TAG156 1 +#define THRUST_PP_BOOL_IMPL_TAG157 1 +#define THRUST_PP_BOOL_IMPL_TAG158 1 +#define THRUST_PP_BOOL_IMPL_TAG159 1 +#define THRUST_PP_BOOL_IMPL_TAG160 1 +#define THRUST_PP_BOOL_IMPL_TAG161 1 +#define THRUST_PP_BOOL_IMPL_TAG162 1 +#define THRUST_PP_BOOL_IMPL_TAG163 1 +#define THRUST_PP_BOOL_IMPL_TAG164 1 +#define THRUST_PP_BOOL_IMPL_TAG165 1 +#define THRUST_PP_BOOL_IMPL_TAG166 1 +#define THRUST_PP_BOOL_IMPL_TAG167 1 +#define THRUST_PP_BOOL_IMPL_TAG168 1 +#define THRUST_PP_BOOL_IMPL_TAG169 1 +#define THRUST_PP_BOOL_IMPL_TAG170 1 +#define THRUST_PP_BOOL_IMPL_TAG171 1 +#define THRUST_PP_BOOL_IMPL_TAG172 1 +#define THRUST_PP_BOOL_IMPL_TAG173 1 +#define THRUST_PP_BOOL_IMPL_TAG174 1 +#define THRUST_PP_BOOL_IMPL_TAG175 1 +#define THRUST_PP_BOOL_IMPL_TAG176 1 +#define THRUST_PP_BOOL_IMPL_TAG177 1 +#define THRUST_PP_BOOL_IMPL_TAG178 1 +#define THRUST_PP_BOOL_IMPL_TAG179 1 +#define THRUST_PP_BOOL_IMPL_TAG180 1 +#define THRUST_PP_BOOL_IMPL_TAG181 1 +#define THRUST_PP_BOOL_IMPL_TAG182 1 +#define THRUST_PP_BOOL_IMPL_TAG183 1 +#define THRUST_PP_BOOL_IMPL_TAG184 1 +#define THRUST_PP_BOOL_IMPL_TAG185 1 +#define THRUST_PP_BOOL_IMPL_TAG186 1 +#define THRUST_PP_BOOL_IMPL_TAG187 1 +#define THRUST_PP_BOOL_IMPL_TAG188 1 +#define THRUST_PP_BOOL_IMPL_TAG189 1 +#define THRUST_PP_BOOL_IMPL_TAG190 1 +#define THRUST_PP_BOOL_IMPL_TAG191 1 +#define THRUST_PP_BOOL_IMPL_TAG192 1 +#define THRUST_PP_BOOL_IMPL_TAG193 1 +#define THRUST_PP_BOOL_IMPL_TAG194 1 +#define THRUST_PP_BOOL_IMPL_TAG195 1 +#define THRUST_PP_BOOL_IMPL_TAG196 1 +#define THRUST_PP_BOOL_IMPL_TAG197 1 +#define THRUST_PP_BOOL_IMPL_TAG198 1 +#define THRUST_PP_BOOL_IMPL_TAG199 1 +#define THRUST_PP_BOOL_IMPL_TAG200 1 +#define THRUST_PP_BOOL_IMPL_TAG201 1 +#define THRUST_PP_BOOL_IMPL_TAG202 1 +#define THRUST_PP_BOOL_IMPL_TAG203 1 +#define THRUST_PP_BOOL_IMPL_TAG204 1 +#define THRUST_PP_BOOL_IMPL_TAG205 1 +#define THRUST_PP_BOOL_IMPL_TAG206 1 +#define THRUST_PP_BOOL_IMPL_TAG207 1 +#define THRUST_PP_BOOL_IMPL_TAG208 1 +#define THRUST_PP_BOOL_IMPL_TAG209 1 +#define THRUST_PP_BOOL_IMPL_TAG210 1 +#define THRUST_PP_BOOL_IMPL_TAG211 1 +#define THRUST_PP_BOOL_IMPL_TAG212 1 +#define THRUST_PP_BOOL_IMPL_TAG213 1 +#define THRUST_PP_BOOL_IMPL_TAG214 1 +#define THRUST_PP_BOOL_IMPL_TAG215 1 +#define THRUST_PP_BOOL_IMPL_TAG216 1 +#define THRUST_PP_BOOL_IMPL_TAG217 1 +#define THRUST_PP_BOOL_IMPL_TAG218 1 +#define THRUST_PP_BOOL_IMPL_TAG219 1 +#define THRUST_PP_BOOL_IMPL_TAG220 1 +#define THRUST_PP_BOOL_IMPL_TAG221 1 +#define THRUST_PP_BOOL_IMPL_TAG222 1 +#define THRUST_PP_BOOL_IMPL_TAG223 1 +#define THRUST_PP_BOOL_IMPL_TAG224 1 +#define THRUST_PP_BOOL_IMPL_TAG225 1 +#define THRUST_PP_BOOL_IMPL_TAG226 1 +#define THRUST_PP_BOOL_IMPL_TAG227 1 +#define THRUST_PP_BOOL_IMPL_TAG228 1 +#define THRUST_PP_BOOL_IMPL_TAG229 1 +#define THRUST_PP_BOOL_IMPL_TAG230 1 +#define THRUST_PP_BOOL_IMPL_TAG231 1 +#define THRUST_PP_BOOL_IMPL_TAG232 1 +#define THRUST_PP_BOOL_IMPL_TAG233 1 +#define THRUST_PP_BOOL_IMPL_TAG234 1 +#define THRUST_PP_BOOL_IMPL_TAG235 1 +#define THRUST_PP_BOOL_IMPL_TAG236 1 +#define THRUST_PP_BOOL_IMPL_TAG237 1 +#define THRUST_PP_BOOL_IMPL_TAG238 1 +#define THRUST_PP_BOOL_IMPL_TAG239 1 +#define THRUST_PP_BOOL_IMPL_TAG240 1 +#define THRUST_PP_BOOL_IMPL_TAG241 1 +#define THRUST_PP_BOOL_IMPL_TAG242 1 +#define THRUST_PP_BOOL_IMPL_TAG243 1 +#define THRUST_PP_BOOL_IMPL_TAG244 1 +#define THRUST_PP_BOOL_IMPL_TAG245 1 +#define THRUST_PP_BOOL_IMPL_TAG246 1 +#define THRUST_PP_BOOL_IMPL_TAG247 1 +#define THRUST_PP_BOOL_IMPL_TAG248 1 +#define THRUST_PP_BOOL_IMPL_TAG249 1 +#define THRUST_PP_BOOL_IMPL_TAG250 1 +#define THRUST_PP_BOOL_IMPL_TAG251 1 +#define THRUST_PP_BOOL_IMPL_TAG252 1 +#define THRUST_PP_BOOL_IMPL_TAG253 1 +#define THRUST_PP_BOOL_IMPL_TAG254 1 +#define THRUST_PP_BOOL_IMPL_TAG255 1 +#define THRUST_PP_BOOL_IMPL_TAG256 1 + +/////////////////////////////////////////////////////////////////////////////// + +#define THRUST_PP_IIF(bit, t, f) THRUST_PP_IIF_IMPL0(bit, t, f) + +#if defined(_MSC_VER) + #define THRUST_PP_IIF_IMPL0(bit, t, f) \ + THRUST_PP_IIF_IMPL1(THRUST_PP_CAT2(THRUST_PP_IIF_IMPL_TAG, bit(t, f))) \ + /**/ + #define THRUST_PP_IIF_IMPL1(id) id +#else + #define THRUST_PP_IIF_IMPL0(bit, t, f) \ + THRUST_PP_CAT2(THRUST_PP_IIF_IMPL_TAG, bit(t, f)) + /**/ +#endif + +#define THRUST_PP_IIF_IMPL_TAG0(t, f) f +#define THRUST_PP_IIF_IMPL_TAG1(t, f) t + +#if defined(__EDG__) + #define THRUST_PP_IF(cond, t, f) THRUST_PP_IF_IMPL0(cond, t, f) + #define THRUST_PP_IF_IMPL0(cond, t, f) \ + THRUST_PP_IIF(THRUST_PP_BOOL(cond), t, f) \ + /**/ +#else + #define THRUST_PP_IF(cond, t, f) THRUST_PP_IIF(THRUST_PP_BOOL(cond), t, f) +#endif + +/// \def THRUST_COMMA_IF(cond) +/// \brief If \a cond is true, expands to a comma. Otherwise, expands to nothing. +/// +/// \par Example: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << THRUST_PP_STRINGIZE(THRUST_COMMA_IF(0)) << "\n" +/// << THRUST_PP_STRINGIZE(THRUST_COMMA_IF(1)) << "\n"; +/// } +/// \endcode +/// +/// The above code expands to: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << "" << "\n" +/// << "," << "\n"; +/// } +/// \endcode +/// +#if defined(__EDG__) + #define THRUST_PP_COMMA_IF(cond) THRUST_PP_COMMA_IF_IMPL0(cond) + #define THRUST_PP_COMMA_IF_IMPL0(cond) \ + THRUST_PP_IF(cond, THRUST_PP_COMMA, THRUST_PP_EMPTY)() \ + /**/ +#else + #define THRUST_PP_COMMA_IF(cond) \ + THRUST_PP_IF(cond, THRUST_PP_COMMA, THRUST_PP_EMPTY)() \ + /**/ +#endif + +/////////////////////////////////////////////////////////////////////////////// + +// http://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments + +#define THRUST_PP_64TH_ARG( \ + _1, _2, _3, _4, _5, _6, _7, _8, _9,_10,_11,_12,_13,_14,_15,_16 \ + , _17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32 \ + , _33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48 \ + , _49,_50,_51,_52,_53,_54,_55,_56,_57,_58,_59,_60,_61,_62,_63, N \ + , ... \ + ) N \ + /**/ + +#define THRUST_PP_HAS_COMMA(...) \ + THRUST_PP_EXPAND(THRUST_PP_64TH_ARG( \ + __VA_ARGS__ \ + , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 \ + , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 \ + , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 \ + , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 \ + )) \ + /**/ + +#define THRUST_PP_TRIGGER_PAREN(...) , + +#define THRUST_PP_IS_VARIADIC_NULLARY(...) \ + THRUST_PP_IS_VARIADIC_NULLARY_IMPL0( \ + /* Test if there is just one argument, eventually an empty one. */ \ + THRUST_PP_HAS_COMMA(__VA_ARGS__), \ + /* Test if THRUST_PP_TRIGGER_PAREN together with the argument adds a */ \ + /* comma. */ \ + THRUST_PP_HAS_COMMA(THRUST_PP_TRIGGER_PAREN __VA_ARGS__), \ + /* Test if the argument together with a parenthesis adds a comma. */ \ + THRUST_PP_HAS_COMMA(__VA_ARGS__ (/*empty*/)), \ + /* Test if placing it between THRUST_PP_TRIGGER_PAREN and the */ \ + /* parenthesis adds a comma. */ \ + THRUST_PP_HAS_COMMA(THRUST_PP_TRIGGER_PAREN __VA_ARGS__ (/*empty*/)) \ + ) \ + /**/ + +#define THRUST_PP_IS_VARIADIC_NULLARY_IMPL0(_0, _1, _2, _3) \ + THRUST_PP_HAS_COMMA( \ + THRUST_PP_CAT5(THRUST_PP_IS_VARIADIC_NULLARY_IMPL_TAG, _0, _1, _2, _3) \ + ) \ + +#define THRUST_PP_IS_VARIADIC_NULLARY_IMPL_TAG0001 , + +/////////////////////////////////////////////////////////////////////////////// + +/// \def THRUST_PP_ARITY(...) +/// \brief Returns the number of arguments that it was called with. Must be +/// called with less than 64 arguments. +/// +/// \par Example: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << THRUST_PP_ARITY() << "\n" +/// << THRUST_PP_ARITY(x) << "\n" +/// << THRUST_PP_ARITY(x, y) << "\n" +/// << THRUST_PP_ARITY(x, y, z) << "\n"; +/// } +/// \endcode +/// +/// The above code expands to: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << 0 << "\n" +/// << 1 << "\n" +/// << 2 << "\n" +/// << 3 << "\n"; +/// } +/// \endcode +/// +#define THRUST_PP_ARITY(...) \ + THRUST_PP_EXPAND( \ + THRUST_PP_IF( \ + THRUST_PP_IS_VARIADIC_NULLARY(__VA_ARGS__) \ + , 0 \ + , THRUST_PP_64TH_ARG( \ + __VA_ARGS__ \ + , 63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48 \ + , 47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32 \ + , 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16 \ + , 15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 \ + ) \ + ) \ + ) \ + /**/ + +/// \def THRUST_PP_DISPATCH(basename, ...) +/// \brief Expands to basenameN(...), where N is the +/// number of variadic arguments that \a THRUST_PP_DISPATCH was called +/// with. This macro can be used to implement "macro overloading". +/// +/// \par Example: +/// +/// \code +/// #include +/// #include +/// +/// #define PLUS(...) THRUST_PP_DISPATCH(PLUS, __VA_ARGS__) +/// #define PLUS0() 0 +/// #define PLUS1(x) x +/// #define PLUS2(x, y) x + y +/// #define PLUS3(x, y, z) x + y + z +/// +/// int main() +/// { +/// std::cout << PLUS() << "\n" +/// << PLUS(1) << "\n" +/// << PLUS(1, 2) << "\n" +/// << PLUS(1, 2, 3) << "\n"; +/// } +/// \endcode +/// +/// The above code expands to: +/// +/// \code +/// #include +/// #include +/// +/// int main() +/// { +/// std::cout << 0 << "\n" +/// << 1 << "\n" +/// << 1 + 2 << "\n" +/// << 1 + 2 + 3 << "\n"; +/// } +/// \endcode +/// +#define THRUST_PP_DISPATCH(basename, ...) \ + THRUST_PP_EXPAND( \ + THRUST_PP_CAT2( \ + basename, \ + THRUST_PP_ARITY(__VA_ARGS__) \ + )(__VA_ARGS__) \ + ) \ + /**/ + +/////////////////////////////////////////////////////////////////////////////// + +/// \def THRUST_CURRENT_FUNCTION +/// \brief The name of the current function as a string. +/// +#if defined(__GNUC__) \ + || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) \ + || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__) + #define THRUST_CURRENT_FUNCTION __PRETTY_FUNCTION__ +#elif defined(__DMC__) && (__DMC__ >= 0x810) + #define THRUST_CURRENT_FUNCTION __PRETTY_FUNCTION__ +#elif defined(__FUNCSIG__) + #define THRUST_CURRENT_FUNCTION __FUNCSIG__ +#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) \ + || (defined(__IBMCTHRUST_PP__) && (__IBMCTHRUST_PP__ >= 500)) + #define THRUST_CURRENT_FUNCTION __FUNCTION__ +#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550) + #define THRUST_CURRENT_FUNCTION __FUNC__ +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) + #define THRUST_CURRENT_FUNCTION __func__ +#elif defined(__cplusplus) && (__cplusplus >= 201103) + #define THRUST_CURRENT_FUNCTION __func__ +#else + #define THRUST_CURRENT_FUNCTION "(unknown)" +#endif + +/////////////////////////////////////////////////////////////////////////////// + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/range/head_flags.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/range/head_flags.h new file mode 100644 index 0000000000000000000000000000000000000000..b755840c991654a8baeadbe374d09f120029ae14 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/range/head_flags.h @@ -0,0 +1,229 @@ +/* + * 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 +#include +#include +#include +#include +#include + + +THRUST_NAMESPACE_BEGIN +namespace detail +{ + + +template::type>, + typename ValueType = bool, + typename IndexType = typename thrust::iterator_difference::type> + class head_flags_with_init +{ + typedef typename thrust::iterator_value::type init_type; + + // XXX WAR cudafe issue + //private: + public: + struct head_flag_functor + { + BinaryPredicate binary_pred; // this must be the first member for performance reasons + init_type init; + IndexType n; + + typedef ValueType result_type; + + __host__ __device__ + head_flag_functor(init_type init, IndexType n) + : binary_pred(), init(init), n(n) + {} + + __host__ __device__ + head_flag_functor(init_type init, IndexType n, BinaryPredicate binary_pred) + : binary_pred(binary_pred), init(init), n(n) + {} + + template + __host__ __device__ __thrust_forceinline__ + result_type operator()(const Tuple &t) + { + const IndexType i = thrust::get<0>(t); + + if(i == 0) + { + return !binary_pred(init, thrust::get<1>(t)); + } + + return !binary_pred(thrust::get<1>(t), thrust::get<2>(t)); + } + }; + + typedef thrust::counting_iterator counting_iterator; + + public: + typedef thrust::transform_iterator< + head_flag_functor, + thrust::zip_iterator > + > iterator; + + __thrust_exec_check_disable__ + __host__ __device__ + head_flags_with_init(RandomAccessIterator first, RandomAccessIterator last, init_type init) + : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator(0), first, first - 1)), + head_flag_functor(init, last - first))), + m_end(m_begin + (last - first)) + {} + + __thrust_exec_check_disable__ + __host__ __device__ + head_flags_with_init(RandomAccessIterator first, RandomAccessIterator last, init_type init, BinaryPredicate binary_pred) + : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator(0), first, first - 1)), + head_flag_functor(init, last - first, binary_pred))), + m_end(m_begin + (last - first)) + {} + + __host__ __device__ + iterator begin() const + { + return m_begin; + } + + __host__ __device__ + iterator end() const + { + return m_end; + } + + template + __host__ __device__ + typename iterator::reference operator[](OtherIndex i) + { + return *(begin() + i); + } + + private: + iterator m_begin, m_end; +}; + + + +template::type>, + typename ValueType = bool, + typename IndexType = typename thrust::iterator_difference::type> + class head_flags +{ + // XXX WAR cudafe issue + //private: + public: + struct head_flag_functor + { + BinaryPredicate binary_pred; // this must be the first member for performance reasons + IndexType n; + + typedef ValueType result_type; + + __host__ __device__ + head_flag_functor(IndexType n) + : binary_pred(), n(n) + {} + + __host__ __device__ + head_flag_functor(IndexType n, BinaryPredicate binary_pred) + : binary_pred(binary_pred), n(n) + {} + + template + __host__ __device__ __thrust_forceinline__ + result_type operator()(const Tuple &t) + { + const IndexType i = thrust::get<0>(t); + + // note that we do not dereference the tuple's 2nd element when i <= 0 + // and therefore do not dereference a bad location at the boundary + return (i == 0 || !binary_pred(thrust::get<1>(t), thrust::get<2>(t))); + } + }; + + typedef thrust::counting_iterator counting_iterator; + + public: + typedef thrust::transform_iterator< + head_flag_functor, + thrust::zip_iterator > + > iterator; + + __host__ __device__ + head_flags(RandomAccessIterator first, RandomAccessIterator last) + : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator(0), first, first - 1)), + head_flag_functor(last - first))), + m_end(m_begin + (last - first)) + {} + + __host__ __device__ + head_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred) + : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator(0), first, first - 1)), + head_flag_functor(last - first, binary_pred))), + m_end(m_begin + (last - first)) + {} + + __host__ __device__ + iterator begin() const + { + return m_begin; + } + + __host__ __device__ + iterator end() const + { + return m_end; + } + + template + __host__ __device__ + typename iterator::reference operator[](OtherIndex i) + { + return *(begin() + i); + } + + private: + iterator m_begin, m_end; +}; + + +template +__host__ __device__ +head_flags + make_head_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred) +{ + return head_flags(first, last, binary_pred); +} + + +template +__host__ __device__ +head_flags + make_head_flags(RandomAccessIterator first, RandomAccessIterator last) +{ + return head_flags(first, last); +} + + +} // end detail +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/raw_pointer_cast.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/raw_pointer_cast.h new file mode 100644 index 0000000000000000000000000000000000000000..53a77861ef0eee454da56b90cf4fc4d4955f974c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/raw_pointer_cast.h @@ -0,0 +1,50 @@ +/* + * 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 +#include + +THRUST_NAMESPACE_BEGIN + +template +__host__ __device__ +typename thrust::detail::pointer_traits::raw_pointer +raw_pointer_cast(Pointer ptr) +{ + return thrust::detail::pointer_traits::get(ptr); +} + +template +__host__ __device__ +ToPointer +reinterpret_pointer_cast(FromPointer ptr) +{ + typedef typename thrust::detail::pointer_element::type to_element; + return ToPointer(reinterpret_cast(thrust::raw_pointer_cast(ptr))); +} + +template +__host__ __device__ +ToPointer +static_pointer_cast(FromPointer ptr) +{ + typedef typename thrust::detail::pointer_element::type to_element; + return ToPointer(static_cast(thrust::raw_pointer_cast(ptr))); +} + +THRUST_NAMESPACE_END diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/reference.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/reference.h new file mode 100644 index 0000000000000000000000000000000000000000..5cc13625dafe81ab42ef23a3ab02902c564432b3 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/reference.h @@ -0,0 +1,518 @@ +/* + * 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. + */ + +/*! \file + * \brief A pointer to a variable which resides in memory associated with a + * system. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ +template +struct is_wrapped_reference; +} + +/*! \p reference acts as a reference-like wrapper for an object residing in + * memory that a \p pointer refers to. + */ +template +class reference +{ +private: + using derived_type = typename std::conditional< + std::is_same::value, reference, Derived + >::type; + +public: + using pointer = Pointer; + using value_type = typename thrust::remove_cvref::type; + + reference(reference const&) = default; + + reference(reference&&) = default; + + /*! Construct a \p reference from another \p reference whose pointer type is + * convertible to \p pointer. After this \p reference is constructed, it + * shall refer to the same object as \p other. + * + * \tparam OtherElement The element type of the other \p reference. + * \tparam OtherPointer The pointer type of the other \p reference. + * \tparam OtherDerived The derived type of the other \p reference. + * \param other A \p reference to copy from. + */ + template + __host__ __device__ + reference( + reference const& other + /*! \cond + */ + , typename std::enable_if< + std::is_convertible< + typename reference::pointer + , pointer + >::value + >::type* = nullptr + /*! \endcond + */ + ) + : ptr(other.ptr) + {} + + /*! Construct a \p reference that refers to an object pointed to by the given + * \p pointer. After this \p reference is constructed, it shall refer to the + * object pointed to by \p ptr. + * + * \param ptr A \p pointer to construct from. + */ + __host__ __device__ + explicit reference(pointer const& p) : ptr(p) {} + + /*! Assign the object referred to \p other to the object referred to by + * this \p reference. + * + * \param other The other \p reference to assign from. + * + * \return *this. + */ + __host__ __device__ + derived_type& operator=(reference const& other) + { + assign_from(&other); + return derived(); + } + + /*! Assign the object referred to by this \p reference with the object + * referred to by another \p reference whose pointer type is convertible to + * \p pointer. + * + * \tparam OtherElement The element type of the other \p reference. + * \tparam OtherPointer The pointer type of the other \p reference. + * \tparam OtherDerived The derived type of the other \p reference. + * \param other The other \p reference to assign from. + * + * \return *this. + */ + template + __host__ __device__ + /*! \cond + */ + typename std::enable_if< + std::is_convertible< + typename reference::pointer + , pointer + >::value, + /*! \endcond + */ + derived_type& + /*! \cond + */ + >::type + /*! \endcond + */ + operator=(reference const& other) + { + assign_from(&other); + return derived(); + } + + /*! Assign \p rhs to the object referred to by this \p tagged_reference. + * + * \param rhs The \p value_type to assign from. + * + * \return *this. + */ + __host__ __device__ + derived_type& operator=(value_type const& rhs) + { + assign_from(&rhs); + return derived(); + } + + /*! Exchanges the value of the object referred to by this \p tagged_reference + * with the object referred to by \p other. + * + * \param other The \p tagged_reference to swap with. + */ + __host__ __device__ + void swap(derived_type& other) + { + // Avoid default-constructing a system; instead, just use a null pointer + // for dispatch. This assumes that `get_value` will not access any system + // state. + typename thrust::iterator_system::type* system = nullptr; + swap(system, other); + } + + __host__ __device__ pointer operator&() const { return ptr; } + + // This is inherently hazardous, as it discards the strong type information + // about what system the object is on. + __host__ __device__ operator value_type() const + { + // Avoid default-constructing a system; instead, just use a null pointer + // for dispatch. This assumes that `get_value` will not access any system + // state. + typename thrust::iterator_system::type* system = nullptr; + return convert_to_value_type(system); + } + + __host__ __device__ + derived_type& operator++() + { + // Sadly, this has to make a copy. The only mechanism we have for + // modifying the value, which may be in memory inaccessible to this + // system, is to get a copy of it, modify the copy, and then update it. + value_type tmp = *this; + ++tmp; + *this = tmp; + return derived(); + } + + __host__ __device__ + value_type operator++(int) + { + value_type tmp = *this; + value_type result = tmp++; + *this = std::move(tmp); + return result; + } + + derived_type& operator--() + { + // Sadly, this has to make a copy. The only mechanism we have for + // modifying the value, which may be in memory inaccessible to this + // system, is to get a copy of it, modify the copy, and then update it. + value_type tmp = *this; + --tmp; + *this = std::move(tmp); + return derived(); + } + + value_type operator--(int) + { + value_type tmp = *this; + value_type result = tmp--; + *this = std::move(tmp); + return derived(); + } + + __host__ __device__ + derived_type& operator+=(value_type const& rhs) + { + value_type tmp = *this; + tmp += rhs; + *this = tmp; + return derived(); + } + + derived_type& operator-=(value_type const& rhs) + { + value_type tmp = *this; + tmp -= rhs; + *this = tmp; + return derived(); + } + + derived_type& operator*=(value_type const& rhs) + { + value_type tmp = *this; + tmp *= rhs; + *this = tmp; + return derived(); + } + + derived_type& operator/=(value_type const& rhs) + { + value_type tmp = *this; + tmp /= rhs; + *this = tmp; + return derived(); + } + + derived_type& operator%=(value_type const& rhs) + { + value_type tmp = *this; + tmp %= rhs; + *this = tmp; + return derived(); + } + + derived_type& operator<<=(value_type const& rhs) + { + value_type tmp = *this; + tmp <<= rhs; + *this = tmp; + return derived(); + } + + derived_type& operator>>=(value_type const& rhs) + { + value_type tmp = *this; + tmp >>= rhs; + *this = tmp; + return derived(); + } + + derived_type& operator&=(value_type const& rhs) + { + value_type tmp = *this; + tmp &= rhs; + *this = tmp; + return derived(); + } + + derived_type& operator|=(value_type const& rhs) + { + value_type tmp = *this; + tmp |= rhs; + *this = tmp; + return derived(); + } + + derived_type& operator^=(value_type const& rhs) + { + value_type tmp = *this; + tmp ^= rhs; + *this = tmp; + return derived(); + } + +private: + pointer const ptr; + + // `thrust::detail::is_wrapped_reference` is a trait that indicates whether + // a type is a fancy reference. It detects such types by loooking for a + // nested `wrapped_reference_hint` type. + struct wrapped_reference_hint {}; + template + friend struct thrust::detail::is_wrapped_reference; + + template + friend class reference; + + __host__ __device__ + derived_type& derived() { return static_cast(*this); } + + template + __host__ __device__ + value_type convert_to_value_type(System* system) const + { + using thrust::system::detail::generic::select_system; + return strip_const_get_value(select_system(*system)); + } + + template + __host__ __device__ + value_type strip_const_get_value(System const& system) const + { + System &non_const_system = const_cast(system); + + using thrust::system::detail::generic::get_value; + return get_value(thrust::detail::derived_cast(non_const_system), ptr); + } + + template + __host__ __device__ + void assign_from(System0* system0, System1* system1, OtherPointer src) + { + using thrust::system::detail::generic::select_system; + strip_const_assign_value(select_system(*system0, *system1), src); + } + + template + __host__ __device__ + void assign_from(OtherPointer src) + { + // Avoid default-constructing systems; instead, just use a null pointer + // for dispatch. This assumes that `get_value` will not access any system + // state. + typename thrust::iterator_system::type* system0 = nullptr; + typename thrust::iterator_system::type* system1 = nullptr; + assign_from(system0, system1, src); + } + + template + __host__ __device__ + void strip_const_assign_value(System const& system, OtherPointer src) + { + System& non_const_system = const_cast(system); + + using thrust::system::detail::generic::assign_value; + assign_value(thrust::detail::derived_cast(non_const_system), ptr, src); + } + + template + __host__ __device__ + void swap(System* system, derived_type& other) + { + using thrust::system::detail::generic::select_system; + using thrust::system::detail::generic::iter_swap; + + iter_swap(select_system(*system, *system), ptr, other.ptr); + } +}; + +template +class reference {}; + +template +class reference {}; + +template < + typename Element, typename Pointer, typename Derived +, typename CharT, typename Traits +> +std::basic_ostream& operator<<( + std::basic_ostream&os +, reference const& r +) { + using value_type = typename reference::value_type; + return os << static_cast(r); +} + +template +class tagged_reference; + +/*! \p tagged_reference acts as a reference-like wrapper for an object residing + * in memory associated with system \p Tag that a \p pointer refers to. + */ +template +class tagged_reference + : public thrust::reference< + Element + , thrust::pointer> + , tagged_reference + > +{ +private: + using base_type = thrust::reference< + Element + , thrust::pointer> + , tagged_reference + >; + +public: + using value_type = typename base_type::value_type; + using pointer = typename base_type::pointer; + + tagged_reference(tagged_reference const&) = default; + + tagged_reference(tagged_reference&&) = default; + + /*! Construct a \p tagged_reference from another \p tagged_reference whose + * pointer type is convertible to \p pointer. After this \p tagged_reference + * is constructed, it shall refer to the same object as \p other. + * + * \tparam OtherElement The element type of the other \p tagged_reference. + * \tparam OtherTag The tag type of the other \p tagged_reference. + * \param other A \p tagged_reference to copy from. + */ + template + __host__ __device__ + tagged_reference(tagged_reference const& other) + : base_type(other) + {} + + /*! Construct a \p tagged_reference that refers to an object pointed to by + * the given \p pointer. After this \p tagged_reference is constructed, it + * shall refer to the object pointed to by \p ptr. + * + * \param ptr A \p pointer to construct from. + */ + __host__ __device__ explicit tagged_reference(pointer const& p) + : base_type(p) + {} + + /*! Assign the object referred to \p other to the object referred to by + * this \p tagged_reference. + * + * \param other The other \p tagged_reference to assign from. + * + * \return *this. + */ + __host__ __device__ + tagged_reference& operator=(tagged_reference const& other) + { + return base_type::operator=(other); + } + + /*! Assign the object referred to by this \p tagged_reference with the object + * referred to by another \p tagged_reference whose pointer type is + * convertible to \p pointer. + * + * \tparam OtherElement The element type of the other \p tagged_reference. + * \tparam OtherTag The tag type of the other \p tagged_reference. + * \param other The other \p tagged_reference to assign from. + * + * \return *this. + */ + template + __host__ __device__ + tagged_reference& + operator=(tagged_reference const& other) + { + return base_type::operator=(other); + } + + /*! Assign \p rhs to the object referred to by this \p tagged_reference. + * + * \param rhs The \p value_type to assign from. + * + * \return *this. + */ + __host__ __device__ + tagged_reference& operator=(value_type const& rhs) + { + return base_type::operator=(rhs); + } +}; + +template +class tagged_reference {}; + +template +class tagged_reference {}; + +/*! Exchanges the values of two objects referred to by \p tagged_reference. + * + * \param x The first \p tagged_reference of interest. + * \param y The second \p tagged_reference of interest. + */ +template +__host__ __device__ +void swap(tagged_reference& x, tagged_reference& y) +{ + x.swap(y); +} + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/reference_forward_declaration.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/reference_forward_declaration.h new file mode 100644 index 0000000000000000000000000000000000000000..6f2b999497abe289b43af6ef828f8151a927ec96 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/reference_forward_declaration.h @@ -0,0 +1,28 @@ +/* + * Copyright 2008-2020 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +THRUST_NAMESPACE_BEGIN + +template +class reference; + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/reverse.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/reverse.inl new file mode 100644 index 0000000000000000000000000000000000000000..dc316d18f52f75d0d9bc5c0a70c37be0fce5b113 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/reverse.inl @@ -0,0 +1,87 @@ +/* + * 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 +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + + +__thrust_exec_check_disable__ +template +__host__ __device__ + void reverse(const thrust::detail::execution_policy_base &exec, + BidirectionalIterator first, + BidirectionalIterator last) +{ + using thrust::system::detail::generic::reverse; + return reverse(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last); +} // end reverse() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + OutputIterator reverse_copy(const thrust::detail::execution_policy_base &exec, + BidirectionalIterator first, + BidirectionalIterator last, + OutputIterator result) +{ + using thrust::system::detail::generic::reverse_copy; + return reverse_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result); +} // end reverse_copy() + + +template + void reverse(BidirectionalIterator first, + BidirectionalIterator last) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::reverse(select_system(system), first, last); +} // end reverse() + + +template + OutputIterator reverse_copy(BidirectionalIterator first, + BidirectionalIterator last, + OutputIterator result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + + System1 system1; + System2 system2; + + return thrust::reverse_copy(select_system(system1,system2), first, last, result); +} // end reverse_copy() + + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/sequence.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/sequence.inl new file mode 100644 index 0000000000000000000000000000000000000000..ffc9b968b97d3747a0b3ef16996c125505acdde0 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/sequence.inl @@ -0,0 +1,114 @@ +/* + * 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 +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + + +__thrust_exec_check_disable__ +template +__host__ __device__ + void sequence(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last) +{ + using thrust::system::detail::generic::sequence; + return sequence(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last); +} // end sequence() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + void sequence(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + T init) +{ + using thrust::system::detail::generic::sequence; + return sequence(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, init); +} // end sequence() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + void sequence(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + T init, + T step) +{ + using thrust::system::detail::generic::sequence; + return sequence(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, init, step); +} // end sequence() + + +template + void sequence(ForwardIterator first, + ForwardIterator last) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::sequence(select_system(system), first, last); +} // end sequence() + + +template + void sequence(ForwardIterator first, + ForwardIterator last, + T init) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::sequence(select_system(system), first, last, init); +} // end sequence() + + +template + void sequence(ForwardIterator first, + ForwardIterator last, + T init, + T step) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::sequence(select_system(system), first, last, init, step); +} // end sequence() + + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/set_operations.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/set_operations.inl new file mode 100644 index 0000000000000000000000000000000000000000..7915f7b3eab6c76c39d5208a181c08a53646596c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/set_operations.inl @@ -0,0 +1,865 @@ +/* + * 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 +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator set_difference(const thrust::detail::execution_policy_base &exec, + InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result) +{ + using thrust::system::detail::generic::set_difference; + return set_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result); +} // end set_difference() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator set_difference(const thrust::detail::execution_policy_base &exec, + InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result, + StrictWeakCompare comp) +{ + using thrust::system::detail::generic::set_difference; + return set_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp); +} // end set_difference() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair + set_difference_by_key(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result) +{ + using thrust::system::detail::generic::set_difference_by_key; + return set_difference_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result); +} // end set_difference_by_key() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair + set_difference_by_key(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result, + StrictWeakCompare comp) +{ + using thrust::system::detail::generic::set_difference_by_key; + return set_difference_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp); +} // end set_difference_by_key() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator set_intersection(const thrust::detail::execution_policy_base &exec, + InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result) +{ + using thrust::system::detail::generic::set_intersection; + return set_intersection(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result); +} // end set_intersection() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator set_intersection(const thrust::detail::execution_policy_base &exec, + InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result, + StrictWeakCompare comp) +{ + using thrust::system::detail::generic::set_intersection; + return set_intersection(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp); +} // end set_intersection() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair + set_intersection_by_key(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + OutputIterator1 keys_result, + OutputIterator2 values_result) +{ + using thrust::system::detail::generic::set_intersection_by_key; + return set_intersection_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, keys_result, values_result); +} // end set_intersection_by_key() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair + set_intersection_by_key(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + OutputIterator1 keys_result, + OutputIterator2 values_result, + StrictWeakCompare comp) +{ + using thrust::system::detail::generic::set_intersection_by_key; + return set_intersection_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, keys_result, values_result, comp); +} // end set_intersection_by_key() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator set_symmetric_difference(const thrust::detail::execution_policy_base &exec, + InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result) +{ + using thrust::system::detail::generic::set_symmetric_difference; + return set_symmetric_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result); +} // end set_symmetric_difference() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator set_symmetric_difference(const thrust::detail::execution_policy_base &exec, + InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result, + StrictWeakCompare comp) +{ + using thrust::system::detail::generic::set_symmetric_difference; + return set_symmetric_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp); +} // end set_symmetric_difference() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair + set_symmetric_difference_by_key(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result) +{ + using thrust::system::detail::generic::set_symmetric_difference_by_key; + return set_symmetric_difference_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result); +} // end set_symmetric_difference_by_key() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair + set_symmetric_difference_by_key(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result, + StrictWeakCompare comp) +{ + using thrust::system::detail::generic::set_symmetric_difference_by_key; + return set_symmetric_difference_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp); +} // end set_symmetric_difference_by_key() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator set_union(const thrust::detail::execution_policy_base &exec, + InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result) +{ + using thrust::system::detail::generic::set_union; + return set_union(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result); +} // end set_union() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator set_union(const thrust::detail::execution_policy_base &exec, + InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result, + StrictWeakCompare comp) +{ + using thrust::system::detail::generic::set_union; + return set_union(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp); +} // end set_union() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair + set_union_by_key(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result) +{ + using thrust::system::detail::generic::set_union_by_key; + return set_union_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result); +} // end set_union_by_key() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +thrust::pair + set_union_by_key(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result, + StrictWeakCompare comp) +{ + using thrust::system::detail::generic::set_union_by_key; + return set_union_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp); +} // end set_union_by_key() + + +template + OutputIterator set_difference(InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::set_difference(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp); +} // end set_difference() + + +template + OutputIterator set_difference(InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::set_difference(select_system(system1,system2,system3), first1, last1, first2, last2, result); +} // end set_difference() + + +template + thrust::pair + set_difference_by_key(InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + typedef typename thrust::iterator_system::type System5; + typedef typename thrust::iterator_system::type System6; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + System5 system5; + System6 system6; + + return thrust::set_difference_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp); +} // end set_difference_by_key() + + +template + thrust::pair + set_difference_by_key(InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + typedef typename thrust::iterator_system::type System5; + typedef typename thrust::iterator_system::type System6; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + System5 system5; + System6 system6; + + return thrust::set_difference_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result); +} // end set_difference_by_key() + + +template + OutputIterator set_intersection(InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::set_intersection(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp); +} // end set_intersection() + + +template + OutputIterator set_intersection(InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::set_intersection(select_system(system1,system2,system3), first1, last1, first2, last2, result); +} // end set_intersection() + + +template + thrust::pair + set_intersection_by_key(InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + OutputIterator1 keys_result, + OutputIterator2 values_result, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + typedef typename thrust::iterator_system::type System5; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + System5 system5; + + return thrust::set_intersection_by_key(select_system(system1,system2,system3,system4,system5), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, keys_result, values_result, comp); +} // end set_intersection_by_key() + + +template + thrust::pair + set_intersection_by_key(InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + OutputIterator1 keys_result, + OutputIterator2 values_result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + typedef typename thrust::iterator_system::type System5; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + System5 system5; + + return thrust::set_intersection_by_key(select_system(system1,system2,system3,system4,system5), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, keys_result, values_result); +} // end set_intersection_by_key() + + +template + OutputIterator set_symmetric_difference(InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::set_symmetric_difference(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp); +} // end set_symmetric_difference() + + +template + OutputIterator set_symmetric_difference(InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::set_symmetric_difference(select_system(system1,system2,system3), first1, last1, first2, last2, result); +} // end set_symmetric_difference() + + +template + thrust::pair + set_symmetric_difference_by_key(InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + typedef typename thrust::iterator_system::type System5; + typedef typename thrust::iterator_system::type System6; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + System5 system5; + System6 system6; + + return thrust::set_symmetric_difference_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp); +} // end set_symmetric_difference_by_key() + + +template + thrust::pair + set_symmetric_difference_by_key(InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + typedef typename thrust::iterator_system::type System5; + typedef typename thrust::iterator_system::type System6; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + System5 system5; + System6 system6; + + return thrust::set_symmetric_difference_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result); +} // end set_symmetric_difference_by_key() + + +template + OutputIterator set_union(InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::set_union(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp); +} // end set_union() + + +template + OutputIterator set_union(InputIterator1 first1, + InputIterator1 last1, + InputIterator2 first2, + InputIterator2 last2, + OutputIterator result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + + System1 system1; + System2 system2; + System3 system3; + + return thrust::set_union(select_system(system1,system2,system3), first1, last1, first2, last2, result); +} // end set_union() + + +template + thrust::pair + set_union_by_key(InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result, + StrictWeakOrdering comp) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + typedef typename thrust::iterator_system::type System5; + typedef typename thrust::iterator_system::type System6; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + System5 system5; + System6 system6; + + return thrust::set_union_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp); +} // end set_union_by_key() + + +template + thrust::pair + set_union_by_key(InputIterator1 keys_first1, + InputIterator1 keys_last1, + InputIterator2 keys_first2, + InputIterator2 keys_last2, + InputIterator3 values_first1, + InputIterator4 values_first2, + OutputIterator1 keys_result, + OutputIterator2 values_result) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + typedef typename thrust::iterator_system::type System5; + typedef typename thrust::iterator_system::type System6; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + System5 system5; + System6 system6; + + return thrust::set_union_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result); +} // end set_union_by_key() + + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/swap.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/swap.h new file mode 100644 index 0000000000000000000000000000000000000000..305750f8ae7887058e4612f590313cb7c0fa962c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/swap.h @@ -0,0 +1,35 @@ +/* + * 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_NAMESPACE_BEGIN + +__thrust_exec_check_disable__ +template +__host__ __device__ +inline void swap(Assignable1 &a, Assignable2 &b) +{ + Assignable1 temp = a; + a = b; + b = temp; +} // end swap() + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/swap.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/swap.inl new file mode 100644 index 0000000000000000000000000000000000000000..196c34f41ee48a4870c409c4957dbdbc6a7b375e --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/swap.inl @@ -0,0 +1,22 @@ +/* + * 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 +#include +#include + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/swap_ranges.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/swap_ranges.inl new file mode 100644 index 0000000000000000000000000000000000000000..1f35c1ff3183df5b4ffe9692903896582d8139a1 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/swap_ranges.inl @@ -0,0 +1,64 @@ +/* + * 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 + +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + + +__thrust_exec_check_disable__ +template +__host__ __device__ + ForwardIterator2 swap_ranges(const thrust::detail::execution_policy_base &exec, + ForwardIterator1 first1, + ForwardIterator1 last1, + ForwardIterator2 first2) +{ + using thrust::system::detail::generic::swap_ranges; + return swap_ranges(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2); +} // end swap_ranges() + + +template + ForwardIterator2 swap_ranges(ForwardIterator1 first1, + ForwardIterator1 last1, + ForwardIterator2 first2) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + + System1 system1; + System2 system2; + + return thrust::swap_ranges(select_system(system1,system2), first1, last1, first2); +} // end swap_ranges() + + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/temporary_array.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/temporary_array.h new file mode 100644 index 0000000000000000000000000000000000000000..cf4bc7d2d2e27e5aeccb1c9bd5bcf734887db09e --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/temporary_array.h @@ -0,0 +1,181 @@ +/* + * 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. + */ + +/*! \file temporary_array.h + * \brief Container-like class temporary storage inside algorithms. + */ + +#pragma once + +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ + +// Forward declare temporary_array, as it's used by the CUDA copy backend, which +// is included in contiguous_storage's definition. +template + class temporary_array; + +} // end detail +THRUST_NAMESPACE_END + +#include +#include +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ + + +template + class temporary_array + : public contiguous_storage< + T, + no_throw_allocator< + temporary_allocator + > + > +{ + private: + typedef contiguous_storage< + T, + no_throw_allocator< + temporary_allocator + > + > super_t; + + // to help out the constructor + typedef no_throw_allocator > alloc_type; + + public: + typedef typename super_t::size_type size_type; + + __host__ __device__ + temporary_array(thrust::execution_policy &system); + + __host__ __device__ + temporary_array(thrust::execution_policy &system, size_type n); + + // provide a kill-switch to explicitly avoid initialization + __host__ __device__ + temporary_array(int uninit, thrust::execution_policy &system, size_type n); + + template + __host__ __device__ + temporary_array(thrust::execution_policy &system, + InputIterator first, + size_type n); + + template + __host__ __device__ + temporary_array(thrust::execution_policy &system, + thrust::execution_policy &input_system, + InputIterator first, + size_type n); + + template + __host__ __device__ + temporary_array(thrust::execution_policy &system, + InputIterator first, + InputIterator last); + + template + __host__ __device__ + temporary_array(thrust::execution_policy &system, + thrust::execution_policy &input_system, + InputIterator first, + InputIterator last); + + __host__ __device__ + ~temporary_array(); +}; // end temporary_array + + +// XXX eliminate this when we do ranges for real +template + class tagged_iterator_range +{ + public: + typedef thrust::detail::tagged_iterator iterator; + + template + tagged_iterator_range(const Ignored1 &, const Ignored2 &, Iterator first, Iterator last) + : m_begin(first), + m_end(last) + {} + + iterator begin(void) const { return m_begin; } + iterator end(void) const { return m_end; } + + private: + iterator m_begin, m_end; +}; + + +// if FromSystem is convertible to ToSystem, then just make a shallow +// copy of the range. else, use a temporary_array +// note that the resulting iterator is explicitly tagged with ToSystem either way +template + struct move_to_system_base + : public eval_if< + is_convertible< + FromSystem, + ToSystem + >::value, + identity_< + tagged_iterator_range + >, + identity_< + temporary_array< + typename thrust::iterator_value::type, + ToSystem + > + > + > +{}; + + +template + class move_to_system + : public move_to_system_base< + Iterator, + FromSystem, + ToSystem + >::type +{ + typedef typename move_to_system_base::type super_t; + + public: + move_to_system(thrust::execution_policy &from_system, + thrust::execution_policy &to_system, + Iterator first, + Iterator last) + : super_t(to_system, from_system, first, last) {} +}; + + +} // end detail +THRUST_NAMESPACE_END + +#include + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/temporary_buffer.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/temporary_buffer.h new file mode 100644 index 0000000000000000000000000000000000000000..be95e7180f5de84627cc2c9671aa56eee4f84d64 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/temporary_buffer.h @@ -0,0 +1,75 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN +namespace detail +{ + + +template +__host__ __device__ + thrust::pair, typename thrust::pointer::difference_type> + down_cast_pair(Pair p) +{ + // XXX should use a hypothetical thrust::static_pointer_cast here + thrust::pointer ptr = thrust::pointer(static_cast(thrust::raw_pointer_cast(p.first))); + + typedef thrust::pair, typename thrust::pointer::difference_type> result_type; + return result_type(ptr, p.second); +} // end down_cast_pair() + + +} // end detail + + +__thrust_exec_check_disable__ +template +__host__ __device__ + thrust::pair, typename thrust::pointer::difference_type> + get_temporary_buffer(const thrust::detail::execution_policy_base &exec, typename thrust::pointer::difference_type n) +{ + using thrust::detail::get_temporary_buffer; // execute_with_allocator + using thrust::system::detail::generic::get_temporary_buffer; + + return thrust::detail::down_cast_pair(get_temporary_buffer(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), n)); +} // end get_temporary_buffer() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + void return_temporary_buffer(const thrust::detail::execution_policy_base &exec, Pointer p, std::ptrdiff_t n) +{ + using thrust::detail::return_temporary_buffer; // execute_with_allocator + using thrust::system::detail::generic::return_temporary_buffer; + + return return_temporary_buffer(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), p, n); +} // end return_temporary_buffer() + + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/transform_scan.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/transform_scan.inl new file mode 100644 index 0000000000000000000000000000000000000000..957001cefd6db76bff13b359fe76668728f61940 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/transform_scan.inl @@ -0,0 +1,117 @@ +/* + * 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 + +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + + +__thrust_exec_check_disable__ +template +__host__ __device__ + OutputIterator transform_inclusive_scan(const thrust::detail::execution_policy_base &exec, + InputIterator first, + InputIterator last, + OutputIterator result, + UnaryFunction unary_op, + AssociativeOperator binary_op) +{ + using thrust::system::detail::generic::transform_inclusive_scan; + return transform_inclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, unary_op, binary_op); +} // end transform_inclusive_scan() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + OutputIterator transform_exclusive_scan(const thrust::detail::execution_policy_base &exec, + InputIterator first, + InputIterator last, + OutputIterator result, + UnaryFunction unary_op, + T init, + AssociativeOperator binary_op) +{ + using thrust::system::detail::generic::transform_exclusive_scan; + return transform_exclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, unary_op, init, binary_op); +} // end transform_exclusive_scan() + + +template + OutputIterator transform_inclusive_scan(InputIterator first, + InputIterator last, + OutputIterator result, + UnaryFunction unary_op, + BinaryFunction binary_op) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + + System1 system1; + System2 system2; + + return thrust::transform_inclusive_scan(select_system(system1,system2), first, last, result, unary_op, binary_op); +} // end transform_inclusive_scan() + + +template + OutputIterator transform_exclusive_scan(InputIterator first, + InputIterator last, + OutputIterator result, + UnaryFunction unary_op, + T init, + AssociativeOperator binary_op) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + + System1 system1; + System2 system2; + + return thrust::transform_exclusive_scan(select_system(system1,system2), first, last, result, unary_op, init, binary_op); +} // end transform_exclusive_scan() + + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/tuple_transform.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/tuple_transform.h new file mode 100644 index 0000000000000000000000000000000000000000..1011d5179e31e1fe15a38431eccff1f3d714888a --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/tuple_transform.h @@ -0,0 +1,84 @@ +/* + * 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 + +#include +#include + +THRUST_NAMESPACE_BEGIN + +namespace detail +{ + +template class UnaryMetaFunction, + typename UnaryFunction, + typename IndexSequence = thrust::make_index_sequence::value>> + struct tuple_transform_functor; + + +template class UnaryMetaFunction, + typename UnaryFunction, + size_t... Is> + struct tuple_transform_functor> +{ + static __host__ + typename tuple_meta_transform::type + do_it_on_the_host(const Tuple &t, UnaryFunction f) + { + typedef typename tuple_meta_transform::type XfrmTuple; + + return XfrmTuple(f(thrust::get(t))...); + } + + static __host__ __device__ + typename tuple_meta_transform::type + do_it_on_the_host_or_device(const Tuple &t, UnaryFunction f) + { + typedef typename tuple_meta_transform::type XfrmTuple; + + return XfrmTuple(f(thrust::get(t))...); + } +}; + + +template class UnaryMetaFunction, + typename Tuple, + typename UnaryFunction> +typename tuple_meta_transform::type +tuple_host_transform(const Tuple &t, UnaryFunction f) +{ + return tuple_transform_functor::do_it_on_the_host(t,f); +} + +template class UnaryMetaFunction, + typename Tuple, + typename UnaryFunction> +typename tuple_meta_transform::type +__host__ __device__ +tuple_host_device_transform(const Tuple &t, UnaryFunction f) +{ + return tuple_transform_functor::do_it_on_the_host_or_device(t,f); +} + +} // end detail + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/type_deduction.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/type_deduction.h new file mode 100644 index 0000000000000000000000000000000000000000..6f240711d0a132166fdb0dee4de775854d9bec2b --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/type_deduction.h @@ -0,0 +1,90 @@ +// Copyright (c) 2018 NVIDIA Corporation +// (Bryce Adelstein Lelbach ) +// Copyright (c) 2013-2018 Eric Niebler (`THRUST_RETURNS`, etc) +// Copyright (c) 2016-2018 Casey Carter (`THRUST_RETURNS`, etc) +// +// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt) + +#pragma once + +#include +#include + +#if THRUST_CPP_DIALECT >= 2011 + +#include + +#include +#include + +/////////////////////////////////////////////////////////////////////////////// + +/// \def THRUST_FWD(x) +/// \brief Performs universal forwarding of a universal reference. +/// +#define THRUST_FWD(x) ::std::forward(x) + +/// \def THRUST_MVCAP(x) +/// \brief Capture `x` into a lambda by moving. +/// +#define THRUST_MVCAP(x) x = ::std::move(x) + +/// \def THRUST_RETOF(invocable, ...) +/// \brief Expands to the type returned by invoking an instance of the invocable +/// type \a invocable with parameters of type \c __VA_ARGS__. Must +/// be called with 1 or fewer parameters to the invocable. +/// +#define THRUST_RETOF(...) THRUST_PP_DISPATCH(THRUST_RETOF, __VA_ARGS__) +#define THRUST_RETOF1(C) decltype(::std::declval()()) +#define THRUST_RETOF2(C, V) decltype(::std::declval()(::std::declval())) + +/// \def THRUST_RETURNS(...) +/// \brief Expands to a function definition that returns the expression +/// \c __VA_ARGS__. +/// +#define THRUST_RETURNS(...) \ + noexcept(noexcept(__VA_ARGS__)) \ + { return (__VA_ARGS__); } \ + /**/ + +/// \def THRUST_DECLTYPE_RETURNS(...) +/// \brief Expands to a function definition, including a trailing returning +/// type, that returns the expression \c __VA_ARGS__. +/// +// Trailing return types seem to confuse Doxygen, and cause it to interpret +// parts of the function's body as new function signatures. +#if defined(THRUST_DOXYGEN) + #define THRUST_DECLTYPE_RETURNS(...) \ + { return (__VA_ARGS__); } \ + /**/ +#else + #define THRUST_DECLTYPE_RETURNS(...) \ + noexcept(noexcept(__VA_ARGS__)) \ + -> decltype(__VA_ARGS__) \ + { return (__VA_ARGS__); } \ + /**/ +#endif + +/// \def THRUST_DECLTYPE_RETURNS_WITH_SFINAE_CONDITION(condition, ...) +/// \brief Expands to a function definition, including a trailing returning +/// type, that returns the expression \c __VA_ARGS__. It shall only +/// participate in overload resolution if \c condition is \c true. +/// +// Trailing return types seem to confuse Doxygen, and cause it to interpret +// parts of the function's body as new function signatures. +#if defined(THRUST_DOXYGEN) + #define THRUST_DECLTYPE_RETURNS(...) \ + { return (__VA_ARGS__); } \ + /**/ +#else + #define THRUST_DECLTYPE_RETURNS_WITH_SFINAE_CONDITION(condition, ...) \ + noexcept(noexcept(__VA_ARGS__)) \ + -> typename std::enable_if::type \ + { return (__VA_ARGS__); } \ + /**/ +#endif + +/////////////////////////////////////////////////////////////////////////////// + +#endif // THRUST_CPP_DIALECT >= 2011 + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/unique.inl b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/unique.inl new file mode 100644 index 0000000000000000000000000000000000000000..ac5475f0238da598ccd20997c04e02b3bb4747b1 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/unique.inl @@ -0,0 +1,393 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include + +THRUST_NAMESPACE_BEGIN + + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator unique(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last) +{ + using thrust::system::detail::generic::unique; + return unique(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last); +} // end unique() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +ForwardIterator unique(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::unique; + return unique(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, binary_pred); +} // end unique() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator unique_copy(const thrust::detail::execution_policy_base &exec, + InputIterator first, + InputIterator last, + OutputIterator output) +{ + using thrust::system::detail::generic::unique_copy; + return unique_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, output); +} // end unique_copy() + + +__thrust_exec_check_disable__ +template +__host__ __device__ +OutputIterator unique_copy(const thrust::detail::execution_policy_base &exec, + InputIterator first, + InputIterator last, + OutputIterator output, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::unique_copy; + return unique_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, output, binary_pred); +} // end unique_copy() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + thrust::pair + unique_by_key(const thrust::detail::execution_policy_base &exec, + ForwardIterator1 keys_first, + ForwardIterator1 keys_last, + ForwardIterator2 values_first) +{ + using thrust::system::detail::generic::unique_by_key; + return unique_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first); +} // end unique_by_key() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + thrust::pair + unique_by_key(const thrust::detail::execution_policy_base &exec, + ForwardIterator1 keys_first, + ForwardIterator1 keys_last, + ForwardIterator2 values_first, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::unique_by_key; + return unique_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, binary_pred); +} // end unique_by_key() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + thrust::pair + unique_by_key_copy(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first, + InputIterator1 keys_last, + InputIterator2 values_first, + OutputIterator1 keys_output, + OutputIterator2 values_output) +{ + using thrust::system::detail::generic::unique_by_key_copy; + return unique_by_key_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output); +} // end unique_by_key_copy() + + +__thrust_exec_check_disable__ +template +__host__ __device__ + thrust::pair + unique_by_key_copy(const thrust::detail::execution_policy_base &exec, + InputIterator1 keys_first, + InputIterator1 keys_last, + InputIterator2 values_first, + OutputIterator1 keys_output, + OutputIterator2 values_output, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::unique_by_key_copy; + return unique_by_key_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output, binary_pred); +} // end unique_by_key_copy() + + +template + ForwardIterator unique(ForwardIterator first, + ForwardIterator last) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::unique(select_system(system), first, last); +} // end unique() + + +template + ForwardIterator unique(ForwardIterator first, + ForwardIterator last, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::unique(select_system(system), first, last, binary_pred); +} // end unique() + + +template + OutputIterator unique_copy(InputIterator first, + InputIterator last, + OutputIterator output) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + + System1 system1; + System2 system2; + + return thrust::unique_copy(select_system(system1,system2), first, last, output); +} // end unique_copy() + + +template + OutputIterator unique_copy(InputIterator first, + InputIterator last, + OutputIterator output, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + + System1 system1; + System2 system2; + + return thrust::unique_copy(select_system(system1,system2), first, last, output, binary_pred); +} // end unique_copy() + + +template + thrust::pair + unique_by_key(ForwardIterator1 keys_first, + ForwardIterator1 keys_last, + ForwardIterator2 values_first) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + + System1 system1; + System2 system2; + + return thrust::unique_by_key(select_system(system1,system2), keys_first, keys_last, values_first); +} // end unique_by_key() + + +template + thrust::pair + unique_by_key(ForwardIterator1 keys_first, + ForwardIterator1 keys_last, + ForwardIterator2 values_first, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + + System1 system1; + System2 system2; + + return thrust::unique_by_key(select_system(system1,system2), keys_first, keys_last, values_first, binary_pred); +} // end unique_by_key() + + +template + thrust::pair + unique_by_key_copy(InputIterator1 keys_first, + InputIterator1 keys_last, + InputIterator2 values_first, + OutputIterator1 keys_output, + OutputIterator2 values_output) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + + return thrust::unique_by_key_copy(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output); +} // end unique_by_key_copy() + + +template + thrust::pair + unique_by_key_copy(InputIterator1 keys_first, + InputIterator1 keys_last, + InputIterator2 values_first, + OutputIterator1 keys_output, + OutputIterator2 values_output, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System1; + typedef typename thrust::iterator_system::type System2; + typedef typename thrust::iterator_system::type System3; + typedef typename thrust::iterator_system::type System4; + + System1 system1; + System2 system2; + System3 system3; + System4 system4; + + return thrust::unique_by_key_copy(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output, binary_pred); +} // end unique_by_key_copy() + +__thrust_exec_check_disable__ +template +__host__ __device__ + typename thrust::iterator_traits::difference_type + unique_count(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::unique_count; + return unique_count(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, binary_pred); +} // end unique_count() + +__thrust_exec_check_disable__ +template +__host__ __device__ + typename thrust::iterator_traits::difference_type + unique_count(const thrust::detail::execution_policy_base &exec, + ForwardIterator first, + ForwardIterator last) +{ + using thrust::system::detail::generic::unique_count; + return unique_count(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last); +} // end unique_count() + +__thrust_exec_check_disable__ +template +__host__ __device__ + typename thrust::iterator_traits::difference_type + unique_count(ForwardIterator first, + ForwardIterator last, + BinaryPredicate binary_pred) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::unique_count(select_system(system), first, last, binary_pred); +} // end unique_count() + +__thrust_exec_check_disable__ +template +__host__ __device__ + typename thrust::iterator_traits::difference_type + unique_count(ForwardIterator first, + ForwardIterator last) +{ + using thrust::system::detail::generic::select_system; + + typedef typename thrust::iterator_system::type System; + + System system; + + return thrust::unique_count(select_system(system), first, last); +} // end unique_count() + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/use_default.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/use_default.h new file mode 100644 index 0000000000000000000000000000000000000000..f25b6274c4475db78807a520bfe72994b517f62c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/use_default.h @@ -0,0 +1,26 @@ +/* + * 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_NAMESPACE_BEGIN + +struct use_default {}; + +THRUST_NAMESPACE_END + diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/util/align.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/util/align.h new file mode 100644 index 0000000000000000000000000000000000000000..a3aa75bfe411204115713a600863d447ebfafc1d --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/util/align.h @@ -0,0 +1,60 @@ +/* + * 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 + +#include + +// functions to handle memory alignment + +THRUST_NAMESPACE_BEGIN +namespace detail +{ +namespace util +{ + + +template +__host__ __device__ +T *align_up(T * ptr, detail::uintptr_t bytes) +{ + return (T *) ( bytes * (((detail::uintptr_t) ptr + (bytes - 1)) / bytes) ); +} + + +template +__host__ __device__ +T *align_down(T * ptr, detail::uintptr_t bytes) +{ + return (T *) ( bytes * (detail::uintptr_t(ptr) / bytes) ); +} + + +template +__host__ __device__ +bool is_aligned(T * ptr, detail::uintptr_t bytes = sizeof(T)) +{ + return detail::uintptr_t(ptr) % bytes == 0; +} + + +} // end namespace util +} // end namespace detail +THRUST_NAMESPACE_END +