src/gallium/drivers/trace/tr_winsys.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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_memory.h"
  29 #include "util/u_hash_table.h"
  30
  31 #include "tr_dump.h"
  32 #include "tr_state.h"
  33 #include "tr_screen.h"
  34 #include "tr_texture.h"
  35 #include "tr_winsys.h"
  36
  37
  38 static unsigned trace_buffer_hash(void *buffer)
  39 {
  40    return (unsigned)(uintptr_t)buffer;
  41 }
  42
  43
  44 static int trace_buffer_compare(void *buffer1, void *buffer2)
  45 {
  46    return (char *)buffer2 - (char *)buffer1;
  47 }
  48
  49
  50 static const char *
  51 trace_winsys_get_name(struct pipe_winsys *_winsys)
  52 {
  53    struct trace_winsys *tr_ws = trace_winsys(_winsys);
  54    struct pipe_winsys *winsys = tr_ws->winsys;
  55    const char *result;
  56
  57    trace_dump_call_begin("pipe_winsys", "get_name");
  58
  59    trace_dump_arg(ptr, winsys);
  60
  61    result = winsys->get_name(winsys);
  62
  63    trace_dump_ret(string, result);
  64
  65    trace_dump_call_end();
  66
  67    return result;
  68 }
  69
  70
  71 static void
  72 trace_winsys_flush_frontbuffer(struct pipe_winsys *_winsys,
  73                                struct pipe_surface *surface,
  74                                void *context_private)
  75 {
  76    struct trace_winsys *tr_ws = trace_winsys(_winsys);
  77    struct pipe_winsys *winsys = tr_ws->winsys;
  78
  79    assert(surface);
  80    if(surface->texture) {
  81       struct trace_screen *tr_scr = trace_screen(surface->texture->screen);
  82       struct trace_texture *tr_tex = trace_texture(tr_scr, surface->texture);
  83       struct trace_surface *tr_surf = trace_surface(tr_tex, surface);
  84       surface = tr_surf->surface;
  85    }
  86
  87    trace_dump_call_begin("pipe_winsys", "flush_frontbuffer");
  88
  89    trace_dump_arg(ptr, winsys);
  90    trace_dump_arg(ptr, surface);
  91    /* XXX: hide, as there is nothing we can do with this
  92    trace_dump_arg(ptr, context_private);
  93    */
  94
  95    winsys->flush_frontbuffer(winsys, surface, context_private);
  96
  97    trace_dump_call_end();
  98 }
  99
 100
 101 static struct pipe_buffer *
 102 trace_winsys_surface_buffer_create(struct pipe_winsys *_winsys,
 103                                    unsigned width, unsigned height,
 104                                    enum pipe_format format,
 105                                    unsigned usage,
 106                                    unsigned *pstride)
 107 {
 108    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 109    struct pipe_winsys *winsys = tr_ws->winsys;
 110    unsigned stride;
 111    struct pipe_buffer *result;
 112
 113    trace_dump_call_begin("pipe_winsys", "surface_buffer_create");
 114
 115    trace_dump_arg(ptr, winsys);
 116    trace_dump_arg(uint, width);
 117    trace_dump_arg(uint, height);
 118    trace_dump_arg(format, format);
 119    trace_dump_arg(uint, usage);
 120
 121    result = winsys->surface_buffer_create(winsys,
 122                                           width, height,
 123                                           format,
 124                                           usage,
 125                                           pstride);
 126
 127    stride = *pstride;
 128
 129    trace_dump_arg(uint, stride);
 130
 131    trace_dump_ret(ptr, result);
 132
 133    trace_dump_call_end();
 134
 135    return result;
 136 }
 137
 138
 139 static struct pipe_buffer *
 140 trace_winsys_buffer_create(struct pipe_winsys *_winsys,
 141                            unsigned alignment,
 142                            unsigned usage,
 143                            unsigned size)
 144 {
 145    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 146    struct pipe_winsys *winsys = tr_ws->winsys;
 147    struct pipe_buffer *buffer;
 148
 149    trace_dump_call_begin("pipe_winsys", "buffer_create");
 150
 151    trace_dump_arg(ptr, winsys);
 152    trace_dump_arg(uint, alignment);
 153    trace_dump_arg(uint, usage);
 154    trace_dump_arg(uint, size);
 155
 156    buffer = winsys->buffer_create(winsys, alignment, usage, size);
 157
 158    trace_dump_ret(ptr, buffer);
 159
 160    trace_dump_call_end();
 161
 162    /* Zero the buffer to avoid dumping uninitialized memory */
 163    if(buffer->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 164       void *map;
 165       map = winsys->buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
 166       if(map) {
 167          memset(map, 0, buffer->size);
 168          winsys->buffer_unmap(winsys, buffer);
 169       }
 170    }
 171
 172    return buffer;
 173 }
 174
 175
 176 static struct pipe_buffer *
 177 trace_winsys_user_buffer_create(struct pipe_winsys *_winsys,
 178                                 void *data,
 179                                 unsigned size)
 180 {
 181    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 182    struct pipe_winsys *winsys = tr_ws->winsys;
 183    struct pipe_buffer *result;
 184
 185    trace_dump_call_begin("pipe_winsys", "user_buffer_create");
 186
 187    trace_dump_arg(ptr, winsys);
 188    trace_dump_arg_begin("data");
 189    trace_dump_bytes(data, size);
 190    trace_dump_arg_end();
 191    trace_dump_arg(uint, size);
 192
 193    result = winsys->user_buffer_create(winsys, data, size);
 194
 195    trace_dump_ret(ptr, result);
 196
 197    trace_dump_call_end();
 198
 199    /* XXX: Mark the user buffers. (we should wrap pipe_buffers, but is is
 200     * impossible to do so while texture-less surfaces are still around */
 201    if(result) {
 202       assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
 203       result->usage |= TRACE_BUFFER_USAGE_USER;
 204    }
 205
 206    return result;
 207 }
 208
 209
 210 void
 211 trace_winsys_user_buffer_update(struct pipe_winsys *_winsys,
 212                                 struct pipe_buffer *buffer)
 213 {
 214    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 215    struct pipe_winsys *winsys = tr_ws->winsys;
 216    const void *map;
 217
 218    if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
 219       map = winsys->buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_READ);
 220       if(map) {
 221          trace_dump_call_begin("pipe_winsys", "buffer_write");
 222
 223          trace_dump_arg(ptr, winsys);
 224
 225          trace_dump_arg(ptr, buffer);
 226
 227          trace_dump_arg_begin("data");
 228          trace_dump_bytes(map, buffer->size);
 229          trace_dump_arg_end();
 230
 231          trace_dump_arg_begin("size");
 232          trace_dump_uint(buffer->size);
 233          trace_dump_arg_end();
 234
 235          trace_dump_call_end();
 236
 237          winsys->buffer_unmap(winsys, buffer);
 238       }
 239    }
 240 }
 241
 242
 243 static void *
 244 trace_winsys_buffer_map(struct pipe_winsys *_winsys,
 245                         struct pipe_buffer *buffer,
 246                         unsigned usage)
 247 {
 248    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 249    struct pipe_winsys *winsys = tr_ws->winsys;
 250    void *map;
 251
 252    map = winsys->buffer_map(winsys, buffer, usage);
 253    if(map) {
 254       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 255          assert(!hash_table_get(tr_ws->buffer_maps, buffer));
 256          hash_table_set(tr_ws->buffer_maps, buffer, map);
 257       }
 258    }
 259
 260    return map;
 261 }
 262
 263
 264 static void
 265 trace_winsys_buffer_unmap(struct pipe_winsys *_winsys,
 266                           struct pipe_buffer *buffer)
 267 {
 268    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 269    struct pipe_winsys *winsys = tr_ws->winsys;
 270    const void *map;
 271
 272    map = hash_table_get(tr_ws->buffer_maps, buffer);
 273    if(map) {
 274       trace_dump_call_begin("pipe_winsys", "buffer_write");
 275
 276       trace_dump_arg(ptr, winsys);
 277
 278       trace_dump_arg(ptr, buffer);
 279
 280       trace_dump_arg_begin("data");
 281       trace_dump_bytes(map, buffer->size);
 282       trace_dump_arg_end();
 283
 284       trace_dump_arg_begin("size");
 285       trace_dump_uint(buffer->size);
 286       trace_dump_arg_end();
 287
 288       trace_dump_call_end();
 289
 290       hash_table_remove(tr_ws->buffer_maps, buffer);
 291    }
 292
 293    winsys->buffer_unmap(winsys, buffer);
 294 }
 295
 296
 297 static void
 298 trace_winsys_buffer_destroy(struct pipe_winsys *_winsys,
 299                             struct pipe_buffer *buffer)
 300 {
 301    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 302    struct pipe_winsys *winsys = tr_ws->winsys;
 303
 304    trace_dump_call_begin("pipe_winsys", "buffer_destroy");
 305
 306    trace_dump_arg(ptr, winsys);
 307    trace_dump_arg(ptr, buffer);
 308
 309    winsys->buffer_destroy(winsys, buffer);
 310
 311    trace_dump_call_end();
 312 }
 313
 314
 315 static void
 316 trace_winsys_fence_reference(struct pipe_winsys *_winsys,
 317                              struct pipe_fence_handle **pdst,
 318                              struct pipe_fence_handle *src)
 319 {
 320    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 321    struct pipe_winsys *winsys = tr_ws->winsys;
 322    struct pipe_fence_handle *dst = *pdst;
 323
 324    trace_dump_call_begin("pipe_winsys", "fence_reference");
 325
 326    trace_dump_arg(ptr, winsys);
 327    trace_dump_arg(ptr, dst);
 328    trace_dump_arg(ptr, src);
 329
 330    winsys->fence_reference(winsys, pdst, src);
 331
 332    trace_dump_call_end();
 333 }
 334
 335
 336 static int
 337 trace_winsys_fence_signalled(struct pipe_winsys *_winsys,
 338                              struct pipe_fence_handle *fence,
 339                              unsigned flag)
 340 {
 341    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 342    struct pipe_winsys *winsys = tr_ws->winsys;
 343    int result;
 344
 345    trace_dump_call_begin("pipe_winsys", "fence_signalled");
 346
 347    trace_dump_arg(ptr, winsys);
 348    trace_dump_arg(ptr, fence);
 349    trace_dump_arg(uint, flag);
 350
 351    result = winsys->fence_signalled(winsys, fence, flag);
 352
 353    trace_dump_ret(int, result);
 354
 355    trace_dump_call_end();
 356
 357    return result;
 358 }
 359
 360
 361 static int
 362 trace_winsys_fence_finish(struct pipe_winsys *_winsys,
 363                           struct pipe_fence_handle *fence,
 364                           unsigned flag)
 365 {
 366    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 367    struct pipe_winsys *winsys = tr_ws->winsys;
 368    int result;
 369
 370    trace_dump_call_begin("pipe_winsys", "fence_finish");
 371
 372    trace_dump_arg(ptr, winsys);
 373    trace_dump_arg(ptr, fence);
 374    trace_dump_arg(uint, flag);
 375
 376    result = winsys->fence_finish(winsys, fence, flag);
 377
 378    trace_dump_ret(int, result);
 379
 380    trace_dump_call_end();
 381
 382    return result;
 383 }
 384
 385
 386 static void
 387 trace_winsys_destroy(struct pipe_winsys *_winsys)
 388 {
 389    struct trace_winsys *tr_ws = trace_winsys(_winsys);
 390    struct pipe_winsys *winsys = tr_ws->winsys;
 391
 392    trace_dump_call_begin("pipe_winsys", "destroy");
 393
 394    trace_dump_arg(ptr, winsys);
 395
 396    /*
 397    winsys->destroy(winsys);
 398    */
 399
 400    trace_dump_call_end();
 401
 402    hash_table_destroy(tr_ws->buffer_maps);
 403
 404    FREE(tr_ws);
 405 }
 406
 407
 408 struct pipe_winsys *
 409 trace_winsys_create(struct pipe_winsys *winsys)
 410 {
 411    struct trace_winsys *tr_ws;
 412
 413    if(!winsys)
 414       goto error1;
 415
 416    tr_ws = CALLOC_STRUCT(trace_winsys);
 417    if(!tr_ws)
 418       goto error1;
 419
 420    tr_ws->base.destroy = trace_winsys_destroy;
 421    tr_ws->base.get_name = trace_winsys_get_name;
 422    tr_ws->base.flush_frontbuffer = trace_winsys_flush_frontbuffer;
 423    tr_ws->base.surface_buffer_create = trace_winsys_surface_buffer_create;
 424    tr_ws->base.buffer_create = trace_winsys_buffer_create;
 425    tr_ws->base.user_buffer_create = trace_winsys_user_buffer_create;
 426    tr_ws->base.buffer_map = trace_winsys_buffer_map;
 427    tr_ws->base.buffer_unmap = trace_winsys_buffer_unmap;
 428    tr_ws->base.buffer_destroy = trace_winsys_buffer_destroy;
 429    tr_ws->base.fence_reference = trace_winsys_fence_reference;
 430    tr_ws->base.fence_signalled = trace_winsys_fence_signalled;
 431    tr_ws->base.fence_finish = trace_winsys_fence_finish;
 432
 433    tr_ws->winsys = winsys;
 434
 435    tr_ws->buffer_maps = hash_table_create(trace_buffer_hash,
 436                                           trace_buffer_compare);
 437    if(!tr_ws->buffer_maps)
 438       goto error2;
 439
 440    trace_dump_call_begin("", "pipe_winsys_create");
 441    trace_dump_ret(ptr, winsys);
 442    trace_dump_call_end();
 443
 444    return &tr_ws->base;
 445
 446 error2:
 447    FREE(tr_ws);
 448 error1:
 449    return winsys;
 450 }