src/gallium/drivers/trace/tr_screen.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "util/u_format.h"
  29 #include "util/u_memory.h"
  30 #include "util/simple_list.h"
  31
  32 #include "tr_dump.h"
  33 #include "tr_dump_defines.h"
  34 #include "tr_dump_state.h"
  35 #include "tr_texture.h"
  36 #include "tr_context.h"
  37 #include "tr_screen.h"
  38 #include "tr_public.h"
  39
  40
  41 static boolean trace = FALSE;
  42
  43 static const char *
  44 trace_screen_get_name(struct pipe_screen *_screen)
  45 {
  46    struct trace_screen *tr_scr = trace_screen(_screen);
  47    struct pipe_screen *screen = tr_scr->screen;
  48    const char *result;
  49
  50    trace_dump_call_begin("pipe_screen", "get_name");
  51
  52    trace_dump_arg(ptr, screen);
  53
  54    result = screen->get_name(screen);
  55
  56    trace_dump_ret(string, result);
  57
  58    trace_dump_call_end();
  59
  60    return result;
  61 }
  62
  63
  64 static const char *
  65 trace_screen_get_vendor(struct pipe_screen *_screen)
  66 {
  67    struct trace_screen *tr_scr = trace_screen(_screen);
  68    struct pipe_screen *screen = tr_scr->screen;
  69    const char *result;
  70
  71    trace_dump_call_begin("pipe_screen", "get_vendor");
  72
  73    trace_dump_arg(ptr, screen);
  74
  75    result = screen->get_vendor(screen);
  76
  77    trace_dump_ret(string, result);
  78
  79    trace_dump_call_end();
  80
  81    return result;
  82 }
  83
  84
  85 static const char *
  86 trace_screen_get_device_vendor(struct pipe_screen *_screen)
  87 {
  88    struct trace_screen *tr_scr = trace_screen(_screen);
  89    struct pipe_screen *screen = tr_scr->screen;
  90    const char *result;
  91
  92    trace_dump_call_begin("pipe_screen", "get_device_vendor");
  93
  94    trace_dump_arg(ptr, screen);
  95
  96    result = screen->get_device_vendor(screen);
  97
  98    trace_dump_ret(string, result);
  99
 100    trace_dump_call_end();
 101
 102    return result;
 103 }
 104
 105
 106 static struct disk_cache *
 107 trace_screen_get_disk_shader_cache(struct pipe_screen *_screen)
 108 {
 109    struct trace_screen *tr_scr = trace_screen(_screen);
 110    struct pipe_screen *screen = tr_scr->screen;
 111
 112    trace_dump_call_begin("pipe_screen", "get_disk_shader_cache");
 113
 114    trace_dump_arg(ptr, screen);
 115
 116    struct disk_cache *result = screen->get_disk_shader_cache(screen);
 117
 118    trace_dump_ret(ptr, result);
 119
 120    trace_dump_call_end();
 121
 122    return result;
 123 }
 124
 125
 126 static int
 127 trace_screen_get_param(struct pipe_screen *_screen,
 128                        enum pipe_cap param)
 129 {
 130    struct trace_screen *tr_scr = trace_screen(_screen);
 131    struct pipe_screen *screen = tr_scr->screen;
 132    int result;
 133
 134    trace_dump_call_begin("pipe_screen", "get_param");
 135
 136    trace_dump_arg(ptr, screen);
 137    trace_dump_arg(int, param);
 138
 139    result = screen->get_param(screen, param);
 140
 141    trace_dump_ret(int, result);
 142
 143    trace_dump_call_end();
 144
 145    return result;
 146 }
 147
 148
 149 static int
 150 trace_screen_get_shader_param(struct pipe_screen *_screen,
 151                               enum pipe_shader_type shader,
 152                               enum pipe_shader_cap param)
 153 {
 154    struct trace_screen *tr_scr = trace_screen(_screen);
 155    struct pipe_screen *screen = tr_scr->screen;
 156    int result;
 157
 158    trace_dump_call_begin("pipe_screen", "get_shader_param");
 159
 160    trace_dump_arg(ptr, screen);
 161    trace_dump_arg(uint, shader);
 162    trace_dump_arg(int, param);
 163
 164    result = screen->get_shader_param(screen, shader, param);
 165
 166    trace_dump_ret(int, result);
 167
 168    trace_dump_call_end();
 169
 170    return result;
 171 }
 172
 173
 174 static float
 175 trace_screen_get_paramf(struct pipe_screen *_screen,
 176                         enum pipe_capf param)
 177 {
 178    struct trace_screen *tr_scr = trace_screen(_screen);
 179    struct pipe_screen *screen = tr_scr->screen;
 180    float result;
 181
 182    trace_dump_call_begin("pipe_screen", "get_paramf");
 183
 184    trace_dump_arg(ptr, screen);
 185    trace_dump_arg(int, param);
 186
 187    result = screen->get_paramf(screen, param);
 188
 189    trace_dump_ret(float, result);
 190
 191    trace_dump_call_end();
 192
 193    return result;
 194 }
 195
 196
 197 static int
 198 trace_screen_get_compute_param(struct pipe_screen *_screen,
 199                                enum pipe_shader_ir ir_type,
 200                                enum pipe_compute_cap param, void *data)
 201 {
 202    struct trace_screen *tr_scr = trace_screen(_screen);
 203    struct pipe_screen *screen = tr_scr->screen;
 204    int result;
 205
 206    trace_dump_call_begin("pipe_screen", "get_compute_param");
 207
 208    trace_dump_arg(ptr, screen);
 209    trace_dump_arg(int, ir_type);
 210    trace_dump_arg(int, param);
 211    trace_dump_arg(ptr, data);
 212
 213    result = screen->get_compute_param(screen, ir_type, param, data);
 214
 215    trace_dump_ret(int, result);
 216
 217    trace_dump_call_end();
 218
 219    return result;
 220 }
 221
 222
 223 static boolean
 224 trace_screen_is_format_supported(struct pipe_screen *_screen,
 225                                  enum pipe_format format,
 226                                  enum pipe_texture_target target,
 227                                  unsigned sample_count,
 228                                  unsigned tex_usage)
 229 {
 230    struct trace_screen *tr_scr = trace_screen(_screen);
 231    struct pipe_screen *screen = tr_scr->screen;
 232    boolean result;
 233
 234    trace_dump_call_begin("pipe_screen", "is_format_supported");
 235
 236    trace_dump_arg(ptr, screen);
 237    trace_dump_arg(format, format);
 238    trace_dump_arg(int, target);
 239    trace_dump_arg(uint, sample_count);
 240    trace_dump_arg(uint, tex_usage);
 241
 242    result = screen->is_format_supported(screen, format, target, sample_count,
 243                                         tex_usage);
 244
 245    trace_dump_ret(bool, result);
 246
 247    trace_dump_call_end();
 248
 249    return result;
 250 }
 251
 252
 253 static struct pipe_context *
 254 trace_screen_context_create(struct pipe_screen *_screen, void *priv,
 255                             unsigned flags)
 256 {
 257    struct trace_screen *tr_scr = trace_screen(_screen);
 258    struct pipe_screen *screen = tr_scr->screen;
 259    struct pipe_context *result;
 260
 261    trace_dump_call_begin("pipe_screen", "context_create");
 262
 263    trace_dump_arg(ptr, screen);
 264    trace_dump_arg(ptr, priv);
 265    trace_dump_arg(uint, flags);
 266
 267    result = screen->context_create(screen, priv, flags);
 268
 269    trace_dump_ret(ptr, result);
 270
 271    trace_dump_call_end();
 272
 273    result = trace_context_create(tr_scr, result);
 274
 275    return result;
 276 }
 277
 278
 279 static void
 280 trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
 281                                struct pipe_resource *resource,
 282                                unsigned level, unsigned layer,
 283                                void *context_private,
 284                                struct pipe_box *sub_box)
 285 {
 286    struct trace_screen *tr_scr = trace_screen(_screen);
 287    struct pipe_screen *screen = tr_scr->screen;
 288
 289    trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
 290
 291    trace_dump_arg(ptr, screen);
 292    trace_dump_arg(ptr, resource);
 293    trace_dump_arg(uint, level);
 294    trace_dump_arg(uint, layer);
 295    /* XXX: hide, as there is nothing we can do with this
 296    trace_dump_arg(ptr, context_private);
 297    */
 298
 299    screen->flush_frontbuffer(screen, resource, level, layer, context_private, sub_box);
 300
 301    trace_dump_call_end();
 302 }
 303
 304
 305 /********************************************************************
 306  * texture
 307  */
 308
 309
 310 static struct pipe_resource *
 311 trace_screen_resource_create(struct pipe_screen *_screen,
 312                             const struct pipe_resource *templat)
 313 {
 314    struct trace_screen *tr_scr = trace_screen(_screen);
 315    struct pipe_screen *screen = tr_scr->screen;
 316    struct pipe_resource *result;
 317
 318    trace_dump_call_begin("pipe_screen", "resource_create");
 319
 320    trace_dump_arg(ptr, screen);
 321    trace_dump_arg(resource_template, templat);
 322
 323    result = screen->resource_create(screen, templat);
 324
 325    trace_dump_ret(ptr, result);
 326
 327    trace_dump_call_end();
 328
 329    if (result)
 330       result->screen = _screen;
 331    return result;
 332 }
 333
 334 static struct pipe_resource *
 335 trace_screen_resource_from_handle(struct pipe_screen *_screen,
 336                                  const struct pipe_resource *templ,
 337                                  struct winsys_handle *handle,
 338                                   unsigned usage)
 339 {
 340    struct trace_screen *tr_screen = trace_screen(_screen);
 341    struct pipe_screen *screen = tr_screen->screen;
 342    struct pipe_resource *result;
 343
 344    /* TODO trace call */
 345
 346    result = screen->resource_from_handle(screen, templ, handle, usage);
 347
 348    if (result)
 349       result->screen = _screen;
 350    return result;
 351 }
 352
 353 static boolean
 354 trace_screen_resource_get_handle(struct pipe_screen *_screen,
 355                                  struct pipe_context *_pipe,
 356                                 struct pipe_resource *resource,
 357                                 struct winsys_handle *handle,
 358                                  unsigned usage)
 359 {
 360    struct trace_screen *tr_screen = trace_screen(_screen);
 361    struct trace_context *tr_pipe = _pipe ? trace_context(_pipe) : NULL;
 362    struct pipe_screen *screen = tr_screen->screen;
 363
 364    /* TODO trace call */
 365
 366    return screen->resource_get_handle(screen, tr_pipe ? tr_pipe->pipe : NULL,
 367                                       resource, handle, usage);
 368 }
 369
 370 static void
 371 trace_screen_resource_changed(struct pipe_screen *_screen,
 372                               struct pipe_resource *resource)
 373 {
 374    struct trace_screen *tr_scr = trace_screen(_screen);
 375    struct pipe_screen *screen = tr_scr->screen;
 376
 377    trace_dump_call_begin("pipe_screen", "resource_changed");
 378
 379    trace_dump_arg(ptr, screen);
 380    trace_dump_arg(ptr, resource);
 381
 382    screen->resource_changed(screen, resource);
 383
 384    trace_dump_call_end();
 385 }
 386
 387 static void
 388 trace_screen_resource_destroy(struct pipe_screen *_screen,
 389                               struct pipe_resource *resource)
 390 {
 391    struct trace_screen *tr_scr = trace_screen(_screen);
 392    struct pipe_screen *screen = tr_scr->screen;
 393
 394    /* Don't trace this, because due to the lack of pipe_resource wrapping,
 395     * we can get this call from inside of driver calls, which would try
 396     * to lock an already-locked mutex.
 397     */
 398    screen->resource_destroy(screen, resource);
 399 }
 400
 401
 402 /********************************************************************
 403  * fence
 404  */
 405
 406
 407 static void
 408 trace_screen_fence_reference(struct pipe_screen *_screen,
 409                              struct pipe_fence_handle **pdst,
 410                              struct pipe_fence_handle *src)
 411 {
 412    struct trace_screen *tr_scr = trace_screen(_screen);
 413    struct pipe_screen *screen = tr_scr->screen;
 414    struct pipe_fence_handle *dst;
 415
 416    assert(pdst);
 417    dst = *pdst;
 418
 419    trace_dump_call_begin("pipe_screen", "fence_reference");
 420
 421    trace_dump_arg(ptr, screen);
 422    trace_dump_arg(ptr, dst);
 423    trace_dump_arg(ptr, src);
 424
 425    screen->fence_reference(screen, pdst, src);
 426
 427    trace_dump_call_end();
 428 }
 429
 430
 431 static boolean
 432 trace_screen_fence_finish(struct pipe_screen *_screen,
 433                           struct pipe_context *_ctx,
 434                           struct pipe_fence_handle *fence,
 435                           uint64_t timeout)
 436 {
 437    struct trace_screen *tr_scr = trace_screen(_screen);
 438    struct pipe_screen *screen = tr_scr->screen;
 439    struct pipe_context *ctx = _ctx ? trace_context(_ctx)->pipe : NULL;
 440    int result;
 441
 442    trace_dump_call_begin("pipe_screen", "fence_finish");
 443
 444    trace_dump_arg(ptr, screen);
 445    trace_dump_arg(ptr, ctx);
 446    trace_dump_arg(ptr, fence);
 447    trace_dump_arg(uint, timeout);
 448
 449    result = screen->fence_finish(screen, ctx, fence, timeout);
 450
 451    trace_dump_ret(bool, result);
 452
 453    trace_dump_call_end();
 454
 455    return result;
 456 }
 457
 458
 459 /********************************************************************
 460  * screen
 461  */
 462
 463 static uint64_t
 464 trace_screen_get_timestamp(struct pipe_screen *_screen)
 465 {
 466    struct trace_screen *tr_scr = trace_screen(_screen);
 467    struct pipe_screen *screen = tr_scr->screen;
 468    uint64_t result;
 469
 470    trace_dump_call_begin("pipe_screen", "get_timestamp");
 471    trace_dump_arg(ptr, screen);
 472
 473    result = screen->get_timestamp(screen);
 474
 475    trace_dump_ret(uint, result);
 476    trace_dump_call_end();
 477
 478    return result;
 479 }
 480
 481 static void
 482 trace_screen_destroy(struct pipe_screen *_screen)
 483 {
 484    struct trace_screen *tr_scr = trace_screen(_screen);
 485    struct pipe_screen *screen = tr_scr->screen;
 486
 487    trace_dump_call_begin("pipe_screen", "destroy");
 488    trace_dump_arg(ptr, screen);
 489    trace_dump_call_end();
 490
 491    screen->destroy(screen);
 492
 493    FREE(tr_scr);
 494 }
 495
 496 boolean
 497 trace_enabled(void)
 498 {
 499    static boolean firstrun = TRUE;
 500
 501    if (!firstrun)
 502       return trace;
 503    firstrun = FALSE;
 504
 505    if(trace_dump_trace_begin()) {
 506       trace_dumping_start();
 507       trace = TRUE;
 508    }
 509
 510    return trace;
 511 }
 512
 513 struct pipe_screen *
 514 trace_screen_create(struct pipe_screen *screen)
 515 {
 516    struct trace_screen *tr_scr;
 517
 518    if (!trace_enabled())
 519       goto error1;
 520
 521    trace_dump_call_begin("", "pipe_screen_create");
 522
 523    tr_scr = CALLOC_STRUCT(trace_screen);
 524    if (!tr_scr)
 525       goto error2;
 526
 527 #define SCR_INIT(_member) \
 528    tr_scr->base._member = screen->_member ? trace_screen_##_member : NULL
 529
 530    tr_scr->base.destroy = trace_screen_destroy;
 531    tr_scr->base.get_name = trace_screen_get_name;
 532    tr_scr->base.get_vendor = trace_screen_get_vendor;
 533    tr_scr->base.get_device_vendor = trace_screen_get_device_vendor;
 534    SCR_INIT(get_disk_shader_cache);
 535    tr_scr->base.get_param = trace_screen_get_param;
 536    tr_scr->base.get_shader_param = trace_screen_get_shader_param;
 537    tr_scr->base.get_paramf = trace_screen_get_paramf;
 538    tr_scr->base.get_compute_param = trace_screen_get_compute_param;
 539    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
 540    assert(screen->context_create);
 541    tr_scr->base.context_create = trace_screen_context_create;
 542    tr_scr->base.resource_create = trace_screen_resource_create;
 543    tr_scr->base.resource_from_handle = trace_screen_resource_from_handle;
 544    tr_scr->base.resource_get_handle = trace_screen_resource_get_handle;
 545    SCR_INIT(resource_changed);
 546    tr_scr->base.resource_destroy = trace_screen_resource_destroy;
 547    tr_scr->base.fence_reference = trace_screen_fence_reference;
 548    tr_scr->base.fence_finish = trace_screen_fence_finish;
 549    tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
 550    tr_scr->base.get_timestamp = trace_screen_get_timestamp;
 551
 552    tr_scr->screen = screen;
 553
 554    trace_dump_ret(ptr, screen);
 555    trace_dump_call_end();
 556
 557    return &tr_scr->base;
 558
 559 error2:
 560    trace_dump_ret(ptr, screen);
 561    trace_dump_call_end();
 562 error1:
 563    return screen;
 564 }
 565
 566
 567 struct trace_screen *
 568 trace_screen(struct pipe_screen *screen)
 569 {
 570    assert(screen);
 571    assert(screen->destroy == trace_screen_destroy);
 572    return (struct trace_screen *)screen;
 573 }