diff options
Diffstat (limited to '')
-rw-r--r-- | third_party/webkit/PerformanceTests/ARES-6/Air/liveness.js | 152 |
1 files changed, 152 insertions, 0 deletions
diff --git a/third_party/webkit/PerformanceTests/ARES-6/Air/liveness.js b/third_party/webkit/PerformanceTests/ARES-6/Air/liveness.js new file mode 100644 index 0000000000..f0ea319734 --- /dev/null +++ b/third_party/webkit/PerformanceTests/ARES-6/Air/liveness.js @@ -0,0 +1,152 @@ +/* + * Copyright (C) 2016 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +"use strict"; + +class Liveness { + constructor(thing, code) + { + this._thing = thing; + this._code = code; + + this._liveAtHead = new Map(); + this._liveAtTail = new Map(); + + for (let block of code) { + this._liveAtHead.set(block, new Set()); + + let liveAtTail = new Set(); + this._liveAtTail.set(block, liveAtTail); + + block.last.forEach( + thing, + (value, role, type, width) => { + if (Arg.isLateUse(role)) + liveAtTail.add(value); + }); + } + + let dirtyBlocks = new Set(code); + + let changed; + do { + changed = false; + + for (let blockIndex = code.size; blockIndex--;) { + let block = code.at(blockIndex); + if (!block) + continue; + + if (!dirtyBlocks.delete(block)) + continue; + + let localCalc = this.localCalc(block); + for (let instIndex = block.size; instIndex--;) + localCalc.execute(instIndex); + + // Handle the early def's of the first instruction. + block.at(0).forEach( + thing, + (value, role, type, width) => { + if (Arg.isEarlyDef(role)) + localCalc.liveSet.remove(value); + }); + + let liveAtHead = this._liveAtHead.get(block); + + if (!mergeIntoSet(liveAtHead, localCalc.liveSet)) + continue; + + for (let predecessor of block.predecessors) { + if (mergeIntoSet(this._liveAtTail.get(predecessor), liveAtHead)) { + dirtyBlocks.add(predecessor); + changed = true; + } + } + } + } while (changed); + } + + get thing() { return this._thing; } + get code() { return this._code; } + get liveAtHead() { return this._liveAtHead; } + get liveAtTail() { return this._liveAtTail; } + + localCalc(block) + { + let liveness = this; + class LocalCalc { + constructor() + { + this._liveSet = new Set(liveness.liveAtTail.get(block)); + } + + get liveSet() { return this._liveSet; } + + execute(instIndex) + { + let inst = block.at(instIndex); + + // First handle the early defs of the next instruction. + if (instIndex + 1 < block.size) { + block.at(instIndex + 1).forEach( + liveness.thing, + (value, role, type, width) => { + if (Arg.isEarlyDef(role)) + this._liveSet.delete(value); + }); + } + + // Then handle defs. + inst.forEach( + liveness.thing, + (value, role, type, width) => { + if (Arg.isLateDef(role)) + this._liveSet.delete(value); + }); + + // Then handle uses. + inst.forEach( + liveness.thing, + (value, role, type, width) => { + if (Arg.isEarlyUse(role)) + this._liveSet.add(value); + }); + + // Finally handle the late uses of the previous instruction. + if (instIndex - 1 >= 0) { + block.at(instIndex - 1).forEach( + liveness.thing, + (value, role, type, width) => { + if (Arg.isLateUse(role)) + this._liveSet.add(value); + }); + } + } + } + + return new LocalCalc(); + } +} + |