Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5564 | serge | 1 | /* |
2 | Copyright (C) Intel Corp. 2006. All Rights Reserved. |
||
3 | Intel funded Tungsten Graphics to |
||
4 | develop this 3D driver. |
||
5 | |||
6 | Permission is hereby granted, free of charge, to any person obtaining |
||
7 | a copy of this software and associated documentation files (the |
||
8 | "Software"), to deal in the Software without restriction, including |
||
9 | without limitation the rights to use, copy, modify, merge, publish, |
||
10 | distribute, sublicense, and/or sell copies of the Software, and to |
||
11 | permit persons to whom the Software is furnished to do so, subject to |
||
12 | the following conditions: |
||
13 | |||
14 | The above copyright notice and this permission notice (including the |
||
15 | next paragraph) shall be included in all copies or substantial |
||
16 | portions of the Software. |
||
17 | |||
18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
||
19 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
||
20 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
||
21 | IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE |
||
22 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION |
||
23 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
||
24 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
||
25 | |||
26 | **********************************************************************/ |
||
27 | /* |
||
28 | * Authors: |
||
29 | * Keith Whitwell |
||
30 | */ |
||
31 | |||
32 | #include "brw_state.h" |
||
33 | #include "intel_batchbuffer.h" |
||
34 | #include "main/imports.h" |
||
35 | #include "util/ralloc.h" |
||
36 | |||
37 | static void |
||
38 | brw_track_state_batch(struct brw_context *brw, |
||
39 | enum aub_state_struct_type type, |
||
40 | uint32_t offset, |
||
41 | int size, |
||
42 | int index) |
||
43 | { |
||
44 | struct intel_batchbuffer *batch = &brw->batch; |
||
45 | |||
46 | if (!brw->state_batch_list) { |
||
47 | /* Our structs are always aligned to at least 32 bytes, so |
||
48 | * our array doesn't need to be any larger |
||
49 | */ |
||
50 | brw->state_batch_list = ralloc_size(brw, sizeof(*brw->state_batch_list) * |
||
51 | batch->bo->size / 32); |
||
52 | } |
||
53 | |||
54 | brw->state_batch_list[brw->state_batch_count].offset = offset; |
||
55 | brw->state_batch_list[brw->state_batch_count].size = size; |
||
56 | brw->state_batch_list[brw->state_batch_count].type = type; |
||
57 | brw->state_batch_list[brw->state_batch_count].index = index; |
||
58 | brw->state_batch_count++; |
||
59 | } |
||
60 | |||
61 | /** |
||
62 | * Convenience function to populate a single drm_intel_aub_annotation data |
||
63 | * structure. |
||
64 | */ |
||
65 | static inline void |
||
66 | make_annotation(drm_intel_aub_annotation *annotation, uint32_t type, |
||
67 | uint32_t subtype, uint32_t ending_offset) |
||
68 | { |
||
69 | annotation->type = type; |
||
70 | annotation->subtype = subtype; |
||
71 | annotation->ending_offset = ending_offset; |
||
72 | } |
||
73 | |||
74 | /** |
||
75 | * Generate a set of aub file annotations for the current batch buffer, and |
||
76 | * deliver them to DRM. |
||
77 | * |
||
78 | * The "used" section of the batch buffer (the portion containing batch |
||
79 | * commands) is annotated with AUB_TRACE_TYPE_BATCH. The remainder of the |
||
80 | * batch buffer (which contains data structures pointed to by batch commands) |
||
81 | * is annotated according to the type of each data structure. |
||
82 | */ |
||
83 | void |
||
84 | brw_annotate_aub(struct brw_context *brw) |
||
85 | { |
||
86 | unsigned annotation_count = 2 * brw->state_batch_count + 1; |
||
87 | drm_intel_aub_annotation annotations[annotation_count]; |
||
88 | int a = 0; |
||
89 | make_annotation(&annotations[a++], AUB_TRACE_TYPE_BATCH, 0, |
||
90 | 4*brw->batch.used); |
||
91 | for (int i = brw->state_batch_count; i-- > 0; ) { |
||
92 | uint32_t type = brw->state_batch_list[i].type; |
||
93 | uint32_t start_offset = brw->state_batch_list[i].offset; |
||
94 | uint32_t end_offset = start_offset + brw->state_batch_list[i].size; |
||
95 | make_annotation(&annotations[a++], AUB_TRACE_TYPE_NOTYPE, 0, |
||
96 | start_offset); |
||
97 | make_annotation(&annotations[a++], AUB_TRACE_TYPE(type), |
||
98 | AUB_TRACE_SUBTYPE(type), end_offset); |
||
99 | } |
||
100 | assert(a == annotation_count); |
||
101 | drm_intel_bufmgr_gem_set_aub_annotations(brw->batch.bo, annotations, |
||
102 | annotation_count); |
||
103 | } |
||
104 | |||
105 | /** |
||
106 | * Allocates a block of space in the batchbuffer for indirect state. |
||
107 | * |
||
108 | * We don't want to allocate separate BOs for every bit of indirect |
||
109 | * state in the driver. It means overallocating by a significant |
||
110 | * margin (4096 bytes, even if the object is just a 20-byte surface |
||
111 | * state), and more buffers to walk and count for aperture size checking. |
||
112 | * |
||
113 | * However, due to the restrictions imposed by the aperture size |
||
114 | * checking performance hacks, we can't have the batch point at a |
||
115 | * separate indirect state buffer, because once the batch points at |
||
116 | * it, no more relocations can be added to it. So, we sneak these |
||
117 | * buffers in at the top of the batchbuffer. |
||
118 | */ |
||
119 | void * |
||
120 | __brw_state_batch(struct brw_context *brw, |
||
121 | enum aub_state_struct_type type, |
||
122 | int size, |
||
123 | int alignment, |
||
124 | int index, |
||
125 | uint32_t *out_offset) |
||
126 | |||
127 | { |
||
128 | struct intel_batchbuffer *batch = &brw->batch; |
||
129 | uint32_t offset; |
||
130 | |||
131 | assert(size < batch->bo->size); |
||
132 | offset = ROUND_DOWN_TO(batch->state_batch_offset - size, alignment); |
||
133 | |||
134 | /* If allocating from the top would wrap below the batchbuffer, or |
||
135 | * if the batch's used space (plus the reserved pad) collides with our |
||
136 | * space, then flush and try again. |
||
137 | */ |
||
138 | if (batch->state_batch_offset < size || |
||
139 | offset < 4*batch->used + batch->reserved_space) { |
||
140 | intel_batchbuffer_flush(brw); |
||
141 | offset = ROUND_DOWN_TO(batch->state_batch_offset - size, alignment); |
||
142 | } |
||
143 | |||
144 | batch->state_batch_offset = offset; |
||
145 | |||
146 | if (unlikely(INTEL_DEBUG & (DEBUG_BATCH | DEBUG_AUB))) |
||
147 | brw_track_state_batch(brw, type, offset, size, index); |
||
148 | |||
149 | *out_offset = offset; |
||
150 | return batch->map + (offset>>2); |
||
151 | }>>> |