fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-03 18:00:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

trace: Make stream a global variable.

Browse source 
This not only simplifies the code, but allows to use atexit() to ensure
the log is closed when applications don't exit cleanly.
This commit is contained in:
José Fonseca 2008-08-14 12:50:52 +01:00
parent 2f34c851c0
commit 196167e9d5
12 changed files with 891 additions and 1002 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
src/gallium/drivers/trace/README
View file

@ -20,16 +20,7 @@ and then try running
which should create a gallium.*.trace file, which is an XML file. You can view
copying trace.xsl and trace.css to the same directory, and opening with a
XSLT capable browser like Firefox or Internet Explorer. It often happens that
the trace file was not properly terminated, and a
</trace>
closing tag is missing from the file end. Add it before try to open or
further transform it by doing
echo '</trace>' >> gallium.??.trace
XSLT capable browser like Firefox or Internet Explorer.
This is still work in progress, namely:
- surface writes are not traced

497
src/gallium/drivers/trace/tr_context.c
View file

File diff suppressed because it is too large Load diff

5
src/gallium/drivers/trace/tr_context.h
View file

@ -34,16 +34,11 @@
#include "pipe/p_context.h"
struct trace_stream;
struct trace_context
{
struct pipe_context base;
struct pipe_context *pipe;
struct trace_stream *stream;
};

323
src/gallium/drivers/trace/tr_dump.c
View file

@ -38,6 +38,11 @@
* @author Jose Fonseca <jrfonseca@tungstengraphics.com>
*/
#include "pipe/p_config.h"
#if defined(PIPE_OS_LINUX)
#include <stdlib.h>
#endif
#include "pipe/p_compiler.h"
#include "util/u_string.h"
@ -46,318 +51,328 @@
#include "tr_dump.h"
static struct trace_stream *stream = NULL;
static INLINE void
trace_dump_write(struct trace_stream *stream, const char *s)
trace_dump_write(const char *buf, size_t size)
{
trace_stream_write(stream, s, strlen(s));
if(stream)
trace_stream_write(stream, buf, size);
}
static INLINE void
trace_dump_writef(struct trace_stream *stream, const char *format, ...)
trace_dump_writes(const char *s)
{
char buf[1024];
trace_dump_write(s, strlen(s));
}
static INLINE void
trace_dump_writef(const char *format, ...)
{
static char buf[1024];
unsigned len;
va_list ap;
va_start(ap, format);
util_vsnprintf(buf, sizeof(buf), format, ap);
len = util_vsnprintf(buf, sizeof(buf), format, ap);
va_end(ap);
trace_dump_write(stream, buf);
trace_dump_write(buf, len);
}
static INLINE void
trace_dump_escape(struct trace_stream *stream, const char *str)
trace_dump_escape(const char *str)
{
const unsigned char *p = (const unsigned char *)str;
unsigned char c;
while((c = *p++) != 0) {
if(c == '<')
trace_dump_write(stream, "&lt;");
trace_dump_writes("&lt;");
else if(c == '>')
trace_dump_write(stream, "&gt;");
trace_dump_writes("&gt;");
else if(c == '&')
trace_dump_write(stream, "&amp;");
trace_dump_writes("&amp;");
else if(c == '\'')
trace_dump_write(stream, "&apos;");
trace_dump_writes("&apos;");
else if(c == '\"')
trace_dump_write(stream, "&quot;");
trace_dump_writes("&quot;");
else if(c >= 0x20 && c <= 0x7e)
trace_dump_writef(stream, "%c", c);
trace_dump_writef("%c", c);
else
trace_dump_writef(stream, "&#%u;", c);
trace_dump_writef("&#%u;", c);
}
}
static INLINE void
trace_dump_indent(struct trace_stream *stream, unsigned level)
trace_dump_indent(unsigned level)
{
unsigned i;
for(i = 0; i < level; ++i)
trace_dump_write(stream, "\t");
trace_dump_writes("\t");
}
static INLINE void
trace_dump_newline(struct trace_stream *stream)
trace_dump_newline(void)
{
trace_dump_write(stream, "\n");
trace_dump_writes("\n");
}
static INLINE void
trace_dump_tag(struct trace_stream *stream,
const char *name)
trace_dump_tag(const char *name)
{
trace_dump_write(stream, "<");
trace_dump_write(stream, name);
trace_dump_write(stream, "/>");
trace_dump_writes("<");
trace_dump_writes(name);
trace_dump_writes("/>");
}
static INLINE void
trace_dump_tag_begin(struct trace_stream *stream,
const char *name)
trace_dump_tag_begin(const char *name)
{
trace_dump_write(stream, "<");
trace_dump_write(stream, name);
trace_dump_write(stream, ">");
trace_dump_writes("<");
trace_dump_writes(name);
trace_dump_writes(">");
}
static INLINE void
trace_dump_tag_begin1(struct trace_stream *stream,
const char *name,
trace_dump_tag_begin1(const char *name,
const char *attr1, const char *value1)
{
trace_dump_write(stream, "<");
trace_dump_write(stream, name);
trace_dump_write(stream, " ");
trace_dump_write(stream, attr1);
trace_dump_write(stream, "='");
trace_dump_escape(stream, value1);
trace_dump_write(stream, "'>");
trace_dump_writes("<");
trace_dump_writes(name);
trace_dump_writes(" ");
trace_dump_writes(attr1);
trace_dump_writes("='");
trace_dump_escape(value1);
trace_dump_writes("'>");
}
static INLINE void
trace_dump_tag_begin2(struct trace_stream *stream,
const char *name,
trace_dump_tag_begin2(const char *name,
const char *attr1, const char *value1,
const char *attr2, const char *value2)
{
trace_dump_write(stream, "<");
trace_dump_write(stream, name);
trace_dump_write(stream, " ");
trace_dump_write(stream, attr1);
trace_dump_write(stream, "=\'");
trace_dump_escape(stream, value1);
trace_dump_write(stream, "\' ");
trace_dump_write(stream, attr2);
trace_dump_write(stream, "=\'");
trace_dump_escape(stream, value2);
trace_dump_write(stream, "\'>");
trace_dump_writes("<");
trace_dump_writes(name);
trace_dump_writes(" ");
trace_dump_writes(attr1);
trace_dump_writes("=\'");
trace_dump_escape(value1);
trace_dump_writes("\' ");
trace_dump_writes(attr2);
trace_dump_writes("=\'");
trace_dump_escape(value2);
trace_dump_writes("\'>");
}
static INLINE void
trace_dump_tag_begin3(struct trace_stream *stream,
const char *name,
trace_dump_tag_begin3(const char *name,
const char *attr1, const char *value1,
const char *attr2, const char *value2,
const char *attr3, const char *value3)
{
trace_dump_write(stream, "<");
trace_dump_write(stream, name);
trace_dump_write(stream, " ");
trace_dump_write(stream, attr1);
trace_dump_write(stream, "=\'");
trace_dump_escape(stream, value1);
trace_dump_write(stream, "\' ");
trace_dump_write(stream, attr2);
trace_dump_write(stream, "=\'");
trace_dump_escape(stream, value2);
trace_dump_write(stream, "\' ");
trace_dump_write(stream, attr3);
trace_dump_write(stream, "=\'");
trace_dump_escape(stream, value3);
trace_dump_write(stream, "\'>");
trace_dump_writes("<");
trace_dump_writes(name);
trace_dump_writes(" ");
trace_dump_writes(attr1);
trace_dump_writes("=\'");
trace_dump_escape(value1);
trace_dump_writes("\' ");
trace_dump_writes(attr2);
trace_dump_writes("=\'");
trace_dump_escape(value2);
trace_dump_writes("\' ");
trace_dump_writes(attr3);
trace_dump_writes("=\'");
trace_dump_escape(value3);
trace_dump_writes("\'>");
}
static INLINE void
trace_dump_tag_end(struct trace_stream *stream,
const char *name)
trace_dump_tag_end(const char *name)
{
trace_dump_write(stream, "</");
trace_dump_write(stream, name);
trace_dump_write(stream, ">");
trace_dump_writes("</");
trace_dump_writes(name);
trace_dump_writes(">");
}
void trace_dump_trace_begin(struct trace_stream *stream,
unsigned version)
boolean trace_dump_trace_begin()
{
trace_dump_write(stream, "<?xml version='1.0' encoding='UTF-8'?>\n");
trace_dump_write(stream, "<?xml-stylesheet type='text/xsl' href='trace.xsl'?>\n");
trace_dump_writef(stream, "<trace version='%u'>\n", version);
if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
return FALSE;
stream = trace_stream_create("gallium", "trace");
if(!stream)
return FALSE;
trace_dump_writes("<?xml version='1.0' encoding='UTF-8'?>\n");
trace_dump_writes("<?xml-stylesheet type='text/xsl' href='trace.xsl'?>\n");
trace_dump_writes("<trace version='0.1'>\n");
#if defined(PIPE_OS_LINUX)
/* Linux applications rarely cleanup GL / Gallium resources so catch
* application exit here */
atexit(trace_dump_trace_end);
#endif
return TRUE;
}
void trace_dump_trace_end(struct trace_stream *stream)
void trace_dump_trace_end(void)
{
trace_dump_write(stream, "</trace>\n");
if(stream) {
trace_dump_writes("</trace>\n");
trace_stream_close(stream);
stream = NULL;
}
}
void trace_dump_call_begin(struct trace_stream *stream,
const char *klass, const char *method)
void trace_dump_call_begin(const char *klass, const char *method)
{
trace_dump_indent(stream, 1);
trace_dump_tag_begin2(stream, "call", "class", klass, "method", method);
trace_dump_newline(stream);
trace_dump_indent(1);
trace_dump_tag_begin2("call", "class", klass, "method", method);
trace_dump_newline();
}
void trace_dump_call_end(struct trace_stream *stream)
void trace_dump_call_end(void)
{
trace_dump_indent(stream, 1);
trace_dump_tag_end(stream, "call");
trace_dump_newline(stream);
trace_dump_indent(1);
trace_dump_tag_end("call");
trace_dump_newline();
}
void trace_dump_arg_begin(struct trace_stream *stream,
const char *name)
void trace_dump_arg_begin(const char *name)
{
trace_dump_indent(stream, 2);
trace_dump_tag_begin1(stream, "arg", "name", name);
trace_dump_indent(2);
trace_dump_tag_begin1("arg", "name", name);
}
void trace_dump_arg_end(struct trace_stream *stream)
void trace_dump_arg_end(void)
{
trace_dump_tag_end(stream, "arg");
trace_dump_newline(stream);
trace_dump_tag_end("arg");
trace_dump_newline();
}
void trace_dump_ret_begin(struct trace_stream *stream)
void trace_dump_ret_begin(void)
{
trace_dump_indent(stream, 2);
trace_dump_tag_begin(stream, "ret");
trace_dump_indent(2);
trace_dump_tag_begin("ret");
}
void trace_dump_ret_end(struct trace_stream *stream)
void trace_dump_ret_end(void)
{
trace_dump_tag_end(stream, "ret");
trace_dump_newline(stream);
trace_dump_tag_end("ret");
trace_dump_newline();
}
void trace_dump_bool(struct trace_stream *stream,
int value)
void trace_dump_bool(int value)
{
trace_dump_writef(stream, "<bool>%c</bool>", value ? '1' : '0');
trace_dump_writef("<bool>%c</bool>", value ? '1' : '0');
}
void trace_dump_int(struct trace_stream *stream,
long int value)
void trace_dump_int(long int value)
{
trace_dump_writef(stream, "<int>%li</int>", value);
trace_dump_writef("<int>%li</int>", value);
}
void trace_dump_uint(struct trace_stream *stream,
long unsigned value)
void trace_dump_uint(long unsigned value)
{
trace_dump_writef(stream, "<uint>%lu</uint>", value);
trace_dump_writef("<uint>%lu</uint>", value);
}
void trace_dump_float(struct trace_stream *stream,
double value)
void trace_dump_float(double value)
{
trace_dump_writef(stream, "<float>%g</float>", value);
trace_dump_writef("<float>%g</float>", value);
}
void trace_dump_bytes(struct trace_stream *stream,
const void *data,
void trace_dump_bytes(const void *data,
long unsigned size)
{
static const char hex_table[16] = "0123456789ABCDEF";
const uint8_t *p = data;
long unsigned i;
trace_dump_write(stream, "<bytes>");
trace_dump_writes("<bytes>");
for(i = 0; i < size; ++i) {
uint8_t byte = *p++;
char hex[2];
hex[0] = hex_table[byte >> 4];
hex[1] = hex_table[byte & 0xf];
trace_stream_write(stream, hex, 2);
trace_dump_write(hex, 2);
}
trace_dump_write(stream, "</bytes>");
trace_dump_writes("</bytes>");
}
void trace_dump_string(struct trace_stream *stream,
const char *str)
void trace_dump_string(const char *str)
{
trace_dump_write(stream, "<string>");
trace_dump_escape(stream, str);
trace_dump_write(stream, "</string>");
trace_dump_writes("<string>");
trace_dump_escape(str);
trace_dump_writes("</string>");
}
void trace_dump_enum(struct trace_stream *stream,
const char *value)
void trace_dump_enum(const char *value)
{
trace_dump_write(stream, "<enum>");
trace_dump_escape(stream, value);
trace_dump_write(stream, "</enum>");
trace_dump_writes("<enum>");
trace_dump_escape(value);
trace_dump_writes("</enum>");
}
void trace_dump_array_begin(struct trace_stream *stream)
void trace_dump_array_begin(void)
{
trace_dump_write(stream, "<array>");
trace_dump_writes("<array>");
}
void trace_dump_array_end(struct trace_stream *stream)
void trace_dump_array_end(void)
{
trace_dump_write(stream, "</array>");
trace_dump_writes("</array>");
}
void trace_dump_elem_begin(struct trace_stream *stream)
void trace_dump_elem_begin(void)
{
trace_dump_write(stream, "<elem>");
trace_dump_writes("<elem>");
}
void trace_dump_elem_end(struct trace_stream *stream)
void trace_dump_elem_end(void)
{
trace_dump_write(stream, "</elem>");
trace_dump_writes("</elem>");
}
void trace_dump_struct_begin(struct trace_stream *stream,
const char *name)
void trace_dump_struct_begin(const char *name)
{
trace_dump_writef(stream, "<struct name='%s'>", name);
trace_dump_writef("<struct name='%s'>", name);
}
void trace_dump_struct_end(struct trace_stream *stream)
void trace_dump_struct_end(void)
{
trace_dump_write(stream, "</struct>");
trace_dump_writes("</struct>");
}
void trace_dump_member_begin(struct trace_stream *stream,
const char *name)
void trace_dump_member_begin(const char *name)
{
trace_dump_writef(stream, "<member name='%s'>", name);
trace_dump_writef("<member name='%s'>", name);
}
void trace_dump_member_end(struct trace_stream *stream)
void trace_dump_member_end(void)
{
trace_dump_write(stream, "</member>");
trace_dump_writes("</member>");
}
void trace_dump_null(struct trace_stream *stream)
void trace_dump_null(void)
{
trace_dump_write(stream, "<null/>");
trace_dump_writes("<null/>");
}
void trace_dump_ptr(struct trace_stream *stream,
const void *value)
void trace_dump_ptr(const void *value)
{
if(value)
trace_dump_writef(stream, "<ptr>%p</ptr>", value);
trace_dump_writef("<ptr>%p</ptr>", value);
else
trace_dump_null(stream);
trace_dump_null();
}

120
src/gallium/drivers/trace/tr_dump.h
View file

@ -4,7 +4,7 @@
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation streams (the
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
@ -34,100 +34,98 @@
#define TR_DUMP_H
#include "pipe/p_compiler.h"
#include "pipe/p_util.h"
struct trace_stream;
void trace_dump_trace_begin(struct trace_stream *stream, unsigned version);
void trace_dump_trace_end(struct trace_stream *stream);
void trace_dump_call_begin(struct trace_stream *stream, const char *klass, const char *method);
void trace_dump_call_end(struct trace_stream *stream);
void trace_dump_arg_begin(struct trace_stream *stream, const char *name);
void trace_dump_arg_end(struct trace_stream *stream);
void trace_dump_ret_begin(struct trace_stream *stream);
void trace_dump_ret_end(struct trace_stream *stream);
void trace_dump_bool(struct trace_stream *stream, int value);
void trace_dump_int(struct trace_stream *stream, long int value);
void trace_dump_uint(struct trace_stream *stream, long unsigned value);
void trace_dump_float(struct trace_stream *stream, double value);
void trace_dump_bytes(struct trace_stream *stream, const void *data, long unsigned size);
void trace_dump_string(struct trace_stream *stream, const char *str);
void trace_dump_enum(struct trace_stream *stream, const char *value);
void trace_dump_array_begin(struct trace_stream *stream);
void trace_dump_array_end(struct trace_stream *stream);
void trace_dump_elem_begin(struct trace_stream *stream);
void trace_dump_elem_end(struct trace_stream *stream);
void trace_dump_struct_begin(struct trace_stream *stream, const char *name);
void trace_dump_struct_end(struct trace_stream *stream);
void trace_dump_member_begin(struct trace_stream *stream, const char *name);
void trace_dump_member_end(struct trace_stream *stream);
void trace_dump_null(struct trace_stream *stream);
void trace_dump_ptr(struct trace_stream *stream, const void *value);
boolean trace_dump_trace_begin(void);
void trace_dump_trace_end(void);
void trace_dump_call_begin(const char *klass, const char *method);
void trace_dump_call_end(void);
void trace_dump_arg_begin(const char *name);
void trace_dump_arg_end(void);
void trace_dump_ret_begin(void);
void trace_dump_ret_end(void);
void trace_dump_bool(int value);
void trace_dump_int(long int value);
void trace_dump_uint(long unsigned value);
void trace_dump_float(double value);
void trace_dump_bytes(const void *data, long unsigned size);
void trace_dump_string(const char *str);
void trace_dump_enum(const char *value);
void trace_dump_array_begin(void);
void trace_dump_array_end(void);
void trace_dump_elem_begin(void);
void trace_dump_elem_end(void);
void trace_dump_struct_begin(const char *name);
void trace_dump_struct_end(void);
void trace_dump_member_begin(const char *name);
void trace_dump_member_end(void);
void trace_dump_null(void);
void trace_dump_ptr(const void *value);
/*
* Code saving macros.
*/
#define trace_dump_arg(_stream, _type, _arg) \
#define trace_dump_arg(_type, _arg) \
do { \
trace_dump_arg_begin(_stream, #_arg); \
trace_dump_##_type(_stream, _arg); \
trace_dump_arg_end(_stream); \
trace_dump_arg_begin(#_arg); \
trace_dump_##_type(_arg); \
trace_dump_arg_end(); \
} while(0)
#define trace_dump_ret(_stream, _type, _arg) \
#define trace_dump_ret(_type, _arg) \
do { \
trace_dump_ret_begin(_stream); \
trace_dump_##_type(_stream, _arg); \
trace_dump_ret_end(_stream); \
trace_dump_ret_begin(); \
trace_dump_##_type(_arg); \
trace_dump_ret_end(); \
} while(0)
#define trace_dump_array(_stream, _type, _obj, _size) \
#define trace_dump_array(_type, _obj, _size) \
do { \
unsigned long idx; \
trace_dump_array_begin(_stream); \
trace_dump_array_begin(); \
for(idx = 0; idx < (_size); ++idx) { \
trace_dump_elem_begin(_stream); \
trace_dump_##_type(_stream, (_obj)[idx]); \
trace_dump_elem_end(_stream); \
trace_dump_elem_begin(); \
trace_dump_##_type((_obj)[idx]); \
trace_dump_elem_end(); \
} \
trace_dump_array_end(_stream); \
trace_dump_array_end(); \
} while(0)
#define trace_dump_struct_array(_stream, _type, _obj, _size) \
#define trace_dump_struct_array(_type, _obj, _size) \
do { \
unsigned long idx; \
trace_dump_array_begin(_stream); \
trace_dump_array_begin(); \
for(idx = 0; idx < (_size); ++idx) { \
trace_dump_elem_begin(_stream); \
trace_dump_##_type(_stream, &(_obj)[idx]); \
trace_dump_elem_end(_stream); \
trace_dump_elem_begin(); \
trace_dump_##_type(&(_obj)[idx]); \
trace_dump_elem_end(); \
} \
trace_dump_array_end(_stream); \
trace_dump_array_end(); \
} while(0)
#define trace_dump_member(_stream, _type, _obj, _member) \
#define trace_dump_member(_type, _obj, _member) \
do { \
trace_dump_member_begin(_stream, #_member); \
trace_dump_##_type(_stream, (_obj)->_member); \
trace_dump_member_end(_stream); \
trace_dump_member_begin(#_member); \
trace_dump_##_type((_obj)->_member); \
trace_dump_member_end(); \
} while(0)
#define trace_dump_arg_array(_stream, _type, _arg, _size) \
#define trace_dump_arg_array(_type, _arg, _size) \
do { \
trace_dump_arg_begin(_stream, #_arg); \
trace_dump_array(_stream, _type, _arg, _size); \
trace_dump_arg_end(_stream); \
trace_dump_arg_begin(#_arg); \
trace_dump_array(_type, _arg, _size); \
trace_dump_arg_end(); \
} while(0)
#define trace_dump_member_array(_stream, _type, _obj, _member) \
#define trace_dump_member_array(_type, _obj, _member) \
do { \
trace_dump_member_begin(_stream, #_member); \
trace_dump_array(_stream, _type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \
trace_dump_member_end(_stream); \
trace_dump_member_begin(#_member); \
trace_dump_array(_type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \
trace_dump_member_end(); \
} while(0)

196
src/gallium/drivers/trace/tr_screen.c
View file

@ -27,7 +27,6 @@
#include "pipe/p_util.h"
#include "tr_stream.h"
#include "tr_dump.h"
#include "tr_state.h"
#include "tr_winsys.h"
@ -38,19 +37,18 @@ static const char *
trace_screen_get_name(struct pipe_screen *_screen)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
const char *result;
trace_dump_call_begin(stream, "pipe_screen", "get_name");
trace_dump_call_begin("pipe_screen", "get_name");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(ptr, screen);
result = screen->get_name(screen);
trace_dump_ret(stream, string, result);
trace_dump_ret(string, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -60,19 +58,18 @@ static const char *
trace_screen_get_vendor(struct pipe_screen *_screen)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
const char *result;
trace_dump_call_begin(stream, "pipe_screen", "get_vendor");
trace_dump_call_begin("pipe_screen", "get_vendor");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(ptr, screen);
result = screen->get_vendor(screen);
trace_dump_ret(stream, string, result);
trace_dump_ret(string, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -83,20 +80,19 @@ trace_screen_get_param(struct pipe_screen *_screen,
int param)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
int result;
trace_dump_call_begin(stream, "pipe_screen", "get_param");
trace_dump_call_begin("pipe_screen", "get_param");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, int, param);
trace_dump_arg(ptr, screen);
trace_dump_arg(int, param);
result = screen->get_param(screen, param);
trace_dump_ret(stream, int, result);
trace_dump_ret(int, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -107,20 +103,19 @@ trace_screen_get_paramf(struct pipe_screen *_screen,
int param)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
float result;
trace_dump_call_begin(stream, "pipe_screen", "get_paramf");
trace_dump_call_begin("pipe_screen", "get_paramf");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, int, param);
trace_dump_arg(ptr, screen);
trace_dump_arg(int, param);
result = screen->get_paramf(screen, param);
trace_dump_ret(stream, float, result);
trace_dump_ret(float, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -134,23 +129,22 @@ trace_screen_is_format_supported(struct pipe_screen *_screen,
unsigned geom_flags)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
boolean result;
trace_dump_call_begin(stream, "pipe_screen", "is_format_supported");
trace_dump_call_begin("pipe_screen", "is_format_supported");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, format, format);
trace_dump_arg(stream, int, target);
trace_dump_arg(stream, uint, tex_usage);
trace_dump_arg(stream, uint, geom_flags);
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);
result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
trace_dump_ret(stream, bool, result);
trace_dump_ret(bool, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -161,20 +155,19 @@ trace_screen_texture_create(struct pipe_screen *_screen,
const struct pipe_texture *templat)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_texture *result;
trace_dump_call_begin(stream, "pipe_screen", "texture_create");
trace_dump_call_begin("pipe_screen", "texture_create");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, template, templat);
trace_dump_arg(ptr, screen);
trace_dump_arg(template, templat);
result = screen->texture_create(screen, templat);
trace_dump_ret(stream, ptr, result);
trace_dump_ret(ptr, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -187,23 +180,22 @@ trace_screen_texture_blanket(struct pipe_screen *_screen,
struct pipe_buffer *buffer)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
unsigned pitch = *ppitch;
struct pipe_texture *result;
trace_dump_call_begin(stream, "pipe_screen", "texture_blanket");
trace_dump_call_begin("pipe_screen", "texture_blanket");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, template, templat);
trace_dump_arg(stream, uint, pitch);
trace_dump_arg(stream, ptr, buffer);
trace_dump_arg(ptr, screen);
trace_dump_arg(template, templat);
trace_dump_arg(uint, pitch);
trace_dump_arg(ptr, buffer);
result = screen->texture_blanket(screen, templat, ppitch, buffer);
trace_dump_ret(stream, ptr, result);
trace_dump_ret(ptr, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -214,18 +206,17 @@ trace_screen_texture_release(struct pipe_screen *_screen,
struct pipe_texture **ptexture)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_texture *texture = *ptexture;
trace_dump_call_begin(stream, "pipe_screen", "texture_release");
trace_dump_call_begin("pipe_screen", "texture_release");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, ptr, texture);
trace_dump_arg(ptr, screen);
trace_dump_arg(ptr, texture);
screen->texture_release(screen, ptexture);
trace_dump_call_end(stream);
trace_dump_call_end();
}
static struct pipe_surface *
@ -236,24 +227,23 @@ trace_screen_get_tex_surface(struct pipe_screen *_screen,
unsigned usage)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_surface *result;
trace_dump_call_begin(stream, "pipe_screen", "get_tex_surface");
trace_dump_call_begin("pipe_screen", "get_tex_surface");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, ptr, texture);
trace_dump_arg(stream, uint, face);
trace_dump_arg(stream, uint, level);
trace_dump_arg(stream, uint, zslice);
trace_dump_arg(stream, uint, usage);
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);
result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
trace_dump_ret(stream, ptr, result);
trace_dump_ret(ptr, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -264,18 +254,17 @@ trace_screen_tex_surface_release(struct pipe_screen *_screen,
struct pipe_surface **psurface)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_surface *surface = *psurface;
trace_dump_call_begin(stream, "pipe_screen", "tex_surface_release");
trace_dump_call_begin("pipe_screen", "tex_surface_release");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, ptr, surface);
trace_dump_arg(ptr, screen);
trace_dump_arg(ptr, surface);
screen->tex_surface_release(screen, psurface);
trace_dump_call_end(stream);
trace_dump_call_end();
}
@ -285,21 +274,20 @@ trace_screen_surface_map(struct pipe_screen *_screen,
unsigned flags)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_surface *result;
trace_dump_call_begin(stream, "pipe_screen", "surface_map");
trace_dump_call_begin("pipe_screen", "surface_map");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, ptr, surface);
trace_dump_arg(stream, uint, flags);
trace_dump_arg(ptr, screen);
trace_dump_arg(ptr, surface);
trace_dump_arg(uint, flags);
result = screen->surface_map(screen, surface, flags);
trace_dump_ret(stream, ptr, result);
trace_dump_ret(ptr, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -310,17 +298,16 @@ trace_screen_surface_unmap(struct pipe_screen *_screen,
struct pipe_surface *surface)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
trace_dump_call_begin(stream, "pipe_screen", "surface_unmap");
trace_dump_call_begin("pipe_screen", "surface_unmap");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(stream, ptr, surface);
trace_dump_arg(ptr, screen);
trace_dump_arg(ptr, surface);
screen->surface_unmap(screen, surface);
trace_dump_call_end(stream);
trace_dump_call_end();
}
@ -328,20 +315,17 @@ static void
trace_screen_destroy(struct pipe_screen *_screen)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
trace_dump_call_begin(stream, "pipe_screen", "destroy");
trace_dump_call_begin("pipe_screen", "destroy");
trace_dump_arg(stream, ptr, screen);
trace_dump_arg(ptr, screen);
screen->destroy(screen);
trace_dump_call_end(stream);
trace_dump_call_end();
trace_dump_trace_end(stream);
trace_stream_close(stream);
trace_dump_trace_end();
FREE(tr_scr);
}
@ -350,26 +334,22 @@ trace_screen_destroy(struct pipe_screen *_screen)
struct pipe_screen *
trace_screen_create(struct pipe_screen *screen)
{
struct trace_stream *stream;
struct trace_screen *tr_scr;
struct pipe_winsys *winsys;
if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
return screen;
if(!screen)
goto error1;
if(!trace_dump_trace_begin())
goto error1;
tr_scr = CALLOC_STRUCT(trace_screen);
if(!tr_scr)
return NULL;
goto error2;
tr_scr->stream = stream = trace_stream_create("gallium", "trace");
if(!tr_scr->stream)
return NULL;
trace_dump_trace_begin(stream, 0);
winsys = trace_winsys_create(stream, screen->winsys);
winsys = trace_winsys_create(screen->winsys);
if(!winsys)
return NULL;
goto error3;
tr_scr->base.winsys = winsys;
tr_scr->base.destroy = trace_screen_destroy;
@ -387,14 +367,20 @@ trace_screen_create(struct pipe_screen *screen)
tr_scr->base.surface_unmap = trace_screen_surface_unmap;
tr_scr->screen = screen;
tr_scr->stream = stream = trace_winsys(winsys)->stream;
trace_dump_call_begin(stream, "", "pipe_screen_create");
trace_dump_arg_begin(stream, "winsys");
trace_dump_ptr(stream, screen->winsys);
trace_dump_arg_end(stream);
trace_dump_ret(stream, ptr, screen);
trace_dump_call_end(stream);
trace_dump_call_begin("", "pipe_screen_create");
trace_dump_arg_begin("winsys");
trace_dump_ptr(screen->winsys);
trace_dump_arg_end();
trace_dump_ret(ptr, screen);
trace_dump_call_end();
return &tr_scr->base;
error3:
FREE(tr_scr);
error2:
trace_dump_trace_end();
error1:
return screen;
}

5
src/gallium/drivers/trace/tr_screen.h
View file

@ -34,16 +34,11 @@
#include "pipe/p_screen.h"
struct trace_stream;
struct trace_screen
{
struct pipe_screen base;
struct pipe_screen *screen;
struct trace_stream *stream;
};

481
src/gallium/drivers/trace/tr_state.c
View file

@ -33,461 +33,442 @@
#include "tr_state.h"
void trace_dump_format(struct trace_stream *stream,
enum pipe_format format)
void trace_dump_format(enum pipe_format format)
{
trace_dump_enum(stream, pf_name(format) );
trace_dump_enum(pf_name(format) );
}
void trace_dump_block(struct trace_stream *stream,
const struct pipe_format_block *block)
void trace_dump_block(const struct pipe_format_block *block)
{
trace_dump_struct_begin(stream, "pipe_format_block");
trace_dump_member(stream, uint, block, size);
trace_dump_member(stream, uint, block, width);
trace_dump_member(stream, uint, block, height);
trace_dump_struct_end(stream);
trace_dump_struct_begin("pipe_format_block");
trace_dump_member(uint, block, size);
trace_dump_member(uint, block, width);
trace_dump_member(uint, block, height);
trace_dump_struct_end();
}
void trace_dump_template(struct trace_stream *stream,
const struct pipe_texture *templat)
void trace_dump_template(const struct pipe_texture *templat)
{
assert(templat);
if(!templat) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_texture");
trace_dump_struct_begin("pipe_texture");
trace_dump_member(stream, int, templat, target);
trace_dump_member(stream, format, templat, format);
trace_dump_member(int, templat, target);
trace_dump_member(format, templat, format);
trace_dump_member_begin(stream, "width");
trace_dump_array(stream, uint, templat->width, 1);
trace_dump_member_end(stream);
trace_dump_member_begin("width");
trace_dump_array(uint, templat->width, 1);
trace_dump_member_end();
trace_dump_member_begin(stream, "height");
trace_dump_array(stream, uint, templat->height, 1);
trace_dump_member_end(stream);
trace_dump_member_begin("height");
trace_dump_array(uint, templat->height, 1);
trace_dump_member_end();
trace_dump_member_begin(stream, "depth");
trace_dump_array(stream, uint, templat->depth, 1);
trace_dump_member_end(stream);
trace_dump_member_begin("depth");
trace_dump_array(uint, templat->depth, 1);
trace_dump_member_end();
trace_dump_member_begin(stream, "block");
trace_dump_block(stream, &templat->block);
trace_dump_member_end(stream);
trace_dump_member_begin("block");
trace_dump_block(&templat->block);
trace_dump_member_end();
trace_dump_member(stream, uint, templat, last_level);
trace_dump_member(stream, uint, templat, tex_usage);
trace_dump_member(uint, templat, last_level);
trace_dump_member(uint, templat, tex_usage);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_rasterizer_state(struct trace_stream *stream,
const struct pipe_rasterizer_state *state)
void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_rasterizer_state");
trace_dump_struct_begin("pipe_rasterizer_state");
trace_dump_member(stream, bool, state, flatshade);
trace_dump_member(stream, bool, state, light_twoside);
trace_dump_member(stream, uint, state, front_winding);
trace_dump_member(stream, uint, state, cull_mode);
trace_dump_member(stream, uint, state, fill_cw);
trace_dump_member(stream, uint, state, fill_ccw);
trace_dump_member(stream, bool, state, offset_cw);
trace_dump_member(stream, bool, state, offset_ccw);
trace_dump_member(stream, bool, state, scissor);
trace_dump_member(stream, bool, state, poly_smooth);
trace_dump_member(stream, bool, state, poly_stipple_enable);
trace_dump_member(stream, bool, state, point_smooth);
trace_dump_member(stream, bool, state, point_sprite);
trace_dump_member(stream, bool, state, point_size_per_vertex);
trace_dump_member(stream, bool, state, multisample);
trace_dump_member(stream, bool, state, line_smooth);
trace_dump_member(stream, bool, state, line_stipple_enable);
trace_dump_member(stream, uint, state, line_stipple_factor);
trace_dump_member(stream, uint, state, line_stipple_pattern);
trace_dump_member(stream, bool, state, line_last_pixel);
trace_dump_member(stream, bool, state, bypass_clipping);
trace_dump_member(stream, bool, state, bypass_vs);
trace_dump_member(stream, bool, state, origin_lower_left);
trace_dump_member(stream, bool, state, flatshade_first);
trace_dump_member(stream, bool, state, gl_rasterization_rules);
trace_dump_member(bool, state, flatshade);
trace_dump_member(bool, state, light_twoside);
trace_dump_member(uint, state, front_winding);
trace_dump_member(uint, state, cull_mode);
trace_dump_member(uint, state, fill_cw);
trace_dump_member(uint, state, fill_ccw);
trace_dump_member(bool, state, offset_cw);
trace_dump_member(bool, state, offset_ccw);
trace_dump_member(bool, state, scissor);
trace_dump_member(bool, state, poly_smooth);
trace_dump_member(bool, state, poly_stipple_enable);
trace_dump_member(bool, state, point_smooth);
trace_dump_member(bool, state, point_sprite);
trace_dump_member(bool, state, point_size_per_vertex);
trace_dump_member(bool, state, multisample);
trace_dump_member(bool, state, line_smooth);
trace_dump_member(bool, state, line_stipple_enable);
trace_dump_member(uint, state, line_stipple_factor);
trace_dump_member(uint, state, line_stipple_pattern);
trace_dump_member(bool, state, line_last_pixel);
trace_dump_member(bool, state, bypass_clipping);
trace_dump_member(bool, state, bypass_vs);
trace_dump_member(bool, state, origin_lower_left);
trace_dump_member(bool, state, flatshade_first);
trace_dump_member(bool, state, gl_rasterization_rules);
trace_dump_member(stream, float, state, line_width);
trace_dump_member(stream, float, state, point_size);
trace_dump_member(stream, float, state, point_size_min);
trace_dump_member(stream, float, state, point_size_max);
trace_dump_member(stream, float, state, offset_units);
trace_dump_member(stream, float, state, offset_scale);
trace_dump_member(float, state, line_width);
trace_dump_member(float, state, point_size);
trace_dump_member(float, state, point_size_min);
trace_dump_member(float, state, point_size_max);
trace_dump_member(float, state, offset_units);
trace_dump_member(float, state, offset_scale);
trace_dump_member_array(stream, uint, state, sprite_coord_mode);
trace_dump_member_array(uint, state, sprite_coord_mode);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_poly_stipple(struct trace_stream *stream,
const struct pipe_poly_stipple *state)
void trace_dump_poly_stipple(const struct pipe_poly_stipple *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_poly_stipple");
trace_dump_struct_begin("pipe_poly_stipple");
trace_dump_member_begin(stream, "stipple");
trace_dump_array(stream,
uint,
trace_dump_member_begin("stipple");
trace_dump_array(uint,
state->stipple,
Elements(state->stipple));
trace_dump_member_end(stream);
trace_dump_member_end();
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_viewport_state(struct trace_stream *stream,
const struct pipe_viewport_state *state)
void trace_dump_viewport_state(const struct pipe_viewport_state *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_viewport_state");
trace_dump_struct_begin("pipe_viewport_state");
trace_dump_member_array(stream, float, state, scale);
trace_dump_member_array(stream, float, state, translate);
trace_dump_member_array(float, state, scale);
trace_dump_member_array(float, state, translate);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_scissor_state(struct trace_stream *stream,
const struct pipe_scissor_state *state)
void trace_dump_scissor_state(const struct pipe_scissor_state *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_scissor_state");
trace_dump_struct_begin("pipe_scissor_state");
trace_dump_member(stream, uint, state, minx);
trace_dump_member(stream, uint, state, miny);
trace_dump_member(stream, uint, state, maxx);
trace_dump_member(stream, uint, state, maxy);
trace_dump_member(uint, state, minx);
trace_dump_member(uint, state, miny);
trace_dump_member(uint, state, maxx);
trace_dump_member(uint, state, maxy);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_clip_state(struct trace_stream *stream,
const struct pipe_clip_state *state)
void trace_dump_clip_state(const struct pipe_clip_state *state)
{
unsigned i;
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_scissor_state");
trace_dump_struct_begin("pipe_scissor_state");
trace_dump_member_begin(stream, "ucp");
trace_dump_array_begin(stream);
trace_dump_member_begin("ucp");
trace_dump_array_begin();
for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i)
trace_dump_array(stream, float, state->ucp[i], 4);
trace_dump_array_end(stream);
trace_dump_member_end(stream);
trace_dump_array(float, state->ucp[i], 4);
trace_dump_array_end();
trace_dump_member_end();
trace_dump_member(stream, uint, state, nr);
trace_dump_member(uint, state, nr);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_constant_buffer(struct trace_stream *stream,
const struct pipe_constant_buffer *state)
void trace_dump_constant_buffer(const struct pipe_constant_buffer *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_constant_buffer");
trace_dump_struct_begin("pipe_constant_buffer");
trace_dump_member(stream, ptr, state, buffer);
trace_dump_member(stream, uint, state, size);
trace_dump_member(ptr, state, buffer);
trace_dump_member(uint, state, size);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_shader_state(struct trace_stream *stream,
const struct pipe_shader_state *state)
void trace_dump_shader_state(const struct pipe_shader_state *state)
{
static char str[8192];
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
tgsi_dump_str(state->tokens, 0, str, sizeof(str));
trace_dump_struct_begin(stream, "pipe_shader_state");
trace_dump_struct_begin("pipe_shader_state");
trace_dump_member_begin(stream, "tokens");
trace_dump_string(stream, str);
trace_dump_member_end(stream);
trace_dump_member_begin("tokens");
trace_dump_string(str);
trace_dump_member_end();
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_depth_stencil_alpha_state(struct trace_stream *stream,
const struct pipe_depth_stencil_alpha_state *state)
void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state)
{
unsigned i;
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state");
trace_dump_struct_begin("pipe_depth_stencil_alpha_state");
trace_dump_member_begin(stream, "depth");
trace_dump_struct_begin(stream, "pipe_depth_state");
trace_dump_member(stream, bool, &state->depth, enabled);
trace_dump_member(stream, bool, &state->depth, writemask);
trace_dump_member(stream, uint, &state->depth, func);
trace_dump_member(stream, bool, &state->depth, occlusion_count);
trace_dump_struct_end(stream);
trace_dump_member_end(stream);
trace_dump_member_begin("depth");
trace_dump_struct_begin("pipe_depth_state");
trace_dump_member(bool, &state->depth, enabled);
trace_dump_member(bool, &state->depth, writemask);
trace_dump_member(uint, &state->depth, func);
trace_dump_member(bool, &state->depth, occlusion_count);
trace_dump_struct_end();
trace_dump_member_end();
trace_dump_member_begin(stream, "stencil");
trace_dump_array_begin(stream);
trace_dump_member_begin("stencil");
trace_dump_array_begin();
for(i = 0; i < Elements(state->stencil); ++i) {
trace_dump_elem_begin(stream);
trace_dump_struct_begin(stream, "pipe_stencil_state");
trace_dump_member(stream, bool, &state->stencil[i], enabled);
trace_dump_member(stream, uint, &state->stencil[i], func);
trace_dump_member(stream, uint, &state->stencil[i], fail_op);
trace_dump_member(stream, uint, &state->stencil[i], zpass_op);
trace_dump_member(stream, uint, &state->stencil[i], zfail_op);
trace_dump_member(stream, uint, &state->stencil[i], ref_value);
trace_dump_member(stream, uint, &state->stencil[i], value_mask);
trace_dump_member(stream, uint, &state->stencil[i], write_mask);
trace_dump_struct_end(stream);
trace_dump_elem_end(stream);
trace_dump_elem_begin();
trace_dump_struct_begin("pipe_stencil_state");
trace_dump_member(bool, &state->stencil[i], enabled);
trace_dump_member(uint, &state->stencil[i], func);
trace_dump_member(uint, &state->stencil[i], fail_op);
trace_dump_member(uint, &state->stencil[i], zpass_op);
trace_dump_member(uint, &state->stencil[i], zfail_op);
trace_dump_member(uint, &state->stencil[i], ref_value);
trace_dump_member(uint, &state->stencil[i], value_mask);
trace_dump_member(uint, &state->stencil[i], write_mask);
trace_dump_struct_end();
trace_dump_elem_end();
}
trace_dump_array_end(stream);
trace_dump_member_end(stream);
trace_dump_array_end();
trace_dump_member_end();
trace_dump_member_begin(stream, "alpha");
trace_dump_struct_begin(stream, "pipe_alpha_state");
trace_dump_member(stream, bool, &state->alpha, enabled);
trace_dump_member(stream, uint, &state->alpha, func);
trace_dump_member(stream, float, &state->alpha, ref);
trace_dump_struct_end(stream);
trace_dump_member_end(stream);
trace_dump_member_begin("alpha");
trace_dump_struct_begin("pipe_alpha_state");
trace_dump_member(bool, &state->alpha, enabled);
trace_dump_member(uint, &state->alpha, func);
trace_dump_member(float, &state->alpha, ref);
trace_dump_struct_end();
trace_dump_member_end();
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_blend_state(struct trace_stream *stream,
const struct pipe_blend_state *state)
void trace_dump_blend_state(const struct pipe_blend_state *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_blend_state");
trace_dump_struct_begin("pipe_blend_state");
trace_dump_member(stream, bool, state, blend_enable);
trace_dump_member(bool, state, blend_enable);
trace_dump_member(stream, uint, state, rgb_func);
trace_dump_member(stream, uint, state, rgb_src_factor);
trace_dump_member(stream, uint, state, rgb_dst_factor);
trace_dump_member(uint, state, rgb_func);
trace_dump_member(uint, state, rgb_src_factor);
trace_dump_member(uint, state, rgb_dst_factor);
trace_dump_member(stream, uint, state, alpha_func);
trace_dump_member(stream, uint, state, alpha_src_factor);
trace_dump_member(stream, uint, state, alpha_dst_factor);
trace_dump_member(uint, state, alpha_func);
trace_dump_member(uint, state, alpha_src_factor);
trace_dump_member(uint, state, alpha_dst_factor);
trace_dump_member(stream, bool, state, logicop_enable);
trace_dump_member(stream, uint, state, logicop_func);
trace_dump_member(bool, state, logicop_enable);
trace_dump_member(uint, state, logicop_func);
trace_dump_member(stream, uint, state, colormask);
trace_dump_member(stream, bool, state, dither);
trace_dump_member(uint, state, colormask);
trace_dump_member(bool, state, dither);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_blend_color(struct trace_stream *stream,
const struct pipe_blend_color *state)
void trace_dump_blend_color(const struct pipe_blend_color *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_blend_color");
trace_dump_struct_begin("pipe_blend_color");
trace_dump_member_array(stream, float, state, color);
trace_dump_member_array(float, state, color);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_framebuffer_state(struct trace_stream *stream,
const struct pipe_framebuffer_state *state)
void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state)
{
trace_dump_struct_begin(stream, "pipe_framebuffer_state");
trace_dump_struct_begin("pipe_framebuffer_state");
trace_dump_member(stream, uint, state, width);
trace_dump_member(stream, uint, state, height);
trace_dump_member(stream, uint, state, num_cbufs);
trace_dump_member_array(stream, ptr, state, cbufs);
trace_dump_member(stream, ptr, state, zsbuf);
trace_dump_member(uint, state, width);
trace_dump_member(uint, state, height);
trace_dump_member(uint, state, num_cbufs);
trace_dump_member_array(ptr, state, cbufs);
trace_dump_member(ptr, state, zsbuf);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_sampler_state(struct trace_stream *stream,
const struct pipe_sampler_state *state)
void trace_dump_sampler_state(const struct pipe_sampler_state *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_sampler_state");
trace_dump_struct_begin("pipe_sampler_state");
trace_dump_member(stream, uint, state, wrap_s);
trace_dump_member(stream, uint, state, wrap_t);
trace_dump_member(stream, uint, state, wrap_r);
trace_dump_member(stream, uint, state, min_img_filter);
trace_dump_member(stream, uint, state, min_mip_filter);
trace_dump_member(stream, uint, state, mag_img_filter);
trace_dump_member(stream, bool, state, compare_mode);
trace_dump_member(stream, uint, state, compare_func);
trace_dump_member(stream, bool, state, normalized_coords);
trace_dump_member(stream, uint, state, prefilter);
trace_dump_member(stream, float, state, shadow_ambient);
trace_dump_member(stream, float, state, lod_bias);
trace_dump_member(stream, float, state, min_lod);
trace_dump_member(stream, float, state, max_lod);
trace_dump_member_array(stream, float, state, border_color);
trace_dump_member(stream, float, state, max_anisotropy);
trace_dump_member(uint, state, wrap_s);
trace_dump_member(uint, state, wrap_t);
trace_dump_member(uint, state, wrap_r);
trace_dump_member(uint, state, min_img_filter);
trace_dump_member(uint, state, min_mip_filter);
trace_dump_member(uint, state, mag_img_filter);
trace_dump_member(bool, state, compare_mode);
trace_dump_member(uint, state, compare_func);
trace_dump_member(bool, state, normalized_coords);
trace_dump_member(uint, state, prefilter);
trace_dump_member(float, state, shadow_ambient);
trace_dump_member(float, state, lod_bias);
trace_dump_member(float, state, min_lod);
trace_dump_member(float, state, max_lod);
trace_dump_member_array(float, state, border_color);
trace_dump_member(float, state, max_anisotropy);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_surface(struct trace_stream *stream,
const struct pipe_surface *state)
void trace_dump_surface(const struct pipe_surface *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_surface");
trace_dump_struct_begin("pipe_surface");
trace_dump_member(stream, ptr, state, buffer);
trace_dump_member(stream, format, state, format);
trace_dump_member(stream, uint, state, status);
trace_dump_member(stream, uint, state, clear_value);
trace_dump_member(stream, uint, state, width);
trace_dump_member(stream, uint, state, height);
trace_dump_member(ptr, state, buffer);
trace_dump_member(format, state, format);
trace_dump_member(uint, state, status);
trace_dump_member(uint, state, clear_value);
trace_dump_member(uint, state, width);
trace_dump_member(uint, state, height);
trace_dump_member_begin(stream, "block");
trace_dump_block(stream, &state->block);
trace_dump_member_end(stream);
trace_dump_member_begin("block");
trace_dump_block(&state->block);
trace_dump_member_end();
trace_dump_member(stream, uint, state, nblocksx);
trace_dump_member(stream, uint, state, nblocksy);
trace_dump_member(stream, uint, state, stride);
trace_dump_member(stream, uint, state, layout);
trace_dump_member(stream, uint, state, offset);
trace_dump_member(stream, uint, state, refcount);
trace_dump_member(stream, uint, state, usage);
trace_dump_member(uint, state, nblocksx);
trace_dump_member(uint, state, nblocksy);
trace_dump_member(uint, state, stride);
trace_dump_member(uint, state, layout);
trace_dump_member(uint, state, offset);
trace_dump_member(uint, state, refcount);
trace_dump_member(uint, state, usage);
trace_dump_member(stream, ptr, state, texture);
trace_dump_member(stream, uint, state, face);
trace_dump_member(stream, uint, state, level);
trace_dump_member(stream, uint, state, zslice);
trace_dump_member(ptr, state, texture);
trace_dump_member(uint, state, face);
trace_dump_member(uint, state, level);
trace_dump_member(uint, state, zslice);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_vertex_buffer(struct trace_stream *stream,
const struct pipe_vertex_buffer *state)
void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_vertex_buffer");
trace_dump_struct_begin("pipe_vertex_buffer");
trace_dump_member(stream, uint, state, pitch);
trace_dump_member(stream, uint, state, max_index);
trace_dump_member(stream, uint, state, buffer_offset);
trace_dump_member(stream, ptr, state, buffer);
trace_dump_member(uint, state, pitch);
trace_dump_member(uint, state, max_index);
trace_dump_member(uint, state, buffer_offset);
trace_dump_member(ptr, state, buffer);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}
void trace_dump_vertex_element(struct trace_stream *stream,
const struct pipe_vertex_element *state)
void trace_dump_vertex_element(const struct pipe_vertex_element *state)
{
assert(state);
if(!state) {
trace_dump_null(stream);
trace_dump_null();
return;
}
trace_dump_struct_begin(stream, "pipe_vertex_element");
trace_dump_struct_begin("pipe_vertex_element");
trace_dump_member(stream, uint, state, src_offset);
trace_dump_member(uint, state, src_offset);
trace_dump_member(stream, uint, state, vertex_buffer_index);
trace_dump_member(stream, uint, state, nr_components);
trace_dump_member(uint, state, vertex_buffer_index);
trace_dump_member(uint, state, nr_components);
trace_dump_member(stream, format, state, src_format);
trace_dump_member(format, state, src_format);
trace_dump_struct_end(stream);
trace_dump_struct_end();
}

59
src/gallium/drivers/trace/tr_state.h
View file

@ -4,7 +4,7 @@
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation streams (the
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
@ -33,63 +33,44 @@
#include "pipe/p_shader_tokens.h"
void trace_dump_format(struct trace_stream *stream,
enum pipe_format format);
void trace_dump_format(enum pipe_format format);
void trace_dump_block(struct trace_stream *stream,
const struct pipe_format_block *block);
void trace_dump_block(const struct pipe_format_block *block);
void trace_dump_template(struct trace_stream *stream,
const struct pipe_texture *templat);
void trace_dump_template(const struct pipe_texture *templat);
void trace_dump_rasterizer_state(struct trace_stream *stream,
const struct pipe_rasterizer_state *state);
void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state);
void trace_dump_poly_stipple(struct trace_stream *stream,
const struct pipe_poly_stipple *state);
void trace_dump_poly_stipple(const struct pipe_poly_stipple *state);
void trace_dump_viewport_state(struct trace_stream *stream,
const struct pipe_viewport_state *state);
void trace_dump_viewport_state(const struct pipe_viewport_state *state);
void trace_dump_scissor_state(struct trace_stream *stream,
const struct pipe_scissor_state *state);
void trace_dump_scissor_state(const struct pipe_scissor_state *state);
void trace_dump_clip_state(struct trace_stream *stream,
const struct pipe_clip_state *state);
void trace_dump_clip_state(const struct pipe_clip_state *state);
void trace_dump_constant_buffer(struct trace_stream *stream,
const struct pipe_constant_buffer *state);
void trace_dump_constant_buffer(const struct pipe_constant_buffer *state);
void trace_dump_token(struct trace_stream *stream,
const struct tgsi_token *token);
void trace_dump_token(const struct tgsi_token *token);
void trace_dump_shader_state(struct trace_stream *stream,
const struct pipe_shader_state *state);
void trace_dump_shader_state(const struct pipe_shader_state *state);
void trace_dump_depth_stencil_alpha_state(struct trace_stream *stream,
const struct pipe_depth_stencil_alpha_state *state);
void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state);
void trace_dump_blend_state(struct trace_stream *stream,
const struct pipe_blend_state *state);
void trace_dump_blend_state(const struct pipe_blend_state *state);
void trace_dump_blend_color(struct trace_stream *stream,
const struct pipe_blend_color *state);
void trace_dump_blend_color(const struct pipe_blend_color *state);
void trace_dump_framebuffer_state(struct trace_stream *stream,
const struct pipe_framebuffer_state *state);
void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state);
void trace_dump_sampler_state(struct trace_stream *stream,
const struct pipe_sampler_state *state);
void trace_dump_sampler_state(const struct pipe_sampler_state *state);
void trace_dump_surface(struct trace_stream *stream,
const struct pipe_surface *state);
void trace_dump_surface(const struct pipe_surface *state);
void trace_dump_vertex_buffer(struct trace_stream *stream,
const struct pipe_vertex_buffer *state);
void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state);
void trace_dump_vertex_element(struct trace_stream *stream,
const struct pipe_vertex_element *state);
void trace_dump_vertex_element(const struct pipe_vertex_element *state);
#endif /* TR_STATE_H */

5
src/gallium/drivers/trace/tr_stream.h
View file

@ -4,7 +4,7 @@
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation streams (the
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
@ -28,6 +28,9 @@
/**
* @file
* Cross-platform sequential access stream abstraction.
*
* These are really general purpose file access functions, and might one day
* be moved into the util module.
*/
#ifndef TR_STREAM_H

185
src/gallium/drivers/trace/tr_winsys.c
View file

@ -29,7 +29,6 @@
#include "pipe/p_state.h"
#include "util/u_hash_table.h"
#include "tr_stream.h"
#include "tr_dump.h"
#include "tr_state.h"
#include "tr_winsys.h"
@ -51,19 +50,18 @@ static const char *
trace_winsys_get_name(struct pipe_winsys *_winsys)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
const char *result;
trace_dump_call_begin(stream, "pipe_winsys", "get_name");
trace_dump_call_begin("pipe_winsys", "get_name");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(ptr, winsys);
result = winsys->get_name(winsys);
trace_dump_ret(stream, string, result);
trace_dump_ret(string, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -75,18 +73,17 @@ trace_winsys_flush_frontbuffer(struct pipe_winsys *_winsys,
void *context_private)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
trace_dump_call_begin(stream, "pipe_winsys", "flush_frontbuffer");
trace_dump_call_begin("pipe_winsys", "flush_frontbuffer");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(stream, ptr, surface);
trace_dump_arg(stream, ptr, context_private);
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, surface);
trace_dump_arg(ptr, context_private);
winsys->flush_frontbuffer(winsys, surface, context_private);
trace_dump_call_end(stream);
trace_dump_call_end();
}
@ -94,19 +91,18 @@ static struct pipe_surface *
trace_winsys_surface_alloc(struct pipe_winsys *_winsys)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_surface *result;
trace_dump_call_begin(stream, "pipe_winsys", "surface_alloc");
trace_dump_call_begin("pipe_winsys", "surface_alloc");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(ptr, winsys);
result = winsys->surface_alloc(winsys);
trace_dump_ret(stream, ptr, result);
trace_dump_ret(ptr, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -121,19 +117,18 @@ trace_winsys_surface_alloc_storage(struct pipe_winsys *_winsys,
unsigned tex_usage)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
int result;
trace_dump_call_begin(stream, "pipe_winsys", "surface_alloc_storage");
trace_dump_call_begin("pipe_winsys", "surface_alloc_storage");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(stream, ptr, surface);
trace_dump_arg(stream, uint, width);
trace_dump_arg(stream, uint, height);
trace_dump_arg(stream, format, format);
trace_dump_arg(stream, uint, flags);
trace_dump_arg(stream, uint, tex_usage);
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, surface);
trace_dump_arg(uint, width);
trace_dump_arg(uint, height);
trace_dump_arg(format, format);
trace_dump_arg(uint, flags);
trace_dump_arg(uint, tex_usage);
result = winsys->surface_alloc_storage(winsys,
surface,
@ -142,9 +137,9 @@ trace_winsys_surface_alloc_storage(struct pipe_winsys *_winsys,
flags,
tex_usage);
trace_dump_ret(stream, int, result);
trace_dump_ret(int, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -155,18 +150,17 @@ trace_winsys_surface_release(struct pipe_winsys *_winsys,
struct pipe_surface **psurface)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_surface *surface = *psurface;
trace_dump_call_begin(stream, "pipe_winsys", "surface_release");
trace_dump_call_begin("pipe_winsys", "surface_release");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(stream, ptr, surface);
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, surface);
winsys->surface_release(winsys, psurface);
trace_dump_call_end(stream);
trace_dump_call_end();
}
@ -177,22 +171,21 @@ trace_winsys_buffer_create(struct pipe_winsys *_winsys,
unsigned size)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_buffer *buffer;
trace_dump_call_begin(stream, "pipe_winsys", "buffer_create");
trace_dump_call_begin("pipe_winsys", "buffer_create");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(stream, uint, alignment);
trace_dump_arg(stream, uint, usage);
trace_dump_arg(stream, uint, size);
trace_dump_arg(ptr, winsys);
trace_dump_arg(uint, alignment);
trace_dump_arg(uint, usage);
trace_dump_arg(uint, size);
buffer = winsys->buffer_create(winsys, alignment, usage, size);
trace_dump_ret(stream, ptr, buffer);
trace_dump_ret(ptr, buffer);
trace_dump_call_end(stream);
trace_dump_call_end();
/* Zero the buffer to avoid dumping uninitialized memory */
if(buffer->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
@ -214,21 +207,20 @@ trace_winsys_user_buffer_create(struct pipe_winsys *_winsys,
unsigned bytes)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_buffer *result;
trace_dump_call_begin(stream, "pipe_winsys", "user_buffer_create");
trace_dump_call_begin("pipe_winsys", "user_buffer_create");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(stream, ptr, ptr);
trace_dump_arg(stream, uint, bytes);
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, ptr);
trace_dump_arg(uint, bytes);
result = winsys->user_buffer_create(winsys, ptr, bytes);
trace_dump_ret(stream, ptr, result);
trace_dump_ret(ptr, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -260,27 +252,26 @@ trace_winsys_buffer_unmap(struct pipe_winsys *_winsys,
struct pipe_buffer *buffer)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
const void *map;
map = hash_table_get(tr_ws->buffer_maps, buffer);
if(map) {
trace_dump_call_begin(stream, "pipe_winsys", "buffer_write");
trace_dump_call_begin("pipe_winsys", "buffer_write");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(ptr, winsys);
trace_dump_arg(stream, ptr, buffer);
trace_dump_arg(ptr, buffer);
trace_dump_arg_begin(stream, "data");
trace_dump_bytes(stream, map, buffer->size);
trace_dump_arg_end(stream);
trace_dump_arg_begin("data");
trace_dump_bytes(map, buffer->size);
trace_dump_arg_end();
trace_dump_arg_begin(stream, "size");
trace_dump_uint(stream, buffer->size);
trace_dump_arg_end(stream);
trace_dump_arg_begin("size");
trace_dump_uint(buffer->size);
trace_dump_arg_end();
trace_dump_call_end(stream);
trace_dump_call_end();
hash_table_remove(tr_ws->buffer_maps, buffer);
}
@ -294,17 +285,16 @@ trace_winsys_buffer_destroy(struct pipe_winsys *_winsys,
struct pipe_buffer *buffer)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
trace_dump_call_begin(stream, "pipe_winsys", "buffer_destroy");
trace_dump_call_begin("pipe_winsys", "buffer_destroy");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(stream, ptr, buffer);
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, buffer);
winsys->buffer_destroy(winsys, buffer);
trace_dump_call_end(stream);
trace_dump_call_end();
}
@ -314,19 +304,18 @@ trace_winsys_fence_reference(struct pipe_winsys *_winsys,
struct pipe_fence_handle *src)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_fence_handle *dst = *pdst;
trace_dump_call_begin(stream, "pipe_winsys", "fence_reference");
trace_dump_call_begin("pipe_winsys", "fence_reference");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(stream, ptr, dst);
trace_dump_arg(stream, ptr, src);
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, dst);
trace_dump_arg(ptr, src);
winsys->fence_reference(winsys, pdst, src);
trace_dump_call_end(stream);
trace_dump_call_end();
}
@ -336,21 +325,20 @@ trace_winsys_fence_signalled(struct pipe_winsys *_winsys,
unsigned flag)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
int result;
trace_dump_call_begin(stream, "pipe_winsys", "fence_signalled");
trace_dump_call_begin("pipe_winsys", "fence_signalled");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(stream, ptr, fence);
trace_dump_arg(stream, uint, flag);
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, fence);
trace_dump_arg(uint, flag);
result = winsys->fence_signalled(winsys, fence, flag);
trace_dump_ret(stream, int, result);
trace_dump_ret(int, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -362,21 +350,20 @@ trace_winsys_fence_finish(struct pipe_winsys *_winsys,
unsigned flag)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
int result;
trace_dump_call_begin(stream, "pipe_winsys", "fence_finish");
trace_dump_call_begin("pipe_winsys", "fence_finish");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(stream, ptr, fence);
trace_dump_arg(stream, uint, flag);
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, fence);
trace_dump_arg(uint, flag);
result = winsys->fence_finish(winsys, fence, flag);
trace_dump_ret(stream, int, result);
trace_dump_ret(int, result);
trace_dump_call_end(stream);
trace_dump_call_end();
return result;
}
@ -386,18 +373,17 @@ static void
trace_winsys_destroy(struct pipe_winsys *_winsys)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
trace_dump_call_begin(stream, "pipe_winsys", "destroy");
trace_dump_call_begin("pipe_winsys", "destroy");
trace_dump_arg(stream, ptr, winsys);
trace_dump_arg(ptr, winsys);
/*
winsys->destroy(winsys);
*/
trace_dump_call_end(stream);
trace_dump_call_end();
hash_table_destroy(tr_ws->buffer_maps);
@ -406,15 +392,16 @@ trace_winsys_destroy(struct pipe_winsys *_winsys)
struct pipe_winsys *
trace_winsys_create(struct trace_stream *stream,
struct pipe_winsys *winsys)
trace_winsys_create(struct pipe_winsys *winsys)
{
struct trace_winsys *tr_ws;
if(!winsys)
goto error1;
tr_ws = CALLOC_STRUCT(trace_winsys);
if(!tr_ws)
return NULL;
goto error1;
tr_ws->base.destroy = trace_winsys_destroy;
tr_ws->base.get_name = trace_winsys_get_name;
@ -432,16 +419,20 @@ trace_winsys_create(struct trace_stream *stream,
tr_ws->base.fence_finish = trace_winsys_fence_finish;
tr_ws->winsys = winsys;
tr_ws->stream = stream;
tr_ws->buffer_maps = hash_table_create(trace_buffer_hash,
trace_buffer_compare);
if(!tr_ws->buffer_maps)
return NULL;
goto error2;
trace_dump_call_begin(stream, "", "pipe_winsys_create");
trace_dump_ret(stream, ptr, winsys);
trace_dump_call_end(stream);
trace_dump_call_begin("", "pipe_winsys_create");
trace_dump_ret(ptr, winsys);
trace_dump_call_end();
return &tr_ws->base;
error2:
FREE(tr_ws);
error1:
return winsys;
}

6
src/gallium/drivers/trace/tr_winsys.h
View file

@ -35,7 +35,6 @@
struct hash_table;
struct trace_stream;
struct trace_winsys
@ -44,8 +43,6 @@ struct trace_winsys
struct pipe_winsys *winsys;
struct trace_stream *stream;
struct hash_table *buffer_maps;
};
@ -60,8 +57,7 @@ trace_winsys(struct pipe_winsys *winsys)
struct pipe_winsys *
trace_winsys_create(struct trace_stream *stream,
struct pipe_winsys *winsys);
trace_winsys_create(struct pipe_winsys *winsys);
#endif /* TR_WINSYS_H_ */