1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
/*
* Copyright © 2012 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* 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, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* 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 NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
/** \file marshal.h
*
* Declarations of functions related to marshalling GL calls from a client
* thread to a server thread.
*/
#ifndef MARSHAL_H
#define MARSHAL_H
#include "main/glthread.h"
#include "main/context.h"
struct marshal_cmd_base
{
/**
* Type of command. See enum marshal_dispatch_cmd_id.
*/
uint16_t cmd_id;
/**
* Size of command, in multiples of 4 bytes, including cmd_base.
*/
uint16_t cmd_size;
};
static inline void *
_mesa_glthread_allocate_command(struct gl_context *ctx,
uint16_t cmd_id,
size_t size)
{
struct glthread_state *glthread = ctx->GLThread;
struct marshal_cmd_base *cmd_base;
if (unlikely(glthread->batch->used + size > MARSHAL_MAX_CMD_SIZE))
_mesa_glthread_flush_batch(ctx);
cmd_base = (struct marshal_cmd_base *)
&glthread->batch->buffer[glthread->batch->used];
glthread->batch->used += size;
cmd_base->cmd_id = cmd_id;
cmd_base->cmd_size = size;
return cmd_base;
}
#define DEBUG_MARSHAL_PRINT_CALLS 0
static inline void
debug_print_sync(const char *func)
{
#if DEBUG_MARSHAL_PRINT_CALLS
printf("sync: %s\n", func);
#endif
}
static inline void
debug_print_marshal(const char *func)
{
#if DEBUG_MARSHAL_PRINT_CALLS
printf("marshal: %s\n", func);
#endif
}
static inline void
debug_print_unmarshal(const char *func)
{
#if DEBUG_MARSHAL_PRINT_CALLS
printf("unmarshal: %s\n", func);
#endif
}
struct _glapi_table *
_mesa_create_marshal_table(const struct gl_context *ctx);
size_t
_mesa_unmarshal_dispatch_cmd(struct gl_context *ctx, const void *cmd);
static inline void
_mesa_post_marshal_hook(struct gl_context *ctx)
{
/* This can be enabled for debugging whether a failure is a synchronization
* problem between the main thread and the worker thread, or a failure in
* how we actually marshal.
*/
if (false)
_mesa_glthread_finish(ctx);
}
#endif /* MARSHAL_H */
|
