src/gallium/drivers/ddebug/dd_screen.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2015 Advanced Micro Devices, Inc.
   4  * Copyright 2008 VMware, Inc.
   5  * All Rights Reserved.
   6  *
   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:
  13  *
  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
  16  * Software.
  17  *
  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.
  25  *
  26  **************************************************************************/
  27
  28 #include "dd_pipe.h"
  29 #include "dd_public.h"
  30 #include "util/u_memory.h"
  31 #include <stdio.h>
  32
  33
  34 static const char *
  35 dd_screen_get_name(struct pipe_screen *_screen)
  36 {
  37    struct pipe_screen *screen = dd_screen(_screen)->screen;
  38
  39    return screen->get_name(screen);
  40 }
  41
  42 static const char *
  43 dd_screen_get_vendor(struct pipe_screen *_screen)
  44 {
  45    struct pipe_screen *screen = dd_screen(_screen)->screen;
  46
  47    return screen->get_vendor(screen);
  48 }
  49
  50 static const char *
  51 dd_screen_get_device_vendor(struct pipe_screen *_screen)
  52 {
  53    struct pipe_screen *screen = dd_screen(_screen)->screen;
  54
  55    return screen->get_device_vendor(screen);
  56 }
  57
  58 static int
  59 dd_screen_get_param(struct pipe_screen *_screen,
  60                     enum pipe_cap param)
  61 {
  62    struct pipe_screen *screen = dd_screen(_screen)->screen;
  63
  64    return screen->get_param(screen, param);
  65 }
  66
  67 static float
  68 dd_screen_get_paramf(struct pipe_screen *_screen,
  69                      enum pipe_capf param)
  70 {
  71    struct pipe_screen *screen = dd_screen(_screen)->screen;
  72
  73    return screen->get_paramf(screen, param);
  74 }
  75
  76 static int
  77 dd_screen_get_shader_param(struct pipe_screen *_screen, unsigned shader,
  78                            enum pipe_shader_cap param)
  79 {
  80    struct pipe_screen *screen = dd_screen(_screen)->screen;
  81
  82    return screen->get_shader_param(screen, shader, param);
  83 }
  84
  85 static uint64_t
  86 dd_screen_get_timestamp(struct pipe_screen *_screen)
  87 {
  88    struct pipe_screen *screen = dd_screen(_screen)->screen;
  89
  90    return screen->get_timestamp(screen);
  91 }
  92
  93 static struct pipe_context *
  94 dd_screen_context_create(struct pipe_screen *_screen, void *priv,
  95                          unsigned flags)
  96 {
  97    struct dd_screen *dscreen = dd_screen(_screen);
  98    struct pipe_screen *screen = dscreen->screen;
  99
 100    flags |= PIPE_CONTEXT_DEBUG;
 101
 102    return dd_context_create(dscreen,
 103                             screen->context_create(screen, priv, flags));
 104 }
 105
 106 static boolean
 107 dd_screen_is_format_supported(struct pipe_screen *_screen,
 108                               enum pipe_format format,
 109                               enum pipe_texture_target target,
 110                               unsigned sample_count,
 111                               unsigned tex_usage)
 112 {
 113    struct pipe_screen *screen = dd_screen(_screen)->screen;
 114
 115    return screen->is_format_supported(screen, format, target, sample_count,
 116                                       tex_usage);
 117 }
 118
 119 static boolean
 120 dd_screen_can_create_resource(struct pipe_screen *_screen,
 121                               const struct pipe_resource *templat)
 122 {
 123    struct pipe_screen *screen = dd_screen(_screen)->screen;
 124
 125    return screen->can_create_resource(screen, templat);
 126 }
 127
 128 static void
 129 dd_screen_flush_frontbuffer(struct pipe_screen *_screen,
 130                             struct pipe_resource *resource,
 131                             unsigned level, unsigned layer,
 132                             void *context_private,
 133                             struct pipe_box *sub_box)
 134 {
 135    struct pipe_screen *screen = dd_screen(_screen)->screen;
 136
 137    screen->flush_frontbuffer(screen, resource, level, layer, context_private,
 138                              sub_box);
 139 }
 140
 141 static int
 142 dd_screen_get_driver_query_info(struct pipe_screen *_screen,
 143                                 unsigned index,
 144                                 struct pipe_driver_query_info *info)
 145 {
 146    struct pipe_screen *screen = dd_screen(_screen)->screen;
 147
 148    return screen->get_driver_query_info(screen, index, info);
 149 }
 150
 151 static int
 152 dd_screen_get_driver_query_group_info(struct pipe_screen *_screen,
 153                                       unsigned index,
 154                                       struct pipe_driver_query_group_info *info)
 155 {
 156    struct pipe_screen *screen = dd_screen(_screen)->screen;
 157
 158    return screen->get_driver_query_group_info(screen, index, info);
 159 }
 160
 161
 162 /********************************************************************
 163  * resource
 164  */
 165
 166 static struct pipe_resource *
 167 dd_screen_resource_create(struct pipe_screen *_screen,
 168                           const struct pipe_resource *templat)
 169 {
 170    struct pipe_screen *screen = dd_screen(_screen)->screen;
 171    struct pipe_resource *res = screen->resource_create(screen, templat);
 172
 173    if (!res)
 174       return NULL;
 175    res->screen = _screen;
 176    return res;
 177 }
 178
 179 static struct pipe_resource *
 180 dd_screen_resource_from_handle(struct pipe_screen *_screen,
 181                                const struct pipe_resource *templ,
 182                                struct winsys_handle *handle,
 183                                unsigned usage)
 184 {
 185    struct pipe_screen *screen = dd_screen(_screen)->screen;
 186    struct pipe_resource *res =
 187       screen->resource_from_handle(screen, templ, handle, usage);
 188
 189    if (!res)
 190       return NULL;
 191    res->screen = _screen;
 192    return res;
 193 }
 194
 195 static struct pipe_resource *
 196 dd_screen_resource_from_user_memory(struct pipe_screen *_screen,
 197                                     const struct pipe_resource *templ,
 198                                     void *user_memory)
 199 {
 200    struct pipe_screen *screen = dd_screen(_screen)->screen;
 201    struct pipe_resource *res =
 202       screen->resource_from_user_memory(screen, templ, user_memory);
 203
 204    if (!res)
 205       return NULL;
 206    res->screen = _screen;
 207    return res;
 208 }
 209
 210 static void
 211 dd_screen_resource_destroy(struct pipe_screen *_screen,
 212                            struct pipe_resource *res)
 213 {
 214    struct pipe_screen *screen = dd_screen(_screen)->screen;
 215
 216    screen->resource_destroy(screen, res);
 217 }
 218
 219 static boolean
 220 dd_screen_resource_get_handle(struct pipe_screen *_screen,
 221                               struct pipe_resource *resource,
 222                               struct winsys_handle *handle,
 223                               unsigned usage)
 224 {
 225    struct pipe_screen *screen = dd_screen(_screen)->screen;
 226
 227    return screen->resource_get_handle(screen, resource, handle, usage);
 228 }
 229
 230
 231 /********************************************************************
 232  * fence
 233  */
 234
 235 static void
 236 dd_screen_fence_reference(struct pipe_screen *_screen,
 237                           struct pipe_fence_handle **pdst,
 238                           struct pipe_fence_handle *src)
 239 {
 240    struct pipe_screen *screen = dd_screen(_screen)->screen;
 241
 242    screen->fence_reference(screen, pdst, src);
 243 }
 244
 245 static boolean
 246 dd_screen_fence_finish(struct pipe_screen *_screen,
 247                        struct pipe_fence_handle *fence,
 248                        uint64_t timeout)
 249 {
 250    struct pipe_screen *screen = dd_screen(_screen)->screen;
 251
 252    return screen->fence_finish(screen, fence, timeout);
 253 }
 254
 255
 256 /********************************************************************
 257  * screen
 258  */
 259
 260 static void
 261 dd_screen_destroy(struct pipe_screen *_screen)
 262 {
 263    struct dd_screen *dscreen = dd_screen(_screen);
 264    struct pipe_screen *screen = dscreen->screen;
 265
 266    screen->destroy(screen);
 267    FREE(dscreen);
 268 }
 269
 270 struct pipe_screen *
 271 ddebug_screen_create(struct pipe_screen *screen)
 272 {
 273    struct dd_screen *dscreen;
 274    const char *option = debug_get_option("GALLIUM_DDEBUG", NULL);
 275    bool dump_always = option && !strncmp(option, "always", 6);
 276    bool no_flush = option && strstr(option, "noflush");
 277    bool help = option && !strcmp(option, "help");
 278    unsigned timeout = 0;
 279
 280    if (help) {
 281       puts("Gallium driver debugger");
 282       puts("");
 283       puts("Usage:");
 284       puts("");
 285       puts("  GALLIUM_DDEBUG=\"always [noflush] [verbose]\"");
 286       puts("    Flush and dump context and driver information after every draw call into");
 287       puts("    $HOME/"DD_DIR"/.");
 288       puts("");
 289       puts("  GALLIUM_DDEBUG=\"[timeout in ms] [noflush] [verbose]\"");
 290       puts("    Flush and detect a device hang after every draw call based on the given");
 291       puts("    fence timeout and dump context and driver information into");
 292       puts("    $HOME/"DD_DIR"/ when a hang is detected.");
 293       puts("");
 294       puts("  If 'noflush' is specified, do not flush on every draw call. In hang");
 295       puts("  detection mode, this only detect hangs in pipe->flush.");
 296       puts("  If 'verbose' is specified, additional information is written to stderr.");
 297       puts("");
 298       puts("  GALLIUM_DDEBUG_SKIP=[count]");
 299       puts("    Skip flush and hang detection for the given initial number of draw calls.");
 300       puts("");
 301       exit(0);
 302    }
 303
 304    if (!option)
 305       return screen;
 306    if (!dump_always && sscanf(option, "%u", &timeout) != 1)
 307       return screen;
 308
 309    dscreen = CALLOC_STRUCT(dd_screen);
 310    if (!dscreen)
 311       return NULL;
 312
 313 #define SCR_INIT(_member) \
 314    dscreen->base._member = screen->_member ? dd_screen_##_member : NULL
 315
 316    dscreen->base.destroy = dd_screen_destroy;
 317    dscreen->base.get_name = dd_screen_get_name;
 318    dscreen->base.get_vendor = dd_screen_get_vendor;
 319    dscreen->base.get_device_vendor = dd_screen_get_device_vendor;
 320    dscreen->base.get_param = dd_screen_get_param;
 321    dscreen->base.get_paramf = dd_screen_get_paramf;
 322    dscreen->base.get_shader_param = dd_screen_get_shader_param;
 323    /* get_video_param */
 324    /* get_compute_param */
 325    SCR_INIT(get_timestamp);
 326    dscreen->base.context_create = dd_screen_context_create;
 327    dscreen->base.is_format_supported = dd_screen_is_format_supported;
 328    /* is_video_format_supported */
 329    SCR_INIT(can_create_resource);
 330    dscreen->base.resource_create = dd_screen_resource_create;
 331    dscreen->base.resource_from_handle = dd_screen_resource_from_handle;
 332    SCR_INIT(resource_from_user_memory);
 333    dscreen->base.resource_get_handle = dd_screen_resource_get_handle;
 334    dscreen->base.resource_destroy = dd_screen_resource_destroy;
 335    SCR_INIT(flush_frontbuffer);
 336    SCR_INIT(fence_reference);
 337    SCR_INIT(fence_finish);
 338    SCR_INIT(get_driver_query_info);
 339    SCR_INIT(get_driver_query_group_info);
 340
 341 #undef SCR_INIT
 342
 343    dscreen->screen = screen;
 344    dscreen->timeout_ms = timeout;
 345    dscreen->mode = dump_always ? DD_DUMP_ALL_CALLS : DD_DETECT_HANGS;
 346    dscreen->no_flush = no_flush;
 347    dscreen->verbose = strstr(option, "verbose") != NULL;
 348
 349    switch (dscreen->mode) {
 350    case DD_DUMP_ALL_CALLS:
 351       fprintf(stderr, "Gallium debugger active. Logging all calls.\n");
 352       break;
 353    case DD_DETECT_HANGS:
 354       fprintf(stderr, "Gallium debugger active. "
 355               "The hang detection timout is %i ms.\n", timeout);
 356       break;
 357    default:
 358       assert(0);
 359    }
 360
 361    dscreen->skip_count = debug_get_num_option("GALLIUM_DDEBUG_SKIP", 0);
 362    if (dscreen->skip_count > 0) {
 363       fprintf(stderr, "Gallium debugger skipping the first %u draw calls.\n",
 364               dscreen->skip_count);
 365    }
 366
 367    return &dscreen->base;
 368 }