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 {
 184    struct pipe_screen *screen = dd_screen(_screen)->screen;
 185    struct pipe_resource *res =
 186       screen->resource_from_handle(screen, templ, handle);
 187
 188    if (!res)
 189       return NULL;
 190    res->screen = _screen;
 191    return res;
 192 }
 193
 194 static struct pipe_resource *
 195 dd_screen_resource_from_user_memory(struct pipe_screen *_screen,
 196                                     const struct pipe_resource *templ,
 197                                     void *user_memory)
 198 {
 199    struct pipe_screen *screen = dd_screen(_screen)->screen;
 200    struct pipe_resource *res =
 201       screen->resource_from_user_memory(screen, templ, user_memory);
 202
 203    if (!res)
 204       return NULL;
 205    res->screen = _screen;
 206    return res;
 207 }
 208
 209 static void
 210 dd_screen_resource_destroy(struct pipe_screen *_screen,
 211                            struct pipe_resource *res)
 212 {
 213    struct pipe_screen *screen = dd_screen(_screen)->screen;
 214
 215    screen->resource_destroy(screen, res);
 216 }
 217
 218 static boolean
 219 dd_screen_resource_get_handle(struct pipe_screen *_screen,
 220                               struct pipe_resource *resource,
 221                               struct winsys_handle *handle)
 222 {
 223    struct pipe_screen *screen = dd_screen(_screen)->screen;
 224
 225    return screen->resource_get_handle(screen, resource, handle);
 226 }
 227
 228
 229 /********************************************************************
 230  * fence
 231  */
 232
 233 static void
 234 dd_screen_fence_reference(struct pipe_screen *_screen,
 235                           struct pipe_fence_handle **pdst,
 236                           struct pipe_fence_handle *src)
 237 {
 238    struct pipe_screen *screen = dd_screen(_screen)->screen;
 239
 240    screen->fence_reference(screen, pdst, src);
 241 }
 242
 243 static boolean
 244 dd_screen_fence_finish(struct pipe_screen *_screen,
 245                        struct pipe_fence_handle *fence,
 246                        uint64_t timeout)
 247 {
 248    struct pipe_screen *screen = dd_screen(_screen)->screen;
 249
 250    return screen->fence_finish(screen, fence, timeout);
 251 }
 252
 253
 254 /********************************************************************
 255  * screen
 256  */
 257
 258 static void
 259 dd_screen_destroy(struct pipe_screen *_screen)
 260 {
 261    struct dd_screen *dscreen = dd_screen(_screen);
 262    struct pipe_screen *screen = dscreen->screen;
 263
 264    screen->destroy(screen);
 265    FREE(dscreen);
 266 }
 267
 268 struct pipe_screen *
 269 ddebug_screen_create(struct pipe_screen *screen)
 270 {
 271    struct dd_screen *dscreen;
 272    const char *option = debug_get_option("GALLIUM_DDEBUG", NULL);
 273    bool dump_always = option && !strcmp(option, "always");
 274    bool no_flush = option && strstr(option, "noflush");
 275    bool help = option && !strcmp(option, "help");
 276    unsigned timeout = 0;
 277
 278    if (help) {
 279       puts("Gallium driver debugger");
 280       puts("");
 281       puts("Usage:");
 282       puts("");
 283       puts("  GALLIUM_DDEBUG=always");
 284       puts("    Dump context and driver information after every draw call into");
 285       puts("    $HOME/"DD_DIR"/.");
 286       puts("");
 287       puts("  GALLIUM_DDEBUG=[timeout in ms] noflush");
 288       puts("    Flush and detect a device hang after every draw call based on the given");
 289       puts("    fence timeout and dump context and driver information into");
 290       puts("    $HOME/"DD_DIR"/ when a hang is detected.");
 291       puts("    If 'noflush' is specified, only detect hangs in pipe->flush.");
 292       puts("");
 293       puts("  GALLIUM_DDEBUG_SKIP=[count]");
 294       puts("    Skip flush and hang detection for the given initial number of draw calls.");
 295       puts("");
 296       exit(0);
 297    }
 298
 299    if (!option)
 300       return screen;
 301    if (!dump_always && sscanf(option, "%u", &timeout) != 1)
 302       return screen;
 303
 304    dscreen = CALLOC_STRUCT(dd_screen);
 305    if (!dscreen)
 306       return NULL;
 307
 308 #define SCR_INIT(_member) \
 309    dscreen->base._member = screen->_member ? dd_screen_##_member : NULL
 310
 311    dscreen->base.destroy = dd_screen_destroy;
 312    dscreen->base.get_name = dd_screen_get_name;
 313    dscreen->base.get_vendor = dd_screen_get_vendor;
 314    dscreen->base.get_device_vendor = dd_screen_get_device_vendor;
 315    dscreen->base.get_param = dd_screen_get_param;
 316    dscreen->base.get_paramf = dd_screen_get_paramf;
 317    dscreen->base.get_shader_param = dd_screen_get_shader_param;
 318    /* get_video_param */
 319    /* get_compute_param */
 320    SCR_INIT(get_timestamp);
 321    dscreen->base.context_create = dd_screen_context_create;
 322    dscreen->base.is_format_supported = dd_screen_is_format_supported;
 323    /* is_video_format_supported */
 324    SCR_INIT(can_create_resource);
 325    dscreen->base.resource_create = dd_screen_resource_create;
 326    dscreen->base.resource_from_handle = dd_screen_resource_from_handle;
 327    SCR_INIT(resource_from_user_memory);
 328    dscreen->base.resource_get_handle = dd_screen_resource_get_handle;
 329    dscreen->base.resource_destroy = dd_screen_resource_destroy;
 330    SCR_INIT(flush_frontbuffer);
 331    SCR_INIT(fence_reference);
 332    SCR_INIT(fence_finish);
 333    SCR_INIT(get_driver_query_info);
 334    SCR_INIT(get_driver_query_group_info);
 335
 336 #undef SCR_INIT
 337
 338    dscreen->screen = screen;
 339    dscreen->timeout_ms = timeout;
 340    dscreen->mode = dump_always ? DD_DUMP_ALL_CALLS : DD_DETECT_HANGS;
 341    dscreen->no_flush = no_flush;
 342
 343    switch (dscreen->mode) {
 344    case DD_DUMP_ALL_CALLS:
 345       fprintf(stderr, "Gallium debugger active. Logging all calls.\n");
 346       break;
 347    case DD_DETECT_HANGS:
 348       fprintf(stderr, "Gallium debugger active. "
 349               "The hang detection timout is %i ms.\n", timeout);
 350       break;
 351    default:
 352       assert(0);
 353    }
 354
 355    dscreen->skip_count = debug_get_num_option("GALLIUM_DDEBUG_SKIP", 0);
 356    if (dscreen->skip_count > 0) {
 357       fprintf(stderr, "Gallium debugger skipping the first %u draw calls.\n",
 358               dscreen->skip_count);
 359    }
 360
 361    return &dscreen->base;
 362 }