Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5564 | serge | 1 | /* |
2 | * Copyright © 2012 Intel Corporation |
||
3 | * |
||
4 | * Permission is hereby granted, free of charge, to any person obtaining a |
||
5 | * copy of this software and associated documentation files (the "Software"), |
||
6 | * to deal in the Software without restriction, including without limitation |
||
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||
8 | * and/or sell copies of the Software, and to permit persons to whom the |
||
9 | * Software is furnished to do so, subject to the following conditions: |
||
10 | * |
||
11 | * The above copyright notice and this permission notice (including the next |
||
12 | * paragraph) shall be included in all copies or substantial portions of the |
||
13 | * Software. |
||
14 | * |
||
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||
18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||
20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||
21 | * DEALINGS IN THE SOFTWARE. |
||
22 | */ |
||
23 | #include |
||
24 | #include "main/mtypes.h" |
||
25 | #include "main/macros.h" |
||
26 | #include "util/ralloc.h" |
||
27 | #include "uniform_initializer_utils.h" |
||
28 | #include |
||
29 | |||
30 | void |
||
31 | fill_storage_array_with_sentinels(gl_constant_value *storage, |
||
32 | unsigned data_size, |
||
33 | unsigned red_zone_size) |
||
34 | { |
||
35 | for (unsigned i = 0; i < data_size; i++) |
||
36 | storage[i].u = 0xDEADBEEF; |
||
37 | |||
38 | for (unsigned i = 0; i < red_zone_size; i++) |
||
39 | storage[data_size + i].u = 0xBADDC0DE; |
||
40 | } |
||
41 | |||
42 | /** |
||
43 | * Verfiy that markers past the end of the real uniform are unmodified |
||
44 | */ |
||
45 | static ::testing::AssertionResult |
||
46 | red_zone_is_intact(gl_constant_value *storage, |
||
47 | unsigned data_size, |
||
48 | unsigned red_zone_size) |
||
49 | { |
||
50 | for (unsigned i = 0; i < red_zone_size; i++) { |
||
51 | const unsigned idx = data_size + i; |
||
52 | |||
53 | if (storage[idx].u != 0xBADDC0DE) |
||
54 | return ::testing::AssertionFailure() |
||
55 | << "storage[" << idx << "].u = " << storage[idx].u |
||
56 | << ", exepected data values = " << data_size |
||
57 | << ", red-zone size = " << red_zone_size; |
||
58 | } |
||
59 | |||
60 | return ::testing::AssertionSuccess(); |
||
61 | } |
||
62 | |||
63 | static const int values[] = { |
||
64 | 2, 0, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53 |
||
65 | }; |
||
66 | |||
67 | /** |
||
68 | * Generate a single data element. |
||
69 | * |
||
70 | * This is by both \c generate_data and \c generate_array_data to create the |
||
71 | * data. |
||
72 | */ |
||
73 | static void |
||
74 | generate_data_element(void *mem_ctx, const glsl_type *type, |
||
75 | ir_constant *&val, unsigned data_index_base) |
||
76 | { |
||
77 | /* Set the initial data values for the generated constant. |
||
78 | */ |
||
79 | ir_constant_data data; |
||
80 | memset(&data, 0, sizeof(data)); |
||
81 | for (unsigned i = 0; i < type->components(); i++) { |
||
82 | const unsigned idx = (i + data_index_base) % ARRAY_SIZE(values); |
||
83 | switch (type->base_type) { |
||
84 | case GLSL_TYPE_UINT: |
||
85 | case GLSL_TYPE_INT: |
||
86 | case GLSL_TYPE_SAMPLER: |
||
87 | case GLSL_TYPE_IMAGE: |
||
88 | data.i[i] = values[idx]; |
||
89 | break; |
||
90 | case GLSL_TYPE_FLOAT: |
||
91 | data.f[i] = float(values[idx]); |
||
92 | break; |
||
93 | case GLSL_TYPE_BOOL: |
||
94 | data.b[i] = bool(values[idx]); |
||
95 | break; |
||
96 | case GLSL_TYPE_DOUBLE: |
||
97 | data.d[i] = double(values[idx]); |
||
98 | break; |
||
99 | case GLSL_TYPE_ATOMIC_UINT: |
||
100 | case GLSL_TYPE_STRUCT: |
||
101 | case GLSL_TYPE_ARRAY: |
||
102 | case GLSL_TYPE_VOID: |
||
103 | case GLSL_TYPE_ERROR: |
||
104 | case GLSL_TYPE_INTERFACE: |
||
105 | ASSERT_TRUE(false); |
||
106 | break; |
||
107 | } |
||
108 | } |
||
109 | |||
110 | /* Generate and verify the constant. |
||
111 | */ |
||
112 | val = new(mem_ctx) ir_constant(type, &data); |
||
113 | |||
114 | for (unsigned i = 0; i < type->components(); i++) { |
||
115 | switch (type->base_type) { |
||
116 | case GLSL_TYPE_UINT: |
||
117 | case GLSL_TYPE_INT: |
||
118 | case GLSL_TYPE_SAMPLER: |
||
119 | case GLSL_TYPE_IMAGE: |
||
120 | ASSERT_EQ(data.i[i], val->value.i[i]); |
||
121 | break; |
||
122 | case GLSL_TYPE_FLOAT: |
||
123 | ASSERT_EQ(data.f[i], val->value.f[i]); |
||
124 | break; |
||
125 | case GLSL_TYPE_BOOL: |
||
126 | ASSERT_EQ(data.b[i], val->value.b[i]); |
||
127 | break; |
||
128 | case GLSL_TYPE_DOUBLE: |
||
129 | ASSERT_EQ(data.d[i], val->value.d[i]); |
||
130 | break; |
||
131 | case GLSL_TYPE_ATOMIC_UINT: |
||
132 | case GLSL_TYPE_STRUCT: |
||
133 | case GLSL_TYPE_ARRAY: |
||
134 | case GLSL_TYPE_VOID: |
||
135 | case GLSL_TYPE_ERROR: |
||
136 | case GLSL_TYPE_INTERFACE: |
||
137 | ASSERT_TRUE(false); |
||
138 | break; |
||
139 | } |
||
140 | } |
||
141 | } |
||
142 | |||
143 | void |
||
144 | generate_data(void *mem_ctx, enum glsl_base_type base_type, |
||
145 | unsigned columns, unsigned rows, |
||
146 | ir_constant *&val) |
||
147 | { |
||
148 | /* Determine what the type of the generated constant should be. |
||
149 | */ |
||
150 | const glsl_type *const type = |
||
151 | glsl_type::get_instance(base_type, rows, columns); |
||
152 | ASSERT_FALSE(type->is_error()); |
||
153 | |||
154 | generate_data_element(mem_ctx, type, val, 0); |
||
155 | } |
||
156 | |||
157 | void |
||
158 | generate_array_data(void *mem_ctx, enum glsl_base_type base_type, |
||
159 | unsigned columns, unsigned rows, unsigned array_size, |
||
160 | ir_constant *&val) |
||
161 | { |
||
162 | /* Determine what the type of the generated constant should be. |
||
163 | */ |
||
164 | const glsl_type *const element_type = |
||
165 | glsl_type::get_instance(base_type, rows, columns); |
||
166 | ASSERT_FALSE(element_type->is_error()); |
||
167 | |||
168 | const glsl_type *const array_type = |
||
169 | glsl_type::get_array_instance(element_type, array_size); |
||
170 | ASSERT_FALSE(array_type->is_error()); |
||
171 | |||
172 | /* Set the initial data values for the generated constant. |
||
173 | */ |
||
174 | exec_list values_for_array; |
||
175 | for (unsigned i = 0; i < array_size; i++) { |
||
176 | ir_constant *element; |
||
177 | |||
178 | generate_data_element(mem_ctx, element_type, element, i); |
||
179 | values_for_array.push_tail(element); |
||
180 | } |
||
181 | |||
182 | val = new(mem_ctx) ir_constant(array_type, &values_for_array); |
||
183 | } |
||
184 | |||
185 | /** |
||
186 | * Verify that the data stored for the uniform matches the initializer |
||
187 | * |
||
188 | * \param storage Backing storage for the uniform |
||
189 | * \param storage_array_size Array size of the backing storage. This must be |
||
190 | * less than or equal to the array size of the type |
||
191 | * of \c val. If \c val is not an array, this must |
||
192 | * be zero. |
||
193 | * \param val Value of the initializer for the unifrom. |
||
194 | * \param red_zone |
||
195 | */ |
||
196 | void |
||
197 | verify_data(gl_constant_value *storage, unsigned storage_array_size, |
||
198 | ir_constant *val, unsigned red_zone_size, |
||
199 | unsigned int boolean_true) |
||
200 | { |
||
201 | if (val->type->base_type == GLSL_TYPE_ARRAY) { |
||
202 | const glsl_type *const element_type = val->array_elements[0]->type; |
||
203 | |||
204 | for (unsigned i = 0; i < storage_array_size; i++) { |
||
205 | verify_data(storage + (i * element_type->components()), 0, |
||
206 | val->array_elements[i], 0, boolean_true); |
||
207 | } |
||
208 | |||
209 | const unsigned components = element_type->components(); |
||
210 | |||
211 | if (red_zone_size > 0) { |
||
212 | EXPECT_TRUE(red_zone_is_intact(storage, |
||
213 | storage_array_size * components, |
||
214 | red_zone_size)); |
||
215 | } |
||
216 | } else { |
||
217 | ASSERT_EQ(0u, storage_array_size); |
||
218 | for (unsigned i = 0; i < val->type->components(); i++) { |
||
219 | switch (val->type->base_type) { |
||
220 | case GLSL_TYPE_UINT: |
||
221 | case GLSL_TYPE_INT: |
||
222 | case GLSL_TYPE_SAMPLER: |
||
223 | case GLSL_TYPE_IMAGE: |
||
224 | EXPECT_EQ(val->value.i[i], storage[i].i); |
||
225 | break; |
||
226 | case GLSL_TYPE_FLOAT: |
||
227 | EXPECT_EQ(val->value.f[i], storage[i].f); |
||
228 | break; |
||
229 | case GLSL_TYPE_BOOL: |
||
230 | EXPECT_EQ(val->value.b[i] ? boolean_true : 0, storage[i].i); |
||
231 | break; |
||
232 | case GLSL_TYPE_DOUBLE: |
||
233 | EXPECT_EQ(val->value.d[i], *(double *)&storage[i*2].i); |
||
234 | break; |
||
235 | case GLSL_TYPE_ATOMIC_UINT: |
||
236 | case GLSL_TYPE_STRUCT: |
||
237 | case GLSL_TYPE_ARRAY: |
||
238 | case GLSL_TYPE_VOID: |
||
239 | case GLSL_TYPE_ERROR: |
||
240 | case GLSL_TYPE_INTERFACE: |
||
241 | ASSERT_TRUE(false); |
||
242 | break; |
||
243 | } |
||
244 | } |
||
245 | |||
246 | if (red_zone_size > 0) { |
||
247 | EXPECT_TRUE(red_zone_is_intact(storage, |
||
248 | val->type->components(), |
||
249 | red_zone_size)); |
||
250 | } |
||
251 | } |
||
252 | }>>>>>><>><>><>><>><>><>><>><>>>> |