PerformanceTests/Animometer/tests/text/resources/layering-text.js

   1 function LayeringTextStage(element, options)
   2 {
   3     Stage.call(this, element, options);
   4     this._textElementParent = this.element;
   5     this._textElements = [];
   6     this._textItemIndex = 0;
   7     this._colorIndex = 0;
   8     this._animateCounts = 0;
   9 }
  10
  11 LayeringTextStage.textItems = [
  12     "<div class='text-layer'>",
  13         "<h2>Types of benchmarks</h2>",
  14         "<ol>",
  15             "<li>Real program",
  16                 "<ul>",
  17                     "<li>word processing software</li>",
  18                     "<li>tool software of CAD</li>",
  19                     "<li>user's application software (i.e.: MIS)</li>",
  20                 "</ul>",
  21             "</li>",
  22             "<li>Kernel",
  23                 "<ul>",
  24                     "<li>contains key codes</li>",
  25                     "<li>normally abstracted from actual program</li>",
  26                     "<li>popular kernel: Livermore loop</li>",
  27                     "<li>linpack benchmark (contains basic linear algebra subroutine written in FORTRAN language)</li>",
  28                     "<li>results are represented in MFLOPS</li>",
  29                 "</ul>",
  30             "</li>",
  31             "<li>Synthetic Benchmark",
  32                 "<ul>",
  33                     "<li>Procedure for programming synthetic benchmark:",
  34                         "<ul>",
  35                             "<li>take statistics of all types of operations from many application programs</li>",
  36                             "<li>get proportion of each operation</li>",
  37                             "<li>write program based on the proportion above</li>",
  38                         "</ul>",
  39                     "</li>",
  40                     "<li>Types of Synthetic Benchmark are:",
  41                         "<ul>",
  42                             "<li>Whetstone</li>",
  43                             "<li>Dhrystone</li>",
  44                         "</ul>",
  45                     "</li>",
  46                     "<li>These were the first general purpose industry standard computer benchmarks. They do not necessarily obtain high scores on modern pipelined computers.</li>",
  47                 "</ul>",
  48             "</li>",
  49             "<li>I/O benchmarks</li>",
  50             "<li>Database benchmarks: to measure the throughput and response times of database management systems (DBMS')</li>",
  51             "<li>Parallel benchmarks: used on machines with multiple cores, processors or systems consisting of multiple machines</li>",
  52         "</ol>",
  53         "<h2>Common benchmarks</h2>",
  54         "<ul>",
  55             "<li>Business Applications Performance Corporation (BAPCo)</li>",
  56             "<li>Embedded Microprocessor Benchmark Consortium (EEMBC)</li>",
  57             "<li>Standard Performance Evaluation Corporation (SPEC), in particular their SPECint and SPECfp</li>",
  58             "<li>Transaction Processing Performance Council (TPC)</li>",
  59             "<li>Coremark: Embedded computing benchmark</li>",
  60         "</ul>",
  61         "<h3>Open source benchmarks</h3>",
  62         "<ul>",
  63             "<li>AIM Multiuser Benchmark: composed of a list of tests that could be mixed to create a 'load mix' that would simulate a specific computer function on any UNIX-type OS.</li>",
  64             "<li>Bonnie++: filesystem and hard drive benchmark</li>",
  65             "<li>BRL-CAD: cross-platform architecture-agnostic benchmark suite based on multithreaded ray tracing performance; baselined against a VAX-11/780; and used since 1984 for evaluating relative CPU performance, compiler differences, optimization levels, coherency, architecture differences, and operating system differences.</li>",
  66         "</ul>",
  67     "</div>"
  68 ];
  69
  70 LayeringTextStage.parseTextItem = function(textItem)
  71 {
  72     var parseResult = {};
  73     parseResult.tagStart = textItem.match(/<(.*?)>/g)[0];
  74     var spaceIndex = parseResult.tagStart.indexOf(" ");
  75     parseResult.nodeName = parseResult.tagStart.substring(1, spaceIndex != -1 ? spaceIndex : parseResult.tagStart.length - 1);
  76     parseResult.args = spaceIndex != -1 ? Utilities.parseArguments(parseResult.tagStart.substring(spaceIndex + 1, parseResult.tagStart.length - 1)) : {};
  77     var tagEnd = "</" + parseResult.nodeName + ">";
  78     parseResult.tagEnd = textItem.endsWith(tagEnd) ? tagEnd : "";
  79     return parseResult;
  80 }
  81
  82 LayeringTextStage.isOpeningTextItem = function(textItem)
  83 {
  84     return !LayeringTextStage.parseTextItem(textItem).tagEnd.length;
  85 }
  86
  87 LayeringTextStage.isClosingTextItem = function(textItem)
  88 {
  89     return textItem.indexOf("/") == +1;
  90 }
  91
  92 LayeringTextStage.textItemsFlags = LayeringTextStage.textItems.map(function(textItem)
  93 {
  94    var textItemFlags = {};
  95    textItemFlags.isOpening = LayeringTextStage.isOpeningTextItem(textItem);
  96    textItemFlags.isClosing = LayeringTextStage.isClosingTextItem(textItem);
  97    return textItemFlags;
  98 });
  99
 100 LayeringTextStage.isColorableTextItem = function(textItemFlags)
 101 {
 102     return !(textItemFlags.isOpening || textItemFlags.isClosing);
 103 }
 104
 105 LayeringTextStage.isInsertableTextItem = function(textItemFlags)
 106 {
 107     return !textItemFlags.isClosing;
 108 }
 109
 110 LayeringTextStage.colorableTextItems = LayeringTextStage.textItemsFlags.filter(function(textItemFlags)
 111 {
 112     return LayeringTextStage.isColorableTextItem(textItemFlags);
 113 }).length;
 114
 115 LayeringTextStage.insertableTextItems = LayeringTextStage.textItemsFlags.filter(function(textItemFlags)
 116 {
 117     return LayeringTextStage.isInsertableTextItem(textItemFlags);
 118 }).length;
 119
 120 LayeringTextStage.colorIndexToTextElementIndex = function(colorIndex)
 121 {
 122     var textElementIndex = 0;
 123     var index = 0;
 124
 125     for (var textItemIndex = 0; textItemIndex < LayeringTextStage.textItemsFlags.length; ++textItemIndex) {
 126         if (LayeringTextStage.isColorableTextItem(LayeringTextStage.textItemsFlags[textItemIndex])) {
 127             if (++index > colorIndex)
 128                 break;
 129         }
 130         if (LayeringTextStage.isInsertableTextItem(LayeringTextStage.textItemsFlags[textItemIndex]))
 131             ++textElementIndex;
 132     }
 133
 134     return textElementIndex;
 135 }
 136
 137 LayeringTextStage.prototype = Object.create(Stage.prototype);
 138 LayeringTextStage.prototype.constructor = LayeringTextStage;
 139
 140 LayeringTextStage.prototype._nextTextItem = function(textItemFlags)
 141 {
 142     var textItem = LayeringTextStage.textItems[this._textItemIndex];
 143     Utilities.extendObject(textItemFlags, LayeringTextStage.textItemsFlags[this._textItemIndex]);
 144     this._textItemIndex = (this._textItemIndex + 1) % LayeringTextStage.textItems.length;
 145     return textItem;
 146 }
 147
 148 LayeringTextStage.prototype._previousTextItem = function(textItemFlags)
 149 {
 150     this._textItemIndex = (this._textItemIndex + LayeringTextStage.textItems.length - 1) % LayeringTextStage.textItems.length;
 151     Utilities.extendObject(textItemFlags, LayeringTextStage.textItemsFlags[this._textItemIndex]);
 152     return LayeringTextStage.textItems[this._textItemIndex];
 153 }
 154
 155 LayeringTextStage.prototype._pushTextElement = function()
 156 {
 157     var textItemFlags = {};
 158     var textItem = this._nextTextItem(textItemFlags);
 159     for ( ; textItemFlags.isClosing; textItem = this._nextTextItem(textItemFlags))
 160         this._textElementParent = this._textElementParent.parentNode;
 161
 162     var parseResult = LayeringTextStage.parseTextItem(textItem);
 163     textItem = textItem.substring(parseResult.tagStart.length, textItem.length - parseResult.tagEnd.length);
 164
 165     var textElement = document.createElement(parseResult.nodeName);
 166
 167     for (var attrname in parseResult.args)
 168         textElement.setAttribute(attrname, parseResult.args[attrname]);
 169
 170     this._textElementParent.appendChild(textElement);
 171
 172     if (!parseResult.tagEnd.length)
 173         this._textElementParent = textElement;
 174
 175     textElement.innerHTML = textItem;
 176
 177     this._textElements.push(textElement);
 178     return this._textElements.length;
 179 }
 180
 181 LayeringTextStage.prototype._popTextElement = function()
 182 {
 183     var textItemFlags = {};
 184     var textItem = this._previousTextItem(textItemFlags);
 185     for ( ; textItemFlags.isClosing; textItem = this._previousTextItem(textItemFlags))
 186         this._textElementParent = this._textElementParent.lastChild;
 187
 188     if (textItemFlags.isOpening)
 189         this._textElementParent = this._textElementParent.parentNode;
 190
 191     this._textElements[this._textElements.length - 1].remove();
 192
 193     this._textElements.pop();
 194     return this._textElements.length;
 195 }
 196
 197 LayeringTextStage.prototype._colorTextItem = function(color)
 198 {
 199     var textElementIndex = LayeringTextStage.colorIndexToTextElementIndex(this._colorIndex);
 200     for ( ; textElementIndex < this._textElements.length; textElementIndex += LayeringTextStage.insertableTextItems)
 201         this._textElements[textElementIndex].style.backgroundColor = color;
 202 }
 203
 204 LayeringTextStage.prototype.animate = function(timeDelta)
 205 {
 206     this._colorTextItem("transparent");
 207     this._colorIndex = (this._colorIndex + 1) % LayeringTextStage.colorableTextItems;
 208     this._colorTextItem("YellowGreen");
 209
 210     var blackTextElements = Math.min(this._textElements.length, LayeringTextStage.insertableTextItems);
 211     var i = 0;
 212     for ( ; i < this._textElements.length - blackTextElements; ++i)
 213         this._textElements[i].style.color = (this._animateCounts & 1) ? "LightYellow" : "white";
 214
 215     for ( ; i < this._textElements.length; ++i)
 216         this._textElements[i].style.color = "black";
 217
 218     ++this._animateCounts;
 219 }
 220
 221 LayeringTextStage.prototype.tune = function(count)
 222 {
 223     if (count == 0)
 224         return this._textElements.length;
 225
 226     if (count > 0) {
 227         for (var i = 0; i < count; ++i)
 228             this._pushTextElement();
 229         return this._textElements.length;
 230     }
 231
 232     count = Math.min(-count, this._textElements.length);
 233     for (var i = 0; i < count; ++i)
 234         this._popTextElement();
 235
 236     return this._textElements.length;
 237 }
 238
 239 function LayeringTextBenchmark(suite, test, options, recordTable, progressBar)
 240 {
 241     StageBenchmark.call(this, suite, test, options, recordTable, progressBar);
 242 }
 243
 244 LayeringTextBenchmark.prototype = Object.create(StageBenchmark.prototype);
 245 LayeringTextBenchmark.prototype.constructor = LayeringTextBenchmark;
 246
 247 LayeringTextBenchmark.prototype.createStage = function(element)
 248 {
 249     return new LayeringTextStage(element, this._options);
 250 }
 251
 252 window.benchmarkClient.create = function(suite, test, options, recordTable, progressBar)
 253 {
 254     return new LayeringTextBenchmark(suite, test, options, recordTable, progressBar);
 255 }