]>
Commit | Line | Data |
---|---|---|
748086b7 | 1 | /* Copyright (C) 2007, 2009 Free Software Foundation, Inc. |
1763dfa7 UW |
2 | |
3 | This file is free software; you can redistribute it and/or modify it under | |
4 | the terms of the GNU General Public License as published by the Free | |
748086b7 | 5 | Software Foundation; either version 3 of the License, or (at your option) |
1763dfa7 UW |
6 | any later version. |
7 | ||
8 | This file is distributed in the hope that it will be useful, but WITHOUT | |
9 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
10 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
11 | for more details. | |
12 | ||
13 | You should have received a copy of the GNU General Public License | |
748086b7 JJ |
14 | along with this file; see the file COPYING3. If not see |
15 | <http://www.gnu.org/licenses/>. */ | |
1763dfa7 UW |
16 | |
17 | /* { dg-do run } */ | |
18 | ||
19 | #include <spu_mfcio.h> | |
6b7d5ac9 | 20 | #include <stdlib.h> |
1763dfa7 UW |
21 | |
22 | /* This test directly accesses the internal table used | |
23 | by the MFC tag manager. */ | |
24 | extern vector unsigned int __mfc_tag_table; | |
25 | ||
26 | ||
27 | /* This tag tests invalid tag release. Invalid tag release does | |
28 | nothing to the tag table. */ | |
29 | void | |
30 | test_tag_release01 (void) | |
31 | { | |
32 | unsigned int copy; | |
33 | copy = spu_extract (__mfc_tag_table, 0); | |
34 | ||
35 | mfc_tag_release (35); | |
36 | if (copy != spu_extract (__mfc_tag_table, 0)) | |
37 | abort (); | |
38 | } | |
39 | ||
40 | /* More invalid release tests. */ | |
41 | void | |
42 | test_tag_release_invalid (void) | |
43 | { | |
44 | unsigned int copy; | |
45 | copy = spu_extract (__mfc_tag_table, 0); | |
46 | ||
47 | if (mfc_tag_release (32) != MFC_TAG_INVALID) | |
48 | abort (); | |
49 | if (copy != spu_extract (__mfc_tag_table, 0)) | |
50 | abort (); | |
51 | ||
52 | if (mfc_tag_release (17) != MFC_TAG_INVALID) | |
53 | abort (); | |
54 | if (copy != spu_extract (__mfc_tag_table, 0)) | |
55 | abort (); | |
56 | } | |
57 | ||
58 | /* Invalid multiple-tag release tests. */ | |
59 | void | |
60 | test_tag_group_release_invalid (void) | |
61 | { | |
62 | unsigned int copy; | |
63 | copy = spu_extract (__mfc_tag_table, 0); | |
64 | ||
65 | if (mfc_multi_tag_release (32, 10) != MFC_TAG_INVALID) | |
66 | abort (); | |
67 | if (copy != spu_extract (__mfc_tag_table, 0)) | |
68 | abort (); | |
69 | ||
70 | if (mfc_multi_tag_release (28, 10) != MFC_TAG_INVALID) | |
71 | abort (); | |
72 | if (copy != spu_extract (__mfc_tag_table, 0)) | |
73 | abort (); | |
74 | ||
75 | if (mfc_multi_tag_release (17, 10) != MFC_TAG_INVALID) | |
76 | abort (); | |
77 | if (copy != spu_extract (__mfc_tag_table, 0)) | |
78 | abort (); | |
79 | ||
80 | if (mfc_multi_tag_release (32, 10) != MFC_TAG_INVALID) | |
81 | abort (); | |
82 | if (copy != spu_extract (__mfc_tag_table, 0)) | |
83 | abort (); | |
84 | } | |
85 | ||
86 | /* The tag table should be in a pristine mode to run this test. */ | |
87 | void | |
88 | test_tag_reserve01 (void) | |
89 | { | |
90 | unsigned int correct_table[32] = | |
91 | { | |
92 | 0x80000000, 0xC0000000, 0xE0000000, | |
93 | 0xF0000000, 0xF8000000, 0xFC000000, 0xFE000000, | |
94 | 0xFF000000, 0xFF800000, 0xFFC00000, 0xFFE00000, | |
95 | 0xFFF00000, 0xFFF80000, 0xFFFC0000, 0xFFFE0000, | |
96 | 0xFFFF0000, 0xFFFF8000, 0xFFFFC000, 0xFFFFE000, | |
97 | 0xFFFFF000, 0xFFFFF800, 0xFFFFFC00, 0xFFFFFE00, | |
98 | 0xFFFFFF00, 0xFFFFFF80, 0xFFFFFFC0, 0xFFFFFFE0, | |
99 | 0xFFFFFFF0, 0xFFFFFFF8, 0xFFFFFFFC, 0xFFFFFFFE, | |
100 | 0xFFFFFFFF | |
101 | }; | |
102 | ||
103 | unsigned int tag; | |
104 | unsigned int i; | |
105 | ||
106 | for (i = 0; i < 32; i++) | |
107 | { | |
108 | tag = mfc_tag_reserve (); | |
109 | if (tag != i) | |
110 | abort (); | |
111 | } | |
112 | ||
113 | for (i = 0; i < 32; i++) | |
114 | { | |
115 | tag = mfc_tag_reserve (); | |
116 | if (tag != MFC_TAG_INVALID) | |
117 | abort (); | |
118 | } | |
119 | ||
120 | for (i = 0; i < 32; i++) | |
121 | { | |
122 | mfc_tag_release (i); | |
123 | if (spu_extract (__mfc_tag_table, 0) != correct_table[i]) | |
124 | abort (); | |
125 | } | |
126 | } | |
127 | ||
128 | /* The tag table should be in a pristine mode to run this test. */ | |
129 | void | |
130 | test_tag_reserve02 (void) | |
131 | { | |
132 | unsigned int correct_table[32] = | |
133 | { | |
134 | 0x80000000, 0xC0000000, 0xA0000000, 0xF0000000, | |
135 | 0xA8000000, 0xFC000000, 0xAA000000, 0xFF000000, | |
136 | 0xAA800000, 0xFFC00000, 0xAAA00000, 0xFFF00000, | |
137 | 0xAAA80000, 0xFFFC0000, 0xAAAA0000, 0xFFFF0000, | |
138 | 0xAAAA8000, 0xFFFFC000, 0xAAAAA000, 0xFFFFF000, | |
139 | 0xAAAAA800, 0xFFFFFC00, 0xAAAAAA00, 0xFFFFFF00, | |
140 | 0xAAAAAA80, 0xFFFFFFC0, 0xAAAAAAA0, 0xFFFFFFF0, | |
141 | 0xAAAAAAA8, 0xFFFFFFFC, 0xAAAAAAAA, 0xFFFFFFFF | |
142 | }; | |
143 | ||
144 | unsigned int correct_table2[32] = | |
145 | { | |
146 | 0x80000000, 0xEAAAAAAA, 0xA0000000, 0xFAAAAAAA, | |
147 | 0xA8000000, 0xFEAAAAAA, 0xAA000000, 0xFFAAAAAA, | |
148 | 0xAA800000, 0xFFEAAAAA, 0xAAA00000, 0xFFFAAAAA, | |
149 | 0xAAA80000, 0xFFFEAAAA, 0xAAAA0000, 0xFFFFAAAA, | |
150 | 0xAAAA8000, 0xFFFFEAAA, 0xAAAAA000, 0xFFFFFAAA, | |
151 | 0xAAAAA800, 0xFFFFFEAA, 0xAAAAAA00, 0xFFFFFFAA, | |
152 | 0xAAAAAA80, 0xFFFFFFEA, 0xAAAAAAA0, 0xFFFFFFFA, | |
153 | 0xAAAAAAA8, 0xFFFFFFFE, 0xAAAAAAAA, 0xFFFFFFFF | |
154 | }; | |
155 | ||
156 | unsigned int tag; | |
157 | unsigned int i; | |
158 | ||
159 | /* Reserve all 32 tags. */ | |
160 | for (i = 0; i < 32; i++) | |
161 | { | |
162 | tag = mfc_tag_reserve(); | |
163 | if (tag != i) | |
164 | abort (); | |
165 | } | |
166 | ||
167 | for (i = 0; i < 32; i++) | |
168 | { | |
169 | tag = mfc_tag_reserve(); | |
170 | if (tag != MFC_TAG_INVALID) | |
171 | abort (); | |
172 | } | |
173 | ||
174 | /* Release only 16 tags with a stride of 2. */ | |
175 | for (i = 0; i < 32; i += 2) | |
176 | { | |
177 | mfc_tag_release (i); | |
178 | if (spu_extract (__mfc_tag_table, 0) != correct_table[i]) | |
179 | abort (); | |
180 | } | |
181 | ||
182 | /* Release the other 16 tags with a stride of 2. */ | |
183 | for (i = 1; i < 32; i += 2) | |
184 | { | |
185 | mfc_tag_release (i); | |
186 | if (spu_extract (__mfc_tag_table, 0) != correct_table2[i]) | |
187 | abort (); | |
188 | } | |
189 | } | |
190 | ||
191 | /* The tag table should be in a pristine mode to run this test. */ | |
192 | void | |
193 | test_tag_reserve03 (void) | |
194 | { | |
195 | unsigned int tag; | |
196 | unsigned int i; | |
197 | ||
198 | /* Reserve all 32 tags. */ | |
199 | for (i = 0; i < 32; i++) | |
200 | { | |
201 | tag = mfc_tag_reserve (); | |
202 | if (tag != i) | |
203 | abort (); | |
204 | } | |
205 | ||
206 | for (i = 0; i < 32; i++) | |
207 | { | |
208 | tag = mfc_tag_reserve (); | |
209 | if (tag != MFC_TAG_INVALID) | |
210 | abort (); | |
211 | } | |
212 | ||
213 | /* Release only 16 tags with a stride of 2. */ | |
214 | for (i = 0; i < 32; i += 2) | |
215 | mfc_tag_release (i); | |
216 | ||
217 | /* Now let's re-reserve those tags. */ | |
218 | for (i = 0; i < 32; i += 2) | |
219 | { | |
220 | tag = mfc_tag_reserve (); | |
221 | if (tag != i) | |
222 | abort (); | |
223 | } | |
224 | ||
225 | /* Release all tags. */ | |
226 | for (i = 0; i < 32; i++) | |
227 | mfc_tag_release (i); | |
228 | ||
229 | if (spu_extract (__mfc_tag_table,0) != 0xFFFFFFFF) | |
230 | abort (); | |
231 | } | |
232 | ||
233 | ||
234 | void | |
235 | test_tag_group_reserve (void) | |
236 | { | |
237 | unsigned int tag; | |
238 | unsigned int i; | |
239 | unsigned int copy; | |
240 | ||
241 | /* Reserve all tags. */ | |
242 | for (i = 0; i < 32; i++) | |
243 | mfc_tag_reserve(); | |
244 | ||
245 | /* Release the first 4. */ | |
246 | for (i = 0; i < 4; i++) | |
247 | mfc_tag_release (i); | |
248 | ||
249 | /* Release tag 5 to 7. */ | |
250 | for (i = 5; i < 8; i++) | |
251 | mfc_tag_release (i); | |
252 | ||
253 | /* Release tag 9 to 19. */ | |
254 | for (i = 9; i < 20; i++) | |
255 | mfc_tag_release (i); | |
256 | ||
257 | /* Tag table should be 0xF77FF000. */ | |
258 | if (spu_extract (__mfc_tag_table, 0) != 0xF77FF000) | |
259 | abort (); | |
260 | ||
261 | ||
262 | /* Verify invalid release is detected. */ | |
263 | copy = spu_extract (__mfc_tag_table, 0); | |
264 | if (mfc_multi_tag_release (1, 5) != MFC_TAG_INVALID) | |
265 | abort (); | |
266 | if (copy != spu_extract (__mfc_tag_table, 0)) | |
267 | abort (); | |
268 | ||
269 | ||
270 | /* Reserve multiple tags. */ | |
271 | tag = mfc_multi_tag_reserve (5); | |
272 | if (tag != 9) | |
273 | abort (); | |
274 | ||
275 | /* Tag table should be 0xF703F000. */ | |
276 | if (spu_extract (__mfc_tag_table, 0) != 0xF703F000) | |
277 | abort (); | |
278 | ||
279 | ||
280 | /* Release 5 tags in the group. */ | |
281 | mfc_multi_tag_release (tag, 5); | |
282 | ||
283 | /* Tag table should be 0xF77FF000. */ | |
284 | if (spu_extract (__mfc_tag_table, 0) != 0xF77FF000) | |
285 | abort (); | |
286 | ||
287 | ||
288 | /* This call should not do anything. */ | |
289 | mfc_multi_tag_release (32, 5); | |
290 | ||
291 | /* Tag table should be 0xF77FF000. */ | |
292 | if (spu_extract (__mfc_tag_table, 0) != 0xF77FF000) | |
293 | abort (); | |
294 | } | |
295 | ||
296 | ||
297 | int | |
298 | main (void) | |
299 | { | |
300 | test_tag_release01 (); | |
301 | test_tag_release_invalid (); | |
302 | test_tag_group_release_invalid (); | |
303 | ||
304 | test_tag_reserve01 (); | |
305 | test_tag_reserve02 (); | |
306 | test_tag_reserve03 (); | |
307 | ||
308 | test_tag_group_reserve (); | |
309 | ||
310 | return 0; | |
311 | } | |
312 |