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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2008-2017 NVIDIA Corporation. All rights reserved.
#ifndef PXTASK_PXTASKMANAGER_H
#define PXTASK_PXTASKMANAGER_H
#include "task/PxTaskDefine.h"
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxErrorCallback.h"
namespace physx
{
PX_PUSH_PACK_DEFAULT
class PxBaseTask;
class PxTask;
class PxLightCpuTask;
typedef unsigned int PxTaskID;
/**
\brief Identifies the type of each heavyweight PxTask object
\note This enum type is only used by PxTask and GpuTask objects, LightCpuTasks do not use this enum.
@see PxTask
@see PxLightCpuTask
*/
struct PxTaskType
{
/**
* \brief Identifies the type of each heavyweight PxTask object
*/
enum Enum
{
TT_CPU, //!< PxTask will be run on the CPU
TT_GPU, //!< PxTask will be run on the GPU
TT_NOT_PRESENT, //!< Return code when attempting to find a task that does not exist
TT_COMPLETED //!< PxTask execution has been completed
};
};
class PxCpuDispatcher;
class PxGpuDispatcher;
/**
\brief The PxTaskManager interface
A PxTaskManager instance holds references to user-provided dispatcher objects, when tasks are
submitted the PxTaskManager routes them to the appropriate dispatcher and handles task profiling if enabled.
Users should not implement the PxTaskManager interface, the SDK creates it's own concrete PxTaskManager object
per-scene which users can configure by passing dispatcher objects into the PxSceneDesc.
@see CpuDispatcher
@see PxGpuDispatcher
*/
class PxTaskManager
{
public:
/**
\brief Set the user-provided dispatcher object for CPU tasks
\param[in] ref The dispatcher object.
@see CpuDispatcher
*/
virtual void setCpuDispatcher(PxCpuDispatcher& ref) = 0;
/**
\brief Set the user-provided dispatcher object for GPU tasks
\param[in] ref The dispatcher object.
@see PxGpuDispatcher
*/
virtual void setGpuDispatcher(PxGpuDispatcher& ref) = 0;
/**
\brief Get the user-provided dispatcher object for CPU tasks
\return The CPU dispatcher object.
@see CpuDispatcher
*/
virtual PxCpuDispatcher* getCpuDispatcher() const = 0;
/**
\brief Get the user-provided dispatcher object for GPU tasks
\return The GPU dispatcher object.
@see PxGpuDispatcher
*/
virtual PxGpuDispatcher* getGpuDispatcher() const = 0;
/**
\brief Reset any dependencies between Tasks
\note Will be called at the start of every frame before tasks are submitted.
@see PxTask
*/
virtual void resetDependencies() = 0;
/**
\brief Called by the owning scene to start the task graph.
\note All tasks with with ref count of 1 will be dispatched.
@see PxTask
*/
virtual void startSimulation() = 0;
/**
\brief Called by the owning scene at the end of a simulation step to synchronize the PxGpuDispatcher
@see PxGpuDispatcher
*/
virtual void stopSimulation() = 0;
/**
\brief Called by the worker threads to inform the PxTaskManager that a task has completed processing
\param[in] task The task which has been completed
*/
virtual void taskCompleted(PxTask& task) = 0;
/**
\brief Retrieve a task by name
\param[in] name The unique name of a task
\return The ID of the task with that name, or TT_NOT_PRESENT if not found
*/
virtual PxTaskID getNamedTask(const char* name) = 0;
/**
\brief Submit a task with a unique name.
\param[in] task The task to be executed
\param[in] name The unique name of a task
\param[in] type The type of the task (default TT_CPU)
\return The ID of the task with that name, or TT_NOT_PRESENT if not found
*/
virtual PxTaskID submitNamedTask(PxTask* task, const char* name, PxTaskType::Enum type = PxTaskType::TT_CPU) = 0;
/**
\brief Submit an unnamed task.
\param[in] task The task to be executed
\param[in] type The type of the task (default TT_CPU)
\return The ID of the task with that name, or TT_NOT_PRESENT if not found
*/
virtual PxTaskID submitUnnamedTask(PxTask& task, PxTaskType::Enum type = PxTaskType::TT_CPU) = 0;
/**
\brief Retrieve a task given a task ID
\param[in] id The ID of the task to return, a valid ID must be passed or results are undefined
\return The task associated with the ID
*/
virtual PxTask* getTaskFromID(PxTaskID id) = 0;
/**
\brief Release the PxTaskManager object, referenced dispatchers will not be released
*/
virtual void release() = 0;
/**
\brief Construct a new PxTaskManager instance with the given [optional] dispatchers
*/
static PxTaskManager* createTaskManager(PxErrorCallback& errorCallback, PxCpuDispatcher* = 0, PxGpuDispatcher* = 0);
protected:
virtual ~PxTaskManager() {}
/*! \cond PRIVATE */
virtual void finishBefore(PxTask& task, PxTaskID taskID) = 0;
virtual void startAfter(PxTask& task, PxTaskID taskID) = 0;
virtual void addReference(PxTaskID taskID) = 0;
virtual void decrReference(PxTaskID taskID) = 0;
virtual int32_t getReference(PxTaskID taskID) const = 0;
virtual void decrReference(PxLightCpuTask&) = 0;
virtual void addReference(PxLightCpuTask&) = 0;
/*! \endcond */
friend class PxBaseTask;
friend class PxTask;
friend class PxLightCpuTask;
friend class PxGpuWorkerThread;
};
PX_POP_PACK
} // end physx namespace
#endif // PXTASK_PXTASKMANAGER_H
|