gcc/testsuite/gcc.target/spu/tag_manager.c

   1 /* Copyright (C) 2007, 2009 Free Software Foundation, Inc.
   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
   5    Software Foundation; either version 3 of the License, or (at your option)
   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
  14    along with this file; see the file COPYING3.  If not see
  15    <http://www.gnu.org/licenses/>.  */
  16
  17 /* { dg-do run } */
  18
  19 #include <spu_mfcio.h>
  20 #include <stdlib.h>
  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