chiark - git - ian - stressapptest/blob - src/pattern.cc

   1 // Copyright 2006 Google Inc. All Rights Reserved.
   2
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6
   7 //      http://www.apache.org/licenses/LICENSE-2.0
   8
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 // pattern.cc : library of stressful data patterns
  16
  17 #include <sys/types.h>
  18
  19 // This file must work with autoconf on its public version,
  20 // so these includes are correct.
  21 #include "pattern.h"
  22 #include "sattypes.h"
  23
  24 // Static data patterns.
  25
  26 static unsigned int walkingOnes_data[] =   {
  27   0x00000001, 0x00000002, 0x00000004, 0x00000008,
  28   0x00000010, 0x00000020, 0x00000040, 0x00000080,
  29   0x00000100, 0x00000200, 0x00000400, 0x00000800,
  30   0x00001000, 0x00002000, 0x00004000, 0x00008000,
  31   0x00010000, 0x00020000, 0x00040000, 0x00080000,
  32   0x00100000, 0x00200000, 0x00400000, 0x00800000,
  33   0x01000000, 0x02000000, 0x04000000, 0x08000000,
  34   0x10000000, 0x20000000, 0x40000000, 0x80000000,
  35   0x40000000, 0x20000000, 0x10000000, 0x08000000,
  36   0x04000000, 0x02000000, 0x01000000, 0x00800000,
  37   0x00400000, 0x00200000, 0x00100000, 0x00080000,
  38   0x00040000, 0x00020000, 0x00010000, 0x00008000,
  39   0x00004000, 0x00002000, 0x00001000, 0x00000800,
  40   0x00000400, 0x00000200, 0x00000100, 0x00000080,
  41   0x00000040, 0x00000020, 0x00000010, 0x00000008,
  42   0x00000004, 0x00000002, 0x00000001, 0x00000000
  43 };
  44 static const struct PatternData walkingOnes = {
  45   "walkingOnes",
  46   walkingOnes_data,
  47   (sizeof walkingOnes_data / sizeof walkingOnes_data[0]) - 1,
  48   {1, 1, 2, 1}  // Weight for choosing 32/64/128/256 bit wide of this pattern
  49 };
  50
  51 static unsigned int walkingInvOnes_data[] =   {
  52   0x00000001, 0xfffffffe, 0x00000002, 0xfffffffd,
  53   0x00000004, 0xfffffffb, 0x00000008, 0xfffffff7,
  54   0x00000010, 0xffffffef, 0x00000020, 0xffffffdf,
  55   0x00000040, 0xffffffbf, 0x00000080, 0xffffff7f,
  56   0x00000100, 0xfffffeff, 0x00000200, 0xfffffdff,
  57   0x00000400, 0xfffffbff, 0x00000800, 0xfffff7ff,
  58   0x00001000, 0xffffefff, 0x00002000, 0xffffdfff,
  59   0x00004000, 0xffffbfff, 0x00008000, 0xffff7fff,
  60   0x00010000, 0xfffeffff, 0x00020000, 0xfffdffff,
  61   0x00040000, 0xfffbffff, 0x00080000, 0xfff7ffff,
  62   0x00100000, 0xffefffff, 0x00200000, 0xffdfffff,
  63   0x00400000, 0xffbfffff, 0x00800000, 0xff7fffff,
  64   0x01000000, 0xfeffffff, 0x02000000, 0xfdffffff,
  65   0x04000000, 0xfbffffff, 0x08000000, 0xf7ffffff,
  66   0x10000000, 0xefffffff, 0x20000000, 0xdfffffff,
  67   0x40000000, 0xbfffffff, 0x80000000, 0x7fffffff,
  68   0x40000000, 0xbfffffff, 0x20000000, 0xdfffffff,
  69   0x10000000, 0xefffffff, 0x08000000, 0xf7ffffff,
  70   0x04000000, 0xfbffffff, 0x02000000, 0xfdffffff,
  71   0x01000000, 0xfeffffff, 0x00800000, 0xff7fffff,
  72   0x00400000, 0xffbfffff, 0x00200000, 0xffdfffff,
  73   0x00100000, 0xffefffff, 0x00080000, 0xfff7ffff,
  74   0x00040000, 0xfffbffff, 0x00020000, 0xfffdffff,
  75   0x00010000, 0xfffeffff, 0x00008000, 0xffff7fff,
  76   0x00004000, 0xffffbfff, 0x00002000, 0xffffdfff,
  77   0x00001000, 0xffffefff, 0x00000800, 0xfffff7ff,
  78   0x00000400, 0xfffffbff, 0x00000200, 0xfffffdff,
  79   0x00000100, 0xfffffeff, 0x00000080, 0xffffff7f,
  80   0x00000040, 0xffffffbf, 0x00000020, 0xffffffdf,
  81   0x00000010, 0xffffffef, 0x00000008, 0xfffffff7,
  82   0x00000004, 0xfffffffb, 0x00000002, 0xfffffffd,
  83   0x00000001, 0xfffffffe, 0x00000000, 0xffffffff
  84 };
  85 static const struct PatternData walkingInvOnes = {
  86   "walkingInvOnes",
  87   walkingInvOnes_data,
  88   (sizeof walkingInvOnes_data / sizeof walkingInvOnes_data[0]) - 1,
  89   {2, 2, 5, 5}
  90 };
  91
  92 static unsigned int walkingZeros_data[] =   {
  93   0xfffffffe, 0xfffffffd, 0xfffffffb, 0xfffffff7,
  94   0xffffffef, 0xffffffdf, 0xffffffbf, 0xffffff7f,
  95   0xfffffeff, 0xfffffdff, 0xfffffbff, 0xfffff7ff,
  96   0xffffefff, 0xffffdfff, 0xffffbfff, 0xffff7fff,
  97   0xfffeffff, 0xfffdffff, 0xfffbffff, 0xfff7ffff,
  98   0xffefffff, 0xffdfffff, 0xffbfffff, 0xff7fffff,
  99   0xfeffffff, 0xfdffffff, 0xfbffffff, 0xf7ffffff,
 100   0xefffffff, 0xdfffffff, 0xbfffffff, 0x7fffffff,
 101   0xbfffffff, 0xdfffffff, 0xefffffff, 0xf7ffffff,
 102   0xfbffffff, 0xfdffffff, 0xfeffffff, 0xff7fffff,
 103   0xffbfffff, 0xffdfffff, 0xffefffff, 0xfff7ffff,
 104   0xfffbffff, 0xfffdffff, 0xfffeffff, 0xffff7fff,
 105   0xffffbfff, 0xffffdfff, 0xffffefff, 0xfffff7ff,
 106   0xfffffbff, 0xfffffdff, 0xfffffeff, 0xffffff7f,
 107   0xffffffbf, 0xffffffdf, 0xffffffef, 0xfffffff7,
 108   0xfffffffb, 0xfffffffd, 0xfffffffe, 0xffffffff
 109 };
 110 static const struct PatternData walkingZeros = {
 111   "walkingZeros",
 112   walkingZeros_data,
 113   (sizeof walkingZeros_data / sizeof walkingZeros_data[0]) - 1,
 114   {1, 1, 2, 1}
 115 };
 116
 117 static unsigned int OneZero_data[] =   { 0x00000000, 0xffffffff};
 118 static const struct PatternData OneZero = {
 119   "OneZero",
 120   OneZero_data,
 121   (sizeof OneZero_data / sizeof OneZero_data[0]) - 1,
 122   {5, 5, 15, 5}
 123 };
 124
 125 static unsigned int JustZero_data[] =   { 0x00000000, 0x00000000};
 126 static const struct PatternData JustZero = {
 127   "JustZero",
 128   JustZero_data,
 129   (sizeof JustZero_data / sizeof JustZero_data[0]) - 1,
 130   {2, 0, 0, 0}
 131 };
 132
 133 static unsigned int JustOne_data[] =   { 0xffffffff, 0xffffffff};
 134 static const struct PatternData JustOne = {
 135   "JustOne",
 136   JustOne_data,
 137   (sizeof JustOne_data / sizeof JustOne_data[0]) - 1,
 138   {2, 0, 0, 0}
 139 };
 140
 141 static unsigned int JustFive_data[] =   { 0x55555555, 0x55555555};
 142 static const struct PatternData JustFive = {
 143   "JustFive",
 144   JustFive_data,
 145   (sizeof JustFive_data / sizeof JustFive_data[0]) - 1,
 146   {2, 0, 0, 0}
 147 };
 148
 149 static unsigned int JustA_data[] =   { 0xaaaaaaaa, 0xaaaaaaaa};
 150 static const struct PatternData JustA = {
 151   "JustA",
 152   JustA_data,
 153   (sizeof JustA_data / sizeof JustA_data[0]) - 1,
 154   {2, 0, 0, 0}
 155 };
 156
 157 static unsigned int FiveA_data[] =   { 0x55555555, 0xaaaaaaaa};
 158 static const struct PatternData FiveA = {
 159   "FiveA",
 160   FiveA_data,
 161   (sizeof FiveA_data / sizeof FiveA_data[0]) - 1,
 162   {1, 1, 1, 1}
 163 };
 164
 165 static unsigned int FiveA8_data[] =   {
 166   0x5aa5a55a, 0xa55a5aa5, 0xa55a5aa5, 0x5aa5a55a
 167 };
 168 static const struct PatternData FiveA8 = {
 169   "FiveA8",
 170   FiveA8_data,
 171   (sizeof FiveA8_data / sizeof FiveA8_data[0]) - 1,
 172   {1, 1, 1, 1}
 173 };
 174
 175 static unsigned int Long8b10b_data[] =   { 0x16161616, 0x16161616 };
 176 static const struct PatternData Long8b10b = {
 177   "Long8b10b",
 178   Long8b10b_data,
 179   (sizeof Long8b10b_data / sizeof Long8b10b_data[0]) - 1,
 180   {2, 0, 0, 0}
 181 };
 182
 183 static unsigned int Short8b10b_data[] =   { 0xb5b5b5b5, 0xb5b5b5b5 };
 184 static const struct PatternData Short8b10b = {
 185   "Short8b10b",
 186   Short8b10b_data,
 187   (sizeof Short8b10b_data / sizeof Short8b10b_data[0]) - 1,
 188   {2, 0, 0, 0}
 189 };
 190
 191 static unsigned int Checker8b10b_data[] =   { 0xb5b5b5b5, 0x4a4a4a4a };
 192 static const struct PatternData Checker8b10b = {
 193   "Checker8b10b",
 194   Checker8b10b_data,
 195   (sizeof Checker8b10b_data / sizeof Checker8b10b_data[0]) - 1,
 196   {1, 0, 0, 1}
 197 };
 198
 199 static unsigned int Five7_data[] =   { 0x55555557, 0x55575555 };
 200 static const struct PatternData Five7 = {
 201   "Five7",
 202   Five7_data,
 203   (sizeof Five7_data / sizeof Five7_data[0]) - 1,
 204   {0, 2, 0, 0}
 205 };
 206
 207 static unsigned int Zero2fd_data[] =   { 0x00020002, 0xfffdfffd };
 208 static const struct PatternData Zero2fd = {
 209   "Zero2fd",
 210   Zero2fd_data,
 211   (sizeof Zero2fd_data / sizeof Zero2fd_data[0]) - 1,
 212   {0, 2, 0, 0}
 213 };
 214
 215 // Extern array of useable patterns.
 216 static const struct PatternData pattern_array[] = {
 217   walkingOnes,
 218   walkingInvOnes,
 219   walkingZeros,
 220   OneZero,
 221   JustZero,
 222   JustOne,
 223   JustFive,
 224   JustA,
 225   FiveA,
 226   FiveA8,
 227   Long8b10b,
 228   Short8b10b,
 229   Checker8b10b,
 230   Five7,
 231   Zero2fd,
 232 };
 233 static const int pattern_array_size =
 234     sizeof pattern_array / sizeof pattern_array[0];
 235
 236 Pattern::Pattern() {
 237   crc_ = NULL;
 238 }
 239
 240 Pattern::~Pattern() {
 241   if (crc_ != NULL) {
 242     delete crc_;
 243   }
 244 }
 245
 246 // Calculate CRC for this pattern. This must match
 247 // the CRC calculation in worker.cc.
 248 int Pattern::CalculateCrc() {
 249   // TODO(johnhuang):
 250   // Consider refactoring to the form:
 251   // while (i < count) AdlerInc(uint64, uint64, AdlerChecksum*)
 252   uint64 a1 = 1;
 253   uint64 a2 = 1;
 254   uint64 b1 = 0;
 255   uint64 b2 = 0;
 256
 257   // checksum is calculated using only the first 4096 bytes of data.
 258   int i = 0;
 259   int blocksize = 4096;
 260   int count = blocksize / sizeof i;
 261   while (i < count) {
 262     a1 += pattern(i);
 263     b1 += a1;
 264     i++;
 265     a1 += pattern(i);
 266     b1 += a1;
 267     i++;
 268
 269     a2 += pattern(i);
 270     b2 += a2;
 271     i++;
 272     a2 += pattern(i);
 273     b2 += a2;
 274     i++;
 275   }
 276   if (crc_ != NULL) {
 277     delete crc_;
 278   }
 279   crc_ = new AdlerChecksum();
 280   crc_->Set(a1, a2, b1, b2);
 281   return 0;
 282 }
 283
 284 // Initialize pattern's CRC.
 285 int Pattern::Initialize(const struct PatternData &pattern_init,
 286                         int buswidth,
 287                         bool invert,
 288                         int weight) {
 289   int result = 1;
 290
 291   pattern_ = &pattern_init;
 292   busshift_ = 2;
 293   inverse_ = invert;
 294   weight_ = weight;
 295
 296   name_.clear();
 297   name_.append(pattern_->name);
 298
 299   if (invert)
 300     name_.append("~");
 301
 302   if (buswidth == 32) {
 303     name_.append("32");
 304     busshift_ = 0;
 305   } else if (buswidth == 64) {
 306     name_.append("64");
 307     busshift_ = 1;
 308   } else if (buswidth == 128) {
 309     name_.append("128");
 310     busshift_ = 2;
 311   } else if (buswidth == 256) {
 312     name_.append("256");
 313     busshift_ = 3;
 314   } else {
 315     logprintf(0, "Process Error: Confused by bus width %d\n",
 316               buswidth);
 317     name_.append("Broken");
 318     result = 0;
 319   }
 320
 321   CalculateCrc();
 322
 323   return result;
 324 }
 325
 326
 327 PatternList::PatternList() {
 328   size_= 0;
 329   initialized_ = 0;
 330 }
 331
 332 PatternList::~PatternList() {
 333   if (initialized_) {
 334     Destroy();
 335   }
 336 }
 337
 338 // Fill in the class with references to the static data patterns
 339 int PatternList::Initialize() {
 340   int patterncount = 0;
 341   int weightcount = 0;
 342
 343   patterns_.resize(pattern_array_size * 8);
 344   for (int i = 0; i < pattern_array_size; i++) {
 345     // Non inverted.
 346     weightcount += pattern_array[i].weight[0];
 347     patterns_[patterncount++].Initialize(pattern_array[i], 32, false,
 348                                          pattern_array[i].weight[0]);
 349     weightcount += pattern_array[i].weight[1];
 350     patterns_[patterncount++].Initialize(pattern_array[i], 64, false,
 351                                          pattern_array[i].weight[1]);
 352     weightcount += pattern_array[i].weight[2];
 353     patterns_[patterncount++].Initialize(pattern_array[i], 128, false,
 354                                          pattern_array[i].weight[2]);
 355     weightcount += pattern_array[i].weight[3];
 356     patterns_[patterncount++].Initialize(pattern_array[i], 256, false,
 357                                          pattern_array[i].weight[3]);
 358
 359     // Inverted.
 360     weightcount += pattern_array[i].weight[0];
 361     patterns_[patterncount++].Initialize(pattern_array[i], 32, true,
 362                                          pattern_array[i].weight[0]);
 363     weightcount += pattern_array[i].weight[1];
 364     patterns_[patterncount++].Initialize(pattern_array[i], 64, true,
 365                                          pattern_array[i].weight[1]);
 366     weightcount += pattern_array[i].weight[2];
 367     patterns_[patterncount++].Initialize(pattern_array[i], 128, true,
 368                                          pattern_array[i].weight[2]);
 369     weightcount += pattern_array[i].weight[3];
 370     patterns_[patterncount++].Initialize(pattern_array[i], 256, true,
 371                                          pattern_array[i].weight[3]);
 372   }
 373   size_ = patterncount;
 374   weightcount_ = weightcount;
 375   initialized_ = 1;
 376
 377   logprintf(12, "Log: initialized %d data patterns\n", size_);
 378
 379   return 1;
 380 }
 381
 382 // Free the stuff.
 383 int PatternList::Destroy() {
 384   if (!initialized_)
 385     return 0;
 386
 387   patterns_.clear();
 388   size_ = 0;
 389   initialized_ = 0;
 390
 391   return 1;
 392 }
 393
 394 // Return pattern numbered "i"
 395 Pattern *PatternList::GetPattern(int i) {
 396   if (static_cast<unsigned int>(i) < size_) {
 397     return &patterns_[i];
 398   }
 399
 400   logprintf(0, "Process Error: Out of bounds pattern access\n");
 401   return 0;
 402 }
 403
 404 // Return a randomly selected pattern.
 405 Pattern *PatternList::GetRandomPattern() {
 406   unsigned int target = random();
 407   target = target % weightcount_;
 408
 409   unsigned int i = 0;
 410   unsigned int sum = 0;
 411   while (target > sum) {
 412     sum += patterns_[i].weight();
 413     i++;
 414   }
 415   if (i < size_) {
 416     return &patterns_[i];
 417   }
 418
 419   logprintf(0, "Process Error: Out of bounds pattern access\n");
 420   return 0;
 421 }