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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
/*
* Copyright 2008-2013 NVIDIA Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*! \file thrust/future.h
* \brief `thrust::future`, an asynchronous value type.
*/
#pragma once
#include <thrust/detail/config.h>
#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
# pragma GCC system_header
#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
# pragma clang system_header
#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
# pragma system_header
#endif // no system header
#include <thrust/detail/cpp14_required.h>
#if THRUST_CPP_DIALECT >= 2014
#include <thrust/execution_policy.h>
#include <thrust/detail/static_assert.h>
#include <utility>
/*
// #include the host system's pointer.h header.
#define __THRUST_HOST_SYSTEM_POINTER_HEADER <__THRUST_HOST_SYSTEM_ROOT/pointer.h>
#include __THRUST_HOST_SYSTEM_POINTER_HEADER
#undef __THRUST_HOST_SYSTEM_POINTER_HEADER
*/
// #include the device system's pointer.h header.
#define __THRUST_DEVICE_SYSTEM_POINTER_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/pointer.h>
#include __THRUST_DEVICE_SYSTEM_POINTER_HEADER
#undef __THRUST_DEVICE_SYSTEM_POINTER_HEADER
/*
// #include the host system's future.h header.
#define __THRUST_HOST_SYSTEM_FUTURE_HEADER <__THRUST_HOST_SYSTEM_ROOT/future.h>
#include __THRUST_HOST_SYSTEM_FUTURE_HEADER
#undef __THRUST_HOST_SYSTEM_FUTURE_HEADER
*/
// #include the device system's future.h header.
#define __THRUST_DEVICE_SYSTEM_FUTURE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/future.h>
#include __THRUST_DEVICE_SYSTEM_FUTURE_HEADER
#undef __THRUST_DEVICE_SYSTEM_FUTURE_HEADER
THRUST_NAMESPACE_BEGIN
///////////////////////////////////////////////////////////////////////////////
// `select_unique_(future|event)_type` is a hook for choosing the
// `unique_eager_event`/`unique_eager_future` type for a system. `decltype` is
// used to determine the return type of an ADL call to
// `select_unique_eager_(future|event)_type(system)`; that return type should
// be the correct event/future type for `system`. Overloads should only be
// declared, not defined.
namespace unimplemented
{
struct no_unique_eager_event_type_found {};
inline __host__
no_unique_eager_event_type_found
unique_eager_event_type(...) noexcept;
struct no_unique_eager_future_type_found {};
template <typename T>
__host__
no_unique_eager_future_type_found
unique_eager_future_type(...) noexcept;
} // namespace unimplemented
namespace unique_eager_event_type_detail
{
using unimplemented::unique_eager_event_type;
template <typename System>
using select = decltype(
unique_eager_event_type(std::declval<System>())
);
} // namespace unique_eager_event_type_detail
namespace unique_eager_future_type_detail
{
using unimplemented::unique_eager_future_type;
template <typename System, typename T>
using select = decltype(
unique_eager_future_type<T>(std::declval<System>())
);
} // namespace unique_eager_future_type_detail
///////////////////////////////////////////////////////////////////////////////
template <typename System>
using unique_eager_event = unique_eager_event_type_detail::select<System>;
template <typename System>
using event = unique_eager_event<System>;
///////////////////////////////////////////////////////////////////////////////
template <typename System, typename T>
using unique_eager_future = unique_eager_future_type_detail::select<System, T>;
template <typename System, typename T>
using future = unique_eager_future<System, T>;
/*
///////////////////////////////////////////////////////////////////////////////
using host_unique_eager_event = unique_eager_event_type_detail::select<
thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::tag
>;
using host_event = host_unique_eager_event;
///////////////////////////////////////////////////////////////////////////////
template <typename T>
using host_unique_eager_future = unique_eager_future_type_detail::select<
thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::tag, T
>;
template <typename T>
using host_future = host_unique_eager_future<T>;
*/
///////////////////////////////////////////////////////////////////////////////
using device_unique_eager_event = unique_eager_event_type_detail::select<
thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag
>;
using device_event = device_unique_eager_event;
///////////////////////////////////////////////////////////////////////////////
template <typename T>
using device_unique_eager_future = unique_eager_future_type_detail::select<
thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag, T
>;
template <typename T>
using device_future = device_unique_eager_future<T>;
///////////////////////////////////////////////////////////////////////////////
struct new_stream_t final {};
THRUST_INLINE_CONSTANT new_stream_t new_stream{};
///////////////////////////////////////////////////////////////////////////////
using thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::when_all;
///////////////////////////////////////////////////////////////////////////////
THRUST_NAMESPACE_END
#endif
|
