diff --git a/.gitattributes b/.gitattributes index 2c2e28df5c25b6e6c034748e08feabb24ebb9ec5..3f2bac6279e58acce1776d409dc5d1b2b97d31cd 100644 --- a/.gitattributes +++ b/.gitattributes @@ -903,3 +903,4 @@ videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/te videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/python/pywrap_quantize_model.so filter=lfs diff=lfs merge=lfs -text videochat2/lib/python3.10/site-packages/torchvision/_C.so filter=lfs diff=lfs merge=lfs -text videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/calibrator/pywrap_calibration.so filter=lfs diff=lfs merge=lfs -text +videochat2/lib/python3.10/site-packages/tensorflow/python/client/_pywrap_tf_session.so filter=lfs diff=lfs merge=lfs -text diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__algorithm/swap_ranges.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__algorithm/swap_ranges.h new file mode 100644 index 0000000000000000000000000000000000000000..fc315ba628523ac9e906a6a6524054a4a6911825 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__algorithm/swap_ranges.h @@ -0,0 +1,36 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ALGORITHM_SWAP_RANGES_H +#define _LIBCUDACXX___ALGORITHM_SWAP_RANGES_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__utility/swap.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 +_ForwardIterator2 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) +{ + for(; __first1 != __last1; ++__first1, (void) ++__first2) + swap(*__first1, *__first2); + return __first2; +} + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ALGORITHM_SWAP_RANGES_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/different_from.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/different_from.h new file mode 100644 index 0000000000000000000000000000000000000000..c4b146ded36f182de178400bc947ee7403daf4ce --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/different_from.h @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H +#define _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H + +#ifndef __cuda_std__ +#include <__config> +#endif //__cuda_std__ + +#include "../__concepts/__concept_macros.h" +#include "../__concepts/same_as.h" +#include "../__type_traits/remove_cvref.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +template +_LIBCUDACXX_CONCEPT __different_from = !same_as, remove_cvref_t<_Up>>; + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/regular.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/regular.h new file mode 100644 index 0000000000000000000000000000000000000000..118e88c3018ee4f3061283a92073f49022e21c92 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/regular.h @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___CONCEPTS_REGULAR_H +#define _LIBCUDACXX___CONCEPTS_REGULAR_H + +#ifndef __cuda_std__ +#include <__config> +#endif //__cuda_std__ + +#include "../__concepts/__concept_macros.h" +#include "../__concepts/equality_comparable.h" +#include "../__concepts/semiregular.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 17 + +// [concept.object] + +template +concept regular = semiregular<_Tp> && equality_comparable<_Tp>; + +#elif _LIBCUDACXX_STD_VER > 11 + +// [concept.object] + +template +_LIBCUDACXX_CONCEPT_FRAGMENT( + __regular_, + requires()( + requires(semiregular<_Tp>), + requires(equality_comparable<_Tp>) + )); + +template +_LIBCUDACXX_CONCEPT regular = _LIBCUDACXX_FRAGMENT(__regular_, _Tp); + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___CONCEPTS_REGULAR_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/same_as.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/same_as.h new file mode 100644 index 0000000000000000000000000000000000000000..039b09e2dadcb271441282cc229366a99283a8b3 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/same_as.h @@ -0,0 +1,40 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___CONCEPTS_SAME_AS_H +#define _LIBCUDACXX___CONCEPTS_SAME_AS_H + +#ifndef __cuda_std__ +#include <__config> +#endif //__cuda_std__ + +#include "../__concepts/__concept_macros.h" +#include "../__type_traits/is_same.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +// [concept.same] + +template +_LIBCUDACXX_CONCEPT __same_as_impl = _IsSame<_Tp, _Up>::value; + +template +_LIBCUDACXX_CONCEPT same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>; + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___CONCEPTS_SAME_AS_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/semiregular.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/semiregular.h new file mode 100644 index 0000000000000000000000000000000000000000..22663849435e5650cff840475df73f2a284b31d2 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/semiregular.h @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H +#define _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H + +#ifndef __cuda_std__ +#include <__config> +#endif //__cuda_std__ + +#include "../__concepts/__concept_macros.h" +#include "../__concepts/constructible.h" +#include "../__concepts/copyable.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 17 + +// [concept.object] + +template +concept semiregular = copyable<_Tp> && default_initializable<_Tp>; + +#elif _LIBCUDACXX_STD_VER > 11 + +// [concept.object] + +template +_LIBCUDACXX_CONCEPT_FRAGMENT( + __semiregular_, + requires()( + requires(copyable<_Tp>), + requires(default_initializable<_Tp>) + )); + +template +_LIBCUDACXX_CONCEPT semiregular = _LIBCUDACXX_FRAGMENT(__semiregular_, _Tp); + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binary_function.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binary_function.h new file mode 100644 index 0000000000000000000000000000000000000000..e476e68c076620ffa5d7312f8edbe1ac73b7ada2 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binary_function.h @@ -0,0 +1,56 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_BINARY_FUNCTION_H +#define _LIBCUDACXX___FUNCTIONAL_BINARY_FUNCTION_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION) + +template +struct _LIBCUDACXX_TEMPLATE_VIS _LIBCUDACXX_DEPRECATED_IN_CXX11 binary_function +{ + typedef _Arg1 first_argument_type; + typedef _Arg2 second_argument_type; + typedef _Result result_type; +}; + +#endif // _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION) + +template struct __binary_function_keep_layout_base { +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using first_argument_type _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Arg1; + using second_argument_type _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Arg2; + using result_type _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Result; +#endif +}; + +#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION) +_LIBCUDACXX_DIAGNOSTIC_PUSH +_LIBCUDACXX_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations") +template +using __binary_function = binary_function<_Arg1, _Arg2, _Result>; +_LIBCUDACXX_DIAGNOSTIC_POP +#else +template +using __binary_function = __binary_function_keep_layout_base<_Arg1, _Arg2, _Result>; +#endif + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_BINARY_FUNCTION_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/bind_back.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/bind_back.h new file mode 100644 index 0000000000000000000000000000000000000000..a9a4a8896641c7f8cc995eedd291a2ef2293c3ee --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/bind_back.h @@ -0,0 +1,75 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_BIND_BACK_H +#define _LIBCUDACXX___FUNCTIONAL_BIND_BACK_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__functional/invoke.h" +#include "../__functional/perfect_forward.h" +#include "../__fwd/get.h" +#include "../__tuple_dir/tuple_size.h" +#include "../__type_traits/decay.h" +#include "../__type_traits/enable_if.h" +#include "../__type_traits/is_constructible.h" +#include "../__type_traits/is_move_constructible.h" +#include "../__utility/forward.h" +#include "../__utility/integer_sequence.h" + +#include "../tuple" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 14 + +template > +struct __bind_back_op; + +template +struct __bind_back_op<_NBound, index_sequence<_Ip...>> { + template + _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY + constexpr auto operator()(_Fn&& __f, _BoundArgs&& __bound_args, _Args&&... __args) const + noexcept(noexcept(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)..., _CUDA_VSTD::get<_Ip>(_CUDA_VSTD::forward<_BoundArgs>(__bound_args))...))) + -> decltype( _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)..., _CUDA_VSTD::get<_Ip>(_CUDA_VSTD::forward<_BoundArgs>(__bound_args))...)) + { return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)..., _CUDA_VSTD::get<_Ip>(_CUDA_VSTD::forward<_BoundArgs>(__bound_args))...); } +}; + +template +struct __bind_back_t : __perfect_forward<__bind_back_op>, _Fn, _BoundArgs> { + using __perfect_forward<__bind_back_op>, _Fn, _BoundArgs>::__perfect_forward; +}; + +template , _Fn>, + is_move_constructible>, + is_constructible, _Args>..., + is_move_constructible>... + >::value +>> +_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY +constexpr auto __bind_back(_Fn&& __f, _Args&&... __args) + noexcept(noexcept(__bind_back_t, tuple...>>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Args>(__args)...)))) + -> decltype( __bind_back_t, tuple...>>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Args>(__args)...))) + { return __bind_back_t, tuple...>>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Args>(__args)...)); } + +#endif // _LIBCUDACXX_STD_VER > 14 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_BIND_BACK_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/bind_front.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/bind_front.h new file mode 100644 index 0000000000000000000000000000000000000000..7ce9e676069cb7b3b922b81cedb3967795835606 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/bind_front.h @@ -0,0 +1,78 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_BIND_FRONT_H +#define _LIBCUDACXX___FUNCTIONAL_BIND_FRONT_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__concepts/__concept_macros.h" +#include "../__functional/invoke.h" +#include "../__functional/perfect_forward.h" +#include "../__type_traits/decay.h" +#include "../__type_traits/enable_if.h" +#include "../__type_traits/is_constructible.h" +#include "../__type_traits/is_move_constructible.h" +#include "../__type_traits/is_nothrow_constructible.h" +#include "../__utility/forward.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 14 + +struct __bind_front_op { + template + _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY + constexpr auto operator()(_Args&& ...__args) const + noexcept(noexcept(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Args>(__args)...))) + -> decltype( _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Args>(__args)...)) + { return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Args>(__args)...); } +}; + +template +struct __bind_front_t : __perfect_forward<__bind_front_op, _Fn, _BoundArgs...> { + using __base = __perfect_forward<__bind_front_op, _Fn, _BoundArgs...>; +#if defined(_LIBCUDACXX_COMPILER_NVRTC) + constexpr __bind_front_t() noexcept = default; + + template + _LIBCUDACXX_INLINE_VISIBILITY constexpr + __bind_front_t(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...))) + : __base(_CUDA_VSTD::forward<_Args>(__args)...) + {} +#else + using __base::__base; +#endif +}; + +template +_LIBCUDACXX_CONCEPT __can_bind_front = is_constructible_v, _Fn> && + is_move_constructible_v> && + (is_constructible_v, _Args> && ...) && + (is_move_constructible_v> && ... ); + +_LIBCUDACXX_TEMPLATE(class _Fn, class... _Args) + (requires __can_bind_front<_Fn, _Args...>) +_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY +constexpr auto bind_front(_Fn&& __f, _Args&&... __args) noexcept(is_nothrow_constructible_v...>, _Args&&...>) { + return __bind_front_t, decay_t<_Args>...>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)...); +} + +#endif // _LIBCUDACXX_STD_VER > 14 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_BIND_FRONT_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binder1st.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binder1st.h new file mode 100644 index 0000000000000000000000000000000000000000..094b92cd97231ae6f065f6bbc45d7e1ec6bcdcc9 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binder1st.h @@ -0,0 +1,59 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_BINDER1ST_H +#define _LIBCUDACXX___FUNCTIONAL_BINDER1ST_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__functional/unary_function.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_BINDERS) + +template +class _LIBCUDACXX_TEMPLATE_VIS _LIBCUDACXX_DEPRECATED_IN_CXX11 binder1st + : public __unary_function +{ +protected: + __Operation op; + typename __Operation::first_argument_type value; +public: + _LIBCUDACXX_INLINE_VISIBILITY binder1st(const __Operation& __x, + const typename __Operation::first_argument_type __y) + : op(__x), value(__y) {} + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_INLINE_VISIBILITY typename __Operation::result_type operator() + (typename __Operation::second_argument_type& __x) const + {return op(value, __x);} + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_INLINE_VISIBILITY typename __Operation::result_type operator() + (const typename __Operation::second_argument_type& __x) const + {return op(value, __x);} +}; + +template +_LIBCUDACXX_DEPRECATED_IN_CXX11 inline _LIBCUDACXX_INLINE_VISIBILITY +binder1st<__Operation> +bind1st(const __Operation& __op, const _Tp& __x) + {return binder1st<__Operation>(__op, __x);} + +#endif // _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_BINDERS) + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_BINDER1ST_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binder2nd.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binder2nd.h new file mode 100644 index 0000000000000000000000000000000000000000..e02ce01a7710d876b7e1cf783a5956371218ab68 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binder2nd.h @@ -0,0 +1,59 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_BINDER2ND_H +#define _LIBCUDACXX___FUNCTIONAL_BINDER2ND_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__functional/unary_function.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_BINDERS) + +template +class _LIBCUDACXX_TEMPLATE_VIS _LIBCUDACXX_DEPRECATED_IN_CXX11 binder2nd + : public __unary_function +{ +protected: + __Operation op; + typename __Operation::second_argument_type value; +public: + _LIBCUDACXX_INLINE_VISIBILITY + binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y) + : op(__x), value(__y) {} + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_INLINE_VISIBILITY typename __Operation::result_type operator() + ( typename __Operation::first_argument_type& __x) const + {return op(__x, value);} + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_INLINE_VISIBILITY typename __Operation::result_type operator() + (const typename __Operation::first_argument_type& __x) const + {return op(__x, value);} +}; + +template +_LIBCUDACXX_DEPRECATED_IN_CXX11 inline _LIBCUDACXX_INLINE_VISIBILITY +binder2nd<__Operation> +bind2nd(const __Operation& __op, const _Tp& __x) + {return binder2nd<__Operation>(__op, __x);} + +#endif // _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_BINDERS) + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_BINDER2ND_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/compose.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/compose.h new file mode 100644 index 0000000000000000000000000000000000000000..b1ab0445856307cb93162f9251a18dc53eb6b466 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/compose.h @@ -0,0 +1,56 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_COMPOSE_H +#define _LIBCUDACXX___FUNCTIONAL_COMPOSE_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__functional/invoke.h" +#include "../__functional/perfect_forward.h" +#include "../__type_traits/decay.h" +#include "../__utility/forward.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 14 + +struct __compose_op { + template + _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY + constexpr auto operator()(_Fn1&& __f1, _Fn2&& __f2, _Args&&... __args) const + noexcept(noexcept(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn2>(__f2), _CUDA_VSTD::forward<_Args>(__args)...)))) + -> decltype( _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn2>(__f2), _CUDA_VSTD::forward<_Args>(__args)...))) + { return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn2>(__f2), _CUDA_VSTD::forward<_Args>(__args)...)); } +}; + +template +struct __compose_t : __perfect_forward<__compose_op, _Fn1, _Fn2> { + using __perfect_forward<__compose_op, _Fn1, _Fn2>::__perfect_forward; +}; + +template +_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY +constexpr auto __compose(_Fn1&& __f1, _Fn2&& __f2) + noexcept(noexcept(__compose_t, decay_t<_Fn2>>(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::forward<_Fn2>(__f2)))) + -> decltype( __compose_t, decay_t<_Fn2>>(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::forward<_Fn2>(__f2))) + { return __compose_t, decay_t<_Fn2>>(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::forward<_Fn2>(__f2)); } + +#endif // _LIBCUDACXX_STD_VER > 14 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_COMPOSE_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/default_searcher.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/default_searcher.h new file mode 100644 index 0000000000000000000000000000000000000000..3b76674073f7d98a599b9b6504bc986e420dc163 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/default_searcher.h @@ -0,0 +1,148 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_DEFAULT_SEARCHER_H +#define _LIBCUDACXX___FUNCTIONAL_DEFAULT_SEARCHER_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +// #include "../__algorithm/search.h" +#include "../__functional/identity.h" +#include "../__functional/operations.h" +#include "../__iterator/iterator_traits.h" +#include "../__utility/pair.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +_LIBCUDACXX_HOST_DEVICE _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +pair<_ForwardIterator1, _ForwardIterator1> +__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, + forward_iterator_tag, forward_iterator_tag) +{ + if (__first2 == __last2) + return _CUDA_VSTD::make_pair(__first1, __first1); // Everything matches an empty sequence + while (true) + { + // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks + while (true) + { + if (__first1 == __last1) // return __last1 if no element matches *__first2 + return _CUDA_VSTD::make_pair(__last1, __last1); + if (__pred(*__first1, *__first2)) + break; + ++__first1; + } + // *__first1 matches *__first2, now match elements after here + _ForwardIterator1 __m1 = __first1; + _ForwardIterator2 __m2 = __first2; + while (true) + { + if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern) + return _CUDA_VSTD::make_pair(__first1, __m1); + if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found + return _CUDA_VSTD::make_pair(__last1, __last1); + if (!__pred(*__m1, *__m2)) // if there is a mismatch, restart with a new __first1 + { + ++__first1; + break; + } // else there is a match, check next elements + } + } +} + +template +_LIBCUDACXX_HOST_DEVICE _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +pair<_RandomAccessIterator1, _RandomAccessIterator1> +__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, + random_access_iterator_tag, random_access_iterator_tag) +{ + typedef typename iterator_traits<_RandomAccessIterator1>::difference_type _Diff1; + typedef typename iterator_traits<_RandomAccessIterator2>::difference_type _Diff2; + // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern + const _Diff2 __len2 = __last2 - __first2; + if (__len2 == 0) + return _CUDA_VSTD::make_pair(__first1, __first1); + const _Diff1 __len1 = __last1 - __first1; + if (__len1 < __len2) + return _CUDA_VSTD::make_pair(__last1, __last1); + const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here + + while (true) + { + while (true) + { + if (__first1 == __s) + return _CUDA_VSTD::make_pair(__last1, __last1); + if (__pred(*__first1, *__first2)) + break; + ++__first1; + } + + _RandomAccessIterator1 __m1 = __first1; + _RandomAccessIterator2 __m2 = __first2; + while (true) + { + if (++__m2 == __last2) + return _CUDA_VSTD::make_pair(__first1, __first1 + __len2); + ++__m1; // no need to check range on __m1 because __s guarantees we have enough source + if (!__pred(*__m1, *__m2)) + { + ++__first1; + break; + } + } + } +} + +#ifndef __cuda_std__ + +#if _LIBCUDACXX_STD_VER > 14 + +// default searcher +template> +class _LIBCUDACXX_TEMPLATE_VIS default_searcher { +public: + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 + default_searcher(_ForwardIterator __f, _ForwardIterator __l, + _BinaryPredicate __p = _BinaryPredicate()) + : __first_(__f), __last_(__l), __pred_(__p) {} + + template + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 + pair<_ForwardIterator2, _ForwardIterator2> + operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const + { + return _CUDA_VSTD::__search(__f, __l, __first_, __last_, __pred_, + typename _CUDA_VSTD::iterator_traits<_ForwardIterator>::iterator_category(), + typename _CUDA_VSTD::iterator_traits<_ForwardIterator2>::iterator_category()); + } + +private: + _ForwardIterator __first_; + _ForwardIterator __last_; + _BinaryPredicate __pred_; +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(default_searcher); + +#endif // _LIBCUDACXX_STD_VER > 14 +#endif // __cuda_std__ + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_DEFAULT_SEARCHER_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/function.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/function.h new file mode 100644 index 0000000000000000000000000000000000000000..d04601dde9b591b0b64feccedce125320f2ae6d0 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/function.h @@ -0,0 +1,1261 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_FUNCTION_H +#define _LIBCUDACXX___FUNCTIONAL_FUNCTION_H + +#ifndef __cuda_std__ + +#ifndef __cuda_std__ +#include <__config> +#include +#include +#include +#include +#endif // __cuda_std__ + +#include "__assert" +#include "../__debug" +#include "../__functional_base" +#include "../__functional/binary_function.h" +#include "../__functional/invoke.h" +#include "../__functional/unary_function.h" +#include "../__iterator/iterator_traits.h" +#include "../__type_traits/conditional.h" +#include "../__type_traits/decay.h" +#include "../__type_traits/enable_if.h" +#include "../__type_traits/is_nothrow_copy_constructible.h" +#include "../__type_traits/is_same.h" +#include "../__type_traits/is_scalar.h" +#include "../__type_traits/is_trivially_copy_constructible.h" +#include "../__type_traits/is_trivially_destructible.h" +#include "../__type_traits/is_void.h" +#include "../__type_traits/remove_cvref.h" +#include "../__utility/forward.h" +#include "../__utility/move.h" +#include "../__utility/piecewise_construct.h" +#include "../__utility/swap.h" +#include "../tuple" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#ifndef _LIBCUDACXX_CXX03_LANG + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +// bad_function_call + +class _LIBCUDACXX_EXCEPTION_ABI bad_function_call + : public exception +{ +#ifdef _LIBCUDACXX_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION +public: + virtual ~bad_function_call() _NOEXCEPT; + + virtual const char* what() const _NOEXCEPT; +#endif +}; + +_LIBCUDACXX_NORETURN inline _LIBCUDACXX_INLINE_VISIBILITY +void __throw_bad_function_call() +{ +#ifndef _LIBCUDACXX_NO_EXCEPTIONS + throw bad_function_call(); +#else + _CUDA_VSTD::abort(); +#endif +} + +template class _LIBCUDACXX_TEMPLATE_VIS function; // undefined + +namespace __function +{ + +template +struct __maybe_derive_from_unary_function +{ +}; + +template +struct __maybe_derive_from_unary_function<_Rp(_A1)> + : public __unary_function<_A1, _Rp> +{ +}; + +template +struct __maybe_derive_from_binary_function +{ +}; + +template +struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> + : public __binary_function<_A1, _A2, _Rp> +{ +}; + +template +_LIBCUDACXX_INLINE_VISIBILITY +bool __not_null(_Fp const&) { return true; } + +template +_LIBCUDACXX_INLINE_VISIBILITY +bool __not_null(_Fp* __ptr) { return __ptr; } + +template +_LIBCUDACXX_INLINE_VISIBILITY +bool __not_null(_Ret _Class::*__ptr) { return __ptr; } + +template +_LIBCUDACXX_INLINE_VISIBILITY +bool __not_null(function<_Fp> const& __f) { return !!__f; } + +#ifdef _LIBCUDACXX_HAS_EXTENSION_BLOCKS +template +_LIBCUDACXX_INLINE_VISIBILITY +bool __not_null(_Rp (^__p)(_Args...)) { return __p; } +#endif + +} // namespace __function + +#ifndef _LIBCUDACXX_CXX03_LANG + +namespace __function { + +// __alloc_func holds a functor and an allocator. + +template class __alloc_func; +template +class __default_alloc_func; + +template +class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)> +{ + __compressed_pair<_Fp, _Ap> __f_; + + public: + typedef _LIBCUDACXX_NODEBUG_TYPE _Fp _Target; + typedef _LIBCUDACXX_NODEBUG_TYPE _Ap _Alloc; + + _LIBCUDACXX_INLINE_VISIBILITY + const _Target& __target() const { return __f_.first(); } + + // WIN32 APIs may define __allocator, so use __get_allocator instead. + _LIBCUDACXX_INLINE_VISIBILITY + const _Alloc& __get_allocator() const { return __f_.second(); } + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __alloc_func(_Target&& __f) + : __f_(piecewise_construct, _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::move(__f)), + _CUDA_VSTD::forward_as_tuple()) + { + } + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __alloc_func(const _Target& __f, const _Alloc& __a) + : __f_(piecewise_construct, _CUDA_VSTD::forward_as_tuple(__f), + _CUDA_VSTD::forward_as_tuple(__a)) + { + } + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __alloc_func(const _Target& __f, _Alloc&& __a) + : __f_(piecewise_construct, _CUDA_VSTD::forward_as_tuple(__f), + _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::move(__a))) + { + } + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __alloc_func(_Target&& __f, _Alloc&& __a) + : __f_(piecewise_construct, _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::move(__f)), + _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::move(__a))) + { + } + + _LIBCUDACXX_INLINE_VISIBILITY + _Rp operator()(_ArgTypes&&... __arg) + { + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first(), + _CUDA_VSTD::forward<_ArgTypes>(__arg)...); + } + + _LIBCUDACXX_INLINE_VISIBILITY + __alloc_func* __clone() const + { + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type _AA; + _AA __a(__f_.second()); + typedef __allocator_destructor<_AA> _Dp; + unique_ptr<__alloc_func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); + ::new ((void*)__hold.get()) __alloc_func(__f_.first(), _Alloc(__a)); + return __hold.release(); + } + + _LIBCUDACXX_INLINE_VISIBILITY + void destroy() _NOEXCEPT { __f_.~__compressed_pair<_Target, _Alloc>(); } + + static void __destroy_and_delete(__alloc_func* __f) { + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type _FunAlloc; + _FunAlloc __a(__f->__get_allocator()); + __f->destroy(); + __a.deallocate(__f, 1); + } +}; + +template +class __default_alloc_func<_Fp, _Rp(_ArgTypes...)> { + _Fp __f_; + +public: + typedef _LIBCUDACXX_NODEBUG_TYPE _Fp _Target; + + _LIBCUDACXX_INLINE_VISIBILITY + const _Target& __target() const { return __f_; } + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __default_alloc_func(_Target&& __f) : __f_(_CUDA_VSTD::move(__f)) {} + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __default_alloc_func(const _Target& __f) : __f_(__f) {} + + _LIBCUDACXX_INLINE_VISIBILITY + _Rp operator()(_ArgTypes&&... __arg) { + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_, _CUDA_VSTD::forward<_ArgTypes>(__arg)...); + } + + _LIBCUDACXX_INLINE_VISIBILITY + __default_alloc_func* __clone() const { + __builtin_new_allocator::__holder_t __hold = + __builtin_new_allocator::__allocate_type<__default_alloc_func>(1); + __default_alloc_func* __res = + ::new ((void*)__hold.get()) __default_alloc_func(__f_); + (void)__hold.release(); + return __res; + } + + _LIBCUDACXX_INLINE_VISIBILITY + void destroy() _NOEXCEPT { __f_.~_Target(); } + + static void __destroy_and_delete(__default_alloc_func* __f) { + __f->destroy(); + __builtin_new_allocator::__deallocate_type<__default_alloc_func>(__f, 1); + } +}; + +// __base provides an abstract interface for copyable functors. + +template class _LIBCUDACXX_TEMPLATE_VIS __base; + +template +class __base<_Rp(_ArgTypes...)> +{ + __base(const __base&); + __base& operator=(const __base&); +public: + _LIBCUDACXX_INLINE_VISIBILITY __base() {} + _LIBCUDACXX_INLINE_VISIBILITY virtual ~__base() {} + virtual __base* __clone() const = 0; + virtual void __clone(__base*) const = 0; + virtual void destroy() _NOEXCEPT = 0; + virtual void destroy_deallocate() _NOEXCEPT = 0; + virtual _Rp operator()(_ArgTypes&& ...) = 0; +#ifndef _LIBCUDACXX_NO_RTTI + virtual const void* target(const type_info&) const _NOEXCEPT = 0; + virtual const type_info& target_type() const _NOEXCEPT = 0; +#endif // _LIBCUDACXX_NO_RTTI +}; + +// __func implements __base for a given functor type. + +template class __func; + +template +class __func<_Fp, _Alloc, _Rp(_ArgTypes...)> + : public __base<_Rp(_ArgTypes...)> +{ + __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> __f_; +public: + _LIBCUDACXX_INLINE_VISIBILITY + explicit __func(_Fp&& __f) + : __f_(_CUDA_VSTD::move(__f)) {} + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __func(const _Fp& __f, const _Alloc& __a) + : __f_(__f, __a) {} + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __func(const _Fp& __f, _Alloc&& __a) + : __f_(__f, _CUDA_VSTD::move(__a)) {} + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __func(_Fp&& __f, _Alloc&& __a) + : __f_(_CUDA_VSTD::move(__f), _CUDA_VSTD::move(__a)) {} + + virtual __base<_Rp(_ArgTypes...)>* __clone() const; + virtual void __clone(__base<_Rp(_ArgTypes...)>*) const; + virtual void destroy() _NOEXCEPT; + virtual void destroy_deallocate() _NOEXCEPT; + virtual _Rp operator()(_ArgTypes&&... __arg); +#ifndef _LIBCUDACXX_NO_RTTI + virtual const void* target(const type_info&) const _NOEXCEPT; + virtual const type_info& target_type() const _NOEXCEPT; +#endif // _LIBCUDACXX_NO_RTTI +}; + +template +__base<_Rp(_ArgTypes...)>* +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const +{ + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; + _Ap __a(__f_.__get_allocator()); + typedef __allocator_destructor<_Ap> _Dp; + unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); + ::new ((void*)__hold.get()) __func(__f_.__target(), _Alloc(__a)); + return __hold.release(); +} + +template +void +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const +{ + ::new ((void*)__p) __func(__f_.__target(), __f_.__get_allocator()); +} + +template +void +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT +{ + __f_.destroy(); +} + +template +void +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT +{ + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; + _Ap __a(__f_.__get_allocator()); + __f_.destroy(); + __a.deallocate(this, 1); +} + +template +_Rp +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) +{ + return __f_(_CUDA_VSTD::forward<_ArgTypes>(__arg)...); +} + +#ifndef _LIBCUDACXX_NO_RTTI + +template +const void* +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT +{ + if (__ti == typeid(_Fp)) + return _CUDA_VSTD::addressof(__f_.__target()); + return nullptr; +} + +template +const type_info& +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT +{ + return typeid(_Fp); +} + +#endif // _LIBCUDACXX_NO_RTTI + +// __value_func creates a value-type from a __func. + +template class __value_func; + +template class __value_func<_Rp(_ArgTypes...)> +{ + typename aligned_storage<3 * sizeof(void*)>::type __buf_; + + typedef __base<_Rp(_ArgTypes...)> __func; + __func* __f_; + + _LIBCUDACXX_NO_CFI static __func* __as_base(void* __p) + { + return reinterpret_cast<__func*>(__p); + } + + public: + _LIBCUDACXX_INLINE_VISIBILITY + __value_func() _NOEXCEPT : __f_(nullptr) {} + + template + _LIBCUDACXX_INLINE_VISIBILITY __value_func(_Fp&& __f, const _Alloc& __a) + : __f_(nullptr) + { + typedef allocator_traits<_Alloc> __alloc_traits; + typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun; + typedef typename __rebind_alloc_helper<__alloc_traits, _Fun>::type _FunAlloc; + + if (__function::__not_null(__f)) + { + _FunAlloc __af(__a); + if (sizeof(_Fun) <= sizeof(__buf_) && + is_nothrow_copy_constructible<_Fp>::value && + is_nothrow_copy_constructible<_FunAlloc>::value) + { + __f_ = + ::new ((void*)&__buf_) _Fun(_CUDA_VSTD::move(__f), _Alloc(__af)); + } + else + { + typedef __allocator_destructor<_FunAlloc> _Dp; + unique_ptr<__func, _Dp> __hold(__af.allocate(1), _Dp(__af, 1)); + ::new ((void*)__hold.get()) _Fun(_CUDA_VSTD::move(__f), _Alloc(__a)); + __f_ = __hold.release(); + } + } + } + + template , __value_func>::value>> + _LIBCUDACXX_INLINE_VISIBILITY explicit __value_func(_Fp&& __f) + : __value_func(_CUDA_VSTD::forward<_Fp>(__f), allocator<_Fp>()) {} + + _LIBCUDACXX_INLINE_VISIBILITY + __value_func(const __value_func& __f) + { + if (__f.__f_ == nullptr) + __f_ = nullptr; + else if ((void*)__f.__f_ == &__f.__buf_) + { + __f_ = __as_base(&__buf_); + __f.__f_->__clone(__f_); + } + else + __f_ = __f.__f_->__clone(); + } + + _LIBCUDACXX_INLINE_VISIBILITY + __value_func(__value_func&& __f) _NOEXCEPT + { + if (__f.__f_ == nullptr) + __f_ = nullptr; + else if ((void*)__f.__f_ == &__f.__buf_) + { + __f_ = __as_base(&__buf_); + __f.__f_->__clone(__f_); + } + else + { + __f_ = __f.__f_; + __f.__f_ = nullptr; + } + } + + _LIBCUDACXX_INLINE_VISIBILITY + ~__value_func() + { + if ((void*)__f_ == &__buf_) + __f_->destroy(); + else if (__f_) + __f_->destroy_deallocate(); + } + + _LIBCUDACXX_INLINE_VISIBILITY + __value_func& operator=(__value_func&& __f) + { + *this = nullptr; + if (__f.__f_ == nullptr) + __f_ = nullptr; + else if ((void*)__f.__f_ == &__f.__buf_) + { + __f_ = __as_base(&__buf_); + __f.__f_->__clone(__f_); + } + else + { + __f_ = __f.__f_; + __f.__f_ = nullptr; + } + return *this; + } + + _LIBCUDACXX_INLINE_VISIBILITY + __value_func& operator=(nullptr_t) + { + __func* __f = __f_; + __f_ = nullptr; + if ((void*)__f == &__buf_) + __f->destroy(); + else if (__f) + __f->destroy_deallocate(); + return *this; + } + + _LIBCUDACXX_INLINE_VISIBILITY + _Rp operator()(_ArgTypes&&... __args) const + { + if (__f_ == nullptr) + __throw_bad_function_call(); + return (*__f_)(_CUDA_VSTD::forward<_ArgTypes>(__args)...); + } + + _LIBCUDACXX_INLINE_VISIBILITY + void swap(__value_func& __f) _NOEXCEPT + { + if (&__f == this) + return; + if ((void*)__f_ == &__buf_ && (void*)__f.__f_ == &__f.__buf_) + { + typename aligned_storage::type __tempbuf; + __func* __t = __as_base(&__tempbuf); + __f_->__clone(__t); + __f_->destroy(); + __f_ = nullptr; + __f.__f_->__clone(__as_base(&__buf_)); + __f.__f_->destroy(); + __f.__f_ = nullptr; + __f_ = __as_base(&__buf_); + __t->__clone(__as_base(&__f.__buf_)); + __t->destroy(); + __f.__f_ = __as_base(&__f.__buf_); + } + else if ((void*)__f_ == &__buf_) + { + __f_->__clone(__as_base(&__f.__buf_)); + __f_->destroy(); + __f_ = __f.__f_; + __f.__f_ = __as_base(&__f.__buf_); + } + else if ((void*)__f.__f_ == &__f.__buf_) + { + __f.__f_->__clone(__as_base(&__buf_)); + __f.__f_->destroy(); + __f.__f_ = __f_; + __f_ = __as_base(&__buf_); + } + else + _CUDA_VSTD::swap(__f_, __f.__f_); + } + + _LIBCUDACXX_INLINE_VISIBILITY + _LIBCUDACXX_EXPLICIT operator bool() const _NOEXCEPT { return __f_ != nullptr; } + +#ifndef _LIBCUDACXX_NO_RTTI + _LIBCUDACXX_INLINE_VISIBILITY + const type_info& target_type() const _NOEXCEPT + { + if (__f_ == nullptr) + return typeid(void); + return __f_->target_type(); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT + { + if (__f_ == nullptr) + return nullptr; + return (const _Tp*)__f_->target(typeid(_Tp)); + } +#endif // _LIBCUDACXX_NO_RTTI +}; + +// Storage for a functor object, to be used with __policy to manage copy and +// destruction. +union __policy_storage +{ + mutable char __small[sizeof(void*) * 2]; + void* __large; +}; + +// True if _Fun can safely be held in __policy_storage.__small. +template +struct __use_small_storage + : public integral_constant< + bool, sizeof(_Fun) <= sizeof(__policy_storage) && + _LIBCUDACXX_ALIGNOF(_Fun) <= _LIBCUDACXX_ALIGNOF(__policy_storage) && + is_trivially_copy_constructible<_Fun>::value && + is_trivially_destructible<_Fun>::value> {}; + +// Policy contains information about how to copy, destroy, and move the +// underlying functor. You can think of it as a vtable of sorts. +struct __policy +{ + // Used to copy or destroy __large values. null for trivial objects. + void* (*const __clone)(const void*); + void (*const __destroy)(void*); + + // True if this is the null policy (no value). + const bool __is_null; + + // The target type. May be null if RTTI is disabled. + const type_info* const __type_info; + + // Returns a pointer to a static policy object suitable for the functor + // type. + template + _LIBCUDACXX_INLINE_VISIBILITY static const __policy* __create() + { + return __choose_policy<_Fun>(__use_small_storage<_Fun>()); + } + + _LIBCUDACXX_INLINE_VISIBILITY + static const __policy* __create_empty() + { + static const _LIBCUDACXX_CONSTEXPR __policy __policy_ = {nullptr, nullptr, + true, +#ifndef _LIBCUDACXX_NO_RTTI + &typeid(void) +#else + nullptr +#endif + }; + return &__policy_; + } + + private: + template static void* __large_clone(const void* __s) + { + const _Fun* __f = static_cast(__s); + return __f->__clone(); + } + + template + static void __large_destroy(void* __s) { + _Fun::__destroy_and_delete(static_cast<_Fun*>(__s)); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY static const __policy* + __choose_policy(/* is_small = */ false_type) { + static const _LIBCUDACXX_CONSTEXPR __policy __policy_ = { + &__large_clone<_Fun>, &__large_destroy<_Fun>, false, +#ifndef _LIBCUDACXX_NO_RTTI + &typeid(typename _Fun::_Target) +#else + nullptr +#endif + }; + return &__policy_; + } + + template + _LIBCUDACXX_INLINE_VISIBILITY static const __policy* + __choose_policy(/* is_small = */ true_type) + { + static const _LIBCUDACXX_CONSTEXPR __policy __policy_ = { + nullptr, nullptr, false, +#ifndef _LIBCUDACXX_NO_RTTI + &typeid(typename _Fun::_Target) +#else + nullptr +#endif + }; + return &__policy_; + } +}; + +// Used to choose between perfect forwarding or pass-by-value. Pass-by-value is +// faster for types that can be passed in registers. +template +using __fast_forward = __conditional_t::value, _Tp, _Tp&&>; + +// __policy_invoker calls an instance of __alloc_func held in __policy_storage. + +template struct __policy_invoker; + +template +struct __policy_invoker<_Rp(_ArgTypes...)> +{ + typedef _Rp (*__Call)(const __policy_storage*, + __fast_forward<_ArgTypes>...); + + __Call __call_; + + // Creates an invoker that throws bad_function_call. + _LIBCUDACXX_INLINE_VISIBILITY + __policy_invoker() : __call_(&__call_empty) {} + + // Creates an invoker that calls the given instance of __func. + template + _LIBCUDACXX_INLINE_VISIBILITY static __policy_invoker __create() + { + return __policy_invoker(&__call_impl<_Fun>); + } + + private: + _LIBCUDACXX_INLINE_VISIBILITY + explicit __policy_invoker(__Call __c) : __call_(__c) {} + + static _Rp __call_empty(const __policy_storage*, + __fast_forward<_ArgTypes>...) + { + __throw_bad_function_call(); + } + + template + static _Rp __call_impl(const __policy_storage* __buf, + __fast_forward<_ArgTypes>... __args) + { + _Fun* __f = reinterpret_cast<_Fun*>(__use_small_storage<_Fun>::value + ? &__buf->__small + : __buf->__large); + return (*__f)(_CUDA_VSTD::forward<_ArgTypes>(__args)...); + } +}; + +// __policy_func uses a __policy and __policy_invoker to create a type-erased, +// copyable functor. + +template class __policy_func; + +template class __policy_func<_Rp(_ArgTypes...)> +{ + // Inline storage for small objects. + __policy_storage __buf_; + + // Calls the value stored in __buf_. This could technically be part of + // policy, but storing it here eliminates a level of indirection inside + // operator(). + typedef __function::__policy_invoker<_Rp(_ArgTypes...)> __invoker; + __invoker __invoker_; + + // The policy that describes how to move / copy / destroy __buf_. Never + // null, even if the function is empty. + const __policy* __policy_; + + public: + _LIBCUDACXX_INLINE_VISIBILITY + __policy_func() : __policy_(__policy::__create_empty()) {} + + template + _LIBCUDACXX_INLINE_VISIBILITY __policy_func(_Fp&& __f, const _Alloc& __a) + : __policy_(__policy::__create_empty()) + { + typedef __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, _Fun>::type _FunAlloc; + + if (__function::__not_null(__f)) + { + __invoker_ = __invoker::template __create<_Fun>(); + __policy_ = __policy::__create<_Fun>(); + + _FunAlloc __af(__a); + if (__use_small_storage<_Fun>()) + { + ::new ((void*)&__buf_.__small) + _Fun(_CUDA_VSTD::move(__f), _Alloc(__af)); + } + else + { + typedef __allocator_destructor<_FunAlloc> _Dp; + unique_ptr<_Fun, _Dp> __hold(__af.allocate(1), _Dp(__af, 1)); + ::new ((void*)__hold.get()) + _Fun(_CUDA_VSTD::move(__f), _Alloc(__af)); + __buf_.__large = __hold.release(); + } + } + } + + template , __policy_func>::value>> + _LIBCUDACXX_INLINE_VISIBILITY explicit __policy_func(_Fp&& __f) + : __policy_(__policy::__create_empty()) { + typedef __default_alloc_func<_Fp, _Rp(_ArgTypes...)> _Fun; + + if (__function::__not_null(__f)) { + __invoker_ = __invoker::template __create<_Fun>(); + __policy_ = __policy::__create<_Fun>(); + if (__use_small_storage<_Fun>()) { + ::new ((void*)&__buf_.__small) _Fun(_CUDA_VSTD::move(__f)); + } else { + __builtin_new_allocator::__holder_t __hold = + __builtin_new_allocator::__allocate_type<_Fun>(1); + __buf_.__large = ::new ((void*)__hold.get()) _Fun(_CUDA_VSTD::move(__f)); + (void)__hold.release(); + } + } + } + + _LIBCUDACXX_INLINE_VISIBILITY + __policy_func(const __policy_func& __f) + : __buf_(__f.__buf_), __invoker_(__f.__invoker_), + __policy_(__f.__policy_) + { + if (__policy_->__clone) + __buf_.__large = __policy_->__clone(__f.__buf_.__large); + } + + _LIBCUDACXX_INLINE_VISIBILITY + __policy_func(__policy_func&& __f) + : __buf_(__f.__buf_), __invoker_(__f.__invoker_), + __policy_(__f.__policy_) + { + if (__policy_->__destroy) + { + __f.__policy_ = __policy::__create_empty(); + __f.__invoker_ = __invoker(); + } + } + + _LIBCUDACXX_INLINE_VISIBILITY + ~__policy_func() + { + if (__policy_->__destroy) + __policy_->__destroy(__buf_.__large); + } + + _LIBCUDACXX_INLINE_VISIBILITY + __policy_func& operator=(__policy_func&& __f) + { + *this = nullptr; + __buf_ = __f.__buf_; + __invoker_ = __f.__invoker_; + __policy_ = __f.__policy_; + __f.__policy_ = __policy::__create_empty(); + __f.__invoker_ = __invoker(); + return *this; + } + + _LIBCUDACXX_INLINE_VISIBILITY + __policy_func& operator=(nullptr_t) + { + const __policy* __p = __policy_; + __policy_ = __policy::__create_empty(); + __invoker_ = __invoker(); + if (__p->__destroy) + __p->__destroy(__buf_.__large); + return *this; + } + + _LIBCUDACXX_INLINE_VISIBILITY + _Rp operator()(_ArgTypes&&... __args) const + { + return __invoker_.__call_(_CUDA_VSTD::addressof(__buf_), + _CUDA_VSTD::forward<_ArgTypes>(__args)...); + } + + _LIBCUDACXX_INLINE_VISIBILITY + void swap(__policy_func& __f) + { + _CUDA_VSTD::swap(__invoker_, __f.__invoker_); + _CUDA_VSTD::swap(__policy_, __f.__policy_); + _CUDA_VSTD::swap(__buf_, __f.__buf_); + } + + _LIBCUDACXX_INLINE_VISIBILITY + explicit operator bool() const _NOEXCEPT + { + return !__policy_->__is_null; + } + +#ifndef _LIBCUDACXX_NO_RTTI + _LIBCUDACXX_INLINE_VISIBILITY + const type_info& target_type() const _NOEXCEPT + { + return *__policy_->__type_info; + } + + template + _LIBCUDACXX_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT + { + if (__policy_->__is_null || typeid(_Tp) != *__policy_->__type_info) + return nullptr; + if (__policy_->__clone) // Out of line storage. + return reinterpret_cast(__buf_.__large); + else + return reinterpret_cast(&__buf_.__small); + } +#endif // _LIBCUDACXX_NO_RTTI +}; + +#if defined(_LIBCUDACXX_HAS_BLOCKS_RUNTIME) + +extern "C" void *_Block_copy(const void *); +extern "C" void _Block_release(const void *); + +template +class __func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)> + : public __base<_Rp(_ArgTypes...)> +{ + typedef _Rp1(^__block_type)(_ArgTypes1...); + __block_type __f_; + +public: + _LIBCUDACXX_INLINE_VISIBILITY + explicit __func(__block_type const& __f) +#ifdef _LIBCUDACXX_HAS_OBJC_ARC + : __f_(__f) +#else + : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr)) +#endif + { } + + // [TODO] add && to save on a retain + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __func(__block_type __f, const _Alloc& /* unused */) +#ifdef _LIBCUDACXX_HAS_OBJC_ARC + : __f_(__f) +#else + : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr)) +#endif + { } + + virtual __base<_Rp(_ArgTypes...)>* __clone() const { + _LIBCUDACXX_ASSERT(false, + "Block pointers are just pointers, so they should always fit into " + "std::function's small buffer optimization. This function should " + "never be invoked."); + return nullptr; + } + + virtual void __clone(__base<_Rp(_ArgTypes...)>* __p) const { + ::new ((void*)__p) __func(__f_); + } + + virtual void destroy() _NOEXCEPT { +#ifndef _LIBCUDACXX_HAS_OBJC_ARC + if (__f_) + _Block_release(__f_); +#endif + __f_ = 0; + } + + virtual void destroy_deallocate() _NOEXCEPT { + _LIBCUDACXX_ASSERT(false, + "Block pointers are just pointers, so they should always fit into " + "std::function's small buffer optimization. This function should " + "never be invoked."); + } + + virtual _Rp operator()(_ArgTypes&& ... __arg) { + return _CUDA_VSTD::__invoke(__f_, _CUDA_VSTD::forward<_ArgTypes>(__arg)...); + } + +#ifndef _LIBCUDACXX_NO_RTTI + virtual const void* target(type_info const& __ti) const _NOEXCEPT { + if (__ti == typeid(__func::__block_type)) + return &__f_; + return (const void*)nullptr; + } + + virtual const type_info& target_type() const _NOEXCEPT { + return typeid(__func::__block_type); + } +#endif // _LIBCUDACXX_NO_RTTI +}; + +#endif // _LIBCUDACXX_HAS_EXTENSION_BLOCKS + +} // namespace __function + +template +class _LIBCUDACXX_TEMPLATE_VIS function<_Rp(_ArgTypes...)> + : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>, + public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)> +{ +#ifndef _LIBCUDACXX_ABI_OPTIMIZED_FUNCTION + typedef __function::__value_func<_Rp(_ArgTypes...)> __func; +#else + typedef __function::__policy_func<_Rp(_ArgTypes...)> __func; +#endif + + __func __f_; + + template , function>, + __invokable<_Fp, _ArgTypes...> + >::value> + struct __callable; + template + struct __callable<_Fp, true> + { + static const bool value = is_void<_Rp>::value || + __is_core_convertible::type, + _Rp>::value; + }; + template + struct __callable<_Fp, false> + { + static const bool value = false; + }; + + template + using _EnableIfLValueCallable = __enable_if_t<__callable<_Fp&>::value>; +public: + typedef _Rp result_type; + + // construct/copy/destroy: + _LIBCUDACXX_INLINE_VISIBILITY + function() _NOEXCEPT { } + _LIBCUDACXX_INLINE_VISIBILITY + function(nullptr_t) _NOEXCEPT {} + function(const function&); + function(function&&) _NOEXCEPT; + template> + function(_Fp); + +#if _LIBCUDACXX_STD_VER <= 14 + template + _LIBCUDACXX_INLINE_VISIBILITY + function(allocator_arg_t, const _Alloc&) _NOEXCEPT {} + template + _LIBCUDACXX_INLINE_VISIBILITY + function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT {} + template + function(allocator_arg_t, const _Alloc&, const function&); + template + function(allocator_arg_t, const _Alloc&, function&&); + template> + function(allocator_arg_t, const _Alloc& __a, _Fp __f); +#endif + + function& operator=(const function&); + function& operator=(function&&) _NOEXCEPT; + function& operator=(nullptr_t) _NOEXCEPT; + template>> + function& operator=(_Fp&&); + + ~function(); + + // function modifiers: + void swap(function&) _NOEXCEPT; + +#if _LIBCUDACXX_STD_VER <= 14 + template + _LIBCUDACXX_INLINE_VISIBILITY + void assign(_Fp&& __f, const _Alloc& __a) + {function(allocator_arg, __a, _CUDA_VSTD::forward<_Fp>(__f)).swap(*this);} +#endif + + // function capacity: + _LIBCUDACXX_INLINE_VISIBILITY + _LIBCUDACXX_EXPLICIT operator bool() const _NOEXCEPT { + return static_cast(__f_); + } + + // deleted overloads close possible hole in the type system + template + bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete; + template + bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete; +public: + // function invocation: + _Rp operator()(_ArgTypes...) const; + +#ifndef _LIBCUDACXX_NO_RTTI + // function target access: + const type_info& target_type() const _NOEXCEPT; + template _Tp* target() _NOEXCEPT; + template const _Tp* target() const _NOEXCEPT; +#endif // _LIBCUDACXX_NO_RTTI +}; + +#if _LIBCUDACXX_STD_VER > 14 +template +function(_Rp(*)(_Ap...)) -> function<_Rp(_Ap...)>; + +template +struct __strip_signature; + +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...)> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) const> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile> { using type = _Rp(_Ap...); }; + +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) &> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) const &> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile &> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile &> { using type = _Rp(_Ap...); }; + +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) noexcept> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) const noexcept> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile noexcept> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile noexcept> { using type = _Rp(_Ap...); }; + +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) & noexcept> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) const & noexcept> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile & noexcept> { using type = _Rp(_Ap...); }; +template +struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile & noexcept> { using type = _Rp(_Ap...); }; + +template::type> +function(_Fp) -> function<_Stripped>; +#endif // _LIBCUDACXX_STD_VER > 14 + +template +function<_Rp(_ArgTypes...)>::function(const function& __f) : __f_(__f.__f_) {} + +#if _LIBCUDACXX_STD_VER <= 14 +template +template +function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, + const function& __f) : __f_(__f.__f_) {} +#endif + +template +function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT + : __f_(_CUDA_VSTD::move(__f.__f_)) {} + +#if _LIBCUDACXX_STD_VER <= 14 +template +template +function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, + function&& __f) + : __f_(_CUDA_VSTD::move(__f.__f_)) {} +#endif + +template +template +function<_Rp(_ArgTypes...)>::function(_Fp __f) : __f_(_CUDA_VSTD::move(__f)) {} + +#if _LIBCUDACXX_STD_VER <= 14 +template +template +function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a, + _Fp __f) + : __f_(_CUDA_VSTD::move(__f), __a) {} +#endif + +template +function<_Rp(_ArgTypes...)>& +function<_Rp(_ArgTypes...)>::operator=(const function& __f) +{ + function(__f).swap(*this); + return *this; +} + +template +function<_Rp(_ArgTypes...)>& +function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT +{ + __f_ = _CUDA_VSTD::move(__f.__f_); + return *this; +} + +template +function<_Rp(_ArgTypes...)>& +function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT +{ + __f_ = nullptr; + return *this; +} + +template +template +function<_Rp(_ArgTypes...)>& +function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) +{ + function(_CUDA_VSTD::forward<_Fp>(__f)).swap(*this); + return *this; +} + +template +function<_Rp(_ArgTypes...)>::~function() {} + +template +void +function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT +{ + __f_.swap(__f.__f_); +} + +template +_Rp +function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const +{ + return __f_(_CUDA_VSTD::forward<_ArgTypes>(__arg)...); +} + +#ifndef _LIBCUDACXX_NO_RTTI + +template +const type_info& +function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT +{ + return __f_.target_type(); +} + +template +template +_Tp* +function<_Rp(_ArgTypes...)>::target() _NOEXCEPT +{ + return (_Tp*)(__f_.template target<_Tp>()); +} + +template +template +const _Tp* +function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT +{ + return __f_.template target<_Tp>(); +} + +#endif // _LIBCUDACXX_NO_RTTI + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +bool +operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +bool +operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +bool +operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +bool +operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +void +swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT +{return __x.swap(__y);} + +#else // _LIBCUDACXX_CXX03_LANG + +#include <__functional_03> + +#endif + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX_CXX03_LANG + +#endif // __cuda_std__ + +#endif // _LIBCUDACXX___FUNCTIONAL_FUNCTION_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/hash.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/hash.h new file mode 100644 index 0000000000000000000000000000000000000000..0c4805145a17a536582321da55192e793d64ac4e --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/hash.h @@ -0,0 +1,692 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_HASH_H +#define _LIBCUDACXX___FUNCTIONAL_HASH_H + +#ifndef __cuda_std__ +#include <__config> +#include +#endif // __cuda_std__ + +#include "../__functional/invoke.h" +#include "../__functional/unary_function.h" +#include "../__fwd/hash.h" +#include "../__type_traits/enable_if.h" +#include "../__type_traits/integral_constant.h" +#include "../__type_traits/is_enum.h" +#include "../__type_traits/is_copy_constructible.h" +#include "../__type_traits/is_default_constructible.h" +#include "../__type_traits/is_move_constructible.h" +#include "../__type_traits/underlying_type.h" +#include "../__utility/forward.h" +#include "../__utility/move.h" +#include "../__utility/pair.h" +#include "../__utility/swap.h" +#include "../cstdint" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#ifndef __cuda_std__ + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +_Size +__loadword(const void* __p) +{ + _Size __r; + std::memcpy(&__r, __p, sizeof(__r)); + return __r; +} + +// We use murmur2 when size_t is 32 bits, and cityhash64 when size_t +// is 64 bits. This is because cityhash64 uses 64bit x 64bit +// multiplication, which can be very slow on 32-bit systems. +template +struct __murmur2_or_cityhash; + +template +struct __murmur2_or_cityhash<_Size, 32> +{ + inline _Size operator()(const void* __key, _Size __len) + _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK; +}; + +// murmur2 +template +_Size +__murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len) +{ + const _Size __m = 0x5bd1e995; + const _Size __r = 24; + _Size __h = __len; + const unsigned char* __data = static_cast(__key); + for (; __len >= 4; __data += 4, __len -= 4) + { + _Size __k = __loadword<_Size>(__data); + __k *= __m; + __k ^= __k >> __r; + __k *= __m; + __h *= __m; + __h ^= __k; + } + switch (__len) + { + case 3: + __h ^= static_cast<_Size>(__data[2] << 16); + _LIBCUDACXX_FALLTHROUGH(); + case 2: + __h ^= static_cast<_Size>(__data[1] << 8); + _LIBCUDACXX_FALLTHROUGH(); + case 1: + __h ^= __data[0]; + __h *= __m; + } + __h ^= __h >> 13; + __h *= __m; + __h ^= __h >> 15; + return __h; +} + +template +struct __murmur2_or_cityhash<_Size, 64> +{ + inline _Size operator()(const void* __key, _Size __len) _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK; + + private: + // Some primes between 2^63 and 2^64. + static const _Size __k0 = 0xc3a5c85c97cb3127ULL; + static const _Size __k1 = 0xb492b66fbe98f273ULL; + static const _Size __k2 = 0x9ae16a3b2f90404fULL; + static const _Size __k3 = 0xc949d7c7509e6557ULL; + + static _Size __rotate(_Size __val, int __shift) { + return __shift == 0 ? __val : ((__val >> __shift) | (__val << (64 - __shift))); + } + + static _Size __rotate_by_at_least_1(_Size __val, int __shift) { + return (__val >> __shift) | (__val << (64 - __shift)); + } + + static _Size __shift_mix(_Size __val) { + return __val ^ (__val >> 47); + } + + static _Size __hash_len_16(_Size __u, _Size __v) + _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK + { + const _Size __mul = 0x9ddfea08eb382d69ULL; + _Size __a = (__u ^ __v) * __mul; + __a ^= (__a >> 47); + _Size __b = (__v ^ __a) * __mul; + __b ^= (__b >> 47); + __b *= __mul; + return __b; + } + + static _Size __hash_len_0_to_16(const char* __s, _Size __len) + _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK + { + if (__len > 8) { + const _Size __a = __loadword<_Size>(__s); + const _Size __b = __loadword<_Size>(__s + __len - 8); + return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b; + } + if (__len >= 4) { + const uint32_t __a = __loadword(__s); + const uint32_t __b = __loadword(__s + __len - 4); + return __hash_len_16(__len + (static_cast<_Size>(__a) << 3), __b); + } + if (__len > 0) { + const unsigned char __a = static_cast(__s[0]); + const unsigned char __b = static_cast(__s[__len >> 1]); + const unsigned char __c = static_cast(__s[__len - 1]); + const uint32_t __y = static_cast(__a) + + (static_cast(__b) << 8); + const uint32_t __z = __len + (static_cast(__c) << 2); + return __shift_mix(__y * __k2 ^ __z * __k3) * __k2; + } + return __k2; + } + + static _Size __hash_len_17_to_32(const char *__s, _Size __len) + _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK + { + const _Size __a = __loadword<_Size>(__s) * __k1; + const _Size __b = __loadword<_Size>(__s + 8); + const _Size __c = __loadword<_Size>(__s + __len - 8) * __k2; + const _Size __d = __loadword<_Size>(__s + __len - 16) * __k0; + return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d, + __a + __rotate(__b ^ __k3, 20) - __c + __len); + } + + // Return a 16-byte hash for 48 bytes. Quick and dirty. + // Callers do best to use "random-looking" values for a and b. + static pair<_Size, _Size> __weak_hash_len_32_with_seeds( + _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b) + _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK + { + __a += __w; + __b = __rotate(__b + __a + __z, 21); + const _Size __c = __a; + __a += __x; + __a += __y; + __b += __rotate(__a, 44); + return pair<_Size, _Size>(__a + __z, __b + __c); + } + + // Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty. + static pair<_Size, _Size> __weak_hash_len_32_with_seeds( + const char* __s, _Size __a, _Size __b) + _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK + { + return __weak_hash_len_32_with_seeds(__loadword<_Size>(__s), + __loadword<_Size>(__s + 8), + __loadword<_Size>(__s + 16), + __loadword<_Size>(__s + 24), + __a, + __b); + } + + // Return an 8-byte hash for 33 to 64 bytes. + static _Size __hash_len_33_to_64(const char *__s, size_t __len) + _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK + { + _Size __z = __loadword<_Size>(__s + 24); + _Size __a = __loadword<_Size>(__s) + + (__len + __loadword<_Size>(__s + __len - 16)) * __k0; + _Size __b = __rotate(__a + __z, 52); + _Size __c = __rotate(__a, 37); + __a += __loadword<_Size>(__s + 8); + __c += __rotate(__a, 7); + __a += __loadword<_Size>(__s + 16); + _Size __vf = __a + __z; + _Size __vs = __b + __rotate(__a, 31) + __c; + __a = __loadword<_Size>(__s + 16) + __loadword<_Size>(__s + __len - 32); + __z += __loadword<_Size>(__s + __len - 8); + __b = __rotate(__a + __z, 52); + __c = __rotate(__a, 37); + __a += __loadword<_Size>(__s + __len - 24); + __c += __rotate(__a, 7); + __a += __loadword<_Size>(__s + __len - 16); + _Size __wf = __a + __z; + _Size __ws = __b + __rotate(__a, 31) + __c; + _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0); + return __shift_mix(__r * __k0 + __vs) * __k2; + } +}; + +// cityhash64 +template +_Size +__murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len) +{ + const char* __s = static_cast(__key); + if (__len <= 32) { + if (__len <= 16) { + return __hash_len_0_to_16(__s, __len); + } else { + return __hash_len_17_to_32(__s, __len); + } + } else if (__len <= 64) { + return __hash_len_33_to_64(__s, __len); + } + + // For strings over 64 bytes we hash the end first, and then as we + // loop we keep 56 bytes of state: v, w, x, y, and z. + _Size __x = __loadword<_Size>(__s + __len - 40); + _Size __y = __loadword<_Size>(__s + __len - 16) + + __loadword<_Size>(__s + __len - 56); + _Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len, + __loadword<_Size>(__s + __len - 24)); + pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z); + pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x); + __x = __x * __k1 + __loadword<_Size>(__s); + + // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks. + __len = (__len - 1) & ~static_cast<_Size>(63); + do { + __x = __rotate(__x + __y + __v.first + __loadword<_Size>(__s + 8), 37) * __k1; + __y = __rotate(__y + __v.second + __loadword<_Size>(__s + 48), 42) * __k1; + __x ^= __w.second; + __y += __v.first + __loadword<_Size>(__s + 40); + __z = __rotate(__z + __w.first, 33) * __k1; + __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first); + __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second, + __y + __loadword<_Size>(__s + 16)); + _CUDA_VSTD::swap(__z, __x); + __s += 64; + __len -= 64; + } while (__len != 0); + return __hash_len_16( + __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z, + __hash_len_16(__v.second, __w.second) + __x); +} + +template +struct __scalar_hash; + +template +struct __scalar_hash<_Tp, 0> + : public __unary_function<_Tp, size_t> +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(_Tp __v) const _NOEXCEPT + { + union + { + _Tp __t; + size_t __a; + } __u; + __u.__a = 0; + __u.__t = __v; + return __u.__a; + } +}; + +template +struct __scalar_hash<_Tp, 1> + : public __unary_function<_Tp, size_t> +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(_Tp __v) const _NOEXCEPT + { + union + { + _Tp __t; + size_t __a; + } __u; + __u.__t = __v; + return __u.__a; + } +}; + +template +struct __scalar_hash<_Tp, 2> + : public __unary_function<_Tp, size_t> +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(_Tp __v) const _NOEXCEPT + { + union + { + _Tp __t; + struct + { + size_t __a; + size_t __b; + } __s; + } __u; + __u.__t = __v; + return __murmur2_or_cityhash()(&__u, sizeof(__u)); + } +}; + +template +struct __scalar_hash<_Tp, 3> + : public __unary_function<_Tp, size_t> +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(_Tp __v) const _NOEXCEPT + { + union + { + _Tp __t; + struct + { + size_t __a; + size_t __b; + size_t __c; + } __s; + } __u; + __u.__t = __v; + return __murmur2_or_cityhash()(&__u, sizeof(__u)); + } +}; + +template +struct __scalar_hash<_Tp, 4> + : public __unary_function<_Tp, size_t> +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(_Tp __v) const _NOEXCEPT + { + union + { + _Tp __t; + struct + { + size_t __a; + size_t __b; + size_t __c; + size_t __d; + } __s; + } __u; + __u.__t = __v; + return __murmur2_or_cityhash()(&__u, sizeof(__u)); + } +}; + +struct _PairT { + size_t first; + size_t second; +}; + +_LIBCUDACXX_INLINE_VISIBILITY +inline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT { + typedef __scalar_hash<_PairT> _HashT; + const _PairT __p = {__lhs, __rhs}; + return _HashT()(__p); +} + +template +struct _LIBCUDACXX_TEMPLATE_VIS hash<_Tp*> + : public __unary_function<_Tp*, size_t> +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(_Tp* __v) const _NOEXCEPT + { + union + { + _Tp* __t; + size_t __a; + } __u; + __u.__t = __v; + return __murmur2_or_cityhash()(&__u, sizeof(__u)); + } +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(bool __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(char __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(signed char __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast(__v);} +}; + +#ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast(__v);} +}; +#endif // _LIBCUDACXX_HAS_NO_UNICODE_CHARS + +#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast(__v);} +}; +#endif // _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(short __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(int __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(long __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast(__v);} +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __scalar_hash +{ +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __scalar_hash +{ +}; + +#ifndef _LIBCUDACXX_HAS_NO_INT128 + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash<__int128_t> + : public __scalar_hash<__int128_t> +{ +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash<__uint128_t> + : public __scalar_hash<__uint128_t> +{ +}; + +#endif + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __scalar_hash +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(float __v) const _NOEXCEPT + { + // -0.0 and 0.0 should return same hash + if (__v == 0.0f) + return 0; + return __scalar_hash::operator()(__v); + } +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __scalar_hash +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(double __v) const _NOEXCEPT + { + // -0.0 and 0.0 should return same hash + if (__v == 0.0) + return 0; + return __scalar_hash::operator()(__v); + } +}; + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __scalar_hash +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(long double __v) const _NOEXCEPT + { + // -0.0 and 0.0 should return same hash + if (__v == 0.0L) + return 0; +#if defined(__i386__) || (defined(__x86_64__) && defined(__ILP32__)) + // Zero out padding bits + union + { + long double __t; + struct + { + size_t __a; + size_t __b; + size_t __c; + size_t __d; + } __s; + } __u; + __u.__s.__a = 0; + __u.__s.__b = 0; + __u.__s.__c = 0; + __u.__s.__d = 0; + __u.__t = __v; + return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d; +#elif defined(__x86_64__) + // Zero out padding bits + union + { + long double __t; + struct + { + size_t __a; + size_t __b; + } __s; + } __u; + __u.__s.__a = 0; + __u.__s.__b = 0; + __u.__t = __v; + return __u.__s.__a ^ __u.__s.__b; +#else + return __scalar_hash::operator()(__v); +#endif + } +}; + +template ::value> +struct _LIBCUDACXX_TEMPLATE_VIS __enum_hash + : public __unary_function<_Tp, size_t> +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(_Tp __v) const _NOEXCEPT + { + typedef typename underlying_type<_Tp>::type type; + return hash()(static_cast(__v)); + } +}; +template +struct _LIBCUDACXX_TEMPLATE_VIS __enum_hash<_Tp, false> { + __enum_hash() = delete; + __enum_hash(__enum_hash const&) = delete; + __enum_hash& operator=(__enum_hash const&) = delete; +}; + +template +struct _LIBCUDACXX_TEMPLATE_VIS hash : public __enum_hash<_Tp> +{ +}; + +#if _LIBCUDACXX_STD_VER > 14 + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS hash + : public __unary_function +{ + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(nullptr_t) const _NOEXCEPT { + return 662607004ull; + } +}; +#endif + +#ifndef _LIBCUDACXX_CXX03_LANG +template +using __check_hash_requirements _LIBCUDACXX_NODEBUG_TYPE = integral_constant::value && + is_move_constructible<_Hash>::value && + __invokable_r::value +>; + +template > +using __has_enabled_hash _LIBCUDACXX_NODEBUG_TYPE = integral_constant::value && + is_default_constructible<_Hash>::value +>; + +#if _LIBCUDACXX_STD_VER > 14 +template +using __enable_hash_helper_imp _LIBCUDACXX_NODEBUG_TYPE = _Type; + +template +using __enable_hash_helper _LIBCUDACXX_NODEBUG_TYPE = __enable_hash_helper_imp<_Type, + __enable_if_t<__all<__has_enabled_hash<_Keys>::value...>::value> +>; +#else +template +using __enable_hash_helper _LIBCUDACXX_NODEBUG_TYPE = _Type; +#endif + +#endif // !_LIBCUDACXX_CXX03_LANG + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // __cuda_std__ + +#endif // _LIBCUDACXX___FUNCTIONAL_HASH_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/identity.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/identity.h new file mode 100644 index 0000000000000000000000000000000000000000..592bc7d2f85bf104c141f66bac9ff9ed174ed9fd --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/identity.h @@ -0,0 +1,50 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_IDENTITY_H +#define _LIBCUDACXX___FUNCTIONAL_IDENTITY_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__utility/forward.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +struct __identity { + template + _LIBCUDACXX_NODISCARD_EXT _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR _Tp&& operator()(_Tp&& __t) const _NOEXCEPT { + return _CUDA_VSTD::forward<_Tp>(__t); + } + + using is_transparent = void; +}; + +#if _LIBCUDACXX_STD_VER > 11 + +struct identity { + template + _LIBCUDACXX_NODISCARD_EXT _LIBCUDACXX_INLINE_VISIBILITY constexpr _Tp&& operator()(_Tp&& __t) const noexcept + { + return _CUDA_VSTD::forward<_Tp>(__t); + } + + using is_transparent = void; +}; +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_IDENTITY_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/is_transparent.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/is_transparent.h new file mode 100644 index 0000000000000000000000000000000000000000..997718aa72f60f08a0881bec045c5d0a89c192b9 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/is_transparent.h @@ -0,0 +1,40 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_IS_TRANSPARENT +#define _LIBCUDACXX___FUNCTIONAL_IS_TRANSPARENT + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__type_traits/integral_constant.h" +#include "../__type_traits/void_t.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +template +struct __is_transparent : false_type {}; + +template +struct __is_transparent<_Tp, _Up, __void_t > + : true_type {}; + +#endif + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_IS_TRANSPARENT diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/mem_fn.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/mem_fn.h new file mode 100644 index 0000000000000000000000000000000000000000..4c0a1b901b0cfa954b0efffb5197cb82d04b8ef0 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/mem_fn.h @@ -0,0 +1,61 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_MEM_FN_H +#define _LIBCUDACXX___FUNCTIONAL_MEM_FN_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__functional/binary_function.h" +#include "../__functional/invoke.h" +#include "../__functional/weak_result_type.h" +#include "../__utility/forward.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +class __mem_fn : public __weak_result_type<_Tp> +{ +public: + // types + typedef _Tp type; +private: + type __f_; + +public: + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 + __mem_fn(type __f) _NOEXCEPT : __f_(__f) {} + + // invoke + template + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 + typename __invoke_return::type + operator() (_ArgTypes&&... __args) const { + return _CUDA_VSTD::__invoke(__f_, _CUDA_VSTD::forward<_ArgTypes>(__args)...); + } +}; + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 +__mem_fn<_Rp _Tp::*> +mem_fn(_Rp _Tp::* __pm) _NOEXCEPT +{ + return __mem_fn<_Rp _Tp::*>(__pm); +} + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_MEM_FN_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/operations.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/operations.h new file mode 100644 index 0000000000000000000000000000000000000000..a4400bf43d1f035d04e316d1aeda6e4aee8cec84 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/operations.h @@ -0,0 +1,622 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_OPERATIONS_H +#define _LIBCUDACXX___FUNCTIONAL_OPERATIONS_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__functional/binary_function.h" +#include "../__functional/unary_function.h" +#include "../__utility/forward.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +// Arithmetic operations + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS plus + : __binary_function<_Tp, _Tp, _Tp> +{ + typedef _Tp __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x + __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(plus); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS plus +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) + _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) + _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) + _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS minus + : __binary_function<_Tp, _Tp, _Tp> +{ + typedef _Tp __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x - __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(minus); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS minus +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) - _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) - _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) - _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS multiplies + : __binary_function<_Tp, _Tp, _Tp> +{ + typedef _Tp __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x * __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(multiplies); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS multiplies +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) * _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) * _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) * _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS divides + : __binary_function<_Tp, _Tp, _Tp> +{ + typedef _Tp __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x / __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(divides); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS divides +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) / _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) / _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) / _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS modulus + : __binary_function<_Tp, _Tp, _Tp> +{ + typedef _Tp __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x % __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(modulus); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS modulus +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) % _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) % _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) % _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS negate + : __unary_function<_Tp, _Tp> +{ + typedef _Tp __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return -__x;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(negate); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS negate +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_Tp&& __x) const + noexcept(noexcept(- _CUDA_VSTD::forward<_Tp>(__x))) + -> decltype( - _CUDA_VSTD::forward<_Tp>(__x)) + { return - _CUDA_VSTD::forward<_Tp>(__x); } + typedef void is_transparent; +}; +#endif + +// Bitwise operations + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS bit_and + : __binary_function<_Tp, _Tp, _Tp> +{ + typedef _Tp __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x & __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(bit_and); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS bit_and +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) & _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) & _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) & _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +struct _LIBCUDACXX_TEMPLATE_VIS bit_not + : __unary_function<_Tp, _Tp> +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return ~__x;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(bit_not); + +template <> +struct _LIBCUDACXX_TEMPLATE_VIS bit_not +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_Tp&& __x) const + noexcept(noexcept(~_CUDA_VSTD::forward<_Tp>(__x))) + -> decltype( ~_CUDA_VSTD::forward<_Tp>(__x)) + { return ~_CUDA_VSTD::forward<_Tp>(__x); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS bit_or + : __binary_function<_Tp, _Tp, _Tp> +{ + typedef _Tp __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x | __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(bit_or); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS bit_or +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) | _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) | _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) | _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS bit_xor + : __binary_function<_Tp, _Tp, _Tp> +{ + typedef _Tp __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x ^ __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(bit_xor); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS bit_xor +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) ^ _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) ^ _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) ^ _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +// Comparison operations + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS equal_to + : __binary_function<_Tp, _Tp, bool> +{ + typedef bool __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + bool operator()(const _Tp& __x, const _Tp& __y) const + {return __x == __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(equal_to); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS equal_to +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) == _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) == _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) == _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS not_equal_to + : __binary_function<_Tp, _Tp, bool> +{ + typedef bool __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + bool operator()(const _Tp& __x, const _Tp& __y) const + {return __x != __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(not_equal_to); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS not_equal_to +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) != _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) != _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) != _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS less + : __binary_function<_Tp, _Tp, bool> +{ + typedef bool __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + bool operator()(const _Tp& __x, const _Tp& __y) const + {return __x < __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(less); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS less +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) < _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) < _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) < _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS less_equal + : __binary_function<_Tp, _Tp, bool> +{ + typedef bool __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + bool operator()(const _Tp& __x, const _Tp& __y) const + {return __x <= __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(less_equal); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS less_equal +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) <= _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) <= _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) <= _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS greater_equal + : __binary_function<_Tp, _Tp, bool> +{ + typedef bool __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + bool operator()(const _Tp& __x, const _Tp& __y) const + {return __x >= __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(greater_equal); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS greater_equal +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) >= _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) >= _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) >= _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS greater + : __binary_function<_Tp, _Tp, bool> +{ + typedef bool __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + bool operator()(const _Tp& __x, const _Tp& __y) const + {return __x > __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(greater); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS greater +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) > _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) > _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) > _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +// Logical operations + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS logical_and + : __binary_function<_Tp, _Tp, bool> +{ + typedef bool __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + bool operator()(const _Tp& __x, const _Tp& __y) const + {return __x && __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(logical_and); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS logical_and +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) && _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) && _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) && _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS logical_not + : __unary_function<_Tp, bool> +{ + typedef bool __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + bool operator()(const _Tp& __x) const + {return !__x;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(logical_not); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS logical_not +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_Tp&& __x) const + noexcept(noexcept(!_CUDA_VSTD::forward<_Tp>(__x))) + -> decltype( !_CUDA_VSTD::forward<_Tp>(__x)) + { return !_CUDA_VSTD::forward<_Tp>(__x); } + typedef void is_transparent; +}; +#endif + +#if _LIBCUDACXX_STD_VER > 11 +template +#else +template +#endif +struct _LIBCUDACXX_TEMPLATE_VIS logical_or + : __binary_function<_Tp, _Tp, bool> +{ + typedef bool __result_type; // used by valarray + _LIBCUDACXX_DISABLE_EXEC_CHECK + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + bool operator()(const _Tp& __x, const _Tp& __y) const + {return __x || __y;} +}; +_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(logical_or); + +#if _LIBCUDACXX_STD_VER > 11 +template <> +struct _LIBCUDACXX_TEMPLATE_VIS logical_or +{ + _LIBCUDACXX_DISABLE_EXEC_CHECK + template + _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY + auto operator()(_T1&& __t, _T2&& __u) const + noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) || _CUDA_VSTD::forward<_T2>(__u))) + -> decltype( _CUDA_VSTD::forward<_T1>(__t) || _CUDA_VSTD::forward<_T2>(__u)) + { return _CUDA_VSTD::forward<_T1>(__t) || _CUDA_VSTD::forward<_T2>(__u); } + typedef void is_transparent; +}; +#endif + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_OPERATIONS_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/perfect_forward.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/perfect_forward.h new file mode 100644 index 0000000000000000000000000000000000000000..6fc538d947a9229164bb288401800c197846b7b7 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/perfect_forward.h @@ -0,0 +1,113 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_PERFECT_FORWARD_H +#define _LIBCUDACXX___FUNCTIONAL_PERFECT_FORWARD_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__concepts/__concept_macros.h" +#include "../__functional/invoke.h" +#include "../__type_traits/enable_if.h" +#include "../__type_traits/is_constructible.h" +#include "../__type_traits/is_nothrow_constructible.h" +#include "../__utility/declval.h" +#include "../__utility/forward.h" +#include "../__utility/integer_sequence.h" +#include "../__utility/move.h" + +#include "../tuple" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 14 + +template +struct __perfect_forward_impl; + +template +struct __perfect_forward_impl<_Op, index_sequence<_Idx...>, _BoundArgs...> { +private: + tuple<_BoundArgs...> __bound_args_; + +public: + _LIBCUDACXX_TEMPLATE(class... _Args) + (requires is_constructible_v, _Args&&...>) + _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY + explicit constexpr __perfect_forward_impl(_Args&&... __bound_args) + noexcept(is_nothrow_constructible_v, _Args&&...>) + : __bound_args_(_CUDA_VSTD::forward<_Args>(__bound_args)...) {} + + __perfect_forward_impl(__perfect_forward_impl const&) = default; + __perfect_forward_impl(__perfect_forward_impl&&) = default; + + __perfect_forward_impl& operator=(__perfect_forward_impl const&) = default; + __perfect_forward_impl& operator=(__perfect_forward_impl&&) = default; + + _LIBCUDACXX_TEMPLATE(class... _Args) + (requires is_invocable_v<_Op, _BoundArgs&..., _Args...>) + _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) & + noexcept(noexcept(_Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...))) + -> decltype( _Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...)) + { return _Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...); } + + _LIBCUDACXX_TEMPLATE(class... _Args) + (requires (!is_invocable_v<_Op, _BoundArgs&..., _Args...>)) + _LIBCUDACXX_INLINE_VISIBILITY auto operator()(_Args&&...) & = delete; + + _LIBCUDACXX_TEMPLATE(class... _Args) + (requires is_invocable_v<_Op, _BoundArgs const&..., _Args...>) + _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) const& + noexcept(noexcept(_Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...))) + -> decltype( _Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...)) + { return _Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...); } + + _LIBCUDACXX_TEMPLATE(class... _Args) + (requires (!is_invocable_v<_Op, _BoundArgs const&..., _Args...>)) + _LIBCUDACXX_INLINE_VISIBILITY auto operator()(_Args&&...) const& = delete; + + _LIBCUDACXX_TEMPLATE(class... _Args) + (requires is_invocable_v<_Op, _BoundArgs..., _Args...>) + _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) && + noexcept(noexcept(_Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...))) + -> decltype( _Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...)) + { return _Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...); } + + _LIBCUDACXX_TEMPLATE(class... _Args) + (requires (!is_invocable_v<_Op, _BoundArgs..., _Args...>)) + _LIBCUDACXX_INLINE_VISIBILITY auto operator()(_Args&&...) && = delete; + + _LIBCUDACXX_TEMPLATE(class... _Args) + (requires is_invocable_v<_Op, _BoundArgs const..., _Args...>) + _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) const&& + noexcept(noexcept(_Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...))) + -> decltype( _Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...)) + { return _Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...); } + + _LIBCUDACXX_TEMPLATE(class... _Args) + (requires (!is_invocable_v<_Op, _BoundArgs const..., _Args...>)) + _LIBCUDACXX_INLINE_VISIBILITY auto operator()(_Args&&...) const&& = delete; +}; + +// __perfect_forward implements a perfect-forwarding call wrapper as explained in [func.require]. +template +using __perfect_forward = __perfect_forward_impl<_Op, index_sequence_for<_Args...>, _Args...>; + +#endif // _LIBCUDACXX_STD_VER > 14 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_PERFECT_FORWARD_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/reference_wrapper.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/reference_wrapper.h new file mode 100644 index 0000000000000000000000000000000000000000..4fa4fb93c46dd11a689d71f749eaab09c4676cd0 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/reference_wrapper.h @@ -0,0 +1,103 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_REFERENCE_WRAPPER_H +#define _LIBCUDACXX___FUNCTIONAL_REFERENCE_WRAPPER_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__functional/weak_result_type.h" +#include "../__memory/addressof.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +class _LIBCUDACXX_TEMPLATE_VIS reference_wrapper : public __weak_result_type<_Tp> +{ +public: + // types + typedef _Tp type; +private: + type* __f_; + + static _LIBCUDACXX_INLINE_VISIBILITY void __fun(_Tp&) _NOEXCEPT; + static void __fun(_Tp&&) = delete; + +public: + template ::value, decltype(__fun(declval<_Up>())) > > + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 + reference_wrapper(_Up&& __u) _NOEXCEPT_(noexcept(__fun(declval<_Up>()))) { + type& __f = static_cast<_Up&&>(__u); + __f_ = _CUDA_VSTD::addressof(__f); + } + + // access + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 + operator type&() const _NOEXCEPT {return *__f_;} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 + type& get() const _NOEXCEPT {return *__f_;} + + // invoke + template + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 + typename __invoke_of::type + operator() (_ArgTypes&&... __args) const { + return _CUDA_VSTD::__invoke(get(), _CUDA_VSTD::forward<_ArgTypes>(__args)...); + } +}; + +#if _LIBCUDACXX_STD_VER > 14 && !defined(_LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES) +template +reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; +#endif + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 +reference_wrapper<_Tp> +ref(_Tp& __t) _NOEXCEPT +{ + return reference_wrapper<_Tp>(__t); +} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 +reference_wrapper<_Tp> +ref(reference_wrapper<_Tp> __t) _NOEXCEPT +{ + return __t; +} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 +reference_wrapper +cref(const _Tp& __t) _NOEXCEPT +{ + return reference_wrapper(__t); +} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 +reference_wrapper +cref(reference_wrapper<_Tp> __t) _NOEXCEPT +{ + return __t; +} + +template void ref(const _Tp&&) = delete; +template void cref(const _Tp&&) = delete; + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_REFERENCE_WRAPPER_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/weak_result_type.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/weak_result_type.h new file mode 100644 index 0000000000000000000000000000000000000000..1b1315306772fbe1ddf1654de575015ce47dfdfb --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/weak_result_type.h @@ -0,0 +1,297 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FUNCTIONAL_WEAK_RESULT_TYPE_H +#define _LIBCUDACXX___FUNCTIONAL_WEAK_RESULT_TYPE_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__functional/binary_function.h" +#include "../__functional/invoke.h" +#include "../__functional/unary_function.h" +#include "../__type_traits/integral_constant.h" +#include "../__type_traits/is_same.h" +#include "../__utility/declval.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +struct __has_result_type +{ +private: + template _LIBCUDACXX_INLINE_VISIBILITY static false_type __test(...); + template _LIBCUDACXX_INLINE_VISIBILITY static true_type __test(typename _Up::result_type* = 0); +public: + static const bool value = decltype(__test<_Tp>(0))::value; +}; + +// __weak_result_type + +template +struct __derives_from_unary_function +{ +private: + struct __two {char __lx; char __lxx;}; + static _LIBCUDACXX_INLINE_VISIBILITY __two __test(...); + template + static _LIBCUDACXX_INLINE_VISIBILITY __unary_function<_Ap, _Rp> + __test(const volatile __unary_function<_Ap, _Rp>*); + +public: + static const bool value = !is_same::value; + typedef decltype(__test((_Tp*)0)) type; +}; + +template +struct __derives_from_binary_function +{ +private: + struct __two {char __lx; char __lxx;}; + static __two _LIBCUDACXX_INLINE_VISIBILITY __test(...); + template + static _LIBCUDACXX_INLINE_VISIBILITY __binary_function<_A1, _A2, _Rp> + __test(const volatile __binary_function<_A1, _A2, _Rp>*); + +public: + static const bool value = !is_same::value; + typedef decltype(__test((_Tp*)0)) type; +}; + +template ::value> +struct __maybe_derive_from_unary_function // bool is true + : public __derives_from_unary_function<_Tp>::type +{ +}; + +template +struct __maybe_derive_from_unary_function<_Tp, false> +{ +}; + +template ::value> +struct __maybe_derive_from_binary_function // bool is true + : public __derives_from_binary_function<_Tp>::type +{ +}; + +template +struct __maybe_derive_from_binary_function<_Tp, false> +{ +}; + +template ::value> +struct __weak_result_type_imp // bool is true + : public __maybe_derive_from_unary_function<_Tp>, + public __maybe_derive_from_binary_function<_Tp> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = typename _Tp::result_type; +#endif +}; + +template +struct __weak_result_type_imp<_Tp, false> + : public __maybe_derive_from_unary_function<_Tp>, + public __maybe_derive_from_binary_function<_Tp> +{ +}; + +template +struct __weak_result_type + : public __weak_result_type_imp<_Tp> +{ +}; + +// 0 argument case + +template +struct __weak_result_type<_Rp ()> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +template +struct __weak_result_type<_Rp (&)()> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +template +struct __weak_result_type<_Rp (*)()> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +// 1 argument case + +template +struct __weak_result_type<_Rp (_A1)> + : public __unary_function<_A1, _Rp> +{ +}; + +template +struct __weak_result_type<_Rp (&)(_A1)> + : public __unary_function<_A1, _Rp> +{ +}; + +template +struct __weak_result_type<_Rp (*)(_A1)> + : public __unary_function<_A1, _Rp> +{ +}; + +template +struct __weak_result_type<_Rp (_Cp::*)()> + : public __unary_function<_Cp*, _Rp> +{ +}; + +template +struct __weak_result_type<_Rp (_Cp::*)() const> + : public __unary_function +{ +}; + +template +struct __weak_result_type<_Rp (_Cp::*)() volatile> + : public __unary_function +{ +}; + +template +struct __weak_result_type<_Rp (_Cp::*)() const volatile> + : public __unary_function +{ +}; + +// 2 argument case + +template +struct __weak_result_type<_Rp (_A1, _A2)> + : public __binary_function<_A1, _A2, _Rp> +{ +}; + +template +struct __weak_result_type<_Rp (*)(_A1, _A2)> + : public __binary_function<_A1, _A2, _Rp> +{ +}; + +template +struct __weak_result_type<_Rp (&)(_A1, _A2)> + : public __binary_function<_A1, _A2, _Rp> +{ +}; + +template +struct __weak_result_type<_Rp (_Cp::*)(_A1)> + : public __binary_function<_Cp*, _A1, _Rp> +{ +}; + +template +struct __weak_result_type<_Rp (_Cp::*)(_A1) const> + : public __binary_function +{ +}; + +template +struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile> + : public __binary_function +{ +}; + +template +struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile> + : public __binary_function +{ +}; + +// 3 or more arguments + +template +struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +template +struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +template +struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +template +struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +template +struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +template +struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +template +struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile> +{ +#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) + using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp; +#endif +}; + +template +struct __invoke_return +{ + typedef decltype(_CUDA_VSTD::__invoke(declval<_Tp>(), declval<_Args>()...)) type; +}; + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FUNCTIONAL_WEAK_RESULT_TYPE_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/array.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/array.h new file mode 100644 index 0000000000000000000000000000000000000000..af3240d40bbf163b48cffa5677a42920318aa71f --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/array.h @@ -0,0 +1,30 @@ +//===---------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===---------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FWD_ARRAY_H +#define _LIBCUDACXX___FWD_ARRAY_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +struct _LIBCUDACXX_TEMPLATE_VIS array; + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FWD_ARRAY_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/get.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/get.h new file mode 100644 index 0000000000000000000000000000000000000000..6cafa280c1207fcf8051a38bb7509fdafa6bade6 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/get.h @@ -0,0 +1,99 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FWD_GET_H +#define _LIBCUDACXX___FWD_GET_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__fwd/array.h" +#include "../__fwd/pair.h" +#include "../__fwd/tuple.h" +#include "../__tuple_dir/tuple_element.h" +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#ifndef _LIBCUDACXX_CXX03_LANG + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +typename tuple_element<_Ip, tuple<_Tp...> >::type& +get(tuple<_Tp...>&) _NOEXCEPT; + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +const typename tuple_element<_Ip, tuple<_Tp...> >::type& +get(const tuple<_Tp...>&) _NOEXCEPT; + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +typename tuple_element<_Ip, tuple<_Tp...> >::type&& +get(tuple<_Tp...>&&) _NOEXCEPT; + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +const typename tuple_element<_Ip, tuple<_Tp...> >::type&& +get(const tuple<_Tp...>&&) _NOEXCEPT; + +#endif // _LIBCUDACXX_CXX03_LANG + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +typename tuple_element<_Ip, pair<_T1, _T2> >::type& +get(pair<_T1, _T2>&) _NOEXCEPT; + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +const typename tuple_element<_Ip, pair<_T1, _T2> >::type& +get(const pair<_T1, _T2>&) _NOEXCEPT; + +#ifndef _LIBCUDACXX_CXX03_LANG +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +typename tuple_element<_Ip, pair<_T1, _T2> >::type&& +get(pair<_T1, _T2>&&) _NOEXCEPT; + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +const typename tuple_element<_Ip, pair<_T1, _T2> >::type&& +get(const pair<_T1, _T2>&&) _NOEXCEPT; +#endif // _LIBCUDACXX_CXX03_LANG + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +_Tp& +get(array<_Tp, _Size>&) _NOEXCEPT; + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +const _Tp& +get(const array<_Tp, _Size>&) _NOEXCEPT; + +#ifndef _LIBCUDACXX_CXX03_LANG +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +_Tp&& +get(array<_Tp, _Size>&&) _NOEXCEPT; + +template +_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 +const _Tp&& +get(const array<_Tp, _Size>&&) _NOEXCEPT; +#endif // _LIBCUDACXX_CXX03_LANG + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FWD_GET_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/hash.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/hash.h new file mode 100644 index 0000000000000000000000000000000000000000..67cef524e4500142b97d07984bbaf85b09d88369 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/hash.h @@ -0,0 +1,28 @@ +//===---------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===---------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FWD_HASH_H +#define _LIBCUDACXX___FWD_HASH_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +struct _LIBCUDACXX_TEMPLATE_VIS hash; + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FWD_HASH_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/memory_resource.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/memory_resource.h new file mode 100644 index 0000000000000000000000000000000000000000..fe6b74d38ac4e6a739331926338a43893d9a46a9 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/memory_resource.h @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FWD_MEMORY_RESOURCE_H +#define _LIBCUDACXX___FWD_MEMORY_RESOURCE_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +namespace pmr { +template +class _LIBCUDACXX_TEMPLATE_VIS polymorphic_allocator; +} // namespace pmr + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FWD_MEMORY_RESOURCE_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/pair.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/pair.h new file mode 100644 index 0000000000000000000000000000000000000000..eeb3b0a9bc2d7f45473d5409a5750a6a79dcc863 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/pair.h @@ -0,0 +1,28 @@ +//===---------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===---------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FWD_PAIR_H +#define _LIBCUDACXX___FWD_PAIR_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +struct _LIBCUDACXX_TEMPLATE_VIS pair; + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FWD_PAIR_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/span.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/span.h new file mode 100644 index 0000000000000000000000000000000000000000..10d19205499f4298587f1ef03e0a2a3990d0fc01 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/span.h @@ -0,0 +1,36 @@ +// -*- C++ -*- +//===---------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===---------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FWD_SPAN_H +#define _LIBCUDACXX___FWD_SPAN_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_INLINE_VAR constexpr size_t dynamic_extent = static_cast(-1); +template class span; + +#endif + +_LIBCUDACXX_END_NAMESPACE_STD + + +#endif // _LIBCUDACXX___FWD_SPAN_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/string.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/string.h new file mode 100644 index 0000000000000000000000000000000000000000..a24c849692e0aab30a8baf438d92386886867e24 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/string.h @@ -0,0 +1,114 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FWD_STRING_H +#define _LIBCUDACXX___FWD_STRING_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__fwd/memory_resource.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +struct _LIBCUDACXX_TEMPLATE_VIS char_traits; +template <> +struct char_traits; + +#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T +template <> +struct char_traits; +#endif + +template <> +struct char_traits; +template <> +struct char_traits; + +#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS +template <> +struct char_traits; +#endif + +template +class _LIBCUDACXX_TEMPLATE_VIS allocator; + +template , class _Allocator = allocator<_CharT> > +class _LIBCUDACXX_TEMPLATE_VIS basic_string; + +using string = basic_string; + +#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS +using wstring = basic_string; +#endif + +#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T +using u8string = basic_string; +#endif + +using u16string = basic_string; +using u32string = basic_string; + +#if _LIBCUDACXX_STD_VER >= 17 + +namespace pmr { +template > +using basic_string = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>; + +using string = basic_string; + +# ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS +using wstring = basic_string; +# endif + +# ifndef _LIBCUDACXX_NO_HAS_CHAR8_T +using u8string = basic_string; +# endif + +using u16string = basic_string; +using u32string = basic_string; + +} // namespace pmr + +#endif // _LIBCUDACXX_STD_VER >= 17 + +// clang-format off +template +class _LIBCUDACXX_PREFERRED_NAME(string) +#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS + _LIBCUDACXX_PREFERRED_NAME(wstring) +#endif +#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T + _LIBCUDACXX_PREFERRED_NAME(u8string) +#endif + _LIBCUDACXX_PREFERRED_NAME(u16string) + _LIBCUDACXX_PREFERRED_NAME(u32string) +#if _LIBCUDACXX_STD_VER >= 17 + _LIBCUDACXX_PREFERRED_NAME(pmr::string) +# ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS + _LIBCUDACXX_PREFERRED_NAME(pmr::wstring) +# endif +# ifndef _LIBCUDACXX_NO_HAS_CHAR8_T + _LIBCUDACXX_PREFERRED_NAME(pmr::u8string) +# endif + _LIBCUDACXX_PREFERRED_NAME(pmr::u16string) + _LIBCUDACXX_PREFERRED_NAME(pmr::u32string) +#endif + basic_string; +// clang-format on + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FWD_STRING_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/string_view.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/string_view.h new file mode 100644 index 0000000000000000000000000000000000000000..e82026ddd74a88e18a8aeaf0bf7ec0e954367561 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/string_view.h @@ -0,0 +1,54 @@ +// -*- C++ -*- +//===---------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===---------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FWD_STRING_VIEW_H +#define _LIBCUDACXX___FWD_STRING_VIEW_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__fwd/string.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template > +class _LIBCUDACXX_TEMPLATE_VIS basic_string_view; + +typedef basic_string_view string_view; +#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T +typedef basic_string_view u8string_view; +#endif +typedef basic_string_view u16string_view; +typedef basic_string_view u32string_view; +#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS +typedef basic_string_view wstring_view; +#endif + +// clang-format off +template +class _LIBCUDACXX_PREFERRED_NAME(string_view) +#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS + _LIBCUDACXX_PREFERRED_NAME(wstring_view) +#endif +#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T + _LIBCUDACXX_PREFERRED_NAME(u8string_view) +#endif + _LIBCUDACXX_PREFERRED_NAME(u16string_view) + _LIBCUDACXX_PREFERRED_NAME(u32string_view) + basic_string_view; +// clang-format on +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FWD_STRING_VIEW_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/tuple.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/tuple.h new file mode 100644 index 0000000000000000000000000000000000000000..7803b15cef137073f0079ec4e45a7533e99e350b --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/tuple.h @@ -0,0 +1,32 @@ +//===---------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===---------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___FWD_TUPLE_H +#define _LIBCUDACXX___FWD_TUPLE_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#ifndef _LIBCUDACXX_CXX03_LANG + +template +class _LIBCUDACXX_TEMPLATE_VIS tuple; + +#endif // _LIBCUDACXX_CXX03_LANG + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___FWD_TUPLE_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/data.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/data.h new file mode 100644 index 0000000000000000000000000000000000000000..7439964f621f5fc0b6a135f00cdb93962c7e5885 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/data.h @@ -0,0 +1,55 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ITERATOR_DATA_H +#define _LIBCUDACXX___ITERATOR_DATA_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../cstddef" +#include "../initializer_list" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +template constexpr +_LIBCUDACXX_INLINE_VISIBILITY +auto data(_Cont& __c) +_NOEXCEPT_(noexcept(__c.data())) +-> decltype (__c.data()) +{ return __c.data(); } + +template constexpr +_LIBCUDACXX_INLINE_VISIBILITY +auto data(const _Cont& __c) +_NOEXCEPT_(noexcept(__c.data())) +-> decltype (__c.data()) +{ return __c.data(); } + +template +_LIBCUDACXX_INLINE_VISIBILITY +constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept { return __array; } + +template +_LIBCUDACXX_INLINE_VISIBILITY +constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept { return __il.begin(); } + +#endif + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ITERATOR_DATA_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/empty.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/empty.h new file mode 100644 index 0000000000000000000000000000000000000000..536a2d0ed3737cac4972bd177d0946805fe76ddf --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/empty.h @@ -0,0 +1,48 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ITERATOR_EMPTY_H +#define _LIBCUDACXX___ITERATOR_EMPTY_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../cstddef" +#include "../initializer_list" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +template +_LIBCUDACXX_NODISCARD_AFTER_CXX17 _LIBCUDACXX_INLINE_VISIBILITY +constexpr auto empty(const _Cont& __c) +_NOEXCEPT_(noexcept(__c.empty())) +-> decltype (__c.empty()) +{ return __c.empty(); } + +template +_LIBCUDACXX_NODISCARD_AFTER_CXX17 _LIBCUDACXX_INLINE_VISIBILITY +constexpr bool empty(const _Tp (&)[_Sz]) noexcept { return false; } + +template +_LIBCUDACXX_NODISCARD_AFTER_CXX17 _LIBCUDACXX_INLINE_VISIBILITY +constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; } + +#endif // _LIBCUDACXX_STD_VER > 17 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ITERATOR_EMPTY_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/erase_if_container.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/erase_if_container.h new file mode 100644 index 0000000000000000000000000000000000000000..ec26718362cda05c0c37863fbfab51a88982a9c1 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/erase_if_container.h @@ -0,0 +1,43 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ITERATOR_ERASE_IF_CONTAINER_H +#define _LIBCUDACXX___ITERATOR_ERASE_IF_CONTAINER_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +_LIBCUDACXX_INLINE_VISIBILITY +typename _Container::size_type +__libcpp_erase_if_container(_Container& __c, _Predicate& __pred) { + typename _Container::size_type __old_size = __c.size(); + + const typename _Container::iterator __last = __c.end(); + for (typename _Container::iterator __iter = __c.begin(); __iter != __last;) { + if (__pred(*__iter)) + __iter = __c.erase(__iter); + else + ++__iter; + } + + return __old_size - __c.size(); +} + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ITERATOR_ERASE_IF_CONTAINER_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/front_insert_iterator.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/front_insert_iterator.h new file mode 100644 index 0000000000000000000000000000000000000000..a989a3bba794668a36f6cc799dc3d230ee6d4320 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/front_insert_iterator.h @@ -0,0 +1,69 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ITERATOR_FRONT_INSERT_ITERATOR_H +#define _LIBCUDACXX___ITERATOR_FRONT_INSERT_ITERATOR_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__iterator/iterator.h" +#include "../__iterator/iterator_traits.h" +#include "../__memory/addressof.h" +#include "../__utility/move.h" +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +_LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH +template +class _LIBCUDACXX_TEMPLATE_VIS front_insert_iterator +#if _LIBCUDACXX_STD_VER <= 14 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES) + : public iterator +#endif +{ +_LIBCUDACXX_SUPPRESS_DEPRECATED_POP +protected: + _Container* container; +public: + typedef _Container container_type; + + _LIBCUDACXX_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(_CUDA_VSTD::addressof(__x)) {} + _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value_) + {container->push_front(__value_); return *this;} +#ifndef _LIBCUDACXX_CXX03_LANG + _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value_) + {container->push_front(_CUDA_VSTD::move(__value_)); return *this;} +#endif // _LIBCUDACXX_CXX03_LANG + _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator& operator*() {return *this;} + _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator& operator++() {return *this;} + _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator operator++(int) {return *this;} +}; + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +front_insert_iterator<_Container> +front_inserter(_Container& __x) +{ + return front_insert_iterator<_Container>(__x); +} + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ITERATOR_FRONT_INSERT_ITERATOR_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/insert_iterator.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/insert_iterator.h new file mode 100644 index 0000000000000000000000000000000000000000..35a866afaaf9622256c916f5a51dc25ba8e0a9ab --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/insert_iterator.h @@ -0,0 +1,71 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ITERATOR_INSERT_ITERATOR_H +#define _LIBCUDACXX___ITERATOR_INSERT_ITERATOR_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__iterator/iterator_traits.h" +#include "../__iterator/iterator.h" +#include "../__memory/addressof.h" +#include "../__utility/move.h" +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +_LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH +template +class _LIBCUDACXX_TEMPLATE_VIS insert_iterator +#if _LIBCUDACXX_STD_VER <= 14 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES) + : public iterator +#endif +{ +_LIBCUDACXX_SUPPRESS_DEPRECATED_POP +protected: + _Container* container; + typename _Container::iterator iter; +public: + typedef _Container container_type; + + _LIBCUDACXX_INLINE_VISIBILITY insert_iterator(_Container& __x, typename _Container::iterator __i) + : container(_CUDA_VSTD::addressof(__x)), iter(__i) {} + _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value_) + {iter = container->insert(iter, __value_); ++iter; return *this;} +#ifndef _LIBCUDACXX_CXX03_LANG + _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value_) + {iter = container->insert(iter, _CUDA_VSTD::move(__value_)); ++iter; return *this;} +#endif // _LIBCUDACXX_CXX03_LANG + _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator*() {return *this;} + _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator++() {return *this;} + _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator++(int) {return *this;} +}; + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +insert_iterator<_Container> +inserter(_Container& __x, typename _Container::iterator __i) +{ + return insert_iterator<_Container>(__x, __i); +} + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ITERATOR_INSERT_ITERATOR_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/next.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/next.h new file mode 100644 index 0000000000000000000000000000000000000000..3ea7022f82e0e51a2db5b1c516952c4f19a38561 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/next.h @@ -0,0 +1,48 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ITERATOR_NEXT_H +#define _LIBCUDACXX___ITERATOR_NEXT_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__assert" +#include "../__iterator/advance.h" +#include "../__iterator/iterator_traits.h" +#include "../__type_traits/enable_if.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +__enable_if_t +< + __is_cpp17_input_iterator<_InputIter>::value, + _InputIter +> +next(_InputIter __x, + typename iterator_traits<_InputIter>::difference_type __n = 1) +{ + _LIBCUDACXX_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value, + "Attempt to next(it, -n) on a non-bidi iterator"); + + _CUDA_VSTD::advance(__x, __n); + return __x; +} + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ITERATOR_NEXT_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/ostreambuf_iterator.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/ostreambuf_iterator.h new file mode 100644 index 0000000000000000000000000000000000000000..68207b14a699608cd55fb92fe7c520b4d729df90 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/ostreambuf_iterator.h @@ -0,0 +1,71 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ITERATOR_OSTREAMBUF_ITERATOR_H +#define _LIBCUDACXX___ITERATOR_OSTREAMBUF_ITERATOR_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__iterator/iterator.h" +#include "../__iterator/iterator_traits.h" +#include "../cstddef" +#include "../iosfwd" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +_LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH +template +class _LIBCUDACXX_TEMPLATE_VIS ostreambuf_iterator +#if _LIBCUDACXX_STD_VER <= 14 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES) + : public iterator +#endif +{ +_LIBCUDACXX_SUPPRESS_DEPRECATED_POP +public: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_streambuf<_CharT,_Traits> streambuf_type; + typedef basic_ostream<_CharT,_Traits> ostream_type; +private: + streambuf_type* __sbuf_; +public: + _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT + : __sbuf_(__s.rdbuf()) {} + _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT + : __sbuf_(__s) {} + _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c) + { + if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof())) + __sbuf_ = 0; + return *this; + } + _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator& operator*() {return *this;} + _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator& operator++() {return *this;} + _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;} + _LIBCUDACXX_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == 0;} + + template + friend + _LIBCUDACXX_HIDDEN _LIBCUDACXX_HOST_DEVICE + ostreambuf_iterator<_Ch, _Tr> + __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s, + const _Ch* __ob, const _Ch* __op, const _Ch* __oe, + ios_base& __iob, _Ch __fl); +}; + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ITERATOR_OSTREAMBUF_ITERATOR_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/prev.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/prev.h new file mode 100644 index 0000000000000000000000000000000000000000..2a42936622243d836ad82390db2d2f3e6f1cf20e --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/prev.h @@ -0,0 +1,47 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ITERATOR_PREV_H +#define _LIBCUDACXX___ITERATOR_PREV_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__assert" +#include "../__iterator/advance.h" +#include "../__iterator/iterator_traits.h" +#include "../__type_traits/enable_if.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +__enable_if_t +< + __is_cpp17_input_iterator<_InputIter>::value, + _InputIter +> +prev(_InputIter __x, + typename iterator_traits<_InputIter>::difference_type __n = 1) +{ + _LIBCUDACXX_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value, + "Attempt to prev(it, +n) on a non-bidi iterator"); + _CUDA_VSTD::advance(__x, -__n); + return __x; +} + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ITERATOR_PREV_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/reverse_iterator.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/reverse_iterator.h new file mode 100644 index 0000000000000000000000000000000000000000..75896e2f27ebd410131873901074d54c229afd80 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/reverse_iterator.h @@ -0,0 +1,186 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___ITERATOR_REVERSE_ITERATOR_H +#define _LIBCUDACXX___ITERATOR_REVERSE_ITERATOR_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__iterator/iterator.h" +#include "../__iterator/iterator_traits.h" +#include "../__memory/addressof.h" +#include "../__type_traits/void_t.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +struct __is_cpp17_stashing_iterator : false_type {}; + +template +struct __is_cpp17_stashing_iterator<_Tp, __void_t> + : true_type {}; + +_LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH +template +class _LIBCUDACXX_TEMPLATE_VIS reverse_iterator +#if _LIBCUDACXX_STD_VER <= 14 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES) + : public iterator::iterator_category, + typename iterator_traits<_Iter>::value_type, + typename iterator_traits<_Iter>::difference_type, + typename iterator_traits<_Iter>::pointer, + typename iterator_traits<_Iter>::reference> +#endif +{ +_LIBCUDACXX_SUPPRESS_DEPRECATED_POP +private: + /*mutable*/ _Iter __t; // no longer used as of LWG #2360, not removed due to ABI break + + static_assert(!__is_cpp17_stashing_iterator<_Iter>::value, + "The specified iterator type cannot be used with reverse_iterator; " + "Using stashing iterators with reverse_iterator causes undefined behavior"); + +protected: + _Iter current; +public: + typedef _Iter iterator_type; + typedef typename iterator_traits<_Iter>::difference_type difference_type; + typedef typename iterator_traits<_Iter>::reference reference; + typedef typename iterator_traits<_Iter>::pointer pointer; + + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator() : __t(), current() {} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {} + template + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator(const reverse_iterator<_Up>& __u) : __t(__u.base()), current(__u.base()) {} + template + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator& operator=(const reverse_iterator<_Up>& __u) + { __t = current = __u.base(); return *this; } + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + _Iter base() const {return current;} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reference operator*() const {_Iter __tmp = current; return *--__tmp;} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + pointer operator->() const {return _CUDA_VSTD::addressof(operator*());} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator& operator++() {--current; return *this;} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator& operator--() {++current; return *this;} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator operator+ (difference_type __n) const {return reverse_iterator(current - __n);} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator operator- (difference_type __n) const {return reverse_iterator(current + __n);} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;} + _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 + reference operator[](difference_type __n) const {return *(*this + __n);} +}; + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +bool +operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) +{ + return __x.base() == __y.base(); +} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +bool +operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) +{ + return __x.base() > __y.base(); +} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +bool +operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) +{ + return __x.base() != __y.base(); +} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +bool +operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) +{ + return __x.base() < __y.base(); +} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +bool +operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) +{ + return __x.base() <= __y.base(); +} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +bool +operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) +{ + return __x.base() >= __y.base(); +} + +#ifndef _LIBCUDACXX_CXX03_LANG +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +auto +operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) +-> decltype(__y.base() - __x.base()) +{ + return __y.base() - __x.base(); +} +#else +template +inline _LIBCUDACXX_INLINE_VISIBILITY +typename reverse_iterator<_Iter1>::difference_type +operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) +{ + return __y.base() - __x.base(); +} +#endif + +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +reverse_iterator<_Iter> +operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x) +{ + return reverse_iterator<_Iter>(__x.base() - __n); +} + +#if _LIBCUDACXX_STD_VER > 11 +template +inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 +reverse_iterator<_Iter> make_reverse_iterator(_Iter __i) +{ + return reverse_iterator<_Iter>(__i); +} +#endif + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___ITERATOR_REVERSE_ITERATOR_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/compressed_pair.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/compressed_pair.h new file mode 100644 index 0000000000000000000000000000000000000000..07fe2bdd55e285ee8c5379b92b107cc35de1f38b --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/compressed_pair.h @@ -0,0 +1,240 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_COMPRESSED_PAIR_HPP +#define _LIBCUDACXX___MDSPAN_COMPRESSED_PAIR_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/macros.h" +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS +#include "../__mdspan/no_unique_address.h" +#endif +#include "../__type_traits/enable_if.h" +#include "../__type_traits/is_empty.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +namespace __detail { + +// For no unique address emulation, this is the case taken when neither are empty. +// For real `[[no_unique_address]]`, this case is always taken. +template struct __compressed_pair { + _LIBCUDACXX_NO_UNIQUE_ADDRESS _Tp __t_val; + _LIBCUDACXX_NO_UNIQUE_ADDRESS _Up __u_val; + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__first() noexcept { return __t_val; } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__first() const noexcept { + return __t_val; + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up &__second() noexcept { return __u_val; } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up const &__second() const noexcept { + return __u_val; + } + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair(__compressed_pair const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair(__compressed_pair &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & + operator=(__compressed_pair const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & + operator=(__compressed_pair &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__compressed_pair() noexcept = default; + template + __MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u) + : __t_val((_TLike &&) __t), __u_val((_ULike &&) __u) {} +}; + +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + +// First empty. +template +struct __compressed_pair< + _Tp, _Up, + _CUDA_VSTD::enable_if_t<_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Tp) && !_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Up)>> + : private _Tp { + _Up __u_val; + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__first() noexcept { + return *static_cast<_Tp *>(this); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__first() const noexcept { + return *static_cast<_Tp const *>(this); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up &__second() noexcept { return __u_val; } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up const &__second() const noexcept { + return __u_val; + } + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair(__compressed_pair const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair(__compressed_pair &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & + operator=(__compressed_pair const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & + operator=(__compressed_pair &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__compressed_pair() noexcept = default; + template + __MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u) + : _Tp((_TLike &&) __t), __u_val((_ULike &&) __u) {} +}; + +// Second empty. +template +struct __compressed_pair< + _Tp, _Up, + _CUDA_VSTD::enable_if_t> + : private _Up { + _Tp __t_val; + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__first() noexcept { return __t_val; } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__first() const noexcept { + return __t_val; + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up &__second() noexcept { + return *static_cast<_Up *>(this); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up const &__second() const noexcept { + return *static_cast<_Up const *>(this); + } + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair(__compressed_pair const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair(__compressed_pair &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & + operator=(__compressed_pair const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & + operator=(__compressed_pair &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__compressed_pair() noexcept = default; + + template + __MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u) + : _Up((_ULike &&) __u), __t_val((_TLike &&) __t) {} +}; + +// Both empty. +template +struct __compressed_pair< + _Tp, _Up, + _CUDA_VSTD::enable_if_t<_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Tp) && _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Up)>> + // We need to use the __no_unique_address_emulation wrapper here to avoid + // base class ambiguities. +#ifdef __MDSPAN_COMPILER_MSVC +// MSVC doesn't allow you to access public static member functions of a type +// when you *happen* to privately inherit from that type. + : protected __no_unique_address_emulation<_Tp, 0>, + protected __no_unique_address_emulation<_Up, 1> +#else + : private __no_unique_address_emulation<_Tp, 0>, + private __no_unique_address_emulation<_Up, 1> +#endif +{ + using __first_base_t = __no_unique_address_emulation<_Tp, 0>; + using __second_base_t = __no_unique_address_emulation<_Up, 1>; + + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__first() noexcept { + return this->__first_base_t::__ref(); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__first() const noexcept { + return this->__first_base_t::__ref(); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up &__second() noexcept { + return this->__second_base_t::__ref(); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up const &__second() const noexcept { + return this->__second_base_t::__ref(); + } + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair(__compressed_pair const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __compressed_pair(__compressed_pair &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & + operator=(__compressed_pair const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair & + operator=(__compressed_pair &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__compressed_pair() noexcept = default; + template + __MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u) noexcept + : __first_base_t(_Tp((_TLike &&) __t)), + __second_base_t(_Up((_ULike &&) __u)) + { } +}; + +#endif // !_LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + +} // end namespace __detail + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_COMPRESSED_PAIR_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/config.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/config.h new file mode 100644 index 0000000000000000000000000000000000000000..dc2de57dbd8b071e1507ff08e05ae79540f624cc --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/config.h @@ -0,0 +1,287 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_CONFIG_HPP +#define _LIBCUDACXX___MDSPAN_CONFIG_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#if _LIBCUDACXX_STD_VER > 11 + +#ifndef __has_include +# define __has_include(x) 0 +#endif + +#ifndef __cuda_std__ +#if __has_include() +# include +#else +# include +# include +#endif +#endif + +#ifdef _MSVC_LANG +#define __MDSPAN_CPLUSPLUS _MSVC_LANG +#else +#define __MDSPAN_CPLUSPLUS __cplusplus +#endif + +#define __MDSPAN_CXX_STD_14 201402L +#define __MDSPAN_CXX_STD_17 201703L +#define __MDSPAN_CXX_STD_20 202002L + +#define __MDSPAN_HAS_CXX_14 (__MDSPAN_CPLUSPLUS >= __MDSPAN_CXX_STD_14) +#define __MDSPAN_HAS_CXX_17 (__MDSPAN_CPLUSPLUS >= __MDSPAN_CXX_STD_17) +#define __MDSPAN_HAS_CXX_20 (__MDSPAN_CPLUSPLUS >= __MDSPAN_CXX_STD_20) + +static_assert(__MDSPAN_CPLUSPLUS >= __MDSPAN_CXX_STD_14, "mdspan requires C++14 or later."); + +#ifndef __MDSPAN_COMPILER_CLANG +# if defined(__clang__) +# define __MDSPAN_COMPILER_CLANG __clang__ +# endif +#endif + +#if !defined(__MDSPAN_COMPILER_MSVC) && !defined(__MDSPAN_COMPILER_MSVC_CLANG) +# if defined(_MSC_VER) +# if !defined(__MDSPAN_COMPILER_CLANG) +# define __MDSPAN_COMPILER_MSVC _MSC_VER +# else +# define __MDSPAN_COMPILER_MSVC_CLANG _MSC_VER +# endif +# endif +#endif + +#ifndef __MDSPAN_COMPILER_INTEL +# ifdef __INTEL_COMPILER +# define __MDSPAN_COMPILER_INTEL __INTEL_COMPILER +# endif +#endif + +#ifndef __MDSPAN_COMPILER_APPLECLANG +# ifdef __apple_build_version__ +# define __MDSPAN_COMPILER_APPLECLANG __apple_build_version__ +# endif +#endif + +#ifndef __MDSPAN_HAS_CUDA +# if defined(__CUDACC__) +# define __MDSPAN_HAS_CUDA __CUDACC__ +# endif +#endif + +#ifndef __MDSPAN_HAS_HIP +# if defined(__HIPCC__) +# define __MDSPAN_HAS_HIP __HIPCC__ +# endif +#endif + +#ifndef __has_cpp_attribute +# define __has_cpp_attribute(x) 0 +#endif + +#ifndef __MDSPAN_PRESERVE_STANDARD_LAYOUT +// Preserve standard layout by default, but we're not removing the old version +// that turns this off until we're sure this doesn't have an unreasonable cost +// to the compiler or optimizer. +# define __MDSPAN_PRESERVE_STANDARD_LAYOUT 1 +#endif + +#ifndef __MDSPAN_USE_CONCEPTS +// Looks like concepts doesn't work in CUDA 12 +# if defined(__cpp_concepts) && __cpp_concepts >= 201507L && !defined __cuda_std__ +# define __MDSPAN_USE_CONCEPTS 1 +# endif +#endif + +#ifndef __MDSPAN_USE_FOLD_EXPRESSIONS +# if (defined(__cpp_fold_expressions) && __cpp_fold_expressions >= 201603L) \ + || (!defined(__cpp_fold_expressions) && __MDSPAN_HAS_CXX_17) +# define __MDSPAN_USE_FOLD_EXPRESSIONS 1 +# endif +#endif + +#ifndef __MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS +# if (!(defined(__cpp_lib_type_trait_variable_templates) && __cpp_lib_type_trait_variable_templates >= 201510L) \ + || !__MDSPAN_HAS_CXX_17) +# if !(defined(__MDSPAN_COMPILER_APPLECLANG) && __MDSPAN_HAS_CXX_17) +# define __MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS 1 +# endif +# endif +#endif + +#ifndef __MDSPAN_USE_VARIABLE_TEMPLATES +# if (defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304 && __MDSPAN_HAS_CXX_17) \ + || (!defined(__cpp_variable_templates) && __MDSPAN_HAS_CXX_17) +# define __MDSPAN_USE_VARIABLE_TEMPLATES 1 +# endif +#endif // __MDSPAN_USE_VARIABLE_TEMPLATES + +#ifndef __MDSPAN_USE_CONSTEXPR_14 +# if (defined(__cpp_constexpr) && __cpp_constexpr >= 201304) \ + || (!defined(__cpp_constexpr) && __MDSPAN_HAS_CXX_14) \ + && (!(defined(__INTEL_COMPILER) && __INTEL_COMPILER <= 1700)) +# define __MDSPAN_USE_CONSTEXPR_14 1 +# endif +#endif + +#ifndef __MDSPAN_USE_INTEGER_SEQUENCE +# if defined(__MDSPAN_COMPILER_MSVC) +# if (defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304) +# define __MDSPAN_USE_INTEGER_SEQUENCE 1 +# endif +# endif +#endif +#ifndef __MDSPAN_USE_INTEGER_SEQUENCE +# if (defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304) \ + || (!defined(__cpp_lib_integer_sequence) && __MDSPAN_HAS_CXX_14) \ + /* as far as I can tell, libc++ seems to think this is a C++11 feature... */ \ + || (defined(__GLIBCXX__) && __GLIBCXX__ > 20150422 && __GNUC__ < 5 && !defined(__INTEL_CXX11_MODE__)) + // several compilers lie about integer_sequence working properly unless the C++14 standard is used +# define __MDSPAN_USE_INTEGER_SEQUENCE 1 +# elif defined(__MDSPAN_COMPILER_APPLECLANG) && __MDSPAN_HAS_CXX_14 + // appleclang seems to be missing the __cpp_lib_... macros, but doesn't seem to lie about C++14 making + // integer_sequence work +# define __MDSPAN_USE_INTEGER_SEQUENCE 1 +# endif +#endif + +#ifndef __MDSPAN_USE_RETURN_TYPE_DEDUCTION +# if (defined(__cpp_return_type_deduction) && __cpp_return_type_deduction >= 201304) \ + || (!defined(__cpp_return_type_deduction) && __MDSPAN_HAS_CXX_14) +# define __MDSPAN_USE_RETURN_TYPE_DEDUCTION 1 +# endif +#endif + +#ifndef __MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION +// GCC 10 is known not to work with CTAD for this case. +# if (defined(__MDSPAN_COMPILER_CLANG) || !defined(_LIBCUDACXX_COMPILER_GCC) || __GNUC__ >= 11) \ + && ((defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201703) \ + || (!defined(__cpp_deduction_guides) && __MDSPAN_HAS_CXX_17)) +# define __MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1 +# endif +#endif + +#ifndef __MDSPAN_USE_ALIAS_TEMPLATE_ARGUMENT_DEDUCTION +// GCC 10 is known not to work with CTAD for this case. +# if (defined(__MDSPAN_COMPILER_CLANG) || !defined(_LIBCUDACXX_COMPILER_GCC) || __GNUC__ >= 11) \ + && ((defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201907) \ + || (!defined(__cpp_deduction_guides) && __MDSPAN_HAS_CXX_20)) +# define __MDSPAN_USE_ALIAS_TEMPLATE_ARGUMENT_DEDUCTION 1 +# endif +#endif + +#ifndef __MDSPAN_USE_STANDARD_TRAIT_ALIASES +# if (defined(__cpp_lib_transformation_trait_aliases) && __cpp_lib_transformation_trait_aliases >= 201304) \ + || (!defined(__cpp_lib_transformation_trait_aliases) && __MDSPAN_HAS_CXX_14) +# define __MDSPAN_USE_STANDARD_TRAIT_ALIASES 1 +# elif defined(__MDSPAN_COMPILER_APPLECLANG) && __MDSPAN_HAS_CXX_14 + // appleclang seems to be missing the __cpp_lib_... macros, but doesn't seem to lie about C++14 +# define __MDSPAN_USE_STANDARD_TRAIT_ALIASES 1 +# endif +#endif + +#ifndef __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND +# ifdef __GNUC__ +# if __GNUC__ < 9 +# define __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND 1 +# endif +# endif +#endif + +#ifndef __MDSPAN_CONDITIONAL_EXPLICIT +# if __MDSPAN_HAS_CXX_20 && !defined(__MDSPAN_COMPILER_MSVC) +# define __MDSPAN_CONDITIONAL_EXPLICIT(COND) explicit(COND) +# else +# define __MDSPAN_CONDITIONAL_EXPLICIT(COND) +# endif +#endif + +#ifndef __MDSPAN_USE_BRACKET_OPERATOR +# if defined(__cpp_multidimensional_subscript) +# define __MDSPAN_USE_BRACKET_OPERATOR 1 +# else +# define __MDSPAN_USE_BRACKET_OPERATOR 0 +# endif +#endif + +#ifndef __MDSPAN_USE_PAREN_OPERATOR +# if !__MDSPAN_USE_BRACKET_OPERATOR +# define __MDSPAN_USE_PAREN_OPERATOR 1 +# else +# define __MDSPAN_USE_PAREN_OPERATOR 0 +# endif +#endif + +#if __MDSPAN_USE_BRACKET_OPERATOR +# define __MDSPAN_OP(mds,...) mds[__VA_ARGS__] +// Corentins demo compiler for subscript chokes on empty [] call, +// though I believe the proposal supports it? +#ifdef __MDSPAN_NO_EMPTY_BRACKET_OPERATOR +# define __MDSPAN_OP0(mds) mds.accessor().access(mds.data_handle(),0) +#else +# define __MDSPAN_OP0(mds) mds[] +#endif +# define __MDSPAN_OP1(mds, a) mds[a] +# define __MDSPAN_OP2(mds, a, b) mds[a,b] +# define __MDSPAN_OP3(mds, a, b, c) mds[a,b,c] +# define __MDSPAN_OP4(mds, a, b, c, d) mds[a,b,c,d] +# define __MDSPAN_OP5(mds, a, b, c, d, e) mds[a,b,c,d,e] +# define __MDSPAN_OP6(mds, a, b, c, d, e, f) mds[a,b,c,d,e,f] +#else +# define __MDSPAN_OP(mds,...) mds(__VA_ARGS__) +# define __MDSPAN_OP0(mds) mds() +# define __MDSPAN_OP1(mds, a) mds(a) +# define __MDSPAN_OP2(mds, a, b) mds(a,b) +# define __MDSPAN_OP3(mds, a, b, c) mds(a,b,c) +# define __MDSPAN_OP4(mds, a, b, c, d) mds(a,b,c,d) +# define __MDSPAN_OP5(mds, a, b, c, d, e) mds(a,b,c,d,e) +# define __MDSPAN_OP6(mds, a, b, c, d, e, f) mds(a,b,c,d,e,f) +#endif + +#endif // _LIBCUDACXX_STD_VER > 11 + +#endif // _LIBCUDACXX___MDSPAN_CONFIG_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/default_accessor.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/default_accessor.h new file mode 100644 index 0000000000000000000000000000000000000000..45f87823de1bc59df426b1555e8ec06d8ee67b47 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/default_accessor.h @@ -0,0 +1,99 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_DEFAULT_ACCESSOR_HPP +#define _LIBCUDACXX___MDSPAN_DEFAULT_ACCESSOR_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/macros.h" +#include "../__type_traits/is_convertible.h" +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +template +struct default_accessor { + + using offset_policy = default_accessor; + using element_type = _ElementType; + using reference = _ElementType&; + using data_handle_type = _ElementType*; + + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr default_accessor() noexcept = default; + + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherElementType, + /* requires */ ( + _LIBCUDACXX_TRAIT(is_convertible, _OtherElementType(*)[], element_type(*)[]) + ) + ) + __MDSPAN_INLINE_FUNCTION + constexpr default_accessor(default_accessor<_OtherElementType>) noexcept {} + + __MDSPAN_INLINE_FUNCTION + constexpr data_handle_type + offset(data_handle_type __p, size_t __i) const noexcept { + return __p + __i; + } + + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr reference access(data_handle_type __p, size_t __i) const noexcept { + return __p[__i]; + } + +}; + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_DEFAULT_ACCESSOR_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/dynamic_extent.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/dynamic_extent.h new file mode 100644 index 0000000000000000000000000000000000000000..0fb760c9f2deaa0a4af6f1c308e9ab12e67d43a3 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/dynamic_extent.h @@ -0,0 +1,83 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_DYNAMIC_EXTENT_HPP +#define _LIBCUDACXX___MDSPAN_DYNAMIC_EXTENT_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__fwd/span.h" // dynamic_extent +#include "../__mdspan/macros.h" +#include "../cstddef" +#include "../limits" // numeric_limits + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +namespace __detail { + +template +_LIBCUDACXX_HOST_DEVICE constexpr auto __make_dynamic_extent() { + return dynamic_extent; +} + +template +_LIBCUDACXX_HOST_DEVICE constexpr auto __make_dynamic_extent_integral() { + return dynamic_extent; +} + +} // end namespace __detail + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +//============================================================================================================== + +#endif // _LIBCUDACXX___MDSPAN_DYNAMIC_EXTENT_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/extents.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/extents.h new file mode 100644 index 0000000000000000000000000000000000000000..1f82f3a3895d5256f86abf7b7e1b9983d558b0a3 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/extents.h @@ -0,0 +1,579 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_EXTENTS_HPP +#define _LIBCUDACXX___MDSPAN_EXTENTS_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/macros.h" +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS +#include "../__mdspan/no_unique_address.h" +#endif +#include "../__mdspan/static_array.h" +#include "../__mdspan/standard_layout_static_array.h" +#include "../__type_traits/conditional.h" +#include "../__type_traits/integral_constant.h" +#include "../__type_traits/is_convertible.h" +#include "../__type_traits/is_nothrow_constructible.h" +#include "../__type_traits/make_unsigned.h" +#include "../__utility/integer_sequence.h" +#include "../array" +#include "../cstddef" +#include "../span" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#if defined(_LIBCUDACXX_PUSH_MACROS) + _LIBCUDACXX_PUSH_MACROS +#endif +#include "../__undef_macros" + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +namespace __detail { + +template +struct __count_dynamic_extents; + +template +struct __count_dynamic_extents<_Ep,_Extents...> { + static constexpr size_t val = (_Ep==dynamic_extent?1:0) + __count_dynamic_extents<_Extents...>::val; +}; + +template<> +struct __count_dynamic_extents<> { + static constexpr size_t val = 0; +}; + +template +_LIBCUDACXX_HOST_DEVICE +static constexpr false_type __check_compatible_extents( + false_type, _CUDA_VSTD::integer_sequence, _CUDA_VSTD::integer_sequence +) noexcept { return { }; } + +// This helper prevents ICE's on MSVC. +template +struct __compare_extent_compatible : integral_constant +{}; + +template +static integral_constant< + bool, + __MDSPAN_FOLD_AND( + ( + __compare_extent_compatible<_Extents, _OtherExtents>::value + ) /* && ... */ + ) +> +_LIBCUDACXX_HOST_DEVICE +__check_compatible_extents( + true_type, _CUDA_VSTD::integer_sequence, _CUDA_VSTD::integer_sequence +) noexcept { return { }; } + +struct __extents_tag { }; + +} // end namespace __detail + +template +class extents +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : private __detail::__no_unique_address_emulation< + __detail::__partially_static_sizes_tagged<__detail::__extents_tag, _ThisIndexType , size_t, _Extents...>> +#endif +{ +public: + + using rank_type = size_t; + using index_type = _ThisIndexType; + using size_type = make_unsigned_t; + +// internal typedefs which for technical reasons are public + using __storage_t = __detail::__partially_static_sizes_tagged<__detail::__extents_tag, index_type, size_t, _Extents...>; + +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + _LIBCUDACXX_NO_UNIQUE_ADDRESS __storage_t __storage_; +#else + using __base_t = __detail::__no_unique_address_emulation<__storage_t>; +#endif + +// private members dealing with the way we internally store dynamic extents + private: + + __MDSPAN_FORCE_INLINE_FUNCTION constexpr + __storage_t& __storage() noexcept { +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + return __storage_; +#else + return this->__base_t::__ref(); +#endif + } + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr __storage_t const& __storage() const noexcept { +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + return __storage_; +#else + return this->__base_t::__ref(); +#endif + } + + template + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr + index_type _static_extent_impl(size_t __n, _CUDA_VSTD::integer_sequence) noexcept { + return __MDSPAN_FOLD_PLUS_RIGHT(((_Idxs == __n) ? _Extents : 0), /* + ... + */ 0); + } + + template + friend class extents; + + template + __MDSPAN_INLINE_FUNCTION + constexpr bool _eq_impl(_CUDA_VSTD::extents<_OtherIndexType, _OtherExtents...>, false_type, _CUDA_VSTD::index_sequence<_Idxs...>) const noexcept { return false; } + template + __MDSPAN_INLINE_FUNCTION + constexpr bool _eq_impl( + _CUDA_VSTD::extents<_OtherIndexType, _OtherExtents...> __other, + true_type, _CUDA_VSTD::index_sequence<_Idxs...> + ) const noexcept { + return __MDSPAN_FOLD_AND( + (__storage().template __get_n<_Idxs>() == __other.__storage().template __get_n<_Idxs>()) /* && ... */ + ); + } + + template + __MDSPAN_INLINE_FUNCTION + constexpr bool _not_eq_impl(_CUDA_VSTD::extents<_OtherIndexType, _OtherExtents...>, false_type, _CUDA_VSTD::index_sequence<_Idxs...>) const noexcept { return true; } + template + __MDSPAN_INLINE_FUNCTION + constexpr bool _not_eq_impl( + _CUDA_VSTD::extents<_OtherIndexType, _OtherExtents...> __other, + true_type, _CUDA_VSTD::index_sequence<_Idxs...> + ) const noexcept { + return __MDSPAN_FOLD_OR( + (__storage().template __get_n<_Idxs>() != __other.__storage().template __get_n<_Idxs>()) /* || ... */ + ); + } + +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + __MDSPAN_INLINE_FUNCTION constexpr explicit + extents(__base_t&& __b) noexcept + : __base_t(_CUDA_VSTD::move(__b)) + { } +#endif + + +// public interface: +public: + /* Defined above for use in the private code + using rank_type = size_t; + using index_type = _ThisIndexType; + */ + + __MDSPAN_INLINE_FUNCTION + static constexpr rank_type rank() noexcept { return sizeof...(_Extents); } + __MDSPAN_INLINE_FUNCTION + static constexpr rank_type rank_dynamic() noexcept { return __MDSPAN_FOLD_PLUS_RIGHT((rank_type(_Extents == dynamic_extent)), /* + ... + */ 0); } + + //-------------------------------------------------------------------------------- + // Constructors, Destructors, and Assignment + + // Default constructor + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr extents() noexcept = default; + + // Converting constructor + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherIndexType, size_t... _OtherExtents, + /* requires */ ( + /* multi-stage check to protect from invalid pack expansion when sizes don't match? */ + decltype(__detail::__check_compatible_extents( + integral_constant{}, + _CUDA_VSTD::integer_sequence{}, + _CUDA_VSTD::integer_sequence{} + ))::value + ) + ) + __MDSPAN_INLINE_FUNCTION + __MDSPAN_CONDITIONAL_EXPLICIT( + (((_Extents != dynamic_extent) && (_OtherExtents == dynamic_extent)) || ...) || + (_CUDA_VSTD::numeric_limits::max() < _CUDA_VSTD::numeric_limits<_OtherIndexType>::max())) + constexpr extents(const extents<_OtherIndexType, _OtherExtents...>& __other) + noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __storage_{ +#else + : __base_t(__base_t{__storage_t{ +#endif + __other.__storage().__enable_psa_conversion() +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + }}) +#endif + { + /* TODO: precondition check + * __other.extent(r) equals Er for each r for which Er is a static extent, and + * either + * - sizeof...(_OtherExtents) is zero, or + * - __other.extent(r) is a representable value of type index_type for all rank index r of __other + */ + } + +#ifdef __NVCC__ + __MDSPAN_TEMPLATE_REQUIRES( + class... _Integral, + /* requires */ ( + // TODO: check whether the other version works with newest NVCC, doesn't with 11.4 + // NVCC seems to pick up rank_dynamic from the wrong extents type??? + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Integral, index_type) /* && ... */) && + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Integral) /* && ... */) && + // NVCC chokes on the fold thingy here so wrote the workaround + ((sizeof...(_Integral) == __detail::__count_dynamic_extents<_Extents...>::val) || + (sizeof...(_Integral) == sizeof...(_Extents))) + ) + ) +#else + __MDSPAN_TEMPLATE_REQUIRES( + class... _Integral, + /* requires */ ( + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Integral, index_type) /* && ... */) && + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Integral) /* && ... */) && + ((sizeof...(_Integral) == rank_dynamic()) || (sizeof...(_Integral) == rank())) + ) + ) +#endif + __MDSPAN_INLINE_FUNCTION + explicit constexpr extents(_Integral... __exts) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __storage_{ +#else + : __base_t(__base_t{typename __base_t::__stored_type{ +#endif + _CUDA_VSTD::conditional_t(), + static_cast(__exts)... +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + }}) +#endif + { + /* TODO: precondition check + * If sizeof...(_IndexTypes) != rank_dynamic() is true, exts_arr[r] equals Er for each r for which Er is a static extent, and + * either + * - sizeof...(__exts) == 0 is true, or + * - each element of __exts is nonnegative and is a representable value of type index_type. + */ + } + + // TODO: check whether this works with newest NVCC, doesn't with 11.4 +#ifdef __NVCC__ + // NVCC seems to pick up rank_dynamic from the wrong extents type??? + // NVCC chokes on the fold thingy here so wrote the workaround + __MDSPAN_TEMPLATE_REQUIRES( + class _IndexType, size_t _Np, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _IndexType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _IndexType) && + ((_Np == __detail::__count_dynamic_extents<_Extents...>::val) || + (_Np == sizeof...(_Extents))) + ) + ) +#else + __MDSPAN_TEMPLATE_REQUIRES( + class _IndexType, size_t _Np, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _IndexType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _IndexType) && + (_Np == rank() || _Np == rank_dynamic()) + ) + ) +#endif + __MDSPAN_CONDITIONAL_EXPLICIT(_Np != rank_dynamic()) + __MDSPAN_INLINE_FUNCTION + constexpr + extents(_CUDA_VSTD::array<_IndexType, _Np> const& __exts) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __storage_{ +#else + : __base_t(__base_t{typename __base_t::__stored_type{ +#endif + _CUDA_VSTD::conditional_t<_Np==rank_dynamic(), + __detail::__construct_psa_from_dynamic_exts_array_tag_t<0>, + __detail::__construct_psa_from_all_exts_array_tag_t>(), + _CUDA_VSTD::array<_IndexType,_Np>{__exts} +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + }}) +#endif + { + /* TODO: precondition check + * If _Np != rank_dynamic() is true, __exts[r] equals Er for each r for which Er is a static extent, and + * either + * - _Np is zero, or + * - __exts[r] is nonnegative and is a representable value of type index_type for all rank index r + */ + } + + // TODO: check whether the below works with newest NVCC, doesn't with 11.4 +#ifdef __NVCC__ + // NVCC seems to pick up rank_dynamic from the wrong extents type??? + // NVCC chokes on the fold thingy here so wrote the workaround + __MDSPAN_TEMPLATE_REQUIRES( + class _IndexType, size_t _Np, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _IndexType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _IndexType) && + ((_Np == __detail::__count_dynamic_extents<_Extents...>::val) || + (_Np == sizeof...(_Extents))) + ) + ) +#else + __MDSPAN_TEMPLATE_REQUIRES( + class _IndexType, size_t _Np, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _IndexType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _IndexType) && + (_Np == rank() || _Np == rank_dynamic()) + ) + ) +#endif + __MDSPAN_CONDITIONAL_EXPLICIT(_Np != rank_dynamic()) + __MDSPAN_INLINE_FUNCTION + constexpr + extents(_CUDA_VSTD::span<_IndexType, _Np> __exts) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __storage_{ +#else + : __base_t(__base_t{typename __base_t::__stored_type{ +#endif + _CUDA_VSTD::conditional_t<_Np==rank_dynamic(), + __detail::__construct_psa_from_dynamic_exts_array_tag_t<0>, + __detail::__construct_psa_from_all_exts_array_tag_t>(), + __exts +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + }}) +#endif + { + /* TODO: precondition check + * If _Np != rank_dynamic() is true, __exts[r] equals Er for each r for which Er is a static extent, and + * either + * - _Np is zero, or + * - __exts[r] is nonnegative and is a representable value of type index_type for all rank index r + */ + } + + // Need this constructor for some submdspan implementation stuff + // for the layout_stride case where I use an extents object for strides + __MDSPAN_INLINE_FUNCTION + constexpr explicit + extents(__storage_t const& __sto ) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __storage_{ +#else + : __base_t(__base_t{ +#endif + __sto +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + }) +#endif + { } + + //-------------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION + static constexpr + size_t static_extent(size_t __n) noexcept { + // Can't do assert here since that breaks true constexpr ness + // assert(__n{}); + } + + __MDSPAN_INLINE_FUNCTION + constexpr + index_type extent(size_t __n) const noexcept { + // Can't do assert here since that breaks true constexpr ness + // assert(__n + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator==(extents const& lhs, extents<_OtherIndexType, _RHS...> const& __rhs) noexcept { + return lhs._eq_impl( + __rhs, integral_constant{}, + _CUDA_VSTD::make_index_sequence{} + ); + } + +#if !(__MDSPAN_HAS_CXX_20) + template + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator!=(extents const& lhs, extents<_OtherIndexType, _RHS...> const& __rhs) noexcept { + return lhs._not_eq_impl( + __rhs, integral_constant{}, + _CUDA_VSTD::make_index_sequence{} + ); + } +#endif + + // End of public interface + +public: // (but not really) + + __MDSPAN_INLINE_FUNCTION static constexpr + extents __make_extents_impl(__detail::__partially_static_sizes&& __bs) noexcept { + // This effectively amounts to a sideways cast that can be done in a constexpr + // context, but we have to do it to handle the case where the extents and the + // strides could accidentally end up with the same types in their hierarchies + // somehow (which would cause layout_stride::mapping to not be standard_layout) + return extents( +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + __base_t{ +#endif + _CUDA_VSTD::move(__bs.template __with_tag<__detail::__extents_tag>()) +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#endif + ); + } + + template + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr + index_type __extent() const noexcept { + return __storage().template __get_n<_Np>(); + } + + template + __MDSPAN_INLINE_FUNCTION + static constexpr + index_type __static_extent() noexcept { + return __storage_t::template __get_static_n<_Np, _Default>(); + } + +}; + +namespace __detail { + +template > +struct __make_dextents; + +template +struct __make_dextents<_IndexType, _Rank, _CUDA_VSTD::extents<_IndexType, _ExtentsPack...>> { + using type = typename __make_dextents<_IndexType, _Rank - 1, + _CUDA_VSTD::extents<_IndexType, _CUDA_VSTD::dynamic_extent, _ExtentsPack...>>::type; +}; + +template +struct __make_dextents<_IndexType, 0, _CUDA_VSTD::extents<_IndexType, _ExtentsPack...>> { + using type = _CUDA_VSTD::extents<_IndexType, _ExtentsPack...>; +}; + +} // end namespace __detail + +template +using dextents = typename __detail::__make_dextents<_IndexType, _Rank>::type; + +#if defined(__MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) +template +extents(_IndexTypes...) + // Workaround for nvcc + //-> extents()...>; + // Adding "(void)" so that clang doesn't complain this is unused + -> extents; +#endif + +namespace __detail { + +template +struct __is_extents : false_type {}; + +template +struct __is_extents<_CUDA_VSTD::extents<_IndexType, _ExtentsPack...>> : true_type {}; + +template +static constexpr bool __is_extents_v = __is_extents<_Tp>::value; + + +template +struct __extents_to_partially_static_sizes; + +template +struct __extents_to_partially_static_sizes<_CUDA_VSTD::extents<_IndexType, _ExtentsPack...>> { + using type = __detail::__partially_static_sizes< + typename _CUDA_VSTD::extents<_IndexType, _ExtentsPack...>::index_type, size_t, + _ExtentsPack...>; +}; + +template +using __extents_to_partially_static_sizes_t = typename __extents_to_partially_static_sizes<_Extents>::type; + +} // end namespace __detail + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#if defined(_LIBCUDACXX_POP_MACROS) + _LIBCUDACXX_POP_MACROS +#endif + +#endif // _LIBCUDACXX___MDSPAN_EXTENTS_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/full_extent_t.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/full_extent_t.h new file mode 100644 index 0000000000000000000000000000000000000000..294ba6c6af883f15bcbbcc5d6caf4b0c706ab2f7 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/full_extent_t.h @@ -0,0 +1,69 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_FULL_EXTENT_T_HPP +#define _LIBCUDACXX___MDSPAN_FULL_EXTENT_T_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/macros.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +struct full_extent_t { explicit full_extent_t() = default; }; + +_LIBCUDACXX_INLINE_VAR constexpr auto full_extent = full_extent_t{ }; + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_FULL_EXTENT_T_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_left.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_left.h new file mode 100644 index 0000000000000000000000000000000000000000..c9d446b8c8446a0631b819ebd2afe20f33af0d03 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_left.h @@ -0,0 +1,270 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_LAYOUT_LEFT_HPP +#define _LIBCUDACXX___MDSPAN_LAYOUT_LEFT_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__assert" +#include "../__mdspan/extents.h" +#include "../__mdspan/macros.h" +#include "../__type_traits/is_constructible.h" +#include "../__type_traits/is_convertible.h" +#include "../__type_traits/is_nothrow_constructible.h" +#include "../__utility/integer_sequence.h" +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +//============================================================================== + +template +class layout_left::mapping { + public: + using extents_type = _Extents; + using index_type = typename extents_type::index_type; + using size_type = typename extents_type::size_type; + using rank_type = typename extents_type::rank_type; + using layout_type = layout_left; + private: + + static_assert(__detail::__is_extents_v, "layout_left::mapping must be instantiated with a specialization of _CUDA_VSTD::extents."); + + template + friend class mapping; + + // i0+(i1 + E(1)*(i2 + E(2)*i3)) + template + struct __rank_count {}; + + template + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __compute_offset( + __rank_count<_r,_Rank>, const _Ip& __i, _Indices... __idx) const { + return __compute_offset(__rank_count<_r+1,_Rank>(), __idx...) * + __extents.template __extent<_r>() + __i; + } + + template + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __compute_offset( + __rank_count, const _Ip& __i) const { + return __i; + } + + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; } + + public: + + //-------------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default; + + _LIBCUDACXX_HOST_DEVICE + constexpr mapping(extents_type const& __exts) noexcept + :__extents(__exts) + { } + + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherExtents, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents) + ) + ) + __MDSPAN_CONDITIONAL_EXPLICIT((!_CUDA_VSTD::is_convertible<_OtherExtents, extents_type>::value)) // needs two () due to comma + __MDSPAN_INLINE_FUNCTION constexpr + mapping(mapping<_OtherExtents> const& __other) noexcept // NOLINT(google-explicit-constructor) + :__extents(__other.extents()) + { + /* + * TODO: check precondition + * __other.required_span_size() is a representable value of type index_type + */ + } + + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherExtents, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents) && + (extents_type::rank() <= 1) + ) + ) + __MDSPAN_CONDITIONAL_EXPLICIT((!_CUDA_VSTD::is_convertible<_OtherExtents, extents_type>::value)) // needs two () due to comma + __MDSPAN_INLINE_FUNCTION constexpr + mapping(layout_right::mapping<_OtherExtents> const& __other) noexcept // NOLINT(google-explicit-constructor) + :__extents(__other.extents()) + { + /* + * TODO: check precondition + * __other.required_span_size() is a representable value of type index_type + */ + } + + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherExtents, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents) + ) + ) + __MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0)) + __MDSPAN_INLINE_FUNCTION constexpr + mapping(layout_stride::mapping<_OtherExtents> const& __other) // NOLINT(google-explicit-constructor) + :__extents(__other.extents()) + { + /* + * TODO: check precondition + * __other.required_span_size() is a representable value of type index_type + */ + NV_IF_TARGET(NV_IS_HOST,( + size_t __stride = 1; + for(rank_type __r=0; __r<__extents.rank(); __r++) { + _LIBCUDACXX_THROW_RUNTIME_ERROR(__stride == static_cast(__other.stride(__r)), + "Assigning layout_stride to layout_left with invalid strides."); + __stride *= __extents.extent(__r); + } + )) + } + + __MDSPAN_INLINE_FUNCTION_DEFAULTED __MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default; + + __MDSPAN_INLINE_FUNCTION + constexpr const extents_type& extents() const noexcept { + return __extents; + } + + __MDSPAN_INLINE_FUNCTION + constexpr index_type required_span_size() const noexcept { + index_type __value = 1; + for(rank_type __r=0; __r(), static_cast(__idxs)...); + } + + + + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; } + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return true; } + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return true; } + + __MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return true; } + __MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return true; } + __MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return true; } + + __MDSPAN_TEMPLATE_REQUIRES( + class _Ext = _Extents, + /* requires */ ( + _Ext::rank() > 0 + ) + ) + __MDSPAN_INLINE_FUNCTION + constexpr index_type stride(rank_type __i) const noexcept { + index_type __value = 1; + for(rank_type __r=0; __r<__i; __r++) __value*=__extents.extent(__r); + return __value; + } + + template + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator==(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept { + return __lhs.extents() == __rhs.extents(); + } + + // In C++ 20 the not equal exists if equal is found +#if !(__MDSPAN_HAS_CXX_20) + template + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator!=(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept { + return __lhs.extents() != __rhs.extents(); + } +#endif + + // Not really public, but currently needed to implement fully constexpr useable submdspan: + template + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __get_stride(_CUDA_VSTD::extents<_SizeType, _Ep...>,_CUDA_VSTD::integer_sequence) const { + return __MDSPAN_FOLD_TIMES_RIGHT((_Idx<_Np? __extents.template __extent<_Idx>():1),1); + } + template + _LIBCUDACXX_HOST_DEVICE + constexpr index_type stride() const noexcept { + return __get_stride<_Np>(__extents, _CUDA_VSTD::make_index_sequence()); + } + +private: + _LIBCUDACXX_NO_UNIQUE_ADDRESS extents_type __extents{}; + +}; + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_LAYOUT_LEFT_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_right.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_right.h new file mode 100644 index 0000000000000000000000000000000000000000..74ad81f92fa63935ea690d285fbaf5b067daa867 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_right.h @@ -0,0 +1,270 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_LAYOUT_RIGHT_HPP +#define _LIBCUDACXX___MDSPAN_LAYOUT_RIGHT_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__assert" +#include "../__mdspan/extents.h" +#include "../__mdspan/layout_stride.h" +#include "../__mdspan/macros.h" +#include "../__type_traits/is_constructible.h" +#include "../__type_traits/is_convertible.h" +#include "../__type_traits/is_nothrow_constructible.h" +#include "../__utility/integer_sequence.h" +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +//============================================================================== +template +class layout_right::mapping { + public: + using extents_type = _Extents; + using index_type = typename extents_type::index_type; + using size_type = typename extents_type::size_type; + using rank_type = typename extents_type::rank_type; + using layout_type = layout_right; + private: + + static_assert(__detail::__is_extents_v, "layout_right::mapping must be instantiated with a specialization of _CUDA_VSTD::extents."); + + template + friend class mapping; + + // i0+(i1 + E(1)*(i2 + E(2)*i3)) + template + struct __rank_count {}; + + template + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __compute_offset( + index_type __offset, __rank_count<_r,_Rank>, const _Ip& __i, _Indices... __idx) const { + return __compute_offset(__offset * __extents.template __extent<_r>() + __i,__rank_count<_r+1,_Rank>(), __idx...); + } + + template + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __compute_offset( + __rank_count<0,extents_type::rank()>, const _Ip& __i, _Indices... __idx) const { + return __compute_offset(__i,__rank_count<1,extents_type::rank()>(),__idx...); + } + + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __compute_offset(size_t __offset, __rank_count) const { + return static_cast(__offset); + } + + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; } + + public: + + //-------------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default; + + _LIBCUDACXX_HOST_DEVICE + constexpr mapping(extents_type const& __exts) noexcept + :__extents(__exts) + { } + + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherExtents, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents) + ) + ) + __MDSPAN_CONDITIONAL_EXPLICIT((!_CUDA_VSTD::is_convertible<_OtherExtents, extents_type>::value)) // needs two () due to comma + __MDSPAN_INLINE_FUNCTION constexpr + mapping(mapping<_OtherExtents> const& __other) noexcept // NOLINT(google-explicit-constructor) + :__extents(__other.extents()) + { + /* + * TODO: check precondition + * __other.required_span_size() is a representable value of type index_type + */ + } + + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherExtents, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents) && + (extents_type::rank() <= 1) + ) + ) + __MDSPAN_CONDITIONAL_EXPLICIT((!_CUDA_VSTD::is_convertible<_OtherExtents, extents_type>::value)) // needs two () due to comma + __MDSPAN_INLINE_FUNCTION constexpr + mapping(layout_left::mapping<_OtherExtents> const& __other) noexcept // NOLINT(google-explicit-constructor) + :__extents(__other.extents()) + { + /* + * TODO: check precondition + * __other.required_span_size() is a representable value of type index_type + */ + } + + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherExtents, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents) + ) + ) + __MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0)) + __MDSPAN_INLINE_FUNCTION constexpr + mapping(layout_stride::mapping<_OtherExtents> const& __other) // NOLINT(google-explicit-constructor) + :__extents(__other.extents()) + { + /* + * TODO: check precondition + * __other.required_span_size() is a representable value of type index_type + */ + NV_IF_TARGET(NV_IS_HOST,( + size_t __stride = 1; + for(rank_type __r=__extents.rank(); __r>0; __r--) { + _LIBCUDACXX_THROW_RUNTIME_ERROR(__stride == static_cast(__other.stride(__r-1)), + "Assigning layout_stride to layout_right with invalid strides."); + __stride *= __extents.extent(__r-1); + } + )) + } + + __MDSPAN_INLINE_FUNCTION_DEFAULTED __MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default; + + __MDSPAN_INLINE_FUNCTION + constexpr const extents_type& extents() const noexcept { + return __extents; + } + + __MDSPAN_INLINE_FUNCTION + constexpr index_type required_span_size() const noexcept { + index_type __value = 1; + for(rank_type __r=0; __r != extents_type::rank(); ++__r) __value*=__extents.extent(__r); + return __value; + } + + //-------------------------------------------------------------------------------- + + __MDSPAN_TEMPLATE_REQUIRES( + class... _Indices, + /* requires */ ( + (sizeof...(_Indices) == extents_type::rank()) && + __MDSPAN_FOLD_AND( + (_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Indices, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Indices)) + ) + ) + ) + _LIBCUDACXX_HOST_DEVICE + constexpr index_type operator()(_Indices... __idxs) const noexcept { + return __compute_offset(__rank_count<0, extents_type::rank()>(), static_cast(__idxs)...); + } + + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; } + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return true; } + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return true; } + __MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return true; } + __MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return true; } + __MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return true; } + + __MDSPAN_TEMPLATE_REQUIRES( + class _Ext = _Extents, + /* requires */ ( + _Ext::rank() > 0 + ) + ) + __MDSPAN_INLINE_FUNCTION + constexpr index_type stride(rank_type __i) const noexcept { + index_type __value = 1; + for(rank_type __r=extents_type::rank()-1; __r>__i; __r--) __value*=__extents.extent(__r); + return __value; + } + + template + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator==(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept { + return __lhs.extents() == __rhs.extents(); + } + + // In C++ 20 the not equal exists if equal is found +#if !(__MDSPAN_HAS_CXX_20) + template + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator!=(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept { + return __lhs.extents() != __rhs.extents(); + } +#endif + + // Not really public, but currently needed to implement fully constexpr useable submdspan: + template + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __get_stride(_CUDA_VSTD::extents<_SizeType, _Ep...>,_CUDA_VSTD::integer_sequence) const { + return __MDSPAN_FOLD_TIMES_RIGHT((_Idx>_Np? __extents.template __extent<_Idx>():1),1); + } + template + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __stride() const noexcept { + return __get_stride<_Np>(__extents, _CUDA_VSTD::make_index_sequence()); + } + +private: + _LIBCUDACXX_NO_UNIQUE_ADDRESS extents_type __extents{}; + +}; + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_LAYOUT_RIGHT_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_stride.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_stride.h new file mode 100644 index 0000000000000000000000000000000000000000..b5ef97af4db812f8e07ee7046a8384f7fca54683 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_stride.h @@ -0,0 +1,555 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_LAYOUT_STRIDE_HPP +#define _LIBCUDACXX___MDSPAN_LAYOUT_STRIDE_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/compressed_pair.h" +#include "../__mdspan/extents.h" +#include "../__mdspan/macros.h" +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS +#include "../__mdspan/no_unique_address.h" +#endif +#include "../__mdspan/static_array.h" +#include "../__type_traits/is_same.h" +#include "../__type_traits/is_constructible.h" +#include "../__type_traits/is_convertible.h" +#include "../__type_traits/is_nothrow_constructible.h" +#include "../__type_traits/remove_const.h" +#include "../__utility/integer_sequence.h" +#include "../__utility/move.h" +#include "../algorithm" +#include "../array" +#if __MDSPAN_USE_CONCEPTS && __MDSPAN_HAS_CXX_20 +#include "../concepts" +#endif +#include "../numeric" +#include "../span" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +struct layout_left { + template + class mapping; +}; +struct layout_right { + template + class mapping; +}; + +namespace __detail { + template + constexpr bool __is_mapping_of = + _CUDA_VSTD::is_same, _Mapping>::value; + +#if __MDSPAN_USE_CONCEPTS && __MDSPAN_HAS_CXX_20 + template + concept __layout_mapping_alike = requires { + requires __is_extents::value; + { _Mp::is_always_strided() } -> same_as; + { _Mp::is_always_exhaustive() } -> same_as; + { _Mp::is_always_unique() } -> same_as; + bool_constant<_Mp::is_always_strided()>::value; + bool_constant<_Mp::is_always_exhaustive()>::value; + bool_constant<_Mp::is_always_unique()>::value; + }; +#endif +} // namespace __detail + +struct layout_stride { + template + class mapping +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : private __detail::__no_unique_address_emulation< + __detail::__compressed_pair< + _Extents, + _CUDA_VSTD::array + > + > +#endif + { + public: + using extents_type = _Extents; + using index_type = typename extents_type::index_type; + using size_type = typename extents_type::size_type; + using rank_type = typename extents_type::rank_type; + using layout_type = layout_stride; + + // This could be a `requires`, but I think it's better and clearer as a `static_assert`. + static_assert(__detail::__is_extents_v<_Extents>, "layout_stride::mapping must be instantiated with a specialization of _CUDA_VSTD::extents."); + + + private: + + //---------------------------------------------------------------------------- + + using __strides_storage_t = _CUDA_VSTD::array;//_CUDA_VSTD::dextents; + using __member_pair_t = __detail::__compressed_pair; + +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + _LIBCUDACXX_NO_UNIQUE_ADDRESS __member_pair_t __members; +#else + using __base_t = __detail::__no_unique_address_emulation<__member_pair_t>; +#endif + + __MDSPAN_FORCE_INLINE_FUNCTION constexpr __strides_storage_t const& + __strides_storage() const noexcept { +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + return __members.__second(); +#else + return this->__base_t::__ref().__second(); +#endif + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr __strides_storage_t& + __strides_storage() noexcept { +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + return __members.__second(); +#else + return this->__base_t::__ref().__second(); +#endif + } + + template + _LIBCUDACXX_HOST_DEVICE + constexpr index_type __get_size(_CUDA_VSTD::extents<_SizeType, _Ep...>,_CUDA_VSTD::integer_sequence) const { + return __MDSPAN_FOLD_TIMES_RIGHT( static_cast(extents().extent(_Idx)), 1 ); + } + + //---------------------------------------------------------------------------- + + template + friend class mapping; + + //---------------------------------------------------------------------------- + + // Workaround for non-deducibility of the index sequence template parameter if it's given at the top level + template + struct __deduction_workaround; + + template + struct __deduction_workaround<_CUDA_VSTD::index_sequence<_Idxs...>> + { + template + __MDSPAN_INLINE_FUNCTION + static constexpr bool _eq_impl(mapping const& __self, mapping<_OtherExtents> const& __other) noexcept { + return __MDSPAN_FOLD_AND((__self.stride(_Idxs) == __other.stride(_Idxs)) /* && ... */) + && __MDSPAN_FOLD_AND((__self.extents().extent(_Idxs) == __other.extents().extent(_Idxs)) /* || ... */); + } + template + __MDSPAN_INLINE_FUNCTION + static constexpr bool _not_eq_impl(mapping const& __self, mapping<_OtherExtents> const& __other) noexcept { + return __MDSPAN_FOLD_OR((__self.stride(_Idxs) != __other.stride(_Idxs)) /* || ... */) + || __MDSPAN_FOLD_OR((__self.extents().extent(_Idxs) != __other.extents().extent(_Idxs)) /* || ... */); + } + + template + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr size_t _call_op_impl(mapping const& __self, _Integral... __idxs) noexcept { + return __MDSPAN_FOLD_PLUS_RIGHT((__idxs * __self.stride(_Idxs)), /* + ... + */ 0); + } + + __MDSPAN_INLINE_FUNCTION + static constexpr size_t _req_span_size_impl(mapping const& __self) noexcept { + // assumes no negative strides; not sure if I'm allowed to assume that or not + return __impl::_call_op_impl(__self, (__self.extents().template __extent<_Idxs>() - 1)...) + 1; + } + + template + __MDSPAN_INLINE_FUNCTION + static constexpr const __strides_storage_t fill_strides(const _OtherMapping& __map) { + return __strides_storage_t{static_cast(__map.stride(_Idxs))...}; + } + + __MDSPAN_INLINE_FUNCTION + static constexpr const __strides_storage_t& fill_strides(const __strides_storage_t& __s) { + return __s; + } + + template + __MDSPAN_INLINE_FUNCTION + static constexpr const __strides_storage_t fill_strides(const _CUDA_VSTD::array<_IntegralType,extents_type::rank()>& __s) { + return __strides_storage_t{static_cast(__s[_Idxs])...}; + } + + template + __MDSPAN_INLINE_FUNCTION + static constexpr const __strides_storage_t fill_strides(const _CUDA_VSTD::span<_IntegralType,extents_type::rank()>& __s) { + return __strides_storage_t{static_cast(__s[_Idxs])...}; + } + + __MDSPAN_INLINE_FUNCTION + static constexpr const __strides_storage_t fill_strides( + __detail::__extents_to_partially_static_sizes_t< + _CUDA_VSTD::dextents>&& __s) { + return __strides_storage_t{static_cast(__s.template __get_n<_Idxs>())...}; + } + + template + __MDSPAN_INLINE_FUNCTION + static constexpr size_t __return_zero() { return 0; } + + template + __MDSPAN_INLINE_FUNCTION + static constexpr typename _Mapping::index_type + __OFFSET(const _Mapping& m) { return m(__return_zero<_Idxs>()...); } + }; + + // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348. + using __impl = __deduction_workaround<_CUDA_VSTD::make_index_sequence<_Extents::rank()>>; + + + //---------------------------------------------------------------------------- + +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + __MDSPAN_INLINE_FUNCTION constexpr explicit + mapping(__member_pair_t&& __m) : __members(_CUDA_VSTD::move(__m)) {} +#else + __MDSPAN_INLINE_FUNCTION constexpr explicit + mapping(__base_t&& __b) : __base_t(_CUDA_VSTD::move(__b)) {} +#endif + + public: // but not really + __MDSPAN_INLINE_FUNCTION + static constexpr mapping + __make_mapping( + __detail::__extents_to_partially_static_sizes_t<_Extents>&& __exts, + __detail::__extents_to_partially_static_sizes_t< + _CUDA_VSTD::dextents>&& __strs + ) noexcept { + // call the private constructor we created for this purpose + return mapping( +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + __base_t{ +#endif + __member_pair_t( + extents_type::__make_extents_impl(_CUDA_VSTD::move(__exts)), + __strides_storage_t{__impl::fill_strides(_CUDA_VSTD::move(__strs))} + ) +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#endif + ); + } + //---------------------------------------------------------------------------- + + + public: + + //-------------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default; + + __MDSPAN_TEMPLATE_REQUIRES( + class _IntegralTypes, + /* requires */ ( + // MSVC 19.32 does not like using index_type here, requires the typename _Extents::index_type + // error C2641: cannot deduce template arguments for '_CUDA_VSTD::layout_stride::mapping' + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, const remove_const_t<_IntegralTypes>&, typename _Extents::index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, typename _Extents::index_type, const remove_const_t<_IntegralTypes>&) + ) + ) + __MDSPAN_INLINE_FUNCTION + constexpr + mapping( + extents_type const& __e, + _CUDA_VSTD::array<_IntegralTypes, extents_type::rank()> const& __s + ) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __members{ +#else + : __base_t(__base_t{__member_pair_t( +#endif + __e, __strides_storage_t(__impl::fill_strides(__s)) +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { + /* + * TODO: check preconditions + * - __s[i] > 0 is true for all i in the range [0, rank_ ). + * - REQUIRED-SPAN-SIZE(__e, __s) is a representable value of type index_type ([basic.fundamental]). + * - If rank_ is greater than 0, then there exists a permutation P of the integers in the + * range [0, rank_), such that __s[ pi ] >= __s[ pi − 1 ] * __e.extent( pi − 1 ) is true for + * all i in the range [1, rank_ ), where pi is the ith element of P. + */ + } + + __MDSPAN_TEMPLATE_REQUIRES( + class _IntegralTypes, + /* requires */ ( + // MSVC 19.32 does not like using index_type here, requires the typename _Extents::index_type + // error C2641: cannot deduce template arguments for '_CUDA_VSTD::layout_stride::mapping' + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, const remove_const_t<_IntegralTypes>&, typename _Extents::index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, typename _Extents::index_type, const remove_const_t<_IntegralTypes>&) + ) + ) + __MDSPAN_INLINE_FUNCTION + constexpr + mapping( + extents_type const& __e, + _CUDA_VSTD::span<_IntegralTypes, extents_type::rank()> const& __s + ) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __members{ +#else + : __base_t(__base_t{__member_pair_t( +#endif + __e, __strides_storage_t(__impl::fill_strides(__s)) +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { + /* + * TODO: check preconditions + * - __s[i] > 0 is true for all i in the range [0, rank_ ). + * - REQUIRED-SPAN-SIZE(__e, __s) is a representable value of type index_type ([basic.fundamental]). + * - If rank_ is greater than 0, then there exists a permutation P of the integers in the + * range [0, rank_), such that __s[ pi ] >= __s[ pi − 1 ] * __e.extent( pi − 1 ) is true for + * all i in the range [1, rank_ ), where pi is the ith element of P. + */ + } + +#if !(__MDSPAN_USE_CONCEPTS && __MDSPAN_HAS_CXX_20) + __MDSPAN_TEMPLATE_REQUIRES( + class _StridedLayoutMapping, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, typename _StridedLayoutMapping::extents_type) && + __detail::__is_mapping_of && + _StridedLayoutMapping::is_always_unique() && + _StridedLayoutMapping::is_always_strided() + ) + ) +#else + template + requires( + __detail::__layout_mapping_alike<_StridedLayoutMapping> && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, typename _StridedLayoutMapping::extents_type) && + _StridedLayoutMapping::is_always_unique() && + _StridedLayoutMapping::is_always_strided() + ) +#endif + __MDSPAN_CONDITIONAL_EXPLICIT( + (!_CUDA_VSTD::is_convertible::value) && + (__detail::__is_mapping_of || + __detail::__is_mapping_of || + __detail::__is_mapping_of) + ) // needs two () due to comma + __MDSPAN_INLINE_FUNCTION constexpr + mapping(_StridedLayoutMapping const& __other) noexcept // NOLINT(google-explicit-constructor) +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __members{ +#else + : __base_t(__base_t{__member_pair_t( +#endif + __other.extents(), __strides_storage_t(__impl::fill_strides(__other)) +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { + /* + * TODO: check preconditions + * - __other.stride(i) > 0 is true for all i in the range [0, rank_ ). + * - __other.required_span_size() is a representable value of type index_type ([basic.fundamental]). + * - OFFSET(__other) == 0 + */ + } + + //-------------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION_DEFAULTED __MDSPAN_CONSTEXPR_14_DEFAULTED + mapping& operator=(mapping const&) noexcept = default; + + __MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + return __members.__first(); +#else + return this->__base_t::__ref().__first(); +#endif + }; + + __MDSPAN_INLINE_FUNCTION + constexpr _CUDA_VSTD::array< index_type, extents_type::rank() > strides() const noexcept { + return __strides_storage(); + } + + __MDSPAN_INLINE_FUNCTION + constexpr index_type required_span_size() const noexcept { + index_type __span_size = 1; + for(unsigned __r = 0; __r < extents_type::rank(); __r++) { + // Return early if any of the extents are zero + if(extents().extent(__r)==0) return 0; + __span_size += ( static_cast(extents().extent(__r) - 1 ) * __strides_storage()[__r]); + } + return __span_size; + } + + + __MDSPAN_TEMPLATE_REQUIRES( + class... _Indices, + /* requires */ ( + sizeof...(_Indices) == _Extents::rank() && + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Indices, index_type) /*&& ...*/ ) && + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Indices) /*&& ...*/) + ) + ) + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr index_type operator()(_Indices... __idxs) const noexcept { + // Should the op_impl operate in terms of `index_type` rather than `size_t`? + // Casting `size_t` to `index_type` here. + return static_cast(__impl::_call_op_impl(*this, static_cast(__idxs)...)); + } + + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; } + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { + return false; + } + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return true; } + + __MDSPAN_INLINE_FUNCTION static constexpr bool is_unique() noexcept { return true; } + __MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { + return required_span_size() == __get_size( extents(), _CUDA_VSTD::make_index_sequence()); + } + __MDSPAN_INLINE_FUNCTION static constexpr bool is_strided() noexcept { return true; } + + + __MDSPAN_TEMPLATE_REQUIRES( + class _Ext = _Extents, + /* requires */ ( + _Ext::rank() > 0 + ) + ) + __MDSPAN_INLINE_FUNCTION + constexpr index_type stride(rank_type __r) const noexcept { + return __strides_storage()[__r]; + } + +#if !(__MDSPAN_USE_CONCEPTS && __MDSPAN_HAS_CXX_20) + __MDSPAN_TEMPLATE_REQUIRES( + class _StridedLayoutMapping, + /* requires */ ( + __detail::__is_mapping_of && + (extents_type::rank() == _StridedLayoutMapping::extents_type::rank()) && + _StridedLayoutMapping::is_always_strided() + ) + ) +#else + template + requires( + __detail::__layout_mapping_alike<_StridedLayoutMapping> && + (extents_type::rank() == _StridedLayoutMapping::extents_type::rank()) && + _StridedLayoutMapping::is_always_strided() + ) +#endif + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator==(const mapping& __x, const _StridedLayoutMapping& __y) noexcept { + bool __strides_match = true; + for(rank_type __r = 0; __r < extents_type::rank(); __r++) + __strides_match = __strides_match && (__x.stride(__r) == __y.stride(__r)); + return (__x.extents() == __y.extents()) && + (__impl::__OFFSET(__y)== static_cast(0)) && + __strides_match; + } + + // This one is not technically part of the proposal. Just here to make implementation a bit more optimal hopefully + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherExtents, + /* requires */ ( + (extents_type::rank() == _OtherExtents::rank()) + ) + ) + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator==(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept { + return __impl::_eq_impl(__lhs, __rhs); + } + +#if !__MDSPAN_HAS_CXX_20 + __MDSPAN_TEMPLATE_REQUIRES( + class _StridedLayoutMapping, + /* requires */ ( + __detail::__is_mapping_of && + (extents_type::rank() == _StridedLayoutMapping::extents_type::rank()) && + _StridedLayoutMapping::is_always_strided() + ) + ) + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator!=(const mapping& __x, const _StridedLayoutMapping& __y) noexcept { + return not (__x == __y); + } + + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherExtents, + /* requires */ ( + (extents_type::rank() == _OtherExtents::rank()) + ) + ) + __MDSPAN_INLINE_FUNCTION + friend constexpr bool operator!=(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept { + return __impl::_not_eq_impl(__lhs, __rhs); + } +#endif + + }; +}; + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_LAYOUT_STRIDE_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/macros.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/macros.h new file mode 100644 index 0000000000000000000000000000000000000000..0a14f21debf0a71f9a9011bc2240d94f2670eb6f --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/macros.h @@ -0,0 +1,639 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#ifndef _LIBCUDACXX___MDSPAN_MACROS_HPP +#define _LIBCUDACXX___MDSPAN_MACROS_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/config.h" +#include "../__type_traits/enable_if.h" +#include "../__type_traits/is_void.h" +#include "../__type_traits/remove_reference.h" +#include "../__utility/declval.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#if _LIBCUDACXX_STD_VER > 11 + +#ifndef __MDSPAN_FORCE_INLINE_FUNCTION +# ifdef __MDSPAN_COMPILER_MSVC // Microsoft compilers +# define __MDSPAN_FORCE_INLINE_FUNCTION __forceinline _LIBCUDACXX_HOST_DEVICE +# else +# define __MDSPAN_FORCE_INLINE_FUNCTION __attribute__((always_inline)) _LIBCUDACXX_HOST_DEVICE +# endif +#endif + +#ifndef __MDSPAN_INLINE_FUNCTION +# define __MDSPAN_INLINE_FUNCTION inline _LIBCUDACXX_HOST_DEVICE +#endif + +// In CUDA defaulted functions do not need host device markup +#ifndef __MDSPAN_INLINE_FUNCTION_DEFAULTED +# define __MDSPAN_INLINE_FUNCTION_DEFAULTED +#endif + +//============================================================================== +// {{{1 + +#define __MDSPAN_PP_COUNT(...) \ + __MDSPAN_PP_INTERNAL_EXPAND_ARGS_PRIVATE( \ + __MDSPAN_PP_INTERNAL_ARGS_AUGMENTER(__VA_ARGS__) \ + ) + +#define __MDSPAN_PP_INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__ +#define __MDSPAN_PP_INTERNAL_EXPAND(x) x +#define __MDSPAN_PP_INTERNAL_EXPAND_ARGS_PRIVATE(...) \ + __MDSPAN_PP_INTERNAL_EXPAND( \ + __MDSPAN_PP_INTERNAL_COUNT_PRIVATE( \ + __VA_ARGS__, 69, 68, 67, 66, 65, 64, 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 \ + ) \ + ) +# define __MDSPAN_PP_INTERNAL_COUNT_PRIVATE( \ + _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, _64, _65, _66, _67, _68, _69, \ + _70, count, ...) count \ + /**/ + +#define __MDSPAN_PP_STRINGIFY_IMPL(x) #x +#define __MDSPAN_PP_STRINGIFY(x) __MDSPAN_PP_STRINGIFY_IMPL(x) + +#define __MDSPAN_PP_CAT_IMPL(x, y) x ## y +#define __MDSPAN_PP_CAT(x, y) __MDSPAN_PP_CAT_IMPL(x, y) + +#define __MDSPAN_PP_EVAL(X, ...) X(__VA_ARGS__) + +#define __MDSPAN_PP_REMOVE_PARENS_IMPL(...) __VA_ARGS__ +#define __MDSPAN_PP_REMOVE_PARENS(...) __MDSPAN_PP_REMOVE_PARENS_IMPL __VA_ARGS__ + +// end Preprocessor helpers }}}1 +//============================================================================== + +//============================================================================== +// {{{1 + +// These compatibility macros don't help with partial ordering, but they should do the trick +// for what we need to do with concepts in mdspan +#ifdef __MDSPAN_USE_CONCEPTS +# define __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) > requires REQ +# define __MDSPAN_FUNCTION_REQUIRES(PAREN_PREQUALS, FNAME, PAREN_PARAMS, QUALS, REQ) \ + __MDSPAN_PP_REMOVE_PARENS(PAREN_PREQUALS) FNAME PAREN_PARAMS QUALS requires REQ \ + /**/ +#else +# define __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) , typename _CUDA_VSTD::enable_if<(REQ), int>::type = 0> +# define __MDSPAN_FUNCTION_REQUIRES(PAREN_PREQUALS, FNAME, PAREN_PARAMS, QUALS, REQ) \ + __MDSPAN_TEMPLATE_REQUIRES( \ + class __function_requires_ignored=void, \ + (_CUDA_VSTD::is_void<__function_requires_ignored>::value && REQ) \ + ) __MDSPAN_PP_REMOVE_PARENS(PAREN_PREQUALS) FNAME PAREN_PARAMS QUALS \ + /**/ +#endif + + +#if defined(__MDSPAN_COMPILER_MSVC) +# define __MDSPAN_TEMPLATE_REQUIRES(...) \ + __MDSPAN_PP_CAT( \ + __MDSPAN_PP_CAT(__MDSPAN_TEMPLATE_REQUIRES_, __MDSPAN_PP_COUNT(__VA_ARGS__))\ + (__VA_ARGS__), \ + ) \ + /**/ +#else +# define __MDSPAN_TEMPLATE_REQUIRES(...) \ + __MDSPAN_PP_EVAL( \ + __MDSPAN_PP_CAT(__MDSPAN_TEMPLATE_REQUIRES_, __MDSPAN_PP_COUNT(__VA_ARGS__)), \ + __VA_ARGS__ \ + ) \ + /**/ +#endif + +#define __MDSPAN_TEMPLATE_REQUIRES_2(TP1, REQ) \ + template end Concept emulation }}}1 +//============================================================================== + +//============================================================================== +// {{{1 + +#if __MDSPAN_USE_RETURN_TYPE_DEDUCTION +# define __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ + auto __MDSPAN_PP_REMOVE_PARENS(SIGNATURE) { return __MDSPAN_PP_REMOVE_PARENS(BODY); } +# define __MDSPAN_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ + decltype(auto) __MDSPAN_PP_REMOVE_PARENS(SIGNATURE) { return __MDSPAN_PP_REMOVE_PARENS(BODY); } +#else +# define __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ + auto __MDSPAN_PP_REMOVE_PARENS(SIGNATURE) \ + -> _CUDA_VSTD::remove_cv_t<_CUDA_VSTD::remove_reference_t> \ + { return __MDSPAN_PP_REMOVE_PARENS(BODY); } +# define __MDSPAN_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \ + auto __MDSPAN_PP_REMOVE_PARENS(SIGNATURE) \ + -> decltype(BODY) \ + { return __MDSPAN_PP_REMOVE_PARENS(BODY); } + +#endif + +// end Return type deduction }}}1 +//============================================================================== + +//============================================================================== +// {{{1 + +struct __mdspan_enable_fold_comma { }; + +#ifdef __MDSPAN_USE_FOLD_EXPRESSIONS +# define __MDSPAN_FOLD_AND(...) ((__VA_ARGS__) && ...) +# define __MDSPAN_FOLD_AND_TEMPLATE(...) ((__VA_ARGS__) && ...) +# define __MDSPAN_FOLD_OR(...) ((__VA_ARGS__) || ...) +# define __MDSPAN_FOLD_ASSIGN_LEFT(__INIT, ...) (__INIT = ... = (__VA_ARGS__)) +# define __MDSPAN_FOLD_ASSIGN_RIGHT(__PACK, ...) (__PACK = ... = (__VA_ARGS__)) +# define __MDSPAN_FOLD_TIMES_RIGHT(__PACK, ...) (__PACK * ... * (__VA_ARGS__)) +# define __MDSPAN_FOLD_PLUS_RIGHT(__PACK, ...) (__PACK + ... + (__VA_ARGS__)) +# define __MDSPAN_FOLD_COMMA(...) ((__VA_ARGS__), ...) +#else + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +namespace __fold_compatibility_impl { + +// We could probably be more clever here, but at the (small) risk of losing some compiler understanding. For the +// few operations we need, it's not worth generalizing over the operation + +#if __MDSPAN_USE_RETURN_TYPE_DEDUCTION + +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr decltype(auto) __fold_right_and_impl() { + return true; +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr decltype(auto) __fold_right_and_impl(_Arg&& __arg, _Args&&... __args) { + return ((_Arg&&)__arg) && __fold_compatibility_impl::__fold_right_and_impl((_Args&&)__args...); +} + +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr decltype(auto) __fold_right_or_impl() { + return false; +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr auto __fold_right_or_impl(_Arg&& __arg, _Args&&... __args) { + return ((_Arg&&)__arg) || __fold_compatibility_impl::__fold_right_or_impl((_Args&&)__args...); +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr auto __fold_left_assign_impl(_Arg1&& __arg1) { + return (_Arg1&&)__arg1; +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr auto __fold_left_assign_impl(_Arg1&& __arg1, _Arg2&& __arg2, _Args&&... __args) { + return __fold_compatibility_impl::__fold_left_assign_impl((((_Arg1&&)__arg1) = ((_Arg2&&)__arg2)), (_Args&&)__args...); +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr auto __fold_right_assign_impl(_Arg1&& __arg1) { + return (_Arg1&&)__arg1; +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr auto __fold_right_assign_impl(_Arg1&& __arg1, _Arg2&& __arg2, _Args&&... __args) { + return ((_Arg1&&)__arg1) = __fold_compatibility_impl::__fold_right_assign_impl((_Arg2&&)__arg2, (_Args&&)__args...); +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr auto __fold_right_plus_impl(_Arg1&& __arg1) { + return (_Arg1&&)__arg1; +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr auto __fold_right_plus_impl(_Arg1&& __arg1, _Arg2&& __arg2, _Args&&... __args) { + return ((_Arg1&&)__arg1) + __fold_compatibility_impl::__fold_right_plus_impl((_Arg2&&)__arg2, (_Args&&)__args...); +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr auto __fold_right_times_impl(_Arg1&& __arg1) { + return (_Arg1&&)__arg1; +} + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr auto __fold_right_times_impl(_Arg1&& __arg1, _Arg2&& __arg2, _Args&&... __args) { + return ((_Arg1&&)__arg1) * __fold_compatibility_impl::__fold_right_times_impl((_Arg2&&)__arg2, (_Args&&)__args...); +} + +#else + +//------------------------------------------------------------------------------ +// {{{2 + +template +struct __fold_right_and_impl_; +template <> +struct __fold_right_and_impl_<> { + using __rv = bool; + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl() noexcept { + return true; + } +}; +template +struct __fold_right_and_impl_<_Arg, _Args...> { + using __next_t = __fold_right_and_impl_<_Args...>; + using __rv = decltype(_CUDA_VSTD::declval<_Arg>() && _CUDA_VSTD::declval()); + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg&& __arg, _Args&&... __args) noexcept { + return ((_Arg&&)__arg) && __next_t::__impl((_Args&&)__args...); + } +}; + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr typename __fold_right_and_impl_<_Args...>::__rv +__fold_right_and_impl(_Args&&... __args) { + return __fold_right_and_impl_<_Args...>::__impl((_Args&&)__args...); +} + +// end right and }}}2 +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// {{{2 + +template +struct __fold_right_or_impl_; +template <> +struct __fold_right_or_impl_<> { + using __rv = bool; + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl() noexcept { + return false; + } +}; +template +struct __fold_right_or_impl_<_Arg, _Args...> { + using __next_t = __fold_right_or_impl_<_Args...>; + using __rv = decltype(_CUDA_VSTD::declval<_Arg>() || _CUDA_VSTD::declval()); + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg&& __arg, _Args&&... __args) noexcept { + return ((_Arg&&)__arg) || __next_t::__impl((_Args&&)__args...); + } +}; + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr typename __fold_right_or_impl_<_Args...>::__rv +__fold_right_or_impl(_Args&&... __args) { + return __fold_right_or_impl_<_Args...>::__impl((_Args&&)__args...); +} + +// end right or }}}2 +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// {{{2 + +template +struct __fold_right_plus_impl_; +template +struct __fold_right_plus_impl_<_Arg> { + using __rv = _Arg&&; + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg&& __arg) noexcept { + return (_Arg&&)__arg; + } +}; +template +struct __fold_right_plus_impl_<_Arg1, _Arg2, _Args...> { + using __next_t = __fold_right_plus_impl_<_Arg2, _Args...>; + using __rv = decltype(_CUDA_VSTD::declval<_Arg1>() + _CUDA_VSTD::declval()); + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg1&& __arg, _Arg2&& __arg2, _Args&&... __args) noexcept { + return ((_Arg1&&)__arg) + __next_t::__impl((_Arg2&&)__arg2, (_Args&&)__args...); + } +}; + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr typename __fold_right_plus_impl_<_Args...>::__rv +__fold_right_plus_impl(_Args&&... __args) { + return __fold_right_plus_impl_<_Args...>::__impl((_Args&&)__args...); +} + +// end right plus }}}2 +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// {{{2 + +template +struct __fold_right_times_impl_; +template +struct __fold_right_times_impl_<_Arg> { + using __rv = _Arg&&; + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg&& __arg) noexcept { + return (_Arg&&)__arg; + } +}; +template +struct __fold_right_times_impl_<_Arg1, _Arg2, _Args...> { + using __next_t = __fold_right_times_impl_<_Arg2, _Args...>; + using __rv = decltype(_CUDA_VSTD::declval<_Arg1>() * _CUDA_VSTD::declval()); + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg1&& __arg, _Arg2&& __arg2, _Args&&... __args) noexcept { + return ((_Arg1&&)__arg) * __next_t::__impl((_Arg2&&)__arg2, (_Args&&)__args...); + } +}; + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr typename __fold_right_times_impl_<_Args...>::__rv +__fold_right_times_impl(_Args&&... __args) { + return __fold_right_times_impl_<_Args...>::__impl((_Args&&)__args...); +} + +// end right times }}}2 +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// {{{2 + +template +struct __fold_right_assign_impl_; +template +struct __fold_right_assign_impl_<_Arg> { + using __rv = _Arg&&; + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg&& __arg) noexcept { + return (_Arg&&)__arg; + } +}; +template +struct __fold_right_assign_impl_<_Arg1, _Arg2, _Args...> { + using __next_t = __fold_right_assign_impl_<_Arg2, _Args...>; + using __rv = decltype(_CUDA_VSTD::declval<_Arg1>() = _CUDA_VSTD::declval()); + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg1&& __arg, _Arg2&& __arg2, _Args&&... __args) noexcept { + return ((_Arg1&&)__arg) = __next_t::__impl((_Arg2&&)__arg2, (_Args&&)__args...); + } +}; + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr typename __fold_right_assign_impl_<_Args...>::__rv +__fold_right_assign_impl(_Args&&... __args) { + return __fold_right_assign_impl_<_Args...>::__impl((_Args&&)__args...); +} + +// end right assign }}}2 +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// {{{2 + +template +struct __fold_left_assign_impl_; +template +struct __fold_left_assign_impl_<_Arg> { + using __rv = _Arg&&; + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg&& __arg) noexcept { + return (_Arg&&)__arg; + } +}; +template +struct __fold_left_assign_impl_<_Arg1, _Arg2, _Args...> { + using __assign_result_t = decltype(_CUDA_VSTD::declval<_Arg1>() = _CUDA_VSTD::declval<_Arg2>()); + using __next_t = __fold_left_assign_impl_<__assign_result_t, _Args...>; + using __rv = typename __next_t::__rv; + __MDSPAN_FORCE_INLINE_FUNCTION + static constexpr __rv + __impl(_Arg1&& __arg, _Arg2&& __arg2, _Args&&... __args) noexcept { + return __next_t::__impl(((_Arg1&&)__arg) = (_Arg2&&)__arg2, (_Args&&)__args...); + } +}; + +template +__MDSPAN_FORCE_INLINE_FUNCTION +constexpr typename __fold_left_assign_impl_<_Args...>::__rv +__fold_left_assign_impl(_Args&&... __args) { + return __fold_left_assign_impl_<_Args...>::__impl((_Args&&)__args...); +} + +// end left assign }}}2 +//------------------------------------------------------------------------------ + +#endif + + +template +_LIBCUDACXX_HOST_DEVICE +constexpr __mdspan_enable_fold_comma __fold_comma_impl(_Args&&...) noexcept { return { }; } + +template +struct __bools; + +} // __fold_compatibility_impl + +_LIBCUDACXX_END_NAMESPACE_STD + +# define __MDSPAN_FOLD_AND(...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_and_impl((__VA_ARGS__)...) +# define __MDSPAN_FOLD_OR(...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_or_impl((__VA_ARGS__)...) +# define __MDSPAN_FOLD_ASSIGN_LEFT(__INIT, ...) _CUDA_VSTD::__fold_compatibility_impl::__fold_left_assign_impl(__INIT, (__VA_ARGS__)...) +# define __MDSPAN_FOLD_ASSIGN_RIGHT(__PACK, ...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_assign_impl((__PACK)..., __VA_ARGS__) +# define __MDSPAN_FOLD_TIMES_RIGHT(__PACK, ...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_times_impl((__PACK)..., __VA_ARGS__) +# define __MDSPAN_FOLD_PLUS_RIGHT(__PACK, ...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_plus_impl((__PACK)..., __VA_ARGS__) +# define __MDSPAN_FOLD_COMMA(...) _CUDA_VSTD::__fold_compatibility_impl::__fold_comma_impl((__VA_ARGS__)...) + +# define __MDSPAN_FOLD_AND_TEMPLATE(...) \ + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_same, __fold_compatibility_impl::__bools<(__VA_ARGS__)..., true>, __fold_compatibility_impl::__bools) + +#endif + +// end Variable template compatibility }}}1 +//============================================================================== + +//============================================================================== +// {{{1 + +#if __MDSPAN_USE_CONSTEXPR_14 +// Workaround for a bug (I think?) in EDG frontends +# ifdef __EDG__ +# define __MDSPAN_CONSTEXPR_14_DEFAULTED +# else +# define __MDSPAN_CONSTEXPR_14_DEFAULTED constexpr +# endif +#else +# define __MDSPAN_CONSTEXPR_14_DEFAULTED +#endif + +// end Pre-C++14 constexpr }}}1 +//============================================================================== + +#endif // _LIBCUDACXX_STD_VER > 11 + +#ifndef _LIBCUDACXX_NO_EXCEPTIONS +#define _LIBCUDACXX_THROW_RUNTIME_ERROR(_COND, _MESSAGE) \ + if (!(_COND)) __throw_runtime_error(_MESSAGE) +#else +#define _LIBCUDACXX_THROW_RUNTIME_ERROR(_COND, _MESSAGE) \ + _LIBCUDACXX_ASSERT(_COND, _MESSAGE) +#endif + +#endif // _LIBCUDACXX___MDSPAN_MACROS_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/maybe_static_value.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/maybe_static_value.h new file mode 100644 index 0000000000000000000000000000000000000000..a6a41aca87248cb599e1534bd18dec66bf7083ba --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/maybe_static_value.h @@ -0,0 +1,167 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_MAYBE_STATIC_VALUE_HPP +#define _LIBCUDACXX___MDSPAN_MAYBE_STATIC_VALUE_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/dynamic_extent.h" +#include "../__mdspan/macros.h" +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS +#include "../__mdspan/no_unique_address.h" +#endif + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +// This is only needed for the non-standard-layout version of partially +// static array. +// Needs to be after the includes above to work with the single header generator +#if !__MDSPAN_PRESERVE_STANDARD_LAYOUT + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +//============================================================================== + +namespace __detail { + +// static case +template +struct __maybe_static_value { + static constexpr _static_t __static_value = __v; + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _dynamic_t __value() const noexcept { + return static_cast<_dynamic_t>(__v); + } + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr + __mdspan_enable_fold_comma + __set_value(_Up&& /*__rhs*/) noexcept { + // Should we assert that the value matches the static value here? + return {}; + } + + //-------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __maybe_static_value() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __maybe_static_value(__maybe_static_value const&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __maybe_static_value(__maybe_static_value&&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __maybe_static_value& operator=(__maybe_static_value const&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __maybe_static_value& operator=(__maybe_static_value&&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__maybe_static_value() noexcept = default; + + __MDSPAN_INLINE_FUNCTION + constexpr explicit __maybe_static_value(_dynamic_t const&) noexcept { + // Should we assert that the value matches the static value here? + } + + //-------------------------------------------------------------------------- + +}; + +// dynamic case +template +struct __maybe_static_value<_dynamic_t, _static_t, __is_dynamic_sentinal, __is_dynamic_sentinal, + __array_entry_index> +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __no_unique_address_emulation<_Tp> +#endif +{ + static constexpr _static_t __static_value = __is_dynamic_sentinal; +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + _LIBCUDACXX_NO_UNIQUE_ADDRESS _dynamic_t __v = {}; + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _dynamic_t __value() const noexcept { + return __v; + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _dynamic_t &__ref() noexcept { + return __v; + } + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr + __mdspan_enable_fold_comma + __set_value(_Up&& __rhs) noexcept { + __v = (_Up &&)rhs; + return {}; + } +#else + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _dynamic_t __value() const noexcept { + return this->__no_unique_address_emulation<_dynamic_t>::__ref(); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _dynamic_t &__ref() noexcept { + return this->__no_unique_address_emulation<_dynamic_t>::__ref(); + } + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr + __mdspan_enable_fold_comma + __set_value(_Up&& __rhs) noexcept { + this->__no_unique_address_emulation<_dynamic_t>::__ref() = (_Up &&)__rhs; + return {}; + } +#endif +}; + +} // namespace __detail + +//============================================================================== + + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // !__MDSPAN_PRESERVE_STANDARD_LAYOUT + +#endif // _LIBCUDACXX___MDSPAN_MAYBE_STATIC_VALUE_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/mdspan.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/mdspan.h new file mode 100644 index 0000000000000000000000000000000000000000..f5323a72ced0f05f91075286f2d9b3a07fb76345 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/mdspan.h @@ -0,0 +1,466 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#ifndef _LIBCUDACXX___MDSPAN_MDSPAN_HPP +#define _LIBCUDACXX___MDSPAN_MDSPAN_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/default_accessor.h" +#include "../__mdspan/layout_right.h" +#include "../__mdspan/extents.h" +#include "../__mdspan/compressed_pair.h" +#include "../__type_traits/extent.h" +#include "../__type_traits/is_constructible.h" +#include "../__type_traits/is_convertible.h" +#include "../__type_traits/is_default_constructible.h" +#include "../__type_traits/is_nothrow_constructible.h" +#include "../__type_traits/rank.h" +#include "../__type_traits/remove_cv.h" +#include "../__type_traits/remove_pointer.h" +#include "../__type_traits/remove_reference.h" +#include "../__type_traits/remove_all_extents.h" +#include "../__utility/as_const.h" +#include "../__utility/integer_sequence.h" +#include "../__utility/move.h" +#include "../array" +#include "../span" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +template < + class _ElementType, + class _Extents, + class _LayoutPolicy = layout_right, + class _AccessorPolicy = default_accessor<_ElementType> +> +class mdspan +{ +private: + static_assert(__detail::__is_extents_v<_Extents>, "mdspan's Extents template parameter must be a specialization of _CUDA_VSTD::extents."); + + // Workaround for non-deducibility of the index sequence template parameter if it's given at the top level + template + struct __deduction_workaround; + + template + struct __deduction_workaround<_CUDA_VSTD::index_sequence<_Idxs...>> + { + __MDSPAN_FORCE_INLINE_FUNCTION static constexpr + size_t __size(mdspan const& __self) noexcept { + return __MDSPAN_FOLD_TIMES_RIGHT((__self.__mapping_ref().extents().template __extent<_Idxs>()), /* * ... * */ size_t(1)); + } + __MDSPAN_FORCE_INLINE_FUNCTION static constexpr + bool __empty(mdspan const& __self) noexcept { + return (__self.rank()>0) && __MDSPAN_FOLD_OR((__self.__mapping_ref().extents().template __extent<_Idxs>()==index_type(0))); + } + template + __MDSPAN_FORCE_INLINE_FUNCTION static constexpr + _ReferenceType __callop(mdspan const& __self, const _CUDA_VSTD::array<_SizeType, _Np>& __indices) noexcept { + return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(__indices[_Idxs]...)); + } + template + __MDSPAN_FORCE_INLINE_FUNCTION static constexpr + _ReferenceType __callop(mdspan const& __self, const _CUDA_VSTD::span<_SizeType, _Np>& __indices) noexcept { + return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(__indices[_Idxs]...)); + } + }; + +public: + + //-------------------------------------------------------------------------------- + // Domain and codomain types + + using extents_type = _Extents; + using layout_type = _LayoutPolicy; + using accessor_type = _AccessorPolicy; + using mapping_type = typename layout_type::template mapping; + using element_type = _ElementType; + using value_type = _CUDA_VSTD::remove_cv_t; + using index_type = typename extents_type::index_type; + using size_type = typename extents_type::size_type; + using rank_type = typename extents_type::rank_type; + using data_handle_type = typename accessor_type::data_handle_type; + using reference = typename accessor_type::reference; + + __MDSPAN_INLINE_FUNCTION static constexpr size_t rank() noexcept { return extents_type::rank(); } + __MDSPAN_INLINE_FUNCTION static constexpr size_t rank_dynamic() noexcept { return extents_type::rank_dynamic(); } + __MDSPAN_INLINE_FUNCTION static constexpr size_t static_extent(size_t __r) noexcept { return extents_type::static_extent(__r); } + __MDSPAN_INLINE_FUNCTION constexpr index_type extent(size_t __r) const noexcept { return __mapping_ref().extents().extent(__r); }; + +private: + + // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348. + using __impl = __deduction_workaround<_CUDA_VSTD::make_index_sequence>; + + using __map_acc_pair_t = __detail::__compressed_pair; + +public: + + //-------------------------------------------------------------------------------- + // [mdspan.basic.cons], mdspan constructors, assignment, and destructor + +#if !__MDSPAN_HAS_CXX_20 + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdspan() = default; +#else + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdspan() + requires( + // Directly using rank_dynamic()>0 here doesn't work for nvcc + (extents_type::rank_dynamic() >0) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_default_constructible, data_handle_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_default_constructible, mapping_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_default_constructible, accessor_type) + ) = default; +#endif + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdspan(const mdspan&) = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdspan(mdspan&&) = default; + + __MDSPAN_TEMPLATE_REQUIRES( + class... _SizeTypes, + /* requires */ ( + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SizeTypes, index_type) /* && ... */) && + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _SizeTypes) /* && ... */) && + ((sizeof...(_SizeTypes) == rank()) || (sizeof...(_SizeTypes) == rank_dynamic())) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, mapping_type, extents_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_default_constructible, accessor_type) + ) + ) + __MDSPAN_INLINE_FUNCTION + explicit constexpr mdspan(data_handle_type __p, _SizeTypes... __dynamic_extents) + // TODO @proposal-bug shouldn't I be allowed to do `move(__p)` here? + : __members(_CUDA_VSTD::move(__p), __map_acc_pair_t(mapping_type(extents_type(static_cast(_CUDA_VSTD::move(__dynamic_extents))...)), accessor_type())) + { } + + __MDSPAN_TEMPLATE_REQUIRES( + class _SizeType, size_t _Np, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SizeType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _SizeType) && + ((_Np == rank()) || (_Np == rank_dynamic())) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, mapping_type, extents_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_default_constructible, accessor_type) + ) + ) + __MDSPAN_CONDITIONAL_EXPLICIT(_Np != rank_dynamic()) + __MDSPAN_INLINE_FUNCTION + constexpr mdspan(data_handle_type __p, const _CUDA_VSTD::array<_SizeType, _Np>& __dynamic_extents) + : __members(_CUDA_VSTD::move(__p), __map_acc_pair_t(mapping_type(extents_type(__dynamic_extents)), accessor_type())) + { } + + __MDSPAN_TEMPLATE_REQUIRES( + class _SizeType, size_t _Np, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SizeType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _SizeType) && + ((_Np == rank()) || (_Np == rank_dynamic())) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, mapping_type, extents_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_default_constructible, accessor_type) + ) + ) + __MDSPAN_CONDITIONAL_EXPLICIT(_Np != rank_dynamic()) + __MDSPAN_INLINE_FUNCTION + constexpr mdspan(data_handle_type __p, _CUDA_VSTD::span<_SizeType, _Np> __dynamic_extents) + : __members(_CUDA_VSTD::move(__p), __map_acc_pair_t(mapping_type(extents_type(_CUDA_VSTD::as_const(__dynamic_extents))), accessor_type())) + { } + + __MDSPAN_FUNCTION_REQUIRES( + (__MDSPAN_INLINE_FUNCTION constexpr), + mdspan, (data_handle_type __p, const extents_type& __exts), , + /* requires */ (_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_default_constructible, accessor_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, mapping_type, extents_type)) + ) : __members(_CUDA_VSTD::move(__p), __map_acc_pair_t(mapping_type(__exts), accessor_type())) + { } + + __MDSPAN_FUNCTION_REQUIRES( + (__MDSPAN_INLINE_FUNCTION constexpr), + mdspan, (data_handle_type __p, const mapping_type& __m), , + /* requires */ (_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_default_constructible, accessor_type)) + ) : __members(_CUDA_VSTD::move(__p), __map_acc_pair_t(__m, accessor_type())) + { } + + __MDSPAN_INLINE_FUNCTION + constexpr mdspan(data_handle_type __p, const mapping_type& __m, const accessor_type& __a) + : __members(_CUDA_VSTD::move(__p), __map_acc_pair_t(__m, __a)) + { } + + __MDSPAN_TEMPLATE_REQUIRES( + class _OtherElementType, class _OtherExtents, class _OtherLayoutPolicy, class _OtherAccessor, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, mapping_type, typename _OtherLayoutPolicy::template mapping<_OtherExtents>) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, accessor_type, _OtherAccessor) + ) + ) + __MDSPAN_INLINE_FUNCTION + constexpr mdspan(const mdspan<_OtherElementType, _OtherExtents, _OtherLayoutPolicy, _OtherAccessor>& __other) + : __members(__other.__ptr_ref(), __map_acc_pair_t(__other.__mapping_ref(), __other.__accessor_ref())) + { + static_assert(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, data_handle_type, typename _OtherAccessor::data_handle_type),"Incompatible data_handle_type for mdspan construction"); + static_assert(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents),"Incompatible extents for mdspan construction"); + /* + * TODO: Check precondition + * For each rank index __r of extents_type, static_extent(__r) == dynamic_extent || static_extent(__r) == __other.extent(__r) is true. + */ + } + + /* Might need this on NVIDIA? + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~mdspan() = default; + */ + + __MDSPAN_INLINE_FUNCTION_DEFAULTED __MDSPAN_CONSTEXPR_14_DEFAULTED mdspan& operator=(const mdspan&) = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED __MDSPAN_CONSTEXPR_14_DEFAULTED mdspan& operator=(mdspan&&) = default; + + + //-------------------------------------------------------------------------------- + // [mdspan.basic.mapping], mdspan mapping domain multidimensional index to access codomain element + + #if __MDSPAN_USE_BRACKET_OPERATOR + __MDSPAN_TEMPLATE_REQUIRES( + class... _SizeTypes, + /* requires */ ( + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SizeTypes, index_type) /* && ... */) && + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _SizeTypes) /* && ... */) && + (rank() == sizeof...(_SizeTypes)) + ) + ) + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr reference operator[](_SizeTypes... __indices) const + { + return __accessor_ref().access(__ptr_ref(), __mapping_ref()(index_type(__indices)...)); + } + #endif + + __MDSPAN_TEMPLATE_REQUIRES( + class _SizeType, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SizeType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _SizeType) + ) + ) + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr reference operator[](const _CUDA_VSTD::array<_SizeType, rank()>& __indices) const + { + return __impl::template __callop(*this, __indices); + } + + __MDSPAN_TEMPLATE_REQUIRES( + class _SizeType, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SizeType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _SizeType) + ) + ) + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr reference operator[](_CUDA_VSTD::span<_SizeType, rank()> __indices) const + { + return __impl::template __callop(*this, __indices); + } + + #if !__MDSPAN_USE_BRACKET_OPERATOR + __MDSPAN_TEMPLATE_REQUIRES( + class _Index, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Index, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Index) && + extents_type::rank() == 1 + ) + ) + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr reference operator[](_Index __idx) const + { + return __accessor_ref().access(__ptr_ref(), __mapping_ref()(index_type(__idx))); + } + #endif + + #if __MDSPAN_USE_PAREN_OPERATOR + __MDSPAN_TEMPLATE_REQUIRES( + class... _SizeTypes, + /* requires */ ( + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SizeTypes, index_type) /* && ... */) && + __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _SizeTypes) /* && ... */) && + extents_type::rank() == sizeof...(_SizeTypes) + ) + ) + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr reference operator()(_SizeTypes... __indices) const + { + return __accessor_ref().access(__ptr_ref(), __mapping_ref()(__indices...)); + } + + __MDSPAN_TEMPLATE_REQUIRES( + class _SizeType, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SizeType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _SizeType) + ) + ) + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr reference operator()(const _CUDA_VSTD::array<_SizeType, rank()>& __indices) const + { + return __impl::template __callop(*this, __indices); + } + + __MDSPAN_TEMPLATE_REQUIRES( + class _SizeType, + /* requires */ ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SizeType, index_type) && + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _SizeType) + ) + ) + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr reference operator()(_CUDA_VSTD::span<_SizeType, rank()> __indices) const + { + return __impl::template __callop(*this, __indices); + } + #endif // __MDSPAN_USE_PAREN_OPERATOR + + __MDSPAN_INLINE_FUNCTION constexpr size_t size() const noexcept { + return __impl::__size(*this); + }; + + __MDSPAN_INLINE_FUNCTION constexpr bool empty() const noexcept { + return __impl::__empty(*this); + }; + + __MDSPAN_INLINE_FUNCTION + friend constexpr void swap(mdspan& __x, mdspan& __y) noexcept { + swap(__x.__ptr_ref(), __y.__ptr_ref()); + swap(__x.__mapping_ref(), __y.__mapping_ref()); + swap(__x.__accessor_ref(), __y.__accessor_ref()); + } + + //-------------------------------------------------------------------------------- + // [mdspan.basic.domobs], mdspan observers of the domain multidimensional index space + + + __MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { return __mapping_ref().extents(); }; + __MDSPAN_INLINE_FUNCTION constexpr const data_handle_type& data_handle() const noexcept { return __ptr_ref(); }; + __MDSPAN_INLINE_FUNCTION constexpr const mapping_type& mapping() const noexcept { return __mapping_ref(); }; + __MDSPAN_INLINE_FUNCTION constexpr const accessor_type& accessor() const noexcept { return __accessor_ref(); }; + + //-------------------------------------------------------------------------------- + // [mdspan.basic.obs], mdspan observers of the mapping + + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return mapping_type::is_always_unique(); }; + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return mapping_type::is_always_exhaustive(); }; + __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return mapping_type::is_always_strided(); }; + + __MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return __mapping_ref().is_unique(); }; + __MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return __mapping_ref().is_exhaustive(); }; + __MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return __mapping_ref().is_strided(); }; + __MDSPAN_INLINE_FUNCTION constexpr index_type stride(size_t __r) const { return __mapping_ref().stride(__r); }; + +private: + + __detail::__compressed_pair __members{}; + + __MDSPAN_FORCE_INLINE_FUNCTION constexpr data_handle_type& __ptr_ref() noexcept { return __members.__first(); } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr data_handle_type const& __ptr_ref() const noexcept { return __members.__first(); } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr mapping_type& __mapping_ref() noexcept { return __members.__second().__first(); } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr mapping_type const& __mapping_ref() const noexcept { return __members.__second().__first(); } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr accessor_type& __accessor_ref() noexcept { return __members.__second().__second(); } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr accessor_type const& __accessor_ref() const noexcept { return __members.__second().__second(); } + + template + friend class mdspan; + +}; + +#if defined(__MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) +__MDSPAN_TEMPLATE_REQUIRES( + class _ElementType, class... _SizeTypes, + /* requires */ __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(is_integral, _SizeTypes) /* && ... */) && + (sizeof...(_SizeTypes) > 0) +) +explicit mdspan(_ElementType*, _SizeTypes...) + -> mdspan<_ElementType, dextents>; + +__MDSPAN_TEMPLATE_REQUIRES( + class _Pointer, + (_LIBCUDACXX_TRAIT(is_pointer, _CUDA_VSTD::remove_reference_t<_Pointer>)) +) +mdspan(_Pointer&&) -> mdspan<_CUDA_VSTD::remove_pointer_t<_CUDA_VSTD::remove_reference_t<_Pointer>>, extents>; +__MDSPAN_TEMPLATE_REQUIRES( + class _CArray, + (_LIBCUDACXX_TRAIT(is_array, _CArray) && (rank_v<_CArray> == 1)) +) +mdspan(_CArray&) -> mdspan<_CUDA_VSTD::remove_all_extents_t<_CArray>, extents>>; + +template +mdspan(_ElementType*, const _CUDA_VSTD::array<_SizeType, _Np>&) + -> mdspan<_ElementType, dextents>; + +template +mdspan(_ElementType*, _CUDA_VSTD::span<_SizeType, _Np>) + -> mdspan<_ElementType, dextents>; + +// This one is necessary because all the constructors take `data_handle_type`s, not +// `_ElementType*`s, and `data_handle_type` is taken from `accessor_type::data_handle_type`, which +// seems to throw off automatic deduction guides. +template +mdspan(_ElementType*, const extents<_SizeType, _ExtentsPack...>&) + -> mdspan<_ElementType, extents<_SizeType, _ExtentsPack...>>; + +template +mdspan(_ElementType*, const _MappingType&) + -> mdspan<_ElementType, typename _MappingType::extents_type, typename _MappingType::layout_type>; + +template +mdspan(const typename _AccessorType::data_handle_type, const _MappingType&, const _AccessorType&) + -> mdspan; +#endif + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_MDSPAN_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/no_unique_address.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/no_unique_address.h new file mode 100644 index 0000000000000000000000000000000000000000..c26892f031c1026b33292ee23ba6fb67e07ac042 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/no_unique_address.h @@ -0,0 +1,145 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX__LIBCUDACXX_NO_UNIQUE_ADDRESS_HPP +#define _LIBCUDACXX__LIBCUDACXX_NO_UNIQUE_ADDRESS_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/macros.h" +#include "../__type_traits/enable_if.h" +#include "../__type_traits/is_empty.h" +#include "../__type_traits/is_trivially_destructible.h" +#include "../__utility/move.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +namespace __detail { + +//============================================================================== + +template +struct __no_unique_address_emulation { + using __stored_type = _Tp; + _Tp __v; + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__ref() const noexcept { + return __v; + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__ref() noexcept { + return __v; + } +}; + +// Empty case +// This doesn't work if _Tp is final, of course, but we're not using anything +// like that currently. That kind of thing could be added pretty easily though +template +struct __no_unique_address_emulation< + _Tp, _Disambiguator, + _CUDA_VSTD::enable_if_t<_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Tp) && + // If the type isn't trivially destructible, its destructor + // won't be called at the right time, so don't use this + // specialization + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_trivially_destructible, _Tp)>> : +#ifdef __MDSPAN_COMPILER_MSVC + // MSVC doesn't allow you to access public static member functions of a type + // when you *happen* to privately inherit from that type. + protected +#else + // But we still want this to be private if possible so that we don't accidentally + // access members of _Tp directly rather than calling __ref() first, which wouldn't + // work if _Tp happens to be stateful and thus we're using the unspecialized definition + // of __no_unique_address_emulation above. + private +#endif + _Tp { + using __stored_type = _Tp; + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__ref() const noexcept { + return *static_cast<_Tp const *>(this); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__ref() noexcept { + return *static_cast<_Tp *>(this); + } + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __no_unique_address_emulation() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __no_unique_address_emulation( + __no_unique_address_emulation const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __no_unique_address_emulation( + __no_unique_address_emulation &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __no_unique_address_emulation & + operator=(__no_unique_address_emulation const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __no_unique_address_emulation & + operator=(__no_unique_address_emulation &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__no_unique_address_emulation() noexcept = default; + + // Explicitly make this not a reference so that the copy or move + // constructor still gets called. + __MDSPAN_INLINE_FUNCTION + explicit constexpr __no_unique_address_emulation(_Tp const& __v) noexcept : _Tp(__v) {} + __MDSPAN_INLINE_FUNCTION + explicit constexpr __no_unique_address_emulation(_Tp&& __v) noexcept : _Tp(_CUDA_VSTD::move(__v)) {} +}; + +//============================================================================== + +} // end namespace __detail + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX__LIBCUDACXX_NO_UNIQUE_ADDRESS_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/standard_layout_static_array.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/standard_layout_static_array.h new file mode 100644 index 0000000000000000000000000000000000000000..13d9c89f0ec22845075b80875cc725fb01c1ce2d --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/standard_layout_static_array.h @@ -0,0 +1,699 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_STANDARD_LAYOUT_STATIC_ARRAY_HPP +#define _LIBCUDACXX___MDSPAN_STANDARD_LAYOUT_STATIC_ARRAY_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/compressed_pair.h" +#include "../__mdspan/dynamic_extent.h" +#include "../__mdspan/macros.h" +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS +#include "../__mdspan/no_unique_address.h" +#endif +#include "../__type_traits/enable_if.h" +#include "../__utility/integer_sequence.h" +#include "../array" +#include "../cstddef" +#include "../span" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +namespace __detail { + +//============================================================================== + +struct __construct_psa_from_dynamic_exts_values_tag_t {}; +_LIBCUDACXX_CPO_ACCESSIBILITY __construct_psa_from_dynamic_exts_values_tag_t __construct_psa_from_dynamic_exts_values_tag; + +struct __construct_psa_from_all_exts_values_tag_t {}; +_LIBCUDACXX_CPO_ACCESSIBILITY __construct_psa_from_all_exts_values_tag_t __construct_psa_from_all_exts_values_tag; + +struct __construct_psa_from_all_exts_array_tag_t {}; +template +struct __construct_psa_from_dynamic_exts_array_tag_t {}; + +//============================================================================== + +template using __repeated_with_idxs = _Tp; + +//============================================================================== + +#if __MDSPAN_PRESERVE_STANDARD_LAYOUT + +/** + * PSA = "partially static array" + * + * @tparam _Tp + * @tparam _ValsSeq + * @tparam __sentinal + */ +template (dynamic_extent), + class _IdxsSeq = _CUDA_VSTD::make_index_sequence<_ValsSeq::size()>> +struct __standard_layout_psa; + +//============================================================================== +// Static case +template +struct __standard_layout_psa< + _Tag, _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __value, __values_or_sentinals...>, + __sentinal, _CUDA_VSTD::integer_sequence> +#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : private __no_unique_address_emulation<__standard_layout_psa< + _Tag, _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>, __sentinal, + _CUDA_VSTD::integer_sequence>> +#endif +{ + + //-------------------------------------------------------------------------- + + using __next_t = + __standard_layout_psa<_Tag, _Tp, _static_t, + _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>, + __sentinal, _CUDA_VSTD::integer_sequence>; + +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + _LIBCUDACXX_NO_UNIQUE_ADDRESS __next_t __next_; +#else + using __base_t = __no_unique_address_emulation<__next_t>; +#endif + + __MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t &__next() noexcept { +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + return __next_; +#else + return this->__base_t::__ref(); +#endif + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t const &__next() const noexcept { +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + return __next_; +#else + return this->__base_t::__ref(); +#endif + } + + static constexpr auto __size = sizeof...(_Idxs) + 1; + static constexpr auto __size_dynamic = __next_t::__size_dynamic; + + //-------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __standard_layout_psa() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __standard_layout_psa(__standard_layout_psa const &) noexcept = + default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __standard_layout_psa(__standard_layout_psa &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa & + operator=(__standard_layout_psa const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa & + operator=(__standard_layout_psa &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__standard_layout_psa() noexcept = default; + + //-------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION + constexpr __standard_layout_psa( + __construct_psa_from_all_exts_values_tag_t, _Tp const & /*__val*/, + __repeated_with_idxs<_Idxs, _Tp> const &... __vals) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __next_{ +#else + : __base_t(__base_t{__next_t( +#endif + __construct_psa_from_all_exts_values_tag, __vals... +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { } + + template + __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa( + __construct_psa_from_dynamic_exts_values_tag_t, + _Ts const &... __vals) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __next_{ +#else + : __base_t(__base_t{__next_t( +#endif + __construct_psa_from_dynamic_exts_values_tag, __vals... +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { } + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + array<_Up, _Np> const &__vals) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __next_{ +#else + : __base_t(__base_t{__next_t( +#endif + __vals +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { } + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_all_exts_array_tag_t const & __tag, + array<_Up, _NStatic> const &__vals) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __next_{ +#else + : __base_t(__base_t{__next_t( +#endif + __tag, __vals +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { } + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic> __tag, + array<_Up, _NDynamic> const &__vals) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __next_{ +#else + : __base_t(__base_t{__next_t( +#endif + __tag, __vals +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { } + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + _CUDA_VSTD::span<_Up, _Np> const &__vals) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __next_{ +#else + : __base_t(__base_t{__next_t( +#endif + __vals +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { } + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_all_exts_array_tag_t const & __tag, + _CUDA_VSTD::span<_Up, _NStatic> const &__vals) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __next_{ +#else + : __base_t(__base_t{__next_t( +#endif + __tag, __vals +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { } + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic> __tag, + _CUDA_VSTD::span<_Up, _NDynamic> const &__vals) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __next_{ +#else + : __base_t(__base_t{__next_t( +#endif + __tag, __vals +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { } + + template + __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa( + __standard_layout_psa<_UTag, _Up, _static_U, _UValsSeq, __u_sentinal, _IdxsSeq> const + &__rhs) noexcept +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + : __next_{ +#else + : __base_t(__base_t{__next_t( +#endif + __rhs.__next() +#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS + } +#else + )}) +#endif + { } + + //-------------------------------------------------------------------------- + + // See https://godbolt.org/z/_KSDNX for a summary-by-example of why this is + // necessary. We're using inheritance here instead of an alias template + // because we have to deduce __values_or_sentinals in several places, and + // alias templates don't permit that in this context. + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr __standard_layout_psa const &__enable_psa_conversion() const + noexcept { + return *this; + } + + template = 0> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept { + return __next().template __get_n<_Ip>(); + } + template = 1> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept { + return __value; + } + template = 0> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr void + __set_n(_Tp const &__rhs) noexcept { + __next().__set_value(__rhs); + } + template = 1> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr void + __set_n(_Tp const &) noexcept { + // Don't assert here because that would break constexpr. This better + // not change anything, though + } + template = __sentinal> + __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept { + return __value; + } + template __default = __sentinal> + __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept { + return __next_t::template __get_static_n<_Ip, __default>(); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get(size_t __n) const noexcept { + return __value * (_Tp(_Idx == __n)) + __next().__get(__n); + } + + //-------------------------------------------------------------------------- +}; + +//============================================================================== + +// Dynamic case, __next_t may or may not be empty +template +struct __standard_layout_psa< + _Tag, _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __sentinal, __values_or_sentinals...>, + __sentinal, _CUDA_VSTD::integer_sequence> { + //-------------------------------------------------------------------------- + + using __next_t = + __standard_layout_psa<_Tag, _Tp, _static_t, + _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>, + __sentinal, _CUDA_VSTD::integer_sequence>; + + using __value_pair_t = __compressed_pair<_Tp, __next_t>; + __value_pair_t __value_pair; + __MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t &__next() noexcept { + return __value_pair.__second(); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t const &__next() const noexcept { + return __value_pair.__second(); + } + + static constexpr auto __size = sizeof...(_Idxs) + 1; + static constexpr auto __size_dynamic = 1 + __next_t::__size_dynamic; + + //-------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __standard_layout_psa() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __standard_layout_psa(__standard_layout_psa const &) noexcept = + default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __standard_layout_psa(__standard_layout_psa &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa & + operator=(__standard_layout_psa const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa & + operator=(__standard_layout_psa &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__standard_layout_psa() noexcept = default; + + //-------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION + constexpr __standard_layout_psa( + __construct_psa_from_all_exts_values_tag_t, _Tp const &__val, + __repeated_with_idxs<_Idxs, _Tp> const &... __vals) noexcept + : __value_pair(__val, + __next_t(__construct_psa_from_all_exts_values_tag, + __vals...)) {} + + template + __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa( + __construct_psa_from_dynamic_exts_values_tag_t, _Tp const &__val, + _Ts const &... __vals) noexcept + : __value_pair(__val, + __next_t(__construct_psa_from_dynamic_exts_values_tag, + __vals...)) {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + array<_Up, _Np> const &__vals) noexcept + : __value_pair(_CUDA_VSTD::get<_Idx>(__vals), __vals) {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_all_exts_array_tag_t __tag, + array<_Up, _NStatic> const &__vals) noexcept + : __value_pair( + _CUDA_VSTD::get<_Idx>(__vals), + __next_t(__tag, + __vals)) {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>, + array<_Up, _NDynamic> const &__vals) noexcept + : __value_pair( + _CUDA_VSTD::get<_IDynamic>(__vals), + __next_t(__construct_psa_from_dynamic_exts_array_tag_t<_IDynamic + 1>{}, + __vals)) {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + _CUDA_VSTD::span<_Up, _Np> const &__vals) noexcept + : __value_pair(__vals[_Idx], __vals) {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_all_exts_array_tag_t __tag, + _CUDA_VSTD::span<_Up, _NStatic> const &__vals) noexcept + : __value_pair( + __vals[_Idx], + __next_t(__tag, + __vals)) {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>, + _CUDA_VSTD::span<_Up, _NDynamic> const &__vals) noexcept + : __value_pair( + __vals[_IDynamic], + __next_t(__construct_psa_from_dynamic_exts_array_tag_t<_IDynamic + 1>{}, + __vals)) {} + + template + __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa( + __standard_layout_psa<_UTag, _Up, _static_U, _UValsSeq, __u_sentinal, _UIdxsSeq> const + &__rhs) noexcept + : __value_pair(__rhs.template __get_n<_Idx>(), __rhs.__next()) {} + + //-------------------------------------------------------------------------- + + // See comment in the previous partial specialization for why this is + // necessary. Or just trust me that it's messy. + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr __standard_layout_psa const &__enable_psa_conversion() const + noexcept { + return *this; + } + + template = 0> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept { + return __next().template __get_n<_Ip>(); + } + template = 1> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept { + return __value_pair.__first(); + } + template = 0> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr void + __set_n(_Tp const &__rhs) noexcept { + __next().__set_value(__rhs); + } + template = 1> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr void + __set_n(_Tp const &__rhs) noexcept { + __value_pair.__first() = __rhs; + } + template __default = __sentinal> + __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept { + return __default; + } + template __default = __sentinal> + __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept { + return __next_t::template __get_static_n<_Ip, __default>(); + } + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get(size_t __n) const noexcept { + return __value_pair.__first() * (_Tp(_Idx == __n)) + __next().__get(__n); + } + + //-------------------------------------------------------------------------- +}; + +// empty/terminal case +template +struct __standard_layout_psa<_Tag, _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t>, __sentinal, + _CUDA_VSTD::integer_sequence> { + //-------------------------------------------------------------------------- + + static constexpr auto __size = 0; + static constexpr auto __size_dynamic = 0; + + //-------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __standard_layout_psa() noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __standard_layout_psa(__standard_layout_psa const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __standard_layout_psa(__standard_layout_psa &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa & + operator=(__standard_layout_psa const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa & + operator=(__standard_layout_psa &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__standard_layout_psa() noexcept = default; + + __MDSPAN_INLINE_FUNCTION + constexpr __standard_layout_psa( + __construct_psa_from_all_exts_values_tag_t) noexcept {} + + template + __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa( + __construct_psa_from_dynamic_exts_values_tag_t) noexcept {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + array<_Up, _Np> const &) noexcept {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_all_exts_array_tag_t, + array<_Up, _NStatic> const &) noexcept {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>, + array<_Up, _NDynamic> const &) noexcept {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + _CUDA_VSTD::span<_Up, _Np> const &) noexcept {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_all_exts_array_tag_t, + _CUDA_VSTD::span<_Up, _NStatic> const &) noexcept {} + + template + __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa( + __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>, + _CUDA_VSTD::span<_Up, _NDynamic> const &) noexcept {} + + template + __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa( + __standard_layout_psa<_UTag, _Up, _static_U, _UValsSeq, __u_sentinal, _UIdxsSeq> const&) noexcept {} + + // See comment in the previous partial specialization for why this is + // necessary. Or just trust me that it's messy. + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr __standard_layout_psa const &__enable_psa_conversion() const + noexcept { + return *this; + } + + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get(size_t /*n*/) const noexcept { + return 0; + } +}; + +// Same thing, but with a disambiguator so that same-base issues doesn't cause +// a loss of standard-layout-ness. +template +struct __partially_static_sizes_tagged + : __standard_layout_psa< + _Tag, T, _static_t, + _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>> { + using __tag_t = _Tag; + using __psa_impl_t = __standard_layout_psa< + _Tag, T, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>>; +#if defined(_LIBCUDACXX_COMPILER_NVRTC) \ + || defined(_LIBCUDACXX_CUDACC_BELOW_11_3) + template = 0> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr + __partially_static_sizes_tagged(_Args&&... __args) noexcept(noexcept(__psa_impl_t(_CUDA_VSTD::declval<_Args>()...))) + : __psa_impl_t(_CUDA_VSTD::forward<_Args>(__args)...) + {} +#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv + using __psa_impl_t::__psa_impl_t; +#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 +#ifdef __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND + __MDSPAN_INLINE_FUNCTION +#endif + constexpr __partially_static_sizes_tagged() noexcept +#ifdef __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND + : __psa_impl_t() { } +#else + = default; +#endif + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __partially_static_sizes_tagged( + __partially_static_sizes_tagged const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __partially_static_sizes_tagged( + __partially_static_sizes_tagged &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_sizes_tagged & + operator=(__partially_static_sizes_tagged const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_sizes_tagged & + operator=(__partially_static_sizes_tagged &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__partially_static_sizes_tagged() noexcept = default; + + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr explicit __partially_static_sizes_tagged( + __partially_static_sizes_tagged<_UTag, T, _static_t, __values_or_sentinals...> const& __vals + ) noexcept : __psa_impl_t(__vals.__enable_psa_conversion()) { } +}; + +struct __no_tag {}; +template +struct __partially_static_sizes + : __partially_static_sizes_tagged<__no_tag, T, _static_t, __values_or_sentinals...> { +private: + using __base_t = + __partially_static_sizes_tagged<__no_tag, T, _static_t, __values_or_sentinals...>; + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr __partially_static_sizes( + __partially_static_sizes_tagged<_UTag, T, _static_t, __values_or_sentinals...>&& __vals + ) noexcept : __base_t(_CUDA_VSTD::move(__vals)) { } +public: +#if defined(_LIBCUDACXX_COMPILER_NVRTC) \ + || defined(_LIBCUDACXX_CUDACC_BELOW_11_3) + template = 0> + __MDSPAN_FORCE_INLINE_FUNCTION constexpr + __partially_static_sizes(_Args&&... __args) noexcept(noexcept(__base_t(_CUDA_VSTD::declval<_Args>()...))) + : __base_t(_CUDA_VSTD::forward<_Args>(__args)...) + {} +#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv + using __base_t::__base_t; +#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 + +#ifdef __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND + __MDSPAN_INLINE_FUNCTION + constexpr __partially_static_sizes() noexcept : __base_t() { } +#endif + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr __partially_static_sizes_tagged< + _UTag, T, _static_t, __values_or_sentinals...> + __with_tag() const noexcept { + return __partially_static_sizes_tagged<_UTag, T, _static_t, __values_or_sentinals...>(*this); + } +}; + +#endif // __MDSPAN_PRESERVE_STATIC_LAYOUT + +} // end namespace __detail + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_STANDARD_LAYOUT_STATIC_ARRAY_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/static_array.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/static_array.h new file mode 100644 index 0000000000000000000000000000000000000000..84df90d64c14b5eb2305c0c90b822ffe92982d22 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/static_array.h @@ -0,0 +1,321 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_STATIC_ARRAY_HPP +#define _LIBCUDACXX___MDSPAN_STATIC_ARRAY_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__fwd/span.h" // dynamic_extent +#include "../__mdspan/dynamic_extent.h" +#include "../__mdspan/macros.h" +#include "../__mdspan/maybe_static_value.h" +#include "../__mdspan/standard_layout_static_array.h" +#include "../__mdspan/type_list.h" +#include "../__utility/integer_sequence.h" +#include "../array" +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#if !__MDSPAN_PRESERVE_STANDARD_LAYOUT + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +namespace __detail { + +//============================================================================== + +template struct __mask_element {}; + +template +struct __mask_sequence_assign_op { + template <_Tp _V> + __mask_sequence_assign_op<_Tp, _Result..., _V> + operator=(__mask_element<_Tp, _V, true>&&); + template <_Tp _V> + __mask_sequence_assign_op<_Tp, _Result...> + operator=(__mask_element<_Tp, _V, false>&&); + using __result = _CUDA_VSTD::integer_sequence<_Tp, _Result...>; +}; + +template +struct __mask_sequence; + +template +struct __mask_sequence<_CUDA_VSTD::integer_sequence<_Tp, _Vals...>, _CUDA_VSTD::integer_sequence> +{ + using type = typename decltype( + __MDSPAN_FOLD_ASSIGN_LEFT( + __mask_sequence_assign_op<_Tp>{}, /* = ... = */ __mask_element<_Tp, _Vals, _Masks>{} + ) + )::__result; +}; + +//============================================================================== + +template +class __partially_static_array_impl; + +template < + class _Tp, class _static_t, + _static_t... __values_or_sentinals, _static_t __sentinal, + size_t... _Idxs, + size_t... _IdxsDynamic, + size_t... _IdxsDynamicIdxs +> +class __partially_static_array_impl< + _Tp, + _static_t, + _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>, + __sentinal, + _CUDA_VSTD::integer_sequence, + _CUDA_VSTD::integer_sequence, + _CUDA_VSTD::integer_sequence +> + : private __maybe_static_value<_Tp, _static_t, __values_or_sentinals, __sentinal, + _Idxs>... { +private: + + template + using __base_n = typename __type_at<_Np, + __type_list<__maybe_static_value<_Tp, _static_t, __values_or_sentinals, __sentinal, _Idxs>...> + >::type; + +public: + + static constexpr auto __size = sizeof...(_Idxs); + static constexpr auto __size_dynamic = + __MDSPAN_FOLD_PLUS_RIGHT(static_cast((__values_or_sentinals == __sentinal)), /* + ... + */ 0); + + //-------------------------------------------------------------------------- + + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __partially_static_array_impl() = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __partially_static_array_impl( + __partially_static_array_impl const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + constexpr __partially_static_array_impl( + __partially_static_array_impl &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_array_impl & + operator=(__partially_static_array_impl const &) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + __MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_array_impl & + operator=(__partially_static_array_impl &&) noexcept = default; + __MDSPAN_INLINE_FUNCTION_DEFAULTED + ~__partially_static_array_impl() noexcept = default; + + __MDSPAN_INLINE_FUNCTION + constexpr __partially_static_array_impl( + __construct_psa_from_all_exts_values_tag_t, + __repeated_with_idxs<_Idxs, _Tp> const &... __vals) noexcept + : __base_n<_Idxs>(__base_n<_Idxs>{{__vals}})... {} + + __MDSPAN_INLINE_FUNCTION + constexpr __partially_static_array_impl( + __construct_psa_from_dynamic_exts_values_tag_t, + __repeated_with_idxs<_IdxsDynamicIdxs, _Tp> const &... __vals) noexcept + : __base_n<_IdxsDynamic>(__base_n<_IdxsDynamic>{{__vals}})... {} + + __MDSPAN_INLINE_FUNCTION constexpr explicit __partially_static_array_impl( + _CUDA_VSTD::array<_Tp, sizeof...(_Idxs)> const& __vals) noexcept + : __partially_static_array_impl( + __construct_psa_from_all_exts_values_tag, + _CUDA_VSTD::get<_Idxs>(__vals)...) {} + + // clang-format off + __MDSPAN_FUNCTION_REQUIRES( + (__MDSPAN_INLINE_FUNCTION constexpr explicit), + __partially_static_array_impl, + (_CUDA_VSTD::array<_Tp, __size_dynamic> const &__vals), noexcept, + /* requires */ + (sizeof...(_Idxs) != __size_dynamic) + ): __partially_static_array_impl( + __construct_psa_from_dynamic_exts_values_tag, + _CUDA_VSTD::get<_IdxsDynamicIdxs>(__vals)...) {} + // clang-format on + + template + __MDSPAN_INLINE_FUNCTION constexpr __partially_static_array_impl( + __partially_static_array_impl< + _Up, _static_u, _UValsSeq, __u_sentinal, _UIdxsSeq, + _UIdxsDynamicSeq, _UIdxsDynamicIdxsSeq> const &__rhs) noexcept + : __partially_static_array_impl( + __construct_psa_from_all_exts_values_tag, + __rhs.template __get_n<_Idxs>()...) {} + + //-------------------------------------------------------------------------- + + // See comment in the previous partial specialization for why this is + // necessary. Or just trust me that it's messy. + __MDSPAN_FORCE_INLINE_FUNCTION + constexpr __partially_static_array_impl const &__enable_psa_conversion() const + noexcept { + return *this; + } + + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept { + return static_cast<__base_n<_Ip> const*>(this)->__value(); + } + + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr void __set_n(_Up&& __rhs) noexcept { + static_cast<__base_n<_Ip>*>(this)->__set_value((_Up&&)__rhs); + } + + template + __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t + __get_static_n() noexcept { + return __base_n<_Ip>::__static_value == __sentinal ? + __default : __base_n<_Ip>::__static_value; + } + + __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp + __get(size_t __n) const noexcept { + return __MDSPAN_FOLD_PLUS_RIGHT( + (_Tp(_Idxs == __n) * __get_n<_Idxs>()), /* + ... + */ _Tp(0) + ); + } + +}; + +//============================================================================== + +template > +struct __partially_static_array_impl_maker; + +template < + class _Tp, class _static_t, _static_t... _Vals, _static_t __sentinal, size_t... _Idxs +> +struct __partially_static_array_impl_maker< + _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t, _Vals...>, __sentinal, _CUDA_VSTD::integer_sequence +> +{ + using __dynamic_idxs = typename __mask_sequence< + _CUDA_VSTD::integer_sequence, + _CUDA_VSTD::integer_sequence + >::type; + using __impl_base = + __partially_static_array_impl<_Tp, _static_t, + _CUDA_VSTD::integer_sequence<_static_t, _Vals...>, + __sentinal, _CUDA_VSTD::integer_sequence, + __dynamic_idxs, + _CUDA_VSTD::make_index_sequence<__dynamic_idxs::size()> + >; +}; + +template +class __partially_static_array_with_sentinal + : public __partially_static_array_impl_maker<_Tp, _static_t, _ValsSeq, __sentinal>::__impl_base +{ +private: + using __base_t = typename __partially_static_array_impl_maker<_Tp, _static_t, _ValsSeq, __sentinal>::__impl_base; +public: +#if defined(_LIBCUDACXX_COMPILER_NVRTC) \ + || defined(_LIBCUDACXX_CUDACC_BELOW_11_3) + constexpr __partially_static_array_with_sentinal() = default; + + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr + __partially_static_array_with_sentinal(_Args&&... __args) noexcept(noexcept(__base_t(_CUDA_VSTD::declval<_Args>()...))) + : __base_t(_CUDA_VSTD::forward<_Args>(__args)...) + {} +#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv + using __base_t::__base_t; +#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 +}; + +//============================================================================== + +template +struct __partially_static_sizes : + __partially_static_array_with_sentinal< + T, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>> +{ +private: + using __base_t = __partially_static_array_with_sentinal< + T, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>>; +public: +#if defined(_LIBCUDACXX_COMPILER_NVRTC) \ + || defined(_LIBCUDACXX_CUDACC_BELOW_11_3) + constexpr __partially_static_sizes() = default; + + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr + __partially_static_sizes(_Args&&... __args) noexcept(noexcept(__base_t(_CUDA_VSTD::declval<_Args>()...))) + : __base_t(_CUDA_VSTD::forward<_Args>(__args)...) + {} +#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv + using __base_t::__base_t; +#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 + template + __MDSPAN_FORCE_INLINE_FUNCTION constexpr __partially_static_sizes + __with_tag() const noexcept { + return *this; + } +}; + +// Tags are needed for the standard layout version, but not here +template +using __partially_static_sizes_tagged = __partially_static_sizes; + +} // end namespace __detail + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // !__MDSPAN_PRESERVE_STANDARD_LAYOUT + +#endif // _LIBCUDACXX___MDSPAN_STATIC_ARRAY_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/submdspan.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/submdspan.h new file mode 100644 index 0000000000000000000000000000000000000000..b551fab61a88b8f8e247d4a424ec0b08b4f271a0 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/submdspan.h @@ -0,0 +1,605 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#ifndef _LIBCUDACXX___MDSPAN_SUBMDSPAN_HPP +#define _LIBCUDACXX___MDSPAN_SUBMDSPAN_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/dynamic_extent.h" +#include "../__mdspan/full_extent_t.h" +#include "../__mdspan/layout_left.h" +#include "../__mdspan/layout_right.h" +#include "../__mdspan/layout_stride.h" +#include "../__mdspan/macros.h" +#include "../__mdspan/mdspan.h" +#include "../__type_traits/conditional.h" +#include "../__type_traits/integral_constant.h" +#include "../__type_traits/is_convertible.h" +#include "../__type_traits/is_same.h" +#include "../__type_traits/is_signed.h" +#include "../__type_traits/remove_const.h" +#include "../__type_traits/remove_reference.h" +#include "../__utility/move.h" +#include "../__utility/pair.h" +#include "../tuple" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +namespace __detail { + +template +struct __slice_wrap { + _Tp slice; + size_t old_extent; + size_t old_stride; +}; + +//-------------------------------------------------------------------------------- + +template +__MDSPAN_INLINE_FUNCTION constexpr +__slice_wrap<_OldExtent, _OldStaticStride, size_t> +__wrap_slice(size_t __val, size_t __ext, size_t __stride) { return { __val, __ext, __stride }; } + +template +__MDSPAN_INLINE_FUNCTION constexpr +__slice_wrap<_OldExtent, _OldStaticStride, integral_constant<_IntegerType, _Value0>> +__wrap_slice(size_t __val, size_t __ext, integral_constant<_IntegerType, _Value0> __stride) +{ +#if __MDSPAN_HAS_CXX_17 + if constexpr (_CUDA_VSTD::is_signed_v<_IntegerType>) { + static_assert(_Value0 >= _IntegerType(0), "Invalid slice specifier"); + } +#endif // __MDSPAN_HAS_CXX_17 + + return { __val, __ext, __stride }; +} + +template +__MDSPAN_INLINE_FUNCTION constexpr +__slice_wrap<_OldExtent, _OldStaticStride, full_extent_t> +__wrap_slice(full_extent_t __val, size_t __ext, size_t __stride) { return { __val, __ext, __stride }; } + +// TODO generalize this to anything that works with get<0> and get<1> +template +__MDSPAN_INLINE_FUNCTION constexpr +__slice_wrap<_OldExtent, _OldStaticStride, _CUDA_VSTD::tuple> +__wrap_slice(_CUDA_VSTD::tuple const& __val, size_t __ext, size_t __stride) +{ + return { __val, __ext, __stride }; +} + +template +__MDSPAN_INLINE_FUNCTION constexpr + __slice_wrap<_OldExtent, _OldStaticStride, + _CUDA_VSTD::tuple, + integral_constant<_IntegerType1, _Value1>>> +__wrap_slice(_CUDA_VSTD::tuple, integral_constant<_IntegerType1, _Value1>> const& __val, size_t __ext, size_t __stride) +{ + static_assert(_Value1 >= _Value0, "Invalid slice tuple"); + return { __val, __ext, __stride }; +} + +//-------------------------------------------------------------------------------- + + +// a layout right remains a layout right if it is indexed by 0 or more scalars, +// then optionally a pair and finally 0 or more all +template < + // what we encountered until now preserves the layout right + bool _Result=true, + // we only encountered 0 or more scalars, no pair or all + bool _EncounteredOnlyScalar=true +> +struct preserve_layout_right_analysis : integral_constant { + using layout_type_if_preserved = layout_right; + using encounter_pair = preserve_layout_right_analysis< + // if we encounter a pair, the layout remains a layout right only if it was one before + // and that only scalars were encountered until now + _Result && _EncounteredOnlyScalar, + // if we encounter a pair, we didn't encounter scalars only + false + >; + using encounter_all = preserve_layout_right_analysis< + // if we encounter a all, the layout remains a layout right if it was one before + _Result, + // if we encounter a all, we didn't encounter scalars only + false + >; + using encounter_scalar = preserve_layout_right_analysis< + // if we encounter a scalar, the layout remains a layout right only if it was one before + // and that only scalars were encountered until now + _Result && _EncounteredOnlyScalar, + // if we encounter a scalar, the fact that we encountered scalars only doesn't change + _EncounteredOnlyScalar + >; +}; + +// a layout left remains a layout left if it is indexed by 0 or more all, +// then optionally a pair and finally 0 or more scalars +template < + bool _Result=true, + bool _EncounteredOnlyAll=true +> +struct preserve_layout_left_analysis : integral_constant { + using layout_type_if_preserved = layout_left; + using encounter_pair = preserve_layout_left_analysis< + // if we encounter a pair, the layout remains a layout left only if it was one before + // and that only all were encountered until now + _Result && _EncounteredOnlyAll, + // if we encounter a pair, we didn't encounter all only + false + >; + using encounter_all = preserve_layout_left_analysis< + // if we encounter a all, the layout remains a layout left only if it was one before + // and that only all were encountered until now + _Result && _EncounteredOnlyAll, + // if we encounter a all, the fact that we encountered scalars all doesn't change + _EncounteredOnlyAll + >; + using encounter_scalar = preserve_layout_left_analysis< + // if we encounter a scalar, the layout remains a layout left if it was one before + _Result, + // if we encounter a scalar, we didn't encounter scalars only + false + >; +}; + +struct ignore_layout_preservation : integral_constant { + using layout_type_if_preserved = void; + using encounter_pair = ignore_layout_preservation; + using encounter_all = ignore_layout_preservation; + using encounter_scalar = ignore_layout_preservation; +}; + +template +struct preserve_layout_analysis + : ignore_layout_preservation { }; +template <> +struct preserve_layout_analysis + : preserve_layout_right_analysis<> { }; +template <> +struct preserve_layout_analysis + : preserve_layout_left_analysis<> { }; + +//-------------------------------------------------------------------------------- + +template < + class _IndexT, + class _PreserveLayoutAnalysis, + class _OffsetsArray=__partially_static_sizes<_IndexT, size_t>, + class _ExtsArray=__partially_static_sizes<_IndexT, size_t>, + class _StridesArray=__partially_static_sizes<_IndexT, size_t>, + class = _CUDA_VSTD::make_index_sequence<_OffsetsArray::__size>, + class = _CUDA_VSTD::make_index_sequence<_ExtsArray::__size>, + class = _CUDA_VSTD::make_index_sequence<_StridesArray::__size> +> +struct __assign_op_slice_handler; + +/* clang-format: off */ +template < + class _IndexT, + class _PreserveLayoutAnalysis, + size_t... _Offsets, + size_t... _Exts, + size_t... _Strides, + size_t... _OffsetIdxs, + size_t... _ExtIdxs, + size_t... _StrideIdxs> +struct __assign_op_slice_handler< + _IndexT, + _PreserveLayoutAnalysis, + __partially_static_sizes<_IndexT, size_t, _Offsets...>, + __partially_static_sizes<_IndexT, size_t, _Exts...>, + __partially_static_sizes<_IndexT, size_t, _Strides...>, + _CUDA_VSTD::integer_sequence, + _CUDA_VSTD::integer_sequence, + _CUDA_VSTD::integer_sequence> +{ + // TODO remove this for better compiler performance + static_assert( + __MDSPAN_FOLD_AND((_Strides == dynamic_extent || _Strides > 0) /* && ... */), + " " + ); + static_assert( + __MDSPAN_FOLD_AND((_Offsets == dynamic_extent || _Offsets >= 0) /* && ... */), + " " + ); + + using __offsets_storage_t = __partially_static_sizes<_IndexT, size_t, _Offsets...>; + using __extents_storage_t = __partially_static_sizes<_IndexT, size_t, _Exts...>; + using __strides_storage_t = __partially_static_sizes<_IndexT, size_t, _Strides...>; + __offsets_storage_t __offsets; + __extents_storage_t __exts; + __strides_storage_t __strides; + +#ifdef __INTEL_COMPILER +#if __INTEL_COMPILER <= 1800 + __MDSPAN_INLINE_FUNCTION constexpr __assign_op_slice_handler(__assign_op_slice_handler&& __other) noexcept + : __offsets(_CUDA_VSTD::move(__other.__offsets)), __exts(_CUDA_VSTD::move(__other.__exts)), __strides(_CUDA_VSTD::move(__other.__strides)) + { } + __MDSPAN_INLINE_FUNCTION constexpr __assign_op_slice_handler( + __offsets_storage_t&& __o, + __extents_storage_t&& __e, + __strides_storage_t&& __s + ) noexcept + : __offsets(_CUDA_VSTD::move(__o)), __exts(_CUDA_VSTD::move(__e)), __strides(_CUDA_VSTD::move(__s)) + { } +#endif +#endif + +// Don't define this unless we need it; they have a cost to compile +#ifndef __MDSPAN_USE_RETURN_TYPE_DEDUCTION + using __extents_type = _CUDA_VSTD::extents<_IndexT, _Exts...>; +#endif + + // For size_t slice, skip the extent and stride, but add an offset corresponding to the value + template + __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator) + constexpr auto + operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, size_t>&& __slice) noexcept + -> __assign_op_slice_handler< + _IndexT, + typename _PreserveLayoutAnalysis::encounter_scalar, + __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>, + __partially_static_sizes<_IndexT, size_t, _Exts...>, + __partially_static_sizes<_IndexT, size_t, _Strides...>/* intentional space here to work around ICC bug*/> { + return { + __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>( + __construct_psa_from_all_exts_values_tag, + __offsets.template __get_n<_OffsetIdxs>()..., __slice.slice), + _CUDA_VSTD::move(__exts), + _CUDA_VSTD::move(__strides) + }; + } + + // Treat integral_constant slice like size_t slice, but with a compile-time offset. + // The result's extents_type can't take advantage of that, + // but it might help for specialized layouts. + template + __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator) + constexpr auto + operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, integral_constant<_IntegerType, _Value0>>&&) noexcept + -> __assign_op_slice_handler< + _IndexT, + typename _PreserveLayoutAnalysis::encounter_scalar, + __partially_static_sizes<_IndexT, size_t, _Offsets..., _Value0>, + __partially_static_sizes<_IndexT, size_t, _Exts...>, + __partially_static_sizes<_IndexT, size_t, _Strides...>/* intentional space here to work around ICC bug*/> { +#if __MDSPAN_HAS_CXX_17 + if constexpr (_CUDA_VSTD::is_signed_v<_IntegerType>) { + static_assert(_Value0 >= _IntegerType(0), "Invalid slice specifier"); + } +#endif // __MDSPAN_HAS_CXX_17 + return { + __partially_static_sizes<_IndexT, size_t, _Offsets..., _Value0>( + __construct_psa_from_all_exts_values_tag, + __offsets.template __get_n<_OffsetIdxs>()..., size_t(_Value0)), + _CUDA_VSTD::move(__exts), + _CUDA_VSTD::move(__strides) + }; + } + + // For a _CUDA_VSTD::full_extent, offset 0 and old extent + template + __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator) + constexpr auto + operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, full_extent_t>&& __slice) noexcept + -> __assign_op_slice_handler< + _IndexT, + typename _PreserveLayoutAnalysis::encounter_all, + __partially_static_sizes<_IndexT, size_t, _Offsets..., 0>, + __partially_static_sizes<_IndexT, size_t, _Exts..., _OldStaticExtent>, + __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>/* intentional space here to work around ICC bug*/> { + return { + __partially_static_sizes<_IndexT, size_t, _Offsets..., 0>( + __construct_psa_from_all_exts_values_tag, + __offsets.template __get_n<_OffsetIdxs>()..., size_t(0)), + __partially_static_sizes<_IndexT, size_t, _Exts..., _OldStaticExtent>( + __construct_psa_from_all_exts_values_tag, + __exts.template __get_n<_ExtIdxs>()..., __slice.old_extent), + __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>( + __construct_psa_from_all_exts_values_tag, + __strides.template __get_n<_StrideIdxs>()..., __slice.old_stride) + }; + } + + // For a _CUDA_VSTD::tuple, add an offset and add a new dynamic extent (strides still preserved) + template + __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator) + constexpr auto + operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, tuple>&& __slice) noexcept + -> __assign_op_slice_handler< + _IndexT, + typename _PreserveLayoutAnalysis::encounter_pair, + __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>, + __partially_static_sizes<_IndexT, size_t, _Exts..., dynamic_extent>, + __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>/* intentional space here to work around ICC bug*/> { + return { + __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>( + __construct_psa_from_all_exts_values_tag, + __offsets.template __get_n<_OffsetIdxs>()..., _CUDA_VSTD::get<0>(__slice.slice)), + __partially_static_sizes<_IndexT, size_t, _Exts..., dynamic_extent>( + __construct_psa_from_all_exts_values_tag, + __exts.template __get_n<_ExtIdxs>()..., _CUDA_VSTD::get<1>(__slice.slice) - _CUDA_VSTD::get<0>(__slice.slice)), + __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>( + __construct_psa_from_all_exts_values_tag, + __strides.template __get_n<_StrideIdxs>()..., __slice.old_stride) + }; + } + + // For a _CUDA_VSTD::tuple of two integral_constant, do something like + // we did above for a tuple of two size_t, but make sure the + // result's extents type make the values compile-time constants. + template + __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator) + constexpr auto + operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, tuple, integral_constant<_IntegerType1, _Value1>>>&& __slice) noexcept + -> __assign_op_slice_handler< + _IndexT, + typename _PreserveLayoutAnalysis::encounter_pair, + __partially_static_sizes<_IndexT, size_t, _Offsets..., size_t(_Value0)>, + __partially_static_sizes<_IndexT, size_t, _Exts..., size_t(_Value1 - _Value0)>, + __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>/* intentional space here to work around ICC bug*/> { + static_assert(_Value1 >= _Value0, "Invalid slice specifier"); + return { + // We're still turning the template parameters _Value0 and _Value1 + // into (constexpr) run-time values here. + __partially_static_sizes<_IndexT, size_t, _Offsets..., size_t(_Value0) > ( + __construct_psa_from_all_exts_values_tag, + __offsets.template __get_n<_OffsetIdxs>()..., _Value0), + __partially_static_sizes<_IndexT, size_t, _Exts..., size_t(_Value1 - _Value0) > ( + __construct_psa_from_all_exts_values_tag, + __exts.template __get_n<_ExtIdxs>()..., _Value1 - _Value0), + __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>( + __construct_psa_from_all_exts_values_tag, + __strides.template __get_n<_StrideIdxs>()..., __slice.old_stride) + }; + } + + // TODO defer instantiation of this? + using layout_type = conditional_t< + _PreserveLayoutAnalysis::value, + typename _PreserveLayoutAnalysis::layout_type_if_preserved, + layout_stride + >; + + // TODO noexcept specification + template + __MDSPAN_INLINE_FUNCTION + __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE( + ( + constexpr /* auto */ + _make_layout_mapping_impl(NewLayout) noexcept + ), + ( + /* not layout stride, so don't pass dynamic_strides */ + /* return */ typename NewLayout::template mapping<_CUDA_VSTD::extents<_IndexT, _Exts...>>( + extents<_IndexT, _Exts...>::__make_extents_impl(_CUDA_VSTD::move(__exts)) + ) /* ; */ + ) + ) + + __MDSPAN_INLINE_FUNCTION + __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE( + ( + constexpr /* auto */ + _make_layout_mapping_impl(layout_stride) noexcept + ), + ( + /* return */ layout_stride::template mapping<_CUDA_VSTD::extents<_IndexT, _Exts...>> + ::__make_mapping(_CUDA_VSTD::move(__exts), _CUDA_VSTD::move(__strides)) /* ; */ + ) + ) + + template // mostly for deferred instantiation, but maybe we'll use this in the future + __MDSPAN_INLINE_FUNCTION + __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE( + ( + constexpr /* auto */ + make_layout_mapping(_OldLayoutMapping const&) noexcept + ), + ( + /* return */ this->_make_layout_mapping_impl(layout_type{}) /* ; */ + ) + ) +}; + +//============================================================================== + +#if __MDSPAN_USE_RETURN_TYPE_DEDUCTION +// Forking this because the C++11 version will be *completely* unreadable +template +__MDSPAN_INLINE_FUNCTION +constexpr auto _submdspan_impl( + _CUDA_VSTD::integer_sequence, + mdspan<_ET, _CUDA_VSTD::extents<_ST, _Exts...>, _LP, _AP> const& __src, + _SliceSpecs&&... __slices +) noexcept +{ + using __index_t = _ST; + auto __handled = + __MDSPAN_FOLD_ASSIGN_LEFT( + ( + __detail::__assign_op_slice_handler< + __index_t, + __detail::preserve_layout_analysis<_LP> + >{ + __partially_static_sizes<__index_t, size_t>{}, + __partially_static_sizes<__index_t, size_t>{}, + __partially_static_sizes<__index_t, size_t>{} + } + ), + /* = ... = */ + __detail::__wrap_slice< + _Exts, dynamic_extent + >( + __slices, __src.extents().template __extent<_Idxs>(), + __src.mapping().stride(_Idxs) + ) + ); + + size_t __offset_size = __src.mapping()(__handled.__offsets.template __get_n<_Idxs>()...); + auto __offset_ptr = __src.accessor().offset(__src.data_handle(), __offset_size); + auto __map = __handled.make_layout_mapping(__src.mapping()); + auto __acc_pol = typename _AP::offset_policy(__src.accessor()); + return mdspan< + _ET, remove_const_t<_CUDA_VSTD::remove_reference_t>, + typename decltype(__handled)::layout_type, remove_const_t<_CUDA_VSTD::remove_reference_t> + >( + _CUDA_VSTD::move(__offset_ptr), _CUDA_VSTD::move(__map), _CUDA_VSTD::move(__acc_pol) + ); +} +#else + +template +auto _submdspan_impl_helper(_Src&& __src, _Handled&& __h, _CUDA_VSTD::integer_sequence) + -> mdspan< + _ET, typename _Handled::__extents_type, typename _Handled::layout_type, typename _AP::offset_policy + > +{ + return { + __src.accessor().offset(__src.data_handle(), __src.mapping()(__h.__offsets.template __get_n<_Idxs>()...)), + __h.make_layout_mapping(__src.mapping()), + typename _AP::offset_policy(__src.accessor()) + }; +} + +template +__MDSPAN_INLINE_FUNCTION +__MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE( + ( + constexpr /* auto */ _submdspan_impl( + _CUDA_VSTD::integer_sequence __seq, + mdspan<_ET, _CUDA_VSTD::extents<_ST, _Exts...>, _LP, _AP> const& __src, + _SliceSpecs&&... __slices + ) noexcept + ), + ( + /* return */ _submdspan_impl_helper<_ET, _AP>( + __src, + __MDSPAN_FOLD_ASSIGN_LEFT( + ( + __detail::__assign_op_slice_handler< + size_t, + __detail::preserve_layout_analysis<_LP> + >{ + __partially_static_sizes<_ST, size_t>{}, + __partially_static_sizes<_ST, size_t>{}, + __partially_static_sizes<_ST, size_t>{} + } + ), + /* = ... = */ + __detail::__wrap_slice< + _Exts, dynamic_extent + >( + __slices, __src.extents().template __extent<_Idxs>(), __src.mapping().stride(_Idxs) + ) + ), + __seq + ) /* ; */ + ) +) + +#endif + +template struct _is_layout_stride : false_type { }; +template<> +struct _is_layout_stride< + layout_stride +> : true_type +{ }; + +} // namespace __detail + +//============================================================================== + +__MDSPAN_TEMPLATE_REQUIRES( + class _ET, class _EXT, class _LP, class _AP, class... _SliceSpecs, + /* requires */ ( + ( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_same, _LP, layout_left) + || _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_same, _LP, layout_right) + || __detail::_is_layout_stride<_LP>::value + ) && + __MDSPAN_FOLD_AND(( + _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SliceSpecs, size_t) + || _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SliceSpecs, tuple) + || _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SliceSpecs, full_extent_t) + ) /* && ... */) && + sizeof...(_SliceSpecs) == _EXT::rank() + ) +) +__MDSPAN_INLINE_FUNCTION +__MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE( + ( + constexpr submdspan( + mdspan<_ET, _EXT, _LP, _AP> const& __src, _SliceSpecs... __slices + ) noexcept + ), + ( + /* return */ + __detail::_submdspan_impl(_CUDA_VSTD::make_index_sequence{}, __src, __slices...) /*;*/ + ) +) +/* clang-format: on */ + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_SUBMDSPAN_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/type_list.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/type_list.h new file mode 100644 index 0000000000000000000000000000000000000000..bd9389d05cc9b44e6ee7c2af49a288a959acfbfd --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/type_list.h @@ -0,0 +1,132 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2019) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Christian R. Trott (crtrott@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef _LIBCUDACXX___MDSPAN_TYPE_LIST_HPP +#define _LIBCUDACXX___MDSPAN_TYPE_LIST_HPP + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__mdspan/macros.h" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +#if _LIBCUDACXX_STD_VER > 11 + +//============================================================================== + +namespace __detail { + +template struct __type_list { static constexpr auto __size = sizeof...(_Ts); }; + +// Implementation of type_list at() that's heavily optimized for small typelists +template struct __type_at; +template > struct __type_at_large_impl; + +template +struct __type_at_entry { }; + +template +struct __type_at_assign_op_ignore_rest { + template + _LIBCUDACXX_HOST_DEVICE + __type_at_assign_op_ignore_rest<_Result> operator=(_Tp&&); + using type = _Result; +}; + +struct __type_at_assign_op_impl { + template + _LIBCUDACXX_HOST_DEVICE + __type_at_assign_op_impl operator=(__type_at_entry<_Ip, _Idx, _Tp>&&); + template + _LIBCUDACXX_HOST_DEVICE + __type_at_assign_op_ignore_rest<_Tp> operator=(__type_at_entry<_Ip, _Ip, _Tp>&&); +}; + +template +struct __type_at_large_impl<_Ip, __type_list<_Ts...>, _CUDA_VSTD::integer_sequence> + : decltype( + __MDSPAN_FOLD_ASSIGN_LEFT(__type_at_assign_op_impl{}, /* = ... = */ __type_at_entry<_Ip, _Idxs, _Ts>{}) + ) +{ }; + +template +struct __type_at<_Ip, __type_list<_Ts...>> + : __type_at_large_impl<_Ip, __type_list<_Ts...>> +{ }; + +template +struct __type_at<0, __type_list<_T0, _Ts...>> { + using type = _T0; +}; + +template +struct __type_at<1, __type_list<_T0, _T1, _Ts...>> { + using type = _T1; +}; + +template +struct __type_at<2, __type_list<_T0, _T1, _T2, _Ts...>> { + using type = _T2; +}; + +template +struct __type_at<3, __type_list<_T0, _T1, _T2, _T3, _Ts...>> { + using type = _T3; +}; + + +} // namespace __detail + +//============================================================================== + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___MDSPAN_TYPE_LIST_HPP diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__tuple_dir/tuple_element.h b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__tuple_dir/tuple_element.h new file mode 100644 index 0000000000000000000000000000000000000000..fefc8cbb5d648c544c950061a490ea7cfaa8eb2c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__tuple_dir/tuple_element.h @@ -0,0 +1,127 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX___TUPLE_TUPLE_ELEMENT_H +#define _LIBCUDACXX___TUPLE_TUPLE_ELEMENT_H + +#ifndef __cuda_std__ +#include <__config> +#endif // __cuda_std__ + +#include "../__tuple_dir/tuple_indices.h" +#include "../__tuple_dir/tuple_types.h" +#include "../__type_traits/add_const.h" +#include "../__type_traits/add_cv.h" +#include "../__type_traits/add_volatile.h" +#include "../cstddef" + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template struct _LIBCUDACXX_TEMPLATE_VIS tuple_element; + +template +struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, const _Tp> +{ + typedef _LIBCUDACXX_NODEBUG_TYPE typename add_const::type>::type type; +}; + +template +struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp> +{ + typedef _LIBCUDACXX_NODEBUG_TYPE typename add_volatile::type>::type type; +}; + +template +struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp> +{ + typedef _LIBCUDACXX_NODEBUG_TYPE typename add_cv::type>::type type; +}; + +#ifndef _LIBCUDACXX_CXX03_LANG + +#ifdef _LIBCUDACXX_COMPILER_MSVC + +namespace __indexer_detail { + +template +struct _nth_of; + +template +struct _nth_of<0, _Head, _Tail...> { + using type = _Head; +}; + +template +struct _nth_of<_Idx, _Head, _Tail...> { + using type = typename _nth_of<_Idx-1, _Tail...>::type; +}; + +template +struct nth_of { + static_assert(_Idx < sizeof...(_Types), ""); + using _impl = _nth_of<_Idx, _Types...>; + using type = typename _impl::type; +}; + +} // namespace __indexer_detail + +template +using __type_pack_element _LIBCUDACXX_NODEBUG_TYPE = typename __indexer_detail::nth_of<_Idx, _Types...>::type; + +#elif !__has_builtin(__type_pack_element) + +namespace __indexer_detail { + +template +struct __indexed { using type _LIBCUDACXX_NODEBUG_TYPE = _Tp; }; + +template struct __indexer; + +template +struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>> + : __indexed<_Idx, _Types>... +{}; + +template +_LIBCUDACXX_INLINE_VISIBILITY +__indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&); + +} // namespace __indexer_detail + +template +using __type_pack_element _LIBCUDACXX_NODEBUG_TYPE = typename decltype( + __indexer_detail::__at_index<_Idx>( + __indexer_detail::__indexer< + __tuple_types<_Types...>, + typename __make_tuple_indices::type + >{}) + )::type; +#endif + +template +struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> > +{ + static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range"); + typedef _LIBCUDACXX_NODEBUG_TYPE __type_pack_element<_Ip, _Types...> type; +}; + +#if _LIBCUDACXX_STD_VER > 11 +template +using tuple_element_t _LIBCUDACXX_NODEBUG_TYPE = typename tuple_element <_Ip, _Tp...>::type; +#endif + +#endif // _LIBCUDACXX_CXX03_LANG + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // _LIBCUDACXX___TUPLE_TUPLE_ELEMENT_H diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/__config b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/__config new file mode 100644 index 0000000000000000000000000000000000000000..4571a089240044592066777222f6cd9cdc767824 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/__config @@ -0,0 +1,79 @@ +// -*- C++ -*- +//===--------------------------- __config ---------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_CONFIG +#define _LIBCUDACXX_EXPERIMENTAL_CONFIG + +#include <__config> + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental { +#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL } } +#define _CUDA_VSTD_EXPERIMENTAL std::experimental + +#define _LIBCUDACXX_BEGIN_NAMESPACE_LFTS _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v1 { +#define _LIBCUDACXX_END_NAMESPACE_LFTS } } } +#define _CUDA_VSTD_LFTS _CUDA_VSTD_EXPERIMENTAL::fundamentals_v1 + +#define _LIBCUDACXX_BEGIN_NAMESPACE_LFTS_V2 _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 { +#define _LIBCUDACXX_END_NAMESPACE_LFTS_V2 } } } +#define _CUDA_VSTD_LFTS_V2 _CUDA_VSTD_EXPERIMENTAL::fundamentals_v2 + +#define _LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR _LIBCUDACXX_BEGIN_NAMESPACE_LFTS namespace pmr { +#define _LIBCUDACXX_END_NAMESPACE_LFTS_PMR _LIBCUDACXX_END_NAMESPACE_LFTS } +#define _CUDA_VSTD_LFTS_PMR _CUDA_VSTD_LFTS::pmr + +#define _LIBCUDACXX_BEGIN_NAMESPACE_CHRONO_LFTS _LIBCUDACXX_BEGIN_NAMESPACE_STD \ + namespace chrono { namespace experimental { inline namespace fundamentals_v1 { +#define _LIBCUDACXX_END_NAMESPACE_CHRONO_LFTS _LIBCUDACXX_END_NAMESPACE_STD } } } + +#if defined(_LIBCUDACXX_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM) +# define _LIBCUDACXX_DEPRECATED_EXPERIMENTAL_FILESYSTEM /* nothing */ +#else +# define _LIBCUDACXX_DEPRECATED_EXPERIMENTAL_FILESYSTEM __attribute__((deprecated("std::experimental::filesystem has now been deprecated in favor of C++17's std::filesystem. Please stop using it and start using std::filesystem. This experimental version will be removed in LLVM 11. You can remove this warning by defining the _LIBCUDACXX_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM macro."))) +#endif + +#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM \ + _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL namespace filesystem _LIBCUDACXX_DEPRECATED_EXPERIMENTAL_FILESYSTEM { \ + inline namespace v1 { + +#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM \ + } } _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL + +#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES \ + _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace coroutines_v1 { + +#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_COROUTINES \ + } _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL + +#define _CUDA_VSTD_CORO _CUDA_VSTD_EXPERIMENTAL::coroutines_v1 + +#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \ + _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 { + +#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD \ + } _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL + +#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \ + _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD namespace simd_abi { + +#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI \ + } _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD + +// TODO: support more targets +#if defined(__AVX__) +#define _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES 32 +#else +#define _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES 16 +#endif + +#endif diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/algorithm b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/algorithm new file mode 100644 index 0000000000000000000000000000000000000000..7fe305cf0b47ec196cb33d4a82ab46c61dedde7f --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/algorithm @@ -0,0 +1,59 @@ +// -*- C++ -*- +//===-------------------------- algorithm ---------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_ALGORITHM +#define _LIBCUDACXX_EXPERIMENTAL_ALGORITHM + +/* + experimental/algorithm synopsis + +#include + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + +template +ForwardIterator search(ForwardIterator first, ForwardIterator last, + const Searcher &searcher); + +// sample removed because it's now part of C++17 + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + +*/ + +#include +#include +#include + +#include <__debug> + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_PUSH_MACROS +#include <__undef_macros> + + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS + +template +_LIBCUDACXX_INLINE_VISIBILITY +_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s) +{ return __s(__f, __l).first; } + +_LIBCUDACXX_END_NAMESPACE_LFTS + +_LIBCUDACXX_POP_MACROS + +#endif /* _LIBCUDACXX_EXPERIMENTAL_ALGORITHM */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/coroutine b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/coroutine new file mode 100644 index 0000000000000000000000000000000000000000..a6b5c5838fd008d8217ba907646a1be951cd56ca --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/coroutine @@ -0,0 +1,334 @@ +// -*- C++ -*- +//===----------------------------- coroutine -----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_COROUTINE +#define _LIBCUDACXX_EXPERIMENTAL_COROUTINE + +/** + experimental/coroutine synopsis + +// C++next + +namespace std { +namespace experimental { +inline namespace coroutines_v1 { + + // 18.11.1 coroutine traits +template +class coroutine_traits; +// 18.11.2 coroutine handle +template +class coroutine_handle; +// 18.11.2.7 comparison operators: +bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +// 18.11.3 trivial awaitables +struct suspend_never; +struct suspend_always; +// 18.11.2.8 hash support: +template struct hash; +template struct hash>; + +} // namespace coroutines_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include +#include +#include // for hash +#include +#include <__debug> + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#ifdef _LIBCUDACXX_HAS_NO_COROUTINES +# if defined(_LIBCUDACXX_WARNING) + _LIBCUDACXX_WARNING(" cannot be used with this compiler") +# else +# warning cannot be used with this compiler +# endif +#endif + +#ifndef _LIBCUDACXX_HAS_NO_COROUTINES + +_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES + +template +struct __coroutine_traits_sfinae {}; + +template +struct __coroutine_traits_sfinae< + _Tp, __void_t> +{ + using promise_type = typename _Tp::promise_type; +}; + +template +struct coroutine_traits + : public __coroutine_traits_sfinae<_Ret> +{ +}; + +template +class _LIBCUDACXX_TEMPLATE_VIS coroutine_handle; + +template <> +class _LIBCUDACXX_TEMPLATE_VIS coroutine_handle { +public: + _LIBCUDACXX_INLINE_VISIBILITY + _LIBCUDACXX_CONSTEXPR coroutine_handle() _NOEXCEPT : __handle_(nullptr) {} + + _LIBCUDACXX_INLINE_VISIBILITY + _LIBCUDACXX_CONSTEXPR coroutine_handle(nullptr_t) _NOEXCEPT : __handle_(nullptr) {} + + _LIBCUDACXX_INLINE_VISIBILITY + coroutine_handle& operator=(nullptr_t) _NOEXCEPT { + __handle_ = nullptr; + return *this; + } + + _LIBCUDACXX_INLINE_VISIBILITY + _LIBCUDACXX_CONSTEXPR void* address() const _NOEXCEPT { return __handle_; } + + _LIBCUDACXX_INLINE_VISIBILITY + _LIBCUDACXX_CONSTEXPR explicit operator bool() const _NOEXCEPT { return __handle_; } + + _LIBCUDACXX_INLINE_VISIBILITY + void operator()() { resume(); } + + _LIBCUDACXX_INLINE_VISIBILITY + void resume() { + _LIBCUDACXX_ASSERT(__is_suspended(), + "resume() can only be called on suspended coroutines"); + _LIBCUDACXX_ASSERT(!done(), + "resume() has undefined behavior when the coroutine is done"); + __builtin_coro_resume(__handle_); + } + + _LIBCUDACXX_INLINE_VISIBILITY + void destroy() { + _LIBCUDACXX_ASSERT(__is_suspended(), + "destroy() can only be called on suspended coroutines"); + __builtin_coro_destroy(__handle_); + } + + _LIBCUDACXX_INLINE_VISIBILITY + bool done() const { + _LIBCUDACXX_ASSERT(__is_suspended(), + "done() can only be called on suspended coroutines"); + return __builtin_coro_done(__handle_); + } + +public: + _LIBCUDACXX_INLINE_VISIBILITY + static coroutine_handle from_address(void* __addr) _NOEXCEPT { + coroutine_handle __tmp; + __tmp.__handle_ = __addr; + return __tmp; + } + + // FIXME: Should from_address(nullptr) be allowed? + _LIBCUDACXX_INLINE_VISIBILITY + static coroutine_handle from_address(nullptr_t) _NOEXCEPT { + return coroutine_handle(nullptr); + } + + template + static coroutine_handle from_address(_Tp*) { + static_assert(_CallIsValid, + "coroutine_handle::from_address cannot be called with " + "non-void pointers"); + } + +private: + bool __is_suspended() const _NOEXCEPT { + // FIXME actually implement a check for if the coro is suspended. + return __handle_; + } + + template friend class coroutine_handle; + void* __handle_; +}; + +// 18.11.2.7 comparison operators: +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return __x.address() == __y.address(); +} +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator!=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return !(__x == __y); +} +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator<(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return less()(__x.address(), __y.address()); +} +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator>(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return __y < __x; +} +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator<=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return !(__x > __y); +} +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator>=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return !(__x < __y); +} + +template +class _LIBCUDACXX_TEMPLATE_VIS coroutine_handle : public coroutine_handle<> { + using _Base = coroutine_handle<>; +public: +#ifndef _LIBCUDACXX_CXX03_LANG + // 18.11.2.1 construct/reset + using coroutine_handle<>::coroutine_handle; +#else + _LIBCUDACXX_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT : _Base() {} + _LIBCUDACXX_INLINE_VISIBILITY coroutine_handle(nullptr_t) _NOEXCEPT : _Base(nullptr) {} +#endif + _LIBCUDACXX_INLINE_VISIBILITY + coroutine_handle& operator=(nullptr_t) _NOEXCEPT { + _Base::operator=(nullptr); + return *this; + } + + _LIBCUDACXX_INLINE_VISIBILITY + _Promise& promise() const { + return *static_cast<_Promise*>( + __builtin_coro_promise(this->__handle_, _LIBCUDACXX_ALIGNOF(_Promise), false)); + } + +public: + _LIBCUDACXX_INLINE_VISIBILITY + static coroutine_handle from_address(void* __addr) _NOEXCEPT { + coroutine_handle __tmp; + __tmp.__handle_ = __addr; + return __tmp; + } + + // NOTE: this overload isn't required by the standard but is needed so + // the deleted _Promise* overload doesn't make from_address(nullptr) + // ambiguous. + // FIXME: should from_address work with nullptr? + _LIBCUDACXX_INLINE_VISIBILITY + static coroutine_handle from_address(nullptr_t) _NOEXCEPT { + return coroutine_handle(nullptr); + } + + template + static coroutine_handle from_address(_Tp*) { + static_assert(_CallIsValid, + "coroutine_handle::from_address cannot be called with " + "non-void pointers"); + } + + template + static coroutine_handle from_address(_Promise*) { + static_assert(_CallIsValid, + "coroutine_handle::from_address cannot be used with " + "pointers to the coroutine's promise type; use 'from_promise' instead"); + } + + _LIBCUDACXX_INLINE_VISIBILITY + static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT { + typedef __remove_cv_t<_Promise> _RawPromise; + coroutine_handle __tmp; + __tmp.__handle_ = __builtin_coro_promise( + _CUDA_VSTD::addressof(const_cast<_RawPromise&>(__promise)), + _LIBCUDACXX_ALIGNOF(_Promise), true); + return __tmp; + } +}; + +#if __has_builtin(__builtin_coro_noop) +struct noop_coroutine_promise {}; + +template <> +class _LIBCUDACXX_TEMPLATE_VIS coroutine_handle + : public coroutine_handle<> { + using _Base = coroutine_handle<>; + using _Promise = noop_coroutine_promise; +public: + + _LIBCUDACXX_INLINE_VISIBILITY + _Promise& promise() const { + return *static_cast<_Promise*>( + __builtin_coro_promise(this->__handle_, _LIBCUDACXX_ALIGNOF(_Promise), false)); + } + + _LIBCUDACXX_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; } + _LIBCUDACXX_CONSTEXPR bool done() const _NOEXCEPT { return false; } + + _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {} + _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {} + _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {} + +private: + _LIBCUDACXX_INLINE_VISIBILITY + friend coroutine_handle noop_coroutine() _NOEXCEPT; + + _LIBCUDACXX_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT { + this->__handle_ = __builtin_coro_noop(); + } +}; + +using noop_coroutine_handle = coroutine_handle; + +inline _LIBCUDACXX_INLINE_VISIBILITY +noop_coroutine_handle noop_coroutine() _NOEXCEPT { + return noop_coroutine_handle(); +} +#endif // __has_builtin(__builtin_coro_noop) + +struct suspend_never { + _LIBCUDACXX_INLINE_VISIBILITY + bool await_ready() const _NOEXCEPT { return true; } + _LIBCUDACXX_INLINE_VISIBILITY + void await_suspend(coroutine_handle<>) const _NOEXCEPT {} + _LIBCUDACXX_INLINE_VISIBILITY + void await_resume() const _NOEXCEPT {} +}; + +struct suspend_always { + _LIBCUDACXX_INLINE_VISIBILITY + bool await_ready() const _NOEXCEPT { return false; } + _LIBCUDACXX_INLINE_VISIBILITY + void await_suspend(coroutine_handle<>) const _NOEXCEPT {} + _LIBCUDACXX_INLINE_VISIBILITY + void await_resume() const _NOEXCEPT {} +}; + +_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_COROUTINES + +_LIBCUDACXX_BEGIN_NAMESPACE_STD + +template +struct hash<_CUDA_VSTD_CORO::coroutine_handle<_Tp> > { + using __arg_type = _CUDA_VSTD_CORO::coroutine_handle<_Tp>; + _LIBCUDACXX_INLINE_VISIBILITY + size_t operator()(__arg_type const& __v) const _NOEXCEPT + {return hash()(__v.address());} +}; + +_LIBCUDACXX_END_NAMESPACE_STD + +#endif // !defined(_LIBCUDACXX_HAS_NO_COROUTINES) + +#endif /* _LIBCUDACXX_EXPERIMENTAL_COROUTINE */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/deque b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/deque new file mode 100644 index 0000000000000000000000000000000000000000..1f2291796db96da200a245a65263f23cdee529b0 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/deque @@ -0,0 +1,46 @@ +// -*- C++ -*- +//===--------------------------- deque ------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_DEQUE +#define _LIBCUDACXX_EXPERIMENTAL_DEQUE +/* + experimental/deque synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template + using deque = std::deque>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +template +using deque = _CUDA_VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCUDACXX_EXPERIMENTAL_DEQUE */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/forward_list b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/forward_list new file mode 100644 index 0000000000000000000000000000000000000000..585ca5a8d6fc9fa262c7a214c86dbf86b921297e --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/forward_list @@ -0,0 +1,46 @@ +// -*- C++ -*- +//===--------------------------- forward_list -----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_FORWARD_LIST +#define _LIBCUDACXX_EXPERIMENTAL_FORWARD_LIST +/* + experimental/forward_list synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template + using forward_list = std::forward_list>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +template +using forward_list = _CUDA_VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCUDACXX_EXPERIMENTAL_FORWARD_LIST */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/functional b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/functional new file mode 100644 index 0000000000000000000000000000000000000000..719396c07c7b6d9f79d5dedd509d740f446b92e0 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/functional @@ -0,0 +1,458 @@ +// -*- C++ -*- +//===-------------------------- functional --------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_FUNCTIONAL +#define _LIBCUDACXX_EXPERIMENTAL_FUNCTIONAL + +/* + experimental/functional synopsis + +#include + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + + // See C++14 20.9.9, Function object binders + template constexpr bool is_bind_expression_v + = is_bind_expression::value; + template constexpr int is_placeholder_v + = is_placeholder::value; + + // 4.2, Class template function + template class function; // undefined + template class function; + + template + void swap(function&, function&); + + template + bool operator==(const function&, nullptr_t) noexcept; + template + bool operator==(nullptr_t, const function&) noexcept; + template + bool operator!=(const function&, nullptr_t) noexcept; + template + bool operator!=(nullptr_t, const function&) noexcept; + + // 4.3, Searchers + template> + class default_searcher; + + template::value_type>, + class BinaryPredicate = equal_to<>> + class boyer_moore_searcher; + + template::value_type>, + class BinaryPredicate = equal_to<>> + class boyer_moore_horspool_searcher; + + template> + default_searcher + make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last, + BinaryPredicate pred = BinaryPredicate()); + + template::value_type>, + class BinaryPredicate = equal_to<>> + boyer_moore_searcher + make_boyer_moore_searcher( + RandomAccessIterator pat_first, RandomAccessIterator pat_last, + Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate()); + + template::value_type>, + class BinaryPredicate = equal_to<>> + boyer_moore_horspool_searcher + make_boyer_moore_horspool_searcher( + RandomAccessIterator pat_first, RandomAccessIterator pat_last, + Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate()); + + } // namespace fundamentals_v1 + } // namespace experimental + + template + struct uses_allocator, Alloc>; + +} // namespace std + +*/ + +#include +#include +#include +#include +#include +#include +#include + +#include <__debug> + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_PUSH_MACROS +#include <__undef_macros> + + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS + +#if _LIBCUDACXX_STD_VER > 11 +// default searcher +template> +class _LIBCUDACXX_TYPE_VIS default_searcher { +public: + _LIBCUDACXX_INLINE_VISIBILITY + default_searcher(_ForwardIterator __f, _ForwardIterator __l, + _BinaryPredicate __p = _BinaryPredicate()) + : __first_(__f), __last_(__l), __pred_(__p) {} + + template + _LIBCUDACXX_INLINE_VISIBILITY + pair<_ForwardIterator2, _ForwardIterator2> + operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const + { + return _CUDA_VSTD::__search(__f, __l, __first_, __last_, __pred_, + typename _CUDA_VSTD::iterator_traits<_ForwardIterator>::iterator_category(), + typename _CUDA_VSTD::iterator_traits<_ForwardIterator2>::iterator_category()); + } + +private: + _ForwardIterator __first_; + _ForwardIterator __last_; + _BinaryPredicate __pred_; + }; + +template> +_LIBCUDACXX_INLINE_VISIBILITY +default_searcher<_ForwardIterator, _BinaryPredicate> +make_default_searcher( _ForwardIterator __f, _ForwardIterator __l, _BinaryPredicate __p = _BinaryPredicate ()) +{ + return default_searcher<_ForwardIterator, _BinaryPredicate>(__f, __l, __p); +} + +template class _BMSkipTable; + +// General case for BM data searching; use a map +template +class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, false> { +public: // TODO private: + typedef _Value value_type; + typedef _Key key_type; + + const _Value __default_value_; + std::unordered_map<_Key, _Value, _Hash, _BinaryPredicate> __table; + +public: + _LIBCUDACXX_INLINE_VISIBILITY + _BMSkipTable(std::size_t __sz, _Value __default, _Hash __hf, _BinaryPredicate __pred) + : __default_value_(__default), __table(__sz, __hf, __pred) {} + + _LIBCUDACXX_INLINE_VISIBILITY + void insert(const key_type &__key, value_type __val) + { + __table [__key] = __val; // Would skip_.insert (val) be better here? + } + + _LIBCUDACXX_INLINE_VISIBILITY + value_type operator [](const key_type & __key) const + { + auto __it = __table.find (__key); + return __it == __table.end() ? __default_value_ : __it->second; + } +}; + + +// Special case small numeric values; use an array +template +class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, true> { +private: + typedef _Value value_type; + typedef _Key key_type; + + typedef typename std::make_unsigned::type unsigned_key_type; + typedef std::array::max()> skip_map; + skip_map __table; + +public: + _LIBCUDACXX_INLINE_VISIBILITY + _BMSkipTable(std::size_t /*__sz*/, _Value __default, _Hash /*__hf*/, _BinaryPredicate /*__pred*/) + { + std::fill_n(__table.begin(), __table.size(), __default); + } + + _LIBCUDACXX_INLINE_VISIBILITY + void insert(key_type __key, value_type __val) + { + __table[static_cast(__key)] = __val; + } + + _LIBCUDACXX_INLINE_VISIBILITY + value_type operator [](key_type __key) const + { + return __table[static_cast(__key)]; + } +}; + + +template ::value_type>, + class _BinaryPredicate = equal_to<>> +class _LIBCUDACXX_TYPE_VIS boyer_moore_searcher { +private: + typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type; + typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type; + typedef _BMSkipTable::value && // what about enums? + sizeof(value_type) == 1 && + is_same<_Hash, hash>::value && + is_same<_BinaryPredicate, equal_to<>>::value + > skip_table_type; + +public: + boyer_moore_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, + _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) + : __first_(__f), __last_(__l), __pred_(__pred), + __pattern_length_(_CUDA_VSTD::distance(__first_, __last_)), + __skip_{make_shared(__pattern_length_, -1, __hf, __pred_)}, + __suffix_{make_shared>(__pattern_length_ + 1)} + { + // build the skip table + for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i ) + __skip_->insert(*__f, __i); + + this->__build_suffix_table ( __first_, __last_, __pred_ ); + } + + template + pair<_RandomAccessIterator2, _RandomAccessIterator2> + operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const + { + static_assert ( std::is_same< + std::__remove_cvref_t::value_type>, + std::__remove_cvref_t::value_type> + >::value, + "Corpus and Pattern iterators must point to the same type" ); + + if (__f == __l ) return make_pair(__l, __l); // empty corpus + if (__first_ == __last_) return make_pair(__f, __f); // empty pattern + + // If the pattern is larger than the corpus, we can't find it! + if ( __pattern_length_ > _CUDA_VSTD::distance (__f, __l)) + return make_pair(__l, __l); + + // Do the search + return this->__search(__f, __l); + } + +public: // TODO private: + _RandomAccessIterator1 __first_; + _RandomAccessIterator1 __last_; + _BinaryPredicate __pred_; + difference_type __pattern_length_; + shared_ptr __skip_; + shared_ptr> __suffix_; + + template + pair<_RandomAccessIterator2, _RandomAccessIterator2> + __search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const + { + _RandomAccessIterator2 __cur = __f; + const _RandomAccessIterator2 __last = __l - __pattern_length_; + const skip_table_type & __skip = *__skip_.get(); + const vector & __suffix = *__suffix_.get(); + + while (__cur <= __last) + { + + // Do we match right where we are? + difference_type __j = __pattern_length_; + while (__pred_(__first_ [__j-1], __cur [__j-1])) { + __j--; + // We matched - we're done! + if ( __j == 0 ) + return make_pair(__cur, __cur + __pattern_length_); + } + + // Since we didn't match, figure out how far to skip forward + difference_type __k = __skip[__cur [ __j - 1 ]]; + difference_type __m = __j - __k - 1; + if (__k < __j && __m > __suffix[ __j ]) + __cur += __m; + else + __cur += __suffix[ __j ]; + } + + return make_pair(__l, __l); // We didn't find anything + } + + + template + void __compute_bm_prefix ( _Iterator __f, _Iterator __l, _BinaryPredicate __pred, _Container &__prefix ) + { + const std::size_t __count = _CUDA_VSTD::distance(__f, __l); + + __prefix[0] = 0; + std::size_t __k = 0; + for ( std::size_t __i = 1; __i < __count; ++__i ) + { + while ( __k > 0 && !__pred ( __f[__k], __f[__i] )) + __k = __prefix [ __k - 1 ]; + + if ( __pred ( __f[__k], __f[__i] )) + __k++; + __prefix [ __i ] = __k; + } + } + + void __build_suffix_table(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, + _BinaryPredicate __pred) + { + const std::size_t __count = _CUDA_VSTD::distance(__f, __l); + vector & __suffix = *__suffix_.get(); + if (__count > 0) + { + _CUDA_VSTD::vector __scratch(__count); + + __compute_bm_prefix(__f, __l, __pred, __scratch); + for ( std::size_t __i = 0; __i <= __count; __i++ ) + __suffix[__i] = __count - __scratch[__count-1]; + + typedef _CUDA_VSTD::reverse_iterator<_RandomAccessIterator1> _RevIter; + __compute_bm_prefix(_RevIter(__l), _RevIter(__f), __pred, __scratch); + + for ( std::size_t __i = 0; __i < __count; __i++ ) + { + const std::size_t __j = __count - __scratch[__i]; + const difference_type __k = __i - __scratch[__i] + 1; + + if (__suffix[__j] > __k) + __suffix[__j] = __k; + } + } + } + +}; + +template::value_type>, + class _BinaryPredicate = equal_to<>> +_LIBCUDACXX_INLINE_VISIBILITY +boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate> +make_boyer_moore_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l, + _Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ()) +{ + return boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p); +} + +// boyer-moore-horspool +template ::value_type>, + class _BinaryPredicate = equal_to<>> +class _LIBCUDACXX_TYPE_VIS boyer_moore_horspool_searcher { +private: + typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type; + typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type; + typedef _BMSkipTable::value && // what about enums? + sizeof(value_type) == 1 && + is_same<_Hash, hash>::value && + is_same<_BinaryPredicate, equal_to<>>::value + > skip_table_type; + +public: + boyer_moore_horspool_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, + _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) + : __first_(__f), __last_(__l), __pred_(__pred), + __pattern_length_(_CUDA_VSTD::distance(__first_, __last_)), + __skip_{_CUDA_VSTD::make_shared(__pattern_length_, __pattern_length_, __hf, __pred_)} + { + // build the skip table + if ( __f != __l ) + { + __l = __l - 1; + for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i ) + __skip_->insert(*__f, __pattern_length_ - 1 - __i); + } + } + + template + pair<_RandomAccessIterator2, _RandomAccessIterator2> + operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const + { + static_assert ( std::is_same< + std::__remove_cvref_t::value_type>, + std::__remove_cvref_t::value_type> + >::value, + "Corpus and Pattern iterators must point to the same type" ); + + if (__f == __l ) return make_pair(__l, __l); // empty corpus + if (__first_ == __last_) return make_pair(__f, __f); // empty pattern + + // If the pattern is larger than the corpus, we can't find it! + if ( __pattern_length_ > _CUDA_VSTD::distance (__f, __l)) + return make_pair(__l, __l); + + // Do the search + return this->__search(__f, __l); + } + +private: + _RandomAccessIterator1 __first_; + _RandomAccessIterator1 __last_; + _BinaryPredicate __pred_; + difference_type __pattern_length_; + shared_ptr __skip_; + + template + pair<_RandomAccessIterator2, _RandomAccessIterator2> + __search ( _RandomAccessIterator2 __f, _RandomAccessIterator2 __l ) const { + _RandomAccessIterator2 __cur = __f; + const _RandomAccessIterator2 __last = __l - __pattern_length_; + const skip_table_type & __skip = *__skip_.get(); + + while (__cur <= __last) + { + // Do we match right where we are? + difference_type __j = __pattern_length_; + while (__pred_(__first_[__j-1], __cur[__j-1])) + { + __j--; + // We matched - we're done! + if ( __j == 0 ) + return make_pair(__cur, __cur + __pattern_length_); + } + __cur += __skip[__cur[__pattern_length_-1]]; + } + + return make_pair(__l, __l); + } +}; + +template::value_type>, + class _BinaryPredicate = equal_to<>> +_LIBCUDACXX_INLINE_VISIBILITY +boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate> +make_boyer_moore_horspool_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l, + _Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ()) +{ + return boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p); +} + +#endif // _LIBCUDACXX_STD_VER > 11 + +_LIBCUDACXX_END_NAMESPACE_LFTS + +_LIBCUDACXX_POP_MACROS + +#endif /* _LIBCUDACXX_EXPERIMENTAL_FUNCTIONAL */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/iterator b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/iterator new file mode 100644 index 0000000000000000000000000000000000000000..05fbb7859ff4cee694a5a0c3bf48010aab41e358 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/iterator @@ -0,0 +1,113 @@ +// -*- C++ -*- +//===----------------------------- iterator -------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_ITERATOR +#define _LIBCUDACXX_EXPERIMENTAL_ITERATOR + +/* +namespace std { + namespace experimental { + inline namespace fundamentals_v2 { + + template > + class ostream_joiner { + public: + typedef charT char_type; + typedef traits traits_type; + typedef basic_ostream ostream_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + ostream_joiner(ostream_type& s, const DelimT& delimiter); + ostream_joiner(ostream_type& s, DelimT&& delimiter); + + template + ostream_joiner& operator=(const T& value); + + ostream_joiner& operator*() noexcept; + ostream_joiner& operator++() noexcept; + ostream_joiner& operator++(int) noexcept; + private: + ostream_type* out_stream; // exposition only + DelimT delim; // exposition only + bool first_element; // exposition only + }; + + template + ostream_joiner, charT, traits> + make_ostream_joiner(basic_ostream& os, DelimT&& delimiter); + + } // inline namespace fundamentals_v2 + } // namespace experimental +} // namespace std + +*/ + +#include + +#if _LIBCUDACXX_STD_VER > 11 + +#include + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS + +template > +class ostream_joiner { +public: + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_ostream ostream_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + ostream_joiner(ostream_type& __os, _Delim&& __d) + : __output_iter(_CUDA_VSTD::addressof(__os)), __delim(_CUDA_VSTD::move(__d)), __first(true) {} + + ostream_joiner(ostream_type& __os, const _Delim& __d) + : __output_iter(_CUDA_VSTD::addressof(__os)), __delim(__d), __first(true) {} + + + template + ostream_joiner& operator=(const _Tp& __v) + { + if (!__first) + *__output_iter << __delim; + __first = false; + *__output_iter << __v; + return *this; + } + + ostream_joiner& operator*() _NOEXCEPT { return *this; } + ostream_joiner& operator++() _NOEXCEPT { return *this; } + ostream_joiner& operator++(int) _NOEXCEPT { return *this; } + +private: + ostream_type* __output_iter; + _Delim __delim; + bool __first; +}; + + +template +ostream_joiner<__decay_t<_Delim>, _CharT, _Traits> +make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d) +{ return ostream_joiner<__decay_t<_Delim>, _CharT, _Traits>(__os, _CUDA_VSTD::forward<_Delim>(__d)); } + +_LIBCUDACXX_END_NAMESPACE_LFTS + +#endif /* _LIBCUDACXX_STD_VER > 11 */ + +#endif // _LIBCUDACXX_EXPERIMENTAL_ITERATOR diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/list b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/list new file mode 100644 index 0000000000000000000000000000000000000000..0600d27e65a29f164c3e71ad583db2d93fe5d7b7 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/list @@ -0,0 +1,46 @@ +// -*- C++ -*- +//===--------------------------- list ------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_LIST +#define _LIBCUDACXX_EXPERIMENTAL_LIST +/* + experimental/list synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template + using list = std::list>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +template +using list = _CUDA_VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCUDACXX_EXPERIMENTAL_LIST */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/map b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/map new file mode 100644 index 0000000000000000000000000000000000000000..222836e18011bfd4043bfeaf40d69612c3cbee44 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/map @@ -0,0 +1,56 @@ +// -*- C++ -*- +//===----------------------------- map ------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_MAP +#define _LIBCUDACXX_EXPERIMENTAL_MAP +/* + experimental/map synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template > + using map = std::map>>; + + template > + using multimap = std::multimap>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +template > +using map = _CUDA_VSTD::map<_Key, _Value, _Compare, + polymorphic_allocator>>; + +template > +using multimap = _CUDA_VSTD::multimap<_Key, _Value, _Compare, + polymorphic_allocator>>; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCUDACXX_EXPERIMENTAL_MAP */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/memory_resource b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/memory_resource new file mode 100644 index 0000000000000000000000000000000000000000..1564496c5457298ad1c8db8dc425571a668a804a --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/memory_resource @@ -0,0 +1,426 @@ +// -*- C++ -*- +//===------------------------ memory_resource -----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_MEMORY_RESOURCE +#define _LIBCUDACXX_EXPERIMENTAL_MEMORY_RESOURCE + +/** + experimental/memory_resource synopsis + +// C++1y + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + class memory_resource; + + bool operator==(const memory_resource& a, + const memory_resource& b) noexcept; + bool operator!=(const memory_resource& a, + const memory_resource& b) noexcept; + + template class polymorphic_allocator; + + template + bool operator==(const polymorphic_allocator& a, + const polymorphic_allocator& b) noexcept; + template + bool operator!=(const polymorphic_allocator& a, + const polymorphic_allocator& b) noexcept; + + // The name resource_adaptor_imp is for exposition only. + template class resource_adaptor_imp; + + template + using resource_adaptor = resource_adaptor_imp< + allocator_traits::rebind_alloc>; + + // Global memory resources + memory_resource* new_delete_resource() noexcept; + memory_resource* null_memory_resource() noexcept; + + // The default memory resource + memory_resource* set_default_resource(memory_resource* r) noexcept; + memory_resource* get_default_resource() noexcept; + + // Standard memory resources + struct pool_options; + class synchronized_pool_resource; + class unsynchronized_pool_resource; + class monotonic_buffer_resource; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include <__debug> + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_PUSH_MACROS +#include <__undef_macros> + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +// Round __s up to next multiple of __a. +inline _LIBCUDACXX_INLINE_VISIBILITY +size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT +{ + _LIBCUDACXX_ASSERT(__s + __a > __s, "aligned allocation size overflows"); + return (__s + __a - 1) & ~(__a - 1); +} + +// 8.5, memory.resource +class _LIBCUDACXX_TYPE_VIS memory_resource +{ + static const size_t __max_align = _LIBCUDACXX_ALIGNOF(max_align_t); + +// 8.5.2, memory.resource.public +public: + virtual ~memory_resource() = default; + + _LIBCUDACXX_INLINE_VISIBILITY + void* allocate(size_t __bytes, size_t __align = __max_align) + { return do_allocate(__bytes, __align); } + + _LIBCUDACXX_INLINE_VISIBILITY + void deallocate(void * __p, size_t __bytes, size_t __align = __max_align) + { do_deallocate(__p, __bytes, __align); } + + _LIBCUDACXX_INLINE_VISIBILITY + bool is_equal(memory_resource const & __other) const _NOEXCEPT + { return do_is_equal(__other); } + +// 8.5.3, memory.resource.priv +protected: + virtual void* do_allocate(size_t, size_t) = 0; + virtual void do_deallocate(void*, size_t, size_t) = 0; + virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0; +}; + +// 8.5.4, memory.resource.eq +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator==(memory_resource const & __lhs, + memory_resource const & __rhs) _NOEXCEPT +{ + return &__lhs == &__rhs || __lhs.is_equal(__rhs); +} + +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator!=(memory_resource const & __lhs, + memory_resource const & __rhs) _NOEXCEPT +{ + return !(__lhs == __rhs); +} + +_LIBCUDACXX_FUNC_VIS +memory_resource * new_delete_resource() _NOEXCEPT; + +_LIBCUDACXX_FUNC_VIS +memory_resource * null_memory_resource() _NOEXCEPT; + +_LIBCUDACXX_FUNC_VIS +memory_resource * get_default_resource() _NOEXCEPT; + +_LIBCUDACXX_FUNC_VIS +memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT; + +// 8.6, memory.polymorphic.allocator.class + +// 8.6.1, memory.polymorphic.allocator.overview +template +class _LIBCUDACXX_TEMPLATE_VIS polymorphic_allocator +{ +public: + typedef _ValueType value_type; + + // 8.6.2, memory.polymorphic.allocator.ctor + _LIBCUDACXX_INLINE_VISIBILITY + polymorphic_allocator() _NOEXCEPT + : __res_(_CUDA_VSTD_LFTS_PMR::get_default_resource()) + {} + + _LIBCUDACXX_INLINE_VISIBILITY + polymorphic_allocator(memory_resource * __r) _NOEXCEPT + : __res_(__r) + {} + + polymorphic_allocator(polymorphic_allocator const &) = default; + + template + _LIBCUDACXX_INLINE_VISIBILITY + polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT + : __res_(__other.resource()) + {} + + polymorphic_allocator & + operator=(polymorphic_allocator const &) = delete; + + // 8.6.3, memory.polymorphic.allocator.mem + _LIBCUDACXX_INLINE_VISIBILITY + _ValueType* allocate(size_t __n) { + if (__n > __max_size()) { + __throw_length_error( + "std::experimental::pmr::polymorphic_allocator::allocate(size_t n)" + " 'n' exceeds maximum supported size"); + } + return static_cast<_ValueType*>( + __res_->allocate(__n * sizeof(_ValueType), _LIBCUDACXX_ALIGNOF(_ValueType)) + ); + } + + _LIBCUDACXX_INLINE_VISIBILITY + void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT { + _LIBCUDACXX_ASSERT(__n <= __max_size(), + "deallocate called for size which exceeds max_size()"); + __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCUDACXX_ALIGNOF(_ValueType)); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY + void construct(_Tp* __p, _Ts &&... __args) + { + _CUDA_VSTD_LFTS::__lfts_user_alloc_construct( + __p, *this, _CUDA_VSTD::forward<_Ts>(__args)... + ); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY + void construct(pair<_T1, _T2>* __p, piecewise_construct_t, + tuple<_Args1...> __x, tuple<_Args2...> __y) + { + ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct + , __transform_tuple( + typename __lfts_uses_alloc_ctor< + _T1, polymorphic_allocator&, _Args1... + >::type() + , _CUDA_VSTD::move(__x) + , typename __make_tuple_indices::type{} + ) + , __transform_tuple( + typename __lfts_uses_alloc_ctor< + _T2, polymorphic_allocator&, _Args2... + >::type() + , _CUDA_VSTD::move(__y) + , typename __make_tuple_indices::type{} + ) + ); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY + void construct(pair<_T1, _T2>* __p) { + construct(__p, piecewise_construct, tuple<>(), tuple<>()); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY + void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) { + construct(__p, piecewise_construct + , _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Up>(__u)) + , _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Vp>(__v))); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY + void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) { + construct(__p, piecewise_construct + , _CUDA_VSTD::forward_as_tuple(__pr.first) + , _CUDA_VSTD::forward_as_tuple(__pr.second)); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY + void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){ + construct(__p, piecewise_construct + , _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_U1>(__pr.first)) + , _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_U2>(__pr.second))); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY + void destroy(_Tp * __p) _NOEXCEPT + { __p->~_Tp(); } + + _LIBCUDACXX_INLINE_VISIBILITY + polymorphic_allocator + select_on_container_copy_construction() const _NOEXCEPT + { return polymorphic_allocator(); } + + _LIBCUDACXX_INLINE_VISIBILITY + memory_resource * resource() const _NOEXCEPT + { return __res_; } + +private: + template + _LIBCUDACXX_INLINE_VISIBILITY + tuple<_Args&&...> + __transform_tuple(integral_constant, tuple<_Args...>&& __t, + __tuple_indices<_Idx...>) const + { + return _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__t))...); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY + tuple + __transform_tuple(integral_constant, tuple<_Args...> && __t, + __tuple_indices<_Idx...>) + { + using _Tup = tuple; + return _Tup(allocator_arg, *this, + _CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__t))...); + } + + template + _LIBCUDACXX_INLINE_VISIBILITY + tuple<_Args&&..., polymorphic_allocator&> + __transform_tuple(integral_constant, tuple<_Args...> && __t, + __tuple_indices<_Idx...>) + { + using _Tup = tuple<_Args&&..., polymorphic_allocator&>; + return _Tup(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__t))..., *this); + } + + _LIBCUDACXX_INLINE_VISIBILITY + size_t __max_size() const _NOEXCEPT + { return numeric_limits::max() / sizeof(value_type); } + + memory_resource * __res_; +}; + +// 8.6.4, memory.polymorphic.allocator.eq + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator==(polymorphic_allocator<_Tp> const & __lhs, + polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT +{ + return *__lhs.resource() == *__rhs.resource(); +} + +template +inline _LIBCUDACXX_INLINE_VISIBILITY +bool operator!=(polymorphic_allocator<_Tp> const & __lhs, + polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT +{ + return !(__lhs == __rhs); +} + +// 8.7, memory.resource.adaptor + +// 8.7.1, memory.resource.adaptor.overview +template +class _LIBCUDACXX_TEMPLATE_VIS __resource_adaptor_imp + : public memory_resource +{ + using _CTraits = allocator_traits<_CharAlloc>; + static_assert(is_same::value + && is_same::value + && is_same::value, ""); + + static const size_t _MaxAlign = _LIBCUDACXX_ALIGNOF(max_align_t); + + using _Alloc = typename _CTraits::template rebind_alloc< + typename aligned_storage<_MaxAlign, _MaxAlign>::type + >; + + using _ValueType = typename _Alloc::value_type; + + _Alloc __alloc_; + +public: + typedef _CharAlloc allocator_type; + + __resource_adaptor_imp() = default; + __resource_adaptor_imp(__resource_adaptor_imp const &) = default; + __resource_adaptor_imp(__resource_adaptor_imp &&) = default; + + // 8.7.2, memory.resource.adaptor.ctor + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __resource_adaptor_imp(allocator_type const & __a) + : __alloc_(__a) + {} + + _LIBCUDACXX_INLINE_VISIBILITY + explicit __resource_adaptor_imp(allocator_type && __a) + : __alloc_(_CUDA_VSTD::move(__a)) + {} + + __resource_adaptor_imp & + operator=(__resource_adaptor_imp const &) = default; + + _LIBCUDACXX_INLINE_VISIBILITY + allocator_type get_allocator() const + { return __alloc_; } + +// 8.7.3, memory.resource.adaptor.mem +protected: + virtual void * do_allocate(size_t __bytes, size_t) + { + if (__bytes > __max_size()) { + __throw_length_error( + "std::experimental::pmr::resource_adaptor::do_allocate(size_t bytes, size_t align)" + " 'bytes' exceeds maximum supported size"); + } + size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign; + return __alloc_.allocate(__s); + } + + virtual void do_deallocate(void * __p, size_t __bytes, size_t) + { + _LIBCUDACXX_ASSERT(__bytes <= __max_size(), + "do_deallocate called for size which exceeds the maximum allocation size"); + size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign; + __alloc_.deallocate((_ValueType*)__p, __s); + } + + virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT { + __resource_adaptor_imp const * __p + = dynamic_cast<__resource_adaptor_imp const *>(&__other); + return __p ? __alloc_ == __p->__alloc_ : false; + } + +private: + _LIBCUDACXX_INLINE_VISIBILITY + size_t __max_size() const _NOEXCEPT { + return numeric_limits::max() - _MaxAlign; + } +}; + +template +using resource_adaptor = __resource_adaptor_imp< + typename allocator_traits<_Alloc>::template rebind_alloc + >; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +_LIBCUDACXX_POP_MACROS + +#endif /* _LIBCUDACXX_EXPERIMENTAL_MEMORY_RESOURCE */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/regex b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/regex new file mode 100644 index 0000000000000000000000000000000000000000..3a7cd32ccecb27054498c4b23734bfc62d60113a --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/regex @@ -0,0 +1,61 @@ +// -*- C++ -*- +//===----------------------------- regex ----------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_REGEX +#define _LIBCUDACXX_EXPERIMENTAL_REGEX +/* + experimental/regex synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template + using match_results = + std::match_results>>; + + typedef match_results cmatch; + typedef match_results wcmatch; + typedef match_results smatch; + typedef match_results wsmatch; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +template +using match_results = + _CUDA_VSTD::match_results<_BiDirIter, + polymorphic_allocator<_CUDA_VSTD::sub_match<_BiDirIter>>>; + +typedef match_results cmatch; +typedef match_results wcmatch; +typedef match_results<_CUDA_VSTD_LFTS_PMR::string::const_iterator> smatch; +typedef match_results<_CUDA_VSTD_LFTS_PMR::wstring::const_iterator> wsmatch; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCUDACXX_EXPERIMENTAL_REGEX */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/set b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/set new file mode 100644 index 0000000000000000000000000000000000000000..995d50a3d489d6fcd286a6958c724451e4dd5e91 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/set @@ -0,0 +1,56 @@ +// -*- C++ -*- +//===--------------------------- list ------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_SET +#define _LIBCUDACXX_EXPERIMENTAL_SET +/* + experimental/set synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template > + using set = std::set>>; + + template > + using multiset = std::multiset>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +template > +using set = _CUDA_VSTD::set<_Value, _Compare, + polymorphic_allocator<_Value>>; + +template > +using multiset = _CUDA_VSTD::multiset<_Value, _Compare, + polymorphic_allocator<_Value>>; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCUDACXX_EXPERIMENTAL_SET */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/simd b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/simd new file mode 100644 index 0000000000000000000000000000000000000000..99453767b5fe80fd53a4b5dd61c5729fdf2169f3 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/simd @@ -0,0 +1,1569 @@ +// -*- C++ -*- +//===------------------------------- simd ---------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#ifndef _LIBCUDACXX_EXPERIMENTAL_SIMD +#define _LIBCUDACXX_EXPERIMENTAL_SIMD + +/* + experimental/simd synopsis + +namespace std::experimental { + +inline namespace parallelism_v2 { + +namespace simd_abi { + +struct scalar {}; +template struct fixed_size {}; +template inline constexpr int max_fixed_size = implementation-defined; +template using compatible = implementation-defined; +template using native = implementation-defined; + +} // simd_abi + +struct element_aligned_tag {}; +struct vector_aligned_tag {}; +template struct overaligned_tag {}; +inline constexpr element_aligned_tag element_aligned{}; +inline constexpr vector_aligned_tag vector_aligned{}; +template inline constexpr overaligned_tag overaligned{}; + +// traits [simd.traits] +template struct is_abi_tag; +template inline constexpr bool is_abi_tag_v = is_abi_tag::value; + +template struct is_simd; +template inline constexpr bool is_simd_v = is_simd::value; + +template struct is_simd_mask; +template inline constexpr bool is_simd_mask_v = is_simd_mask::value; + +template struct is_simd_flag_type; +template inline constexpr bool is_simd_flag_type_v = is_simd_flag_type::value; + +template struct abi_for_size { using type = see below; }; +template using abi_for_size_t = typename abi_for_size::type; + +template > struct simd_size; +template > +inline constexpr size_t simd_size_v = simd_size::value; + +template struct memory_alignment; +template +inline constexpr size_t memory_alignment_v = memory_alignment::value; + +// class template simd [simd.class] +template > class simd; +template using native_simd = simd>; +template using fixed_size_simd = simd>; + +// class template simd_mask [simd.mask.class] +template > class simd_mask; +template using native_simd_mask = simd_mask>; +template using fixed_size_simd_mask = simd_mask>; + +// casts [simd.casts] +template see below simd_cast(const simd&); +template see below static_simd_cast(const simd&); + +template +fixed_size_simd> to_fixed_size(const simd&) noexcept; +template +fixed_size_simd_mask> to_fixed_size(const simd_mask&) noexcept; +template native_simd to_native(const fixed_size_simd&) noexcept; +template +native_simd_mask to_native(const fixed_size_simd_mask> &) noexcept; +template simd to_compatible(const fixed_size_simd&) noexcept; +template simd_mask to_compatible(const fixed_size_simd_mask&) noexcept; + +template +tuple>...> split(const simd&); +template +tuple>...> split(const simd_mask&); +template +array / V::size()> split( +const simd&); +template +array / V::size()> split( +const simd_mask&); + +template +simd + ...)>> concat(const simd&...); +template +simd_mask + ...)>> concat(const simd_mask&...); + +// reductions [simd.mask.reductions] +template bool all_of(const simd_mask&) noexcept; +template bool any_of(const simd_mask&) noexcept; +template bool none_of(const simd_mask&) noexcept; +template bool some_of(const simd_mask&) noexcept; +template int popcount(const simd_mask&) noexcept; +template int find_first_set(const simd_mask&); +template int find_last_set(const simd_mask&); + +bool all_of(see below) noexcept; +bool any_of(see below) noexcept; +bool none_of(see below) noexcept; +bool some_of(see below) noexcept; +int popcount(see below) noexcept; +int find_first_set(see below) noexcept; +int find_last_set(see below) noexcept; + +// masked assignment [simd.whereexpr] +template class const_where_expression; +template class where_expression; + +// masked assignment [simd.mask.where] +template struct nodeduce { using type = T; }; // exposition only + +template using nodeduce_t = typename nodeduce::type; // exposition only + +template +where_expression, simd> +where(const typename simd::mask_type&, simd&) noexcept; + +template +const_where_expression, const simd> +where(const typename simd::mask_type&, const simd&) noexcept; + +template +where_expression, simd_mask> +where(const nodeduce_t>&, simd_mask&) noexcept; + +template +const_where_expression, const simd_mask> +where(const nodeduce_t>&, const simd_mask&) noexcept; + +template where_expression where(see below k, T& d) noexcept; + +template +const_where_expression where(see below k, const T& d) noexcept; + +// reductions [simd.reductions] +template > +T reduce(const simd&, BinaryOperation = BinaryOperation()); + +template +typename V::value_type reduce(const const_where_expression& x, +typename V::value_type neutral_element, BinaryOperation binary_op); + +template +typename V::value_type reduce(const const_where_expression& x, plus<> binary_op = plus<>()); + +template +typename V::value_type reduce(const const_where_expression& x, multiplies<> binary_op); + +template +typename V::value_type reduce(const const_where_expression& x, bit_and<> binary_op); + +template +typename V::value_type reduce(const const_where_expression& x, bit_or<> binary_op); + +template +typename V::value_type reduce(const const_where_expression& x, bit_xor<> binary_op); + +template T hmin(const simd&); +template T hmin(const const_where_expression&); +template T hmax(const simd&); +template T hmax(const const_where_expression&); + +// algorithms [simd.alg] +template simd min(const simd&, const simd&) noexcept; + +template simd max(const simd&, const simd&) noexcept; + +template +std::pair, simd> minmax(const simd&, const simd&) noexcept; + +template +simd clamp(const simd& v, const simd& lo, const simd& hi); + +// [simd.whereexpr] +template +class const_where_expression { + const M& mask; // exposition only + T& data; // exposition only +public: + const_where_expression(const const_where_expression&) = delete; + const_where_expression& operator=(const const_where_expression&) = delete; + remove_const_t operator-() const &&; + template void copy_to(U* mem, Flags f) const &&; +}; + +template +class where_expression : public const_where_expression { +public: + where_expression(const where_expression&) = delete; + where_expression& operator=(const where_expression&) = delete; + template void operator=(U&& x); + template void operator+=(U&& x); + template void operator-=(U&& x); + template void operator*=(U&& x); + template void operator/=(U&& x); + template void operator%=(U&& x); + template void operator&=(U&& x); + template void operator|=(U&& x); + template void operator^=(U&& x); + template void operator<<=(U&& x); + template void operator>>=(U&& x); + void operator++(); + void operator++(int); + void operator--(); + void operator--(int); + template void copy_from(const U* mem, Flags); +}; + +// [simd.class] +template class simd { +public: + using value_type = T; + using reference = see below; + using mask_type = simd_mask; + + using abi_type = Abi; + static constexpr size_t size() noexcept; + simd() = default; + + // implicit type conversion constructor + template simd(const simd>&); + + // implicit broadcast constructor (see below for constraints) + template simd(U&& value); + + // generator constructor (see below for constraints) + template explicit simd(G&& gen); + + // load constructor + template simd(const U* mem, Flags f); + + // loads [simd.load] + template void copy_from(const U* mem, Flags f); + + // stores [simd.store] + template void copy_to(U* mem, Flags f) const; + + // scalar access [simd.subscr] + reference operator[](size_t); + value_type operator[](size_t) const; + + // unary operators [simd.unary] + simd& operator++(); + simd operator++(int); + simd& operator--(); + simd operator--(int); + mask_type operator!() const; + simd operator~() const; // see below + simd operator+() const; + simd operator-() const; + + // binary operators [simd.binary] + friend simd operator+ (const simd&, const simd&); + friend simd operator- (const simd&, const simd&); + friend simd operator* (const simd&, const simd&); + friend simd operator/ (const simd&, const simd&); + friend simd operator% (const simd&, const simd&); + friend simd operator& (const simd&, const simd&); + friend simd operator| (const simd&, const simd&); + friend simd operator^ (const simd&, const simd&); + friend simd operator<<(const simd&, const simd&); + friend simd operator>>(const simd&, const simd&); + friend simd operator<<(const simd&, int); + friend simd operator>>(const simd&, int); + + // compound assignment [simd.cassign] + friend simd& operator+= (simd&, const simd&); + friend simd& operator-= (simd&, const simd&); + friend simd& operator*= (simd&, const simd&); + friend simd& operator/= (simd&, const simd&); + friend simd& operator%= (simd&, const simd&); + + friend simd& operator&= (simd&, const simd&); + friend simd& operator|= (simd&, const simd&); + friend simd& operator^= (simd&, const simd&); + friend simd& operator<<=(simd&, const simd&); + friend simd& operator>>=(simd&, const simd&); + friend simd& operator<<=(simd&, int); + friend simd& operator>>=(simd&, int); + + // compares [simd.comparison] + friend mask_type operator==(const simd&, const simd&); + friend mask_type operator!=(const simd&, const simd&); + friend mask_type operator>=(const simd&, const simd&); + friend mask_type operator<=(const simd&, const simd&); + friend mask_type operator> (const simd&, const simd&); + friend mask_type operator< (const simd&, const simd&); +}; + +// [simd.math] +template using scharv = simd; // exposition only +template using shortv = simd; // exposition only +template using intv = simd; // exposition only +template using longv = simd; // exposition only +template using llongv = simd; // exposition only +template using floatv = simd; // exposition only +template using doublev = simd; // exposition only +template using ldoublev = simd; // exposition only +template using samesize = fixed_size_simd; // exposition only + +template floatv acos(floatv x); +template doublev acos(doublev x); +template ldoublev acos(ldoublev x); + +template floatv asin(floatv x); +template doublev asin(doublev x); +template ldoublev asin(ldoublev x); + +template floatv atan(floatv x); +template doublev atan(doublev x); +template ldoublev atan(ldoublev x); + +template floatv atan2(floatv y, floatv x); +template doublev atan2(doublev y, doublev x); +template ldoublev atan2(ldoublev y, ldoublev x); + +template floatv cos(floatv x); +template doublev cos(doublev x); +template ldoublev cos(ldoublev x); + +template floatv sin(floatv x); +template doublev sin(doublev x); +template ldoublev sin(ldoublev x); + +template floatv tan(floatv x); +template doublev tan(doublev x); +template ldoublev tan(ldoublev x); + +template floatv acosh(floatv x); +template doublev acosh(doublev x); +template ldoublev acosh(ldoublev x); + +template floatv asinh(floatv x); +template doublev asinh(doublev x); +template ldoublev asinh(ldoublev x); + +template floatv atanh(floatv x); +template doublev atanh(doublev x); +template ldoublev atanh(ldoublev x); + +template floatv cosh(floatv x); +template doublev cosh(doublev x); +template ldoublev cosh(ldoublev x); + +template floatv sinh(floatv x); +template doublev sinh(doublev x); +template ldoublev sinh(ldoublev x); + +template floatv tanh(floatv x); +template doublev tanh(doublev x); +template ldoublev tanh(ldoublev x); + +template floatv exp(floatv x); +template doublev exp(doublev x); +template ldoublev exp(ldoublev x); + +template floatv exp2(floatv x); +template doublev exp2(doublev x); +template ldoublev exp2(ldoublev x); + +template floatv expm1(floatv x); +template doublev expm1(doublev x); +template ldoublev expm1(ldoublev x); + +template floatv frexp(floatv value, samesize>* exp); +template doublev frexp(doublev value, samesize>* exp); +template ldoublev frexp(ldoublev value, samesize>* exp); + +template samesize> ilogb(floatv x); +template samesize> ilogb(doublev x); +template samesize> ilogb(ldoublev x); + +template floatv ldexp(floatv x, samesize> exp); +template doublev ldexp(doublev x, samesize> exp); +template ldoublev ldexp(ldoublev x, samesize> exp); + +template floatv log(floatv x); +template doublev log(doublev x); +template ldoublev log(ldoublev x); + +template floatv log10(floatv x); +template doublev log10(doublev x); +template ldoublev log10(ldoublev x); + +template floatv log1p(floatv x); +template doublev log1p(doublev x); +template ldoublev log1p(ldoublev x); + +template floatv log2(floatv x); +template doublev log2(doublev x); +template ldoublev log2(ldoublev x); + +template floatv logb(floatv x); +template doublev logb(doublev x); +template ldoublev logb(ldoublev x); + +template floatv modf(floatv value, floatv* iptr); +template doublev modf(doublev value, doublev* iptr); +template ldoublev modf(ldoublev value, ldoublev* iptr); + +template floatv scalbn(floatv x, samesize> n); +template doublev scalbn(doublev x, samesize> n); +template ldoublev scalbn(ldoublev x, samesize> n); +template floatv scalbln(floatv x, samesize> n); +template doublev scalbln(doublev x, samesize> n); +template ldoublev scalbln(ldoublev x, samesize> n); + +template floatv cbrt(floatv x); +template doublev cbrt(doublev x); +template ldoublev cbrt(ldoublev x); + +template scharv abs(scharv j); +template shortv abs(shortv j); +template intv abs(intv j); +template longv abs(longv j); +template llongv abs(llongv j); +template floatv abs(floatv j); +template doublev abs(doublev j); +template ldoublev abs(ldoublev j); + +template floatv hypot(floatv x, floatv y); +template doublev hypot(doublev x, doublev y); +template ldoublev hypot(doublev x, doublev y); +template floatv hypot(floatv x, floatv y, floatv z); +template doublev hypot(doublev x, doublev y, doublev z); +template ldoublev hypot(ldoublev x, ldoublev y, ldoublev z); + +template floatv pow(floatv x, floatv y); +template doublev pow(doublev x, doublev y); +template ldoublev pow(ldoublev x, ldoublev y); + +template floatv sqrt(floatv x); +template doublev sqrt(doublev x); +template ldoublev sqrt(ldoublev x); + +template floatv erf(floatv x); +template doublev erf(doublev x); +template ldoublev erf(ldoublev x); +template floatv erfc(floatv x); +template doublev erfc(doublev x); +template ldoublev erfc(ldoublev x); + +template floatv lgamma(floatv x); +template doublev lgamma(doublev x); +template ldoublev lgamma(ldoublev x); + +template floatv tgamma(floatv x); +template doublev tgamma(doublev x); +template ldoublev tgamma(ldoublev x); + +template floatv ceil(floatv x); +template doublev ceil(doublev x); +template ldoublev ceil(ldoublev x); + +template floatv floor(floatv x); +template doublev floor(doublev x); +template ldoublev floor(ldoublev x); + +template floatv nearbyint(floatv x); +template doublev nearbyint(doublev x); +template ldoublev nearbyint(ldoublev x); + +template floatv rint(floatv x); +template doublev rint(doublev x); +template ldoublev rint(ldoublev x); + +template samesize> lrint(floatv x); +template samesize> lrint(doublev x); +template samesize> lrint(ldoublev x); +template samesize> llrint(floatv x); +template samesize> llrint(doublev x); +template samesize> llrint(ldoublev x); + +template floatv round(floatv x); +template doublev round(doublev x); +template ldoublev round(ldoublev x); +template samesize> lround(floatv x); +template samesize> lround(doublev x); +template samesize> lround(ldoublev x); +template samesize> llround(floatv x); +template samesize> llround(doublev x); +template samesize> llround(ldoublev x); + +template floatv trunc(floatv x); +template doublev trunc(doublev x); +template ldoublev trunc(ldoublev x); + +template floatv fmod(floatv x, floatv y); +template doublev fmod(doublev x, doublev y); +template ldoublev fmod(ldoublev x, ldoublev y); + +template floatv remainder(floatv x, floatv y); +template doublev remainder(doublev x, doublev y); +template ldoublev remainder(ldoublev x, ldoublev y); + +template floatv remquo(floatv x, floatv y, samesize>* quo); +template doublev remquo(doublev x, doublev y, samesize>* quo); +template ldoublev remquo(ldoublev x, ldoublev y, samesize>* quo); + +template floatv copysign(floatv x, floatv y); +template doublev copysign(doublev x, doublev y); +template ldoublev copysign(ldoublev x, ldoublev y); + +template doublev nan(const char* tagp); +template floatv nanf(const char* tagp); +template ldoublev nanl(const char* tagp); + +template floatv nextafter(floatv x, floatv y); +template doublev nextafter(doublev x, doublev y); +template ldoublev nextafter(ldoublev x, ldoublev y); + +template floatv nexttoward(floatv x, ldoublev y); +template doublev nexttoward(doublev x, ldoublev y); +template ldoublev nexttoward(ldoublev x, ldoublev y); + +template floatv fdim(floatv x, floatv y); +template doublev fdim(doublev x, doublev y); +template ldoublev fdim(ldoublev x, ldoublev y); + +template floatv fmax(floatv x, floatv y); +template doublev fmax(doublev x, doublev y); +template ldoublev fmax(ldoublev x, ldoublev y); + +template floatv fmin(floatv x, floatv y); +template doublev fmin(doublev x, doublev y); +template ldoublev fmin(ldoublev x, ldoublev y); + +template floatv fma(floatv x, floatv y, floatv z); +template doublev fma(doublev x, doublev y, doublev z); +template ldoublev fma(ldoublev x, ldoublev y, ldoublev z); + +template samesize> fpclassify(floatv x); +template samesize> fpclassify(doublev x); +template samesize> fpclassify(ldoublev x); + +template simd_mask isfinite(floatv x); +template simd_mask isfinite(doublev x); +template simd_mask isfinite(ldoublev x); + +template simd_mask isinf(floatv x); +template simd_mask isinf(doublev x); +template simd_mask isinf(ldoublev x); + +template simd_mask isnan(floatv x); +template simd_mask isnan(doublev x); +template simd_mask isnan(ldoublev x); + +template simd_mask isnormal(floatv x); +template simd_mask isnormal(doublev x); +template simd_mask isnormal(ldoublev x); + +template simd_mask signbit(floatv x); +template simd_mask signbit(doublev x); +template simd_mask signbit(ldoublev x); + +template simd_mask isgreater(floatv x, floatv y); +template simd_mask isgreater(doublev x, doublev y); +template simd_mask isgreater(ldoublev x, ldoublev y); + +template simd_mask isgreaterequal(floatv x, floatv y); +template simd_mask isgreaterequal(doublev x, doublev y); +template simd_mask isgreaterequal(ldoublev x, ldoublev y); + +template simd_mask isless(floatv x, floatv y); +template simd_mask isless(doublev x, doublev y); +template simd_mask isless(ldoublev x, ldoublev y); + +template simd_mask islessequal(floatv x, floatv y); +template simd_mask islessequal(doublev x, doublev y); +template simd_mask islessequal(ldoublev x, ldoublev y); + +template simd_mask islessgreater(floatv x, floatv y); +template simd_mask islessgreater(doublev x, doublev y); +template simd_mask islessgreater(ldoublev x, ldoublev y); + +template simd_mask isunordered(floatv x, floatv y); +template simd_mask isunordered(doublev x, doublev y); +template simd_mask isunordered(ldoublev x, ldoublev y); + +template struct simd_div_t { V quot, rem; }; +template simd_div_t> div(scharv numer, scharv denom); +template simd_div_t> div(shortv numer, shortv denom); +template simd_div_t> div(intv numer, intv denom); +template simd_div_t> div(longv numer, longv denom); +template simd_div_t> div(llongv numer, llongv denom); + +// [simd.mask.class] +template +class simd_mask { +public: + using value_type = bool; + using reference = see below; + using simd_type = simd; + using abi_type = Abi; + static constexpr size_t size() noexcept; + simd_mask() = default; + + // broadcast constructor + explicit simd_mask(value_type) noexcept; + + // implicit type conversion constructor + template simd_mask(const simd_mask>&) noexcept; + + // load constructor + template simd_mask(const value_type* mem, Flags); + + // loads [simd.mask.copy] + template void copy_from(const value_type* mem, Flags); + template void copy_to(value_type* mem, Flags) const; + + // scalar access [simd.mask.subscr] + reference operator[](size_t); + value_type operator[](size_t) const; + + // unary operators [simd.mask.unary] + simd_mask operator!() const noexcept; + + // simd_mask binary operators [simd.mask.binary] + friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept; + friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept; + friend simd_mask operator& (const simd_mask&, const simd_mask&) noexcept; + friend simd_mask operator| (const simd_mask&, const simd_mask&) noexcept; + friend simd_mask operator^ (const simd_mask&, const simd_mask&) noexcept; + + // simd_mask compound assignment [simd.mask.cassign] + friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept; + friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept; + friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept; + + // simd_mask compares [simd.mask.comparison] + friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept; + friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept; +}; + +} // parallelism_v2 +} // std::experimental + +*/ + +#include +#include +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD + +#if _LIBCUDACXX_STD_VER >= 17 + +enum class _StorageKind { + _Scalar, + _Array, + _VecExt, +}; + +template <_StorageKind __kind, int _Np> +struct __simd_abi {}; + +template +class __simd_storage {}; + +template +class __simd_storage<_Tp, __simd_abi<_StorageKind::_Array, __num_element>> { + std::array<_Tp, __num_element> __storage_; + + template + friend struct simd; + + template + friend struct simd_mask; + +public: + _Tp __get(size_t __index) const noexcept { return __storage_[__index]; }; + void __set(size_t __index, _Tp __val) noexcept { + __storage_[__index] = __val; + } +}; + +template +class __simd_storage<_Tp, __simd_abi<_StorageKind::_Scalar, 1>> { + _Tp __storage_; + + template + friend struct simd; + + template + friend struct simd_mask; + +public: + _Tp __get(size_t __index) const noexcept { return (&__storage_)[__index]; }; + void __set(size_t __index, _Tp __val) noexcept { + (&__storage_)[__index] = __val; + } +}; + +#ifndef _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION + +constexpr size_t __floor_pow_of_2(size_t __val) { + return ((__val - 1) & __val) == 0 ? __val + : __floor_pow_of_2((__val - 1) & __val); +} + +constexpr size_t __ceil_pow_of_2(size_t __val) { + return __val == 1 ? 1 : __floor_pow_of_2(__val - 1) << 1; +} + +template +struct __vec_ext_traits { +#if !defined(_LIBCUDACXX_COMPILER_CLANG) + typedef _Tp type __attribute__((vector_size(__ceil_pow_of_2(__bytes)))); +#endif +}; + +#if defined(_LIBCUDACXX_COMPILER_CLANG) +#define _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, _NUM_ELEMENT) \ + template <> \ + struct __vec_ext_traits<_TYPE, sizeof(_TYPE) * _NUM_ELEMENT> { \ + using type = \ + _TYPE __attribute__((vector_size(sizeof(_TYPE) * _NUM_ELEMENT))); \ + } + +#define _LIBCUDACXX_SPECIALIZE_VEC_EXT_32(_TYPE) \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 1); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 2); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 3); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 4); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 5); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 6); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 7); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 8); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 9); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 10); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 11); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 12); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 13); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 14); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 15); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 16); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 17); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 18); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 19); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 20); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 21); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 22); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 23); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 24); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 25); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 26); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 27); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 28); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 29); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 30); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 31); \ + _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 32); + +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(char); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(char16_t); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(char32_t); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(wchar_t); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed char); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed short); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed int); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed long); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed long long); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned char); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned short); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned int); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned long); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned long long); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(float); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(double); +_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(long double); + +#undef _LIBCUDACXX_SPECIALIZE_VEC_EXT_32 +#undef _LIBCUDACXX_SPECIALIZE_VEC_EXT +#endif + +template +class __simd_storage<_Tp, __simd_abi<_StorageKind::_VecExt, __num_element>> { + using _StorageType = + typename __vec_ext_traits<_Tp, sizeof(_Tp) * __num_element>::type; + + _StorageType __storage_; + + template + friend struct simd; + + template + friend struct simd_mask; + +public: + _Tp __get(size_t __index) const noexcept { return __storage_[__index]; }; + void __set(size_t __index, _Tp __val) noexcept { + __storage_[__index] = __val; + } +}; + +#endif // _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION + +template +class __simd_reference { + static_assert(std::is_same<_Vp, _Tp>::value, ""); + + template + friend struct simd; + + template + friend struct simd_mask; + + __simd_storage<_Tp, _Abi>* __ptr_; + size_t __index_; + + __simd_reference(__simd_storage<_Tp, _Abi>* __ptr, size_t __index) + : __ptr_(__ptr), __index_(__index) {} + + __simd_reference(const __simd_reference&) = default; + +public: + __simd_reference() = delete; + __simd_reference& operator=(const __simd_reference&) = delete; + + operator _Vp() const { return __ptr_->__get(__index_); } + + __simd_reference operator=(_Vp __value) && { + __ptr_->__set(__index_, __value); + return *this; + } + + __simd_reference operator++() && { + return std::move(*this) = __ptr_->__get(__index_) + 1; + } + + _Vp operator++(int) && { + auto __val = __ptr_->__get(__index_); + __ptr_->__set(__index_, __val + 1); + return __val; + } + + __simd_reference operator--() && { + return std::move(*this) = __ptr_->__get(__index_) - 1; + } + + _Vp operator--(int) && { + auto __val = __ptr_->__get(__index_); + __ptr_->__set(__index_, __val - 1); + return __val; + } + + __simd_reference operator+=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) + __value; + } + + __simd_reference operator-=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) - __value; + } + + __simd_reference operator*=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) * __value; + } + + __simd_reference operator/=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) / __value; + } + + __simd_reference operator%=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) % __value; + } + + __simd_reference operator>>=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) >> __value; + } + + __simd_reference operator<<=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) << __value; + } + + __simd_reference operator&=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) & __value; + } + + __simd_reference operator|=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) | __value; + } + + __simd_reference operator^=(_Vp __value) && { + return std::move(*this) = __ptr_->__get(__index_) ^ __value; + } +}; + +template +constexpr decltype(_To{std::declval<_From>()}, true) +__is_non_narrowing_convertible_impl(_From) { + return true; +} + +template +constexpr bool __is_non_narrowing_convertible_impl(...) { + return false; +} + +template +constexpr typename std::enable_if::value && + std::is_arithmetic<_From>::value, + bool>::type +__is_non_narrowing_arithmetic_convertible() { + return __is_non_narrowing_convertible_impl<_To>(_From{}); +} + +template +constexpr typename std::enable_if::value && + std::is_arithmetic<_From>::value), + bool>::type +__is_non_narrowing_arithmetic_convertible() { + return false; +} + +template +constexpr _Tp __variadic_sum() { + return _Tp{}; +} + +template +constexpr _Tp __variadic_sum(_Up __first, _Args... __rest) { + return static_cast<_Tp>(__first) + __variadic_sum<_Tp>(__rest...); +} + +template +struct __nodeduce { + using type = _Tp; +}; + +template +constexpr bool __vectorizable() { + return std::is_arithmetic<_Tp>::value && !std::is_const<_Tp>::value && + !std::is_volatile<_Tp>::value && !std::is_same<_Tp, bool>::value; +} + +_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD +_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI + +using scalar = __simd_abi<_StorageKind::_Scalar, 1>; + +template +using fixed_size = __simd_abi<_StorageKind::_Array, _Np>; + +template +_LIBCUDACXX_INLINE_VAR constexpr size_t max_fixed_size = 32; + +template +using compatible = fixed_size<16 / sizeof(_Tp)>; + +#ifndef _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION +template +using native = __simd_abi<_StorageKind::_VecExt, + _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>; +#else +template +using native = + fixed_size<_Tp, _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>; +#endif // _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION + +_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI +_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD + +template > +class simd; +template > +class simd_mask; + +struct element_aligned_tag {}; +struct vector_aligned_tag {}; +template +struct overaligned_tag {}; +_LIBCUDACXX_INLINE_VAR constexpr element_aligned_tag element_aligned{}; +_LIBCUDACXX_INLINE_VAR constexpr vector_aligned_tag vector_aligned{}; +template +_LIBCUDACXX_INLINE_VAR constexpr overaligned_tag<_Np> overaligned{}; + +// traits [simd.traits] +template +struct is_abi_tag : std::integral_constant {}; + +template <_StorageKind __kind, int _Np> +struct is_abi_tag<__simd_abi<__kind, _Np>> + : std::integral_constant {}; + +template +struct is_simd : std::integral_constant {}; + +template +struct is_simd> : std::integral_constant {}; + +template +struct is_simd_mask : std::integral_constant {}; + +template +struct is_simd_mask> : std::integral_constant { +}; + +template +struct is_simd_flag_type : std::integral_constant {}; + +template <> +struct is_simd_flag_type + : std::integral_constant {}; + +template <> +struct is_simd_flag_type + : std::integral_constant {}; + +template +struct is_simd_flag_type> + : std::integral_constant {}; + +template +_LIBCUDACXX_INLINE_VAR constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value; +template +_LIBCUDACXX_INLINE_VAR constexpr bool is_simd_v = is_simd<_Tp>::value; +template +_LIBCUDACXX_INLINE_VAR constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value; +template +_LIBCUDACXX_INLINE_VAR constexpr bool is_simd_flag_type_v = + is_simd_flag_type<_Tp>::value; +template +struct abi_for_size { + using type = simd_abi::fixed_size<_Np>; +}; +template +using abi_for_size_t = typename abi_for_size<_Tp, _Np>::type; + +template > +struct simd_size; + +template +struct simd_size<_Tp, __simd_abi<__kind, _Np>> + : std::integral_constant { + static_assert( + std::is_arithmetic<_Tp>::value && + !std::is_same::type, bool>::value, + "Element type should be vectorizable"); +}; + +// TODO: implement it. +template +struct memory_alignment; + +template > +_LIBCUDACXX_INLINE_VAR constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value; + +template +_LIBCUDACXX_INLINE_VAR constexpr size_t memory_alignment_v = + memory_alignment<_Tp, _Up>::value; + +// class template simd [simd.class] +template +using native_simd = simd<_Tp, simd_abi::native<_Tp>>; +template +using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>; + +// class template simd_mask [simd.mask.class] +template +using native_simd_mask = simd_mask<_Tp, simd_abi::native<_Tp>>; + +template +using fixed_size_simd_mask = simd_mask<_Tp, simd_abi::fixed_size<_Np>>; + +// casts [simd.casts] +template +struct __static_simd_cast_traits { + template + static simd<_Tp, _Abi> __apply(const simd<_Up, _Abi>& __v); +}; + +template +struct __static_simd_cast_traits> { + template + static typename std::enable_if::size() == + simd<_Tp, _NewAbi>::size(), + simd<_Tp, _NewAbi>>::type + __apply(const simd<_Up, _Abi>& __v); +}; + +template +struct __simd_cast_traits { + template + static typename std::enable_if< + __is_non_narrowing_arithmetic_convertible<_Up, _Tp>(), + simd<_Tp, _Abi>>::type + __apply(const simd<_Up, _Abi>& __v); +}; + +template +struct __simd_cast_traits> { + template + static typename std::enable_if< + __is_non_narrowing_arithmetic_convertible<_Up, _Tp>() && + simd<_Up, _Abi>::size() == simd<_Tp, _NewAbi>::size(), + simd<_Tp, _NewAbi>>::type + __apply(const simd<_Up, _Abi>& __v); +}; + +template +auto simd_cast(const simd<_Up, _Abi>& __v) + -> decltype(__simd_cast_traits<_Tp>::__apply(__v)) { + return __simd_cast_traits<_Tp>::__apply(__v); +} + +template +auto static_simd_cast(const simd<_Up, _Abi>& __v) + -> decltype(__static_simd_cast_traits<_Tp>::__apply(__v)) { + return __static_simd_cast_traits<_Tp>::__apply(__v); +} + +template +fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value> +to_fixed_size(const simd<_Tp, _Abi>&) noexcept; + +template +fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value> +to_fixed_size(const simd_mask<_Tp, _Abi>&) noexcept; + +template +native_simd<_Tp> to_native(const fixed_size_simd<_Tp, _Np>&) noexcept; + +template +native_simd_mask<_Tp> to_native(const fixed_size_simd_mask<_Tp, _Np>&) noexcept; + +template +simd<_Tp> to_compatible(const fixed_size_simd<_Tp, _Np>&) noexcept; + +template +simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept; + +template +tuple>...> split(const simd<_Tp, _Abi>&); + +template +tuple>...> +split(const simd_mask<_Tp, _Abi>&); + +template +array<_SimdType, simd_size::value / + _SimdType::size()> +split(const simd&); + +template +array<_SimdType, simd_size::value / + _SimdType::size()> +split(const simd_mask&); + +template +simd<_Tp, abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>> +concat(const simd<_Tp, _Abis>&...); + +template +simd_mask<_Tp, + abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>> +concat(const simd_mask<_Tp, _Abis>&...); + +// reductions [simd.mask.reductions] +template +bool all_of(const simd_mask<_Tp, _Abi>&) noexcept; +template +bool any_of(const simd_mask<_Tp, _Abi>&) noexcept; +template +bool none_of(const simd_mask<_Tp, _Abi>&) noexcept; +template +bool some_of(const simd_mask<_Tp, _Abi>&) noexcept; +template +int popcount(const simd_mask<_Tp, _Abi>&) noexcept; +template +int find_first_set(const simd_mask<_Tp, _Abi>&); +template +int find_last_set(const simd_mask<_Tp, _Abi>&); +bool all_of(bool) noexcept; +bool any_of(bool) noexcept; +bool none_of(bool) noexcept; +bool some_of(bool) noexcept; +int popcount(bool) noexcept; +int find_first_set(bool) noexcept; +int find_last_set(bool) noexcept; + +// masked assignment [simd.whereexpr] +template +class const_where_expression; +template +class where_expression; + +// masked assignment [simd.mask.where] +template +where_expression, simd<_Tp, _Abi>> +where(const typename simd<_Tp, _Abi>::mask_type&, simd<_Tp, _Abi>&) noexcept; + +template +const_where_expression, const simd<_Tp, _Abi>> +where(const typename simd<_Tp, _Abi>::mask_type&, + const simd<_Tp, _Abi>&) noexcept; + +template +where_expression, simd_mask<_Tp, _Abi>> +where(const typename __nodeduce>::type&, + simd_mask<_Tp, _Abi>&) noexcept; + +template +const_where_expression, const simd_mask<_Tp, _Abi>> +where(const typename __nodeduce>::type&, + const simd_mask<_Tp, _Abi>&) noexcept; + +template +where_expression where(bool, _Tp&) noexcept; + +template +const_where_expression where(bool, const _Tp&) noexcept; + +// reductions [simd.reductions] +template > +_Tp reduce(const simd<_Tp, _Abi>&, _BinaryOp = _BinaryOp()); + +template +typename _SimdType::value_type +reduce(const const_where_expression<_MaskType, _SimdType>&, + typename _SimdType::value_type neutral_element, _BinaryOp binary_op); + +template +typename _SimdType::value_type +reduce(const const_where_expression<_MaskType, _SimdType>&, + plus binary_op = {}); + +template +typename _SimdType::value_type +reduce(const const_where_expression<_MaskType, _SimdType>&, + multiplies binary_op); + +template +typename _SimdType::value_type +reduce(const const_where_expression<_MaskType, _SimdType>&, + bit_and binary_op); + +template +typename _SimdType::value_type +reduce(const const_where_expression<_MaskType, _SimdType>&, + bit_or binary_op); + +template +typename _SimdType::value_type +reduce(const const_where_expression<_MaskType, _SimdType>&, + bit_xor binary_op); + +template +_Tp hmin(const simd<_Tp, _Abi>&); +template +typename _SimdType::value_type +hmin(const const_where_expression<_MaskType, _SimdType>&); +template +_Tp hmax(const simd<_Tp, _Abi>&); +template +typename _SimdType::value_type +hmax(const const_where_expression<_MaskType, _SimdType>&); + +// algorithms [simd.alg] +template +simd<_Tp, _Abi> min(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept; + +template +simd<_Tp, _Abi> max(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept; + +template +std::pair, simd<_Tp, _Abi>> +minmax(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept; + +template +simd<_Tp, _Abi> clamp(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&, + const simd<_Tp, _Abi>&); + +// [simd.whereexpr] +// TODO implement where expressions. +template +class const_where_expression { +public: + const_where_expression(const const_where_expression&) = delete; + const_where_expression& operator=(const const_where_expression&) = delete; + __remove_const_t<_Tp> operator-() const&&; + template + void copy_to(_Up*, _Flags) const&&; +}; + +template +class where_expression : public const_where_expression<_MaskType, _Tp> { +public: + where_expression(const where_expression&) = delete; + where_expression& operator=(const where_expression&) = delete; + template + void operator=(_Up&&); + template + void operator+=(_Up&&); + template + void operator-=(_Up&&); + template + void operator*=(_Up&&); + template + void operator/=(_Up&&); + template + void operator%=(_Up&&); + template + void operator&=(_Up&&); + template + void operator|=(_Up&&); + template + void operator^=(_Up&&); + template + void operator<<=(_Up&&); + template + void operator>>=(_Up&&); + void operator++(); + void operator++(int); + void operator--(); + void operator--(int); + template + void copy_from(const _Up*, _Flags); +}; + +// [simd.class] +// TODO: implement simd +template +class simd { +public: + using value_type = _Tp; + using reference = __simd_reference<_Tp, _Tp, _Abi>; + using mask_type = simd_mask<_Tp, _Abi>; + using abi_type = _Abi; + + simd() = default; + simd(const simd&) = default; + simd& operator=(const simd&) = default; + + static constexpr size_t size() noexcept { + return simd_size<_Tp, _Abi>::value; + } + +private: + __simd_storage<_Tp, _Abi> __s_; + + template + static constexpr bool __can_broadcast() { + return (std::is_arithmetic<_Up>::value && + __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) || + (!std::is_arithmetic<_Up>::value && + std::is_convertible<_Up, _Tp>::value) || + std::is_same::type, int>::value || + (std::is_same::type, + unsigned int>::value && + std::is_unsigned<_Tp>::value); + } + + template + static constexpr decltype( + std::forward_as_tuple(std::declval<_Generator>()( + std::integral_constant())...), + bool()) + __can_generate(std::index_sequence<__indicies...>) { + return !__variadic_sum( + !__can_broadcast()( + std::integral_constant()))>()...); + } + + template + static bool __can_generate(...) { + return false; + } + + template + void __generator_init(_Generator&& __g, std::index_sequence<__indicies...>) { + int __not_used[]{((*this)[__indicies] = + __g(std::integral_constant()), + 0)...}; + (void)__not_used; + } + +public: + // implicit type conversion constructor + template >::value && + __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()>::type> + simd(const simd<_Up, simd_abi::fixed_size>& __v) { + for (size_t __i = 0; __i < size(); __i++) { + (*this)[__i] = static_cast<_Tp>(__v[__i]); + } + } + + // implicit broadcast constructor + template ()>::type> + simd(_Up&& __rv) { + auto __v = static_cast<_Tp>(__rv); + for (size_t __i = 0; __i < size(); __i++) { + (*this)[__i] = __v; + } + } + + // generator constructor + template (std::make_index_sequence()), + int>::type()> + explicit simd(_Generator&& __g) { + __generator_init(std::forward<_Generator>(__g), + std::make_index_sequence()); + } + + // load constructor + template < + class _Up, class _Flags, + class = typename std::enable_if<__vectorizable<_Up>()>::type, + class = typename std::enable_if::value>::type> + simd(const _Up* __buffer, _Flags) { + // TODO: optimize for overaligned flags + for (size_t __i = 0; __i < size(); __i++) { + (*this)[__i] = static_cast<_Tp>(__buffer[__i]); + } + } + + // loads [simd.load] + template + typename std::enable_if<__vectorizable<_Up>() && + is_simd_flag_type<_Flags>::value>::type + copy_from(const _Up* __buffer, _Flags) { + *this = simd(__buffer, _Flags()); + } + + // stores [simd.store] + template + typename std::enable_if<__vectorizable<_Up>() && + is_simd_flag_type<_Flags>::value>::type + copy_to(_Up* __buffer, _Flags) const { + // TODO: optimize for overaligned flags + for (size_t __i = 0; __i < size(); __i++) { + __buffer[__i] = static_cast<_Up>((*this)[__i]); + } + } + + // scalar access [simd.subscr] + reference operator[](size_t __i) { return reference(&__s_, __i); } + + value_type operator[](size_t __i) const { return __s_.__get(__i); } + + // unary operators [simd.unary] + simd& operator++(); + simd operator++(int); + simd& operator--(); + simd operator--(int); + mask_type operator!() const; + simd operator~() const; + simd operator+() const; + simd operator-() const; + + // binary operators [simd.binary] + friend simd operator+(const simd&, const simd&); + friend simd operator-(const simd&, const simd&); + friend simd operator*(const simd&, const simd&); + friend simd operator/(const simd&, const simd&); + friend simd operator%(const simd&, const simd&); + friend simd operator&(const simd&, const simd&); + friend simd operator|(const simd&, const simd&); + friend simd operator^(const simd&, const simd&); + friend simd operator<<(const simd&, const simd&); + friend simd operator>>(const simd&, const simd&); + friend simd operator<<(const simd&, int); + friend simd operator>>(const simd&, int); + + // compound assignment [simd.cassign] + friend simd& operator+=(simd&, const simd&); + friend simd& operator-=(simd&, const simd&); + friend simd& operator*=(simd&, const simd&); + friend simd& operator/=(simd&, const simd&); + friend simd& operator%=(simd&, const simd&); + + friend simd& operator&=(simd&, const simd&); + friend simd& operator|=(simd&, const simd&); + friend simd& operator^=(simd&, const simd&); + friend simd& operator<<=(simd&, const simd&); + friend simd& operator>>=(simd&, const simd&); + friend simd& operator<<=(simd&, int); + friend simd& operator>>=(simd&, int); + + // compares [simd.comparison] + friend mask_type operator==(const simd&, const simd&); + friend mask_type operator!=(const simd&, const simd&); + friend mask_type operator>=(const simd&, const simd&); + friend mask_type operator<=(const simd&, const simd&); + friend mask_type operator>(const simd&, const simd&); + friend mask_type operator<(const simd&, const simd&); +}; + +// [simd.mask.class] +template +// TODO: implement simd_mask +class simd_mask { +public: + using value_type = bool; + // TODO: this is strawman implementation. Turn it into a proxy type. + using reference = bool&; + using simd_type = simd<_Tp, _Abi>; + using abi_type = _Abi; + static constexpr size_t size() noexcept; + simd_mask() = default; + + // broadcast constructor + explicit simd_mask(value_type) noexcept; + + // implicit type conversion constructor + template + simd_mask(const simd_mask<_Up, simd_abi::fixed_size>&) noexcept; + + // load constructor + template + simd_mask(const value_type*, _Flags); + + // loads [simd.mask.copy] + template + void copy_from(const value_type*, _Flags); + template + void copy_to(value_type*, _Flags) const; + + // scalar access [simd.mask.subscr] + reference operator[](size_t); + value_type operator[](size_t) const; + + // unary operators [simd.mask.unary] + simd_mask operator!() const noexcept; + + // simd_mask binary operators [simd.mask.binary] + friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept; + friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept; + friend simd_mask operator&(const simd_mask&, const simd_mask&)noexcept; + friend simd_mask operator|(const simd_mask&, const simd_mask&) noexcept; + friend simd_mask operator^(const simd_mask&, const simd_mask&) noexcept; + + // simd_mask compound assignment [simd.mask.cassign] + friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept; + friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept; + friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept; + + // simd_mask compares [simd.mask.comparison] + friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept; + friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept; +}; + +#endif // _LIBCUDACXX_STD_VER >= 17 + +_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD + +#endif /* _LIBCUDACXX_EXPERIMENTAL_SIMD */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/string b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/string new file mode 100644 index 0000000000000000000000000000000000000000..0e502e823b3fcc8ce8103bf701a33890ba6936e8 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/string @@ -0,0 +1,61 @@ +// -*- C++ -*- +//===--------------------------- string ----------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_STRING +#define _LIBCUDACXX_EXPERIMENTAL_STRING +/* + experimental/string synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + // basic_string using polymorphic allocator in namespace pmr + template > + using basic_string = + std::basic_string>; + + // basic_string typedef names using polymorphic allocator in namespace + // std::experimental::pmr + typedef basic_string string; + typedef basic_string u16string; + typedef basic_string u32string; + typedef basic_string wstring; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +template > +using basic_string = + _CUDA_VSTD::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>; + +typedef basic_string string; +typedef basic_string u16string; +typedef basic_string u32string; +typedef basic_string wstring; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCUDACXX_EXPERIMENTAL_STRING */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/type_traits b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/type_traits new file mode 100644 index 0000000000000000000000000000000000000000..81555c2b2968bb638f91f6d6010d86901034b193 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/type_traits @@ -0,0 +1,154 @@ +// -*- C++ -*- +//===-------------------------- type_traits -------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_TYPE_TRAITS +#define _LIBCUDACXX_EXPERIMENTAL_TYPE_TRAITS + +/** + experimental/type_traits synopsis + +// C++1y +#include + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + + // 3.3.2, Other type transformations + template class invocation_type; // not defined + template class invocation_type; + template class raw_invocation_type; // not defined + template class raw_invocation_type; + + template + using invocation_type_t = typename invocation_type::type; + template + using raw_invocation_type_t = typename raw_invocation_type::type; + + // 3.3.4, Detection idiom + template using void_t = void; + + struct nonesuch { + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + void operator=(nonesuch const&) = delete; + }; + + template class Op, class... Args> + using is_detected = see below; + template class Op, class... Args> + constexpr bool is_detected_v = is_detected::value; + template class Op, class... Args> + using detected_t = see below; + template class Op, class... Args> + using detected_or = see below; + template class Op, class... Args> + using detected_or_t = typename detected_or::type; + template class Op, class... Args> + using is_detected_exact = is_same>; + template class Op, class... Args> + constexpr bool is_detected_exact_v + = is_detected_exact::value; + template class Op, class... Args> + using is_detected_convertible = is_convertible, To>; + template class Op, class... Args> + constexpr bool is_detected_convertible_v + = is_detected_convertible::value; + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include + +#if _LIBCUDACXX_STD_VER > 11 + +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS + +// 3.3.2, Other type transformations +/* +template +class _LIBCUDACXX_TEMPLATE_VIS raw_invocation_type; + +template +class _LIBCUDACXX_TEMPLATE_VIS raw_invocation_type<_Fn(_Args...)>; + +template +class _LIBCUDACXX_TEMPLATE_VIS invokation_type; + +template +class _LIBCUDACXX_TEMPLATE_VIS invokation_type<_Fn(_Args...)>; + +template +using invokation_type_t = typename invokation_type<_Tp>::type; + +template +using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type; +*/ + +// 3.3.4, Detection idiom +template using void_t = void; + +struct nonesuch : private _CUDA_VSTD::__nat { // make nonesuch "not an aggregate" + ~nonesuch() = delete; + nonesuch (nonesuch const&) = delete; + void operator=(nonesuch const&) = delete; + }; + +template class _Op, class... _Args> +struct _DETECTOR { + using value_t = false_type; + using type = _Default; + }; + +template class _Op, class... _Args> +struct _DETECTOR<_Default, void_t<_Op<_Args...>>, _Op, _Args...> { + using value_t = true_type; + using type = _Op<_Args...>; + }; + + +template class _Op, class... _Args> + using is_detected = typename _DETECTOR::value_t; +template class _Op, class... _Args> + using detected_t = typename _DETECTOR::type; +template class _Op, class... _Args> + _LIBCUDACXX_CONSTEXPR bool is_detected_v = is_detected<_Op, _Args...>::value; + +template class _Op, class... _Args> + using detected_or = _DETECTOR; +template class _Op, class... _Args> + using detected_or_t = typename detected_or::type; + +template class _Op, class... _Args> + using is_detected_exact = is_same>; +template class _Op, class... _Args> + _LIBCUDACXX_CONSTEXPR bool is_detected_exact_v = is_detected_exact::value; + +template class _Op, class... _Args> + using is_detected_convertible = is_convertible, To>; +template class _Op, class... _Args> + _LIBCUDACXX_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible::value; + + +_LIBCUDACXX_END_NAMESPACE_LFTS + +#endif /* _LIBCUDACXX_STD_VER > 11 */ + +#endif /* _LIBCUDACXX_EXPERIMENTAL_TYPE_TRAITS */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/unordered_map b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/unordered_map new file mode 100644 index 0000000000000000000000000000000000000000..221156a3e84b733508447f28d66260711e0268f5 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/unordered_map @@ -0,0 +1,64 @@ +// -*- C++ -*- +//===------------------------- unordered_map ------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_UNORDERED_MAP +#define _LIBCUDACXX_EXPERIMENTAL_UNORDERED_MAP +/* + experimental/unordered_map synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template , + class Pred = equal_to> + using unordered_map = + std::unordered_map>>; + + template , + class Pred = equal_to> + using unordered_multimap = + std::unordered_multimap>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +template , class _Pred = equal_to<_Key>> +using unordered_map = _CUDA_VSTD::unordered_map<_Key, _Value, _Hash, _Pred, + polymorphic_allocator>>; + +template , class _Pred = equal_to<_Key>> +using unordered_multimap = _CUDA_VSTD::unordered_multimap<_Key, _Value, _Hash, _Pred, + polymorphic_allocator>>; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCUDACXX_EXPERIMENTAL_UNORDERED_MAP */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/utility b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/utility new file mode 100644 index 0000000000000000000000000000000000000000..8f7f7a149d9fcac076a7f994787b239db2c0d734 --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/utility @@ -0,0 +1,46 @@ +// -*- C++ -*- +//===-------------------------- utility ----------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_UTILITY +#define _LIBCUDACXX_EXPERIMENTAL_UTILITY + +/* + experimental/utility synopsis + +// C++1y + +#include + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + + 3.1.2, erased-type placeholder + struct erased_type { }; + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS + + struct _LIBCUDACXX_TEMPLATE_VIS erased_type { }; + +_LIBCUDACXX_END_NAMESPACE_LFTS + +#endif /* _LIBCUDACXX_EXPERIMENTAL_UTILITY */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/vector b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/vector new file mode 100644 index 0000000000000000000000000000000000000000..d3c593467c5599e21ee93fecea716f03f4b2152c --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/experimental/vector @@ -0,0 +1,46 @@ +// -*- C++ -*- +//===--------------------------- vector ------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCUDACXX_EXPERIMENTAL_VECTOR +#define _LIBCUDACXX_EXPERIMENTAL_VECTOR +/* + experimental/vector synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template + using vector = std::vector>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include +#include +#include + +#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR + +template +using vector = _CUDA_VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>; + +_LIBCUDACXX_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCUDACXX_EXPERIMENTAL_VECTOR */ diff --git a/videochat2/lib/python3.10/site-packages/tensorflow/python/client/_pywrap_tf_session.so b/videochat2/lib/python3.10/site-packages/tensorflow/python/client/_pywrap_tf_session.so new file mode 100644 index 0000000000000000000000000000000000000000..34ff229feba567fc6c0e15ea0f91dc7676ba876f --- /dev/null +++ b/videochat2/lib/python3.10/site-packages/tensorflow/python/client/_pywrap_tf_session.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f921f13e360fd2c244c53a3c562b9277b9f82ebac501345b38b72298e04e7ca0 +size 2862344