/**************************************************************************
*
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * Copyright 2008 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "util/u_format.h"
#include "util/u_memory.h"
-#include "util/u_simple_list.h"
+#include "util/simple_list.h"
-#include "tr_buffer.h"
#include "tr_dump.h"
+#include "tr_dump_defines.h"
#include "tr_dump_state.h"
#include "tr_texture.h"
#include "tr_context.h"
#include "tr_screen.h"
#include "tr_public.h"
-#include "util/u_inlines.h"
-#include "pipe/p_format.h"
-
static boolean trace = FALSE;
-static boolean rbug = FALSE;
static const char *
trace_screen_get_name(struct pipe_screen *_screen)
}
-static int
-trace_screen_get_param(struct pipe_screen *_screen,
- int param)
+static const char *
+trace_screen_get_device_vendor(struct pipe_screen *_screen)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
- int result;
+ const char *result;
- trace_dump_call_begin("pipe_screen", "get_param");
+ trace_dump_call_begin("pipe_screen", "get_device_vendor");
trace_dump_arg(ptr, screen);
- trace_dump_arg(int, param);
- result = screen->get_param(screen, param);
+ result = screen->get_device_vendor(screen);
- trace_dump_ret(int, result);
+ trace_dump_ret(string, result);
trace_dump_call_end();
}
-static float
-trace_screen_get_paramf(struct pipe_screen *_screen,
- int param)
+static struct disk_cache *
+trace_screen_get_disk_shader_cache(struct pipe_screen *_screen)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
- float result;
- trace_dump_call_begin("pipe_screen", "get_paramf");
+ trace_dump_call_begin("pipe_screen", "get_disk_shader_cache");
trace_dump_arg(ptr, screen);
- trace_dump_arg(int, param);
- result = screen->get_paramf(screen, param);
+ struct disk_cache *result = screen->get_disk_shader_cache(screen);
- trace_dump_ret(float, result);
+ trace_dump_ret(ptr, result);
trace_dump_call_end();
}
-static boolean
-trace_screen_is_format_supported(struct pipe_screen *_screen,
- enum pipe_format format,
- enum pipe_texture_target target,
- unsigned tex_usage,
- unsigned geom_flags)
+static int
+trace_screen_get_param(struct pipe_screen *_screen,
+ enum pipe_cap param)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
- boolean result;
+ int result;
- trace_dump_call_begin("pipe_screen", "is_format_supported");
+ trace_dump_call_begin("pipe_screen", "get_param");
trace_dump_arg(ptr, screen);
- trace_dump_arg(format, format);
- trace_dump_arg(int, target);
- trace_dump_arg(uint, tex_usage);
- trace_dump_arg(uint, geom_flags);
+ trace_dump_arg(int, param);
- result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
+ result = screen->get_param(screen, param);
- trace_dump_ret(bool, result);
+ trace_dump_ret(int, result);
trace_dump_call_end();
}
-static struct pipe_context *
-trace_screen_context_create(struct pipe_screen *_screen, void *priv)
+static int
+trace_screen_get_shader_param(struct pipe_screen *_screen,
+ enum pipe_shader_type shader,
+ enum pipe_shader_cap param)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
- struct pipe_context *result;
+ int result;
- trace_dump_call_begin("pipe_screen", "context_create");
+ trace_dump_call_begin("pipe_screen", "get_shader_param");
trace_dump_arg(ptr, screen);
+ trace_dump_arg(uint, shader);
+ trace_dump_arg(int, param);
- result = screen->context_create(screen, priv);
+ result = screen->get_shader_param(screen, shader, param);
- trace_dump_ret(ptr, result);
+ trace_dump_ret(int, result);
trace_dump_call_end();
- result = trace_context_create(tr_scr, result);
-
return result;
}
-static void
-trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
- struct pipe_surface *_surface,
- void *context_private)
+static float
+trace_screen_get_paramf(struct pipe_screen *_screen,
+ enum pipe_capf param)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_surface *tr_surf = trace_surface(_surface);
struct pipe_screen *screen = tr_scr->screen;
- struct pipe_surface *surface = tr_surf->surface;
+ float result;
- trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
+ trace_dump_call_begin("pipe_screen", "get_paramf");
trace_dump_arg(ptr, screen);
- trace_dump_arg(ptr, surface);
- /* XXX: hide, as there is nothing we can do with this
- trace_dump_arg(ptr, context_private);
- */
+ trace_dump_arg(int, param);
- screen->flush_frontbuffer(screen, surface, context_private);
+ result = screen->get_paramf(screen, param);
- trace_dump_call_end();
-}
+ trace_dump_ret(float, result);
+ trace_dump_call_end();
-/********************************************************************
- * texture
- */
+ return result;
+}
-static struct pipe_texture *
-trace_screen_texture_create(struct pipe_screen *_screen,
- const struct pipe_texture *templat)
+static int
+trace_screen_get_compute_param(struct pipe_screen *_screen,
+ enum pipe_shader_ir ir_type,
+ enum pipe_compute_cap param, void *data)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
- struct pipe_texture *result;
+ int result;
- trace_dump_call_begin("pipe_screen", "texture_create");
+ trace_dump_call_begin("pipe_screen", "get_compute_param");
trace_dump_arg(ptr, screen);
- trace_dump_arg(template, templat);
+ trace_dump_arg(int, ir_type);
+ trace_dump_arg(int, param);
+ trace_dump_arg(ptr, data);
- result = screen->texture_create(screen, templat);
+ result = screen->get_compute_param(screen, ir_type, param, data);
- trace_dump_ret(ptr, result);
+ trace_dump_ret(int, result);
trace_dump_call_end();
- result = trace_texture_create(tr_scr, result);
-
return result;
}
-static struct pipe_texture *
-trace_screen_texture_from_handle(struct pipe_screen *_screen,
- const struct pipe_texture *templ,
- struct winsys_handle *handle)
-{
- struct trace_screen *tr_screen = trace_screen(_screen);
- struct pipe_screen *screen = tr_screen->screen;
- struct pipe_texture *result;
-
- /* TODO trace call */
-
- result = screen->texture_from_handle(screen, templ, handle);
-
- result = trace_texture_create(trace_screen(_screen), result);
-
- return result;
-}
static boolean
-trace_screen_texture_get_handle(struct pipe_screen *_screen,
- struct pipe_texture *_texture,
- struct winsys_handle *handle)
-{
- struct trace_screen *tr_screen = trace_screen(_screen);
- struct trace_texture *tr_texture = trace_texture(_texture);
- struct pipe_screen *screen = tr_screen->screen;
- struct pipe_texture *texture = tr_texture->texture;
-
- /* TODO trace call */
-
- return screen->texture_get_handle(screen, texture, handle);
-}
-
-
-
-static void
-trace_screen_texture_destroy(struct pipe_texture *_texture)
+trace_screen_is_format_supported(struct pipe_screen *_screen,
+ enum pipe_format format,
+ enum pipe_texture_target target,
+ unsigned sample_count,
+ unsigned tex_usage)
{
- struct trace_screen *tr_scr = trace_screen(_texture->screen);
- struct trace_texture *tr_tex = trace_texture(_texture);
+ struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
- struct pipe_texture *texture = tr_tex->texture;
-
- assert(texture->screen == screen);
+ boolean result;
- trace_dump_call_begin("pipe_screen", "texture_destroy");
+ trace_dump_call_begin("pipe_screen", "is_format_supported");
trace_dump_arg(ptr, screen);
- trace_dump_arg(ptr, texture);
+ trace_dump_arg(format, format);
+ trace_dump_arg(int, target);
+ trace_dump_arg(uint, sample_count);
+ trace_dump_arg(uint, tex_usage);
- trace_dump_call_end();
+ result = screen->is_format_supported(screen, format, target, sample_count,
+ tex_usage);
- trace_texture_destroy(tr_tex);
-}
+ trace_dump_ret(bool, result);
+ trace_dump_call_end();
-/********************************************************************
- * surface
- */
+ return result;
+}
-static struct pipe_surface *
-trace_screen_get_tex_surface(struct pipe_screen *_screen,
- struct pipe_texture *_texture,
- unsigned face, unsigned level,
- unsigned zslice,
- unsigned usage)
+static struct pipe_context *
+trace_screen_context_create(struct pipe_screen *_screen, void *priv,
+ unsigned flags)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_texture *tr_tex = trace_texture(_texture);
struct pipe_screen *screen = tr_scr->screen;
- struct pipe_texture *texture = tr_tex->texture;
- struct pipe_surface *result = NULL;
-
- assert(texture->screen == screen);
+ struct pipe_context *result;
- trace_dump_call_begin("pipe_screen", "get_tex_surface");
+ trace_dump_call_begin("pipe_screen", "context_create");
trace_dump_arg(ptr, screen);
- trace_dump_arg(ptr, texture);
- trace_dump_arg(uint, face);
- trace_dump_arg(uint, level);
- trace_dump_arg(uint, zslice);
- trace_dump_arg(uint, usage);
+ trace_dump_arg(ptr, priv);
+ trace_dump_arg(uint, flags);
- result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
+ result = screen->context_create(screen, priv, flags);
trace_dump_ret(ptr, result);
trace_dump_call_end();
- result = trace_surface_create(tr_tex, result);
+ result = trace_context_create(tr_scr, result);
return result;
}
static void
-trace_screen_tex_surface_destroy(struct pipe_surface *_surface)
+trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
+ struct pipe_resource *resource,
+ unsigned level, unsigned layer,
+ void *context_private,
+ struct pipe_box *sub_box)
{
- struct trace_screen *tr_scr = trace_screen(_surface->texture->screen);
- struct trace_surface *tr_surf = trace_surface(_surface);
+ struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
- struct pipe_surface *surface = tr_surf->surface;
- trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
+ trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
trace_dump_arg(ptr, screen);
- trace_dump_arg(ptr, surface);
+ trace_dump_arg(ptr, resource);
+ trace_dump_arg(uint, level);
+ trace_dump_arg(uint, layer);
+ /* XXX: hide, as there is nothing we can do with this
+ trace_dump_arg(ptr, context_private);
+ */
- trace_dump_call_end();
+ screen->flush_frontbuffer(screen, resource, level, layer, context_private, sub_box);
- trace_surface_destroy(tr_surf);
+ trace_dump_call_end();
}
+static void
+trace_screen_get_driver_uuid(struct pipe_screen *_screen, char *uuid)
+{
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+ trace_dump_call_begin("pipe_screen", "get_driver_uuid");
+ trace_dump_arg(ptr, screen);
+ screen->get_driver_uuid(screen, uuid);
-/********************************************************************
- * buffer
- */
-
-
-
-
+ trace_dump_ret(string, uuid);
+ trace_dump_call_end();
+}
-static struct pipe_buffer *
-trace_screen_buffer_create(struct pipe_screen *_screen,
- unsigned alignment,
- unsigned usage,
- unsigned size)
+static void
+trace_screen_get_device_uuid(struct pipe_screen *_screen, char *uuid)
{
- struct trace_screen *tr_scr = trace_screen(_screen);
- struct pipe_screen *screen = tr_scr->screen;
- struct pipe_buffer *result;
-
- trace_dump_call_begin("pipe_screen", "buffer_create");
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+ trace_dump_call_begin("pipe_screen", "get_device_uuid");
trace_dump_arg(ptr, screen);
- trace_dump_arg(uint, alignment);
- trace_dump_arg(uint, usage);
- trace_dump_arg(uint, size);
- result = screen->buffer_create(screen, alignment, usage, size);
-
- trace_dump_ret(ptr, result);
+ screen->get_device_uuid(screen, uuid);
+ trace_dump_ret(string, uuid);
trace_dump_call_end();
+}
- /* Zero the buffer to avoid dumping uninitialized memory */
- if(result->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
- void *map;
- map = pipe_buffer_map(screen, result, PIPE_BUFFER_USAGE_CPU_WRITE);
- if(map) {
- memset(map, 0, result->size);
- screen->buffer_unmap(screen, result);
- }
- }
- return trace_buffer_create(tr_scr, result);
-}
+/********************************************************************
+ * texture
+ */
-static struct pipe_buffer *
-trace_screen_user_buffer_create(struct pipe_screen *_screen,
- void *data,
- unsigned size)
+static struct pipe_resource *
+trace_screen_resource_create(struct pipe_screen *_screen,
+ const struct pipe_resource *templat)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
- struct pipe_buffer *result;
+ struct pipe_resource *result;
- trace_dump_call_begin("pipe_screen", "user_buffer_create");
+ trace_dump_call_begin("pipe_screen", "resource_create");
trace_dump_arg(ptr, screen);
- trace_dump_arg_begin("data");
- trace_dump_bytes(data, size);
- trace_dump_arg_end();
- trace_dump_arg(uint, size);
+ trace_dump_arg(resource_template, templat);
- result = screen->user_buffer_create(screen, data, size);
+ result = screen->resource_create(screen, templat);
trace_dump_ret(ptr, result);
trace_dump_call_end();
- if(result) {
- assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
- result->usage |= TRACE_BUFFER_USAGE_USER;
- }
-
- return trace_buffer_create(tr_scr, result);
+ if (result)
+ result->screen = _screen;
+ return result;
}
-
-/**
- * This function is used to track if data has been changed on a user buffer
- * without map/unmap being called.
- */
-void
-trace_screen_user_buffer_update(struct pipe_screen *_screen,
- struct pipe_buffer *_buffer)
+static struct pipe_resource *
+trace_screen_resource_from_handle(struct pipe_screen *_screen,
+ const struct pipe_resource *templ,
+ struct winsys_handle *handle,
+ unsigned usage)
{
-#if 0
- struct trace_screen *tr_scr = trace_screen(_screen);
- struct pipe_screen *screen = tr_scr->screen;
- const void *map;
-
- if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
- map = screen->buffer_map(screen, buffer, PIPE_BUFFER_USAGE_CPU_READ);
- if(map) {
- trace_dump_call_begin("pipe_winsys", "buffer_write");
-
- trace_dump_arg(ptr, screen);
-
- trace_dump_arg(ptr, buffer);
-
- trace_dump_arg_begin("data");
- trace_dump_bytes(map, buffer->size);
- trace_dump_arg_end();
+ struct trace_screen *tr_screen = trace_screen(_screen);
+ struct pipe_screen *screen = tr_screen->screen;
+ struct pipe_resource *result;
- trace_dump_arg_begin("size");
- trace_dump_uint(buffer->size);
- trace_dump_arg_end();
+ /* TODO trace call */
- trace_dump_call_end();
+ result = screen->resource_from_handle(screen, templ, handle, usage);
- screen->buffer_unmap(screen, buffer);
- }
- }
-#endif
+ if (result)
+ result->screen = _screen;
+ return result;
}
-
-static void *
-trace_screen_buffer_map(struct pipe_screen *_screen,
- struct pipe_buffer *_buffer,
- unsigned usage)
+static bool
+trace_screen_check_resource_capability(struct pipe_screen *_screen,
+ struct pipe_resource *resource,
+ unsigned bind)
{
- struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_buffer *tr_buf = trace_buffer(_buffer);
- struct pipe_screen *screen = tr_scr->screen;
- struct pipe_buffer *buffer = tr_buf->buffer;
- void *map;
-
- assert(screen->buffer_map);
- map = screen->buffer_map(screen, buffer, usage);
- if(map) {
- if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
- tr_buf->map = map;
- }
- }
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
- return map;
+ return screen->check_resource_capability(screen, resource, bind);
}
-
-static void *
-trace_screen_buffer_map_range(struct pipe_screen *_screen,
- struct pipe_buffer *_buffer,
- unsigned offset,
- unsigned length,
- unsigned usage)
+static boolean
+trace_screen_resource_get_handle(struct pipe_screen *_screen,
+ struct pipe_context *_pipe,
+ struct pipe_resource *resource,
+ struct winsys_handle *handle,
+ unsigned usage)
{
- struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_buffer *tr_buf = trace_buffer(_buffer);
- struct pipe_screen *screen = tr_scr->screen;
- struct pipe_buffer *buffer = tr_buf->buffer;
- void *map;
-
- assert(screen->buffer_map_range);
- map = screen->buffer_map_range(screen, buffer, offset, length, usage);
- if(map) {
- if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
- tr_buf->map = map;
- }
- }
+ struct trace_screen *tr_screen = trace_screen(_screen);
+ struct trace_context *tr_pipe = _pipe ? trace_context(_pipe) : NULL;
+ struct pipe_screen *screen = tr_screen->screen;
- return map;
-}
+ /* TODO trace call */
+ return screen->resource_get_handle(screen, tr_pipe ? tr_pipe->pipe : NULL,
+ resource, handle, usage);
+}
-static void
-buffer_write(struct pipe_screen *screen,
- struct pipe_buffer *buffer,
- unsigned offset,
- const char *map,
- unsigned size)
+static struct pipe_resource *
+trace_screen_resource_from_memobj(struct pipe_screen *_screen,
+ const struct pipe_resource *templ,
+ struct pipe_memory_object *memobj,
+ uint64_t offset)
{
- assert(map);
-
- trace_dump_call_begin("pipe_screen", "buffer_write");
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+ trace_dump_call_begin("pipe_screen", "resource_from_memobj");
trace_dump_arg(ptr, screen);
-
- trace_dump_arg(ptr, buffer);
-
+ trace_dump_arg(resource_template, templ);
+ trace_dump_arg(ptr, memobj);
trace_dump_arg(uint, offset);
- trace_dump_arg_begin("data");
- trace_dump_bytes(map + offset, size);
- trace_dump_arg_end();
+ struct pipe_resource *res =
+ screen->resource_from_memobj(screen, templ, memobj, offset);
- trace_dump_arg(uint, size);
+ if (!res)
+ return NULL;
+ res->screen = _screen;
+ trace_dump_ret(ptr, res);
trace_dump_call_end();
-
+ return res;
}
-
static void
-trace_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
- struct pipe_buffer *_buffer,
- unsigned offset,
- unsigned length)
+trace_screen_resource_changed(struct pipe_screen *_screen,
+ struct pipe_resource *resource)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_buffer *tr_buf = trace_buffer(_buffer);
struct pipe_screen *screen = tr_scr->screen;
- struct pipe_buffer *buffer = tr_buf->buffer;
- assert(tr_buf->map);
- buffer_write(screen, buffer, offset, tr_buf->map, length);
- tr_buf->range_flushed = TRUE;
- screen->buffer_flush_mapped_range(screen, buffer, offset, length);
-}
+ trace_dump_call_begin("pipe_screen", "resource_changed");
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, resource);
-static void
-trace_screen_buffer_unmap(struct pipe_screen *_screen,
- struct pipe_buffer *_buffer)
-{
- struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_buffer *tr_buf = trace_buffer(_buffer);
- struct pipe_screen *screen = tr_scr->screen;
- struct pipe_buffer *buffer = tr_buf->buffer;
+ screen->resource_changed(screen, resource);
- if (tr_buf->map && !tr_buf->range_flushed)
- buffer_write(screen, buffer, 0, tr_buf->map, buffer->size);
- tr_buf->map = NULL;
- tr_buf->range_flushed = FALSE;
- screen->buffer_unmap(screen, buffer);
+ trace_dump_call_end();
}
-
static void
-trace_screen_buffer_destroy(struct pipe_buffer *_buffer)
+trace_screen_resource_destroy(struct pipe_screen *_screen,
+ struct pipe_resource *resource)
{
- struct trace_screen *tr_scr = trace_screen(_buffer->screen);
- struct trace_buffer *tr_buf = trace_buffer(_buffer);
+ struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
- struct pipe_buffer *buffer = tr_buf->buffer;
-
- trace_dump_call_begin("pipe_screen", "buffer_destroy");
-
- trace_dump_arg(ptr, screen);
- trace_dump_arg(ptr, buffer);
-
- trace_dump_call_end();
- trace_buffer_destroy(tr_scr, _buffer);
+ /* Don't trace this, because due to the lack of pipe_resource wrapping,
+ * we can get this call from inside of driver calls, which would try
+ * to lock an already-locked mutex.
+ */
+ screen->resource_destroy(screen, resource);
}
}
-static int
-trace_screen_fence_signalled(struct pipe_screen *_screen,
- struct pipe_fence_handle *fence,
- unsigned flags)
+static boolean
+trace_screen_fence_finish(struct pipe_screen *_screen,
+ struct pipe_context *_ctx,
+ struct pipe_fence_handle *fence,
+ uint64_t timeout)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
+ struct pipe_context *ctx = _ctx ? trace_context(_ctx)->pipe : NULL;
int result;
- trace_dump_call_begin("pipe_screen", "fence_signalled");
+ trace_dump_call_begin("pipe_screen", "fence_finish");
trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, ctx);
trace_dump_arg(ptr, fence);
- trace_dump_arg(uint, flags);
+ trace_dump_arg(uint, timeout);
- result = screen->fence_signalled(screen, fence, flags);
+ result = screen->fence_finish(screen, ctx, fence, timeout);
- trace_dump_ret(int, result);
+ trace_dump_ret(bool, result);
trace_dump_call_end();
}
-static int
-trace_screen_fence_finish(struct pipe_screen *_screen,
- struct pipe_fence_handle *fence,
- unsigned flags)
-{
- struct trace_screen *tr_scr = trace_screen(_screen);
- struct pipe_screen *screen = tr_scr->screen;
- int result;
+/********************************************************************
+ * memobj
+ */
- trace_dump_call_begin("pipe_screen", "fence_finish");
+static struct pipe_memory_object *
+trace_screen_memobj_create_from_handle(struct pipe_screen *_screen,
+ struct winsys_handle *handle,
+ bool dedicated)
+{
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+ trace_dump_call_begin("pipe_screen", "memobj_create_from_handle");
trace_dump_arg(ptr, screen);
- trace_dump_arg(ptr, fence);
- trace_dump_arg(uint, flags);
+ trace_dump_arg(ptr, handle);
+ trace_dump_arg(bool, dedicated);
- result = screen->fence_finish(screen, fence, flags);
+ struct pipe_memory_object *res =
+ screen->memobj_create_from_handle(screen, handle, dedicated);
- trace_dump_ret(int, result);
+ trace_dump_ret(ptr, res);
+ trace_dump_call_end();
+
+ return res;
+}
+static void
+trace_screen_memobj_destroy(struct pipe_screen *_screen,
+ struct pipe_memory_object *memobj)
+{
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+
+ trace_dump_call_begin("pipe_screen", "memobj_destroy");
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, memobj);
trace_dump_call_end();
- return result;
+ screen->memobj_destroy(screen, memobj);
}
* screen
*/
+static uint64_t
+trace_screen_get_timestamp(struct pipe_screen *_screen)
+{
+ struct trace_screen *tr_scr = trace_screen(_screen);
+ struct pipe_screen *screen = tr_scr->screen;
+ uint64_t result;
+
+ trace_dump_call_begin("pipe_screen", "get_timestamp");
+ trace_dump_arg(ptr, screen);
+
+ result = screen->get_timestamp(screen);
+
+ trace_dump_ret(uint, result);
+ trace_dump_call_end();
+
+ return result;
+}
+
static void
trace_screen_destroy(struct pipe_screen *_screen)
{
trace_dump_call_begin("pipe_screen", "destroy");
trace_dump_arg(ptr, screen);
trace_dump_call_end();
- trace_dump_trace_end();
-
- if (tr_scr->rbug)
- trace_rbug_stop(tr_scr->rbug);
screen->destroy(screen);
return trace;
firstrun = FALSE;
- trace_dump_init();
-
if(trace_dump_trace_begin()) {
trace_dumping_start();
trace = TRUE;
}
- if (debug_get_bool_option("GALLIUM_RBUG", FALSE)) {
- trace = TRUE;
- rbug = TRUE;
- }
-
return trace;
}
trace_screen_create(struct pipe_screen *screen)
{
struct trace_screen *tr_scr;
- struct pipe_winsys *winsys;
-
- if(!screen)
- goto error1;
if (!trace_enabled())
goto error1;
trace_dump_call_begin("", "pipe_screen_create");
tr_scr = CALLOC_STRUCT(trace_screen);
- if(!tr_scr)
+ if (!tr_scr)
goto error2;
-#if 0
- winsys = trace_winsys_create(screen->winsys);
- if(!winsys)
- goto error3;
-#else
- winsys = screen->winsys;
-#endif
- pipe_mutex_init(tr_scr->list_mutex);
- make_empty_list(&tr_scr->buffers);
- make_empty_list(&tr_scr->contexts);
- make_empty_list(&tr_scr->textures);
- make_empty_list(&tr_scr->surfaces);
- make_empty_list(&tr_scr->transfers);
-
- tr_scr->base.winsys = winsys;
+#define SCR_INIT(_member) \
+ tr_scr->base._member = screen->_member ? trace_screen_##_member : NULL
+
tr_scr->base.destroy = trace_screen_destroy;
tr_scr->base.get_name = trace_screen_get_name;
tr_scr->base.get_vendor = trace_screen_get_vendor;
+ tr_scr->base.get_device_vendor = trace_screen_get_device_vendor;
+ SCR_INIT(get_disk_shader_cache);
tr_scr->base.get_param = trace_screen_get_param;
+ tr_scr->base.get_shader_param = trace_screen_get_shader_param;
tr_scr->base.get_paramf = trace_screen_get_paramf;
+ tr_scr->base.get_compute_param = trace_screen_get_compute_param;
tr_scr->base.is_format_supported = trace_screen_is_format_supported;
assert(screen->context_create);
tr_scr->base.context_create = trace_screen_context_create;
- tr_scr->base.texture_create = trace_screen_texture_create;
- tr_scr->base.texture_from_handle = trace_screen_texture_from_handle;
- tr_scr->base.texture_get_handle = trace_screen_texture_get_handle;
- tr_scr->base.texture_destroy = trace_screen_texture_destroy;
- tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
- tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
- tr_scr->base.buffer_create = trace_screen_buffer_create;
- tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
- if (screen->buffer_map)
- tr_scr->base.buffer_map = trace_screen_buffer_map;
- if (screen->buffer_map_range)
- tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
- if (screen->buffer_flush_mapped_range)
- tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
- if (screen->buffer_unmap)
- tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
- tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
+ tr_scr->base.resource_create = trace_screen_resource_create;
+ tr_scr->base.resource_from_handle = trace_screen_resource_from_handle;
+ SCR_INIT(check_resource_capability);
+ tr_scr->base.resource_get_handle = trace_screen_resource_get_handle;
+ SCR_INIT(resource_from_memobj);
+ SCR_INIT(resource_changed);
+ tr_scr->base.resource_destroy = trace_screen_resource_destroy;
tr_scr->base.fence_reference = trace_screen_fence_reference;
- tr_scr->base.fence_signalled = trace_screen_fence_signalled;
tr_scr->base.fence_finish = trace_screen_fence_finish;
+ SCR_INIT(memobj_create_from_handle);
+ SCR_INIT(memobj_destroy);
tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
+ tr_scr->base.get_timestamp = trace_screen_get_timestamp;
+ SCR_INIT(get_driver_uuid);
+ SCR_INIT(get_device_uuid);
tr_scr->screen = screen;
- tr_scr->private_context = screen->context_create(screen, NULL);
- if (tr_scr->private_context == NULL)
- goto error3;
trace_dump_ret(ptr, screen);
trace_dump_call_end();
- if (rbug)
- tr_scr->rbug = trace_rbug_start(tr_scr);
-
return &tr_scr->base;
-error3:
- FREE(tr_scr);
error2:
trace_dump_ret(ptr, screen);
trace_dump_call_end();
- trace_dump_trace_end();
error1:
return screen;
}