src/gallium/auxiliary/util/u_timed_winsys.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA
   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 SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  18  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  19  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  20  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  *
  26  *
  27  **************************************************************************/
  28 /*
  29  * Authors: Keith Whitwell <keithw-at-tungstengraphics-dot-com>
  30  */
  31
  32 #include "pipe/p_winsys.h"
  33 #include "u_timed_winsys.h"
  34 #include "util/u_memory.h"
  35 #include <sys/time.h>
  36
  37
  38
  39 struct timed_winsys {
  40    struct pipe_winsys base;
  41    struct pipe_winsys *backend;
  42    unsigned long long last_dump;
  43    struct {
  44       const char *name_key;
  45       double total;
  46       unsigned calls;
  47    } funcs[13];
  48 };
  49
  50
  51 static struct timed_winsys *timed_winsys( struct pipe_winsys *winsys )
  52 {
  53    return (struct timed_winsys *)winsys;
  54 }
  55
  56
  57 static unsigned long long get_time( void )
  58 {
  59   struct timeval systime;
  60   gettimeofday( &systime, NULL );
  61   return (((unsigned long long) systime.tv_sec) * 1000000LL)  + systime.tv_usec;
  62 }
  63
  64
  65 static unsigned long long time_start( void )
  66 {
  67    return get_time();
  68 }
  69
  70
  71 static void time_display( struct pipe_winsys *winsys )
  72 {
  73    struct timed_winsys *tws = timed_winsys(winsys);
  74    unsigned i;
  75    double overall = 0;
  76
  77    for (i = 0; i < Elements(tws->funcs); i++) {
  78       if (tws->funcs[i].name_key) {
  79          debug_printf("*** %-25s %5.3fms (%d calls, avg %.3fms)\n",
  80                       tws->funcs[i].name_key,
  81                       tws->funcs[i].total,
  82                       tws->funcs[i].calls,
  83                       tws->funcs[i].total / tws->funcs[i].calls);
  84          overall += tws->funcs[i].total;
  85          tws->funcs[i].calls = 0;
  86          tws->funcs[i].total = 0;
  87       }
  88    }
  89
  90    debug_printf("*** %-25s %5.3fms\n",
  91                 "OVERALL WINSYS",
  92                 overall);
  93 }
  94
  95 static void time_finish( struct pipe_winsys *winsys,
  96                          long long startval,
  97                          unsigned idx,
  98                          const char *name )
  99 {
 100    struct timed_winsys *tws = timed_winsys(winsys);
 101    unsigned long long endval = get_time();
 102    double elapsed = (endval - startval)/1000.0;
 103
 104    if (endval - startval > 1000LL)
 105       debug_printf("*** %s %.3f\n", name, elapsed );
 106
 107    assert( tws->funcs[idx].name_key == name ||
 108            tws->funcs[idx].name_key == NULL);
 109
 110    tws->funcs[idx].name_key = name;
 111    tws->funcs[idx].total += elapsed;
 112    tws->funcs[idx].calls++;
 113
 114    if (endval - tws->last_dump > 10LL * 1000LL * 1000LL) {
 115       time_display( winsys );
 116       tws->last_dump = endval;
 117    }
 118 }
 119
 120
 121 /* Pipe has no concept of pools, but the psb driver passes a flag that
 122  * can be mapped onto pools in the backend.
 123  */
 124 static struct pipe_buffer *
 125 timed_buffer_create(struct pipe_winsys *winsys,
 126                     unsigned alignment,
 127                     unsigned usage,
 128                     unsigned size )
 129 {
 130    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 131    unsigned long long start = time_start();
 132
 133    struct pipe_buffer *buf = backend->buffer_create( backend, alignment, usage, size );
 134
 135    time_finish(winsys, start, 0, __FUNCTION__);
 136
 137    return buf;
 138 }
 139
 140
 141
 142
 143 static struct pipe_buffer *
 144 timed_user_buffer_create(struct pipe_winsys *winsys,
 145                              void *data,
 146                              unsigned bytes)
 147 {
 148    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 149    unsigned long long start = time_start();
 150
 151    struct pipe_buffer *buf = backend->user_buffer_create( backend, data, bytes );
 152
 153    time_finish(winsys, start, 1, __FUNCTION__);
 154
 155    return buf;
 156 }
 157
 158
 159 static void *
 160 timed_buffer_map(struct pipe_winsys *winsys,
 161                      struct pipe_buffer *buf,
 162                      unsigned flags)
 163 {
 164    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 165    unsigned long long start = time_start();
 166
 167    void *map = backend->buffer_map( backend, buf, flags );
 168
 169    time_finish(winsys, start, 2, __FUNCTION__);
 170
 171    return map;
 172 }
 173
 174
 175 static void
 176 timed_buffer_unmap(struct pipe_winsys *winsys,
 177                        struct pipe_buffer *buf)
 178 {
 179    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 180    unsigned long long start = time_start();
 181
 182    backend->buffer_unmap( backend, buf );
 183
 184    time_finish(winsys, start, 3, __FUNCTION__);
 185 }
 186
 187
 188 static void
 189 timed_buffer_destroy(struct pipe_winsys *winsys,
 190                          struct pipe_buffer *buf)
 191 {
 192    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 193    unsigned long long start = time_start();
 194
 195    backend->buffer_destroy( backend, buf );
 196
 197    time_finish(winsys, start, 4, __FUNCTION__);
 198 }
 199
 200
 201 static void
 202 timed_flush_frontbuffer( struct pipe_winsys *winsys,
 203                          struct pipe_surface *surf,
 204                          void *context_private)
 205 {
 206    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 207    unsigned long long start = time_start();
 208
 209    backend->flush_frontbuffer( backend, surf, context_private );
 210
 211    time_finish(winsys, start, 5, __FUNCTION__);
 212 }
 213
 214
 215
 216
 217 static struct pipe_surface *
 218 timed_surface_alloc(struct pipe_winsys *winsys)
 219 {
 220    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 221    unsigned long long start = time_start();
 222
 223    struct pipe_surface *surf = backend->surface_alloc( backend );
 224
 225    time_finish(winsys, start, 6, __FUNCTION__);
 226
 227    return surf;
 228 }
 229
 230
 231
 232 static int
 233 timed_surface_alloc_storage(struct pipe_winsys *winsys,
 234                               struct pipe_surface *surf,
 235                               unsigned width, unsigned height,
 236                               enum pipe_format format,
 237                               unsigned flags,
 238                               unsigned tex_usage)
 239 {
 240    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 241    unsigned long long start = time_start();
 242
 243    int ret = backend->surface_alloc_storage( backend, surf, width, height,
 244                                              format, flags, tex_usage );
 245
 246    time_finish(winsys, start, 7, __FUNCTION__);
 247
 248    return ret;
 249 }
 250
 251
 252 static void
 253 timed_surface_release(struct pipe_winsys *winsys, struct pipe_surface **s)
 254 {
 255    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 256    unsigned long long start = time_start();
 257
 258    backend->surface_release( backend, s );
 259
 260    time_finish(winsys, start, 8, __FUNCTION__);
 261 }
 262
 263
 264
 265 static const char *
 266 timed_get_name( struct pipe_winsys *winsys )
 267 {
 268    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 269    unsigned long long start = time_start();
 270
 271    const char *ret = backend->get_name( backend );
 272
 273    time_finish(winsys, start, 9, __FUNCTION__);
 274
 275    return ret;
 276 }
 277
 278 static void
 279 timed_fence_reference(struct pipe_winsys *winsys,
 280                     struct pipe_fence_handle **ptr,
 281                     struct pipe_fence_handle *fence)
 282 {
 283    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 284    unsigned long long start = time_start();
 285
 286    backend->fence_reference( backend, ptr, fence );
 287
 288    time_finish(winsys, start, 10, __FUNCTION__);
 289 }
 290
 291
 292 static int
 293 timed_fence_signalled( struct pipe_winsys *winsys,
 294                        struct pipe_fence_handle *fence,
 295                        unsigned flag )
 296 {
 297    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 298    unsigned long long start = time_start();
 299
 300    int ret = backend->fence_signalled( backend, fence, flag );
 301
 302    time_finish(winsys, start, 11, __FUNCTION__);
 303
 304    return ret;
 305 }
 306
 307 static int
 308 timed_fence_finish( struct pipe_winsys *winsys,
 309                      struct pipe_fence_handle *fence,
 310                      unsigned flag )
 311 {
 312    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 313    unsigned long long start = time_start();
 314
 315    int ret = backend->fence_finish( backend, fence, flag );
 316
 317    time_finish(winsys, start, 12, __FUNCTION__);
 318
 319    return ret;
 320 }
 321
 322 static void
 323 timed_winsys_destroy( struct pipe_winsys *winsys )
 324 {
 325    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
 326    backend->destroy( backend );
 327    FREE(winsys);
 328 }
 329
 330
 331
 332 struct pipe_winsys *u_timed_winsys_create( struct pipe_winsys *backend )
 333 {
 334    struct timed_winsys *ws = CALLOC_STRUCT(timed_winsys);
 335
 336    ws->base.user_buffer_create = timed_user_buffer_create;
 337    ws->base.buffer_map = timed_buffer_map;
 338    ws->base.buffer_unmap = timed_buffer_unmap;
 339    ws->base.buffer_destroy = timed_buffer_destroy;
 340    ws->base.buffer_create = timed_buffer_create;
 341    ws->base.flush_frontbuffer = timed_flush_frontbuffer;
 342    ws->base.get_name = timed_get_name;
 343    ws->base.surface_alloc = timed_surface_alloc;
 344    ws->base.surface_alloc_storage = timed_surface_alloc_storage;
 345    ws->base.surface_release = timed_surface_release;
 346    ws->base.fence_reference = timed_fence_reference;
 347    ws->base.fence_signalled = timed_fence_signalled;
 348    ws->base.fence_finish = timed_fence_finish;
 349    ws->base.destroy = timed_winsys_destroy;
 350
 351    ws->backend = backend;
 352
 353    return &ws->base;
 354 }
 355