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