1 /**************************************************************************
3 * Copyright 2015 Advanced Micro Devices, Inc.
4 * Copyright 2008 VMware, Inc.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * on the rights to use, copy, modify, merge, publish, distribute, sub
11 * license, and/or sell copies of the Software, and to permit persons to whom
12 * the Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 * USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
29 #include "dd_public.h"
30 #include "util/u_memory.h"
35 dd_screen_get_name(struct pipe_screen
*_screen
)
37 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
39 return screen
->get_name(screen
);
43 dd_screen_get_vendor(struct pipe_screen
*_screen
)
45 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
47 return screen
->get_vendor(screen
);
51 dd_screen_get_device_vendor(struct pipe_screen
*_screen
)
53 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
55 return screen
->get_device_vendor(screen
);
59 dd_screen_get_param(struct pipe_screen
*_screen
,
62 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
64 return screen
->get_param(screen
, param
);
68 dd_screen_get_paramf(struct pipe_screen
*_screen
,
71 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
73 return screen
->get_paramf(screen
, param
);
77 dd_screen_get_compute_param(struct pipe_screen
*_screen
,
78 enum pipe_shader_ir ir_type
,
79 enum pipe_compute_cap param
,
82 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
84 return screen
->get_compute_param(screen
, ir_type
, param
, ret
);
88 dd_screen_get_shader_param(struct pipe_screen
*_screen
, unsigned shader
,
89 enum pipe_shader_cap param
)
91 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
93 return screen
->get_shader_param(screen
, shader
, param
);
97 dd_screen_get_timestamp(struct pipe_screen
*_screen
)
99 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
101 return screen
->get_timestamp(screen
);
104 static void dd_screen_query_memory_info(struct pipe_screen
*_screen
,
105 struct pipe_memory_info
*info
)
107 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
109 return screen
->query_memory_info(screen
, info
);
112 static struct pipe_context
*
113 dd_screen_context_create(struct pipe_screen
*_screen
, void *priv
,
116 struct dd_screen
*dscreen
= dd_screen(_screen
);
117 struct pipe_screen
*screen
= dscreen
->screen
;
119 flags
|= PIPE_CONTEXT_DEBUG
;
121 return dd_context_create(dscreen
,
122 screen
->context_create(screen
, priv
, flags
));
126 dd_screen_is_format_supported(struct pipe_screen
*_screen
,
127 enum pipe_format format
,
128 enum pipe_texture_target target
,
129 unsigned sample_count
,
132 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
134 return screen
->is_format_supported(screen
, format
, target
, sample_count
,
139 dd_screen_can_create_resource(struct pipe_screen
*_screen
,
140 const struct pipe_resource
*templat
)
142 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
144 return screen
->can_create_resource(screen
, templat
);
148 dd_screen_flush_frontbuffer(struct pipe_screen
*_screen
,
149 struct pipe_resource
*resource
,
150 unsigned level
, unsigned layer
,
151 void *context_private
,
152 struct pipe_box
*sub_box
)
154 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
156 screen
->flush_frontbuffer(screen
, resource
, level
, layer
, context_private
,
161 dd_screen_get_driver_query_info(struct pipe_screen
*_screen
,
163 struct pipe_driver_query_info
*info
)
165 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
167 return screen
->get_driver_query_info(screen
, index
, info
);
171 dd_screen_get_driver_query_group_info(struct pipe_screen
*_screen
,
173 struct pipe_driver_query_group_info
*info
)
175 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
177 return screen
->get_driver_query_group_info(screen
, index
, info
);
181 /********************************************************************
185 static struct pipe_resource
*
186 dd_screen_resource_create(struct pipe_screen
*_screen
,
187 const struct pipe_resource
*templat
)
189 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
190 struct pipe_resource
*res
= screen
->resource_create(screen
, templat
);
194 res
->screen
= _screen
;
198 static struct pipe_resource
*
199 dd_screen_resource_from_handle(struct pipe_screen
*_screen
,
200 const struct pipe_resource
*templ
,
201 struct winsys_handle
*handle
,
204 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
205 struct pipe_resource
*res
=
206 screen
->resource_from_handle(screen
, templ
, handle
, usage
);
210 res
->screen
= _screen
;
214 static struct pipe_resource
*
215 dd_screen_resource_from_user_memory(struct pipe_screen
*_screen
,
216 const struct pipe_resource
*templ
,
219 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
220 struct pipe_resource
*res
=
221 screen
->resource_from_user_memory(screen
, templ
, user_memory
);
225 res
->screen
= _screen
;
230 dd_screen_resource_destroy(struct pipe_screen
*_screen
,
231 struct pipe_resource
*res
)
233 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
235 screen
->resource_destroy(screen
, res
);
239 dd_screen_resource_get_handle(struct pipe_screen
*_screen
,
240 struct pipe_context
*_pipe
,
241 struct pipe_resource
*resource
,
242 struct winsys_handle
*handle
,
245 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
246 struct pipe_context
*pipe
= _pipe
? dd_context(_pipe
)->pipe
: NULL
;
248 return screen
->resource_get_handle(screen
, pipe
, resource
, handle
, usage
);
252 /********************************************************************
257 dd_screen_fence_reference(struct pipe_screen
*_screen
,
258 struct pipe_fence_handle
**pdst
,
259 struct pipe_fence_handle
*src
)
261 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
263 screen
->fence_reference(screen
, pdst
, src
);
267 dd_screen_fence_finish(struct pipe_screen
*_screen
,
268 struct pipe_context
*_ctx
,
269 struct pipe_fence_handle
*fence
,
272 struct pipe_screen
*screen
= dd_screen(_screen
)->screen
;
273 struct pipe_context
*ctx
= _ctx
? dd_context(_ctx
)->pipe
: NULL
;
275 return screen
->fence_finish(screen
, ctx
, fence
, timeout
);
279 /********************************************************************
284 dd_screen_destroy(struct pipe_screen
*_screen
)
286 struct dd_screen
*dscreen
= dd_screen(_screen
);
287 struct pipe_screen
*screen
= dscreen
->screen
;
289 screen
->destroy(screen
);
294 ddebug_screen_create(struct pipe_screen
*screen
)
296 struct dd_screen
*dscreen
;
299 unsigned timeout
= 0;
300 unsigned apitrace_dump_call
= 0;
303 option
= debug_get_option("GALLIUM_DDEBUG", NULL
);
307 if (!strcmp(option
, "help")) {
308 puts("Gallium driver debugger");
312 puts(" GALLIUM_DDEBUG=\"always [noflush] [verbose]\"");
313 puts(" Flush and dump context and driver information after every draw call into");
314 puts(" $HOME/"DD_DIR
"/.");
316 puts(" GALLIUM_DDEBUG=\"[timeout in ms] [noflush] [verbose]\"");
317 puts(" Flush and detect a device hang after every draw call based on the given");
318 puts(" fence timeout and dump context and driver information into");
319 puts(" $HOME/"DD_DIR
"/ when a hang is detected.");
321 puts(" GALLIUM_DDEBUG=\"pipelined [timeout in ms] [verbose]\"");
322 puts(" Detect a device hang after every draw call based on the given fence");
323 puts(" timeout without flushes and dump context and driver information into");
324 puts(" $HOME/"DD_DIR
"/ when a hang is detected.");
326 puts(" GALLIUM_DDEBUG=\"apitrace [call#] [verbose]\"");
327 puts(" Dump apitrace draw call information into $HOME/"DD_DIR
"/. Implies 'noflush'.");
329 puts(" If 'noflush' is specified, do not flush on every draw call. In hang");
330 puts(" detection mode, this only detect hangs in pipe->flush.");
331 puts(" If 'verbose' is specified, additional information is written to stderr.");
333 puts(" GALLIUM_DDEBUG_SKIP=[count]");
334 puts(" Skip flush and hang detection for the given initial number of draw calls.");
339 no_flush
= strstr(option
, "noflush") != NULL
;
341 if (!strncmp(option
, "always", 6)) {
342 mode
= DD_DUMP_ALL_CALLS
;
343 } else if (!strncmp(option
, "apitrace", 8)) {
344 mode
= DD_DUMP_APITRACE_CALL
;
347 if (sscanf(option
+8, "%u", &apitrace_dump_call
) != 1)
349 } else if (!strncmp(option
, "pipelined", 8)) {
350 mode
= DD_DETECT_HANGS_PIPELINED
;
352 if (sscanf(option
+10, "%u", &timeout
) != 1)
355 mode
= DD_DETECT_HANGS
;
357 if (sscanf(option
, "%u", &timeout
) != 1)
361 dscreen
= CALLOC_STRUCT(dd_screen
);
365 #define SCR_INIT(_member) \
366 dscreen->base._member = screen->_member ? dd_screen_##_member : NULL
368 dscreen
->base
.destroy
= dd_screen_destroy
;
369 dscreen
->base
.get_name
= dd_screen_get_name
;
370 dscreen
->base
.get_vendor
= dd_screen_get_vendor
;
371 dscreen
->base
.get_device_vendor
= dd_screen_get_device_vendor
;
372 dscreen
->base
.get_param
= dd_screen_get_param
;
373 dscreen
->base
.get_paramf
= dd_screen_get_paramf
;
374 dscreen
->base
.get_compute_param
= dd_screen_get_compute_param
;
375 dscreen
->base
.get_shader_param
= dd_screen_get_shader_param
;
376 dscreen
->base
.query_memory_info
= dd_screen_query_memory_info
;
377 /* get_video_param */
378 /* get_compute_param */
379 SCR_INIT(get_timestamp
);
380 dscreen
->base
.context_create
= dd_screen_context_create
;
381 dscreen
->base
.is_format_supported
= dd_screen_is_format_supported
;
382 /* is_video_format_supported */
383 SCR_INIT(can_create_resource
);
384 dscreen
->base
.resource_create
= dd_screen_resource_create
;
385 dscreen
->base
.resource_from_handle
= dd_screen_resource_from_handle
;
386 SCR_INIT(resource_from_user_memory
);
387 dscreen
->base
.resource_get_handle
= dd_screen_resource_get_handle
;
388 dscreen
->base
.resource_destroy
= dd_screen_resource_destroy
;
389 SCR_INIT(flush_frontbuffer
);
390 SCR_INIT(fence_reference
);
391 SCR_INIT(fence_finish
);
392 SCR_INIT(get_driver_query_info
);
393 SCR_INIT(get_driver_query_group_info
);
397 dscreen
->screen
= screen
;
398 dscreen
->timeout_ms
= timeout
;
399 dscreen
->mode
= mode
;
400 dscreen
->no_flush
= no_flush
;
401 dscreen
->verbose
= strstr(option
, "verbose") != NULL
;
402 dscreen
->apitrace_dump_call
= apitrace_dump_call
;
404 switch (dscreen
->mode
) {
405 case DD_DUMP_ALL_CALLS
:
406 fprintf(stderr
, "Gallium debugger active. Logging all calls.\n");
408 case DD_DETECT_HANGS
:
409 case DD_DETECT_HANGS_PIPELINED
:
410 fprintf(stderr
, "Gallium debugger active. "
411 "The hang detection timeout is %i ms.\n", timeout
);
413 case DD_DUMP_APITRACE_CALL
:
414 fprintf(stderr
, "Gallium debugger active. Going to dump an apitrace call.\n");
420 dscreen
->skip_count
= debug_get_num_option("GALLIUM_DDEBUG_SKIP", 0);
421 if (dscreen
->skip_count
> 0) {
422 fprintf(stderr
, "Gallium debugger skipping the first %u draw calls.\n",
423 dscreen
->skip_count
);
426 return &dscreen
->base
;