Home | History | Annotate | Download | only in src
      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 }
    422